synkit 0.0.1__py3-none-any.whl

synkit/IO/data_io.py

@@ -0,0 +1,277 @@
+import os
+import json
+import pickle
+import numpy as np
+from numpy import ndarray
+from joblib import dump, load
+from typing import List, Dict, Any, Generator
+from synkit.IO.debug import setup_logging
+
+logger = setup_logging()
+
+
+def save_database(database: list[dict], pathname: str = "./Data/database.json") -> None:
+    """
+    Save a database (a list of dictionaries) to a JSON file.
+
+    Parameters:
+    - database: The database to be saved.
+    - pathname: The path where the database will be saved.
+                    Defaults to './Data/database.json'.
+
+    Raises:
+    - TypeError: If the database is not a list of dictionaries.
+    - ValueError: If there is an error writing the file.
+    """
+    if not all(isinstance(item, dict) for item in database):
+        raise TypeError("Database should be a list of dictionaries.")
+
+    try:
+        with open(pathname, "w") as f:
+            json.dump(database, f)
+    except IOError as e:
+        raise ValueError(f"Error writing to file {pathname}: {e}")
+
+
+def load_database(pathname: str = "./Data/database.json") -> List[Dict]:
+    """
+    Load a database (a list of dictionaries) from a JSON file.
+
+    Parameters:
+    - pathname: The path from where the database will be loaded.
+    Defaults to './Data/database.json'.
+
+    Returns:
+    - List[Dict]: The loaded database.
+
+    Raises:
+    - ValueError: If there is an error reading the file.
+    """
+    try:
+        with open(pathname, "r") as f:
+            database = json.load(f)  # Load the JSON data from the file
+        return database
+    except IOError as e:
+        raise ValueError(f"Error reading to file {pathname}: {e}")
+
+
+def save_to_pickle(data: List[Dict[str, Any]], filename: str) -> None:
+    """
+    Save a list of dictionaries to a pickle file.
+
+    Parameters:
+    - data (List[Dict[str, Any]]): A list of dictionaries to be saved.
+    - filename (str): The name of the file where the data will be saved.
+    """
+    with open(filename, "wb") as file:
+        pickle.dump(data, file)
+
+
+def load_from_pickle(filename: str) -> List[Any]:
+    """
+    Load data from a pickle file.
+
+    Parameters:
+    - filename (str): The name of the pickle file to load data from.
+
+    Returns:
+    - List[Any]: The data loaded from the pickle file.
+    """
+    with open(filename, "rb") as file:
+        return pickle.load(file)
+
+
+def load_gml_as_text(gml_file_path):
+    """
+    Load the contents of a GML file as a text string.
+
+    Parameters:
+    - gml_file_path (str): The file path to the GML file.
+
+    Returns:
+    - str: The text content of the GML file.
+    """
+    try:
+        with open(gml_file_path, "r") as file:
+            return file.read()
+    except FileNotFoundError:
+        print(f"File not found: {gml_file_path}")
+        return None
+    except Exception as e:
+        print(f"An error occurred: {e}")
+        return None
+
+
+def save_text_as_gml(gml_text, file_path):
+    """
+    Save a GML text string to a file.
+
+    Parameters:
+    - gml_text (str): The GML content as a text string.
+    - file_path (str): The file path where the GML text will be saved.
+
+    Returns:
+    - bool: True if saving was successful, False otherwise.
+    """
+    try:
+        with open(file_path, "w") as file:
+            file.write(gml_text)
+        print(f"GML text successfully saved to {file_path}")
+        return True
+    except Exception as e:
+        print(f"An error occurred while saving the GML text: {e}")
+        return False
+
+
+def save_compressed(array: ndarray, filename: str) -> None:
+    """
+    Saves a NumPy array in a compressed format using .npz extension.
+
+    Parameters:
+    - array (ndarray): The NumPy array to be saved.
+    - filename (str): The file path or name to save the array to,
+    with a '.npz' extension.
+
+    Returns:
+    - None: This function does not return any value.
+    """
+    np.savez_compressed(filename, array=array)
+
+
+def load_compressed(filename: str) -> ndarray:
+    """
+    Loads a NumPy array from a compressed .npz file.
+
+    Parameters:
+    - filename (str): The path of the .npz file to load.
+
+    Returns:
+    - ndarray: The loaded NumPy array.
+
+    Raises:
+    - KeyError: If the .npz file does not contain an array with the key 'array'.
+    """
+    with np.load(filename) as data:
+        if "array" in data:
+            return data["array"]
+        else:
+            raise KeyError(
+                "The .npz file does not contain" + " an array with the key 'array'."
+            )
+
+
+def save_model(model: Any, filename: str) -> None:
+    """
+    Save a machine learning model to a file using joblib.
+
+    Parameters:
+    - model (Any): The machine learning model to save.
+    - filename (str): The path to the file where the model will be saved.
+    """
+    dump(model, filename)
+    logger.info(f"Model saved successfully to {filename}")
+
+
+def load_model(filename: str) -> Any:
+    """
+    Load a machine learning model from a file using joblib.
+
+    Parameters:
+    - filename (str): The path to the file from which the model will be loaded.
+
+    Returns:
+    - Any: The loaded machine learning model.
+    """
+    model = load(filename)
+    logger.info(f"Model loaded successfully from {filename}")
+    return model
+
+
+def save_dict_to_json(data: dict, file_path: str) -> None:
+    """
+    Save a dictionary to a JSON file.
+
+    Parameters:
+    -----------
+    data : dict
+        The dictionary to be saved.
+
+    file_path : str
+        The path to the file where the dictionary should be saved.
+        Make sure the file has a .json extension.
+
+    Returns:
+    --------
+    None
+    """
+    with open(file_path, "w") as json_file:
+        json.dump(data, json_file, indent=4)
+
+    logger.info(f"Dictionary successfully saved to {file_path}")
+
+
+def load_dict_from_json(file_path: str) -> dict:
+    """
+    Load a dictionary from a JSON file.
+
+    Parameters:
+    -----------
+    file_path : str
+        The path to the JSON file from which to load the dictionary.
+        Make sure the file has a .json extension.
+
+    Returns:
+    --------
+    dict
+        The dictionary loaded from the JSON file.
+    """
+    try:
+        with open(file_path, "r") as json_file:
+            data = json.load(json_file)
+        logger.info(f"Dictionary successfully loaded from {file_path}")
+        return data
+    except Exception as e:
+        logger.error(e)
+        return None
+
+
+def load_from_pickle_generator(file_path: str) -> Generator[Any, None, None]:
+    """
+    A generator that yields items from a pickle file where each pickle load returns a list
+    of dictionaries.
+
+    Paremeters:
+    - file_path (str): The path to the pickle file to load.
+
+    - Yields:
+    Any: Yields a single item from the list of dictionaries stored in the pickle file.
+    """
+    with open(file_path, "rb") as file:
+        while True:
+            try:
+                batch_items = pickle.load(file)
+                for item in batch_items:
+                    yield item
+            except EOFError:
+                break
+
+
+def collect_data(num_batches: int, temp_dir: str, file_template: str) -> List[Any]:
+    """
+    Collects and aggregates data from multiple pickle files into a single list.
+
+    Paremeters:
+    - num_batches (int): The number of batch files to process.
+    - temp_dir (str): The directory where the batch files are stored.
+    - file_template (str): The template string for batch file names, expecting an integer
+    formatter.
+
+    Returns:
+    List[Any]: A list of aggregated data items from all batch files.
+    """
+    collected_data: List[Any] = []
+    for i in range(num_batches):
+        file_path = os.path.join(temp_dir, file_template.format(i))
+        for item in load_from_pickle_generator(file_path):
+            collected_data.append(item)
+    return collected_data

