rcsb.exdb 1.31__py3-none-any.whl

rcsb/__init__.py

@@ -0,0 +1 @@
+__path__ = __import__("pkgutil").extend_path(__path__, __name__)

rcsb/exdb/__init__.py

@@ -0,0 +1 @@
+__path__ = __import__("pkgutil").extend_path(__path__, __name__)

rcsb/exdb/branch/BranchedEntityExtractor.py

@@ -0,0 +1,82 @@
+##
+# File: BranchedEntityExtractor.py
+# Date: 24-May-2021  jdw
+#
+# Utilities to extract selected details from the core branched entity collections.
+#
+#
+# Updates:
+#
+##
+__docformat__ = "google en"
+__author__ = "John Westbrook"
+__email__ = "jwest@rcsb.rutgers.edu"
+__license__ = "Apache 2.0"
+
+import logging
+
+from rcsb.exdb.utils.ObjectExtractor import ObjectExtractor
+from rcsb.utils.io.MarshalUtil import MarshalUtil
+
+logger = logging.getLogger(__name__)
+
+
+class BranchedEntityExtractor(object):
+    """Utilities to extract selected details from the core branched entity collections."""
+
+    def __init__(self, cfgOb):
+        self.__cfgOb = cfgOb
+
+    def exportBranchedEntityDetails(self, filePath, fmt="json"):
+        """Export branched entity details (BIRD mapping and WURCS descriptors)"""
+        rD = self.getBranchedDetails()
+        # ----
+        mU = MarshalUtil()
+        ok = mU.doExport(filePath, rD, fmt=fmt, indent=3)
+        logger.info("Exporting (%d) branched entities status %r", len(rD), ok)
+        return ok
+
+    def getBranchedDetails(self):
+        """Get branched entity details (BIRD mapping and WURCS descriptors)"""
+        rD = {}
+        try:
+
+            #
+            obEx = ObjectExtractor(
+                self.__cfgOb,
+                databaseName="pdbx_core",
+                collectionName="pdbx_core_branched_entity",
+                useCache=False,
+                keyAttribute="entity",
+                uniqueAttributes=["rcsb_id"],
+                selectionQuery={},
+                selectionList=["rcsb_id", "pdbx_entity_branch_descriptor", "rcsb_branched_entity_container_identifiers"],
+            )
+            #
+            # eCount = obEx.getCount()
+            # logger.info("Branched entity count is %d", eCount)
+            objD = obEx.getObjects()
+            rD = {}
+            for _, eD in objD.items():
+                rcsbId = eD["rcsb_id"]
+                #
+                prdId = None
+                try:
+                    pD = eD["rcsb_branched_entity_container_identifiers"]
+                    prdId = pD["prd_id"]
+                except Exception:
+                    pass
+                #
+                wurcs = None
+                try:
+                    for tD in eD["pdbx_entity_branch_descriptor"]:
+                        if tD["type"] == "WURCS":
+                            wurcs = tD["descriptor"]
+                except Exception:
+                    pass
+                if prdId or wurcs:
+                    rD[rcsbId] = {"prdId": prdId, "wurcs": wurcs}
+
+        except Exception as e:
+            logger.exception("Failing with %s", str(e))
+        return rD

rcsb/exdb/branch/GlycanProvider.py

