rcsb.exdb 1.31__py3-none-any.whl

rcsb/exdb/examples-seq/testEntityPolymerExtractor.py

@@ -0,0 +1,171 @@
+##
+# File:    EntityPolymerExtractorTests.py
+# Author:  J. Westbrook
+# Date:    25-Mar-2019
+#
+# Updates:
+#  21-Apr-2019 jdw Separate tests against the  mock-data repo in this module
+#
+##
+"""
+Tests for extractor entity polymer  collections (limited tests from mock-data repos)
+
+"""
+
+__docformat__ = "google en"
+__author__ = "John Westbrook"
+__email__ = "jwest@rcsb.rutgers.edu"
+__license__ = "Apache 2.0"
+
+
+import logging
+import os
+import time
+import unittest
+
+from rcsb.exdb.seq.EntityPolymerExtractor import EntityPolymerExtractor
+from rcsb.utils.config.ConfigUtil import ConfigUtil
+from rcsb.utils.io.MarshalUtil import MarshalUtil
+from rcsb.utils.taxonomy.TaxonomyProvider import TaxonomyProvider
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s]-%(module)s.%(funcName)s: %(message)s")
+logger = logging.getLogger()
+
+HERE = os.path.abspath(os.path.dirname(__file__))
+TOPDIR = os.path.dirname(os.path.dirname(os.path.dirname(HERE)))
+
+
+class EntityPolymerExtractorTests(unittest.TestCase):
+    def __init__(self, methodName="runTest"):
+        super(EntityPolymerExtractorTests, self).__init__(methodName)
+        self.__verbose = True
+
+    def setUp(self):
+        #
+        #
+        self.__mockTopPath = os.path.join(TOPDIR, "rcsb", "mock-data")
+        configPath = os.path.join(TOPDIR, "rcsb", "mock-data", "config", "dbload-setup-example.yml")
+        #
+        configName = "site_info_configuration"
+        self.__cfgOb = ConfigUtil(configPath=configPath, defaultSectionName=configName, mockTopPath=self.__mockTopPath)
+        #
+        self.__cachePath = os.path.join(TOPDIR, "CACHE")
+        self.__workPath = os.path.join(HERE, "test-output")
+        self.__taxonomyDataPath = os.path.join(self.__cachePath, self.__cfgOb.get("NCBI_TAXONOMY_CACHE_DIR", sectionName=configName))
+        #
+        self.__cacheKwargs = {"fmt": "json", "indent": 3}
+        self.__exdbCacheDirPath = os.path.join(self.__cachePath, self.__cfgOb.get("EXDB_CACHE_DIR", sectionName=configName))
+        #
+        self.__mU = MarshalUtil()
+        self.__entryLimitTest = 18
+        #
+        self.__startTime = time.time()
+        logger.debug("Starting %s at %s", self.id(), time.strftime("%Y %m %d %H:%M:%S", time.localtime()))
+
+    def tearDown(self):
+        endTime = time.time()
+        logger.info("Completed %s at %s (%.4f seconds)\n", self.id(), time.strftime("%Y %m %d %H:%M:%S", time.localtime()), endTime - self.__startTime)
+
+    def testExtractEntityPolymers(self):
+        """Test case - extract entity polymer info"""
+        try:
+            epe = EntityPolymerExtractor(self.__cfgOb, exdbDirPath=self.__exdbCacheDirPath, useCache=False, cacheKwargs=self.__cacheKwargs, entryLimit=self.__entryLimitTest)
+            eCount = epe.getEntryCount()
+            self.assertGreaterEqual(eCount, self.__entryLimitTest)
+            #
+        except Exception as e:
+            logger.exception("Failing with %s", str(e))
+            self.fail()
+
+    def testAccessEntityPolymerFeatures(self):
+        """Test case - access cached entity polymer info from test cache"""
+        try:
+            epe = EntityPolymerExtractor(self.__cfgOb, exdbDirPath=self.__exdbCacheDirPath, useCache=False, cacheKwargs=self.__cacheKwargs)
+            eCount = epe.getEntryCount()
+            logger.info("Entry count %d", eCount)
+            self.assertGreaterEqual(eCount, self.__entryLimitTest)
+            #
+            unpL = epe.getRefSeqAccessions("UNP")
+            logger.info("Ref seq count %d", len(unpL))
+            self.assertGreaterEqual(len(unpL), 1)
+            #
+            for entryId in ["3RER"]:
+                for entityId in ["1"]:
+                    uL = epe.getEntityRefSeqAccessions("UNP", entryId, entityId)
+                    logger.info("UNP for %s %s %r", entryId, entityId, uL)
+            #
+        except Exception as e:
+            logger.exception("Failing with %s", str(e))
+            self.fail()
+
+    def testTaxonomyReadCache(self):
+        """Test case - access cached entity polymer info from test cache"""
+        try:
+            epe = EntityPolymerExtractor(self.__cfgOb, exdbDirPath=self.__exdbCacheDirPath, useCache=False, cacheKwargs=self.__cacheKwargs)
+            logger.info("Cache entry count %d", epe.getEntryCount())
+            #
+            obsL = []
+            tD = epe.getOrigTaxons()
+            logger.info("Taxons %d", len(tD))
+
+            tU = TaxonomyProvider(taxDirPath=self.__taxonomyDataPath, useCache=True)
+            #
+            for entryId, taxIdL in tD.items():
+                for entityId, iTaxId in taxIdL:
+                    # logger.info("entryId %r entityId %r taxId %r" % (entryId, entityId, taxId))
+                    mTaxId = tU.getMergedTaxId(iTaxId)
+                    if iTaxId != mTaxId:
+                        obsL.append({"entryId": entryId, "entityId": entityId, "taxId": iTaxId, "replaceTaxId": mTaxId})
+            logger.info("Obsolete list length %d", len(obsL))
+            self.__mU.doExport(os.path.join(self.__workPath, "obsolete-taxons.json"), obsL, fmt="json", indent=3)
+            #
+        except Exception as e:
+            logger.exception("Failing with %s", str(e))
+            self.fail()
+
+    def testAccessEntityPolymerReadCache(self):
+        """Test case - access cached entity polymer info from test cache"""
+        try:
+            epe = EntityPolymerExtractor(self.__cfgOb, exdbDirPath=self.__exdbCacheDirPath, useCache=False, cacheKwargs=self.__cacheKwargs)
+            logger.info("Cache entry count %d", epe.getEntryCount())
+            cD = epe.countRefSeqAccessions("UNP")
+            self.assertGreaterEqual(len(cD), 2)
+            logger.info("UNP reference sequences per entity %r", dict(sorted(cD.items())))
+            logger.info("Reference sequences per entity %r", dict(sorted(epe.countRefSeqAccessionAny().items())))
+            logger.info("Reference sequences per ref db %r", dict(sorted(epe.countRefSeqAccessionDbType().items())))
+            #
+            ok = epe.checkRefSeqAlignRange("UNP")
+            self.assertTrue(ok)
+            unpL = epe.getRefSeqAccessions("UNP")
+            logger.info("Unique UNP reference sequences %d", len(unpL))
+            self.assertTrue(ok)
+            tD = epe.getUniqueTaxons()
+            logger.info("Unique taxons %d", len(tD))
+            tD = epe.countRefSeqAccessionByTaxon("UNP")
+            logger.info("Unique taxons %d", len(tD))
+            #
+        except Exception as e:
+            logger.exception("Failing with %s", str(e))
+            self.fail()
+
+
+def entityPolymerExtractSuite():
+    suiteSelect = unittest.TestSuite()
+    suiteSelect.addTest(EntityPolymerExtractorTests("testExtractEntityPolymers"))
+    suiteSelect.addTest(EntityPolymerExtractorTests("testAccessEntityPolymerFeatures"))
+    suiteSelect.addTest(EntityPolymerExtractorTests("testAccessEntityPolymerReadCache"))
+    return suiteSelect
+
+
+def entityTaxonomyExtractSuite():
+    suiteSelect = unittest.TestSuite()
+    suiteSelect.addTest(EntityPolymerExtractorTests("testTaxonomyReadCache"))
+    return suiteSelect
+
+
+if __name__ == "__main__":
+    mySuite = entityPolymerExtractSuite()
+    unittest.TextTestRunner(verbosity=2).run(mySuite)
+
+    mySuite = entityTaxonomyExtractSuite()
+    unittest.TextTestRunner(verbosity=2).run(mySuite)

