import pandas as pd import pickle from typing import List, Dict, Optional from copy import copy as cp import json class TCMEntity(): empty_override = True desc = '' cid = -1 entity = 'superclass' def __init__(self, pref_name: str, desc: str = '', synonyms: Optional[List[str]] = None, **kwargs): self.pref_name = pref_name self.desc = desc self.synonyms = [] if synonyms is None else [x for x in synonyms if str(x).strip() != 'NA'] self.targets = {"known": dict(), "predicted": dict()} self.formulas = [] self.herbs = [] self.ingrs = [] for k, v in kwargs.items(): self.__dict__[k] = v def serialize(self): init_dict = dict( cid=self.cid, targets_known=self.targets['known'], targets_pred=self.targets['predicted'], pref_name=self.pref_name, desc=self.desc, synonyms=cp(self.synonyms), entity=self.entity ) link_dict = self._get_link_dict() out_dict = {"init": init_dict, "links": link_dict} return out_dict @classmethod def load(cls, db: 'TCMDB', ser_dict: dict, skip_links = True): init_args = ser_dict['init'] if skip_links: init_args.update({"empty_override":True}) else: init_args.update({"empty_override": False}) new_entity = cls(**init_args) if not skip_links: links = ser_dict['links'] new_entity._set_links(db, links) return (new_entity) def _get_link_dict(self): return dict( ingrs=[x.cid for x in self.ingrs], herbs=[x.pref_name for x in self.herbs], formulas=[x.pref_name for x in self.formulas] ) def _set_links(self, db: 'TCMDB', links: dict): for ent_type in links: self.__dict__[ent_type] = [db.__dict__[ent_type].get(x) for x in links[ent_type]] self.__dict__[ent_type] = [x for x in self.__dict__[ent_type] if x is not None] class Ingredient(TCMEntity): entity: str = 'ingredient' def __init__(self, cid: int, targets_pred: Optional[Dict] = None, targets_known: Optional[Dict] = None, synonyms: Optional[List[str]] = None, pref_name: str = '', desc: str = '', empty_override: bool = True, **kwargs): if not empty_override: assert targets_known is not None or targets_pred is not None, \ f"Cant submit a compound with no targets at all (CID:{cid})" super().__init__(pref_name, synonyms, desc, **kwargs) self.cid = cid self.targets = { 'known': targets_known if targets_known is not None else {"symbols": [], 'entrez_ids': []}, 'predicted': targets_pred if targets_pred is not None else {"symbols": [], 'entrez_ids': []} } class Herb(TCMEntity): entity: str = 'herb' def __init__(self, pref_name: str, ingrs: Optional[List[Ingredient]] = None, synonyms: Optional[List[str]] = None, desc: str = '', empty_override: bool = True, **kwargs): if ingrs is None: ingrs = [] if not ingrs and not empty_override: raise ValueError(f"No ingredients provided for {pref_name}") super().__init__(pref_name, synonyms, desc, **kwargs) self.ingrs = ingrs def is_same(self, other: 'Herb') -> bool: if len(self.ingrs) != len(other.ingrs): return False this_ingrs = set(x.cid for x in self.ingrs) other_ingrs = set(x.cid for x in other.ingrs) return this_ingrs == other_ingrs class Formula(TCMEntity): entity: str = 'formula' def __init__(self, pref_name: str, herbs: Optional[List[Herb]] = None, synonyms: Optional[List[str]] = None, desc: str = '', empty_override: bool = False, **kwargs): if herbs is None: herbs = [] if not herbs and not empty_override: raise ValueError(f"No herbs provided for {pref_name}") super().__init__(pref_name, synonyms, desc, **kwargs) self.herbs = herbs def is_same(self, other: 'Formula') -> bool: if len(self.herbs) != len(other.herbs): return False this_herbs = set(x.pref_name for x in self.herbs) other_herbs = set(x.pref_name for x in other.herbs) return this_herbs == other_herbs class TCMDB: hf_repo: str = "f-galkin/batman2" hf_subsets: Dict[str, str] = {'formulas': 'batman_formulas', 'herbs': 'batman_herbs', 'ingredients': 'batman_ingredients'} def __init__(self, p_batman: str): p_batman = p_batman.removesuffix("/") + "/" self.batman_files = dict(p_formulas='formula_browse.txt', p_herbs='herb_browse.txt', p_pred_by_tg='predicted_browse_by_targets.txt', p_known_by_tg='known_browse_by_targets.txt', p_pred_by_ingr='predicted_browse_by_ingredinets.txt', p_known_by_ingr='known_browse_by_ingredients.txt') self.batman_files = {x: p_batman + y for x, y in self.batman_files.items()} self.ingrs = None self.herbs = None self.formulas = None @classmethod def make_new_db(cls, p_batman: str): new_db = cls(p_batman) new_db.parse_ingredients() new_db.parse_herbs() new_db.parse_formulas() return (new_db) def parse_ingredients(self): pred_tgs = pd.read_csv(self.batman_files['p_pred_by_tg'], sep='\t', index_col=None, header=0, na_filter=False) known_tgs = pd.read_csv(self.batman_files['p_known_by_tg'], sep='\t', index_col=None, header=0, na_filter=False) entrez_to_symb = {int(pred_tgs.loc[x, 'entrez_gene_id']): pred_tgs.loc[x, 'entrez_gene_symbol'] for x in pred_tgs.index} # 9927 gene targets entrez_to_symb.update({int(known_tgs.loc[x, 'entrez_gene_id']): \ known_tgs.loc[x, 'entrez_gene_symbol'] for x in known_tgs.index}) known_ingreds = pd.read_csv(self.batman_files['p_known_by_ingr'], index_col=0, header=0, sep='\t', na_filter=False) # this BATMAN table is badly formatted # you cant just read it # df_pred = pd.read_csv(p_pred, index_col=0, header=0, sep='\t') pred_ingreds = dict() with open(self.batman_files['p_pred_by_ingr'], 'r') as f: # skip header f.readline() newline = f.readline() while newline != '': cid, other_line = newline.split(' ', 1) name, entrez_ids = other_line.rsplit(' ', 1) entrez_ids = [int(x.split("(")[0]) for x in entrez_ids.split("|") if not x == "\n"] pred_ingreds[int(cid)] = {"targets": entrez_ids, 'name': name} newline = f.readline() all_BATMAN_CIDs = list(set(pred_ingreds.keys()) | set(known_ingreds.index)) all_BATMAN_CIDs = [int(x) for x in all_BATMAN_CIDs if str(x).strip() != 'NA'] # get targets for selected cpds ingredients = dict() for cid in all_BATMAN_CIDs: known_name, pred_name, synonyms = None, None, [] if cid in known_ingreds.index: known_name = known_ingreds.loc[cid, 'IUPAC_name'] known_symbs = known_ingreds.loc[cid, 'known_target_proteins'].split("|") else: known_symbs = [] pred_ids = pred_ingreds.get(cid, []) if pred_ids: pred_name = pred_ids.get('name') if known_name is None: cpd_name = pred_name elif known_name != pred_name: cpd_name = min([known_name, pred_name], key=lambda x: sum([x.count(y) for y in "'()-[]1234567890"])) synonyms = [x for x in [known_name, pred_name] if x != cpd_name] pred_ids = pred_ids.get('targets', []) ingredients[cid] = dict(pref_name=cpd_name, synonyms=synonyms, targets_known={"symbols": known_symbs, "entrez_ids": [int(x) for x, y in entrez_to_symb.items() if y in known_symbs]}, targets_pred={"symbols": [entrez_to_symb.get(x) for x in pred_ids], "entrez_ids": pred_ids}) ingredients_objs = {x: Ingredient(cid=x, **y) for x, y in ingredients.items()} self.ingrs = ingredients_objs def parse_herbs(self): if self.ingrs is None: raise ValueError("Herbs cannot be added before the ingredients") # load the herbs file name_cols = ['Pinyin.Name', 'Chinese.Name', 'English.Name', 'Latin.Name'] herbs_df = pd.read_csv(self.batman_files['p_herbs'], index_col=None, header=0, sep='\t', na_filter=False) for i in herbs_df.index: herb_name = herbs_df.loc[i, 'Pinyin.Name'].strip() if herb_name == 'NA': herb_name = [x.strip() for x in herbs_df.loc[i, name_cols].tolist() if not x == 'NA'] herb_name = [x for x in herb_name if x != ''] if not herb_name: raise ValueError(f"LINE {i}: provided a herb with no names") else: herb_name = herb_name[-1] herb_cids = herbs_df.loc[i, 'Ingredients'].split("|") herb_cids = [x.split("(")[-1].removesuffix(")").strip() for x in herb_cids] herb_cids = [int(x) for x in herb_cids if x.isnumeric()] missed_ingrs = [x for x in herb_cids if self.ingrs.get(x) is None] for cid in missed_ingrs: self.add_ingredient(cid=int(cid), pref_name='', empty_override=True) herb_ingrs = [self.ingrs[int(x)] for x in herb_cids] self.add_herb(pref_name=herb_name, ingrs=herb_ingrs, synonyms=[x for x in herbs_df.loc[i, name_cols].tolist() if not x == "NA"], empty_override=True) def parse_formulas(self): if self.herbs is None: raise ValueError("Formulas cannot be added before the herbs") formulas_df = pd.read_csv(self.batman_files['p_formulas'], index_col=None, header=0, sep='\t', na_filter=False) for i in formulas_df.index: composition = formulas_df.loc[i, 'Pinyin.composition'].split(",") composition = [x.strip() for x in composition if not x.strip() == 'NA'] if not composition: continue missed_herbs = [x.strip() for x in composition if self.herbs.get(x) is None] for herb in missed_herbs: self.add_herb(pref_name=herb, desc='Missing in the original herb catalog, but present among formula components', ingrs=[], empty_override=True) formula_herbs = [self.herbs[x] for x in composition] self.add_formula(pref_name=formulas_df.loc[i, 'Pinyin.Name'].strip(), synonyms=[formulas_df.loc[i, 'Chinese.Name']], herbs=formula_herbs) def add_ingredient(self, **kwargs): if self.ingrs is None: self.ingrs = dict() new_ingr = Ingredient(**kwargs) if not new_ingr.cid in self.ingrs: self.ingrs.update({new_ingr.cid: new_ingr}) def add_herb(self, **kwargs): if self.herbs is None: self.herbs = dict() new_herb = Herb(**kwargs) old_herb = self.herbs.get(new_herb.pref_name) if not old_herb is None: if_same = new_herb.is_same(old_herb) if if_same: return same_name = new_herb.pref_name all_dupes = [self.herbs[x] for x in self.herbs if x.split('~')[0] == same_name] + [new_herb] new_names = [same_name + f"~{x + 1}" for x in range(len(all_dupes))] for i, duped in enumerate(all_dupes): duped.pref_name = new_names[i] self.herbs.pop(same_name) self.herbs.update({x.pref_name: x for x in all_dupes}) else: self.herbs.update({new_herb.pref_name: new_herb}) for cpd in new_herb.ingrs: cpd_herbs = [x.pref_name for x in cpd.herbs] if not new_herb.pref_name in cpd_herbs: cpd.herbs.append(new_herb) def add_formula(self, **kwargs): if self.formulas is None: self.formulas = dict() new_formula = Formula(**kwargs) old_formula = self.formulas.get(new_formula.pref_name) if not old_formula is None: is_same = new_formula.is_same(old_formula) if is_same: return same_name = new_formula.pref_name all_dupes = [self.formulas[x] for x in self.formulas if x.split('~')[0] == same_name] + [new_formula] new_names = [same_name + f"~{x + 1}" for x in range(len(all_dupes))] for i, duped in enumerate(all_dupes): duped.pref_name = new_names[i] self.formulas.pop(same_name) self.formulas.update({x.pref_name: x for x in all_dupes}) else: self.formulas.update({new_formula.pref_name: new_formula}) for herb in new_formula.herbs: herb_formulas = [x.pref_name for x in herb.formulas] if not new_formula.pref_name in herb_formulas: herb.formulas.append(new_formula) def link_ingredients_n_formulas(self): for h in self.herbs.values(): for i in h.ingrs: fla_names = set(x.pref_name for x in i.formulas) i.formulas += [x for x in h.formulas if not x.pref_name in fla_names] for f in h.formulas: ingr_cids = set(x.cid for x in f.ingrs) f.ingrs += [x for x in h.ingrs if not x.cid in ingr_cids] def serialize(self): out_dict = dict( ingredients={cid: ingr.serialize() for cid, ingr in self.ingrs.items()}, herbs={name: herb.serialize() for name, herb in self.herbs.items()}, formulas={name: formula.serialize() for name, formula in self.formulas.items()} ) return (out_dict) def save_to_flat_json(self, p_out: str): ser_db = db.serialize() flat_db = dict() for ent_type in ser_db: for i, obj in ser_db[ent_type].items(): flat_db[f"{ent_type}:{i}"] = obj with open(p_out, "w") as f: f.write(json.dumps(flat_db)) def save_to_json(self, p_out: str): with open(p_out, "w") as f: json.dump(self.serialize(), f) @classmethod def load(cls, ser_dict: dict): db = cls(p_batman="") # make sure to create all entities before you link them together db.ingrs = {int(cid): Ingredient.load(db, ingr, skip_links=True) for cid, ingr in ser_dict['ingredients'].items()} db.herbs = {name: Herb.load(db, herb, skip_links=True) for name, herb in ser_dict['herbs'].items()} db.formulas = {name: Formula.load(db, formula, skip_links=True) for name, formula in ser_dict['formulas'].items()} # now set the links for i in db.ingrs.values(): # NB: somehow gotta make it work w/out relying on str-int conversion i._set_links(db, ser_dict['ingredients'][str(i.cid)]['links']) for h in db.herbs.values(): h._set_links(db, ser_dict['herbs'][h.pref_name]['links']) for f in db.formulas.values(): f._set_links(db, ser_dict['formulas'][f.pref_name]['links']) return (db) @classmethod def read_from_json(cls, p_file: str): with open(p_file, "r") as f: json_db = json.load(f) db = cls.load(json_db) return (db) @classmethod def download_from_hf(cls): from datasets import load_dataset dsets = {x: load_dataset(cls.hf_repo, y) for x, y in cls.hf_subsets.items()} # speed this up somehow known_tgs = {str(x['cid']): [y.split("(") for y in eval(x['targets_known'])] for x in dsets['ingredients']['train']} known_tgs = {x:{'symbols':[z[0] for z in y], "entrez_ids":[int(z[1].strip(")")) for z in y]} for x,y in known_tgs.items()} pred_tgs = {str(x['cid']): [y.split("(") for y in eval(x['targets_pred'])] for x in dsets['ingredients']['train']} pred_tgs = {x:{'symbols':[z[0] for z in y], "entrez_ids":[int(z[1].strip(")")) for z in y]} for x,y in pred_tgs.items()} json_db = dict() json_db['ingredients'] = {str(x['cid']): {'init': dict(cid=int(x['cid']), targets_known=known_tgs[str(x['cid'])], targets_pred=pred_tgs[str(x['cid'])], pref_name=x['pref_name'], synonyms=eval(x['synonyms']), desc=x['description'] ), 'links': dict( herbs=eval(x['herbs']), formulas=eval(x['formulas']) ) } for x in dsets['ingredients']['train']} json_db['herbs'] = {x['pref_name']: {'init': dict(pref_name=x['pref_name'], synonyms=eval(x['synonyms']), desc=x['description']), 'links': dict(ingrs=eval(x['ingredients']), formulas=eval(x['formulas']))} for x in dsets['herbs']['train']} json_db['formulas'] = {x['pref_name']: {'init': dict(pref_name=x['pref_name'], synonyms=eval(x['synonyms']), desc=x['description']), 'links': dict(ingrs=eval(x['ingredients']), herbs=eval(x['herbs']))} for x in dsets['formulas']['train']} db = cls.load(json_db) return (db) def drop_isolated(self, how='any'): match how: case 'any': self.herbs = {x: y for x, y in self.herbs.items() if (y.ingrs and y.formulas)} self.formulas = {x: y for x, y in self.formulas.items() if (y.ingrs and y.herbs)} self.ingrs = {x: y for x, y in self.ingrs.items() if (y.formulas and y.herbs)} case 'all': self.herbs = {x: y for x, y in self.herbs.items() if (y.ingrs or y.formulas)} self.formulas = {x: y for x, y in self.formulas.items() if (y.ingrs or y.herbs)} self.ingrs = {x: y for x, y in self.ingrs.items() if (y.formulas or y.herbs)} case _: raise ValueError(f'Unknown how parameter: {how}. Known parameters are "any" and "all"') def select_formula_by_cpd(self, cids: List): cids = set(x for x in cids if x in self.ingrs) if not cids: return cpd_counts = {x: len(set([z.cid for z in y.ingrs]) & cids) for x, y in self.formulas.items()} n_max = max(cpd_counts.values()) if n_max == 0: return (n_max, []) selected = [x for x, y in cpd_counts.items() if y == n_max] return (n_max, selected) def pick_formula_by_cpd(self, cids: List): cids = [x for x in cids if x in self.ingrs] if not cids: return raise NotImplementedError() def select_formula_by_herb(self, herbs: List): raise NotImplementedError() def pick_formula_by_herb(self, herbs: List): raise NotImplementedError() def main(ab_initio=False, p_BATMAN="./BATMAN/", fname='BATMAN_DB.json'): p_BATMAN = p_BATMAN.removesuffix("/") + "/" # Use in case you want to recreate the TCMDB database of Chinese medicine from BATMAN files if ab_initio: db = TCMDB.make_new_db(p_BATMAN) db.link_ingredients_n_formulas() db.save_to_json(p_BATMAN + fname) # db.save_to_json('../TCM screening/BATMAN_DB.json') else: db = TCMDB.read_from_json('../TCM screening/BATMAN_DB.json') # db = TCMDB.read_from_json(p_BATMAN + fname) cids = [969516, # curcumin 445154, # resveratrol 5280343, # quercetin 6167, # colchicine 5280443, # apigening 65064, # EGCG3 5757, # estradiol 5994, # progesterone 5280863, # kaempferol 107985, # triptolide 14985, # alpha-tocopherol 1548943, # Capsaicin 64982, # Baicalin 6013, # Testosterone ] p3_formula = db.select_formula_by_cpd(cids) # somehow save file if needed ↓ ser_db = db.serialize() ### if __name__ == '__main__': main(ab_initio=True, p_BATMAN="./BATMAN/", fname='BATMAN_DB.json')