rcsb.exdb 1.31__py3-none-any.whl

rcsb/exdb/examples-seq/ReferenceSequenceUtils.py

@@ -0,0 +1,123 @@
+##
+# File: ReferenceSequenceUtils.py
+# Date: 28-Mar-2019  jdw
+#
+# Selected utilities to integrate reference sequence information with PDB polymer entity data.
+#
+# Updates:
+#  21-Apr-2019 jdw refactor
+#
+##
+__docformat__ = "google en"
+__author__ = "John Westbrook"
+__email__ = "jwest@rcsb.rutgers.edu"
+__license__ = "Apache 2.0"
+
+import logging
+import os
+
+from rcsb.exdb.seq.EntityPolymerExtractor import EntityPolymerExtractor
+from rcsb.utils.io.MarshalUtil import MarshalUtil
+from rcsb.utils.seq.UniProtUtils import UniProtUtils
+
+logger = logging.getLogger(__name__)
+
+
+class ReferenceSequenceUtils(object):
+    """Selected utilities to integrate reference sequence information with PDB polymer entity data."""
+
+    def __init__(self, cfgOb, refDbName, **kwargs):
+        self.__cfgOb = cfgOb
+        self.__refDbName = refDbName
+        self.__mU = MarshalUtil()
+        #
+        self.__refIdList = self.__getReferenceAssignments(refDbName, **kwargs)
+        self.__refD, self.__matchD = self.__rebuildCache(refDbName, self.__refIdList, **kwargs)
+
+    def __getReferenceAssignments(self, refDbName, **kwargs):
+        """Get all accessions assigned to input reference sequence database"""
+        rL = []
+        exdbDirPath = kwargs.get("exdbDirPath", None)
+        cacheKwargs = kwargs.get("cacheKwargs", None)
+        useCache = kwargs.get("useCache", True)
+        entryLimit = kwargs.get("entryLimit", None)
+
+        try:
+            epe = EntityPolymerExtractor(self.__cfgOb, exdbDirPath=exdbDirPath, useCache=useCache, cacheKwargs=cacheKwargs, entryLimit=entryLimit)
+            eCount = epe.getEntryCount()
+            rL = epe.getRefSeqAccessions(refDbName)
+            logger.info("Reading polymer entity cache with repository entry count %d ref accession length %d ", eCount, len(rL))
+            #
+        except Exception as e:
+            logger.exception("Failing with %s", str(e))
+
+        return rL
+
+    def __rebuildCache(self, refDbName, idList, **kwargs):
+        """ """
+        dD = {}
+        dirPath = kwargs.get("exdbDirPath", None)
+        cacheKwargs = kwargs.get("cacheKwargs", None)
+        useCache = kwargs.get("useCache", True)
+        fetchLimit = kwargs.get("fetchLimit", None)
+        saveText = kwargs.get("saveText", False)
+
+        ext = "pic" if cacheKwargs["fmt"] == "pickle" else "json"
+        fn = "ref-sequence-data-cache" + "." + ext
+        cacheFilePath = os.path.join(dirPath, fn)
+        self.__mU.mkdir(dirPath)
+        if not useCache:
+            for fp in [cacheFilePath]:
+                try:
+                    os.remove(fp)
+                except Exception:
+                    pass
+        #
+        if useCache and cacheFilePath and self.__mU.exists(cacheFilePath):
+            dD = self.__mU.doImport(cacheFilePath, **cacheKwargs)
+        else:
+            dD = self.__fetchReferenceEntries(refDbName, idList, saveText=saveText, fetchLimit=fetchLimit)
+            if cacheFilePath and cacheKwargs:
+                self.__mU.mkdir(dirPath)
+                ok = self.__mU.doExport(cacheFilePath, dD, **cacheKwargs)
+                logger.info("Cache save status %r", ok)
+
+        return dD["refDbCache"], dD["matchInfo"]
+
+    def __fetchReferenceEntries(self, refDbName, idList, saveText=False, fetchLimit=None):
+        """Fetch database entries from the input reference sequence database name."""
+        dD = {"refDbName": refDbName, "refDbCache": {}, "matchInfo": {}}
+
+        try:
+            idList = idList[:fetchLimit] if fetchLimit else idList
+            logger.info("Starting fetch for %d %s entries", len(idList), refDbName)
+            if refDbName == "UNP":
+                fobj = UniProtUtils(saveText=saveText)
+                refD, matchD = fobj.fetchList(idList)
+                dD = {"refDbName": refDbName, "refDbCache": refD, "matchInfo": matchD}
+
+        except Exception as e:
+            logger.exception("Failing with %s", str(e))
+
+        return dD
+
+    def __dumpEntries(self, refD):
+        for (eId, eDict) in refD.items():
+            logger.info("------ Entry id %s", eId)
+            for k, v in eDict.items():
+                logger.info("%-15s = %r", k, v)
+
+    def getReferenceAccessionAlignSummary(self):
+        """Summarize the alignment of PDB accession assignments with the current reference sequence database."""
+        numPrimary = 0
+        numSecondary = 0
+        numNone = 0
+        for _, mD in self.__matchD.items():
+            if mD["matched"] == "primary":
+                numPrimary += 1
+            elif mD["matched"] == "secondary":
+                numSecondary += 1
+            else:
+                numNone += 1
+        logger.debug("Matched primary:  %d secondary: %d none %d", numPrimary, numSecondary, numNone)
+        return numPrimary, numSecondary, numNone

