chemrecon 0.1.1__py3-none-any.whl

chemrecon/schema/entry_types/aam.py

@@ -0,0 +1,34 @@
+from typing import Optional
+
+from chemrecon.schema import Entry
+from chemrecon.schema.db_object import Column, col_recon_id
+
+class AAM(Entry):
+    """ Represents an atom-to-atom map.
+    """
+
+    # Attributes
+    reaction_smiles: str  #: The canonical reaction SMILES string.
+
+    # Database
+    entrytype_name = 'AAM'
+    _table_name = 'AAM'
+    _columns = [
+        col_recon_id,
+        Column('reaction_smiles', str, index_hash = True),
+    ]
+    _index = [1]
+
+    # Visualisation
+    _draw_colour = '7AFF78'
+
+    def __init__(
+        self,
+        reaction_smiles: str,
+        recon_id: Optional[int] = None,
+    ):
+        super().__init__(recon_id)
+        self.reaction_smiles = reaction_smiles
+
+    def _vis_str(self) -> str:
+        return self.reaction_smiles

chemrecon/schema/entry_types/aam_repr.py

@@ -0,0 +1,37 @@
+from typing import Optional
+
+from chemrecon.schema import Entry, IdTypeAAMEnum
+from chemrecon.schema.db_object import Column, col_recon_id, col_source_id_hashed
+
+
+class AAMRepr(Entry):
+    """ Represents an enzyme entry. """
+    # Attributes
+    source_id: str  #: Identifier string. (**index**)
+    id_type: IdTypeAAMEnum  #: The type of the identifier string (e.g. Reaction SMILES). (**index**)
+
+    # Database
+    entrytype_name = 'AAMRepr'
+    _table_name = 'AAMRepr'
+    _columns = [
+        col_recon_id,
+        col_source_id_hashed,
+        Column('id_type', IdTypeAAMEnum),
+    ]
+    _index = [1, 2]
+
+    # Visualisation
+    _draw_colour = '7AFF78'
+
+    def __init__(
+        self,
+        source_id: str,
+        id_type: IdTypeAAMEnum,
+        recon_id: Optional[int] = None,
+    ):
+        super().__init__(recon_id)
+        self.source_id = source_id
+        self.id_type = id_type
+
+    def _vis_str(self) -> str:
+        return f'{self.id_type.name}: {self.source_id}'

chemrecon/schema/entry_types/compound.py

@@ -0,0 +1,52 @@
+from typing import Optional
+
+from chemrecon.schema import SourceEntry
+from chemrecon.schema.db_object import (
+    Column, col_name, col_properties, col_quality,
+    col_recon_id,
+    col_source_id,
+)
+from chemrecon.schema.enums import IdTypeCompoundEnum, Quality
+
+
+class Compound(SourceEntry):
+    """ Represents a compound entry.
+    """
+    # Attributes
+    source_id: str  #: Identifier of the database entry. (**index**)
+    id_type: IdTypeCompoundEnum  #: Source of the database entry. (**index**)
+    name: Optional[str]  #: Name of the database entry. This May be the common name, IUPAC systematic name, or others.
+    quality: Optional[Quality]  #: Indicates the quality of the entry, if this is specified by the source database.
+    properties: list[str]  #: Additional properties
+
+    # Database
+    entrytype_name = 'Compound'
+    _table_name = 'Compound'
+    _columns = [
+        col_recon_id,
+        col_source_id,
+        Column('id_type', IdTypeCompoundEnum),
+        col_name,
+        col_quality,
+        col_properties,
+    ]
+    _index = [1, 2]
+
+    # Visualisation
+    _draw_colour = 'C6FFFF'
+
+    def __init__(
+            self,
+            source_id: str,
+            id_type: IdTypeCompoundEnum,
+            name: Optional[str] = None,
+            quality: Quality = None,
+            recon_id: Optional[int] = None,
+            properties: Optional[list[str]] = None,
+    ):
+        super().__init__(recon_id)
+        self.source_id = source_id
+        self.id_type = id_type
+        self.name = name
+        self.quality = quality
+        self.properties = properties if properties else list()

