ddi-fw 0.0.238__py3-none-any.whl → 0.0.239__py3-none-any.whl

ddi_fw/drugbank/drugbank_parser.py

@@ -1,157 +0,0 @@
-# # https://caseolap.github.io/docs/drug/drugbank/
-# #https://gist.github.com/rosherbal/56461421c69a8a7da775336c95fa62e0
-
-import os
-import zipfile
-import xml.etree.ElementTree as ET
-from xml.etree.ElementTree import XMLParser, XMLPullParser
-import pandas as pd
-import xmlschema
-import json as json
-import sys
-import unicodedata
-import re
-from importlib import resources as impresources
-from ddi_fw.utils import ZipHelper
-
-
-def slugify(value, allow_unicode=False):
-    """
-    Taken from https://github.com/django/django/blob/master/django/utils/text.py
-    Convert to ASCII if 'allow_unicode' is False. Convert spaces or repeated
-    dashes to single dashes. Remove characters that aren't alphanumerics,
-    underscores, or hyphens. Convert to lowercase. Also strip leading and
-    trailing whitespace, dashes, and underscores.
-    """
-    value = str(value)
-    if allow_unicode:
-        value = unicodedata.normalize('NFKC', value)
-    else:
-        value = unicodedata.normalize('NFKD', value).encode(
-            'ascii', 'ignore').decode('ascii')
-    value = re.sub(r'[^\w\s-]', '', value.lower())
-    return re.sub(r'[-\s]+', '-', value).strip('-_')
-
-
-def replace_key(key: str):
-    if key.startswith('@'):
-        key = key[1:]
-    if key == '$':
-        key = "value"
-    elif '{http://www.drugbank.ca}' in key:
-        key = key.replace('{http://www.drugbank.ca}', '')
-    return key
-
-
-def modify_keys(d):
-    for k, v in d.copy().items():
-        if isinstance(v, dict):
-            d.pop(k)
-            d[replace_key(k)] = v
-            modify_keys(v)
-        elif isinstance(v, list):
-            d.pop(k)
-            d[replace_key(k)] = v
-            for i in v:
-                if isinstance(i, list) or isinstance(i, dict):
-                    modify_keys(i)
-                # print(i)
-
-        else:
-            if k == "keyToChange":
-                v = int(v)
-            d.pop(k)
-            d[replace_key(k)] = v
-    return d
-
-
-class DrugBankParser:
-    def __init__(self, zip_file='drugbank.zip', input_path='./drugbank'):
-
-        # sys.path.insert(0,'/content/drive/My Drive/drugbank')
-        # HERE = '/content/drive/My Drive/drugbank'
-        HERE = input_path
-        xsd_file='drugbank.xsd'
-        DRUGBANK_XSD = impresources.files("ddi_fw.drugbank").joinpath("drugbank.xsd").open()
-        # DRUGBANK_XSD = HERE + '/' + xsd_file
-        DRUGBANK_ZIP = HERE + '/' + zip_file
-        xsd = xmlschema.XMLSchema(DRUGBANK_XSD)
-        self.drug_type_schema = xsd.complex_types[1]
-        self.zf = zipfile.ZipFile(DRUGBANK_ZIP, 'r')
-
-    def parse(self, save_path='./drugbank/drugs', override = False):
-        if not override:
-            print('No parsing process has been executed!!!')
-            return
-
-        elements = []
-        k = 0
-
-        for name in self.zf.namelist():
-            f = self.zf.open(name)
-            # tree = ET.parse(f)
-            # root = tree.getroot()
-            previous_element = None
-            for event, element in ET.iterparse(f, events=('end',)):  # "end"
-                # if k == 10:
-                #     break
-                if len(elements) == 0:
-                    elements.append(element)
-                elif len(elements) == 1:
-                    elements.append(element)
-                elif len(elements) == 2:
-                    elements[0] = elements[1]
-                    elements[1] = element
-                if len(elements) == 2:
-                    previous_element = elements[len(elements)-2]
-                drug = None
-                # previous_element = element.find("..")
-                #
-                if previous_element is not None and previous_element.tag == '{http://www.drugbank.ca}transporters' and event == 'end' and element.tag == "{http://www.drugbank.ca}drug":
-                    drug = element
-                    elements = []
-
-                    # for child in element:
-                    #     print(child.text)
-
-                if drug is None:
-                    continue
-
-                name = drug.find("{http://www.drugbank.ca}name")
-
-                d_name = None
-                if name is not None:
-                    d_name = name.text
-                    line = name.text
-
-                if d_name is None:
-                    continue
-
-                k = k + 1
-
-                # print(d_name)
-
-                # if lax is used we have to send d[0] as a parameter
-                d = self.drug_type_schema.decode(drug, validation='strict')
-                # pretty_dict = {replace_key(k): v for k, v in d[0].items()}
-                pretty_dict = modify_keys(d)
-                # for key, value in pretty_dict.items():
-                #     print(key, '->', value)
-                # file_name = slugify(d_name)
-
-                from pathlib import Path
-
-                Path(save_path).mkdir(parents=True, exist_ok=True)
-
-                primary_id = [
-                    id['value'] for id in pretty_dict["drugbank-id"] if id['primary'] == True][0]
-                with open(f'{save_path}/{primary_id}.json', 'w', encoding='utf-8') as f:
-                    json.dump(pretty_dict, f, ensure_ascii=False, indent=4)
-
-        print("Done")
-
-    def zip_files(self, chunk_size=1000, input_path='./drugbank/drugs', output_path='./drugbank/zips'):
-        zip_helper = ZipHelper()
-        zip_helper.zip(zip_prefix='drugs', input_path=input_path,
-                       output_path=output_path, chunk_size=chunk_size)
-

