topologicpy 0.8.87__py3-none-any.whl → 0.8.89__py3-none-any.whl

topologicpy/Graph.py

@@ -4753,13 +4753,16 @@ class Graph:
     @staticmethod
     def BySpatialRelationships(
         *topologies,
-        include: list = ["contains", "coveredBy", "covers", "crosses", "disjoint", "equals", "overlaps", "touches","within"],
-        useInternalVertex = False,
-        vertexIDKey = "id",
-        edgeKeyFwd = "relFwd",
-        edgeKeyBwd = "relBwd",
-        connectsKey = "connects",
-        storeBREP = False,
+        include: list = ["contains", "coveredBy", "covers", "crosses", "disjoint", "equals", "overlaps", "touches","within", "proximity"],
+        proximityValues = [1, 5, 10],
+        proximityLabels = ["near", "intermediate", "far"],
+        useShortestDistance: bool = False,
+        useInternalVertex: bool = False,
+        vertexIDKey: str = "id",
+        edgeKeyFwd: str = "relFwd",
+        edgeKeyBwd: str = "relBwd",
+        connectsKey:str = "connects",
+        storeBREP: bool = False,
         mantissa: int = 6,
         tolerance: float = 0.0001,
         silent: bool = False
@@ -4773,6 +4776,18 @@ class Graph:
             The list of input topologies
         include : list , optional
             The type(s) of spatial relationships to build. Default is ["contains", "disjoint", "equals", "overlaps", "touches", "within", "covers", "coveredBy"]
+        proximityValues: list , optional
+            The list of maximum distance values that specify the desired proximityLabel.
+            This list must be sorted in ascending order and have the same number of elements as the proximityLabels list.
+            Objects that are further than the largest specified distance are not classified and not included.
+            An object is considered to fall within the range if it is less than or equal to the value in this list.
+            If you wish ALL objects to be classified specifiy the last number in this list to be larger than the
+            largest distance that can exist between any two objects in the list. Default is [1, 5, 10]
+        proximityLabels: list , optional
+            The list of range labels (e.g. "near", "intermediate", "far") that correspond to the proximityValues list.
+            The list must have the same number of elements as the proximityValues list. Default is ["near", "intermediate", "far"]
+        useShortestDistance: bool , optional
+            If set to True, the shortest distance between objects is used. Otherwise, the distance between their centroids is used. Default is False.
         useInternalVertex: bool , optional
             If set to True, an internal vertex of the represented topology will be used as a graph node.
             Otherwise, its centroid will be used. Default is False.
@@ -4801,6 +4816,7 @@ class Graph:
         """
         from topologicpy.Graph import Graph
         from topologicpy.BVH import BVH
+        from topologicpy.Cell import Cell
         from topologicpy.Vertex import Vertex
         from topologicpy.Topology import Topology
         from topologicpy.Dictionary import Dictionary
@@ -4819,12 +4835,252 @@ class Graph:
             if not silent:
                 print("Graph.BySpatialRelationships - Error: No valid topologies. Returning None")
             return None
+        
+        if len(proximityValues) != len(proximityLabels):
+            if not silent:
+                print("Graph.BySpatialRelationships - Error: the proximityValues and proximityLabels input parameters are not of the same length. Returning None")
+            return None
+        
+        include = [t.lower() for t in include if t.lower() in ["contains", "coveredBy", "covers", "crosses", "disjoint", "equals", "overlaps", "touches","within", "proximity"]]
+        
+        if len(include) == 0:
+            if not silent:
+                print("Graph.BySpatialRelationships - Error: The include input parameter does not contain any valid spatial relationship types. Returning None")
+            return None
 
         if n == 1:
             v = Topology.InternalVertex(topologyList[0]) if useInternalVertex else Topology.Centroid(topologyList[0])
             v = Topology.SetDictionary(v, Topology.Dictionary(topologyList[0]))
             return Graph.ByVerticesEdges([v], [])
 
+        # ---------- Calculate Proximity ------------
+
+        def _calc_proximity(topologies: list,
+                            ranges: list,
+                            labels: list,
+                            useShortestDistance: bool = True,
+                            tolerance: float = 0.0001,
+                            silent: bool = False):
+            """
+            Creates a proximity graph from a list of topologies using a BVH
+            to prune distance checks for large input sets.
+
+            Each topology is represented by a vertex in the graph.
+            An edge is created between two vertices if the distance between
+            their corresponding topologies is <= max(ranges).
+
+            A BVH is used as a broad-phase accelerator: for each topology,
+            a query box centred at its centroid and sized to cover the
+            maximum proximity range is used to retrieve only nearby
+            candidates. Exact distances are then computed only for those
+            candidates.
+
+            Parameters
+            ----------
+            topologies : list of topologic_core.Topology
+                The input topologies to be represented as vertices.
+            ranges : list of float
+                A list of positive numeric thresholds (e.g. [1.0, 3.0, 5.0]).
+                Interpreted as upper bounds of proximity bands.
+                Distances larger than max(ranges) are ignored (no edge).
+            labels : list of str
+                A list of proximity labels, same length as `ranges`.
+                For a pair distance d:
+                    - d <= ranges[0] -> labels[0]
+                    - ranges[0] < d <= ranges[1] -> labels[1]
+                    - ...
+            useShortestDistance : bool , optional
+                If True, use Topology.ShortestDistance(topologyA, topologyB)
+                if available. If False (or if that fails), fall back to the
+                distance between the centroids of the two topologies.
+                Default is True.
+            tolerance : float , optional
+                A small numeric tolerance used when comparing distances to
+                range bounds. Default is 0.0001.
+            silent : bool , optional
+                If False, basic sanity-check warnings are printed.
+                Default is False.
+
+            Returns
+            -------
+            graph : topologic_core.Graph
+                A graph whose vertices correspond to the input topologies
+                and whose edges connect topologies that fall within the
+                supplied distance ranges. Each edge dictionary contains:
+                    - "distance"  : float  (actual distance)
+                    - "proximity" : str    (label from `labels`)
+                    - "range_max" : float  (upper bound used for the bin)
+                    - "source_index" : int
+                    - "target_index" : int
+
+            Notes
+            -----
+            - Complexity is approximately O(n log n + k) where k is the
+                number of candidate pairs returned by the BVH.
+            - BVH is used only as a broad-phase filter; exact distance
+                tests still guarantee correctness with respect to `ranges`.
+            """
+
+            # Basic validation
+            if not isinstance(topologies, list) or len(topologies) < 2:
+                if not silent:
+                    print("Graph.BySpatialRelationships - Error: Need a list of at least two topologies.")
+                return None
+
+            if not isinstance(ranges, list) or not isinstance(labels, list):
+                if not silent:
+                    print("Graph.BySpatialRelationships - Error: 'proximityValues' and 'proximityLabels' must be lists.")
+                return None
+
+            if len(ranges) == 0 or len(ranges) != len(labels):
+                if not silent:
+                    print("Graph.BySpatialRelationships - Error: 'proximityValues' must be non-empty and "
+                            "have the same length as 'labels'.")
+                return None
+
+            # Sort ranges and labels together (ascending by range)
+            try:
+                rl = sorted(zip(ranges, labels), key=lambda x: x[0])
+            except Exception:
+                if not silent:
+                    print("Graph.BySpatialRelationships - Error: Could not sort ranges; check they are numeric.")
+                return None
+
+            sorted_ranges = [r for (r, _) in rl]
+            sorted_labels = [lab for (_, lab) in rl]
+
+            max_range = sorted_ranges[-1]
+
+            # Precompute representative vertices (centroids) for each topology
+            vertices = []
+            n = len(topologies)
+            for i, topo in enumerate(topologies):
+                if not topo:
+                    if not silent:
+                        print(f"Graph.BySpatialRelationships - Warning: Ignoring None topology at index {i}.")
+                    vertices.append(None)
+                    continue
+                try:
+                    c_vtx = Topology.Centroid(topo)
+                except Exception:
+                    # Fallback if centroid fails
+                    if not silent:
+                        print(f"Graph.BySpatialRelationships - Error: Failed to compute centroid for topology {i}, "
+                                f"using origin as placeholder.")
+                    c_vtx = Vertex.ByCoordinates(0, 0, 0)
+
+                # Attach index dictionary to the vertex (not to the original topology)
+                d_keys = ["index"]
+                d_vals = [i]
+                v_dict = Dictionary.ByKeysValues(d_keys, d_vals)
+                c_vtx = Topology.SetDictionary(c_vtx, v_dict)
+                vertices.append(c_vtx)
+
+            # Build BVH on the original topologies
+            try:
+                bvh = BVH.ByTopologies(topologies)
+            except Exception as e:
+                if not silent:
+                    print(f"Graph.BySpatialRelationships - Error: Failed to build BVH, falling back to O(n^2): {e}")
+                # Fallback: use the non-BVH variant if you like,
+                # or just early-return None. Here we just bail out.
+                return None
+
+            # Map from topology identity to index for fast lookup
+            id_to_index = {id(topo): i for i, topo in enumerate(topologies)}
+
+            # Helper to compute distance between two topologies
+            def _distance(topoA, topoB, vA, vB):
+                d_val = None
+                if useShortestDistance:
+                    try:
+                        d_val = Topology.ShortestDistance(topoA, topoB)
+                    except Exception:
+                        d_val = None
+                if d_val is None:
+                    try:
+                        d_val = Vertex.Distance(vA, vB)
+                    except Exception:
+                        d_val = None
+                return d_val
+
+            edges = []
+
+            # Main loop: for each topology, query BVH for candidates within
+            # a bounding box of size 2*max_range around its centroid.
+            for i in range(n):
+                topo_i = topologies[i]
+                v_i = vertices[i]
+                if topo_i is None or v_i is None:
+                    continue
+
+                # Build a query box centered at the centroid with size 2 * max_range
+                try:
+                    query_box = Cell.Prism(
+                        origin=v_i,
+                        width=2 * max_range,
+                        length=2 * max_range,
+                        height=2 * max_range
+                    )
+                except Exception as q_err:
+                    if not silent:
+                        print(f"Graph.BySpatialRelationships - Error: Failed to build query box for {i}: {q_err}")
+                    continue
+
+                try:
+                    candidates = BVH.Clashes(bvh, query_box)
+                except Exception as c_err:
+                    if not silent:
+                        print(f"Graph.BySpatialRelationships - Error: BVH.Clashes failed for {i}: {c_err}")
+                    continue
+
+                if not candidates:
+                    continue
+
+                for cand in candidates:
+                    j = id_to_index.get(id(cand), None)
+                    if j is None:
+                        continue
+                    # Enforce i < j to avoid duplicate edges
+                    if j <= i:
+                        continue
+
+                    topo_j = topologies[j]
+                    v_j = vertices[j]
+                    if topo_j is None or v_j is None:
+                        continue
+
+                    # Compute exact distance
+                    d = _distance(topo_i, topo_j, v_i, v_j)
+                    if d is None:
+                        if not silent:
+                            print(f"Graph.BySpatialRelationships - Error: Could not compute distance between "
+                                    f"{i} and {j}.")
+                        continue
+
+                    # Skip if beyond max range (plus tolerance)
+                    if d > max_range + tolerance:
+                        continue
+
+                    # Bin the distance into the appropriate range/label
+                    label = None
+                    range_max = None
+                    for r, lab in zip(sorted_ranges, sorted_labels):
+                        if d <= r + tolerance:
+                            label = lab
+                            range_max = r
+                            break
+
+                    if label is None:
+                        continue
+
+                    e_keys = ["distance", "proximity", "range_max", "source_index", "target_index"]
+                    e_values = [float(d), str(label), float(range_max), i, j]
+                    d = Dictionary.ByKeysValues(e_keys, e_values)
+                    edges.append(d)
+
+            return edges
+
         # ---------- BVH once ----------
         bvh = BVH.ByTopologies(topologyList, silent=True)
 
@@ -4838,7 +5094,8 @@ class Graph:
         for i, t in enumerate(topologyList):
             d = Topology.Dictionary(t)
             d = Dictionary.SetValueAtKey(d, vertexIDKey, i)
-            d = Dictionary.SetValuesAtKeys(d, ["brep", "brepType", "brepTypeString"], [Topology.BREPString(t), Topology.Type(t), Topology.TypeAsString(t)])
+            if storeBREP == True:
+                d = Dictionary.SetValuesAtKeys(d, ["brep", "brepType", "brepTypeString"], [Topology.BREPString(t), Topology.Type(t), Topology.TypeAsString(t)])
             vertex_dicts[i] = d
             v = Topology.InternalVertex(t) if useInternalVertex else Topology.Centroid(t)
             vertices_objs[i] = v
@@ -4882,16 +5139,38 @@ class Graph:
                 # keep same tag both ways for symmetric predicates
                 fwd = rel
                 bwd = rel
-            edges.append([ai, bj])
-            edge_dicts.append(
-                Dictionary.ByKeysValues(
+            if [ai, bj] in edges:
+                i = edges.index([ai, bj])
+                edge_dict = Dictionary.ByKeysValues(
                     [edgeKeyFwd, edgeKeyBwd, connectsKey],
-                    [fwd, bwd, [ai, bj]],
-                )
-            )
+                    [fwd, bwd, [ai, bj]])
+                edge_dicts[i] = edge_dict
+            else:
+
+                edges.append([ai, bj])
+                edge_dicts.append(
+                    Dictionary.ByKeysValues(
+                        [edgeKeyFwd, edgeKeyBwd, connectsKey],
+                        [fwd, bwd, [ai, bj]],
+                    ))
 
         # ---------- main loops (each unordered pair once) ----------
+        if "proximity" in include:
+            prox_dicts = _calc_proximity(topologies = topologyList,
+                            ranges = proximityValues,
+                            labels = proximityLabels,
+                            useShortestDistance = useShortestDistance,
+                            tolerance = tolerance,
+                            silent = silent)
+            for prox_dict in prox_dicts:
+                ai = Dictionary.ValueAtKey(prox_dict, "source_index")
+                bj = Dictionary.ValueAtKey(prox_dict, "target_index")
+                rel = Dictionary.ValueAtKey(prox_dict, "proximity")
+                if (rel in proximityLabels):
+                    _add_edge(ai, bj, rel)
+        
         for i, a in enumerate(topologyList):
+            candidates = []
             ai = i
             candidates = BVH.Clashes(bvh, a) or []
             if not candidates:
@@ -4901,7 +5180,7 @@ class Graph:
 
             for b in candidates:
                 bj = index_of.get(id(b))
-                if bj is None or bj <= ai:
+                if bj is None or bj <= ai: 
                     continue  # skip self and already-processed pairs
 
                 # Ultra-fast "disjoint" emit via AABB if requested and boxes do not overlap
@@ -4909,7 +5188,7 @@ class Graph:
                     if want_disjoint:
                         _add_edge(ai, bj, "disjoint")
                     continue  # done with this pair
-
+                
                 # Otherwise evaluate exact relation (short-circuit inside)
                 rel = Topology.SpatialRelationship(
                     a,

topologicpy/Plotly.py

@@ -799,7 +799,7 @@ class Plotly:
                                     z=z,
                                     name=legendLabel,
                                     showlegend=showLegend,
-                                    marker=dict(symbol="circle", size=marker_width, color=color),
+                                    marker=dict(symbol="circle", size=marker_width, color=d_color),
                                     mode=mode,
                                     line=dict(color=d_color, width=width, dash=dot),
                                     legendgroup=legendGroup,

topologicpy/Shell.py

@@ -179,8 +179,7 @@ class Shell():
             #return Cluster.ByTopologies(skEdges)
         #print("ShellByDisjointFaces - Error: Could not derive central skeleton of interior walls. Returning None.")
         #return None
-
-            shell = Topology.Slice(internalBoundary, skeleton_cluster, tolerance=tolerance)
+            shell = Topology.Slice(Topology.Copy(internalBoundary), skeleton_cluster, tolerance=tolerance)
             if mergeJunctions == True:
                 vertices = Topology.Vertices(shell, silent=True)
                 centers = []

topologicpy/Topology.py

@@ -10098,7 +10098,9 @@ class Topology():
     @staticmethod
     def SpatialRelationship(topologyA,
                             topologyB,
-                            include: list = ["contains", "coveredBy", "covers", "crosses", "disjoint", "equals", "overlaps", "touches","within"],
+                            include: list = ["contains", "coveredBy", "covers", "crosses", "disjoint", "equals", "overlaps", "touches","within", "proximity"],
+                            proximityValues = [1, 5, 10],
+                            proximityLabels = ["near", "intermediate", "far"],
                             mantissa: int = 6,
                             tolerance: float = 0.0001,
                             silent: bool = False):
@@ -10123,6 +10125,17 @@ class Topology():
             - Overlaps: The intersection of the two geometries results in a new, distinct geometry of the same dimension. For example, two overlapping polygons produce a new polygon.
             - Touches: The geometries share at least one point on their boundaries but their interiors do not intersect.
             - Within: The interior and boundary of geometry A are completely contained within the interior of geometry B.
+            - Proximity: Classifies the shortest distance between the objects according to proximityValues and proximityLabels.
+        proximityValues: list , optional
+            The list of maximum distance values that specify the desired proximityLabel.
+            This list must be sorted in ascending order and have the same number of elements as the proximityLabels list.
+            Objects that are further than the largest specified distance are not classified and not included.
+            An object is considered to fall within the range if it is less than or equal to the value in this list.
+            If you wish ALL objects to be classified specifiy the last number in this list to be larger than the
+            largest distance that can exist between any two objects in the list. Default is [1, 5, 10]
+        proximityLabels: list , optional
+            The list of range labels (e.g. "near", "intermediate", "far") that correspond to the proximityValues list.
+            The list must have the same number of elements as the proximityValues list. Default is ["near", "intermediate", "far"]
         mantissa : int , optional
             The desired length of the mantissa. Default is 6.
         tolerance : float , optional
@@ -10147,6 +10160,11 @@ class Topology():
             if not silent:
                 print("Topology.SpatialRelationship - Error: The topologyB input parameter is not a valid Topology. Returning None.")
             return None
+        
+        if len(proximityValues) != len(proximityLabels):
+            if not silent:
+                print("Topology.SpatialRelationship - Error: the proximityValues and proximityLabels input parameters are not of the same length. Returning None")
+            return None
 
         from topologicpy.Vertex import Vertex
         from topologicpy.Cluster import Cluster
@@ -10263,6 +10281,13 @@ class Topology():
 
         # ---------- predicates ----------
 
+        def proximity(a, b, proximityValues, proximityLabels):
+            sd = Topology.ShortestDistance(a,b, tolerance=tolerance, silent=silent)
+            for i, pv in enumerate(proximityValues):
+                if sd <= pv:
+                    return proximityLabels[i]
+            return None
+
         def contains(a, b):
             # The inverse of "within," where geometry A contains geometry B.
             # The interior and boundary of B are completely contained within the interior of A.
@@ -10439,8 +10464,11 @@ class Topology():
         # 7) touches (incl. vertex-at-endpoint)
         if "touches" in inc and touches(topologyA, topologyB):
             return "touches"
+        # 8) proximity
+        if "proximity" in inc:
+            return proximity(topologyA, topologyB, proximityValues, proximityLabels)
         
-        return "unknown"
+        return None
 
     @staticmethod
     def Spin(topology, origin=None, triangulate: bool = True, direction: list = [0, 0, 1], angle: float = 360, sides: int = 16,

topologicpy/version.py

@@ -1 +1 @@
-__version__ = '0.8.87'
+__version__ = '0.8.89'

{topologicpy-0.8.87.dist-info → topologicpy-0.8.89.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: topologicpy
-Version: 0.8.87
+Version: 0.8.89
 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.87.dist-info → topologicpy-0.8.89.dist-info}/RECORD

@@ -12,28 +12,28 @@ topologicpy/Dictionary.py,sha256=goODXIM6AoC5Qn_d8LGc5pRoxZKgIWbkn3IOEbsQ4c4,449
 topologicpy/Edge.py,sha256=aiRd1xZgG2GGYHxva0bM-kDy3AVmwGA_S2pMur8EeMg,74911
 topologicpy/EnergyModel.py,sha256=MEai1GF1hINeH5bhclJj_lpMU3asFTvW2RlPm40GNj4,57794
 topologicpy/Face.py,sha256=qAl36LcwiyRclMM2pI9NyWHzmgNlaykXiJx1wu10RmA,201317
-topologicpy/Graph.py,sha256=GtDUoAOLG1jAIBPcuUBLwjkvNZP7-gDL-x6fcSbCtmI,794853
+topologicpy/Graph.py,sha256=AfX4M_55zGBOm5RwpVEkr3JHv-hITFh9ckW1_jsLxFs,808052
 topologicpy/Grid.py,sha256=3OsBMyHh4w8gpFOTMKHMNTpo62V0CwRNu5cwm87yDUA,18421
 topologicpy/Helper.py,sha256=NsmMlbbKFPRX6jfoko-ZQVQ7MBsfVp9FD0ZvC2U7q-8,32002
 topologicpy/Honeybee.py,sha256=dBk01jIvxjQMGHqSarM1Cukv16ot4Op7Dwlitn2OMoc,48990
 topologicpy/Kuzu.py,sha256=fxaDPWM5Xam7Tot0olPZsazS_7xgE_Vo-jf0Sbv3VZE,36298
 topologicpy/Matrix.py,sha256=bOofT34G3YHu9aMIWx60YHAJga4R0GbDjsZBUD4Hu_k,22706
 topologicpy/Neo4j.py,sha256=J8jU_mr5-mWC0Lg_D2dMjMlx1rY_eh8ks_aubUuTdWw,22319
-topologicpy/Plotly.py,sha256=sYCP7D112sbWWGnA2q7ThjHv7KHL5wHUwsIs5xEnvLA,123246
+topologicpy/Plotly.py,sha256=jQTIPaOZErZhj1vDjsF3SYsDhPx4fQ0W75q6XEQFMBk,123248
 topologicpy/Polyskel.py,sha256=oVfM4lqSMPTjnkHfsRU9VI8Blt6Vf0LVPkD9ebz7Wmw,27082
 topologicpy/PyG.py,sha256=wOsoBFxMgwZYWjj86OMkz_PJuQ02locV_djhSDD6dVc,109644
 topologicpy/ShapeGrammar.py,sha256=q_BvMKOBDW3GVSRjPLIGAZkHW2egw3mTOPzIyEpYOLg,23349
-topologicpy/Shell.py,sha256=qvIkE76cie7cOl-AK23ORi6mDQb-UsXVOF7or7hBvWw,101070
+topologicpy/Shell.py,sha256=2EPzDT_t0IAjBRYPDuKNAz_Ax_HaEkvNpXBxDkPdcTg,101084
 topologicpy/Speckle.py,sha256=-eiTqJugd7pHiHpD3pDUcDO6CGhVyPV14HFRzaqEoaw,18187
 topologicpy/Sun.py,sha256=ezisiHfc2nd7A_8w0Ykq2VgbS0A9WNSg-tBwvfTQAVM,36735
-topologicpy/Topology.py,sha256=p8jOONJz19PrFAuMV3eGti6iTer8bAUk0zpvKmkAK48,546600
+topologicpy/Topology.py,sha256=E_AyPPCIx_Eq-UT74QS3LKFXIwdwekRjJJGTo1CRMRY,548577
 topologicpy/Vector.py,sha256=pEC8YY3TeHGfGdeNgvdHjgMDwxGabp5aWjwYC1HSvMk,42236
 topologicpy/Vertex.py,sha256=26TrlX9OCZUN-lMlZG3g4RHTWBqw69NW4AOEgRz_YMo,91269
 topologicpy/Wire.py,sha256=au0ZkuuZgVzHYE5E1fRwflRT3win0yTivHKOhonAzUk,234116
 topologicpy/__init__.py,sha256=RMftibjgAnHB1vdL-muo71RwMS4972JCxHuRHOlU428,928
-topologicpy/version.py,sha256=koft0X1ZY8adezuRt_HJmfuap76X3-p_mFskEkgvYXg,23
-topologicpy-0.8.87.dist-info/licenses/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
-topologicpy-0.8.87.dist-info/METADATA,sha256=_9u_cKxdwaFzHH_RADU3YEESPkfjqPpIszuPaaUGNFc,10535
-topologicpy-0.8.87.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-topologicpy-0.8.87.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
-topologicpy-0.8.87.dist-info/RECORD,,
+topologicpy/version.py,sha256=YhsAc7e0YNllH7mN5LamhWpA_q-FmHWAFByeNTu5xTk,23
+topologicpy-0.8.89.dist-info/licenses/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
+topologicpy-0.8.89.dist-info/METADATA,sha256=55cNepIhl59TBcxtlcTmihxcT8dcait0fIEuKHXUq3A,10535
+topologicpy-0.8.89.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+topologicpy-0.8.89.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
+topologicpy-0.8.89.dist-info/RECORD,,