chemrecon 0.1.1__py3-none-any.whl

chemrecon/chem/gml/gml.py

@@ -0,0 +1,324 @@
+""" Code to handle S_GML from Juri's M-CSA tool
+"""
+from __future__ import annotations
+
+import re
+from typing import Optional
+
+import matplotlib.pyplot as plt
+import networkx as nx
+from rdkit import Chem as rdk
+
+from chemrecon.chem.mol import Mol
+
+# Regex patterns
+rule_pattern = re.compile(
+    r'^rule \[(?:ruleID \".*\")?(?:left \[(.*?)\])?context \[(.*?)\](?:right \[(.*?)\])?\]$'
+)
+label_sub = re.compile(
+    r'id (\d+) label \"([A-Z][a-z]?\d?\+?\-?|Amino\(..?, ..., \d+, [\w|*]\)|Alias\(.,.\)|\*)\"'
+)
+label_rep = r'id \g<1> label "\g<1>: \g<2>"'
+
+
+def sanitise_gml(gml: str) -> str:
+    r = f'{gml}'
+    r.replace('\n', '').replace('\t', '')
+    return r
+
+
+class GMLException(Exception):
+    pass
+
+
+class GMLEmptyException(Exception):
+    pass
+
+
+class GMLEntry:
+    entry_index: int
+    proposals: list[list[GMLStep]]
+    map: dict[int, int]  # For proposal 0
+
+    def __init__(self, index: int):
+        self.entry_index = index
+        self.proposals = []
+
+    def add_step(self, proposal_index: int, step: GMLStep):
+        # Extend proposals list
+        while len(self.proposals) < proposal_index:
+            self.proposals.append([])
+
+        # Add step
+        self.proposals[proposal_index - 1].append(step)
+
+    def set_map(self, aam: dict[int, int]):
+        self.map = aam
+        sanity_check(self.left_graph(), self.right_graph(), self.map)
+
+    # Getters always get proposal 0 (best star rating in M-CSA)
+    def left_graph(self) -> GMLGraph:
+        return self.proposals[0][0].left_graph()
+
+    def right_graph(self) -> GMLGraph:
+        return self.proposals[0][-1].right_graph()
+
+    def atom_atom_map(self) -> dict[int, int]:
+        return self.map
+
+class GMLStep:
+    step_index: int
+    gml: str
+    lhs: GMLGraph
+    rhs: GMLGraph
+
+    # Pure gml
+    left_gml: str
+    context_gml: str
+    right_gml: str
+
+    def __init__(self, step_index: int, gml: str):
+        self.step_index = step_index
+        self.gml = str(gml).replace('\n', '').replace('\t', '')
+
+        # Make S_GML for educt and product sides
+        match = re.match(rule_pattern, self.gml)
+        self.left_gml = match.group(1)
+        self.context_gml = match.group(2)
+        self.right_gml = match.group(3)
+
+        lhs = (f'graph [\n {self.left_gml} {self.context_gml} \n]'
+               if self.left_gml else f'graph [\n{self.context_gml}\n]')
+        rhs = (f'graph [\n {self.context_gml} {self.right_gml} \n]'
+               if self.right_gml else f'graph [\n{self.context_gml}\n]')
+
+        self.lhs = GMLGraph(
+            gml = lhs
+        )
+        self.rhs = GMLGraph(
+            gml = rhs
+        )
+
+    def left_graph(self) -> GMLGraph:
+        return self.lhs
+
+    def right_graph(self) -> GMLGraph:
+        return self.rhs
+
+
+class GMLGraph:
+    graph: nx.Graph
+    gml: str
+    component_subsets: list[frozenset[int]]
+    component_subgraphs: list[nx.Graph]
+
+    def __init__(self, gml: str, graph: nx.Graph = None):
+        self.gml = sanitise_gml(gml)
+
+        # TODO raise exception of called with empty graph
+
+        if graph:
+            self.graph = graph
+        else:
+            # Make graph from gml
+            self.graph = nx.parse_gml(
+                gml,
+                label = 'id'
+            )
+        self.component_subgraphs = []
+        self.component_subsets = []
+
+    def get_component_subsets(self) -> list[frozenset[int]]:
+        if not self.component_subsets:
+            self.component_subsets = list(
+                frozenset(s)
+                for s in nx.connected_components(self.graph)
+            )
+        return self.component_subsets
+
+    def get_components_subgraphs(self) -> list[nx.Graph]:
+        if self.component_subgraphs:
+            return self.component_subgraphs
+        else:
+            if not self.component_subsets:
+                # Make subsets
+                self.get_component_subsets()
+            # Set the subgraphs
+            self.component_subgraphs = [
+                nx.subgraph(self.graph, compset) for compset in self.component_subsets
+            ]
+            return self.component_subgraphs
+
+    def remove_hydrogens(self):
+        g_ = self.graph.copy()
+        to_remove: list = list()
+        for n in g_.nodes():
+            if g_.nodes[n]['label'] == 'H' and g_.degree[n] > 0:
+                to_remove.append(n)
+        g_.remove_nodes_from(to_remove)
+        self.graph = g_
+
+    def get_subgraph(self, indices: set[int]) -> nx.Graph:
+        return self.graph.subgraph(indices)
+
+    def draw(self):
+        # Draw with networkx and matplotlib - need to display atom numbers on label!
+        plt.figure(1, figsize = (8, 8), dpi = 240)
+        pos = nx.spring_layout(self.graph)
+
+        # Graph structure and node labels
+        nx.draw(
+            self.graph, pos,
+            with_labels = True,
+            node_size = 50,
+            font_size = 6,
+            labels = {
+                k: f"{k}: {n['label']}" for k, n in self.graph.nodes.items()
+            }
+        )
+
+        # Edge labels
+        edict = dict()
+        for (u, v, d) in self.graph.edges.data('label'):
+            edict[(u, v)] = d
+
+        nx.draw_networkx_edge_labels(
+            self.graph, pos, edict, font_color = 'blue', font_size = 6
+        )
+
+        # Display graph
+        plt.show()
+        # TODO
+
+
+# ChemGraph generation
+def chemgraph_from_mol(mol: Mol) -> GMLGraph:
+    # Based on an RDK mol, create a ChemGraph object.
+    struct_graph = nx.Graph()
+    for atom in mol.mol.GetAtoms():
+        # Make the label based on element and charge
+        fcharge = atom.GetFormalCharge()
+        symbol = atom.GetSymbol()
+
+        # Do not include hydrogen
+        if symbol == 'H' and len(atom.GetNeighbors()) > 0:
+            continue
+
+        # Make label
+        label: str = 'ERR'
+        match fcharge:
+            case 0:
+                label = symbol
+            case -1:
+                label = f'{symbol}-'
+            case 1:
+                label = f'{symbol}+'
+            case _ if fcharge < 0:
+                label = f'{symbol}{fcharge}-'
+            case _ if fcharge >= 0:
+                label = f'{symbol}{fcharge}+'
+
+        struct_graph.add_node(
+            atom.GetIdx(),
+            label = label
+        )
+
+    for bond in mol.mol.GetBonds():
+        label: str = 'ERR'
+        match bond.GetBondType():
+            case rdk.BondType.SINGLE:
+                label = '-'
+            case rdk.BondType.DOUBLE:
+                label = '='
+            case rdk.BondType.TRIPLE:
+                label = '#'
+            case rdk.BondType.AROMATIC:
+                label = ':'
+            case _:
+                raise RuntimeError(f'Unimplemented bond-type {bond.GetBondType()}')
+
+        struct_graph.add_edge(
+            bond.GetBeginAtomIdx(),
+            bond.GetEndAtomIdx(),
+            label = label
+        )
+
+    # Finalize and add the graph to the list of graphs to match
+    cgraph = GMLGraph(
+        gml = '',
+        graph = struct_graph
+    )
+    return cgraph
+
+
+# Entry serialisation
+# ----------------------------------------------------------------------------------------------------------------------
+def graph_to_gml(graph: nx.Graph, relabel_map: Optional[dict[int, int]] = None) -> str:
+    """ Only returns 'inner' gml.
+    """
+    if relabel_map is None:
+        relabel_map = {x: x for x in graph.nodes}
+
+    s = '[\n'
+    # s = 'graph [\n'
+    # Nodes
+    for n_index in graph.nodes:
+        label = graph.nodes[n_index]['label']
+        s += f'\tnode [ id {relabel_map[n_index]} label "{label}"]\n'
+
+    # Edges
+    for x, y in graph.edges:
+        label = graph.edges[(x, y)]['label']
+        s += f'\tedge [ source {relabel_map[x]} target {relabel_map[y]} label "{label}" ]\n'
+    s += '\n]'
+    return s
+
+# Reaction graph sanitation and handling -------------------------------------------------------------------------------
+def remove_residues(
+    chemgraph: GMLGraph
+) -> GMLGraph:
+    """ Given a chemgraph representing either side of a reaction, return the same graph with identified
+        catalytic enzyme residues removed.
+    """
+    g: nx.Graph = chemgraph.graph
+    remove_nodes: set = set()  #
+
+    components = list(nx.connected_components(g))
+    for component in components:
+        for v in component:
+            l: str = g.nodes[v]['label']
+            if l.startswith('Amino'):
+                # Remove the entire component if it contains an amino acid
+                remove_nodes = remove_nodes.union(component)
+                break
+
+    # Remove the nodes
+    g_ = g.copy(as_view = False)
+    g_.remove_nodes_from(remove_nodes)
+    if g_.number_of_nodes() == 0:
+        raise GMLEmptyException
+    return GMLGraph(gml = '', graph = g_)
+
+
+# Misc
+# --------------------------------------------------------------------------------------------------------------
+# Matching functions for graph similarity
+def nmatch(n1, n2):
+    try:
+        return n1['label'] == n2['label']
+    except KeyError:
+        return 1
+
+
+def ematch(e1, e2):
+    try:
+        return e1['label'] == e2['label']
+    except KeyError:
+        return 1
+
+def sanity_check(l_graph: GMLGraph, r_graph: GMLGraph, map: dict[int, int]):
+    for l_index, r_index in map.items():
+        l_label: str = l_graph.graph.nodes[l_index]['label']
+        r_label: str = r_graph.graph.nodes[r_index]['label']
+        if l_label.removesuffix('-').removesuffix('+') != r_label.removesuffix('-').removesuffix('+'):
+            assert False, 'Wrong match'

