sapiopycommons 2024.3.19a157__py3-none-any.whl → 2025.1.17a402__py3-none-any.whl

sapiopycommons/chem/Molecules.py

@@ -1,5 +1,6 @@
 # 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
@@ -8,7 +9,8 @@ from rdkit.Chem import rdMolDescriptors
 from rdkit.Chem.EnumerateStereoisomers import StereoEnumerationOptions, EnumerateStereoisomers
 from rdkit.Chem.MolStandardize import rdMolStandardize
 from rdkit.Chem.SaltRemover import SaltRemover
-from rdkit.Chem.rdchem import Mol
+from rdkit.Chem.rdChemReactions import ChemicalReaction
+from rdkit.Chem.rdchem import Mol, RWMol, Bond
 
 from sapiopycommons.chem.IndigoMolecules import indigo, renderer, indigo_inchi
 
@@ -20,6 +22,43 @@ tautomer_params.tautomerReassignStereo = False
 tautomer_params.tautomerRemoveIsotopicHs = True
 enumerator = rdMolStandardize.TautomerEnumerator(tautomer_params)
 
+
+def remove_dative_bonds_from_mol(mol: Mol) -> RWMol:
+    """
+    Create a new copy of RWMol molecule and remove all dative bonds in the molecule.
+    :param mol: The original molecule
+    :return: The new molecule with dative bonds removed.
+    """
+    ret: RWMol = Chem.RWMol(mol)
+    bonds_to_remove = []
+    bond: Bond
+    for bond in ret.GetBonds():
+        if bond.GetBondType() in [Chem.BondType.DATIVER, Chem.BondType.DATIVE, Chem.BondType.DATIVEL,
+                                  Chem.BondType.DATIVEONE]:
+            bonds_to_remove.append((bond.GetBeginAtomIdx(), bond.GetEndAtomIdx()))
+    for atom1_idx, atom2_idx in bonds_to_remove:
+        ret.RemoveBond(atom1_idx, atom2_idx)
+    return ret
+
+
+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
@@ -86,7 +125,6 @@ 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.
@@ -96,7 +134,7 @@ def mol_to_sapio_partial_pojo(mol: Mol):
     Chem.SanitizeMol(mol)
     mol.UpdatePropertyCache()
     smiles = Chem.MolToSmiles(mol)
-    molBlock = Chem.MolToMolBlock(mol)
+    molBlock = Chem.MolToMolBlock(mol, forceV3000=True)
     img = mol_to_img(mol)
     molecule = dict()
     molecule["smiles"] = smiles
@@ -105,23 +143,52 @@ def mol_to_sapio_partial_pojo(mol: Mol):
     return molecule
 
 
