topologicpy 0.7.91__py3-none-any.whl → 0.7.92__py3-none-any.whl

topologicpy/Graph.py

@@ -264,7 +264,7 @@ class _DrawTree(object):
         return self.__str__()
 
 class Graph:
-    def AdjacencyDictionary(graph, vertexLabelKey: str = "label", edgeKey: str = "Length", includeWeights: bool = False, reverse: bool = False, mantissa: int = 6):
+    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.
 
@@ -274,7 +274,7 @@ class Graph:
             The input graph.
         vertexLabelKey : str , optional
             The returned vertices are labelled according to the dictionary values stored under this key.
-            If the vertexLabelKey does not exist, it will be created and the vertices are labelled numerically and stored in the vertex dictionary under this key. The default is "label".
+            If the vertexLabelKey does not exist, it will be created and the vertices are labelled numerically and stored in the vertex dictionary under this key. The default is None.
         edgeKey : str , optional
             If set, the edges' dictionaries will be searched for this key to set their weight. If the key is set to "length" (case insensitive), the length of the edge will be used as its weight. If set to None, a weight of 1 will be used. The default is "Length".
         includeWeights : bool , optional
@@ -298,6 +298,8 @@ class Graph:
         if not Topology.IsInstance(graph, "Graph"):
             print("Graph.AdjacencyDictionary - Error: The input graph is not a valid graph. Returning None.")
             return None
+        if vertexLabelKey == None:
+            vertexLabelKey = "__label__"
         if not isinstance(vertexLabelKey, str):
             print("Graph.AdjacencyDictionary - Error: The input vertexLabelKey is not a valid string. Returning None.")
             return None
@@ -353,6 +355,12 @@ class Graph:
                         temp_list.append(adjLabel)
             temp_list.sort()
             adjDict[vertex_label] = temp_list
+        if vertexLabelKey == "__label__": # This is label we added, so remove it
+            vertices = Graph.Vertices(graph)
+            for v in vertices:
+                d = Topology.Dictionary(v)
+                d = Dictionary.RemoveKey(d, vertexLabelKey)
+                v = Topology.SetDictionary(v, d)
         return adjDict
     
     @staticmethod
@@ -1328,16 +1336,16 @@ class Graph:
         return bot_graph.serialize(format=format)
 
     @staticmethod
-    def BetweenessCentrality(graph, key: str = "betweeness_centrality", mantissa: int = 6, tolerance: float = 0.001, silent: bool = False):
+    def BetweennessCentrality(graph, key: str = "betweenness_centrality", mantissa: int = 6, tolerance: float = 0.001, silent: bool = False):
         """
-            Returns the betweeness centrality measure of the input list of vertices within the input graph. The order of the returned list is the same as the order of the input list of vertices. If no vertices are specified, the betweeness centrality of all the vertices in the input graph is computed. See https://en.wikipedia.org/wiki/Betweenness_centrality.
+            Returns the betweenness centrality measure of the input list of vertices within the input graph. The order of the returned list is the same as the order of the input list of vertices. If no vertices are specified, the betweeness centrality of all the vertices in the input graph is computed. See https://en.wikipedia.org/wiki/Betweenness_centrality.
 
         Parameters
         ----------
         graph : topologic_core.Graph
             The input graph.
         key : str , optional
-            The dictionary key under which to save the betweeness centrality score. The default is "betweneess_centrality".
+            The dictionary key under which to save the betweeness centrality score. The default is "betweenness_centrality".
         mantissa : int , optional
             The desired length of the mantissa. The default is 6.
         tolerance : float , optional
@@ -1346,70 +1354,38 @@ class Graph:
         Returns
         -------
         list
-            The betweeness centrality of the input list of vertices within the input graph. The values are in the range 0 to 1.
+            The betweenness centrality of the input list of vertices within the input graph. The values are in the range 0 to 1.
 
         """
