chemrecon 0.1.1__py3-none-any.whl

chemrecon/utils/get_id_type.py

@@ -0,0 +1,70 @@
+# Match the identifiers org prefix as group 1, and the actual id as group 2
+import re
+from typing import Optional
+
+from chemrecon.core.id_types import (IdentifierType, IdentifierTypeAAM, IdentifierTypeCompound,
+                           IdentifierTypeEnzyme, IdentifierTypeReaction,
+                           IdentifierTypeStructureRepresentation,
+                           id_types_aam, id_types_compound,
+                           id_types_enzyme, id_types_reaction, id_types_structure_representation,
+                           identifiers_org_dict, )
+
+identifiers_org_regex = re.compile(r'(https?://identifiers.org/[a-zA-Z./\-]+/)(.+)')
+
+# Sub-lookup dicts for identifier type names for each entrytype (compounds, reactions, etc)
+id_type_name_lookup_subsdicts: dict[type[IdentifierType], dict[str, IdentifierType]] = dict()
+typelists: dict[type[IdentifierType], list[IdentifierType]] = {
+    IdentifierTypeCompound: id_types_compound,
+    IdentifierTypeStructureRepresentation: id_types_structure_representation,
+    IdentifierTypeReaction: id_types_reaction,
+    IdentifierTypeEnzyme: id_types_enzyme,
+    IdentifierTypeAAM: id_types_aam
+}
+for entrytype_idtype, idtypes in typelists.items():
+    subdict: dict[str, IdentifierType] = dict()
+    for idtype in idtypes:
+        subdict[idtype.name.lower()] = idtype
+        subdict[idtype.shortname.lower()] = idtype
+        for name in idtype.alt_names:
+            subdict[name.lower()] = idtype
+    id_type_name_lookup_subsdicts[entrytype_idtype] = subdict
+
+
+
+def get_id_type[T: IdentifierType](
+    type_str: str,
+    identifier_supertype: type[T]
+) -> Optional[T]:
+    """ Get an identifier type by a strign description. """
+    try:
+        return id_type_name_lookup_subsdicts[identifier_supertype][type_str.lower()]
+    except KeyError:
+        return None
+
+def get_id_type_from_name[T: IdentifierType](name: str) -> T:
+    """ Get an identifier type (of type T, e.g. Compound, Reaction, Struct representation, ...) """
+    raise NotImplementedError
+
+def get_possible_id_types_from_source_id[T: IdentifierType](name: str) -> list[T]:
+    """ Get a list of possible compatible identifiers (of type T, e.g. Compound, Reaction,
+    Struct representation, ...) """
+    raise NotImplementedError
+
+def get_id_from_identifiers_org(
+    string: str,
+    identifier_supertype: type[IdentifierType]
+) -> Optional[tuple[IdentifierType, str]]:
+    """ Get an identifier type (of type T, e.g. Compound, Reaction, Struct representation, ...) """
+    match = re.match(identifiers_org_regex, string)
+    if match:
+        prefix = match.group(1)
+        match_id = match.group(2).removesuffix('/')     # TODO should trailing '/' be removed in all cases?
+        try:
+            id_type: IdentifierType = identifiers_org_dict[prefix]
+            if not isinstance(id_type, identifier_supertype):
+                return None
+            return (id_type, match_id)
+        except KeyError:
+            return None
+    else:
+        return None

chemrecon/utils/hungarian.py