@@ -0,0 +1,116 @@
+##
+#  File:           GlycanProvider.py
+#  Date:           24-May-2021 jdw
+#
+#  Updated:
+#
+##
+"""
+Accessors for glycan mapped annotations.
+
+"""
+
+import logging
+import os.path
+import time
+
+from rcsb.exdb.branch.GlycanUtils import GlycanUtils
+from rcsb.utils.io.MarshalUtil import MarshalUtil
+from rcsb.utils.io.StashableBase import StashableBase
+
+logger = logging.getLogger(__name__)
+
+
+class GlycanProvider(StashableBase):
+    """Accessors and generators for entity glycan mapped identifiers.
+
+    dirPath -> CACHE/glycan/
+                             branched_entity_glycan_identifier_map.json
+                             accession-wurcs-mapping.json
+                     stash/entity_glycan_mapped_identifiers.tar.gz
+
+    """
+
+    def __init__(self, **kwargs):
+        #
+        self.__version = "0.50"
+        cachePath = kwargs.get("cachePath", ".")
+        useCache = kwargs.get("useCache", True)
+        self.__dirName = "glycan"
+        self.__dirPath = os.path.join(cachePath, self.__dirName)
+        super(GlycanProvider, self).__init__(cachePath, [self.__dirName])
+        #
+        self.__mU = MarshalUtil(workPath=self.__dirPath)
+        self.__glyD = self.__reload(fmt="json", useCache=useCache)
+        #
+
+    def testCache(self, minCount=1):
+        if minCount == 0:
+            return True
+        if self.__glyD and minCount and ("identifiers" in self.__glyD) and len(self.__glyD["identifiers"]) >= minCount:
+            logger.info("Glycan identifiers (%d)", len(self.__glyD["identifiers"]))
+            return True
+        return False
+
+    def getIdentifiers(self):
+        """Return a dictionary of related identifiers organized by branched entity id.
+
+        Returns:
+            (dict): {entityId: {'idType1': ids, 'idType1': ids}, ... }
+        """
+        try:
+            return self.__glyD["identifiers"] if self.__glyD["identifiers"] else {}
+        except Exception as e:
+            logger.error("Failing with %r", str(e))
+        return {}
+
+    def __getMappingFilePath(self, fmt="json"):
+        baseFileName = "branched_entity_glycan_identifier_map"
+        fExt = ".json" if fmt == "json" else ".pic"
+        fp = os.path.join(self.__dirPath, baseFileName + fExt)
+        return fp
+
+    def update(self, cfgOb, fmt="json", indent=3):
+        """Update branched entity glycan accession mapping cache.
+
+        Args:
+            cfgObj (object): ConfigInfo() object instance
+
+        Returns:
+            (bool): True for success for False otherwise
+        """
+        ok = False
+        try:
+            gU = GlycanUtils(cfgOb, self.__dirPath)
+            eaD = gU.updateEntityAccessionMap()
+            logger.info("Got branched entity glycan accession map (%d)", len(eaD))
+            #
+            tS = time.strftime("%Y %m %d %H:%M:%S", time.localtime())
+            self.__glyD = {"version": self.__version, "created": tS, "identifiers": eaD}
+            #
+            mappingFilePath = self.__getMappingFilePath(fmt=fmt)
+            kwargs = {"indent": indent} if fmt == "json" else {}
+            ok = self.__mU.doExport(mappingFilePath, self.__glyD, fmt=fmt, **kwargs)
+        except Exception as e:
+            logger.exception("Failing with %s", str(e))
+        return ok
+
+    def reload(self):
+        """Reload from the current cache file."""
+        ok = False
+        try:
+            self.__glyD = self.__reload(fmt="json", useCache=True)
+            ok = self.__glyD is not None
+        except Exception as e:
+            logger.exception("Failing with %s", str(e))
+        return ok
+
+    def __reload(self, fmt="json", useCache=True):
+        mappingFilePath = self.__getMappingFilePath(fmt=fmt)
+        tS = time.strftime("%Y %m %d %H:%M:%S", time.localtime())
+        pcD = {"version": self.__version, "created": tS, "identifiers": {}}
+
+        if useCache and self.__mU.exists(mappingFilePath):
+            logger.info("reading cached path %r", mappingFilePath)
+            pcD = self.__mU.doImport(mappingFilePath, fmt=fmt)
+        return pcD

rcsb/exdb/branch/GlycanUtils.py

