pymetadata 0.6.3__tar.gz → 0.6.4__tar.gz

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

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

{pymetadata-0.6.3 → pymetadata-0.6.4}/.github/workflows/ci-cd.yml

@@ -52,7 +52,7 @@ jobs:
         persist-credentials: false
     - name: Install uv and set the python version
       # astral-sh/setup-uv publishes no floating major tag beyond v7
-      uses: astral-sh/setup-uv@v10.0.1
+      uses: astral-sh/setup-uv@v10.1.0
       with:
         python-version: ${{ matrix.python-version }}
         enable-cache: true
@@ -92,7 +92,7 @@ jobs:
       with:
         persist-credentials: false
     - name: Install uv
-      uses: astral-sh/setup-uv@v10.0.1
+      uses: astral-sh/setup-uv@v10.1.0
       with:
         python-version: "3.14"
         enable-cache: true

{pymetadata-0.6.3 → pymetadata-0.6.4}/.github/workflows/docs.yml

@@ -29,7 +29,7 @@ jobs:
       - name: Configure GitHub Pages
         uses: actions/configure-pages@v6
       - name: Install uv and set the python version
-        uses: astral-sh/setup-uv@v10.0.1
+        uses: astral-sh/setup-uv@v10.1.0
         with:
           python-version: "3.14"
           enable-cache: true

{pymetadata-0.6.3 → pymetadata-0.6.4}/.github/workflows/ty.yml

@@ -26,7 +26,7 @@ jobs:
         with:
           persist-credentials: false
       - name: Install uv and set the python version
-        uses: astral-sh/setup-uv@v10.0.1
+        uses: astral-sh/setup-uv@v10.1.0
         with:
           python-version: "3.14"
           enable-cache: true

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

@@ -8,7 +8,7 @@ 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.3"
+version: "0.6.4"
 date-released: "2026-09-07"
 doi: "10.5281/zenodo.5308801"
 license: MIT

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pymetadata
-Version: 0.6.3
+Version: 0.6.4
 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

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

