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

topologicpy/Graph.py

@@ -1142,8 +1142,6 @@ class Graph:
             The desired key name to use for geometry. The default is "brep".
         typeKey : str , optional
             The dictionary key to use to look up the type of the node. The default is "type".
-        geometryKey : str , optional
-            The dictionary key to use to look up the geometry of the node. The default is "brep".
         spaceType : str , optional
             The dictionary string value to use to look up vertices of type "space". The default is "space".
         wallType : str , optional
@@ -1778,7 +1776,7 @@ class Graph:
         edges_ds = [] # A list to hold the vertices data structures until we can build the actual graphs
         # Access specific columns within the grouped DataFrame
         for graph_id, group_edge_df in grouped_edges:
-            #vertices = vertices_ds[graph_id]
+            vertices = vertices_ds[graph_id]
             edges = []
             es = [] # a list to check for duplicate edges
             duplicate_edges = 0
@@ -1807,7 +1805,11 @@ class Graph:
                     values = [label, mask]+featureList
                 if not (src_id == dst_id) and not [src_id, dst_id] in es and not [dst_id, src_id] in es:
                     es.append([src_id, dst_id])
-                    edge = Edge.ByVertices([vertices[src_id], vertices[dst_id]], tolerance=tolerance)
+                    try:
+                        edge = Edge.ByVertices([vertices[src_id], vertices[dst_id]], tolerance=tolerance)
+                    except:
+                        print("Graph.ByCSVPath - Warning: Failed to create and add a edge to the list of edges.")
+                        edge = None
                     if Topology.IsInstance(edge, "Edge"):
                         d = Dictionary.ByKeysValues(edge_keys, values)
                         if Topology.IsInstance(d, "Dictionary"):
@@ -4886,14 +4888,14 @@ class Graph:
                        edgeSRCHeader="src_id", edgeDSTHeader="dst_id",
                        edgeLabelHeader="label", edgeFeaturesHeader="feat",
                        edgeTrainMaskHeader="train_mask", edgeValidateMaskHeader="val_mask", edgeTestMaskHeader="test_mask",
-                       edgeMaskKey=None,
+                       edgeMaskKey="mask",
                        edgeTrainRatio=0.8, edgeValidateRatio=0.1, edgeTestRatio=0.1,
                        bidirectional=True,
 
                        nodeLabelKey="label", defaultNodeLabel=0, nodeFeaturesKeys=[],
                        nodeIDHeader="node_id", nodeLabelHeader="label", nodeFeaturesHeader="feat",
                        nodeTrainMaskHeader="train_mask", nodeValidateMaskHeader="val_mask", nodeTestMaskHeader="test_mask",
-                       nodeMaskKey=None,
+                       nodeMaskKey="mask",
                        nodeTrainRatio=0.8, nodeValidateRatio=0.1, nodeTestRatio=0.1,
                        mantissa=6, tolerance=0.0001, overwrite=False):
         """
@@ -4920,6 +4922,8 @@ class Graph:
             The edge label dictionary key saved in each graph edge. The default is "label".
         defaultEdgeLabel : int , optional
             The default edge label to use if no edge label is found. The default is 0.
+        edgeLabelHeader : str , optional
+            The desired edge label column header. The default is "label".
         edgeSRCHeader : str , optional
             The desired edge source column header. The default is "src_id".
         edgeDSTHeader : str , optional
@@ -4967,6 +4971,9 @@ class Graph:
             The desired node validate mask column header. The default is "val_mask".
         nodeTestMaskHeader : str , optional
             The desired node test mask column header. The default is "test_mask".
+        nodeMaskKey : str , optional
+            The dictionary key where the node train, validate, test category is to be found. The value should be 0 for train
+            1 for validate, and 2 for test. If no key is found, the ratio of train/validate/test will be used. The default is "mask".
         nodeTrainRatio : float , optional
             The desired ratio of the node data to use for training. The number must be between 0 and 1. The default is 0.8 which means 80% of the data will be used for training.
             This value is ignored if an nodeMaskKey is foud.

topologicpy/Plotly.py

@@ -2032,6 +2032,10 @@ class Plotly:
             return None
         if not camera == None and not center == None and not up == None:
             figure = Plotly.SetCamera(figure, camera=camera, center=center, up=up, projection=projection)
+        figure.update_layout(
+            autosize=True,
+            margin=dict(l=40, r=40, t=40, b=40)
+            )
         if renderer.lower() == "offline":
             ofl.plot(figure)
         else:

topologicpy/Shell.py

@@ -1189,12 +1189,12 @@ class Shell():
         ----------
         shell : topologic_core.Shell
             The input shell.
-        tolerance : float, optional
-            The desired tolerance. The default is 0.0001.
         origin : topologic_core.Vertex , optional
             The desired origin of the plane unto which the planar shell will be projected. If set to None, the centroid of the input shell will be chosen. The default is None.
         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
         -------

topologicpy/Topology.py

@@ -1955,11 +1955,13 @@ class Topology():
                 converted_entity = Wire.Circle(origin, radius)
 
             elif entity_type in ['POLYLINE', 'LWPOLYLINE']:
-                vertices = [Vertex.ByCoordinates(p[0], p[1], p[2]) for p in entity.points()]
+                with entity.points('xyz') as points:
+                    vertices = [Vertex.ByCoordinates(*_) for _ in points]
                 converted_entity = Wire.ByVertices(vertices)
 
             elif entity_type == 'ARC':
-                vertices = [Vertex.ByCoordinates(p.x, p.y, p.z) for p in entity.vertices()]
+                with entity.points('xyz') as points:
+                    vertices = [Vertex.ByCoordinates(*_) for _ in points]
                 converted_entity = Wire.ByVertices(vertices)
 
             elif entity_type == 'MESH':
@@ -7393,6 +7395,12 @@ class Topology():
             The list of vertices.
 
         """