@@ -0,0 +1,114 @@
+##
+#  File:           GlycanUtils.py
+#  Date:           24-May-2021 jdw
+#
+#  Updated:
+##
+"""
+Utilities for fetching and mapping glycan accessions.
+"""
+
+import logging
+import os.path
+
+from rcsb.exdb.branch.BranchedEntityExtractor import BranchedEntityExtractor
+from rcsb.utils.io.MarshalUtil import MarshalUtil
+from rcsb.utils.io.UrlRequestUtil import UrlRequestUtil
+
+logger = logging.getLogger(__name__)
+
+
+class GlycanUtils:
+    """Utilities for fetching and mapping glycan annotations."""
+
+    def __init__(self, cfgOb, dirPath):
+        self.__cfgOb = cfgOb
+        self.__dirPath = dirPath
+        self.__mU = MarshalUtil(workPath=self.__dirPath)
+        #
+
+    def __getRawGlycanDetailsPath(self):
+        return os.path.join(self.__dirPath, "pdb-raw-branched-entity-details.json")
+
+    def getBranchedEntityDetails(self):
+        """For branched entities, get BIRD mapping and WURCS details"""
+        ok = False
+        try:
+            bEx = BranchedEntityExtractor(self.__cfgOb)
+            branchedEntityD = bEx.getBranchedDetails()
+            logger.info("Branched entity descriptor details count %d", len(branchedEntityD))
+            detailsPath = self.__getRawGlycanDetailsPath()
+            ok = bEx.exportBranchedEntityDetails(detailsPath, fmt="json")
+            logger.info("Store raw branched entity data (%r) %s", ok, detailsPath)
+        except Exception as e:
+            logger.exception("Failing with %s", str(e))
+        #
+        return branchedEntityD
+
+    def __getGlycanAccessionMapPath(self):
+        return os.path.join(self.__dirPath, "accession-wurcs-mapping.json")
+
+    def fetchGlycanAccessionMap(self):
+        mapD = {}
+        accessionMapPath = self.__getGlycanAccessionMapPath()
+        if self.__mU.exists(accessionMapPath):
+            mapD = self.__mU.doImport(accessionMapPath, fmt="json")
+        return mapD
+
+    def storeGlycanAccessionMap(self, mapD):
+        accessionMapPath = self.__getGlycanAccessionMapPath()
+        ok = self.__mU.doExport(accessionMapPath, mapD, fmt="json", indent=3)
+        return ok
+
+    def updateEntityAccessionMap(self):
+        """Update entity to glycan accession mapping
+
+        Returns:
+            dict: {entityId: {'glyTouCanId':... , 'prdId': ..., }, ... }
+        """
+        entityAccessionMapD = {}
+        wurcsTupL = []
+        uniqueWurcsD = {}
+        accessionMapD = self.fetchGlycanAccessionMap()
+        branchedEntityD = self.getBranchedEntityDetails()
+        for entityId, iD in branchedEntityD.items():
+            if iD["wurcs"] and iD["wurcs"] not in accessionMapD and iD["wurcs"] not in uniqueWurcsD:
+                wurcsTupL.append((entityId, iD["wurcs"]))
+                uniqueWurcsD.setdefault(iD["wurcs"], []).append(entityId)
+        if wurcsTupL:
+            tMap = self.getAccessionMapping(wurcsTupL)
+            accessionMapD.update(tMap)
+            self.storeGlycanAccessionMap(accessionMapD)
+        #
+
+        for entityId, iD in branchedEntityD.items():
+            if iD["wurcs"] in accessionMapD:
+                prdId = iD["prdId"] if iD["wurcs"] else None
+                entityAccessionMapD[entityId] = {"glyTouCanId": accessionMapD[iD["wurcs"]][0], "prdId": prdId}
+        return entityAccessionMapD
+
+    def getAccessionMapping(self, wurcsTupL):
+        """Fetch GlyTouCan accessions for the input WURCS desriptor list"""
+        accessionMapD = {}
+        logger.info("Fetching (%d) WURCS descriptors", len(wurcsTupL))
+        baseUrl = "https://api.glycosmos.org"
+        endPoint = "glytoucan/sparql/wurcs2gtcids"
+        numDescriptors = len(wurcsTupL)
+        for ii, (entityId, wurcs) in enumerate(wurcsTupL, 1):
+            try:
+                pD = {}
+                pD["wurcs"] = wurcs
+                uR = UrlRequestUtil()
+                rDL, retCode = uR.post(baseUrl, endPoint, pD, returnContentType="JSON")
+                logger.debug(" %r wurcs fetch result (%r) %r", entityId, retCode, rDL)
+                if rDL:
+                    for rD in rDL:
+                        if "id" in rD:
+                            accessionMapD.setdefault(wurcs, []).append(rD["id"])
+                        else:
+                            logger.info("%r fetch fails (%r) (%r) %r", entityId, retCode, wurcs, rDL)
+                if ii % 5 == 0:
+                    logger.info("Fetched %d/%d", ii, numDescriptors)
+            except Exception as e:
+                logger.exception("Failing for (%r) wurcs (%r) with %s", entityId, wurcs, str(e))
+        return accessionMapD

rcsb/exdb/chemref/ChemRefEtlWorker.py