rcsb/exdb/examples-seq/ReferenceSequenceUtilsTests.py

@@ -0,0 +1,109 @@
+##
+# File:    ReferenceSequenceUtilsTests.py
+# Author:  J. Westbrook
+# Date:    22-Apr-2019
+#
+# Updates:
+#
+##
+"""
+Tests updating reference sequence cache
+
+"""
+
+__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")
+        #
+        # Caution: this is very site specific setting !
+        configName = "site_info_remote"
+        self.__cfgOb = ConfigUtil(configPath=configPath, defaultSectionName=configName, mockTopPath=self.__mockTopPath)
+        if configName != "site_info_configuration":
+            self.__cfgOb.replaceSectionName("site_info_configuration", configName)
+        #
+        self.__workPath = os.path.join(HERE, "test-cache-preserve")
+        #
+        self.__entityPolymerCachePath = os.path.join(self.__workPath, "entity-polymer-data-cache.pic")
+        self.__entityPolymerCacheKwargs = {"fmt": "pickle"}
+        self.__useEntityPolymerCache = True
+        #
+        self.__refDbCachePath = os.path.join(self.__workPath, "unp-data-test-cache.json")
+        self.__refDbCacheKwargs = {"fmt": "json", "indent": 3}
+        #
+        self.__refDbUseCache = True
+        self.__fetchLimit = 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 testUpdateUniProtCache(self):
+        """Test case - extract entity polymer info and update reference sequence cache"""
+        try:
+            refDbName = "UNP"
+            rsu = ReferenceSequenceUtils(
+                self.__cfgOb,
+                refDbName,
+                referenceCachePath=self.__refDbCachePath,
+                referenceCacheKwargs=self.__refDbCacheKwargs,
+                useReferenceCache=self.__refDbUseCache,
+                entityPolymerCachePath=self.__entityPolymerCachePath,
+                entityPolymerCacheKwargs=self.__entityPolymerCacheKwargs,
+                useEntityPolymerCache=self.__useEntityPolymerCache,
+                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("testUpdateUniProtCache"))
+    return suiteSelect
+
+
+if __name__ == "__main__":
+
+    mySuite = unpFetchSuite()
+    unittest.TextTestRunner(verbosity=2).run(mySuite)

rcsb/exdb/examples-seq/exampleObjectExtractor.py