chemrecon/schema/entry_types/enzyme.py

@@ -0,0 +1,49 @@
+from typing import Optional
+
+from chemrecon.schema import IdTypeEnzymeEnum, Quality
+from chemrecon.schema.db_object import (
+    Column, SourceEntry, col_name, col_properties, col_quality,
+    col_recon_id,
+    col_source_id,
+)
+
+class Enzyme(SourceEntry):
+    """ Represents an enzyme entry. """
+    # Attributes
+    source_id: str  #: Identifier of the database entry. (**index**)
+    id_type: IdTypeEnzymeEnum  #: Source of the database entry. Always ``EC`` as of the current version. (**index**)
+    name: Optional[str]  #: Name of the enzyme.
+    quality: Optional[Quality]  #: Indicates the quality of the entry, if this is specified by the source database.
+    properties: list[str]  #: Additional properties
+
+    # Database
+    entrytype_name = 'Enzyme'
+    _table_name = 'Enzyme'
+    _columns = [
+        col_recon_id,
+        col_source_id,
+        Column('id_type', IdTypeEnzymeEnum),
+        col_name,
+        col_quality,
+        col_properties,
+    ]
+    _index = [1, 2]
+
+    # Visualisation
+    _draw_colour = 'F8FF9B'
+
+    def __init__(
+            self,
+            source_id: str,
+            id_type: IdTypeEnzymeEnum,
+            name: Optional[str] = None,
+            recon_id: Optional[int] = None,
+            quality: Optional[Quality] = None,
+            properties: Optional[list[str]] = None,
+    ):
+        super().__init__(recon_id)
+        self.source_id = source_id
+        self.id_type = id_type
+        self.name = name
+        self.quality = quality
+        self.properties = properties if properties else list()

chemrecon/schema/entry_types/molstructure.py

@@ -0,0 +1,64 @@
+from typing import Optional
+
+from chemrecon.schema import Entry, FeatureEnum
+from chemrecon.schema.db_object import Column, col_recon_id
+
+
+class MolStructure(Entry):
+    """ Abstract representation of a structure in SMILES format.
+    """
+    # Attributes
+    smiles: str  #: The canonical SMILES identifier.
+    std_feats: Optional[list[FeatureEnum]]  #: The features w.r.t which this structure is standardized (see TODO).
+    molformula: Optional[str]  #: The sum formula.
+
+    # Database
+    entrytype_name = 'MolStructure'
+    _table_name = 'MolStructure'
+    _columns = [
+        col_recon_id,
+        Column('smiles', str, index_hash = True),
+        Column('std_feats', list[FeatureEnum]),
+        Column('molformula', str),
+    ]
+    _index = [1]
+
+    # Visualisation
+    _draw_colour = '00FFFF'
+
+    def __init__(
+        self,
+        smiles: str,
+        std_feats: Optional[list[FeatureEnum]] = None,
+        molformula: Optional[str] = None,
+        recon_id: Optional[int] = None,
+    ):
+        super().__init__(recon_id)
+        self.smiles = smiles
+        self.std_feats = std_feats
+        self.molformula = molformula
+
+        # Calculate std. features if none
+        if self.std_feats is None:
+            from chemrecon import mol_from_smiles
+            mol = mol_from_smiles(smiles = self.smiles)
+            self.std_feats = {feat.feature_enum for feat in mol.features}
+
+        # Calculate sum formula if not given
+        if self.molformula is None:
+            # TODO
+            pass
+
+    def _vis_str(self) -> str:
+        return f'{self.smiles}\n({self._feat_str()})'
+
+    def _feat_str(self) -> str:
+        if self.std_feats is None:
+            return '?'
+        s: str = ''
+        s += 'F,' if FeatureEnum.F in self.std_feats else '-,'
+        s += 'I,' if FeatureEnum.I in self.std_feats else '-,'
+        s += 'C,' if FeatureEnum.C in self.std_feats else '-,'
+        s += 'T,' if FeatureEnum.T in self.std_feats else '-,'
+        s += 'S,' if FeatureEnum.S in self.std_feats else '-,'
+        return s

