topologicpy 0.5.3__py3-none-any.whl → 0.5.5__py3-none-any.whl

topologicpy/Graph.py

@@ -337,7 +337,7 @@ class Graph:
                         elif (len(gk) < 1) and (len(vk) > 0):
                             d = vd
                         if d:
-                            _ = Topology.SetDictionary(gv,d)
+                            _ = Topology.SetDictionary(gv, d)
                     unique = False
                     returnVertex = gv
                     break
@@ -527,6 +527,370 @@ class Graph:
         lcc = Graph.LocalClusteringCoefficient(graph, vertices)
         acc = round(sum(lcc)/float(len(lcc)), mantissa)
         return acc
+    
+    @staticmethod
+    def BOTGraph(graph,
+                bidirectional=False,
+                includeAttributes=False,
+                includeLabel=False,
+                siteLabel = "Site_0001",
+                siteDictionary = None,
+                buildingLabel = "Building_0001",
+                buildingDictionary = None , 
+                storeyPrefix = "Storey",
+                floorLevels =[],
+                labelKey="label",
+                typeKey="type",
+                sourceKey="source",
+                targetKey="target",
+                xKey = "x",
+                yKey = "y",
+                zKey = "z",
+                spaceType = "space",
+                wallType = "wall",
+                slabType = "slab",
+                doorType = "door",
+                windowType = "window",
+                contentType = "content"
+                ):
+        """
+        Creates an RDF graph according to the BOT ontology. See https://w3c-lbd-cg.github.io/bot/.
+
+        Parameters
+        ----------
+        graph : topologic.Graph
+            The input graph.
+        bidirectional : bool , optional
+            If set to True, reverse relationships are created wherever possible. Otherwise, they are not. The default is False.
+        includeAttributes : bool , optional
+            If set to True, the attributes associated with vertices in the graph are written out. Otherwise, they are not. The default is False.
+        includeLabel : bool , optional
+            If set to True, a label is attached to each node. Otherwise, it is not. The default is False.
+        siteLabel : str , optional
+            The desired site label. The default is "Site_0001".
+        siteDictionary : dict , optional
+            The dictionary of site attributes to include in the output. The default is None.
+        buildingLabel : str , optional
+            The desired building label. The default is "Building_0001".
+        buildingDictionary : dict , optional
+            The dictionary of building attributes to include in the output. The default is None.
+        storeyPrefix : str , optional
+            The desired prefixed to use for each building storey. The default is "Storey".
+        floorLevels : list , optional
+            The list of floor levels. This should be a numeric list, sorted from lowest to highest.
+            If not provided, floorLevels will be computed automatically based on the nodes' 'z' attribute.
+        typeKey : str , optional
+            The dictionary key to use to look up the type of the node. The default is "type".
+        labelKey : str , optional
+            The dictionary key to use to look up the label of the node. The default is "label".
+        sourceKey : str , optional
+            The desired dictionary key to use to store the source vertex. The default is "source".
+        targetKey : str , optional
+            The desired dictionary key to use to store the target vertex. The default is "target".
+        xKey : str , optional
+            The dictionary key to use to look up the x-coordinate of the node. The default is "x".
+        yKey : str , optional
+            The dictionary key to use to look up the y-coordinate of the node. The default is "y".
+        zKey : str , optional
+            The dictionary key to use to look up the z-coordinate of the node. The default is "z".
+        spaceType : str , optional
+            The dictionary string value to use to look up nodes of type "space". The default is "space".
+        wallType : str , optional
+            The dictionary string value to use to look up nodes of type "wall". The default is "wall".
+        slabType : str , optional
+            The dictionary string value to use to look up nodes of type "slab". The default is "slab".
+        doorType : str , optional
+            The dictionary string value to use to look up nodes of type "door". The default is "door".
+        windowType : str , optional
+            The dictionary string value to use to look up nodes of type "window". The default is "window".
+        contentType : str , optional
+            The dictionary string value to use to look up nodes of type "content". The default is "contents".
+
+        Returns
+        -------
+        rdflib.graph.Graph
+            The rdf graph using the BOT ontology.
+        """
+
+        from topologicpy.Helper import Helper
+        import os
+        import warnings
+        
+        try:
+            from rdflib import Graph as RDFGraph
+            from rdflib import URIRef, Literal, Namespace
+            from rdflib.namespace import RDF, RDFS
+        except:
+            print("Graph.BOTGraph - Installing required rdflib library.")
+            try:
+                os.system("pip install rdflib")
+            except:
+                os.system("pip install rdflib --user")
+            try:
+                from rdflib import Graph as RDFGraph
+                from rdflib import URIRef, Literal, Namespace
+                from rdflib.namespace import RDF, RDFS
+                print("Graph.BOTGraph - rdflib library installed correctly.")
+            except:
+                warnings.warn("Graph.BOTGraph - Error: Could not import rdflib. Please try to install rdflib manually. Returning None.")
+                return None
+        
+        if floorLevels == None:
+            floorLevels = []
+        json_data = Graph.JSONData(graph, vertexLabelKey=labelKey)
+        # Create an empty RDF graph
+        rdf_graph = RDFGraph()
+        
+        # Define namespaces
+        rdf = Namespace("http://www.w3.org/1999/02/22-rdf-syntax-ns#")
+        rdfs = Namespace("http://www.w3.org/2000/01/rdf-schema#")
+        bot = Namespace("https://w3id.org/bot#")
+        
+        # Define a custom prefix mapping
+        rdf_graph.namespace_manager.bind("bot", bot)
+        
+        # Add site
+        site_uri = URIRef(siteLabel)
+        rdf_graph.add((site_uri, rdf.type, bot.Site))
+        if includeLabel:
+            rdf_graph.add((site_uri, RDFS.label, Literal("Site_0001")))
+        if isinstance(siteDictionary, topologic.Dictionary):
+            keys = Dictionary.Keys(siteDictionary)
+            for key in keys:
+                value = Dictionary.ValueAtKey(siteDictionary, key)
+                if key == labelKey:
+                    if includeLabel:
+                        rdf_graph.add((site_uri, RDFS.label, Literal(value)))
+                    elif key != typeKey:
+                        rdf_graph.add((site_uri, bot[key], Literal(value)))
+        # Add building
+        building_uri = URIRef(buildingLabel)
+        rdf_graph.add((building_uri, rdf.type, bot.Building))
+        if includeLabel:
+            rdf_graph.add((building_uri, RDFS.label, Literal(buildingLabel)))
+        if isinstance(buildingDictionary, topologic.Dictionary):
+            keys = Dictionary.Keys(buildingDictionary)
+            for key in keys:
+                value = Dictionary.ValueAtKey(buildingDictionary, key)
+                if key == labelKey:
+                    if includeLabel:
+                        rdf_graph.add((building_uri, RDFS.label, Literal(value)))
+                    elif key != typeKey:
+                        rdf_graph.add((building_uri, bot[key], Literal(value)))
+        # Add stories
+        # if floor levels are not given, then need to be computed
+        if len(floorLevels) == 0:
+            for node, attributes in json_data['nodes'].items():
+                if slabType.lower() in attributes[typeKey].lower():
+                    floorLevels.append(attributes[zKey])
+            floorLevels = list(set(floorLevels))
+            floorLevels.sort()
+        storey_uris = []
+        n = max(len(str(len(floorLevels))),4)
+        for i, floor_level in enumerate(floorLevels):
+            storey_uri = URIRef(storeyPrefix+"_"+str(i+1).zfill(n))
+            rdf_graph.add((storey_uri, rdf.type, bot.Storey))
+            if includeLabel:
+                rdf_graph.add((storey_uri, RDFS.label, Literal(storeyPrefix+"_"+str(i+1).zfill(n))))
+            storey_uris.append(storey_uri)
+
+        # Add triples to relate building to site and stories to building
+        rdf_graph.add((site_uri, bot.hasBuilding, building_uri))
+        if bidirectional:
+            rdf_graph.add((building_uri, bot.isPartOf, site_uri)) # might not be needed
+
+        for storey_uri in storey_uris:
+            rdf_graph.add((building_uri, bot.hasStorey, storey_uri))
+            if bidirectional:
+                rdf_graph.add((storey_uri, bot.isPartOf, building_uri)) # might not be needed
+        
+        # Add vertices as RDF resources
+        for node, attributes in json_data['nodes'].items():
+            node_uri = URIRef(node)
+            if spaceType.lower() in attributes[typeKey].lower():
+                rdf_graph.add((node_uri, rdf.type, bot.Space))
+                # Find the storey it is on
+                z = attributes[zKey]
+                level = Helper.Position(z, floorLevels)
+                if level > len(storey_uris):
+                    level = len(storey_uris)
+                storey_uri = storey_uris[level-1]
+                rdf_graph.add((storey_uri, bot.hasSpace, node_uri))
+                if bidirectional:
+                    rdf_graph.add((node_uri, bot.isPartOf, storey_uri)) # might not be needed
+            elif windowType.lower() in attributes[typeKey].lower():
+                rdf_graph.add((node_uri, rdf.type, bot.Window))
+            elif doorType.lower() in attributes[typeKey].lower():
+                rdf_graph.add((node_uri, rdf.type, bot.Door))
+            elif wallType.lower() in attributes[typeKey].lower():
+                rdf_graph.add((node_uri, rdf.type, bot.Wall))
+            elif slabType.lower() in attributes[typeKey].lower():
+                rdf_graph.add((node_uri, rdf.type, bot.Slab))
+            else:
+                rdf_graph.add((node_uri, rdf.type, bot.Element))
+            
+            if includeAttributes:
+                for key, value in attributes.items():
+                    if key == labelKey:
+                        if includeLabel:
+                            rdf_graph.add((node_uri, RDFS.label, Literal(value)))
+                    elif key != typeKey:
+                        rdf_graph.add((node_uri, bot[key], Literal(value)))
+            if includeLabel:
+                for key, value in attributes.items():
+                    if key == labelKey:
+                        rdf_graph.add((node_uri, RDFS.label, Literal(value)))
+        
+        # Add edges as RDF triples
+        for edge, attributes in json_data['edges'].items():
+            source = attributes[sourceKey]
+            target = attributes[targetKey]
+            source_uri = URIRef(source)
+            target_uri = URIRef(target)
+            if spaceType.lower() in json_data['nodes'][source][typeKey].lower() and spaceType.lower() in json_data['nodes'][target][typeKey].lower():
+                rdf_graph.add((source_uri, bot.adjacentTo, target_uri))
+                if bidirectional:
+                    rdf_graph.add((target_uri, bot.adjacentTo, source_uri))
+            elif spaceType.lower() in json_data['nodes'][source][typeKey].lower() and wallType.lower() in json_data['nodes'][target][typeKey].lower():
+                rdf_graph.add((target_uri, bot.interfaceOf, source_uri))
+            elif spaceType.lower() in json_data['nodes'][source][typeKey].lower() and slabType.lower() in json_data['nodes'][target][typeKey].lower():
+                rdf_graph.add((target_uri, bot.interfaceOf, source_uri))
+            elif spaceType.lower() in json_data['nodes'][source][typeKey].lower() and contentType.lower() in json_data['nodes'][target][typeKey].lower():
+                rdf_graph.add((source_uri, bot.containsElement, target_uri))
+                if bidirectional:
+                    rdf_graph.add((target_uri, bot.isPartOf, source_uri))
+            else:
+                rdf_graph.add((source_uri, bot.connectsTo, target_uri))
+                if bidirectional:
+                    rdf_graph.add((target_uri, bot.connectsTo, source_uri))
+            #for key, value in attributes.items():
+                #rdf_graph.add((source_uri, bot[key], Literal(value)))
+        # Return serialized  RDF graph
+        #rdf_serialized = rdf_graph.serialize(format=format)
+        return rdf_graph
+
+    @staticmethod
+    def BOTString(graph,
+                format="turtle",
+                bidirectional=False,
+                includeAttributes=False,
+                includeLabel=False,
+                siteLabel = "Site_0001",
+                siteDictionary = None,
+                buildingLabel = "Building_0001",
+                buildingDictionary = None , 
+                storeyPrefix = "Storey",
+                floorLevels =[],
+                labelKey="label",
+                typeKey="type",
+                sourceKey="source",
+                targetKey="target",
+                xKey = "x",
+                yKey = "y",
+                zKey = "z",
+                spaceType = "space",
+                wallType = "wall",
+                slabType = "slab",
+                doorType = "door",
+                windowType = "window",
+                contentType = "content",
+                ):
+        
+        """
+        Returns an RDF graph serialized string according to the BOT ontology. See https://w3c-lbd-cg.github.io/bot/.
+
+        Parameters
+        ----------
+        graph : topologic.Graph
+            The input graph.
+        format : str , optional
+            The desired output format, the options are listed below. Thde default is "turtle".
+            turtle, ttl or turtle2 : Turtle, turtle2 is just turtle with more spacing & linebreaks
+            xml or pretty-xml : RDF/XML, Was the default format, rdflib < 6.0.0
+            json-ld : JSON-LD , There are further options for compact syntax and other JSON-LD variants
+            ntriples, nt or nt11 : N-Triples , nt11 is exactly like nt, only utf8 encoded
+            n3 : Notation-3 , N3 is a superset of Turtle that also caters for rules and a few other things
+            trig : Trig , Turtle-like format for RDF triples + context (RDF quads) and thus multiple graphs
+            trix : Trix , RDF/XML-like format for RDF quads
+            nquads : N-Quads , N-Triples-like format for RDF quads
+        bidirectional : bool , optional
+            If set to True, reverse relationships are created wherever possible. Otherwise, they are not. The default is False.
+        includeAttributes : bool , optional
+            If set to True, the attributes associated with vertices in the graph are written out. Otherwise, they are not. The default is False.
+        includeLabel : bool , optional
+            If set to True, a label is attached to each node. Otherwise, it is not. The default is False.
+        siteLabel : str , optional
+            The desired site label. The default is "Site_0001".
+        siteDictionary : dict , optional
+            The dictionary of site attributes to include in the output. The default is None.
+        buildingLabel : str , optional
+            The desired building label. The default is "Building_0001".
+        buildingDictionary : dict , optional
+            The dictionary of building attributes to include in the output. The default is None.
+        storeyPrefix : str , optional
+            The desired prefixed to use for each building storey. The default is "Storey".
+        floorLevels : list , optional
+            The list of floor levels. This should be a numeric list, sorted from lowest to highest.
+            If not provided, floorLevels will be computed automatically based on the nodes' 'z' attribute.
+        typeKey : str , optional
+            The dictionary key to use to look up the type of the node. The default is "type".
+        labelKey : str , optional
+            The dictionary key to use to look up the label of the node. The default is "label".
+        sourceKey : str , optional
+            The desired dictionary key to use to store the source vertex. The default is "source".
+        targetKey : str , optional
+            The desired dictionary key to use to store the target vertex. The default is "target".
+        xKey : str , optional
+            The dictionary key to use to look up the x-coordinate of the node. The default is "x".
+        yKey : str , optional
+            The dictionary key to use to look up the y-coordinate of the node. The default is "y".
+        zKey : str , optional
+            The dictionary key to use to look up the z-coordinate of the node. The default is "z".
+        spaceType : str , optional
+            The dictionary string value to use to look up nodes of type "space". The default is "space".
+        wallType : str , optional
+            The dictionary string value to use to look up nodes of type "wall". The default is "wall".
+        slabType : str , optional
+            The dictionary string value to use to look up nodes of type "slab". The default is "slab".
+        doorType : str , optional
+            The dictionary string value to use to look up nodes of type "door". The default is "door".
+        windowType : str , optional
+            The dictionary string value to use to look up nodes of type "window". The default is "window".
+        contentType : str , optional
+            The dictionary string value to use to look up nodes of type "content". The default is "contents".
+
+        
+        Returns
+        -------
+        str
+            The rdf graph serialized string using the BOT ontology.
+        """
+        
+        bot_graph = Graph.BOTGraph(graph,
+                            bidirectional=bidirectional,
+                            includeAttributes=includeAttributes,
+                            includeLabel=includeLabel,
+                            siteLabel=siteLabel,
+                            siteDictionary=siteDictionary,
+                            buildingLabel=buildingLabel,
+                            buildingDictionary=buildingDictionary, 
+                            storeyPrefix=storeyPrefix,
+                            floorLevels=floorLevels,
+                            labelKey=labelKey,
+                            typeKey=typeKey,
+                            sourceKey=sourceKey,
+                            targetKey=targetKey,
+                            xKey=xKey,
+                            yKey=yKey,
+                            zKey=zKey,
+                            spaceType = spaceType,
+                            wallType = wallType,
+                            slabType = slabType,
+                            doorType = doorType,
+                            windowType = windowType,
+                            contentType = contentType
+                            )
+        return bot_graph.serialize(format=format)
 
     @staticmethod
     def BetweenessCentrality(graph, vertices=None, sources=None, destinations=None, tolerance=0.001):