ddi_fw/drugbank/drugbank_processor.py

@@ -1,355 +0,0 @@
-import sqlite3
-import pandas as pd
-import os
-import json
-import glob
-from tqdm import tqdm
-
-import csv
-
-from rdkit import Chem
-from rdkit.Chem import AllChem
-import numpy as np
-from ddi_fw.drugbank.event_extractor import EventExtractor
-from ddi_fw.ner.ner import CTakesNER
-
-from ddi_fw.utils import ZipHelper
-# from event_extractor import EventExtractor
-
-
-def multiline_to_singleline(multiline):
-    if multiline is None:
-        return ""
-    return " ".join(line.strip() for line in multiline.splitlines())
-
-# targets -> target -> polypeptide
-# enzymes -> enzyme -> polypeptide
-# pathways from KEGG, KEGG ID is obtained from DrugBank
-# https://www.genome.jp/dbget-bin/www_bget?drug:D03136
-# https://www.kegg.jp/entry/D03136
-
-
-class DrugBankProcessor():
-
-    def mask_interaction(self, drug_1, drug_2, interaction):
-        return interaction.replace(
-            drug_1, "DRUG").replace(drug_2, "DRUG")
-
-    def extract_zip_files(self, input_path='zips', output_path='drugs', override=False):
-        if override:
-            zip_helper = ZipHelper()
-            zip_helper.extract(input_path=input_path, output_path=output_path)
-
-    def get_external_identifiers(self, input_path='drugs'):
-        external_identifier_list = []
-        all_json_files = input_path+'/*.json*'
-
-        for filepath in tqdm(glob.glob(all_json_files)):
-            with open(filepath, 'r', encoding="utf8") as f:
-
-                data = json.load(f)
-                drug_1 = data['name']
-                drug_1_id = [d['value']
-                             for d in data['drugbank-id'] if d['primary'] == True][0]
-                external_identifiers = data['external-identifiers'] if "external-identifiers" in data else None
-                external_identifiers_dict = {}
-                external_identifiers_dict['name'] = drug_1
-                external_identifiers_dict['drugbank_id'] = drug_1_id
-                if external_identifiers is not None:
-                    for p in external_identifiers['external-identifier']:
-                        external_identifiers_dict[p['resource'].lower().replace(
-                            " ", "_")] = p['identifier']
-                    # external_identifiers_dict = dict(
-                    #     [(p['resource'].lower().replace(" ","_"), p['identifier']) for p in external_identifiers['external-identifier']])
-                    # external_identifiers_dict['name'] = drug_1
-                    # external_identifiers_dict['drugbank_id'] = drug_1_id
-                external_identifier_list.append(external_identifiers_dict)
-        return external_identifier_list
-
-    def process(self,
-                ner_data_path,
-                input_path='drugs',
-                output_path='output',
-                save_as_sql=True,
-                db_path=r"./drugbank.db",
-                zip_outputs=True):
-        if not os.path.exists(output_path):
-            os.makedirs(output_path)
-        ner_df = CTakesNER().load(ner_data_path)
-        drugs_pickle_path = output_path+'/drugs.pkl'
-        drugs_csv_path = output_path+'/drugs.gzip'
-        ddi_pickle_path = output_path + '/ddi.pkl'
-        ddi_csv_path = output_path + '/ddi.gzip'
-
-        if not os.path.exists(drugs_pickle_path) or not os.path.exists(ddi_pickle_path):
-            drug_rows = []
-            all_ddis = []
-            external_identifier_list = []
-            all_json_files = input_path+'/*.json*'
-
-            for filepath in tqdm(glob.glob(all_json_files)):
-                with open(filepath, 'r', encoding="utf8") as f:
-
-                    data = json.load(f)
-
-                    # if data['drug-interactions'] is None:
-                    if False:
-                        continue
-                    else:
-                        drug_1 = data['name']
-                        drug_1_id = [d['value']
-                                     for d in data['drugbank-id'] if d['primary'] == True][0]
-                        description = multiline_to_singleline(
-                            data['description'])
-                        if data['drug-interactions'] is not None:
-                            drug_interactions = [
-                                interaction for interaction in data['drug-interactions']['drug-interaction']]
-                            ddis = [(drug_1, interaction['name'], interaction['description'])
-                                    for interaction in data['drug-interactions']['drug-interaction']]
-
-                            ddi_dict = [{
-                                'drug_1_id': drug_1_id,
-                                'drug_1': drug_1,
-                                'drug_2_id': interaction['drugbank-id']['value'],
-                                'drug_2': interaction['name'],
-                                'interaction': interaction['description'],
-                                'masked_interaction': self.mask_interaction(drug_1, interaction['name'], interaction['description'])}
-                                for interaction in data['drug-interactions']['drug-interaction']]
-                            all_ddis.extend(ddi_dict)
-
-                        synthesis_reference = data['synthesis-reference']
-                        indication = multiline_to_singleline(
-                            data['indication'])
-                        pharmacodynamics = multiline_to_singleline(
-                            data['pharmacodynamics'])
-                        mechanism_of_action = multiline_to_singleline(
-                            data['mechanism-of-action'])
-                        toxicity = multiline_to_singleline(data['toxicity'])
-                        metabolism = multiline_to_singleline(
-                            data['metabolism'])
-                        absorption = multiline_to_singleline(
-                            data['absorption'])
-                        half_life = multiline_to_singleline(data['half-life'])
-                        protein_binding = multiline_to_singleline(
-                            data['protein-binding'])
-                        route_of_elimination = multiline_to_singleline(
-                            data['route-of-elimination'])
-                        volume_of_distribution = multiline_to_singleline(
-                            data['volume-of-distribution'])
-                        clearance = multiline_to_singleline(data['clearance'])
-
-                        food_interactions = data['food-interactions']
-                        sequences = data['sequences'] if "sequences" in data else None
-
-                        external_identifiers = data['external-identifiers'] if "external-identifiers" in data else None
-                        experimental_properties = data['experimental-properties'] if "experimental-properties" in data else None
-                        calculated_properties = data['calculated-properties'] if "calculated-properties" in data else None
-
-                        enzymes_polypeptides = None
-                        targets_polypeptides = None
-                        pathways = None
-
-                        # targets = data['targets'] if "targets" in data else None
-                        if data['targets'] is not None:
-                            # targets_polypeptides = [p['id'] for d in data['targets']['target'] for p in d['polypeptide'] if 'polypeptide' in d ]
-                            targets_polypeptides = [
-                                p['id'] for d in data['targets']['target'] if 'polypeptide' in d for p in d['polypeptide']]
-
-                        if data['enzymes'] is not None:
-                            # enzymes_polypeptides = [p['id'] for d in data['enzymes']['enzyme'] for p in d['polypeptide'] if 'polypeptide' in d]
-                            enzymes_polypeptides = [
-                                p['id'] for d in data['enzymes']['enzyme'] if 'polypeptide' in d for p in d['polypeptide']]
-
-                        if data['pathways'] is not None:
-                            pathways = [
-                                d['smpdb-id'] for d in data['pathways']['pathway']]
-
-                        if external_identifiers is not None:
-                            external_identifiers_dict = dict(
-                                [(p['resource'], p['identifier']) for p in external_identifiers['external-identifier']])
-                            external_identifiers_dict['drugbank_id'] = drug_1_id
-                            external_identifier_list.append(
-                                external_identifiers_dict)
-# add note column
-                        smiles = None
-                        morgan_hashed = None
-                        if calculated_properties is not None:
-                            calculated_properties_dict = dict(
-                                [(p['kind'], p['value']) for p in calculated_properties['property']])
-                            smiles = calculated_properties_dict['SMILES'] if 'SMILES' in calculated_properties_dict else None
-                            if smiles is not None:
-                                try:
-                                    mol = Chem.MolFromSmiles(smiles)
-                                    morgan_hashed = AllChem.GetMorganFingerprintAsBitVect(
-                                        mol, 2, nBits=881).ToList()
-                                except:
-                                    print("An exception occurred")
-                        if morgan_hashed is None:
-                            morgan_hashed = np.zeros(881).tolist()
-
-                        # TODO cui, tui, entities other types of texts, test it
-                        tuis_description = ner_df[ner_df['drugbank_id']
-                                                  == drug_1_id]['tui_description'].values
-                        if len(tuis_description) > 0:
-                            tuis_description = tuis_description[0]
-                        else:
-                            tuis_description = None
-
-                        cuis_description = ner_df[ner_df['drugbank_id']
-                                                  == drug_1_id]['cui_description'].values
-                        if len(cuis_description) > 0:
-                            cuis_description = cuis_description[0]
-                        else:
-                            cuis_description = None
-
-                        entities_description = ner_df[ner_df['drugbank_id']
-                                                      == drug_1_id]['entities_description'].values
-                        if len(entities_description) > 0:
-                            entities_description = entities_description[0]
-                        else:
-                            entities_description = None
-
-                        # k = [p[k]  for p in calculated_properties['property'] for k in p.keys() if k =='SMILES']
-                        # external_identifiers['external-identifier']
-                        # experimental_properties['property']
-
-# list to single line reminder
-                        row = {'drugbank_id': drug_1_id,
-                               'name': drug_1,
-                               'description': description,
-                               'synthesis_reference': synthesis_reference,
-                               'indication': indication,
-                               'pharmacodynamics': pharmacodynamics,
-                               'mechanism_of_action': mechanism_of_action,
-                               'toxicity': toxicity,
-                               'metabolism': metabolism,
-                               'absorption': absorption,
-                               'half_life': half_life,
-                               'protein_binding': protein_binding,
-                               'route_of_elimination': route_of_elimination,
-                               'volume_of_distribution': volume_of_distribution,
-                               'clearance': clearance,
-                               'smiles': smiles,
-                               'smiles_morgan_fingerprint': ','.join(map(str, morgan_hashed)),
-                               'enzymes_polypeptides': '|'.join(enzymes_polypeptides) if enzymes_polypeptides is not None else None,
-                               'targets_polypeptides': '|'.join(targets_polypeptides) if targets_polypeptides is not None else None,
-                               'pathways': '|'.join(pathways) if pathways is not None else None,
-                               'tuis_description': '|'.join(tuis_description) if tuis_description is not None else None,
-                               'cuis_description': '|'.join(cuis_description) if cuis_description is not None else None,
-                               'entities_description': '|'.join(entities_description) if entities_description is not None else None
-                               #    'external_identifiers': external_identifiers_dict
-                               }
-                        drug_rows.append(row)
-
-                    # if len(drug_rows) == 10:
-                    #     break
-            # print(smiles_count)
-            print(f"Size of drugs {len(drug_rows)}")
-            print(f"Size of DDIs {len(all_ddis)}")
-            np.set_printoptions(threshold=np.inf)
-
-            # drug_names = [row['name'] for row in drug_rows]
-            drug_names = ['DRUG']
-            event_extractor = EventExtractor(drug_names)
-
-            replace_dict = {'MYO-029': 'Stamulumab'}
-            for ddi in tqdm(all_ddis):
-                for key, value in replace_dict.items():
-                    ddi['masked_interaction'] = ddi['masked_interaction'].replace(
-                        key, value)
-            #     interaction = ddi['interaction']
-            #     mechanism, action, drugA, drugB = event_extractor.extract(interaction)
-            #     ddi['mechanism'] = mechanism
-            #     ddi['action'] = action
-
-            self.drugs_df = pd.DataFrame(drug_rows)
-            # self.drugs_df.to_pickle(drugs_pickle_path)
-            # self.drugs_df.to_csv(
-            #     drugs_csv_path,  index=False, compression='gzip')
-
-            # print('mechanism_action calculation')
-            self.ddis_df = pd.DataFrame(all_ddis)
-
-            count = [0]
-
-            def fnc2(interaction, count):
-                count[0] = count[0] + 1
-                if count[0] % 1000 == 0:
-                    print(f'{count[0]}/{len(all_ddis)}')
-                mechanism, action, drugA, drugB = event_extractor.extract(
-                    interaction)
-                return mechanism+'__' + action
-
-            # self.ddis_df['mechanism_action'] = self.ddis_df['interaction'].apply(lambda x: fnc2(x))
-            # tqdm.pandas()
-            self.ddis_df['mechanism_action'] = self.ddis_df['masked_interaction'].apply(
-                fnc2, args=(count,))
-
-            # self.ddis_df.to_csv(ddi_csv_path,  index=False, compression='gzip')
-            # self.ddis_df.to_pickle(ddi_pickle_path)
-            zip_helper = ZipHelper()
-
-            if save_as_sql:
-                conn = sqlite3.connect(db_path)
-                self.drugs_df.to_sql(
-                    '_Drugs', conn, if_exists='replace', index=True)
-                self.ddis_df.to_sql('_Interactions', conn,
-                                    if_exists='replace', index=True)
-                ext_id_df = pd.DataFrame.from_records(external_identifier_list)
-                ext_id_df.to_sql('_ExternalIdentifiers', conn,
-                                 if_exists='replace', index=True)
-
-                zip_helper.zip_single_file(
-                    file_path=db_path, output_path=output_path+'/zips', name='db')
-                conn.close()
-
-            if zip_outputs:
-                zip_helper.zip_single_file(
-                    file_path=drugs_pickle_path, output_path=output_path+'/zips', name='drugs-pickle')
-                zip_helper.zip_single_file(
-                    file_path=ddi_pickle_path, output_path=output_path+'/zips', name='ddi-pickle')
-
-        else:
-            print('Output path has processed data, load function is called')
-            self.load(output_path)
-
-    def load(self, path):
-        drugs_pickle_path = path+'/drugs.pkl'
-        ddi_pickle_path = path+'/ddi.pkl'
-        if os.path.exists(drugs_pickle_path) and os.path.exists(ddi_pickle_path):
-            self.drugs_df = pd.read_pickle(drugs_pickle_path)
-            self.ddis_df = pd.read_pickle(ddi_pickle_path)
-        else:
-            print('One of given paths could not found')
-
-    def load_from_csv(self, path):
-        drugs_csv_path = path+'/drugs.gzip'
-        ddi_csv_path = path+'/ddi.gzip'
-        if os.path.exists(drugs_csv_path) and os.path.exists(ddi_csv_path):
-            self.drugs_df = pd.read_csv(drugs_csv_path, compression='gzip')
-            self.ddis_df = pd.read_csv(ddi_csv_path, compression='gzip')
-        else:
-            print('One of given paths could not found')
-
-    def load2(self, path):
-        drugs_pickle_path = path+'/drugs.pkl'
-        ddi_csv_path = path+'/ddi.gzip'
-        if os.path.exists(drugs_pickle_path) and os.path.exists(ddi_csv_path):
-            self.drugs_df = pd.read_pickle(drugs_pickle_path)
-            self.ddis_df = pd.read_csv(ddi_csv_path, compression='gzip')
-        else:
-            print('One of given paths could not found')
-
-    def drugs_as_dataframe(self):
-        return self.drugs_df
-
-    def filtered_drugs_as_dataframe(self, drug_ids):
-        return self.drugs_df[self.drugs_df['drugbank_id'].isin(drug_ids)]
-
-    def ddis_as_dataframe(self):
-        return self.ddis_df
-
-    def filtered_ddis(self, drugs):
-        ddis_df = self.ddis_df.copy()
-        return ddis_df[(ddis_df['drug_1'] in drugs) & (
-            ddis_df['drug_2'] in drugs)]