chemrecon 0.1.1__py3-none-any.whl

chemrecon/schema/relation_types_procedural/aam_convert_relation.py

@@ -0,0 +1,69 @@
+from __future__ import annotations
+
+from typing import Optional
+
+from chemrecon.chem.chemreaction import ChemReaction, chem_reaction_from_rxn
+from chemrecon.chem.gml.gml_to_rdk import gml_to_rdkit_reaction
+from chemrecon.core.id_types import A_GML_RULE, A_RXN
+from chemrecon.schema import (ProceduralGeneratorError, ProceduralRelation, AAMRepr, AAM, )
+
+
+class AAMConvert(ProceduralRelation[AAMRepr, AAM]):
+    """ Standardized and canonical conversion of AAM representations (e.g. reaction SMILES, MolFile, …) into a
+        consistent format, stored as a canonical reaction SMILES string.
+    """
+    # Attributes
+
+    # Database
+    entrytype_name = 'AAM Convert'
+    _table_name = 'AAMConvert'
+    symmetric = False
+    source_entrytype = AAMRepr
+    target_entrytype = AAM
+    _attribute_columns = []
+    _index = []
+
+    def __init__(
+        self,
+        recon_id_1: Optional[int] = None,
+        recon_id_2: Optional[int] = None
+    ):
+        super().__init__(recon_id_1, recon_id_2)
+
+    @classmethod
+    def generate(
+        cls,
+        take_entry: AAMRepr
+    ) -> list[tuple[ProceduralRelation[AAMRepr, AAM], AAM]]:
+
+        r: Optional[ChemReaction] = None
+        try:
+            match take_entry.id_type:
+                case A_RXN.enum_type:
+                    r = chem_reaction_from_rxn(rxn = take_entry.source_id)
+                case A_GML_RULE.enum_type:
+                    rdk_reaction = gml_to_rdkit_reaction(gml = take_entry.source_id)
+                    r = ChemReaction(
+                        rdk_reaction = rdk_reaction
+                    )
+                case _:
+                    # Log error and continue
+                    raise ProceduralGeneratorError('Cannot create atom-to-atom map for reaction (unsupported format).')
+        except Exception as e:
+            raise ProceduralGeneratorError(f'Failed converting AAM representation to internal format.') from e
+        if r is None:
+            raise ProceduralGeneratorError(f'AAM conversion failed.')
+
+        assert take_entry.recon_id is not None
+        r_smarts = r.to_reaction_smiles()
+        r_entry = AAM(
+            reaction_smiles = r_smarts
+        )
+
+        # Return AAM
+        return [
+            (
+                AAMConvert(),
+                r_entry
+            )
+        ]

chemrecon/schema/relation_types_procedural/compound_select_structure_proceduralrelation.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+from chemrecon.schema.procedural_relation_entrygraph import ProceduralRelationEG
+from chemrecon.schema.direction import Direction
+from chemrecon.entrygraph.scoring import Scorer
+from chemrecon.schema.entry_types.compound import Compound
+from chemrecon.schema.entry_types.molstructure import MolStructure
+from chemrecon.schema.relation_types_composed.compound_has_molstructure_relation import CompoundHasMolStructure
+from chemrecon.schema.relation_types_source.compound_reference_relation import CompoundReference
+from chemrecon.schema.relation_types_source.molstructure_standardisation_relation import MolStructureStandardization
+from chemrecon.entrygraph.explorationprotocol import ExplorationProtocol
+
+ProtocolSelectStructure = ExplorationProtocol(
+    relation_types = {
+        (CompoundReference, Direction.SYMMETRIC),
+        (CompoundHasMolStructure, Direction.FORWARDS),
+        (MolStructureStandardization, Direction.FORWARDS),
+    },
+)
+eg_scorer_compound_select_structure = Scorer[MolStructure](
+    score_entry_type = MolStructure
+)
+
+class CompoundSelectStructure(ProceduralRelationEG[Compound, MolStructure]):
+    """ Procedural relation which computes the most related molecular structures for a given compound using entry graph
+        scoring.
+    """
+
+    # Database
+    _table_name = 'CompoundSelectStructure'
+    source_entrytype = Compound
+    target_entrytype = MolStructure
+
+    # For EG
+    protocol = ProtocolSelectStructure
+    entrygraph_scorer = eg_scorer_compound_select_structure

chemrecon/schema/relation_types_procedural/compound_similarlity_proceduralrelation.py

@@ -0,0 +1 @@
+# TODO

chemrecon/schema/relation_types_procedural/molstructure_convert_relation.py

