topologicpy 0.8.21__py3-none-any.whl → 0.8.23__py3-none-any.whl

topologicpy/ANN.py

@@ -1,4 +1,4 @@
-# Copyright (C) 2024
+# Copyright (C) 2025
 # Wassim Jabi <wassim.jabi@gmail.com>
 #
 # This program is free software: you can redistribute it and/or modify it under

topologicpy/Aperture.py

@@ -1,4 +1,4 @@
-# Copyright (C) 2024
+# Copyright (C) 2025
 # Wassim Jabi <wassim.jabi@gmail.com>
 #
 # This program is free software: you can redistribute it and/or modify it under

topologicpy/BVH.py

@@ -1,4 +1,4 @@
-# Copyright (C) 2024
+# Copyright (C) 2025
 # Wassim Jabi <wassim.jabi@gmail.com>
 #
 # This program is free software: you can redistribute it and/or modify it under

topologicpy/CSG.py

@@ -0,0 +1,389 @@
+# Copyright (C) 2025
+# Wassim Jabi <wassim.jabi@gmail.com>
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Affero General Public License as published by the Free Software
+# Foundation, either version 3 of the License, or (at your option) any later
+# version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Affero General Public License along with
+# this program. If not, see <https://www.gnu.org/licenses/>.
+
+class CSG():
+    @staticmethod
+    def _unique_coords(used_coords=[], width=10, length=10, height=10, max_attempts=1000, mantissa=6, tolerance=0.0001):
+        import math
+        import random
+
+        def is_too_close(p1, p2):
+            return math.dist(p1, p2) < tolerance
+
+        if used_coords == []:
+            return [0,0,0]
+        
+        attempts = 0
+        while attempts < max_attempts:
+            x = round(random.uniform(0, width), mantissa)
+            y = round(random.uniform(0, length), mantissa)
+            z = round(random.uniform(0, height), mantissa)
+            candidate = [x, y, z]
+            if all(not is_too_close(candidate, used) for used in used_coords):
+                return candidate
+            attempts += 1
+
+        raise RuntimeError("Could not find a unique coordinate within the attempt limit.")
+    
+    @staticmethod
+    def AddTopologyVertex(graph, topology, matrix: list = None, mantissa: int = 6, tolerance: float = 0.0001, silent: bool = False):
+        """
+        Adds a topology vertex to the graph.
+
+        Parameters
+        ----------
+        graph : topologic_core.Graph
+            The input graph.
+        topology : topologic_core.Topology
+            The input topology..
+        matrix : list , optional
+            The desired 4X4 transformation matrix to apply to the result before any further operations. The default is None.
+        mantissa : int , optional
+            The desired length of the 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
+        -------
+            topologic_core.Vertex
+                The added vertex.
+        """
+
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Dictionary import Dictionary
+        from topologicpy.Matrix import Matrix
+        from topologicpy.Topology import Topology
+        from topologicpy.Graph import Graph
+
+        if matrix == None:
+            matrix = Matrix.Identity()
+        if graph == None:
+            used_coords = []
+        else:
+            used_coords = [Vertex.Coordinates(v, mantissa=mantissa) for v in Graph.Vertices(graph)]
+        loc = CSG._unique_coords(used_coords=used_coords, width=10, length=10, height=10, max_attempts=1000, mantissa=mantissa, tolerance=tolerance)
+        v = Vertex.ByCoordinates(loc)
+        keys = ["brep",
+                "brepType",
+                "brepTypeString",
+                "matrix",
+                "type",
+                "id"]
+        values = [Topology.BREPString(topology),
+                Topology.Type(topology),
+                Topology.TypeAsString(topology),
+                matrix,
+                "topology",
+                Topology.UUID(v)]
+        
+        d = Dictionary.ByKeysValues(keys, values)
+        v = Topology.SetDictionary(v, d)
+        if graph == None:
+            graph = Graph.ByVerticesEdges([v], [])
+        else:
+            graph = Graph.AddVertex(graph, v, tolerance=tolerance, silent=silent)
+        return v
+
+    @staticmethod
+    def AddOperationVertex(graph, operation, a, b, matrix = None, mantissa: int = 6, tolerance: float = 0.0001, silent: bool = False):
+        """
+        Adds an operation vertex to the graph that performs a CSG operation on two child vertices. For ordered operations, the order of a and b inputs is important.
+
+        Parameters
+        ----------
+        graph : topologic_core.Graph
+            The input graph.
+        operation : str
+            The operation to perform. One of "union", "difference", "intersection", "xor", "merge", "impose", "imprint", "slice".
+        a : topologic_core.Vertex
+            The first input vertex.
+        b : topologic_core.Vertex
+            The second input vertex.
+        matrix : list , optional
+            The desired 4X4 transformation matrix to apply to the result before any further operations. The default is None.
+        mantissa : int , optional
+            The desired length of the 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
+        -------
+            topologic_core.Vertex
+                The added vertex.
+        """
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Dictionary import Dictionary
+        from topologicpy.Topology import Topology
+        from topologicpy.Graph import Graph
+
+        if graph == None:
+            used_coords = []
+        else:
+            used_coords = [Vertex.Coordinates(v, mantissa=mantissa) for v in Graph.Vertices(graph)]
+        loc = CSG._unique_coords(used_coords=used_coords, width=10, length=10, height=10, max_attempts=1000, mantissa=mantissa, tolerance=tolerance)
+        v = Vertex.ByCoordinates(loc)
+        a_id = Dictionary.ValueAtKey(Topology.Dictionary(a), "id")
+        b_id = Dictionary.ValueAtKey(Topology.Dictionary(b), "id")
+
+        keys = ["brep",
+                "brepType",
+                "brepTypeString",
+                "matrix",
+                "type",
+                "id",
+                "operation",
+                "a_id",
+                "b_id"]
+        values = [None,
+                None,
+                None,
+                matrix,
+                "operation",
+                Topology.UUID(v),
+                operation,
+                a_id,
+                b_id]
+        
+        d = Dictionary.ByKeysValues(keys, values)
+        v = Topology.SetDictionary(v, d)
+        return v
+    
+    @staticmethod
+    def Connect(graph, vertexA, vertexB, tolerance: float = 0.0001, silent: bool = False):
+        """
+        Connects two vertices in the graph with a directional edge from vertexA to vertexB.
+
+        Parameters
+        ----------
+        graph : topologic_core.Graph
+            The input graph.
+        vertexA : topologic_core.Vertex
+            The first input vertex.
+        vertexB : topologic_core.Vertex
+            The second input vertex.
+        matrix : list , optional
+            The desired 4X4 transformation matrix to apply to the result before any further operations. The default is None.
+        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.Vertex
+                The added vertex.
+        """
+        from topologicpy.Graph import Graph
+        from topologicpy.Edge import Edge
+        from topologicpy.Topology import Topology
+
+        if not Topology.IsInstance(vertexA, "Vertex"):
+            if not silent:
+                print("CSG.Connect - Error: The input vertexA parameter is not a valid vertex. Returning None.")
+            return None
+        if not Topology.IsInstance(vertexB, "Vertex"):
+            if not silent:
+                print("CSG.Connect - Error: The input vertexB parameter is not a valid vertex. Returning None.")
+            return None
+        edge = Edge.ByVertices(vertexA, vertexB, tolerance=tolerance)
+        if graph == None:
+            vertices = [vertexA, vertexB]
+            edges = [edge]
+        else:
+            if not Topology.IsInstance(graph, "Graph"):
+                if not silent:
+                    print("CSG.Connect - Error: The input graph parameter is not a valid graph. Returning None.")
+                return None
+            vertices = Graph.Vertices(graph)
+            edges = Graph.Edges(graph)
+            if len(edges) > 0:
+                edges.append(edge)
+            else:
+                edges = [edge]
+        graph = Graph.ByVerticesEdges(vertices, edges)
+        return graph
+
+    @staticmethod
+    def Init():
+        """
+        Returns an initial empty graph.
+
+        Parameters
+        ----------
+
+        Returns
+        -------
+            topologic_core.Graph
+                The initialized empty graph.
+        """
+
+        from topologicpy.Graph import Graph
+
+        return Graph.ByVerticesEdges([], [])
+    
+    @staticmethod
+    def Invoke(graph, silent: bool = False):
+        """
+        Traverses the graph and evaluates all CSG operations from leaves to root, returning the final result.
+
+        Parameters
+        ----------
+        graph : topologic_core.Graph
+            The input graph.
+        silent : bool , optional
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
+        
+        Returns
+        -------
+            topologic_core.Topology
+                The final topology.
+        """
+
+        from topologicpy.Topology import Topology
+        from topologicpy.Dictionary import Dictionary
+        from topologicpy.Graph import Graph
+        
+        if not Topology.IsInstance(graph, "Graph"):
+            if not silent:
+                print("CSG.Connect - Error: The input graphA parameter is not a valid graph. Returning None.")
+            return None
+        
+        def traverse(vertex):
+            d = Topology.Dictionary(vertex)
+            node_type = Dictionary.ValueAtKey(d, "type")
+
+            if node_type == "topology":
+                topology = Topology.ByBREPString(Dictionary.ValueAtKey(d, "brep"))
+                matrix = Dictionary.ValueAtKey(d, "matrix")
+                topology = Topology.Transform(topology, matrix)
+                topology = Topology.SetDictionary(topology, d)
+                return topology
+
+            elif node_type == "operation":
+                op = Dictionary.ValueAtKey(d, "operation")
+                a_id = Dictionary.ValueAtKey(d, "a_id")
+
+                children = Graph.IncomingVertices(graph, vertex, directed=True)
+                if len(children) != 2:
+                    if not silent:
+                        print(f"CSG.Invoke - Error: Operation '{op}' must have exactly 2 children. Returning None.")
+                    return None
+                
+                child_0 = children[0]
+                child_1 = children[1]
+                child_0_id = Dictionary.ValueAtKey(Topology.Dictionary(child_0), "id")
+                if child_0_id != a_id:
+                    child_0 = children[1]
+                    child_1 = children[0]
+                a = traverse(child_0)
+                b = traverse(child_1)
+                if op.lower() == "union":
+                    result = Topology.Union(a, b, silent=silent)
+                elif op.lower() == "intersection":
+                    result = Topology.Intersect(a, b, silent=silent)
+                elif op.lower() == "difference":
+                    result = Topology.Difference(a, b, silent=silent)
+                elif op.lower() == "xor" or "sym" in op.lower():
+                    result = Topology.SymmeticDifference(a, b, silent=silent)
+                elif op.lower() == "merge":
+                    result = Topology.Merge(a, b, silent=silent)
+                elif op.lower() == "impose":
+                    result = Topology.Impose(a, b, silent=silent)
+                elif op.lower() == "imprint":
+                    result = Topology.Imprint(a, b, silent=silent)
+                elif op.lower() == "slice":
+                    result = Topology.Slice(a, b, silent=silent)
+                else:
+                    if not silent:
+                        print(f"CSG.Invoke - Error: Unknown operation '{op}'. Returning None.")
+                    return None
+                keys = ["brep",
+                        "brepType",
+                        "brepTypeString"]
+                values = [Topology.BREPString(result),
+                        Topology.Type(result),
+                        Topology.TypeAsString(result)]
+                d = Dictionary.SetValuesAtKeys(d, keys=keys, values=values)
+                vertex = Topology.SetDictionary(vertex, d)
+                matrix = Dictionary.ValueAtKey(d, "matrix")
+                if not matrix == None:
+                    result = Topology.Transform(result, matrix)
+                result = Topology.SetDictionary(result, d)
+                return result
+            else:
+                if not silent:
+                    print(f"CSG.Invoke - Error: Unknown node type '{node_type}'. Returning None.")
+                return None
+
+        # Assume root is the vertex with no outgoing edges
+        roots = [v for v in Graph.Vertices(graph) if not Graph.OutgoingVertices(graph, v, directed=True)]
+        if len(roots) != 1:
+            if not silent:
+                print("CSG.Invoke - Error: Graph must have exactly one root node. Returning None.")
+            return None
+
+        return traverse(roots[0])
+
+    def Topologies(graph, xOffset: float = 0, yOffset: float = 0, zOffset: float = 0, scale: float = 1, silent: bool = False):
+        """
+        Places each geometry (using its centroid) at its corresponding vertex location in the graph.
+
+        Parameters
+        ----------
+        graph : topologic_core.Graph
+            The input graph.
+        xOffset : float , optional
+            An additional x offset. The default is 0.
+        yOffset : float , optional
+            An additional y offset. The default is 0.
+        zOffset : float , optional
+            An additional z offset. The default is 0.
+        scale : float , optional
+            A desired scale to resize the placed topologies. The default is 1.
+        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 topologies placed at their corresponding location in the graph.
+        """
+        
+        from topologicpy.Topology import Topology
+        from topologicpy.Dictionary import Dictionary
+        from topologicpy.Graph import Graph
+
+        if not Topology.IsInstance(graph, "Graph"):
+            if not silent:
+                print("CSG.Topologies - Error: The input graph parameter is not a valid graph. Returning None.")
+            return None
+        placed_topologies= []
+
+        for vertex in Graph.Vertices(graph):
+            geom = Topology.ByBREPString(Dictionary.ValueAtKey(Topology.Dictionary(vertex), "brep"))
+            originA = Topology.Centroid(geom)
+            geom = Topology.Scale(geom, origin=originA, x=scale, y=scale, z=scale)
+            originB = vertex
+            placed = Topology.Place(geom, originA, originB)
+            placed = Topology.Translate(placed, x=xOffset, y=yOffset, z=zOffset)
+            placed_topologies.append(placed)
+
+        return placed_topologies
+