+        from topologicpy.Graph import Graph
+        
+        if Topology.IsInstance(topology, "Vertex"):
+            return []
+        if Topology.IsInstance(topology, "Graph"):
+            return Graph.Vertices(topology)
         return Topology.SubTopologies(topology=topology, subTopologyType="vertex")
     
     @staticmethod
@@ -7411,8 +7419,11 @@ class Topology():
             The list of edges.
 
         """
+        from topologicpy.Graph import Graph
         if Topology.IsInstance(topology, "Edge") or Topology.IsInstance(topology, "Vertex"):
             return []
+        if Topology.IsInstance(topology, "Graph"):
+            return Graph.Edges(topology)
         return Topology.SubTopologies(topology=topology, subTopologyType="edge")
     
     @staticmethod

topologicpy/Vertex.py

@@ -511,7 +511,7 @@ class Vertex():
             # Calculate the Euclidean distance
             distance = np.linalg.norm(point1 - point2)
             
-            return distance
+            return float(distance)
 
         def distance_point_to_line(point, line_start, line_end):
             # Convert input points to NumPy arrays for vector operations
@@ -1493,8 +1493,8 @@ class Vertex():
             
             # Calculate the distance between the closest point and the given point
             distance = np.linalg.norm(point - closest_point)
-            
-            return distance
+            return float(distance)
+        
         if not Topology.IsInstance(vertex, "Vertex"):
             print("Vertex.PerpendicularDistance - Error: The input vertex is not a valid topologic vertex. Returning None.")
             return None

topologicpy/Wire.py

@@ -21,7 +21,7 @@ from topologicpy.Topology import Topology
 import math
 import itertools
 
-class Wire(Topology):
+class Wire():
     @staticmethod
     def Arc(startVertex, middleVertex, endVertex, sides: int = 16, close: bool = True, tolerance: float = 0.0001):
         """
@@ -310,7 +310,7 @@ class Wire(Topology):
         return Wire.ByEdges(edges, tolerance=tolerance)
 
     @staticmethod
-    def ByOffset(wire, offset: float = 1.0, offsetKey: str = "offset", stepOffset: float = 0, bisectors: 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", 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.
 
@@ -322,10 +322,18 @@ class Wire(Topology):
             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".
-        stepOffset : float , optional
-            The amount to offset along each edge when transitioning between parallel edges with different offsets. The default is 0.
+        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. The default is False.
+        tranferDictionaries : 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
@@ -363,6 +371,7 @@ class Wire(Topology):
         offset_edges = []
         final_vertices = []
         bisectors_list = []
+        edge_dictionaries = []
         for edge in edges:
             d = Topology.Dictionary(edge)
             d_offset = Dictionary.ValueAtKey(d, offsetKey)
@@ -371,65 +380,108 @@ class Wire(Topology):
             offsets.append(d_offset)
             offset_edge = Edge.ByOffset2D(edge, d_offset)
             offset_edges.append(offset_edge)
-        o_edges = []
         for i in range(len(edges)):
-            edge_a = edges[i]
             o_edge_a = offset_edges[i]
             v_a = Edge.StartVertex(edges[i])
             if i == 0:
                 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)
                     if bisectors == True:
                         bisectors_list.append(Edge.ByVertices(v_a, v1))
                 else:
                     prev_edge = offset_edges[-1]
