Fix UniProt DE parsing and model metadata fields

Author: mitsenkov

tests/test_uniprot_metadata.py

@@ -0,0 +1,166 @@
+from __future__ import annotations
+
+from uniprot.scripts.extract_subset import parse_de_sections, parse_organism
+from uniprot.scripts.export_model_metadata import (
+    ManifestRow,
+    ModelMetadataRow,
+    build_record,
+)
+
+
+def test_parse_de_sections_preserves_square_brackets_in_names() -> None:
+    lines = [
+        "DE   RecName: Full=Acyl-[acyl-carrier-protein]--UDP-N-acetylglucosamine O-acyltransferase;",
+    ]
+
+    full_names, short_names = parse_de_sections(lines)
+
+    assert full_names == [
+        "Acyl-[acyl-carrier-protein]--UDP-N-acetylglucosamine O-acyltransferase"
+    ]
+    assert short_names == []
+
+
+def test_parse_de_sections_preserves_semicolons_inside_names() -> None:
+    lines = [
+        "DE   RecName: Full=nitrite reductase (cytochrome; ammonia-forming) {ECO:0000256|ARBA:ARBA00011887};",
+    ]
+
+    full_names, short_names = parse_de_sections(lines)
+
+    assert full_names == ["nitrite reductase (cytochrome; ammonia-forming)"]
+    assert short_names == []
+
+
+def test_parse_de_sections_uses_submitted_names_as_full_name_fallback() -> None:
+    lines = [
+        "DE   SubName: Full=Methyl-coenzyme M reductase alpha {ECO:0000313|EMBL:ABW73421.1};",
+        "DE   Flags: Fragment;",
+    ]
+
+    full_names, short_names = parse_de_sections(lines)
+
+    assert full_names == ["Methyl-coenzyme M reductase alpha"]
+    assert short_names == []
+
+
+def test_parse_de_sections_keeps_recommended_names_before_submitted_names() -> None:
+    lines = [
+        "DE   RecName: Full=Curated recommended name;",
+        "DE   SubName: Full=Submitted fallback name {ECO:0000313|EMBL:ABC123.1};",
+    ]
+
+    full_names, short_names = parse_de_sections(lines)
+
+    assert full_names == ["Curated recommended name", "Submitted fallback name"]
+    assert short_names == []
+
+
+def test_parse_organism_preserves_parenthetical_text_in_scientific_name() -> None:
+    organism, common_names, synonyms = parse_organism("Escherichia coli (strain K12).")
+
+    assert organism == "Escherichia coli (strain K12)"
+    assert common_names == ["strain K12"]
+    assert synonyms == []
+
+
+def test_build_record_adds_model_level_complex_fields() -> None:
+    config = {
+        "latestVersion": 1,
+        "allVersions": [1],
+        "providerId": "AF-TEST",
+        "entityType": "protein",
+    }
+    manifest_rows = [
+        ManifestRow(
+            model_entity_id="AF-0000000000000001",
+            entity_id="1",
+            chain_id="A",
+            uniprot_ac="P11111",
+            sequence_start=None,
+            sequence_end=None,
+            is_fragment=False,
+            is_isoform=False,
+            entity_type="protein",
+            average_plddt=90.0,
+            fraction_plddt_very_low=0.0,
+            fraction_plddt_low=0.0,
+            fraction_plddt_confident=0.2,
+            fraction_plddt_very_high=0.8,
+        ),
+        ManifestRow(
+            model_entity_id="AF-0000000000000001",
+            entity_id="2",
+            chain_id="B",
+            uniprot_ac="Q22222",
+            sequence_start=None,
+            sequence_end=None,
+            is_fragment=False,
+            is_isoform=False,
+            entity_type="protein",
+            average_plddt=88.0,
+            fraction_plddt_very_low=0.0,
+            fraction_plddt_low=0.1,
+            fraction_plddt_confident=0.2,
+            fraction_plddt_very_high=0.7,
+        ),
+    ]
+    entry_map = {
+        "P11111": {
+            "primary_ac": "P11111",
+            "entry_name": "PROT1_TEST",
+            "protein_full_names": ["Protein one"],
+            "protein_short_names": None,
+            "gene_names": "GENE1",
+            "gene_synonyms": None,
+            "gene_ordered_locus_names": None,
+            "gene_orf_names": None,
+            "organism": "Organismus exampleus",
+            "organism_common_names": None,
+            "organism_synonyms": None,
+            "taxid": 1111,
+            "sequence_version_date": "2024-01-01",
+            "sequence": "ACDE",
+            "is_uniprot_reference_proteome": True,
+            "reviewed": True,
+        },
+        "Q22222": {
+            "primary_ac": "Q22222",
+            "entry_name": "PROT2_TEST",
+            "protein_full_names": ["Protein two"],
+            "protein_short_names": None,
+            "gene_names": "GENE2",
+            "gene_synonyms": None,
+            "gene_ordered_locus_names": None,
+            "gene_orf_names": None,
+            "organism": "Organismus exampleus",
+            "organism_common_names": None,
+            "organism_synonyms": None,
+            "taxid": 1111,
+            "sequence_version_date": "2024-01-01",
+            "sequence": "FGHI",
+            "is_uniprot_reference_proteome": True,
+            "reviewed": True,
+        },
+    }
+    model_metadata = {
+        "AF-0000000000000001": ModelMetadataRow(
+            iptm=0.91,
+            average_plddt=89.3,
+            complex_name=None,
+            is_am_data=False,
+        )
+    }
+
+    record = build_record(
+        "AF-0000000000000001",
+        config,
+        manifest_rows,
+        entry_map,
+        model_metadata,
+    )
+
+    assert record["assemblyType"] == "Hetero"
+    assert record["oligomericState"] == "dimer"
+    assert record["oligomericStateDescription"] == "Heterodimer"
+    assert record["complexComposition"] == ["P11111_1", "Q22222_1"]