topologicpy/Cell.py

@@ -1,4 +1,4 @@
-# Copyright (C) 2024
+# Copyright (C) 2025
 # Wassim Jabi <wassim.jabi@gmail.com>
 #
 # This program is free software: you can redistribute it and/or modify it under
@@ -850,6 +850,43 @@ class Cell():
             print("Cell.ContainmentStatus - Error: Could not determine containment status. Returning None.")
             return None
  
+    @staticmethod
+    def Cube(origin = None,
+            size: float = 1,
+            uSides: int = 1, vSides: int = 1, wSides: int = 1,
+            direction: list = [0, 0, 1], placement: str ="center", tolerance: float = 0.0001):
+        """
+        Creates a cube.
+
+        Parameters
+        ----------
+        origin : topologic_core.Vertex , optional
+            The origin location of the cube. The default is None which results in the cube being placed at (0, 0, 0).
+        size : float , optional
+            The size of the cube. The default is 1.
+        uSides : int , optional
+            The number of sides along the width. The default is 1.
+        vSides : int , optional
+            The number of sides along the length. The default is 1.
+        wSides : int , optional
+            The number of sides along the height. The default is 1.
+        direction : list , optional
+            The vector representing the up direction of the cube. The default is [0, 0, 1].
+        placement : str , optional
+            The description of the placement of the origin of the cube. This can be "bottom", "center", or "lowerleft". It is case insensitive. The default is "center".
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
+        
+        Returns
+        -------
+        topologic_core.Cell
+            The created cube.
+
+        """
+        return Cell.Prism(origin=origin, width=size, length=size, height=size,
+                          uSides=uSides, vSides=vSides, wSides=wSides,
+                          direction=direction, placement=placement, tolerance=tolerance)
+    
     @staticmethod
     def Cylinder(origin = None, radius: float = 0.5, height: float = 1, uSides: int = 16, vSides: int = 1, direction: list = [0, 0, 1],
                      placement: str = "center", mantissa: int = 6, tolerance: float = 0.0001):