@@ -0,0 +1,109 @@
+##
+# File:    ObjectExtractorTests.py
+# Author:  J. Westbrook
+# Date:    25-Apr-2019
+#
+# Updates:
+#
+##
+"""
+Tests for extractor selected values from 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.utils.ObjectExtractor import ObjectExtractor
+from rcsb.utils.io.MarshalUtil import MarshalUtil
+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 ObjectExtractorTests(unittest.TestCase):
+    def __init__(self, methodName="runTest"):
+        super(ObjectExtractorTests, self).__init__(methodName)
+        self.__verbose = False
+
+    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_remote_configuration"
+        self.__cfgOb = ConfigUtil(configPath=configPath, defaultSectionName=configName, mockTopPath=self.__mockTopPath)
+        #
+        self.__workPath = "."
+        self.__mU = MarshalUtil(workPath=self.__workPath)
+        self.__entityTaxonPath = os.path.join(self.__workPath, "entity_taxon.tdd")
+        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 testExtractEntityTaxonomyContent(self):
+        """Test case - extract unique entity source and host taxonomies"""
+        tL = []
+        try:
+            obEx = ObjectExtractor(
+                self.__cfgOb,
+                databaseName="pdbx_core",
+                collectionName="pdbx_core_polymer_entity",
+                useCache=False,
+                keyAttribute="entity",
+                uniqueAttributes=["rcsb_id"],
+                selectionQuery=None,
+                selectionList=["rcsb_id", "rcsb_entity_source_organism.ncbi_taxonomy_id", "rcsb_entity_host_organism.ncbi_taxonomy_id"],
+            )
+            eCount = obEx.getCount()
+            logger.info("Polymer entity count is %d", eCount)
+            objD = obEx.getObjects()
+            sD = {}
+            hD = {}
+            for rId, eD in objD.items():
+                try:
+                    for tD in eD["rcsb_entity_source_organism"]:
+                        sD.setdefault(rId, []).append(str(tD["ncbi_taxonomy_id"]))
+
+                except Exception:
+                    pass
+                try:
+                    for tD in eD["rcsb_entity_host_organism"]:
+                        hD.setdefault(rId, []).append(str(tD["ncbi_taxonomy_id"]))
+                except Exception:
+                    pass
+            for rId, taxIdL in sD.items():
+                tS = "|".join(sorted(set(taxIdL)))
+                if tS:
+                    lS = "%s\t%s" % (rId, "|".join(sorted(set(taxIdL))))
+                tL.append(lS)
+            self.__mU.doExport(self.__entityTaxonPath, tL, fmt="list")
+        except Exception as e:
+            logger.exception("Failing with %s", str(e))
+            self.fail()
+
+
+def objectExtractorSuite():
+    suiteSelect = unittest.TestSuite()
+    suiteSelect.addTest(ObjectExtractorTests("testExtractEntityTaxonomyContent"))
+    return suiteSelect
+
+
+if __name__ == "__main__":
+    mySuite = objectExtractorSuite()
+    unittest.TextTestRunner(verbosity=2).run(mySuite)

rcsb/exdb/examples-seq/fixtureEntityPolymerExtractor.py

@@ -0,0 +1,85 @@
+##
+# File:    EntityPolymerExtractorFixture.py
+# Author:  J. Westbrook
+# Date:    25-Mar-2019
+#
+# Updates:
+#  21-Apr-2019 jdw Separate tests against the  mock-data repo in this module
+#   4-Sep-201  jdw make this a fixture
+#
+##
+"""
+Fixture extractor to preserve entity polymer data.
+
+"""
+
+__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
+
+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 EntityPolymerExtractorFixture(unittest.TestCase):
+    def __init__(self, methodName="runTest"):
+        super(EntityPolymerExtractorFixture, 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": "pickle"}
+        self.__exdbCacheDirPath = os.path.join(self.__cachePath, self.__cfgOb.get("EXDB_CACHE_DIR", sectionName=configName))
+        #
+        self.__entryLimitTest = 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 testExtractEntityPolymers(self):
+        """Fixture - extract and save 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, 10)
+            #
+        except Exception as e:
+            logger.exception("Failing with %s", str(e))
+            self.fail()
+
+
+def entityPolymerExtractSuite():
+    suiteSelect = unittest.TestSuite()
+    suiteSelect.addTest(EntityPolymerExtractorFixture("testExtractEntityPolymers"))
+    return suiteSelect
+
+
+if __name__ == "__main__":
+    mySuite = entityPolymerExtractSuite()
+    unittest.TextTestRunner(verbosity=2).run(mySuite)

rcsb/exdb/examples-seq/testEntityInstanceExtractor.py