-        def vertex_betweenness_centrality(graph, vertices):
-            """
-            Compute the betweenness centrality for vertices in the given TopologicPy graph.
-
-            Args:
-                graph: The TopologicPy Graph object.
-
-            Returns:
-                dict: A dictionary mapping each vertex to its betweenness centrality value.
-            """
-            from collections import defaultdict
-            n = len(vertices)
-            idList = []
-            vertex_map = {}
-            for i, v in enumerate(vertices):
-                d = Topology.Dictionary(v)
-                d = Dictionary.SetValueAtKey(d, "__id_", str(i))
-                v = Topology.SetDictionary(v, d)
-                idList.append(str(i))
-                vertex_map[str(i)] = v
-            if n < 2:
-                return {v: 0.0 for v in idList}
-            centrality = defaultdict(float)
-
-            for source in idList:
-                stack, paths, sigma = [], {}, {v: 0.0 for v in idList}
-                sigma[source] = 1.0
-                paths[source] = []
-
-                queue = [source]
-                while queue:
-                    v = queue.pop(0)
-                    stack.append(v)
-                    vertex = vertex_map[v]
-                    for neighbor in Graph.AdjacentVertices(graph, vertex):
-                        d = Topology.Dictionary(neighbor)
-                        neighbor_id = Dictionary.ValueAtKey(d, "__id_")
-                        if neighbor_id not in paths:
-                            queue.append(neighbor_id)
-                            paths[neighbor_id] = [v]
-                        elif v not in paths[neighbor_id]:
-                            paths[neighbor_id].append(v)
-                        sigma[neighbor_id] += sigma[v]
-
-                delta = {v: 0.0 for v in idList}
-                while stack:
-                    w = stack.pop()
-                    for v in paths.get(w, []):
-                        delta[v] += (sigma[v] / sigma[w]) * (1 + delta[w])
-                    if w != source:
-                        centrality[w] += delta[w]
-            # Normalize centrality values
-            max_centrality = max([centrality[v] for v in idList])
-            min_centrality = min([centrality[v] for v in idList])
-            centrality = [round((centrality[v]-min_centrality)/max_centrality, mantissa) for v in idList]
-            for i, v in enumerate(vertices):
-                d = Topology.Dictionary(v)
-                d = Dictionary.SetValueAtKey(d, "betweeness_centrality", centrality[i])
-                d = Dictionary.RemoveKey(d, "__id_")
-                v = Topology.SetDictionary(v, d)
-            return centrality
+        def bfs_paths(source):
+            queue = [(source, [source])]
+            while queue:
+                (vertex, path) = queue.pop(0)
+                for next in set(py_graph[vertex]) - set(path):
+                    queue.append((next, path + [next]))
+                    yield path + [next]
+
+        def shortest_paths_count(source):
+            paths = list(bfs_paths(source))
+            shortest_paths = {v: [] for v in py_graph}
+            for path in paths:
+                shortest_paths[path[-1]].append(path)
+            return shortest_paths
+
+        def calculate_betweenness():
+            betweenness = {v: 0.0 for v in py_graph}
+            for s in py_graph:
+                shortest_paths = shortest_paths_count(s)
+                dependency = {v: 0.0 for v in py_graph}
+                for t in py_graph:
+                    if t != s:
+                        for path in shortest_paths[t]:
+                            for v in path[1:-1]:
+                                dependency[v] += 1.0 / len(shortest_paths[t])
+                for v in py_graph:
+                    if v != s:
+                        betweenness[v] += dependency[v]
+            return betweenness
         
         from topologicpy.Topology import Topology
         from topologicpy.Dictionary import Dictionary
@@ -1431,115 +1407,26 @@ class Graph:
             vertices[0] = Topology.SetDictionary(vertices[0], d)
             return [1.0]
         