topologicpy/CellComplex.py

@@ -1,4 +1,4 @@
-# Copyright (C) 2024
+# Copyright (C) 2025
 # Wassim Jabi <wassim.jabi@gmail.com>
 #
 # This program is free software: you can redistribute it and/or modify it under
@@ -450,6 +450,44 @@ class CellComplex():
         _ = cellComplex.Cells(None, cells) # Hook to Core
         return cells
 
+    @staticmethod
+    def Cube(origin= None,
+            size: float = 1.0,
+            uSides: int = 2, vSides: int = 2, wSides: int = 2,
+            direction: list = [0, 0, 1], placement: str = "center", tolerance: float = 0.0001):
+        """
+        Creates a cube with internal cells.
+
+        Parameters
+        ----------
+        origin : topologic_core.Vertex , optional
+            The origin location of the cube. The default is None which results in the cube being placed at (0, 0, 0).
+        size : float , optional
+            The size of the cube. The default is 1.
+        uSides : int , optional
+            The number of sides along the width. The default is 1.
+        vSides : int, optional
+            The number of sides along the length. The default is 1.
+        wSides : int , optional
+            The number of sides along the height. The default is 1.
+        direction : list , optional
+            The vector representing the up direction of the cube. The default is [0, 0, 1].
+        placement : str , optional
+            The description of the placement of the origin of the cube. This can be "bottom", "center", or "lowerleft". It is case insensitive. The default is "center".
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
+        
+        Returns
+        -------
+        topologic_core.CellComplex
+            The created cube.
+
+        """
+        return CellComplex.Prism(origin=origin,
+                                 width=size, length=size, height=size,
+                                 uSides=uSides, vSides=vSides, wSides=wSides,
+                                 direction=direction, placement=placement, tolerance=tolerance)
+    
     @staticmethod
     def Decompose(cellComplex, tiltAngle: float = 10.0, tolerance: float = 0.0001) -> dict:
         """

topologicpy/Cluster.py

@@ -1,4 +1,4 @@
-# Copyright (C) 2024
+# Copyright (C) 2025
 # Wassim Jabi <wassim.jabi@gmail.com>
 #
 # This program is free software: you can redistribute it and/or modify it under

topologicpy/Color.py

@@ -1,4 +1,4 @@
-# Copyright (C) 2024
+# Copyright (C) 2025
 # Wassim Jabi <wassim.jabi@gmail.com>
 #
 # This program is free software: you can redistribute it and/or modify it under

topologicpy/Context.py

@@ -1,4 +1,4 @@
-# Copyright (C) 2024
+# Copyright (C) 2025
 # Wassim Jabi <wassim.jabi@gmail.com>
 #
 # This program is free software: you can redistribute it and/or modify it under

topologicpy/DGL.py

@@ -1,4 +1,4 @@
-# Copyright (C) 2024
+# Copyright (C) 2025
 # Wassim Jabi <wassim.jabi@gmail.com>
 #
 # This program is free software: you can redistribute it and/or modify it under

topologicpy/Dictionary.py

@@ -1,4 +1,4 @@
-# Copyright (C) 2024
+# Copyright (C) 2025
 # Wassim Jabi <wassim.jabi@gmail.com>
 #
 # This program is free software: you can redistribute it and/or modify it under
@@ -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/Edge.py

@@ -1,4 +1,4 @@
-# Copyright (C) 2024
+# Copyright (C) 2025
 # Wassim Jabi <wassim.jabi@gmail.com>
 #
 # This program is free software: you can redistribute it and/or modify it under

topologicpy/EnergyModel.py

@@ -1,4 +1,4 @@
-# Copyright (C) 2024
+# Copyright (C) 2025
 # Wassim Jabi <wassim.jabi@gmail.com>
 #
 # This program is free software: you can redistribute it and/or modify it under

topologicpy/Face.py

@@ -1,4 +1,4 @@
-# Copyright (C) 2024
+# Copyright (C) 2025
 # Wassim Jabi <wassim.jabi@gmail.com>
 #
 # This program is free software: you can redistribute it and/or modify it under

topologicpy/Graph.py

@@ -1,4 +1,4 @@
-# Copyright (C) 2024
+# Copyright (C) 2025
 # Wassim Jabi <wassim.jabi@gmail.com>
 #
 # This program is free software: you can redistribute it and/or modify it under
@@ -4379,12 +4379,17 @@ 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,
-                weightJaccard: 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,
@@ -4402,18 +4407,28 @@ 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.
-        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 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 1.0.
+            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 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
@@ -4433,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
@@ -4551,40 +4570,56 @@ class Graph:
 
             return numerator / denominator if denominator > 0 else 0.0
         
-        def metrics_similarity(graphA, graphB, mantissa=6):
-            # Example using global metrics + mean of node metrics
-            def safe_mean(lst):
+        def safe_mean(lst):
                 return sum(lst)/len(lst) if lst else 0
-
-            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 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)
@@ -4640,22 +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 + weightJaccard
+        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
         jaccard_score = weighted_jaccard_similarity(graphA, graphB, vertexIDKey=vertexIDKey, edgeWeightKey=edgeWeightKey, mantissa=mantissa) if weightJaccard else 0
-        metrics_score = metrics_similarity(graphA, graphB, mantissa=mantissa) if weightMetrics 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 +
+            global_clustering_coefficient_score * weightGlobalClusteringCoefficient +
             jaccard_score * weightJaccard +
-            metrics_score * weightMetrics +
+            pagerank_score * weightPageRank +
             structure_score * weightStructure +
-            wl_score * weightWL
+            weisfeiler_lehman_score * weightWeisfeilerLehman
         )
 
         if total_weight <= 0:
@@ -4665,11 +4720,15 @@ class Graph:
         
         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),
-                 "metrics": round(metrics_score, mantissa),
+                 "pagerank": round(pagerank_score, mantissa),
                  "structure": round(structure_score, mantissa),
-                 "wl": round(wl_score, mantissa),
+                 "weisfeiler_lehman": round(weisfeiler_lehman_score, mantissa),
                  "overall": round(overall_score, mantissa)
                 }
 

topologicpy/Grid.py

@@ -1,4 +1,4 @@
-# Copyright (C) 2024
+# Copyright (C) 2025
 # Wassim Jabi <wassim.jabi@gmail.com>
 #
 # This program is free software: you can redistribute it and/or modify it under

topologicpy/Helper.py

@@ -1,4 +1,4 @@
-# Copyright (C) 2024
+# Copyright (C) 2025
 # Wassim Jabi <wassim.jabi@gmail.com>
 #
 # This program is free software: you can redistribute it and/or modify it under

topologicpy/Honeybee.py

@@ -1,4 +1,4 @@
-# Copyright (C) 2024
+# Copyright (C) 2025
 # Wassim Jabi <wassim.jabi@gmail.com>
 #
 # This program is free software: you can redistribute it and/or modify it under

topologicpy/Matrix.py

@@ -1,4 +1,4 @@
-# Copyright (C) 2024
+# Copyright (C) 2025
 # Wassim Jabi <wassim.jabi@gmail.com>
 #
 # This program is free software: you can redistribute it and/or modify it under

topologicpy/Neo4j.py

@@ -1,4 +1,4 @@
-# Copyright (C) 2024
+# Copyright (C) 2025
 # Wassim Jabi <wassim.jabi@gmail.com>
 #
 # This program is free software: you can redistribute it and/or modify it under

topologicpy/Plotly.py

@@ -1,4 +1,4 @@
-# Copyright (C) 2024
+# Copyright (C) 2025
 # Wassim Jabi <wassim.jabi@gmail.com>
 #
 # This program is free software: you can redistribute it and/or modify it under
@@ -511,7 +511,7 @@ class Plotly:
         borderSizes = []
         for i in range(len(vertices)):
             sizes.append(size)
-            labels.append("Vertex_"+str(i+1).zfill(n))
+            labels.append("")
             colors.append(Color.AnyToHex(color))
             borderColors.append(borderColor)
             borderSizes.append(size+borderWidth*2)
@@ -543,7 +543,7 @@ class Plotly:
                             if not temp_color == None:
                                 colors[m] = Color.AnyToHex(temp_color)
                         if not labelKey == None:
-                            labels[m] = str(Dictionary.ValueAtKey(d, key=labelKey)) or labels[m]
+                            labels[m] = Dictionary.ValueAtKey(d, key=labelKey, defaultValue=" ")
                         if not sizeKey == None:
                             sizes[m] = Dictionary.ValueAtKey(d, key=sizeKey)
                             if sizes[m] == None:

topologicpy/Polyskel.py

@@ -210,7 +210,7 @@ def skeletonize(polygon, holes=None):
 
 
 
-# # Copyright (C) 2024
+# # Copyright (C) 2025
 # # Wassim Jabi <wassim.jabi@gmail.com>
 # #
 # # This program is free software: you can redistribute it and/or modify it under

topologicpy/PyG.py

@@ -1,4 +1,4 @@
-# Copyright (C) 2024
+# Copyright (C) 2025
 # Wassim Jabi <wassim.jabi@gmail.com>
 #
 # This program is free software: you can redistribute it and/or modify it under

topologicpy/Shell.py

@@ -1,4 +1,4 @@
-# Copyright (C) 2024
+# Copyright (C) 2025
 # Wassim Jabi <wassim.jabi@gmail.com>
 #
 # This program is free software: you can redistribute it and/or modify it under

topologicpy/Speckle.py

@@ -1,4 +1,4 @@
-# Copyright (C) 2024
+# Copyright (C) 2025
 # Wassim Jabi <wassim.jabi@gmail.com>
 #
 # This program is free software: you can redistribute it and/or modify it under

topologicpy/Sun.py

@@ -1,4 +1,4 @@
-# Copyright (C) 2024
+# Copyright (C) 2025
 # Wassim Jabi <wassim.jabi@gmail.com>
 #
 # This program is free software: you can redistribute it and/or modify it under

topologicpy/Topology.py

@@ -1,4 +1,4 @@
-# Copyright (C) 2024
+# Copyright (C) 2025
 # Wassim Jabi <wassim.jabi@gmail.com>
 #
 # This program is free software: you can redistribute it and/or modify it under
@@ -846,7 +846,7 @@ class Topology():
         return apTopologies
     
     @staticmethod
-    def Union(topologyA, topologyB, tranDict=False, tolerance=0.0001):
+    def Union(topologyA, topologyB, tranDict: bool = False, tolerance: float = 0.0001, silent: bool = False):
         """
         See Topology.Boolean()
 
