topologicpy 0.7.51__py3-none-any.whl → 0.7.54__py3-none-any.whl

topologicpy/Face.py

@@ -276,7 +276,7 @@ class Face():
         return face
 
     @staticmethod
-    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):
+    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, epsilon: float = 0.01, tolerance: float = 0.0001,  silent: bool = False, numWorkers: int = None):
         """
         Creates an offset face from the input face. A positive offset value results in an offset to the interior of an anti-clockwise face.
 
@@ -302,10 +302,15 @@ class Face():
             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.
+        epsilon : float , optional
+            The desired epsilon (another form of tolerance for shortest edge to remove). The default is 0.01. (This is set to a larger number as it was found to work better)
         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.
+        numWorkers : int , optional
+            Number of workers run in parallel to process. If you set it to 1, no parallel processing will take place.
+            The default is None which causes the algorithm to use twice the number of cpu cores in the host computer.
         
         Returns
         -------
@@ -338,8 +343,10 @@ class Face():
                                                  reverse=reverse,
                                                  bisectors=bisectors,
                                                  transferDictionaries=transferDictionaries,
+                                                 epsilon=epsilon,
                                                  tolerance=tolerance,
-                                                 silent=silent)
+                                                 silent=silent,
+                                                 numWorkers=numWorkers)
         offset_internal_boundaries = []
         for internal_boundary in internal_boundaries:
             offset_internal_boundary = Wire.ByOffset(internal_boundary,
@@ -352,8 +359,10 @@ class Face():
                                                     reverse=reverse,
                                                     bisectors=bisectors,
                                                     transferDictionaries=transferDictionaries,
+                                                    epsilon=epsilon,
                                                     tolerance=tolerance,
-                                                    silent=silent)
+                                                    silent=silent,
+                                                    numWorkers=numWorkers)
             offset_internal_boundaries.append(offset_internal_boundary)
         
         if bisectors == True:
@@ -367,8 +376,10 @@ class Face():
                                     reverse=reverse,
                                     bisectors=False,
                                     transferDictionaries=transferDictionaries,
+                                    epsilon=epsilon,
                                     tolerance=tolerance,
-                                    silent=silent)
+                                    silent=silent,
+                                    numWorkers=numWorkers)
             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)

topologicpy/Graph.py

@@ -2177,6 +2177,12 @@ class Graph:
             for ifc_rel in ifc_relationships:
                 source = None
                 destinations = []
+                if ifc_rel.is_a("IfcRelConnectsPorts"):
+                    source = ifc_rel.RelatingPort
+                    destinations = ifc_rel.RelatedPorts
+                if ifc_rel.is_a("IfcRelConnectsPortToElement"):
+                    source = ifc_rel.RelatingPort
+                    destinations = [ifc_rel.RelatedElement]
                 if ifc_rel.is_a("IfcRelAggregates"):
                     source = ifc_rel.RelatingObject
                     destinations = ifc_rel.RelatedObjects

topologicpy/Plotly.py

@@ -635,7 +635,7 @@ class Plotly:
             labels = []
             groupList = []
             label = ""
-            group = ""
+            group = None
             if labelKey or groupKey:
                 if groups:
                     if len(groups) > 0:
@@ -655,7 +655,7 @@ class Plotly:
                     y.append(v[1])
                     z.append(v[2])
                     label = ""
-                    group = ""
+                    group = None
                     if len(dictionaries) > 0:
                         d = dictionaries[m]
                         if d:
@@ -737,7 +737,7 @@ class Plotly:
                     y+=[sv[1], ev[1], None] # y-coordinates of edge ends
                     z+=[sv[2], ev[2], None] # z-coordinates of edge ends
                     label = ""
-                    group = ""
+                    group = None
                     if len(dictionaries) > 0:
                         d = dictionaries[m]
                         if d:

topologicpy/PyG.py

@@ -176,7 +176,12 @@ class CustomGraphDataset(Dataset):
             if self.graph_level:
                 label_value = self.graph_df[self.graph_df['graph_id'] == graph_id]['label'].values[0]
                 
-                if isinstance(label_value, int):
+                if isinstance(label_value, np.int64):
+                    label_value = int(label_value)
+                if isinstance(label_value, np.float64):
+                    label_value = float(label_value)
+
+                if isinstance(label_value, int) or isinstance(label_value, np.int64):
                     y = torch.tensor([label_value], dtype=torch.long)
                 elif isinstance(label_value, float):
                     y = torch.tensor([label_value], dtype=torch.float)

topologicpy/Topology.py

@@ -2475,9 +2475,9 @@ class Topology():
             
             # If no color is defined, return a consistent random color based on the entity type
             if "wall" in is_a:
-                color = (0.4, 0.4, 0.4)
+                color = (175, 175, 175)
             elif "slab" in is_a:
-                color = (0.6, 0.6, 0.6)
+                color = (200, 200, 200)
             elif "space" in is_a:
                 color = (250, 250, 250)
             else:
@@ -8402,6 +8402,21 @@ class Topology():
         tran_mat = Vector.TransformationMatrix(up, direction)
         unflat_topology = Topology.Transform(topology, tran_mat)
         unflat_topology = Topology.Translate(unflat_topology, Vertex.X(origin), Vertex.Y(origin), Vertex.Z(origin))
+
+        unflat_topology = Topology.SetDictionary(unflat_topology, Topology.Dictionary(topology), silent=True)
+        unflat_vertices = Topology.Vertices(unflat_topology)
+        vertices = Topology.Vertices(topology)
+        unflat_edges = Topology.Edges(unflat_topology)
+        edges = Topology.Edges(topology)
+        faces = []
+        unflat_faces = []
+        if Topology.IsInstance(topology, "Face"):
+            unflat_faces = Topology.Faces(unflat_topology)
+            faces = Topology.Faces(topology)
+        elements = vertices+edges+faces
+        unflat_elements = unflat_vertices+unflat_edges+unflat_faces
+        for i, f, in enumerate(unflat_elements):
+            f = Topology.SetDictionary(f, Topology.Dictionary(elements[i]), silent=True)
         return unflat_topology
     
     @staticmethod
@@ -8763,8 +8778,8 @@ class Topology():
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
         numWorkers : int , optional
-            Number of workers run in parallel to process. The default is None which causes the algorithm to use twice the number of cpu cores in the host computer.
-
+            Number of workers run in parallel to process. If you set it to 1, no parallel processing will take place.
+            The default is None which causes the algorithm to use twice the number of cpu cores in the host computer.
         Returns
         -------
         Topology
@@ -8775,6 +8790,43 @@ class Topology():
         from topologicpy.Dictionary import Dictionary
         from topologicpy.Cluster import Cluster
         from topologicpy.Plotly import Plotly
+
+
+        def transfer_dictionaries_by_selectors(object, selectors, tranVertices=False, tranEdges=False, tranFaces=False, tranCells=False, tolerance=0.0001):
+            if tranVertices == True:
+                vertices = Topology.Vertices(object)
+                for vertex in vertices:
+                    for selector in selectors:
+                        d = Vertex.Distance(selector, vertex)
+                        if d < tolerance:
+                            vertex = Topology.SetDictionary(vertex, Topology.Dictionary(selector), silent=True)
+                            break
+            if tranEdges == True:
+                edges = Topology.Edges(object)
+                for selector in selectors:
+                    for edge in edges:
+                        d = Vertex.Distance(selector, edge)
+                        if d < tolerance:
+
+                            edge = Topology.SetDictionary(edge, Topology.Dictionary(selector), silent=True)
+                            break
+            if tranFaces == True:
+                faces = Topology.Faces(object)
+                for face in faces:
+                    for selector in selectors:
+                        d = Vertex.Distance(selector, face)
+                        if d < tolerance:
+                            face = Topology.SetDictionary(face, Topology.Dictionary(selector), silent=True)
+                            break
+            if tranCells == True:
+                cells = Topology.Cells(object)
+                for cell in cells:
+                    for selector in selectors:
+                        if Vertex.IsInternal(selector, cell):
+                            cell = Topology.SetDictionary(cell, Topology.Dictionary(selector), silent=True)
+                            break
+            return object
+        
         if not Topology.IsInstance(topology, "Topology"):
             print("Topology.TransferDictionariesBySelectors - Error: The input topology parameter is not a valid topology. Returning None.")
             return None
@@ -8788,6 +8840,9 @@ class Topology():
         if len(selectors_tmp) < 1:
             print("Topology.TransferDictionariesBySelectors - Error: The input selectors do not contain any valid topologies. Returning None.")
             return None
+        
+        if numWorkers == 1:
+            return transfer_dictionaries_by_selectors(topology, selectors, tranVertices=tranVertices, tranEdges=tranEdges, tranFaces=tranFaces, tranCells=tranCells, tolerance=tolerance)
         sinkEdges = []
         sinkFaces = []
         sinkCells = []

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", reverse: bool = False, 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, epsilon: float = 0.01, tolerance: float = 0.0001,  silent: bool = False, numWorkers: int = None):
         """
         Creates an offset wire from the input wire. A positive offset value results in an offset to the interior of an anti-clockwise wire.
 
