pymetadata 0.5.4__tar.gz → 0.5.5__tar.gz

{pymetadata-0.5.4 → pymetadata-0.5.5}/.bumpversion.toml

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

{pymetadata-0.5.4 → pymetadata-0.5.5}/.gitignore

@@ -1,3 +1,4 @@
+uv.lock
 .vscode
 *.pyc
 *~

{pymetadata-0.5.4 → pymetadata-0.5.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pymetadata
-Version: 0.5.4
+Version: 0.5.5
 Summary: pymetadata are python utilities for working with metadata.
 Author-email: Matthias König <konigmatt@googlemail.com>
 Maintainer-email: Matthias König <konigmatt@googlemail.com>
@@ -28,14 +28,14 @@ Requires-Dist: requests>=2.32.3
 Requires-Dist: rich>=13.9.4
 Requires-Dist: xmltodict>=0.14.2
 Provides-Extra: dev
-Requires-Dist: bump-my-version>=0.29.0; extra == 'dev'
-Requires-Dist: mypy>=1.9.0; extra == 'dev'
+Requires-Dist: bump-my-version>=1.2.4; extra == 'dev'
+Requires-Dist: mypy>=1.18.2; extra == 'dev'
 Requires-Dist: pre-commit>=4.0.1; extra == 'dev'
-Requires-Dist: ruff>=0.8.6; extra == 'dev'
+Requires-Dist: ruff>=0.14.0; extra == 'dev'
 Provides-Extra: test
-Requires-Dist: pytest-cov>=5.0.0; extra == 'test'
-Requires-Dist: pytest>=8.1.1; extra == 'test'
-Requires-Dist: tox>=4.14.2; extra == 'test'
+Requires-Dist: pytest-cov>=7.0.0; extra == 'test'
+Requires-Dist: pytest>=8.4.2; extra == 'test'
+Requires-Dist: tox>=4.31.0; extra == 'test'
 Description-Content-Type: text/markdown
 
 ![pymetadata logo](https://github.com/matthiaskoenig/pymetadata/raw/develop/docs/images/favicon/pymetadata-100x100-300dpi.png)

{pymetadata-0.5.4 → pymetadata-0.5.5}/docs/composite_annotations.md

@@ -2,7 +2,7 @@
 
 Composite annotations are semantic annotations that are comprised of multiple annotation
 terms linked using  standard  qualifiers  (also  known  as  “relations”  or  “predicates”)
-to  indicate  the  meaning  of  anannotation.
+to  indicate  the  meaning  of  annotation.
 Composite annotations are used when a single knowledge resource term is not available to
 sufficiently define a model or data element.  For model-component annotations,
 composite annotations have two primary components:

{pymetadata-0.5.4 → pymetadata-0.5.5}/pyproject.toml

@@ -49,15 +49,15 @@ dependencies = [
 
 [project.optional-dependencies]
 dev = [
-    "bump-my-version>=0.29.0",
-	"ruff>=0.8.6",
+    "bump-my-version>=1.2.4",
+	"ruff>=0.14.0",
 	"pre-commit>=4.0.1",
-	"mypy>=1.9.0",
+	"mypy>=1.18.2",
 ]
 test = [
-    "tox>=4.14.2",
-    "pytest>=8.1.1",
-    "pytest-cov>=5.0.0",
+    "tox>=4.31.0",
+    "pytest>=8.4.2",
+    "pytest-cov>=7.0.0",
 ]
 
 [project_urls]

pymetadata-0.5.5/release-notes/0.5.5.md

@@ -0,0 +1,13 @@
+# Release notes for pymetadata 0.5.5
+![pymetadata](https://github.com/matthiaskoenig/pymetadata/raw/develop/docs/images/favicon/pymetadata-100x100-300dpi.png)
+
+We are pleased to release the next version of pymetadata including the
+following changes:
+
+## Features & fixes
+- remove custom namespaces (#62)
+- better support of compact identifiers.org identifiers (#63)
+- support of bioregistry.io as provider (#40)
+- updated ECO ontology
+
+Your pymetadata team

{pymetadata-0.5.4 → pymetadata-0.5.5}/src/pymetadata/__init__.py

@@ -3,7 +3,7 @@
 from pathlib import Path
 
 __author__ = "Matthias Koenig"
-__version__ = "0.5.4"
+__version__ = "0.5.5"
 
 
 program_name: str = "pymetadata"

{pymetadata-0.5.4 → pymetadata-0.5.5}/src/pymetadata/core/annotation.py

@@ -5,12 +5,14 @@ Core data structure to store annotations.
 
 import re
 import urllib
+from enum import Enum
 from pprint import pprint
 from typing import Any, Dict, Final, List, Optional, Tuple, Union
 
 import requests
 
 from pymetadata import log
+from pymetadata.console import console
 from pymetadata.core.xref import CrossReference, is_url
 from pymetadata.identifiers.miriam import BQB, BQM
 from pymetadata.identifiers.registry import REGISTRY
@@ -19,19 +21,31 @@ from pymetadata.ontologies.ols import ONTOLOGIES, OLSQuery
 
 OLS_QUERY = OLSQuery(ontologies=ONTOLOGIES)
 
-IDENTIFIERS_ORG_PREFIX: Final = "http://identifiers.org"
+IDENTIFIERS_ORG_PREFIX: Final = "https://identifiers.org"
 IDENTIFIERS_ORG_PATTERN1: Final = re.compile(r"^https?://identifiers.org/(.+?)/(.+)")
 IDENTIFIERS_ORG_PATTERN2: Final = re.compile(r"^https?://identifiers.org/(.+)")
+
+BIOREGISTRY_PREFIX: Final = "https://bioregistry.io"
+BIOREGISTRY_PATTERN: Final = re.compile(r"^https?://bioregistry.io/(.+)")
+
 MIRIAM_URN_PATTERN: Final = re.compile(r"^urn:miriam:(.+)")
 
 logger = log.get_logger(__name__)
 
 
+class ProviderType(str, Enum):
+    """Provider type."""
+
+    IDENTIFIERS_ORG = "identifiers.org"
+    BIOREGISTRY_IO = "bioregistry.io"
+    NONE = "none"
+
+
 class RDFAnnotation:
     """RDFAnnotation class.
 
     Basic storage of annotation information. This consists of the relation
-    and the the resource.
+    and the resource.
     The annotations can be attached to other objects thereby forming
     triples which can be converted to RDF.
 
@@ -40,6 +54,7 @@ class RDFAnnotation:
         - `collection/term`, i.e., the combination of collection and term
         - `http(s)://arbitrary.url`, an arbitrary URL
         - urn:miriam:uniprot:P03023
+        - https://bioregistry.io/chebi:15996 urls via the bioregistry provider
     """
 
     replaced_collections: Dict[str, str] = {
@@ -53,6 +68,7 @@ class RDFAnnotation:
         self.collection: Optional[str] = None
         self.term: Optional[str] = None
         self.resource: str = resource
+        self.provider: ProviderType = ProviderType.IDENTIFIERS_ORG
 
         if not qualifier:
             raise ValueError(
@@ -75,15 +91,19 @@ class RDFAnnotation:
             if match1:
                 # handle identifiers.org pattern
                 self.collection, self.term = match1.group(1), match1.group(2)
+                self.provider = ProviderType.IDENTIFIERS_ORG
 
             if not self.collection:
-                # tests new short pattern
+                # tests new compact patterns
                 match2 = IDENTIFIERS_ORG_PATTERN2.match(resource)
                 if match2:
                     tokens = match2.group(1).split(":")
                     if len(tokens) == 2:
                         self.collection = tokens[0].lower()
+
+                        # check if the namespace is embedded
                         self.term = match2.group(1)
+                        self.provider = ProviderType.IDENTIFIERS_ORG
                     else:
                         logger.warning(
                             f"Identifiers.org URL does not conform to new"
@@ -94,10 +114,16 @@ class RDFAnnotation:
                 # other urls are directly stored as resources without collection
                 self.collection = None
                 self.term = resource
-                logger.debug(
-                    f"{resource} does not conform to "
-                    f"http(s)://identifiers.org/collection/id or http(s)://identifiers.org/id",
-                )
+                if BIOREGISTRY_PATTERN.match(resource):
+                    self.provider = ProviderType.BIOREGISTRY_IO
+                    console.print(self.provider)
+                else:
+                    self.provider = ProviderType.NONE
+                    logger.warning(
+                        f"{resource} does not conform to "
+                        f"http(s)://identifiers.org/collection/id or http(s)://identifiers.org/id or "
+                        f"https://bioregistry.io/id .",
+                    )
 
         # handle urns
         elif resource.startswith("urn:miriam:"):
@@ -106,6 +132,7 @@ class RDFAnnotation:
                 tokens = match3.group(1).split(":")
                 self.collection = tokens[0]
                 self.term = ":".join(tokens[1:]).replace("%3A", ":")
+                self.provider = ProviderType.IDENTIFIERS_ORG
 
                 logger.warning(
                     f"Deprecated urn pattern `{resource}` updated: "
@@ -118,9 +145,11 @@ class RDFAnnotation:
             if len(tokens) > 1:
                 self.collection = tokens[0]
                 self.term = "/".join(tokens[1:])
+                self.provider = ProviderType.IDENTIFIERS_ORG
             elif len(tokens) == 1 and ":" in tokens[0]:
                 self.collection = tokens[0].split(":")[0].lower()
                 self.term = tokens[0]
+                self.provider = ProviderType.IDENTIFIERS_ORG
 
             # validation
             if len(tokens) < 2 and not self.collection:
@@ -132,6 +161,13 @@ class RDFAnnotation:
                 )
                 self.collection = None
                 self.term = resource
+                self.provider = ProviderType.NONE
+
+        # shorten compact terms
+        if self.term and self.collection:
+            self.term = self.shorten_compact_term(
+                term=self.term, collection=self.collection
+            )
 
         # clean legacy collections
         if self.collection in self.replaced_collections:
@@ -139,6 +175,21 @@ class RDFAnnotation:
 
         self.validate()
 
+    @staticmethod
+    def shorten_compact_term(term: str, collection: str) -> str:
+        """Shorten the compact terms and return term.
+
+        If the namespace is not embeddd in the term return the shortened term.
+        """
+        namespace = REGISTRY.ns_dict.get(collection, None)
+        if namespace and not namespace.namespaceEmbeddedInLui:
+            # shorter term
+            if term.lower().startswith(collection):
+                tokens = term.split(":")
+                term = ":".join(tokens[1:])
+
+        return term
+
     @staticmethod
     def from_tuple(t: Tuple[Union[BQB, BQM], str]) -> "RDFAnnotation":
         """Construct from tuple."""
@@ -164,12 +215,12 @@ class RDFAnnotation:
 
     def __repr__(self) -> str:
         """Get representation string."""
-        return f"RDFAnnotation({self.qualifier}|{self.collection}|{self.term})"
+        return f"RDFAnnotation({self.qualifier}|{self.collection}|{self.term}|{self.provider.value})"
 
     def to_dict(self) -> Dict:
         """Convert to dict."""
         return {
-            "qualifier": self.qualifier.value,  # FIXME use enums!
+            "qualifier": self.qualifier.value,
             "collection": self.collection,
             "term": self.term,
         }
@@ -346,52 +397,59 @@ class RDFAnnotationData(RDFAnnotation):
 
 if __name__ == "__main__":
     for annotation in [
-        # FIXME: support this
-        RDFAnnotation(
-            qualifier=BQB.IS_VERSION_OF,
-            resource="NCIT:C75913",
-        ),
-        RDFAnnotation(
-            qualifier=BQB.IS_VERSION_OF,
-            resource="taxonomy/562",
-        ),
-        RDFAnnotation(
-            qualifier=BQB.IS_VERSION_OF,
-            resource="http://identifiers.org/taxonomy/9606",
-        ),
         RDFAnnotation(
             qualifier=BQB.IS_VERSION_OF,
-            resource="http://identifiers.org/biomodels.sbo/SBO:0000247",
-        ),
-        RDFAnnotation(
-            qualifier=BQB.IS_VERSION_OF, resource="urn:miriam:obo.go:GO%3A0005623"
-        ),
-        RDFAnnotation(
-            qualifier=BQB.IS_VERSION_OF, resource="urn:miriam:chebi:CHEBI%3A33699"
-        ),
-        RDFAnnotation(qualifier=BQB.IS_VERSION_OF, resource="chebi/CHEBI:456215"),
-        RDFAnnotation(
-            qualifier=BQB.IS, resource="https://en.wikipedia.org/wiki/Cytosol"
-        ),
-        RDFAnnotation(
-            qualifier=BQB.IS_VERSION_OF, resource="urn:miriam:uniprot:P03023"
-        ),
-        RDFAnnotation(
-            qualifier=BQB.IS_VERSION_OF,
-            resource="http://identifiers.org/go/GO:0005829",
-        ),
-        RDFAnnotation(
-            qualifier=BQB.IS_VERSION_OF, resource="http://identifiers.org/go/GO:0005829"
-        ),
-        RDFAnnotation(
-            qualifier=BQB.IS_VERSION_OF, resource="http://identifiers.org/GO:0005829"
-        ),
-        RDFAnnotation(
-            qualifier=BQB.IS_VERSION_OF, resource="http://identifiers.org/GO:0005829"
+            resource="https://bioregistry.io/chebi:15996",
         ),
-        RDFAnnotation(qualifier=BQB.IS_VERSION_OF, resource="bto/BTO:0000089"),
-        RDFAnnotation(qualifier=BQB.IS_VERSION_OF, resource="BTO:0000089"),
-        RDFAnnotation(qualifier=BQB.IS_VERSION_OF, resource="chebi/CHEBI:000012"),
+        # RDFAnnotation(
+        #     qualifier=BQB.IS_VERSION_OF,
+        #     resource="NCIT:C75913",
+        # ),
+        # RDFAnnotation(
+        #     qualifier=BQB.IS_VERSION_OF,
+        #     resource="ncit:C75913",
+        # ),
+        # RDFAnnotation(
+        #     qualifier=BQB.IS_VERSION_OF,
+        #     resource="taxonomy/562",
+        # ),
+        # RDFAnnotation(
+        #     qualifier=BQB.IS_VERSION_OF,
+        #     resource="http://identifiers.org/taxonomy/9606",
+        # ),
+        # RDFAnnotation(
+        #     qualifier=BQB.IS_VERSION_OF,
+        #     resource="http://identifiers.org/biomodels.sbo/SBO:0000247",
+        # ),
+        # RDFAnnotation(
+        #     qualifier=BQB.IS_VERSION_OF, resource="urn:miriam:obo.go:GO%3A0005623"
+        # ),
+        # RDFAnnotation(
+        #     qualifier=BQB.IS_VERSION_OF, resource="urn:miriam:chebi:CHEBI%3A33699"
+        # ),
+        # RDFAnnotation(qualifier=BQB.IS_VERSION_OF, resource="chebi/CHEBI:456215"),
+        # RDFAnnotation(
+        #     qualifier=BQB.IS, resource="https://en.wikipedia.org/wiki/Cytosol"
+        # ),
+        # RDFAnnotation(
+        #     qualifier=BQB.IS_VERSION_OF, resource="urn:miriam:uniprot:P03023"
+        # ),
+        # RDFAnnotation(
+        #     qualifier=BQB.IS_VERSION_OF,
+        #     resource="http://identifiers.org/go/GO:0005829",
+        # ),
+        # RDFAnnotation(
+        #     qualifier=BQB.IS_VERSION_OF, resource="http://identifiers.org/go/GO:0005829"
+        # ),
+        # RDFAnnotation(
+        #     qualifier=BQB.IS_VERSION_OF, resource="http://identifiers.org/GO:0005829"
+        # ),
+        # RDFAnnotation(
+        #     qualifier=BQB.IS_VERSION_OF, resource="http://identifiers.org/GO:0005829"
+        # ),
+        # RDFAnnotation(qualifier=BQB.IS_VERSION_OF, resource="bto/BTO:0000089"),
+        # RDFAnnotation(qualifier=BQB.IS_VERSION_OF, resource="BTO:0000089"),
+        # RDFAnnotation(qualifier=BQB.IS_VERSION_OF, resource="chebi/CHEBI:000012"),
     ]:
         print("-" * 80)
         data = RDFAnnotationData(annotation)

pymetadata-0.5.5/src/pymetadata/identifiers/registry.py

@@ -0,0 +1,173 @@
+"""
+Helper tools to work with identifiers registry.
+
+https://identifiers.org/
+https://docs.identifiers.org/articles/api.html
+"""
+
+from __future__ import annotations
+
+import inspect
+import os
+import time
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+import requests
+
+import pymetadata
+from pymetadata import log
+from pymetadata.cache import DataclassJSONEncoder, read_json_cache, write_json_cache
+from pymetadata.console import console
+
+logger = log.get_logger(__name__)
+
+
+@dataclass
+class Resource:
+    """Resource."""
+
+    id: Optional[int]
+    providerCode: str
+    name: str
+    urlPattern: str
+    mirId: Optional[str] = field(repr=False)
+    description: str = field(repr=False)
+    official: bool = field(repr=False)
+
+    sampleId: Optional[str] = field(repr=False)
+    resourceHomeUrl: Optional[str] = field(repr=False)
+    institution: dict = field(repr=False)
+    location: dict = field(repr=False)
+    deprecated: bool = field(repr=False)
+    deprecationDate: str = field(repr=False)
+    protectedUrls: bool = field(repr=False, default=False)
+    renderProtectedLanding: bool = field(repr=False, default=False)
+    authHelpUrl: Optional[str] = field(repr=False, default=None)
+    authHelpDescription: Optional[str] = field(repr=False, default=None)
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> Resource:
+        """Handle additional keyword arguments."""
+        return cls(
+            **{k: v for k, v in d.items() if k in inspect.signature(cls).parameters}
+        )
+
+
+@dataclass
+class Namespace:
+    """Namespace."""
+
+    id: Optional[str]
+    prefix: Optional[str]
+    name: str
+    pattern: str
+    namespaceEmbeddedInLui: bool
+    description: str = field(repr=False)
+    mirId: Optional[str] = field(repr=False, default=None)
+    resources: Optional[List] = field(repr=False, default=None)
+    created: Optional[str] = field(repr=False, default=None)
+    modified: Optional[str] = field(repr=False, default=None)
+    sampleId: Optional[str] = field(repr=False, default=None)
+    deprecated: bool = field(repr=False, default=False)
+    deprecationDate: Optional[str] = field(repr=False, default=None)
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> Namespace:
+        """Handle additional keyword arguments."""
+        return cls(
+            **{k: v for k, v in d.items() if k in inspect.signature(cls).parameters}
+        )
+
+    def __post_init__(self) -> None:
+        """Set resources."""
+        if self.resources is not None:
+            self.resources = [Resource.from_dict(d) for d in self.resources]
+        else:
+            self.resources = list()
+
+
+class Registry:
+    """Managing the available annotation information.
+
+    Registry of meta information.
+    """
+
+    URL = "https://registry.api.identifiers.org/resolutionApi/getResolverDataset"
+
+    def __init__(
+        self,
+        cache_duration: int = 24,
+        cache: bool = True,
+    ):
+        """Initialize registry.
+
+        :param cache_path: Path of cached identifiers.org path
+        :param cache_duration: Duration of caching in hours.
+        :param cache: boolean flag to stop caching
+        """
+        self.registry_path = pymetadata.CACHE_PATH / "identifiers_registry.json"
+
+        # check if update needed
+        if cache:
+            if os.path.exists(self.registry_path):
+                registry_age = (
+                    time.time() - os.path.getmtime(self.registry_path)
+                ) / 3600  # [hr]
+                update = registry_age > cache_duration
+            else:
+                update = True
+        else:
+            update = True
+
+        self.ns_dict: Dict[str, Namespace] = (
+            self.update() if update else Registry.load_registry(self.registry_path)
+        )
+
+    def update(self) -> Dict[str, Namespace]:
+        """Update registry."""
+        Registry.update_registry(registry_path=self.registry_path)
+        return Registry.load_registry(registry_path=self.registry_path)
+
+    @staticmethod
+    def update_registry(
+        registry_path: Optional[Path] = None,
+    ) -> Dict[str, Namespace]:
+        """Update registry from identifiers.org webservice."""
+        logger.info(f"Update registry from '{Registry.URL}'")
+        response = requests.get(Registry.URL)
+        namespaces = response.json()["payload"]["namespaces"]
+
+        ns_dict = {}
+        for _, data in enumerate(namespaces):
+            ns = Namespace.from_dict(data)
+            ns_dict[ns.prefix] = ns
+
+        if registry_path is not None:
+            write_json_cache(
+                data=ns_dict,
+                cache_path=registry_path,
+                json_encoder=DataclassJSONEncoder,
+            )
+
+        return ns_dict  # type: ignore
+
+    @staticmethod
+    def load_registry(registry_path: Path) -> Dict[str, Namespace]:
+        """Load namespaces with resources from path."""
+        if not registry_path.exists():
+            Registry.update_registry(registry_path=registry_path)
+
+        d = read_json_cache(cache_path=registry_path)
+        if not d:
+            raise ValueError("Registry could not be loaded from cache.")
+
+        return {k: Namespace(**v) for k, v in d.items()}
+
+
+REGISTRY = Registry()
+
+if __name__ == "__main__":
+    registry = Registry(cache=False)
+    console.print(registry.ns_dict)