rcsb/exdb/examples-seq/testReferenceSequenceAssignmentUpdater.py

@@ -0,0 +1,79 @@
+##
+# File:    UpdateReferenceSequencesTests.py
+# Author:  J. Westbrook
+# Date:    12-Oct-2019
+#
+# Updates:
+#
+##
+"""
+Tests for reference sequence assignment update operations
+"""
+
+__docformat__ = "google en"
+__author__ = "John Westbrook"
+__email__ = "jwest@rcsb.rutgers.edu"
+__license__ = "Apache 2.0"
+
+import logging
+import os
+import time
+import unittest
+
+from rcsb.exdb.seq.ReferenceSequenceAssignmentUpdater import ReferenceSequenceAssignmentUpdater
+from rcsb.utils.config.ConfigUtil import ConfigUtil
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s]-%(module)s.%(funcName)s: %(message)s")
+logger = logging.getLogger()
+
+HERE = os.path.abspath(os.path.dirname(__file__))
+TOPDIR = os.path.dirname(os.path.dirname(os.path.dirname(HERE)))
+
+
+class ReferenceSequenceAssignmentUpdaterTests(unittest.TestCase):
+    def __init__(self, methodName="runTest"):
+        super(ReferenceSequenceAssignmentUpdaterTests, self).__init__(methodName)
+        self.__verbose = True
+
+    def setUp(self):
+        #
+        self.__mockTopPath = os.path.join(TOPDIR, "rcsb", "mock-data")
+        configPath = os.path.join(TOPDIR, "rcsb", "mock-data", "config", "dbload-setup-example.yml")
+        configName = "site_info_configuration"
+        self.__cfgOb = ConfigUtil(configPath=configPath, defaultSectionName=configName, mockTopPath=self.__mockTopPath)
+        #
+        self.__resourceName = "MONGO_DB"
+        self.__cachePath = os.path.join(TOPDIR, "CACHE")
+        self.__testEntityCacheKwargs = {"fmt": "json", "indent": 3}
+        self.__fetchLimitTest = None
+        #
+        self.__startTime = time.time()
+        logger.debug("Starting %s at %s", self.id(), time.strftime("%Y %m %d %H:%M:%S", time.localtime()))
+
+    def tearDown(self):
+        endTime = time.time()
+        logger.info("Completed %s at %s (%.4f seconds)\n", self.id(), time.strftime("%Y %m %d %H:%M:%S", time.localtime()), endTime - self.__startTime)
+
+    def testUpdateAssignments(self):
+        """Test case - get reference sequences and update candidates"""
+        try:
+            rsau = ReferenceSequenceAssignmentUpdater(self.__cfgOb, useCache=False, cachePath=self.__cachePath, fetchLimit=self.__fetchLimitTest, siftsAbbreviated="TEST")
+            updateLimit = None
+            updateId = "2019_01"
+            lenUpd, numUpd = rsau.doUpdate(updateId, updateLimit=updateLimit)
+            logger.info("Update length %d numUpd %d", lenUpd, numUpd)
+            # self.assertEqual(numUpd, lenUpd)
+        except Exception as e:
+            logger.exception("Failing with %s", str(e))
+            self.fail()
+
+
+def referenceUpdaterSuite():
+    suiteSelect = unittest.TestSuite()
+    suiteSelect.addTest(ReferenceSequenceAssignmentUpdaterTests("testUpdateAssignments"))
+    return suiteSelect
+
+
+if __name__ == "__main__":
+    mySuite = referenceUpdaterSuite()
+    unittest.TextTestRunner(verbosity=2).run(mySuite)

