chemrecon 0.1.1__py3-none-any.whl

chemrecon/query/get_relations.py

@@ -0,0 +1,143 @@
+""" Contains functions to find relations (including procedural) related to an entry.
+"""
+from typing import DefaultDict
+
+import chemrecon.schema
+
+from chemrecon import Entry, Relation, ProceduralRelation, ComposedRelation
+from chemrecon.schema.direction import Direction
+from chemrecon.entrygraph.entrygraph import EntryGraph, Edge
+from chemrecon.entrygraph.explore import explore
+from chemrecon.schema.procedural_relation_entrygraph import ProceduralRelationEG
+from chemrecon.entrygraph.explorationprotocol import ExplorationProtocol
+
+import chemrecon.connection as globals
+
+# Relation lists for each entry type
+# ----------------------------------------------------------------------------------------------------------------------
+_entrytype_relation_types: dict[
+    type[Entry],
+    list[tuple[type[Relation], Direction, ExplorationProtocol]]
+] = DefaultDict(list)
+
+for reltype in chemrecon.schema.relationtypes:
+    if reltype.symmetric:
+        # Symmetric
+        protocol_spec = ExplorationProtocol(
+            relation_types = {(reltype, Direction.SYMMETRIC)}
+        )
+        _entrytype_relation_types[reltype.source_entrytype].append(
+            (reltype, Direction.SYMMETRIC, protocol_spec)
+        )
+    else:
+        # Not symmetric
+        protocol_spec_forward = ExplorationProtocol(
+            relation_types = {(reltype, Direction.FORWARDS)},
+        )
+        _entrytype_relation_types[reltype.source_entrytype].append(
+            (reltype, Direction.FORWARDS, protocol_spec_forward)
+        )
+        if not issubclass(reltype, ProceduralRelation):
+            # Add backwards explorer only if not procedural
+            protocol_spec_backward = ExplorationProtocol(
+                relation_types = {(reltype, Direction.BACKWARDS)},
+            )
+            _entrytype_relation_types[reltype.target_entrytype].append(
+                (reltype, Direction.BACKWARDS, protocol_spec_backward)
+            )
+
+# Getter functions
+# ----------------------------------------------------------------------------------------------------------------------
+def get_relations_from_entry[R: Relation](
+        entry: Entry,
+        relation_type: type[R],
+        get_backward_relations: bool = True
+) -> list[tuple[R, Entry]]:
+    """ Get relations of a given type with the specified entry as the source.
+    """
+    # TODO support for get_backward_relations !
+    # TODO entrygraph-based method will save procedural relations to the DB!
+    # TODO better generics for this!
+
+    if entry.recon_id is None:
+        # Get recon_id first
+        index_result = globals.handler.get_entry_by_index(entry)
+        if not index_result:
+            raise ValueError(f'Given entry: {entry} not found in database.')
+
+    res = globals.handler.get_relations_with_entries_by_recon_ids(
+        entry_type = type(entry),
+        recon_ids = [entry.recon_id],
+        relation_type = relation_type
+    )
+    out_list: list[tuple[Relation, Entry]] = list()
+    for target, relations in res[0].items():
+        for rel in relations:
+            out_list.append((rel, target))
+    return out_list
+
+def get_all_relations(
+        entry: Entry,
+        get_backward_relations: bool = True,
+        get_transitive_relations: bool = False,
+        get_procedural_relations: bool = False,
+        get_procedural_eg_relations: bool = False
+) -> list[tuple[Relation, Entry]]:
+    """ Get all relations of a given entry.
+        Note: Procedural relations cannot be explored backwards.
+    """
+    # TODO change to entrygraph-based method to save procedural relations to the DB!
+    # TODO better generics for this!
+
+    if entry.recon_id is None:
+        # Get recon_id first
+        index_result = globals.handler.get_entry_by_index(entry)
+        if not index_result:
+            raise ValueError(f'Given entry: {entry} not found in database.')
+
+    output_list: list[tuple[Relation, Entry]]
+
+    # Create EG spec
+    entrytypes: set[type[Entry]] = set()
+    relation_types: set[tuple[type[Relation], Direction]] = set()
+    for r_type, direction, _ in _entrytype_relation_types[type(entry)]:
+
+        # Skip if not in defined relation types
+        if issubclass(r_type, ComposedRelation) and not get_transitive_relations:
+            continue
+        if issubclass(r_type, ProceduralRelation):
+            if not get_procedural_eg_relations: continue
+            if issubclass(r_type, ProceduralRelationEG):
+                if not get_procedural_eg_relations:
+                    continue
+        if (not get_backward_relations) and (type(entry) is not r_type.source_entrytype):
+            continue
+
+        # Add to specification
+        entrytypes.add(r_type.source_entrytype)
+        entrytypes.add(r_type.target_entrytype)
+
+        if r_type.symmetric:
+            relation_types.add((r_type, Direction.SYMMETRIC))
+        else:
+            if r_type.source_entrytype == type(entry):
+                relation_types.add((r_type, Direction.FORWARDS))
+            if get_backward_relations and r_type.target_entrytype == type(entry):
+                relation_types.add((r_type, Direction.BACKWARDS))
+
+    protocol_all = ExplorationProtocol(
+        relation_types = relation_types,
+    )
+
+    # Create an EntryGraph and explore to depth 1
+    eg = EntryGraph(
+        initial_entries = {entry}
+    )
+    explore(eg, protocol = protocol_all, steps = 1)
+
+    # Get out-edges of a node (vertex with index 0 is the starting node)
+    res = eg.get_out_edges_of_vertex(0)  # list of (Edge, Vertex)
+    return [
+        (edge.relation, vertex.entry)
+        for edge, vertex in res if isinstance(edge, Edge)  # Filter out artificial edges
+    ]