@@ -879,15 +879,15 @@ class Topology():
                         else:
                             internal_boundaries.append(eb)
                     return Face.ByWires(external_boundary, internal_boundaries)
-        return Topology.Boolean(topologyA, topologyB, operation="union", tranDict=tranDict, tolerance=tolerance)
+        return Topology.Boolean(topologyA, topologyB, operation="union", tranDict=tranDict, tolerance=tolerance, silent=silent)
     
     @staticmethod
-    def Difference(topologyA, topologyB, tranDict=False, tolerance=0.0001):
+    def Difference(topologyA, topologyB, tranDict: bool = False, tolerance: float = 0.0001, silent: bool = False):
         """
         See Topology.Boolean().
 
         """
-        return Topology.Boolean(topologyA=topologyA, topologyB=topologyB, operation="difference", tranDict=tranDict, tolerance=tolerance)
+        return Topology.Boolean(topologyA=topologyA, topologyB=topologyB, operation="difference", tranDict=tranDict, tolerance=tolerance, silent=silent)
     
     @staticmethod
     def ExternalBoundary(topology):
@@ -1006,63 +1006,63 @@ class Topology():
             return Topology.SelfMerge(Topology.SelfMerge(Cluster.ByTopologies(results)))
     
     @staticmethod
-    def SymmetricDifference(topologyA, topologyB, tranDict=False, tolerance=0.0001):
+    def SymmetricDifference(topologyA, topologyB, tranDict: bool = False, tolerance: float = 0.0001, silent: bool = False):
         """
         See Topology.Boolean().
 
         """