@@ -0,0 +1,118 @@
+##
+# File: ChemRefEtlWorker.py
+# Date: 2-Jul-2018  jdw
+#
+# ETL utilities for processing chemical reference data and related data integration.
+#
+# Updates:
+#  9-Dec-2018  jdw add validation methods
+#  3-Sep-2019  jdw move to rcsb.exdb.chemref
+#  7-Aug-2025  dwp change target DB and collection from "drugbank_core" to "dw" and "core_drugbank" (as part of transition to DW);
+#                  make use of configuration file for loading drugbank collection and setting indexed fields
+#
+##
+__docformat__ = "google en"
+__author__ = "John Westbrook"
+__email__ = "jwest@rcsb.rutgers.edu"
+__license__ = "Apache 2.0"
+
+import logging
+
+from rcsb.db.mongo.DocumentLoader import DocumentLoader
+from rcsb.db.processors.DataExchangeStatus import DataExchangeStatus
+from rcsb.db.utils.SchemaProvider import SchemaProvider
+from rcsb.exdb.chemref.ChemRefExtractor import ChemRefExtractor
+from rcsb.utils.chemref.DrugBankProvider import DrugBankProvider
+
+
+logger = logging.getLogger(__name__)
+
+
+class ChemRefEtlWorker(object):
+    """Prepare and load chemical reference data collections."""
+
+    def __init__(self, cfgOb, cachePath, useCache=True, numProc=2, chunkSize=10, maxStepLength=2000, readBackCheck=False, documentLimit=None, verbose=False):
+        self.__cfgOb = cfgOb
+        self.__cachePath = cachePath
+        self.__useCache = useCache
+        self.__readBackCheck = readBackCheck
+        self.__numProc = numProc
+        self.__chunkSize = chunkSize
+        self.__maxStepLength = maxStepLength
+        self.__documentLimit = documentLimit
+        #
+        self.__resourceName = "MONGO_DB"
+        self.__verbose = verbose
+        self.__statusList = []
+        self.__schP = SchemaProvider(self.__cfgOb, self.__cachePath, useCache=self.__useCache)
+        #
+
+    def __updateStatus(self, updateId, databaseName, collectionName, status, startTimestamp):
+        try:
+            sFlag = "Y" if status else "N"
+            desp = DataExchangeStatus()
+            desp.setStartTime(tS=startTimestamp)
+            desp.setObject(databaseName, collectionName)
+            desp.setStatus(updateId=updateId, successFlag=sFlag)
+            desp.setEndTime()
+            self.__statusList.append(desp.getStatus())
+            return True
+        except Exception as e:
+            logger.exception("Failing with %s", str(e))
+        return False
+
+    def load(self, updateId, extResource, loadType="full"):
+        """Load chemical reference integrated data for the input external resource-"""
+        try:
+            self.__statusList = []
+            desp = DataExchangeStatus()
+            statusStartTimestamp = desp.setStartTime()
+            addValues = {}
+            collectionGroupName = "core_drugbank"
+            #
+            if extResource == "DrugBank":
+                databaseNameMongo = self.__schP.getDatabaseMongoName(collectionGroupName=collectionGroupName)
+                configName = self.__cfgOb.getDefaultSectionName()
+                user = self.__cfgOb.get("_DRUGBANK_AUTH_USERNAME", sectionName=configName)
+                pw = self.__cfgOb.get("_DRUGBANK_AUTH_PASSWORD", sectionName=configName)
+                #
+                dbP = DrugBankProvider(cachePath=self.__cachePath, useCache=self.__useCache, username=user, password=pw)
+                #
+                crExt = ChemRefExtractor(self.__cfgOb)
+                idD = crExt.getChemCompAccessionMapping(extResource)
+                dList = dbP.getDocuments(mapD=idD)
+                #
+                logger.info("Resource %r extracted mapped document length %d", extResource, len(dList))
+                logger.debug("Objects %r", dList[:2])
+                _, _, collectionList, docIndexD = self.__schP.getSchemaInfo(collectionGroupName=collectionGroupName)
+                collectionName = collectionList[0] if collectionList else "unassigned"
+                indexDL = docIndexD[collectionName] if collectionName in docIndexD else []
+                logger.info("Database %r collection %r index attributes %r", databaseNameMongo, collectionName, indexDL)
+                #
+                # For some reason, 'addValues' was being overwritten with an empty dict (https://github.com/rcsb/py-rcsb_exdb/commit/26bd79e9a2fffc97c034b4116dece9248d1c1f39)
+                # Will need to review this -- do we want to add the schema version values or not? (Also, see similar logic in UniProtCoreEtlWorker.py)
+                # collectionVersion = sD.getCollectionVersion(collectionName)
+                # addValues = {"_schema_version": collectionVersion}
+            #
+            dl = DocumentLoader(
+                self.__cfgOb,
+                self.__cachePath,
+                self.__resourceName,
+                numProc=self.__numProc,
+                chunkSize=self.__chunkSize,
+                maxStepLength=self.__maxStepLength,
+                documentLimit=self.__documentLimit,
+                verbose=self.__verbose,
+                readBackCheck=self.__readBackCheck,
+            )
+            #
+            ok = dl.load(databaseNameMongo, collectionName, loadType=loadType, documentList=dList, keyNames=None, addValues=addValues, indexDL=indexDL)
+            self.__updateStatus(updateId, databaseNameMongo, collectionName, ok, statusStartTimestamp)
+
+            return True
+        except Exception as e:
+            logger.exception("Failing with %s", str(e))
+        return False
+
+    def getLoadStatus(self):
+        return self.__statusList

