topologicpy 0.8.44__py3-none-any.whl → 0.8.46__py3-none-any.whl

topologicpy/Graph.py

@@ -4575,6 +4575,56 @@ class Graph:
         edges = [e for e in edges if Topology.IsInstance(e, "Edge")]
         return topologic.Graph.ByVerticesEdges(vertices, edges) # Hook to Core
     
+    @staticmethod
+    def Choice(graph, method: str = "vertex", weightKey="length", normalize: bool = False, nxCompatible: bool = False, key: str = "choice", colorKey="ch_color", colorScale="viridis", mantissa: int = 6, tolerance: float = 0.001, silent: bool = False):
+        """
+            This is an alias method for Graph.BetweenessCentrality. Returns the choice (Betweeness Centrality) of the input graph. The order of the returned list is the same as the order of vertices/edges. See https://en.wikipedia.org/wiki/Betweenness_centrality.
+
+        Parameters
+        ----------
+        graph : topologic_core.Graph
+            The input graph.
+        method : str , optional
+            The method of computing the betweenness centrality. The options are "vertex" or "edge". The default is "vertex".
+        weightKey : str , optional
+            If specified, the value in the connected edges' dictionary specified by the weightKey string will be aggregated to calculate
+            the shortest path. If a numeric value cannot be retrieved from an edge, a value of 1 is used instead.
+            This is used in weighted graphs. if weightKey is set to "Length" or "Distance", the length of the edge will be used as its weight.
+        normalize : bool , optional
+            If set to True, the values are normalized to be in the range 0 to 1. Otherwise they are not. The default is False.
+        nxCompatible : bool , optional
+            If set to True, and normalize input parameter is also set to True, the values are set to be identical to NetworkX values. Otherwise, they are normalized between 0 and 1. The default is False.
+        key : str , optional
+            The desired dictionary key under which to store the betweenness centrality score. The default is "betweenness_centrality".
+        colorKey : str , optional
+            The desired dictionary key under which to store the betweenness centrality color. The default is "betweenness_centrality".
+        colorScale : str , optional
+            The desired type of plotly color scales to use (e.g. "viridis", "plasma"). The default is "viridis". For a full list of names, see https://plotly.com/python/builtin-colorscales/.
+            In addition to these, three color-blind friendly scales are included. These are "protanopia", "deuteranopia", and "tritanopia" for red, green, and blue colorblindness respectively.
+        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 choice (betweenness centrality) of the input list of vertices within the input graph. The values are in the range 0 to 1.
+
+        """
+        return Graph.BetweennessCentrality(graph,
+                                           method=method,
+                                           weightKey=weightKey,
+                                           normalize=normalize,
+                                           nxCompatible=nxCompatible,
+                                           key=key,
+                                           colorKey=colorKey,
+                                           colorScale=colorScale,
+                                           mantissa=mantissa,
+                                           tolerance=tolerance,
+                                           silent=silent)
+
+
     @staticmethod
     def ChromaticNumber(graph, maxColors: int = 3, silent: bool = False):
         """
@@ -4750,7 +4800,8 @@ class Graph:
                 weightJaccard: float = 0.0,
                 vertexIDKey: str = "id",
                 edgeWeightKey: str = None,
-                iterations: int = 3,
+                vertexKey: str = None,
+                iterations: int = 2,
                 mantissa: int = 6,
                 silent: bool = False):
         """
@@ -4797,8 +4848,10 @@ class Graph:
             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.
+        vertexKey: str , optional
+            The vertex key to use for the Weifeiler-Lehman initial labels. The default is None which means it will use vertex degree as an initial label.
         iterations : int , optional
-            The desired number of Weisfeiler-Lehman iterations. Default is 3.
+            The desired number of Weisfeiler-Lehman kernel iterations. Default is 2.
         mantissa : int , optional
             The desired length of the mantissa. The default is 6.
         silent : bool , optional
@@ -4885,7 +4938,7 @@ class Graph:
                 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.
+                The desired number of Weisfeiler-Lehman iterations. Default is 2.
             mantissa : int , optional
                 The desired length of the mantissa. The default is 6.
 
@@ -5012,39 +5065,9 @@ class Graph:
 
             return round((vertex_score + edge_score) / 2, mantissa)
 
