topologicpy 0.8.20__py3-none-any.whl → 0.8.22__py3-none-any.whl

topologicpy/Dictionary.py

@@ -773,7 +773,7 @@ class Dictionary():
             return None
     
     @staticmethod
-    def ValueAtKey(dictionary, key, silent=False):
+    def ValueAtKey(dictionary, key, defaultValue=None, silent=False):
         """
         Returns the value of the input key in the input dictionary.
 
@@ -783,6 +783,8 @@ class Dictionary():
             The input dictionary.
         key : string
             The input key.
+        defaultValue : any , optional
+            The default value to return if the key or value are not found. The default is None.
         silent : bool , optional
             If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
 
@@ -804,10 +806,10 @@ class Dictionary():
             return None
         if Topology.IsInstance(dictionary, "Dictionary"):
             dic = Dictionary.PythonDictionary(dictionary)
-            return dic.get(key, None)
+            return dic.get(key, defaultValue)
         elif isinstance(dictionary, dict):
-            return dictionary.get(key, None)
-        return None
+            return dictionary.get(key, defaultValue)
+        return defaultValue
         
         # if isinstance(dictionary, dict):
         #     attr = dictionary[key]

topologicpy/Graph.py

@@ -4379,17 +4379,26 @@ class Graph:
     
     @staticmethod
     def Compare(graphA, graphB,
-                weightAttributes: float = 1.0,
-                weightGeometry: float = 1.0,
-                weightMetrics: float = 1.0,
-                weightStructure: float = 1.0,
-                weightWL: float = 1.0,
+                weightAttributes: float = 0.0,
+                weightGeometry: float = 0.0,
+                weightBetwennessCentrality: float = 0.0,
+                weightClosenessCentrality: float = 0.0,
+                weightDegreeCentrality: float = 0.0,
+                weightDiameter: float = 0.0,
+                weightGlobalClusteringCoefficient: float = 0.0,
+                weightPageRank: float = 0.0,
+                weightStructure: float = 0.0,
+                weightWeisfeilerLehman: float = 0.0,
+                weightJaccard: float = 0.0,
+                vertexIDKey: str = "id",
+                edgeWeightKey: str = None,
                 iterations: int = 3,
                 mantissa: int = 6,
                 silent: bool = False):
         """
-        Compares two graphs and returns a similarity score based on attributres, geometry, metrics, structure, and
+        Compares two graphs and returns a similarity score based on attributres, geometry, metrics, structure, 
         the Weisfeiler-Lehman graph kernel. See https://en.wikipedia.org/wiki/Weisfeiler_Leman_graph_isomorphism_test
+        , and the weight Jaccard Similarity. See https://www.statology.org/jaccard-similarity/
 
         Parameters
         ----------
@@ -4398,16 +4407,34 @@ class Graph:
         graphB : topologic Graph
             The second input graph.
         weightAttributes : float , optional
-            The desired weight for attribute similarity (dictionary key overlap at vertices). Default is 1.0.
+            The desired weight for attribute similarity (dictionary key overlap at vertices). Default is 0.0.
+        weightBetwennessCentrality : float , optional
+            The desired weight for betweenness centrality similarity (graph-level and node-level). Default is 0.0.
+        weightClosenessCentrality : float , optional
+            The desired weight for closeness centrality similarity (graph-level and node-level). Default is 0.0.
+        weightDegreeCentrality : float , optional
+            The desired weight for degree centrality similarity (graph-level and node-level). Default is 0.0.
+        weightDiameter : float , optional
+            The desired weight for diameter similarity (graph-level and node-level). Default is 0.0.
         weightGeometry : float , optional
-            The desired weight for geometric similarity (vertex positions). Default is 1.0.
-        weightMetrics : float , optional
-            The desired weight for metric similarity (graph-level and node-level). Default is 1.0.
-            The compared metrics are: betweenness centrality, closeness centrality, clustering coefficient, degree, diameter, and pagerank.
+            The desired weight for geometric similarity (vertex positions). Default is 0.0.
+        weightGlobalClusteringCoefficient : float , optional
+            The desired weight for global clustering coefficient similarity (graph-level and node-level). Default is 0.0.
+        weightJaccard: float , optional
+            The desired weight for the Weighted Jaccard similarity. Default is 0.0.
+        weightPageRank : float , optional
+            The desired weight for PageRank similarity (graph-level and node-level). Default is 0.0.
         weightStructure : float , optional
