synkit 1.6.5__py3-none-win_amd64.whl

synkit/Graph/ITS/its_relabel.py

@@ -0,0 +1,187 @@
+from __future__ import annotations
+from typing import Any, Dict, Iterable, List, Tuple
+from rdkit import Chem
+
+from synkit.Graph.syn_graph import SynGraph
+from synkit.IO import setup_logging
+from synkit.IO.graph_to_mol import GraphToMol
+from synkit.IO.chem_converter import smiles_to_graph
+from synkit.Graph.Matcher.graph_morphism import find_graph_isomorphism
+
+logger = setup_logging("INFO")
+
+
+class ITSRelabel:
+    """Extend reaction SMILES through atom-map alignment between reactant and
+    product SynGraphs.
+
+    :cvar logger: Logger instance for debug and info messages.
+    :type logger: logging.Logger
+    :ivar graph_to_mol: Converter from SynGraph to RDKit Mol.
+    :type graph_to_mol: GraphToMol
+    """
+
+    def __init__(self) -> None:
+        """Initialize ITSRelabel with default GraphToMol converter."""
+        self.graph_to_mol = GraphToMol()
+
+    @staticmethod
+    def _get_nodes_with_atom_map(graph: SynGraph) -> List[Any]:
+        """Extract node IDs with a non-zero atom_map attribute from a SynGraph.
+
+        :param graph: Input SynGraph with 'atom_map' on nodes.
+        :type graph: SynGraph
+        :return: List of node identifiers where 'atom_map' != 0.
+        :rtype: List[Any]
+        """
+        return [
+            n
+            for n, attrs in graph.raw.nodes(data=True)
+            if attrs.get("atom_map", 0) != 0
+        ]
+
+    @staticmethod
+    def _remove_internal_edges(graph: SynGraph, nodes: List[Any]) -> SynGraph:
+        """Remove edges connecting nodes in the given list from a SynGraph.
+
+        :param graph: Input SynGraph to prune.
+        :type graph: SynGraph
+        :param nodes: Node IDs whose connecting edges will be removed.
+        :type nodes: List[Any]
+        :return: A new SynGraph with specified edges removed.
+        :rtype: SynGraph
+        """
+        G_copy = SynGraph(graph.raw.copy())
+        node_set = set(nodes)
+        edges_to_remove = [
+            (u, v) for u, v in G_copy.raw.edges() if u in node_set and v in node_set
+        ]
+        G_copy.raw.remove_edges_from(edges_to_remove)
+        return G_copy
+
+    @staticmethod
+    def _dict_to_tuple_list(
+        mapping: Dict[Any, Any], sort_by_key: bool = False, sort_by_value: bool = False
+    ) -> List[Tuple[Any, Any]]:
+        """Convert a mapping dict into a sorted list of tuples.
+
+        :param mapping: Dictionary to convert.
+        :type mapping: Dict[Any, Any]
+        :param sort_by_key: Sort tuples by key if True.
+        :type sort_by_key: bool
+        :param sort_by_value: Sort tuples by value if True.
+        :type sort_by_value: bool
+        :return: List of (key, value) tuples.
+        :rtype: List[Tuple[Any, Any]]
+        """
+        items = list(mapping.items())
+        if sort_by_key:
+            items.sort(key=lambda x: x[0])
+        elif sort_by_value:
+            items.sort(key=lambda x: x[1])
+        return items
+
+    def _update_mapping(
+        self,
+        G: SynGraph,
+        H: SynGraph,
+        mapping: Iterable[Tuple[Any, Any]],
+        aam_key: str = "atom_map",
+    ) -> Tuple[SynGraph, SynGraph]:
+        """Update node attributes in two SynGraphs based on a sequential
+        mapping.
+
+        This method resets the specified atom-map attribute for all
+        nodes in both graphs to 0, then assigns a new atom-map value
+        (i+1) for each mapped pair:     G.nodes[g_node][aam_key] = i + 1
+        H.nodes[h_node][aam_key] = i + 1
+
+        :param G: First SynGraph to update (reactant).
+        :type G: SynGraph
+        :param H: Second SynGraph to update (product).
+        :type H: SynGraph
+        :param mapping: Iterable of (g_node, h_node) tuples defining
+            node correspondence.
+        :type mapping: Iterable[Tuple[Any, Any]]
+        :param aam_key: Name of the atom-map attribute on each node.
+        :type aam_key: str
+        :return: Tuple of updated SynGraphs (G_updated, H_updated).
+        :rtype: Tuple[SynGraph, SynGraph]
+        """
+        # Create deep copies of raw graphs
+        G_copy = SynGraph(G.raw.copy())
+        H_copy = SynGraph(H.raw.copy())
+
+        # Reset atom-map to zero for all nodes
+        for node in G_copy.raw.nodes():
+            G_copy.raw.nodes[node][aam_key] = 0
+        for node in H_copy.raw.nodes():
+            H_copy.raw.nodes[node][aam_key] = 0
+
+        # Assign new sequential mapping values
+        for i, (g_node, h_node) in enumerate(mapping):
+            value = i + 1
+            if g_node in G_copy.raw:
+                G_copy.raw.nodes[g_node][aam_key] = value
+            else:
+                logger.warning(f"Node {g_node} not found in reactant graph")
+            if h_node in H_copy.raw:
+                H_copy.raw.nodes[h_node][aam_key] = value
+            else:
+                logger.warning(f"Node {h_node} not found in product graph")
+
+        return G_copy, H_copy
+
+    def fit(self, rsmi: str) -> str:
+        """Generate an extended reaction SMILES by aligning atom maps of
+        reactant and product.
+
+        :param rsmi: Reaction SMILES string formatted as 'reactant>>product'.
+        :type rsmi: str
+        :return: Extended reaction SMILES after remapping.
+        :rtype: str
+        :raises ValueError: If input format is invalid or graphs are not isomorphic.
+
+        .. rubric:: Examples
+
+        >>> its = ITSRelabel()
+        >>> its.fit('CCO:1>>CC=O:1')
+        'CCO>>CC=O'
+        """
+        # Parse reaction SMILES
+        try:
+            react_smiles, prod_smiles = rsmi.split(">>")
+        except ValueError as e:
+            raise ValueError("Expected 'reactant>>product' format") from e
+
+        # Convert to SynGraphs
+        G = SynGraph(
+            smiles_to_graph(
+                react_smiles, drop_non_aam=False, use_index_as_atom_map=False
+            )
+        )
+        H = SynGraph(
+            smiles_to_graph(
+                prod_smiles, drop_non_aam=False, use_index_as_atom_map=False
+            )
+        )
+
+        # Identify and prune mapped nodes
+        R_nodes = self._get_nodes_with_atom_map(G)
+        P_nodes = self._get_nodes_with_atom_map(H)
+        Gp = self._remove_internal_edges(G, R_nodes)
+        Hp = self._remove_internal_edges(H, P_nodes)
+
+        # Find isomorphism mapping
+        mapping = find_graph_isomorphism(Gp.raw, Hp.raw, use_defaults=True)
+        if not mapping:
+            raise ValueError("No isomorphism found between pruned graphs")
+
+        # Update atom_map attributes
+        mapped_pairs = self._dict_to_tuple_list(mapping, sort_by_key=True)
+        G_new, H_new = self._update_mapping(G, H, mapped_pairs, aam_key="atom_map")
+
+        # Convert back to molecules and SMILES
+        mol_G = self.graph_to_mol.graph_to_mol(G_new.raw, use_h_count=True)
+        mol_H = self.graph_to_mol.graph_to_mol(H_new.raw, use_h_count=True)
+        return f"{Chem.MolToSmiles(mol_G)}>>{Chem.MolToSmiles(mol_H)}"

