vantami 0.4.3__py3-none-any.whl

vantami/__init__.py

@@ -0,0 +1,12 @@
+from vantami import api
+from vantami import chemistry
+from vantami import cli
+from vantami import data
+from vantami import deep
+from vantami import io
+from vantami import metrics
+from vantami import nlp
+from vantami import standardize
+from vantami import ml
+from vantami import stats
+from vantami import visualize

vantami/api/convert.py

@@ -0,0 +1,45 @@
+import os
+import json
+
+import polars as pl
+
+
+def opsin_convert(df: pl.DataFrame, opsin_paths: str, name_col: str = 'Name', out_col: str = 'SMILES'):
+    """
+    Convert IUPAC names to SMILES
+
+    Parameters
+    ----------
+
+    df: pl.DataFrame
+        A polars DataFrame
+    opsin_paths: str
+        Path to a JSON file containing paths for OPSIN-related files. Must contain path to opsin .jar file ['opsin']
+        and to a directory with read/write permission ['io']
+    name_col: str
+        Name of the column with IUPAC names of chemicals
+    out_col: str
+        Name of the column for output
+    """
+
+    with open(opsin_paths, 'r') as file:
+        paths = json.load(file)
+
+    in_path = os.path.join(paths['io'], 'names_in.txt')
+    out_path = os.path.join(paths['io'], 'names_out.txt')
+
+    names = df[name_col].to_list()
+
+    with open(in_path, 'w') as f:
+        for name in names:
+            f.write(name + '\n')
+
+    open(out_path, 'w')
+
+    command = f"java -jar {paths['opsin']} -osmi {in_path} {out_path}"
+    os.system(command)
+
+    smiles = open(out_path, 'r').readlines()
+
+    df = df.with_columns(pl.Series(out_col, smiles))
+    return df

vantami/api/resolve.py