rcsb/exdb/examples-seq/testReferenceSequenceUtils.py

@@ -0,0 +1,108 @@
+##
+# File:    ReferenceSequenceUtilsTests.py
+# Author:  J. Westbrook
+# Date:    25-Mar-2019
+#
+# Updates:
+#
+##
+"""
+Tests for accessing reference sequence data corresponding to polymer entity sequence assignments.
+
+(Limited tests against to mock-data repos.)
+
+"""
+
+__docformat__ = "google en"
+__author__ = "John Westbrook"
+__email__ = "jwest@rcsb.rutgers.edu"
+__license__ = "Apache 2.0"
+
+
+import logging
+import os
+import time
+import unittest
+
+
+from rcsb.exdb.seq.ReferenceSequenceUtils import ReferenceSequenceUtils
+from rcsb.utils.config.ConfigUtil import ConfigUtil
+from rcsb.utils.io.MarshalUtil import MarshalUtil
+
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s]-%(module)s.%(funcName)s: %(message)s")
+logger = logging.getLogger()
+
+HERE = os.path.abspath(os.path.dirname(__file__))
+TOPDIR = os.path.dirname(os.path.dirname(os.path.dirname(HERE)))
+
+
+class ReferenceSequenceUtilsTests(unittest.TestCase):
+    def __init__(self, methodName="runTest"):
+        super(ReferenceSequenceUtilsTests, self).__init__(methodName)
+        self.__verbose = True
+
+    def setUp(self):
+        #
+        self.__mockTopPath = os.path.join(TOPDIR, "rcsb", "mock-data")
+        configPath = os.path.join(TOPDIR, "rcsb", "mock-data", "config", "dbload-setup-example.yml")
+        #
+        configName = "site_info_configuration"
+        self.__cfgOb = ConfigUtil(configPath=configPath, defaultSectionName=configName, mockTopPath=self.__mockTopPath)
+        #
+        self.__cachePath = os.path.join(TOPDIR, "CACHE")
+        #
+        self.__cacheKwargs = {"fmt": "json", "indent": 3}
+        self.__exdbCacheDirPath = os.path.join(self.__cachePath, self.__cfgOb.get("EXDB_CACHE_DIR", sectionName=configName))
+        #
+        # Reference sequence test data cache -
+        #
+        self.__refDbCachePath = os.path.join(HERE, "test-output", "unp-data-test-cache.json")
+        self.__cacheKwargs = {"fmt": "json", "indent": 3}
+        self.__useCache = False
+        self.__fetchLimit = None
+        #
+        # Entity polymer extracted data ...
+        #
+        self.__entryLimit = 500
+        #
+        self.__mU = MarshalUtil()
+        #
+        self.__startTime = time.time()
+        logger.debug("Starting %s at %s", self.id(), time.strftime("%Y %m %d %H:%M:%S", time.localtime()))
+
+    def tearDown(self):
+        endTime = time.time()
+        logger.info("Completed %s at %s (%.4f seconds)\n", self.id(), time.strftime("%Y %m %d %H:%M:%S", time.localtime()), endTime - self.__startTime)
+
+    def testFetchUnp(self):
+        """Test case - extract entity polymer info -"""
+        try:
+            refDbName = "UNP"
+            rsu = ReferenceSequenceUtils(
+                self.__cfgOb,
+                refDbName,
+                exdbDirPath=self.__exdbCacheDirPath,
+                cacheKwargs=self.__cacheKwargs,
+                useCache=self.__useCache,
+                entryLimit=self.__entryLimit,
+                fetchLimit=self.__fetchLimit,
+            )
+            numPrimary, numSecondary, numNone = rsu.getReferenceAccessionAlignSummary()
+            self.assertGreaterEqual(numPrimary, 70)
+            logger.info("For %r matched primary:  %d secondary: %d none %d", refDbName, numPrimary, numSecondary, numNone)
+            #
+        except Exception as e:
+            logger.exception("Failing with %s", str(e))
+            self.fail()
+
+
+def unpFetchSuite():
+    suiteSelect = unittest.TestSuite()
+    suiteSelect.addTest(ReferenceSequenceUtilsTests("testFetchUnp"))
+    return suiteSelect
+
+
+if __name__ == "__main__":
+    mySuite = unpFetchSuite()
+    unittest.TextTestRunner(verbosity=2).run(mySuite)

