rcsb.exdb 1.31__py3-none-any.whl → 1.32__py3-none-any.whl

rcsb/exdb/tests/testPubChemDataCacheProvider.py

@@ -1,124 +0,0 @@
-##
-# File:    PubChemDataCacheProviderTests.py
-# Author:  J. Westbrook
-# Date:    17-Jul-2020
-#
-# Updates:
-#
-##
-"""
-Tests for reference data cache maintenance operations
-"""
-
-__docformat__ = "google en"
-__author__ = "John Westbrook"
-__email__ = "jwest@rcsb.rutgers.edu"
-__license__ = "Apache 2.0"
-
-import logging
-import os
-import platform
-import resource
-import time
-import unittest
-
-from rcsb.exdb.chemref.PubChemDataCacheProvider import PubChemDataCacheProvider
-
-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 PubChemDataCacheProviderTests(unittest.TestCase):
-    def __init__(self, methodName="runTest"):
-        super(PubChemDataCacheProviderTests, self).__init__(methodName)
-        self._verbose = True
-
-    def setUp(self):
-        #
-        self.__cidList = ["49866376", "66835630", "71664579", "11915", "12072107"]
-        self.__cachePath = os.path.join(HERE, "test-output", "CACHE")
-        #
-        # Site configuration used for database resource access -
-        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.__startTime = time.time()
-        logger.debug("Starting %s at %s", self.id(), time.strftime("%Y %m %d %H:%M:%S", time.localtime()))
-
-    def tearDown(self):
-        unitS = "MB" if platform.system() == "Darwin" else "GB"
-        rusageMax = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss
-        logger.info("Maximum resident memory size %.4f %s", rusageMax / 10 ** 6, unitS)
-        endTime = time.time()
-        logger.info("Completed %s at %s (%.4f seconds)", self.id(), time.strftime("%Y %m %d %H:%M:%S", time.localtime()), endTime - self.__startTime)
-
-    def testALoadAndUpdate(self):
-        """Test case - load and reload/update data store."""
-        try:
-            #  -- Update/create cache ---
-            exportPath = os.path.join(self.__cachePath, "PubChem")
-            pcdcP = PubChemDataCacheProvider(self.__cfgOb, self.__cachePath)
-            ok, failList = pcdcP.load(self.__cidList, exportPath=exportPath)
-            self.assertTrue(ok)
-            self.assertEqual(len(failList), 0)
-            logger.info("Status %r failList %r", ok, failList)
-            #
-            idL = pcdcP.getRefIdCodes()
-            logger.info("idL %r", idL)
-            self.assertGreaterEqual(len(idL), len(self.__cidList))
-            #
-            ok, failList = pcdcP.updateMissing(self.__cidList, exportPath=exportPath)
-            self.assertTrue(ok)
-            self.assertEqual(len(failList), 0)
-        except Exception as e:
-            logger.exception("Failing with %s", str(e))
-            self.fail()
-
-    def testBackupAndRestore(self):
-        """Test case - load and dump operations."""
-        try:
-            #  -- Backup/Restore cache ---
-            pcdcP = PubChemDataCacheProvider(self.__cfgOb, self.__cachePath)
-            ok, failList = pcdcP.load(self.__cidList, exportPath=None)
-            self.assertEqual(len(failList), 0)
-            self.assertTrue(ok)
-            ok = pcdcP.dump(fmt="json")
-            self.assertTrue(ok)
-            #
-        except Exception as e:
-            logger.exception("Failing with %s", str(e))
-            self.fail()
-
-    def testGetRelatedIdentifiers(self):
-        """Test case - get PubChem xrefs."""
-        try:
-            #  --- Get related identifiers ---
-            pcdcP = PubChemDataCacheProvider(self.__cfgOb, self.__cachePath)
-            rD = pcdcP.getRelatedMapping(self.__cidList)
-            logger.info("rD %r", rD)
-            self.assertGreaterEqual(len(rD), len(self.__cidList))
-            #
-        except Exception as e:
-            logger.exception("Failing with %s", str(e))
-            self.fail()
-
-
-def pubChemDataCacheProviderSuite():
-    suiteSelect = unittest.TestSuite()
-    suiteSelect.addTest(PubChemDataCacheProviderTests("testALoadAndUpdate"))
-    suiteSelect.addTest(PubChemDataCacheProviderTests("testBackupAndRestore"))
-    suiteSelect.addTest(PubChemDataCacheProviderTests("testGetRelatedIdentifiers"))
-
-    return suiteSelect
-
-
-if __name__ == "__main__":
-    mySuite = pubChemDataCacheProviderSuite()
-    unittest.TextTestRunner(verbosity=2).run(mySuite)

