Datasets:

f-galkin
/

batman2

@@ -1,549 +1,546 @@
-import pandas as pd
-import pickle
-from typing import List, Dict, Optional
-from copy import copy as cp
-import json
-from abc import ABC, abstractmethod
-class TCMEntity(ABC):
-    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')

+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')