-        return vertex_betweenness_centrality(graph, vertices)
-
-    @staticmethod
-    def BetweenessCentrality_old(graph, vertices=None, sources=None, destinations=None, key: str = "betweeness_centrality", mantissa: int = 6, tolerance: float = 0.001):
-        """
-            Returns the betweeness centrality measure of the input list of vertices within the input graph. The order of the returned list is the same as the order of the input list of vertices. If no vertices are specified, the betweeness centrality of all the vertices in the input graph is computed. See https://en.wikipedia.org/wiki/Betweenness_centrality.
+        py_graph = Graph.AdjacencyDictionary(g)
+        betweenness = calculate_betweenness()
+        for v in betweenness:
+            betweenness[v] /= 2.0  # Each shortest path is counted twice
 
-        Parameters
-        ----------
-        graph : topologic_core.Graph
-            The input graph.
-        vertices : list , optional
-            The input list of vertices. The default is None which means all vertices in the input graph are considered.
-        sources : list , optional
-            The input list of source vertices. The default is None which means all vertices in the input graph are considered.
-        destinations : list , optional
-            The input list of destination vertices. The default is None which means all vertices in the input graph are considered.
-        key : str , optional
-            The dictionary key under which to save the betweeness centrality score. The default is "betweneess_centrality".
-        mantissa : int , optional
-            The desired length of the mantissa. The default is 6.
-        tolerance : float , optional
-            The desired tolerance. The default is 0.0001.
-
-        Returns
-        -------
-        list
-            The betweeness centrality of the input list of vertices within the input graph. The values are in the range 0 to 1.
-
-        """
-        from topologicpy.Vertex import Vertex
-        from topologicpy.Topology import Topology
-        from topologicpy.Dictionary import Dictionary
-
-        def betweeness(vertices, topologies, tolerance=0.001):
-            returnList = [0] * len(vertices)
-            for topology in topologies:
-                t_vertices = Topology.Vertices(topology)
-                for t_v in t_vertices:
-                    index = Vertex.Index(t_v, vertices, strict=False, tolerance=tolerance)
-                    if not index == None:
-                        returnList[index] = returnList[index]+1
-            return returnList
-
-        if not Topology.IsInstance(graph, "Graph"):
-            print("Graph.BetweenessCentrality - Error: The input graph is not a valid graph. Returning None.")
-            return None
-        graphVertices = Graph.Vertices(graph)
+        max_betweenness = max(betweenness.values())
+        if max_betweenness > 0:
+            for v in betweenness:
+                betweenness[v] /= max_betweenness  # Normalize to [0, 1]
         
-        if not isinstance(vertices, list):
-            vertices = graphVertices
-        else:
-            vertices = [v for v in vertices if Topology.IsInstance(v, "Vertex")]
-        if len(vertices) < 1:
-            print("Graph.BetweenessCentrality - Error: The input list of vertices does not contain valid vertices. Returning None.")
-            return None
-        if not isinstance(sources, list):
-            sources = graphVertices
-        else:
-            sources = [v for v in sources if Topology.IsInstance(v, "Vertex")]
-        if len(sources) < 1:
-            print("Graph.BetweenessCentrality - Error: The input list of sources does not contain valid vertices. Returning None.")
-            return None
-        if not isinstance(destinations, list):
-            destinations = graphVertices
-        else:
-            destinations = [v for v in destinations if Topology.IsInstance(v, "Vertex")]
-        if len(destinations) < 1:
-            print("Graph.BetweenessCentrality - Error: The input list of destinations does not contain valid vertices. Returning None.")
-            return None
-        graphEdges = Graph.Edges(graph)
-        if len(graphEdges) == 0:
-            print("Graph.BetweenessCentrality - Warning: The input graph is a null graph.")
-            scores = [0 for t in vertices]
-            for i, v in enumerate(vertices):
-                d = Topology.Dictionary(v)
-                d = Dictionary.SetValueAtKey(d, key, scores[i])
-                v = Topology.SetDictionary(v, d)
-            return scores
-        paths = []
-        try:
-            for so in tqdm(sources, desc="Computing Shortest Paths", leave=False):
-                v1 = Graph.NearestVertex(graph, so)
-                for si in destinations:
-                    v2 = Graph.NearestVertex(graph, si)
-                    if not v1 == v2:
-                        path = Graph.ShortestPath(graph, v1, v2)
-                        if path:
-                            paths.append(path)
-        except:
-            for so in sources:
-                v1 = Graph.NearestVertex(graph, so)
-                for si in destinations:
-                    v2 = Graph.NearestVertex(graph, si)
-                    if not v1 == v2:
-                        path = Graph.ShortestPath(graph, v1, v2)
-                        if path:
-                            paths.append(path)
-
-        scores = betweeness(vertices, paths, tolerance=tolerance)
-        minValue = min(scores)
-        maxValue = max(scores)
-        size = maxValue - minValue
-        scores = [round((v-minValue)/size, mantissa) for v in scores]
-        for i, v in enumerate(vertices):
-            d = Topology.Dictionary(v)
-            d = Dictionary.SetValueAtKey(d, key, scores[i])
-            v = Topology.SetDictionary(v, d)
-        return scores
+        
+        return_betweenness = [0]*len(vertices)
+        for i, v in betweenness.items():
+            vertex = vertices[int(i)]
+            d = Topology.Dictionary(vertex)
+            d = Dictionary.SetValueAtKey(d, key, round(v, mantissa))
+            vertex = Topology.SetDictionary(vertex, d)
+            return_betweenness[int(i)] = v
+        
+        return return_betweenness
     
     @staticmethod
     def ByAdjacencyMatrixCSVPath(path: str, dictionaries: list = None, silent: bool = False):
