topologicpy 0.7.71__py3-none-any.whl → 0.7.73__py3-none-any.whl

topologicpy/Graph.py

@@ -742,6 +742,102 @@ class Graph:
         _ = graph.AllPaths(vertexA, vertexB, True, timeLimit, paths) # Hook to Core
         return paths
 
+    @staticmethod
+    def AreIsomorphic(graphA, graphB, maxIterations=10, silent=False):
+        """
+        Tests if the two input graphs are isomorphic according to the Weisfeiler Lehman graph isomorphism test. 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.
+        maxIterations : int , optional
+            This number limits the number of iterations to prevent the function from running indefinitely, particularly for very large or complex graphs.
+        silent : bool , optional
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
+        
+        Returns
+        -------
+        bool
+            True if the two input graphs are isomorphic. False otherwise
+
+        """
+
+        from topologicpy.Topology import Topology
+
+        def weisfeiler_lehman_test(graph1, graph2, max_iterations=10):
+            """
+            Test if two graphs are isomorphic using the Weisfeiler-Leman (WL) algorithm with early stopping.
+
+            Parameters:
+            graph1 (dict): Adjacency list representation of the first graph.
+            graph2 (dict): Adjacency list representation of the second graph.
+            max_iterations (int): Maximum WL iterations allowed (default is 10).
+
+            Returns:
+            bool: True if the graphs are WL-isomorphic, False otherwise.
+            """
+
+            def wl_iteration(labels, graph):
+                """Perform one WL iteration and return updated labels."""
+                new_labels = {}
+                for node in graph:
+                    neighborhood_labels = sorted([labels[neighbor] for neighbor in graph[node]])
+                    new_labels[node] = (labels[node], tuple(neighborhood_labels))
+                unique_labels = {}
+                count = 0
+                for node in sorted(new_labels):
+                    if new_labels[node] not in unique_labels:
+                        unique_labels[new_labels[node]] = count
+                        count += 1
+                    new_labels[node] = unique_labels[new_labels[node]]
+                return new_labels
+
+            # Initialize labels
+            labels1 = {node: 1 for node in graph1}
+            labels2 = {node: 1 for node in graph2}
+
+            for i in range(max_iterations):
+                # Perform WL iteration for both graphs
+                new_labels1 = wl_iteration(labels1, graph1)
+                new_labels2 = wl_iteration(labels2, graph2)
+
+                # Check if the label distributions match
+                if sorted(new_labels1.values()) != sorted(new_labels2.values()):
+                    return False
+
+                # Check for stability (early stopping)
+                if new_labels1 == labels1 and new_labels2 == labels2:
+                    break
+
+                # Update labels for next iteration
+                labels1, labels2 = new_labels1, new_labels2
+
+            return True
+        
+        if not Topology.IsInstance(graphA, "Graph") and not Topology.IsInstance(graphB, "Graph"):
+            if not silent:
+                print("Graph.AreIsomorphic - Error: The input graph parameters are not valid graphs. Returning None.")
+            return None
+        if not Topology.IsInstance(graphA, "Graph"):
+            if not silent:
+                print("Graph.AreIsomorphic - Error: The input graphA parameter is not a valid graph. Returning None.")
+            return None
+        if not Topology.IsInstance(graphB, "Graph"):
+            if not silent:
+                print("Graph.AreIsomorphic - Error: The input graphB parameter is not a valid graph. Returning None.")
+            return None
+        if maxIterations <= 0:
+            if not silent:
+                print("Graph.AreIsomorphic - Error: The input maxIterations parameter is not within a valid range. Returning None.")
+            return None
+        
+        g1 = Graph.AdjacencyDictionary(graphA)
+        g2 = Graph.AdjacencyDictionary(graphB)
+        return weisfeiler_lehman_test(g1, g2, max_iterations=maxIterations)
+
     @staticmethod
     def AverageClusteringCoefficient(graph, mantissa: int = 6, silent: bool = False):
         """
@@ -3971,7 +4067,7 @@ class Graph:
                         d = Graph.TopologicalDistance(graph, va, vb, tolerance)
                     top_dist += d
                 if top_dist == 0:
-                    print("Topological Distance is Zero!!")
+                    print("Graph.ClosenessCentrality - Warning: Topological Distance is Zero.")
                     scores.append(0)
                 else:
                     scores.append(round((n-1)/top_dist, mantissa))
@@ -7847,20 +7943,24 @@ class Graph:
              sides = 8,
              angle = 0,
              vertexColor="black",
+             vertexColorKey=None,
              vertexSize=6,
+             vertexSizeKey=None,
              vertexLabelKey=None,
              vertexGroupKey=None,
              vertexGroups=[],
              showVertices=True,
-             showVertexLabels=False,
+             showVertexLabel=False,
              showVertexLegend=False,
              edgeColor="black",
+             edgeColorKey=None,
              edgeWidth=1,
+             edgeWidthKey=None,
              edgeLabelKey=None,
              edgeGroupKey=None,
              edgeGroups=[],
              showEdges=True,
-             showEdgeLabels=False,
+             showEdgeLabel=False,
              showEdgeLegend=False,
              colorScale='viridis',
              renderer=None,
@@ -7904,8 +8004,12 @@ class Graph:
             - An hsv/hsva string (e.g. 'hsv(0,100%,100%)')
             - A named CSS color.
             The default is "black".
+        vertexColorKey : str , optional
+            The dictionary key under which to find the vertex color. The default is None.
         vertexSize : float , optional
             The desired size of the vertices. The default is 1.1.
+        vertexSizeKey : str , optional
+            The dictionary key under which to find the vertex size. The default is None.
         vertexLabelKey : str , optional
             The dictionary key to use to display the vertex label. The default is None.
         vertexGroupKey : str , optional
@@ -7914,7 +8018,7 @@ class Graph:
             The list of vertex groups against which to index the color of the vertex. The default is [].
         showVertices : bool , optional
             If set to True the vertices will be drawn. Otherwise, they will not be drawn. The default is True.
-        showVertexLabels : bool , optional
+        showVertexLabel : bool , optional
             If set to True, the vertex labels are shown permenantely on screen. Otherwise, they are not. The default is False.
         showVertexLegend : bool , optional
             If set to True the vertex legend will be drawn. Otherwise, it will not be drawn. The default is False.
@@ -7926,8 +8030,12 @@ class Graph:
             - An hsv/hsva string (e.g. 'hsv(0,100%,100%)')
             - A named CSS color.
             The default is "black".
+        edgeColorKey : str , optional
+            The dictionary key under which to find the edge color. The default is None.
         edgeWidth : float , optional
             The desired thickness of the output edges. The default is 1.
+        edgeWidthKey : str , optional
+            The dictionary key under which to find the edge width. The default is None.
         edgeLabelKey : str , optional
             The dictionary key to use to display the edge label. The default is None.
         edgeGroupKey : str , optional
@@ -7936,7 +8044,7 @@ class Graph:
             The list of edge groups against which to index the color of the edge. The default is [].
         showEdges : bool , optional
             If set to True the edges will be drawn. Otherwise, they will not be drawn. The default is True.
-        showEdgeLabels : bool , optional
+        showEdgeLabel : bool , optional
             If set to True, the edge labels are shown permenantely on screen. Otherwise, they are not. The default is False.
         showEdgeLegend : bool , optional
             If set to True the edge legend will be drawn. Otherwise, it will not be drawn. The default is False.
@@ -7997,7 +8105,7 @@ class Graph:
             print("Graph.Show - Error: The input graph is not a valid graph. Returning None.")
             return None
         
-        data= Plotly.DataByGraph(graph, sagitta=sagitta, absolute=absolute, sides=sides,  angle=angle, vertexColor=vertexColor, vertexSize=vertexSize, vertexLabelKey=vertexLabelKey, vertexGroupKey=vertexGroupKey, vertexGroups=vertexGroups, showVertices=showVertices, showVertexLabels=showVertexLabels, showVertexLegend=showVertexLegend, edgeColor=edgeColor, edgeWidth=edgeWidth, edgeLabelKey=edgeLabelKey, edgeGroupKey=edgeGroupKey, edgeGroups=edgeGroups, showEdges=showEdges, showEdgeLabels=showEdgeLabels, showEdgeLegend=showEdgeLegend, colorScale=colorScale, silent=silent)
+        data= Plotly.DataByGraph(graph, sagitta=sagitta, absolute=absolute, sides=sides,  angle=angle, vertexColor=vertexColor, vertexColorKey=vertexColorKey, vertexSize=vertexSize, vertexSizeKey=vertexSizeKey, vertexLabelKey=vertexLabelKey, vertexGroupKey=vertexGroupKey, vertexGroups=vertexGroups, showVertices=showVertices, showVertexLabel=showVertexLabel, showVertexLegend=showVertexLegend, edgeColor=edgeColor, edgeColorKey=edgeColorKey, edgeWidth=edgeWidth, edgeWidthKey=edgeWidthKey, edgeLabelKey=edgeLabelKey, edgeGroupKey=edgeGroupKey, edgeGroups=edgeGroups, showEdges=showEdges, showEdgeLabel=showEdgeLabel, showEdgeLegend=showEdgeLegend, colorScale=colorScale, silent=silent)
         fig = Plotly.FigureByData(data, width=width, height=height, xAxis=xAxis, yAxis=yAxis, zAxis=zAxis, axisSize=axisSize, backgroundColor=backgroundColor,
                                   marginLeft=marginLeft, marginRight=marginRight, marginTop=marginTop, marginBottom=marginBottom, tolerance=tolerance)
         Plotly.Show(fig, renderer=renderer, camera=camera, center=center, up=up, projection=projection)

topologicpy/Helper.py

@@ -95,6 +95,117 @@ class Helper:
 
         return closest_index
 
+    @staticmethod
+    def ClusterByKeys(elements, dictionaries, *keys, silent=False):
+        """
+            Clusters the input list of elements and dictionaries based on the input key or keys.
+
+            Parameters
+            ----------
+            elements : list
+                The input list of elements to be clustered.
+            dictionaries : list[Topology.Dictionary]
+                The input list of dictionaries to be consulted for clustering. This is assumed to be in the same order as the list of elements.
+            keys : str or list or comma-separated str input parameters
+                The key or keys in the topology's dictionary to use for clustering.
+            silent : bool , optional
+                If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
+
+
+            Returns
+            -------
+            dict
+                A dictionary containing the elements and the dictionaries, but clustered. The dictionary has two keys:
+                "elements": list
+                    A nested list of elements where each item is a list of elements with the same key values.
+                "dictionaries": list
+                    A nested list of dictionaries where each item is a list of dictionaries with the same key values.
+            """
+        
+        from topologicpy.Dictionary import Dictionary
+        from topologicpy.Helper import Helper
+        import inspect
+
+        keys_list = list(keys)
+        keys_list = Helper.Flatten(keys_list)
+        keys_list = [x for x in keys_list if isinstance(x, str)]
+
+        if len(keys_list) == 0:
+            if not silent:
+                print("Helper.ClusterByKeys - Error: The input keys parameter is an empty list. Returning None.")
+                curframe = inspect.currentframe()
+                calframe = inspect.getouterframes(curframe, 2)
+                print('caller name:', calframe[1][3])
+            return None
+        
+        if len(keys_list) == 0:
+            if not silent:
+                print("Helper.ClusterByKeys - Error: The input keys parameter does not contain any valid strings. Returning None.")
+                curframe = inspect.currentframe()
+                calframe = inspect.getouterframes(curframe, 2)
+                print('caller name:', calframe[1][3])
+            return None
+        if not (len(elements) == len(dictionaries)):
+            if not silent:
+                print("Helper.ClusterByKeys - Error: The input elements parameter does not have the same length as the input dictionaries parameter. Returning None.")
+            return None
+        
+        elements_clusters = []
+        dict_clusters = []
+        values = []
+        new_dictionaries = []
+        for i, d in enumerate(dictionaries):
+            element = elements[i]
+
+            d_keys = Dictionary.Keys(d)
+            if len(d_keys) > 0:
+                values_list = []
+                for key in keys_list:
+                    v = Dictionary.ValueAtKey(d, key)
+                    if not v == None:
+                        values_list.append(v)
+                values_list = str(values_list)
+                d = Dictionary.SetValueAtKey(d, "_clustering_key_", values_list)
+                new_dictionaries.append(d)
+                values.append(values_list)
+        
+        values = list(set(values))
+        remaining_dictionaries = [x for x in new_dictionaries]
+        remaining_elements = [x for x in elements]
+        remaining_indices = [i for i, x in enumerate(elements)]
+
+        if len(values) == 0:
+            return {"elements": [elements], "dictionaries": [dictionaries]}
+        for value in values:
+            if len(remaining_dictionaries) == 0:
+                break
+            dict = Dictionary.Filter(remaining_elements, remaining_dictionaries, searchType="equal to", key="_clustering_key_", value=value)
+            filtered_indices = dict['filteredIndices']
+            final_dictionaries = []
+            final_elements = []
+            if len(filtered_indices) > 0:
+                for filtered_index in filtered_indices:
+                    filtered_dictionary = remaining_dictionaries[filtered_index]
+                    filtered_dictionary = Dictionary.RemoveKey(filtered_dictionary, "_clustering_key_")
+                    final_dictionaries.append(filtered_dictionary)
+                    filtered_element = remaining_elements[filtered_index]
+                    final_elements.append(filtered_element)
+                dict_clusters.append(final_dictionaries)
+                elements_clusters.append(final_elements)
+            remaining_dictionaries = dict['otherDictionaries']
+            remaining_elements = dict['otherElements']
+            remaining_indices = dict['otherIndices']
+        if len(remaining_elements) > 0:
+            temp_dict_cluster = []
+            temp_element_cluster = []
+            for remaining_index in remaining_indices:
+                temp_element_cluster.append(remaining_elements[remaining_index])
+                temp_dict_cluster.append(remaining_dictionaries[remaining_index])
+            if len(temp_element_cluster) > 0:
+                dict_clusters.append(temp_dict_cluster)
+                elements_clusters.append(temp_element_cluster)
+        return {"elements": elements_clusters, "dictionaries": dict_clusters}
+
     @staticmethod
     def Flatten(listA):
         """