topologicpy 0.8.7__py3-none-any.whl → 0.8.8__py3-none-any.whl

topologicpy/Graph.py

@@ -264,6 +264,164 @@ class _DrawTree(object):
         return self.__str__()
 
 class Graph:
+    @staticmethod
+    def AddEdge(graph, edge, transferVertexDictionaries: bool = False, transferEdgeDictionaries: bool = False, tolerance: float = 0.0001, silent: bool = False):
+        """
+        Adds the input edge to the input Graph.
+
+        Parameters
+        ----------
+        graph : topologic_core.Graph
+            The input graph.
+        edge : topologic_core.Edge
+            The input edge.
+        transferVertexDictionaries : bool, optional
+            If set to True, the dictionaries of the vertices are transferred to the graph.
+        transferEdgeDictionaries : bool, optional
+            If set to True, the dictionaries of the edges are transferred to the graph.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
+        silent : bool , optional
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
+
+        Returns
+        -------
+        topologic_core.Graph
+            The input graph with the input edge added to it.
+
+        """
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Edge import Edge
+        from topologicpy.Dictionary import Dictionary
+        from topologicpy.Topology import Topology
+
+        def addIfUnique(graph_vertices, vertex, tolerance=0.0001):
+            unique = True
+            returnVertex = vertex
+            for gv in graph_vertices:
+                if (Vertex.Distance(vertex, gv) < tolerance):
+                    if transferVertexDictionaries == True:
+                        gd = Topology.Dictionary(gv)
+                        vd = Topology.Dictionary(vertex)
+                        gk = gd.Keys()
+                        vk = vd.Keys()
+                        d = None
+                        if (len(gk) > 0) and (len(vk) > 0):
+                            d = Dictionary.ByMergedDictionaries([gd, vd])
+                        elif (len(gk) > 0) and (len(vk) < 1):
+                            d = gd
+                        elif (len(gk) < 1) and (len(vk) > 0):
+                            d = vd
+                        if d:
+                            _ = Topology.SetDictionary(gv, d, silent=True)
+                    unique = False
+                    returnVertex = gv
+                    break
+            if unique:
+                graph_vertices.append(vertex)
+            return [graph_vertices, returnVertex]
+
+        if not Topology.IsInstance(graph, "Graph"):
+            if not silent:
+                print("Graph.AddEdge - Error: The input graph is not a valid graph. Returning None.")
+            return None
+        if not Topology.IsInstance(edge, "Edge"):
+            if not silent:
+                print("Graph.AddEdge - Error: The input edge is not a valid edge. Returning the input graph.")
+            return graph
+        graph_vertices = Graph.Vertices(graph)
+        graph_edges = Graph.Edges(graph, graph_vertices, tolerance=tolerance)
+        vertices = Topology.Vertices(edge)
+        new_vertices = []
+        for vertex in vertices:
+            graph_vertices, nv = addIfUnique(graph_vertices, vertex, tolerance=tolerance)
+            new_vertices.append(nv)
+        new_edge = Edge.ByVertices([new_vertices[0], new_vertices[1]], tolerance=tolerance)
+        if transferEdgeDictionaries == True:
+            d = Topology.Dictionary(edge)
+            keys = Dictionary.Keys(d)
+            if isinstance(keys, list):
+                if len(keys) > 0:
+                    _ = Topology.SetDictionary(new_edge, d, silent=True)
+        graph_edges.append(new_edge)
+        new_graph = Graph.ByVerticesEdges(graph_vertices, graph_edges)
+        return new_graph
+    
+    @staticmethod
+    def AddVertex(graph, vertex, tolerance: float = 0.0001, silent: bool = False):
+        """
+        Adds the input vertex to the input graph.
+
+        Parameters
+        ----------
+        graph : topologic_core.Graph
+            The input graph.
+        vertex : topologic_core.Vertex
+            The input vertex.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
+        silent : bool , optional
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
+
+        Returns
+        -------
+        topologic_core.Graph
+            The input graph with the input vertex added to it.
+
+        """
+        from topologicpy.Topology import Topology
+
+        if not Topology.IsInstance(graph, "Graph"):
+            if not silent:
+                print("Graph.AddVertex - Error: The input graph is not a valid graph. Returning None.")
+            return None
+        if not Topology.IsInstance(vertex, "Vertex"):
+            if not silent:
+                print("Graph.AddVertex - Error: The input vertex is not a valid vertex. Returning the input graph.")
+            return graph
+        _ = graph.AddVertices([vertex], tolerance) # Hook to Core
+        return graph
+
+    @staticmethod
+    def AddVertices(graph, vertices, tolerance: float = 0.0001, silent: bool = False):
+        """
+        Adds the input vertex to the input graph.
+
+        Parameters
+        ----------
+        graph : topologic_core.Graph
+            The input graph.
+        vertices : list
+            The input list of vertices.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
+        silent : bool , optional
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
+
+        Returns
+        -------
+        topologic_core.Graph
+            The input graph with the input vertex added to it.
+
+        """
+        from topologicpy.Topology import Topology
+
+        if not Topology.IsInstance(graph, "Graph"):
+            if not silent:
+                print("Graph.AddVertices - Error: The input graph is not a valid graph. Returning None.")
+            return None
+        if not isinstance(vertices, list):
+            if not silent:
+                print("Graph.AddVertices - Error: The input list of vertices is not a valid list. Returning None.")
+            return None
+        vertices = [v for v in vertices if Topology.IsInstance(v, "Vertex")]
+        if len(vertices) < 1:
+            if not silent:
+                print("Graph.AddVertices - Error: Could not find any valid vertices in the input list of vertices. Returning None.")
+            return None
+        _ = graph.AddVertices(vertices, tolerance) # Hook to Core
+        return graph
+    
     def AdjacencyDictionary(graph, vertexLabelKey: str = None, edgeKey: str = "Length", includeWeights: bool = False, reverse: bool = False, mantissa: int = 6):
         """
         Returns the adjacency dictionary of the input Graph.
@@ -517,167 +675,101 @@ class Graph:
         return adjList
 
     @staticmethod
-    def AddEdge(graph, edge, transferVertexDictionaries: bool = False, transferEdgeDictionaries: bool = False, tolerance: float = 0.0001, silent: bool = False):
+    def AdjacentVertices(graph, vertex, silent: bool = False):
         """
