def networkx_to_graph_tool(networkx_graph: nx.Graph) -> gt.Graph:
        """
        Converts a networkx graph to a graph-tool graph.
        """
        # Phase 0: Create a directed or undirected graph-tool Graph
        graph_tool_graph = gt.Graph(directed=networkx_graph.is_directed())

        # Add the Graph properties as "internal properties"
        for key, value in list(networkx_graph.graph.items()):
            # Convert the value and key into a type for graph-tool
            tname, value, key = get_prop_type(value, key)

            prop = graph_tool_graph.new_graph_property(tname)  # Create the PropertyMap

            graph_tool_graph.graph_properties[key] = prop  # Set the PropertyMap
            graph_tool_graph.graph_properties[key] = value  # Set the actual value

        # Phase 1: Add the vertex and edge property maps
        # Go through all nodes and edges and add seen properties
        # Add the node properties first
        nprops = set()  # cache keys to only add properties once
        for node, data in networkx_graph.nodes(data=True):

            # Go through all the properties if not seen and add them.
            for key, val in list(data.items()):
                if key in nprops:
                    continue  # Skip properties already added

                # Convert the value and key into a type for graph-tool
                tname, _, key = get_prop_type(val, key)

                prop = graph_tool_graph.new_vertex_property(tname)  # Create the PropertyMap
                graph_tool_graph.vertex_properties[key] = prop  # Set the PropertyMap

                # Add the key to the already seen properties
                nprops.add(key)

        # Also add the node id: in NetworkX a node can be any hashable type, but
        # in graph-tool node are defined as indices. So we capture any strings
        # in a special PropertyMap called 'id' -- modify as needed!
        graph_tool_graph.vertex_properties['id'] = graph_tool_graph.new_vertex_property('string')
        # Add the edge properties second
        eprops = set()  # cache keys to only add properties once
        for src, dst, data in networkx_graph.edges(data=True):
            # Go through all the edge properties if not seen and add them.
            for key, val in list(data.items()):
                if key in eprops: continue  # Skip properties already added
                # Convert the value and key into a type for graph-tool
                tname, _, key = get_prop_type(val, key)
                prop = graph_tool_graph.new_edge_property(tname)  # Create the PropertyMap
                graph_tool_graph.edge_properties[key] = prop  # Set the PropertyMap
                # Add the key to the already seen properties
                eprops.add(key)
        # Phase 2: Actually add all the nodes and vertices with their properties
        # Add the nodes
        vertices = {}  # vertex mapping for tracking edges later
        for node, data in networkx_graph.nodes(data=True):
            # Create the vertex and annotate for our edges later
            v = graph_tool_graph.add_vertex()
            vertices[node] = v
            # Set the vertex properties, not forgetting the id property
            data['id'] = str(node)
            for key, value in list(data.items()):
                graph_tool_graph.vp[key][v] = value  # vp is short for vertex_properties
        # Add the edges
        for src, dst, data in networkx_graph.edges(data=True):
            # Look up the vertex structs from our vertices mapping and add edge.
            e = graph_tool_graph.add_edge(vertices[src], vertices[dst])
            # Add the edge properties
            for key, value in list(data.items()):
                graph_tool_graph.ep[key][e] = value  # ep is short for edge_properties
        # Done, finally!
        return graph_tool_graph    }