molSimplify 1.7.4__py3-none-any.whl

molSimplify/Informatics/lacRACAssemble_bisdithiolenes.py

@@ -0,0 +1,236 @@
+from molSimplify.Classes.ligand import ligand_breakdown, ligand
+from molSimplify.Classes.globalvars import globalvars
+from molSimplify.Informatics.lacRACAssemble import (generate_all_ligand_autocorrelations,
+                                                    generate_all_ligand_misc,
+                                                    append_descriptors,
+                                                    generate_metal_deltametrics,
+                                                    generate_full_complex_autocorrelations,
+                                                    generate_metal_autocorrelations,
+                                                    generate_metal_ox_autocorrelations,
+                                                    generate_metal_ox_deltametrics,
+                                                    generate_all_ligand_deltametrics
+                                                    )
+
+globs = globalvars()
+
+
+def lig_assign_bisdithiolene(inmol, liglist, ligdents, ligcons):
+    """[summary]
+
+    Parameters
+    ----------
+    inmol : mol3D object
+        5-coordinate mol3D object
+    liglist : list
+        see ligand class
+    ligdents : list
+        see ligand class
+    ligcons : list
+        [see ligand class
+
+    Returns
+    -------
+    ax_ligand_list, eq_ligand_list, ax_con_int_list, eq_con_int_list
+        see ligands class
+
+    Raises
+    ------
+    ValueError
+        If unrecognized ligdent.
+    """
+    ax_ligand_list = list()
+    eq_ligand_list = list()
+    ax_con_int_list = list()
+    eq_con_int_list = list()
+    for i, ligand_indices in enumerate(liglist):
+        this_ligand = ligand(inmol, ligand_indices, ligdents[i])
+        this_ligand.obtain_mol3d()
+        if ligdents[i] == 1:
+            ax_con = ligcons[i]
+            ax_ligand_list.append(this_ligand)
+            current_ligand_index_list = this_ligand.index_list
+            ax_con_int_list.append([current_ligand_index_list.index(x) for x in ax_con])
+        elif ligdents[i] == 2:
+            eq_con = ligcons[i]
+            eq_ligand_list.append(this_ligand)
+            current_ligand_index_list = this_ligand.index_list
+            eq_con_int_list.append([current_ligand_index_list.index(x) for x in eq_con])
+        else:
+            raise ValueError('Ligdent unknown: ' + str(ligdents[i]))
+    return ax_ligand_list, eq_ligand_list, ax_con_int_list, eq_con_int_list
+
+
+def get_descriptor_vector(this_complex, custom_ligand_dict=False,
+                          ox_modifier=False, NumB=False, Gval=False,
+                          lacRACs=True, loud=False, metal_ind=None,
+                          smiles_charge=False, eq_sym=False,
+                          use_dist=False, size_normalize=False):
+    """ Calculate and return all geo-based RACs for a given octahedral complex (featurize).
+
+    Parameters
+    ----------
+        this_complex : mol3D
+            Transition metal complex to be featurized.
+        custom_ligand_dict : bool, optional
+            Custom ligand dictionary to evaluate for complex if passed, by default False
+            Skip the ligand breakdown steps -
+            in cases where 3D geo is not correct/formed
+            custom_ligand_dict.keys() must be eq_ligands_list, ax_ligand_list
+            ax_con_int_list ,eq_con_int_list
+            with types: eq/ax_ligand_list list of mol3D
+            eq/ax_con_int_list list of list/tuple of int e.g,  [[1,2] [1,2]]
+        ox_modifier : bool, optional
+            dict, used to modify prop vector (e.g. for adding
+            ONLY used with  ox_nuclear_charge ox or charge)
+            {"Fe":2, "Co": 3} etc, by default False
+        NumB : bool, optional
+            Use Number of Bonds as additional RAC, by default False
+        Gval : bool, optional
+            Use group number as RAC, by default False
+        lacRACs : bool, optional
+            Use ligand_assign_consistent (lac) to represent mol3D given
+            if False, use ligand_assign (older), default True
+        loud : bool, optional
+            Print degubbging information, by default False
+        metal_ind : bool, optional
+            index of the metal atom to generate property, by default False
+        smiles_charge : bool, optional
+            use obmol conversion through smiles to assign ligand_misc_charges, by default False
+
+    Returns
+    -------
+        descriptor_names : list
+            Compiled list of descriptor names
+        descriptors : list
+            Compiled list of descriptor values
+
+    """
+    # modifier -
+    descriptor_names = []
+    descriptors = []
+    # Generate custom_ligand_dict if one not passed!
+    if not custom_ligand_dict:
+        if lacRACs:
+            from molSimplify.Classes.ligand import ligand_assign_consistent as ligand_assign
+        else:
+            from molSimplify.Classes.ligand import ligand_assign as ligand_assign
+        liglist, ligdents, ligcons = ligand_breakdown(this_complex, BondedOct=True) # Complex is assumed to be octahedral
+        if sum(ligdents) == 6:
+            (ax_ligand_list, eq_ligand_list, ax_natoms_list, eq_natoms_list,
+             ax_con_int_list, eq_con_int_list, ax_con_list, eq_con_list,
+             built_ligand_list) = ligand_assign(this_complex, liglist,
+                                                ligdents, ligcons, loud,
+                                                eq_sym_match=eq_sym)
+            custom_ligand_dict = {'ax_ligand_list': ax_ligand_list,
+                                  'eq_ligand_list': eq_ligand_list,
+                                  'ax_con_int_list': ax_con_int_list,
+                                  'eq_con_int_list': eq_con_int_list}
+        elif sum(ligdents) == 5:
+            (ax_ligand_list, eq_ligand_list,
+             ax_con_int_list, eq_con_int_list) = lig_assign_bisdithiolene(
+                 this_complex, liglist, ligdents, ligcons)
+            custom_ligand_dict = {'ax_ligand_list': ax_ligand_list,
+                                  'eq_ligand_list': eq_ligand_list,
+                                  'ax_con_int_list': ax_con_int_list,
+                                  'eq_con_int_list': eq_con_int_list}
+
+    # misc descriptors
+    results_dictionary = generate_all_ligand_misc(this_complex, loud=False,
+                                                  custom_ligand_dict=custom_ligand_dict,
+                                                  smiles_charge=smiles_charge)
+    descriptor_names, descriptors = append_descriptors(descriptor_names, descriptors,
+                                                       results_dictionary['colnames'],
+                                                       results_dictionary['result_ax'],
+                                                       'misc', 'ax')
+    descriptor_names, descriptors = append_descriptors(descriptor_names, descriptors,
+                                                       results_dictionary['colnames'],
+                                                       results_dictionary['result_eq'],
+                                                       'misc', 'eq')
+
+    # full ACs
+    results_dictionary = generate_full_complex_autocorrelations(this_complex, depth=3, loud=False,
+                                                                flag_name=False, modifier=ox_modifier,
+                                                                NumB=NumB, Gval=Gval, use_dist=use_dist,
+                                                                size_normalize=size_normalize)
+    descriptor_names, descriptors = append_descriptors(descriptor_names, descriptors,
+                                                       results_dictionary['colnames'],
+                                                       results_dictionary['results'],
+                                                       'f', 'all')
+
+    # ligand ACs
+    results_dictionary = generate_all_ligand_autocorrelations(this_complex, depth=3, loud=False,
+                                                              flag_name=False,
+                                                              custom_ligand_dict=custom_ligand_dict,
+                                                              NumB=NumB, Gval=Gval, use_dist=use_dist,
+                                                              size_normalize=size_normalize)
+    descriptor_names, descriptors = append_descriptors(descriptor_names, descriptors,
+                                                       results_dictionary['colnames'],
+                                                       results_dictionary['result_ax_full'],
+                                                       'f', 'ax')
+    descriptor_names, descriptors = append_descriptors(descriptor_names, descriptors,
+                                                       results_dictionary['colnames'],
+                                                       results_dictionary['result_eq_full'],
+                                                       'f', 'eq')
+    descriptor_names, descriptors = append_descriptors(descriptor_names, descriptors,
+                                                       results_dictionary['colnames'],
+                                                       results_dictionary['result_ax_con'],
+                                                       'lc', 'ax')
+    descriptor_names, descriptors = append_descriptors(descriptor_names, descriptors,
+                                                       results_dictionary['colnames'],
+                                                       results_dictionary['result_eq_con'],
+                                                       'lc', 'eq')
+
+    results_dictionary = generate_all_ligand_deltametrics(this_complex, depth=3, loud=False,
+                                                          custom_ligand_dict=custom_ligand_dict,
+                                                          NumB=NumB, Gval=Gval,
+                                                          use_dist=use_dist,
+                                                          size_normalize=size_normalize)
+    descriptor_names, descriptors = append_descriptors(descriptor_names, descriptors,
+                                                       results_dictionary['colnames'],
+                                                       results_dictionary['result_ax_con'],
+                                                       'D_lc', 'ax')
+    descriptor_names, descriptors = append_descriptors(descriptor_names, descriptors,
+                                                       results_dictionary['colnames'],
+                                                       results_dictionary['result_eq_con'],
+                                                       'D_lc', 'eq')
+
+    # metal ACs
+    results_dictionary = generate_metal_autocorrelations(this_complex, depth=3, loud=False,
+                                                         modifier=ox_modifier, NumB=NumB,
+                                                         Gval=Gval, metal_ind=metal_ind,
+                                                         use_dist=use_dist,
+                                                         size_normalize=size_normalize)
+    descriptor_names, descriptors = append_descriptors(descriptor_names, descriptors,
+                                                       results_dictionary['colnames'],
+                                                       results_dictionary['results'],
+                                                       'mc', 'all')
+
+    results_dictionary = generate_metal_deltametrics(this_complex, depth=3, loud=False,
+                                                     modifier=ox_modifier, NumB=NumB,
+                                                     Gval=Gval, metal_ind=metal_ind,
+                                                     use_dist=use_dist,
+                                                     size_normalize=size_normalize)
+    descriptor_names, descriptors = append_descriptors(descriptor_names, descriptors,
+                                                       results_dictionary['colnames'],
+                                                       results_dictionary['results'],
+                                                       'D_mc', 'all')
+
+    # ## ox-metal ACs, if ox available
+    if ox_modifier:
+        results_dictionary = generate_metal_ox_autocorrelations(ox_modifier, this_complex, depth=3,
+                                                                loud=False, metal_ind=metal_ind,
+                                                                use_dist=use_dist,
+                                                                size_normalize=size_normalize)
+        descriptor_names, descriptors = append_descriptors(descriptor_names, descriptors,
+                                                           results_dictionary['colnames'],
+                                                           results_dictionary['results'],
+                                                           'mc', 'all')
+        results_dictionary = generate_metal_ox_deltametrics(ox_modifier, this_complex, depth=3,
+                                                            loud=False, metal_ind=metal_ind,
+                                                            use_dist=use_dist,
+                                                            size_normalize=size_normalize)
+        descriptor_names, descriptors = append_descriptors(descriptor_names, descriptors,
+                                                           results_dictionary['colnames'],
+                                                           results_dictionary['results'],
+                                                           'D_mc', 'all')
+    return descriptor_names, descriptors

