topologicpy 0.7.34__py3-none-any.whl → 0.7.37__py3-none-any.whl

topologicpy/Face.py

@@ -276,9 +276,9 @@ class Face():
         return face
 
     @staticmethod
-    def ByOffset(face, offset: float = 1.0, tolerance: float = 0.0001):
+    def ByOffset(face, offset: float = 1.0, offsetKey: str = "offset", stepOffsetA: float = 0, stepOffsetB: float = 0, stepOffsetKeyA: str = "stepOffsetA", stepOffsetKeyB: str = "stepOffsetB", reverse: bool = False, bisectors: bool = False, transferDictionaries: bool = False, tolerance: float = 0.0001,  silent: bool = False):
         """
-        Creates an offset face from the input face. A positive offset value results in a smaller face to the inside of the input face.
+        Creates an offset face from the input face. A positive offset value results in an offset to the interior of an anti-clockwise face.
 
         Parameters
         ----------
@@ -286,32 +286,105 @@ class Face():
             The input face.
         offset : float , optional
             The desired offset distance. The default is 1.0.
+        offsetKey : str , optional
+            The edge dictionary key under which to find the offset value. If a value cannot be found, the offset input parameter value is used instead. The default is "offset".
+        stepOffsetA : float , optional
+            The amount to offset along the previous edge when transitioning between parallel edges with different offsets. The default is 0.
+        stepOffsetB : float , optional
+            The amount to offset along the next edge when transitioning between parallel edges with different offsets. The default is 0.
+        stepOffsetKeyA : str , optional
+            The vertex dictionary key under which to find the step offset A value. If a value cannot be found, the stepOffsetA input parameter value is used instead. The default is "stepOffsetA".
+        stepOffsetKeyB : str , optional
+            The vertex dictionary key under which to find the step offset B value. If a value cannot be found, the stepOffsetB input parameter value is used instead. The default is "stepOffsetB".
+        bisectors : bool , optional
+            If set to True, The bisectors (seams) edges will be included in the returned wire. This will result in the returned shape to be a shell rather than a face. The default is False.
+        reverse : bool , optional
+            If set to True, the direction of offsets is reversed. Otherwise, it is not. The default is False.
+        transferDictionaries : bool , optional
+            If set to True, the dictionaries of the original wire, its edges, and its vertices are transfered to the new wire. Otherwise, they are not. The default is False.
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
+        silent : bool , optional
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
         
         Returns
         -------
-        topologic_core.Face
-            The created face.
+        topologic_core.Face or topologic_core.Shell
+            The created face or shell.
 
         """
         from topologicpy.Wire import Wire
+        from topologicpy.Cluster import Cluster
         from topologicpy.Topology import Topology
+        from topologicpy.Helper import Helper
 
         if not Topology.IsInstance(face, "Face"):
-            print("Face.ByOffset - Warning: The input face parameter is not a valid face. Returning None.")
+            if not silent:
+                print("Face.ByOffset - Warning: The input face parameter is not a valid face. Returning None.")
             return None
+        
         eb = Face.Wire(face)
         internal_boundaries = Face.InternalBoundaries(face)
-        offset_external_boundary = Wire.ByOffset(wire=eb, offset=offset, bisectors=False, tolerance=tolerance)
+        offset_external_boundary = Wire.ByOffset(eb,
+                                                 offset=offset,
+                                                 offsetKey=offsetKey,
+                                                 stepOffsetA=stepOffsetA,
+                                                 stepOffsetB=stepOffsetB,
+                                                 stepOffsetKeyA=stepOffsetKeyA,
+                                                 stepOffsetKeyB=stepOffsetKeyB,
+                                                 reverse=reverse,
+                                                 bisectors=bisectors,
+                                                 transferDictionaries=transferDictionaries,
+                                                 tolerance=tolerance,
+                                                 silent=silent)
         offset_internal_boundaries = []
         for internal_boundary in internal_boundaries:
