rcsb.exdb 1.31__py3-none-any.whl

rcsb/exdb/seq/ReferenceSequenceAnnotationAdapter.py

@@ -0,0 +1,598 @@
+##
+# File: ReferenceSequenceAnnotationAdapter.py
+# Date: 8-Oct-2019  jdw
+#
+# Selected utilities to update reference sequence annotations information
+# in the core_entity collection.
+#
+# Updates:
+#
+##
+__docformat__ = "google en"
+__author__ = "John Westbrook"
+__email__ = "jwest@rcsb.rutgers.edu"
+__license__ = "Apache 2.0"
+
+import copy
+import logging
+
+from collections import defaultdict
+
+from rcsb.exdb.utils.ObjectAdapterBase import ObjectAdapterBase
+
+logger = logging.getLogger(__name__)
+
+
+class ReferenceSequenceAnnotationAdapter(ObjectAdapterBase):
+    """Selected utilities to update reference sequence annotations information
+    in the core_entity collection.
+    """
+
+    def __init__(self, referenceSequenceAnnotationProvider):
+        super(ReferenceSequenceAnnotationAdapter, self).__init__()
+        #
+        self.__rsaP = referenceSequenceAnnotationProvider
+        self.__ssP = self.__rsaP.getSiftsSummaryProvider()
+        self.__ecP = self.__rsaP.getEcProvider()
+        self.__refD = self.__rsaP.getRefData()
+        self.__matchD = self.__rsaP.getMatchInfo()
+        self.__ggP = self.__rsaP.getGlyGenProvider()
+        #
+
+    def filter(self, obj, **kwargs):
+        isTestMode = False
+        if isTestMode:
+            ok1, tObj = self.__filterAccessions(copy.deepcopy(obj))
+            ok2, tObj = self.__filterFeatures(tObj)
+            return ok1 and ok2, obj
+        else:
+            ok1, obj = self.__filterAccessions(obj)
+            ok2, obj = self.__filterFeatures(obj)
+            return ok1 and ok2, obj
+
+    def __filterFeatures(self, obj):
+        """Uses data from uniprot_exdb.reference_entry to populate the following data at the pdbx_core_polymer_entity collection:
+            rcsb_polymer_entity_annotation:
+                - GO (data from UniProt + lineage info from GO source)
+                - InterPro (data from UniProt)
+                - Pfam (is possible but not currently enabled)
+                - GlyGen
+            rcsb_enzyme_class_combined
+                - EC (data from UniProt)
+            rcsb_ec_lineage
+                - EC (data from EC source)
+            rcsb_gene_name
+                - Gene/taxonomy data from UniProt
+        """
+        ok = True
+        try:
+            if not ("rcsb_polymer_entity_container_identifiers" in obj and "rcsb_id" in obj):
+                return False, obj
+            entityKey = obj["rcsb_id"]
+            eciD = obj["rcsb_polymer_entity_container_identifiers"]
+
+            #
+            logger.debug(" ------------- Running feature filter on %r --------------", entityKey)
+            #
+            rsDL = []
+            soDL = []
+            peaDL = []
+            peObj = {}
+            #
+            try:
+                rsDL = eciD["reference_sequence_identifiers"]
+            except Exception:
+                pass
+
+            try:
+                soDL = obj["rcsb_entity_source_organism"]
+            except Exception:
+                pass
+            #
+            try:
+                peObj = obj["rcsb_polymer_entity"]
+            except Exception:
+                pass
+            #
+            try:
+                peaDL = obj["rcsb_polymer_entity_annotation"]
+            except Exception:
+                pass
+            #
+            # rsD {'database_name': 'UniProt', 'database_accession': 'P06881', 'provenance_source': 'PDB'}
+            unpIdS = set()
+            for rsD in rsDL:
+                if "database_name" in rsD and rsD["database_name"] == "UniProt" and "database_accession" in rsD:
+                    unpIdS.add(rsD["database_accession"])
+            #
+            unpGeneDL = []
+            unpAnnDL = []
+            glygenDL = []
+            geneLookupD = {}
+            geneFilterD = defaultdict(int)
+            resourceFilterD = defaultdict(int)
+            # Loop over all UniProt IDs from `rcsb_polymer_entity_container_identifiers.reference_sequence_identifiers.database_accession`
+            for unpId in unpIdS:
+                uD = self.__refD[unpId] if unpId in self.__refD else None
+                # uD represents a document from uniprot_exdb.reference_entry
+                if not uD:
+                    # This occurs when the UniProt IDs from:
+                    #   rcsb_polymer_entity_container_identifiers.reference_sequence_identifiers.database_accession
+                    # are not in:
+                    #   uniprot_exdb.reference_entry
+                    logger.info("%s no reference data for unexpected UniProt accession %r", entityKey, unpId)
+                    continue
+                if "gene" in uD and "taxonomy_id" in uD:
+                    taxId = int(uD["taxonomy_id"])
+                    logger.debug("%s : %r gene names %r", entityKey, unpId, uD["gene"])
+                    for tD in uD["gene"]:
+                        geneFilterD[tD["name"]] += 1
+                        if geneFilterD[tD["name"]] > 1:
+                            continue
+                        geneLookupD[tD["name"].upper()] = tD["name"]
+                        unpGeneDL.append({"provenance_source": "UniProt", "value": tD["name"], "taxonomy_id": taxId})
+                if "dbReferences" in uD:
+                    logger.debug("%s : %r references %d", entityKey, unpId, len(uD["dbReferences"]))
+                    for tD in uD["dbReferences"]:
+                        # Skipping Pfam now
+                        if "resource" in tD and "id_code" in tD and tD["resource"] in ["GO", "InterPro"]:
+                            resourceFilterD[(tD["resource"], tD["id_code"])] += 1
+                            if resourceFilterD[(tD["resource"], tD["id_code"])] > 1:
+                                logger.debug("Skipping duplicate annotation %r %r", tD["resource"], tD["id_code"])
+                                continue
+                            if tD["resource"] in ["GO"]:
+                                if self.__rsaP.goIdExists(tD["id_code"]):
+                                    goLin = self.__rsaP.getGeneOntologyLineage([tD["id_code"]])
+                                    goName = self.__rsaP.getGeneOntologyName(tD["id_code"])
+                                    if goLin and goName:
+                                        unpAnnDL.append(
+                                            {
+                                                "provenance_source": "UniProt",
+                                                "annotation_id": tD["id_code"],
+                                                "type": tD["resource"],
+                                                "name": goName,
+                                                "assignment_version": uD["version"],
+                                                "annotation_lineage": goLin,
+                                            }
+                                        )
+                            elif tD["resource"] in ["Pfam"]:
+                                pfamName = self.__rsaP.getPfamName(tD["id_code"])
+                                if pfamName:
+                                    unpAnnDL.append(
+                                        {
+                                            "provenance_source": "UniProt",
+                                            "annotation_id": tD["id_code"],
+                                            "name": pfamName,
+                                            "type": tD["resource"],
+                                            "assignment_version": uD["version"],
+                                        }
+                                    )
+                                else:
+                                    unpAnnDL.append({"provenance_source": "UniProt", "annotation_id": tD["id_code"], "type": tD["resource"], "assignment_version": uD["version"]})
+
+                            elif tD["resource"] in ["InterPro"]:
+                                interProName = self.__rsaP.getInterProName(tD["id_code"])
+                                interProLinL = self.__rsaP.getInterProLineage(tD["id_code"])
+                                if interProName and interProLinL:
+                                    unpAnnDL.append(
+                                        {
+                                            "provenance_source": "UniProt",
+                                            "annotation_id": tD["id_code"],
+                                            "name": interProName,
+                                            "type": tD["resource"],
+                                            "assignment_version": uD["version"],
+                                            "annotation_lineage": interProLinL,
+                                        }
+                                    )
+                                else:
+                                    unpAnnDL.append({"provenance_source": "UniProt", "annotation_id": tD["id_code"], "type": tD["resource"], "assignment_version": uD["version"]})
+
+                            else:
+                                unpAnnDL.append({"provenance_source": "UniProt", "annotation_id": tD["id_code"], "type": tD["resource"], "assignment_version": uD["version"]})
+                #
+                if self.__ggP and self.__ggP.hasGlycoprotein(unpId):
+                    logger.debug("Mapping glycoprotein for %r", unpId)
+                    glygenDL.append(
+                        {
+                            "provenance_source": "PDB",  # This should be GlyGen
+                            "annotation_id": unpId,
+                            "name": "Glycoprotein",
+                            "type": "GlyGen",
+                            "assignment_version": "1.0",
+                        }
+                    )
+
+            #
+            # raD {'resource_identifier': 'PF00503', 'provenance_source': 'SIFTS', 'resource_name': 'Pfam'}
+            # "provenance_source":  <"PDB"|"RCSB"|"SIFTS"|"UniProt"> "GO", "InterPro", "Pfam"
+            #
+            # ------------
+            # Filter existing annotations identifiers
+            # (remove any pre-existing UniProt and GlyGen annotations, so that most recent ones gathered above can be added)
+            if peaDL:
+                qL = []
+                for peaD in peaDL:
+                    if (peaD["provenance_source"] == "UniProt") or (peaD["type"] == "GlyGen"):
+                        continue
+                    qL.append(peaD)
+                # Put back the base object list -
+                peaDL = qL
+
+            for unpAnnD in unpAnnDL:
+                peaDL.append(unpAnnD)
+            #
+            if glygenDL:
+                # logger.debug("%r glygenDL (%d) %r", entityKey, len(glygenDL), glygenDL)
+                peaDL.extend(glygenDL)
+
+            if peaDL:
+                obj["rcsb_polymer_entity_annotation"] = peaDL
+                # logger.info("annotation object is %r", obj["rcsb_polymer_entity_annotation"])
+            #
+            # --------------  Add gene names -----------------
+            #
+            numSource = len(soDL)  # number of items originally present in rcsb_entity_source_organism
+            logger.debug("%s unpGeneDL %r", entityKey, unpGeneDL)
+            for ii, soD in enumerate(soDL):
+                if "ncbi_taxonomy_id" not in soD:
+                    continue
+                logger.debug("soD (%d) taxonomy %r", ii, soD["ncbi_taxonomy_id"])
+                # Filter any existing annotations
+                if "rcsb_gene_name" in soD:
+                    qL = []
+                    for qD in soD["rcsb_gene_name"]:
+                        if "value" not in qD:
+                            continue
+                        if qD["provenance_source"] != "UniProt":
+                            # standardize case consistent with UniProt
+                            if qD["value"].upper() in geneLookupD:
+                                qD["value"] = geneLookupD[qD["value"].upper()]
+                            else:
+                                geneLookupD[qD["value"].upper()] = qD["value"]
+                            qL.append(qD)
+                    soD["rcsb_gene_name"] = qL
+                taxId = soD["ncbi_taxonomy_id"]
+                for unpGeneD in unpGeneDL:
+                    # Only for matching taxonomies
+                    if taxId == unpGeneD["taxonomy_id"]:
+                        # skip cases with primary annotations and multiple sources
+                        if "rcsb_gene_name" in soD and numSource > 1:
+                            logger.debug("%s skipping special chimeric case", entityKey)
+                            continue
+                        soD.setdefault("rcsb_gene_name", []).append({"provenance_source": unpGeneD["provenance_source"], "value": unpGeneD["value"]})
+                #
+                # --------------  Remapping/extending EC assignments. --------------
+                if peObj:
+                    linL = []
+                    enzD = {}
+                    if "rcsb_enzyme_class_combined" in peObj:
+                        logger.debug("%s PDB EC assignment %r", entityKey, peObj["rcsb_enzyme_class_combined"])
+                        enzD = {tD["ec"]: tD["provenance_source"] for tD in peObj["rcsb_enzyme_class_combined"]}
+                        logger.debug("%s PDB EC assignment mapped %r", entityKey, enzD)
+                    #
+                    unpEcD = {}
+                    for unpId in unpIdS:
+                        uD = self.__refD[unpId] if unpId in self.__refD else None
+                        if not uD:
+                            logger.info("%s no data for unexpected UniProt accession %r", entityKey, unpId)
+                            continue
+                        if "dbReferences" in uD:
+                            logger.debug("%s : %r references %d", entityKey, unpId, len(uD["dbReferences"]))
+                            for tD in uD["dbReferences"]:
+                                if "resource" in tD and "id_code" in tD and tD["resource"] in ["EC"]:
+                                    logger.debug("%s UniProt accession %r EC %r", entityKey, unpId, tD)
+                                    tEc = self.__ecP.normalize(tD["id_code"])
+                                    if self.__ecP.exists(tEc):
+                                        unpEcD[tEc] = "UniProt"
+                    # integrate the UniProt data and update the object -
+                    if unpEcD:
+                        logger.debug("%s UniProt EC assignment %r", entityKey, unpEcD)
+                        for ecId in unpEcD:
+                            if ecId in enzD:
+                                continue
+                            enzD[ecId] = unpEcD[ecId]
+                        for ecId in enzD:
+                            tL = self.__ecP.getLineage(ecId)
+                            if tL:
+                                linL.extend(tL)
+                        peObj["rcsb_enzyme_class_combined"] = [{"ec": k, "provenance_source": v, "depth": k.count(".") + 1} for k, v in enzD.items()]
+                        peObj["rcsb_ec_lineage"] = [{"depth": tup[0], "id": tup[1], "name": tup[2]} for tup in linL]
+                    #
+        except Exception as e:
+            ok = False
+            logger.exception("Feature filter adapter failing with error with %s", str(e))
+        #
+        return ok, obj
+
+    def __filterAccessions(self, obj):
+        ok = True
+        try:
+            entityKey = obj["rcsb_id"]
+            logger.debug(" ------------- Running accession filter on %r --------------", entityKey)
+            #
+            referenceDatabaseName = "UniProt"
+            provSourceL = ["PDB"]
+            alignDL = None
+            ersDL = None
+            authAsymIdL = None
+            taxIdL = None
+            try:
+                ersDL = obj["rcsb_polymer_entity_container_identifiers"]["reference_sequence_identifiers"]
+                authAsymIdL = obj["rcsb_polymer_entity_container_identifiers"]["auth_asym_ids"]
+            except Exception:
+                logger.debug("%s no reference assignment protein sequence.", entityKey)
+
+            #
+            try:
+                taxIdL = [oD["ncbi_taxonomy_id"] for oD in obj["rcsb_entity_source_organism"]]
+                taxIdL = list(set(taxIdL))
+                logger.debug("%s taxonomy (%d) %r", entityKey, len(taxIdL), taxIdL)
+            except Exception as e:
+                logger.debug("Failing with %s", str(e))
+            #
+            if ersDL:
+                retDL = []
+                dupD = {}
+                # Loop over all identifier docs in `rcsb_polymer_entity_container_identifiers.reference_sequence_identifiers`
+                for ersD in ersDL:
+                    # Check currency of reference assignments made by entities in provSourceL (e.g. in this case only PDB)
+                    isMatchedRefDb, isMatchedAltDb, updErsD = self.__reMapAccessions(entityKey, ersD, referenceDatabaseName, taxIdL, provSourceL)
+                    # Possible results:
+                    # '4XVA_1' isMatchedRefDb False isMatchedAltDb False updErsD {'database_name': 'UniProt', 'database_accession': 'P00431', 'provenance_source': 'SIFTS'}
+                    #     - Most are this
+                    #     - '4XBI_1' another example updErsD {'database_name': 'UniProt', 'database_accession': 'Q8IB03', 'provenance_source': 'SIFTS'}
+                    # '8IVK_1' isMatchedRefDb True isMatchedAltDb False updErsD {'database_name': 'UniProt', 'database_accession': 'C3SKF0', 'provenance_source': 'PDB'}
+                    #     - Not super common
+                    # '1W3M_1' isMatchedRefDb False isMatchedAltDb True updErsD {'database_name': 'NORINE', 'database_accession': 'NOR00763', 'provenance_source': 'PDB'}
+                    #     - Not super common
+                    logger.debug("%r isMatchedRefDb %r isMatchedAltDb %r updErsD %r", entityKey, isMatchedRefDb, isMatchedAltDb, updErsD)
+
+                    if (isMatchedRefDb or isMatchedAltDb) and updErsD["database_accession"] not in dupD:
+                        dupD[updErsD["database_accession"]] = True
+                        retDL.append(updErsD)
+                    #
+                    # Re-apply the latest SIFTS mapping if available and we did not match the target reference database ...
+                    if not isMatchedRefDb and entityKey not in dupD:
+                        dupD[entityKey] = True
+                        siftsAccDL = self.__getSiftsAccessions(entityKey, authAsymIdL)
+                        for siftsAccD in siftsAccDL:
+                            logger.debug("Using/adding SIFTS accession mapping for %s", entityKey)
+                            retDL.append(siftsAccD)
+                        if not siftsAccDL:
+                            logger.debug("No alternative SIFTS accession mapping for %s", entityKey)
+                            # No alternative SIFTS accession mapping for 1W3M_1
+
+                if retDL:
+                    logger.debug("%s retDL %r", entityKey, retDL)
+                    obj["rcsb_polymer_entity_container_identifiers"]["reference_sequence_identifiers"] = retDL
+                else:
+                    del obj["rcsb_polymer_entity_container_identifiers"]["reference_sequence_identifiers"]
+                    logger.debug("Incomplete reference sequence mapping for %s", entityKey)
+            #
+            # ------------- update alignment details -------------
+            try:
+                alignDL = obj["rcsb_polymer_entity_align"]
+            except Exception:
+                pass
+            if alignDL and authAsymIdL:
+                retDL = []
+                dupD = {}
+                for alignD in alignDL:
+                    isMatchedRefDb, isMatchedAltDb, updAlignD, alignHash = self.__reMapAlignments(entityKey, alignD, referenceDatabaseName, taxIdL, provSourceL)
+                    #
+                    if (isMatchedRefDb or isMatchedAltDb) and alignHash not in dupD:
+                        if alignHash:
+                            dupD[alignHash] = True
+                        retDL.append(updAlignD)
+                    #
+                    # logger.debug("%s retDL %r", entityKey, retDL)
+                    #
+                    if not isMatchedRefDb and entityKey not in dupD:
+                        dupD[entityKey] = True
+                        siftsAlignDL = self.__getSiftsAlignments(entityKey, authAsymIdL)
+                        for siftsAlignD in siftsAlignDL:
+                            logger.debug("Using/adding SIFTS mapping for the alignment of %s", entityKey)
+                            retDL.append(siftsAlignD)
+                        if not siftsAlignDL:
+                            logger.debug("No alternative SIFTS alignment for %s", entityKey)
+                    #
+                if retDL:
+                    obj["rcsb_polymer_entity_align"] = retDL
+                else:
+                    del obj["rcsb_polymer_entity_align"]
+                    logger.debug("Reference sequence alignment NOT updated for %s", entityKey)
+        except Exception as e:
+            ok = False
+            logger.exception("Filter adapter failing with error with %s", str(e))
+        #
+        return ok, obj
+
+    def __reMapAccessions(self, entityKey, rsiD, referenceDatabaseName, taxIdL, provSourceL, excludeReferenceDatabases=None):
+        """Internal method to re-map accession for the input database and assignment source
+
+        Args:
+            rsiDL (list): current list of accession
+            databaseName (str, optional): resource database name. Defaults to 'UniProt'.
+            provSource (str, optional): assignment provenance. Defaults to 'PDB'.
+
+        Returns:
+            bool, bool, dict: flag for mapping success, flag for a supported reference database,
+                              and remapped (and unmapped) accessions in the input object list
+
+        Example:
+                    "P14118": {
+                    "searchId": "P14118",
+                    "matchedIds": {
+                        "P84099": {
+                        "taxId": 10090
+                        },
+                        "P84100": {
+                        "taxId": 10116
+                        },
+                        "P84098": {
+                        "taxId": 9606
+                        }
+                    },
+                    "matched": "secondary"
+                },
+        """
+        isMatchedRefDb = False
+        isMatchedAltDb = False
+        excludeReferenceDatabases = excludeReferenceDatabases if excludeReferenceDatabases else ["PDB"]
+        refDbList = ["UniProt", "GenBank", "EMBL", "NDB", "NORINE", "PIR", "PRF", "RefSeq"]
+        #
+        rId = rsiD["database_accession"]
+        logger.debug("%s rId %r db %r prov %r", entityKey, rId, rsiD["database_name"], rsiD["provenance_source"])
+        #
+        if rsiD["database_name"] in excludeReferenceDatabases:
+            isMatchedAltDb = False
+        elif rsiD["database_name"] == referenceDatabaseName and rsiD["provenance_source"] in provSourceL:
+            try:
+                # self.__matchD represents uniprot_exdb.reference_match
+                if rId in self.__matchD and self.__matchD[rId]["matched"] in ["primary"]:
+                    # no change
+                    isMatchedRefDb = True
+                elif rId in self.__matchD and self.__matchD[rId]["matched"] in ["secondary"]:
+                    logger.debug("secondary %r matched len %d", self.__matchD[rId]["matched"], len(self.__matchD[rId]["matchedIds"]))
+                    if len(self.__matchD[rId]["matchedIds"]) == 1:
+                        for mId, mD in self.__matchD[rId]["matchedIds"].items():
+                            rsiD["database_accession"] = mId
+                            logger.debug("%s matched secondary %s -> %s", entityKey, rId, mId)
+                            isMatchedRefDb = True
+                    elif taxIdL and len(taxIdL) == 1:
+                        #  -- simplest match case --
+                        numM = 0
+                        for mId, mD in self.__matchD[rId]["matchedIds"].items():
+                            if taxIdL[0] == mD["taxId"]:
+                                rsiD["database_accession"] = mId
+                                numM += 1
+                        if numM == 1:
+                            isMatchedRefDb = True
+                            logger.debug("%s matched secondary with taxId %r %s -> %s", entityKey, taxIdL[0], rId, rsiD["database_accession"])
+                    elif not taxIdL:
+                        logger.debug("%s no taxids with UniProt (%s) secondary mapping", entityKey, rId)
+                    else:
+                        logger.info("%s ambiguous mapping for a UniProt (%s) secondary mapping - taxIds %r", entityKey, rId, taxIdL)
+                #
+            except Exception:
+                pass
+
+        elif rsiD["provenance_source"] in provSourceL and rsiD["database_name"] in refDbList:
+            logger.debug("%s leaving reference accession for %s %s assigned by %r", entityKey, rId, rsiD["database_name"], provSourceL)
+            isMatchedRefDb = False
+            isMatchedAltDb = True
+        else:
+            logger.debug("%s leaving an unverified reference accession for %s %s assigned by %r", entityKey, rId, rsiD["database_name"], rsiD["provenance_source"])
+        #
+        logger.debug("%s isMatched %r isExcluded %r for accession %r", entityKey, isMatchedRefDb, isMatchedAltDb, rId)
+        #
+        return isMatchedRefDb, isMatchedAltDb, rsiD
+
+    def __reMapAlignments(self, entityKey, alignD, referenceDatabaseName, taxIdL, provSourceL, excludeReferenceDatabases=None):
+        """Internal method to re-map alignments for the input database and assignment source
+
+        Args:
+            alignD (dict): alignment object including accession and aligned regions
+            databaseName (str, optional): resource database name. Defaults to 'UniProt'.
+            provSourceL (list, optional): assignment provenance. Defaults to 'PDB'.
+
+        Returns:
+            bool, bool, list: flag for mapping success (refdb), flag for mapping success (altdb),
+                               and remapped (and unmapped) accessions in the input align list
+        """
+        isMatchedAltDb = False
+        isMatchedRefDb = False
+        excludeReferenceDatabases = excludeReferenceDatabases if excludeReferenceDatabases else ["PDB"]
+        refDbList = ["UniProt", "GenBank", "EMBL", "NDB", "NORINE", "PIR", "PRF", "RefSeq"]
+        provSourceL = provSourceL if provSourceL else []
+        rId = alignD["reference_database_accession"]
+        #
+        if alignD["reference_database_name"] in excludeReferenceDatabases:
+            isMatchedAltDb = False
+        elif alignD["reference_database_name"] == referenceDatabaseName and alignD["provenance_source"] in provSourceL:
+            try:
+                if rId in self.__matchD and self.__matchD[rId]["matched"] in ["primary"]:
+                    # no change
+                    isMatchedRefDb = True
+                elif rId in self.__matchD and self.__matchD[rId]["matched"] in ["secondary"]:
+                    if len(self.__matchD[rId]["matchedIds"]) == 1:
+                        for mId, mD in self.__matchD[rId]["matchedIds"].items():
+                            alignD["reference_database_accession"] = mId
+                            isMatchedRefDb = True
+                    elif taxIdL and len(taxIdL) == 1:
+                        #  -- simplest match case --
+                        numM = 0
+                        for mId, mD in self.__matchD[rId]["matchedIds"].items():
+                            if taxIdL[0] == mD["taxId"]:
+                                alignD["reference_database_accession"] = mId
+                                numM += 1
+                        if numM == 1:
+                            isMatchedRefDb = True
+                    elif not taxIdL:
+                        logger.debug("%s no taxids with UniProt (%s) secondary mapping", entityKey, rId)
+                    else:
+                        logger.info("%s ambiguous mapping for a UniProt (%s) secondary mapping - taxIds %r", entityKey, rId, taxIdL)
+                #
+            except Exception:
+                pass
+        elif alignD["provenance_source"] in provSourceL and alignD["reference_database_name"] in refDbList:
+            logger.debug("%s leaving reference alignment for %s %s assigned by %r", entityKey, rId, alignD["reference_database_name"], provSourceL)
+            isMatchedRefDb = False
+            isMatchedAltDb = True
+        else:
+            logger.debug("%s leaving a reference alignment for %s %s assigned by %r", entityKey, rId, alignD["reference_database_name"], alignD["provenance_source"])
+        #
+        logger.debug("%s isMatched %r isExcluded %r for alignment %r", entityKey, isMatchedRefDb, isMatchedAltDb, rId)
+        return isMatchedRefDb, isMatchedAltDb, alignD, self.__hashAlignment(alignD)
+
+    def __hashAlignment(self, aD):
+        """
+        Example:
+
+            {'reference_database_name': 'UniProt', 'reference_database_accession': 'P62942', 'provenance_source': 'PDB',
+              'aligned_regions': [{'entity_beg_seq_id': 1, 'ref_beg_seq_id': 1, 'length': 107}]}]
+        """
+        hsh = None
+        hL = []
+        try:
+            hL.append(aD["reference_database_accession"])
+            for aR in aD["aligned_regions"]:
+                hL.append(aR["entity_beg_seq_id"])
+                hL.append(aR["ref_beg_seq_id"])
+                hL.append(aR["length"])
+            hsh = tuple(hL)
+        except Exception:
+            pass
+        return hsh
+
+    def __getSiftsAccessions(self, entityKey, authAsymIdL):
+        retL = []
+        saoLD = self.__ssP.getLongestAlignments(entityKey[:4], authAsymIdL)
+        for (_, dbAccession), _ in saoLD.items():
+            retL.append({"database_name": "UniProt", "database_accession": dbAccession, "provenance_source": "SIFTS"})
+        return retL
+
+    def __getSiftsAlignments(self, entityKey, authAsymIdL):
+        retL = []
+        saoLD = self.__ssP.getLongestAlignments(entityKey[:4], authAsymIdL)
+        for (_, dbAccession), saoL in saoLD.items():
+            dD = {"reference_database_name": "UniProt", "reference_database_accession": dbAccession, "provenance_source": "SIFTS", "aligned_regions": []}
+            for sao in saoL:
+                dD["aligned_regions"].append({"ref_beg_seq_id": sao.getDbSeqIdBeg(), "entity_beg_seq_id": sao.getEntitySeqIdBeg(), "length": sao.getEntityAlignLength()})
+            retL.append(dD)
+        return retL
+
+    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