synkit/IO/data_process.py

@@ -0,0 +1,49 @@
+from typing import List, Dict, Any
+
+
+def merge_dicts(
+    list1: List[Dict[str, Any]],
+    list2: List[Dict[str, Any]],
+    key: str,
+    intersection: bool = True,
+) -> List[Dict[str, Any]]:
+    """
+    Merges two lists of dictionaries based on a specified key, with an option to
+    either merge only dictionaries with matching key values (intersection) or
+    all dictionaries (union).
+
+    Parameters:
+    - list1 (List[Dict[str, Any]]): The first list of dictionaries.
+    - list2 (List[Dict[str, Any]]): The second list of dictionaries.
+    - key (str): The key used to match and merge dictionaries from both lists.
+    - intersection (bool): If True, only merge dictionaries with matching key values;
+      if False, merge all dictionaries, combining those with matching key values.
+
+    Returns:
+    - List[Dict[str, Any]]: A list of dictionaries with merged contents from both
+      input lists according to the specified merging strategy.
+    """
+    dict1 = {item[key]: item for item in list1}
+    dict2 = {item[key]: item for item in list2}
+
+    if intersection:
+        # Intersection of keys: only keys present in both dictionaries are merged
+        merged_list = []
+        for item1 in list1:
+            r_id = item1.get(key)
+            if r_id in dict2:
+                merged_item = {**item1, **dict2[r_id]}
+                merged_list.append(merged_item)
+        return merged_list
+    else:
+        # Union of keys: all keys from both dictionaries are merged
+        merged_dict = {}
+        all_keys = set(dict1) | set(dict2)
+        for k in all_keys:
+            if k in dict1 and k in dict2:
+                merged_dict[k] = {**dict1[k], **dict2[k]}
+            elif k in dict1:
+                merged_dict[k] = dict1[k]
+            else:
+                merged_dict[k] = dict2[k]
+        return list(merged_dict.values())

