chemrecon 0.1.1__py3-none-any.whl

chemrecon/entrygraph/explore_procedure.py

@@ -0,0 +1,183 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import Optional, ClassVar
+
+import psycopg as pg
+from psycopg import sql as sql
+
+from chemrecon.entrygraph.filter import EntryFilter, RelationFilter
+from chemrecon.schema.db_object import Entry, Relation
+
+
+class ExploreProcedure[T_takes: Entry, T_gives: Entry](ABC):
+    takes_entrytype: type[T_takes]
+    gives_entrytype: type[T_gives]
+    relation_type: type[Relation]  # Filter on the produced relations
+    entry_filter: Optional[EntryFilter[T_gives]]   # Filter on T_gives
+    relation_filter: Optional[RelationFilter]
+
+    # Pre-computed SQL snippets
+    _opt_relation_filter_clause: sql.Composable
+    _opt_entry_filter_clause: sql.Composable
+
+    n_params: ClassVar[int]
+
+    # SQL
+    q: sql.Composed
+    cursor: pg.Cursor
+
+    def __init__(
+        self,
+        relationtype: type[Relation],
+        relation_filter: Optional[RelationFilter],
+        entry_filter: Optional[EntryFilter],
+    ):
+        # Init
+        self.relation_type = relationtype
+        self.relation_filter = relation_filter
+        self.entry_filter = entry_filter
+
+        if relation_filter is not None:
+            #assert relation_filter.relation_type == relationtype
+            pass
+        if entry_filter is not None:
+            #assert entry_filter.entry_type == self.gives_entrytype
+            pass
+
+        # Generate the various clauses ahead of time
+        match self.relation_filter:
+            # TODO filtering
+            #case RelationFilterSource():
+            #    # Filter
+            #    self._opt_relation_filter_clause = sql.SQL("""
+            #        AND (rel_src in {src_set})
+            #    """).format(
+            #        src_set = list(relation_filter.allowed_sources)
+            #    )
+            case _:
+                # No filter
+                self._opt_relation_filter_clause = sql.SQL('')
+
+        # Entry clause
+        # TODO change to filter entries on the DB level (hard for symmetric relations?)
+        #   for symmetric - BOTH recon ids need to be in the set of allowed id types?
+        self._opt_entry_filter_clause = self.make_entry_filter_clause()
+
+        # Generate the query except for the formats
+        # Clause is prepared with as much formating as possible now, %(reconids)s param will be used when
+        # calling only
+        self.q = sql.SQL("""
+          SELECT *
+          FROM {rel_view}
+          WHERE {where_clause} {opt_relation_clause} {opt_entry_clause}
+          ;
+        """).format(
+            rel_view = sql.Identifier(f'{self.relation_type.get_table_name()}_v'),
+            where_clause = self.make_where_clause(),
+            opt_relation_clause = self._opt_relation_filter_clause,
+            opt_entry_clause = self._opt_entry_filter_clause
+        )
+
+    @abstractmethod
+    def make_where_clause(self) -> sql.SQL:
+        """ Returns a parametrised SQL string to be used when calling. """
+        pass
+
+    @abstractmethod
+    def make_entry_filter_clause(self) -> sql.SQL:
+        """ Returns an SQL string filtering correctly by recon_id_1, recon_id_2, or both. """
+        pass
+
+
+class ExploreProcedureT1[T_takes: Entry, T_gives: Entry](ExploreProcedure[T_takes, T_gives]):
+    # Explore from T1
+    takes_entrytype: type[T_takes]
+    gives_entrytype: type[T_gives]
+    relation_type: type[Relation[T_takes, T_gives]]
+    entry_filter: Optional[EntryFilter[T_gives]]
+    relation_filter: Optional[RelationFilter[T_takes, T_gives]]
+
+    n_params: ClassVar[int] = 1
+
+    def __init__(
+        self,
+        relationtype: type[Relation[T_takes, T_gives]],
+        relation_filter: Optional[RelationFilter[T_takes, T_gives]],
+        entry_filter: Optional[EntryFilter[T_gives]]
+    ):
+        assert not relationtype.symmetric
+        self.takes_entrytype = relationtype.source_entrytype
+        self.produces_entrytype = relationtype.target_entrytype
+        self.relation = relationtype
+
+        super().__init__(relationtype, relation_filter, entry_filter)
+
+    def make_where_clause(self) -> sql.SQL:
+        return sql.SQL("recon_id_1 = %s")
+
+    def make_entry_filter_clause(self) -> sql.SQL:
+        # TODO
+        return sql.SQL('')
+
+
+class ExploreProcedureT2[T_takes: Entry, T_gives: Entry](ExploreProcedure[T_takes, T_gives]):
+    # Explore from T2
+    takes_entrytype: type[T_takes]
+    gives_entrytype: type[T_gives]
+    relation_type: type[Relation[T_gives, T_takes]]
+    entry_filter: Optional[EntryFilter[T_gives]]
+    relation_filter: Optional[RelationFilter[T_gives, T_takes]]
+
+    n_params: ClassVar[int] = 1
+
+    def __init__(
+        self,
+        relationtype: type[Relation[T_gives, T_takes]],
+        relation_filter: Optional[RelationFilter[T_gives, T_takes]],
+        entry_filter: Optional[EntryFilter[T_gives]]
+    ):
+        assert not relationtype.symmetric
+        self.takes_entrytype = relationtype.target_entrytype
+        self.produces_entrytype = relationtype.source_entrytype
+        self.relation = relationtype
+
+        super().__init__(relationtype, relation_filter, entry_filter)
+
+    def make_where_clause(self) -> sql.SQL:
+        return sql.SQL("recon_id_2 = %s")
+
+    def make_entry_filter_clause(self) -> sql.SQL:
+        # TODO
+        return sql.SQL('')
+
+
+class ExploreProcedureSym[T: Entry](ExploreProcedure[T, T]):
+    # Explore from T
+    takes_entrytype: type[T]
+    gives_entrytype: type[T]
+    relation_type: type[Relation[T, T]]
+    entry_filter: Optional[EntryFilter[T]]
+    relation_filter: Optional[RelationFilter[T, T]]
+
+    n_params: ClassVar[int] = 2
+
+    def __init__(
+        self,
+        relationtype: type[Relation[T, T]],
+        relation_filter: Optional[RelationFilter[T, T]],
+        entry_filter: Optional[EntryFilter[T]]
+    ):
+        assert relationtype.symmetric
+        self.takes_entrytype = relationtype.source_entrytype
+        self.produces_entrytype = relationtype.target_entrytype
+        self.relation = relationtype
+
+        super().__init__(relationtype, relation_filter, entry_filter)
+
+    def make_where_clause(self) -> sql.SQL:
+        return sql.SQL("(recon_id_1 = %s) OR (recon_id_2 = %s)")
+
+    def make_entry_filter_clause(self) -> sql.SQL:
+        # TODO
+        return sql.SQL('')

