synkit 1.6.5__py3-none-win_amd64.whl

synkit/Graph/Feature/graph_signature.py

@@ -0,0 +1,239 @@
+import hashlib
+import networkx as nx
+
+
+class GraphSignature:
+    """Provides methods to generate canonical signatures for graph edges (with
+    flexible 'order' and 'state' attributes, and node degrees/neighbor
+    information), various spectral invariants, adjacency matrix, and complete
+    graphs.
+
+    Aims for high uniqueness without relying solely on isomorphism
+    checks.
+    """
+
+    def __init__(self, graph: nx.Graph):
+        """Initializes the GraphSignature class with a specified graph.
+
+        :param graph: A NetworkX graph instance.
+        :type graph: nx.Graph
+        """
+        self.graph = graph
+        self._validate_graph()
+
+    def _validate_graph(self):
+        """Validates that all nodes have the required attributes ('element' and
+        'charge'), and all edges have the required 'order' attribute as int,
+        float, or tuple of two floats, and optionally the 'state' attribute.
+
+        :raises ValueError: If required node or edge attributes are missing or
+                            have invalid types.
+        """
+        for node, data in self.graph.nodes(data=True):
+            if "element" not in data:
+                raise ValueError(f"Node {node} is missing the 'element' attribute.")
+            if "charge" not in data:
+                raise ValueError(f"Node {node} is missing the 'charge' attribute.")
+
+        for u, v, data in self.graph.edges(data=True):
+            if "order" not in data:
+                raise ValueError(f"Edge ({u}, {v}) is missing the 'order' attribute.")
+            order = data["order"]
+            if isinstance(order, tuple):
+                if len(order) != 2 or not all(
+                    isinstance(o, (int, float)) for o in order
+                ):
+                    raise ValueError(
+                        f"Edge ({u}, {v}) has an invalid 'order'. It must be a tuple of two ints/floats."
+                    )
+            elif not isinstance(order, (int, float)):
+                raise ValueError(
+                    f"Edge ({u}, {v}) has an invalid 'order'. It must be an int, float, or a tuple of two ints/floats."
+                )
+
+            # Optional: Validate 'state' attribute if present
+            state = data.get("state", "steady")  # Default to 'steady' if missing
+            if state not in {"break", "form", "steady"}:
+                raise ValueError(
+                    f"Edge ({u}, {v}) has an invalid 'state'. It must be 'break', 'form', or 'steady'."
+                )
+
+    def create_edge_signature(
+        self, include_neighbors: bool = False, max_hop: int = 2
+    ) -> str:
+        """Generates a canonical edge signature by formatting each edge with
+        sorted node elements (including charge), node degrees, bond order, bond
+        state, and optionally including neighbor information and topological
+        context.
+
+        :param include_neighbors: Whether to include neighbors' details in the edge signature.
+        :type include_neighbors: bool
+        :param max_hop: Maximum number of hops to include for neighbor-level structural information.
+        :type max_hop: int
+
+        :return: A concatenated and sorted string of edge representations.
+        :rtype: str
+        """
+        edge_signature_parts = []
+
+        for u, v, data in self.graph.edges(data=True):
+            # Retrieve bond order (default to (1.0, 1.0) if missing)
+            order = data.get("order", (1.0, 1.0))
+
+            # Format order as a tuple (default or actual value)
+            if isinstance(order, tuple):
+                order_str = f"{{{order[0]:.1f},{order[1]:.1f}}}"
+            else:
+                order_str = f"{float(order):.1f}"
+
+            # Get node elements and charges for both nodes
+            node1_element = self.graph.nodes[u].get(
+                "element", "X"
+            )  # Default to 'X' if missing
+            node1_charge = self.graph.nodes[u].get(
+                "charge", 0
+            )  # Default to 0 if missing
+            node2_element = self.graph.nodes[v].get("element", "X")
+            node2_charge = self.graph.nodes[v].get("charge", 0)
+
+            # Construct node representation with element and charge
+            node1 = f"{node1_element}{node1_charge}"
+            node2 = f"{node2_element}{node2_charge}"
+
+            # Optionally include neighbors in the signature
+            if include_neighbors:
+                neighbors_u = sorted(
+                    [
+                        f"{self.graph.nodes[neighbor].get('element', 'X')}{self.graph.nodes[neighbor].get('charge', 0)}"
+                        + f"d{self.graph.degree(neighbor)}"
+                        for neighbor in self.graph.neighbors(u)
+                    ]
+                )
+                neighbors_v = sorted(
+                    [
+                        f"{self.graph.nodes[neighbor].get('element', 'X')}{self.graph.nodes[neighbor].get('charge', 0)}"
+                        + f"d{self.graph.degree(neighbor)}"
+                        for neighbor in self.graph.neighbors(v)
+                    ]
+                )
+
+                # Represent neighbors within square brackets
+                node1_neighbors = "".join(neighbors_u)
+                node2_neighbors = "".join(neighbors_v)
+                node1 = f"{node1}[{node1_neighbors}]"
+                node2 = f"{node2}[{node2_neighbors}]"
+
+            # Include k-hop neighborhood information
+            if max_hop > 1:
+                node1_neighbors_khop = self._get_khop_neighbors(u, max_hop)
+                node2_neighbors_khop = self._get_khop_neighbors(v, max_hop)
+                node1 += f"[{node1_neighbors_khop}]"
+                node2 += f"[{node2_neighbors_khop}]"
+
+            # Sort nodes to ensure consistency in edge signature (avoid direction dependency)
+            node1, node2 = sorted([node1, node2])
+
+            # Format the edge signature and append it
+            edge_part = f"{node1}{order_str}{node2}"
+            edge_signature_parts.append(edge_part)
+
+        # Sort all edge signatures to ensure consistency in the final representation
+        return "/".join(sorted(edge_signature_parts))
+
+    def _get_khop_neighbors(self, node, max_hop):
+        """Retrieves the k-hop neighborhood information for a given node.
+
+        :param node: The node for which to get neighborhood information.
+        :type node: int
+        :param max_hop: Maximum number of hops for neighborhood exploration.
+        :type max_hop: int
+
+        :return: A concatenated string representing the k-hop neighborhood information.
+        :rtype: str
+        """
+        k_hop_neighbors = []
+        current_hop_neighbors = [node]
+        for _ in range(max_hop):
+            next_hop_neighbors = []
+            for n in current_hop_neighbors:
+                next_hop_neighbors.extend(list(self.graph.neighbors(n)))
+            # Filter out already seen nodes to avoid loops
+            next_hop_neighbors = set(next_hop_neighbors) - set(k_hop_neighbors)
+            k_hop_neighbors.extend(next_hop_neighbors)
+            current_hop_neighbors = next_hop_neighbors
+
+        # Return sorted k-hop neighborhood info
+        return "".join(
+            sorted(
+                [
+                    f"{self.graph.nodes[neighbor].get('element', 'X')}{self.graph.nodes[neighbor].get('charge', 0)}"
+                    for neighbor in k_hop_neighbors
+                ]
+            )
+        )
+
+    def create_wl_hash(self, iterations: int = 3) -> str:
+        """Generates a Weisfeiler-Lehman (WL) hash for the graph to capture its
+        structural features.
+
+        :param iterations: Number of WL iterations to perform.
+        :type iterations: int
+
+        :return: A hexadecimal hash representing the WL feature.
+        :rtype: str
+        """
+        # Initialize labels with both 'element' and 'charge'
+        labels = {
+            node: f"{data['element']}{data.get('charge', 0)}"
+            for node, data in self.graph.nodes(data=True)
+        }
+        for _ in range(iterations):
+            new_labels = {}
+            for node in self.graph.nodes():
+                # Gather sorted labels of neighbors
+                neighbor_labels = sorted(
+                    labels[neighbor] for neighbor in self.graph.neighbors(node)
+                )
+                # Concatenate current label with neighbor labels
+                concatenated = labels[node] + "".join(neighbor_labels)
+                # Hash the concatenated string to obtain a new label
+                new_label = hashlib.sha256(concatenated.encode()).hexdigest()
+                new_labels[node] = new_label
+            labels = new_labels
+        # Aggregate all node labels into a sorted string and hash it
+        sorted_labels = sorted(labels.values())
+        aggregated = "".join(sorted_labels)
+        graph_hash = hashlib.sha256(aggregated.encode()).hexdigest()
+        return graph_hash
+
+    def create_graph_signature(
+        self,
+        include_wl_hash: bool = True,
+        include_neighbors: bool = True,
+        max_hop: int = 1,
+    ) -> str:
+        """Combines edge, various spectral invariants, and WL hash into a
+        single comprehensive graph signature.
+
+        :param include_wl_hash: Whether to include the Weisfeiler-Lehman hash.
+        :type include_wl_hash: bool
+        :param include_neighbors: Whether to include neighbor information in edge signatures.
+        :type include_neighbors: bool
+        :param max_hop: Maximum neighborhood depth used by edge signatures.
+        :type max_hop: int
+
+        :return: A concatenated string representing the complete graph signature.
+        :rtype: str
+        """
+        signatures = []
+
+        if include_wl_hash:
+            wl_signature = self.create_wl_hash()
+            signatures.append(f"{wl_signature}")
+
+        edge_signature = self.create_edge_signature(
+            include_neighbors=include_neighbors, max_hop=max_hop
+        )
+        signatures.append(f"{edge_signature}")
+
+        return "|".join(signatures)