@@ -336,10 +336,16 @@ class Wire():
             If set to True, The bisectors (seams) edges will be included in the returned wire. 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.
+        epsilon : float , optional
+            The desired epsilon (another form of tolerance for shortest edge to remove). The default is 0.01. (This is set to a larger number as it was found to work better)
         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.
+        numWorkers : int , optional
+            Number of workers run in parallel to process. If you set it to 1, no parallel processing will take place.
+            The default is None which causes the algorithm to use twice the number of cpu cores in the host computer.
+
         
         Returns
         -------
@@ -355,12 +361,15 @@ class Wire():
         from topologicpy.Cluster import Cluster
         from topologicpy.Topology import Topology
         from topologicpy.Vector import Vector
+        from topologicpy.Helper import Helper
 
         if not Topology.IsInstance(wire, "Wire"):
             if not silent:
                 print("Wire.ByOffset - Error: The input wire parameter is not a valid wire. Returning None.")
                 return None
         
+        temp_face = Face.ByWire(wire)
+        original_area = Face.Area(temp_face)
         if reverse == True:
             fac = -1
         else:
@@ -372,6 +381,7 @@ class Wire():
         flat_wire = Topology.Flatten(wire, direction=temp_normal, origin=origin)
         normal = Face.Normal(temp_face)
         flat_wire = Topology.Flatten(wire, direction=normal, origin=origin)