-        return Topology.Boolean(topologyA=topologyA, topologyB=topologyB, operation="symdif", tranDict=tranDict, tolerance=tolerance)
+        return Topology.Boolean(topologyA=topologyA, topologyB=topologyB, operation="symdif", tranDict=tranDict, tolerance=tolerance, silent=silent)
     
     @staticmethod
-    def SymDif(topologyA, topologyB, tranDict=False, tolerance=0.0001):
+    def SymDif(topologyA, topologyB, tranDict: bool = False, tolerance: float = 0.0001, silent: bool = False):
         """
         See Topology.Boolean().
 
         """
-        return Topology.Boolean(topologyA=topologyA, topologyB=topologyB, operation="symdif", tranDict=tranDict, tolerance=tolerance)
+        return Topology.Boolean(topologyA=topologyA, topologyB=topologyB, operation="symdif", tranDict=tranDict, tolerance=tolerance, silent=silent)
     
     @staticmethod
-    def XOR(topologyA, topologyB, tranDict=False, tolerance=0.0001):
+    def XOR(topologyA, topologyB, tranDict: bool = False, tolerance: float = 0.0001, silent: bool = False):
         """
         See Topology.Boolean().
 
         """
-        return Topology.Boolean(topologyA=topologyA, topologyB=topologyB, operation="symdif", tranDict=tranDict, tolerance=tolerance)
+        return Topology.Boolean(topologyA=topologyA, topologyB=topologyB, operation="symdif", tranDict=tranDict, tolerance=tolerance, silent=silent)
     
     @staticmethod