chemrecon/entrygraph/filter.py

@@ -0,0 +1,88 @@
+""" TODO re-implement this later, for now, filters should just be functions
+"""
+
+from abc import ABC, abstractmethod
+from typing import Callable
+
+from chemrecon.schema.db_object import SourceEntry
+from chemrecon.core.id_types import IdentifierType
+from chemrecon.schema.db_object import Entry, Relation
+from chemrecon.schema.enums import SourceDatabase
+
+
+class EntryFilter[T: Entry](ABC):
+    """ Base class for filters. """
+    entry_type: type[Entry]
+    allowed_id_types: set[IdentifierType]
+    has_id_type_field: bool
+
+    @abstractmethod
+    def __call__(self, entry: T) -> bool:
+        # Base implementation
+        return True
+
+class RelationFilter[T1: Entry, T2: Entry](ABC):
+    """ Base class for filters. """
+    relation_type: type[Relation[T1, T2]]
+    allowed_sources: set[SourceDatabase]
+    has_src_field: bool
+
+    def __init__(self, relation_type: type[Relation[T1, T2]]):
+        self.relation_type = relation_type
+
+    @abstractmethod
+    def __call__(self, relation: Relation[T1, T2]) -> bool:
+        # Base implementation
+        return True
+
+class EntryFilterIdType[T: SourceEntry](EntryFilter[T]):
+    """
+    """
+    allowed_id_types: set[IdentifierType]
+    # TODO
+
+    def __init__(self, allowed_id_types: set[IdentifierType]):
+        self.allowed_id_types = allowed_id_types
+        raise NotImplementedError()
+
+    def __call__(self, entry: T) -> bool:
+        raise NotImplementedError()
+
+# TODO similar to EntryFilterIdType, but for source
+
+
+class EntryFilterProcedure[T: Entry](EntryFilter):
+    """ Allows custom filtering on the application level in addition to type filtering.
+    """
+    procedure: Callable[[T], bool]
+
+    def __init__(self, filter_proc: Callable[[T], bool]):
+        self.procedure = filter_proc
+        super().__init__()
+
+    def __call__(self, entry: T) -> bool:
+        if super().__call__(entry):
+            return self.procedure(entry)
+        else:
+            return False
+
+
+
+class RelationFilterProcedure[T1: Entry, T2: Entry](RelationFilter):
+    """ Allows custom filtering on the application level in addition to source
+    """
+    procedure: Callable[[Relation[T1, T2]], bool]
+
+    def __call__(self, relation: Relation[T1, T2]) -> bool:
+        if super().__call__(relation):
+            return self.procedure(relation)
+        else:
+            return False
+
+    def __init__(
+        self,
+        relation_type: type[Relation[T1, T2]],
+        filter_proc: Callable[[Relation[T1, T2]], bool]
+    ):
+        super().__init__(relation_type)
+        self.procedure = filter_proc

