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

topologicpy/Graph.py

@@ -22,6 +22,7 @@ import warnings
 
 from collections import namedtuple
 from multiprocessing import Process, Queue
+from typing import Any
 
 try:
     import numpy as np
@@ -5251,7 +5252,8 @@ class Graph:
                    useInternalVertex: bool = False,
                    storeBREP: bool =False,
                    mantissa: int = 6,
-                   tolerance: float = 0.0001):
+                   tolerance: float = 0.0001,
+                   silent: float = False):
         """
         Creates a graph.See https://en.wikipedia.org/wiki/Graph_(discrete_mathematics).
 
@@ -5305,6 +5307,8 @@ class Graph:
             If set to True, store the BRep of the subtopology in its representative vertex. Default is False.
         tolerance : float , optional
             The desired tolerance. Default is 0.0001.
+        silent : bool , optional
+            If set to True, error and warning messages are suppressed. Default is False.
 
         Returns
         -------
@@ -5319,6 +5323,10 @@ class Graph:
         from topologicpy.Topology import Topology
         from topologicpy.Aperture import Aperture
         
+        if not Topology.IsInstance(topology, "topology"):
+            if not silent:
+                print("Graph.ByTopology - Error: The input topology parameter is not a valid topology. Returning None.")
+            return None
         def _viaSharedTopologies(vt, sharedTops):
             verts = []
             eds = []
@@ -15533,7 +15541,16 @@ class Graph:
         return graph
 
     @staticmethod
-    def ShortestPath(graph, vertexA, vertexB, vertexKey="", edgeKey="Length", tolerance=0.0001):
+    def ShortestPath(graph,
+                     vertexA,
+                     vertexB,
+                     vertexKey: str = "",
+                     edgeKey: str = "Length",
+                     transferDictionaries: bool = False,
+                     straighten: bool = False,
+                     face: Any = None,
+                     tolerance: float = 0.0001,
+                     silent: bool = False):
         """
         Returns the shortest path that connects the input vertices. The shortest path will take into consideration both the vertexKey and the edgeKey if both are specified and will minimize the total "cost" of the path. Otherwise, it will take into consideration only whatever key is specified.
 
@@ -15549,8 +15566,19 @@ class Graph:
             The vertex key to minimise. If set the vertices dictionaries will be searched for this key and the associated value will be used to compute the shortest path that minimized the total value. The value must be numeric. Default is None.
         edgeKey : string , optional
             The edge key to minimise. If set the edges dictionaries will be searched for this key and the associated value will be used to compute the shortest path that minimized the total value. The value of the key must be numeric. If set to "length" (case insensitive), the shortest path by length is computed. Default is "length".
+        transferDictionaries : bool , optional
+            If set to True, the dictionaries from the graph vertices will be transferred to the vertices of the shortest path. Otherwise, they won't. Default is False.
+            Note: Edge dictionaries are not transferred (In straightened paths, the path edges are no longer the same as
+            the original graph edges. Thus, you must implement your own logic to transfer edge dictionaries if needed).
+       straighten : bool , optional
+            If set to True, the path will be straightened as much as possible while remaining inside the specified face.
+            Thus, the face input must be a valid topologic Face that is planar and residing on the XY plane. Default is False.
+        face : topologic_core.Face , optional
+            The face on which the path resides. This is used for straightening the path. Default is None.
         tolerance : float , optional
             The desired tolerance. Default is 0.0001.
+        silent : bool , optional
+            If set to True, error and warning messages are suppressed. Default is False.
         
         Returns
         -------
@@ -15563,21 +15591,29 @@ class Graph:
         from topologicpy.Topology import Topology
 
         if not Topology.IsInstance(graph, "Graph"):
-            print("Graph.ShortestPath - Error: The input graph is not a valid graph. Returning None.")
+            if not silent:
+                print("Graph.ShortestPath - Error: The input graph is not a valid graph. Returning None.")
             return None
         if not Topology.IsInstance(vertexA, "Vertex"):