synkit/Graph/ITS/its_reverter.py

@@ -0,0 +1,356 @@
+from __future__ import annotations
+
+from typing import Any, Literal, Optional
+import networkx as nx
+
+Side = Literal["reactant", "product", "r", "p", 0, 1]
+
+
+class ITSReverter:
+    """Reconstruct reactant/product molecular graphs from an ITS-style graph.
+
+    Expected ITS format
+    -------------------
+    Nodes store paired attributes such as::
+
+        element=('C', 'C')
+        charge=(0, 0)
+        hcount=(3, 3)
+
+    Edges store paired attributes such as::
+
+        order=(1.0, 0.0)
+        bond_type=('SINGLE', '')
+        conjugated=(False, False)
+
+    where index 0 = reactant side and index 1 = product side.
+
+    .. rubric:: Notes
+
+    - ``typesGH`` is not required for reconstruction.
+    - ``standard_order`` is a reaction-delta attribute and is not used to rebuild
+      a side-specific molecular graph.
+    - By default, isolated atoms are kept. This is important for cases where a
+      mapped atom becomes disconnected on one side.
+
+    .. rubric:: Example
+
+    .. code-block:: python
+
+        reverter = ITSReverter(its)
+
+        g_reactant = reverter.to_reactant_graph()
+        g_product = reverter.to_product_graph()
+
+        print(g_reactant.nodes(data=True))
+        print(g_product.edges(data=True))
+    """
+
+    #: node attributes commonly stored in ITS and worth restoring
+    DEFAULT_NODE_ATTRS = (
+        "element",
+        "aromatic",
+        "hcount",
+        "charge",
+        "hybridization",
+        "neighbors",
+        "atom_map",
+        "lone_pairs",
+        "radical",
+        "valence_electrons",
+        "h_pairs",
+        "h_pairs_left",
+        "h_pairs_right",
+        "h_pair_atom_maps",
+    )
+
+    #: edge attributes commonly stored in ITS and worth restoring
+    DEFAULT_EDGE_ATTRS = (
+        "kekule_order",
+        "sigma_order",
+        "pi_order",
+        "order",
+        "bond_type",
+        "conjugated",
+        "in_ring",
+    )
+
+    def __init__(self, its_graph: nx.Graph):
+        """
+        :param its_graph: ITS graph with paired node/edge attributes.
+        :type its_graph: nx.Graph
+        """
+        self.its_graph = its_graph
+
+    @staticmethod
+    def _side_to_index(side: Side) -> int:
+        """Convert side identifier to tuple index.
+
+        :param side: Side specifier.
+        :type side: Side
+        :return: 0 for reactant, 1 for product.
+        :rtype: int
+        :raises ValueError: If the side is invalid.
+        """
+        if side in ("reactant", "r", 0):
+            return 0
+        if side in ("product", "p", 1):
+            return 1
+        raise ValueError(f"Unsupported side: {side!r}")
+
+    @staticmethod
+    def _pick_side_value(value: Any, idx: int) -> Any:
+        """Pick one side from a paired ITS attribute.
+
+        If ``value`` is a 2-tuple, return the selected side.
+        Otherwise return the value unchanged.
+
+        :param value: Attribute value.
+        :type value: Any
+        :param idx: Side index.
+        :type idx: int
+        :return: Side-specific value.
+        :rtype: Any
+        """
+        if isinstance(value, tuple) and len(value) == 2:
+            return value[idx]
+        return value
+
+    @classmethod
+    def _node_exists_on_side(cls, attrs: dict[str, Any], idx: int) -> bool:
+        """Decide whether a node exists on a given side.
+
+        A node is treated as present if its side-specific ``element`` is not empty.
+
+        :param attrs: ITS node attributes.
+        :type attrs: dict[str, Any]
+        :param idx: Side index.
+        :type idx: int
+        :return: Whether the node exists on that side.
+        :rtype: bool
+        """
+        present = attrs.get("present")
+        if isinstance(present, tuple) and len(present) == 2:
+            return bool(present[idx])
+
+        element = cls._pick_side_value(attrs.get("element"), idx)
+        return element not in (None, "")
+
+    @classmethod
+    def _edge_exists_on_side(cls, attrs: dict[str, Any], idx: int) -> bool:
+        """Decide whether an edge exists on a given side.
+
+        Priority:
+        1. ``order``
+        2. ``kekule_order``
+        3. ``bond_type``
+
+        :param attrs: ITS edge attributes.
+        :type attrs: dict[str, Any]
+        :param idx: Side index.
+        :type idx: int
+        :return: Whether the bond exists on that side.
+        :rtype: bool
+        """
+        order = cls._pick_side_value(attrs.get("order"), idx)
+        if order not in (None, "", 0, 0.0):
+            return True
+
+        kekule_order = cls._pick_side_value(attrs.get("kekule_order"), idx)
+        if kekule_order not in (None, "", 0, 0.0):
+            return True
+
+        bond_type = cls._pick_side_value(attrs.get("bond_type"), idx)
+        if bond_type not in (None, ""):
+            return True
+
+        return False
+
+    @classmethod
+    def _extract_side_attrs(
+        cls,
+        attrs: dict[str, Any],
+        idx: int,
+        keep_keys: Optional[tuple[str, ...]] = None,
+        exclude_keys: Optional[set[str]] = None,
+    ) -> dict[str, Any]:
+        """Extract side-specific attributes from a paired ITS attribute dict.
+
+        :param attrs: ITS attribute dictionary.
+        :type attrs: dict[str, Any]
+        :param idx: Side index.
+        :type idx: int
+        :param keep_keys: Optional whitelist of keys to keep.
+        :type keep_keys: Optional[tuple[str, ...]]
+        :param exclude_keys: Optional set of keys to exclude.
+        :type exclude_keys: Optional[set[str]]
+        :return: Flattened side-specific attribute dictionary.
+        :rtype: dict[str, Any]
+        """
+        out: dict[str, Any] = {}
+        exclude_keys = exclude_keys or set()
+
+        for key, value in attrs.items():
+            if keep_keys is not None and key not in keep_keys:
+                continue
+            if key in exclude_keys:
+                continue
+            out[key] = cls._pick_side_value(value, idx)
+
+        return out
+
+    @staticmethod
+    def _recompute_neighbors(graph: nx.Graph) -> None:
+        """
+        Recompute ``neighbors`` attribute from graph connectivity.
+
+        The value is stored as a sorted list of neighboring element symbols.
+
+        :param graph: Molecular graph.
+        :type graph: nx.Graph
+        """
+        for node in graph.nodes:
+            neighbor_elements = []
+            for nb in graph.neighbors(node):
+                elem = graph.nodes[nb].get("element")
+                neighbor_elements.append(elem)
+            graph.nodes[node]["neighbors"] = sorted(neighbor_elements)
+
+    def to_graph(
+        self,
+        side: Side,
+        node_attrs: Optional[tuple[str, ...]] = None,
+        edge_attrs: Optional[tuple[str, ...]] = None,
+        recompute_neighbors: bool = False,
+        drop_isolated: bool = False,
+    ) -> nx.Graph:
+        """Reconstruct one side-specific molecular graph.
+
+        :param side:
+            Which side to reconstruct.
+            Accepted values: ``"reactant"``, ``"product"``, ``"r"``, ``"p"``, ``0``, ``1``.
+        :type side: Side
+        :param node_attrs:
+            Node attribute keys to keep. If ``None``, uses ``DEFAULT_NODE_ATTRS``.
+        :type node_attrs: Optional[tuple[str, ...]]
+        :param edge_attrs:
+            Edge attribute keys to keep. If ``None``, uses ``DEFAULT_EDGE_ATTRS``.
+        :type edge_attrs: Optional[tuple[str, ...]]
+        :param recompute_neighbors:
+            If ``True``, overwrite the stored ``neighbors`` attribute using the
+            reconstructed graph connectivity.
+        :type recompute_neighbors: bool
+        :param drop_isolated:
+            If ``True``, remove nodes with degree 0 after reconstruction.
+            Default is ``False`` so disconnected mapped atoms are preserved.
+        :type drop_isolated: bool
+        :return:
+            Side-specific molecular graph.
+        :rtype: nx.Graph
+        """
+        idx = self._side_to_index(side)
+        node_attrs = node_attrs or self.DEFAULT_NODE_ATTRS
+        edge_attrs = edge_attrs or self.DEFAULT_EDGE_ATTRS
+
+        g = nx.Graph()
+
+        # nodes
+        for node, attrs in self.its_graph.nodes(data=True):
+            if not self._node_exists_on_side(attrs, idx):
+                continue
+
+            flat_node_attrs = self._extract_side_attrs(
+                attrs=attrs,
+                idx=idx,
+                keep_keys=node_attrs,
+                exclude_keys={"typesGH"},
+            )
+            g.add_node(node, **flat_node_attrs)
+
+        # edges
+        for u, v, attrs in self.its_graph.edges(data=True):
+            if u not in g or v not in g:
+                continue
+            if not self._edge_exists_on_side(attrs, idx):
+                continue
+
+            flat_edge_attrs = self._extract_side_attrs(
+                attrs=attrs,
+                idx=idx,
+                keep_keys=edge_attrs,
+                exclude_keys={"standard_order"},
+            )
+            g.add_edge(u, v, **flat_edge_attrs)
+
+        if recompute_neighbors:
+            self._recompute_neighbors(g)
+
+        if drop_isolated:
+            isolates = list(nx.isolates(g))
+            g.remove_nodes_from(isolates)
+
+        stereo = self.its_graph.graph.get("stereo_descriptors", {})
+        if isinstance(stereo, dict) and ("reactant" in stereo or "product" in stereo):
+            side_name = "reactant" if idx == 0 else "product"
+            g.graph["stereo_descriptors"] = dict(stereo.get(side_name, {}))
+            g.graph["stereo_projection"] = side_name
+        elif isinstance(stereo, dict):
+            g.graph["stereo_descriptors"] = dict(stereo)
+
+        return g
+
+    def to_reactant_graph(
+        self,
+        recompute_neighbors: bool = False,
+        drop_isolated: bool = False,
+    ) -> nx.Graph:
+        """Reconstruct the reactant-side graph.
+
+        :param recompute_neighbors: Whether to recompute ``neighbors``.
+        :type recompute_neighbors: bool
+        :param drop_isolated: Whether to remove isolated nodes.
+        :type drop_isolated: bool
+        :return: Reactant molecular graph.
+        :rtype: nx.Graph
+        """
+        return self.to_graph(
+            side="reactant",
+            recompute_neighbors=recompute_neighbors,
+            drop_isolated=drop_isolated,
+        )
+
+    def to_product_graph(
+        self,
+        recompute_neighbors: bool = False,
+        drop_isolated: bool = False,
+    ) -> nx.Graph:
+        """Reconstruct the product-side graph.
+
+        :param recompute_neighbors: Whether to recompute ``neighbors``.
+        :type recompute_neighbors: bool
+        :param drop_isolated: Whether to remove isolated nodes.
+        :type drop_isolated: bool
+        :return: Product molecular graph.
+        :rtype: nx.Graph
+        """
+        return self.to_graph(
+            side="product",
+            recompute_neighbors=recompute_neighbors,
+            drop_isolated=drop_isolated,
+        )
+
+    def to_transition_state_graph(self) -> nx.Graph:
+        """Return an ITS projection carrying only transition-state stereo.
+
+        Structural node and edge attributes remain paired because the ITS is
+        SynKit's transition-state representation. The stereo registry is
+        flattened to the optional ``transition`` descriptors so ordinary
+        registry consumers can inspect fleeting stereo without confusing it
+        with either stable endpoint.
+        """
+        graph = self.its_graph.copy()
+        stereo = self.its_graph.graph.get("stereo_descriptors", {})
+        transition = stereo.get("transition", {}) if isinstance(stereo, dict) else {}
+        graph.graph["stereo_descriptors"] = dict(transition)
+        graph.graph["stereo_projection"] = "transition"
+        return graph