-            offset_internal_boundaries.append(Wire.ByOffset(wire=internal_boundary, offset=offset, bisectors=False, tolerance=tolerance))
-        face = Face.ByWires(offset_external_boundary, offset_internal_boundaries, tolerance=tolerance)
-        if not Topology.IsInstance(face, "Face"):
-            print("Face.ByOffset - Warning: Could not create face from wires. Returning None.")
+            offset_internal_boundary = Wire.ByOffset(internal_boundary,
+                                                    offset=offset,
+                                                    offsetKey=offsetKey,
+                                                    stepOffsetA=stepOffsetA,
+                                                    stepOffsetB=stepOffsetB,
+                                                    stepOffsetKeyA=stepOffsetKeyA,
+                                                    stepOffsetKeyB=stepOffsetKeyB,
+                                                    reverse=reverse,
+                                                    bisectors=bisectors,
+                                                    transferDictionaries=transferDictionaries,
+                                                    tolerance=tolerance,
+                                                    silent=silent)
+            offset_internal_boundaries.append(offset_internal_boundary)
+        
+        if bisectors == True:
+            return_face = Face.ByOffset(face,
+                                    offset=offset,
+                                    offsetKey=offsetKey,
+                                    stepOffsetA=stepOffsetA,
+                                    stepOffsetB=stepOffsetB,
+                                    stepOffsetKeyA=stepOffsetKeyA,
+                                    stepOffsetKeyB=stepOffsetKeyB,
+                                    reverse=reverse,
+                                    bisectors=False,
+                                    transferDictionaries=transferDictionaries,
+                                    tolerance=tolerance,
+                                    silent=silent)
+            all_edges = Topology.Edges(offset_external_boundary)+[Topology.Edges(ib) for ib in offset_internal_boundaries]
+            all_edges += Topology.Edges(face)
+            all_edges = Helper.Flatten(all_edges)
+            all_edges_cluster = Cluster.ByTopologies(all_edges)
+            if reverse == True:
+                return_face = Topology.Slice(return_face, all_edges_cluster)
+            else:
+                return_face = Topology.Slice(face, all_edges_cluster)
+            if not Topology.IsInstance(return_face, "Shell"):
+                if not silent:
+                    print("Face.ByOffset - Warning: Could not create shell by slicing. Returning None.")
+                return None
+            return return_face
+        return_face = Face.ByWires(offset_external_boundary, offset_internal_boundaries, tolerance=tolerance)
+        if not Topology.IsInstance(return_face, "Face"):
+            if not silent:
+                print("Face.ByOffset - Warning: Could not create face from wires. Returning None.")
             return None
-        return face
+        return return_face
     
     @staticmethod
     def ByShell(shell, origin= None, angTolerance: float = 0.1, tolerance: float = 0.0001, silent=False):
@@ -563,7 +636,7 @@ class Face():
             The input wire.
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
-         silent : bool , optional
+        silent : bool , optional
             If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
 
         Returns

topologicpy/Topology.py

@@ -1893,7 +1893,7 @@ class Topology():
         return Topology.ByBREPFile(file)
 
     @staticmethod