@@ -0,0 +1,49 @@
+from typing import Optional
+
+from chemrecon.chem.mol import Mol
+from chemrecon.chem.create_mol import mol_from_structurerepresentation
+from chemrecon.schema import MolStructureRepr, MolStructure
+from chemrecon.schema.db_object import ProceduralGeneratorError, ProceduralRelation
+
+
+class MolStructureConvert(ProceduralRelation[MolStructureRepr, MolStructure]):
+    """ Standardized and canonical conversion of molecular structure representations (e.g. SMILES, InChI, ...) into
+        a consistent format, stored as a canonical SMILES string.
+    """
+    # Attributes
+
+    # Database
+    entrytype_name = 'MolStructureConvert'
+    _table_name = 'MolStructureConvert'
+    symmetric = False
+    source_entrytype = MolStructureRepr
+    target_entrytype = MolStructure
+    _attribute_columns = []
+    _index = []
+
+    def __init__(
+        self,
+        recon_id_1: Optional[int] = None,
+        recon_id_2: Optional[int] = None
+    ):
+        super().__init__(recon_id_1, recon_id_2)
+
+
+    @classmethod
+    def generate(
+        cls, take_entry: MolStructureRepr
+    ) -> list[tuple[ProceduralRelation[MolStructureRepr, MolStructure], MolStructure]]:
+
+        try:
+            mol: Mol = mol_from_structurerepresentation(take_entry, template = True)
+            new_entry: MolStructure = mol.to_database_struct()
+            return [
+                (
+                    MolStructureConvert(),
+                    new_entry
+                )
+            ]
+
+        except Exception as e:
+            # Failed for this item
+            raise ProceduralGeneratorError(f'Creating molecule failed for {take_entry.source_id}') from e

chemrecon/schema/relation_types_procedural/reaction_select_aam_proceduralrelation.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from chemrecon.schema.direction import Direction
+from chemrecon.entrygraph.scoring import Scorer
+from chemrecon.schema.entry_types.aam import AAM
+from chemrecon.schema.entry_types.enzyme import Enzyme
+from chemrecon.schema.entry_types.reaction import Reaction
+from chemrecon.schema.procedural_relation_entrygraph import ProceduralRelationEG
+from chemrecon.schema.relation_types_composed.reaction_has_aam_relation import ReactionHasAAM
+from chemrecon.schema.relation_types_source.reaction_has_enzyme_relation import ReactionHasEnzyme
+from chemrecon.schema.relation_types_source.reaction_reference_relation import ReactionReference
+from chemrecon.entrygraph.explorationprotocol import ExplorationProtocol
+
+ProtocolSelectAAM = ExplorationProtocol(
+    relation_types = {
+        (ReactionReference, Direction.SYMMETRIC),
+        (ReactionHasEnzyme, Direction.BOTH),
+        (ReactionHasAAM, Direction.FORWARDS)
+    },
+    # TODO filter (filter out name entries)
+)
+eg_scorer_reaction_select_aam = Scorer(
+    score_entry_type = AAM,
+    # TODO more advanced weighing
+)
+
+class ReactionSelectAAM(ProceduralRelationEG[Reaction, AAM]):
+    """ Procedural relation which computes the most related AAMs for a given reaction using entry graph scoring.
+    """
+
+    # Database
+    _table_name = 'ReactionSelectAAM'
+    source_entrytype = Reaction
+    target_entrytype = AAM
+
+    # For EG
+    protocol = ProtocolSelectAAM
+    entrygraph_scorer = eg_scorer_reaction_select_aam

chemrecon/schema/relation_types_procedural/reaction_similarity_proceduralrelation.py

@@ -0,0 +1 @@
+# TODO

chemrecon/schema/relation_types_source/aam_involves_molstructure_relation.py