-            print("Graph.ShortestPath - Error: The input vertexA is not a valid vertex. Returning None.")
+            if not silent:
+                print("Graph.ShortestPath - Error: The input vertexA is not a valid vertex. Returning None.")
             return None
         if not Topology.IsInstance(vertexB, "Vertex"):
-            print("Graph.ShortestPath - Error: The input vertexB is not a valid vertex. Returning None.")
+            if not silent:
+                print("Graph.ShortestPath - Error: The input vertexB is not a valid vertex. Returning None.")
             return None
+        if straighten == True:
+            if not Topology.IsInstance(face, "face"):
+                if not silent:
+                    print("Graph.ShortestPath - Error: Straighten is set to True, but the face parameter is not a valid toopologic face. Returning None.")
+                return None
         if edgeKey:
             if edgeKey.lower() == "length":
                 edgeKey = "Length"
         try:
             gsv = Graph.NearestVertex(graph, vertexA)
             gev = Graph.NearestVertex(graph, vertexB)
-            shortest_path = graph.ShortestPath(gsv, gev, vertexKey, edgeKey)
+            shortest_path = graph.ShortestPath(gsv, gev, vertexKey, edgeKey) # Hook to Core
             if not shortest_path == None:
                 if Topology.IsInstance(shortest_path, "Edge"):
                         shortest_path = Wire.ByEdges([shortest_path])
@@ -15586,6 +15622,14 @@ class Graph:
                     if Topology.IsInstance(shortest_path, "Wire"):
                         shortest_path = Wire.Reverse(shortest_path)
                 shortest_path = Wire.OrientEdges(shortest_path, Wire.StartVertex(shortest_path), tolerance=tolerance)
+            if Topology.IsInstance(shortest_path, "wire"):
+                if straighten == True and Topology.IsInstance(face, "face"):
+                    shortest_path = Wire.StraightenInFace(shortest_path, face)
+                if transferDictionaries == True:
+                    path_verts = Topology.Vertices(shortest_path)
+                    for p_v in path_verts:
+                        g_v = Graph.NearestVertex(graph, p_v)
+                        p_v = Topology.SetDictionary(p_v, Topology.Dictionary(g_v))
             return shortest_path
         except:
             return None

topologicpy/Wire.py

@@ -331,16 +331,19 @@ class Wire():
                         
         else:
             best_br = boundingRectangle
-        x_min, y_min, maxX, maxY = best_br
+        x_min, y_min, x_max, y_max = best_br
         vb1 = Vertex.ByCoordinates(x_min, y_min, 0)
-        vb2 = Vertex.ByCoordinates(maxX, y_min, 0)
-        vb3 = Vertex.ByCoordinates(maxX, maxY, 0)
-        vb4 = Vertex.ByCoordinates(x_min, maxY, 0)
+        vb2 = Vertex.ByCoordinates(x_max, y_min, 0)
+        vb3 = Vertex.ByCoordinates(x_max, y_max, 0)
+        vb4 = Vertex.ByCoordinates(x_min, y_max, 0)
 
         boundingRectangle = Wire.ByVertices([vb1, vb2, vb3, vb4], close=True, tolerance=tolerance, silent=silent)
         boundingRectangle = Topology.Rotate(boundingRectangle, origin=origin, axis=[0, 0, 1], angle=-best_z)
         boundingRectangle = Topology.Unflatten(boundingRectangle, origin=f_origin, direction=normal)
-        dictionary = Dictionary.ByKeysValues(["zrot"], [best_z])
+        dictionary = Dictionary.ByKeysValues(["zrot", "xmin", "ymin", "xmax", "ymax", "width", "length"],
+                                             [best_z, x_min, y_min, x_max, y_max, (x_max - x_min), (y_max - y_min)])
+
+        #dictionary = Dictionary.ByKeysValues(["zrot"], [best_z])
         boundingRectangle = Topology.SetDictionary(boundingRectangle, dictionary)
         return boundingRectangle
 
@@ -2426,7 +2429,254 @@ class Wire():
         # Unflatten the wire
         return_wire = Topology.Unflatten(flat_wire, origin=Vertex.Origin(), direction=normal)
         return return_wire