@@ -0,0 +1,31 @@
+import networkx as nx
+
+def max_weight_matching[T1, T2](
+    edges: dict[tuple[T1, T2], float],
+    min_weight: bool = False
+) -> dict[T1, T2]:
+    """ Takes as edges a dictionary T1 -> [T2], with a float value giving the weight for each match in the
+        second set.
+        Returns the maximum weight bipartite matching as a list of tuples (T1, T2).
+        If min_weight is true, uses negative weight values.
+    """
+    # Construct a weighted bipartite graph
+    g = nx.Graph()
+    for (a, b), w in edges.items():
+        g.add_node(a)
+        g.add_node(b)
+        g.add_edge(a, b, weight = ((2 - w) if min_weight else w))
+
+    # Find the maximal matching
+    matching = nx.max_weight_matching(g, maxcardinality = True)
+    keys: set[T1] = {k for k, _ in edges.keys()}
+    out: dict[T1, T2] = dict()
+    for a, b in matching:
+        if a in keys:
+            out[a] = b
+        elif b in keys:
+            out[b] = a
+        else:
+            raise RuntimeError
+
+    return out

chemrecon/utils/reactant_matching.py

@@ -0,0 +1,168 @@
+""" Implements a heuristic algorithm to match structures of a ChemReaction to the structures attached to a
+    Compound.
+"""
+from __future__ import annotations
+
+from collections import OrderedDict
+from enum import Enum
+from typing import Hashable
+
+from chemrecon import Direction, ChemReaction, Mol
+from chemrecon.chem.create_mol import mol_from_struct_entry
+from chemrecon.entrygraph.entrygraph import EntryGraph
+from chemrecon.entrygraph.explorationprotocol import ExplorationProtocol
+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.utils import hungarian
+
+
+class FlipState(Enum):
+    NORMAL = 0
+    FLIPPED = 1
+
+
+def match_reactants(
+        reaction: ChemReaction,
+        compound_entries_lhs: dict[str, list[Compound]],
+        compound_entries_rhs: dict[str, list[Compound]],
+        consider_n_most_confident_structures: int = 1,
+        consider_first_entry_primary: bool = True,
+        consider_flipped: bool = False,
+        search_depth: int = 2
+) -> tuple[dict[Mol, str], dict[Mol, str], FlipState]:
+    """ ...
+        Compound entries are given as a dict (with key = primary_id), and a list of associated entries, possibly only 1.
+        If consider_first_entry_primary is set, for each given compound as a list of entries, the first entry in the
+        list will have higher weight in the EntryGraph.
+        Each compound can be given with multiple entries (for SBML files, for instance).
+        If consider_flipped is set, will also consider the case when LHS and RHS are flipped.
+        If look_deep is set, will consider structures not directly associated with the entries, instead using a deeper
+        Entrygraph search.
+        Also returns whether flipped was best
+    """
+
+    # First, find structures using EntryGraphs
+    compound_structures_lhs: dict[str, OrderedDict[Mol, float]] = OrderedDict()
+    compound_structures_rhs: dict[str, OrderedDict[Mol, float]] = OrderedDict()
+    for compound_entries, compound_structures in [
+        [compound_entries_lhs, compound_structures_lhs],
+        [compound_entries_rhs, compound_structures_rhs]
+    ]:
+        compound_entries: dict[str, list[Compound]]
+        compound_structures: dict[str, OrderedDict[Mol, float]]
+
+        for k, entry_list in compound_entries.items():
+            try:
+                compound_structures[k] = dict()
+                for struct_entry, score in search_structures(entry_list).items():
+                    try:
+                        compound_structures[k][mol_from_struct_entry(struct_entry)] = score
+                    except AttributeError:
+                        # Could not generate Mol
+                        pass
+            except ValueError:
+                # No valid initial entries
+                compound_structures[k] = dict()
+
+    # Perform matching based on the Mols in the ChemReaction
+    match_l: dict[Mol, str]
+    match_r: dict[Mol, str]
+    match_ll, score_ll = match(
+        reaction.get_lhs_templates(),
+        compound_structures_lhs,
+        consider_n_most_confident_structures = consider_n_most_confident_structures
+    )
+    match_rr, score_rr = match(
+        reaction.get_rhs_templates(),
+        compound_structures_rhs,
+        consider_n_most_confident_structures = consider_n_most_confident_structures
+    )
+
+    # Consider the reaction flipped
+    if consider_flipped:
+        match_lr, score_lr = match(
+            reaction.get_lhs_templates(),
+            compound_structures_rhs,
+            consider_n_most_confident_structures = consider_n_most_confident_structures
+        )
+        match_rl, score_rl = match(
+            reaction.get_rhs_templates(),
+            compound_structures_lhs,
+            consider_n_most_confident_structures = consider_n_most_confident_structures
+        )
+
+        if (score_lr + score_rl) > (score_ll + score_rr):
+            print(f'  -> flipped best ({score_lr:.2f} + {score_rl:.2f}) > ({score_ll:.2f} + {score_rr:.2f})')
+            flipstate = FlipState.FLIPPED
+            match_l = match_lr
+            match_r = match_rl
+        else:
+            print(f'  -> non-flipped best ({score_lr:.2f} + {score_rl:.2f}) < ({score_ll:.2f} + {score_rr:.2f})')
+            flipstate = FlipState.NORMAL
+            match_l = match_ll
+            match_r = match_rr
+    else:
+        flipstate = FlipState.NORMAL
+        match_l = match_ll
+        match_r = match_rr
+
+    # Return chosen matching
+    return (match_l, match_r, flipstate)
+
+
+# Matching alg
+def match[T: Hashable](
+        reaction_mols: list[Mol],
+        compound_mols: dict[T, OrderedDict[Mol, float]],
+        consider_n_most_confident_structures: int = 1,
+) -> tuple[dict[Mol, T], int]:
+    """ Given the mols from the reaction and the compound_mols (with confidence), get the best mapping.
+        Type parameter T is the key, probalby str (primary_id).
+        Returns the matching, as well as a confidence level (0 to 1).
+    """
+    similarity: dict[tuple[Mol, T], float] = dict()
+
+    # First, compute the pairwise similarity of all compounds
+    for mol in reaction_mols:
+        for primary_id, mols_ in compound_mols.items():
+            # if len(mols_) == 0:
+            #    # No structures given
+            #    continue
+
+            sims: list[float] = list()
+            for mol_, conf in list(mols_.items())[:consider_n_most_confident_structures]:
+                # Get distance
+                sims.append(mol.get_similarity(mol_) * conf)  # 1 if identical, approaches 0 as difference increases.
+
+            # Calculate the similarity as the maximum of (sim * conf)
+            similarity[(mol, primary_id)] = max(sims) if sims else 0
+
+    # Run the Hungarian algorithm to determine the best matching
+    matching = hungarian.max_weight_matching(edges = similarity)
+
+    # Compute the confidence/score of the matching as avg. weight of matched edges
+    confidence = sum(similarity[mol, primary_id] for mol, primary_id in matching.items()) / len(reaction_mols)
+    return matching, confidence
+
+
+def search_structures(compound_entries: list[Compound]) -> OrderedDict[MolStructure, float]:
+    eg = EntryGraph(initial_entries = set(compound_entries))
+    explore(eg, structure_protocol, steps = 4)
+    return scorer_structure(eg)
+
+
+# EntryGraph specifications for search
+# ----------------------------------------------------------------------------------------------------------------------
+structure_protocol = ExplorationProtocol(
+    relation_types = {CompoundSelectStructure}
+)
+scorer_structure = Scorer[MolStructure](
+    score_entry_type = MolStructure
+)
+
+# TODO score depending on whether primary id is weighted higher