@@ -1571,17 +1458,21 @@ class Graph:
         return Graph.ByAdjacencyMatrix(adjacencyMatrix=adjacency_matrix, dictionaries=dictionaries, silent=silent)
 
     @staticmethod
-    def ByAdjacencyMatrix(adjacencyMatrix, dictionaries = None, xMin=-0.5, yMin=-0.5, zMin=-0.5, xMax=0.5, yMax=0.5, zMax=0.5, silent=False):
+    def ByAdjacencyMatrix(adjacencyMatrix, dictionaries = None, edgeKeyFwd="weightFwd", edgeKeyBwd="weightBwd", xMin=-0.5, yMin=-0.5, zMin=-0.5, xMax=0.5, yMax=0.5, zMax=0.5, silent=False):
         """
         Returns graphs according to the input folder path. This method assumes the CSV files follow DGL's schema.
 
         Parameters
         ----------
         adjacencyMatrix : list
-            The adjacency matrix expressed as a nested list of 0s and 1s.
+            The adjacency matrix expressed as a nested list of 0s and a number not 0 which represents the edge weight.
         dictionaries : list , optional
             A list of dictionaries to assign to the vertices of the graph. This list should be in
             the same order and of the same length as the rows in the adjacency matrix.
+        edgeKeyFwd : str , optional
+            The dictionary key under which to store the edge weight value for forward edge. The default is "weight".
+        edgeKeyBwd : str , optional
+            The dictionary key under which to store the edge weight value for backward edge. The default is "weight".
         xMin : float , optional
             The desired minimum value to assign for a vertex's X coordinate. The default is -0.5.
         yMin : float , optional
@@ -1606,6 +1497,7 @@ class Graph:
         from topologicpy.Vertex import Vertex
         from topologicpy.Edge import Edge
         from topologicpy.Topology import Topology
+        from topologicpy.Dictionary import Dictionary
         import  random
 
         if not isinstance(adjacencyMatrix, list):
@@ -1632,11 +1524,17 @@ class Graph:
         
         # Add edges based on the adjacency matrix
         edges = []
+        visited = []
         for i in range(len(adjacencyMatrix)):
             for j in range(len(adjacencyMatrix)):
                 if not i == j:
-                    if not adjacencyMatrix[i][j] == 0:
-                        edges.append(Edge.ByVertices([vertices[i], vertices[j]]))
+                    if (adjacencyMatrix[i][j] != 0 or adjacencyMatrix[j][i] != 0) and not (i,j) in visited:
+                        edge = Edge.ByVertices([vertices[i], vertices[j]]) # Create only one edge
+                        d = Dictionary.ByKeysValues([edgeKeyFwd, edgeKeyBwd], [adjacencyMatrix[i][j], adjacencyMatrix[j][i]])
+                        edge = Topology.SetDictionary(edge, d)
+                        edges.append(edge)
+                        visited.append((i,j))
+                        visited.append((j,i))
         
         return Graph.ByVerticesEdges(vertices, edges)
 

topologicpy/Vector.py

@@ -312,7 +312,7 @@ class Vector(list):
         return vector
 
     @staticmethod
-    def CompassAngle(vectorA, vectorB, mantissa=6, tolerance=0.0001):
+    def CompassAngle(vectorA, vectorB, mantissa: int = 6, tolerance: float = 0.0001, silent: bool = False):
         """
         Returns the horizontal compass angle in degrees between the two input vectors. The angle is measured in clockwise fashion.
         0 is along the positive Y-axis, 90 is along the positive X axis.
