chemrecon 0.1.1__py3-none-any.whl

chemrecon/__init__.py

@@ -0,0 +1,73 @@
+""" Defines metadata and the most general exports in the chemrecon.* namespace.
+"""
+# Metadata
+__version__ = '0.1.1'  # Library version
+__db_version__: list[str] = ['0.1.1']  # Compatible database versions
+
+
+# Imports
+import psycopg
+
+
+# Connection and handler
+import chemrecon.connection
+from chemrecon.connection import (
+    connect, connect_public, connect_local_docker, connect_local_docker_dev, disconnect,
+    get_query_handler
+)
+from chemrecon.database.params import Params
+
+
+# Project initialization
+# Try to set the default database connection
+try:
+    disconnect()
+    # connect_public()
+except psycopg.OperationalError as e:
+    print(f'Cannot connect to default database: {e}')
+
+# Import from schema
+from chemrecon.schema import *
+
+from chemrecon.core.query_handler import QueryHandler
+from chemrecon.core.populate_query_handler import PopulateQueryHandler
+
+# Export identifier types
+from chemrecon.core.id_types import *
+
+# Entry creators
+# from chemrecon.query.create_entry import (
+#     entry,
+#     compound_entry, reaction_entry, enzyme_entry,
+#     aam_representation_entry, structure_representation_entry,
+#     structure_entry, aam_entry,
+#     enzyme_from_ec_number,
+#     entry_from_identifiers_org
+# )
+
+from chemrecon.query.find_entry import (
+    find_entry,
+    find_compound_entry, find_reaction_entry, find_enzyme_entry,
+    find_structure_representation_entry, find_aam_representation_entry,
+    find_structure_entry, find_aam_entry
+)
+
+# Relation getters
+from chemrecon.query.get_relations import *
+
+# EntryGraphs
+from chemrecon.entrygraph.entrygraph import EntryGraph, Vertex, Edge
+from chemrecon.schema.direction import Direction
+from chemrecon.entrygraph.filter import (
+    EntryFilter, EntryFilterProcedure,
+    RelationFilter, RelationFilterProcedure
+)
+from chemrecon.entrygraph.explorationprotocol import ExplorationProtocol
+from chemrecon.entrygraph.explore import explore
+from chemrecon.entrygraph.scoring import Scorer
+
+# Pre-defined entrygraph types
+from chemrecon.query.default_protocols import *
+
+# Chemistry - Molecules
+from chemrecon.chem.mol import Mol

chemrecon/chem/chemreaction.py