chemrecon/chem/gml/gml_reactant_matching.py

@@ -0,0 +1,130 @@
+from __future__ import annotations
+
+import networkx as nx
+
+from chem.elements import ChemGraph, chemgraph_from_mol, ematch, nmatch
+from chem.elements import mol_from_structurerepresentation
+from chemrecon.core.query_handler import QueryHandler
+from chemrecon.schema.entry_types.compound import Compound
+from chemrecon.schema.entry_types.reaction import Reaction
+from chemrecon.schema.relation_types_source.compound_has_structure_representation_relation import \
+    CompoundHasStructureRepresentation
+from chemrecon.schema.relation_types_source.reaction_involves_compound_relation import ReactionInvolvesCompound
+from utils import hungarian as hungarian
+
+
+# TODO change to use the general reactant_matching with ChemReactions
+
+def match_reactants(
+    handler: QueryHandler,
+    procedure: Procedure,
+    chemgraph: ChemGraph,
+    reaction: Reaction,
+    side: int  # -1 or 1
+) -> dict[frozenset[int], tuple[Compound, int]]:
+    """ Given a left or right S_GML of a reaction (already sanitised by removing enzymes), tries to match the
+        components of the graph to a list of entries with known structures using graph similarity. Returns a
+        mapping, from each reactant (compound, multiplicity index), to the set of nodes with which they
+        were identified.
+    """
+
+    # TODO eventually replace the structure getting alg. with entry graph-based approach
+
+    # Get participant compounds
+    reaction_all_compounds: list[tuple[Compound, int]] = list()  # With stoich
+    compound_result_dict = handler.get_relations_with_entries_by_recon_ids_of_t1(
+        entry_type = Reaction,
+        recon_ids = [reaction.recon_id],
+        relation_type = ReactionInvolvesCompound,
+    )[0]
+    for compound_entry, relations in compound_result_dict.items():
+        relations: list[ReactionInvolvesCompound]
+        for relation in relations:
+            reaction_all_compounds.append(
+                (compound_entry, relation.n)
+            )
+
+    # Get existing structures for the attached compounds (converted to chemgraph objects?)
+    compound_graphs: dict[Compound, ChemGraph] = dict()
+    for compound_entry, stoich in reaction_all_compounds:
+        # Only take compounds on the correct side
+        if stoich * side < 0:
+            continue
+
+        # Get structures
+        struct_repr_relations = handler.get_relations_with_entries_by_recon_ids_of_t1(
+            entry_type = Compound,
+            recon_ids = [compound_entry.recon_id],
+            relation_type = CompoundHasStructureRepresentation
+        )
+        struct_reprs = struct_repr_relations[0].keys()
+
+        # For now, select an arbitrary structure
+        try:
+            struct_repr = list(struct_reprs)[0]
+        except IndexError:
+            # No structures found
+            continue
+
+        # Convert the selected structure to a S_GML ChemGraph
+        compound_graphs[compound_entry] = chemgraph_from_mol(mol_from_structurerepresentation(struct_repr))
+
+    # Perform the matching algorithm on match_structures against components of the given chemgraph
+    chemgraph.remove_hydrogens()
+    component_subsets: list[frozenset[int]] = chemgraph.get_component_subsets()
+    component_subgraphs: list[nx.Graph] = chemgraph.get_components_subgraphs()
+
+    # Log an error if component numbers don't match
+    if len(component_subgraphs) != len(compound_graphs):
+        # TODO Try to fix this by balancing cofactors etc
+        # TODO May be extra hydrons, water etc
+        # TODO  - entry #6 has an extra water on both sides for instance
+        procedure.log_notice(f'Could not get structures for all components.'
+                             f' Reaction {reaction} (side {side}).'
+                             f' Number of S_GML graph components ({len(component_subgraphs)})'
+                             f' does not match number of reactants ({len(compound_graphs)}).')
+
+    # Pairwise similarity (maps from each compound to the index of the component and the similarity)
+    graph_distance_pairwise: dict[Compound, list[tuple[int, float]]] = dict()
+
+    # Compute the similarity
+    for compound_entry, compound_chemgraph in compound_graphs.items():
+        component_distances: list[tuple[int, float]] = list()
+        for component_index, component in enumerate(component_subgraphs):
+            # nx.optimize_graph_edit_distance is a generator which generates successively more precise values.
+            dist = next(nx.optimize_graph_edit_distance(
+                compound_chemgraph.graph,
+                component,
+                node_match = nmatch,
+                edge_match = ematch
+            ))
+            component_distances.append((component_index, dist))
+        graph_distance_pairwise[compound_entry] = component_distances
+
+    # We make duplicate instances of each compound to match if stoich != 1
+    compound_instances: dict[tuple[Compound, int], ChemGraph] = dict()
+    for compound, stoich in reaction_all_compounds:
+        if stoich * side < 0:
+            continue
+        for i in range(abs(stoich)):
+            try:
+                compound_instances[(compound, i)] = compound_graphs[compound]
+            except KeyError as e:
+                pass
+
+    # Run the hungarian algorithm to get the best match with the instanced compounds
+    edges: dict[tuple[tuple[Compound, int], int], float] = dict()
+    for (compound, compound_instance_index), _ in compound_instances.items():
+        for component_index, distance in graph_distance_pairwise[compound]:
+            edges[((compound, compound_instance_index), component_index)] = distance
+    matching = hungarian.max_weight_matching(
+        edges = edges,
+        min_weight = True
+    )
+    # TODO extra logic to iterate the edit distance algorithm if the matching is 'close'?
+
+    matching_dict: dict[set[int], tuple[Compound, int]] = dict()
+    for (compound, compound_index), component_index in matching.items():
+        matching_dict[component_subsets[component_index]] = (compound, compound_index)
+
+    return matching_dict