chemrecon/query/get_structures_from_compound.py

@@ -0,0 +1,65 @@
+from collections import OrderedDict
+
+from src.chemrecon import Direction
+from chem.mol import MolTemplate, Mol
+from chem.create_mol import mol_from_struct_entry
+from chemrecon.entrygraph.explore import explore
+from chemrecon.entrygraph.scoring import Scorer
+from chemrecon.schema import (
+    Compound, MolStructure
+)
+from chemrecon.schema.relation_types_procedural.compound_select_structure_proceduralrelation import \
+    CompoundSelectStructure
+from chemrecon.entrygraph.explorationprotocol import ExplorationProtocol
+
+
+def get_structures_from_compound(
+    entries: Compound | list[Compound],
+    consider_first_entry_primary: bool = False,
+) -> OrderedDict[MolTemplate, float]:
+
+    # TODO update with new protocol syntax
+    raise NotImplementedError()
+
+    entry_set: set[Compound] = set()
+    match entries:
+        case Compound():
+            entry_set = {entries}
+        case list():
+            entry_set = set(entries)
+        case _:
+            raise ValueError()
+
+    # Construct entrygraph and run ranking  # TODO set first entry as primary if specified!
+    try:
+        eg = EG_Structure(
+            initial_entries = entry_set
+        )
+    except ValueError as e:
+        return OrderedDict()
+    explore(entrygraph = eg, steps = 2)
+
+    # Score
+    scoring = scorer_default(eg)
+    scoring_out: OrderedDict[Mol, float] = OrderedDict()
+    for k, v in scoring.items():
+        try:
+            scoring_out[mol_from_struct_entry(k)] = v
+        except AttributeError:
+            continue
+
+    return scoring_out
+
+
+# Specification
+EG_Structure = ExplorationProtocol(
+    entry_types = {Compound, MolStructure},
+    relation_types = {
+        (CompoundSelectStructure, Direction.FORWARDS)
+    },
+    entry_types_initial = {Compound}
+)
+
+scorer_default = Scorer[MolStructure](
+    score_entry_type = MolStructure
+)

chemrecon/schema/__init__.py

