vantami 0.4.3__py3-none-any.whl

vantami/cli/CDDD.py

@@ -0,0 +1,63 @@
+""" Wrapper for CDDD.py due to requirement of specific python environment """
+import argparse
+import pandas as pd
+import numpy as np
+import pickle
+from cddd.inference import InferenceModel
+from typing import Union, List
+
+parser = argparse.ArgumentParser(prog='CDDD', description='Calculate CDDD descriptors from SMILES')
+
+parser.add_argument('-i', '--input', help='Path to an input file. Must be a .csv file.')
+parser.add_argument('-o', '--output', help='Path to an output file. Must be a .pkl file.')
+parser.add_argument('-s', '--smiles_col', help='Name of the column holding the SMILES')
+parser.add_argument('-d', '--descriptor_col', help='Name of the column to which write the descriptors')
+parser.add_argument('-n', '--n_cpu', help='Number of CPU threads to use during calculations')
+parser.add_argument('-m', '--model', help='Path to the default_model of CDDD')
+
+parsed_args = parser.parse_args()
+
+def main(args):
+
+    input_ = args.input  # .csv file
+    output_ = args.output   # .pkl file
+    smiles_col_ = args.smiles_col
+    descriptor_col_ = args.descriptor_col
+    n_cpu = int(args.n_cpu)
+    model_path = args.model
+
+    model = InferenceModel(model_path, use_gpu=False, cpu_threads=n_cpu)
+
+    df = pd.read_csv(input_, sep='\t')
+    # unpack lists
+    df.loc[:, smiles_col_] = df[smiles_col_].apply(lambda entry: entry.split(' : ') if ' : ' in entry else entry)
+
+    def process(smiles: Union[str, List[str]], model_):
+
+        if isinstance(smiles, str):
+            try:
+                fp = model_.seq_to_emb(smiles)[0]
+                return fp
+
+            except Exception as e:
+                print(f'Could not process < {smiles} > due to the following error:\n{e}')
+                return np.nan
+
+        if isinstance(smiles, list) & all([isinstance(smi, str) for smi in smiles]):
+            try:
+                fps = [model_.seq_to_emb(smi)[0] for smi in smiles]
+                return fps
+
+            except Exception as e:
+                print(f'Unable to process < {smiles} > due to: \n{e}')
+                return np.nan
+
+        print(f'Expected < smiles > argument to be of type str or List[str], received < {type(smiles)} > instead.')
+        return np.nan
+
+    df[descriptor_col_] = df[smiles_col_].apply(process, model_=model)
+    pickle.dump(df, open(output_, 'wb'), protocol=4)
+
+
+if __name__ == '__main__':
+    main(parsed_args)

vantami/cli/CIR.py