molSimplify/Informatics/misc_descriptors.py

@@ -0,0 +1,198 @@
+from molSimplify.Classes.ligand import ligand_breakdown, ligand_assign
+from molSimplify.Informatics.graph_analyze import (get_lig_EN,
+                                                   get_truncated_kier,
+                                                   kier)
+import numpy as np
+
+
+def generate_all_ligand_misc(mol, loud, custom_ligand_dict=False, force_legacy=False):
+    # custom_ligand_dict.keys() must be eq_ligands_list, ax_ligand_list
+    ##                                    ax_con_int_list ,eq_con_int_list
+    # with types: eq/ax_ligand_list list of mol3D
+    # eq/ax_con_int_list list of list/tuple of int e.g,  [[1,2] [1,2]]
+    # use force_legacy to get kier indices/MCDL
+    result_ax = list()
+    result_eq = list()
+    if force_legacy:
+        colnames = ['dent', 'maxDEN', 'ki', 'tki', 'charge']
+    else:
+        colnames = ['dent', 'charge']
+    if not custom_ligand_dict:
+        liglist, ligdents, ligcons = ligand_breakdown(mol, BondedOct=True) # Complex is assumed to be octahedral
+        ax_ligand_list, eq_ligand_list, ax_natoms_list, eq_natoms_list, ax_con_int_list, eq_con_int_list, ax_con_list, eq_con_list, built_ligand_list = ligand_assign(
+            mol, liglist, ligdents, ligcons, loud, name=False)
+    else:
+        ax_ligand_list = custom_ligand_dict["ax_ligand_list"]
+        eq_ligand_list = custom_ligand_dict["eq_ligand_list"]
+        ax_con_int_list = custom_ligand_dict["ax_con_int_list"]
+        eq_con_int_list = custom_ligand_dict["eq_con_int_list"]
+    # count ligands
+    n_ax = len(ax_ligand_list)
+    n_eq = len(eq_ligand_list)
+    # allocate
+    result_ax_dent = False
+    result_eq_dent = False
+    result_ax_maxdelen = False
+    result_eq_maxdelen = False
+    result_ax_ki = False
+    result_eq_ki = False
+    result_ax_tki = False
+    result_eq_tki = False
+    result_ax_charge = False
+    result_eq_charge = False
+    # loop over axial ligands
+    if n_ax > 0:
+        for i in range(0, n_ax):
+            ax_ligand_list[i].mol.convert2OBMol()
+            if not (i == 0):
+                result_ax_dent += ax_ligand_list[i].dent
+                if force_legacy:
+                    result_ax_maxdelen += get_lig_EN(
+                        ax_ligand_list[i].mol, ax_con_int_list[i])
+                    result_ax_ki += kier(ax_ligand_list[i].mol)
+                    result_ax_tki += get_truncated_kier(
+                        ax_ligand_list[i].mol, ax_con_int_list[i])
+                result_ax_charge += ax_ligand_list[i].mol.OBMol.GetTotalCharge()
+            else:
+                result_ax_dent = ax_ligand_list[i].dent
+                if force_legacy:
+                    result_ax_maxdelen = get_lig_EN(
+                        ax_ligand_list[i].mol, ax_con_int_list[i])
+                    result_ax_ki = kier(ax_ligand_list[i].mol)
+                    result_ax_tki = get_truncated_kier(
+                        ax_ligand_list[i].mol, ax_con_int_list[i])
+                result_ax_charge = ax_ligand_list[i].mol.OBMol.GetTotalCharge()
+        # average axial results
+        result_ax_dent = np.divide(result_ax_dent, n_ax)
+        if force_legacy:
+            result_ax_maxdelen = np.divide(result_ax_maxdelen, n_ax)
+            result_ax_ki = np.divide(result_ax_ki, n_ax)
+            result_ax_tki = np.divide(result_ax_tki, n_ax)
+        result_ax_charge = np.divide(result_ax_charge, n_ax)
+
+    # loop over eq ligands
+    if n_eq > 0:
+        for i in range(0, n_eq):
+            eq_ligand_list[i].mol.convert2OBMol()
+            if not (i == 0):
+                result_eq_dent += eq_ligand_list[i].dent
+                if force_legacy:
+                    result_eq_maxdelen += get_lig_EN(
+                        eq_ligand_list[i].mol, eq_con_int_list[i])
+                    result_eq_ki += kier(eq_ligand_list[i].mol)
+                    result_eq_tki += get_truncated_kier(
+                        eq_ligand_list[i].mol, eq_con_int_list[i])
+                result_eq_charge += eq_ligand_list[i].mol.OBMol.GetTotalCharge()
+            else:
+                result_eq_dent = eq_ligand_list[i].dent
+                if force_legacy:
+                    result_eq_maxdelen = get_lig_EN(
+                        eq_ligand_list[i].mol, eq_con_int_list[i])
+                    result_eq_ki = kier(eq_ligand_list[i].mol)
+                    result_eq_tki = get_truncated_kier(
+                        eq_ligand_list[i].mol, eq_con_int_list[i])
+                result_eq_charge = eq_ligand_list[i].mol.OBMol.GetTotalCharge()
+        # average eq results
+        result_eq_dent = np.divide(result_eq_dent, n_eq)
+        if force_legacy:
+            result_eq_maxdelen = np.divide(result_eq_maxdelen, n_eq)
+            result_eq_ki = np.divide(result_eq_ki, n_eq)
+            result_eq_tki = np.divide(result_eq_tki, n_eq)
+        result_eq_charge = np.divide(result_eq_charge, n_eq)
+        # save the results
+    result_ax.append(result_ax_dent)
+    if force_legacy:
+        result_ax.append(result_ax_maxdelen)
+        result_ax.append(result_ax_ki)
+        result_ax.append(result_ax_tki)
+    result_ax.append(result_ax_charge)
+
+    result_eq.append(result_eq_dent)
+    if force_legacy:
+        result_eq.append(result_eq_maxdelen)
+        result_eq.append(result_eq_ki)
+        result_eq.append(result_eq_tki)
+    result_eq.append(result_eq_charge)
+
+    results_dictionary = {'colnames': colnames,
+                          'result_ax': result_ax, 'result_eq': result_eq}
+    return results_dictionary
+
+
+def generate_all_ligand_misc_dimers(mol, loud, custom_ligand_dict=False):
+    # custom_ligand_dict.keys() must be ax1_ligands_list, ax2_ligand_list, ax3_ligand_list
+    ##                                    ax1_con_int_list , ax2_con_int_list, ax3_con_int_list
+    # with types: ax_{i}_ligand_list list of mol3D
+    # ax_{i}_con_int_list list of list/tuple of int e.g,  [[1,2] [1,2]]
+    result_ax1 = list()
+    result_ax2 = list()
+    result_ax3 = list()
+    result_axs = [result_ax1, result_ax2, result_ax3]
+    colnames = ['dent', 'maxDEN', 'ki', 'tki', 'charge']
+    if not custom_ligand_dict:
+        raise ValueError('No custom_ligand_dict provided!')
+        #liglist, ligdents, ligcons = ligand_breakdown(mol, BondedOct=True)
+        # ax_ligand_list, eq_ligand_list, ax_natoms_list, eq_natoms_list, ax_con_int_list, eq_con_int_list, ax_con_list, eq_con_list, built_ligand_list = ligand_assign(
+        #    mol, liglist, ligdents, ligcons, loud, name=False)
+    else:
+        ax1_ligand_list = custom_ligand_dict["ax1_ligand_list"]
+        ax2_ligand_list = custom_ligand_dict["ax2_ligand_list"]
+        ax3_ligand_list = custom_ligand_dict["ax3_ligand_list"]
+        ax1_con_int_list = custom_ligand_dict["ax1_con_int_list"]
+        ax2_con_int_list = custom_ligand_dict["ax2_con_int_list"]
+        ax3_con_int_list = custom_ligand_dict["ax3_con_int_list"]
+        axligs = [ax1_ligand_list, ax2_ligand_list, ax3_ligand_list]
+        axcons = [ax1_con_int_list, ax2_con_int_list, ax3_con_int_list]
+        n_axs = [len(i) for i in axligs]
+    # allocate
+    '''
+        result_ax_dent = False
+        result_eq_dent = False
+        result_ax_maxdelen = False
+        result_eq_maxdelen = False
+        result_ax_ki = False
+        result_eq_ki = False
+        result_ax_tki = False
+        result_eq_tki = False
+        result_ax_charge = False
+        result_eq_charge = False
+        '''
+    # loop over axial ligands
+    assert all([i > 0 for i in n_axs]
+               ), 'At least one axis has no ligands. # Ligands: %s' % n_axs
+    for ax_ligand_list, ax_con_int_list, n_ax, result_ax in zip(axligs, axcons, n_axs, result_axs):
+        for i in range(0, n_ax):
+            ax_ligand_list[i].mol.convert2OBMol()
+            if i == 0:
+                result_ax_dent = ax_ligand_list[i].dent
+                result_ax_maxdelen = get_lig_EN(
+                    ax_ligand_list[i].mol, ax_con_int_list[i])
+                result_ax_ki = kier(ax_ligand_list[i].mol)
+                result_ax_tki = get_truncated_kier(
+                    ax_ligand_list[i].mol, ax_con_int_list[i])
+                result_ax_charge = ax_ligand_list[i].mol.OBMol.GetTotalCharge()
+            else:
+                result_ax_dent += ax_ligand_list[i].dent
+                result_ax_maxdelen += get_lig_EN(
+                    ax_ligand_list[i].mol, ax_con_int_list[i])
+                result_ax_ki += kier(ax_ligand_list[i].mol)
+                result_ax_tki += get_truncated_kier(
+                    ax_ligand_list[i].mol, ax_con_int_list[i])
+                result_ax_charge += ax_ligand_list[i].mol.OBMol.GetTotalCharge()
+        # average axial results
+        result_ax_dent = np.divide(result_ax_dent, n_ax)
+        result_ax_maxdelen = np.divide(result_ax_maxdelen, n_ax)
+        result_ax_ki = np.divide(result_ax_ki, n_ax)
+        result_ax_tki = np.divide(result_ax_tki, n_ax)
+        result_ax_charge = np.divide(result_ax_charge, n_ax)
+
+        result_ax.append(result_ax_dent)
+        result_ax.append(result_ax_maxdelen)
+        result_ax.append(result_ax_ki)
+        result_ax.append(result_ax_tki)
+        result_ax.append(result_ax_charge)
+    assert all([len(i) > 0 for i in [result_ax1, result_ax2,
+                                     result_ax3]]), 'Some results are empty.'
+    results_dictionary = {'colnames': colnames, 'result_ax1': result_ax1,
+                          'result_ax2': result_ax2, 'result_ax3': result_ax3}
+    return results_dictionary