-    def Merge(topologyA, topologyB, tranDict=False, tolerance=0.0001):
+    def Merge(topologyA, topologyB, tranDict: bool = False, tolerance: float = 0.0001, silent: bool = False):
         """
         See Topology.Boolean().
 
         """
-        return Topology.Boolean(topologyA=topologyA, topologyB=topologyB, operation="merge", tranDict=tranDict, tolerance=tolerance)
+        return Topology.Boolean(topologyA=topologyA, topologyB=topologyB, operation="merge", tranDict=tranDict, tolerance=tolerance, silent=silent)
     
     @staticmethod
-    def Slice(topologyA, topologyB, tranDict=False, tolerance=0.0001):
+    def Slice(topologyA, topologyB, tranDict: bool = False, tolerance: float = 0.0001, silent: bool = False):
         """
         See Topology.Boolean().
 
         """
-        return Topology.Boolean(topologyA=topologyA, topologyB=topologyB, operation="slice", tranDict=tranDict, tolerance=tolerance)
+        return Topology.Boolean(topologyA=topologyA, topologyB=topologyB, operation="slice", tranDict=tranDict, tolerance=tolerance, silent=silent)
     
     @staticmethod
-    def Impose(topologyA, topologyB, tranDict=False, tolerance=0.0001):
+    def Impose(topologyA, topologyB, tranDict: bool = False, tolerance: float = 0.0001, silent: bool = False):
         """
         See Topology.Boolean().
 
         """
-        return Topology.Boolean(topologyA=topologyA, topologyB=topologyB, operation="impose", tranDict=tranDict, tolerance=tolerance)
+        return Topology.Boolean(topologyA=topologyA, topologyB=topologyB, operation="impose", tranDict=tranDict, tolerance=tolerance, silent=silent)
     
     @staticmethod
-    def Imprint(topologyA, topologyB, tranDict=False, tolerance=0.0001):
+    def Imprint(topologyA, topologyB, tranDict: bool = False, tolerance: float = 0.0001, silent: bool = False):
         """
         See Topology.Boolean().
 
         """
-        return Topology.Boolean(topologyA=topologyA, topologyB=topologyB, operation="imprint", tranDict=tranDict, tolerance=tolerance)
+        return Topology.Boolean(topologyA=topologyA, topologyB=topologyB, operation="imprint", tranDict=tranDict, tolerance=tolerance, silent=silent)
     
     @staticmethod
-    def Boolean(topologyA, topologyB, operation="union", tranDict=False, tolerance=0.0001):
+    def Boolean(topologyA, topologyB, operation: str = "union", tranDict: bool = False, tolerance: float = 0.0001, silent: bool = False):
         """
         Execute the input boolean operation type on the input operand topologies and return the result. See https://en.wikipedia.org/wiki/Boolean_operation.
 
@@ -1078,6 +1078,8 @@ class Topology():
             If set to True the dictionaries of the operands are merged and transferred to the result. The default is False.
         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
         -------
@@ -1087,23 +1089,26 @@ class Topology():
         """
         from topologicpy.Dictionary import Dictionary
         if not Topology.IsInstance(topologyA, "Topology"):
-            print("Topology.Boolean - Error: the input topologyA parameter is not a valid topology. Returning None.")
+            if not silent:
+                print("Topology.Boolean - Error: the input topologyA parameter is not a valid topology. Returning None.")
             return None
         if not Topology.IsInstance(topologyB, "Topology"):
-            print("Topology.Boolean - Error: the input topologyB parameter is not a valid topology. Returning None.")
+            if not silent:
+                print("Topology.Boolean - Error: the input topologyB parameter is not a valid topology. Returning None.")
             return None
         if not isinstance(operation, str):
-            print("Topology.Boolean - Error: the input operation parameter is not a valid string. Returning None.")
+            if not silent:
+                print("Topology.Boolean - Error: the input operation parameter is not a valid string. Returning None.")
             return None
         if not operation.lower() in ["union", "difference", "intersect", "symdif", "merge", "slice", "impose", "imprint"]:
-            print("Topology.Boolean - Error: the input operation parameter is not a recognized operation. Returning None.")
+            if not silent:
+                print("Topology.Boolean - Error: the input operation parameter is not a recognized operation. Returning None.")
             return None
         if not isinstance(tranDict, bool):
-            print("Topology.Boolean - Error: the input tranDict parameter is not a valid boolean. Returning None.")
+            if not silent:
+                print("Topology.Boolean - Error: the input tranDict parameter is not a valid boolean. Returning None.")
             return None
         topologyC = None
-        #topologyC = Topology.Intersect(topologyA, topologyB)
-        #try:
         if operation.lower() == "union":
             topologyC = topologyA.Union(topologyB, False)
         elif operation.lower() == "difference":

topologicpy/Vector.py

@@ -1,4 +1,4 @@
-# Copyright (C) 2024
+# Copyright (C) 2025
 # Wassim Jabi <wassim.jabi@gmail.com>
 #
 # This program is free software: you can redistribute it and/or modify it under

topologicpy/Vertex.py

@@ -1,4 +1,4 @@
-# Copyright (C) 2024
+# Copyright (C) 2025
 # Wassim Jabi <wassim.jabi@gmail.com>
 #
 # This program is free software: you can redistribute it and/or modify it under

topologicpy/Wire.py

@@ -1,4 +1,4 @@
-# Copyright (C) 2024
+# Copyright (C) 2025
 # Wassim Jabi <wassim.jabi@gmail.com>
 #
 # This program is free software: you can redistribute it and/or modify it under

topologicpy/__init__.py

@@ -1,4 +1,4 @@
-# Copyright (C) 2024
+# Copyright (C) 2025
 # Wassim Jabi <wassim.jabi@gmail.com>
 #
 # This program is free software: you can redistribute it and/or modify it under

topologicpy/version.py

@@ -1 +1 @@
-__version__ = '0.8.21'
+__version__ = '0.8.23'