@@ -0,0 +1,185 @@
+import argparse
+import numpy as np
+import pandas as pd
+from urllib.request import urlopen
+from urllib.error import HTTPError, URLError
+import time
+import rdkit
+from rdkit.Chem import AllChem
+from rdkit import RDLogger
+
+parser = argparse.ArgumentParser(prog='ChemicalIdentityResolver',
+                                 description='Uses NCI/NIH CIR to find SMILES for a given name')
+
+parser.add_argument('-i', '--input', help='Absolute path to an input file')
+parser.add_argument('-o', '--output', help='Absolute path to an output file')
+parser.add_argument('-n', '--name', help="Name of the column holding molecule's names")
+parser.add_argument('-r', '--resolver', help='Type of resolved identity')
+
+parsed_args = parser.parse_args()
+
+
+def main(args):
+    """
+    TODO: add modules for using common chemistry CAS resolver
+    TODO: add modules for using ECHA website for resolving names/CAS
+    Resolves chemical identities representations using the NCI/NIH CIR API.
+    Accepted inputs and outputs are: .xlsx, .csv, .parquet, .pkl.
+    Accepted keywords for resolver are: smiles, stdinchi, stdinchikey, cas, iupac_name
+
+    Example of usage:
+
+    python3 CIR.py --input data.csv --output data_out.csv --name molecules --resolver smiles --strip_salts True
+
+    Parameters
+    ----------
+    args : argparse.Namespace
+        Parsed arguments from command line.
+    """
+
+    def chemical_resolver(name: str, resolver: str = 'smiles', sleep_time: int = 6, max_retries: int = 5):
+        """
+        Resolve chemical identity a single molecule using NCI/NIH CIR API
+
+        Parameters
+        ---------------
+        name   : str
+                 name of a molecule
+        resolver : str
+                 type of output. available are: smiles, stdinchi, stdinchikey, cas, iupac_name
+        sleep_time : int
+                     time to wait between attempting a retry
+        max_retries : int
+                      maximum number of attempts to make
+        """
+
+        name = name.lower().strip().replace(' ', '%20')
+        url = f'https://cactus.nci.nih.gov/chemical/structure/{name.lower()}/{resolver.lower()}'
+
+        try:
+            out = urlopen(url, data=None, timeout=8).read().decode()
+            return out
+        except HTTPError as e:
+            print(f'Failed to resolve "{name.replace("%20", " ")}" due to {e}')
+            try:
+                out = urlopen(url+'?resolver=name_by_chemspider', data=None, timeout=16).read().decode()
+                return out
+            except HTTPError as e:
+                print(f'Failed to resolve "{name.replace("%20", " ")}" due to {e}')
+                return np.nan
+            except Exception:
+                return np.nan
+        except URLError or ConnectionResetError as e:
+            print(f'Connection lost while resolving "{name.replace("%20", " ")}" due to {e}. '
+                  f'Retrying in {sleep_time} seconds.')
+            retries = 1
+            while retries <= max_retries:
+                try:
+                    time.sleep(sleep_time)
+                    sleep_time += 2
+                    out = urlopen(url, data=None).read().decode()
+                    print(f'"{name.replace("%20", " ")}" solved successfully')
+                    return out
+                except HTTPError as e:
+                    print(f'Failed to resolve "{name.replace("%20", " ")}" after {retries} attempts due to {e}')
+                    return np.nan
+                except URLError or ConnectionResetError as e:
+                    print(f'Connection lost while resolving "{name.replace("%20", " ")}" due to {e}. '
+                          f'Retrying in {sleep_time} seconds.')
+                    pass
+                retries += 1
+            print(f'Failed to resolve "{name.replace("%20", " ")}" after {max_retries} attempts')
+            return np.nan
+        except UnicodeEncodeError:
+            print(f'Could not properly encode {name}. Skipping.')
+            return np.nan
+
+    def validate_smiles(df: pd.DataFrame, smiles_col: str = 'SMILES'):
+
+        RDLogger.DisableLog('rdApp.*')
+
+        """
+        Use RDKit to check if a SMILES can be converted to a valid molecule and check it for potential errors.
+
+        Parameters
+        ---------------
+        df : pd.DataFrame
+             with SMILES
+        smiles_col : str
+                     Column in df holding SMILES of molecules
+        """
+
+        def rdkit_validate(smiles: str):
+
+            try:
+                mol = rdkit.Chem.MolFromSmiles(smiles, sanitize=True)
+                if mol is not None:
+                    return True, None
+                else:
+                    mol = rdkit.Chem.MolFromSmiles(smiles, sanitize=False)
+                    if mol is not None:
+                        rdkit_problems = [problem.GetType() for problem in rdkit.Chem.DetectChemistryProblems(mol)]
+                        return False, rdkit_problems
+                    else:
+                        return False, 'Invalid molecule'
+            except Exception as e:
+                return False, 'Invalid molecule'
+
+        out = df[smiles_col].apply(rdkit_validate).tolist()
+
+        df['Correct'] = [x[0] for x in out]
+        df['Issues'] = [x[1] for x in out]
+
+        return df
+
+    input_ = args.input
+    output_ = args.output
+    name_ = args.name
+    resolver_ = args.resolver
+
+    if resolver_ not in ['smiles', 'stdinchi', 'stdinchikey', 'cas', 'iupac_name']:
+        raise ValueError('Wrong format passed. Expected one of: smiles, stdinchi, stdinchikey, cas, iupac_name')
+
+    in_ext = input_.split('.')[-1]
+    out_ext = output_.split('.')[-1]
+
+    if in_ext == 'xlsx':
+        data = pd.read_excel(input_)
+    elif in_ext == 'csv':
+        data = pd.read_csv(input_)
+    elif in_ext == 'parquet':
+        data = pd.read_parquet(input_)
+    elif in_ext == 'pkl':
+        data = pd.read_pickle(input_)
+    else:
+        raise ValueError(f'Unrecognized file extension. Expected one of: .xlsx, .csv, .parquet, .pkl')
+
+    data['Mol_ID'] = [x for x in range(len(data))]
+    data['Output'] = data[name_].apply(chemical_resolver, resolver=resolver_)
+
+    solved = data.dropna(subset='Output', axis=0)
+    unsolved = data.drop(index=solved.index)
+
+    write_path = output_.rstrip(f'.{out_ext}')
+
+    if str(resolver_) == 'smiles':
+        solved = validate_smiles(solved, 'Output')
+
+    if out_ext == 'xlsx':
+        solved.to_excel(f'{write_path}_resolved.xlsx', index=False)
+        unsolved.to_excel(f'{write_path}_unsolved.xlsx', index=False)
+    elif out_ext == 'csv':
+        solved.to_csv(f'{write_path}_resolved.csv', header=True, index=False)
+        unsolved.to_csv(f'{write_path}_unsolved.csv', header=True, index=False)
+    elif out_ext == 'parquet':
+        solved.to_parquet(f'{write_path}_resolved.parquet')
+        unsolved.to_parquet(f'{write_path}_unsolved.parquet')
+    elif out_ext == 'pkl':
+        solved.to_pickle(f'{write_path}_resolved.pkl')
+        unsolved.to_pickle(f'{write_path}_unsolved.pkl')
+    else:
+        raise ValueError(f'Unrecognized file extension. Expected one of: .xlsx, .csv, .parquet, .pkl')
+
+
+if __name__ == '__main__':
+    main(parsed_args)