synkit/Graph/Feature/hash_fps.py

@@ -0,0 +1,133 @@
+import networkx as nx
+import hashlib
+from typing import Optional, Any
+
+
+class HashFPs:
+    def __init__(
+        self, graph: nx.Graph, numBits: int = 256, hash_alg: str = "sha256"
+    ) -> None:
+        """Initialize the HashFPs class with a graph and configuration
+        settings.
+
+        :param graph: The graph to be fingerprinted.
+        :type graph: nx.Graph
+        :param numBits: Number of bits in the output binary hash. Default is 256 bits.
+        :type numBits: int
+        :param hash_alg: The hash algorithm to use, such as 'sha256' or 'sha512'.
+        :type hash_alg: str
+
+        :raises ValueError: If `numBits` is non-positive or if `hash_alg` is not supported by hashlib.
+        """
+        self.graph = graph
+        self.numBits = numBits
+        self.hash_alg = hash_alg
+        self.validate_parameters()
+
+    def validate_parameters(self) -> None:
+        """Validate the initial parameters for errors."""
+        if self.numBits <= 0:
+            raise ValueError("Number of bits must be positive")
+        if not hasattr(hashlib, self.hash_alg):
+            raise ValueError(f"Unsupported hash algorithm: {self.hash_alg}")
+
+    def hash_fps(
+        self,
+        start_node: Optional[int] = None,
+        end_node: Optional[int] = None,
+        max_path_length: Optional[int] = None,
+    ) -> str:
+        """Generate a binary hash fingerprint of the graph based on its paths
+        and cycles.
+
+        :param start_node: The starting node index for path detection.
+        :type start_node: Optional[int]
+        :param end_node: The ending node index for path detection.
+        :type end_node: Optional[int]
+        :param max_path_length: The maximum length for paths to be considered.
+        :type max_path_length: Optional[int]
+
+        :return: A binary string representing the truncated hash of the graph's structural features.
+        :rtype: str
+        """
+        hash_object = self.initialize_hash()
+        features = self.extract_features(start_node, end_node, max_path_length)
+        full_hash_binary = self.finalize_hash(hash_object, features)
+        return full_hash_binary
+
+    def initialize_hash(self) -> Any:
+        """Initialize and return the hash object based on the specified
+        algorithm."""
+        return getattr(hashlib, self.hash_alg)()
+
+    def extract_features(
+        self,
+        start_node: Optional[int],
+        end_node: Optional[int],
+        max_path_length: Optional[int],
+    ) -> str:
+        """Extract features from the graph based on paths and cycles.
+
+        :param start_node: The starting node for path detection.
+        :type start_node: Optional[int]
+        :param end_node: The ending node for path detection.
+        :type end_node: Optional[int]
+        :param max_path_length: Cutoff for path length during detection.
+        :type max_path_length: Optional[int]
+
+        :return: A string of concatenated feature values.
+        :rtype: str
+        """
+        cycles = list(nx.simple_cycles(self.graph))
+        paths = []
+        if start_node is not None and end_node is not None:
+            paths = list(
+                nx.all_simple_paths(
+                    self.graph,
+                    source=start_node,
+                    target=end_node,
+                    cutoff=max_path_length,
+                )
+            )
+        features = [len(c) for c in cycles] + [len(p) for p in paths]
+        return "".join(map(str, features))
+
+    def finalize_hash(self, hash_object: Any, features: str) -> str:
+        """Finalize the hash using the features extracted and return the hash
+        as a binary string.
+
+        :param hash_object: The hash object.
+        :type hash_object: Any
+        :param features: Concatenated string of graph features.
+        :type features: str
+
+        :return: The final binary string of the hash, truncated or extended to `numBits`.
+        :rtype: str
+        """
+        hash_object.update(features.encode())
+        full_hash_binary = bin(int(hash_object.hexdigest(), 16))[2:]
+        if len(full_hash_binary) < self.numBits:
+            full_hash_binary += self.iterative_deepening(
+                hash_object, self.numBits - len(full_hash_binary)
+            )
+        return full_hash_binary[: self.numBits]
+
+    def iterative_deepening(self, hash_object: Any, remaining_bits: int) -> str:
+        """Extend hash length using iterative hashing until the desired bit
+        length is achieved.
+
+        :param hash_object: The hash object for iterative deepening.
+        :type hash_object: hashlib._Hash
+        :param remaining_bits: Number of bits needed to reach `numBits`.
+        :type remaining_bits: int
+
+        :return: Additional binary data to achieve the desired hash length.
+        :rtype: str
+        """
+        additional_data = ""
+        while (
+            len(additional_data) * 4 < remaining_bits
+        ):  # Each hex digit represents 4 bits
+            hash_object.update(additional_data.encode())
+            additional_data += hash_object.hexdigest()
+        return bin(int(additional_data, 16))[2:][:remaining_bits]

