topologicpy 0.8.36__py3-none-any.whl → 0.8.37__py3-none-any.whl

topologicpy/Cell.py

@@ -1122,6 +1122,7 @@ class Cell():
             width=1,
             length=1,
             height=1,
+            wSides=1,
             a=0.25,
             b=0.25,
             c=0.25,
@@ -1129,6 +1130,7 @@ class Cell():
             flipVertical = False,
             direction=[0,0,1],
             placement="center",
+            mantissa=6,
             tolerance=0.0001,
             silent=False):
         """
@@ -1144,16 +1146,24 @@ class Cell():
             The overall length of the C-shape. The default is 1.0.
         height : float , optional
             The overall height of the C-shape. The default is 1.0.
+        wSides : int , optional
+            The desired number of sides along the Z-axis. The default is 1.
         a : float , optional
             The hortizontal thickness of the vertical arm of the C-shape. The default is 0.25.
         b : float , optional
             The vertical thickness of the bottom horizontal arm of the C-shape. The default is 0.25.
         c : float , optional
             The vertical thickness of the top horizontal arm of the C-shape. The default is 0.25.
+        flipHorizontal : bool , optional
+            if set to True, the shape is flipped horizontally. The default is False.
+        flipVertical : bool , optional
+            if set to True, the shape is flipped vertically. The default is False.
         direction : list , optional
             The vector representing the up direction of the C-shape. The default is [0, 0, 1].
         placement : str , optional
             The description of the placement of the origin of the C-shape. This can be "center", "lowerleft", "upperleft", "lowerright", "upperright". It is case insensitive. The default is "center".
+        mantissa: int , optional
+            The desired length of the mantissa. The default is 6.
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
         silent : bool , optional
@@ -1166,7 +1176,7 @@ class Cell():
 
         """
         from topologicpy.Vertex import Vertex
-        from topologicpy.Face import Face
+        from topologicpy.Wire import Wire
         from topologicpy.Topology import Topology
 
         if not isinstance(width, int) and not isinstance(width, float):
@@ -1234,8 +1244,8 @@ class Cell():
         if not len(direction) == 3:
             if not silent:
                 print("Cell.CShape - Error: The direction input parameter is not a valid vector. Returning None.")
-            return None
-        c_shape_face = Face.CShape(origin=origin,
+            return None        
+        c_shape_wire = Wire.CShape(origin=origin,
                                    width=width,
                                    length=length,
                                    a=a,
@@ -1247,9 +1257,12 @@ class Cell():
                                    placement="center",
                                    tolerance=tolerance,
                                    silent=silent)
-        
-        return_cell = Cell.ByThickenedFace(c_shape_face, thickness=height, bothSides=True, reverse=False,
-                            planarize = False, tolerance=tolerance, silent=silent)
+        distance = height/wSides
+        wires = [c_shape_wire]
+        for i in range(wSides):
+            c_shape_wire = Topology.Translate(c_shape_wire, 0, 0, distance)
+            wires.append(c_shape_wire)
+        return_cell = Cell.ByWires(wires, triangulate=False, mantissa=mantissa, tolerance=tolerance, silent=silent)
         xOffset = 0
         yOffset = 0
         zOffset = 0
@@ -1972,18 +1985,20 @@ class Cell():
     
     @staticmethod
     def IShape(origin=None,
-            width=1,
-            length=1,
-            height=1,
-            a=0.25,
-            b=0.25,
-            c=0.25,
-            flipHorizontal = False,
-            flipVertical = False,
-            direction=[0,0,1],
-            placement="center",
-            tolerance=0.0001,
-            silent=False):
+            width: float = 1,
+            length: float = 1,
+            height: float = 1,
+            wSides: int = 1,
+            a: float = 0.25,
+            b: float = 0.25,
+            c: float = 0.25,
+            flipHorizontal: bool = False,
+            flipVertical: bool = False,
+            direction: list = [0,0,1],
+            placement: str = "center",
+            mantissa: int = 6,
+            tolerance: float = 0.0001,
+            silent: bool = False):
         """
         Creates an I-shape cell.
 
@@ -1995,16 +2010,26 @@ class Cell():
             The overall width of the I-shape. The default is 1.0.
         length : float , optional
             The overall length of the I-shape. The default is 1.0.
+        height : float , optional
+            The overall height of the I-shape. The default is 1.0.
+        wSides : int , optional
+            The desired number of sides along the Z-Axis. The default is 1.
         a : float , optional
             The hortizontal thickness of the central vertical arm of the I-shape. The default is 0.25.
         b : float , optional
             The vertical thickness of the bottom horizontal arm of the I-shape. The default is 0.25.
         c : float , optional
             The vertical thickness of the top horizontal arm of the I-shape. The default is 0.25.
+        flipHorizontal : bool , optional
+            if set to True, the shape is flipped horizontally. The default is False.
+        flipVertical : bool , optional
+            if set to True, the shape is flipped vertically. The default is False.
         direction : list , optional
             The vector representing the up direction of the I-shape. The default is [0, 0, 1].
         placement : str , optional
             The description of the placement of the origin of the I-shape. This can be "center", "bottom", "top", "lowerleft", "upperleft", "lowerright", "upperright". It is case insensitive. The default is "center".
+        mantissa : int , optional
+            The desired length of the mantissa. The default is 6.
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
         silent : bool , optional
@@ -2017,7 +2042,7 @@ class Cell():
 
         """
         from topologicpy.Vertex import Vertex
-        from topologicpy.Face import Face
+        from topologicpy.Wire import Wire
         from topologicpy.Topology import Topology
 
         if not isinstance(width, int) and not isinstance(width, float):
@@ -2074,7 +2099,7 @@ class Cell():
             if not silent:
                 print("Cell.IShape - Error: The direction input parameter is not a valid vector. Returning None.")
             return None