-        Adds the input edge to the input Graph.
+        Returns the list of vertices connected to the input vertex.
 
         Parameters
         ----------
         graph : topologic_core.Graph
             The input graph.
-        edge : topologic_core.Edge
-            The input edge.
-        transferVertexDictionaries : bool, optional
-            If set to True, the dictionaries of the vertices are transferred to the graph.
-        transferEdgeDictionaries : bool, optional
-            If set to True, the dictionaries of the edges are transferred to the graph.
-        tolerance : float , optional
-            The desired tolerance. The default is 0.0001.
+        vertex : topologic_core.Vertex
+            the input vertex.
         silent : bool , optional
             If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
 
         Returns
         -------
-        topologic_core.Graph
-            The input graph with the input edge added to it.
+        list
+            The list of adjacent vertices.
 
         """
-        from topologicpy.Vertex import Vertex
-        from topologicpy.Edge import Edge
-        from topologicpy.Dictionary import Dictionary
         from topologicpy.Topology import Topology
 
-        def addIfUnique(graph_vertices, vertex, tolerance=0.0001):
-            unique = True
-            returnVertex = vertex
-            for gv in graph_vertices:
-                if (Vertex.Distance(vertex, gv) < tolerance):
-                    if transferVertexDictionaries == True:
-                        gd = Topology.Dictionary(gv)
-                        vd = Topology.Dictionary(vertex)
-                        gk = gd.Keys()
-                        vk = vd.Keys()
-                        d = None
-                        if (len(gk) > 0) and (len(vk) > 0):
-                            d = Dictionary.ByMergedDictionaries([gd, vd])
-                        elif (len(gk) > 0) and (len(vk) < 1):
-                            d = gd
-                        elif (len(gk) < 1) and (len(vk) > 0):
-                            d = vd
-                        if d:
-                            _ = Topology.SetDictionary(gv, d, silent=True)
-                    unique = False
-                    returnVertex = gv
-                    break
-            if unique:
-                graph_vertices.append(vertex)
-            return [graph_vertices, returnVertex]
-
         if not Topology.IsInstance(graph, "Graph"):
             if not silent:
-                print("Graph.AddEdge - Error: The input graph is not a valid graph. Returning None.")
+                print("Graph.AdjacentVertices - Error: The input graph is not a valid graph. Returning None.")
             return None
-        if not Topology.IsInstance(edge, "Edge"):
+        if not Topology.IsInstance(vertex, "Vertex"):
             if not silent:
-                print("Graph.AddEdge - Error: The input edge is not a valid edge. Returning the input graph.")
-            return graph
-        graph_vertices = Graph.Vertices(graph)
-        graph_edges = Graph.Edges(graph, graph_vertices, tolerance=tolerance)
-        vertices = Topology.Vertices(edge)
-        new_vertices = []
-        for vertex in vertices:
-            graph_vertices, nv = addIfUnique(graph_vertices, vertex, tolerance=tolerance)
-            new_vertices.append(nv)
-        new_edge = Edge.ByVertices([new_vertices[0], new_vertices[1]], tolerance=tolerance)
-        if transferEdgeDictionaries == True:
-            d = Topology.Dictionary(edge)
-            keys = Dictionary.Keys(d)
-            if isinstance(keys, list):
-                if len(keys) > 0:
-                    _ = Topology.SetDictionary(new_edge, d, silent=True)
-        graph_edges.append(new_edge)
-        new_graph = Graph.ByVerticesEdges(graph_vertices, graph_edges)
-        return new_graph
+                print("Graph.AdjacentVertices - Error: The input vertex is not a valid vertex. Returning None.")
+            return None
+        vertices = []
+        _ = graph.AdjacentVertices(vertex, vertices) # Hook to Core
+        return list(vertices)
     
     @staticmethod
-    def AddVertex(graph, vertex, tolerance: float = 0.0001, silent: bool = False):
+    def AdjacentVerticesByCompassDirection(graph, vertex, compassDirection: str = "Up", tolerance: float = 0.0001, silent: bool = False):
         """