-def mol_to_sapio_substance(mol: Mol, include_stereoisomers: bool = False,
+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,
                            normalize: bool = False, remove_salt: bool = False, make_images: bool = False,
-                           salt_def: str | None = None, canonical_tautomer: bool = True):
+                           salt_def: str | None = None, canonical_tautomer: bool = True,
+                           enhanced_stereo: bool = False, remove_atom_map: 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)
@@ -157,7 +224,7 @@ def mol_to_sapio_substance(mol: Mol, include_stereoisomers: bool = False,
     exactMass = Descriptors.ExactMolWt(mol)
     molFormula = rdMolDescriptors.CalcMolFormula(mol)
     charge = Chem.GetFormalCharge(mol)
-    molBlock = Chem.MolToMolBlock(mol)
+    molBlock = Chem.MolToMolBlock(mol, forceV3000=True)
 
     molecule["cLogP"] = cLogP
     molecule["tpsa"] = tpsa
@@ -169,7 +236,9 @@ def mol_to_sapio_substance(mol: Mol, include_stereoisomers: bool = False,
     # This is number of H-Bond Donor
     molecule["numHBonds"] = rdMolDescriptors.CalcNumHBD(mol)
     molecule["molBlock"] = molBlock
-    rdkit_inchi = MolToInchi(mol)
+    # Create a copy of molecule before modifying it for InChI generation.
+    inchi_mol: Mol = remove_dative_bonds_from_mol(mol)
+    rdkit_inchi = MolToInchi(inchi_mol)
     # If INCHI is completely invalid, we fail this molecule.
     if not rdkit_inchi:
         MolToInchi(mol, treatWarningAsError=True)
@@ -181,27 +250,37 @@ def mol_to_sapio_substance(mol: Mol, include_stereoisomers: bool = False,
     # We need to test the INCHI can be loaded back to indigo.
     indigo_mol = indigo.loadMolecule(molBlock)
     indigo_mol.aromatize()
-    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
+    if enhanced_stereo:
+        # Remove enhanced stereo layer when generating InChI as the stereo hash is generated separately for reg.
+        Chem.CanonicalizeEnhancedStereo(inchi_mol)
+        molecule["inchi"] = Chem.MolToInchi(inchi_mol)
+        molecule["inchiKey"] = Chem.MolToInchiKey(inchi_mol)
+    else:
+        indigo_inchi.resetOptions()
+        indigo_inchi_mol = indigo.loadMolecule(Chem.MolToMolBlock(inchi_mol, forceV3000=True))
+        indigo_inchi_str = indigo_inchi.getInchi(indigo_inchi_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()
-
-    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]
+    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)
     return molecule
 
 
-def mol_to_sapio_compound(mol: Mol, include_stereoisomers: bool = False,
+def mol_to_sapio_compound(mol: Mol, include_stereoisomers=False, enhanced_stereo: bool = False,
                           salt_def: str | None = None, resolve_canonical: bool = True,
-                          make_images: bool = False, canonical_tautomer: bool = True):
+                          make_images: bool = False, canonical_tautomer: bool = True,
+                          remove_atom_map: bool = True):
     ret = dict()
-    ret['originalMol'] = mol_to_sapio_substance(mol, include_stereoisomers,
+    ret['originalMol'] = mol_to_sapio_substance(mol, include_stereoisomers=False,
                                                 normalize=False, remove_salt=False, make_images=make_images,
-                                                canonical_tautomer=canonical_tautomer)
+                                                canonical_tautomer=canonical_tautomer,
+                                                enhanced_stereo=enhanced_stereo, remove_atom_map=remove_atom_map)
     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)
+                                                     salt_def=salt_def, canonical_tautomer=canonical_tautomer,
+                                                     enhanced_stereo=enhanced_stereo, remove_atom_map=remove_atom_map)
     return ret

sapiopycommons/customreport/column_builder.py