rcsb/exdb/seq/AnnotationExtractor.py

@@ -0,0 +1,76 @@
+##
+# File: AnnotationExtractor.py
+# Date: 15-Oct-2019  jdw
+#
+# Utilities to extract selected annotation details from the exchange collections.
+#
+# Currently, used to established covered annotations for scoping tree brower displays
+# for expansive annotation hierarchies.
+#
+# 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
+
+logger = logging.getLogger(__name__)
+
+
+class AnnotationExtractor(object):
+    """Utilities to extract selected annotation details from the exchange collections."""
+
+    def __init__(self, cfgOb):
+        self.__cfgOb = cfgOb
+
+    def getUniqueIdentifiers(self, annotationType):
+        """Extract unique rcsb_polymer_entity_annotation ids for the input annotation type.
+
+        Args:
+            annotationType (str): a value of rcsb_polymer_entity_annotation.type
+
+        Returns:
+            list: unique list of identifiers of annotationType
+        """
+        idL = self.__extractEntityAnnotationIdentifiers(annotationType)
+        return idL
+
+    def __extractEntityAnnotationIdentifiers(self, annotationType):
+        """Extract unique rcsb_polymer_entity_annotation ids for the input annotation type."""
+        try:
+            databaseName = "pdbx_core"
+            collectionName = "pdbx_core_polymer_entity"
+            obEx = ObjectExtractor(
+                self.__cfgOb,
+                databaseName=databaseName,
+                collectionName=collectionName,
+                cacheFilePath=None,
+                useCache=False,
+                keyAttribute="entity",
+                uniqueAttributes=["rcsb_id"],
+                cacheKwargs=None,
+                objectLimit=None,
+                # selectionQuery={"rcsb_polymer_entity_annotation.type": annotationType},
+                selectionQuery=None,
+                selectionList=["rcsb_id", "rcsb_polymer_entity_annotation.annotation_id", "rcsb_polymer_entity_annotation.type"],
+            )
+            eCount = obEx.getCount()
+            logger.info("For type %r polymer entity annotation object count is %d", annotationType, eCount)
+            idS = set()
+            objD = obEx.getObjects()
+            for _, eD in objD.items():
+                try:
+                    for tD in eD["rcsb_polymer_entity_annotation"]:
+                        if tD["type"] == annotationType:
+                            idS.add(tD["annotation_id"])
+                except Exception:
+                    pass
+            logger.info("Unique identifiers %d", len(idS))
+            return list(idS)
+        except Exception as e:
+            logger.exception("Failing with %s", str(e))