synkit/IO/debug.py

@@ -0,0 +1,78 @@
+import os
+import logging
+import warnings
+from rdkit import rdBase
+
+
+def setup_logging(log_level: str = "INFO", log_filename: str = None) -> logging.Logger:
+    """
+    Configures logging to either the console or a file based on provided parameters.
+
+    Parameters
+    ----------
+    log_level : str, optional
+        Logging level to set. Defaults to 'INFO'. Options include 'DEBUG', 'INFO',
+        'WARNING', 'ERROR', 'CRITICAL'.
+    log_filename : str, optional
+        If provided, logs are written to this file. Defaults to None,
+        which logs to console.
+
+    Returns
+    -------
+    logging.Logger
+        Configured logger instance.
+
+    Raises
+    ------
+    ValueError
+        If an invalid log level is provided.
+    """
+    log_format = "%(asctime)s - %(levelname)s - %(message)s"
+    numeric_level = getattr(logging, log_level.upper(), None)
+
+    if not isinstance(numeric_level, int):
+        raise ValueError(f"Invalid log level: {log_level}")
+
+    logger = logging.getLogger()
+    logger.handlers.clear()  # Efficiently remove all existing handlers
+
+    if log_filename:
+        os.makedirs(os.path.dirname(log_filename), exist_ok=True)
+        logging.basicConfig(
+            level=numeric_level, format=log_format, filename=log_filename, filemode="a"
+        )
+    else:
+        logging.basicConfig(level=numeric_level, format=log_format)
+
+    return logger
+
+
+def configure_warnings_and_logs(
+    ignore_warnings: bool = False, disable_rdkit_logs: bool = False
+) -> None:
+    """
+    Configures Python warnings and RDKit log behavior based on input flags.
+
+    Parameters
+    ----------
+    ignore_warnings : bool, optional
+        Whether to suppress Python warnings. Default is False.
+    disable_rdkit_logs : bool, optional
+        Whether to disable RDKit error and warning logs. Default is False.
+
+    Usage
+    -----
+    This function is useful for controlling verbosity in production or testing, but
+    should be used cautiously during development to avoid missing critical issues.
+    """
+    if ignore_warnings:
+        warnings.filterwarnings("ignore")
+    else:
+        warnings.resetwarnings()
+
+    if disable_rdkit_logs:
+        rdBase.DisableLog("rdApp.error")
+        rdBase.DisableLog("rdApp.warning")
+    else:
+        rdBase.EnableLog("rdApp.error")
+        rdBase.EnableLog("rdApp.warning")

synkit/IO/dg_to_gml.py