chemrecon/chem/gml/gml_to_rdk.py

@@ -0,0 +1,217 @@
+from __future__ import annotations
+
+import re
+
+import networkx as nx
+from rdkit import Chem as rdk
+from rdkit.Chem.rdChemReactions import ChemicalReaction
+
+from chemrecon.chem.gml.gml import remove_residues, GMLGraph
+
+
+atom_regex = re.compile(r'([A-Z][a-z]*)([0-9])?([+\-])?')
+
+
+# Molecule
+def gml_to_rdkit_mol(gml: str) -> rdk.Mol:
+    gmlgraph = GMLGraph(gml)
+    rdk_mol = rdk.EditableMol(rdk.Mol())
+    node_index: dict[int, int] = {}
+
+    # Atoms
+    for nx_index, nx_properties in gmlgraph.graph.nodes.items():
+        # Add atom with element (charge?) given by the label, and atom map number given by the index
+        atom = None
+        label: str = nx_properties['label']
+        if label == '*':
+            atom = atom = rdk.AtomFromSmiles(f'[*]')
+        else:
+            match = atom_regex.match(label)
+            charge = 0
+            try:
+                symbol = match.group(1)
+                plusminus = match.group(3)
+                if plusminus is None:
+                    charge = 0
+                else:
+                    if plusminus == '+':
+                        charge = 1
+                    elif plusminus == '-':
+                        charge = -1
+                    else:
+                        raise Exception()
+
+                chargeabs = match.group(2)
+                if chargeabs:
+                    charge * int(chargeabs)
+
+            except Exception:
+                raise ValueError(f'Cannot convert S_GML: Atom label: {label}')
+                # error.
+
+            if symbol == 'R':
+                # Radical
+                # TODO
+                atom = rdk.AtomFromSmiles(f'[*]')
+            elif symbol.startswith('Alias'):
+                # 'Alias in GML?'
+                # TODO what does this mean exactly
+                atom = rdk.AtomFromSmiles(f'[*]')
+            else:
+                atom = rdk.AtomFromSmiles(f'[{symbol}]')
+
+            # Set charge based on match
+            atom.SetFormalCharge(charge)
+
+        # Atom is set
+        if atom is None:
+            raise ValueError(f'Cannot convert S_GML: Atom label: {label}')
+
+        atom.SetAtomMapNum(nx_index)
+        atom_index = rdk_mol.AddAtom(atom)
+        node_index[nx_index] = atom_index
+
+    # Edges
+    for a, b in gmlgraph.graph.edges():
+        index_a = node_index[a]
+        index_b = node_index[b]
+        label: str = gmlgraph.graph.get_edge_data(a, b)['label']
+        match label:
+            case '-':
+                bondtype = rdk.BondType.SINGLE
+            case '=':
+                bondtype = rdk.BondType.DOUBLE
+            case '#':
+                bondtype = rdk.BondType.TRIPLE
+            case ':':
+                bondtype = rdk.BondType.AROMATIC
+            case _:
+                raise ValueError(f'Unknown bond type: {label}.')
+        rdk_mol.AddBond(index_a, index_b, bondtype)
+
+    # Mol is done, change to uneditable
+    rdk_mol_final = rdk_mol.GetMol()
+    return rdk_mol_final
+
+# Reaction
+def gml_to_rdkit_reaction(gml: str) -> ChemicalReaction:
+    """ Relies on S_GML in the format outputted by the M-CSA script.
+    """
+
+    # TODO change to re-use above code?
+
+    # Load two S_GML strings
+    l_str = ''
+    r_str = ''
+    step: int = 0
+    currentstr: str = ''
+    for l in gml.splitlines():
+        if l.startswith('graph') or l.startswith('left') or l.startswith('right'):
+            if step == 1:
+                l_str = currentstr
+            elif step == 2:
+                r_str = currentstr
+            # Start new string
+            step += 1
+            currentstr = ''
+        # Add to current string
+        currentstr += l
+
+    assert step == 2
+    r_str = currentstr
+
+    # Get the components and turn into MolInstances
+        # TODO should not be necessary
+    l_chemgraph = remove_residues(GMLGraph(l_str.replace('left', 'graph')))
+    r_chemgraph = remove_residues(GMLGraph(r_str.replace('right', 'graph')))
+
+    # For each component, add it
+    rdk_r = ChemicalReaction()
+    rdk_reaction = ChemicalReaction()
+
+    for chemgraph, side in [[l_chemgraph, -1], [r_chemgraph, 1]]:
+        for component in chemgraph.get_components_subgraphs():
+            component: nx.Graph
+            rdk_mol = rdk.EditableMol(rdk.Mol())
+            node_index: dict[int, int] = {}
+
+            # Atoms
+            for nx_index, nx_properties in component.nodes.items():
+                # Add atom with element (charge?) given by the label, and atom map number given by the index
+                atom = None
+                label: str = nx_properties['label']
+                if label == '*':
+                    atom = rdk.AtomFromSmiles(f'[*]')
+                else:
+                    match = atom_regex.match(label)
+                    charge = 0
+                    try:
+                        symbol = match.group(1)
+                        plusminus = match.group(3)
+                        if plusminus is None:
+                            charge = 0
+                        else:
+                            if plusminus == '+':
+                                charge = 1
+                            elif plusminus == '-':
+                                charge = -1
+                            else:
+                                raise Exception()
+
+                        chargeabs = match.group(2)
+                        if chargeabs:
+                            charge * int(chargeabs)
+
+                    except Exception:
+                        raise ValueError(f'Cannot convert S_GML: Atom label: {label}')
+                        # error.
+                    if symbol == 'R':
+                        # Radical
+                        # TODO
+                        atom = rdk.AtomFromSmiles(f'[*]')
+                    elif symbol.startswith('Alias'):
+                        # 'Alias in GML?'
+                        # TODO what does this mean exactly
+                        atom = rdk.AtomFromSmiles(f'[*]')
+                    else:
+                        atom = rdk.AtomFromSmiles(f'[{symbol}]')
+
+
+                if atom is None:
+                    raise ValueError(f'Cannot convert S_GML: Atom label: {label}')
+                atom.SetFormalCharge(charge)
+                atom.SetAtomMapNum(nx_index)
+                atom_index = rdk_mol.AddAtom(atom)
+                node_index[nx_index] = atom_index
+
+            # Edges
+            for a, b in component.edges():
+                index_a = node_index[a]
+                index_b = node_index[b]
+                label: str = component.get_edge_data(a, b)['label']
+                match label:
+                    case '-':
+                        bondtype = rdk.BondType.SINGLE
+                    case '=':
+                        bondtype = rdk.BondType.DOUBLE
+                    case '#':
+                        bondtype = rdk.BondType.TRIPLE
+                    case ':':
+                        bondtype = rdk.BondType.AROMATIC
+                    case _:
+                        raise ValueError(f'Unknown bond type: {label}.')
+                rdk_mol.AddBond(index_a, index_b, bondtype)
+
+                pass
+
+            # Mol is done, change to uneditable
+            rdk_mol_final = rdk_mol.GetMol()
+            # TODO ADD mol to reaction
+            match side:
+                case -1:
+                    rdk_reaction.AddReactantTemplate(rdk_mol_final)
+                case 1:
+                    rdk_reaction.AddProductTemplate(rdk_mol_final)
+
+    # Reaction now completed
+    return rdk_reaction