-        Adds the input vertex to the input graph.
+        Returns the list of vertices connected to the input vertex that are in the input compass direction.
 
         Parameters
         ----------
         graph : topologic_core.Graph
             The input graph.
         vertex : topologic_core.Vertex
-            The input vertex.
+            the input vertex.
+        compassDirection : str , optional
+            The compass direction. See Vector.CompassDirections(). The default is "Up".
         tolerance : float , optional
-            The desired tolerance. The default is 0.0001.
+                The desired tolerance. The default is 0.0001.
         silent : bool , optional
             If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
 
         Returns
         -------
-        topologic_core.Graph
-            The input graph with the input vertex added to it.
+        list
+            The list of adjacent vertices that are in the compass direction.
 
         """
+        from topologicpy.Vector import Vector
+        from topologicpy.Edge import Edge
         from topologicpy.Topology import Topology
-
-        if not Topology.IsInstance(graph, "Graph"):
+        
+        if not Topology.IsInstance(graph, "graph"):
             if not silent:
-                print("Graph.AddVertex - Error: The input graph is not a valid graph. Returning None.")
+                print("Graph.AdjacentVerticesByCompassDirection - Error: The input graph parameter is not a valid graph. Returning None.")
             return None
-        if not Topology.IsInstance(vertex, "Vertex"):
+        if not Topology.IsInstance(vertex, "vertex"):
             if not silent:
-                print("Graph.AddVertex - Error: The input vertex is not a valid vertex. Returning the input graph.")
-            return graph
-        _ = graph.AddVertices([vertex], tolerance) # Hook to Core
-        return graph
-
-    @staticmethod
-    def AddVertices(graph, vertices, tolerance: float = 0.0001, silent: bool = False):
-        """
-        Adds the input vertex to the input graph.
-
-        Parameters
-        ----------
-        graph : topologic_core.Graph
-            The input graph.
-        vertices : list
-            The input list of vertices.
-        tolerance : float , optional
-            The desired tolerance. The default is 0.0001.
-        silent : bool , optional
-            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
-
-        Returns
-        -------
-        topologic_core.Graph
-            The input graph with the input vertex added to it.
-
-        """
-        from topologicpy.Topology import Topology
-
-        if not Topology.IsInstance(graph, "Graph"):
-            if not silent:
-                print("Graph.AddVertices - Error: The input graph is not a valid graph. Returning None.")
+                print("Graph.AdjacentVerticesByCompassDirection - Error: The input vertex parameter is not a valid vertex. Returning None.")
             return None
-        if not isinstance(vertices, list):
+        if not isinstance(compassDirection, str):
             if not silent:
-                print("Graph.AddVertices - Error: The input list of vertices is not a valid list. Returning None.")
+                print("Graph.AdjacentVerticesByCompassDirection - Error: The input compassDirection parameter is not a valid string. Returning None.")
             return None
-        vertices = [v for v in vertices if Topology.IsInstance(v, "Vertex")]
-        if len(vertices) < 1:
+        
+        directions = [v.lower() for v in Vector.CompassDirections()]
+
+        if not compassDirection.lower() in directions:
             if not silent:
-                print("Graph.AddVertices - Error: Could not find any valid vertices in the input list of vertices. Returning None.")
+                print("Graph.AdjacentVerticesByCompassDirection - Error: The input compassDirection parameter is not a valid compass direction. Returning None.")
             return None
-        _ = graph.AddVertices(vertices, tolerance) # Hook to Core
-        return graph
-    
+
+        adjacent_vertices = Graph.AdjacentVertices(graph, vertex)
+        return_vertices = []
+        for v in adjacent_vertices:
+            e = Edge.ByVertices(vertex, v)
+            vector = Edge.Direction(e)
+            compass_direction = Vector.CompassDirection(vector, tolerance=tolerance)
+            if compass_direction.lower() == compassDirection.lower():
+                return_vertices.append(v)
+        return return_vertices
+
     @staticmethod
-    def AdjacentVertices(graph, vertex, silent: bool = False):
+    def AdjacentVerticesByVector(graph, vertex, vector: list = [0,0,1], tolerance: float = 0.0001, silent: bool = False):
         """