-            The desired weight for structural similarity (number of vertices and edges). Default is 1.0.
-        weightWL : float , optional
-            The desired weight for Weisfeiler-Lehman kernel similarity (iterative label propagation). Default is 1.0.
+            The desired weight for structural similarity (number of vertices and edges). Default is 0.0.
+        weightWeisfeilerLehman : float , optional
+            The desired weight for Weisfeiler-Lehman kernel similarity (iterative label propagation). Default is 0.0.
+        
+        vertexIDKey: str , optional
+            The dictionary key under which to find the unique vertex ID. The default is "id".
+        edgeWeightKey: str , optional
+            The dictionary key under which to find the weight of the edge for weighted graphs.
+            If this parameter is specified as "length" or "distance" then the length of the edge is used as its weight.
+            The default is None which means all edges are treated as if they have a weight of 1.
         iterations : int , optional
             The desired number of Weisfeiler-Lehman iterations. Default is 3.
         mantissa : int , optional
@@ -4421,12 +4448,16 @@ class Graph:
             A dictionary of similarity scores between 0 (completely dissimilar) and 1 (identical), based on weighted components.
             The keys in the dictionary are:
             "attribute"
+            "betwenness_centrality"
+            "closeness_centrality"
+            "degree_centrality"
             "geometry"
-            "metrics"
+            "global_clustering_coefficient"
+            "jaccard"
+            "pagerank"
             "structure"
-            "wl"
+            "weisfeiler_lehman"
             "overall"