+        original_edges = Topology.Edges(wire)
         edges = Topology.Edges(flat_wire)
         original_edges = Topology.Edges(wire)
         offsets = []
@@ -482,16 +492,24 @@ class Wire():
             if bisectors == True:
                 bisectors_list.append(Edge.ByVertices(v_a, v1))
         
-        return_wire = Wire.ByVertices(final_vertices, close=Wire.IsClosed(wire))
-        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.")
-        else:
-            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.")
-        wire_edges = Topology.Edges(return_wire)
         
+        # wire_edges = []
+        # for i in range(len(final_vertices)-1):
+        #     v1 = final_vertices[i]
+        #     v2 = final_vertices[i+1]
+        #     w_e = Edge.ByVertices(v1,v2)
+        #     #w_e = Edge.SetLength(w_e, Edge.Length(w_e)+(2*epsilon), bothSides = True)
+        #     wire_edges.append(w_e)
+        # if Wire.IsClosed(wire):
+        #     v1 = final_vertices[-1]
+        #     v2 = final_vertices[0]
+        #     #w_e = Edge.SetLength(w_e, Edge.Length(w_e)+(2*epsilon), bothSides = True)
+        #     wire_edges.append(w_e)
+        
+        return_wire = Wire.ByVertices(final_vertices, close=Wire.IsClosed(wire))
+        #wire_edges = Topology.Edges(wire_edges)
+        wire_edges = [Edge.SetLength(w_e, Edge.Length(w_e)+(2*epsilon), bothSides=True) for w_e in Topology.Edges(return_wire)]
+        return_wire_edges = Topology.Edges(return_wire)
         if transferDictionaries == True:
             if not len(wire_edges) == len(edge_dictionaries):
                 if not silent:
@@ -502,8 +520,9 @@ class Wire():
                 if len(edge_dictionaries) > 0:
                     temp_dictionary = edge_dictionaries[min(i,len(edge_dictionaries)-1)]
                     wire_edge = Topology.SetDictionary(wire_edge, temp_dictionary, silent=True)
+                    return_wire_edges[i] = Topology.SetDictionary(return_wire_edges[i], temp_dictionary, silent=True)
         if bisectors == True:
-            temp_return_wire = Topology.SelfMerge(Cluster.ByTopologies(Topology.Edges(return_wire)+bisectors_list))
+            temp_return_wire = Topology.SelfMerge(Cluster.ByTopologies(wire_edges+bisectors_list))
             if transferDictionaries == True:
                 sel_vertices = Topology.Vertices(return_wire)
                 sel_vertices += Topology.Vertices(flat_wire)
@@ -512,11 +531,47 @@ class Wire():
                 for edge in edges:
                     d = Topology.Dictionary(edge)
                     c = Topology.Centroid(edge)