rcsb/exdb/tests/testPubChemEtlWorkflow.py

@@ -1,134 +0,0 @@
-##
-# File:    PubChemEtlWorkflowTests.py
-# Author:  J. Westbrook
-# Date:    29-Jul-2020
-#
-# Updates:
-#  13-Mar-2023 aae Disable git stash testing
-##
-"""
-Tests for PubChem ETL workflow methods
-"""
-
-__docformat__ = "google en"
-__author__ = "John Westbrook"
-__email__ = "jwest@rcsb.rutgers.edu"
-__license__ = "Apache 2.0"
-
-import logging
-import os
-import platform
-import resource
-import time
-import unittest
-
-from rcsb.exdb.wf.PubChemEtlWorkflow import PubChemEtlWorkflow
-
-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 PubChemEtlWorkflowTests(unittest.TestCase):
-    def __init__(self, methodName="runTest"):
-        super(PubChemEtlWorkflowTests, self).__init__(methodName)
-        self.__verbose = True
-
-    def setUp(self):
-        #
-        self.__dataPath = os.path.join(HERE, "test-data")
-        self.__cachePath = os.path.join(HERE, "test-output", "CACHE")
-        #
-        # Site configuration used for database resource access -
-        # self.__mockTopPath = os.path.join(TOPDIR, "rcsb", "mock-data")
-        self.__configPath = os.path.join(TOPDIR, "rcsb", "mock-data", "config", "dbload-setup-example.yml")
-        self.__configName = "site_info_configuration"
-        #
-        # These are test source files for chemical component/BIRD indices
-        self.__ccUrlTarget = os.path.join(self.__dataPath, "components-abbrev.cif")
-        self.__birdUrlTarget = os.path.join(self.__dataPath, "prdcc-abbrev.cif")
-        self.__ccFileNamePrefix = "cc-abbrev"
-        #
-        # This tests pushing files to the stash
-        self.__testStashServer = True
-        self.__testStashGit = False
-        #
-        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):
-        unitS = "MB" if platform.system() == "Darwin" else "GB"
-        rusageMax = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss
-        logger.info("Maximum resident memory size %.4f %s", rusageMax / 10 ** 6, unitS)
-        endTime = time.time()
-        logger.info("Completed %s at %s (%.4f seconds)", self.id(), time.strftime("%Y %m %d %H:%M:%S", time.localtime()), endTime - self.__startTime)
-
-    def testAUpdateIndex(self):
-        """Test case - build CCD/BIRD search indices and search for PubChem matches."""
-        try:
-            #  -- Update local chemical indices and  create PubChem mapping index ---
-
-            pcewP = PubChemEtlWorkflow(configPath=self.__configPath, configName=self.__configName, cachePath=self.__cachePath)
-            ok = pcewP.updateMatchedIndex(
-                ccUrlTarget=self.__ccUrlTarget,
-                birdUrlTarget=self.__birdUrlTarget,
-                ccFileNamePrefix=self.__ccFileNamePrefix,
-                numProcChemComp=4,
-                rebuildChemIndices=True,
-                useStash=self.__testStashServer,
-                useGit=self.__testStashGit
-            )
-            self.assertTrue(ok)
-        except Exception as e:
-            logger.exception("Failing with %s", str(e))
-            self.fail()
-
-    def testBDump(self):
-        """Test case - dump current stored state"""
-        try:
-            #  --
-            pcewP = PubChemEtlWorkflow(configPath=self.__configPath, configName=self.__configName, cachePath=self.__cachePath)
-            ok = pcewP.dump(useStash=self.__testStashServer, useGit=self.__testStashGit)
-            self.assertTrue(ok)
-        except Exception as e:
-            logger.exception("Failing with %s", str(e))
-            self.fail()
-
-    def testCRestore(self):
-        """Test case - restore object store from the prior dump"""
-        try:
-            #  --
-            pcewP = PubChemEtlWorkflow(configPath=self.__configPath, configName=self.__configName, cachePath=self.__cachePath)
-            ok = pcewP.restore()
-            self.assertTrue(ok)
-        except Exception as e:
-            logger.exception("Failing with %s", str(e))
-            self.fail()
-
-    def testDUpdateData(self):
-        """Test case - update corresponding data and generate corresponding identifiers."""
-        try:
-            #  --
-            pcewP = PubChemEtlWorkflow(configPath=self.__configPath, configName=self.__configName, cachePath=self.__cachePath)
-            ok = pcewP.updateMatchedData(useStash=self.__testStashServer, useGit=self.__testStashGit)
-            self.assertTrue(ok)
-        except Exception as e:
-            logger.exception("Failing with %s", str(e))
-            self.fail()
-
-
-def pubChemEtlWorkflowSuite():
-    suiteSelect = unittest.TestSuite()
-    suiteSelect.addTest(PubChemEtlWorkflowTests("testAUpdateIndex"))
-    suiteSelect.addTest(PubChemEtlWorkflowTests("testBDump"))
-    suiteSelect.addTest(PubChemEtlWorkflowTests("testCRestore"))
-    suiteSelect.addTest(PubChemEtlWorkflowTests("testDUpdateData"))
-
-    return suiteSelect
-
-
-if __name__ == "__main__":
-    mySuite = pubChemEtlWorkflowSuite()
-    unittest.TextTestRunner(verbosity=2).run(mySuite)