synkit/Graph/Feature/morgan_fps.py

@@ -0,0 +1,88 @@
+import networkx as nx
+import hashlib
+from typing import Any
+
+
+class MorganFPs:
+    def __init__(
+        self,
+        graph: nx.Graph,
+        radius: int = 3,
+        nBits: int = 1024,
+        hash_alg: str = "sha256",
+    ):
+        """Initialize the MorganFPs class to generate fingerprints based on the
+        Morgan algorithm, approximating Extended Connectivity Fingerprints
+        (ECFPs).
+
+        :param graph: The graph to analyze.
+        :type graph: nx.Graph
+        :param radius: The radius to consider for node neighborhood analysis.
+        :type radius: int
+        :param nBits: Total number of bits in the final fingerprint output.
+        :type nBits: int
+        :param hash_alg: Hash algorithm to use for generating hashes of node
+                         neighborhoods.
+        :type hash_alg: str
+        """
+        self.graph = graph
+        self.radius = radius
+        self.nBits = nBits
+        self.hash_alg = hash_alg
+        self.hash_function = getattr(hashlib, self.hash_alg)
+
+    def generate_fingerprint(self) -> str:
+        """Generate a binary string fingerprint of the graph based on the local
+        environments of nodes. Ensures the output is exactly `nBits` in length
+        using iterative deepening if necessary.
+
+        :return: A binary string of length `nBits` representing the fingerprint of the graph.
+        :rtype: str
+        """
+        fingerprint = ""
+        for node in self.graph.nodes():
+            neighborhood = nx.single_source_shortest_path_length(
+                self.graph, node, cutoff=self.radius
+            )
+            neighborhood_str = "-".join(
+                [
+                    f"{nbr}-{dist}"
+                    for nbr, dist in sorted(neighborhood.items())
+                    if nbr != node
+                ]
+            )
+            hash_obj = self.hash_function(neighborhood_str.encode())
+            node_hash = bin(int(hash_obj.hexdigest(), 16))[2:].zfill(
+                hash_obj.digest_size * 8
+            )
+            if len(fingerprint) + len(node_hash) > self.nBits:
+                needed_bits = self.nBits - len(fingerprint)
+                node_hash = node_hash[:needed_bits]
+            fingerprint += node_hash
+            if len(fingerprint) == self.nBits:
+                return fingerprint
+
+        if len(fingerprint) < self.nBits:
+            fingerprint += self.iterative_deepening(
+                hash_obj, self.nBits - len(fingerprint)
+            )
+        return fingerprint
+
+    def iterative_deepening(self, hash_object: Any, remaining_bits: int) -> str:
+        """Extend the hash length using iterative hashing until the desired bit
+        length is achieved.
+
+        :param hash_object: The hash object used for iterative deepening.
+        :type hash_object: hashlib._Hash
+        :param remaining_bits: Number of bits needed to complete the fingerprint to
+                               `nBits`.
+        :type remaining_bits: int
+
+        :return: Additional binary data to achieve the desired hash length.
+        :rtype: str
+        """
+        additional_data = ""
+        while len(additional_data) * 4 < remaining_bits:
+            hash_object.update(additional_data.encode())
+            additional_data += hash_object.hexdigest()
+        return bin(int(additional_data, 16))[2:][:remaining_bits]

