chemrecon 0.1.1__tar.gz

chemrecon-0.1.1/PKG-INFO

@@ -0,0 +1,143 @@
+Metadata-Version: 2.4
+Name: chemrecon
+Version: 0.1.1
+Summary: The ChemRecon library for integration and exploration of interconnected biochemical databases.
+Keywords: bioinformatics
+Author: Casper Asbjørn Eriksen
+Author-email: Casper Asbjørn Eriksen <casbjorn@imada.sdu.dk>
+License-Expression: GPL-3.0-only
+Classifier: Programming Language :: Python :: 3.12
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Classifier: Topic :: Scientific/Engineering :: Chemistry
+Requires-Dist: psycopg[binary]~=3.3.2
+Requires-Dist: rustworkx~=0.17.1
+Requires-Dist: networkx~=3.6.1
+Requires-Dist: matplotlib~=3.10
+Requires-Dist: rdkit
+Requires-Dist: sphinx==8.3.0 ; extra == 'docs'
+Requires-Dist: myst-parser ; extra == 'docs'
+Requires-Dist: sphinx-autobuild ; extra == 'docs'
+Requires-Dist: enum-tools[sphinx]==0.12.0 ; extra == 'docs'
+Requires-Dist: sphinx-toolbox ; extra == 'docs'
+Requires-Dist: nbsphinx ; extra == 'docs'
+Requires-Dist: ipykernel>=7.1.0 ; extra == 'docs'
+Requires-Dist: furo ; extra == 'docs'
+Requires-Dist: sphinxext-opengraph ; extra == 'docs'
+Maintainer: Casper Asbjørn Eriksen
+Maintainer-email: Casper Asbjørn Eriksen <casbjorn@imada.sdu.dk>
+Requires-Python: >=3.12
+Provides-Extra: docs
+Description-Content-Type: text/markdown
+
+# ChemRecon
+*v. 0.1.1*
+
+ChemRecon is a Python library and consolidated meta-database designed to simplify the integration and exploration of 
+biochemical data from a range of sources. 
+It is built from full-database downloads of compounds, reactions, enzymes, molecular structures, and atom-to-atom maps 
+from the following source databases: BiGG, BRENDA, ChEBI, ECMDB, M-CSA, MetaMDB, and PubChem.
+
+Heterogenous data formats were standardized, and relationships within and between these databases were reconstructed in 
+a consistent format. 
+The resulting meta-database is freely accessible online and is complemented by a Python library which allows for easy 
+integration into existing workflows.
+This enables unified querying of entries from all the source databases, and discovery and visualization of 
+relationships between these entries.
+
+![entrygraph](docs/source/resources/eg.svg)
+
+ChemRecon was developed at the 
+    [Algorithmic Cheminformatics Group](https://cheminf.imada.sdu.dk/),
+    [Department of Mathematics and Computer Science](https://cheminf.imada.sdu.dk/),
+    [University of Southern Denmark](https://sdu.dk).
+
+## Paper
+If ChemRecon proves useful to your research, you may want to cite the following paper.
+ * **Title**
+    
+    C. A. Eriksen, J. L. Andersen, R. Fagerberg, D. Merkle
+
+    Arxiv preprint, submitted to Bioinformatics.
+
+    TODO more
+
+## Availability and Installation
+ChemRecon is available via your Python package manager from the Python Package Index (PyPI): 
+[chemrecon](https://pypi.org/project/chemrecon/)
+It can be installed using pip:
+
+`pip install chemrecon`
+
+Visualizing entry graphs requires [GraphViz](https://www.graphviz.org/) to be installed, and for the `dot` executable,
+which renders the graphs, to be available on your system's `PATH`.
+See the [GraphViz Python package](https://pypi.org/project/graphviz/) for instructions.
+
+***
+
+## Documentation
+The documentation, including instructions on usage, tutorials, and complete description covering the types of entries
+and relations supported, is available on the [ChemRecon homepage](https://www.cheminf.imada.sdu.dk/chemrecon).
+
+## Usage
+The following is an example of a typical ChemRecon workflow, producing the graph seen above.
+For more detailed examples, see the tutorial section of the documentation.
+
+```python
+from chemrecon import *
+
+connect_public()
+
+# Perform a database query to find the 'citrate' entry in BiGG.
+citrate_entry = find_entry(id_type = C_BIGG, source_id = 'M_cit')
+
+# Define a protocol to find related entries and molecular structures (protocols like this are included)
+compound_structure_protocol = ExplorationProtocol(
+    relation_types = {CompoundReference, CompoundHasMolStructure, MolStructureStandardization}
+)
+
+# Create and expand an entry graph, according to this protocol, by traversing the database.
+eg = EntryGraph(initial_entries = {citrate_entry})
+explore(eg, compound_structure_protocol, steps = 5)
+
+# Score the molecular structures in the graph according to their 'connectedness'
+scorer = Scorer(score_entry_type = MolStructure)
+scores = scorer(citrate_entry)  # Result is an OrderedDict
+
+# Draw the graph with these scores, producing the image seen on this page
+eg.show(scores = scores)
+```
+
+***
+
+## Database
+ChemRecon needs to be connected to a database to function.
+The easiest is to connect to the public database, hosted by [SDU](https://sdu.dk):
+```
+connect_public()
+```
+Alternatively, a local instance of the database can be hosted via Docker.
+Instructions are given in the [documentation](https://chemrecon.org).
+This has the advantage of lower latency, making queries and entry graph construction faster, and allows adding
+custom data sources.
+
+## Source Databases
+ChemRecon contains compound, molecular structure, reaction, atom-to-atom map, and enzyme entries from the following
+databases.
+
+| Source   	 | Compound 	   | Structure 	   | Reaction 	 | AAM   	 | Enzyme 	 | Version |
+|------------|--------------|---------------|------------|---------|----------|---------|
+| BiGG     	 | 20428    	   | -         	   | 33942    	 | -     	 | 5705   	 | 1.6     |
+| BRENDA   	 | -        	   | -         	   | 61129    	 | -     	 | 8697  	  | 2025_1  |
+| ChEBI    	 | 224485   	   | 330207     	  | -        	 | -     	 | -      	 | 2024-05 |
+| ECMDB    	 | 3760     	   | 7517     	    | -        	 | -     	 | -      	 | 2.0     |
+| M-CSA    	 | -        	   | -         	   | 1003    	  | 342 	   | 1003  	  | 2024-11 |
+| MetaMDB  	 | 80815    	   | 4392     	    | 74520    	 | 1003 	  | -  	     | 2025-02 |
+| MetaNetX 	 | 2601834  	   | 2297518     	 | 143880   	 | -     	 | 48175  	 | 4.4     |
+| PubChem  	 | 9031498    	 | 5000000     	 | -    	     | -     	 | -      	 | 2024-09 |
+
+In addition to the source databases, ChemRecon can make use of a greater number of *auxiliary* databases, including 
+MetaCyc and KEGG.  Data from these sources is are not directly included due to being proprietary or difficult to access. 
+However, the source databases contain references to the auxiliary databases, so entries are created which contain only 
+the identifier and no additional information. This allows users to use ChemRecon workflows based on identifiers from a 
+great number of databases, not just the source databases.

chemrecon-0.1.1/README.md

@@ -0,0 +1,111 @@
+# ChemRecon
+*v. 0.1.1*
+
+ChemRecon is a Python library and consolidated meta-database designed to simplify the integration and exploration of 
+biochemical data from a range of sources. 
+It is built from full-database downloads of compounds, reactions, enzymes, molecular structures, and atom-to-atom maps 
+from the following source databases: BiGG, BRENDA, ChEBI, ECMDB, M-CSA, MetaMDB, and PubChem.
+
+Heterogenous data formats were standardized, and relationships within and between these databases were reconstructed in 
+a consistent format. 
+The resulting meta-database is freely accessible online and is complemented by a Python library which allows for easy 
+integration into existing workflows.
+This enables unified querying of entries from all the source databases, and discovery and visualization of 
+relationships between these entries.
+
+![entrygraph](docs/source/resources/eg.svg)
+
+ChemRecon was developed at the 
+    [Algorithmic Cheminformatics Group](https://cheminf.imada.sdu.dk/),
+    [Department of Mathematics and Computer Science](https://cheminf.imada.sdu.dk/),
+    [University of Southern Denmark](https://sdu.dk).
+
+## Paper
+If ChemRecon proves useful to your research, you may want to cite the following paper.
+ * **Title**
+    
+    C. A. Eriksen, J. L. Andersen, R. Fagerberg, D. Merkle
+
+    Arxiv preprint, submitted to Bioinformatics.
+
+    TODO more
+
+## Availability and Installation
+ChemRecon is available via your Python package manager from the Python Package Index (PyPI): 
+[chemrecon](https://pypi.org/project/chemrecon/)
+It can be installed using pip:
+
+`pip install chemrecon`
+
+Visualizing entry graphs requires [GraphViz](https://www.graphviz.org/) to be installed, and for the `dot` executable,
+which renders the graphs, to be available on your system's `PATH`.
+See the [GraphViz Python package](https://pypi.org/project/graphviz/) for instructions.
+
+***
+
+## Documentation
+The documentation, including instructions on usage, tutorials, and complete description covering the types of entries
+and relations supported, is available on the [ChemRecon homepage](https://www.cheminf.imada.sdu.dk/chemrecon).
+
+## Usage
+The following is an example of a typical ChemRecon workflow, producing the graph seen above.
+For more detailed examples, see the tutorial section of the documentation.
+
+```python
+from chemrecon import *
+
+connect_public()
+
+# Perform a database query to find the 'citrate' entry in BiGG.
+citrate_entry = find_entry(id_type = C_BIGG, source_id = 'M_cit')
+
+# Define a protocol to find related entries and molecular structures (protocols like this are included)
+compound_structure_protocol = ExplorationProtocol(
+    relation_types = {CompoundReference, CompoundHasMolStructure, MolStructureStandardization}
+)
+
+# Create and expand an entry graph, according to this protocol, by traversing the database.
+eg = EntryGraph(initial_entries = {citrate_entry})
+explore(eg, compound_structure_protocol, steps = 5)
+
+# Score the molecular structures in the graph according to their 'connectedness'
+scorer = Scorer(score_entry_type = MolStructure)
+scores = scorer(citrate_entry)  # Result is an OrderedDict
+
+# Draw the graph with these scores, producing the image seen on this page
+eg.show(scores = scores)
+```
+
+***
+
+## Database
+ChemRecon needs to be connected to a database to function.
+The easiest is to connect to the public database, hosted by [SDU](https://sdu.dk):
+```
+connect_public()
+```
+Alternatively, a local instance of the database can be hosted via Docker.
+Instructions are given in the [documentation](https://chemrecon.org).
+This has the advantage of lower latency, making queries and entry graph construction faster, and allows adding
+custom data sources.
+
+## Source Databases
+ChemRecon contains compound, molecular structure, reaction, atom-to-atom map, and enzyme entries from the following
+databases.
+
+| Source   	 | Compound 	   | Structure 	   | Reaction 	 | AAM   	 | Enzyme 	 | Version |
+|------------|--------------|---------------|------------|---------|----------|---------|
+| BiGG     	 | 20428    	   | -         	   | 33942    	 | -     	 | 5705   	 | 1.6     |
+| BRENDA   	 | -        	   | -         	   | 61129    	 | -     	 | 8697  	  | 2025_1  |
+| ChEBI    	 | 224485   	   | 330207     	  | -        	 | -     	 | -      	 | 2024-05 |
+| ECMDB    	 | 3760     	   | 7517     	    | -        	 | -     	 | -      	 | 2.0     |
+| M-CSA    	 | -        	   | -         	   | 1003    	  | 342 	   | 1003  	  | 2024-11 |
+| MetaMDB  	 | 80815    	   | 4392     	    | 74520    	 | 1003 	  | -  	     | 2025-02 |
+| MetaNetX 	 | 2601834  	   | 2297518     	 | 143880   	 | -     	 | 48175  	 | 4.4     |
+| PubChem  	 | 9031498    	 | 5000000     	 | -    	     | -     	 | -      	 | 2024-09 |
+
+In addition to the source databases, ChemRecon can make use of a greater number of *auxiliary* databases, including 
+MetaCyc and KEGG.  Data from these sources is are not directly included due to being proprietary or difficult to access. 
+However, the source databases contain references to the auxiliary databases, so entries are created which contain only 
+the identifier and no additional information. This allows users to use ChemRecon workflows based on identifiers from a 
+great number of databases, not just the source databases.

chemrecon-0.1.1/pyproject.toml

@@ -0,0 +1,72 @@
+[project]
+name = 'chemrecon'
+version = "0.1.1"
+description = 'The ChemRecon library for integration and exploration of interconnected biochemical databases.'
+authors = [
+    {name = 'Casper Asbjørn Eriksen', email = 'casbjorn@imada.sdu.dk'}
+]
+maintainers = [
+    {name = 'Casper Asbjørn Eriksen', email = 'casbjorn@imada.sdu.dk'}
+]
+readme = {file = "README.md", content-type = "text/markdown"}
+license = 'GPL-3.0-only'
+keywords = [
+    'bioinformatics',
+]
+
+# Requirements
+requires-python = '>=3.12'
+dependencies = [
+    "psycopg[binary] ~= 3.3.2",  # Binary also adds Postgres client binaries
+    "rustworkx ~= 0.17.1",
+    "networkx ~= 3.6.1",
+    "matplotlib ~= 3.10",
+    "rdkit",
+]
+
+classifiers = [
+    'Programming Language :: Python :: 3.12',
+    'License :: OSI Approved :: GNU General Public License v3 (GPLv3)',
+    'Topic :: Scientific/Engineering :: Bio-Informatics',
+    'Topic :: Scientific/Engineering :: Chemistry'
+]
+
+#[project.urls]
+Homepage = 'https://chemrecon.org'
+Documentation = 'https://docs.chemrecon.org'
+Repository = 'https://gitlab.com/casbjorn/chemrecon'
+#Changelog = ''
+
+[project.optional-dependencies]
+docs = [
+    'sphinx==8.3.0',  # Downgrade needed for enumtools, see https://github.com/domdfcoding/enum_tools/issues/118
+    'myst-parser',
+    'sphinx-autobuild',
+    'enum-tools[sphinx] == 0.12.0',
+    'sphinx-toolbox',
+    'nbsphinx',
+    "ipykernel>=7.1.0",
+    'furo',
+    'sphinxext-opengraph'
+]
+
+[dependency-groups]
+dev = [
+    'pytest >=8.1.1,<9'
+]
+
+# uv
+[build-system]
+requires = [
+    'uv_build ~= 0.9.27'
+]
+build-backend = 'uv_build'
+
+[tool.uv]
+package = true
+
+[[tool.uv.index]]
+name = "testpypi"
+url = "https://test.pypi.org/simple/"
+publish-url = "https://test.pypi.org/legacy/"
+explicit = true

chemrecon-0.1.1/src/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-0.1.1/src/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-0.1.1/src/chemrecon/chem/constant_compounds.py

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