rcsb/exdb/tests/testPubChemEtlWrapper.py

@@ -1,155 +0,0 @@
-##
-# File:    PubChemEtlWrapperTests.py
-# Author:  J. Westbrook
-# Date:    20-Jul-2020
-#
-# Updates:
-#  13-Mar-2023 aae Updates to use multiprocess count, disable git stash testing,
-#                  Fix tests after removing obsolete entries from test data
-##
-"""
-Tests for PubChem ETL wrapper methods
-"""
-
-__docformat__ = "google en"
-__author__ = "John Westbrook"
-__email__ = "jwest@rcsb.rutgers.edu"
-__license__ = "Apache 2.0"
-
-import logging
-import os
-import platform
-import resource
-import time
-import unittest
-
-from rcsb.exdb.chemref.PubChemEtlWrapper import PubChemEtlWrapper
-
-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 PubChemEtlWrapperTests(unittest.TestCase):
-    def __init__(self, methodName="runTest"):
-        super(PubChemEtlWrapperTests, self).__init__(methodName)
-        self.__verbose = True
-
-    def setUp(self):
-        #
-        self.__workPath = os.path.join(HERE, "test-output")
-        self.__dataPath = os.path.join(HERE, "test-data")
-        self.__cachePath = os.path.join(HERE, "test-output", "CACHE")
-        self.__dirPath = os.path.join(self.__cachePath, "PubChem")
-        self.__mU = MarshalUtil(workPath=self.__cachePath)
-        #
-        # Site configuration used for database resource access -
-        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)
-        #
-        # These are test source files for chemical component/BIRD indices
-        self.__ccUrlTarget = os.path.join(self.__dataPath, "components-abbrev.cif")
-        self.__birdUrlTarget = os.path.join(self.__dataPath, "prdcc-abbrev.cif")
-        self.__numComponents = 25
-        self.__numSelectMatches = 23
-        self.__numAltMatches = 2
-        self.__numTotalMatches = 50
-        #
-        # This tests pushing files to the stash
-        self.__testStashServer = True
-        self.__testStashGit = False
-        #
-        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):
-        unitS = "MB" if platform.system() == "Darwin" else "GB"
-        rusageMax = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss
-        logger.info("Maximum resident memory size %.4f %s", rusageMax / 10 ** 6, unitS)
-        endTime = time.time()
-        logger.info("Completed %s at %s (%.4f seconds)", self.id(), time.strftime("%Y %m %d %H:%M:%S", time.localtime()), endTime - self.__startTime)
-
-    def testAFromBootstrap(self):
-        """Test case - build CCD/BIRD search indices and search for PubChem matches."""
-        try:
-            #  -- Update local chemical indices and  create PubChem mapping index ---
-
-            pcewP = PubChemEtlWrapper(self.__cfgOb, self.__cachePath)
-            ok = pcewP.updateIndex(
-                ccUrlTarget=self.__ccUrlTarget,
-                birdUrlTarget=self.__birdUrlTarget,
-                ccFileNamePrefix="cc-abbrev",
-                exportPath=self.__dirPath,
-                rebuildChemIndices=True,
-                numProcChemComp=4,
-            )
-            self.assertTrue(ok)
-            #
-            mL = pcewP.getMatches()
-            self.assertGreaterEqual(len(mL), self.__numTotalMatches)
-            selectMatchD, altMatchD = pcewP.getSelectedMatches()
-            #
-            logger.info("matchD (%d)", len(selectMatchD))
-            self.assertGreaterEqual(len(selectMatchD), self.__numSelectMatches)
-            self.assertGreaterEqual(len(altMatchD), self.__numAltMatches)
-            #
-            ok = pcewP.dump(contentType="index")
-            self.assertTrue(ok)
-            ok = pcewP.toStash(contentType="index", useStash=self.__testStashServer, useGit=self.__testStashGit)
-            self.assertTrue(ok)
-        except Exception as e:
-            logger.exception("Failing with %s", str(e))
-            self.fail()
-
-    def testBFromRestore(self):
-        """Test case - operations from a restored starting point"""
-        try:
-            #  --
-            pcewP = PubChemEtlWrapper(self.__cfgOb, self.__cachePath)
-            ok = pcewP.fromStash(contentType="index")
-            self.assertTrue(ok)
-            #
-            numObjects = pcewP.reloadDump(contentType="index")
-            logger.info("Restored %d correspondence records", numObjects)
-            self.assertGreaterEqual(numObjects, self.__numComponents)
-            mapD, extraMapD = pcewP.getSelectedMatches(exportPath=os.path.join(self.__cachePath, "mapping"))
-            self.assertGreaterEqual(len(mapD), self.__numSelectMatches)
-            logger.info("mapD (%d) extraMapD (%d) %r", len(mapD), len(extraMapD), extraMapD)
-            self.assertGreaterEqual(len(extraMapD), self.__numAltMatches)
-            cidList = pcewP.getMatches()
-            logger.info("cidList (%d)", len(cidList))
-            self.assertGreaterEqual(len(cidList), self.__numTotalMatches - 2)
-            ok = pcewP.updateMatchedData()
-            self.assertTrue(ok)
-            ok = pcewP.dump(contentType="data")
-            self.assertTrue(ok)
-            ok = pcewP.toStash(contentType="data", useStash=self.__testStashServer, useGit=self.__testStashGit)
-            self.assertTrue(ok)
-            ok = pcewP.updateIdentifiers()
-            self.assertTrue(ok)
-            ok = pcewP.dump(contentType="identifiers")
-            self.assertTrue(ok)
-            ok = pcewP.toStash(contentType="identifiers", useStash=self.__testStashServer, useGit=self.__testStashGit)
-            self.assertTrue(ok)
-        except Exception as e:
-            logger.exception("Failing with %s", str(e))
-            self.fail()
-
-
-def pubChemEtlWrapperSuite():
-    suiteSelect = unittest.TestSuite()
-    suiteSelect.addTest(PubChemEtlWrapperTests("testAFromBootstrap"))
-    suiteSelect.addTest(PubChemEtlWrapperTests("testBFromRestore"))
-    return suiteSelect
-
-
-if __name__ == "__main__":
-    mySuite = pubChemEtlWrapperSuite()
-    unittest.TextTestRunner(verbosity=2).run(mySuite)