+                    v1 = Edge.Intersect2D(prev_edge, o_edge_a, silent=True)
+                    if Topology.IsInstance(v1, "Vertex"):
+                        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)
+                    else:
+                        connection = Edge.Connection(prev_edge, o_edge_a)
+                        if Topology.IsInstance(connection, "Edge"):
+                            d = Topology.Dictionary(v_a)
+                            d_stepOffsetA = Dictionary.ValueAtKey(d, stepOffsetKeyA)
+                            if d_stepOffsetA == None:
+                                d_stepOffsetA = stepOffsetA
+                            d_stepOffsetB = Dictionary.ValueAtKey(d, stepOffsetKeyB)
+                            if d_stepOffsetB == None:
+                                d_stepOffsetB = stepOffsetB
+                            v1_1 = Topology.TranslateByDirectionDistance(Edge.EndVertex(prev_edge),
+                                                                        direction = Vector.Reverse(Edge.Direction(prev_edge)),
+                                                                        distance = d_stepOffsetA)
+                                                                                                    
+                            v1_2 = Topology.TranslateByDirectionDistance(Edge.StartVertex(o_edge_a),
+                                                                        direction = Edge.Direction(o_edge_a),
+                                                                        distance = d_stepOffsetB)
+                            bisectors_list.append(Edge.ByVertices(v_a, v1_1))
+                            bisectors_list.append(Edge.ByVertices(v_a, v1_2))
+                            final_vertices.append(v1_1)
+                            final_vertices.append(v1_2)
+                            if transferDictionaries == True:
+                                v1_1 = Topology.SetDictionary(v1_1, Topology.Dictionary(v_a), silent=True)
+                                v1_2 = Topology.SetDictionary(v1_2, Topology.Dictionary(v_a), silent=True)
+                                edge_dictionaries.append(Topology.Dictionary(v_a))
+                                edge_dictionaries.append(Topology.Dictionary(edges[i]))
             else:
                 prev_edge = offset_edges[i-1]
                 v1 = Edge.Intersect2D(prev_edge, o_edge_a, silent=True)
                 if Topology.IsInstance(v1, "Vertex"):
                     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), silent=True)
+                        edge_dictionaries.append(Topology.Dictionary(edges[i]))
                     final_vertices.append(v1)
                 else:
                     connection = Edge.Connection(prev_edge, o_edge_a)
                     if Topology.IsInstance(connection, "Edge"):
-                        v1_1 = Topology.TranslateByDirectionDistance(Edge.StartVertex(connection),
+                        d = Topology.Dictionary(v_a)
+                        d_stepOffsetA = Dictionary.ValueAtKey(d, stepOffsetKeyA)
+                        if d_stepOffsetA == None:
+                            d_stepOffsetA = stepOffsetA
+                        d_stepOffsetB = Dictionary.ValueAtKey(d, stepOffsetKeyB)
+                        if d_stepOffsetB == None:
+                            d_stepOffsetB = stepOffsetB
+                        v1_1 = Topology.TranslateByDirectionDistance(Edge.EndVertex(prev_edge),
                                                                      direction = Vector.Reverse(Edge.Direction(prev_edge)),
-                                                                     distance = stepOffset)
+                                                                     distance = d_stepOffsetA)
                                                                                                 
-                        v1_2 = Topology.TranslateByDirectionDistance(Edge.EndVertex(connection),
+                        v1_2 = Topology.TranslateByDirectionDistance(Edge.StartVertex(o_edge_a),
                                                                      direction = Edge.Direction(o_edge_a),
-                                                                     distance = stepOffset)
+                                                                     distance = d_stepOffsetB)
                         bisectors_list.append(Edge.ByVertices(v_a, v1_1))
                         bisectors_list.append(Edge.ByVertices(v_a, v1_2))
                         final_vertices.append(v1_1)
                         final_vertices.append(v1_2)