-                    c = Topology.SetDictionary(c, d)
+                    c = Topology.SetDictionary(c, d, silent=True)
                     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)
+                temp_return_wire = Topology.TransferDictionariesBySelectors(temp_return_wire, sel_vertices, tranVertices=True, numWorkers=numWorkers)
+                temp_return_wire = Topology.TransferDictionariesBySelectors(temp_return_wire, sel_edges, tranEdges=True, numWorkers=numWorkers)
+                
             return_wire = temp_return_wire
+        
+        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.")
+        else:
+            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.")
+                    print("Wire.ByOffset - Warning: Pursuing a workaround, but it might take a longer to complete.")
+                
+                #cycles = Wire.Cycles(return_wire, maxVertices = len(final_vertices))
+                temp_wire = Topology.SelfMerge(Cluster.ByTopologies(wire_edges))
+                cycles = Wire.Cycles(temp_wire, maxVertices = len(final_vertices))
+                distances = []
+                for cycle in cycles:
+                    cycle_centroid = Topology.Centroid(cycle)
+                    distance = Vertex.Distance(origin, cycle_centroid)
+                    distances.append(distance)
+                cycles = Helper.Sort(cycles, distances)
+                # Get the top three or less
+                cycles = cycles[:min(3, len(cycles))]
+                areas = [Face.Area(Face.ByWire(cycle)) for cycle in cycles]
+                cycles = Helper.Sort(cycles, areas)
+                return_cycle = Wire.Reverse(cycles[-1])
+                return_cycle = Wire.Simplify(return_cycle, tolerance=epsilon)
+                return_cycle = Wire.RemoveCollinearEdges(return_cycle)
+                sel_edges = []
+                for temp_edge in wire_edges:
+                    x = Topology.Centroid(temp_edge)
+                    d = Topology.Dictionary(temp_edge)
+                    x = Topology.SetDictionary(x, d, silent=True)
+                    sel_edges.append(x)
+                return_cycle = Topology.TransferDictionariesBySelectors(return_cycle, Topology.Vertices(return_wire), tranVertices=True, tolerance=tolerance, numWorkers=numWorkers)
+                return_cycle = Topology.TransferDictionariesBySelectors(return_cycle, sel_edges, tranEdges=True, tolerance=tolerance, numWorkers=numWorkers)
+                return_wire = return_cycle
         return_wire = Topology.Unflatten(return_wire, direction=normal, origin=origin)
         if transferDictionaries == True:
             return_wire = Topology.SetDictionary(return_wire, Topology.Dictionary(wire), silent=True)

topologicpy/version.py

@@ -1 +1 @@
-__version__ = '0.7.51'
+__version__ = '0.7.54'

{topologicpy-0.7.51.dist-info → topologicpy-0.7.54.dist-info}/METADATA

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

@@ -9,27 +9,27 @@ topologicpy/DGL.py,sha256=Dd6O08D-vSxpjHYgKm45JpKiaeGvWlg1BRMzYMAXGNc,138991
 topologicpy/Dictionary.py,sha256=X_WARSYtWtYIsEUKdLH-plZmGZ3pHz_FBFxxeHGHdrU,27065
 topologicpy/Edge.py,sha256=vhYHkobSLGSWV-oe2oJFFDobqFToDyb7s71yQ840AAA,65166
 topologicpy/EnergyModel.py,sha256=XcCP55VW5WHDIIKcURijmBOZEgNUDEn_V9h5EejkntA,53876
-topologicpy/Face.py,sha256=7GCYo4ATkMW1skiv4gXOVARM29A7Buim9lTQu57B22Y,115489
-topologicpy/Graph.py,sha256=1dtcE342b6d7cTiMbtUWWOud6Vu0vHaf4HP2eG_-iqg,402544
+topologicpy/Face.py,sha256=YjU6TxxW2Mf5InumMvzXUXVVRdtjxyRGauRIhGXzkao,116411
+topologicpy/Graph.py,sha256=capDrtqrvNSyivrcRnHDIEGgO43ZxjqykeFiGBV3GIA,402880
 topologicpy/Grid.py,sha256=3-sn7CHWGcXk18XCnHjsUttNJTWwmN63g_Insj__p04,18218
 topologicpy/Helper.py,sha256=i-AfI29NMsZXBaymjilfvxQbuS3wpYbpPw4RWu1YCHs,16358
 topologicpy/Honeybee.py,sha256=vcBECJlgWVjNNdD9ZmjNik_pA1Y_ZNoOorsQb2CiyGA,21965
 topologicpy/Matrix.py,sha256=umgR7An919-wGInXJ1wpqnoQ2jCPdyMe2rcWTZ16upk,8079
 topologicpy/Neo4j.py,sha256=YvtF7RYUMATEZ8iHwFwK_MOxEDyARby2DTI2CCK6-cI,19694