-    def ByDXFFile(file):
+    def ByDXFFile(file, sides: int = 16):
         """
         Imports a list of topologies from a DXF file.
         This is an experimental method with limited capabilities.
@@ -1902,6 +1902,8 @@ class Topology():
         ----------
         file : a DXF file object
             The DXF file object.
+        sides : int , optional
+            The desired number of sides of splines. The default is 16.
 
         Returns
         -------
@@ -1916,6 +1918,8 @@ class Topology():
         from topologicpy.Cell import Cell
         from topologicpy.CellComplex import CellComplex
         from topologicpy.Topology import Topology
+        from topologicpy.Dictionary import Dictionary
+
 
         try:
             import ezdxf
@@ -1936,34 +1940,123 @@ class Topology():
             print("Topology.ByDXFFile - Error: the input file parameter is not a valid file. Returning None.")
             return None
         
-        def convert_entity(entity):
-            entity_type = entity.dxftype()
-            converted_entity = None
+        import ezdxf
 
-            if entity_type == 'POINT':
-                x, y, z = entity.dxf.location.x, entity.dxf.location.y, entity.dxf.location.z
-                converted_entity = Vertex.ByCoordinates(x, y, z)
 
-            elif entity_type == 'LINE':
-                start = Vertex.ByCoordinates(entity.dxf.start.x, entity.dxf.start.y, entity.dxf.start.z)
-                end = Vertex.ByCoordinates(entity.dxf.end.x, entity.dxf.end.y, entity.dxf.end.z)
-                converted_entity = Edge.ByVertices(start, end)
 
+        def get_layer_color(layers, layer_name):
+            # iteration
+            for layer in layers:
+                if layer_name == layer.dxf.name:
+                    r,g,b = layer.rgb
+                    return [r,g,b]
+            return 
+
+        def convert_entity(entity, file, sides=36):
+            entity_type = entity.dxftype()
+            python_dict = entity.dxf.all_existing_dxf_attribs()
+            keys = python_dict.keys()
+            for key in keys:
+                if python_dict[key].__class__ == ezdxf.acc.vector.Vec3:
+                    python_dict[key] = list(python_dict[key])
+            try:
+                r,g,b = entity.rgb
+            except:
+                rgb_list = get_layer_color(file.layers, entity.dxf.layer)
+                if rgb_list == None:
+                    rgb_list = [0,0,0]
+            python_dict['color'] = rgb_list
+            python_dict['type'] = entity_type
+            d = Dictionary.ByPythonDictionary(python_dict)
+            
+            if entity_type == 'POINT':
+                point = entity.dxf.location.xyz
+                e = Vertex.ByCoordinates(point[0], point[1], point[2])
+                e = Topology.SetDictionary(e, d)
+            
+            elif entity_type == 'LINE':
+                sp = entity.dxf.start.xyz
+                ep = entity.dxf.end.xyz
+                sv = Vertex.ByCoordinates(sp[0], sp[1], sp[2])
+                ev = Vertex.ByCoordinates(ep[0], ep[1], ep[2])
+                e = Edge.ByVertices(sv,ev)
+                e = Topology.SetDictionary(e, d)
+        
+            elif entity_type == 'POLYLINE':
+                if entity.dxf.flags == 1:
+                    closed = True
+                else:
+                    closed = False
+                vertices = []
+                for vertex in entity.vertices:
+                    point = vertex.dxf.location.xyz
+                    vertices.append(Vertex.ByCoordinates(point[0], point[1], point[2]))
+                if entity.dxf.hasattr("closed"):
+                    closed = entity.closed
+                e = Wire.ByVertices(vertices, close=closed)
+                e = Topology.SetDictionary(e, d)
+
+            elif entity_type == 'LWPOLYLINE':
+                vertices = []
+                for point in entity.get_points():
+                    vertices.append(Vertex.ByCoordinates(point[0], point[1], 0))
+                if entity.dxf.hasattr("closed"):
+                    close = entity.closed
+                else:
+                    close = False
+                e = Wire.ByVertices(vertices, close=close)
+                e = Topology.SetDictionary(e, d)
+        
             elif entity_type == 'CIRCLE':
-                origin = Vertex.ByCoordinates(entity.dxf.center.x, entity.dxf.center.y, entity.dxf.center.z)
+                center = entity.dxf.center.xyz
                 radius = entity.dxf.radius
-                converted_entity = Wire.Circle(origin, radius)
-
-            elif entity_type in ['POLYLINE', 'LWPOLYLINE']:
-                with entity.points('xyz') as points:
-                    vertices = [Vertex.ByCoordinates(*_) for _ in points]
-                converted_entity = Wire.ByVertices(vertices)
-
+                num_points = 36  # Approximate the circle with 36 points
+                vertices = []
+                for i in range(sides):
+                    angle = 2 * np.pi * i / num_points
+                    x = center[0] + radius * np.cos(angle)
+                    y = center[1] + radius * np.sin(angle)
+                    z = center[2]
+                    vertices.append(Vertex.ByCoordinates(x,y,z))
+                e = Wire.ByVertices(vertices, close=True)
+                e = Topology.SetDictionary(e, d)
+            
             elif entity_type == 'ARC':
-                with entity.points('xyz') as points:
-                    vertices = [Vertex.ByCoordinates(*_) for _ in points]
-                converted_entity = Wire.ByVertices(vertices)
+                center = entity.dxf.center.xyz
+                radius = entity.dxf.radius
+                start_angle = np.deg2rad(entity.dxf.start_angle)
+                end_angle = np.deg2rad(entity.dxf.end_angle)
+                vertices = []
+                for i in range(sides+1):
+                    angle = start_angle + (end_angle - start_angle) * i / (num_points - 1)
+                    x = center[0] + radius * np.cos(angle)
+                    y = center[1] + radius * np.sin(angle)
+                    z = center[2]
+                    vertices.append(Vertex.ByCoordinates(x,y,z))
+                e = Wire.ByVertices(vertices, close=False)
+                e = Topology.SetDictionary(e, d)
+
+            elif entity_type == 'SPLINE':
+                # draw the curve tangents as red lines:
+                ct = entity.construction_tool()
+                vertices = []
+                for t in np.linspace(0, ct.max_t, 64):
+                    point, derivative = ct.derivative(t, 1)
+                    vertices.append(Vertex.ByCoordinates(list(point)))
+                converted_entity = Wire.ByVertices(vertices, close=entity.closed)
+                vertices = []
+                for i in range(sides+1):
+                    if i == 0:
+                        u = 0
+                    elif i == sides:
+                        u = 1
+                    else:
+                        u = float(i)/float(sides)
+                    vertices.append(Wire.VertexByParameter(converted_entity, u))
 
+                e = Wire.ByVertices(vertices, close=entity.closed)
+                e = Topology.SetDictionary(e, d)
+            
             elif entity_type == 'MESH':
                 vertices = [list(v) for v in entity.vertices]
                 faces = [list(face) for face in entity.faces]
@@ -1976,16 +2069,17 @@ class Topology():
                         temp = Shell.ByFaces(Topology.Faces(converted_entity))
                         if not Topology.IsInstance(temp, "Shell"):
                             temp = converted_entity
-                converted_entity = temp
-            return converted_entity
+                e = temp
+                e = Topology.SetDictionary(e, d)
+            return e
 
-        def convert_insert(entity, file):
+        def convert_insert(entity, file, sides=16):
             block_name = entity.dxf.name
             block = file.blocks.get(block_name)
             converted_entities = []
 
             for block_entity in block:
-                converted_entity = convert_entity(block_entity)
+                converted_entity = convert_entity(block_entity, sides=sides)
                 if converted_entity is not None:
                     converted_entities.append(converted_entity)
 
@@ -2006,9 +2100,9 @@ class Topology():
                     continue  # Ignore TEXT and MTEXT
 
                 if entity_type == 'INSERT':
-                    converted_entities.extend(convert_insert(entity, file))
+                    converted_entities.extend(convert_insert(entity, file, sides=sides))
                 else:
-                    converted_entity = convert_entity(entity)
+                    converted_entity = convert_entity(entity, file, sides=sides)
                     if converted_entity is not None:
                         converted_entities.append(converted_entity)
 
@@ -2017,7 +2111,7 @@ class Topology():
         return converted_entities
 
     @staticmethod
-    def ByDXFPath(path):
+    def ByDXFPath(path, sides: int = 16):
         """
         Imports a list of topologies from a DXF file path.
         This is an experimental method with limited capabilities.