chemrecon/entrygraph/scoring.py

@@ -0,0 +1,141 @@
+""" Methods for producing a ranking on an entry graph.
+"""
+from collections import OrderedDict
+from typing import Callable, Optional, TYPE_CHECKING
+
+import rustworkx
+
+from chemrecon.entrygraph.entrygraph import (
+    Edge, EntryGraph, SourceEdgeArtificial, SourceVertexArtificial, Vertex,
+)
+from chemrecon.schema import Entry, Relation
+
+if TYPE_CHECKING:
+    from chemrecon.schema.procedural_relation_entrygraph import ProceduralRelationEG
+
+
+class Scorer[T_rank: Entry]:
+    """ A scorer is a callable which takes an entrygraph and produces a ranking of the vertices according to
+        the parameters of the scorer.
+
+        The score of an entry is (informally) the probability that a random walk starting at one of the initial entries
+        of the entry graph will terminate at that entry.
+        The parameters of the random walk can be customized by specifying weights (probabilities) using a weight
+        function on entries and relations, which alters the probability of choosing a given path.
+        The default weight of all entries and relations is 1.
+        For example, if you do not trust a particular source, edges and vertices from that source can have their
+        weight reduced, making them count less in the scoring algorithm.
+
+        A damping factor, `alpha` can be specified.
+        With probability `1-alpha`, the random walk will choose to go to a random entry rather than continuing the walk.
+        Furthermore, a _decay_factor_ can be specified such that entries further away from the initial entries are given
+        lower scores.
+        A decay factor of `0` disables this adjustment. The default is `0.2`.
+
+        Scores are normalized such that the sum of scores is **1**, which allows comparing scores across entry graphs.
+
+        Formally, the scores are computed using the PageRank algorithm (https://en.wikipedia.org/wiki/PageRank),
+        starting from the initial vertices, and with dangling vertices pointing back to all initial vertices with
+        equal probability.
+
+    """
+    score_entry_type: type[T_rank]
+
+    entry_weight: Callable[[Entry], float]
+    relation_weight: Callable[[Relation], float]
+
+    # Algorithm parameters
+    alpha: float
+    decay_factor: float
+
+    def __init__(
+            self,
+            score_entry_type: type[Entry],
+            alpha: float = 0.85,
+            decay_factor: float = 0.2,
+            entry_weight: Optional[Callable[[Entry], float]] = None,
+            relation_weight: Optional[Callable[[Relation], float]] = None,
+    ):
+        """ Specify a scorer.
+        """
+        self.alpha = alpha
+        self.decay_factor = decay_factor
+
+        self.score_entry_type = score_entry_type
+
+        if entry_weight is not None:
+            self.entry_weight = entry_weight
+        else:
+            self.entry_weight = lambda e: 1
+
+        if relation_weight is not None:
+            self.relation_weight = relation_weight
+        else:
+            self.relation_weight = lambda r: 1
+
+    def __call__(self, entrygraph: EntryGraph) -> OrderedDict[T_rank, float]:
+        """ Produces a ranking of the entries of the type `score_entry_type`.
+            The result is an `OrderedDict`, with entries given in descending order of score.
+        """
+        from chemrecon.schema.procedural_relation_entrygraph import ProceduralRelationEG
+
+        g = entrygraph.g.copy()
+
+        # Add source vertex and connect to initial vertices
+        source_vertex_index = g.add_node(SourceVertexArtificial())
+        for init_v_index in entrygraph.initial_vertices:
+            g.add_edge(source_vertex_index, init_v_index, SourceEdgeArtificial())
+
+        # Get the weight for all edges
+        edge_weight_dict: dict[Edge, float] = dict()
+        for e_index in g.edge_indices():
+            e = g.get_edge_data_by_index(e_index)
+            source_index = g.get_edge_endpoints_by_index(e_index)[0]
+            if isinstance(e, Edge):
+                edge_weight_dict[e] = (
+                        self.relation_weight(e.relation)
+                        * self.entry_weight(g.get_node_data(source_index).entry)
+                )
+            else:
+                edge_weight_dict[e] = 1
+
+            # Modify edges by 'score' parameter of EG-based procedural relations
+            if isinstance(e, Edge):
+                if isinstance(e.relation, ProceduralRelationEG):
+                    edge_weight_dict[e] *= e.relation.score
+
+        for e_index in g.edge_indices():
+            e = g.get_edge_data_by_index(e_index)
+
+        # Produce the initial score (ranking all vertices, not normalized)
+        init_scoring = rustworkx.pagerank(
+            g,
+            alpha = self.alpha,
+            weight_fn = lambda e_: edge_weight_dict.get(e_, 1),
+            dangling = {source_vertex_index: 1},  # Terminal nodes should loop back to source
+            personalization = {source_vertex_index: 1}  # Random traversals go back to source
+        )
+
+        # Use only eligible entries (filter by relevant entry type)
+        scoring: dict[Vertex, float] = dict()
+        for v_idx, score in init_scoring.items():
+            v = g.get_node_data(v_idx)
+            if isinstance(v, Vertex) and isinstance(v.entry, self.score_entry_type):
+                scoring[v] = score
+
+        # Apply decay based on the generation
+        if self.decay_factor != 0:
+            for v, score in scoring.items():
+                v: Vertex
+                scoring[v] = score * ((1 - self.decay_factor)**v.generation)
+
+        # Normalise s.t. sum(scoring.values()) == 1.0
+        score_sum = sum(s for _, s in scoring.items())
+        for v, score in scoring.items():
+            scoring[v] = score / score_sum
+
+        # Finalise
+        return OrderedDict(
+            (k.entry, v) for k, v in
+            sorted(scoring.items(), key = lambda pair: pair[1], reverse = True)
+        )