rcsb/exdb/tests/testPubChemIndexCacheProvider.py

@@ -1,123 +0,0 @@
-##
-# File:    PubChemIndexCacheProviderTests.py
-# Author:  J. Westbrook
-# Date:    16-Jul-2020
-#
-# Updates:
-#  13-Mar-2023 aae Fix tests after removing obsolete entries from test data
-##
-"""
-Tests for PubChem index cache maintenance operations
-"""
-
-__docformat__ = "google en"
-__author__ = "John Westbrook"
-__email__ = "jwest@rcsb.rutgers.edu"
-__license__ = "Apache 2.0"
-
-import logging
-import os
-import platform
-import resource
-import time
-import unittest
-
-from rcsb.exdb.chemref.PubChemIndexCacheProvider import PubChemIndexCacheProvider
-
-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 PubChemIndexCacheProviderTests(unittest.TestCase):
-    def __init__(self, methodName="runTest"):
-        super(PubChemIndexCacheProviderTests, self).__init__(methodName)
-        self.__verbose = True
-
-    def setUp(self):
-        #
-        self.__dataPath = os.path.join(HERE, "test-data")
-        self.__cachePath = os.path.join(HERE, "test-output", "CACHE")
-        #
-        # Site configuration used for database resource access -
-        self.__mockTopPath = os.path.join(TOPDIR, "rcsb", "mock-data")
-        configPath = os.path.join(TOPDIR, "rcsb", "mock-data", "config", "dbload-setup-example.yml")
-        self.__configName = "site_info_configuration"
-        self.__cfgOb = ConfigUtil(configPath=configPath, defaultSectionName=self.__configName, mockTopPath=self.__mockTopPath)
-        #
-        # These are test source files for chemical component/BIRD indices
-        self.__ccUrlTarget = os.path.join(self.__dataPath, "components-abbrev.cif")
-        self.__birdUrlTarget = os.path.join(self.__dataPath, "prdcc-abbrev.cif")
-        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):
-        unitS = "MB" if platform.system() == "Darwin" else "GB"
-        rusageMax = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss
-        logger.info("Maximum resident memory size %.4f %s", rusageMax / 10 ** 6, unitS)
-        endTime = time.time()
-        logger.info("Completed %s at %s (%.4f seconds)", self.id(), time.strftime("%Y %m %d %H:%M:%S", time.localtime()), endTime - self.__startTime)
-
-    def testAPubChemIndexCacheProvider(self):
-        """Test case - search, backup, restore and select PubChem correspondences for reference chemical definitions."""
-        try:
-            #  -- Update/create mapping index cache ---
-            numObj = 25
-            pcicP = PubChemIndexCacheProvider(self.__cfgOb, self.__cachePath)
-            pcicP.updateMissing(
-                expireDays=0,
-                cachePath=self.__cachePath,
-                ccUrlTarget=self.__ccUrlTarget,
-                birdUrlTarget=self.__birdUrlTarget,
-                ccFileNamePrefix="cc-abbrev",
-                exportPath=os.path.join(self.__cachePath, "PubChem"),
-                rebuildChemIndices=False,
-                fetchLimit=None,
-            )
-            matchD = pcicP.getMatchData(expireDays=0)
-            logger.info("matchD (%d)", len(matchD))
-            self.assertGreaterEqual(len(matchD), numObj)
-            ok = pcicP.testCache()
-            self.assertTrue(ok)
-            #
-            ok = pcicP.dump()
-            self.assertTrue(ok)
-            #
-            mapD, extraMapD = pcicP.getSelectedMatches(exportPath=os.path.join(self.__cachePath, "mapping"))
-            self.assertGreaterEqual(len(mapD), 20)
-            logger.info("mapD (%d) extraMapD (%d) %r", len(mapD), len(extraMapD), extraMapD)
-            self.assertGreaterEqual(len(extraMapD), 2)
-            cidList = pcicP.getMatches()
-            logger.info("cidList (%d)", len(cidList))
-            self.assertGreaterEqual(len(cidList), 49)
-            #
-        except Exception as e:
-            logger.exception("Failing with %s", str(e))
-            self.fail()
-
-    def testBPubChemIndexCacheProvider(self):
-        """Test case -  verify the PubChem index cache"""
-        try:
-            #  -- check cache
-            pcicP = PubChemIndexCacheProvider(self.__cfgOb, self.__cachePath)
-            ok = pcicP.testCache()
-            self.assertTrue(ok)
-        except Exception as e:
-            logger.exception("Failing with %s", str(e))
-            self.fail()
-
-
-def pubChemIndexCacheProviderSuite():
-    suiteSelect = unittest.TestSuite()
-    suiteSelect.addTest(PubChemIndexCacheProviderTests("testAPubChemIndexCacheProvider"))
-    suiteSelect.addTest(PubChemIndexCacheProviderTests("testBPubChemIndexCacheProviderCache"))
-    return suiteSelect
-
-
-if __name__ == "__main__":
-    mySuite = pubChemIndexCacheProviderSuite()
-    unittest.TextTestRunner(verbosity=2).run(mySuite)