vantami/cli/Dock.py

@@ -0,0 +1,215 @@
+"""
+version = 0.1.0
+date = 25.06.2024
+author = M-Iwan
+"""
+
+import argparse
+import numpy as np
+import pandas as pd
+from rdkit import Chem
+from rdkit.Chem import Draw
+from rdkit.Chem.AllChem import ETKDGv3, EmbedMolecule, MMFFOptimizeMolecule, MMFFGetMoleculeProperties, MMFFGetMoleculeForceField
+import os
+import re
+import glob
+import json
+import copy
+
+parser = argparse.ArgumentParser(prog='Dock',
+                                 description='Command line implementation of SMINA for docking')
+
+parser.add_argument('-i', '--input', help='Absolute path to an input file')
+parser.add_argument('-o', '--output', help='Absolute path to an output file')
+parser.add_argument('-c', '--conf', help="Absolute path to .json configuration file")
+parser.add_argument('-s', '--smiles_col', help="Name of the column holding SMILES.")
+parser.add_argument('-n', '--mol_id', help='Name of the column with Mol_ID')
+parser.add_argument('-d', '--dock_col', help='Name of the column where to save the results')
+
+parsed_args = parser.parse_args()
+
+
+def main(args):
+    """ File with classes and functions related to computational-chemistry related tasks """
+
+    class Molecule:
+
+        def __init__(self, smiles: str, mol_id: str):
+
+            self.smiles = smiles
+            self.mol_id = mol_id
+            self.mol = Chem.MolFromSmiles(self.smiles)
+            self.dock_score = None
+
+        def embed(self, attempts: int = 10):
+            """
+            Attempt to find lowest-energy 3D coordinates from 2D molecule.
+            """
+            self.mol = Chem.AddHs(self.mol)
+            params = ETKDGv3()
+            mols = []
+            energies = []
+
+            def optimize_molecule(mol_, conf_id_):
+                ex_code = MMFFOptimizeMolecule(mol_, maxIters=500, confId=conf_id_)
+                match ex_code:
+                    case -1:  # optimization not possible, return whatever molecule was embedded
+                        print('Could not setup the force field for provided molecule')
+                        return mol_, np.nan
+                    case 0:  # optimization converged, proceed normally
+                        prop = MMFFGetMoleculeProperties(mol_)
+                        ff = MMFFGetMoleculeForceField(mol_, prop)
+                        energy_ = ff.CalcEnergy()
+                        return mol_, energy_
+                    case 1:  # force field setup correct, but convergence not reached
+                        _ = MMFFOptimizeMolecule(mol_, maxIters=5000, confId=conf_id_)
+                        prop = MMFFGetMoleculeProperties(mol_)
+                        ff = MMFFGetMoleculeForceField(mol_, prop)
+                        energy_ = ff.CalcEnergy()
+                        return mol_, energy_
+
+            for attempt in range(attempts):
+                mol = copy.deepcopy(self.mol)
+                conf_id = EmbedMolecule(mol, params)
+                if conf_id >= 0:  # in case of correct embedding the returned number is not negative
+                    mol, energy = optimize_molecule(mol, conf_id)
+                    mols.append(mol)
+                    energies.append(energy)
+                else:
+                    conf_id = EmbedMolecule(mol, maxAttempts=1000, useRandomCoords=True)
+                    if isinstance(conf_id, int):  # check if other embedding works
+                        mol, energy = optimize_molecule(mol, conf_id)
+                        mols.append(mol)
+                        energies.append(energy)
+                    else:
+                        return mol  # return unoptimized mol
+
+            if not all([x is np.nan for x in energies]):  # if there is at least one correct energy
+                min_id = np.nanargmin(energies)
+                return mols[min_id]  # return mol with the lowest energy
+            else:
+                print(f'Optimization not possible for < {self.smiles} >')
+                mol = copy.deepcopy(self.mol)
+                EmbedMolecule(mol)
+                return mol  # return original molecule
+
+        def show(self):
+            return Draw.MolToImage(self.mol, size=(512, 512))
+
+        def dock(self, dock_params: dict):
+
+            output = dock_params['output_dir'].rstrip('/')
+
+            os.makedirs(output, exist_ok=True)  # make dir if it's not there yet
+
+            mol_in = f'{output}/mol_{self.mol_id}.mol'
+            mol_out = f'{output}/mol_{self.mol_id}.mol2'
+
+            if glob.glob(mol_in):
+                print(f'Molecule file mol_{self.mol_id}.mol already exists.')
+            else:
+                self.mol = self.embed()
+                Chem.MolToMolFile(self.mol, mol_in)
+                convert_command = f'obabel -imol {mol_in} -omol2 -O {mol_out}'
+                os.system(convert_command)
+
+                smina = dock_params['smina_path']
+                protein = dock_params['protein_path']
+                mol2_in = f'{output}/mol_{self.mol_id}.mol2'
+                mol2_out = f'{output}/mol_{self.mol_id}_out.mol2'
+                log_out = f'{output}/mol_{self.mol_id}_out.log'
+
+                x_coord = dock_params['x_coord']
+                x_size = dock_params['x_size']
+
+                y_coord = dock_params['y_coord']
+                y_size = dock_params['y_size']
+
+                z_coord = dock_params['z_coord']
+                z_size = dock_params['z_size']
+
+                exh = dock_params['exhaustiveness']
+
+                dock_command = (f'{smina} -r {protein} -l {mol2_in} --center_x {x_coord} --center_y {y_coord} --center_z {z_coord} '
+                                f'--size_x {x_size} --size_y {y_size} --size_z {z_size} --exhaustiveness {exh} --out {mol2_out};')
+
+                os.system(dock_command)
+
+                output_command = f'{smina} -r {protein} -l {mol2_out} --score_only --log {log_out}'
+
+                os.system(output_command)
+
+                output = open(log_out, 'r').read()
+                score = np.min([float(score) for score in re.findall(r'Affinity:\s*([\-?+\d.]+)\s+\(kcal/mol\)', output)])
+
+                self.dock_score = score
+
+        def read_dock(self, output_dir: str):
+
+            log_file = glob.glob(f"{output_dir.rstrip('/')}/mol_{self.mol_id}_out.log")
+
+            if len(log_file) == 0:
+                print('Molecule not yet docked')
+                self.dock_score = np.nan
+            else:
+                output = open(log_file[0], 'r').read()
+                self.dock_score = np.min([float(score) for score in re.findall(r'Affinity:\s*([\-?+\d.]+)\s+\(kcal/mol\)', output)])
+
+    def read_df(path):
+        ext = path.split('.')[-1]
+        if ext == 'xlsx':
+            df = pd.read_excel(path)
+        elif ext == 'csv':
+            df = pd.read_csv(path)
+        elif ext == 'parquet':
+            df = pd.read_parquet(path)
+        elif ext == 'pkl':
+            df = pd.read_pickle(path)
+        else:
+            raise ValueError('Incorrect extension')
+
+        return df
+
+    def write_df(df, path):
+        ext = path.split('.')[-1]
+        if len(df) >= 1:
+            if ext == 'xlsx':
+                df.to_excel(path, index=False)
+            elif ext == 'csv':
+                df.to_csv(path, index=False, header=True)
+            elif ext == 'parquet':
+                df.to_parquet(path)
+            elif ext == 'pkl':
+                df.to_pickle(path)
+            else:
+                raise ValueError('Incorrect extension')
+
+    def dock_score(row, smiles_col_, mol_id_col_, dock_params_):
+        smiles = row[smiles_col_]
+        mol_id = row[mol_id_col_]
+        mol = Molecule(smiles,  mol_id)
+        mol.dock(dock_params_)
+        score = mol.dock_score
+        return score
+
+    input_path = args.input
+    output_path = args.output
+    config_path = args.conf
+    smiles_col = args.smiles_col
+    mol_id_col = args.mol_id
+    dock_col = args.dock_col
+
+    data = read_df(input_path)
+
+    dock_params = json.load(open(config_path, 'r'))
+
+    if mol_id_col not in data.columns:
+        data[mol_id_col] = np.arange(0, len(data))
+
+    data[dock_col] = data.apply(dock_score, smiles_col_=smiles_col, mol_id_col_=mol_id_col, dock_params_=dock_params, axis=1)
+
+    write_df(data, output_path)
+
+
+if __name__ == '__main__':
+    main(parsed_args)