@@ -0,0 +1,124 @@
+import regex
+from synkit.IO.debug import setup_logging
+from synkit.Chem.Reaction.standardize import Standardize
+from mod import DGVertexMapper, smiles, Rule
+
+logger = setup_logging()
+
+
+class DGToGML:
+    def __init__(self) -> None:
+        self.standardizer = Standardize()
+        pass
+
+    @staticmethod
+    def getReactionSmiles(dg):
+        origSmiles = {}
+        for v in dg.vertices:
+            s = v.graph.smilesWithIds
+            s = regex.sub(":([0-9]+)]", ":o\\1]", s)
+            origSmiles[v.graph] = s
+
+        res = {}
+        for e in dg.edges:
+            vms = DGVertexMapper(e, rightLimit=1, leftLimit=1)
+            # vms = DGVertexMapper(e)
+            eductSmiles = [origSmiles[g] for g in vms.left]
+
+            for ev in vms.left.vertices:
+                s = eductSmiles[ev.graphIndex]
+                s = s.replace(f":o{ev.vertex.id}]", f":{ev.id}]")
+                eductSmiles[ev.graphIndex] = s
+
+            strs = set()
+            for vm in DGVertexMapper(e, rightLimit=1, leftLimit=1):
+                # for vm in DGVertexMapper(e):
+                productSmiles = [origSmiles[g] for g in vms.right]
+                for ev in vms.left.vertices:
+                    pv = vm.map[ev]
+                    if not pv:
+                        continue
+                    s = productSmiles[pv.graphIndex]
+                    s = s.replace(f":o{pv.vertex.id}]", f":{ev.id}]")
+                    productSmiles[pv.graphIndex] = s
+                count = vms.left.numVertices
+                for pv in vms.right.vertices:
+                    ev = vm.map.inverse(pv)
+                    if ev:
+                        continue
+                    s = productSmiles[pv.graphIndex]
+                    s = s.replace(f":o{pv.vertex.id}]", f":{count}]")
+                    count += 1
+                    productSmiles[pv.graphIndex] = s
+                left = ".".join(eductSmiles)
+                right = ".".join(productSmiles)
+                s = f"{left}>>{right}"
+                assert ":o" not in s
+                strs.add(s)
+            res[e] = list(sorted(strs))
+        return res
+
+    @staticmethod
+    def parseReactionSmiles(line: str) -> Rule:
+        sLeft, sRight = line.split(">>")
+        ssLeft = sLeft.split(".")
+        ssRight = sRight.split(".")
+        mLeft = [smiles(s, add=False) for s in ssLeft]
+        mRight = [smiles(s, add=False) for s in ssRight]
+
+        def printGraph(g):
+            extFromInt = {}
+            for iExt in range(g.minExternalId, g.maxExternalId + 1):
+                v = g.getVertexFromExternalId(iExt)
+                if not v.isNull():
+                    extFromInt[v] = iExt
+            s = ""
+            for v in g.vertices:
+                assert v in extFromInt
+                s += '\t\tnode [ id %d label "%s" ]\n' % (extFromInt[v], v.stringLabel)
+            for e in g.edges:
+                s += '\t\tedge [ source %d target %d label "%s" ]\n' % (
+                    extFromInt[e.source],
+                    extFromInt[e.target],
+                    e.stringLabel,
+                )
+            return s
+
+        s = "rule [\n\tleft [\n"
+        for m in mLeft:
+            s += printGraph(m)
+        s += "\t]\n\tright [\n"
+        for m in mRight:
+            s += printGraph(m)
+        s += "\t]\n]\n"
+        return s, Rule.fromGMLString(s, add=False)
+
+    def fit(self, dg, origSmiles):
+        """
+        Matches the original SMILES to a list of generated reaction SMILES and
+        returns the parsed reaction.
+
+        Parameters:
+        - dg (DataGenerator): The data generator instance containing the reactions.
+        - origSmiles (str): The original SMILES string to match.
+
+        Returns:
+        - Parsed reaction if a match is found; otherwise, None.
+        """
+        try:
+            res = DGToGML.getReactionSmiles(dg)
+            smiles_list = [value for values in res.values() for value in values]
+
+            smiles_standard = [
+                self.standardizer.fit(rsmi, True, True) for rsmi in smiles_list
+            ]
+            origSmiles_standard = self.standardizer.fit(origSmiles, True, True)
+
+            for index, value in enumerate(smiles_standard):
+                if value == origSmiles_standard:
+                    return self.parseReactionSmiles(smiles_list[index])
+
+            return None
+        except Exception as e:
+            logger.error(f"An error occurred: {e}")
+            return None

synkit/IO/gml_to_nx.py