chemrecon/query/__init__.py

@@ -0,0 +1,26 @@
+"""
+This module contains functions useful for querying the database.
+These functions are also available in the `chemrecon` scope.
+"""
+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 (
+    get_relations_from_entry,
+    get_all_relations,
+)
+
+# 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
+# )
+

chemrecon/query/create_entry.py

@@ -0,0 +1,86 @@
+# """ Contains methods to create entries to look up in the databases.
+# """
+#
+#
+# from chemrecon.core.id_types import (
+#     IdentifierType, IdentifierTypeCompound, IdentifierTypeReaction, IdentifierTypeStructureRepresentation,
+#     IdentifierTypeEnzyme, E_EC, IdentifierTypeAAM
+# )
+# from chemrecon.schema import (
+#     Entry, Compound, Enzyme, Reaction, MolStructureRepr, MolStructure,
+#     AAMRepr, AAM
+# )
+#
+#
+# # Direct creation of prototype entries
+# # ----------------------------------------------------------------------------------------------------------------------
+# def entry(id_type: IdentifierType, source_id: str) -> Entry:
+#     """ Create a 'prototype' entry, which may or may not correspond to an actual entry in the database.
+#     """
+#     match id_type:
+#         case IdentifierTypeCompound():
+#             return compound_entry(id_type, source_id)
+#         case IdentifierTypeReaction():
+#             return reaction_entry(id_type, source_id)
+#         case IdentifierTypeEnzyme():
+#             return enzyme_entry(id_type, source_id)
+#         case IdentifierTypeStructureRepresentation():
+#             return structure_representation_entry(id_type, source_id)
+#         case IdentifierTypeAAM():
+#             return aam_representation_entry(id_type, source_id)
+#         case _:
+#             # Not implemented
+#             raise NotImplementedError()
+#
+# def compound_entry(id_type: IdentifierTypeCompound, source_id: str) -> Compound:
+#     """ TODO docs
+#     """
+#     return Compound(id_type = id_type, source_id = id_type.std_identifier(source_id))
+#
+# def reaction_entry(id_type: IdentifierTypeReaction, source_id: str) -> Reaction:
+#     """ TODO docs
+#     """
+#     return Reaction(id_type = id_type, source_id = id_type.std_identifier(source_id))
+#
+# def enzyme_entry(id_type: IdentifierTypeEnzyme, source_id: str) -> Enzyme:
+#     """ TODO docs
+#     """
+#     return Enzyme(id_type = id_type, source_id = id_type.std_identifier(source_id))
+#
+# def structure_representation_entry(id_type: IdentifierTypeStructureRepresentation, source_id: str) -> MolStructureRepr:
+#     """ TODO docs
+#     """
+#     return MolStructureRepr(id_type = id_type, source_id = id_type.std_identifier(source_id))
+#
+# def aam_representation_entry(id_type: IdentifierTypeAAM, source_id: str) -> AAMRepr:
+#     """ TODO docs
+#     """
+#     return AAMRepr(id_type = id_type, source_id = id_type.std_identifier(source_id))
+#
+# def structure_entry(smiles: str) -> MolStructure:
+#     """ TODO docs
+#     """
+#     return MolStructure(smiles = smiles)
+#
+# def aam_entry(reaction_smiles: str) -> AAM:
+#     """ TODO docs
+#     """
+#     return AAM(reaction_smiles = reaction_smiles)
+#
+#
+# # Special for ec
+# def enzyme_from_ec_number(ec_number: str) -> Enzyme:
+#     """ Create a prototype enzyme entry from an EC number.
+#     """
+#     return Enzyme(id_type = E_EC, source_id = E_EC.std_identifier(ec_number))
+#
+#
+# # Creation from identifiers.org strings
+# # ----------------------------------------------------------------------------------------------------------------------
+# def entry_from_identifiers_org(identifiers_org_string: str) -> Entry:
+#     """ Create an entry from an identifiers.org string. If the string is not valid for any types in the database, raise
+#         ValueError.
+#     """
+#     # TODO
+#     # TODO raise ValueError if invalid string
+#     raise NotImplementedError()