-    
+
+    @staticmethod
+    def Funnel(face,
+                vertexA,
+                vertexB,
+                portals,
+                tolerance: float = 0.0001,
+                silent: float = False):
+        """
+        Returns a Wire representing a smoothed path inside the given face using
+        the funnel (string-pulling) algorithm.
+
+        The algorithm assumes that a corridor has already been computed, and is
+        provided as an ordered list of "portals" (pairs of vertices) that lie
+        on the face between the start and end locations.
+
+        Parameters
+        ----------
+        face : topologic_core.Face
+            The planar face on which navigation occurs. All vertices must lie
+            on this face.
+        vertexA : topologic_core.Vertex
+            The start point of the path.
+        vertexB : topologic_core.Vertex
+            The end point of the path.
+        portals : list of tuple(Vertex, Vertex)
+            Ordered list of corridor edges. Each item is (leftVertex, rightVertex)
+            describing the visible "portal" between two consecutive regions along
+            the navmesh path.
+        tolerance : float , optional
+            Numerical tolerance used when comparing orientations and distances.
+            Default is 0.0001.
+        silent : bool , optional
+            If set to True, error and warning messages are suppressed. Default is False.
+
+        Returns
+        -------
+        wire : topologic_core.Wire
+            A Wire representing the smoothed path from startVertex to endVertex
+            that stays inside the navigation corridor on the face.
+        """
+        from topologicpy.Dictionary import Dictionary
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Face import Face
+        from topologicpy.Topology import Topology
+
+        if not Topology.IsInstance(face, "face"):
+            if not silent:
+                print("Wire.Funnel - Error: The input face parameter is not a topologic face. Returning None.")
+            return None
+        if not Topology.IsInstance(vertexA, "vertex"):
+            if not silent:
+                print("Wire.Funnel - Error: The input vertexA parameter is not a topologic vertex. Returning None.")
+            return None
+        if not Topology.IsInstance(vertexB, "vertex"):
+            if not silent:
+                print("Wire.Funnel - Error: The input vertexB parameter is not a topologic vertex. Returning None.")
+            return None
+
+        # ------------------------------------------------------------
+        # 1. Basic helpers
+        # ------------------------------------------------------------
+        def _norm(v):
+            return math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2])
+
+        def _normalize(v):
+            n = _norm(v)
+            if n < tolerance:
+                return (0.0, 0.0, 0.0)
+            return (v[0] / n, v[1] / n, v[2] / n)
+
+        def _dot(a, b):
+            return a[0] * b[0] + a[1] * b[1] + a[2] * b[2]
+
+        def _cross(a, b):
+            return (
+                a[1] * b[2] - a[2] * b[1],
+                a[2] * b[0] - a[0] * b[2],
+                a[0] * b[1] - a[1] * b[0],
+            )
+
+        def _sub(a, b):
+            return (a[0] - b[0], a[1] - b[1], a[2] - b[2])
+
+        def _tri_area2(a2, b2, c2):
+            """
+            Twice the signed area of triangle (a, b, c) in 2D.
+            Positive => c is to the left of ab
+            Negative => c is to the right of ab
+            """
+            return (b2[0] - a2[0]) * (c2[1] - a2[1]) - (b2[1] - a2[1]) * (c2[0] - a2[0])
+
+        def _coords3d(v):
+            x, y, z = Vertex.Coordinates(v)
+            return (x, y, z)
+
+        # ------------------------------------------------------------
+        # 2. Build a local 2D coordinate system on the face
+        # ------------------------------------------------------------
+        # Face normal
+        n_vec = Face.Normal(face)  # [nx, ny, nz]
+        n = _normalize((n_vec[0], n_vec[1], n_vec[2]))
+
+        # Choose an arbitrary vector not parallel to n
+        if abs(n[0]) < 0.9:
+            arbitrary = (1.0, 0.0, 0.0)
+        else:
+            arbitrary = (0.0, 1.0, 0.0)
+
+        u = _normalize(_cross(n, arbitrary))  # tangent
+        v = _cross(n, u)                      # bitangent, already orthogonal and normalized
+
+        def _project_to_2d(vertex):
+            p = _coords3d(vertex)
+            # project onto basis (u, v)
+            return (_dot(p, u), _dot(p, v))
+
+        # Precompute 2D coords for start, end and all portal vertices
+        start2d = _project_to_2d(vertexA)
+        end2d = _project_to_2d(vertexB)
+
+        portal2d = []
+        for l_v, r_v in portals:
+            portal2d.append((_project_to_2d(l_v), _project_to_2d(r_v)))
+
+        # ------------------------------------------------------------
+        # 3. Funnel algorithm in 2D
+        #   (based on classic Recast / string-pulling implementation)
+        # ------------------------------------------------------------
+        path_vertices = [vertexA]
+
+        apex2d = start2d
+        apexVertex = vertexA
+        apexIndex = -1
+
+        left2d = start2d
+        right2d = start2d
+        leftVertex = vertexA
+        rightVertex = vertexB
+        leftIndex = -1
+        rightIndex = -1
+
+        n_portals = len(portals)
+        i = 0
+
+        # We will process all portals, and then a final "portal" at the goal (end, end)
+        while i <= n_portals:
+            if i < n_portals:
+                newLeft2d, newRight2d = portal2d[i]
+                newLeftVertex, newRightVertex = portals[i]
+            else:
+                # last "portal" is the goal point itself
+                newLeft2d = end2d
+                newRight2d = end2d
+                newLeftVertex = vertexB
+                newRightVertex = vertexB
+
+            # --------------------------------------------------------
+            # Update right side of funnel
+            # --------------------------------------------------------
+            area_apex_right_newRight = _tri_area2(apex2d, right2d, newRight2d)
+            if area_apex_right_newRight <= tolerance:
+                # New right vertex is "inside" or tightening the funnel
+                area_apex_left_newRight = _tri_area2(apex2d, left2d, newRight2d)
+                if (apexVertex == rightVertex) or (area_apex_left_newRight > tolerance):
+                    # Tighten the funnel on the right side
+                    right2d = newRight2d
+                    rightVertex = newRightVertex
+                    rightIndex = i
+                else:
+                    # Right over left, so left becomes the new apex
+                    path_vertices.append(leftVertex)
+                    apex2d = _project_to_2d(leftVertex)
+                    apexVertex = leftVertex
+                    apexIndex = leftIndex
+
+                    # Reset funnel
+                    left2d = apex2d
+                    right2d = apex2d
+                    leftVertex = apexVertex
+                    rightVertex = apexVertex
+                    leftIndex = apexIndex
+                    rightIndex = apexIndex
+
+                    # Restart from the new apex
+                    i = apexIndex + 1
+                    continue
+
+            # --------------------------------------------------------
+            # Update left side of funnel
+            # --------------------------------------------------------
+            area_apex_left_newLeft = _tri_area2(apex2d, left2d, newLeft2d)
+            if area_apex_left_newLeft >= -tolerance:
+                # New left vertex is "inside" or tightening the funnel
+                area_apex_right_newLeft = _tri_area2(apex2d, right2d, newLeft2d)
+                if (apexVertex == leftVertex) or (area_apex_right_newLeft < -tolerance):
+                    # Tighten funnel on the left side
+                    left2d = newLeft2d
+                    leftVertex = newLeftVertex
+                    leftIndex = i
+                else:
+                    # Left over right, so right becomes the new apex
+                    path_vertices.append(rightVertex)
+                    apex2d = _project_to_2d(rightVertex)
+                    apexVertex = rightVertex
+                    apexIndex = rightIndex
+
+                    # Reset funnel
+                    left2d = apex2d
+                    right2d = apex2d
+                    leftVertex = apexVertex
+                    rightVertex = apexVertex
+                    leftIndex = apexIndex
+                    rightIndex = apexIndex
+
+                    # Restart from the new apex
+                    i = apexIndex + 1
+                    continue
+
+            i += 1
+
+        # Finally, add the end point if it is not already in the path
+        if path_vertices[-1] is not vertexB:
+            path_vertices.append(vertexB)
+
+        # ------------------------------------------------------------
+        # 4. Build and return the Topologic wire
+        # ------------------------------------------------------------
+        return_wire = Wire.ByVertices(path_vertices, close=False, silent=True)
+        bb = Wire.BoundingRectangle(face)
+        d = Topology.Dictionary(bb)
+        width = Dictionary.ValueAtKey(d, "width")
+        length = Dictionary.ValueAtKey(d, "length")
+        size = max(width, length)
+        percentage = 0.25 # Start with 25% of the total size
+        is_ok = False
+        while is_ok == False and percentage > 0:
+            new_wire = Wire.Simplify(return_wire, tolerance=size*percentage, silent=True)
+            test_wire = Topology.Scale(new_wire, Topology.Centroid(new_wire), 0.95, 0.95, 1)
+            result = Topology.Difference(test_wire, face, tolerance=tolerance, silent=True)
+            if result is None:
+                is_ok = True
+                return_wire = new_wire
+            percentage -= 0.01
+        print("Wire.Funnel - Result:", result)
+        print("Wire.Funnel - Percentage:", percentage)
+        return new_wire
+
     @staticmethod
     def InteriorAngles(wire, tolerance: float = 0.0001, mantissa: int = 6) -> list:
         """
@@ -4188,7 +4438,7 @@ class Wire():
             if not silent:
                 print("Wire.Simplify - Warning: Could not generate enough vertices for a simplified wire. Returning the original wire.")
             wire
-        new_wire = Wire.ByVertices(new_vertices, close=Wire.IsClosed(wire), tolerance=tolerance)
+        new_wire = Wire.ByVertices(new_vertices, close=Wire.IsClosed(wire), tolerance=tolerance, silent=True)
         if not Topology.IsInstance(new_wire, "wire"):
             if not silent:
                 print("Wire.Simplify - Warning: Could not generate a simplified wire. Returning the original wire.")
@@ -4713,6 +4963,124 @@ class Wire():
         sv, ev = Wire.StartEndVertices(wire, silent=silent)
         return sv
 
+    @staticmethod
+    def StraightenInFace(wire, face, tolerance: float = 0.0001):
+        """
+        Returns a new Wire obtained by recursively replacing segments of the
+        input wire with the longest possible straight edge that is fully
+        embedded in the given face.
+
+        For each starting vertex v_i along the wire, this method searches for
+        the furthest vertex v_j (j > i) such that the straight Edge between
+        v_i and v_j satisfies:
+
+            Topology.Difference(edge, face) == None
+
+        i.e. the edge lies completely within (or on the boundary of) the face.
+        All edges of the original wire between vertex indices i and j are then
+        replaced by this straight edge, and the process is repeated recursively
+        from index j.
+
+        Parameters
+        ----------
+        wire : topologic_core.Wire
+            The input path wire whose vertices define the route to be
+            straightened.
+        face : topologic_core.Face
+            The face within which the straightened edges must lie.
+        tolerance : float , optional
+            Numerical tolerance used for internal robustness checks. The
+            Topology.Difference call itself is left with its default tolerance.
+            Default is 1e-6.
+
+        Returns
+        -------
+        wire : topologic_core.Wire
+            A new Wire whose vertices define the recursively straightened path.
+        """
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Edge import Edge
+        from topologicpy.Wire import Wire
+        from topologicpy.Face import Face
+        from topologicpy.Topology import Topology
+        # Get ordered vertices of the wire
+        vertices = Topology.Vertices(wire)
+        n = len(vertices)
+
+        if n <= 2:
+            # Nothing to straighten
+            return wire
+
+        def _edge_inside_face(v_start, v_end):
+            """
+            Returns True if the straight edge between v_start and v_end is
+            fully embedded in the face, i.e. Topology.Difference(edge, face)
+            returns None.
+            """
+            if v_start is v_end:
+                return True
+            edge = Edge.ByStartVertexEndVertex(v_start, v_end)
+            diff = Topology.Difference(edge, face)
+            return diff is None
+
+        def _find_longest_valid_index(start_idx):
+            """
+            For a fixed start_idx, search for the largest index j >= start_idx+1
+            such that the direct edge (vertices[start_idx], vertices[j]) is
+            fully inside the face.
+
+            If for any reason no such j exists (which should not happen if the
+            original wire lies in the face), it falls back to start_idx + 1.
+            """
+            v_start = vertices[start_idx]
+            best_j = None
+
+            for j in range(start_idx + 1, n):
+                v_end = vertices[j]
+                if _edge_inside_face(v_start, v_end):
+                    best_j = j
+                # Do NOT break on failure: a further vertex might still
+                # be reachable by a straight edge that stays in the face.
+
+            if best_j is None:
+                # Fallback: use the immediate next vertex to avoid stalling
+                best_j = min(start_idx + 1, n - 1)
+
+            return best_j
+
+        def _straighten_recursive(start_idx, out_vertices):
+            """
+            Recursive helper.
+
+            Appends the chosen vertices to out_vertices. At each step, it
+            decides how far it can jump from start_idx with a single straight
+            edge inside the face, then recurses from that new index.
+            """
+            # Base case: we are at the last vertex
+            if start_idx == n - 1:
+                out_vertices.append(vertices[start_idx])
+                return
+
+            # Find furthest valid index reachable from start_idx
+            next_idx = _find_longest_valid_index(start_idx)
+
+            # Add the starting vertex for this segment
+            out_vertices.append(vertices[start_idx])
+
+            # Recurse from the chosen furthest index
+            _straighten_recursive(next_idx, out_vertices)
+
+        # Run the recursion
+        new_vertices = []
+        _straighten_recursive(0, new_vertices)
+
+        # In case of any numerical quirks, ensure the last original vertex is present
+        if new_vertices[-1] is not vertices[-1]:
+            new_vertices.append(vertices[-1])
+
+        # Build the new straightened wire
+        return Wire.ByVertices(new_vertices, close=False)
+
     @staticmethod
     def Trapezoid(origin= None, widthA: float = 1.0, widthB: float = 0.75, offsetA: float = 0.0, offsetB: float = 0.0, length: float = 1.0, direction: list = [0, 0, 1], placement: str = "center", tolerance: float = 0.0001):
         """