rcsb/exdb/chemref/ChemRefExtractor.py

@@ -0,0 +1,70 @@
+##
+# File: ChemRefExtractor.py
+# Date: 2-Jul-2018  jdw
+#
+# Selected utilities to extract data from chemical component core collections.
+#
+# Updates:
+#  7-Jan-2019  jdw moved from ChemRefEtlWorker.
+#  3-Sep-2019  jdw moved again to module rcsb.exdb.chemref
+# 14-Aug-2025  dwp rename bird_chem_comp_core to core_chem_comp
+#
+##
+__docformat__ = "google en"
+__author__ = "John Westbrook"
+__email__ = "jwest@rcsb.rutgers.edu"
+__license__ = "Apache 2.0"
+
+import logging
+
+from rcsb.exdb.utils.ObjectExtractor import ObjectExtractor
+
+logger = logging.getLogger(__name__)
+
+
+class ChemRefExtractor(object):
+    """Selected utilities to extract data from chemical component core collections."""
+
+    def __init__(self, cfgOb):
+        self.__cfgOb = cfgOb
+        self.__resourceName = "MONGO_DB"
+        #
+
+    def getChemCompAccessionMapping(self, referenceResourceName):
+        """Get the accession code mapping between chemical component identifiers and identifier(s) for the
+            input external reference resource.
+
+        Args:
+            referenceResourceName (str):  resource name (e.g. DrugBank, ChEMBL, CCDC)
+
+        Returns:
+            dict: {referenceResourceId: chem_comp/bird_id, referenceResourceId: chem_comp/bird_id, ...  }
+
+        """
+        idD = {}
+        try:
+            databaseName = "dw"
+            collectionName = "core_chem_comp"
+            selectD = {"rcsb_chem_comp_related.resource_name": referenceResourceName}
+            selectionList = ["rcsb_id", "rcsb_chem_comp_related"]
+            logger.info("Searching %s %s with selection query %r", databaseName, collectionName, selectD)
+            obEx = ObjectExtractor(
+                self.__cfgOb,
+                databaseName=databaseName,
+                collectionName=collectionName,
+                keyAttribute="rcsb_id",
+                uniqueAttributes=["rcsb_id"],
+                selectionQuery=selectD,
+                selectionList=selectionList,
+                stripObjectId=True,
+            )
+            logger.info("Reference data object count %d", obEx.getCount())
+            objD = obEx.getObjects()
+            for _, doc in objD.items():
+                dL = doc["rcsb_chem_comp_related"] if "rcsb_chem_comp_related" in doc else []
+                for dD in dL:
+                    if dD["resource_name"] == referenceResourceName and "resource_accession_code" in dD:
+                        idD.setdefault(dD["resource_accession_code"], []).append(dD["comp_id"])
+        except Exception as e:
+            logger.exception("Failing with %s", str(e))
+        return idD

rcsb/exdb/chemref/ChemRefMappingProvider.py