-        def weisfeiler_lehman_fingerprint(graph, iterations=3):
-            vertices = Graph.Vertices(graph)
-            labels = {}
-
-            for v in vertices:
-                d = Topology.Dictionary(v)
-                label = str(Dictionary.ValueAtKey(d, "label")) if d and Dictionary.ValueAtKey(d, "label") else "0"
-                labels[v] = label
-
-            all_label_counts = Counter()
-
-            for _ in range(iterations):
-                new_labels = {}
-                for v in vertices:
-                    neighbors = Graph.AdjacentVertices(graph, v)
-                    neighbor_labels = sorted(labels.get(n, "0") for n in neighbors)
-                    long_label = labels[v] + "_" + "_".join(neighbor_labels)
-                    hashed_label = hashlib.md5(long_label.encode()).hexdigest()
-                    new_labels[v] = hashed_label
-                    all_label_counts[hashed_label] += 1
-                labels = new_labels
-
-            return all_label_counts
-
-        def weisfeiler_lehman_similarity(graphA, graphB, iterations=3, mantissa=6):
-            f1 = weisfeiler_lehman_fingerprint(graphA, iterations)
-            f2 = weisfeiler_lehman_fingerprint(graphB, iterations)
-
-            common_labels = set(f1.keys()) & set(f2.keys())
-            score = sum(min(f1[label], f2[label]) for label in common_labels)
-            norm = max(sum(f1.values()), sum(f2.values()), 1)
-
-            return round(score / norm, mantissa)
+        def weisfeiler_lehman_similarity(graphA, graphB, key=None, iterations=3, mantissa=6):
+            score = Graph.WLKernel(graphA, graphB, key=key, iterations=iterations, normalize=True, mantissa=mantissa)
+            return score
         
         if not Topology.IsInstance(graphA, "graph"):
             if not silent:
@@ -5080,7 +5103,7 @@ class Graph:
         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