@@ -0,0 +1,170 @@
+##
+# File:    EntityInstanceExtractorTests.py
+# Author:  J. Westbrook
+# Date:    19-Dec-2019
+#
+# Updates:
+#
+##
+"""
+Tests for preliminary version of the extractor selected values from entity instance collections.
+
+     PRELIMINARY VERSION
+"""
+
+__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.EntityInstanceExtractor import EntityInstanceExtractor
+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 EntityInstanceExtractorTests(unittest.TestCase):
+    def __init__(self, methodName="runTest"):
+        super(EntityInstanceExtractorTests, 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.__cfgOb.dump()
+        self.__resourceName = "MONGO_DB"
+        self.__readBackCheck = True
+        self.__numProc = 2
+        self.__chunkSize = 10
+        self.__documentLimit = None
+        self.__filterType = "assign-dates"
+        #
+        #
+        self.__workPath = os.path.join(HERE, "test-output")
+        self.__entitySavePath = os.path.join(HERE, "test-output", "entity-data-dictionary.json")
+        self.__entrySavePath = os.path.join(HERE, "test-output", "entry-data-dictionary.json")
+        self.__instanceSavePath = os.path.join(HERE, "test-output", "instance-data-dictionary.json")
+        self.__saveKwargs = {"fmt": "json", "indent": 3}
+        self.__mU = MarshalUtil()
+        self.__entryLimit = 3
+        #
+        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.debug("Completed %s at %s (%.4f seconds)\n", self.id(), time.strftime("%Y %m %d %H:%M:%S", time.localtime()), endTime - self.__startTime)
+
+    def testExtractEntryInfo(self):
+        """Test case - extract entry instance data -"""
+        try:
+            eiExt = EntityInstanceExtractor(self.__cfgOb)
+            entryD = eiExt.getEntryInfo()
+            self.assertTrue(len(entryD) > 15)
+            ok = self.__mU.doExport(self.__entrySavePath, entryD, fmt="json")
+            self.assertTrue(ok)
+            #
+        except Exception as e:
+            logger.exception("Failing with %s", str(e))
+            self.fail()
+
+    def testExtractEntityPolymers(self):
+        """Test case - extract entity polymer instance data -"""
+        try:
+            eiExt = EntityInstanceExtractor(self.__cfgOb)
+            entryD = eiExt.getEntryInfo()
+            self.assertTrue(len(entryD) > 15)
+            ok = self.__mU.doExport(self.__entrySavePath, entryD, fmt="json")
+            self.assertTrue(ok)
+            logger.info("EntryD length %d", len(entryD))
+            entryD = self.__mU.doImport(self.__entrySavePath, fmt="json")
+            #
+            entryD = eiExt.getPolymerEntities(entryD, savePath=self.__entitySavePath, entryLimit=None, saveKwargs=self.__saveKwargs)
+            self.assertTrue(len(entryD) > 15)
+            logger.info("EntryD + polymer entities length %d", len(entryD))
+            #
+            #
+        except Exception as e:
+            logger.exception("Failing with %s", str(e))
+            self.fail()
+
+    def testExtractEntityInstances(self):
+        """Test case - extract entity instance data -"""
+        try:
+            eiExt = EntityInstanceExtractor(self.__cfgOb)
+            entryD = eiExt.getEntryInfo()
+            self.assertTrue(len(entryD) > 15)
+            #
+            entryD = eiExt.getPolymerEntities(entryD, savePath=self.__entitySavePath, entryLimit=None, saveKwargs=self.__saveKwargs)
+            self.assertTrue(len(entryD) > 15)
+            #
+            entryD = eiExt.getEntityInstances(entryD, savePath=self.__instanceSavePath, entryLimit=self.__entryLimit, saveKwargs=self.__saveKwargs)
+            self.assertTrue(len(entryD) > 15)
+            #
+        except Exception as e:
+            logger.exception("Failing with %s", str(e))
+            self.fail()
+
+    def testAnalEntityInstances(self):
+        """Test case - analysis of entity instance data -"""
+        try:
+            eiExt = EntityInstanceExtractor(self.__cfgOb)
+            entryD = eiExt.getEntryInfo()
+            self.assertTrue(len(entryD) > 15)
+            #
+            entryD = eiExt.getPolymerEntities(entryD, savePath=self.__entitySavePath, entryLimit=None, saveKwargs=self.__saveKwargs)
+            self.assertTrue(len(entryD) > 15)
+            #
+            entryD = eiExt.getEntityInstances(entryD, savePath=self.__instanceSavePath, entryLimit=self.__entryLimit, saveKwargs=self.__saveKwargs)
+            self.assertTrue(len(entryD) > 15)
+
+            logger.info("EntryD + polymer entities instances length %d", len(entryD))
+            #
+            # entryD = self.__mU.doImport(self.__instanceSavePath, fmt="json")
+            # logger.info("entryD %r", entryD)
+            for entryId in entryD:
+                for entityId, eD in entryD[entryId]["selected_polymer_entities"].items():
+                    analD = eD["anal_instances"] if "anal_instances" in eD else {}
+                    for asymId, aD in analD.items():
+                        logger.debug("entryId %s entityId %s asymId %s analD: %r", entryId, entityId, asymId, aD)
+        except Exception as e:
+            logger.exception("Failing with %s", str(e))
+            self.fail()
+
+
+def entityInstanceExtractSuite():
+    suiteSelect = unittest.TestSuite()
+    suiteSelect.addTest(EntityInstanceExtractorTests("testExtractEntityPolymers"))
+    suiteSelect.addTest(EntityInstanceExtractorTests("testExtractEntityInstances"))
+    suiteSelect.addTest(EntityInstanceExtractorTests("testAnalEntityInstances"))
+    return suiteSelect
+
+
+def entryExtractSuite():
+    suiteSelect = unittest.TestSuite()
+    suiteSelect.addTest(EntityInstanceExtractorTests("testExtractEntryInfo"))
+    return suiteSelect
+
+
+if __name__ == "__main__":
+    mySuite = entityInstanceExtractSuite()
+    unittest.TextTestRunner(verbosity=2).run(mySuite)
+
+    mySuite = entryExtractSuite()
+    unittest.TextTestRunner(verbosity=2).run(mySuite)