+                        if transferDictionaries == True:
+                            v1_1 = Topology.SetDictionary(v1_1, Topology.Dictionary(v_a))
+                            v1_2 = Topology.SetDictionary(v1_2, Topology.Dictionary(v_a))
+                            edge_dictionaries.append(Topology.Dictionary(v_a))
+                            edge_dictionaries.append(Topology.Dictionary(edges[i]))
+        v_a = Edge.EndVertex(edges[-1])
         if Wire.IsClosed(wire) == False:
-            v_a = Edge.EndVertex(edges[-1])
             v1 = Edge.EndVertex(offset_edges[-1])
             final_vertices.append(v1)
+            if transferDictionaries == True:
+                v1 = Topology.SetDictionary(v1, Topology.Dictionary(v_a), silent=True)
             if bisectors == True:
                 bisectors_list.append(Edge.ByVertices(v_a, v1))
-        else:
-            v1 = Edge.Intersect2D(o_edge_a, offset_edges[0], silent=True)
-            if Topology.IsInstance(v1, "Vertex"):
-                if bisectors == True:
-                    bisectors_list.append(Edge.ByVertices(Edge.StartVertex(edges[0]), v1))
-                final_vertices.append(v1)
-            else:
-                connection = Edge.Connection(offset_edges[0], o_edge_a)
-                if Topology.IsInstance(connection, "Edge"):
-                    v1_1 = Edge.StartVertex(connection)
-                    v1_2 = Edge.EndVertex(connection)
-                    bisectors_list.append(Edge.ByVertices(v_a, v1_1))
-                    bisectors_list.append(Edge.ByVertices(v_a, v1_2))
-                    final_vertices.append(v1_1)
-                    final_vertices.append(v1_2)
         
+
         return_wire = Wire.ByVertices(final_vertices, close=Wire.IsClosed(wire))
-        if bisectors == True:
-            return_wire = Topology.SelfMerge(Cluster.ByTopologies(bisectors_list+Topology.Edges(return_wire)))
+        wire_edges = Topology.Edges(return_wire)
+        if transferDictionaries == True:
+            for i, wire_edge in enumerate(wire_edges):
+                wire_edge = Topology.SetDictionary(wire_edge, edge_dictionaries[i], silent=True)
         if not Topology.IsInstance(return_wire, "Wire"):
             if not silent:
                 print("Wire.ByOffset - Warning: The resulting wire is not well-formed, please check your offsets.")
@@ -437,7 +489,24 @@ class Wire(Topology):
             if not Wire.IsManifold(return_wire) and bisectors == False:
                 if not silent:
                     print("Wire.ByOffset - Warning: The resulting wire is non-manifold, please check your offsets.")
+        if bisectors == True:
+            temp_return_wire = Topology.SelfMerge(Cluster.ByTopologies(Topology.Edges(return_wire)+bisectors_list))
+            if transferDictionaries == True:
+                sel_vertices = Topology.Vertices(return_wire)
+                sel_vertices += Topology.Vertices(flat_wire)
+                edges = Topology.Edges(return_wire)
+                sel_edges = []
+                for edge in edges:
+                    d = Topology.Dictionary(edge)
+                    c = Topology.Centroid(edge)
+                    c = Topology.SetDictionary(c, d)
+                    sel_edges.append(c)
+                temp_return_wire = Topology.TransferDictionariesBySelectors(temp_return_wire, sel_vertices, tranVertices=True)
+                temp_return_wire = Topology.TransferDictionariesBySelectors(temp_return_wire, sel_edges, tranEdges=True)
+            return_wire = temp_return_wire
         return_wire = Topology.Unflatten(return_wire, direction=normal, origin=origin)
+        if transferDictionaries == True:
+            return_wire = Topology.SetDictionary(return_wire, Topology.Dictionary(wire), silent=True)
         return return_wire
 
     @staticmethod

topologicpy/version.py

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: topologicpy
-Version: 0.7.29
+Version: 0.7.34
 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.29.dist-info → topologicpy-0.7.34.dist-info}/RECORD