-topologicpy/Plotly.py,sha256=gfGadsDBgXOeefzzceXkVshqONuPtkGiW-XNVuT2rrA,106193
+topologicpy/Plotly.py,sha256=Aaq6D9D7gov5OrfoKLs_j3LJfdkCC-Gh8GaU5n2UOGQ,106199
 topologicpy/Polyskel.py,sha256=EFsuh2EwQJGPLiFUjvtXmAwdX-A4r_DxP5hF7Qd3PaU,19829
-topologicpy/PyG.py,sha256=3U59QObO56EBwrvaplGeLZhbTao0gJCYhWm3oTpjFAE,109505
+topologicpy/PyG.py,sha256=LU9LCCzjxGPUM31qbaJXZsTvniTtgugxJY7y612t4A4,109757
 topologicpy/Shell.py,sha256=joahFtpRQTWJpQOmi3qU4Xe0Sx2XXeayHlXTNx8CzMk,87610
 topologicpy/Speckle.py,sha256=rUS6PCaxIjEF5_fUruxvMH47FMKg-ohcoU0qAUb-yNM,14267
 topologicpy/Sun.py,sha256=42tDWMYpwRG7Z2Qjtp94eRgBuqySq7k8TgNUZDK7QxQ,36837
-topologicpy/Topology.py,sha256=100DUg9EUcFg3K9wlNdaKrXcFEZLvqHsexs3R-8pbYw,416196
+topologicpy/Topology.py,sha256=q-RMY4i0Ub7LmJOmh14hf4GoHJ2TF5YN4YtkhUN_z-s,419052
 topologicpy/Vector.py,sha256=WQQUbwrg7VKImtxuBUi2i-FRiPT77WlrzLP05gdXKM8,33079
 topologicpy/Vertex.py,sha256=bLY60YWoMsgCgHk7F7k9F93Sq2FJ6AzUcTfJ83NZfHA,71107
-topologicpy/Wire.py,sha256=h-vcKAuyHVvfX34nJx4bVF-AxeaUCx4NbVzGBq98M9o,154201
+topologicpy/Wire.py,sha256=OoPb7SJl0VpZDZpGL0-VkYJ35zPANS7gHDt9tixOSxc,157629
 topologicpy/__init__.py,sha256=D7ky87CAQMiS2KE6YLvcTLkTgA2PY7rASe6Z23pjp9k,872
-topologicpy/version.py,sha256=Nl_BpJIhLQbbkeSiv2q5IgytCINu26pAUqkPjuq0FPg,23
-topologicpy-0.7.51.dist-info/LICENSE,sha256=BRNw73R2WdDBICtwhI3wm3cxsaVqLTAGuRwrTltcfxs,1068
-topologicpy-0.7.51.dist-info/METADATA,sha256=E68AdA4I73vasiialUPW6sDhhX4xFhYSwysUl_7ZR1g,10918
-topologicpy-0.7.51.dist-info/WHEEL,sha256=UvcQYKBHoFqaQd6LKyqHw9fxEolWLQnlzP0h_LgJAfI,91
-topologicpy-0.7.51.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
-topologicpy-0.7.51.dist-info/RECORD,,
+topologicpy/version.py,sha256=QSD1X6KT5Pd5JrzAuS4UG70OK1cKLrNByM8LpoGYluI,23
+topologicpy-0.7.54.dist-info/LICENSE,sha256=BRNw73R2WdDBICtwhI3wm3cxsaVqLTAGuRwrTltcfxs,1068
+topologicpy-0.7.54.dist-info/METADATA,sha256=TCoA8opbxCAdgeBy9D49fzOIFXzclFi8w6LDHLKU9RA,10918
+topologicpy-0.7.54.dist-info/WHEEL,sha256=uCRv0ZEik_232NlR4YDw4Pv3Ajt5bKvMH13NUU7hFuI,91
+topologicpy-0.7.54.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
+topologicpy-0.7.54.dist-info/RECORD,,

{topologicpy-0.7.51.dist-info → topologicpy-0.7.54.dist-info}/WHEEL

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