chemrecon/schema/entry_types/molstructure_repr.py

@@ -0,0 +1,41 @@
+from typing import Optional
+
+from chemrecon.schema import Column, Entry, IdTypeStructureRepresentationEnum
+from chemrecon.schema.db_object import col_recon_id, col_source_id_hashed
+class MolStructureRepr(Entry):
+    """ Represents a representation of a structure, such as an S_SMILES string, S_MOLFILE or similar. """
+    # Attributes
+    source_id: str  #: Identifier string. (**index**)
+    id_type: IdTypeStructureRepresentationEnum  #: The type of the identifier string (e.g. SMILES, InChI). (**index**)
+    #: If marked as implicit, this molecular structure only exists implicitly in an atom-to-atom map, and is not
+    #: directly referenced by a known compound.
+    implicit: bool
+
+    # Database
+    entrytype_name = 'MolStructureRepr'
+    _table_name = 'MolStructureRepr'
+    _columns = [
+        col_recon_id,
+        col_source_id_hashed,
+        Column('id_type', IdTypeStructureRepresentationEnum),
+        Column('implicit', bool)
+    ]
+    _index = [1, 2]
+
+    # Visualisation
+    _draw_colour = '7AFF78'
+
+    def __init__(
+        self,
+        source_id: str,
+        implicit: bool,
+        id_type: IdTypeStructureRepresentationEnum,
+        recon_id: Optional[int] = None,
+    ):
+        super().__init__(recon_id)
+        self.source_id = source_id
+        self.id_type = id_type
+        self.implicit = implicit
+
+    def _vis_str(self) -> str:
+        return f'{self.id_type.name}: {self.source_id}'

chemrecon/schema/entry_types/reaction.py

@@ -0,0 +1,57 @@
+from typing import Optional
+
+from chemrecon.schema import IdTypeReactionEnum, Quality
+from chemrecon.schema.db_object import (
+    Column, SourceEntry, col_name, col_properties, col_quality,
+    col_recon_id,
+    col_source_id,
+)
+
+class Reaction(SourceEntry):
+    """ Represents a compound entry. """
+    # Attributes
+    source_id: str  #: Identifier of the database entry. (**index**)
+    id_type: IdTypeReactionEnum  #: Source of the database entry. (**index**)
+    name: Optional[str]
+    is_transport: Optional[bool]  #: Whether the reaction is explicitly marked as a transport reaction.
+    is_reversible: Optional[bool]  #: Whether the reaction is explicitly marked as reversible.
+    quality: Optional[Quality]  #: Indicates the quality of the entry, if this is specified by the source database.
+    properties: list[str]  #: Additional properties
+
+    # Database
+    entrytype_name = 'Reaction'
+    _table_name = 'Reaction'
+    _columns = [
+        col_recon_id,
+        col_source_id,
+        Column('id_type', IdTypeReactionEnum),
+        col_name,
+        Column('is_transport', bool),
+        Column('is_reversible', bool),
+        col_quality,
+        col_properties,
+    ]
+    _index = [1, 2]
+
+    # Visualisation
+    _draw_colour = '9EFFA1'
+
+    def __init__(
+            self,
+            source_id: str,
+            id_type: IdTypeReactionEnum,
+            name: Optional[str] = None,
+            is_transport: Optional[bool] = None,
+            is_reversible: Optional[bool] = None,
+            quality: Optional[Quality] = None,
+            recon_id: Optional[int] = None,
+            properties: Optional[list[str]] = None,
+    ):
+        super().__init__(recon_id)
+        self.source_id = source_id
+        self.id_type = id_type
+        self.name = name
+        self.is_transport = is_transport
+        self.is_reversible = is_reversible
+        self.quality = quality
+        self.properties = properties if properties else list()

chemrecon/schema/enums.py