@@ -10,25 +10,25 @@ topologicpy/Dictionary.py,sha256=KqJ29YyE23Y3Xc6XmKLSCZXRfBvm-OEOxlMZ4dt-rfM,270
 topologicpy/Edge.py,sha256=vhYHkobSLGSWV-oe2oJFFDobqFToDyb7s71yQ840AAA,65166
 topologicpy/EnergyModel.py,sha256=ni0H1JgvLl1-q90yK9Sm1qj5P1fTuidlimEIcwuj6qE,53287
 topologicpy/Face.py,sha256=u-DPS5guhzfwxZUuUNYqtPJG6OdeHpY1XQHRSKn6rqk,110148
-topologicpy/Graph.py,sha256=ZU4etwhj6-_JUci3-CK5AoMUoFaTMtVvRWdSHW52SR0,391660
+topologicpy/Graph.py,sha256=ICwFUYLka6tEPMo43I9QAe24ljItMUZOZYL21xpDPIg,392146
 topologicpy/Grid.py,sha256=Q-2WNBkvIsJks7pbGkzzkRWVB4fTMYgWipG3lcDXbpE,18496
 topologicpy/Helper.py,sha256=mLwJmhyc-d-JqW82MBf7JwM91zWHVx8RzOmndPWHm-k,17717
 topologicpy/Honeybee.py,sha256=vcBECJlgWVjNNdD9ZmjNik_pA1Y_ZNoOorsQb2CiyGA,21965
 topologicpy/Matrix.py,sha256=umgR7An919-wGInXJ1wpqnoQ2jCPdyMe2rcWTZ16upk,8079
 topologicpy/Neo4j.py,sha256=Gy2PS4Ky8BNhohKreoV4zgzW9OXCjhSwiZF_Aq21_wU,19589
-topologicpy/Plotly.py,sha256=iJ7zCoe2V1PqGH7GzTTvSfCXY5aRCG0fdYf4Sh6igZ8,98844
+topologicpy/Plotly.py,sha256=qMhBMAYoNMsc-cKdNpqM2p9rqAVXWvBNTzmTKw7iU_0,98963
 topologicpy/Polyskel.py,sha256=4R5_DEdfrmi-4gR6axHNoHTCSAE2TCekOyN8jvb7bHQ,19722
-topologicpy/Shell.py,sha256=n91gViexVMcH3Iors6xeC_Wnn38E40KLqKq5MXQiDU4,79912
+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=Z-zddTGL_wkQmhrkXlredpQxx7Myd4Xp-yNw2d95iks,361647
+topologicpy/Topology.py,sha256=iL2kCRHtFTMBqFbvdJy_-E0NtLChsD7606x_F1UrKFE,362074
 topologicpy/Vector.py,sha256=WQQUbwrg7VKImtxuBUi2i-FRiPT77WlrzLP05gdXKM8,33079
-topologicpy/Vertex.py,sha256=xnCoPG7BTKBG-JU3C0e11KcpDJbDt9t1Ahj4f5Ul13I,71151
-topologicpy/Wire.py,sha256=oB3q2BysEuxnsiCPHeXlk0rn-gPEzQhqIwez69rWXYo,148009
+topologicpy/Vertex.py,sha256=EQdVYHmW85_pZdHZB3N8pEi0GiadCCkF3z_oqohA7B0,71161
+topologicpy/Wire.py,sha256=Luau9ko3AA-CxPx--JX_OzscSFgUU23m8_bs5KNYgHc,153544
 topologicpy/__init__.py,sha256=D7ky87CAQMiS2KE6YLvcTLkTgA2PY7rASe6Z23pjp9k,872
-topologicpy/version.py,sha256=xOCS8lbkurK74UxFSq0o5XwzFE6wZmnSDNE1O_J3ePM,23
-topologicpy-0.7.29.dist-info/LICENSE,sha256=BRNw73R2WdDBICtwhI3wm3cxsaVqLTAGuRwrTltcfxs,1068
-topologicpy-0.7.29.dist-info/METADATA,sha256=u0Idlv2W5yKI4QkzZhdnsA2JRKUsxdJA5WiETrER8vQ,10916
-topologicpy-0.7.29.dist-info/WHEEL,sha256=rWxmBtp7hEUqVLOnTaDOPpR-cZpCDkzhhcBce-Zyd5k,91
-topologicpy-0.7.29.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
-topologicpy-0.7.29.dist-info/RECORD,,
+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-0.7.29.dist-info → topologicpy-0.7.34.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (71.0.4)
+Generator: setuptools (71.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any