-        Returns the list of vertices connected to the input vertex.
+        Returns the list of vertices connected to the input vertex that are in the input vector direction.
 
         Parameters
         ----------
@@ -685,28 +777,48 @@ class Graph:
             The input graph.
         vertex : topologic_core.Vertex
             the input vertex.
+        vector : list , optional
+            The vector direction. The default is [0,0,1].
+        tolerance : float , optional
+                The desired tolerance. The default is 0.0001.
         silent : bool , optional
             If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
 
         Returns
         -------
         list
-            The list of adjacent vertices.
+            The list of adjacent vertices that are in the vector direction.
 
         """
+        from topologicpy.Vector import Vector
+        from topologicpy.Edge import Edge
         from topologicpy.Topology import Topology
-
-        if not Topology.IsInstance(graph, "Graph"):
+        
+        if not Topology.IsInstance(graph, "graph"):
             if not silent:
-                print("Graph.AdjacentVertices - Error: The input graph is not a valid graph. Returning None.")
+                print("Graph.AdjacentVerticesByVector- Error: The input graph parameter is not a valid graph. Returning None.")
             return None
-        if not Topology.IsInstance(vertex, "Vertex"):
+        if not Topology.IsInstance(vertex, "vertex"):
             if not silent:
-                print("Graph.AdjacentVertices - Error: The input vertex is not a valid vertex. Returning None.")
+                print("Graph.AdjacentVerticesByVector- Error: The input vertex parameter is not a valid vertex. Returning None.")
             return None
-        vertices = []
-        _ = graph.AdjacentVertices(vertex, vertices) # Hook to Core
-        return list(vertices)
+        if not isinstance(vector, list):
+            if not silent:
+                print("Graph.AdjacentVerticesByVector- Error: The input vector parameter is not a valid vector. Returning None.")
+            return None
+        if len(vector) != 3:
+            if not silent:
+                print("Graph.AdjacentVerticesByVector- Error: The input vector parameter is not a valid vector. Returning None.")
+            return None
+
+        adjacent_vertices = Graph.AdjacentVertices(graph, vertex)
+        return_vertices = []
+        for v in adjacent_vertices:
+            e = Edge.ByVertices(vertex, v)
+            edge_vector = Edge.Direction(e)
+            if Vector.CompassDirection(vector, tolerance=tolerance).lower() == Vector.CompassDirection(edge_vector, tolerance=tolerance).lower():
+                return_vertices.append(v)
+        return return_vertices
     
     @staticmethod
     def AllPaths(graph, vertexA, vertexB, timeLimit=10, silent: bool = False):
@@ -8789,7 +8901,7 @@ class Graph:
         return max_flow
 
     @staticmethod
-    def MeshData(g, tolerance: float = 0.0001):
+    def MeshData(graph, tolerance: float = 0.0001):
         """
         Returns the mesh data of the input graph.
 
@@ -8815,14 +8927,14 @@ class Graph:
         from topologicpy.Dictionary import Dictionary
         from topologicpy.Topology import Topology
 
-        g_vertices = Graph.Vertices(g)
+        g_vertices = Graph.Vertices(graph)
         m_vertices = []
         v_dicts = []
         for g_vertex in g_vertices:
             m_vertices.append(Vertex.Coordinates(g_vertex))
             d = Dictionary.PythonDictionary(Topology.Dictionary(g_vertex))
             v_dicts.append(d)