rcsb/exdb/seq/LigandNeighborMappingExtractor.py

@@ -0,0 +1,84 @@
+##
+# File: LigandNeighborMappingExtractor.py
+# Date: 28-Jun-2021  jdw
+#
+# Utilities to extract ligand neighbor mapping details from the exchange collections.
+#
+# Updates:
+#  17-Jul-2024 dwp Stop fetching and including rcsb_ligand_neighbors.ligand_is_bound, since no longer populating that field
+#
+##
+__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 LigandNeighborMappingExtractor(object):
+    """Utilities to extract ligand neighbor mapping details from the exchange collections."""
+
+    def __init__(self, cfgOb):
+        self.__cfgOb = cfgOb
+
+    def getLigandNeighbors(self):
+        """Extract unique chemical component ids involved in neighbor interactions with each
+        polymer and branched entity instance.
+
+        Returns:
+            dict: {'entryId_entityId':  [(chem_comp_id, isBound),...], }
+        """
+        return self.__extractLigandNeighbors()
+
+    def __extractLigandNeighbors(self):
+        """Extract unique chemical component ids involved in neighbor interactions with each
+        polymer and branched entity instance."""
+        try:
+            databaseName = "pdbx_core"
+            collectionName = "pdbx_core_polymer_entity_instance"
+            obEx = ObjectExtractor(
+                self.__cfgOb,
+                databaseName=databaseName,
+                collectionName=collectionName,
+                cacheFilePath=None,
+                useCache=False,
+                keyAttribute="rcsb_id",
+                uniqueAttributes=["rcsb_id"],
+                cacheKwargs=None,
+                objectLimit=None,
+                # selectionQuery={"rcsb_polymer_entity_annotation.type": annotationType},
+                selectionQuery=None,
+                selectionList=[
+                    "rcsb_id",
+                    "rcsb_polymer_entity_instance_container_identifiers.entry_id",
+                    "rcsb_polymer_entity_instance_container_identifiers.entity_id",
+                    "rcsb_polymer_entity_instance_container_identifiers.asym_id",
+                    "rcsb_ligand_neighbors.ligand_comp_id",
+                ],
+            )
+            eCount = obEx.getCount()
+            logger.info("Total neighbor count (%d)", eCount)
+            rD = {}
+            objD = obEx.getObjects()
+            for _, peiD in objD.items():
+                try:
+                    entryId = peiD["rcsb_polymer_entity_instance_container_identifiers"]["entry_id"]
+                    entityId = peiD["rcsb_polymer_entity_instance_container_identifiers"]["entity_id"]
+                    ky = entryId + "_" + entityId
+                    for lnD in peiD["rcsb_ligand_neighbors"] if "rcsb_ligand_neighbors" in peiD else []:
+                        if "ligand_comp_id" in lnD:
+                            rD.setdefault(ky, set()).add(lnD["ligand_comp_id"])
+                        else:
+                            logger.warning("%s %s missing details lnD %r", entryId, entityId, lnD)
+                except Exception as e:
+                    logger.exception("Failing with %s", str(e))
+            rD = {k: list(v) for k, v in rD.items()}
+            logger.info("Unique instance %d", len(rD))
+            return rD
+        except Exception as e:
+            logger.exception("Failing with %s", str(e))