@@ -2026,6 +2120,8 @@ class Topology():
         ----------
         path : str
             The path to the DXF file.
+        sides : int , optional
+            The desired number of sides of splines. The default is 16.
 
         Returns
         -------
@@ -2057,7 +2153,7 @@ class Topology():
         if not file:
             print("Topology.ByDXFPath - Error: the input file parameter is not a valid file. Returning None.")
             return None
-        return Topology.ByDXFFile(file)
+        return Topology.ByDXFFile(file, sides=sides)
 
     @staticmethod
     def ByIFCFile(file, transferDictionaries=False, includeTypes=[], excludeTypes=[]):
@@ -6989,6 +7085,8 @@ class Topology():
             if isinstance(colorKey, str):
                 f_color = Dictionary.ValueAtKey(d, colorKey)
                 if f_color:
+                    vertexColor = Color.PlotlyColor(f_color, alpha=1.0, useAlpha=False)
+                    edgeColor = Color.PlotlyColor(f_color, alpha=1.0, useAlpha=False)
                     faceColor = Color.PlotlyColor(f_color, alpha=1.0, useAlpha=False)
                 faceOpacity = Dictionary.ValueAtKey(d, opacityKey) or faceOpacity
             data += Plotly.DataByTopology(topology=topology,

topologicpy/Wire.py

@@ -310,7 +310,7 @@ class Wire():
         return Wire.ByEdges(edges, tolerance=tolerance)
 
     @staticmethod
-    def ByOffset(wire, offset: float = 1.0, offsetKey: str = "offset", stepOffsetA: float = 0, stepOffsetB: float = 0, stepOffsetKeyA: str = "stepOffsetA", stepOffsetKeyB: str = "stepOffsetB", bisectors: bool = False, transferDictionaries: bool = False, tolerance: float = 0.0001,  silent: bool = False):
+    def ByOffset(wire, offset: float = 1.0, offsetKey: str = "offset", stepOffsetA: float = 0, stepOffsetB: float = 0, stepOffsetKeyA: str = "stepOffsetA", stepOffsetKeyB: str = "stepOffsetB", reverse: bool = False, bisectors: bool = False, transferDictionaries: bool = False, tolerance: float = 0.0001,  silent: bool = False):
         """
         Creates an offset wire from the input wire. A positive offset value results in an offset to the interior of an anti-clockwise wire.
 
@@ -330,9 +330,11 @@ class Wire():
             The vertex dictionary key under which to find the step offset A value. If a value cannot be found, the stepOffsetA input parameter value is used instead. The default is "stepOffsetA".
         stepOffsetKeyB : str , optional
             The vertex dictionary key under which to find the step offset B value. If a value cannot be found, the stepOffsetB input parameter value is used instead. The default is "stepOffsetB".
+        reverse : bool , optional
+            If set to True, the direction of offsets is reversed. Otherwise, it is not. The default is False.
         bisectors : bool , optional
             If set to True, The bisectors (seams) edges will be included in the returned wire. The default is False.
-        tranferDictionaries : bool , optional
+        transferDictionaries : bool , optional
             If set to True, the dictionaries of the original wire, its edges, and its vertices are transfered to the new wire. Otherwise, they are not. The default is False.
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
@@ -359,6 +361,10 @@ class Wire():
                 print("Wire.ByOffset - Error: The input wire parameter is not a valid wire. Returning None.")
                 return None
         
+        if reverse == True:
+            fac = -1
+        else:
+            fac = 1
         origin = Vertex.Origin()
         temp_vertices = [Topology.Vertices(wire)[0], Topology.Vertices(wire)[1], Topology.Centroid(wire)]
         temp_face = Face.ByWire(Wire.ByVertices(temp_vertices, close=True))
@@ -377,6 +383,7 @@ class Wire():
             d_offset = Dictionary.ValueAtKey(d, offsetKey)
             if d_offset == None:
                 d_offset = offset
+            d_offset = d_offset*fac
             offsets.append(d_offset)
             offset_edge = Edge.ByOffset2D(edge, d_offset)
             offset_edges.append(offset_edge)
@@ -387,7 +394,6 @@ class Wire():
                 if Wire.IsClosed(wire) == False:
                     v1 = Edge.StartVertex(offset_edges[0])
                     if transferDictionaries == True:
-                        d_temp = Topology.Dictionary(v_a)
                         v1 = Topology.SetDictionary(v1, Topology.Dictionary(v_a), silent=True)
                         edge_dictionaries.append(Topology.Dictionary(edges[i]))
                     final_vertices.append(v1)
@@ -400,7 +406,6 @@ class Wire():
                         if bisectors == True:
                             bisectors_list.append(Edge.ByVertices(v_a, v1))
                         if transferDictionaries == True:
-                            d_temp = Topology.Dictionary(v_a)
                             v1 = Topology.SetDictionary(v1, Topology.Dictionary(v_a))
                             edge_dictionaries.append(Topology.Dictionary(edges[i]))
                         final_vertices.append(v1)

topologicpy/version.py

@@ -1 +1 @@
-__version__ = '0.7.34'
+__version__ = '0.7.37'

{topologicpy-0.7.34.dist-info → topologicpy-0.7.37.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: topologicpy
-Version: 0.7.34
+Version: 0.7.37
 Summary: An Advanced Spatial Modelling and Analysis Software Library for Architecture, Engineering, and Construction.
 Author-email: Wassim Jabi <wassim.jabi@gmail.com>
 License: MIT License

{topologicpy-0.7.34.dist-info → topologicpy-0.7.37.dist-info}/RECORD

@@ -9,7 +9,7 @@ topologicpy/DGL.py,sha256=Dd6O08D-vSxpjHYgKm45JpKiaeGvWlg1BRMzYMAXGNc,138991
 topologicpy/Dictionary.py,sha256=KqJ29YyE23Y3Xc6XmKLSCZXRfBvm-OEOxlMZ4dt-rfM,27094
 topologicpy/Edge.py,sha256=vhYHkobSLGSWV-oe2oJFFDobqFToDyb7s71yQ840AAA,65166
 topologicpy/EnergyModel.py,sha256=ni0H1JgvLl1-q90yK9Sm1qj5P1fTuidlimEIcwuj6qE,53287
-topologicpy/Face.py,sha256=u-DPS5guhzfwxZUuUNYqtPJG6OdeHpY1XQHRSKn6rqk,110148
+topologicpy/Face.py,sha256=SrP7LbOK9wjArYTO2fDVrtxItGXNkCMqmMRNz4-46gA,115473
 topologicpy/Graph.py,sha256=ICwFUYLka6tEPMo43I9QAe24ljItMUZOZYL21xpDPIg,392146
 topologicpy/Grid.py,sha256=Q-2WNBkvIsJks7pbGkzzkRWVB4fTMYgWipG3lcDXbpE,18496
 topologicpy/Helper.py,sha256=mLwJmhyc-d-JqW82MBf7JwM91zWHVx8RzOmndPWHm-k,17717
@@ -21,14 +21,14 @@ topologicpy/Polyskel.py,sha256=4R5_DEdfrmi-4gR6axHNoHTCSAE2TCekOyN8jvb7bHQ,19722
 topologicpy/Shell.py,sha256=bJ8zu5gj-TSOADR-p3YQ9yLPHFTffnv-29uD5b6Zvuc,79912
 topologicpy/Speckle.py,sha256=rUS6PCaxIjEF5_fUruxvMH47FMKg-ohcoU0qAUb-yNM,14267
 topologicpy/Sun.py,sha256=_gZfVyH0SDLQmmt775UeeAJ_BtwXO1STQnUMV1qkU0s,37161
-topologicpy/Topology.py,sha256=iL2kCRHtFTMBqFbvdJy_-E0NtLChsD7606x_F1UrKFE,362074
+topologicpy/Topology.py,sha256=Sfw0C5Sd1m3ndLyM_zrCLzegfMd6ytnaK82J_ToK5lQ,366264
 topologicpy/Vector.py,sha256=WQQUbwrg7VKImtxuBUi2i-FRiPT77WlrzLP05gdXKM8,33079
 topologicpy/Vertex.py,sha256=EQdVYHmW85_pZdHZB3N8pEi0GiadCCkF3z_oqohA7B0,71161
-topologicpy/Wire.py,sha256=Luau9ko3AA-CxPx--JX_OzscSFgUU23m8_bs5KNYgHc,153544
+topologicpy/Wire.py,sha256=Ls2ItdNQ_qbC1RUc8bAtGbM5B5A-uShjHdiOFVVwx-8,153711
 topologicpy/__init__.py,sha256=D7ky87CAQMiS2KE6YLvcTLkTgA2PY7rASe6Z23pjp9k,872
-topologicpy/version.py,sha256=cxijp04lr4v3ZnLuLmrlFIoTuvxTkFkuNf13YTxYPmo,23
-topologicpy-0.7.34.dist-info/LICENSE,sha256=BRNw73R2WdDBICtwhI3wm3cxsaVqLTAGuRwrTltcfxs,1068
-topologicpy-0.7.34.dist-info/METADATA,sha256=YtAZb3NSLWZL8AsRQy3xLzd7Ja1pvRnrgypt0V_hKVE,10916
-topologicpy-0.7.34.dist-info/WHEEL,sha256=Wyh-_nZ0DJYolHNn1_hMa4lM7uDedD_RGVwbmTjyItk,91
-topologicpy-0.7.34.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
-topologicpy-0.7.34.dist-info/RECORD,,
+topologicpy/version.py,sha256=ELkwc8QfDXR6OC99fHNSgYmlBjnbBmo_0j-69MXQmNA,23
+topologicpy-0.7.37.dist-info/LICENSE,sha256=BRNw73R2WdDBICtwhI3wm3cxsaVqLTAGuRwrTltcfxs,1068
+topologicpy-0.7.37.dist-info/METADATA,sha256=ZOohbLJX-LIHwG-aIFZUdZbgYqxppOt5uroiZvyoobU,10916
+topologicpy-0.7.37.dist-info/WHEEL,sha256=Wyh-_nZ0DJYolHNn1_hMa4lM7uDedD_RGVwbmTjyItk,91
+topologicpy-0.7.37.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
+topologicpy-0.7.37.dist-info/RECORD,,