@@ -0,0 +1,77 @@
+from typing import Optional
+
+from chemrecon.schema.db_object import Column, Relation, InverseRelation
+from chemrecon.schema.entry_types.aam import AAM
+from chemrecon.schema.entry_types.molstructure import MolStructure
+
+
+class AAMInvolvesMolStructure(Relation[AAM, MolStructure]):
+    """ Relates the molecular structures involved in an atom-to-atom-mapped reaction.
+        These molecular structures are implicitly a part of the AAM structure.
+    """
+    # Attributes
+    side: int  #: The side of the reaction which contains this structure (-1 or 1)
+    structure_atom_index_in_aam: list[int]  #: Atom mapping numbers of the atoms in the structure w.r.t. the AAM.
+
+    # Database
+    entrytype_name = 'AAM Involves MolStructure'
+    _table_name = 'AAMInvolvesMolStructure'
+    symmetric = False
+    source_entrytype = AAM
+    target_entrytype = MolStructure
+    _attribute_columns = [
+        Column('structure_atom_index_in_aam', list[int])
+    ]
+    _index = [0]
+
+    def __init__(
+        self,
+        side: int,
+        structure_atom_index_in_aam: list[int],
+        recon_id_1: Optional[int] = None,
+        recon_id_2: Optional[int] = None
+    ):
+        super().__init__(recon_id_1, recon_id_2)
+        self.side = side
+        self.structure_atom_index_in_aam = structure_atom_index_in_aam
+
+    def _vis_str(self) -> str:
+        return f'has structure ({self.side})'
+
+class MolStructureParticipatesInAAM(InverseRelation[MolStructure, AAM]):
+    """ Relates the molecular structures involved in an atom-to-atom-mapped reaction.
+        These molecular structures are implicitly a part of the AAM structure.
+    """
+    # Attributes
+    side: int  #: The side of the reaction which contains this structure (-1 or 1)
+    structure_atom_index_in_aam: list[int]  #: Atom mapping numbers of the atoms in the structure w.r.t. the AAM.
+
+    # Inverse
+    inverse_main_relation = AAMInvolvesMolStructure
+
+    # Database
+    entrytype_name = 'MolStructure Participats in AAM'
+    _table_name = 'MolStructureParticipatesInAAM'
+    symmetric = False
+    source_entrytype = MolStructure
+    target_entrytype = AAM
+    _attribute_columns = [
+        Column('structure_atom_index_in_aam', list[int])
+    ]
+    _index = [0]
+
+    def __init__(
+        self,
+        side: int,
+        structure_atom_index_in_aam: list[int],
+        recon_id_1: Optional[int] = None,
+        recon_id_2: Optional[int] = None
+    ):
+        super().__init__(recon_id_1, recon_id_2)
+        self.side = side
+        self.structure_atom_index_in_aam = structure_atom_index_in_aam
+
+    def _vis_str(self) -> str:
+        return f'in reaction ({self.side})'
+
+AAMInvolvesMolStructure.has_inverse = MolStructureParticipatesInAAM

chemrecon/schema/relation_types_source/aam_repr_involves_molstructure_repr_relation.py

@@ -0,0 +1,79 @@
+from typing import Optional
+
+from chemrecon.schema.db_object import Column, Relation, InverseRelation
+from chemrecon.schema.entry_types.aam_repr import AAMRepr
+from chemrecon.schema.entry_types.molstructure_repr import MolStructureRepr
+
+
+class AAMReprInvolvesMolStructureRepr(Relation[AAMRepr, MolStructureRepr]):
+    """ Relates the molecular structure representation involved in an atom-to-atom-mapped reaction.
+        These molecular structures are implicitly a part of the AAM structure.
+    """
+    # Attributes
+    index: int  #: Index in the mapping string
+    stoich: int  #: The stoichiometric coefficient of the MolStructureRepr
+
+    # Database
+    entrytype_name = 'AAMRepr Involves MolStructureRepr'
+    _table_name = 'AAMReprInvolvesMolStructureRepr'
+    symmetric = False
+    source_entrytype = AAMRepr
+    target_entrytype = MolStructureRepr
+    _attribute_columns = [
+        Column('index', int),
+        Column('stoich', int)
+    ]
+    _index = [0]
+
+    def __init__(
+        self,
+        index: int,
+        stoich: int,
+        recon_id_1: Optional[int] = None,
+        recon_id_2: Optional[int] = None
+    ):
+        super().__init__(recon_id_1, recon_id_2)
+        self.index = index
+        self.stoich = stoich
+
+    def _vis_str(self) -> str:
+        return f'has structure (side: {self.stoich})'
+
+class MolStructureReprParticipatesInAAMRepr(InverseRelation[MolStructureRepr, AAMRepr]):
+    """ Relates the molecular structure representation involved in an atom-to-atom-mapped reaction.
+        These molecular structures are implicitly a part of the AAM structure.
+    """
+    # Attributes
+    index: int  #: Index in the mapping string
+    stoich: int  #: The stoichiometric coefficient of the MolStructureRepr
+
+    # Inverse
+    inverse_main_relation = AAMReprInvolvesMolStructureRepr
+
+    # Database
+    entrytype_name = 'MolStructureRepr Participates in AAMRepr'
+    _table_name = 'MolStructureReprParticipatesInAAMRepr'
+    symmetric = False
+    source_entrytype = MolStructureRepr
+    target_entrytype = AAMRepr
+    _attribute_columns = [
+        Column('index', int),
+        Column('stoich', int)
+    ]
+    _index = [0]
+
+    def __init__(
+        self,
+        index: int,
+        stoich: int,
+        recon_id_1: Optional[int] = None,
+        recon_id_2: Optional[int] = None
+    ):
+        super().__init__(recon_id_1, recon_id_2)
+        self.index = index
+        self.stoich = stoich
+
+    def _vis_str(self) -> str:
+        return f'in aam ({self.stoich})'
+
+AAMReprInvolvesMolStructureRepr.has_inverse = MolStructureReprParticipatesInAAMRepr