@@ -0,0 +1,223 @@
+""" Implements a wrapper for the RDKit reaction type."""
+from __future__ import annotations
+
+from enum import Enum
+from typing import Optional
+
+import rdkit.Chem.rdChemReactions as rdk_r
+from rdkit.Chem.rdChemReactions import ChemicalReaction
+from rdkit.Chem import Draw as rdk_draw
+
+from chemrecon.chem.mol import MolTemplate, MolInstance
+from chemrecon.chem.sumformula import SumFormula
+from chemrecon.schema.entry_types.aam import AAM
+
+
+class Side(Enum):
+    L = -1
+    R = 1
+
+type stoich = int
+
+class ChemReaction:
+    reaction: ChemicalReaction
+    _reaction_smiles: Optional[str]
+
+    # Templates represent the structure of each compound. (There can be duplicate templates)
+    lhs_templates: dict[MolTemplate, stoich]
+    rhs_templates: dict[MolTemplate, stoich]
+
+    # Instances represent specific structures with maps as they participate in the reaction.
+    lhs_instances: list[MolInstance]
+    rhs_instances: list[MolInstance]
+
+    # Mapping between each instance and its corresponding template
+    instance_template_dict = dict[MolInstance, MolTemplate]
+
+    # Properties of the given instances, as read through the input files if possible
+    instance_properties: dict[MolInstance, dict[str, str]]
+    template_ids: dict[MolTemplate, str]
+    template_names: dict[MolTemplate, str]
+
+    # Atom-to-atom map of this reaction
+    map: dict[tuple[MolInstance, int], tuple[MolInstance, int]]
+    lhs_index: dict[int, tuple[MolInstance, int]]  # The global map number to (molecule, index) tuple
+    rhs_index: dict[int, tuple[MolInstance, int]]  # The global map number to (molecule, index) tuple
+
+    def __init__(self, rdk_reaction: ChemicalReaction):
+        self.reaction = rdk_reaction
+        self._reaction_smiles = None
+
+        self.lhs_instances = list()
+        self.rhs_instances = list()
+        self.lhs_templates = dict()
+        self.rhs_templates = dict()
+
+        self.instance_template_dict = dict()
+        self.map = dict()
+
+        self.instance_properties = dict()
+        self.template_ids = dict()
+        self.template_names = dict()
+
+        # Set reactant and product MolInstances and map
+        for rdk_mol in self.reaction.GetReactants():
+            self.lhs_instances.append(
+                MolInstance(rdk_mol, provenance = 'implicit')
+            )
+
+        for rdk_mol in self.reaction.GetProducts():
+            self.rhs_instances.append(
+                MolInstance(rdk_mol, provenance = 'implicit')
+            )
+
+        # Populate map
+        # The global map number to (molecule, index) tuple
+        # Global map number -> molecule, index (referring to the order of atoms in the SMILES string)
+        self.lhs_index = dict()
+        self.rhs_index = dict()
+        for lhs_instance in self.lhs_instances:
+            for local_index, global_index in enumerate(lhs_instance.get_atom_map_in_native_order()):
+                self.lhs_index[global_index] = (lhs_instance, local_index)
+        for rhs_instance in self.rhs_instances:
+            for local_index, global_index in enumerate(rhs_instance.get_atom_map_in_native_order()):
+                self.rhs_index[global_index] = (rhs_instance, local_index)
+
+        self.map = dict()
+        for i, (lhs_mol, lhs_index) in self.lhs_index.items():
+            try:
+                self.map[(lhs_mol, lhs_index)] = self.rhs_index[i]
+            except KeyError:
+                # Missing map
+                # TODO do something if this is not a hydrogen?
+                pass
+
+        # self.map = {
+        #     (lhs_mol, lhs_index): self.rhs_index[i]
+        #     for i, (lhs_mol, lhs_index) in self.lhs_index.items()
+        # }
+
+        # Compute templates and add
+        for side, instance_list, template_list in [
+            (-1, self.lhs_instances, self.lhs_templates),
+            (1, self.rhs_instances, self.rhs_templates)
+        ]:
+            mol_instance: MolInstance
+            for mol_instance in instance_list:
+                template = mol_instance.to_mol_template()
+
+                # Add to instance-template dict
+                self.instance_template_dict[mol_instance] = template
+
+                # Add to template lists
+                template_list[template] = template_list.get(template, 0) + side
+
+    # Getters
+    # ------------------------------------------------------------------------------------------------------------------
+    def get_lhs_templates(self) -> list[MolTemplate]:
+        return list(self.lhs_templates.keys())
+
+    def get_rhs_templates(self) -> list[MolTemplate]:
+        return list(self.rhs_templates.keys())
+
+    # Balance
+    # ------------------------------------------------------------------------------------------------------------------
+    def get_balance_difference(self) -> SumFormula:
+        """ Get the difference between the LHS and RHS as a (possible negative) MolFormula.
+            Positive counts indicate a surplus on the LHS, negative counts indicate a surplus on the RHS.
+        """
+        raise NotImplementedError()
+
+        # lhs_sum = sum(m.get_molformula() for m in self.lhs_instances)
+        # rhs_sum = sum(m.get_molformula() for m in self.rhs_instances)
+        # return lhs_sum - rhs_sum
+
+    def is_balanced(self) -> bool:
+        """ Returns true if balanced in both atomic composition and charge.
+            If not balanced, use .get_balance_differenec() to inspect the difference between LHS and RHS.
+        """
+        return self.get_balance_difference().is_zero()
+
+    # Representations
+    # ------------------------------------------------------------------------------------------------------------------
+    def to_reaction_smiles(self) -> str:
+        if self._reaction_smiles is None:
+            # self._reaction_smiles = rdk_r.ReactionToSmarts(self.reaction)
+            self._reaction_smiles = rdk_r.ReactionToSmiles(self.reaction)
+
+        return self._reaction_smiles
+
+    # Serialise
+    def serialize(self) -> dict:
+        return {
+            'reaction_smiles': self.to_reaction_smiles(),
+            'lhs': [
+                mol.serialize() for mol in self.lhs_instances
+            ],
+            'rhs': [
+                mol.serialize() for mol in self.rhs_instances
+            ],
+            'balanced': 'TODO',  # TODO
+            'balance_difference': 'TODO',  # TODO compute difference in sum formulae for LHS and RHS
+        }
+
+    # Misc
+    # ------------------------------------------------------------------------------------------------------------------
+    def __hash__(self):
+        return self.to_reaction_smiles().__hash__()
+
+    def sanity_check(self):
+        """ Raises an exception if the AAM maps atoms of different elements.
+        """
+        # Check all instances have smiles
+        for inst in [*self.lhs_instances, *self.rhs_instances]:
+            if inst.smiles is None:
+                raise AssertionError('Instance invalid.')
+
+        # Check mapping
+        for global_index, (molinst_l, local_index_l) in self.lhs_index.items():
+            try:
+                molinst_r, local_index_r = self.rhs_index[global_index]
+            except KeyError:
+                # Atom 'disappears'
+                continue
+
+            l_atom = molinst_l.mol.GetAtomWithIdx(local_index_l)
+            r_atom = molinst_r.mol.GetAtomWithIdx(local_index_r)
+            if l_atom.GetAtomicNum() != r_atom.GetAtomicNum():
+                raise AssertionError(f'Element mismatch: L: {local_index_l}, R: {local_index_r}')
+
+
+
+
+    # Visualisation
+    # ------------------------------------------------------------------------------------------------------------------
+    def show(self):
+        img = rdk_draw.ReactionToImage(rxn = self.reaction, subImgSize = (800, 800))
+        img.show()
+        pass
+
+# Creators
+# ----------------------------------------------------------------------------------------------------------------------
+def chem_reaction_from_aam_entry(
+    entry: AAM
+) -> ChemReaction:
+    """ Given an AAM entry, load into a ChemReaction object.
+    """
+    return chem_reaction_from_reactionsmiles(
+        entry.reaction_smiles
+    )
+
+def chem_reaction_from_reactionsmiles(
+    reactionsmiles: str
+) -> ChemReaction:
+    rdk_reaction = rdk_r.ReactionFromSmarts(reactionsmiles)
+    return ChemReaction(rdk_reaction)
+
+def chem_reaction_from_rxn(
+    rxn: str,
+    provenance: Optional[str] = None,
+    safe: bool = False
+) -> ChemReaction:
+    rdk_reaction = rdk_r.ReactionFromRxnBlock(rxn, sanitize = not safe, removeHs = not safe)
+    return ChemReaction(rdk_reaction)