-
         """
         
         import hashlib
@@ -4473,40 +4504,122 @@ class Graph:
             avg_dist = total_dist / len(v1)
             return round(1 / (1 + avg_dist), mantissa) # Inverse average distance
         
-        def metrics_similarity(graphA, graphB, mantissa=6):
-            # Example using global metrics + mean of node metrics
-            def safe_mean(lst):
-                return sum(lst)/len(lst) if lst else 0
+        def weighted_jaccard_similarity(graph1, graph2, vertexIDKey="id", edgeWeightKey=None, mantissa=6):
+            """
+            Computes weighted Jaccard similarity between two graphs by comparing their edge weights.
+
+            Parameters
+            ----------
+            graph1 : topologic Graph
+                First graph.
+            graph2 : topologic Graph
+                Second graph.
+            vertexIDKey: str , optional
+                The dictionary key under which to find the unique vertex ID. The default is "id".
+            edgeWeightKey: str , optional
+                The dictionary key under which to find the weight of the edge for weighted graphs.
+                If this parameter is specified as "length" or "distance" then the length of the edge is used as its weight.
+                The default is None which means all edges are treated as if they have a weight of 1.
+            iterations : int , optional
+                The desired number of Weisfeiler-Lehman iterations. Default is 3.
+            mantissa : int , optional
+                The desired length of the mantissa. The default is 6.
+
+            Returns
+            -------
+            float
+                Similarity score between 0 and 1.
+            """
+            from topologicpy.Vertex import Vertex
+            from topologicpy.Graph import Graph
+            from topologicpy.Topology import Topology
+            from topologicpy.Dictionary import Dictionary
+            from topologicpy.Edge import Edge
 
-            metrics1 = {
-                "closeness": safe_mean(Graph.ClosenessCentrality(graphA)),
-                "betweenness": safe_mean(Graph.BetweennessCentrality(graphA)),
-                "degree": safe_mean(Graph.DegreeCentrality(graphA)),
-                "pagerank": safe_mean(Graph.PageRank(graphA)),
-                "clustering": Graph.GlobalClusteringCoefficient(graphA),
-                "diameter": Graph.Diameter(graphA)
-            }
-
-            metrics2 = {
-                "closeness": safe_mean(Graph.ClosenessCentrality(graphB)),
-                "betweenness": safe_mean(Graph.BetweennessCentrality(graphB)),
-                "degree": safe_mean(Graph.DegreeCentrality(graphB)),
-                "pagerank": safe_mean(Graph.PageRank(graphB)),
-                "clustering": Graph.GlobalClusteringCoefficient(graphB),
-                "diameter": Graph.Diameter(graphB)
-            }
-
-            # Compute similarity as 1 - normalized absolute difference
-            similarities = []
-            for key in metrics1:
-                v1, v2 = metrics1[key], metrics2[key]
-                if v1 == 0 and v2 == 0:
-                    similarities.append(1)
-                else:
-                    diff = abs(v1 - v2) / max(abs(v1), abs(v2), 1e-6)
-                    similarities.append(1 - diff)
 
-            return round(sum(similarities) / len(similarities), mantissa)
+            def edge_id(edge, vertexIDKey="id", mantissa=6):
+                v1 = Edge.StartVertex(edge)
+                v2 = Edge.EndVertex(edge)
+                d1 = Topology.Dictionary(v1)
+                d2 = Topology.Dictionary(v2)
+                v1_id = Dictionary.ValueAtKey(d1, vertexIDKey) if d1 and Dictionary.ValueAtKey(d1, vertexIDKey) is not None else str(sorted(Vertex.Coordinates(v1, mantissa=mantissa)))
+                v2_id = Dictionary.ValueAtKey(d2, vertexIDKey) if d2 and Dictionary.ValueAtKey(d2, vertexIDKey) is not None else str(sorted(Vertex.Coordinates(v2, mantissa=mantissa)))
+
+                return tuple(sorted(tuple([v1_id, v2_id])))
+
+            def edge_weights(graph, edgeWeightKey=None, mantissa=6):
+                weights = {}
+                for edge in Graph.Edges(graph):
+                    if edgeWeightKey == None:
+                        weight = 1
+                    elif edgeWeightKey.lower() == "length" or edgeWeightKey.lower() == "distance":
+                        weight = Edge.Length(edge)
+                    else:
+                        d = Topology.Dictionary(edge)
+                        weight = Dictionary.ValueAtKey(d, edgeWeightKey) if d and Dictionary.ValueAtKey(d, edgeWeightKey) is not None else 1.0
+                    eid = edge_id(edge, vertexIDKey=vertexIDKey, mantissa=mantissa)
+                    weights[eid] = weight
+                return weights
+            
+            w1 = edge_weights(graph1, edgeWeightKey=edgeWeightKey)
+            w2 = edge_weights(graph2, edgeWeightKey=edgeWeightKey)
+            keys = set(w1.keys()) | set(w2.keys())
+
+            numerator = sum(min(w1.get(k, 0), w2.get(k, 0)) for k in keys)
+            denominator = sum(max(w1.get(k, 0), w2.get(k, 0)) for k in keys)
+
+            return numerator / denominator if denominator > 0 else 0.0
+        
+        def safe_mean(lst):
+                return sum(lst)/len(lst) if lst else 0
+        
+        def betweenness_centrality_similarity(graphA, graphB, mantissa=6):
+            v1 = safe_mean(Graph.BetweennessCentrality(graphA))
+            v2 = safe_mean(Graph.BetweennessCentrality(graphB))
+            if v1 == 0 and v2 == 0:
+                return 1
+            diff = abs(v1 - v2) / max(abs(v1), abs(v2), 1e-6)
+            return round((1 - diff), mantissa)
+        
+        def closeness_centrality_similarity(graphA, graphB, mantissa=6):
+            v1 = safe_mean(Graph.ClosenessCentrality(graphA))
+            v2 = safe_mean(Graph.ClosenessCentrality(graphB))
+            if v1 == 0 and v2 == 0:
+                return 1
+            diff = abs(v1 - v2) / max(abs(v1), abs(v2), 1e-6)
+            return round((1 - diff), mantissa)
+        
+        def degree_centrality_similarity(graphA, graphB, mantissa=6):
+            v1 = safe_mean(Graph.DegreeCentrality(graphA))
+            v2 = safe_mean(Graph.DegreeCentrality(graphB))
+            if v1 == 0 and v2 == 0:
+                return 1
+            diff = abs(v1 - v2) / max(abs(v1), abs(v2), 1e-6)
+            return round((1 - diff), mantissa)
+        
+        def diameter_similarity(graphA, graphB, mantissa=6):
+            v1 = Graph.Diameter(graphA)
+            v2 = Graph.Diameter(graphB)
+            if v1 == 0 and v2 == 0:
+                return 1
+            diff = abs(v1 - v2) / max(abs(v1), abs(v2), 1e-6)
+            return round((1 - diff), mantissa)
+        
+        def global_clustering_coefficient_similarity(graphA, graphB, mantissa=6):
+            v1 = Graph.GlobalClusteringCoefficient(graphA)
+            v2 = Graph.GlobalClusteringCoefficient(graphB)
+            if v1 == 0 and v2 == 0:
+                return 1
+            diff = abs(v1 - v2) / max(abs(v1), abs(v2), 1e-6)
+            return round((1 - diff), mantissa)
+        
+        def pagerank_similarity(graphA, graphB, mantissa=6):
+            v1 = safe_mean(Graph.PageRank(graphA))
+            v2 = safe_mean(Graph.PageRank(graphB))
+            if v1 == 0 and v2 == 0:
+                return 1
+            diff = abs(v1 - v2) / max(abs(v1), abs(v2), 1e-6)
+            return round((1 - diff), mantissa)
         
         def structure_similarity(graphA, graphB, mantissa=6):
             v1 = Graph.Vertices(graphA)
@@ -4562,20 +4675,42 @@ class Graph:
                 print("Graph.Compare - Error: The graphB input parameter is not a valid topologic graph. Returning None.")
             return 
         
-        total_weight = weightAttributes + weightGeometry + weightMetrics + weightStructure + weightWL
+        total_weight = sum([weightAttributes,
+                            weightGeometry,
+                            weightBetwennessCentrality,
+                            weightClosenessCentrality,
+                            weightDegreeCentrality,
+                            weightDiameter,
+                            weightGlobalClusteringCoefficient,
+                            weightPageRank,
+                            weightStructure,
+                            weightWeisfeilerLehman,
+                            weightJaccard])
 
         attribute_score = attribute_similarity(graphA, graphB, mantissa=mantissa) if weightAttributes else 0
+        betweenness_centrality_score = betweenness_centrality_similarity(graphA, graphB, mantissa=mantissa) if weightBetwennessCentrality else 0
+        closeness_centrality_score = closeness_centrality_similarity(graphA, graphB, mantissa=mantissa) if weightClosenessCentrality else 0
+        degree_centrality_score = degree_centrality_similarity(graphA, graphB, mantissa=mantissa) if weightDegreeCentrality else 0
+        diameter_score = diameter_similarity(graphA, graphB, mantissa=mantissa) if weightDiameter else 0
+        global_clustering_coefficient_score = global_clustering_coefficient_similarity(graphA, graphB, mantissa=mantissa) if weightGlobalClusteringCoefficient else 0
         geometry_score = geometry_similarity(graphA, graphB, mantissa=mantissa) if weightGeometry else 0
-        metrics_score = metrics_similarity(graphA, graphB, mantissa=mantissa) if weightMetrics else 0
+        jaccard_score = weighted_jaccard_similarity(graphA, graphB, vertexIDKey=vertexIDKey, edgeWeightKey=edgeWeightKey, mantissa=mantissa) if weightJaccard else 0
+        pagerank_score = pagerank_similarity(graphA, graphB, mantissa=mantissa) if weightPageRank else 0
         structure_score = structure_similarity(graphA, graphB, mantissa=mantissa) if weightStructure else 0
-        wl_score = weisfeiler_lehman_similarity(graphA, graphB, iterations, mantissa=mantissa) if weightWL else 0
+        weisfeiler_lehman_score = weisfeiler_lehman_similarity(graphA, graphB, iterations, mantissa=mantissa) if weightWeisfeilerLehman else 0
 
         weighted_sum = (
             attribute_score * weightAttributes +
+            betweenness_centrality_score * weightBetwennessCentrality +
+            closeness_centrality_score * weightClosenessCentrality +
+            degree_centrality_score * weightDegreeCentrality +
+            diameter_score * weightDiameter +
             geometry_score * weightGeometry +
-            metrics_score * weightMetrics +
+            global_clustering_coefficient_score * weightGlobalClusteringCoefficient +
+            jaccard_score * weightJaccard +
+            pagerank_score * weightPageRank +
             structure_score * weightStructure +
-            wl_score * weightWL
+            weisfeiler_lehman_score * weightWeisfeilerLehman
         )
 
         if total_weight <= 0:
@@ -4583,12 +4718,18 @@ class Graph:
         else:
             overall_score = weighted_sum / total_weight
         
-        return  { "attribute": round(attribute_score, mantissa),
-                "geometry": round(geometry_score, mantissa),
-                "metrics": round(metrics_score, mantissa),
-                "structure": round(structure_score, mantissa),
-                "wl": round(wl_score, mantissa),
-                "overall": round(overall_score, mantissa)
+        return  {
+                 "attribute": round(attribute_score, mantissa),
+                 "betwenness_centrality": round(betweenness_centrality_score, mantissa),
+                 "closeness_centrality": round(closeness_centrality_score, mantissa),
+                 "degree_centrality": round(degree_centrality_score, mantissa),
+                 "geometry": round(geometry_score, mantissa),
+                 "global_clustering_coefficient": round(global_clustering_coefficient_score, mantissa),
+                 "jaccard": round(jaccard_score, mantissa),
+                 "pagerank": round(pagerank_score, mantissa),
+                 "structure": round(structure_score, mantissa),
+                 "weisfeiler_lehman": round(weisfeiler_lehman_score, mantissa),
+                 "overall": round(overall_score, mantissa)
                 }
 
     @staticmethod
@@ -11018,3 +11159,85 @@ class Graph:
             g = Graph.ByVerticesEdges(final_vertices, final_edges)
             return g
         return None
+
+    @staticmethod
+    def WeightedJaccardSimilarity(graphA, graphB, vertexA, vertexB, vertexIDKey="id", edgeWeightKey=None, mantissa=6, silent=False):
+        """
+        Computes the weighted Jaccard similarity between two vertices based on their neighbors and
+        edge weights. Accepts either one graph (both vertices are in the same graph) or two graphs
+        (each vertex is in a separate graph).
+
+        Parameters
+        ----------
+        graphA : topologic_core.Graph
+            The first graph
+        graphB : topologic_core.Graph
+            The second graph (this can be the same as the first graph)
+        vertexA : topologic_core.Vertex
+            The first vertex.
+        vertexB : topologic_core.Vertex
+            The second vertex.
+        vertexIDKey : str , optional
+            The dictionary key under which to find the unique vertex ID. The default is "id".
+        edgeWeightKey : str , optional
+            The dictionary key under which to find the weight of the edge for weighted graphs.
+            If this parameter is specified as "length" or "distance" then the length of the edge is used as its weight.
+            The default is None which means all edges are treated as if they have a weight of 1.
+        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
+        -------
+        float
+            Weighted Jaccard similarity score between 0 (no overlap) and 1 (perfect match).
+
+        """
+        from topologicpy.Graph import Graph
+        from topologicpy.Topology import Topology
+        from topologicpy.Dictionary import Dictionary
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Edge import Edge
+
+        if graphB == None:
+            graphB = graphA
+
+        def edge_id(edge, vertexIDKey="id", mantissa=6):
+            v1 = Edge.StartVertex(edge)
+            v2 = Edge.EndVertex(edge)
+            d1 = Topology.Dictionary(v1)
+            d2 = Topology.Dictionary(v2)
+            v1_id = Dictionary.ValueAtKey(d1, vertexIDKey) if d1 and Dictionary.ValueAtKey(d1, vertexIDKey) is not None else str(sorted(Vertex.Coordinates(v1, mantissa=mantissa)))
+            v2_id = Dictionary.ValueAtKey(d2, vertexIDKey) if d2 and Dictionary.ValueAtKey(d2, vertexIDKey) is not None else str(sorted(Vertex.Coordinates(v2, mantissa=mantissa)))
+            return tuple(sorted([v1_id, v2_id]))
+        
+        def get_neighbors_with_weights(graph, vertex, vertexIDKey="id", edgeWeightKey=None, mantissa=6):
+            weights = {}
+            for edge in Graph.Edges(graph, [vertex]):
+                eid = edge_id(edge, vertexIDKey=vertexIDKey, mantissa=mantissa)
+                if edgeWeightKey == None:
+                    weight = 1.0
+                elif edgeWeightKey.lower() == "length" or edgeWeightKey.lower() == "distance":
+                    weight = Edge.Length(edge, mantissa=mantissa)
+                else:
+                    d = Topology.Dictionary(edge)
+                    d_weight = Dictionary.ValueAtKey(d, edgeWeightKey, silent=silent)
+                    if not d or d_weight is None:
+                        if not silent:
+                            print(f"Graph.WeightedJaccardSimilarity - Warning: The dictionary of edge {eid} is missing '{edgeWeightKey}' key. Defaulting the edge weight to 1.0.")
+                        weight = 1.0
+                    else:
+                        weight = d_weight
+                weights[eid] = weight
+            return weights
+
+        weights1 = get_neighbors_with_weights(graphA, vertexA, vertexIDKey=vertexIDKey, edgeWeightKey=edgeWeightKey, mantissa=mantissa)
+        weights2 = get_neighbors_with_weights(graphB, vertexB, vertexIDKey=vertexIDKey, edgeWeightKey=edgeWeightKey, mantissa=mantissa)
+
+        keys = set(weights1.keys()) | set(weights2.keys())
+
+        numerator = sum(min(weights1.get(k, 0), weights2.get(k, 0)) for k in keys)
+        denominator = sum(max(weights1.get(k, 0), weights2.get(k, 0)) for k in keys)
+
+        return round(numerator / denominator, mantissa) if denominator != 0 else 0.0

topologicpy/version.py

@@ -1 +1 @@
-__version__ = '0.8.20'
+__version__ = '0.8.22'

{topologicpy-0.8.20.dist-info → topologicpy-0.8.22.dist-info}/METADATA

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

@@ -7,11 +7,11 @@ topologicpy/Cluster.py,sha256=o5jdMRpcGfSGGiXQdFg-e9XcnBF5AqTj3xb1nSpwJWE,58606
 topologicpy/Color.py,sha256=q9xsGmxFMz7sQKmygwSVS12GaTRB-OT0-_i6t3-cthE,20307
 topologicpy/Context.py,sha256=ppApYKngZZCQBFWaxIMi2z2dokY23c935IDCBosxDAE,3055
 topologicpy/DGL.py,sha256=M_znFtyPBJJz-iXLYZs2wwBj24fhevIo739dGha0chM,139041
-topologicpy/Dictionary.py,sha256=7h-Gszgnt2OEOvOSADJ4pa-mTNlhQ9cuIiB5WHEW6aY,33949
+topologicpy/Dictionary.py,sha256=TO5Ar9j_xUSV325MYbUHdNrKfgo9VcehcZCeZWAn6b0,34126
 topologicpy/Edge.py,sha256=yxkCVDYBflJNEYxnjMmlyvbkpg8TNy7y5bSH3yQ4jzs,71418
 topologicpy/EnergyModel.py,sha256=UoQ9Jm-hYsN383CbcLKw-y6BKitRHj0uyh84yQ-8ACg,53856
 topologicpy/Face.py,sha256=SlhB8L7BpDjd4a9YZE4UJ3zoGuF1oq9MSpuesEWro_Q,184847
-topologicpy/Graph.py,sha256=fsWgbYp1di1HtDipsXY9d2i42Fn_3dXsVKTac9vl7bU,515137
+topologicpy/Graph.py,sha256=c2VvEvEM3hGgFR6xP-A58HXcgEVnPyA_heFOoNZ4p_Y,527640
 topologicpy/Grid.py,sha256=2s9cSlWldivn1i9EUz4OOokJyANveqmRe_vR93CAndI,18245
 topologicpy/Helper.py,sha256=4H5KPiv_eiEs489UOOyGLe9RaeoZIfmMh3mk_YCHmXg,29100
 topologicpy/Honeybee.py,sha256=uDVtDbloydNoaBFcSNukKL_2PLyD6XKkCp1VHz1jtaU,21751
@@ -28,9 +28,9 @@ topologicpy/Vector.py,sha256=GkGt-aJ591IJ2IPffMAudvITLDPi2qZibZc4UAav6m8,42407
 topologicpy/Vertex.py,sha256=q99IrWwdNlvVfUXz6iP8icmP8NzP2nsiqtgnF9Jnpx8,80913
 topologicpy/Wire.py,sha256=IVPzBKsckuxC-rHvwxmvtVF7PpApz2lhPHomtQMo_kg,228499
 topologicpy/__init__.py,sha256=vlPCanUbxe5NifC4pHcnhSzkmmYcs_UrZrTlVMsxcFs,928
-topologicpy/version.py,sha256=uWqZIJblLUrle0kYZkrKO4aVSNXiyYenL0G_TSUJllE,23
-topologicpy-0.8.20.dist-info/licenses/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
-topologicpy-0.8.20.dist-info/METADATA,sha256=0_3vo7ubfFiV0woZaJt8RCFHF9MZZ_Sc7VnqYZX4Mao,10535
-topologicpy-0.8.20.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-topologicpy-0.8.20.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
-topologicpy-0.8.20.dist-info/RECORD,,
+topologicpy/version.py,sha256=SuLneBfTbTDP--cc9ZcmXl_eRJruqxfxMHpHGiHHHZA,23
+topologicpy-0.8.22.dist-info/licenses/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
+topologicpy-0.8.22.dist-info/METADATA,sha256=9_VzttjULYoYaVn35tAzKn6Q7cf2l4mfnGKYkOE_tFo,10535
+topologicpy-0.8.22.dist-info/WHEEL,sha256=ooBFpIzZCPdw3uqIQsOo4qqbA4ZRPxHnOH7peeONza0,91
+topologicpy-0.8.22.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
+topologicpy-0.8.22.dist-info/RECORD,,

{topologicpy-0.8.20.dist-info → topologicpy-0.8.22.dist-info}/WHEEL

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