{topologicpy-0.8.21.dist-info → topologicpy-0.8.23.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: topologicpy
-Version: 0.8.21
+Version: 0.8.23
 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.23.dist-info/RECORD

@@ -0,0 +1,37 @@
+topologicpy/ANN.py,sha256=DrNAhNHp-jSvsPc1fb7KVPU46cYmejAvghhknOM430Y,47932
+topologicpy/Aperture.py,sha256=wNn5miB_IrGCBYuQ18HXQYRva20dUC3id4AJCulL7to,2723
+topologicpy/BVH.py,sha256=PAezG_P_W5_FUjUGB-HRRb4bzesE9DW89G2Vm-6ChWw,12932
+topologicpy/CSG.py,sha256=6vawdxs0_r7i9ElnwDO1Mouv_yPOTBr_4IhBnfVsBHk,15680
+topologicpy/Cell.py,sha256=F8ifMa-3NI5GYRx86J0cokgdoLduBiaw5DIKQFMHtCs,119904
+topologicpy/CellComplex.py,sha256=5O15NirkK2M1AvNcq9Z8N5lNb-hD9kGNXIJXWJJuj7k,59931
+topologicpy/Cluster.py,sha256=BSaLcHe4TinFTIwjFo4660rPX2y9Lqly2hv48WCq6fE,58606
+topologicpy/Color.py,sha256=ZVVQRKGjebY9aOU1gpN_AbssdRRiVKlZV3f8TrsTNgg,20307
+topologicpy/Context.py,sha256=G3CwMvN8Jw2rnQRwB-n4MaQq_wLS0vPimbXKwsdMJ80,3055
+topologicpy/DGL.py,sha256=HQXy9iDnrvWGDxaBfe5pRbweQ2zLBvAf6UdjfhKkQYI,139041
+topologicpy/Dictionary.py,sha256=Lf24WHW8q_RCq0l8VpT3XJTn6UuStY66JI4Lb4W08jI,34126
+topologicpy/Edge.py,sha256=pu4tZbRbK8qx2oqRbwHAeKuwU2X8JFGPSJjJMTJw8Q0,71418
+topologicpy/EnergyModel.py,sha256=Pyb28gDDwhzlQIH0xqAygqS0P3SJxWyyV7OWS_AAfRs,53856
+topologicpy/Face.py,sha256=7K46gB_UIKjKEKyzyY0JqGarqjwjH0ggS-JQTpDtWC4,184847
+topologicpy/Graph.py,sha256=29oDBceDUoZVbwZ4ajBJWfQD4JIPYGUgDeEqmm7CBX0,527640
+topologicpy/Grid.py,sha256=qRnFUvs079zMOZ6COWzBX6408niI7HyNz-BM0VRguXY,18245
+topologicpy/Helper.py,sha256=JdvC30WMrla46mTj5TdwCV_bRv-6y8vK5Bkx0prluy4,29100
+topologicpy/Honeybee.py,sha256=yctkwfdupKnp7bAOjP1Z4YaYpRrWoMEb4gz9Z5zaWwE,21751
+topologicpy/Matrix.py,sha256=BHGDRkBn1pf5DkRoY8feAhDGHTF3bjFM4jluiEb_A0w,22779
+topologicpy/Neo4j.py,sha256=vNMaqTWerwr-3luLjYEXNhf8T97aFee6x5sIKBHY73s,22392
+topologicpy/Plotly.py,sha256=eHTKT8vOHJDLwH4xypj52atGLR0dGic45d-BiPA55Q8,119219
+topologicpy/Polyskel.py,sha256=oVfM4lqSMPTjnkHfsRU9VI8Blt6Vf0LVPkD9ebz7Wmw,27082
+topologicpy/PyG.py,sha256=zvV6jtnol_aFiN6JRoMpYwBVfOU2aFs9gdWSdEo6mtU,109757
+topologicpy/Shell.py,sha256=3zUSf0VfkAF73ZyTYNWYW21x4-vyfi7JkYu_r5GTVIc,87983
+topologicpy/Speckle.py,sha256=-eiTqJugd7pHiHpD3pDUcDO6CGhVyPV14HFRzaqEoaw,18187
+topologicpy/Sun.py,sha256=_VBBAUIDhvpkp72JBZlv7k9qx9jYubm3yM56UZ1Nc6c,36837
+topologicpy/Topology.py,sha256=BKiVJ-R5FfwXJ2FYp1V8pjaPoMxRm83MGe2RzBx0_tQ,479205
+topologicpy/Vector.py,sha256=mx7fgABdioikPWM9HzXKzmqfx3u_XBcU_jlLD4qK2x8,42407
+topologicpy/Vertex.py,sha256=PIwfbA7_TxK_dSGlSeM5mson97TRr4dYrfZyOLgO150,80913
+topologicpy/Wire.py,sha256=eRs4PM7h4yU5v6umPh0oBJR4cN8BwsqlVroaFdnvK4w,228499
+topologicpy/__init__.py,sha256=RMftibjgAnHB1vdL-muo71RwMS4972JCxHuRHOlU428,928
+topologicpy/version.py,sha256=x1ObPzSnRGxtlZbyDdxO7Th6BX-tC0y4aFEdmCRhvqg,23
+topologicpy-0.8.23.dist-info/licenses/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
+topologicpy-0.8.23.dist-info/METADATA,sha256=vQCjkz3HxMfw9u7K87Q8eiY5cvWggKY1QuZWIgm8fBE,10535
+topologicpy-0.8.23.dist-info/WHEEL,sha256=wXxTzcEDnjrTwFYjLPcsW_7_XihufBwmpiBeiXNBGEA,91
+topologicpy-0.8.23.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
+topologicpy-0.8.23.dist-info/RECORD,,

{topologicpy-0.8.21.dist-info → topologicpy-0.8.23.dist-info}/WHEEL

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

topologicpy-0.8.21.dist-info/RECORD

@@ -1,36 +0,0 @@
-topologicpy/ANN.py,sha256=m_WxD1lgQqDhUpaM20Lia6TmJACDYaAE96wigsi-99U,47932
-topologicpy/Aperture.py,sha256=p9pUzTQSBWoUaDiug1V1R1hnEIEwYSXFg2t7iRAmNRY,2723
-topologicpy/BVH.py,sha256=1q2lR5eDs7Wnwv7M-Kr7Cj3GG_iy7d1ddaZqWGHdX-w,12932
-topologicpy/Cell.py,sha256=BN6hjYpN6Fse0mn7d7oHh65D7c6Mt1Yu7iK3lEp_Cj0,118262
-topologicpy/CellComplex.py,sha256=udDzbMub3d2QYn1XGMzt3F9Su2VXuAGvn0eoTtOIn3g,58207
-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/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=Iq2UI-CdW3usxpgxRi-caxQeUmkFfGhD37c6mPT2Gd8,523908
-topologicpy/Grid.py,sha256=2s9cSlWldivn1i9EUz4OOokJyANveqmRe_vR93CAndI,18245
-topologicpy/Helper.py,sha256=4H5KPiv_eiEs489UOOyGLe9RaeoZIfmMh3mk_YCHmXg,29100
-topologicpy/Honeybee.py,sha256=uDVtDbloydNoaBFcSNukKL_2PLyD6XKkCp1VHz1jtaU,21751
-topologicpy/Matrix.py,sha256=i22RLP5ebUAMuU7V1tZ__Z4lf1pg9fzq9nENsDZUV74,22779
-topologicpy/Neo4j.py,sha256=BKOF29fRgXmdpMGkrNzuYbyqgCJ6ElPPMYlfTxXiVbc,22392
-topologicpy/Plotly.py,sha256=gSe3tWLgF75-rPDjqw7riUIJpv0j_K7hedoxi3-OptE,119244
-topologicpy/Polyskel.py,sha256=ro5in--VT_uag55r5xymU5ufyAahsovIiJwyiqG_qH8,27082
-topologicpy/PyG.py,sha256=LU9LCCzjxGPUM31qbaJXZsTvniTtgugxJY7y612t4A4,109757
-topologicpy/Shell.py,sha256=--dJoSdz6BapxVEyG2DI0W5apO_xwLORj5qmR15yl2Y,87983
-topologicpy/Speckle.py,sha256=AlsGlSDuKRtX5jhVsPNSSjjbZis079HbUchDH_5RJmE,18187
-topologicpy/Sun.py,sha256=42tDWMYpwRG7Z2Qjtp94eRgBuqySq7k8TgNUZDK7QxQ,36837
-topologicpy/Topology.py,sha256=QY195KZ5EostlGRnsPGSFglRIU0tunD2CiwsFPfpOqY,478447
-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=zZ7tNz8qiJpD43ZZY6gDLsQEo04V3AXFbZKZwwi4Pww,23
-topologicpy-0.8.21.dist-info/licenses/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
-topologicpy-0.8.21.dist-info/METADATA,sha256=uin9-ogEkyhyjro0BGZPrFB4abynjZPuv7G3lTk6XzA,10535
-topologicpy-0.8.21.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-topologicpy-0.8.21.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
-topologicpy-0.8.21.dist-info/RECORD,,