pymetadata 0.6.4__tar.gz → 0.6.6__tar.gz

{pymetadata-0.6.4 → pymetadata-0.6.6}/.bumpversion.toml

@@ -1,5 +1,5 @@
 [tool.bumpversion]
-current_version = "0.6.4"
+current_version = "0.6.6"
 commit = true
 parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)"
 serialize = ["{major}.{minor}.{patch}"]

{pymetadata-0.6.4 → pymetadata-0.6.6}/CITATION.cff

@@ -8,8 +8,8 @@ authors:
     given-names: "Matthias"
     orcid: "https://orcid.org/0000-0003-1725-179X"
     affiliation: "Humboldt-University Berlin, Faculty of Life Science, Institute for Biology, Biology, Berlin; University Lübeck; University Hospital Schleswig-Holstein, Campus Lübeck, First Department of Medicine, Germany"
-version: "0.6.4"
-date-released: "2026-09-07"
+version: "0.6.6"
+date-released: "2026-09-22"
 doi: "10.5281/zenodo.5308801"
 license: MIT
 repository-code: "https://github.com/matthiaskoenig/pymetadata"

{pymetadata-0.6.4 → pymetadata-0.6.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pymetadata
-Version: 0.6.4
+Version: 0.6.6
 Summary: pymetadata are python utilities for working with metadata.
 Project-URL: Homepage, https://matthiaskoenig.github.io/pymetadata
 Project-URL: Documentation, https://matthiaskoenig.github.io/pymetadata
@@ -64,7 +64,7 @@ If you have any questions or issues please [open an issue](https://github.com/ma
 
 If you use `pymetadata` please cite the archived software on [Zenodo](https://doi.org/10.5281/zenodo.5308801):
 
-> König, M. (2026). *pymetadata are python utilities for working with metadata* (Version 0.6.0) [Computer software]. Zenodo. https://doi.org/10.5281/zenodo.22639628
+> König, M. (2026). *pymetadata are python utilities for working with metadata* (Version 0.6.5) [Computer software]. Zenodo. https://doi.org/10.5281/zenodo.22903506
 
 ```bibtex
 @software{konig_pymetadata,
@@ -72,10 +72,10 @@ If you use `pymetadata` please cite the archived software on [Zenodo](https://do
   title     = {pymetadata are python utilities for working with metadata},
   year      = {2026},
   month     = sep,
-  version   = {0.6.0},
+  version   = {0.6.5},
   publisher = {Zenodo},
-  doi       = {10.5281/zenodo.22639628},
-  url       = {https://doi.org/10.5281/zenodo.22639628},
+  doi       = {10.5281/zenodo.22903506},
+  url       = {https://doi.org/10.5281/zenodo.22903506},
 }
 ```
 

{pymetadata-0.6.4 → pymetadata-0.6.6}/README.md

@@ -19,7 +19,7 @@ If you have any questions or issues please [open an issue](https://github.com/ma
 
 If you use `pymetadata` please cite the archived software on [Zenodo](https://doi.org/10.5281/zenodo.5308801):
 
-> König, M. (2026). *pymetadata are python utilities for working with metadata* (Version 0.6.0) [Computer software]. Zenodo. https://doi.org/10.5281/zenodo.22639628
+> König, M. (2026). *pymetadata are python utilities for working with metadata* (Version 0.6.5) [Computer software]. Zenodo. https://doi.org/10.5281/zenodo.22903506
 
 ```bibtex
 @software{konig_pymetadata,
@@ -27,10 +27,10 @@ If you use `pymetadata` please cite the archived software on [Zenodo](https://do
   title     = {pymetadata are python utilities for working with metadata},
   year      = {2026},
   month     = sep,
-  version   = {0.6.0},
+  version   = {0.6.5},
   publisher = {Zenodo},
-  doi       = {10.5281/zenodo.22639628},
-  url       = {https://doi.org/10.5281/zenodo.22639628},
+  doi       = {10.5281/zenodo.22903506},
+  url       = {https://doi.org/10.5281/zenodo.22903506},
 }
 ```
 

{pymetadata-0.6.4 → pymetadata-0.6.6}/docs/annotations.md

@@ -59,6 +59,13 @@ print(annotation.resource_normalized)
 # https://identifiers.org/sabiork/1406
 ```
 
+Bioregistry URLs such as `https://bioregistry.io/CMO:0000003` also expose a
+collection (`cmo`) and compact term (`CMO:0000003`). Their normalized resource
+remains the original Bioregistry URL. `RDFAnnotationData` resolves configured
+OLS ontologies even when they have no identifiers.org namespace, including
+CMO, DRON, MMO and SCDO. Bioregistry terms are not validated against the
+identifiers.org registry.
+
 ## Validation
 
 Validation answers two questions: is the qualifier a real MIRIAM qualifier, and does the term match the pattern the identifiers.org registry defines for its collection?

{pymetadata-0.6.4 → pymetadata-0.6.6}/docs/development.md

@@ -162,6 +162,8 @@ uvx ty check
 
 The configuration lives in `[tool.ty]` in `pyproject.toml`. Warnings are treated as errors, so the codebase is kept free of diagnostics. Suppress an unavoidable diagnostic with a rule specific `# ty: ignore[rule-name]` rather than a blanket comment.
 
+`[tool.pyright]` in `pyproject.toml` is not a second type check. It only points the [pyright](https://github.com/microsoft/pyright) language server, which editors and coding agents use for navigation, at the uv environment in `.venv`, so that the imports of the dependencies resolve.
+
 ## Documentation
 
 The documentation is built with [Zensical](https://zensical.org/), the static site generator of the Material for MkDocs authors. The sources are markdown files in `docs/`, the site is configured in `zensical.toml` in the repository root. Nothing rendered is committed: the site is built by the `documentation` workflow on every push and published to [matthiaskoenig.github.io/pymetadata](https://matthiaskoenig.github.io/pymetadata) from the `develop` branch.

{pymetadata-0.6.4 → pymetadata-0.6.6}/docs/index.md

@@ -70,7 +70,7 @@ If you have any questions or issues please [open an issue](https://github.com/ma
 
 If you use `pymetadata` please cite the archived software on [Zenodo](https://doi.org/10.5281/zenodo.5308801):
 
-> König, M. (2026). *pymetadata are python utilities for working with metadata* (Version 0.6.0) [Computer software]. Zenodo. https://doi.org/10.5281/zenodo.22639628
+> König, M. (2026). *pymetadata are python utilities for working with metadata* (Version 0.6.5) [Computer software]. Zenodo. https://doi.org/10.5281/zenodo.22903506
 
 ```bibtex
 @software{konig_pymetadata,
@@ -78,10 +78,10 @@ If you use `pymetadata` please cite the archived software on [Zenodo](https://do
   title     = {pymetadata are python utilities for working with metadata},
   year      = {2026},
   month     = sep,
-  version   = {0.6.0},
+  version   = {0.6.5},
   publisher = {Zenodo},
-  doi       = {10.5281/zenodo.22639628},
-  url       = {https://doi.org/10.5281/zenodo.22639628},
+  doi       = {10.5281/zenodo.22903506},
+  url       = {https://doi.org/10.5281/zenodo.22903506},
 }
 ```
 

{pymetadata-0.6.4 → pymetadata-0.6.6}/pyproject.toml

@@ -93,3 +93,10 @@ include = ["src", "tests"]
 [tool.ty.terminal]
 # warnings are failures: keep the codebase free of any diagnostic
 error-on-warning = true
+
+[tool.pyright]
+# pyright is not a check of the project, types are checked with ty; this only
+# points the pyright language server of an editor or agent at the uv
+# environment, so that the dependencies resolve
+venvPath = "."
+venv = ".venv"

pymetadata-0.6.6/release-notes/0.6.5.md

@@ -0,0 +1,8 @@
+# Release notes for pymetadata 0.6.5
+![pymetadata](./docs/images/favicon/pymetadata-100x100-300dpi.png)
+
+## Fixes
+- Bioregistry URLs now expose their collection and compact term, allowing `RDFAnnotationData` to resolve metadata through OLS while preserving the original URL. Configured OLS ontologies no longer require an identifiers.org namespace, and DRON, MMO and SCDO are now included (#87).
+- OLS identifier prefixes are stripped once, case-insensitively, with either a colon or underscore separator. Identifiers such as `SIO_001013`, `OBI_0000070` and `chebi:37924` now produce the correct term IRI (#87).
+
+Your pymetadata team

pymetadata-0.6.6/release-notes/0.6.6.md

@@ -0,0 +1,8 @@
+# Release notes for pymetadata 0.6.6
+![pymetadata](./docs/images/favicon/pymetadata-100x100-300dpi.png)
+
+## Fixes
+
+- Write web service caches atomically so concurrent Python test environments and application processes do not read partial JSON. Failed writes preserve the previous cache (#91).
+
+Your pymetadata team

{pymetadata-0.6.4 → pymetadata-0.6.6}/src/pymetadata/__init__.py

@@ -7,7 +7,7 @@ from pathlib import Path
 logging.getLogger(__name__).addHandler(logging.NullHandler())
 
 __author__ = "Matthias Koenig"
-__version__ = "0.6.4"
+__version__ = "0.6.6"
 
 
 program_name: str = "pymetadata"

{pymetadata-0.6.4 → pymetadata-0.6.6}/src/pymetadata/cache.py

@@ -15,6 +15,7 @@ whatever was cached before.
 
 import json
 import logging
+import tempfile
 import time
 from json.encoder import JSONEncoder
 from pathlib import Path
@@ -124,7 +125,9 @@ def write_json_cache(
 ) -> None:
     """Write a JSON cache file.
 
-    Missing parent directories are created.
+    Missing parent directories are created. The file is replaced atomically so
+    concurrent readers never see partial JSON and failed writes preserve the
+    previous cache.
 
     Args:
         data: data to serialize
@@ -133,9 +136,17 @@ def write_json_cache(
             `DataclassJSONEncoder` for dataclasses
     """
     cache_path.parent.mkdir(parents=True, exist_ok=True)
-    with open(cache_path, "w") as fp:
-        logger.info("Write cache: %s", cache_path)
-        if json_encoder:
+    temporary_path: Path | None = None
+    try:
+        # Use the same filesystem for atomic replacement. Close the file before
+        # replacing it so this also works on Windows.
+        with tempfile.NamedTemporaryFile(
+            mode="w", dir=cache_path.parent, delete=False
+        ) as fp:
+            temporary_path = Path(fp.name)
+            logger.info("Write cache: %s", cache_path)
             json.dump(data, fp=fp, indent=2, cls=json_encoder)
-        else:
-            json.dump(data, fp=fp, indent=2)
+        temporary_path.replace(cache_path)
+    finally:
+        if temporary_path is not None:
+            temporary_path.unlink(missing_ok=True)

{pymetadata-0.6.4 → pymetadata-0.6.6}/src/pymetadata/core/annotation.py

@@ -58,7 +58,9 @@ IDENTIFIERS_ORG_PATTERN_CLASSIC: Final = re.compile(
 )
 
 BIOREGISTRY_PREFIX: Final = "https://bioregistry.io"
-BIOREGISTRY_PATTERN: Final = re.compile(r"^https?://bioregistry.io/(.+)")
+BIOREGISTRY_PATTERN: Final = re.compile(
+    r"^https?://bioregistry\.io/([a-zA-Z0-9._-]+):([^?#]+)$"
+)
 
 MIRIAM_URN_PATTERN: Final = re.compile(r"^urn:miriam:(.+)")
 
@@ -155,7 +157,12 @@ class RDFAnnotation:
                 # other urls are directly stored as resources without collection
                 self.collection = None
                 self.term = resource
-                if BIOREGISTRY_PATTERN.match(resource):
+                match_bioregistry = BIOREGISTRY_PATTERN.match(resource)
+                if match_bioregistry:
+                    self.collection = match_bioregistry.group(1).lower()
+                    self.term = (
+                        f"{match_bioregistry.group(1)}:{match_bioregistry.group(2)}"
+                    )
                     self.provider = ProviderType.BIOREGISTRY_IO
                 else:
                     self.provider = ProviderType.NONE
@@ -196,7 +203,11 @@ class RDFAnnotation:
                 self.provider = ProviderType.NONE
 
         # shorten compact terms
-        if self.term and self.collection:
+        if (
+            self.term
+            and self.collection
+            and self.provider == ProviderType.IDENTIFIERS_ORG
+        ):
             self.term = self.shorten_compact_term(
                 term=self.term, collection=self.collection
             )
@@ -256,12 +267,15 @@ class RDFAnnotation:
         `https://identifiers.org/<collection>/<term>`. Whether the term is
         valid does not matter here, this is the task of `validate`.
 
-        Resources without a collection, i.e., arbitrary urls, are returned
-        unchanged.
+        Bioregistry URLs retain their original resource while exposing their
+        collection and compact term for OLS resolution. Arbitrary URLs are also
+        returned unchanged.
         """
         if not self.term:
             return None
 
+        if self.provider == ProviderType.BIOREGISTRY_IO:
+            return self.resource
         if self.provider != ProviderType.IDENTIFIERS_ORG or self.collection is None:
             return self.term
 
@@ -353,12 +367,17 @@ class RDFAnnotation:
         """Validate qualifier and term of the annotation.
 
         Returns:
-            True if the qualifier is a MIRIAM qualifier and the term matches the
-            pattern of its collection.
+            True if the qualifier is a MIRIAM qualifier and an identifiers.org
+            term matches its collection pattern. Other providers do not use
+            identifiers.org term validation.
         """
         valid_qualifier: bool = self.check_qualifier(self.qualifier)
         valid_term: bool = True
-        if self.collection and self.term:
+        if (
+            self.collection
+            and self.term
+            and self.provider == ProviderType.IDENTIFIERS_ORG
+        ):
             valid_term = self.check_miriam_term()
 
         return valid_qualifier and valid_term
@@ -408,7 +427,7 @@ class RDFAnnotationData(RDFAnnotation):
         self.warnings: list = []
         self.errors: list = []
 
-        if self.collection:
+        if self.collection and self.provider == ProviderType.IDENTIFIERS_ORG:
             # register MIRIAM xrefs
             namespace = get_registry().ns_dict.get(self.collection, None)
             if not namespace:

{pymetadata-0.6.4 → pymetadata-0.6.6}/src/pymetadata/webservices/ols.py

@@ -20,6 +20,7 @@ See <https://www.ebi.ac.uk/ols4>.
 
 import contextlib
 import logging
+import re
 import urllib.parse
 from dataclasses import dataclass, field
 from pathlib import Path
@@ -70,6 +71,7 @@ ONTOLOGIES = [
     OLSOntology(name="cmo"),
     OLSOntology(name="chmo"),
     OLSOntology(name="doid"),
+    OLSOntology(name="dron"),
     OLSOntology(name="efo", iri_pattern="http://www.ebi.ac.uk/efo/EFO_{$Id}"),
     OLSOntology(name="fix"),
     OLSOntology(name="fma"),
@@ -81,12 +83,14 @@ ONTOLOGIES = [
     OLSOntology(name="mondo"),
     OLSOntology(name="ncit"),
     OLSOntology(name="mp"),
+    OLSOntology(name="mmo"),
     OLSOntology(name="oba"),
     OLSOntology(name="opmi"),
     OLSOntology(name="omit"),
     OLSOntology(
         name="sio", iri_pattern="http://semanticscience.org/resource/SIO_{$Id}"
     ),
+    OLSOntology(name="scdo"),
     OLSOntology(name="vto"),
 ]
 
@@ -146,8 +150,7 @@ class OLSQuery:
         """
         ols_ontology: OLSOntology | None = self.ontologies.get(ontology, None)
         # remove prefix if existing
-        if term.startswith(ontology.upper()):
-            term = term.replace(f"{ontology.upper()}:", "")
+        term = re.sub(rf"^{re.escape(ontology)}[:_]", "", term, count=1, flags=re.I)
 
         if ols_ontology is None:
             logger.warning(
@@ -177,23 +180,21 @@ class OLSQuery:
         if not term:
             return {"errors": [], "warnings": [f"No term: '{ontology}'"]}
 
-        namespace = get_registry().ns_dict.get(ontology)
-        ols_pattern = None
-        if namespace and namespace.resources:
-            for ns_resource in namespace.resources:
-                if ns_resource.providerCode == "ols":
-                    ols_pattern = ns_resource.urlPattern
-                    break
-
-        if not ols_pattern:
-            return {
-                "errors": [],
-                "warnings": [f"'{ontology}' is not on OLS."],
-            }
-
         if ontology == "taxonomy":
             ontology = "ncbitaxon"
 
+        # Configured ontologies need no identifiers.org namespace. Bioregistry
+        # includes ontologies which are absent from that registry.
+        if ontology not in self.ontologies:
+            namespace = get_registry().ns_dict.get(ontology)
+            if not namespace or not any(
+                resource.providerCode == "ols" for resource in namespace.resources or []
+            ):
+                return {
+                    "errors": [],
+                    "warnings": [f"'{ontology}' is not on OLS."],
+                }
+
         iri = self.get_iri(ontology=ontology, term=term)
 
         # double urlencode iri for OLS

{pymetadata-0.6.4 → pymetadata-0.6.6}/tests/core/test_annotation.py

@@ -149,7 +149,7 @@ rdf_annotation_data = [
     (
         BQB.IS,
         "https://bioregistry.io/chebi:15996",
-        "RDFAnnotation(BQB.IS|None|https://bioregistry.io/chebi:15996|bioregistry.io)",
+        "RDFAnnotation(BQB.IS|chebi|chebi:15996|bioregistry.io)",
     ),
     (
         BQB.IS,

pymetadata-0.6.6/tests/test_annotation_resolution.py

@@ -0,0 +1,108 @@
+"""Regression tests for resolver URLs and ontology identifiers."""
+
+import urllib.parse
+from pathlib import Path
+from types import SimpleNamespace
+
+import pytest
+
+from pymetadata.core.annotation import (
+    BQB,
+    ProviderType,
+    RDFAnnotation,
+    RDFAnnotationData,
+)
+from pymetadata.webservices.ols import ONTOLOGIES, OLSQuery
+
+
+@pytest.mark.parametrize("prefix", ["CMO", "cmo", "DRON", "MMO", "SCDO"])
+def test_bioregistry_resolves_without_identifiers_namespace(
+    prefix: str, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """Bioregistry terms resolve through configured OLS ontologies."""
+
+    def unexpected_registry() -> None:
+        raise AssertionError(
+            "Configured Bioregistry terms need no identifiers registry"
+        )
+
+    monkeypatch.setattr("pymetadata.core.annotation.get_registry", unexpected_registry)
+    monkeypatch.setattr("pymetadata.webservices.ols.get_registry", unexpected_registry)
+    query = OLSQuery(ONTOLOGIES, cache_path=tmp_path)
+    monkeypatch.setattr("pymetadata.core.annotation.get_ols_query", lambda: query)
+    urls: list[str] = []
+
+    def respond(url: str) -> dict:
+        urls.append(urllib.parse.unquote(urllib.parse.unquote(url)))
+        return {"label": "body height", "description": ["Height of a body."]}
+
+    monkeypatch.setattr("pymetadata.webservices.ols.get_json", respond)
+    resource = f"https://bioregistry.io/{prefix}:0000003"
+    annotation = RDFAnnotation(BQB.IS, resource)
+    data = RDFAnnotationData(annotation)
+
+    assert annotation.collection == prefix.lower()
+    assert annotation.provider == ProviderType.BIOREGISTRY_IO
+    assert annotation.resource_normalized == resource
+    assert data.label == "body height"
+    assert data.errors == []
+    assert data.warnings == []
+    assert annotation.validate()
+    # Repeated resolution uses the successful OLS response already on disk.
+    assert RDFAnnotationData(annotation).label == "body height"
+    assert urls == [
+        f"https://www.ebi.ac.uk/ols4/api/ontologies/{prefix.lower()}/terms/"
+        f"http://purl.obolibrary.org/obo/{prefix.upper()}_0000003"
+    ]
+
+
+@pytest.mark.parametrize(
+    "ontology,term,iri",
+    [
+        ("sio", "SIO_001013", "http://semanticscience.org/resource/SIO_001013"),
+        ("obi", "OBI_0000070", "http://purl.obolibrary.org/obo/OBI_0000070"),
+        ("chebi", "chebi:37924", "http://purl.obolibrary.org/obo/CHEBI_37924"),
+        ("chebi", "CHEBI:37924", "http://purl.obolibrary.org/obo/CHEBI_37924"),
+        ("sio", "001013", "http://semanticscience.org/resource/SIO_001013"),
+    ],
+)
+def test_ols_iri_prefix(ontology: str, term: str, iri: str, tmp_path: Path) -> None:
+    """A local identifier or CURIE contributes its ontology prefix only once."""
+    assert OLSQuery(ONTOLOGIES, cache_path=tmp_path).get_iri(ontology, term) == iri
+
+
+def test_unknown_bioregistry_ontology_is_not_guessed(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """An unconfigured ontology without an OLS provider stays unresolved."""
+    registry = SimpleNamespace(ns_dict={})
+    monkeypatch.setattr("pymetadata.webservices.ols.get_registry", lambda: registry)
+    query = OLSQuery(ONTOLOGIES, cache_path=tmp_path)
+    monkeypatch.setattr("pymetadata.core.annotation.get_ols_query", lambda: query)
+
+    def unexpected_request(url: str) -> dict:
+        raise AssertionError(f"Unsupported ontology must not be queried: {url}")
+
+    monkeypatch.setattr("pymetadata.webservices.ols.get_json", unexpected_request)
+    data = RDFAnnotationData(
+        RDFAnnotation(BQB.IS, "https://bioregistry.io/unknown:123")
+    )
+    assert data.label is None
+    assert data.errors == []
+    assert data.warnings == ["'unknown' is not on OLS."]
+
+
+@pytest.mark.parametrize(
+    "resource",
+    [
+        "https://bioregistryXio/CMO:0000003",
+        "https://bioregistry.io/CMO:",
+        "https://bioregistry.io/CMO",
+    ],
+)
+def test_non_bioregistry_identifier_url_is_preserved(resource: str) -> None:
+    """Lookalike hosts and URLs without an accession are arbitrary resources."""
+    annotation = RDFAnnotation(BQB.IS, resource)
+    assert annotation.provider == ProviderType.NONE
+    assert annotation.collection is None
+    assert annotation.resource_normalized == resource

{pymetadata-0.6.4 → pymetadata-0.6.6}/tests/test_cache.py

@@ -5,6 +5,7 @@ import logging
 import os
 import time
 from pathlib import Path
+from typing import Any
 
 import pytest
 
@@ -114,3 +115,38 @@ def test_write_json_cache_creates_parents(tmp_path: Path) -> None:
     write_json_cache(data={"a": 1}, cache_path=cache_path)
 
     assert json.loads(cache_path.read_text()) == {"a": 1}
+
+
+def test_write_json_cache_overlapping_access(tmp_path: Path) -> None:
+    """Readers and overlapping writers never see partially written JSON."""
+    cache_path = tmp_path / "data.json"
+    write_json_cache(data={"old": True}, cache_path=cache_path)
+
+    class OverlappingEncoder(json.JSONEncoder):
+        def default(self, o: Any) -> Any:
+            """Read and replace the cache while the outer write is in progress."""
+            assert read_json_cache(cache_path) == {"old": True}
+            write_json_cache(data={"other": "writer"}, cache_path=cache_path)
+            assert read_json_cache(cache_path) == {"other": "writer"}
+            return "encoded"
+
+    write_json_cache(
+        data={"new": object()},
+        cache_path=cache_path,
+        json_encoder=OverlappingEncoder,
+    )
+
+    assert read_json_cache(cache_path) == {"new": "encoded"}
+    assert list(tmp_path.iterdir()) == [cache_path]
+
+
+def test_write_json_cache_failure_preserves_cache(tmp_path: Path) -> None:
+    """A serialization failure preserves the old cache and removes temporary files."""
+    cache_path = tmp_path / "data.json"
+    write_json_cache(data={"old": True}, cache_path=cache_path)
+
+    with pytest.raises(TypeError, match="not JSON serializable"):
+        write_json_cache(data={"new": object()}, cache_path=cache_path)
+
+    assert read_json_cache(cache_path) == {"old": True}
+    assert list(tmp_path.iterdir()) == [cache_path]