@@ -858,7 +1222,7 @@ class Graph:
         # Iterate through the grouped nodes DataFrames
         for graph_id, group_node_df in grouped_nodes:
             vertices = []
-            verts = [] #This is a list of x,y,z tuples to make sure the vertices have unique locations.
+            verts = [] #This is a list of x, y, z tuples to make sure the vertices have unique locations.
             n_verts = 0
             for index, row in group_node_df.iterrows():
                 n_verts += 1
@@ -886,12 +1250,12 @@ class Graph:
                     y = random.randrange(0,1000)
                 if not isinstance(z, numbers.Number):
                     z = random.randrange(0,1000)
-                while [x,y,z] in verts:
+                while [x, y, z] in verts:
                     x = x + random.randrange(10000,30000,1000)
                     y = y + random.randrange(4000,6000, 100)
                     z = z + random.randrange(70000,90000, 1000)
-                verts.append([x,y,z])
-                v = Vertex.ByCoordinates(x,y,z)
+                verts.append([x, y, z])
+                v = Vertex.ByCoordinates(x, y, z)
                 if isinstance(v, topologic.Vertex):
                     if len(nodeFeaturesKeys) == 0:
                         values = [node_id, label, mask, features]
@@ -1247,7 +1611,7 @@ class Graph:
                     x = random.uniform(xMin,xMax)
                     y = random.uniform(yMin,yMax)
                     z = random.uniform(zMin,zMax)