topologicpy/version.py

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

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

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

@@ -12,7 +12,7 @@ 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=AfX4M_55zGBOm5RwpVEkr3JHv-hITFh9ckW1_jsLxFs,808052
+topologicpy/Graph.py,sha256=Tokxg55wHmx5hd9eai7EMRUdptADLt7HmJNrhq00UZk,810723
 topologicpy/Grid.py,sha256=3OsBMyHh4w8gpFOTMKHMNTpo62V0CwRNu5cwm87yDUA,18421
 topologicpy/Helper.py,sha256=NsmMlbbKFPRX6jfoko-ZQVQ7MBsfVp9FD0ZvC2U7q-8,32002
 topologicpy/Honeybee.py,sha256=dBk01jIvxjQMGHqSarM1Cukv16ot4Op7Dwlitn2OMoc,48990
@@ -29,11 +29,11 @@ topologicpy/Sun.py,sha256=ezisiHfc2nd7A_8w0Ykq2VgbS0A9WNSg-tBwvfTQAVM,36735
 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/Wire.py,sha256=Rhqw0CGEWIMVL1ICQqkCp9G-VnhhHLhEiDDR00fAn_s,248919
 topologicpy/__init__.py,sha256=RMftibjgAnHB1vdL-muo71RwMS4972JCxHuRHOlU428,928
-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,,
+topologicpy/version.py,sha256=Pd3D7UyrHnkE76qM_AOq2A2ifXXq1OxDwEg8Q1gGwk8,23
+topologicpy-0.8.91.dist-info/licenses/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
+topologicpy-0.8.91.dist-info/METADATA,sha256=S_NaUxOVkvDCJJ4xVVdtRSLZnkW0tzPwic19V2FLkuw,10535
+topologicpy-0.8.91.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+topologicpy-0.8.91.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
+topologicpy-0.8.91.dist-info/RECORD,,