@@ -51,6 +51,14 @@ RDFAnnotation(qualifier=BQB.IS, resource="https://en.wikipedia.org/wiki/Cytosol"
 
 `resource_normalized` returns `https://identifiers.org/<prefix>:<accession>`. For namespaces which embed their prefix in the identifier (GO, CHEBI, SBO, BTO) the prefix is already part of the term and is not added a second time.
 
+The normalization never changes what a resource says: `resource_normalized` is a URL, and parsing it again gives the same `collection` and `term`. A collection which is not in the identifiers.org registry, or a term which does not carry the prefix of its collection, cannot be written as a compact identifier and is returned as `https://identifiers.org/<collection>/<term>`:
+
+```python
+annotation = RDFAnnotation(qualifier=BQB.IS, resource="urn:miriam:sabiork:1406")
+print(annotation.resource_normalized)
+# https://identifiers.org/sabiork/1406
+```
+
 ## 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/release-notes/0.6.4.md

@@ -0,0 +1,13 @@
+# Release notes for pymetadata 0.6.4
+![pymetadata](./docs/images/favicon/pymetadata-100x100-300dpi.png)
+
+We are pleased to release the next version of pymetadata including the
+following changes:
+
+## Fixes
+- `Omex.from_directory`, and with it `Omex.from_omex` and `Omex.from_url`, add the entries in the order of the manifest, followed by the files which the manifest does not list, sorted by their location. The entries were added in the order of `os.walk`, which is the order of the file system, so `manifest.entries` and `entries_by_format` of the same archive differed between machines
+- `RDFAnnotation.resource_normalized` keeps the collection and the term of every resource: the result is a URL, and parsing it again gives the same `collection` and `term`. A collection which is not in the identifiers.org registry (`http://identifiers.org/sabiork/1406`, `urn:miriam:foo:bar`) was reduced to the bare term, and a term which does not match the pattern of its collection (`http://identifiers.org/chebi/000000035`) lost its collection. Both are now returned as `https://identifiers.org/<collection>/<term>`, and the compact identifier of a prefix which is not in the registry stays the URL `https://identifiers.org/CMO:0000012` (#81)
+- identifiers.org URLs of a prefix with a hyphen or an underscore, like `ec-code`, `pdb-ccd` or `go_ref`, are parsed into collection and term instead of being kept as an arbitrary URL (#81)
+- the collection of a MIRIAM URN and of the `collection/term` notation is lowercased, as it already was for URLs, so `TAXONOMY/9606` is the collection `taxonomy` (#81)
+
+Your pymetadata team

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

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

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

@@ -48,11 +48,13 @@ def get_ols_query() -> OLSQuery:
 
 
 IDENTIFIERS_ORG_PREFIX: Final = "https://identifiers.org"
+# prefixes of the registry consist of letters, digits, `.`, `_` and `-`,
+# e.g., `ec-code` or `go_ref`
 IDENTIFIERS_ORG_PATTERN_COMPACT: Final = re.compile(
-    r"^https?://identifiers.org/([a-zA-Z0-9.]+):(.+)"
+    r"^https?://identifiers.org/([a-zA-Z0-9._-]+):(.+)"
 )
 IDENTIFIERS_ORG_PATTERN_CLASSIC: Final = re.compile(
-    r"^https?://identifiers.org/([a-zA-Z0-9.]+)/(.+)"
+    r"^https?://identifiers.org/([a-zA-Z0-9._-]+)/(.+)"
 )
 
 BIOREGISTRY_PREFIX: Final = "https://bioregistry.io"
@@ -167,21 +169,15 @@ class RDFAnnotation:
             match3 = MIRIAM_URN_PATTERN.match(resource)
             if match3:
                 tokens = match3.group(1).split(":")
-                self.collection = tokens[0]
+                self.collection = tokens[0].lower()
                 self.term = ":".join(tokens[1:]).replace("%3A", ":")
                 self.provider = ProviderType.IDENTIFIERS_ORG
 
-                logger.warning(
-                    "Deprecated urn pattern `%s` updated: %s",
-                    resource,
-                    self.resource_normalized,
-                )
-
         else:
             # handle short notation
             tokens = resource.split("/")
             if len(tokens) > 1:
-                self.collection = tokens[0]
+                self.collection = tokens[0].lower()
                 self.term = "/".join(tokens[1:])
                 self.provider = ProviderType.IDENTIFIERS_ORG
             elif len(tokens) == 1 and ":" in tokens[0]:
@@ -209,6 +205,13 @@ class RDFAnnotation:
         if self.collection in self.replaced_collections:
             self.collection = self.replaced_collections[self.collection]
 
+        if resource.startswith("urn:miriam:"):
+            logger.warning(
+                "Deprecated urn pattern `%s` updated: %s",
+                resource,
+                self.resource_normalized,
+            )
+
         if validate:
             self.validate()
 
@@ -244,21 +247,33 @@ class RDFAnnotation:
         `https://identifiers.org/<prefix>:<accession>`. If the namespace is
         embedded in the LUI the prefix is already part of the term, otherwise
         the prefix of the identifiers.org registry is prepended.
+
+        The normalization never changes what the resource says: the result is
+        an url, and parsing it again yields the same `collection` and `term`.
+        A collection which is not in the registry, or a term which does not
+        carry the prefix of its collection, can not be written as a compact
+        identifier and is returned as
+        `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.
         """
         if not self.term:
             return None
 
-        if (
-            self.provider == ProviderType.IDENTIFIERS_ORG
-            and self.collection is not None
-        ):
-            namespace = get_registry().ns_dict.get(self.collection, None)
-            if namespace:
-                if namespace.namespaceEmbeddedInLui:
-                    return f"{IDENTIFIERS_ORG_PREFIX}/{self.term}"
-                return f"{IDENTIFIERS_ORG_PREFIX}/{self.collection}:{self.term}"
+        if self.provider != ProviderType.IDENTIFIERS_ORG or self.collection is None:
+            return self.term
+
+        namespace = get_registry().ns_dict.get(self.collection, None)
+        if namespace and not namespace.namespaceEmbeddedInLui:
+            return f"{IDENTIFIERS_ORG_PREFIX}/{self.collection}:{self.term}"
+
+        # the term is only a compact identifier if its prefix is the collection
+        if self.term.lower().startswith(f"{self.collection}:"):
+            return f"{IDENTIFIERS_ORG_PREFIX}/{self.term}"
 
-        return self.term
+        return f"{IDENTIFIERS_ORG_PREFIX}/{self.collection}/{self.term}"
 
     def __repr__(self) -> str:
         """Get representation string."""

{pymetadata-0.6.3 → pymetadata-0.6.4}/src/pymetadata/omex.py

@@ -743,6 +743,10 @@ class Omex:
         `Omex.guess_format`; SED-ML files added this way get `master=True`,
         as they are the entry point of a simulation study.
 
+        The entries are in the order of the manifest, followed by the files
+        which the manifest does not list, sorted by their location. The order
+        does not depend on the file system.
+
         Args:
             directory: directory with the content of the archive
 
@@ -785,7 +789,8 @@ class Omex:
         # new archive
         omex = Omex()
 
-        # iterate over all locations and add entry
+        # locations of all files
+        file_paths: dict[str, str] = {}
         for root, _dirs, files in os.walk(str(directory)):
             for file in files:
                 file_path = os.path.join(root, file)
@@ -795,32 +800,46 @@ class Omex:
                 if location == "./manifest.xml":
                     # manifest is created from the internal manifest entries
                     continue
+                file_paths[location] = file_path
+
+        # The order of `os.walk` is the order of the file system, which differs
+        # between machines: the entries are added in the order of the manifest,
+        # followed by the files which the manifest does not list, by location.
+        positions: dict[str, int] = {}
+        if manifest:
+            positions = {e.location: k for k, e in enumerate(manifest.entries)}
+        locations = sorted(
+            file_paths, key=lambda loc: (positions.get(loc, len(positions)), loc)
+        )
 
-                logger.debug("'%s' -> '%s'", file_path, location)
-                entry: ManifestEntry
-                if manifest and location in manifest:
-                    # use entry from existing manifest
-                    entry = manifest[location]
-                else:
-                    if manifest and location not in manifest:
-                        logger.warning(
-                            "Entry with location missing in manifest.xml: '%s'",
-                            location,
-                        )
-
-                    format = Omex.guess_format(Path(file_path))
-                    master = False
-                    if format and ManifestEntry.is_format(
-                        format_key="sedml", format=format
-                    ):
-                        master = True
-                    entry = ManifestEntry(
-                        location=location,
-                        format=format,
-                        master=master,
+        # iterate over all locations and add entry
+        for location in locations:
+            file_path = file_paths[location]
+            logger.debug("'%s' -> '%s'", file_path, location)
+            entry: ManifestEntry
+            if manifest and location in manifest:
+                # use entry from existing manifest
+                entry = manifest[location]
+            else:
+                if manifest and location not in manifest:
+                    logger.warning(
+                        "Entry with location missing in manifest.xml: '%s'",
+                        location,
                     )
 
-                omex.add_entry(entry_path=Path(file_path), entry=entry)
+                format = Omex.guess_format(Path(file_path))
+                master = False
+                if format and ManifestEntry.is_format(
+                    format_key="sedml", format=format
+                ):
+                    master = True
+                entry = ManifestEntry(
+                    location=location,
+                    format=format,
+                    master=master,
+                )
+
+            omex.add_entry(entry_path=Path(file_path), entry=entry)
 
         return omex
 

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

@@ -227,3 +227,82 @@ def test_resource_normalized(resource: str, expected: str) -> None:
     """Test normalization to identifiers.org compact identifiers."""
     a = RDFAnnotation(qualifier=BQB.IS, resource=resource)
     assert a.resource_normalized == expected
+
+
+resource_kept_data = [
+    # collection which is not in the registry (see #81)
+    ("http://identifiers.org/sabiork/1406", "https://identifiers.org/sabiork/1406"),
+    ("urn:miriam:foo:bar", "https://identifiers.org/foo/bar"),
+    ("foo/bar", "https://identifiers.org/foo/bar"),
+    # collection which is not in the registry, term with a prefix of its own
+    (
+        "http://identifiers.org/unit/UO:0000040",
+        "https://identifiers.org/unit/UO:0000040",
+    ),
+    # compact identifier of a prefix which is not in the registry
+    ("https://identifiers.org/CMO:0000012", "https://identifiers.org/CMO:0000012"),
+    ("CMO:0000012", "https://identifiers.org/CMO:0000012"),
+    # term which does not match the pattern of its collection
+    (
+        "http://identifiers.org/chebi/000000035",
+        "https://identifiers.org/chebi/000000035",
+    ),
+    ("taxonomy/abc", "https://identifiers.org/taxonomy:abc"),
+    # prefix with a hyphen or an underscore
+    ("urn:miriam:ec-code:1.1.1.1", "https://identifiers.org/ec-code:1.1.1.1"),
+    (
+        "https://identifiers.org/ec-code/1.1.1.1",
+        "https://identifiers.org/ec-code:1.1.1.1",
+    ),
+    ("go_ref/GO_REF:0000041", "https://identifiers.org/GO_REF:0000041"),
+    (
+        "https://identifiers.org/GO_REF:0000041",
+        "https://identifiers.org/GO_REF:0000041",
+    ),
+    # prefixes are case insensitive
+    ("urn:miriam:CHEBI:CHEBI%3A33699", "https://identifiers.org/CHEBI:33699"),
+    ("TAXONOMY/9606", "https://identifiers.org/taxonomy:9606"),
+]
+
+
+def assert_resource_kept(resource: str) -> None:
+    """Assert that the normalized resource is a url with the same meaning."""
+    a = RDFAnnotation(qualifier=BQB.IS, resource=resource, validate=False)
+    normalized = a.resource_normalized
+    assert normalized
+    assert normalized.startswith("https://")
+
+    b = RDFAnnotation(qualifier=BQB.IS, resource=normalized, validate=False)
+    assert (b.collection, b.term) == (a.collection, a.term)
+    assert b.resource_normalized == normalized
+
+
+@pytest.mark.parametrize("resource,expected", resource_kept_data)
+def test_resource_normalized_keeps_resource(resource: str, expected: str) -> None:
+    """Test that collection and term survive the normalization, see #81."""
+    a = RDFAnnotation(qualifier=BQB.IS, resource=resource, validate=False)
+    assert a.resource_normalized == expected
+    assert_resource_kept(resource)
+
+
+@pytest.mark.parametrize(
+    "resource", [resource for resource, _ in resource_normalized_data]
+)
+def test_resource_normalized_roundtrip(resource: str) -> None:
+    """Test that the normalized resource parses to the same annotation."""
+    assert_resource_kept(resource)
+
+
+def test_resource_normalized_registry() -> None:
+    """Test the normalization with the sample of every registry namespace."""
+    from pymetadata.webservices.registry import get_registry
+
+    for prefix, namespace in get_registry().ns_dict.items():
+        sample_id = namespace.sampleId
+        if not sample_id:
+            continue
+        for resource in [
+            f"https://identifiers.org/{prefix}/{sample_id}",
+            f"urn:miriam:{prefix}:{sample_id.replace(':', '%3A')}",
+        ]:
+            assert_resource_kept(resource)

{pymetadata-0.6.3 → pymetadata-0.6.4}/tests/test_omex.py

@@ -272,3 +272,66 @@ def test_manifest_without_namespace(tmp_path: Path) -> None:
     manifest = Manifest.from_manifest(manifest_path)
     assert len(manifest) == 2
     assert manifest["./model.xml"].master is True
+
+
+# locations of a manifest in an order which is neither sorted nor the order in
+# which the files are created, so that no file system returns it by chance
+ORDERED_LOCATIONS = [
+    f"./{directory}{name}.xml"
+    for name in ["m", "b", "z", "a", "q", "c", "y", "d"]
+    for directory in ["models/", "", "data/"]
+]
+
+
+def _ordered_directory(directory: Path, locations: list[str]) -> Path:
+    """Write the files of all locations and a manifest which lists `locations`."""
+    for location in sorted(ORDERED_LOCATIONS):
+        path = directory / location
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text("<sbml/>")
+
+    manifest = Manifest()
+    for location in locations:
+        manifest.add_entry(ManifestEntry(location=location, format="sbml"))
+    manifest.to_manifest(directory / "manifest.xml")
+    return directory
+
+
+def test_from_directory_keeps_manifest_order(tmp_path: Path) -> None:
+    """The entries of a directory are in the order of its manifest.
+
+    The order in which the file system returns the files differs between
+    machines and must not be the order of the entries.
+    """
+    directory = _ordered_directory(tmp_path, ORDERED_LOCATIONS)
+    omex = Omex.from_directory(directory)
+    locations = [entry.location for entry in omex.manifest.entries]
+    assert locations == [".", "./manifest.xml", *ORDERED_LOCATIONS]
+
+
+def test_from_directory_appends_unlisted_files(tmp_path: Path) -> None:
+    """Files which the manifest does not list follow the listed ones, sorted."""
+    listed = ORDERED_LOCATIONS[:5]
+    directory = _ordered_directory(tmp_path, listed)
+    omex = Omex.from_directory(directory)
+    locations = [entry.location for entry in omex.manifest.entries]
+    unlisted = sorted(set(ORDERED_LOCATIONS) - set(listed))
+    assert locations == [".", "./manifest.xml", *listed, *unlisted]
+
+
+def test_from_directory_without_manifest_is_sorted(tmp_path: Path) -> None:
+    """Without a manifest the entries are sorted by their location."""
+    directory = _ordered_directory(tmp_path, [])
+    (directory / "manifest.xml").unlink()
+    omex = Omex.from_directory(directory)
+    locations = [entry.location for entry in omex.manifest.entries]
+    assert locations == [".", "./manifest.xml", *sorted(ORDERED_LOCATIONS)]
+
+
+def test_omex_roundtrip_keeps_manifest_order(tmp_path: Path) -> None:
+    """The order of the entries survives writing and reading an archive."""
+    omex = Omex.from_directory(_ordered_directory(tmp_path / "in", ORDERED_LOCATIONS))
+    omex_path = tmp_path / "ordered.omex"
+    omex.to_omex(omex_path)
+    locations = [entry.location for entry in Omex.from_omex(omex_path).manifest.entries]
+    assert locations == [".", "./manifest.xml", *ORDERED_LOCATIONS]