@@ -328,6 +328,8 @@ class Vector(list):
             The length of the desired mantissa. The default is 6.
         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
         -------
@@ -335,9 +337,21 @@ class Vector(list):
             The horizontal compass angle in degrees between the two input vectors.
 
         """
+        if not isinstance(vectorA, list):
+            if not silent:
+                print("Vector.Coordinates - Error: The input vectorA parameter is not a valid vector. Returning Nonne.")
+            return None
+        if not isinstance(vectorB, list):
+            if not silent:
+                print("Vector.Coordinates - Error: The input vectorB parameter is not a valid vector. Returning Nonne.")
+            return None
         if abs(vectorA[0]) < tolerance and abs(vectorA[1]) < tolerance:
+            if not silent:
+                print("Vector.CompassAngle - Error: The input vectorA parameter is vertical in the Z Axis. Returning Nonne.")
             return None
         if abs(vectorB[0]) < tolerance and abs(vectorB[1]) < tolerance:
+            if not silent:
+                print("Vector.CompassAngle - Error: The input vectorB parameter is vertical in the Z Axis. Returning Nonne.")
             return None
         p1 = (vectorA[0], vectorA[1])
         p2 = (vectorB[0], vectorB[1])
@@ -346,7 +360,7 @@ class Vector(list):
         return round(rad2deg((ang1 - ang2) % (2 * pi)), mantissa)
 
     @staticmethod
-    def Coordinates(vector, outputType="xyz", mantissa: int = 6):
+    def Coordinates(vector, outputType="xyz", mantissa: int = 6, silent: bool = False):
         """
         Returns the coordinates of the input vector.
 
@@ -358,6 +372,8 @@ class Vector(list):
             The desired output type. Could be any permutation or substring of "xyz" or the string "matrix". The default is "xyz". The input is case insensitive and the coordinates will be returned in the specified order.
         mantissa : int , optional
             The desired length of the mantissa. The default is 6.
+        silent : bool , optional
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
 
         Returns
         -------
@@ -366,6 +382,8 @@ class Vector(list):
 
         """
         if not isinstance(vector, list):
+            if not silent:
+                print("Vector.Coordinates - Error: The input vector parameter is not a valid vector. Returning None.")
             return None
         x = round(vector[0], mantissa)
         y = round(vector[1], mantissa)
@@ -390,7 +408,7 @@ class Vector(list):
         return output
     
     @staticmethod
-    def Cross(vectorA, vectorB, mantissa=6, tolerance=0.0001):
+    def Cross(vectorA, vectorB, mantissa: int = 6, tolerance: float = 0.0001, silent: bool = False):
         """
         Returns the cross product of the two input vectors. The resulting vector is perpendicular to the plane defined by the two input vectors.
 
@@ -404,6 +422,8 @@ class Vector(list):
             The length of the desired mantissa. The default is 6.
         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
         -------