-                    centroid = Vertex.ByCoordinates(x,y,z)
+                    centroid = Vertex.ByCoordinates(x, y, z)
                 d = Dictionary.ByKeysValues(["id","psets", "type", "type_id", "name", "label"], [obj_id, psets, obj_type, obj_type_id, name, label])
                 centroid = Topology.SetDictionary(centroid, d)
                 return centroid
@@ -1375,9 +1739,9 @@ class Graph:
         Parameters
         ----------
         vertices : list
-            The list of [x,y,z] coordinates of the vertices/
+            The list of [x, y, z] coordinates of the vertices/
         edges : list
-            the list of [i,j] indices into the vertices list to signify and edge that connects vertices[i] to vertices[j].
+            the list of [i, j] indices into the vertices list to signify and edge that connects vertices[i] to vertices[j].
         vertexDictionaries : list , optional
             The python dictionaries of the vertices (in the same order as the list of vertices).
         edgeDictionaries : list , optional
@@ -1469,6 +1833,7 @@ class Graph:
         from topologicpy.Edge import Edge
         from topologicpy.Cluster import Cluster
         from topologicpy.Topology import Topology
+        from topologicpy.Aperture import Aperture
 
         def mergeDictionaries(sources):
             if isinstance(sources, list) == False:
@@ -1687,7 +2052,7 @@ class Graph:
 
             cells = []
             _ = topology.Cells(None, cells)