@@ -0,0 +1,154 @@
+""" Enums and corresponding objects
+"""
+
+from __future__ import annotations
+
+from enum import Enum
+
+from chemrecon.core import id_types as id_types
+from chemrecon.core.id_types import (
+    IdentifierType,
+)
+
+
+class SourceDatabase(Enum):
+    unknown = 0
+    BIGG = 1
+    CHEBI = 2
+    ECMDB = 3
+    MCSA = 4
+    METAMDB = 5
+    METANETX = 6
+    PUBCHEM = 7
+    MANUALLY_ADDED = 8
+    AUTOMATIC = 9
+
+    def __str__(self):
+        return self.name
+    def __repr__(self):
+        return self.name
+
+
+class Quality(Enum):
+    unknown = 0
+    automatic = 1
+    preliminary = 2
+    manual = 3
+    manual_curated = 4
+
+    def __str__(self):
+        return self.name
+    def __repr__(self):
+        return self.name
+
+
+class FeatureEnum(Enum):
+    F = 1
+    I = 2
+    C = 3
+    T = 4
+    S = 5
+
+    def __str__(self):
+        return self.name
+    def __repr__(self):
+        return self.name
+
+
+class IdTypeEnum(Enum):
+    pass
+
+    def __str__(self):
+        return self.name
+    def __repr__(self):
+        return self.name
+
+
+class IdTypeCompoundEnum(IdTypeEnum):
+    unknown = id_types.C_UNKNOWN
+    cname = id_types.C_NAME
+    mnx = id_types.C_MNX
+    bigg = id_types.C_BIGG
+    chebi = id_types.C_CHEBI
+    pubchem_cid = id_types.C_PUBCHEM
+    kegg = id_types.C_KEGG
+    ecmdb = id_types.C_ECMDB
+    inchikey = id_types.C_INCHIKEY
+    slm = id_types.C_SLM
+    envipath = id_types.C_ENVIPATH
+    lipidmaps = id_types.C_LIPIDMAPS
+    hmdb = id_types.C_HMDB
+    metacyc = id_types.C_METACYC
+    seed = id_types.C_SEED
+    sabiork = id_types.C_SABIORK
+    reactome = id_types.C_REACTOME
+    pdbe = id_types.C_PDBE
+    biocyc = id_types.C_BIOCYC
+    metamdb = id_types.C_METAMDB
+    brenda = id_types.C_BRENDA
+
+class IdTypeStructureRepresentationEnum(IdTypeEnum):
+    unknown = id_types.S_UNKNOWN
+    smiles = id_types.S_SMILES
+    inchi = id_types.S_INCHI
+    molfile = id_types.S_MOLFILE
+    gml = id_types.S_GML
+
+
+class IdTypeReactionEnum(IdTypeEnum):
+    unknown = id_types.R_UNKNOWN
+    rname = id_types.R_NAME
+    mnx = id_types.R_MNX
+    metacyc = id_types.R_METACYC
+    bigg = id_types.R_BIGG
+    seed = id_types.R_SEED
+    kegg = id_types.R_KEGG
+    rhea = id_types.R_RHEA
+    sabiork = id_types.R_SABIORK
+    metamdb = id_types.R_METAMDB
+    mcsa = id_types.R_MCSA
+    brenda = id_types.R_BRENDA
+
+
+class IdTypeAAMEnum(IdTypeEnum):
+    unknown = id_types.A_UNKNOWN
+    reactionsmiles = id_types.A_REACTIONSMILES
+    rxn = id_types.A_RXN
+    gml_rule = id_types.A_GML_RULE
+
+
+class IdTypeEnzymeEnum(IdTypeEnum):
+    unknown = id_types.E_UNKNOWN
+    ename = id_types.E_NAME
+    ec = id_types.E_EC
+
+
+
+# Enum registration
+# ----------------------------------------------------------------------------------------------------------------
+enum_register = [
+    SourceDatabase, Quality, FeatureEnum,
+    IdTypeCompoundEnum, IdTypeStructureRepresentationEnum,
+    IdTypeReactionEnum, IdTypeAAMEnum, IdTypeEnzymeEnum
+]
+
+# Set the corresponding enum type for each IdType
+for member in IdTypeCompoundEnum:
+    if isinstance(member.value, IdentifierType):
+        member.value.enum_type = IdTypeCompoundEnum.__getitem__(member.name)
+
+for member in IdTypeReactionEnum:
+    if isinstance(member.value, IdentifierType):
+        member.value.enum_type = IdTypeReactionEnum.__getitem__(member.name)
+
+for member in IdTypeStructureRepresentationEnum:
+    if isinstance(member.value, IdentifierType):
+        member.value.enum_type = IdTypeStructureRepresentationEnum.__getitem__(member.name)
+
+for member in IdTypeEnzymeEnum:
+    if isinstance(member.value, IdentifierType):
+        member.value.enum_type = IdTypeEnzymeEnum.__getitem__(member.name)
+
+for member in IdTypeAAMEnum:
+    if isinstance(member.value, IdentifierType):
+        member.value.enum_type = IdTypeAAMEnum.__getitem__(member.name)