@@ -411,9 +431,21 @@ class Vector(list):
             The vector representing the cross product of the two input vectors.
 
         """
-        if not isinstance(vectorA, list) or not isinstance(vectorB, list):
+        if not isinstance(vectorA, list):
+            if not silent:
+                print("Vector.Cross - Error: The input vectorA parameter is not a valid vector. Returning None.")
+            return None
+        if not isinstance(vectorB, list):
+            if not silent:
+                print("Vector.Cross - Error: The input vectorB parameter is not a valid vector. Returning None.")
             return None
-        if Vector.Magnitude(vector=vectorA, mantissa=mantissa) < tolerance or Vector.Magnitude(vector=vectorB, mantissa=mantissa) < tolerance:
+        if Vector.Magnitude(vector=vectorA, mantissa=mantissa) < tolerance:
+            if not silent:
+                print("Vector.Cross - Error: The magnitude of the input vectorA parameter is less than the input tolerance parameter. Returning None.")
+            return None
+        if Vector.Magnitude(vector=vectorB, mantissa=mantissa) < tolerance:
+            if not silent:
+                print("Vector.Cross - Error: The magnitude of the input vectorB parameter is less than the input tolerance parameter. Returning None.")
             return None
         vecA = np.array(vectorA)
         vecB = np.array(vectorB)
@@ -423,7 +455,7 @@ class Vector(list):
         return [round(vecC[0], mantissa), round(vecC[1], mantissa), round(vecC[2], mantissa)]
 
     @staticmethod
-    def Dot(vectorA, vectorB, mantissa=6):
+    def Dot(vectorA, vectorB, mantissa: int = 6, tolerance: float = 0.0001, silent: bool = False):
         """
         Returns the dot product of the two input vectors which is a measure of how much they are aligned.
 
@@ -435,6 +467,10 @@ class Vector(list):
             The second vector.
         mantissa : int, optional
             The length of the desired mantissa. The default is 6.
+        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
         -------
@@ -442,6 +478,22 @@ class Vector(list):
             The vector representing the cross product of the two input vectors.
 
         """
+        if not isinstance(vectorA, list):
+            if not silent:
+                print("Vector.Dot - Error: The input vectorA parameter is not a valid vector. Returning None.")
+            return None
+        if not isinstance(vectorB, list):
+            if not silent:
+                print("Vector.Dot - Error: The input vectorB parameter is not a valid vector. Returning None.")
+            return None
+        if Vector.Magnitude(vector=vectorA, mantissa=mantissa) < tolerance:
+            if not silent:
+                print("Vector.Dot - Error: The magnitude of the input vectorA parameter is less than the input tolerance parameter. Returning None.")
+            return None
+        if Vector.Magnitude(vector=vectorB, mantissa=mantissa) < tolerance:
+            if not silent:
+                print("Vector.Dot - Error: The magnitude of the input vectorB parameter is less than the input tolerance parameter. Returning None.")
+            return None
         return round(sum(a*b for a, b in zip(vectorA, vectorB)), mantissa)
     
     @staticmethod
@@ -506,42 +558,6 @@ class Vector(list):
             # Compute bisecting vector
             return False
     
-    @staticmethod
-    def IsParallel(vectorA, vectorB):
-        """
-        Returns True if the input vectors are parallel. Returns False otherwise.
-        
-        Parameters
-        ----------
-        vectorA : list
-            The first input vector.
-        vectorB : list
-            The second input vector.
-            
-        Returns
-        -------
-        bool
-            True if the input vectors are parallel. False otherwise.
-        
-        """
-        import numpy as np
-
-        # Ensure vectors are numpy arrays
-        vector1 = np.array(vectorA)
-        vector2 = np.array(vectorB)
-        
-        # Normalize input vectors
-        vector1_norm = vector1 / np.linalg.norm(vector1)
-        vector2_norm = vector2 / np.linalg.norm(vector2)
-        
-        # Check if the angle between vectors is either 0 or 180 degrees
-        dot_product = np.dot(vector1_norm, vector2_norm)
-        if np.isclose(dot_product, 1.0):
-            return True
-        else:
-            # Compute bisecting vector
-            return False
-    
     @staticmethod
     def IsCollinear(vectorA, vectorB):
         """

topologicpy/version.py

@@ -1 +1 @@
-__version__ = '0.7.91'
+__version__ = '0.7.92'