synkit/Graph/Feature/path_fps.py

@@ -0,0 +1,81 @@
+import networkx as nx
+import hashlib
+from typing import Any
+
+
+class PathFPs:
+    def __init__(
+        self,
+        graph: nx.Graph,
+        max_length: int = 10,
+        nBits: int = 1024,
+        hash_alg: str = "sha256",
+    ) -> None:
+        """Initialize the PathFPs class to create a binary fingerprint based on
+        paths in a graph.
+
+        :param graph: Graph on which to perform analysis.
+        :type graph: nx.Graph
+        :param max_length: Limit on path lengths considered in the fingerprint.
+        :type max_length: int
+        :param nBits: Size of the binary fingerprint in bits.
+        :type nBits: int
+        :param hash_alg: Cryptographic hash function used for path hashing.
+        :type hash_alg: str
+        """
+        self.graph = graph
+        self.max_length = max_length
+        self.nBits = nBits
+        self.hash_alg = hash_alg
+        self.hash_function = getattr(hashlib, self.hash_alg)
+
+    def generate_fingerprint(self) -> str:
+        """Generate a binary string fingerprint of the graph by hashing paths
+        up to a certain length and combining them.
+
+        :return: A binary string of length `nBits` that represents the fingerprint of the graph.
+        :rtype: str
+        """
+        fingerprint = ""
+        for node in self.graph.nodes():
+            for target in self.graph.nodes():
+                if node != target:
+                    for path in nx.all_simple_paths(
+                        self.graph, source=node, target=target, cutoff=self.max_length
+                    ):
+                        path_str = "-".join(map(str, path))
+                        hash_obj = self.hash_function(path_str.encode())
+                        path_hash = bin(int(hash_obj.hexdigest(), 16))[2:].zfill(
+                            hash_obj.digest_size * 8
+                        )
+                        if len(fingerprint) + len(path_hash) > self.nBits:
+                            needed_bits = self.nBits - len(fingerprint)
+                            path_hash = path_hash[:needed_bits]
+                        fingerprint += path_hash
+                        if len(fingerprint) == self.nBits:
+                            return fingerprint
+
+        if len(fingerprint) < self.nBits:
+            fingerprint += self.iterative_deepening(
+                hash_obj, self.nBits - len(fingerprint)
+            )
+        return fingerprint
+
+    def iterative_deepening(self, hash_object: Any, remaining_bits: int) -> str:
+        """Extend the hash length using iterative hashing until the desired bit
+        length is achieved.
+
+        :param hash_object: The hash object used for iterative deepening.
+        :type hash_object: hashlib._Hash
+        :param remaining_bits: Number of bits needed to complete the fingerprint
+                               to `nBits`.
+        :type remaining_bits: int
+
+        :return: Additional binary data to achieve the desired hash length.
+        :rtype: str
+        """
+        additional_data = ""
+        while len(additional_data) * 4 < remaining_bits:
+            hash_object.update(additional_data.encode())
+            additional_data += hash_object.hexdigest()
+        return bin(int(additional_data, 16))[2:][:remaining_bits]