molSimplify/Informatics/organic_fingerprints.py

@@ -0,0 +1,61 @@
+from rdkit import Chem
+from rdkit.Chem import AllChem
+from molSimplify.Classes.mol3D import mol3D
+
+
+# Nice explanation of fingerprints here:
+# https://www.rdkit.org/UGM/2012/Landrum_RDKit_UGM.Fingerprints.Final.pptx.pdf
+# Nice tutorial here:
+# https://www.rdkit.org/docs/GettingStartedInPython.html
+# Morgan paper: JCIM 50:742-54 (2010).
+
+# This script takes in a mol3D object and gets an ECFP.
+# This assumes that you can get the smiles from the mol3D,
+# which can be obtained by the bound method "get_smiles"
+# of the mol3D class. RDKit has functionality for
+# drawing the necessary bits --> DrawMorganBit
+# @param --> mol3D class of molecule, returns fingerprint
+def get_morgan(mol, morgan_radius=4):
+    if isinstance(mol, mol3D):
+        smiles = mol.get_smiles(use_mol2=True)
+    elif isinstance(mol, str):
+        smiles = mol
+    else:
+        raise ValueError("First argument not a smiles string or mol3D")
+    m = Chem.MolFromSmiles(smiles)
+    # empty bit dictionary that gets populated
+    # Morgan FPs should be compared with tanimoto similarity
+    # By default, Morgan FPs have 2048 bits.
+    bit_vector = {}
+    morgan_fingerprint_vector = AllChem.GetMorganFingerprintAsBitVect(m, radius=morgan_radius, bitInfo=bit_vector)
+    return bit_vector
+
+
+def get_substructure_smiles(mol, atomID, radius):
+    if isinstance(mol, mol3D):
+        smiles = mol.get_smiles(use_mol2=True)
+    elif isinstance(mol, str):
+        smiles = mol
+    else:
+        raise ValueError("First argument not a smiles string or mol3D")
+    m = Chem.MolFromSmiles(smiles)
+    if radius > 0:
+        environment_morgan = Chem.FindAtomEnvironmentOfRadiusN(m, radius, atomID)
+        atoms_to_use = []
+        for b in environment_morgan:
+            atoms_to_use.append(m.GetBondWithIdx(b).GetBeginAtomIdx())
+            atoms_to_use.append(m.GetBondWithIdx(b).GetEndAtomIdx())
+        atoms_to_use = list(set(atoms_to_use))
+    else:
+        atoms_to_use = [atomID]
+        environment_morgan = None
+    smiles_1 = Chem.MolFragmentToSmiles(m, atoms_to_use, bondsToUse=environment_morgan,
+                                        allHsExplicit=True, allBondsExplicit=True, rootedAtAtom=atomID)
+    return smiles_1
+
+# bit_vector_benzene = get_morgan(mol='c1ccccc1')
+# smi = get_substructure_smiles('c1ccccc1',list(bit_vector_benzene.values())[0][0][0],list(bit_vector_benzene.values())[0][0][1])
+# print(smi) # this tells you the substructures in the bit
+# bit_vector_pyridine = get_morgan(mol='c1ncccc1')
+# below you can see what pyridine and benzene have in common
+# print(set(bit_vector.keys()).intersection(bit_vector_py.keys()))