chemrecon/schema/procedural_relation_entrygraph.py

@@ -0,0 +1,66 @@
+""" Defines procedural entries which are generated using entry graphs.
+"""
+from __future__ import annotations
+
+from abc import ABC
+from typing import ClassVar, final, Optional
+
+import chemrecon.entrygraph.scoring as scoring
+
+import chemrecon.entrygraph.explore as explore
+from chemrecon.schema.db_object import Entry, ProceduralRelation
+from chemrecon.schema.db_object import col_score
+from chemrecon.entrygraph.explorationprotocol import ExplorationProtocol
+from chemrecon.entrygraph.entrygraph import EntryGraph
+
+
+class ProceduralRelationEG[T1: Entry, T2: Entry](ProceduralRelation[T1, T2], ABC):
+    """ A procedural relation which is calculated based on an entrygraph of other relations
+        in the database.
+        Requires entrygraph to only accept entries of type T1 as initial entries, and the
+        scorer to score entries of type T2.
+    """
+    # Attribute
+    score: float  #: The score of the target entry in the entry graph.
+
+    # Defines the parameters from which the EG is generated
+    protocol: ClassVar[ExplorationProtocol]
+    entrygraph_scorer: ClassVar[scoring.Scorer]
+
+    # Necessary
+    symmetric = False
+    _attribute_columns = [
+        col_score
+    ]
+    _index = []
+
+
+    def __init__(
+        self,
+        recon_id_1: Optional[int] = None,
+        recon_id_2: Optional[int] = None,
+        score: float = 0.0
+    ):
+        self.score = score
+        super().__init__(recon_id_1 = recon_id_1, recon_id_2 = recon_id_2)
+
+    @final
+    @classmethod
+    def generate(
+        cls,
+        take_entry: T1,
+    ) -> list[tuple[ProceduralRelation[T1, T2], T2]]:
+        """ Generation of procedural relations relies on generating the associated entrygraph.
+        """
+        eg = EntryGraph(
+            initial_entries = {take_entry}
+        )
+        explore.explore(eg, steps = 4, protocol = cls.protocol)
+        score = cls.entrygraph_scorer(eg)
+        return [
+            (cls(recon_id_1 = None, recon_id_2 = None, score = score), score_entry)
+            for score_entry, score in score.items()
+        ]
+
+    def _vis_str(self) -> str:
+        return f'score: {self.score}'

chemrecon/schema/relation_types_composed/compound_has_molstructure_relation.py