@@ -0,0 +1,119 @@
+import re
+import networkx as nx
+from typing import Tuple
+from synkit.ITS.its_construction import ITSConstruction
+
+
+class GMLToNX:
+    def __init__(self, gml_text: str):
+        """
+        Initializes a GMLToNX object that can parse GML-like text into separate
+        NetworkX graphs representing different stages or components of a chemical reaction.
+        """
+        self.gml_text = gml_text
+        self.graphs = {"left": nx.Graph(), "context": nx.Graph(), "right": nx.Graph()}
+
+    def _parse_element(self, line: str, current_section: str):
+        """
+        Parses a line of GML-like text to extract node or edge data and adds it to the
+        current section's graph.
+        """
+        label_to_order = {"-": 1, ":": 1.5, "=": 2, "#": 3}
+        tokens = line.split()
+
+        if "node" in line:
+            node_id = int(tokens[tokens.index("id") + 1])
+            label = tokens[tokens.index("label") + 1].strip('"')
+            element, charge = self._extract_element_and_charge(label)
+            node_attributes = {
+                "element": element,
+                "charge": charge,
+                "atom_map": node_id,
+            }
+            self.graphs[current_section].add_node(node_id, **node_attributes)
+
+        elif "edge" in line:
+            source = int(tokens[tokens.index("source") + 1])
+            target = int(tokens[tokens.index("target") + 1])
+            label = tokens[tokens.index("label") + 1].strip('"')
+            order = label_to_order.get(label, 0)
+            self.graphs[current_section].add_edge(source, target, order=order)
+
+    def _extract_element_and_charge(self, label: str) -> Tuple[str, int]:
+        """
+        Extracts the chemical element and its charge from a node label.
+        """
+        match = re.match(r"([A-Za-z*]+)(\d+)?([+-])?$", label)
+        if not match:
+            return ("X", 0)
+        element = match.group(1)
+        num = match.group(2)
+        sign = match.group(3)
+        charge = 0
+        if sign:
+            charge_val = int(num) if num else 1
+            charge = charge_val if sign == "+" else -charge_val
+        return element, charge
+
+    def _synchronize_nodes_and_edges(self):
+        """
+        Ensures that all nodes and edges in 'context' appear in both 'left' and 'right'.
+        We do not remove edges from left or right if they are not in context.
+        We only add missing context nodes and edges to left and right.
+        """
+        # Add missing context nodes to left and right
+        for node, ndata in self.graphs["context"].nodes(data=True):
+            if node not in self.graphs["left"]:
+                self.graphs["left"].add_node(node, **ndata)
+            else:
+                # Merge attributes if node already exists in left
+                for k, v in ndata.items():
+                    self.graphs["left"].nodes[node][k] = v
+
+            if node not in self.graphs["right"]:
+                self.graphs["right"].add_node(node, **ndata)
+            else:
+                # Merge attributes if node already exists in right
+                for k, v in ndata.items():
+                    self.graphs["right"].nodes[node][k] = v
+
+        # Add missing context edges to left and right
+        for s, t, edata in self.graphs["context"].edges(data=True):
+            if not self.graphs["left"].has_edge(s, t):
+                self.graphs["left"].add_edge(s, t, **edata)
+            if not self.graphs["right"].has_edge(s, t):
+                self.graphs["right"].add_edge(s, t, **edata)
+
+    def transform(self) -> Tuple[nx.Graph, nx.Graph, nx.Graph]:
+        """
+        Transforms the GML-like text into three NetworkX graphs: left, right, and context.
+        """
+        current_section = None
+        lines = self.gml_text.split("\n")
+        for line in lines:
+            line = line.strip()
+            if line.startswith("rule") or line == "]":
+                continue
+            if any(section in line for section in ["left", "context", "right"]):
+                current_section = line.split("[")[0].strip()
+                continue
+            if line.startswith("node") or line.startswith("edge"):
+                self._parse_element(line, current_section)
+
+        # Synchronize after parsing
+        self._synchronize_nodes_and_edges()
+
+        # Create the ITS graph
+        its_graph = ITSConstruction.ITSGraph(self.graphs["left"], self.graphs["right"])
+
+        # Restore node attributes in ITS graph from left (or right)
+        for n in its_graph.nodes():
+            if n in self.graphs["left"].nodes:
+                for k, v in self.graphs["left"].nodes[n].items():
+                    its_graph.nodes[n][k] = v
+
+        self.graphs["context"] = ITSConstruction.ITSGraph(
+            self.graphs["left"], self.graphs["right"]
+        )
+
+        return self.graphs["left"], self.graphs["right"], self.graphs["context"]