chemrecon/utils/rxnutils.py

@@ -0,0 +1,44 @@
+import re
+
+re_comment = re.compile(r'{(.*)}')
+
+
+def extract_molblocks_v2000(rxnblock: str) -> list[tuple[str, str]]:
+    """ Gets the individual molblocks for each compound involved in the reaction. Returns tuples of the
+    molblock and comment string.
+    """
+    molblocks: list[tuple[str, str]] = list()
+
+    for mol_n, mol_str in enumerate(rxnblock.split('$MOL')):
+
+        # Skip the first, $RXN block
+        if mol_str.startswith('$RXN'):
+            continue
+
+        # Comment
+        comment_match = re.search(re_comment, mol_str)
+        if comment_match:
+            comment_str = comment_match[0]
+        else:
+            comment_str = ''
+
+        # Block
+        lines = mol_str.splitlines()
+
+        # First, read count line to get number of atoms
+        countline_i = 0
+        while len(lines[countline_i]) == 0 or (not lines[countline_i].strip()[0].isnumeric()):
+            countline_i += 1
+        countline = lines[countline_i]
+
+        countline_items = filter(lambda x: x, countline.split(' '))
+        n_atoms = int(countline[0:3])
+        molblock = '\n'.join(lines[1:])
+
+        molblocks.append((molblock, comment_str))
+
+    # Finalise
+    return molblocks
+
+
+