@@ -0,0 +1,60 @@
+from sapiopylib.rest.pojo.CustomReport import ReportColumn
+from sapiopylib.rest.pojo.datatype.FieldDefinition import FieldType
+
+from sapiopycommons.general.aliases import DataTypeIdentifier, FieldIdentifier, AliasUtil
+from sapiopycommons.general.exceptions import SapioException
+
+# The system fields that every record has and their field types. System fields aren't generated as record model fields
+# for all platform version, hence the need to create a dict for them in the off chance that they're not present on
+# the model wrapper.
+SYSTEM_FIELDS: dict[str, FieldType] = {
+    "DataRecordName": FieldType.IDENTIFIER,
+    "RecordId": FieldType.LONG,
+    "DateCreated": FieldType.DATE,
+    "CreatedBy": FieldType.STRING,
+    "VeloxLastModifiedDate": FieldType.DATE,
+    "VeloxLastModifiedBy": FieldType.STRING
+}
+
+
+class ColumnBuilder:
+    """
+    A class for building report columns for custom reports.
+    """
+    @staticmethod
+    def build_column(data_type: DataTypeIdentifier, field: FieldIdentifier, field_type: FieldType | None = None) \
+            -> ReportColumn:
+        """
+        Build a ReportColumn from a variety of possible inputs.
+
+        :param data_type: An object that can be used to identify a data type.
+        :param field: An object that can be used to identify a data field.
+        :param field_type: The field type of the provided field. This is only required if the field type cannot be
+            determined from the given data type and field, which occurs when the given field is a string and the
+            given data type is not a wrapped record model or record model wrapper.
+        :return: A ReportColumn for the inputs.
+        """
+        # Get the data type and field names from the inputs.
+        data_type_name = AliasUtil.to_data_type_name(data_type)
+        field_name = AliasUtil.to_data_field_name(field)
+        if field_type is None:
+            field_type = ColumnBuilder.__field_type(data_type, field)
+        if field_type is None:
+            raise SapioException("The field_type parameter is required for the provided data_type and field inputs.")
+        return ReportColumn(data_type_name, field_name, field_type)
+
+    @staticmethod
+    def __field_type(data_type: DataTypeIdentifier, field: FieldIdentifier) -> FieldType | None:
+        """
+        Given a record model wrapper and a field name, return the field type for that field. Accounts for system fields.
+
+        :param data_type: The record model wrapper that the field is on.
+        :param field: The field name to return the type of.
+        :return: The field type of the given field name.
+        """
+        # Check if the field name is a system field. If it is, use the field type defined in this file.
+        field_name: str = AliasUtil.to_data_field_name(field)
+        if field_name in SYSTEM_FIELDS:
+            return SYSTEM_FIELDS.get(field_name)
+        # Otherwise, check if the field type can be found from the wrapper.
+        return AliasUtil.to_field_type(field, data_type)

sapiopycommons/customreport/custom_report_builder.py