-            if (viaSharedTopologies == True) or (viaSharedApertures == True) or (toExteriorTopologies == True) or (toExteriorApertures == True) or (toContents == True):
+            if any([viaSharedTopologies, viaSharedApertures, toExteriorTopologies, toExteriorApertures, toContents]):
                 for aCell in cells:
                     if useInternalVertex == True:
                         vCell = Topology.InternalVertex(aCell, tolerance=tolerance)
@@ -1710,9 +2075,9 @@ class Graph:
                     contents = []
                     _ = aCell.Contents(contents)
                     for aFace in faces:
-                        cells = []
-                        _ = aFace.Cells(topology, cells)
-                        if len(cells) > 1:
+                        cells1 = []
+                        _ = aFace.Cells(topology, cells1)
+                        if len(cells1) > 1:
                             sharedTopologies.append(aFace)
                             apertures = []
                             _ = aFace.Apertures(apertures)
@@ -1724,6 +2089,7 @@ class Graph:
                             _ = aFace.Apertures(apertures)
                             for anAperture in apertures:
                                 exteriorApertures.append(anAperture)
+
                     if viaSharedTopologies:
                         for sharedTopology in sharedTopologies:
                             if useInternalVertex == True:
@@ -1746,6 +2112,8 @@ class Graph:
                                 contents = []
                                 _ = sharedTopology.Contents(contents)
                                 for content in contents:
+                                    if isinstance(content, topologic.Aperture):
+                                        content = Aperture.Topology(content)
                                     if useInternalVertex == True:
                                         vst2 = Topology.InternalVertex(content, tolerance)
                                     else:
@@ -1767,38 +2135,38 @@ class Graph:
                         for sharedAperture in sharedApertures:
                             sharedAp = sharedAperture.Topology()
                             if useInternalVertex == True:
-                                vst = Topology.InternalVertex(sharedAp, tolerance)
+                                vsa = Topology.InternalVertex(sharedAp, tolerance)
                             else:
-                                vst = sharedAp.CenterOfMass()
+                                vsa = sharedAp.CenterOfMass()
                             d1 = sharedAp.GetDictionary()
-                            vst = topologic.Vertex.ByCoordinates(vst.X()+(tolerance*100), vst.Y()+(tolerance*100), vst.Z()+(tolerance*100))
+                            vsa = topologic.Vertex.ByCoordinates(vsa.X()+(tolerance*100), vsa.Y()+(tolerance*100), vsa.Z()+(tolerance*100))
                             if storeBRep:
                                 d2 = Dictionary.ByKeysValues(["brep", "brepType", "brepTypeString"], [Topology.BREPString(sharedAperture), Topology.Type(sharedAperture), Topology.TypeAsString(sharedAperture)])
                                 d3 = mergeDictionaries2([d1, d2])
-                                _ = vst.SetDictionary(d3)
+                                _ = vsa.SetDictionary(d3)
                             else:
-                                _ = vst.SetDictionary(d1)
-                            vertices.append(vst)
-                            tempe = Edge.ByStartVertexEndVertex(vCell, vst, tolerance=tolerance)
+                                _ = vsa.SetDictionary(d1)
+                            vertices.append(vsa)
+                            tempe = Edge.ByStartVertexEndVertex(vCell, vsa, tolerance=tolerance)
                             tempd = Dictionary.ByKeysValues(["relationship"],["Via Shared Apertures"])
                             _ = tempe.SetDictionary(tempd)
                             edges.append(tempe)
                     if toExteriorTopologies:
                         for exteriorTopology in exteriorTopologies:
                             if useInternalVertex == True:
-                                vst = Topology.InternalVertex(exteriorTopology, tolerance)
+                                vet = Topology.InternalVertex(exteriorTopology, tolerance)
                             else:
-                                vst = exteriorTopology.CenterOfMass()
-                            _ = vst.SetDictionary(exteriorTopology.GetDictionary())
+                                vet = exteriorTopology.CenterOfMass()
+                            _ = vet.SetDictionary(exteriorTopology.GetDictionary())
                             d1 = exteriorTopology.GetDictionary()
                             if storeBRep:
                                 d2 = Dictionary.ByKeysValues(["brep", "brepType", "brepTypeString"], [Topology.BREPString(exteriorTopology), Topology.Type(exteriorTopology), Topology.TypeAsString(exteriorTopology)])
                                 d3 = mergeDictionaries2([d1, d2])
-                                _ = vst.SetDictionary(d3)
+                                _ = vet.SetDictionary(d3)
                             else:
-                                _ = vst.SetDictionary(d1)
-                            vertices.append(vst)
-                            tempe = Edge.ByStartVertexEndVertex(vCell, vst, tolerance=tolerance)
+                                _ = vet.SetDictionary(d1)
+                            vertices.append(vet)
+                            tempe = Edge.ByStartVertexEndVertex(vCell, vet, tolerance=tolerance)
                             tempd = Dictionary.ByKeysValues(["relationship"],["To Exterior Topologies"])
                             _ = tempe.SetDictionary(tempd)
                             edges.append(tempe)
@@ -1806,6 +2174,8 @@ class Graph:
                                 contents = []
                                 _ = exteriorTopology.Contents(contents)
                                 for content in contents:
+                                    if isinstance(content, topologic.Aperture):
+                                        content = Aperture.Topology(content)
                                     if useInternalVertex == True:
                                         vst2 = Topology.InternalVertex(content, tolerance)
                                     else:
@@ -1819,7 +2189,7 @@ class Graph:
                                     else:
                                         _ = vst2.SetDictionary(d1)
                                     vertices.append(vst2)
-                                    tempe = Edge.ByStartVertexEndVertex(vst, vst2, tolerance=tolerance)
+                                    tempe = Edge.ByStartVertexEndVertex(vet, vst2, tolerance=tolerance)
                                     tempd = Dictionary.ByKeysValues(["relationship"],["To Contents"])
                                     _ = tempe.SetDictionary(tempd)
                                     edges.append(tempe)
@@ -1827,19 +2197,19 @@ class Graph:
                         for exteriorAperture in exteriorApertures:
                             extTop = exteriorAperture.Topology()
                             if useInternalVertex == True:
-                                vst = Topology.InternalVertex(extTop, tolerance)
+                                vea = Topology.InternalVertex(extTop, tolerance)
                             else:
-                                vst = exteriorAperture.Topology().CenterOfMass()
+                                vea = exteriorAperture.Topology().CenterOfMass()
                             d1 = exteriorAperture.Topology().GetDictionary()
-                            vst = topologic.Vertex.ByCoordinates(vst.X()+(tolerance*100), vst.Y()+(tolerance*100), vst.Z()+(tolerance*100))
+                            vea = topologic.Vertex.ByCoordinates(vea.X()+(tolerance*100), vea.Y()+(tolerance*100), vea.Z()+(tolerance*100))
                             if storeBRep:
                                 d2 = Dictionary.ByKeysValues(["brep", "brepType", "brepTypeString"], [Topology.BREPString(exteriorAperture), Topology.Type(exteriorAperture), Topology.TypeAsString(exteriorAperture)])
                                 d3 = mergeDictionaries2([d1, d2])