-        weisfeiler_lehman_score = weisfeiler_lehman_similarity(graphA, graphB, iterations, mantissa=mantissa) if weightWeisfeilerLehman else 0
+        weisfeiler_lehman_score = weisfeiler_lehman_similarity(graphA, graphB, key=vertexKey, iterations=iterations, mantissa=mantissa) if weightWeisfeilerLehman else 0
 
         weighted_sum = (
             accessibility_centrality_score * weightAccessibilityCentrality +
@@ -5427,94 +5450,159 @@ class Graph:
         graph = Graph.RemoveVertex(graph,ev, tolerance=tolerance)
         return graph
     
+
     @staticmethod
-    def ClosenessCentrality(graph, weightKey="length", normalize: bool = False, nxCompatible: bool = True, key: str = "closeness_centrality", colorKey="cc_color", colorScale="viridis", mantissa: int = 6, tolerance: float = 0.001, silent: bool = False):
+    def ClosenessCentrality(
+        graph,
+        weightKey: str = "length",
+        normalize: bool = False,
+        nxCompatible: bool = True,
+        key: str = "closeness_centrality",
+        colorKey: str = "cc_color",
+        colorScale: str = "viridis",
+        mantissa: int = 6,
+        tolerance: float = 0.0001,
+        silent: bool = False
+    ):
         """
-            Returns the closeness centrality of the input graph. The order of the returned list is the same as the order of vertices/edges. See https://en.wikipedia.org/wiki/Betweenness_centrality.
+        Returns the closeness centrality of the input graph. The order of the returned
+        list matches the order of Graph.Vertices(graph).
+        See: https://en.wikipedia.org/wiki/Closeness_centrality
 
         Parameters
         ----------
         graph : topologic_core.Graph
             The input graph.
         weightKey : str , optional
-            If specified, the value in the connected edges' dictionary specified by the weightKey string will be aggregated to calculate
-            the shortest path. If a numeric value cannot be retrieved from an edge, a value of 1 is used instead.
-            This is used in weighted graphs. if weightKey is set to "Length" or "Distance", the length of the edge will be used as its weight.
+            If specified, this edge attribute will be used as the distance weight when
+            computing shortest paths. If set to a name containing "Length" or "Distance",
+            it will be mapped to "length".
+            Note: Graph.NetworkXGraph automatically provides a "length" attribute on all edges.
         normalize : bool , optional
-            If set to True, the values are normalized to be in the range 0 to 1. Otherwise they are not. The default is False.
+            If True, the returned values are rescaled to [0, 1]. Otherwise raw values
+            from NetworkX (optionally using the improved formula) are returned.
         nxCompatible : bool , optional
-            If set to True, use networkX to scale by the fraction of nodes reachable. This gives the Wasserman and Faust improved formula.
-            For single component graphs it is the same as the original formula.
+            If True, use NetworkX's wf_improved scaling (Wasserman and Faust).
+            For single-component graphs it matches the original formula.
         key : str , optional
-            The desired dictionary key under which to store the closeness centrality score. The default is "closeness_centrality".
+            The dictionary key under which to store the closeness centrality score.
         colorKey : str , optional
-            The desired dictionary key under which to store the closeness centrality color. The default is "cc_color".
+            The dictionary key under which to store a color derived from the score.
         colorScale : str , optional
-            The desired type of plotly color scales to use (e.g. "viridis", "plasma"). The default is "viridis". For a full list of names, see https://plotly.com/python/builtin-colorscales/.
-            In addition to these, three color-blind friendly scales are included. These are "protanopia", "deuteranopia", and "tritanopia" for red, green, and blue colorblindness respectively.
+            Plotly color scale name (e.g., "viridis", "plasma").
         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, error and warning messages are suppressed. The default is False.
 
         Returns
         -------
-        list
-            The closeness centrality of the input list of vertices within the input graph. The values are in the range 0 to 1.
-
+        list[float]
+            Closeness centrality values for vertices in the same order as Graph.Vertices(graph).
         """
         import warnings
-
         try:
             import networkx as nx
-        except:
-            print("Graph.ClosenessCentrality - Information: Installing required networkx library.")
-            try:
-                os.system("pip install networkx")
-            except:
-                os.system("pip install networkx --user")
-            try:
-                import networkx as nx
-                print("Graph.ClosenessCentrality - Infromation: networkx library installed correctly.")
-            except:
-                warnings.warn("Graph.ClosenessCentrality - Error: Could not import networkx. Please try to install networkx manually. Returning None.")
-                return None
-        
+        except Exception as e:
+            warnings.warn(
+                f"Graph.ClosenessCentrality - Error: networkx is required but not installed ({e}). Returning None."
+            )
+            return None
+
         from topologicpy.Dictionary import Dictionary
         from topologicpy.Color import Color
         from topologicpy.Topology import Topology
         from topologicpy.Helper import Helper
 
+        # Topology.IsInstance is case-insensitive, so a single call is sufficient.
         if not Topology.IsInstance(graph, "graph"):
             if not silent:
-                print("Graph.ClosenessCentrality - Error: The input graph is not a valid graph. Returning None.")
+                print("Graph.ClosenessCentrality - Error: The input is not a valid Graph. Returning None.")
             return None
-        
-        if weightKey:
-            if "len" in weightKey.lower() or "dis" in weightKey.lower():
+        vertices = Graph.Vertices(graph)
+        if len(vertices) == 0:
+            if not silent:
+                print("Graph.ClosenessCentrality - Warning: Graph has no vertices. Returning [].")
+            return []
+
+        # Normalize the weight key semantics
+        distance_attr = None
+        if isinstance(weightKey, str) and weightKey:
+            if ("len" in weightKey.lower()) or ("dis" in weightKey.lower()):
                 weightKey = "length"
+            distance_attr = weightKey
+
+        # Build the NX graph
         nx_graph = Graph.NetworkXGraph(graph)
-        vertices = Graph.Vertices(graph)
-        vertices_dict = nx.closeness_centrality(nx_graph, distance=weightKey, wf_improved=nxCompatible)
-        values = [round(v, mantissa) for v in list(vertices_dict.values())]
-        if normalize == True:
-            if mantissa > 0: # We cannot round numbers from 0 to 1 with a mantissa = 0.
-                values = [round(v, mantissa) for v in Helper.Normalize(values)]
+
+        # Graph.NetworkXGraph automatically adds "length" to all edges.
+        # So if distance_attr == "length", we trust it and skip per-edge checks.
+        if distance_attr and distance_attr != "length":
+            # For any non-"length" custom attribute, verify presence; else fall back unweighted.
+            attr_missing = any(
+                (distance_attr not in data) or (data[distance_attr] is None)
+                for _, _, data in nx_graph.edges(data=True)
+            )
+            if attr_missing:
+                if not silent:
+                    print("Graph.ClosenessCentrality - Warning: The specified edge attribute was not found on all edges. Falling back to unweighted closeness.")
+                distance_arg = None
             else:
-                values = Helper.Normalize(values)
-            min_value = 0
-            max_value = 1
+                distance_arg = distance_attr
         else:
-            min_value = min(values)
-            max_value = max(values)
+            # Use "length" directly or unweighted if distance_attr is falsy.
+            distance_arg = distance_attr if distance_attr else None
 
-        for i, value in enumerate(values):
+        # Compute centrality (dict keyed by NetworkX nodes)
+        try:
+            cc_dict = nx.closeness_centrality(nx_graph, distance=distance_arg, wf_improved=nxCompatible)
+        except Exception as e:
+            if not silent:
+                print(f"Graph.ClosenessCentrality - Error: NetworkX failed to compute centrality ({e}). Returning None.")
+            return None
+
+        # NetworkX vertex ids are in the same numerice order as the list of vertices starting from 0.
+        raw_values = []
+        for i, v in enumerate(vertices):
+            try:
+                raw_values.append(float(cc_dict.get(i, 0.0)))
+            except Exception:
+                if not silent:
+                    print(f,"Graph.ClosenessCentrality - Warning: Could not retrieve score for vertex {i}. Assigning a Zero (0).")
+                raw_values.append(0.0)
+
+        # Optional normalization ONLY once, then rounding once at the end
+        values_for_return = Helper.Normalize(raw_values) if normalize else raw_values
+
+        # Values for color scaling should reflect the displayed numbers
+        color_values = values_for_return
+
+        # Single rounding at the end for return values
+        if mantissa is not None and mantissa >= 0:
+            values_for_return = [round(v, mantissa) for v in values_for_return]
+
+        # Prepare color mapping range, guarding equal-range case
+        if color_values:
+            min_value = min(color_values)
+            max_value = max(color_values)
+        else:
+            min_value, max_value = 0.0, 1.0
+
+        if abs(max_value - min_value) < tolerance:
+            max_value = min_value + tolerance
+
+        # Annotate vertices with score and color
+        for i, value in enumerate(color_values):
             d = Topology.Dictionary(vertices[i])
-            color = Color.AnyToHex(Color.ByValueInRange(value, minValue=min_value, maxValue=max_value, colorScale=colorScale))
-            d = Dictionary.SetValuesAtKeys(d, [key, colorKey], [value, color])
+            color_hex = Color.AnyToHex(
+                Color.ByValueInRange(value, minValue=min_value, maxValue=max_value, colorScale=colorScale)
+            )
+            d = Dictionary.SetValuesAtKeys(d, [key, colorKey], [values_for_return[i], color_hex])
             vertices[i] = Topology.SetDictionary(vertices[i], d)
 
-        return values
+        return values_for_return
 
     @staticmethod
     def Community(graph, key: str = "partition", mantissa: int = 6, tolerance: float = 0.0001, silent: bool = False):
@@ -5684,7 +5772,7 @@ class Graph:
     @staticmethod
     def Connectivity(graph, vertices=None, weightKey: str = None, normalize: bool = False, key: str = "connectivity", colorKey: str = "cn_color", colorScale="Viridis", mantissa: int = 6, tolerance = 0.0001, silent = False):
         """
-        Return the connectivity 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 connectivity of all the vertices in the input graph is computed. See https://www.spacesyntax.online/term/connectivity/.
+        This is an alias method for Graph.DegreeCentrality. Return the connectivity 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 connectivity of all the vertices in the input graph is computed. See https://www.spacesyntax.online/term/connectivity/.
 
         Parameters
         ----------
@@ -5718,38 +5806,17 @@ class Graph:
             The connectivity score of the input list of vertices within the input graph. The values are in the range 0 to 1 if normalized.
 
         """
-        
-        from topologicpy.Topology import Topology
-        from topologicpy.Dictionary import Dictionary
-        from topologicpy.Helper import Helper
-        from topologicpy.Color import Color
-
-        if not Topology.IsInstance(graph, "Graph"):
-            if not silent:
-                print("Graph.Connectivity - Error: The input graph is not a valid graph. Returning None.")
-            return None
-        if vertices == None:
-            vertices = Graph.Vertices(graph)
-        values = [Graph.VertexDegree(graph, v, weightKey=weightKey, mantissa=mantissa, tolerance=tolerance, silent=silent) for v in vertices]
-        values = [round(v, mantissa) for v in values]
-        if normalize == True:
-            if mantissa > 0:
-                values = [round(v, mantissa) for v in Helper.Normalize(values)]
-            else:
-                values = Helper.Normalize(values)
-            min_value = 0
-            max_value = 1
-        else:
-            min_value = min(values)
-            max_value = max(values)
+        return Graph.DegreeCentrality(graph=graph,
+                                      vertices=vertices,
+                                      weightKey=weightKey,
+                                      normalize=normalize,
+                                      key="connectivity",
+                                      colorKey=colorKey,
+                                      colorScale=colorScale,
+                                      mantissa=mantissa,
+                                      tolerance=tolerance,
+                                      silent=silent)
 
-        for i, value in enumerate(values):
-            color = Color.AnyToHex(Color.ByValueInRange(value, minValue=min_value, maxValue=max_value, colorScale=colorScale))
-            d = Topology.Dictionary(vertices[i])
-            d = Dictionary.SetValuesAtKeys(d, [key, colorKey], [value, color])
-            v = Topology.SetDictionary(vertices[i], d)
-        return values
-    
     @staticmethod
     def ContainsEdge(graph, edge, tolerance=0.0001):
         """
@@ -5884,7 +5951,7 @@ class Graph:
                          tolerance: float = 0.001,
                          silent: bool = False):
         """
-            Returns the degree centrality of the input graph. The order of the returned list is the same as the order of vertices. See https://en.wikipedia.org/wiki/Degree_centrality.
+        Returns the degree centrality of the input graph. The order of the returned list is the same as the order of vertices. See https://en.wikipedia.org/wiki/Degree_centrality.
 
         Parameters
         ----------
@@ -5911,30 +5978,42 @@ class Graph:
         Returns
         -------
         list
-            The betweenness centrality of the input list of vertices within the input graph. The values are in the range 0 to 1.
+            The degree centrality of the input list of vertices within the input graph. The values are in the range 0 to 1.
 
         """
         
-        from topologicpy.Dictionary import Dictionary
-        from topologicpy.Color import Color
         from topologicpy.Topology import Topology
+        from topologicpy.Dictionary import Dictionary
         from topologicpy.Helper import Helper
+        from topologicpy.Color import Color
 
-        if not Topology.IsInstance(graph, "graph"):
+        if not Topology.IsInstance(graph, "Graph"):
             if not silent:
                 print("Graph.DegreeCentrality - Error: The input graph is not a valid graph. Returning None.")
             return None
+        if vertices == None:
+            vertices = Graph.Vertices(graph)
+        values = [Graph.VertexDegree(graph, v, weightKey=weightKey, mantissa=mantissa, tolerance=tolerance, silent=silent) for v in vertices]
+        if normalize == True:
+            if mantissa > 0:
+                values = [round(v, mantissa) for v in Helper.Normalize(values)]
+            else:
+                values = Helper.Normalize(values)
+            min_value = 0
+            max_value = 1
+        else:
+            min_value = min(values)
+            max_value = max(values)
+        
+        if abs(max_value - min_value) < tolerance:
+            max_value = min_value + tolerance
 
-        return Graph.Connectivity(graph,
-                                  vertices=vertices,
-                                  weightKey=weightKey,
-                                  normalize=normalize,
-                                  key=key,
-                                  colorKey=colorKey,
-                                  colorScale=colorScale,
-                                  mantissa=mantissa,
-                                  tolerance=tolerance,
-                                  silent=silent)
+        for i, value in enumerate(values):
+            color = Color.AnyToHex(Color.ByValueInRange(value, minValue=min_value, maxValue=max_value, colorScale=colorScale))
+            d = Topology.Dictionary(vertices[i])
+            d = Dictionary.SetValuesAtKeys(d, [key, colorKey], [value, color])
+            v = Topology.SetDictionary(vertices[i], d)
+        return values
     
     @staticmethod
     def DegreeMatrix(graph):
@@ -9442,6 +9521,70 @@ class Graph:
             incoming_vertices.append(Graph.NearestVertex(graph, sv))
         return incoming_vertices
     
+    @staticmethod
+    def Integration(
+        graph,
+        weightKey: str = "length",
+        normalize: bool = False,
+        nxCompatible: bool = True,
+        key: str = "integration",
+        colorKey: str = "in_color",
+        colorScale: str = "viridis",
+        mantissa: int = 6,
+        tolerance: float = 0.0001,
+        silent: bool = False
+    ):
+        """
+        This is an alias method for Graph.ClosenessCentrality. Returns the integration (closeness centrality) of the input graph. The order of the returned
+        list matches the order of Graph.Vertices(graph).
+        See: https://en.wikipedia.org/wiki/Closeness_centrality
+
+        Parameters
+        ----------
+        graph : topologic_core.Graph
+            The input graph.
+        weightKey : str , optional
+            If specified, this edge attribute will be used as the distance weight when
+            computing shortest paths. If set to a name containing "Length" or "Distance",
+            it will be mapped to "length".
+            Note: Graph.NetworkXGraph automatically provides a "length" attribute on all edges.
+        normalize : bool , optional
+            If True, the returned values are rescaled to [0, 1]. Otherwise raw values
+            from NetworkX (optionally using the improved formula) are returned.
+        nxCompatible : bool , optional
+            If True, use NetworkX's wf_improved scaling (Wasserman and Faust).
+            For single-component graphs it matches the original formula.
+        key : str , optional
+            The dictionary key under which to store the closeness centrality score.
+        colorKey : str , optional
+            The dictionary key under which to store a color derived from the score.
+        colorScale : str , optional
+            Plotly color scale name (e.g., "viridis", "plasma").
+        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, error and warning messages are suppressed. The default is False.
+
+        Returns
+        -------
+        list[float]
+            Integration (closeness centrality) values for vertices in the same order as Graph.Vertices(graph).
+        """
+        return Graph.ClosenessCentrality(
+        graph,
+        weightKey=weightKey,
+        normalize=normalize,
+        nxCompatible=nxCompatible,
+        key=key,
+        colorKey=colorKey,
+        colorScale=colorScale,
+        mantissa=mantissa,
+        tolerance=tolerance,
+        silent=silent
+        )
+    
     @staticmethod
     def IsBipartite(graph, tolerance=0.0001):
         """
@@ -13749,6 +13892,171 @@ class Graph:
         diffBA = Graph.Difference(graphB, graphA, vertexKeys=vertexKeys, useCentroid=useCentroid, tolerance=tolerance, silent=True)
         return Graph.Union(diffAB, diffBA, vertexKeys=vertexKeys, useCentroid=useCentroid, tolerance=tolerance, silent=True)
     
+    @staticmethod
+    def WLFeatures(graph, key: str = None, iterations: int = 2, silent: bool = False):
+        """
+        Returns a Weisfeiler-Lehman subtree features for a Graph. See https://en.wikipedia.org/wiki/Weisfeiler_Leman_graph_isomorphism_test
+
+        Parameters
+        ----------
+        graph : topologic_core.Graph
+            The  input graph.
+        key : str , optional
+            The vertex key to use as an initial label. The default is None which means the vertex degree is used instead.
+        iterations : int , optional
+            The desired number of WL iterations. (non-negative int). The default is 2.
+        silent : bool, optional
+            If set to True, error and warning messages are suppressed. Default is False.
+        
+        Returns
+        -------
+        dict
+            {feature_id: count} where feature_id is an int representing a WL label.
+        """
+
+        from topologicpy.Topology import Topology
+        from topologicpy.Dictionary import Dictionary
+        from collections import defaultdict
+        
+        def _neighbors_map(graph):
+            """
+            Returns:
+                vertices: list of vertex objects in a stable order
+                vidx: dict mapping vertex -> index
+                nbrs: dict index -> sorted list of neighbor indices
+            """
+            vertices = Graph.Vertices(graph)
+            vidx = {v: i for i, v in enumerate(vertices)}
+            nbrs = {}
+            for v in vertices:
+                i = vidx[v]
+                adj = Graph.AdjacentVertices(graph, v) or []
+                nbrs[i] = sorted(vidx[a] for a in adj if a in vidx and a is not v)
+            return vertices, vidx, nbrs
+
+        def _initial_labels(graph, key=None, default="degree"):
+            """
+            Returns an integer label per node index using either vertex dictionary labels
+            or a structural default (degree or constant).
+            """
+            vertices, vidx, nbrs = _neighbors_map(graph)
+            labels = {}
+            if key:
+                found_any = False
+                tmp = {}
+                for v in vertices:
+                    d = Topology.Dictionary(v)
+                    val = Dictionary.ValueAtKey(d, key)
+                    if val is not None:
+                        found_any = True
+                    tmp[vidx[v]] = str(val) if val is not None else None
+                if found_any:
+                    # fill missing with a sentinel
+                    for i, val in tmp.items():
+                        labels[i] = val if val is not None else "__MISSING__"
+                else:
+                    # fall back to structural init if no labels exist
+                    if default == "degree":
+                        labels = {i: str(len(nbrs[i])) for i in nbrs}
+                    else:
+                        labels = {i: "0" for i in nbrs}
+            else: # Add a vertex degree information.
+                _ = Graph.DegreeCentrality(graph, key="_dc_")
+                return _initial_labels(graph, key="_dc_")
+            return labels, nbrs
+
+        def _canonize_string_labels(str_labels):
+            """
+            Deterministically map arbitrary strings to dense integer ids.
+            Returns:
+                int_labels: dict node_index -> int label
+                vocab: dict string_label -> int id
+            """
+            # stable order by string to keep mapping deterministic across runs
+            unique = sorted(set(str_labels.values()))
+            vocab = {lab: k for k, lab in enumerate(unique)}
+            return {i: vocab[s] for i, s in str_labels.items()}, vocab
+
+        from topologicpy.Topology import Topology
+
+        if not Topology.IsInstance(graph, "Graph"):
+            if not silent:
+                print("Graph.WLFeatures - Error: The input graph parameter is not a valid topologic graph. Returning None.")
+            return None
+        
+        str_labels, nbrs = _initial_labels(graph, key=key)
+        features = defaultdict(int)
+
+        # iteration 0
+        labels, _ = _canonize_string_labels(str_labels)
+        for lab in labels.values():
+            features[lab] += 1
+
+        # WL iterations
+        cur = labels
+        for _ in range(iterations):
+            new_str = {}
+            for i in nbrs:
+                neigh = [cur[j] for j in nbrs[i]]
+                neigh.sort()
+                new_str[i] = f"{cur[i]}|{','.join(map(str, neigh))}"
+            cur, _ = _canonize_string_labels(new_str)
+            for lab in cur.values():
+                features[lab] += 1
+
+        return dict(features)
+
+    @staticmethod
+    def WLKernel(graphA, graphB, key: str = None, iterations: int = 2, normalize: bool = True, mantissa: int = 6, silent: bool = False):
+        """
+        Returns a cosine-normalized Weisfeiler-Lehman kernel between two graphs. See https://en.wikipedia.org/wiki/Weisfeiler_Leman_graph_isomorphism_test
+
+        Parameters
+        ----------
+        graphA : topologic_core.Graph
+            The first input graph.
+        graphB : topologic_core.Graph
+            The second input graph.
+        key : str , optional
+            The vertex key to use as an initial label. The default is None which means the vertex degree is used instead.
+        iterations : int , optional
+            The desired number of WL iterations. (non-negative int). The default is 2.
+        normalize : bool , optional
+            if set to True, the returned value is normalized between 0 and 1. The default is True.
+        mantissa : int , optional
+            The desired length of the mantissa. The default is 6.
+        
+        Returns
+        -------
+        float
+            The cosine-normalized Weisfeiler-Lehman kernel
+        """
+        from topologicpy.Topology import Topology
+
+        if not Topology.IsInstance(graphA, "Graph"):
+            if not silent:
+                print("Graph.WLFeatures - Error: The input graphA parameter is not a valid topologic graph. Returning None.")
+            return None
+        if not Topology.IsInstance(graphB, "Graph"):
+            if not silent:
+                print("Graph.WLFeatures - Error: The input graphB parameter is not a valid topologic graph. Returning None.")
+            return None
+        f1 = Graph.WLFeatures(graphA, key=key, iterations=iterations)
+        f2 = Graph.WLFeatures(graphB, key=key, iterations=iterations)
+
+        # dot product
+        keys = set(f1) | set(f2)
+        dot = sum(f1.get(k, 0) * f2.get(k, 0) for k in keys)
+
+        if not normalize:
+            return round(float(dot), mantissa)
+
+        import math
+        n1 = math.sqrt(sum(v*v for v in f1.values()))
+        n2 = math.sqrt(sum(v*v for v in f2.values()))
+        return_value = float(dot) / (n1 * n2) if n1 > 0 and n2 > 0 else 0.0
+        return round(return_value, mantissa)
+
     @staticmethod
     def XOR(graphA, graphB, vertexKeys, useCentroid: bool = False, tolerance: float = 0.001, silent: bool = False):
         """

topologicpy/version.py

@@ -1 +1 @@
-__version__ = '0.8.44'
+__version__ = '0.8.46'

{topologicpy-0.8.44.dist-info → topologicpy-0.8.46.dist-info}/METADATA

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

@@ -12,7 +12,7 @@ topologicpy/Dictionary.py,sha256=sPskW5bopbDzLz6MGKm8lN_OeyeAgsqdLvwwNcG0J3g,446
 topologicpy/Edge.py,sha256=dLoAPuRKbjVg_dzloTgjRnQyv_05U9nfrtLO3tqyuys,74167
 topologicpy/EnergyModel.py,sha256=Pyb28gDDwhzlQIH0xqAygqS0P3SJxWyyV7OWS_AAfRs,53856
 topologicpy/Face.py,sha256=pN1fssyDLYWf1vU0NOBRx69DaUL958wRSxT-7VBCuCg,203184
-topologicpy/Graph.py,sha256=GykBbB8KKcy2oPV2Dsnz_vkyWGgczxLi0puVx5NJUYU,648088
+topologicpy/Graph.py,sha256=io5l8IV60q5ySrpPTid7TL0he4ouD9nJIoTU-erL6Z8,661704
 topologicpy/Grid.py,sha256=EbI2NcYhQDpD5mItd7A1Lpr8Puuf87vZPWuoh7_gChQ,18483
 topologicpy/Helper.py,sha256=qEsE4yaboEGW94q9lFCff0I_JwwTTQnDAFXw006yHaQ,31203
 topologicpy/Honeybee.py,sha256=yctkwfdupKnp7bAOjP1Z4YaYpRrWoMEb4gz9Z5zaWwE,21751
@@ -30,9 +30,9 @@ topologicpy/Vector.py,sha256=X12eqskn28bdB7sLY1EZhq3noPYzPbNEgHPb4a959ss,42302
 topologicpy/Vertex.py,sha256=RlGQnxQSb_kAus3tJgXd-v-Ptubtt09PQPA9IMwfXmI,84835
 topologicpy/Wire.py,sha256=sJE8qwqYOomvN3snMWmj2P2-Sq25ul_OQ95YFz6DFUw,230553
 topologicpy/__init__.py,sha256=RMftibjgAnHB1vdL-muo71RwMS4972JCxHuRHOlU428,928
-topologicpy/version.py,sha256=H1GigrgdekxMys9lmJxIRnIFrNk4zrmX7xz5PrqPdxE,23
-topologicpy-0.8.44.dist-info/licenses/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
-topologicpy-0.8.44.dist-info/METADATA,sha256=YU_ze05mFUZrce4XzGuVddWEEOzOM_oTPndhJHejKC0,10535
-topologicpy-0.8.44.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-topologicpy-0.8.44.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
-topologicpy-0.8.44.dist-info/RECORD,,
+topologicpy/version.py,sha256=lWn332GY1e40h1ASpBjJjwG1eoQEgys8nvUCuPd_VMU,23
+topologicpy-0.8.46.dist-info/licenses/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
+topologicpy-0.8.46.dist-info/METADATA,sha256=TJ0qyM1tswkGy-aJjUmdi5Zmn1BLH1RAoFV9iEi6EI8,10535
+topologicpy-0.8.46.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+topologicpy-0.8.46.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
+topologicpy-0.8.46.dist-info/RECORD,,