@@ -0,0 +1,137 @@
+from sapiopylib.rest.pojo.CustomReport import ReportColumn, CustomReportCriteria, AbstractReportTerm, \
+    ExplicitJoinDefinition, RelatedRecordCriteria, QueryRestriction, FieldCompareReportTerm
+from sapiopylib.rest.pojo.datatype.FieldDefinition import FieldType
+
+from sapiopycommons.customreport.column_builder import ColumnBuilder
+from sapiopycommons.customreport.term_builder import TermBuilder
+from sapiopycommons.general.aliases import DataTypeIdentifier, FieldIdentifier, AliasUtil, SapioRecord
+from sapiopycommons.general.exceptions import SapioException
+
+
+class CustomReportBuilder:
+    """
+    A class used for building custom reports. Look into using the TermBuilder and ColumnBuilder classes for building
+    parts of a custom report.
+    """
+    root_data_type: DataTypeIdentifier
+    data_type_name: str
+    root_term: AbstractReportTerm | None
+    record_criteria: RelatedRecordCriteria
+    column_list: list[ReportColumn]
+    join_list: list[ExplicitJoinDefinition]
+
+    def __init__(self, root_data_type: DataTypeIdentifier):
+        """
+        :param root_data_type: An object that can be used to identify a data type name. Used as the root data type name
+            of this search.
+        """
+        self.root_data_type = root_data_type
+        self.data_type_name = AliasUtil.to_data_type_name(root_data_type)
+        self.root_term = None
+        self.record_criteria = RelatedRecordCriteria(QueryRestriction.QUERY_ALL)
+        self.column_list = []
+        self.join_list = []
+
+    def get_term_builder(self) -> TermBuilder:
+        """
+        :return: A TermBuilder with a data type matching this report builder's root data type.
+        """
+        return TermBuilder(self.root_data_type)
+
+    def has_root_term(self) -> bool:
+        """
+        :return: Whether this report builder has had its root term set.
+        """
+        return self.root_term is not None
+
+    def set_root_term(self, term: AbstractReportTerm) -> None:
+        """
+        Set the root term of the report. Use the TermBuilder class to construct the report terms.
+
+        :param term: The term to set as the root term.
+        """
+        self.root_term = term
+
+    def has_columns(self) -> bool:
+        """
+        :return: Whether this report builder has any report columns.
+        """
+        return bool(self.column_list)
+
+    def add_column(self, field: FieldIdentifier, field_type: FieldType = None,
+                   *, data_type: DataTypeIdentifier | None = None) -> None:
+        """
+        Add a column to this report builder.
+
+        :param field: An object that can be used to identify a data field.
+        :param field_type: The field type of the provided field. This is only required if the field type cannot be
+            determined from the given data type and field, which occurs when the given field is a string and the
+            given data type is not a wrapped record model or record model wrapper.
+        :param data_type: An object that can be used to identify a data type. If not provided, uses the root data type
+            provided when this builder was initialized. You'll only want to specify this value when adding a column
+            that is from a different data type than the root data type.
+        """
+        if data_type is None:
+            data_type = self.root_data_type
+        self.column_list.append(ColumnBuilder.build_column(data_type, field, field_type))
+
+    def add_columns(self, fields: list[FieldIdentifier], *, data_type: DataTypeIdentifier | None = None) -> None:
+        """
+        Add columns to this report builder.
+
+        :param fields: A list of objects that can be used to identify data fields.
+        :param data_type: An object that can be used to identify a data type. If not provided, uses the root data type
+            provided when this builder was initialized. You'll only want to specify this value when adding a column
+            that is from a different data type than the root data type.
+        """
+        for field in fields:
+            self.add_column(field, data_type=data_type)
+
+    def set_query_restriction(self, base_record: SapioRecord, search_related: QueryRestriction) -> None:
+        """
+        Set a restriction on the report for this report builder such that the returned results must be related in
+        some way to the provided base record. Without this, the report searches all records in the system that match the
+        root term.
+
+        :param base_record: The base record to run the search from.
+        :param search_related: Determine the relationship of the related records that can appear in the search, be those
+            children, parents, descendants, or ancestors.
+        """
+        if search_related == QueryRestriction.QUERY_ALL:
+            raise SapioException("The search_related must be something other than QUERY_ALL when setting a query restriction.")
+        self.record_criteria = RelatedRecordCriteria(search_related,
+                                                     AliasUtil.to_record_id(base_record),
+                                                     AliasUtil.to_data_type_name(base_record))
+
+    def add_join(self, comparison_term: FieldCompareReportTerm, data_type: DataTypeIdentifier | None = None) -> None:
+        """
+        Add a join statement to this report builder.
+
+        :param comparison_term: The field comparison term to join with.
+        :param data_type: The data type name that this join is on. If not provided, then the left side data type name
+            of the comparison term will be the data type that is joined against.
+        """
+        if data_type is None:
+            data_type: str = comparison_term.left_data_type_name
+        else:
+            data_type: str = AliasUtil.to_data_type_name(data_type)
+        self.join_list.append(ExplicitJoinDefinition(data_type, comparison_term))
+
+    def build_report_criteria(self, page_size: int = 0, page_number: int = -1, case_sensitive: bool = False,
+                              owner_restriction_set: list[str] = None) -> CustomReportCriteria:
+        """
+        Generate a CustomReportCriteria using the column list, root term, and root data type from this report builder.
+        You can use the CustomReportManager or CustomReportUtil to run the constructed report.
+
+        :param page_size: The page size of the custom report.
+        :param page_number: The page number of the current report.
+        :param case_sensitive: When searching texts, should the search be case-sensitive?
+        :param owner_restriction_set: Specifies to only return records if the record is owned by this list of usernames.
+        :return: A CustomReportCriteria from this report builder.
+        """
+        if not self.has_root_term():
+            raise SapioException("Cannot build a report with no root term.")
+        if not self.has_columns():
+            raise SapioException("Cannot build a report with no columns.")
+        return CustomReportCriteria(self.column_list, self.root_term, self.record_criteria, self.data_type_name,
+                                    case_sensitive, page_size, page_number, owner_restriction_set, self.join_list)