chemrecon/chem/constant_compounds.py

@@ -0,0 +1,3 @@
+""" Pre-defined molecules which skip lookup (water, co2, ...)
+"""
+# TODO

chemrecon/chem/create_mol.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+from typing import Optional
+
+from rdkit import Chem as rdk
+
+from chemrecon.chem.gml.gml_to_rdk import gml_to_rdkit_mol
+from chemrecon.chem.mol import MolTemplate, MolInstance, feat_enum_map
+from chemrecon.core.id_types import S_SMILES, S_INCHI, S_GML, S_MOLFILE
+from chemrecon.chem.mol import Mol
+from chemrecon.schema.entry_types.molstructure import MolStructure
+from chemrecon.schema.entry_types.molstructure_repr import MolStructureRepr
+
+
+def mol_from_smiles(smiles: str, provenance: Optional[str] = None, template: bool = False, safe = False) -> Mol:
+    if template:
+        mol = MolTemplate(
+            rdk.MolFromSmiles(smiles),
+            provenance = provenance
+        )
+    else:
+        mol = MolInstance(
+            rdk.MolFromSmiles(smiles),
+            provenance = provenance
+        )
+    return mol
+
+
+def mol_from_inchi(inchi: str, provenance: Optional[str] = None, template: bool = False, safe = False) -> Mol:
+    if template:
+        mol = MolTemplate(rdk.MolFromInchi(inchi), provenance = provenance)
+    else:
+        mol = MolInstance(rdk.MolFromInchi(inchi), provenance = provenance)
+    return mol
+
+
+def mol_from_molblock(molblock: str, provenance: Optional[str] = None, template: bool = False, safe = False) -> Mol:
+    if template:
+        mol = MolTemplate(
+            rdk.MolFromMolBlock(molblock, sanitize = not safe, removeHs = not safe),
+            provenance = provenance
+        )
+    else:
+        mol = MolInstance(
+            rdk.MolFromMolBlock(molblock, sanitize = not safe, removeHs = not safe),
+            provenance = provenance
+        )
+    return mol
+
+
+def mol_from_gml(gml: str, provenance: Optional[str] = None, template: bool = False) -> Mol:
+    rdk_mol: rdk.Mol = gml_to_rdkit_mol(gml)
+    mol = mol_from_rdk_mol(rdk_mol, provenance, template)
+    return mol
+
+
+def mol_from_rdk_mol(rdk_mol: rdk.Mol, provenance: Optional[str] = None, template: bool = False) -> Mol:
+    if template:
+        mol = MolTemplate(rdk_mol, provenance = provenance)
+    else:
+        mol = MolInstance(rdk_mol, provenance = provenance)
+    return mol
+
+
+def mol_from_structurerepresentation(
+    entry: MolStructureRepr,
+    provenance: Optional[str] = None,
+    template: bool = False,
+    safe: bool = False
+):
+    match entry.id_type:
+        case S_SMILES.enum_type:
+            return mol_from_smiles(entry.source_id, provenance, template = template, safe = safe)
+        case S_INCHI.enum_type:
+            return mol_from_inchi(entry.source_id, provenance, template = template, safe = safe)
+        case S_MOLFILE.enum_type:
+            return mol_from_molblock(entry.source_id, provenance, template = template, safe = safe)
+        case S_GML.enum_type:
+            return mol_from_gml(entry.source_id, provenance, template = template)
+        case _:
+            raise ValueError
+
+
+def mol_from_struct_entry(entry: MolStructure):
+    mol = Mol(
+        rdk.MolFromSmiles(entry.smiles),
+        set_features ={
+            feat_enum_map[f] for f in entry.std_feats
+        }
+    )
+    return mol