@@ -0,0 +1,59 @@
+from typing import Optional
+
+from chemrecon.schema.db_object import col_src
+from chemrecon.schema.enums import SourceDatabase
+from chemrecon.schema import Compound, MolStructure, ComposedRelation
+from chemrecon.schema.entry_types.molstructure_repr import MolStructureRepr
+from chemrecon.schema.relation_types_source.compound_has_structure_representation_relation import (
+    CompoundHasStructureRepresentation
+)
+from chemrecon.schema.relation_types_procedural.molstructure_convert_relation import MolStructureConvert
+
+class CompoundHasMolStructure(ComposedRelation[Compound, MolStructure, MolStructureRepr]):
+    """ This relation gives the associated molecular structures of a compound in a standardized format.
+        This relation is composed of the `CompoundHasMolStructureRepr` relation and the `MolStructureConvert`
+        relations.
+        So if a compound entry includes an InChI, Molfile representation of a structure, this relation gives the same
+        structure in the standardized, SMILES-based format.
+    """
+    # Attributes
+    src: SourceDatabase  #: The source database containing this structure.
+
+    # Transitive
+    rel_type_1 = CompoundHasStructureRepresentation
+    rel_type_2 = MolStructureConvert
+    intermediate_entrytype = MolStructureRepr
+
+    # Database
+    entrytype_name = 'Compound has MolStructure'
+    _table_name = 'CompoundHasMolStructure'
+    symmetric = False
+    source_entrytype = Compound
+    target_entrytype = MolStructure
+    _attribute_columns = [
+        col_src
+    ]
+    _index = [0]
+
+    # Filters
+    @classmethod
+    def filter_intermediate(cls, e: MolStructureRepr) -> bool:
+        if e.implicit:
+            return False
+        return True
+
+    def __init__(
+            self,
+            rel_1: CompoundHasStructureRepresentation,
+            rel_2: MolStructureConvert,
+            intermediate: MolStructureRepr,
+            recon_id_1: Optional[int] = None,
+            recon_id_2: Optional[int] = None
+    ):
+        # Inherits src from rel1
+        self.src = rel_1.src
+        super().__init__(rel_1, rel_2, intermediate, recon_id_1, recon_id_2)
+
+    def _vis_str(self) -> str:
+        return f'{self.src.name}'
+

chemrecon/schema/relation_types_composed/reaction_has_aam_relation.py

@@ -0,0 +1,50 @@
+from typing import Optional
+
+from chemrecon.schema.db_object import col_src
+from chemrecon.schema import Reaction, AAM, ComposedRelation
+from chemrecon.schema.enums import SourceDatabase
+from chemrecon.schema.entry_types.aam_repr import AAMRepr
+from chemrecon.schema.relation_types_procedural.aam_convert_relation import \
+    AAMConvert
+from chemrecon.schema.relation_types_source.reaction_has_aam_representation_relation import \
+    ReactionHasAAMRepr
+
+
+class ReactionHasAAM(ComposedRelation[Reaction, AAM, AAMRepr]):
+    """ This relation gives the associated AAM of a reaction in a standardized format.
+        This relation is composed of the `ReactionHasAAMRepr` relation and the `AAMConvert` relations.
+        So if a reaction entry includes an RXN or GML representation of a map, this relation gives the same
+        map in the standardized, ReactionSMILES-based format.
+    """
+    # Attributes
+    src: SourceDatabase  #: The source database specifying this AAM.
+
+    # Transitive
+    rel_type_1 = ReactionHasAAMRepr
+    rel_type_2 = AAMConvert
+    intermediate_entrytype = AAMRepr
+
+    # Database
+    entrytype_name = 'Reaction has AAM'
+    _table_name = 'ReactionHasAAM'
+    symmetric = False
+    source_entrytype = Reaction
+    target_entrytype = AAM
+    _attribute_columns = [
+        col_src
+    ]
+    _index = [0]
+
+    def __init__(
+            self,
+            rel_1: ReactionHasAAMRepr,
+            rel_2: AAMConvert,
+            intermediate: AAMRepr,
+            recon_id_1: Optional[int] = None,
+            recon_id_2: Optional[int] = None
+    ):
+        self.src = rel_1.src
+        super().__init__(rel_1, rel_2, intermediate, recon_id_1, recon_id_2)
+
+    def _vis_str(self) -> str:
+        return f'{self.src.name}'