chemrecon/utils/set_cwd.py

@@ -0,0 +1,12 @@
+import os
+
+def set_cwd():
+    while os.getcwd().split('/')[-1] not in {
+        'chemrecon',
+        'ChemRecon',
+        'src',
+        'chemrecon_populator'
+    }:
+        os.chdir('..')
+
+    print(f'Changed directory: {os.getcwd()}')

chemrecon-0.1.1.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,86 @@
+chemrecon/__init__.py,sha256=BFgYLCNdIybZFfwmD4G6im0vRhFxTvyCB7WMr_Tt1Bc,2098
+chemrecon/chem/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+chemrecon/chem/chemreaction.py,sha256=AA1JsVbYUi7aAbGkxQ027Vou0ZPUPCqAjeaLXwiOIZk,8525
+chemrecon/chem/constant_compounds.py,sha256=3wOvVs7RKRCiV5n4d44NsfDKo4aDcuGXOiSIZc83Wl0,72
+chemrecon/chem/create_mol.py,sha256=5ObHNF30rrdyTuY0jdXjN2Pqgk3cyagpl_vnixo-m3Q,3075
+chemrecon/chem/elements.py,sha256=09QkK8C0BZT1WbTu6pQQqssGmnC8Km0_MCm9xURDADQ,5146
+chemrecon/chem/gml/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+chemrecon/chem/gml/gml.py,sha256=AP9VQbTkWaNLwwceSC8KT9iG2wYBsEvFv264JjNpS1I,9468
+chemrecon/chem/gml/gml_reactant_matching.py,sha256=xYw23uNIuuxzaMrtQoHhY7M0ZpBiuSzuszaXKGjr9ko,6010
+chemrecon/chem/gml/gml_to_rdk.py,sha256=gjUiJHR9WrGcvz_2etEOnpgH49vtqIHwMwtgzI6Eo78,7470
+chemrecon/chem/mol.py,sha256=mg0cSFYzWKTPiOrfKlcTLtcRlgQFTWAOArqoR2Rr5kQ,15200
+chemrecon/chem/sumformula.py,sha256=6RuzXvhtKTRWGXpTS-QcfalsqwtxTzEolF5LiVdPVaM,4176
+chemrecon/connection.py,sha256=2I0Y0Nxmd_mXBpU-0bTnAsinrmFfj2Qtw0LadklE0p8,3277
+chemrecon/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+chemrecon/core/id_types.py,sha256=WvuG_AOqznMcj-zsAkQzHxOuelUBZThl5TvIZTJ4nZM,19432
+chemrecon/core/ontology.py,sha256=GJ6qrD6CZNvhT8DEnCnoMa5QjFjwTKqWomrlQp0tNME,5162
+chemrecon/core/populate_query_handler.py,sha256=-IXehaqm-iWNdaOx00_RwW4QwR-xYGWoslVwdDcH8UI,12988
+chemrecon/core/query_handler.py,sha256=5YQBbRSg72gdf1Zkuew1md8mMwyuJK9WlyuLze0AuW0,24039
+chemrecon/database/__init__.py,sha256=nYwlJnBC-i88HqDvoap-ZQHUqKoeuCDSsptJjfqNgxo,53
+chemrecon/database/connect.py,sha256=lobpyqkmiF7VTTgAqzHPANyjtu01i-se9BsENsvnxng,2031
+chemrecon/database/connection_params/chemrecon_pub.dbinfo,sha256=RcotjdR1twQ6uh2OJCFz6r9tq-zAegnSIE91MQ_DSoo,72
+chemrecon/database/connection_params/local_docker_dev.dbinfo,sha256=REtQj-C9delndbH9achchc8FS2TtOGbd7AjsnN49bug,50
+chemrecon/database/connection_params/local_docker_init.dbinfo,sha256=yxe6DPeFcSy_q02L3VwKDsX_Of5AXSogkGSwa4qpFQY,51
+chemrecon/database/connection_params/local_docker_pub.dbinfo,sha256=8LmyxYI5fMIVM6CKKDVLmfWXbYjCI8R79nEOhGNFDKA,67
+chemrecon/database/params.py,sha256=wbo_ChWOYG_mDOyXn1nIAQnt9fe9zlEzXvf7eACUVLY,2566
+chemrecon/entrygraph/draw.py,sha256=alpETBm4m4dusjTmY9iWRAOkq-O8OgMvOmYBaGw4vjU,3601
+chemrecon/entrygraph/entrygraph.py,sha256=cYXC6BORm-cFeyegpXCk3MHghc4ccRzPhEq6Kl1HOp8,11565
+chemrecon/entrygraph/explorationprotocol.py,sha256=vq5djr7J_VhDdVb7LOK2BVpMnW0E2DMCAtymoRd6_mU,10246
+chemrecon/entrygraph/explore.py,sha256=zA_KCCGgfSA15Yn_6P_DSxKiBAm22V05F98kFOvHzYg,18340
+chemrecon/entrygraph/explore_procedure.py,sha256=P_TM7jIRHvxIysN0lcAYCzOH0ic41dr41s1M43E3Dqc,6239
+chemrecon/entrygraph/filter.py,sha256=CN3nw4WRwa4baUtdg-rn5GOEIhJHu-HURe3ie1cDDMY,2553
+chemrecon/entrygraph/scoring.py,sha256=3qQo_hnCH9lMmjVWVcMSte2PXszO-ag__KhqMgH3ezk,5868
+chemrecon/query/__init__.py,sha256=is4JVcbIFPeBOoq7qPYwDFjtYf2EPmzUVvLpG2uOduI,766
+chemrecon/query/create_entry.py,sha256=T8Lb77Is5w5BjL9_N0qxsWhAJMbdRqBhebGm6qI0NUk,3424
+chemrecon/query/default_protocols.py,sha256=gxfWpK2XQVxRwk8trtua1fnwRqrv2N1AzZskpwgbFR0,2799
+chemrecon/query/find_entry.py,sha256=4T3d5pCBiZNmTXAn6lM5NK4NMN6eyD1NsmwWygXypzw,4041
+chemrecon/query/get_relations.py,sha256=blZNbI-dQO7mhPuFXE4YCtpfYRDPXN5JvmcUswjd7fw,5635
+chemrecon/query/get_structures_from_compound.py,sha256=f2QuNulVY2R0-RnIiSbVfb4_b8smW8L1cMmIytKby10,1833
+chemrecon/schema/__init__.py,sha256=Pu_i7-jvKf_KOJxWaTs8_3uMiOv1a45O16QD9Hxkclo,3718
+chemrecon/schema/db_object.py,sha256=6qMgkKApbUsjvv6ocwZ5ifLBCvJsiX4j9dAZe3kfLto,12876
+chemrecon/schema/direction.py,sha256=k4F252HHAt2FqjjhNY-wihTN12iCgx6866LE9MUevnQ,266
+chemrecon/schema/entry_types/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+chemrecon/schema/entry_types/aam.py,sha256=lW-yN8MVEChx5MwXcMw9tGmnGrb-rtYxBk6DNgUsBLU,772
+chemrecon/schema/entry_types/aam_repr.py,sha256=DYjqloFHv0jvq_dQad7TNzzumry_iiA_7y7d2weQILY,982
+chemrecon/schema/entry_types/compound.py,sha256=DBIDPNojqn51dnlRcGeFfgLa-zD_kLVik-GGEvc10SI,1621
+chemrecon/schema/entry_types/enzyme.py,sha256=qpO_z0OZfENptehBo1sbF4jXCUME9f4oOGGpIbR-l_g,1547
+chemrecon/schema/entry_types/molstructure.py,sha256=MFf_kVpM8t2vfXNV8_g_82cJ5b8PEU19BoLonQEr0x4,2043
+chemrecon/schema/entry_types/molstructure_repr.py,sha256=rrz6XqJ7JXd_lmAIPKWbjo1Z9sEK7CWhxF2TgZMlQ-M,1422
+chemrecon/schema/entry_types/reaction.py,sha256=7XPLatMvaU-v2K4Cdlh2ht9BInnp-yNABEJxEnXTW9U,1956
+chemrecon/schema/enums.py,sha256=JlwqU4IqzCkaKEdpUtiE39IibtNz_r3opK0DOitdexM,3780
+chemrecon/schema/procedural_relation_entrygraph.py,sha256=UqlCem7wBLCTq1jbCQB_pvPwf7kF8uFyX-MR7sFOtPM,2120
+chemrecon/schema/relation_types_composed/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+chemrecon/schema/relation_types_composed/compound_has_molstructure_relation.py,sha256=d1GfBPiStbmD_X7WIwWnH0Vl5GLsz_95xlEv4glifJA,2182
+chemrecon/schema/relation_types_composed/reaction_has_aam_relation.py,sha256=0q39smTcByAguDXQgkWGoGv9dGYE50tMslmMjEoBZm8,1744
+chemrecon/schema/relation_types_procedural/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+chemrecon/schema/relation_types_procedural/aam_convert_relation.py,sha256=84OCfMK35YAGEDtAmWdnuSOHRSJfuEAk0zzHSOUb_nA,2295
+chemrecon/schema/relation_types_procedural/compound_select_structure_proceduralrelation.py,sha256=HwRRpFP4ftzwFZexCWfKNelvCnkgN6ai15SDySZOO-M,1545
+chemrecon/schema/relation_types_procedural/compound_similarlity_proceduralrelation.py,sha256=chG3GNX2BBDTWIuSVfZUJ_YF_ZVBSoel2d_AN0OChS0,6
+chemrecon/schema/relation_types_procedural/molstructure_convert_relation.py,sha256=SKoim_kn0kxkKHKO1EzRNpSnxvt-zh9wB089bJ77zT0,1625
+chemrecon/schema/relation_types_procedural/reaction_select_aam_proceduralrelation.py,sha256=39yXLPRK9k3xUJJV75exVGZZT5-z3dV6cxNVsXCTqS0,1499
+chemrecon/schema/relation_types_procedural/reaction_similarity_proceduralrelation.py,sha256=chG3GNX2BBDTWIuSVfZUJ_YF_ZVBSoel2d_AN0OChS0,6
+chemrecon/schema/relation_types_source/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+chemrecon/schema/relation_types_source/aam_involves_molstructure_relation.py,sha256=Blu1QsIpM8ZEX7pvFR9yUkFPJcAy3gN3EdtUoV4JBk8,2702
+chemrecon/schema/relation_types_source/aam_repr_involves_molstructure_repr_relation.py,sha256=OmFGuP4mR6Ctmex-zZyxn0HQsntD0OBkLmYyBq9FSa0,2582
+chemrecon/schema/relation_types_source/compound_has_structure_representation_relation.py,sha256=jqdN9w6IPqNH_FhCjsOPezqJL_EMl7K2zzy9z8MGXrQ,1001
+chemrecon/schema/relation_types_source/compound_reference_relation.py,sha256=kiXcxTkYqHxjINhwsC6K7K7BDvJ69BjJ00SH-qiNbQY,907
+chemrecon/schema/relation_types_source/molstructure_standardisation_relation.py,sha256=RRrTPYhAJL17ZAbzb3nOUuhRTVLsDEuWuWauFZ62pQI,2201
+chemrecon/schema/relation_types_source/ontology/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+chemrecon/schema/relation_types_source/ontology/compound_ontology.py,sha256=_cFQgMRaX48frvrJ1YzbFNwOyPyL7uR42i8qa3omQT4,10314
+chemrecon/schema/relation_types_source/ontology/enzyme_ontology.py,sha256=KrSprX-pUFzbH82Y1oJtkDP9vwvDUyfvsPKHWyyYHRg,3969
+chemrecon/schema/relation_types_source/ontology/reaction_ontology.py,sha256=VCRrWGGEcz2mDvNucnPWqajbPYqw_QSlgKBEDNnIaEI,3903
+chemrecon/schema/relation_types_source/reaction_has_aam_representation_relation.py,sha256=eIj2FqFPM2wO5f4GmAWF05hSkHpxH_PB4CrT17vqBBA,947
+chemrecon/schema/relation_types_source/reaction_has_enzyme_relation.py,sha256=WEW84bxD2bEFmnnnL9oLVEL78TvR5ZfO5UxgBefv1WQ,1924
+chemrecon/schema/relation_types_source/reaction_involves_compound_relation.py,sha256=Q4ayiZpz0IFPKsm6vr2ZepmZPlI9Cwa2YRmoeLGaXSE,2079
+chemrecon/schema/relation_types_source/reaction_reference_relation.py,sha256=6liEih9Y3sFaQJZ3rEeJQm5C10cj0a6MMaEUeBdX394,908
+chemrecon/scripts/initialize_database.py,sha256=FDMz61-o3BwvQOGbTX6UC3csh08olxYVCfF6-ycEcXk,19855
+chemrecon/utils/copy_signature.py,sha256=pSqKIamm5j24YysvMfB0vbBsQOvsbekW7mtFgJ8ifE4,452
+chemrecon/utils/encodeable_list.py,sha256=2MkzvTQzibUWuDHOL02IByYXv9j3T9QK1Z4qjfHffW0,337
+chemrecon/utils/get_id_type.py,sha256=t93W9wBHvge09gDjbdZjQl57Vzg8wuBYvSGCP27l_uw,2990
+chemrecon/utils/hungarian.py,sha256=Y1JR0r8dFt5lCTuj1Bj_3D4t8xmr57CHv3lkwo2L_rk,986
+chemrecon/utils/reactant_matching.py,sha256=rfRapLqsgDHaiRUP34qvc15eQLOB_Z9CaVJ_ttb7s1o,6857
+chemrecon/utils/rxnutils.py,sha256=7FgDzjY7qfTV32q1RWzFYqjPM1vEW_DXOMcfiQAzNAA,1190
+chemrecon/utils/set_cwd.py,sha256=n7wGQS9MxmxpAUVQla_VRFytXmMcps97WhS57CUrlGU,237
+chemrecon-0.1.1.dist-info/WHEEL,sha256=iHtWm8nRfs0VRdCYVXocAWFW8ppjHL-uTJkAdZJKOBM,80
+chemrecon-0.1.1.dist-info/METADATA,sha256=a8Rvo9fM0sM0azTZ3fr7vW2ETLh5_-UN8ndVJEmr9bY,6618
+chemrecon-0.1.1.dist-info/RECORD,,

chemrecon-0.1.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.9.30
+Root-Is-Purelib: true
+Tag: py3-none-any