@@ -0,0 +1,86 @@
+""" Re-exports all concrete schema objects
+"""
+from __future__ import annotations
+
+from chemrecon.schema.db_object import (Entry, SourceEntry, Relation, DatabaseObject, Column,
+                                        ProceduralRelation, ProceduralGeneratorError, ComposedRelation)
+
+from chemrecon.schema.enums import *
+
+# Re-export entry types
+from chemrecon.schema.entry_types.aam import AAM
+from chemrecon.schema.entry_types.aam_repr import AAMRepr
+from chemrecon.schema.entry_types.compound import Compound
+from chemrecon.schema.entry_types.enzyme import Enzyme
+from chemrecon.schema.entry_types.reaction import Reaction
+from chemrecon.schema.entry_types.molstructure_repr import MolStructureRepr
+from chemrecon.schema.entry_types.molstructure import MolStructure
+
+# Re-export relation types (with corresponding inverses, defined in the same file as the main)
+from chemrecon.schema.relation_types_source.aam_involves_molstructure_relation import *
+from chemrecon.schema.relation_types_source.aam_repr_involves_molstructure_repr_relation import *
+from chemrecon.schema.relation_types_procedural.aam_convert_relation import *
+from chemrecon.schema.relation_types_composed.compound_has_molstructure_relation import *
+from chemrecon.schema.relation_types_source.compound_has_structure_representation_relation import *
+from chemrecon.schema.relation_types_source.compound_reference_relation import *
+from chemrecon.schema.relation_types_composed.reaction_has_aam_relation import *
+from chemrecon.schema.relation_types_source.reaction_has_aam_representation_relation import *
+from chemrecon.schema.relation_types_source.reaction_has_enzyme_relation import *
+from chemrecon.schema.relation_types_source.reaction_involves_compound_relation import *
+from chemrecon.schema.relation_types_source.reaction_reference_relation import *
+from chemrecon.schema.relation_types_procedural.molstructure_convert_relation import *
+from chemrecon.schema.relation_types_source.molstructure_standardisation_relation import *
+
+# Ontology
+from chemrecon.schema.relation_types_source.ontology.compound_ontology import *
+from chemrecon.schema.relation_types_source.ontology.reaction_ontology import *
+from chemrecon.schema.relation_types_source.ontology.enzyme_ontology import *
+
+# Procedural relation types, import only the relation, not the protocol
+from chemrecon.schema.relation_types_procedural.compound_select_structure_proceduralrelation import (
+    CompoundSelectStructure
+)
+from chemrecon.schema.relation_types_procedural.reaction_select_aam_proceduralrelation import (
+    ReactionSelectAAM
+)
+
+# Export lists
+entrytypes: list[type[Entry]] = [
+    Compound, MolStructureRepr, MolStructure, Reaction, Enzyme,
+    AAMRepr, AAM
+]
+relationtypes: list[type[Relation]] = [
+    # Main source relations
+    CompoundReference,
+    CompoundHasStructureRepresentation, CompoundHasMolStructure,
+    MolStructureConvert, MolStructureStandardization,
+    ReactionReference,
+    ReactionInvolvesCompound, CompoundParticipatesInReaction,
+    ReactionHasEnzyme,
+    ReactionHasAAMRepr,
+    ReactionHasAAM,
+    AAMReprInvolvesMolStructureRepr,
+    AAMConvert,
+    AAMInvolvesMolStructure,
+
+    # Ontology, Compound
+    CompoundIsA, CompoundHasInstance,
+    CompoundHasNewID, CompoundHasOldID,
+    CompoundHasPart, CompoundIsPartOf,
+    CompoundHasConjugateAcid, CompoundHasConjugateBase,
+    CompoundHasTautomer,
+    CompoundHasStereoIsomer,
+    CompoundHasIsotopologue,
+
+    # Ontology, Reaction
+    ReactionIsA, ReactionHasInstance,
+    ReactionHasNewID, ReactionHasOldID,
+
+    # Ontology, Enzyme
+    EnzymeIsA, EnzymeHasInstance,
+    EnzymeHasNewID, EnzymeHasOldID,
+
+    # EntryGraph Procedural
+    CompoundSelectStructure,
+    ReactionSelectAAM,
+]

chemrecon/schema/db_object.py