@@ -0,0 +1,139 @@
+##
+#  File:           ChemRefMappingProvider.py
+#  Date:           18-Jun-2021 jdw
+#
+#  Updated:
+#
+##
+"""
+Accessors for chemical reference identifier mapping data.
+"""
+
+import datetime
+import logging
+import os.path
+import time
+
+from rcsb.utils.io.FileUtil import FileUtil
+from rcsb.utils.io.MarshalUtil import MarshalUtil
+from rcsb.utils.io.StashableBase import StashableBase
+from rcsb.exdb.chemref.ChemRefExtractor import ChemRefExtractor
+
+logger = logging.getLogger(__name__)
+
+
+class ChemRefMappingProvider(StashableBase):
+    """Accessors for chemical reference identifier mapping data."""
+
+    def __init__(self, cachePath, useCache=True):
+        #
+        self.__cachePath = cachePath
+        self.__useCache = useCache
+        self.__dirName = "chemref-mapping"
+        super(ChemRefMappingProvider, self).__init__(self.__cachePath, [self.__dirName])
+        self.__dirPath = os.path.join(self.__cachePath, self.__dirName)
+        #
+        self.__mU = MarshalUtil(workPath=self.__dirPath)
+        self.__rD = {}
+        self.__mapD = self.__reload(self.__dirPath, useCache)
+        #
+
+    def testCache(self, minCount=0):
+        logger.info("Mapping count %d", len(self.__mapD["mapping"]) if "mapping" in self.__mapD else 0)
+        if minCount == 0 or self.__mapD and "mapping" in self.__mapD and len(self.__mapD["mapping"]) >= minCount:
+            return True
+        else:
+            return False
+
+    def getReferenceIds(self, referenceResourceName, localId):
+        """Get the identifiers in the reference resource corresponding to input local
+        identifiers (Chemical Component or BIRD).
+
+        Args:
+            referenceResourceName (str): chemical reference resource name (DrugBank, ChEMBL, ChEBI, PubChem, ...)
+            localId (str): local identifier for a Chemical Component or BIRD definition
+
+        Returns:
+            list: list of reference identifiers
+        """
+        if not self.__rD:
+            for rN, forwardD in self.__mapD["mapping"].items():
+                # {refId :[lId, lId, ...], ...}
+                reverseD = {}
+                for refId, rcsbIdL in forwardD.items():
+                    for rId in rcsbIdL:
+                        reverseD.setdefault(rId, []).append(refId)
+                self.__rD[rN] = reverseD
+        #
+        try:
+            return self.__rD[referenceResourceName.upper()][localId]
+        except Exception:
+            return []
+
+    def getLocalIds(self, referenceResourceName, referenceId):
+        """Get the local identifiers (Chemical Component or BIRD) corresponding to identifiers in
+        chemical reference resource.
+
+        Args:
+            referenceResourceName (str): chemical reference resource name (DrugBank, ChEMBL, ChEBI, PubChem, ...)
+            referenceId (str): identifier in the chemical reference resource
+
+        Returns:
+            list: list of local Chemical Component or BIRD identifiers
+        """
+        try:
+            return self.__mapD["mapping"][referenceResourceName.upper()][referenceId]
+        except Exception:
+            return []
+
+    def __getMappingDataPath(self):
+        return os.path.join(self.__dirPath, "chemref-mapping-data.json")
+
+    def reload(self):
+        self.__mapD = self.__reload(self.__dirPath, useCache=True)
+        return True
+
+    def __reload(self, dirPath, useCache):
+        startTime = time.time()
+        fD = {}
+        ok = False
+        mappingPath = self.__getMappingDataPath()
+        #
+        logger.info("useCache %r mappingPath %r", useCache, mappingPath)
+        if useCache and self.__mU.exists(mappingPath):
+            fD = self.__mU.doImport(mappingPath, fmt="json")
+            ok = True
+        else:
+            fU = FileUtil()
+            fU.mkdir(dirPath)
+        # ---
+        logger.info("Completed reload with status (%r) at %s (%.4f seconds)", ok, time.strftime("%Y %m %d %H:%M:%S", time.localtime()), time.time() - startTime)
+        return fD
+
+    def fetchChemRefMapping(self, cfgOb, referenceResourceNameList=None):
+        """Fetch reference resource mapping for chemical component and BIRD definitions
+
+        Args:
+            cfgOb (obj): instance configuration class ConfigUtil()
+            referenceResourceNameList (list, optional): list of chemical reference resources. Defaults to [DrugBank, ChEMBL].
+
+        Returns:
+            bool: True for success or False otherwise
+        """
+        try:
+            rnL = referenceResourceNameList if referenceResourceNameList is not None else ["DrugBank", "ChEMBL"]
+            mD = {}
+            crExt = ChemRefExtractor(cfgOb)
+            for referenceResourceName in rnL:
+                idD = crExt.getChemCompAccessionMapping(referenceResourceName=referenceResourceName)
+                logger.info("%s mapping dictionary (%d)", referenceResourceName, len(idD))
+                mD[referenceResourceName.upper()] = idD
+            #
+            fp = self.__getMappingDataPath()
+            tS = datetime.datetime.now().isoformat()
+            vS = datetime.datetime.now().strftime("%Y-%m-%d")
+            ok = self.__mU.doExport(fp, {"version": vS, "created": tS, "mapping": mD}, fmt="json", indent=3)
+            return ok
+        except Exception as e:
+            logger.exception("Failing with %s", str(e))
+        return False