sapiopycommons 2024.9.20a333__tar.gz → 2024.9.30a335__tar.gz

{sapiopycommons-2024.9.20a333 → sapiopycommons-2024.9.30a335}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: sapiopycommons
-Version: 2024.9.20a333
+Version: 2024.9.30a335
 Summary: Official Sapio Python API Utilities Package
 Project-URL: Homepage, https://github.com/sapiosciences
 Author-email: Jonathan Steck <jsteck@sapiosciences.com>, Yechen Qiao <yqiao@sapiosciences.com>

{sapiopycommons-2024.9.20a333 → sapiopycommons-2024.9.30a335}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "sapiopycommons"
-version='2024.09.20a333'
+version='2024.09.30a335'
 authors = [
     { name="Jonathan Steck", email="jsteck@sapiosciences.com" },
     { name="Yechen Qiao", email="yqiao@sapiosciences.com" },

{sapiopycommons-2024.9.20a333 → sapiopycommons-2024.9.30a335}/src/sapiopycommons/chem/IndigoMolecules.py

@@ -9,7 +9,6 @@ indigo.setOption("ignore-stereochemistry-errors", True)
 indigo.setOption("render-stereo-style", "ext")
 indigo.setOption("aromaticity-model", "generic")
 indigo.setOption("render-coloring", True)
-indigo.setOption("molfile-saving-mode", "3000")
 indigo_inchi = IndigoInchi(indigo);
 
 

{sapiopycommons-2024.9.20a333 → sapiopycommons-2024.9.30a335}/src/sapiopycommons/chem/Molecules.py

@@ -1,6 +1,5 @@
 # Author Yechen Qiao
 # Common Molecule Utilities for Molecule Transfers with Sapio
-from typing import cast
 
 from rdkit import Chem
 from rdkit.Chem import Crippen, MolToInchi
@@ -21,25 +20,6 @@ tautomer_params.tautomerReassignStereo = False
 tautomer_params.tautomerRemoveIsotopicHs = True
 enumerator = rdMolStandardize.TautomerEnumerator(tautomer_params)
 
-
-def get_enhanced_stereo_reg_hash(mol: Mol, enhanced_stereo: bool) -> str:
-    """
-    Get the Registration Hash for the molecule by the current registration configuration.
-    When we are running if we are canonicalization of tautomers or cleaning up any other way, do they first before calling.
-    :param mol: The molecule to obtain hash for.
-    :param canonical_tautomer: Whether the registry system canonicalize the tautomers.
-    :param enhanced_stereo: Whether we are computing enhanced stereo at all.
-    :return: The enhanced stereo hash.
-    """
-    if enhanced_stereo:
-        from rdkit.Chem.RegistrationHash import GetMolLayers, GetMolHash, HashScheme
-        layers = GetMolLayers(mol, enable_tautomer_hash_v2=True)
-        hash_scheme: HashScheme = HashScheme.TAUTOMER_INSENSITIVE_LAYERS
-        return GetMolHash(layers, hash_scheme=hash_scheme)
-    else:
-        return ""
-
-
 def neutralize_atoms(mol) -> Mol:
     """
     Neutralize atoms per https://baoilleach.blogspot.com/2019/12/no-charge-simple-approach-to.html
@@ -106,6 +86,7 @@ def mol_to_img(mol_str: str) -> str:
     return renderer.renderToString(mol)
 
 
+
 def mol_to_sapio_partial_pojo(mol: Mol):
     """
     Get the minimum information about molecule to Sapio, just its SMILES, V3000, and image data.
@@ -115,7 +96,7 @@ def mol_to_sapio_partial_pojo(mol: Mol):
     Chem.SanitizeMol(mol)
     mol.UpdatePropertyCache()
     smiles = Chem.MolToSmiles(mol)
-    molBlock = Chem.MolToMolBlock(mol, forceV3000=True)
+    molBlock = Chem.MolToMolBlock(mol)
     img = mol_to_img(mol)
     molecule = dict()
     molecule["smiles"] = smiles
@@ -124,52 +105,23 @@ def mol_to_sapio_partial_pojo(mol: Mol):
     return molecule
 
 
-def get_cxs_smiles_hash(mol: Mol, enhanced_stereo: bool) -> str:
-    """
-    Return the SHA1 CXS Smiles hash for the canonical, isomeric CXS SMILES of the molecule.
-    """
-    if not enhanced_stereo:
-        return ""
-    import hashlib
-    return hashlib.sha1(Chem.MolToCXSmiles(mol, canonical=True, isomericSmiles=True).encode()).hexdigest()
-
-
-def get_has_or_group(mol: Mol, enhanced_stereo: bool) -> bool:
-    """
-    Return true if and only if: enhanced stereochemistry is enabled and there is at least one OR group in mol.
-    """
-    if not enhanced_stereo:
-        return False
-    from rdkit.Chem import StereoGroup_vect, STEREO_OR
-    stereo_groups: StereoGroup_vect = mol.GetStereoGroups()
-    for stereo_group in stereo_groups:
-        if stereo_group.GetGroupType() == STEREO_OR:
-            return True
-    return False
-
-
-def mol_to_sapio_substance(mol: Mol, include_stereoisomers=False,
+def mol_to_sapio_substance(mol: Mol, include_stereoisomers: bool = False,
                            normalize: bool = False, remove_salt: bool = False, make_images: bool = False,
-                           salt_def: str | None = None, canonical_tautomer: bool = True,
-                           enhanced_stereo: bool = False, remove_atom_map: bool = True):
+                           salt_def: str | None = None, canonical_tautomer: bool = True):
     """
     Convert a molecule in RDKit to a molecule POJO in Sapio.
 
     :param mol: The molecule in RDKit.
+    :param include_stereoisomers: If true, will compute all stereoisomer permutations of this molecule.
     :param normalize If true, will normalize the functional groups and return normalized result.
     :param remove_salt If true, we will remove salts iteratively from the molecule before returning their data.
     We will also populate desaltedList with molecules we deleted.
-    :param make_images Whether to make images as part of the result without having another script to resolve it.
     :param salt_def: if not none, specifies custom salt to be used during the desalt process.
     :param canonical_tautomer: if True, we will attempt to compute canonical tautomer for the molecule. Slow!
     This is needed for a registry. Note it stops after enumeration of 1000.
-    :param enhanced_stereo: If enabled, enhanced stereo hash will be produced.
-    :param remove_atom_map: When set, clear all atom AAM maps that were set had it been merged into some reactions earlier.
     :return: The molecule POJO for Sapio.
     """
     molecule = dict()
-    if remove_atom_map:
-        [a.SetAtomMapNum(0) for a in mol.GetAtoms()]
     Chem.SanitizeMol(mol)
     mol.UpdatePropertyCache()
     Chem.GetSymmSSSR(mol)
@@ -205,7 +157,7 @@ def mol_to_sapio_substance(mol: Mol, include_stereoisomers=False,
     exactMass = Descriptors.ExactMolWt(mol)
     molFormula = rdMolDescriptors.CalcMolFormula(mol)
     charge = Chem.GetFormalCharge(mol)
-    molBlock = Chem.MolToMolBlock(mol, forceV3000=True)
+    molBlock = Chem.MolToMolBlock(mol)
 
     molecule["cLogP"] = cLogP
     molecule["tpsa"] = tpsa
@@ -229,38 +181,28 @@ def mol_to_sapio_substance(mol: Mol, include_stereoisomers=False,
     # We need to test the INCHI can be loaded back to indigo.
     indigo_mol = indigo.loadMolecule(molBlock)
     indigo_mol.aromatize()
-    if enhanced_stereo:
-        # Remove enhanced stereo layer when generating InChI as the stereo hash is generated separately for reg.
-        mol_copy: Mol = Chem.MolFromMolBlock(Chem.MolToMolBlock(mol))
-        Chem.CanonicalizeEnhancedStereo(mol_copy)
-        molecule["inchi"] = Chem.MolToInchi(mol_copy)
-        molecule["inchiKey"] = Chem.MolToInchiKey(mol_copy)
-    else:
-        indigo_inchi.resetOptions()
-        indigo_inchi_str = indigo_inchi.getInchi(indigo_mol)
-        molecule["inchi"] = indigo_inchi_str
-        indigo_inchi_key_str = indigo_inchi.getInchiKey(indigo_inchi_str)
-        molecule["inchiKey"] = indigo_inchi_key_str
+    indigo_inchi.resetOptions()
+    indigo_inchi_str = indigo_inchi.getInchi(indigo_mol)
+    molecule["inchi"] = indigo_inchi_str
+    indigo_inchi_key_str = indigo_inchi.getInchiKey(indigo_inchi_str)
+    molecule["inchiKey"] = indigo_inchi_key_str
     molecule["smiles"] = indigo_mol.smiles()
-    molecule["reg_hash"] = get_enhanced_stereo_reg_hash(mol, enhanced_stereo=enhanced_stereo)
-    molecule["cxsmiles_hash"] = get_cxs_smiles_hash(mol, enhanced_stereo=enhanced_stereo)
-    molecule["has_or_group"] = get_has_or_group(mol, enhanced_stereo=enhanced_stereo)
 
+    if include_stereoisomers and has_chiral_centers(mol):
+        stereoisomers = find_all_possible_stereoisomers(mol, only_unassigned=False, try_embedding=False, unique=True)
+        molecule["stereoisomers"] = [mol_to_sapio_partial_pojo(x) for x in stereoisomers]
     return molecule
 
 
-def mol_to_sapio_compound(mol: Mol, include_stereoisomers=False, enhanced_stereo: bool = False,
+def mol_to_sapio_compound(mol: Mol, include_stereoisomers: bool = False,
                           salt_def: str | None = None, resolve_canonical: bool = True,
-                          make_images: bool = False, canonical_tautomer: bool = True,
-                          remove_atom_map: bool = True):
+                          make_images: bool = False, canonical_tautomer: bool = True):
     ret = dict()
-    ret['originalMol'] = mol_to_sapio_substance(mol, include_stereoisomers=False,
+    ret['originalMol'] = mol_to_sapio_substance(mol, include_stereoisomers,
                                                 normalize=False, remove_salt=False, make_images=make_images,
-                                                canonical_tautomer=canonical_tautomer,
-                                                enhanced_stereo=enhanced_stereo, remove_atom_map=remove_atom_map)
+                                                canonical_tautomer=canonical_tautomer)
     if resolve_canonical:
         ret['canonicalMol'] = mol_to_sapio_substance(mol, include_stereoisomers=False,
                                                      normalize=True, remove_salt=True, make_images=make_images,
-                                                     salt_def=salt_def, canonical_tautomer=canonical_tautomer,
-                                                     enhanced_stereo=enhanced_stereo, remove_atom_map=remove_atom_map)
+                                                     salt_def=salt_def, canonical_tautomer=canonical_tautomer)
     return ret

{sapiopycommons-2024.9.20a333 → sapiopycommons-2024.9.30a335}/src/sapiopycommons/files/file_util.py

@@ -23,8 +23,8 @@ class FileUtil:
     """
     @staticmethod
     def tokenize_csv(file_bytes: bytes, required_headers: list[str] | None = None, header_row_index: int | None = 0,
-                     seperator: str = ",", *, encoding: str | None = None, exception_on_empty: bool = True) \
-            -> tuple[list[dict[str, str]], list[list[str]]]:
+                     seperator: str = ",", *, encoding: str | None = None, encoding_error: str | None = "strict",
+                     exception_on_empty: bool = True) -> tuple[list[dict[str, str]], list[list[str]]]:
         """
         Tokenize a CSV file. The provided file must be uniform. That is, if row 1 has 10 cells, all the rows in the file
         must have 10 cells. Otherwise, the Pandas parser throws a tokenizer exception.
@@ -39,7 +39,11 @@ class FileUtil:
         :param seperator: The character that separates cells in the table.
         :param encoding: The encoding used to read the given file bytes. If not provided, uses utf-8. If your file
             contains a non-utf-8 character, then a UnicodeDecodeError will be thrown. If this happens, consider using
-            ISO-8859-1 as the encoding.
+            ISO-8859-1 as the encoding, or investigate what encoding would handle the characters in your file.
+        :param encoding_error: The error handling behavior if an encoding error is encountered. By default, the behavior
+            is "strict", meaning that encoding errors raise an exception. Change this to "ignore" to skip over invalid
+            characters or "replace" to replace invalid characters with a ? character. For a full list of options, see
+            https://docs.python.org/3/library/codecs.html#error-handlers
         :param exception_on_empty: Throw a user error exception if the provided file bytes result in an empty list in
             the first element of the returned tuple.
         :return: The CSV parsed into a list of dicts where each dict is a row, mapping the headers to the cells for
@@ -49,7 +53,7 @@ class FileUtil:
         # Parse the file bytes into two DataFrames. The first is metadata of the file located above the header row,
         # while the second is the body of the file below the header row.
         file_body, file_metadata = FileUtil.csv_to_data_frames(file_bytes, header_row_index, seperator,
-                                                               encoding=encoding)
+                                                               encoding=encoding, encoding_error=encoding_error)
         # Parse the metadata from above the header row index into a list of lists.
         metadata: list[list[str]] = FileUtil.data_frame_to_lists(file_metadata)
         # Parse the data from the file body into a list of dicts.
@@ -90,7 +94,8 @@ class FileUtil:
 
     @staticmethod
     def csv_to_data_frames(file_bytes: bytes, header_row_index: int | None = 0, seperator: str = ",",
-                           *, encoding: str | None = None) -> tuple[DataFrame, DataFrame | None]:
+                           *, encoding: str | None = None, encoding_error: str | None = "strict") \
+            -> tuple[DataFrame, DataFrame | None]:
         """
         Parse the file bytes for a CSV into DataFrames. The provided file must be uniform. That is, if row 1 has 10
         cells, all the rows in the file must have 10 cells. Otherwise, the Pandas parser throws a tokenizer exception.
@@ -103,7 +108,11 @@ class FileUtil:
         :param seperator: The character that separates cells in the table.
         :param encoding: The encoding used to read the given file bytes. If not provided, uses utf-8. If your file
             contains a non-utf-8 character, then a UnicodeDecodeError will be thrown. If this happens, consider using
-            ISO-8859-1 as the encoding.
+            ISO-8859-1 as the encoding, or investigate what encoding would handle the characters in your file.
+        :param encoding_error: The error handling behavior if an encoding error is encountered. By default, the behavior
+            is "strict", meaning that encoding errors raise an exception. Change this to "ignore" to skip over invalid
+            characters or "replace" to replace invalid characters with a ? character. For a full list of options, see
+            https://docs.python.org/3/library/codecs.html#error-handlers
         :return: A tuple of two DataFrames. The first is the frame for the CSV table body, while the second is for the
             metadata from above the header row, or None if there is no metadata.
         """