rcsb/exdb/tests/testReferenceSequenceAnnotationAdapter.py

@@ -1,106 +0,0 @@
-##
-# File:    ReferenceSequenceAnnotationAdapterTests.py
-# Author:  J. Westbrook
-# Date:    14-Feb-2020
-#
-# Updates:
-#
-##
-"""
-Tests of reference seequence annotation adapter.
-"""
-
-__docformat__ = "google en"
-__author__ = "John Westbrook"
-__email__ = "jwest@rcsb.rutgers.edu"
-__license__ = "Apache 2.0"
-
-import logging
-import os
-import platform
-import resource
-import time
-import unittest
-
-from rcsb.exdb.seq.ReferenceSequenceAnnotationAdapter import ReferenceSequenceAnnotationAdapter
-from rcsb.exdb.seq.ReferenceSequenceAnnotationProvider import ReferenceSequenceAnnotationProvider
-from rcsb.exdb.utils.ObjectTransformer import ObjectTransformer
-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 ReferenceSequenceAnnotationAdapterTests(unittest.TestCase):
-    def __init__(self, methodName="runTest"):
-        super(ReferenceSequenceAnnotationAdapterTests, self).__init__(methodName)
-        self.__verbose = True
-
-    def setUp(self):
-        #
-        self.__mockTopPath = os.path.join(TOPDIR, "rcsb", "mock-data")
-        self.__cachePath = os.path.join(TOPDIR, "CACHE")
-        self.__useCache = True
-        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.__fetchLimit = 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):
-        unitS = "MB" if platform.system() == "Darwin" else "GB"
-        rusageMax = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss
-        logger.info("Maximum resident memory size %.4f %s", rusageMax / 10 ** 6, unitS)
-        endTime = time.time()
-        logger.info("Completed %s at %s (%.4f seconds)", self.id(), time.strftime("%Y %m %d %H:%M:%S", time.localtime()), endTime - self.__startTime)
-
-    # NOTE: IF YOU DISABLE THE TEST BELOW, THEN 'testReferenceCacheProvider' FAILS. CHECK WHETHER ALL 'Reference' PROVIDERS CAN BE DISABLED.
-    # @unittest.skip("Disable test - no longer using in production, and fails too frequently with 'Bad xml text' when fetching from UniProt")
-    def testAnnotationAdapter(self):
-        """Test case - create and read cache reference sequences assignments and related data."""
-        try:
-            databaseName = "pdbx_core"
-            collectionName = "pdbx_core_polymer_entity"
-            polymerType = "Protein"
-            #  -- create cache ---
-            rsaP = ReferenceSequenceAnnotationProvider(
-                self.__cfgOb, databaseName, collectionName, polymerType, fetchLimit=self.__fetchLimit, siftsAbbreviated="TEST", cachePath=self.__cachePath, useCache=True
-            )
-            ok = rsaP.testCache(minMissing=10)
-            self.assertTrue(ok)
-            numRef1 = rsaP.getRefDataCount()
-            #
-            # ---  Reload from cache ---
-            rsaP = ReferenceSequenceAnnotationProvider(self.__cfgOb, databaseName, collectionName, polymerType, cachePath=self.__cachePath, useCache=True)
-            ok = rsaP.testCache(minMissing=10)
-            self.assertTrue(ok)
-            numRef2 = rsaP.getRefDataCount()
-            self.assertEqual(numRef1, numRef2)
-            #
-            rsa = ReferenceSequenceAnnotationAdapter(rsaP)
-            obTr = ObjectTransformer(self.__cfgOb, objectAdapter=rsa)
-            ok = obTr.doTransform(
-                databaseName=databaseName, collectionName=collectionName, fetchLimit=self.__fetchLimit, selectionQuery={"entity_poly.rcsb_entity_polymer_type": polymerType}
-            )
-            self.assertTrue(ok)
-
-        except Exception as e:
-            logger.exception("Failing with %s", str(e))
-            self.fail()
-
-
-def referenceSequenceAnnotationAdapterSuite():
-    suiteSelect = unittest.TestSuite()
-    suiteSelect.addTest(ReferenceSequenceAnnotationAdapterTests("testAnnotationAdapter"))
-    return suiteSelect
-
-
-if __name__ == "__main__":
-    mySuite = referenceSequenceAnnotationAdapterSuite()
-    unittest.TextTestRunner(verbosity=2).run(mySuite)