uniprot/scripts/export_model_metadata.py

@@ -421,6 +421,15 @@ def derive_oligomeric_state(subunit_count: int) -> str:
     return OLIGOMERIC_STATE_MAP.get(subunit_count, "oligomer")
 
 
+def derive_oligomeric_state_description(
+    assembly_type: Optional[str],
+    oligomeric_state: Optional[str],
+) -> Optional[str]:
+    if not assembly_type or not oligomeric_state:
+        return None
+    return f"{assembly_type}{oligomeric_state}"
+
+
 def aggregate_metric(rows: Sequence[ManifestRow], attr: str) -> Optional[float]:
     values = [getattr(row, attr) for row in rows if getattr(row, attr) is not None]
     if not values:
@@ -617,13 +626,23 @@ def build_record(
     )
 
     is_complex = len(manifest_rows) > 1
+    complex_composition = (
+        [f"{component.accession}_{count}" for component, count in zip(components, component_counts)]
+        if is_complex
+        else None
+    )
 
     assembly_type = None
     oligomeric_state = None
+    oligomeric_state_description = None
     if is_complex:
         unique_accessions = {row.uniprot_ac for row in manifest_rows if row.uniprot_ac}
         assembly_type = "Hetero" if len(unique_accessions) > 1 else "Homo"
         oligomeric_state = derive_oligomeric_state(len(manifest_rows))
+        oligomeric_state_description = derive_oligomeric_state_description(
+            assembly_type,
+            oligomeric_state,
+        )
 
     model_meta = model_metadata.get(model_entity_id)
     iptm_value = model_meta.iptm if (is_complex and model_meta) else None
@@ -680,6 +699,10 @@ def consistent_or_none(values: Sequence[Optional[int]]) -> Optional[int]:
     if is_complex and assembly_type and oligomeric_state:
         record["assemblyType"] = assembly_type
         record["oligomericState"] = oligomeric_state
+    if complex_composition:
+        record["complexComposition"] = complex_composition
+    if oligomeric_state_description:
+        record["oligomericStateDescription"] = oligomeric_state_description
     record["uniprotAccession"] = accessions
     record["uniprotDescription"] = descriptions
     record["isUniProtReferenceProteome"] = is_uniprot_reference_proteome

uniprot/scripts/extract_subset.py

@@ -175,10 +175,50 @@ def extract_accessions(lines: Sequence[str]) -> List[str]:
 
 def strip_annotations(value: str) -> str:
     cleaned = value.strip()
-    cleaned = re.split(r"\s*[\{\[]", cleaned, 1)[0].strip()
+    while True:
+        updated = re.sub(r"\s*\{[^{}]*\}\s*$", "", cleaned).strip()
+        if updated == cleaned:
+            break
+        cleaned = updated
     return cleaned.rstrip(";").strip()
 
 
+def iter_de_fields(content: str) -> Iterable[tuple[str, str]]:
+    """Yield DE name fields without splitting on semicolons inside names."""
+
+    field_matcher = re.compile(r"(Full|Short|Allergen|Biotech|CD_antigen|INN)=")
+    position = 0
+    while True:
+        match = field_matcher.search(content, position)
+        if not match:
+            break
+        kind = match.group(1)
+        start = match.end()
+        paren_depth = 0
+        square_depth = 0
+        brace_depth = 0
+        end = start
+        while end < len(content):
+            char = content[end]
+            if char == "(":
+                paren_depth += 1
+            elif char == ")" and paren_depth:
+                paren_depth -= 1
+            elif char == "[":
+                square_depth += 1
+            elif char == "]" and square_depth:
+                square_depth -= 1
+            elif char == "{":
+                brace_depth += 1
+            elif char == "}" and brace_depth:
+                brace_depth -= 1
+            elif char == ";" and paren_depth == 0 and square_depth == 0 and brace_depth == 0:
+                break
+            end += 1
+        yield kind, content[start:end]
+        position = end + 1
+
+
 def parse_alt_products(lines: Sequence[str]) -> Dict[str, List[str]]:
     """
     Extract isoform definitions from the CC ALTERNATIVE PRODUCTS block.
@@ -390,9 +430,7 @@ def unique(values: Sequence[str]) -> List[str]:
             if other_match:
                 current_section = None
                 content = other_match.group(1).strip()
-        for match in RE_DE_FIELD.finditer(content):
-            kind = match.group(1)
-            raw_val = match.group(2)
+        for kind, raw_val in iter_de_fields(content):
             value = strip_annotations(raw_val)
             if not value:
                 continue
@@ -411,7 +449,7 @@ def parse_organism(raw: str) -> tuple[Optional[str], List[str], List[str]]:
         return None, [], []
     value = value.rstrip(".")
     paren_values = [match.strip().rstrip(".") for match in re.findall(r"\(([^)]+)\)", value)]
-    main = value.split("(", 1)[0].strip() if "(" in value else value.strip()
+    main = value.strip()
     if paren_values:
         common_names = [paren_values[0]] if paren_values[0] else []
         synonyms = [name for name in paren_values[1:] if name]