-                                _ = vst.SetDictionary(d3)
+                                _ = vea.SetDictionary(d3)
                             else:
-                                _ = vst.SetDictionary(d1)
-                            vertices.append(vst)
-                            tempe = Edge.ByStartVertexEndVertex(vCell, vst, tolerance=tolerance)
+                                _ = vea.SetDictionary(d1)
+                            vertices.append(vea)
+                            tempe = Edge.ByStartVertexEndVertex(vCell, vea, tolerance=tolerance)
                             tempd = Dictionary.ByKeysValues(["relationship"],["To Exterior Apertures"])
                             _ = tempe.SetDictionary(tempd)
                             edges.append(tempe)
@@ -1847,20 +2217,22 @@ class Graph:
                         contents = []
                         _ = aCell.Contents(contents)
                         for content in contents:
+                            if isinstance(content, topologic.Aperture):
+                                content = Aperture.Topology(content)
                             if useInternalVertex == True:
-                                vst = Topology.InternalVertex(content, tolerance)
+                                vcn = Topology.InternalVertex(content, tolerance)
                             else:
-                                vst = content.CenterOfMass()
-                            vst = topologic.Vertex.ByCoordinates(vst.X()+(tolerance*100), vst.Y()+(tolerance*100), vst.Z()+(tolerance*100))
+                                vcn = content.CenterOfMass()
+                            vcn = topologic.Vertex.ByCoordinates(vcn.X()+(tolerance*100), vcn.Y()+(tolerance*100), vcn.Z()+(tolerance*100))
                             d1 = content.GetDictionary()
                             if storeBRep:
                                 d2 = Dictionary.ByKeysValues(["brep", "brepType", "brepTypeString"], [Topology.BREPString(content), Topology.Type(content), Topology.TypeAsString(content)])
                                 d3 = mergeDictionaries2([d1, d2])
-                                _ = vst.SetDictionary(d3)
+                                _ = vcn.SetDictionary(d3)
                             else:
-                                _ = vst.SetDictionary(d1)
-                            vertices.append(vst)
-                            tempe = Edge.ByStartVertexEndVertex(vCell, vst, tolerance=tolerance)
+                                _ = vcn.SetDictionary(d1)
+                            vertices.append(vcn)
+                            tempe = Edge.ByStartVertexEndVertex(vCell, vcn, tolerance=tolerance)
                             tempd = Dictionary.ByKeysValues(["relationship"],["To Contents"])
                             _ = tempe.SetDictionary(tempd)
                             edges.append(tempe)
@@ -1885,7 +2257,7 @@ class Graph:
             vertices = []
             edges = []
             if useInternalVertex == True:
-                vCell = Topology.InternalVertex(Topology.Copy(topology), tolerance=tolerance)
+                vCell = Topology.InternalVertex(topology, tolerance=tolerance)
             else:
                 vCell = topology.CenterOfMass()
             d1 = topology.GetDictionary()
@@ -1920,7 +2292,7 @@ class Graph:
                     tempd = Dictionary.ByKeysValues(["relationship"],["To Outposts"])
                     _ = tempe.SetDictionary(tempd)
                     edges.append(tempe)
-            if (toExteriorTopologies == True) or (toExteriorApertures == True) or (toContents == True):
+            if any([toExteriorTopologies, toExteriorApertures, toContents]):
                 faces = Topology.Faces(topology)
                 exteriorTopologies = []
                 exteriorApertures = []
@@ -1951,6 +2323,8 @@ class Graph:
                                 contents = []
                                 _ = exteriorTopology.Contents(contents)
                                 for content in contents:
+                                    if isinstance(content, topologic.Aperture):
+                                        content = Aperture.Topology(content)
                                     if useInternalVertex == True:
                                         vst2 = Topology.InternalVertex(content, tolerance)
                                     else:
@@ -1992,6 +2366,8 @@ class Graph:
                         contents = []
                         _ = topology.Contents(contents)
                         for content in contents:
+                            if isinstance(content, topologic.Aperture):
+                                content = Aperture.Topology(content)
                             if useInternalVertex == True:
                                 vst = Topology.InternalVertex(content, tolerance)
                             else:
@@ -2094,7 +2470,7 @@ class Graph:
 
             topFaces = []
             _ = topology.Faces(None, topFaces)
-            if (viaSharedTopologies == True) or (viaSharedApertures == True) or (toExteriorTopologies == True) or (toExteriorApertures == True) or (toContents == True):
+            if any([viaSharedTopologies, viaSharedApertures, toExteriorTopologies, toExteriorApertures, toContents == True]):
                 for aFace in topFaces:
                     if useInternalVertex == True:
                         vFace = Topology.InternalVertex(aFace, tolerance=tolerance)
@@ -2145,6 +2521,8 @@ class Graph:
                                 contents = []
                                 _ = sharedTopology.Contents(contents)
                                 for content in contents:
+                                    if isinstance(content, topologic.Aperture):
+                                        content = Aperture.Topology(content)
                                     if useInternalVertex == True:
                                         vst2 = Topology.InternalVertex(content, tolerance)
                                     else:
@@ -2203,6 +2581,8 @@ class Graph:
                                 contents = []
                                 _ = exteriorTopology.Contents(contents)
                                 for content in contents:
+                                    if isinstance(content, topologic.Aperture):
+                                        content = Aperture.Topology(content)
                                     if useInternalVertex == True:
                                         vst2 = Topology.InternalVertex(content, tolerance)
                                     else:
@@ -2244,6 +2624,8 @@ class Graph:
                         contents = []
                         _ = aFace.Contents(contents)
                         for content in contents:
+                            if isinstance(content, topologic.Aperture):
+                                content = Aperture.Topology(content)
                             if useInternalVertex == True:
                                 vst = Topology.InternalVertex(content, tolerance)
                             else:
@@ -2388,6 +2770,8 @@ class Graph:
                                 contents = []
                                 _ = exteriorTopology.Contents(contents)
                                 for content in contents:
+                                    if isinstance(content, topologic.Aperture):
+                                        content = Aperture.Topology(content)
                                     if useInternalVertex == True:
                                         vst2 = Topology.InternalVertex(content, tolerance)
                                     else:
@@ -2429,6 +2813,8 @@ class Graph:
                         contents = []
                         _ = topology.Contents(contents)
                         for content in contents:
+                            if isinstance(content, topologic.Aperture):
+                                content = Aperture.Topology(content)
                             if useInternalVertex == True:
                                 vst = Topology.InternalVertex(content, tolerance)
                             else:
@@ -2590,6 +2976,8 @@ class Graph:
                                 contents = []
                                 _ = sharedTopology.Contents(contents)
                                 for content in contents:
+                                    if isinstance(content, topologic.Aperture):
+                                        content = Aperture.Topology(content)
                                     if useInternalVertex == True:
                                         vst2 = Topology.InternalVertex(content, tolerance)
                                     else:
@@ -2639,6 +3027,8 @@ class Graph:
                                 contents = []
                                 _ = vst.Contents(contents)
                                 for content in contents:
+                                    if isinstance(content, topologic.Aperture):
+                                        content = Aperture.Topology(content)
                                     if useInternalVertex == True:
                                         vst2 = Topology.InternalVertex(content, tolerance)
                                     else:
@@ -2680,6 +3070,8 @@ class Graph:
                         contents = []
                         _ = anEdge.Contents(contents)
                         for content in contents:
+                            if isinstance(content, topologic.Aperture):
+                                content = Aperture.Topology(content)
                             if useInternalVertex == True:
                                 vst = Topology.InternalVertex(content, tolerance)
                             else:
@@ -2830,6 +3222,8 @@ class Graph:
                                 contents = []
                                 _ = vst.Contents(contents)
                                 for content in contents:
+                                    if isinstance(content, topologic.Aperture):
+                                        content = Aperture.Topology(content)
                                     if useInternalVertex == True:
                                         vst2 = Topology.InternalVertex(content, tolerance)
                                     else:
@@ -2880,6 +3274,8 @@ class Graph:
                 contents = []
                 _ = topology.Contents(contents)
                 for content in contents:
+                    if isinstance(content, topologic.Aperture):
+                        content = Aperture.Topology(content)
                     if useInternalVertex == True:
                         vst = Topology.InternalVertex(content, tolerance)
                     else:
@@ -2929,7 +3325,6 @@ class Graph:
         if not isinstance(topology, topologic.Topology):
             print("Graph.ByTopology - Error: The input topology is not a valid topology. Returning None.")
             return None
-        topology = Topology.Copy(topology)
         graph = None
         item = [topology, None, None, None, direct, directApertures, viaSharedTopologies, viaSharedApertures, toExteriorTopologies, toExteriorApertures, toContents, None, useInternalVertex, storeBRep, tolerance]
         vertices = []
@@ -3172,7 +3567,7 @@ class Graph:
         for i, v in enumerate(vertices):
                 d = Topology.Dictionary(v)
                 d = Dictionary.SetValueAtKey(d, newKey, colors[i])
-                v = Topology.SetDictionary(v,d)
+                v = Topology.SetDictionary(v, d)
         return graph
     
     @staticmethod
@@ -3208,8 +3603,8 @@ class Graph:
             d1 = Vertex.Distance(vertex, sv)
             d2 = Vertex.Distance(vertex, ev)
             if d1 < d2:
-                return [ev,1]
-            return [sv,0]
+                return [ev, 1]
+            return [sv, 0]
         if not isinstance(graph, topologic.Graph):
             print("Graph.ContractEdge - Error: The input graph parameter is not a valid graph. Returning None.")
             return None
@@ -3699,6 +4094,177 @@ class Graph:
         except:
             return False
 