chemrecon/query/default_protocols.py

@@ -0,0 +1,57 @@
+""" ChemRecon comes with a set of pre-defined exploration protocols for various purposes.
+    These are located in the chemrecon.query.default_protocols module.
+    We recommend looking in this file for inspiration on how to define custom protocols.
+"""
+from src.chemrecon import Direction
+from chemrecon.entrygraph.filter import EntryFilterProcedure
+from chemrecon.entrygraph.explorationprotocol import ExplorationProtocol
+from chemrecon.schema.entry_types.compound import Compound
+from chemrecon.schema.entry_types.molstructure_repr import MolStructureRepr
+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
+
+# TODO filters
+
+# General
+# ----------------------------------------------------------------------------------------------------------------------
+#: The Compound-Structure protocol can be used to quickly gain an overview of the structural information
+#: relating to a given compound.
+#: The database compounds are traversed via the `CompoundReference` relation in order to expand the graph to include
+#: other databases which contain the compound.
+#: The `CompoundHasMolStructure` relation is then used to find the associated structure for each compound.
+#: The `MolStructureStandardization` relation is used to standardize various properties of the structures, which can be
+#: helpful in case the databases simply disagree on easy-to-standardize properties, such as charge or tautomerism.
+protocol_compound_structure = ExplorationProtocol(
+    relation_types = {
+        (CompoundReference, Direction.SYMMETRIC),
+        (CompoundHasMolStructure, Direction.FORWARDS),
+        (MolStructureStandardization, Direction.FORWARDS),
+    }
+)
+
+# Search graphs - for selection rather than manual inspection
+# ----------------------------------------------------------------------------------------------------------------------
+protocol_select_structure = ExplorationProtocol(
+    relation_types = {
+        (CompoundReference, Direction.SYMMETRIC),
+        (CompoundHasMolStructure, Direction.FORWARDS),
+        (MolStructureStandardization, Direction.FORWARDS),
+    },
+)
+
+# TODO - FILTER - disallow implicit Structures!
+def _select_structure_entry_filter(e: MolStructureRepr) -> bool:
+    if e.implicit:
+        return False
+    else:
+        return True
+
+struct_repr_filter = EntryFilterProcedure[MolStructureRepr](
+    filter_proc = _select_structure_entry_filter
+)
+
+
+# TODO include some ontology relations, such as the old_id and new_id relations
+