@@ -115,7 +124,8 @@ class FileUtil:
                 # can throw off the header row index.
                 file_metadata = pandas.read_csv(file_io, header=None, dtype=dtype(str),
                                                 skiprows=lambda x: x >= header_row_index,
-                                                skip_blank_lines=False, sep=seperator, encoding=encoding)
+                                                skip_blank_lines=False, sep=seperator, encoding=encoding,
+                                                encoding_errors=encoding_error)
         with io.BytesIO(file_bytes) as file_io:
             # The use of the dtype argument is to ensure that everything from the file gets read as a string. Added
             # because some numerical values would get ".0" appended to them, even when casting the DataFrame cell to a

{sapiopycommons-2024.9.20a333 → sapiopycommons-2024.9.30a335}/src/sapiopycommons/multimodal/multimodal_data.py

@@ -38,9 +38,6 @@ class PyMolecule:
     normError: str | None
     desaltError: str | None
     desaltedList: list[str] | None
-    registrationHash: str | None
-    hasOrGroup: bool
-    CXSMILESHash: str | None
 
 
 @dataclass
@@ -103,9 +100,9 @@ class PyMoleculeLoaderResult:
         compoundList: the compounds successfully loaded.
         errorList: an error record is added here for each one we failed to load in Sapio.
     """
-    compoundByStr: dict[str, PyCompound] | None
-    compoundList: list[PyCompound] | None
-    errorList: list[ChemLoadingError] | None
+    compoundByStr: dict[str, PyCompound]
+    compoundList: list[PyCompound]
+    errorList: list[ChemLoadingError]
 
 
 @dataclass