+    @staticmethod
+    def ExportToBOT(graph,
+                    path,
+                    format="turtle",
+                    overwrite = False,
+                    bidirectional=False,
+                    includeAttributes=False,
+                    includeLabel=False,
+                    siteLabel = "Site_0001",
+                    siteDictionary = None,
+                    buildingLabel = "Building_0001",
+                    buildingDictionary = None , 
+                    storeyPrefix = "Storey",
+                    floorLevels =[],
+                    labelKey="label",
+                    typeKey="type",
+                    sourceKey="source",
+                    targetKey="target",
+                    xKey = "x",
+                    yKey = "y",
+                    zKey = "z",
+                    spaceType = "space",
+                    wallType = "wall",
+                    slabType = "slab",
+                    doorType = "door",
+                    windowType = "window",
+                    contentType = "content",
+                    ):
+        
+        """
+        Returns an RDF graph serialized string according to the BOT ontology. See https://w3c-lbd-cg.github.io/bot/.
+
+        Parameters
+        ----------
+        graph : topologic.Graph
+            The input graph.
+        format : str , optional
+            The desired output format, the options are listed below. Thde default is "turtle".
+            turtle, ttl or turtle2 : Turtle, turtle2 is just turtle with more spacing & linebreaks
+            xml or pretty-xml : RDF/XML, Was the default format, rdflib < 6.0.0
+            json-ld : JSON-LD , There are further options for compact syntax and other JSON-LD variants
+            ntriples, nt or nt11 : N-Triples , nt11 is exactly like nt, only utf8 encoded
+            n3 : Notation-3 , N3 is a superset of Turtle that also caters for rules and a few other things
+            trig : Trig , Turtle-like format for RDF triples + context (RDF quads) and thus multiple graphs
+            trix : Trix , RDF/XML-like format for RDF quads
+            nquads : N-Quads , N-Triples-like format for RDF quads
+        path : str
+            The desired path to where the RDF/BOT file will be saved.
+        overwrite : bool , optional
+            If set to True, any existing file is overwritten. Otherwise, it is not. The default is False.
+        bidirectional : bool , optional
+            If set to True, reverse relationships are created wherever possible. Otherwise, they are not. The default is False.
+        includeAttributes : bool , optional
+            If set to True, the attributes associated with vertices in the graph are written out. Otherwise, they are not. The default is False.
+        includeLabel : bool , optional
+            If set to True, a label is attached to each node. Otherwise, it is not. The default is False.
+        siteLabel : str , optional
+            The desired site label. The default is "Site_0001".
+        siteDictionary : dict , optional
+            The dictionary of site attributes to include in the output. The default is None.
+        buildingLabel : str , optional
+            The desired building label. The default is "Building_0001".
+        buildingDictionary : dict , optional
+            The dictionary of building attributes to include in the output. The default is None.
+        storeyPrefix : str , optional
+            The desired prefixed to use for each building storey. The default is "Storey".
+        floorLevels : list , optional
+            The list of floor levels. This should be a numeric list, sorted from lowest to highest.
+            If not provided, floorLevels will be computed automatically based on the nodes' 'z' attribute.
+        typeKey : str , optional
+            The dictionary key to use to look up the type of the node. The default is "type".
+        labelKey : str , optional
+            The dictionary key to use to look up the label of the node. The default is "label".
+        sourceKey : str , optional
+            The desired dictionary key to use to store the source vertex. The default is "source".
+        targetKey : str , optional
+            The desired dictionary key to use to store the target vertex. The default is "target".
+        xKey : str , optional
+            The dictionary key to use to look up the x-coordinate of the node. The default is "x".
+        yKey : str , optional
+            The dictionary key to use to look up the y-coordinate of the node. The default is "y".
+        zKey : str , optional
+            The dictionary key to use to look up the z-coordinate of the node. The default is "z".
+        spaceType : str , optional
+            The dictionary string value to use to look up nodes of type "space". The default is "space".
+        wallType : str , optional
+            The dictionary string value to use to look up nodes of type "wall". The default is "wall".
+        slabType : str , optional
+            The dictionary string value to use to look up nodes of type "slab". The default is "slab".
+        doorType : str , optional
+            The dictionary string value to use to look up nodes of type "door". The default is "door".
+        windowType : str , optional
+            The dictionary string value to use to look up nodes of type "window". The default is "window".
+        contentType : str , optional
+            The dictionary string value to use to look up nodes of type "content". The default is "contents".
+        format : str , optional
+            The desired output format, the options are listed below. Thde default is "turtle".
+            turtle, ttl or turtle2 : Turtle, turtle2 is just turtle with more spacing & linebreaks
+            xml or pretty-xml : RDF/XML, Was the default format, rdflib < 6.0.0
+            json-ld : JSON-LD , There are further options for compact syntax and other JSON-LD variants
+            ntriples, nt or nt11 : N-Triples , nt11 is exactly like nt, only utf8 encoded
+            n3 : Notation-3 , N3 is a superset of Turtle that also caters for rules and a few other things
+            trig : Trig , Turtle-like format for RDF triples + context (RDF quads) and thus multiple graphs
+            trix : Trix , RDF/XML-like format for RDF quads
+            nquads : N-Quads , N-Triples-like format for RDF quads
+        
+        Returns
+        -------
+        str
+            The rdf graph serialized string using the BOT ontology.
+        """
+        from os.path import exists
+        bot_graph = Graph.BOTGraph(graph,
+                            bidirectional=bidirectional,
+                            includeAttributes=includeAttributes,
+                            includeLabel=includeLabel,
+                            siteLabel=siteLabel,
+                            siteDictionary=siteDictionary,
+                            buildingLabel=buildingLabel,
+                            buildingDictionary=buildingDictionary, 
+                            storeyPrefix=storeyPrefix,
+                            floorLevels=floorLevels,
+                            labelKey=labelKey,
+                            typeKey=typeKey,
+                            sourceKey=sourceKey,
+                            targetKey=targetKey,
+                            xKey=xKey,
+                            yKey=yKey,
+                            zKey=zKey,
+                            spaceType = spaceType,
+                            wallType = wallType,
+                            slabType = slabType,
+                            doorType = doorType,
+                            windowType = windowType,
+                            contentType = contentType
+                            )
+        if "turtle" in format.lower() or "ttl" in format.lower() or "turtle2" in format.lower():
+            ext = ".ttl"
+        elif "xml" in format.lower() or "pretty=xml" in format.lower() or "rdf/xml" in format.lower():
+            ext = ".xml"
+        elif "json" in format.lower():
+            ext = ".json"
+        elif "ntriples" in format.lower() or "nt" in format.lower() or "nt11" in format.lower():
+            ext = ".nt"
+        elif "n3" in format.lower() or "notation" in format.lower():
+            ext = ".n3"
+        elif "trig" in format.lower():
+            ext = ".trig"
+        elif "trix" in format.lower():
+            ext = ".trix"
+        elif "nquads" in format.lower():
+            ext = ".nquads"
+        else:
+            format = "turtle"
+            ext = ".ttl"
+        n = len(ext)
+        # Make sure the file extension is .brep
+        ext = path[len(path)-n:len(path)]
+        if ext.lower() != ext:
+            path = path+ext
+        if not overwrite and exists(path):
+            print("Graph.ExportToBOT - Error: a file already exists at the specified path and overwrite is set to False. Returning None.")
+            return None
+        status = False
+        try:
+            bot_graph.serialize(destination=path, format=format)
+            status = True
+        except:
+            status = False
+        return status
+    
     @staticmethod
     def ExportToCSV(graph, path, graphLabel, graphFeatures="",  
                        graphIDHeader="graph_id", graphLabelHeader="label", graphFeaturesHeader="feat",
@@ -3905,7 +4471,7 @@ class Graph:
                     flag = True
                 if nodeMaskKey in keys:
                     value = Dictionary.ValueAtKey(nd, nodeMaskKey)
-                    if not value in [0,1,2]:
+                    if not value in [0, 1, 2]:
                         flag = True
                     elif value == 0:
                         train_mask = True
@@ -3992,7 +4558,7 @@ class Graph:
                     flag = True
                 if edgeMaskKey in keys:
                     value = Dictionary.ValueAtKey(ed, edgeMaskKey)
-                    if not value in [0,1,2]:
+                    if not value in [0, 1, 2]:
                         flag = True
                     elif value == 0:
                         train_mask = True
@@ -4193,7 +4759,7 @@ class Graph:
                     source, target = edge_id
                     file.write(f'<edge id="{edge_id}" source="{source}" target="{target}" label="{edge_attrs["label"]}">\n')
                     if "color" in edge_attrs:
-                        r,g,b = Color.ByCSSNamedColor(edge_attrs["color"])
+                        r, g, b = Color.ByCSSNamedColor(edge_attrs["color"])
                         file.write(f'<viz:color r="{r}" g="{g}" b="{b}"/>\n')
                     file.write('<attvalues>\n')
                     keys = edge_attrs.keys()
@@ -4302,7 +4868,7 @@ class Graph:
             if not vertex_color in Color.CSSNamedColors():
                 vertex_color = defaultVertexColor
             node_dict['color'] = vertex_color
-            r,g,b = Color.ByCSSNamedColor(vertex_color)
+            r, g, b = Color.ByCSSNamedColor(vertex_color)
             node_dict['r'] = r
             node_dict['g'] = g
             node_dict['b'] = b
@@ -4370,7 +4936,7 @@ class Graph:
                 edge_color = defaultVertexColor
             edge_dict['color'] = edge_color
             
-            r,g,b = Color.ByCSSNamedColor(edge_color)
+            r, g, b = Color.ByCSSNamedColor(edge_color)
             edge_dict['r'] = r
             edge_dict['g'] = g
             edge_dict['b'] = b
@@ -4887,7 +5453,7 @@ class Graph:
         return graph.GetGUID()
 
     @staticmethod
-    def IncomingEdges(graph: topologic.Graph, vertex: topologic.Vertex, directed: bool=False, tolerance: float=0.0001) -> list:
+    def IncomingEdges(graph: topologic.Graph, vertex: topologic.Vertex, directed: bool = False, tolerance: float = 0.0001) -> list:
         """
         Returns the incoming edges connected to a vertex. An edge is considered incoming if its end vertex is
         coincident with the input vertex.
@@ -4928,7 +5494,7 @@ class Graph:
         return incoming_edges
     
     @staticmethod
-    def IncomingVertices(graph: topologic.Graph, vertex: topologic.Vertex, directed: bool=False, tolerance: float=0.0001) -> list:
+    def IncomingVertices(graph: topologic.Graph, vertex: topologic.Vertex, directed: bool = False, tolerance: float = 0.0001) -> list:
         """
         Returns the incoming vertices connected to a vertex. A vertex is considered incoming if it is an adjacent vertex to the input vertex
         and the the edge connecting it to the input vertex is an incoming edge.
@@ -5113,7 +5679,7 @@ class Graph:
         return vertices
     
     @staticmethod
-    def JSONData(graph, vertexLabelKey="", edgeLabelKey="", mantissa=6):
+    def JSONData(graph, vertexLabelKey="", edgeLabelKey="", sourceKey="source", targetKey="target", mantissa=6):
         """
         Converts the input graph into JSON data.
 
@@ -5127,6 +5693,10 @@ class Graph:
         edgeLabelKey : str , optional
             If set to a valid string, the edge label will be set to the value at this key. Otherwise it will be set to Edge_XXXX where XXXX is a sequential unique number.
             Note: If edge labels are not unique, they will be forced to be unique.
+        sourceKey : str , optional
+            The dictionary key used to store the source vertex. The default is "source".
+        targetKey : str , optional
+            The dictionary key used to store the target vertex. The default is "source".
         mantissa : int , optional
             The desired length of the mantissa. The default is 6.
 
@@ -5146,7 +5716,7 @@ class Graph:
         j_data = {}
         j_data['nodes'] = {}
         j_data['edges'] = {}
-        n = max(len(str(len(vertices))),4)
+        n = max(len(str(len(vertices))), 4)
         v_labels = []
         v_dicts = []
         for i, v in enumerate(vertices):
@@ -5179,8 +5749,8 @@ class Graph:
             ev_label = v_labels[evi]
             d = Topology.Dictionary(e)
             
-            d = Dictionary.SetValueAtKey(d, "source", sv_label)
-            d = Dictionary.SetValueAtKey(d, "target", ev_label)
+            d = Dictionary.SetValueAtKey(d, sourceKey, sv_label)
+            d = Dictionary.SetValueAtKey(d, targetKey, ev_label)
             e_dict = Dictionary.PythonDictionary(d)
             e_label = Dictionary.ValueAtKey(d, edgeLabelKey)
             if isinstance(e_label, str):
@@ -5534,7 +6104,7 @@ class Graph:
                 keys.append(residualKey)
                 values.append(residual)
                 d = Dictionary.ByKeysValues(keys, values)
-                edge = Topology.SetDictionary(edge,d)
+                edge = Topology.SetDictionary(edge, d)
         return max_flow
 
     @staticmethod
@@ -5551,8 +6121,8 @@ class Graph:
         -------
         dict
             The python dictionary of the mesh data of the input graph. The keys in the dictionary are:
-            'vertices' : The list of [x,y,z] coordinates of the vertices.
-            'edges' : the list of [i,j] indices into the vertices list to signify and edge that connects vertices[i] to vertices[j].
+            'vertices' : The list of [x, y, z] coordinates of the vertices.
+            'edges' : the list of [i, j] indices into the vertices list to signify and edge that connects vertices[i] to vertices[j].
             'vertexDictionaries' : The python dictionaries of the vertices (in the same order as the list of vertices).
             'edgeDictionaries' : The python dictionaries of the edges (in the same order as the list of edges).
 
@@ -5898,7 +6468,7 @@ class Graph:
         return len(Graph.Vertices(graph))
     
     @staticmethod
-    def OutgoingEdges(graph: topologic.Graph, vertex: topologic.Vertex, directed: bool=False, tolerance: float=0.0001) -> list:
+    def OutgoingEdges(graph: topologic.Graph, vertex: topologic.Vertex, directed: bool = False, tolerance: float = 0.0001) -> list:
         """
         Returns the outgoing edges connected to a vertex. An edge is considered outgoing if its start vertex is
         coincident with the input vertex.
@@ -5939,7 +6509,7 @@ class Graph:
         return outgoing_edges
     
     @staticmethod
-    def OutgoingVertices(graph: topologic.Graph, vertex: topologic.Vertex, directed: bool=False, tolerance: float=0.0001) -> list:
+    def OutgoingVertices(graph: topologic.Graph, vertex: topologic.Vertex, directed: bool = False, tolerance: float = 0.0001) -> list:
         """
         Returns the list of outgoing vertices connected to a vertex. A vertex is considered outgoing if it is an adjacent vertex to the input vertex
         and the the edge connecting it to the input vertex is an outgoing edge.
@@ -6537,7 +7107,7 @@ class Graph:
         zAxis : bool , optional
             If set to True the z axis is drawn. Otherwise it is not drawn. The default is False.
         axisSize : float , optional
-            The size of the X,Y,Z, axes. The default is 1.
+            The size of the X, Y, Z, axes. The default is 1.
         backgroundColor : str , optional
             The desired color of the background. This can be any plotly color string and may be specified as:
             - A hex string (e.g. '#ff0000')
@@ -6555,11 +7125,11 @@ class Graph:
         marginBottom : int , optional
             The size in pixels of the bottom margin. The default value is 0.
         camera : list , optional
-            The desired location of the camera). The default is [-1.25,-1.25,1.25].
+            The desired location of the camera). The default is [-1.25, -1.25, 1.25].
         center : list , optional
-            The desired center (camera target). The default is [0,0,0].
+            The desired center (camera target). The default is [0, 0, 0].
         up : list , optional
-            The desired up vector. The default is [0,0,1].
+            The desired up vector. The default is [0, 0, 1].
         projection : str , optional
             The desired type of projection. The options are "orthographic" or "perspective". It is case insensitive. The default is "perspective"
 
@@ -6735,7 +7305,7 @@ class Graph:
         return Graph.ByVerticesEdges(dictionary['vertices'], dictionary['edges'])
     
     @staticmethod
-    def VertexDegree(graph : topologic.Graph, vertex: topologic.Vertex, edgeKey: str=None, tolerance: float=0.0001):
+    def VertexDegree(graph : topologic.Graph, vertex: topologic.Vertex, edgeKey: str = None, tolerance: float = 0.0001):
         """
         Returns the degree of the input vertex. See https://en.wikipedia.org/wiki/Degree_(graph_theory).