@@ -0,0 +1,363 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from enum import Enum
+from typing import Any, ClassVar, Optional, OrderedDict
+
+from chemrecon.core.id_types import IdentifierType
+from chemrecon.schema.enums import Quality, SourceDatabase
+
+
+class DatabaseObject(ABC):
+    """ Most generic database object, covers both entries and relations.
+    """
+    entrytype_name: ClassVar[str]
+    _table_name: ClassVar[str]
+
+    @classmethod
+    def get_table_name(cls) -> str:
+        return cls._table_name
+
+
+class Column:
+    """ Wrapper for database columns.
+    """
+    name: str
+    col_type: type
+    serial: bool  # If numeric, whether serial
+    index_hash: bool  # Whether this should be hashed if used in an index.
+
+    def __init__(self, name: str, col_type: type, serial: bool = False, index_hash: bool = False):
+        self.name = name
+        self.col_type = col_type
+        self.serial = serial
+        self.index_hash = index_hash
+
+    def __repr__(self):
+        return f'col: {self.name}'
+
+
+# Entry abstract base class
+# --------------------------------------------------------------------------------------------------------------
+class Entry(DatabaseObject, ABC):
+    """ Generic base class for entries.
+    """
+    # Attributes
+
+    #: Internal identifier in the *ChemRecon* database.
+    #: Normally, entries have a nonnegative `recon_id`, unique to the table.
+    #: A negative `recon_id` indicates that the object is 'virtual', that is, it was created by a procedural relation,
+    #: and does not exist in the database.
+    #: A `recon_id` of `None` indicates that the entry is not stored in the database.
+    recon_id: Optional[int]
+
+    # Database
+    _columns: ClassVar[list[Column]]  # List of columns. The zeroth (recon_id) will be considered the PK.
+    _index: ClassVar[list[int]]  # List of the columns on which to create a (possibly hashed) index.
+
+    # For visualization
+    _draw_colour: ClassVar[str]
+
+    def get_columns_with_values(self, include_recon_id = True) -> dict[Column, Any]:
+        """ Get the columns of this entry with values. """
+        return OrderedDict(
+            (c, self.__getattribute__(c.name)) for c in self._columns if
+            (c is not col_recon_id) or include_recon_id
+        )
+
+    def get_index_columns_with_values(self) -> dict[Column, Any]:
+        """ Get the index (primary key) columns of this entry with values. """
+        return OrderedDict(
+            (c, self.__getattribute__(c.name)) for c in self.get_index_columns()
+        )
+
+    # Methods for database interaction
+    @classmethod
+    def get_columns(cls, include_recon_id = True) -> list[Column]:
+        if include_recon_id:
+            return cls._columns
+        else:
+            return cls._columns[1:]  # Assuming recon_id is columns[0]
+
+    @classmethod
+    def get_index_indices(cls) -> list[int]:
+        return cls._index
+
+    @classmethod
+    def get_index_columns(cls) -> list[Column]:
+        return [cls._columns[i] for i in cls._index]
+
+    # Misc
+    def __init__(self, recon_id: Optional[int] = None):
+        super().__init__()
+        self.recon_id = recon_id
+
+    def __repr__(self):
+        attr_cols: str = ', '.join(
+            f'{c.name}: {v}'
+            for c, v in self.get_columns_with_values(include_recon_id = False).items()
+            if (v is not None) and (v != [])
+        )
+        return f'<{self._table_name} {self.recon_id or '-'}: {attr_cols}>'
+
+    # Comparison and identity
+    def __eq__(self, other: Entry):
+        if type(self) is not type(other):
+            return False
+        elif self.recon_id is not None and other.recon_id is not None:
+            # Compare recon_id if applicable
+            return self.recon_id == other.recon_id
+        else:
+            # Else, compare by index columns
+            return all(
+                self.__getattribute__(col.name) == other.__getattribute__(col.name)
+                for col in self.get_index_columns()
+            )
+
+    def __hash__(self):
+        return tuple(self.__getattribute__(col.name) for col in self.get_index_columns()).__hash__()
+
+    def __lt__(self, other: Entry):
+        # Compare by reconid, otherwise by index
+        if (self.recon_id is not None) and (other.recon_id is not None):
+            return self.recon_id.__lt__(other.recon_id)
+        else:
+            # Compare by index columns
+            return tuple(self.get_columns_with_values().values()) < tuple(
+                other.get_columns_with_values().values())
+
+    @classmethod
+    def get_supertype_of_id_types(cls) -> Optional[type[IdentifierType]]:
+        for c in cls.get_columns():
+            if c.name == 'id_type':
+                if not issubclass(c.col_type, IdentifierType):
+                    raise ValueError('Error in identifier type assignment of column.')
+                return c.col_type
+        return None
+
+    # Visualisation
+    @abstractmethod
+    def _vis_str(self) -> str:
+        """ Get the string of the primary information for visualization.
+        """
+        pass
+
+    def _vis_attrs(self) -> dict[str, str]:
+        """ Define extra attributes used in visualization.
+        """
+        return {
+            'fillcolor': f'"#{self._draw_colour}"'
+        }
+
+    # Encoding (for memoization/caching)
+    def encode(self):
+        return str(self.recon_id).encode()
+
+    def serialise(self, index_only: bool = False) -> dict:
+        d = dict()
+        if index_only:
+            for col, val in self.get_index_columns_with_values().items():
+                d[col.name] = serialise_col(col, val)
+        else:
+            for col, val in self.get_columns_with_values().items():
+                d[col.name] = serialise_col(col, val)
+        return d
+
+
+# Entry as a database stand-in
+class SourceEntry(Entry, ABC):
+    """ An entry which stands for a database entry in one of the source databases.
+    """
+    source_id: str
+    id_type: Enum
+
+    def _vis_str(self) -> str:
+        return f'{self.id_type.name}: {self.source_id}'
+
+
+# Relation
+# --------------------------------------------------------------------------------------------------------------
+class Relation[T1, T2](DatabaseObject, ABC):
+    """ Generic base class for relations between entries.
+    """
+    # Attributes
+    recon_id_1: Optional[int]  #: Recon ID of source
+    recon_id_2: Optional[int]  #: Recon ID of target
+    entry_1: Optional[T1]  # Entries on either end. Used on prototypes, and can also be fetched via the db.
+    entry_2: Optional[T2]
+
+    # Database
+    ignore_generation_limit: ClassVar[bool] = False  # If true, will continue exploring after generation limit
+    symmetric: ClassVar[bool]  # If symmetric, will always have recon_id_1 <= recon_id_2
+
+    # Set if this is the main table of another inverse relation
+    has_inverse: ClassVar[Optional[type[Relation]]]  #: :meta private:
+
+    _attribute_columns: ClassVar[list[Column]]
+    _index: ClassVar[list[int]]  # List of col index in attr list on which to create an index.
+
+    source_entrytype: ClassVar[type[Entry]]  #: :meta private:
+    target_entrytype: ClassVar[type[Entry]]  #: :meta private:
+
+    # Methods for database interaction
+    @classmethod
+    def get_attribute_columns(cls) -> list[Column]:
+        # Note: does not include source/target columns
+        return cls._attribute_columns
+
+    @classmethod
+    def get_columns(cls, include_recon_ids: bool = True) -> list[Column]:
+        if include_recon_ids:
+            return [col_recon_id_1, col_recon_id_2, *cls._attribute_columns]
+        else:
+            return cls._attribute_columns
+
+    @classmethod
+    def get_index_indices(cls) -> list[int]:
+        return cls._index
+
+    @classmethod
+    def get_index_columns(cls) -> list[Column]:
+        return [col_recon_id_1, col_recon_id_2, *[
+            cls._attribute_columns[i]
+            for i in cls._index
+        ]]
+
+    def get_columns_with_values(self, include_recon_ids: bool = True) -> dict[Column, Any]:
+        """ Get the columns of this entry with values. """
+        return OrderedDict(
+            (c, self.__getattribute__(c.name)) for c in self.get_columns(include_recon_ids)
+        )
+
+    def get_index_columns_with_values(self) -> dict[Column, Any]:
+        """ Get the index (primary key) columns of this entry with values.
+            This always includes `recon_id_1` and `recon_id_2`, and may include attribute columns.
+        """
+        return OrderedDict(
+            (c, self.__getattribute__(c.name)) for c in self.get_index_columns()
+        )
+
+    @classmethod
+    def get_entry_table_names(cls) -> tuple[str, str]:
+        return cls.source_entrytype.get_table_name(), cls.target_entrytype.get_table_name()
+
+    # Misc
+    def __init__(
+            self,
+            recon_id_1: Optional[int] = None,
+            recon_id_2: Optional[int] = None,
+    ):
+        super().__init__()
+        self.recon_id_1, self.recon_id_2 = recon_id_1, recon_id_2
+
+    def __repr__(self):
+        arrow = '<->' if self.symmetric else '->'
+        attr_cols: str = ', '.join(
+            f'{c.name}: {v}'
+            for c, v in self.get_columns_with_values(include_recon_ids = False).items()
+        )
+        return f'<{self._table_name} {self.recon_id_1} {arrow} {self.recon_id_2}] {attr_cols}>'
+
+    # Visualisation
+    def _vis_attrs(self) -> dict[str, str]:
+        """ Define extra attributes used in visualization.
+        """
+        return dict()
+
+    def _vis_str(self) -> str:
+        """ Define extra attributes
+        """
+        return ''
+
+# Inverse relations
+class InverseRelation[T1: Entry, T2: Entry](Relation[T1, T2], ABC):
+    """ Represents the inverse of another (main) relation.
+        The main relation should have the has_inverse tag set.
+        Exists in the database only as views of the main relation.
+    """
+    inverse_main_relation: ClassVar[type[Relation]]  #: :meta private:
+
+    # Check that attribute columns are the same as for the main relation
+
+
+# Procedural Relations
+class ProceduralRelation[T1: Entry, T2: Entry](Relation[T1, T2], ABC):
+    """ Procedural relations are not stored in the database but computed at runtime.
+        Other than this, they have the same interface as normal relations.
+        Some can be computed only "one-way" (e.g. a compound can be standardized, but not un-standardized)
+    """
+
+    @classmethod
+    @abstractmethod
+    def generate(
+            cls,
+            take_entry: T1,
+    ) -> list[tuple[ProceduralRelation[T1, T2], T2]]:
+        """ Given a T1, generate relations from that.
+        """
+        raise NotImplementedError()
+
+
+class ProceduralGeneratorError(Exception):
+    """ Should be thrown by generator methods.
+    """
+    pass
+
+
+# Composed Relations
+class ComposedRelation[T1, T2, T_intermediate](Relation[T1, T2], ABC):
+    # Composed of two other relations
+    rel_type_1: ClassVar[type[Relation]]  #: :meta private:
+    rel_type_2: ClassVar[type[Relation]]  #: :meta private:
+    intermediate_entrytype: ClassVar[type[Entry]]  #: :meta private:
+
+    # Init based on the given relations and intermediate
+    @abstractmethod
+    def __init__(
+            self,
+            rel_1: Relation[T1, T_intermediate],
+            rel_2: Relation[T_intermediate, T2],
+            intermediate: T_intermediate,
+            recon_id_1: Optional[int] = None,
+            recon_id_2: Optional[int] = None,
+    ):
+        """ Init for composed relations should be overriden to set attributes of the composed relation based on the
+            attributes of relations and entries used to create it.
+        """
+        super().__init__(recon_id_1, recon_id_2)
+
+    # Filter functions on the composed edges, which determine whether to create the procedural relations
+    @classmethod
+    def filter_rel_1(cls, r: Relation[T1, T_intermediate]) -> bool:
+        return True
+
+    @classmethod
+    def filter_intermediate(cls, e: T_intermediate) -> bool:
+        return True
+
+    @classmethod
+    def filter_rel_2(cls, r: Relation[T_intermediate, T2]) -> bool:
+        return True
+
+
+# Predefined columns
+# ----------------------------------------------------------------------------------------------------------------------
+col_recon_id = Column('recon_id', int, serial = True)
+col_source_id = Column('source_id', str)
+col_source_id_hashed = Column('source_id', str, index_hash = True)
+col_name = Column('name', str)
+col_src = Column('src', SourceDatabase)
+col_quality = Column('quality', Quality)
+col_properties = Column('properties', list[str])
+col_recon_id_2 = Column('recon_id_2', int)
+col_recon_id_1 = Column('recon_id_1', int)
+col_score = Column('score', float)
+
+
+# Util
+# ----------------------------------------------------------------------------------------------------------------------
+def serialise_col(col: Column, value: Any) -> Any:
+    if isinstance(value, Enum):
+        return value.name
+    else:
+        return value

chemrecon/schema/direction.py

@@ -0,0 +1,10 @@
+from __future__ import annotations
+
+from enum import Enum
+
+
+class Direction(Enum):
+    FORWARDS = 1  #: From source to target.
+    BACKWARDS = 2  #: From target to source.
+    BOTH = 3  #: Both of the above.
+    SYMMETRIC = 4  #: To be used for symmetric relations.