synkit/Graph/Feature/wl_hash.py

@@ -0,0 +1,134 @@
+import copy
+import networkx as nx
+from typing import List, Dict, Union, Tuple
+
+
+class WLHash:
+    """A class that implements the Weisfeiler-Lehman graph hashing algorithm,
+    supporting multiple node/edge attributes for hashing.
+
+    :ivar node: A single attribute name or a list of attribute names for nodes used in hashing.
+    :ivar edge: A single attribute name or a list of attribute names for edges used in hashing.
+    :ivar iterations: Number of iterations for the Weisfeiler-Lehman algorithm.
+    :ivar digest_size: Length of the hash to be generated.
+    """
+
+    def __init__(
+        self,
+        node: Union[str, List[str]] = ["element", "charge"],
+        edge: Union[str, List[str]] = "order",
+        iterations: int = 5,
+        digest_size: int = 16,
+    ):
+        """Initializes the WLHash class with configuration for hashing.
+
+        :param node: A node attribute name or list of node attribute names.
+        :param edge: An edge attribute name or list of edge attribute names.
+        :param iterations: The number of WL iterations (default 5).
+        :param digest_size: The length of the generated hash (default 16).
+        """
+        self.node = node
+        self.edge = edge
+        self.iterations = iterations
+        self.digest_size = digest_size
+
+    def _prepare_graph(
+        self, graph: nx.Graph
+    ) -> Tuple[nx.Graph, Union[str, None], Union[str, None]]:
+        """Prepare a deep copy of the graph with combined/missing node and edge
+        attributes.
+
+        Returns (H, node_attr_name, edge_attr_name).
+        """
+        # Deep-copy to avoid mutating original graph
+        H = copy.deepcopy(graph)
+
+        # --- NODE ATTRIBUTE HANDLING ---
+        if isinstance(self.node, (list, tuple)) and len(self.node) > 1:
+            combined_node_attr = "_wl_hash_node_attr"
+            for n, data in H.nodes(data=True):
+                # Combine each attribute's string value (default empty)
+                vals = [str(data.get(attr, "")) for attr in self.node]
+                data[combined_node_attr] = "|".join(vals)
+            node_attr_name = combined_node_attr
+        else:
+            node_attr_name = (
+                self.node
+                if isinstance(self.node, str)
+                else (self.node[0] if self.node else None)
+            )
+            # Ensure missing attributes default to empty string
+            if node_attr_name:
+                for _, data in H.nodes(data=True):
+                    data.setdefault(node_attr_name, "")
+
+        # --- EDGE ATTRIBUTE HANDLING ---
+        if isinstance(self.edge, (list, tuple)) and len(self.edge) > 1:
+            combined_edge_attr = "_wl_hash_edge_attr"
+            for u, v, data in H.edges(data=True):
+                vals = [str(data.get(attr, "")) for attr in self.edge]
+                data[combined_edge_attr] = "|".join(vals)
+            edge_attr_name = combined_edge_attr
+        else:
+            edge_attr_name = (
+                self.edge
+                if isinstance(self.edge, str)
+                else (self.edge[0] if self.edge else None)
+            )
+            if edge_attr_name:
+                for _, _, data in H.edges(data=True):
+                    data.setdefault(edge_attr_name, "")
+
+        return H, node_attr_name, edge_attr_name
+
+    def weisfeiler_lehman_graph_hash(self, graph: nx.Graph) -> str:
+        """Computes the WL graph hash for the entire graph."""
+        G, node_attr, edge_attr = self._prepare_graph(graph)
+        return nx.weisfeiler_lehman_graph_hash(
+            G,
+            node_attr=node_attr,
+            edge_attr=edge_attr,
+            iterations=self.iterations,
+            digest_size=self.digest_size,
+        )
+
+    def weisfeiler_lehman_subgraph_hashes(
+        self, graph: nx.Graph
+    ) -> Dict[Union[int, str], List[str]]:
+        """Computes the WL subgraph hashes for each node in the graph."""
+        G, node_attr, edge_attr = self._prepare_graph(graph)
+        return nx.weisfeiler_lehman_subgraph_hashes(
+            G,
+            node_attr=node_attr,
+            edge_attr=edge_attr,
+            iterations=self.iterations,
+            digest_size=self.digest_size,
+        )
+
+    def process_data(
+        self,
+        data: List[Dict[str, Union[str, nx.Graph]]],
+        graph_key: str = "ITS",
+        subgraph: bool = False,
+    ) -> List[Dict[str, Union[str, None]]]:
+        """Applies WL hashing (or subgraph hashing) to a list of data entries.
+
+        Each entry must contain a graph under 'graph_key'.
+        """
+        for entry in data:
+            if graph_key in entry and isinstance(entry[graph_key], nx.Graph):
+                graph = entry[graph_key]
+                try:
+                    if subgraph:
+                        entry["WL"] = self.weisfeiler_lehman_subgraph_hashes(graph)
+                    else:
+                        entry["WL"] = self.weisfeiler_lehman_graph_hash(graph)
+                except Exception as e:
+                    print(f"Error processing graph {entry.get('name', 'Unnamed')}: {e}")
+                    entry["WL"] = None
+            else:
+                print(
+                    f"Missing or invalid '{graph_key}' for graph in data: {entry.get('name', 'Unnamed')}"
+                )
+                entry["WL"] = None
+        return data