rcsb/exdb/seq/LigandNeighborMappingProvider.py

@@ -0,0 +1,106 @@
+##
+#  File:           LigandNeighborMappingProvider.py
+#  Date:           28-Jun-2021 jdw
+#
+#  Updated:
+#
+##
+"""
+Accessors for essential ligand neighbor mapping details associated with polymer and branched
+entity instances.
+"""
+
+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.seq.LigandNeighborMappingExtractor import LigandNeighborMappingExtractor
+
+logger = logging.getLogger(__name__)
+
+
+class LigandNeighborMappingProvider(StashableBase):
+    """Accessors for essential ligand neighbor mapping details associated with polymer and branched
+    entity instances."""
+
+    def __init__(self, cachePath, useCache=True):
+        #
+        self.__cachePath = cachePath
+        self.__useCache = useCache
+        self.__dirName = "ligand-neighbor-mapping"
+        super(LigandNeighborMappingProvider, self).__init__(self.__cachePath, [self.__dirName])
+        self.__dirPath = os.path.join(self.__cachePath, self.__dirName)
+        #
+        self.__mU = MarshalUtil(workPath=self.__dirPath)
+        self.__mapD = self.__reload(self.__dirPath, useCache)
+        #
+
+    def testCache(self, minCount=0):
+        logger.info("Cached ligand neighbor 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 getLigandNeighbors(self, rcsbEntityId):
+        """Get the unique list of ligand neighbors for the input polymer or branched entity instance.
+
+        Args:
+            rcsbEntityId (str): entryId '_' entityId
+
+        Returns:
+            list: [chem_comp_id, ... ]
+        """
+        try:
+            return list(set([t for t in self.__mapD["mapping"][rcsbEntityId.upper()]]))
+        except Exception:
+            return []
+
+    def reload(self):
+        self.__mapD = self.__reload(self.__dirPath, useCache=True)
+
+    def __reload(self, dirPath, useCache):
+        startTime = time.time()
+        retD = {}
+        ok = False
+        mappingPath = self.__getMappingDataPath()
+        #
+        logger.info("useCache %r mappingPath %r", useCache, mappingPath)
+        if useCache and self.__mU.exists(mappingPath):
+            retD = self.__mU.doImport(mappingPath, fmt="json")
+            ok = True
+        else:
+            fU = FileUtil()
+            fU.mkdir(dirPath)
+        # ---
+        num = len(retD["mapping"]) if "mapping" in retD else 0
+        logger.info("Completed ligand mapping reload (%d) with status (%r) at %s (%.4f seconds)", num, ok, time.strftime("%Y %m %d %H:%M:%S", time.localtime()), time.time() - startTime)
+        return retD
+
+    def __getMappingDataPath(self):
+        return os.path.join(self.__dirPath, "ligand-neighbor-mapping-data.json")
+
+    def fetchLigandNeighborMapping(self, cfgOb):
+        """Fetch ligand neighbor mapping details
+
+        Args:
+            cfgOb (obj): instance configuration class ConfigUtil()
+
+        Returns:
+            bool: True for success or False otherwise
+        """
+        try:
+            lnmEx = LigandNeighborMappingExtractor(cfgOb)
+            lnD = lnmEx.getLigandNeighbors()
+            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": lnD}, fmt="json", indent=3)
+            return ok
+        except Exception as e:
+            logger.exception("Failing with %s", str(e))
+        return False