synkit/Graph/ITS/normalize_aam.py

@@ -0,0 +1,145 @@
+import networkx as nx
+from rdkit import Chem
+from typing import List
+
+from synkit.IO.chem_converter import rsmi_to_graph
+from synkit.IO.graph_to_mol import GraphToMol
+from synkit.Chem.Reaction.fix_aam import FixAAM
+from synkit.Graph.Hyrogen._misc import implicit_hydrogen
+from synkit.Graph.ITS.its_construction import ITSConstruction
+from synkit.Graph.ITS.its_decompose import get_rc
+
+
+class NormalizeAAM:
+    """Provides functionalities to normalize atom mappings in SMILES
+    representations, extract and process reaction centers from ITS graphs, and
+    convert between graph representations and molecular models."""
+
+    def __init__(self) -> None:
+        """Initializes the NormalizeAAM class."""
+        pass
+
+    @staticmethod
+    def fix_rsmi_kekulize(rsmi: str) -> str:
+        """Filters the reactants and products of a reaction SMILES string.
+
+        :param rsmi: A string representing the reaction SMILES in the form of "reactants >> products".
+        :type rsmi: str
+
+        :return: A filtered reaction SMILES string where invalid reactants/products are removed.
+        :rtype: str
+        """
+        # Split the reaction into reactants and products
+        reactants, products = rsmi.split(">>")
+
+        # Filter valid reactants and products
+        filtered_reactants = NormalizeAAM.fix_kekulize(reactants)
+        filtered_products = NormalizeAAM.fix_kekulize(products)
+
+        # Return the filtered reaction SMILES
+        return f"{filtered_reactants}>>{filtered_products}"
+
+    @staticmethod
+    def fix_kekulize(smiles: str) -> str:
+        """Filters and returns valid SMILES strings from a string of SMILES,
+        joined by '.'.
+
+        This function processes a string of SMILES separated by periods (e.g., "CCO.CC=O"),
+        filters out invalid SMILES, and returns a string of valid SMILES joined by periods.
+
+        :param smiles: A string containing SMILES strings separated by periods ('.').
+        :type smiles: str
+
+        :return: A string of valid SMILES, joined by periods ('.').
+        :rtype: str
+        """
+        smiles_list = smiles.split(".")  # Split SMILES by period
+        valid_smiles = []  # List to store valid SMILES strings
+
+        for smile in smiles_list:
+            mol = Chem.MolFromSmiles(smile, sanitize=False)
+            if mol:  # Check if molecule is valid
+                valid_smiles.append(
+                    Chem.MolToSmiles(
+                        mol, canonical=True, kekuleSmiles=True, allHsExplicit=True
+                    )
+                )
+        return ".".join(valid_smiles)  # Return valid SMILES joined by '.'
+
+    @staticmethod
+    def extract_subgraph(graph: nx.Graph, indices: List[int]) -> nx.Graph:
+        """Extracts a subgraph from a given graph based on a list of node
+        indices.
+
+        :param graph: The original graph from which to extract the subgraph.
+        :type graph: nx.Graph
+        :param indices: A list of node indices that define the subgraph.
+        :type indices: List[int]
+
+        :return: The extracted subgraph.
+        :rtype: nx.Graph
+        """
+        return graph.subgraph(indices).copy()
+
+    def reset_indices_and_atom_map(
+        self, subgraph: nx.Graph, aam_key: str = "atom_map"
+    ) -> nx.Graph:
+        """Resets the node indices and the atom_map of the subgraph to be
+        continuous from 1 onwards.
+
+        :param subgraph: The subgraph with possibly non-continuous indices.
+        :type subgraph: nx.Graph
+        :param aam_key: The attribute key for atom mapping. Defaults to 'atom_map'.
+        :type aam_key: str
+
+        :return: A new subgraph with continuous indices and adjusted atom_map.
+        :rtype: nx.Graph
+        """
+        new_graph = nx.Graph()
+        node_id_mapping = {
+            old_id: new_id for new_id, old_id in enumerate(subgraph.nodes(), 1)
+        }
+        for old_id, new_id in node_id_mapping.items():
+            node_data = subgraph.nodes[old_id].copy()
+            node_data[aam_key] = new_id
+            new_graph.add_node(new_id, **node_data)
+            for u, v, data in subgraph.edges(data=True):
+                new_graph.add_edge(node_id_mapping[u], node_id_mapping[v], **data)
+        return new_graph
+
+    def fit(self, rsmi: str, fix_aam_indice: bool = True) -> str:
+        """Processes a reaction SMILES (RSMI) to adjust atom mappings, extract
+        reaction centers, decompose into separate reactant and product graphs,
+        and generate the corresponding SMILES.
+
+        :param rsmi: The reaction SMILES string to be processed.
+        :type rsmi: str
+        :param fix_aam_indice: Whether to fix the atom mapping numbers.
+                               Defaults to True.
+        :type fix_aam_indice: bool
+
+        :return: The resulting reaction SMILES string with updated atom mappings.
+        :rtype: str
+        """
+        rsmi = self.fix_rsmi_kekulize(rsmi)
+        if fix_aam_indice:
+            rsmi = FixAAM().fix_aam_rsmi(rsmi)
+        r_graph, p_graph = rsmi_to_graph(
+            rsmi,
+            sanitize=True,
+            use_index_as_atom_map=True,
+            drop_non_aam=True,
+        )
+        its = ITSConstruction().ITSGraph(r_graph, p_graph)
+        rc = get_rc(its)
+        list_hydrogen = []
+        for _, value in rc.nodes(data=True):
+            if value["element"] == "H":
+                list_hydrogen.append(value["atom_map"])
+        r_graph = implicit_hydrogen(r_graph, list_hydrogen)
+        p_graph = implicit_hydrogen(p_graph, list_hydrogen)
+
+        r_mol, p_mol = GraphToMol().graph_to_mol(
+            r_graph, sanitize=True, use_h_count=True
+        ), GraphToMol().graph_to_mol(p_graph, sanitize=True, use_h_count=True)
+        return f"{Chem.MolToSmiles(r_mol)}>>{Chem.MolToSmiles(p_mol)}"