-        i_shape_face = Face.IShape(origin=origin,
+        i_shape_wire = Wire.IShape(origin=origin,
                                    width=width,
                                    length=length,
                                    a=a,
@@ -2082,12 +2107,18 @@ class Cell():
                                    c=c,
                                    flipHorizontal=flipHorizontal,
                                    flipVertical=flipVertical,
-                                   direction=direction,
-                                   placement=placement,
+                                   direction=[0,0,1],
+                                   placement="center",
                                    tolerance=tolerance,
                                    silent=silent)
-        return_cell = Cell.ByThickenedFace(i_shape_face, thickness=height, bothSides=True, reverse=False,
-                            planarize = False, tolerance=tolerance, silent=silent)
+        distance = height/wSides
+        wires = [i_shape_wire]
+        for i in range(wSides):
+            i_shape_wire = Topology.Translate(i_shape_wire, 0, 0, distance)
+            wires.append(i_shape_wire)
+        return_cell = Cell.ByWires(wires, triangulate=False, mantissa=mantissa, tolerance=tolerance, silent=silent)
+        # move down to center
+        return_cell = Topology.Translate(return_cell, 0, 0, -height*0.5)
         xOffset = 0
         yOffset = 0
         zOffset = 0
@@ -2156,12 +2187,14 @@ class Cell():
             width=1,
             length=1,
             height=1,
+            wSides=1,
             a=0.25,
             b=0.25,
             flipHorizontal = False,
             flipVertical = False,
             direction=[0,0,1],
             placement="center",
+            mantissa=6,
             tolerance=0.0001,
             silent=False):
         """
@@ -2177,14 +2210,22 @@ class Cell():
             The overall length of the L-shape. The default is 1.0.
         height : float , optional
             The overall height of the L-shape. The default is 1.0.
+        wSides : int , optional
+            The desired number of sides along the Z-axis. The default is 1.
         a : float , optional
             The hortizontal thickness of the vertical arm of the L-shape. The default is 0.25.
         b : float , optional
             The vertical thickness of the horizontal arm of the L-shape. The default is 0.25.
+        flipHorizontal : bool , optional
+            if set to True, the shape is flipped horizontally. The default is False.
+        flipVertical : bool , optional
+            if set to True, the shape is flipped vertically. The default is False.
         direction : list , optional
             The vector representing the up direction of the L-shape. The default is [0, 0, 1].
         placement : str , optional
             The description of the placement of the origin of the L-shape. This can be "center", "bottom", "top", "lowerleft", "upperleft", "lowerright", "upperright". It is case insensitive. The default is "center".
+        manitssa : int , optional
+            The desired length of the mantissa. The default is 6.
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
         silent : bool , optional
@@ -2197,7 +2238,7 @@ class Cell():
 
         """
         from topologicpy.Vertex import Vertex
-        from topologicpy.Face import Face
+        from topologicpy.Wire import Wire
         from topologicpy.Topology import Topology
 
         if not isinstance(width, int) and not isinstance(width, float):
@@ -2262,7 +2303,7 @@ class Cell():
             if not silent:
                 print("Cell.LShape - Error: The direction input parameter is not a valid vector. Returning None.")
             return None
-        l_shape_face = Face.LShape(origin=origin,
+        l_shape_wire = Wire.LShape(origin=origin,
                                    width=width,
                                    length=length,
                                    a=a,
@@ -2273,9 +2314,12 @@ class Cell():
                                    placement="center",
                                    tolerance=tolerance,
                                    silent=silent)
-        
-        return_cell = Cell.ByThickenedFace(l_shape_face, thickness=height, bothSides=True, reverse=False,
-                            planarize = False, tolerance=tolerance, silent=silent)
+        distance = height/wSides
+        wires = [l_shape_wire]
+        for i in range(wSides):
+            l_shape_wire = Topology.Translate(l_shape_wire, 0, 0, distance)
+            wires.append(l_shape_wire)
+        return_cell = Cell.ByWires(wires, triangulate=False, mantissa=mantissa, tolerance=tolerance, silent=silent)
         xOffset = 0
         yOffset = 0
         zOffset = 0
@@ -3326,12 +3370,14 @@ class Cell():
             width=1,
             length=1,
             height=1,
+            wSides=1,
             a=0.25,
             b=0.25,
             flipHorizontal = False,
             flipVertical = False,
             direction=[0,0,1],
             placement="center",
+            mantissa=6,
             tolerance=0.0001,
             silent=False):
         """
@@ -3347,14 +3393,22 @@ class Cell():
             The overall length of the T-shape. The default is 1.0.
         height : float , optional
             the overall height of the T-shape. The default is 1.0.
+        wSides : int , optional
+            The desired number of sides along the Z-axis. The default is 1.
         a : float , optional
             The hortizontal thickness of the vertical arm of the T-shape. The default is 0.25.
         b : float , optional
             The vertical thickness of the horizontal arm of the T-shape. The default is 0.25.
+        flipHorizontal : bool , optional
+            if set to True, the shape is flipped horizontally. The default is False.
+        flipVertical : bool , optional
+            if set to True, the shape is flipped vertically. The default is False.
         direction : list , optional
             The vector representing the up direction of the T-shape. The default is [0, 0, 1].
         placement : str , optional
             The description of the placement of the origin of the T-shape. This can be "center", "lowerleft", "upperleft", "lowerright", "upperright". It is case insensitive. The default is "center".
+        mantissa: int , optional
+            The desired length of the mantissa. The default is 6.
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
         silent : bool , optional
@@ -3367,7 +3421,7 @@ class Cell():
 
         """
         from topologicpy.Vertex import Vertex
-        from topologicpy.Face import Face
+        from topologicpy.Wire import Wire
         from topologicpy.Topology import Topology
 
         if not isinstance(width, int) and not isinstance(width, float):
@@ -3424,19 +3478,26 @@ class Cell():
             if not silent:
                 print("Cell.TShape - Error: The direction input parameter is not a valid vector. Returning None.")
             return None