-        g_edges = Graph.Edges(g)
+        g_edges = Graph.Edges(graph)
         m_edges = []
         e_dicts = []
         for g_edge in g_edges:

topologicpy/Vector.py

@@ -359,6 +359,120 @@ class Vector(list):
         ang2 = arctan2(*p2[::-1])
         return round(rad2deg((ang1 - ang2) % (2 * pi)), mantissa)
 
+    @staticmethod
+    def CompassDirection(vector, tolerance: float = 0.0001, silent: bool = False):
+        """
+        Returns the compass direction of the input direction.
+        The possible returned values are:
+        - North, East, South, West
+        - Northeast, Southeast, Southwest, Northwest
+        - A combination of the above (e.g. Up_Noertheast)
+        - Up, Down
+        - Origin
+
+        Parameters
+        ----------
+        vector : list
+            The input vector.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
+        silent : bool , optional
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
+
+        Returns
+        -------
+        str
+            The compass direction of the input vector. The possible values are:
+            - North, East, South, West
+            - Northeast, Southeast, Southwest, Northwest
+            - A combination of the above (e.g. Up_Noertheast)
+            - Up, Down
+            - Origin
+
+        """
+        import math
+
+        if not isinstance(vector, list):
+            if not silent:
+                print("Vector.CompassDirection - Error: The input vector parameter is not a valid vector. Returning None.")
+            return None
+        if len(vector) != 3:
+            if not silent:
+                print("Vector.CompassDirection - Error: The input vector parameter is not a valid vector. Returning None.")
+            return None
+        
+        x, y, z = vector
+        
+        # Handle the origin
+        if abs(x) < tolerance and abs(y) < tolerance and abs(z) < tolerance:
+            return "Origin"
+        
+        # Normalize vector to prevent magnitude bias
+        magnitude = math.sqrt(x**2 + y**2 + z**2)
+        x, y, z = x / magnitude, y / magnitude, z / magnitude
+        
+        # Apply tolerance to components
+        x = 0 if abs(x) < tolerance else x
+        y = 0 if abs(y) < tolerance else y
+        z = 0 if abs(z) < tolerance else z
+        
+        # Compass-based direction in the XY-plane
+        if x == 0 and y > 0:
+            horizontal_dir = "North"
+        elif x == 0 and y < 0:
+            horizontal_dir = "South"
+        elif y == 0 and x > 0:
+            horizontal_dir = "East"
+        elif y == 0 and x < 0:
+            horizontal_dir = "West"
+        elif x > 0 and y > 0:
+            horizontal_dir = "Northeast"
+        elif x < 0 and y > 0:
+            horizontal_dir = "Northwest"
+        elif x < 0 and y < 0:
+            horizontal_dir = "Southwest"
+        elif x > 0 and y < 0:
+            horizontal_dir = "Southeast"
+        else:
+            horizontal_dir = ""
+        
+        # Add vertical direction
+        if z > 0:
+            if horizontal_dir:
+                return f"Up_{horizontal_dir}"
+            return "Up"
+        elif z < 0:
+            if horizontal_dir:
+                return f"Down_{horizontal_dir}"
+            return "Down"
+        else:
+            return horizontal_dir
+    
+    @staticmethod
+    def CompassDirections():
+        """
+        Returns the list of allowed compass directions.
+
+        Parameters
+        ----------
+
+        Returns
+        -------
+        list
+            The list of compass directions. These are:
+            - ["Origin", "Up", "Down",
+              "North", "Northeast", "East", "Southeast", "South", "Southwest", "West", "Northwest",
+              "Up_North", "Up_Northeast", "Up_East", "Up_Southeast", "Up_South", "Up_Southwest", "Up_West", "Up_Northwest",
+               "Down_North", "Down_Northeast", "Down_East", "Down_Southeast", "Down_South", "Down_Southwest", "Down_West", "Down_Northwest",
+              ]
+
+        """
+        return ["Origin", "Up", "Down",
+                "North", "Northeast", "East", "Southeast", "South", "Southwest", "West", "Northwest",
+                "Up_North", "Up_Northeast", "Up_East", "Up_Southeast", "Up_South", "Up_Southwest", "Up_West", "Up_Northwest",
+                "Down_North", "Down_Northeast", "Down_East", "Down_Southeast", "Down_South", "Down_Southwest", "Down_West", "Down_Northwest"
+                ]
+    
     @staticmethod
     def Coordinates(vector, outputType="xyz", mantissa: int = 6, silent: bool = False):
         """

topologicpy/version.py

@@ -1 +1 @@
-__version__ = '0.8.7'
+__version__ = '0.8.8'

{topologicpy-0.8.7.dist-info → topologicpy-0.8.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: topologicpy
-Version: 0.8.7
+Version: 0.8.8
 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.7.dist-info → topologicpy-0.8.8.dist-info}/RECORD

@@ -11,7 +11,7 @@ topologicpy/Dictionary.py,sha256=t0O7Du-iPq46FyKqZfcjHfsUK1E8GS_e67R2V5cpkbw,331
 topologicpy/Edge.py,sha256=lWwJdQkAhiH5POB7TN6HSLv03g2jXHzBU7e2fE3eAno,71340
 topologicpy/EnergyModel.py,sha256=UoQ9Jm-hYsN383CbcLKw-y6BKitRHj0uyh84yQ-8ACg,53856
 topologicpy/Face.py,sha256=D1g4O5i5QMPZvIoX06Z-FsyNsYBDkCiHWJp00uqnr5o,180742
-topologicpy/Graph.py,sha256=rq7QGgb2eTJucFT6YeQujs1zoZg-KHMvHOWPjG1btG4,492418
+topologicpy/Graph.py,sha256=yjD778MyWFLmUEryGFEzFZOJmnrZwkqrVYvpmH76Oxs,497462
 topologicpy/Grid.py,sha256=2s9cSlWldivn1i9EUz4OOokJyANveqmRe_vR93CAndI,18245
 topologicpy/Helper.py,sha256=DAAE_Ie_ekeMnCvcW08xXRwSAGCkjrS4lbz-o3ELuY4,27172
 topologicpy/Honeybee.py,sha256=Y_El6M8x3ixvvIe_VcRiwj_4C89ZZg5_WlT7adbCkpw,21849
@@ -24,13 +24,13 @@ topologicpy/Shell.py,sha256=fLRnQ79vtdBDRW1Xn8Gaap34XheGbw7UBFd-ALJ2Y1g,87978
 topologicpy/Speckle.py,sha256=AlsGlSDuKRtX5jhVsPNSSjjbZis079HbUchDH_5RJmE,18187
 topologicpy/Sun.py,sha256=42tDWMYpwRG7Z2Qjtp94eRgBuqySq7k8TgNUZDK7QxQ,36837
 topologicpy/Topology.py,sha256=qw64d3Ct6u7W8Fy_-JIg3_xsyOzDIQ1hdnpxF2p_wH4,463931
-topologicpy/Vector.py,sha256=Cl7besf20cAGmyNPh-9gbFAHnRU5ZWSMChJ3VyFIDs4,35416
+topologicpy/Vector.py,sha256=3gW0Y7mTcpc6ctjSfRWQXGKjIyHASKrMyIyPDT0kO2E,39573
 topologicpy/Vertex.py,sha256=tv6C-rbuNgXHDGgVLT5fbalynLdXqlUuiCDKtkeQ0vk,77814
 topologicpy/Wire.py,sha256=Gl3Jpygwp8775SG57ua5r5ffTHcN4FOAkeI87yP1cok,234001
 topologicpy/__init__.py,sha256=vlPCanUbxe5NifC4pHcnhSzkmmYcs_UrZrTlVMsxcFs,928
-topologicpy/version.py,sha256=JGCf_Ym2Ht0sZ3u8dNB1-xTLbDj-N0D-i99vGQQMfWs,22
-topologicpy-0.8.7.dist-info/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
-topologicpy-0.8.7.dist-info/METADATA,sha256=uDBR73QF2TnGhpaMNI-vIBGeZTF-c7IMM5DI7AxwzEI,10512
-topologicpy-0.8.7.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-topologicpy-0.8.7.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
-topologicpy-0.8.7.dist-info/RECORD,,
+topologicpy/version.py,sha256=ysM7ZSdOuCpaNFiqoGIRai1zq8iwLDlTTCvJsGJ1_eA,22
+topologicpy-0.8.8.dist-info/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
+topologicpy-0.8.8.dist-info/METADATA,sha256=h8t8ZxpBukHW7YQu9muct8f09ZIkb_tZFhP_IPWtc4c,10512
+topologicpy-0.8.8.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+topologicpy-0.8.8.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
+topologicpy-0.8.8.dist-info/RECORD,,