chemrecon/chem/elements.py

@@ -0,0 +1,141 @@
+""" Basic chemical information.
+"""
+from typing import NamedTuple
+
+class Element(NamedTuple):
+    num: int
+    symbol: str
+    name: str
+
+n =     Element(0,      'n',    'Neutron')  # Included for correct list indices
+H =     Element(1,      'H',    'Hydrogen')
+He =    Element(2,      'He',   '')
+Li =    Element(3,      'Li',   '')
+Be =    Element(4,      'Be',   '')
+B =     Element(5,      'B',    '')
+C =     Element(6,      'C',    '')
+N =     Element(7,      'N',    '')
+O =     Element(8,      'O',    '')
+F =     Element(9,      'F',    '')
+Ne =    Element(10,     'Ne',   '')
+Na =    Element(11,     'Na',   '')
+Mg =    Element(12,     'Mg',   '')
+Al =    Element(13,     'Al',   '')
+Si =    Element(14,     'Si',   '')
+P =     Element(15,     'P',    '')
+S =     Element(16,     'S',    '')
+Cl =    Element(17,     'Cl',   '')
+Ar =    Element(18,     'Ar',   '')
+K =     Element(19,     'K',    '')
+Ca =    Element(20,     'Ca',   '')
+Sc =    Element(21,     'Sc',   '')
+Ti =    Element(22,     'Ti',   '')
+V =     Element(23,     'V',    '')
+Cr =    Element(24,     'Cr',   '')
+Mn =    Element(25,     'Mn',   '')
+Fe =    Element(26,     'Fe',   '')
+Co =    Element(27,     'Co',   '')
+Ni =    Element(28,     'Ni',   '')
+Cu =    Element(29,     'Cu',   '')
+Zn =    Element(30,     'Zn',   '')
+Ga =    Element(31,     'Ga',   '')
+Ge =    Element(32,     'Ge',   '')
+As =    Element(33,     'As',   '')
+Se =    Element(34,     'Se',   '')
+Br =    Element(35,     'Br',   '')
+Kr =    Element(36,     'Kr',   '')
+Rb =    Element(37,     'Rb',   '')
+Sr =    Element(38,     'Sr',   '')
+Y =     Element(39,     'Y',    '')
+Zr =    Element(40,     'Zr',   '')
+Nb =    Element(41,     'Nb',   '')
+Mo =    Element(42,     'Mo',   '')
+Tc =    Element(43,     'Tc',   '')
+Ru =    Element(44,     'Ru',   '')
+Rh =    Element(45,     'Rh',   '')
+Pd =    Element(46,     'Pd',   '')
+Ag =    Element(47,     'Ag',   '')
+Cd =    Element(48,     'Cd',   '')
+In =    Element(49,     'In',   '')
+Sn =    Element(50,     'Sn',   '')
+Sb =    Element(51,     'Sb',   '')
+Te =    Element(52,     'Te',   '')
+I =     Element(53,     'I',    '')
+Xe =    Element(54,     'Xe',   '')
+Cs =    Element(55,     'Cs',   '')
+Ba =    Element(56,     'Ba',   '')
+La =    Element(57,     'La',   '')
+Ce =    Element(58,     'Ce',   '')
+Pr =    Element(59,     'Pr',   '')
+Nd =    Element(60,     'Nd',   '')
+Pm =    Element(61,     'Pm',   '')
+Sm =    Element(62,     'Sm',   '')
+Eu =    Element(63,     'Eu',   '')
+Gd =    Element(64,     'Gd',   '')
+Tb =    Element(65,     'Tb',   '')
+Dy =    Element(66,     'Dy',   '')
+Ho =    Element(67,     'Ho',   '')
+Er =    Element(68,     'Er',   '')
+Tm =    Element(69,     'Tm',   '')
+Yb =    Element(70,     'Yb',   '')
+Lu =    Element(71,     'Lu',   '')
+Hf =    Element(72,     'Hf',   '')
+Ta =    Element(73,     'Ta',   '')
+W =     Element(74,     'W',    '')
+Re =    Element(75,     'Re',   '')
+Os =    Element(76,     'Os',   '')
+Ir =    Element(77,     'Ir',   '')
+Pt =    Element(78,     'Pt',   '')
+Au =    Element(79,     'Au',   '')
+Hg =    Element(80,     'Hg',   '')
+Tl =    Element(81,     'Tl',   '')
+Pb =    Element(82,     'Pb',   '')
+Bi =    Element(83,     'Bi',   '')
+Po =    Element(84,     'Po',   '')
+At =    Element(85,     'At',   '')
+Rn =    Element(86,     'Rn',   '')
+Fr =    Element(87,     'Fr',   '')
+Ra =    Element(88,     'Ra',   '')
+Ac =    Element(89,     'Ac',   '')
+Th =    Element(90,     'Th',   '')
+Pa =    Element(91,     'Pa',   '')
+U =     Element(92,     'U',    '')
+Np =    Element(93,     'Np',   '')
+Pu =    Element(94,     'Pu',   '')
+Am =    Element(95,     'Am',   '')
+Cm =    Element(96,     'Cm',   '')
+Bk =    Element(97,     'Bk',   '')
+Cf =    Element(98,     'Cf',   '')
+Es =    Element(99,     'Es',   '')
+Fm =    Element(100,    'Fm',   '')
+Md =    Element(101,    'Md',   '')
+No =    Element(102,    'No',   '')
+Lr =    Element(103,    'Lr',   '')
+Rf =    Element(104,    'Rf',   '')
+Db =    Element(105,    'Db',   '')
+Sg =    Element(106,    'Sg',   '')
+Bh =    Element(107,    'Bh',   '')
+Hs =    Element(108,    'Hs',   '')
+Mt =    Element(109,    'Mt',   '')
+Ds =    Element(110,    'Ds',   '')
+Rg =    Element(111,    'Rg',   '')
+Cn =    Element(112,    'Cn',   '')
+Nh =    Element(113,    'Nh',   '')
+Fl =    Element(114,    'Fl',   '')
+Mc =    Element(115,    'Mc',   '')
+Lv =    Element(116,    'Lv',   '')
+Ts =    Element(117,    'Ts',   '')
+Og =    Element(118,    'Og',   '')
+
+elements: list[Element] = [
+    n,
+    H,              He,
+    Li, Be, B, C, N, O, F, Ne, Na, Mg, Al, Si, P, S, Cl, Ar, K, Ca, Sc, Ti, V, Cr, Mn, Fe,
+    Co, Ni, Cu, Zn, Ga, Ge, As, Se, Br, Kr, Rb, Sr, Y, Zr, Nb, Mo, Tc, Ru, Rh, Pd, Ag, Cd, In,
+    Sn, Sb, Te, I, Xe, Cs, Ba, La, Ce, Pr, Nd, Pm, Sm, Eu, Gd, Tb, Dy, Ho, Er, Tm, Yb, Lu, Hf,
+    Ta, W, Re, Os, Ir, Pt, Au, Hg, Tl, Pb, Bi, Po, At, Rn, Fr, Ra, Ac, Th, Pa, U, Np, Pu, Am, Cm,
+    Bk, Cf, Es, Fm, Md, No, Lr, Rf, Db, Sg, Bh, Hs, Mt, Ds, Rg, Cn, Nh, Fl, Mc, Lv, Ts, Og,
+]
+
+symbol_element: dict[str, Element] = {e.symbol: e for e in elements}
+atomicnum_element: dict[int, Element] = {e.num: e for e in elements}