chemrecon/schema/relation_types_source/compound_has_structure_representation_relation.py

@@ -0,0 +1,33 @@
+from typing import Optional
+
+from chemrecon.schema import Relation, Compound, SourceDatabase, MolStructureRepr
+from chemrecon.schema.db_object import col_src
+
+
+class CompoundHasStructureRepresentation(Relation[Compound, MolStructureRepr]):
+    """ Relates a compound entry to the structure representation (e.g. SMILES, InChI) given by that database.
+    """
+    # Attributes
+    src: SourceDatabase  #: The source database containing this representation.
+
+    # Database
+    _table_name = 'CompoundHasStructureRepresentation'
+    symmetric = False
+    source_entrytype = Compound
+    target_entrytype = MolStructureRepr
+    _attribute_columns = [
+        col_src
+    ]
+    _index = [0]
+
+    def __init__(
+        self,
+        src: SourceDatabase = SourceDatabase.unknown,
+        recon_id_1: Optional[int] = None,
+        recon_id_2: Optional[int] = None
+    ):
+        super().__init__(recon_id_1, recon_id_2)
+        self.src = src
+
+    def _vis_str(self) -> str:
+        return f'{self.src.name}'

chemrecon/schema/relation_types_source/compound_reference_relation.py

@@ -0,0 +1,34 @@
+from typing import Optional
+
+from chemrecon.schema import Relation, Compound, SourceDatabase
+from chemrecon.schema.db_object import col_src
+
+
+class CompoundReference(Relation[Compound, Compound]):
+    """ Inter- or intra-database reference between compounds.
+    """
+    # Attributes
+    src: SourceDatabase  #: The source of the relation
+
+    # Database
+    entrytype_name = 'Compound Reference'
+    _table_name = 'CompoundReference'
+    symmetric = True
+    source_entrytype = Compound
+    target_entrytype = Compound
+    _attribute_columns = [
+        col_src
+    ]
+    _index = [0]
+
+    def __init__(
+        self,
+        src: SourceDatabase = SourceDatabase.unknown,
+        recon_id_1: Optional[int] = None,
+        recon_id_2: Optional[int] = None
+    ):
+        super().__init__(recon_id_1, recon_id_2)
+        self.src = src
+
+    def _vis_str(self) -> str:
+        return f'ref ({self.src.name})'

chemrecon/schema/relation_types_source/molstructure_standardisation_relation.py

@@ -0,0 +1,71 @@
+from typing import Optional
+
+from chemrecon.chem.mol import feats, Mol
+from chemrecon.chem.create_mol import mol_from_smiles
+from chemrecon.schema import Column, FeatureEnum, ProceduralGeneratorError, ProceduralRelation, MolStructure
+
+
+class MolStructureStandardization(ProceduralRelation[MolStructure, MolStructure]):
+    """ Standardization of molecular structures according to a particular 'feature' (Fragment, Isotope, Charge,
+        Tautomerism, Stereochemical).
+    """
+
+    # Attributes
+    feat: FeatureEnum  #: The feature w.r.t. which the structure is standardized.
+
+    # Database
+    entrytype_name = 'MolStructure standardisation'
+    _table_name = 'MolStructureStandardisation'
+    ignore_generation_limit = True
+    symmetric = False
+    source_entrytype = MolStructure
+    target_entrytype = MolStructure
+    _attribute_columns = [
+        Column('feat', FeatureEnum)
+    ]
+    _index = [0]
+
+    def __init__(
+        self,
+        feat: FeatureEnum,
+        recon_id_1: Optional[int] = None,
+        recon_id_2: Optional[int] = None
+    ):
+        super().__init__(recon_id_1, recon_id_2)
+        self.feat = feat
+
+    @classmethod
+    def generate(
+        cls, take_entry: MolStructure
+    ) -> list[tuple[ProceduralRelation[MolStructure, MolStructure], MolStructure]]:
+
+        # Create mol object
+        m: Mol
+        try:
+            m = mol_from_smiles(take_entry.smiles)
+        except ValueError as e:
+            # Mol creation fails
+            raise ProceduralGeneratorError('Could not create mol for std.') from e
+
+        feat_entries: list[tuple[FeatureEnum, MolStructure]] = list()
+        for f in feats:
+            if f not in m.features:
+                try:
+                    m_: Mol = Mol(f.standardise(m))
+                except Exception as e:
+                    # Failed standardisation
+                    continue
+
+                feat_entries.append((f.feature_enum, m_.to_database_struct()))
+
+        return [
+            (
+                MolStructureStandardization(feat = f),
+                e
+            )
+            for f, e in feat_entries
+        ]
+
+    # Visualisation
+    def _vis_str(self) -> str:
+        return f'std: {self.feat.name}'