@@ -0,0 +1,290 @@
+from typing import Union, List
+import numpy as np
+import time
+from urllib.request import urlopen
+from urllib.error import HTTPError, URLError
+import pubchempy as pcp
+import requests
+
+
+def cactus_resolver(name: str, resolver: str = 'smiles', sleep_time: int = 6, max_retries: int = 3, verbose: int = 0):
+    """
+    Resolve chemical identity of 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
+    verbose : int
+        Option to control verbosity level. Set to 0 for no logging.
+    """
+
+    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=300).read().decode()
+        return out
+    except HTTPError as e:
+        if verbose > 0:
+            print(f"Failed to resolve [{name.replace('%20', ' ')}] due to {e}")
+        return np.nan
+    except URLError or ConnectionResetError as e:
+        if verbose > 0:
+            print(f"Connection lost while resolving [{name.replace('%20', ' ')}] "
+                  f"due to {e}. 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()
+                if verbose > 0:
+                    print(f"[{name.replace('%20', ' ')}] solved successfully")
+                return out
+            except HTTPError as e:
+                if verbose > 0:
+                    print(f"Failed to resolve [{name.replace('%20', ' ')}] "
+                          f"after {retries} attempts due to {e}")
+                return np.nan
+            except (URLError, ConnectionResetError) as e:
+                if verbose > 0:
+                    print(f"Connection lost while resolving [{name.replace('%20', ' ')}] "
+                          f"due to {e}. Retrying in {sleep_time} seconds.")
+            retries += 1
+        if verbose > 0:
+            print(f"Failed to resolve [{name.replace('%20', ' ')}] after {max_retries} attempts")
+        return np.nan
+
+
+def pubchem_resolver(name: str, resolver: Union [str, list], sleep_time: int = 6, max_retries: int = 3):
+    """
+    Resolve chemical identity of a single molecule using PubChem API
+
+    Parameters
+    ---------------
+    name   : str
+             name of a molecule
+    resolver : Union[str | list]
+             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')
+
+    try:
+        out = pcp.get_properties(resolver, name, 'name')
+        if out:
+            return out[0]
+        else:
+            return {}
+    except HTTPError as e:
+        print(f"Failed to resolve [{name.replace('%20', ' ')}] due to {e}")
+        return {}
+    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 = pcp.get_properties(resolver, name, 'name')
+                if out:
+                    print(f"[{name.replace('%20', ' ')}] solved successfully")
+                    return out
+                else:
+                    return {}
+            except HTTPError as e:
+                print(f"Failed to resolve [{name.replace('%20', ' ')}] after {retries} attempts due to {e}")
+                return {}
+            except (URLError, 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 {}
+
+
+def commonchemistry_resolver(cas, parser):
+    url = f'https://commonchemistry.cas.org/detail?cas_rn={cas}'
+    try:
+        out = urlopen(url, timeout=30).read().decode('utf-8')
+    except:
+        pass
+    raise NotImplementedError
+
+
+"""
+    "def process_cas(cas, parser):\n",
+    "    if not 'NOCAS' in cas:\n",
+    "        url = f'https://commonchemistry.cas.org/detail?cas_rn={cas}'\n",
+    "        try:\n",
+    "            out = urlopen(url, data=None, timeout=3600).read().decode('utf-8')\n",
+    "            root = html.fromstring(out, parser=parser)\n",
+    "            try:\n",
+    "                for child in root.find('./body/app-root/app-detail/ngx-json-ld'):\n",
+    "                    dc = ast.literal_eval(child.text)['hasBioChemEntityPart']['identifier']\n",
+    "                    if re.search(r'\\AInChI', dc) is not None:\n",
+    "                        mol = MolFromInchi(dc)\n",
+    "                        smiles = Chem.MolToSmiles(mol)\n",
+    "                        return smiles \n",
+    "            except Exception as e:\n",
+    "                print(e)\n",
+    "                return np.nan\n",
+    "        except (HTTPError, URLError, ConnectionResetError, UnicodeEncodeError):\n",
+    "            return np.nan"
+"""
+
+
+def proxy_cactus_resolver(names: Union[str, List[str]], proxies: dict, resolver: str = 'smiles',
+                          timeout: int = 6, verbose: int = 0) -> dict:
+    """
+    Resolve chemical identity of a molecule using NCI/NIH CIR API.
+
+    Uses the Chemical Identifier Resolver (CIR) web service to convert various
+    chemical identifiers to the specified format.
+
+    Parameters
+    ----------
+    names: str
+        Name of the molecule to resolve (or a list of names).
+    proxies: dict
+        Dictionary containing proxy configuration for HTTP/HTTPS requests
+    resolver: str, optional
+        Output format requested. Available options: 'smiles', 'stdinchi',
+        'stdinchikey', 'cas', 'iupac_name'. Default is 'smiles'.
+    timeout: int, optional
+        Request timeout in seconds. Default is 6.
+    verbose: int, optional
+        Verbosity level. Set to 0 for silent operation. Default is 0.
+
+    Returns
+    -------
+    str or None
+        The resolved chemical identifier in requested format if successful,
+        None if resolution failed.
+
+    Notes
+    -----
+    Author: Mateusz Iwan
+    Email: mateusz.iwan@bayer.com / mateusz.iwan@hotmail.com
+    Environment: Technically any
+    """
+
+    resolver = resolver.lower().strip()
+
+    if not isinstance(names, (str, list)):  # check type
+        raise TypeError('Argument < names > must be a string or a list of strings')
+    if isinstance(names, list) and not all(isinstance(name, str) for name in names):
+        raise TypeError('When < names > is a list, all elements must be strings')
+
+    input_names = [names] if isinstance(names, str) else names
+
+    outputs = {}
+    session = requests.Session()
+
+    for orig_name in input_names:
+        name = orig_name.lower().strip().replace(' ', '%20')
+        url = f'https://cactus.nci.nih.gov/chemical/structure/{name}/{resolver}'
+        try:
+            response = session.get(url, timeout=timeout, proxies=proxies)
+            if (code := response.status_code) != 200:
+                if verbose > 0:
+                    print(f'Failed with status code {code} for {orig_name}')
+                outputs[orig_name] = None
+                continue
+            outputs[orig_name] = response.text.strip()
+
+        except requests.exceptions.RequestException as e:
+            if verbose > 0:
+                print(f'Request exception: {e}')
+            outputs[orig_name] = None
+    return outputs
+
+
+def proxy_pubchem_resolver(idxs: Union[str, List[str]], proxies: dict,
+                           idx_type: str, timeout: int = 6, verbose: int = 0):
+    """
+    Retrieve all available properties for a compound from PubChem using its name or CID.
+    Passing multiple values is supported.
+
+    Parameters
+    ----------
+    idxs: Union[str, List[str]]
+        Name(s) of the compound or PubChem CID(s)
+    proxies : dict
+        Dictionary containing proxy configuration for HTTP/HTTPS requests
+    idx_type: str
+        'cid' or 'name'
+    timeout : int, optional
+        Request timeout in seconds. Default is 6.
+    verbose : int, optional
+        Verbosity level. Set to 0 for silent operation. Default is 0.
+
+    Returns
+    -------
+    dict
+        Dictionary containing all available properties
+
+    Notes
+    -----
+    Author: Mateusz Iwan
+    Email: mateusz.iwan@bayer.com / mateusz.iwan@hotmail.com
+    Environment: Any  # technically
+    """
+
+    if not isinstance(idxs, (str, list)):  # check type
+        raise TypeError('Argument < names > must be a string or a list of strings')
+    if isinstance(idxs, list) and not all(isinstance(idx, str) for idx in idxs):
+        raise TypeError('When < names > is a list, all elements must be strings')
+
+    property_list = [
+        "MolecularFormula", "CanonicalSMILES",
+        "IsomericSMILES", "InChI",
+        "InChIKey", "IUPACName",
+    ]
+    property_string = ",".join(property_list)
+
+    input_ids = [idxs] if isinstance(idxs, str) else idxs
+
+    outputs = {}
+    session = requests.Session()
+
+    for orig_id in input_ids:
+        idx = orig_id.lower().strip().replace(' ', '%20')
+        url = f'https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/{idx_type}/{idx}/property/{property_string}/JSON'
+        try:
+            response = session.get(url, timeout=timeout, proxies=proxies)
+            if (code := response.status_code) != 200:
+                if verbose > 0:
+                    print(f'Failed with status code {code} for {orig_id}')
+                outputs[orig_id] = None
+                continue
+            data = response.json()
+            try:
+                properties = data['PropertyTable']['Properties'][0]
+                outputs[orig_id] = properties
+
+            except (KeyError, IndexError) as e:
+                if verbose > 0:
+                    print(f"Error extracting properties: {e}")
+                outputs[orig_id] = None
+
+        except requests.exceptions.RequestException as e:
+            if verbose > 0:
+                print(f'Request exception: {e}')
+            outputs[orig_id] = None
+
+    return outputs

vantami/cache.py

@@ -0,0 +1,14 @@
+from pathlib import Path
+
+def get_novami_cache_dir() -> Path:
+    cache_dir = Path.home() / ".cache" / "novami"
+    cache_dir.mkdir(parents=True, exist_ok=True)
+    return cache_dir
+
+
+def get_chemberta_model_path() -> Path:
+    return get_novami_cache_dir() / "ChemBERTa-model.joblib"
+
+def get_chemberta_tokenizer_path() -> Path:
+    return get_novami_cache_dir() / "ChemBERTa-tokenizer.joblib"
+

vantami/chemistry/molecule.py

@@ -0,0 +1,273 @@
+""" File with classes and functions related to computational-chemistry related tasks """
+import copy
+import numpy as np
+from rdkit import Chem
+from rdkit.Chem import Draw
+from rdkit.Chem.AllChem import (ETKDGv3, EmbedMolecule, MMFFOptimizeMolecule,
+                                MMFFGetMoleculeProperties, MMFFGetMoleculeForceField)
+from rdkit.Chem.MolStandardize import rdMolStandardize
+import prolif as plf
+import os
+import glob
+import re
+import pandas as pd
+import MDAnalysis as mda
+
+
+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_params = {}
+        self.dock_score = None
+        self.protein_path = None
+        self.docked_path = None
+        self.original_path = None
+        self.hydrogen_path = None
+        self.split_paths = []
+        self.pli_df = None
+        self.pli = False
+        self.tautomers = None
+
+    def __str__(self):
+        return f'Molecule object of < {self.smiles} >'
+
+    def __repr__(self):
+        return f'Molecule object of < {self.smiles} > with id < {self.mol_id} >'
+
+    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 validate_mol(self):
+        raise NotImplementedError
+
+    def show(self):
+        return Draw.MolToImage(self.mol, size=(512, 512))
+
+    def dock(self, dock_params: dict, overwrite: bool = False):
+
+        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) and not overwrite:
+            print(f'Molecule file mol_{self.mol_id}.mol already exists.')
+        else:
+            self.mol = self.embed()
+            Chem.MolToMolFile(self.mol, mol_in)
+            self.original_path = 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)])
+
+            with open(log_out, 'a') as file:
+                file.write(f'--- Docking parameters ---\n')
+                for name, value in dock_params.items():
+                    file.write(f'< {name} > : < {value} >\n')
+
+            if isinstance(score, float):
+                print(f'Docking successful')
+                self.dock_params = dock_params
+                self.dock_score = score
+                self.protein_path = protein
+                self.docked_path = mol2_out
+
+    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)])
+            self.docked_path = glob.glob(f"{output_dir.rstrip('/')}/mol_{self.mol_id}_out.mol2")[0]
+            self.original_path = glob.glob(f"{output_dir.rstrip('/')}/mol_{self.mol_id}.mol")[0]
+            output_list = output.split('\n')
+            for line in output_list:
+                if (matches := re.search(r'\A<\s(.+)\s>\s:\s<\s(.+)\s>\Z', line)) is not None:  # new!
+                    self.dock_params[matches.group(1)] = matches.group(2)
+            self.protein_path = self.dock_params['protein_path']
+
+    def calculate_pli(self, count: bool = False, file_path: str = None):
+        """
+        Calculate protein-ligand interaction fingerprint using prolif library.
+
+        Parameters
+        ----------
+        count: bool
+            Whether to return count fingerprint or bit fingerprint. Defaults to False
+        file_path: str
+            If not None, use provided path to file instead of self.docked_path
+        """
+
+        def split_mol_file(path_):
+            """
+            plf has issues accepting conformers from RDKit so the original file is split into separate .mol files,
+            and processed individually
+            """
+            split_indices_ = []
+            file_ = open(path_, 'r').readlines()
+            for i_, line_ in enumerate(file_):
+                if '*****' in line_:  # used to define a new conformation
+                    split_indices_.append(i_)
+            split_indices_.append(len(file_))
+            for j_ in range(len(split_indices_)-1):
+                new_path_ = path_.rstrip('.mol') + f'_{j_}.mol'
+                new_file_ = file_[split_indices_[j_]: split_indices_[j_+1]]
+                with open(new_path_, 'w') as f:
+                    for line_ in new_file_:
+                        f.write(line_)
+                self.split_paths.append(new_path_)
+
+        if not all([self.dock_score is not None, self.protein_path is not None, self.docked_path is not None]):
+            print(f'Molecule not docked successfully')
+        else:
+            assert self.protein_path.split('.')[-1] == 'pdb'  # check protein file extension
+            assert self.docked_path.split('.')[-1] == 'mol2'  # check molecule file extension
+            """
+            # alternative solution using rdkit
+            rdkit_protein = Chem.MolFromPDBFile(self.protein_path, removeHs=False)  # read protein file
+            plf_protein = plf.Molecule(rdkit_protein)  # potentially change back to plf.Molecule(rdkit_protein)
+            """
+            u = mda.Universe(self.protein_path)
+            plf_protein = plf.Molecule.from_mda(u)
+
+            if file_path is None:  # proceed as usual:
+                # OpenBabel sometimes would not add hydrogen atoms to .mol2 file, so it's first converted to .mol file
+                conversion_path = self.docked_path.rstrip('2')
+                self.hydrogen_path = self.docked_path.rstrip('.mol2') + '_H.mol'
+                convert_command_1 = f"obabel -imol2 {self.docked_path} -omol -O {conversion_path}"
+                convert_command_2 = f'obabel -imol {conversion_path} -omol -O {self.hydrogen_path} -p 7.4'
+                os.system(convert_command_1)
+                os.system(convert_command_2)
+                os.system(f'rm {conversion_path}')
+            else:  # use manually prepared file; expected to be .mol file with hydrogen atoms
+                self.hydrogen_path = file_path
+
+            split_mol_file(self.hydrogen_path)
+
+            for i, path in enumerate(self.split_paths):
+                try:
+                    ifp = plf.Fingerprint()
+                    rdkit_mol = Chem.MolFromMolFile(path, removeHs=False)  # read .mol file
+                    # noinspection PyTypeChecker
+                    ifp.run_from_iterable([plf.Molecule.from_rdkit(rdkit_mol)], plf_protein)  # calculate
+                    ifp_df = ifp.to_dataframe(index_col='Pose', drop_empty=False, count=count)  # pass to dataframe
+                    ifp_df = pd.melt(ifp_df)  # remove multi-indexing
+                    ifp_df['dock_number'] = i
+
+                    if self.pli_df is None:
+                        self.pli_df = ifp_df
+                    else:
+                        self.pli_df = pd.concat([self.pli_df, ifp_df], axis=0, ignore_index=True)
+
+                    os.system(f'rm {path}')
+
+                except AttributeError as e:
+                    print(f'Could not calculate IFP due to:\n{e}')
+
+        if self.pli_df is not None:  # combine and clean dfs
+            self.pli_df = self.pli_df.drop(columns=['ligand'])
+            self.pli_df['Mol_ID'] = self.mol_id
+            self.pli_df['SMILES'] = self.smiles
+            self.pli_df = self.pli_df.rename(columns={'protein': 'residue'})
+            self.pli = True
+
+    def enumerate_tautomers(self):
+        enumerator = rdMolStandardize.TautomerEnumerator()
+        canon = enumerator.canonicalize(self.mol)
+        csmi = Chem.MolToSmiles(canon)
+        res = [canon]
+        tautomers = enumerator.Enumerate(self.mol)
+        smis = [Chem.MolToSmiles(x) for x in tautomers]
+        stpl = sorted((x, y) for x,y in zip(smis, tautomers) if x != csmi)
+        res += [y for x, y in stpl]
+        self.tautomers = res
+
+    def enumerate_conformers(self):
+        raise NotImplementedError