chemrecon/query/find_entry.py

@@ -0,0 +1,84 @@
+""" Functions for finding entries given an index.
+"""
+from typing import Optional
+
+import chemrecon.connection as connection
+
+from chemrecon import IdentifierType, Entry, IdentifierTypeCompound, IdentifierTypeReaction, IdentifierTypeEnzyme, \
+    IdentifierTypeStructureRepresentation, IdentifierTypeAAM
+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
+
+
+def find_entry(id_type: IdentifierType, source_id: str) -> Optional[Entry]:
+    """ Look for an entry with the specified type and id in the connected Database.
+        If not found, returns None.
+    """
+    match id_type:
+        case IdentifierTypeCompound():
+            return find_compound_entry(id_type, source_id)
+        case IdentifierTypeReaction():
+            return find_reaction_entry(id_type, source_id)
+        case IdentifierTypeEnzyme():
+            return find_enzyme_entry(id_type, source_id)
+        case IdentifierTypeStructureRepresentation():
+            return find_structure_representation_entry(id_type, source_id)
+        case IdentifierTypeAAM():
+            return find_aam_representation_entry(id_type, source_id)
+        case _:
+            # Not implemented
+            raise NotImplementedError()
+
+def find_compound_entry(id_type: IdentifierTypeCompound, source_id: str) -> Optional[Compound]:
+    """ Look for an entry with the specified type and id in the connected Database.
+        If not found, returns None.
+    """
+    e = Compound(id_type = id_type.enum_type, source_id = id_type.std_identifier(source_id))
+    return connection.handler.get_entry_by_index(e)
+
+def find_reaction_entry(id_type: IdentifierTypeReaction, source_id: str) -> Optional[Reaction]:
+    """ Look for an entry with the specified type and id in the connected Database.
+        If not found, returns None.
+    """
+    e = Reaction(id_type = id_type.enum_type, source_id = id_type.std_identifier(source_id))
+    return connection.handler.get_entry_by_index(e)
+
+def find_enzyme_entry(id_type: IdentifierTypeEnzyme, source_id: str) -> Optional[Enzyme]:
+    """ Look for an entry with the specified type and id in the connected Database.
+        If not found, returns None.
+    """
+    e = Enzyme(id_type = id_type.enum_type, source_id = id_type.std_identifier(source_id))
+    return connection.handler.get_entry_by_index(e)
+
+def find_structure_representation_entry(id_type: IdentifierTypeStructureRepresentation, source_id: str) -> Optional[MolStructureRepr]:
+    """ Look for an entry with the specified type and id in the connected Database.
+        If not found, returns None.
+    """
+    e = MolStructureRepr(id_type = id_type.enum_type, source_id = id_type.std_identifier(source_id), implicit = False)
+    return connection.handler.get_entry_by_index(e)
+
+def find_aam_representation_entry(id_type: IdentifierTypeAAM, source_id: str) -> Optional[AAMRepr]:
+    """ Look for an entry with the specified type and id in the connected Database.
+        If not found, returns None.
+    """
+    e = AAMRepr(id_type = id_type.enum_type, source_id = id_type.std_identifier(source_id))
+    return connection.handler.get_entry_by_index(e)
+
+def find_structure_entry(smiles: str) -> Optional[MolStructure]:
+    """ Look for an entry with the specified type and id in the connected Database.
+        If not found, returns None.
+    """
+    e = MolStructure(smiles = smiles)
+    return connection.handler.get_entry_by_index(e)
+
+def find_aam_entry(reaction_smiles: str) -> Optional[AAM]:
+    """ Look for an entry with the specified type and id in the connected Database.
+        If not found, returns None.
+    """
+    e = AAM(reaction_smiles = reaction_smiles)
+    return connection.handler.get_entry_by_index(e)