{topologicpy-0.7.91.dist-info → topologicpy-0.7.92.dist-info}/METADATA

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

@@ -11,7 +11,7 @@ topologicpy/Dictionary.py,sha256=t0O7Du-iPq46FyKqZfcjHfsUK1E8GS_e67R2V5cpkbw,331
 topologicpy/Edge.py,sha256=KWOJCkLDwCWyZJ5MKwDhT5umWwCYBHtLOz6ulHrSOfY,67205
 topologicpy/EnergyModel.py,sha256=AqTtmXE35SxvRXhG3vYAQd7GQDW-6HtjYPHua6ME4Eg,53762
 topologicpy/Face.py,sha256=2k1vSRK1M-s588RcqGHEalwIHJ9nT3qgx3pU4ktN0dU,150077
-topologicpy/Graph.py,sha256=Qm0V17oeIlhr62faoYqJpNUMzAB5d0F-3zes4jCtRi8,460350
+topologicpy/Graph.py,sha256=LJek7dV9bq9uBf_2akAYrETjbSFfoPgLaMsHs4brvc4,455475
 topologicpy/Grid.py,sha256=2s9cSlWldivn1i9EUz4OOokJyANveqmRe_vR93CAndI,18245
 topologicpy/Helper.py,sha256=F3h4_qcOD_PHAoVe0tEbEE7_jYyVcaHjtwVs4QHOZuI,23978
 topologicpy/Honeybee.py,sha256=HfTaEV1R8K1xOVQQy9sBOhBTF_ap8A2RxZOYhirp_Mw,21835
@@ -24,13 +24,13 @@ topologicpy/Shell.py,sha256=UdDz3zfIYmGRjoZIseviJ2cXNtR5Kx5tIsZLhWMyO_U,87906
 topologicpy/Speckle.py,sha256=AlsGlSDuKRtX5jhVsPNSSjjbZis079HbUchDH_5RJmE,18187
 topologicpy/Sun.py,sha256=42tDWMYpwRG7Z2Qjtp94eRgBuqySq7k8TgNUZDK7QxQ,36837
 topologicpy/Topology.py,sha256=d99wryPPXvw7eRw12GVKV-DT6jhlmVq6GsMAjg-E-40,441693
-topologicpy/Vector.py,sha256=A1g83zDHep58iVPY8WQ8iHNrSOfGWFEzvVeDuMnjDNY,33078
+topologicpy/Vector.py,sha256=Cl7besf20cAGmyNPh-9gbFAHnRU5ZWSMChJ3VyFIDs4,35416
 topologicpy/Vertex.py,sha256=sYWTbAHqKGRUAJRCIUqrCO_xFhvsXK09Sx7E4dafPLQ,73754
 topologicpy/Wire.py,sha256=HjagWKoJb8Z3zhgOij_4k6ZnKIl5gk8LletHbsT1ZKU,190632
 topologicpy/__init__.py,sha256=vlPCanUbxe5NifC4pHcnhSzkmmYcs_UrZrTlVMsxcFs,928
-topologicpy/version.py,sha256=em3O4PG8JKL9957EgCcS5zUXOhgyMhAa6bmjZHQ7UmE,23
-topologicpy-0.7.91.dist-info/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
-topologicpy-0.7.91.dist-info/METADATA,sha256=m96FnumZC4Hy2QqaPuRryOZron2mQdjkGJvv5HJs3kM,10513
-topologicpy-0.7.91.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-topologicpy-0.7.91.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
-topologicpy-0.7.91.dist-info/RECORD,,
+topologicpy/version.py,sha256=hEe71TmHDfYxdkk064adNlI0kHL1_wHg4VoGMKoeSWM,23
+topologicpy-0.7.92.dist-info/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
+topologicpy-0.7.92.dist-info/METADATA,sha256=t-giZYVXIF8phaA32BSO55_r4qGngtkKS_MMHUjD-aA,10513
+topologicpy-0.7.92.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+topologicpy-0.7.92.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
+topologicpy-0.7.92.dist-info/RECORD,,