-        t_shape_face = Face.TShape(origin=origin,
+        t_shape_wire = Wire.TShape(origin=origin,
                                    width=width,
                                    length=length,
                                    a=a,
                                    b=b,
                                    flipHorizontal=flipHorizontal,
                                    flipVertical=flipVertical,
-                                   direction=direction,
-                                   placement=placement,
+                                   direction=[0,0,1],
+                                   placement="center",
                                    tolerance=tolerance,
                                    silent=silent)
-        return_cell = Cell.ByThickenedFace(t_shape_face, thickness=height, bothSides=True, reverse=False,
-                            planarize = False, tolerance=tolerance, silent=silent)
+
+        distance = height/wSides
+        wires = [t_shape_wire]
+        for i in range(wSides):
+            t_shape_wire = Topology.Translate(t_shape_wire, 0, 0, distance)
+            wires.append(t_shape_wire)
+        return_cell = Cell.ByWires(wires, triangulate=False, mantissa=mantissa, tolerance=tolerance, silent=silent)
+        # move down to center
+        return_cell = Topology.Translate(return_cell, 0, 0, -height*0.5)
         xOffset = 0
         yOffset = 0
         zOffset = 0

topologicpy/Face.py

@@ -2080,6 +2080,10 @@ class Face():
             The vertical thickness of the bottom horizontal arm of the I-shape. The default is 0.25.
         c : float , optional
             The vertical thickness of the top horizontal arm of the I-shape. The default is 0.25.
+        flipHorizontal : bool , optional
+            if set to True, the shape is flipped horizontally. The default is False.
+        flipVertical : bool , optional
+            if set to True, the shape is flipped vertically. The default is False.
         direction : list , optional
             The vector representing the up direction of the I-shape. The default is [0, 0, 1].
         placement : str , optional

topologicpy/Graph.py

@@ -723,6 +723,68 @@ class Graph:
                     matrix[evi][svi] = valueBwd
         return matrix
     
+
+    @staticmethod
+    def AdjacencyMatrixCSVString(graph, vertexKey=None, reverse=False, edgeKeyFwd=None, edgeKeyBwd=None, bidirKey=None, bidirectional=True, useEdgeIndex=False, useEdgeLength=False, mantissa: int = 6, tolerance=0.0001):
+        """
+        Returns the adjacency matrix CSV string of the input Graph. See https://en.wikipedia.org/wiki/Adjacency_matrix.
+
+        Parameters
+        ----------
+        graph : topologic_core.Graph
+            The input graph.
+        vertexKey : str , optional
+            If set, the returned list of vertices is sorted according to the dictionary values stored under this key. The default is None.
+        reverse : bool , optional
+            If set to True, the vertices are sorted in reverse order (only if vertexKey is set). Otherwise, they are not. The default is False.
+        edgeKeyFwd : str , optional
+            If set, the value at this key in the connecting edge from start vertex to end vertex (forward) will be used instead of the value 1. The default is None. useEdgeIndex and useEdgeLength override this setting.
+        edgeKeyBwd : str , optional
+            If set, the value at this key in the connecting edge from end vertex to start vertex (backward) will be used instead of the value 1. The default is None. useEdgeIndex and useEdgeLength override this setting.
+        bidirKey : bool , optional
+            If set to True or False, this key in the connecting edge will be used to determine is the edge is supposed to be bidirectional or not. If set to None, the input variable bidrectional will be used instead. The default is None
+        bidirectional : bool , optional
+            If set to True, the edges in the graph that do not have a bidireKey in their dictionaries will be treated as being bidirectional. Otherwise, the start vertex and end vertex of the connecting edge will determine the direction. The default is True.
+        useEdgeIndex : bool , optional
+            If set to True, the adjacency matrix values will the index of the edge in Graph.Edges(graph). The default is False. Both useEdgeIndex, useEdgeLength should not be True at the same time. If they are, useEdgeLength will be used.
+        useEdgeLength : bool , optional
+            If set to True, the adjacency matrix values will the length of the edge in Graph.Edges(graph). The default is False. Both useEdgeIndex, useEdgeLength should not be True at the same time. If they are, useEdgeLength will be used.
+        mantissa : int , optional
+            The desired length of the mantissa. The default is 6.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
+
+        Returns
+        -------
+        str
+            A string in CSV format representing the adjacency matrix.
+            Returns an empty string if conversion fails.
+        """
+        import io
+
+        adj_matrix = Graph.AdjacencyMatrix(graph,
+                                           vertexKey=vertexKey,
+                                           reverse=reverse,
+                                           edgeKeyFwd=edgeKeyFwd,
+                                           edgeKeyBwd=edgeKeyBwd,
+                                           bidirKey=bidirKey,
+                                           bidirectional=bidirectional,
+                                           useEdgeIndex=useEdgeIndex,
+                                           useEdgeLength=useEdgeLength,
+                                           mantissa=mantissa,
+                                           tolerance=tolerance)
+
+        try:
+            # Convert the adjacency matrix (nested list) to a DataFrame
+            adjacency_matrix_df = pd.DataFrame(adj_matrix)
+
+            # Use a buffer to get the CSV output as a string
+            csv_buffer = io.StringIO()
+            adjacency_matrix_df.to_csv(csv_buffer, index=False, header=False)
+            return csv_buffer.getvalue()
+        except Exception as e:
+            return ""
+        
     @staticmethod
     def AdjacencyList(graph, vertexKey=None, reverse=True, tolerance=0.0001):
         """
@@ -9465,6 +9527,267 @@ class Graph:
 
         return True
 
+    @staticmethod
+    def JSONLDData(graph, context=None, verticesKey="nodes", edgesKey="edges", labelKey="label", sourceKey="source", targetKey="target", categoryKey="category", xKey="x", yKey="y", zKey="z", mantissa=6):
+        """
+        Exports the Graph to a JSON-LD representation.
+
+        Parameters
+        ----------
+        graph : topologic_core.Graph
+            The TopologicPy Graph object to export.
+        context : dict, optional
+            A JSON-LD context mapping TopologicPy keys to IRIs (e.g., schema.org, geo, etc.).
+        verticesKey : str , optional
+            The desired key name to call vertices. The default is "vertices".
+        edgesKey : str , optional
+            The desired key name to call edges. The default is "edges".
+        labelKey : str , optional
+            The desired key name to use for label. The default is "label".
+        sourceKey : str , optional
+            The desired key name to use for source. The default is "source".
+        targetKey : str , optional
+            The desired key name to use for target. The default is "target".
+        categoryKey : str , optional
+            The desired key name to use for lcategoryabel. The default is "category".
+        xKey : str , optional
+            The desired key name to use for x-coordinates. The default is "x".
+        yKey : str , optional
+            The desired key name to use for y-coordinates. The default is "y".
+        zKey : str , optional
+            The desired key name to use for z-coordinates. The default is "z".
+        mantissa : int , optional
+            The desired length of the mantissa. The default is 6.
+        
+        Returns
+        -------
+        dict
+            A JSON-LD representation of the graph.
+        """
+        from topologicpy.Graph import Graph
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Edge import Edge
+        from topologicpy.Topology import Topology
+        from topologicpy.Dictionary import Dictionary
+
+        if context is None:
+            context = {
+                labelKey: "rdfs:"+labelKey,
+                categoryKey: "schema:"+categoryKey,
+                xKey: "schema:"+xKey,
+                yKey: "schema:"+yKey,
+                zKey: "schema:"+zKey,
+                "Graph": "https://topologic.app/vocab#Graph",
+                "Vertex": "https://topologic.app/vocab#Vertex",
+                "Edge": "https://topologic.app/vocab#Edge"
+            }
+
+        
+        # Helper: Serialize a Vertex
+        def serialize_vertex(vertex):
+            props = Dictionary.PythonDictionary(Topology.Dictionary(vertex))
+            coords = Vertex.Coordinates(vertex, mantissa=mantissa)
+            props.update({
+                "@type": "Vertex",
+                xKey: coords[0],
+                yKey: coords[1],
+                zKey: coords[2],
+            })
+            props["@id"] = Topology.UUID(vertex)
+            return props
+
+        # Helper: Serialize an Edge
+        def serialize_edge(edge, tp_edge, edge_dict, s_vertices):
+            sv = edge[0]
+            ev = edge[1]
+            edge_dict.update({
+                "@type": "Edge",
+                sourceKey: s_vertices[sv]["@id"],
+                targetKey: s_vertices[ev]["@id"]
+            })
+            edge_dict["@id"] = Topology.UUID(tp_edge)
+            return edge_dict
+
+        # Assemble graph
+        jsonld = {
+            "@context": context,
+            "@id": Topology.UUID(graph),
+            "@type": "Graph",
+            verticesKey: [],
+            edgesKey: []
+        }
+
+        vertices = Graph.Vertices(graph)
+        tp_edges = Graph.Edges(graph)
+        mesh_data = Graph.MeshData(graph)
+        m_edges = mesh_data['edges']
+        edge_dicts = mesh_data['edgeDictionaries']
+
+        s_vertices = []
+        for v in vertices:
+            sv = serialize_vertex(v)
+            s_vertices.append(sv)
+            jsonld[verticesKey].append(sv)
+
+        for i, tp_edge in enumerate(tp_edges):
+            se = serialize_edge(m_edges[i], tp_edge, edge_dicts[i], s_vertices)
+            jsonld[edgesKey].append(se)
+
+        return jsonld
+
+    @staticmethod
+    def JSONLDString(graph, context=None, verticesKey="nodes", edgesKey="edges", labelKey="label", sourceKey="source", targetKey="target", categoryKey="category", xKey="x", yKey="y", zKey="z", indent=2, sortKeys=False, mantissa=6):
+        """
+        Converts the input graph into a JSON-LD string.
+
+        Parameters
+        ----------
+        graph : topologic_core.Graph
+            The TopologicPy Graph object to export.
+        context : dict, optional
+            A JSON-LD context mapping TopologicPy keys to IRIs (e.g., schema.org, geo, etc.)
+        context : dict, optional
+            A JSON-LD context mapping TopologicPy keys to IRIs (e.g., schema.org, geo, etc.).
+        verticesKey : str , optional
+            The desired key name to call vertices. The default is "vertices".
+        edgesKey : str , optional
+            The desired key name to call edges. The default is "edges".
+        labelKey : str , optional
+            The desired key name to use for label. The default is "label".
+        sourceKey : str , optional
+            The desired key name to use for source. The default is "source".
+        targetKey : str , optional
+            The desired key name to use for target. The default is "target".
+        categoryKey : str , optional
+            The desired key name to use for lcategoryabel. The default is "category".
+        xKey : str , optional
+            The desired key name to use for x-coordinates. The default is "x".
+        yKey : str , optional
+            The desired key name to use for y-coordinates. The default is "y".
+        zKey : str , optional
+            The desired key name to use for z-coordinates. The default is "z".
+        indent : int , optional
+            The desired indent. The default is 2.
+        sortKeys : bool , optional
+            If set to True, the keys will be sorted. Otherwise, they won't be. The default is False.
+        mantissa : int , optional
+            The desired length of the mantissa. The default is 6.
+        Returns
+        -------
+        dict
+            A JSON-LD representation of the graph.
+        """
+        import json
+        jsonld_data = Graph.JSONLDData(graph,
+                                context=context,
+                                verticesKey=verticesKey,
+                                edgesKey=edgesKey,
+                                labelKey=labelKey,
+                                sourceKey=sourceKey,
+                                targetKey=targetKey,
+                                categoryKey=categoryKey,
+                                xKey=xKey,
+                                yKey=yKey,
+                                zKey=zKey,
+                                mantissa=mantissa)
+        return json.dumps(jsonld_data, indent=indent, ort_keys=sortKeys)
+
+    @staticmethod
+    def ExportToJSONLD(graph,
+                       path,
+                       context=None,
+                       verticesKey="nodes",
+                       edgesKey="edges",
+                       labelKey="label",
+                       sourceKey="source",
+                       targetKey="target",
+                       categoryKey="category",
+                       xKey="x",
+                       yKey="y",
+                       zKey="z",
+                       indent=2,
+                       sortKeys=False,
+                       mantissa=6,
+                       overwrite=False):
+        """
+        Exports the input graph to a JSON file.
+
+        Parameters
+        ----------
+        graph : topologic_core.Graph
+            The input graph.
+        path : str
+            The path to the JSON file.
+        verticesKey : str , optional
+            The desired key name to call vertices. The default is "vertices".
+        edgesKey : str , optional
+            The desired key name to call edges. The default is "edges".
+        vertexLabelKey : str , optional
+            If set to a valid string, the vertex label will be set to the value at this key. Otherwise it will be set to Vertex_XXXX where XXXX is a sequential unique number.
+            Note: If vertex labels are not unique, they will be forced to be unique.
+        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.
+        xKey : str , optional
+            The desired key name to use for x-coordinates. The default is "x".
+        yKey : str , optional
+            The desired key name to use for y-coordinates. The default is "y".
+        zKey : str , optional
+            The desired key name to use for z-coordinates. The default is "z".
+        indent : int , optional
+            The desired amount of indent spaces to use. The default is 4.
+        sortKeys : bool , optional
+            If set to True, the keys will be sorted. Otherwise, they won't be. The default is False.
+        mantissa : int , optional
+            The desired length of the mantissa. The default is 6.
+        overwrite : bool , optional
+            If set to True the ouptut file will overwrite any pre-existing file. Otherwise, it won't. The default is False.
+
+        Returns
+        -------
+        bool
+            The status of exporting the JSON file. If True, the operation was successful. Otherwise, it was unsuccesful.
+
+        """
+        import json
+        from os.path import exists
+        # Make sure the file extension is .json
+        ext = path[len(path)-5:len(path)]
+        if ext.lower() != ".json":
+            path = path+".json"
+        if not overwrite and exists(path):
+            print("Graph.ExportToJSONLD - Error: a file already exists at the specified path and overwrite is set to False. Returning None.")
+            return None
+        f = None
+        try:
+            if overwrite == True:
+                f = open(path, "w")
+            else:
+                f = open(path, "x") # Try to create a new File
+        except:
+            raise Exception("Graph.ExportToJSONLD - Error: Could not create a new file at the following location: "+path)
+        if (f):
+            jsonld_data = Graph.JSONLDData(graph,
+                                context=context,
+                                verticesKey=verticesKey,
+                                edgesKey=edgesKey,
+                                labelKey=labelKey,
+                                sourceKey=sourceKey,
+                                targetKey=targetKey,
+                                categoryKey=categoryKey,
+                                xKey=xKey,
+                                yKey=yKey,
+                                zKey=zKey,
+                                mantissa=mantissa)
+            if jsonld_data != None:
+                json.dump(jsonld_data, f, indent=indent, sort_keys=sortKeys)
+                f.close()
+                return True
+            else:
+                f.close()
+                return False
+        return False
+
     @staticmethod
     def JSONData(graph,
                  verticesKey: str = "vertices",
@@ -9597,7 +9920,7 @@ class Graph:
                    sortKeys=False,
                    mantissa=6):
         """
-        Converts the input graph into JSON data.
+        Converts the input graph into a JSON string.
 
         Parameters
         ----------
@@ -9991,58 +10314,269 @@ class Graph:
             longest_path = Topology.SetDictionary(longest_path, d)
         return longest_path
 
-    @staticmethod
-    def Match(graphA, graphB, vertexKey: str = None, silent: bool = False):
+    def Match(graphA, graphB, vertexKeys: list = None, edgeKeys: list = None, maxMatches: int = 10, timeLimit: int = 10, tolerance: float = 0.0, silent: bool = False):
         """
-        Matches two input graphs using isomorphism coupled with semantic matching.
+        Matches graphA as a subgraph of graphB using structural and semantic similarity.
 
         Parameters
         ----------
         graphA : topologic_core.Graph
-            The first input graph. This should be the smaller sub-graph or a graph isomorphice with the second input graph.
+            The smaller graph (subgraph).
         graphB : topologic_core.Graph
-            The second input graph.
-        vertexKey : str , optional
-            If set, the dictionaries of the vertices will be searched for this key and their values matched.
-        silent : bool , optional
-            If set to True, error and warning messages are suppressed. The default is False.
+            The larger graph (supergraph).
+        vertexKeys : str or list of str, optional
+            Keys used to semantically compare vertices.
+        edgeKeys : str or list of str, optional
+            Keys used to semantically compare edges.
+        maxMatches : int , optional
+            The maximum number of matches to find. The default is 10.
+        timeLimit : int , optional
+                The time limit in seconds. The default is 10 seconds. Note that this time limit only applies to finding the matches.
+        tolerance : float, optional
+            Allowed numeric deviation or minimum string similarity (e.g. 0.2 = ≥80% match). Default is 0.
+        silent : bool, optional
+            If True, suppresses warnings and errors.
 
         Returns
         -------
-        list
-            A list of dictionaries that match the vertices of graphA to the vertices of graphB.
+        list of dict
+            List of mappings from node index in graphA to graphB, sorted by descending similarity.
         """
-        
         import networkx as nx
         from topologicpy.Topology import Topology
+        from topologicpy.Graph import Graph
+        from topologicpy.Helper import Helper
+        from difflib import SequenceMatcher
+        import time
 
-        if not Topology.IsInstance(graphA, "graph"):
-            if not silent:
-                print("Graph.Map - Error: The graphA input parameter is not a valid graph. Returning None.")
-            return None
-        
-        if not Topology.IsInstance(graphB, "graph"):
+        def string_similarity(s1, s2):
+            return SequenceMatcher(None, s1.lower(), s2.lower()).ratio()
+
+        if not Topology.IsInstance(graphA, "Graph") or not Topology.IsInstance(graphB, "Graph"):
             if not silent:
-                print("Graph.Map - Error: The graphB input parameter is not a valid graph. Returning None.")
+                print("Graph.Match - Error: One or both inputs are not valid Graphs.")
             return None
 
+        # Normalize keys
+        if isinstance(vertexKeys, str):
+            vertexKeys = [vertexKeys]
+        if isinstance(edgeKeys, str):
+            edgeKeys = [edgeKeys]
+
         nx_ga = Graph.NetworkXGraph(graphA)
         nx_gb = Graph.NetworkXGraph(graphB)
 
+        def similarity_score(val1, val2):
+            try:
+                v1 = float(val1)
+                v2 = float(val2)
+                if v1 == 0:
+                    return 1.0 if abs(v2) <= tolerance else 0.0
+                diff = abs(v1 - v2) / abs(v1)
+                return max(0.0, 1.0 - diff)
+            except (ValueError, TypeError):
+                return string_similarity(str(val1), str(val2))
+
+        def compute_mapping_score(mapping):
+            total_score = 0
+            count = 0
+
+            # Score vertices
+            for i_b, i_a in mapping.items():
+                a_attrs = nx_ga.nodes[i_a]
+                b_attrs = nx_gb.nodes[i_b]
+                if vertexKeys:
+                    for key in vertexKeys:
+                        if key in a_attrs and key in b_attrs:
+                            score = similarity_score(a_attrs[key], b_attrs[key])
+                            total_score += score
+                            count += 1
+
+            # Score edges
+            for (i_a1, i_a2) in nx_ga.edges:
+                if i_a1 in mapping and i_a2 in mapping:
+                    j_b1 = mapping[i_a1]
+                    j_b2 = mapping[i_a2]
+                    if nx_gb.has_edge(j_b1, j_b2):
+                        a_attrs = nx_ga.get_edge_data(i_a1, i_a2)
+                        b_attrs = nx_gb.get_edge_data(j_b1, j_b2)
+                        if edgeKeys:
+                            for key in edgeKeys:
+                                if key in a_attrs and key in b_attrs:
+                                    score = similarity_score(a_attrs[key], b_attrs[key])
+                                    total_score += score
+                                    count += 1
+
+            return total_score / count if count > 0 else 1.0
+
         def node_match(n1, n2):
-            if vertexKey:
-                return str(n1.get(vertexKey)) == str(n2.get(vertexKey))
-            return True  # topology-only match
+            if vertexKeys:
+                for key in vertexKeys:
+                    if key not in n1 or key not in n2:
+                        return False
+                    sim = similarity_score(n1[key], n2[key])
+                    if sim < (1.0 - tolerance):
+                        return False
+            return True
+
+        def edge_match(e1, e2):
+            if edgeKeys:
+                for key in edgeKeys:
+                    if key not in e1 or key not in e2:
+                        return False
+                    sim = similarity_score(e1[key], e2[key])
+                    if sim < (1.0 - tolerance):
+                        return False
+            return True
 
         matcher = nx.algorithms.isomorphism.GraphMatcher(
-            nx_gb, nx_ga, node_match=node_match if vertexKey else None
+            nx_gb, nx_ga,
+            node_match=node_match if vertexKeys else None,
+            edge_match=edge_match if edgeKeys else None
         )
 
-        matches = list(matcher.subgraph_isomorphisms_iter())
-        if not matches and not silent:
+        start = time.time()
+        raw_matches = []
+        for i, m in enumerate(matcher.subgraph_isomorphisms_iter()):
+            raw_matches.append(m)
+            elapsed_time = time.time() - start
+            if i + 1 >= maxMatches or elapsed_time >= timeLimit:
+                break
+        
+        if not raw_matches and not silent:
             print("Graph.Match - Warning: No subgraph isomorphisms found.")
-        return matches
+            return []
 
+        scores = [compute_mapping_score(m) for m in raw_matches]
+        sorted_matches = Helper.Sort(raw_matches, scores, reverseFlags=[True])
+        return sorted_matches
+
+    # @staticmethod
+    # def Match(graphA, graphB, vertexKeys=None, edgeKeys=None, tolerance: float = 0.0, silent: bool = False):
+    #     """
+    #     Matches graphA as a subgraph of graphB using structural and semantic similarity.
+
+    #     Parameters
+    #     ----------
+    #     graphA : topologic_core.Graph
+    #         The smaller graph (subgraph).
+    #     graphB : topologic_core.Graph
+    #         The larger graph (supergraph).
+    #     vertexKeys : str or list of str, optional
+    #         Keys used to semantically compare vertices.
+    #     edgeKeys : str or list of str, optional
+    #         Keys used to semantically compare edges.
+    #     tolerance : float, optional
+    #         Allowed numeric deviation or minimum string similarity (e.g. 0.2 = ≥80% match). Default is 0.
+    #     silent : bool, optional
+    #         If True, suppresses warnings and errors.
+
+    #     Returns
+    #     -------
+    #     list of dict
+    #         List of mappings from node index in graphA to graphB, sorted by descending similarity.
+    #     """
+    #     import networkx as nx
+    #     from topologicpy.Topology import Topology
+    #     from topologicpy.Graph import Graph
+    #     from topologicpy.Helper import Helper
+    #     from difflib import SequenceMatcher
+
+    #     def string_similarity(s1, s2):
+    #         return SequenceMatcher(None, s1.lower(), s2.lower()).ratio()
+
+    #     if not Topology.IsInstance(graphA, "Graph") or not Topology.IsInstance(graphB, "Graph"):
+    #         if not silent:
+    #             print("Graph.Match - Error: One or both inputs are not valid Graphs.")
+    #         return None
+
+    #     # Normalize keys
+    #     if isinstance(vertexKeys, str):
+    #         vertexKeys = [vertexKeys]
+    #     if isinstance(edgeKeys, str):
+    #         edgeKeys = [edgeKeys]
+
+    #     nx_ga = Graph.NetworkXGraph(graphA)
+    #     nx_gb = Graph.NetworkXGraph(graphB)
+
+    #     def similarity_score(val1, val2):
+    #         try:
+    #             v1 = float(val1)
+    #             v2 = float(val2)
+    #             if v1 == 0:
+    #                 return 1.0 if abs(v2) <= tolerance else 0.0
+    #             diff = abs(v1 - v2) / abs(v1)
+    #             return max(0.0, 1.0 - diff)
+    #         except (ValueError, TypeError):
+    #             return string_similarity(str(val1), str(val2))
+
+    #     def compute_mapping_score(mapping):
+    #         total_score = 0
+    #         count = 0
+
+    #         # Score vertices
+    #         for i_a, i_b in mapping.items():
+    #             a_attrs = nx_ga.nodes[i_a]
+    #             b_attrs = nx_gb.nodes[i_b]
+    #             if vertexKeys:
+    #                 for key in vertexKeys:
+    #                     if key in a_attrs and key in b_attrs:
+    #                         score = similarity_score(a_attrs[key], b_attrs[key])
+    #                         total_score += score
+    #                         count += 1
+
+    #         # Score edges
+    #         for (i_a1, i_a2) in nx_ga.edges:
+    #             if i_a1 in mapping and i_a2 in mapping:
+    #                 j_b1 = mapping[i_a1]
+    #                 j_b2 = mapping[i_a2]
+    #                 if nx_gb.has_edge(j_b1, j_b2):
+    #                     a_attrs = nx_ga.get_edge_data(i_a1, i_a2)
+    #                     b_attrs = nx_gb.get_edge_data(j_b1, j_b2)
+    #                     if edgeKeys:
+    #                         for key in edgeKeys:
+    #                             if key in a_attrs and key in b_attrs:
+    #                                 score = similarity_score(a_attrs[key], b_attrs[key])
+    #                                 total_score += score
+    #                                 count += 1
+
+    #         return total_score / count if count > 0 else 1.0
+
+    #     def node_match(n1, n2):
+    #         if vertexKeys:
+    #             for key in vertexKeys:
+    #                 if key not in n1 or key not in n2:
+    #                     return False
+    #                 sim = similarity_score(n1[key], n2[key])
+    #                 if sim < (1.0 - tolerance):
+    #                     return False
+    #         return True
+
+    #     def edge_match(e1, e2):
+    #         if edgeKeys:
+    #             for key in edgeKeys:
+    #                 if key not in e1 or key not in e2:
+    #                     return False
+    #                 sim = similarity_score(e1[key], e2[key])
+    #                 if sim < (1.0 - tolerance):
+    #                     return False
+    #         return True
+
+    #     matcher = nx.algorithms.isomorphism.GraphMatcher(
+    #         nx_gb, nx_ga,
+    #         node_match=node_match if vertexKeys else None,
+    #         edge_match=edge_match if edgeKeys else None
+    #     )
+
+    #     raw_matches = list(matcher.subgraph_isomorphisms_iter())
+    #     if not raw_matches and not silent:
+    #         print("Graph.Match - Warning: No subgraph isomorphisms found.")
+    #         return []
+
+    #     scores = [compute_mapping_score(m) for m in raw_matches]
+    #     sorted_matches = Helper.Sort(raw_matches, scores, reverse=True)
+
+    #     return sorted_matches
 
     @staticmethod
     def MaximumDelta(graph):

topologicpy/Plotly.py

@@ -551,10 +551,10 @@ class Plotly:
                         if not labelKey == None:
                             labels[m] = Dictionary.ValueAtKey(d, key=labelKey, defaultValue=" ")
                         if not sizeKey == None:
-                            sizes[m] = Dictionary.ValueAtKey(d, key=sizeKey)
+                            sizes[m] = float(Dictionary.ValueAtKey(d, key=sizeKey))
                             if sizes[m] == None:
                                sizes[m] = size
-                            if sizes[m] <= 0:
+                            if float(sizes[m]) <= 0:
                                 sizes[m] = 1.1
                         if not borderColorKey == None:
                             temp_color = Dictionary.ValueAtKey(d, key=borderColorKey)

topologicpy/Topology.py

@@ -10147,28 +10147,37 @@ class Topology():
         """
         import uuid
         from topologicpy.Dictionary import Dictionary
+        from topologicpy.Graph import Graph
 
         predefined_namespace_dns = uuid.UUID('6ba7b810-9dad-11d1-80b4-00c04fd430c8')
         namespace_uuid = uuid.uuid5(predefined_namespace_dns, namespace)
-        cellComplexes = Topology.CellComplexes(topology)
-        cells = Topology.Cells(topology)
-        shells = Topology.Shells(topology)
-        faces = Topology.Faces(topology)
-        wires = Topology.Wires(topology)
-        edges = Topology.Edges(topology)
-        vertices = Topology.Vertices(topology)
-        apertures = Topology.Apertures(topology, subTopologyType="all")
-        subTopologies = cellComplexes+cells+shells+faces+wires+edges+vertices+apertures
-        dictionaries = [Dictionary.PythonDictionary(Topology.Dictionary(topology))]
-        dictionaries += [Dictionary.PythonDictionary(Topology.Dictionary(s)) for s in subTopologies]
-        dict_str = str(dictionaries)
-        top_geom = Topology.Geometry(topology, mantissa=6)
-        verts_str = str(top_geom['vertices'])
-        edges_str = str(top_geom['edges'])
-        faces_str = str(top_geom['faces'])
-        geo_str = verts_str+edges_str+faces_str
-        final_str = geo_str+dict_str
-        uuid_str = uuid.uuid5(namespace_uuid, final_str)
+        if Topology.IsInstance(topology, "graph"):
+            mesh_data = Graph.MeshData(topology)
+            verts_str = str(mesh_data["vertices"])
+            edges_str = str(mesh_data["edges"])
+            dict_str = str(mesh_data['vertexDictionaries']+mesh_data["edgeDictionaries"])
+            final_str = verts_str+edges_str+dict_str
+            uuid_str = uuid.uuid5(namespace_uuid, final_str)
+        else:
+            cellComplexes = Topology.CellComplexes(topology)
+            cells = Topology.Cells(topology)
+            shells = Topology.Shells(topology)
+            faces = Topology.Faces(topology)
+            wires = Topology.Wires(topology)
+            edges = Topology.Edges(topology)
+            vertices = Topology.Vertices(topology)
+            apertures = Topology.Apertures(topology, subTopologyType="all")
+            subTopologies = cellComplexes+cells+shells+faces+wires+edges+vertices+apertures
+            dictionaries = [Dictionary.PythonDictionary(Topology.Dictionary(topology))]
+            dictionaries += [Dictionary.PythonDictionary(Topology.Dictionary(s)) for s in subTopologies]
+            dict_str = str(dictionaries)
+            top_geom = Topology.Geometry(topology, mantissa=6)
+            verts_str = str(top_geom['vertices'])
+            edges_str = str(top_geom['edges'])
+            faces_str = str(top_geom['faces'])
+            geo_str = verts_str+edges_str+faces_str
+            final_str = geo_str+dict_str
+            uuid_str = uuid.uuid5(namespace_uuid, final_str)
         return str(uuid_str)
     
     @staticmethod

topologicpy/Wire.py

@@ -2793,6 +2793,10 @@ class Wire():
             The vertical thickness of the lower horizontal arm of the I-shape. The default is 0.25.
         c : float , optional
             The vertical thickness of the upper horizontal arm of the I-shape. The default is 0.25.
+        flipHorizontal : bool , optional
+            if set to True, the shape is flipped horizontally. The default is False.
+        flipVertical : bool , optional
+            if set to True, the shape is flipped vertically. The default is False.
         direction : list , optional
             The vector representing the up direction of the I-shape. The default is [0, 0, 1].
         placement : str , optional

topologicpy/version.py

@@ -1 +1 @@
-__version__ = '0.8.36'
+__version__ = '0.8.37'

{topologicpy-0.8.36.dist-info → topologicpy-0.8.37.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: topologicpy
-Version: 0.8.36
+Version: 0.8.37
 Summary: An AI-Powered Spatial Modelling and Analysis Software Library for Architecture, Engineering, and Construction.
 Author-email: Wassim Jabi <wassim.jabi@gmail.com>
 License: AGPL v3 License

{topologicpy-0.8.36.dist-info → topologicpy-0.8.37.dist-info}/RECORD

@@ -2,7 +2,7 @@ topologicpy/ANN.py,sha256=DrNAhNHp-jSvsPc1fb7KVPU46cYmejAvghhknOM430Y,47932
 topologicpy/Aperture.py,sha256=wNn5miB_IrGCBYuQ18HXQYRva20dUC3id4AJCulL7to,2723
 topologicpy/BVH.py,sha256=Iwp_8VDG8ETE4330k7ifWxdI4jmWmv9h8e8IIIZZFGY,13043
 topologicpy/CSG.py,sha256=uDkOSmc8m1V_k7T3UCerODhOSyYNO4FRDzoOqt0kEt8,15590
-topologicpy/Cell.py,sha256=7goddVyduyeZFbBBMAUG4_JGa-bjvjgpVm42fOvF9sk,173110
+topologicpy/Cell.py,sha256=3et98bv27m1-7OqFCeD4cLMBgC_BAsSGyxHi_4PgJ4Y,176072
 topologicpy/CellComplex.py,sha256=NP6yptbkGXYmlfBv9fRimOnNle0mkjV8Yo_ug5NKpKE,60877
 topologicpy/Cluster.py,sha256=wvfMAx6aPrSAt5nQ4--KnqD4EK9MGjch6Dg985WF7JQ,58748
 topologicpy/Color.py,sha256=ZVVQRKGjebY9aOU1gpN_AbssdRRiVKlZV3f8TrsTNgg,20307
@@ -11,28 +11,28 @@ topologicpy/DGL.py,sha256=HQXy9iDnrvWGDxaBfe5pRbweQ2zLBvAf6UdjfhKkQYI,139041
 topologicpy/Dictionary.py,sha256=PageNwgFmLakb0cKizsCEGkL_u_JV0CVqYGRM60XdsI,40837
 topologicpy/Edge.py,sha256=CPdQKaE7ft6zgh0vxekkfGRRUY_yEqkEJ14NvjSgJOA,73190
 topologicpy/EnergyModel.py,sha256=Pyb28gDDwhzlQIH0xqAygqS0P3SJxWyyV7OWS_AAfRs,53856
-topologicpy/Face.py,sha256=L7D1rO3ntZ1vCWFMN0Pd-G6dEq_Fe6Eg3_Ms5X5yJN8,201370
-topologicpy/Graph.py,sha256=kk0c7Vl40jjQ72qn56cc6SbGHduIqBwLOdEIOPsdjK4,581757
+topologicpy/Face.py,sha256=BT_5ymb7-s-Wb1tuaBtkopJpeNg-RbooTUk_-KInQ6c,201618
+topologicpy/Graph.py,sha256=jUuaoEPQaF-4wEEcVhOHJnep9EmVlpzjCGdgmSXyRNc,605657
 topologicpy/Grid.py,sha256=EbI2NcYhQDpD5mItd7A1Lpr8Puuf87vZPWuoh7_gChQ,18483
 topologicpy/Helper.py,sha256=qEsE4yaboEGW94q9lFCff0I_JwwTTQnDAFXw006yHaQ,31203
 topologicpy/Honeybee.py,sha256=yctkwfdupKnp7bAOjP1Z4YaYpRrWoMEb4gz9Z5zaWwE,21751
 topologicpy/Matrix.py,sha256=LqVckk2qTwKwEo79eyNsOrHVSHdO82JCREcfy6WIk4I,22716
 topologicpy/Neo4j.py,sha256=ELKmON7R16j1kQD8xRHDGGCvzjIM2HGHNekdaXDUw6w,22371
-topologicpy/Plotly.py,sha256=uqAfiSKpi1eCgoanA1ddgR9C31aeQgv0m0IQMDByfkY,120519
+topologicpy/Plotly.py,sha256=B6CxNyAGfhv70N6sa4B4aHLYd7zIpH5S1hmpk3sQ3ys,120533
 topologicpy/Polyskel.py,sha256=oVfM4lqSMPTjnkHfsRU9VI8Blt6Vf0LVPkD9ebz7Wmw,27082
 topologicpy/PyG.py,sha256=zvV6jtnol_aFiN6JRoMpYwBVfOU2aFs9gdWSdEo6mtU,109757
 topologicpy/ShapeGrammar.py,sha256=UVb8VPwVKd6V3zDTNzpBecQPgYo1EjSsS10XJ8k5YcI,23364
 topologicpy/Shell.py,sha256=fx0WTndC8blkvWe38nKsJsI_AmklOA0qsjU0gbZp4b4,90501
 topologicpy/Speckle.py,sha256=-eiTqJugd7pHiHpD3pDUcDO6CGhVyPV14HFRzaqEoaw,18187
 topologicpy/Sun.py,sha256=_VBBAUIDhvpkp72JBZlv7k9qx9jYubm3yM56UZ1Nc6c,36837
-topologicpy/Topology.py,sha256=27KbYx9-W8j5Ef44eMLnTMh0avkTI8WcT5TD0isDu9A,466111
+topologicpy/Topology.py,sha256=G6KtKRKabV1gNUKCZ3rzZJkCogGkOJDnCl-_S7DuHKc,466648
 topologicpy/Vector.py,sha256=X12eqskn28bdB7sLY1EZhq3noPYzPbNEgHPb4a959ss,42302
 topologicpy/Vertex.py,sha256=epBfbD7fm87T-TZ0WuwrioXdYqg9NgRlHn_qUFtVbkc,84562
-topologicpy/Wire.py,sha256=nNsBhzHdg2TXj24OTtuOkQ6AGNcITE5h_I3j02Ckoyg,231299
+topologicpy/Wire.py,sha256=vE6IoObVucOZVTFMPiHuNN4DDezRHHyFbwhF5WRBm3s,231547
 topologicpy/__init__.py,sha256=RMftibjgAnHB1vdL-muo71RwMS4972JCxHuRHOlU428,928
-topologicpy/version.py,sha256=ImLBq3Km5E4vhZfPIT4-5gepfQy6e8kz6LS9ac50W7U,23
-topologicpy-0.8.36.dist-info/licenses/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
-topologicpy-0.8.36.dist-info/METADATA,sha256=4BPPT871pkw8SfY3nUotK3Bukgd5-yrXz21uKPxHr0c,10535
-topologicpy-0.8.36.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-topologicpy-0.8.36.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
-topologicpy-0.8.36.dist-info/RECORD,,
+topologicpy/version.py,sha256=VE1FGBgDJhbrCqc_YF_8MXIrldKfurVX4fi2rgDHG5I,23
+topologicpy-0.8.37.dist-info/licenses/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
+topologicpy-0.8.37.dist-info/METADATA,sha256=3U3CqjhrPP3kyS3CiWqO5bAqGJkYJZ7GlYb2K33MC1w,10535
+topologicpy-0.8.37.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+topologicpy-0.8.37.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
+topologicpy-0.8.37.dist-info/RECORD,,