pyobo 0.10.12__py3-none-any.whl → 0.11.0__py3-none-any.whl

pyobo/aws.py

@@ -1,10 +1,8 @@
-# -*- coding: utf-8 -*-
-
 """Interface for caching data on AWS S3."""
 
 import logging
 import os
-from typing import Optional, Set
+from typing import Optional
 
 import boto3
 import humanize
@@ -57,8 +55,8 @@ def download_artifacts(bucket: str, suffix: Optional[str] = None) -> None:
 
 def upload_artifacts(
     bucket: str,
-    whitelist: Optional[Set[str]] = None,
-    blacklist: Optional[Set[str]] = None,
+    whitelist: Optional[set[str]] = None,
+    blacklist: Optional[set[str]] = None,
     s3_client=None,
 ) -> None:
     """Upload all artifacts to AWS."""

pyobo/cli/__init__.py

@@ -1,5 +1,3 @@
-# -*- coding: utf-8 -*-
-
 """CLI for PyOBO."""
 
 from .cli import main

pyobo/cli/aws.py

@@ -1,5 +1,3 @@
-# -*- coding: utf-8 -*-
-
 """CLI for PyOBO's interface to S3."""
 
 import click

pyobo/cli/cli.py

@@ -1,5 +1,3 @@
-# -*- coding: utf-8 -*-
-
 """CLI for PyOBO."""
 
 import logging
@@ -15,7 +13,6 @@ from tabulate import tabulate
 from .aws import main as aws_main
 from .database import main as database_main
 from .lookup import lookup
-from ..apps.cli import main as apps_main
 from ..constants import RAW_DIRECTORY
 from ..plugins import has_nomenclature_plugin, iter_nomenclature_plugins
 from ..registries import iter_cached_obo
@@ -116,7 +113,6 @@ def remapping(file):
 
 
 main.add_command(lookup)
-main.add_command(apps_main)
 main.add_command(aws_main)
 main.add_command(database_main)
 

pyobo/cli/database.py

@@ -1,5 +1,3 @@
-# -*- coding: utf-8 -*-
-
 """CLI for PyOBO Database Generation."""
 
 import logging
@@ -317,7 +315,7 @@ def properties(directory: str, zenodo: bool, force: bool, no_strict: bool):
 @zenodo_option
 @force_option
 @no_strict_option
-def xrefs(directory: str, zenodo: bool, force: bool, no_strict: bool):  # noqa: D202
+def xrefs(directory: str, zenodo: bool, force: bool, no_strict: bool):
     """Make the prefix-identifier-xref dump."""
     with logging_redirect_tqdm():
         paths = db_output_helper(

pyobo/cli/lookup.py

@@ -1,5 +1,3 @@
-# -*- coding: utf-8 -*-
-
 """CLI for PyOBO lookups."""
 
 import json

pyobo/cli/utils.py

@@ -1,5 +1,3 @@
-# -*- coding: utf-8 -*-
-
 """Utilities for the CLI."""
 
 import datetime

pyobo/constants.py

@@ -1,10 +1,6 @@
-# -*- coding: utf-8 -*-
-
 """Constants for PyOBO."""
 
-import json
 import logging
-import os
 import re
 
 import pystow
@@ -13,7 +9,6 @@ __all__ = [
     "RAW_DIRECTORY",
     "DATABASE_DIRECTORY",
     "SPECIES_REMAPPING",
-    "VERSION_PINS",
 ]
 
 logger = logging.getLogger(__name__)
@@ -101,31 +96,3 @@ PROVENANCE_PREFIXES = {
     "isbn",
     "issn",
 }
-
-# Load version pin dictionary from the environmental variable VERSION_PINS
-try:
-    VERSION_PINS_STR = os.getenv("VERSION_PINS")
-    if not VERSION_PINS_STR:
-        VERSION_PINS = {}
-    else:
-        VERSION_PINS = json.loads(VERSION_PINS_STR)
-        for k, v in VERSION_PINS.items():
-            if not isinstance(k, str) or not isinstance(v, str):
-                logger.error("The prefix and version name must both be " "strings")
-            VERSION_PINS = {}
-            break
-except ValueError as e:
-    logger.error(
-        "The value for the environment variable VERSION_PINS must be a valid JSON string: %s" % e
-    )
-    VERSION_PINS = {}
-
-if VERSION_PINS:
-    logger.debug(
-        f"These are the resource versions that are pinned.\n{VERSION_PINS}. "
-        f"\nPyobo will download the latest version of a resource if it's "
-        f"not pinned.\nIf you want to use a specific version of a "
-        f"resource, edit your VERSION_PINS environmental "
-        f"variable which is a JSON string to include a prefix and version "
-        f"name."
-    )

pyobo/getters.py

@@ -1,5 +1,3 @@
-# -*- coding: utf-8 -*-
-
 """Utilities for OBO files."""
 
 import datetime
@@ -11,16 +9,11 @@ import subprocess
 import typing
 import urllib.error
 from collections import Counter
+from collections.abc import Iterable, Mapping, Sequence
 from pathlib import Path
 from typing import (
     Callable,
-    Iterable,
-    List,
-    Mapping,
     Optional,
-    Sequence,
-    Set,
-    Tuple,
     TypeVar,
     Union,
 )
@@ -30,7 +23,7 @@ from bioontologies import robot
 from tqdm.auto import tqdm
 
 from .constants import DATABASE_DIRECTORY
-from .identifier_utils import MissingPrefix, wrap_norm_prefix
+from .identifier_utils import MissingPrefixError, wrap_norm_prefix
 from .plugins import has_nomenclature_plugin, run_nomenclature_plugin
 from .struct import Obo
 from .utils.io import get_writer
@@ -39,17 +32,17 @@ from .version import get_git_hash, get_version
 
 __all__ = [
     "get_ontology",
-    "NoBuild",
+    "NoBuildError",
 ]
 
 logger = logging.getLogger(__name__)
 
 
-class NoBuild(RuntimeError):
+class NoBuildError(RuntimeError):
     """Base exception for being unable to build."""
 
 
-class UnhandledFormat(NoBuild):
+class UnhandledFormatError(NoBuildError):
     """Only OWL is available."""
 
 
@@ -117,7 +110,7 @@ def get_ontology(
 
     ontology_format, path = _ensure_ontology_path(prefix, force=force, version=version)
     if path is None:
-        raise NoBuild(prefix)
+        raise NoBuildError(prefix)
     elif ontology_format == "obo":
         pass  # all gucci
     elif ontology_format == "owl":
@@ -127,7 +120,7 @@ def get_ontology(
         robot.convert(path, _converted_obo_path, check=robot_check)
         path = _converted_obo_path
     else:
-        raise UnhandledFormat(f"[{prefix}] unhandled ontology file format: {path.suffix}")
+        raise UnhandledFormatError(f"[{prefix}] unhandled ontology file format: {path.suffix}")
 
     from .reader import from_obo_path
 
@@ -147,8 +140,8 @@ def get_ontology(
 
 def _ensure_ontology_path(
     prefix: str, force, version
-) -> Union[Tuple[str, Path], Tuple[None, None]]:
-    for ontology_format, url in [  # noqa:B007
+) -> Union[tuple[str, Path], tuple[None, None]]:
+    for ontology_format, url in [
         ("obo", bioregistry.get_obo_download(prefix)),
         ("owl", bioregistry.get_owl_download(prefix)),
         ("json", bioregistry.get_json_download(prefix)),
@@ -246,7 +239,7 @@ def iter_helper(
     leave: bool = False,
     strict: bool = True,
     **kwargs,
-) -> Iterable[Tuple[str, str, X]]:
+) -> Iterable[tuple[str, str, X]]:
     """Yield all mappings extracted from each database given."""
     for prefix, mapping in iter_helper_helper(f, strict=strict, **kwargs):
         it = tqdm(
@@ -266,7 +259,7 @@ def _prefixes(
     skip_below: Optional[str] = None,
     skip_below_inclusive: bool = True,
     skip_pyobo: bool = False,
-    skip_set: Optional[Set[str]] = None,
+    skip_set: Optional[set[str]] = None,
 ) -> Iterable[str]:
     for prefix, resource in sorted(bioregistry.read_registry().items()):
         if resource.no_own_terms:
@@ -299,10 +292,10 @@ def iter_helper_helper(
     skip_below: Optional[str] = None,
     skip_below_inclusive: bool = True,
     skip_pyobo: bool = False,
-    skip_set: Optional[Set[str]] = None,
+    skip_set: Optional[set[str]] = None,
     strict: bool = True,
     **kwargs,
-) -> Iterable[Tuple[str, X]]:
+) -> Iterable[tuple[str, X]]:
     """Yield all mappings extracted from each database given.
 
     :param f: A function that takes a prefix and gives back something that will be used by an outer function.
@@ -342,13 +335,13 @@ def iter_helper_helper(
             logger.warning("[%s] unable to download", prefix)
             if strict and not bioregistry.is_deprecated(prefix):
                 raise
-        except MissingPrefix as e:
+        except MissingPrefixError as e:
             logger.warning("[%s] missing prefix: %s", prefix, e)
             if strict and not bioregistry.is_deprecated(prefix):
                 raise e
         except subprocess.CalledProcessError:
             logger.warning("[%s] ROBOT was unable to convert OWL to OBO", prefix)
-        except UnhandledFormat as e:
+        except UnhandledFormatError as e:
             logger.warning("[%s] %s", prefix, e)
         except ValueError as e:
             if _is_xml(e):
@@ -390,7 +383,7 @@ def _prep_dir(directory: Union[None, str, pathlib.Path]) -> pathlib.Path:
 
 
 def db_output_helper(
-    f: Callable[..., Iterable[Tuple[str, ...]]],
+    f: Callable[..., Iterable[tuple[str, ...]]],
     db_name: str,
     columns: Sequence[str],
     *,
@@ -399,7 +392,7 @@ def db_output_helper(
     use_gzip: bool = True,
     summary_detailed: Optional[Sequence[int]] = None,
     **kwargs,
-) -> List[pathlib.Path]:
+) -> list[pathlib.Path]:
     """Help output database builds.
 
     :param f: A function that takes a prefix and gives back something that will be used by an outer function.
@@ -413,7 +406,7 @@ def db_output_helper(
     directory = _prep_dir(directory)
 
     c: typing.Counter[str] = Counter()
-    c_detailed: typing.Counter[Tuple[str, ...]] = Counter()
+    c_detailed: typing.Counter[tuple[str, ...]] = Counter()
 
     if use_gzip:
         db_path = directory.joinpath(f"{db_name}.tsv.gz")
@@ -475,7 +468,7 @@ def db_output_helper(
             indent=2,
         )
 
-    rv: List[pathlib.Path] = [
+    rv: list[pathlib.Path] = [
         db_metadata_path,
         db_path,
         db_sample_path,

pyobo/gilda_utils.py

@@ -1,10 +1,9 @@
-# -*- coding: utf-8 -*-
-
 """PyOBO's Gilda utilities."""
 
 import logging
+from collections.abc import Iterable
 from subprocess import CalledProcessError
-from typing import Iterable, List, Optional, Tuple, Type, Union
+from typing import Optional, Union
 
 import bioregistry
 import gilda.api
@@ -22,7 +21,7 @@ from pyobo import (
     get_ids,
     get_obsolete,
 )
-from pyobo.getters import NoBuild
+from pyobo.getters import NoBuildError
 from pyobo.utils.io import multidict
 
 __all__ = [
@@ -41,7 +40,7 @@ def iter_gilda_prediction_tuples(
     grounder: Optional[Grounder] = None,
     identifiers_are_names: bool = False,
     strict: bool = False,
-) -> Iterable[Tuple[str, str, str, str, str, str, str, str, float]]:
+) -> Iterable[tuple[str, str, str, str, str, str, str, str, float]]:
     """Iterate over prediction tuples for a given prefix."""
     if grounder is None:
         grounder = gilda.api.grounder
@@ -94,7 +93,7 @@ def get_grounder(
     prefixes: Union[str, Iterable[str]],
     *,
     unnamed: Optional[Iterable[str]] = None,
-    grounder_cls: Optional[Type[Grounder]] = None,
+    grounder_cls: Optional[type[Grounder]] = None,
     versions: Union[None, str, Iterable[Union[str, None]]] = None,
     strict: bool = True,
     skip_obsolete: bool = False,
@@ -115,7 +114,7 @@ def get_grounder(
     if len(prefixes) != len(versions):
         raise ValueError
 
-    terms: List[gilda.term.Term] = []
+    terms: list[gilda.term.Term] = []
     for prefix, version in zip(tqdm(prefixes, leave=False, disable=not progress), versions):
         try:
             p_terms = list(
@@ -128,7 +127,7 @@ def get_grounder(
                     progress=progress,
                 )
             )
-        except (NoBuild, CalledProcessError):
+        except (NoBuildError, CalledProcessError):
             continue
         else:
             terms.extend(p_terms)
@@ -251,7 +250,7 @@ def get_gilda_terms(
 
 
 def get_gilda_term_subset(
-    source: str, ancestors: Union[str, List[str]], **kwargs
+    source: str, ancestors: Union[str, list[str]], **kwargs
 ) -> Iterable[gilda.term.Term]:
     """Get a subset of terms."""
     subset = {
@@ -264,7 +263,7 @@ def get_gilda_term_subset(
             yield term
 
 
-def _ensure_list(s: Union[str, List[str]]) -> List[str]:
+def _ensure_list(s: Union[str, list[str]]) -> list[str]:
     if isinstance(s, str):
         return [s]
     return s

pyobo/identifier_utils.py

@@ -1,12 +1,9 @@
-# -*- coding: utf-8 -*-
-
 """Utilities for handling prefixes."""
 
 from __future__ import annotations
 
 import logging
 from functools import wraps
-from typing import Optional, Tuple, Union
 
 import bioregistry
 from curies import Reference, ReferenceTuple
@@ -28,10 +25,15 @@ __all__ = [
 logger = logging.getLogger(__name__)
 
 
-class MissingPrefix(ValueError):
+class MissingPrefixError(ValueError):
     """Raised on a missing prefix."""
 
-    def __init__(self, prefix, curie, xref=None, ontology=None):
+    reference: Reference | None
+
+    def __init__(
+        self, prefix: str, curie: str, xref: str | None = None, ontology: str | None = None
+    ):
+        """Initialize the error."""
         self.prefix = prefix
         self.curie = curie
         self.xref = xref
@@ -50,13 +52,13 @@ class MissingPrefix(ValueError):
         return s
 
 
-def _normalize_prefix(prefix: str, *, curie=None, xref=None, strict: bool = True) -> Optional[str]:
+def _normalize_prefix(prefix: str, *, curie=None, xref=None, strict: bool = True) -> str | None:
     """Normalize a namespace and return, if possible."""
     norm_prefix = bioregistry.normalize_prefix(prefix)
     if norm_prefix is not None:
         return norm_prefix
     elif strict:
-        raise MissingPrefix(prefix=prefix, curie=curie, xref=xref)
+        raise MissingPrefixError(prefix=prefix, curie=curie, xref=xref)
     else:
         return None
 
@@ -64,9 +66,7 @@ def _normalize_prefix(prefix: str, *, curie=None, xref=None, strict: bool = True
 BAD_CURIES = set()
 
 
-def normalize_curie(
-    curie: str, *, strict: bool = True
-) -> Union[Tuple[str, str], Tuple[None, None]]:
+def normalize_curie(curie: str, *, strict: bool = True) -> tuple[str, str] | tuple[None, None]:
     """Parse a string that looks like a CURIE.
 
     :param curie: A compact uniform resource identifier (CURIE)

pyobo/mocks.py

@@ -1,8 +1,7 @@
-# -*- coding: utf-8 -*-
-
 """Mocks for PyOBO."""
 
-from typing import List, Mapping, Optional, Tuple, TypeVar, Union
+from collections.abc import Mapping
+from typing import Optional, TypeVar, Union
 from unittest import mock
 
 import pandas as pd
@@ -25,7 +24,7 @@ def get_mock_id_name_mapping(data: Mapping[str, Mapping[str, str]]) -> mock._pat
     return _replace_mapping_getter("pyobo.api.names.get_id_name_mapping", data)
 
 
-def get_mock_id_synonyms_mapping(data: Mapping[str, Mapping[str, List[str]]]) -> mock._patch:
+def get_mock_id_synonyms_mapping(data: Mapping[str, Mapping[str, list[str]]]) -> mock._patch:
     """Mock the :func:`pyobo.extract.get_id_synonyms_mapping` function.
 
     :param data: A mapping from prefix to mappings of identifier to lists of synonyms.
@@ -33,7 +32,7 @@ def get_mock_id_synonyms_mapping(data: Mapping[str, Mapping[str, List[str]]]) ->
     return _replace_mapping_getter("pyobo.api.names.get_id_synonyms_mapping", data)
 
 
-def get_mock_id_alts_mapping(data: Mapping[str, Mapping[str, List[str]]]) -> mock._patch:
+def get_mock_id_alts_mapping(data: Mapping[str, Mapping[str, list[str]]]) -> mock._patch:
     """Mock the :func:`pyobo.extract.get_id_to_alts` function.
 
     :param data: A mapping from prefix to mappings of identifier to lists of alternative identifiers.
@@ -52,7 +51,7 @@ def _replace_mapping_getter(name: str, data: Mapping[str, Mapping[str, X]]) -> m
 
 
 def get_mock_get_xrefs_df(
-    df: Union[List[Tuple[str, str, str, str, str]], pd.DataFrame]
+    df: Union[list[tuple[str, str, str, str, str]], pd.DataFrame],
 ) -> mock._patch:
     """Mock the :func:`pyobo.xrefsdb.xrefs_pipeline.get_xref_df` function.
 

pyobo/normalizer.py

@@ -1,12 +1,11 @@
-# -*- coding: utf-8 -*-
-
 """Use synonyms from OBO to normalize names."""
 
 import logging
 from abc import ABC, abstractmethod
+from collections.abc import Iterable, Mapping
 from dataclasses import dataclass
 from functools import lru_cache
-from typing import Dict, Iterable, List, Mapping, Optional, Set, Tuple, Union
+from typing import Optional, Union
 
 import bioregistry
 
@@ -23,29 +22,29 @@ __all__ = [
 
 logger = logging.getLogger(__name__)
 
-NormalizationSuccess = Tuple[str, str, str]
-NormalizationFailure = Tuple[None, None, str]
+NormalizationSuccess = tuple[str, str, str]
+NormalizationFailure = tuple[None, None, str]
 NormalizationResult = Union[NormalizationSuccess, NormalizationFailure]
 
 
 class Normalizer(ABC):
     """A normalizer."""
 
-    id_to_name: Dict[str, str]
-    id_to_synonyms: Dict[str, List[str]]
+    id_to_name: dict[str, str]
+    id_to_synonyms: dict[str, list[str]]
 
     #: A mapping from all synonyms to the set of identifiers that they point to.
     #: In a perfect world, each would only be a single element.
-    synonym_to_identifiers_mapping: Dict[str, Set[str]]
+    synonym_to_identifiers_mapping: dict[str, set[str]]
     #: A mapping from normalized names to the actual ones that they came from
-    norm_name_to_name: Dict[str, Set[str]]
+    norm_name_to_name: dict[str, set[str]]
 
     def __init__(
         self,
-        id_to_name: Dict[str, str],
-        id_to_synonyms: Dict[str, List[str]],
+        id_to_name: dict[str, str],
+        id_to_synonyms: dict[str, list[str]],
         remove_prefix: Optional[str] = None,
-    ) -> None:  # noqa: D107
+    ) -> None:
         """Initialize the normalizer.
 
         :param id_to_name: An identifier to name dictionary.
@@ -64,7 +63,7 @@ class Normalizer(ABC):
         self.norm_name_to_name = self._get_norm_name_to_names(self.synonym_to_identifiers_mapping)
 
     @classmethod
-    def _get_norm_name_to_names(cls, synonyms: Iterable[str]) -> Dict[str, Set[str]]:
+    def _get_norm_name_to_names(cls, synonyms: Iterable[str]) -> dict[str, set[str]]:
         return multisetdict((cls._normalize_text(synonym), synonym) for synonym in synonyms)
 
     @staticmethod
@@ -81,7 +80,7 @@ class Normalizer(ABC):
         id_to_name: Mapping[str, str],
         id_to_synonyms: Mapping[str, Iterable[str]],
         remove_prefix: Optional[str] = None,
-    ) -> Iterable[Tuple[str, str]]:
+    ) -> Iterable[tuple[str, str]]:
         if remove_prefix is not None:
             remove_prefix = f'{remove_prefix.lower().rstrip(":")}:'
 
@@ -101,7 +100,7 @@ class Normalizer(ABC):
                 # it might overwrite but this is probably always due to alternate ids
                 yield synonym, identifier
 
-    def get_names(self, query: str) -> List[str]:
+    def get_names(self, query: str) -> list[str]:
         """Get all names to which the query text maps."""
         norm_text = self._normalize_text(query)
         return list(self.norm_name_to_name.get(norm_text, []))
@@ -112,7 +111,7 @@ class Normalizer(ABC):
         raise NotImplementedError
 
 
-@lru_cache()
+@lru_cache
 def get_normalizer(prefix: str) -> Normalizer:
     """Get an OBO normalizer."""
     norm_prefix = bioregistry.normalize_prefix(prefix)
@@ -149,7 +148,8 @@ def ground(prefix: Union[str, Iterable[str]], query: str) -> NormalizationResult
 class OboNormalizer(Normalizer):
     """A utility for normalizing by names."""
 
-    def __init__(self, prefix: str) -> None:  # noqa: D107
+    def __init__(self, prefix: str) -> None:
+        """Initialize the normalizer by an ontology's Bioregistry prefix."""
         self.prefix = prefix
         self._len_prefix = len(prefix)
         id_to_name = names.get_id_name_mapping(prefix)
@@ -160,7 +160,7 @@ class OboNormalizer(Normalizer):
             remove_prefix=prefix,
         )
 
-    def __repr__(self) -> str:  # noqa: D105
+    def __repr__(self) -> str:
         return f'OboNormalizer(prefix="{self.prefix}")'
 
     def normalize(self, query: str) -> NormalizationResult:
@@ -188,20 +188,20 @@ class MultiNormalizer:
     If you're looking for taxa of exotic plants, you might use:
 
     >>> from pyobo.normalizer import MultiNormalizer
-    >>> normalizer = MultiNormalizer(prefixes=['ncbitaxon', 'itis'])
-    >>> normalizer.normalize('Homo sapiens')
+    >>> normalizer = MultiNormalizer(prefixes=["ncbitaxon", "itis"])
+    >>> normalizer.normalize("Homo sapiens")
     ('ncbitaxon', '9606', 'Homo sapiens')
-    >>> normalizer.normalize('Abies bifolia')  # variety not listed in NCBI
+    >>> normalizer.normalize("Abies bifolia")  # variety not listed in NCBI
     ('itis', '507501', 'Abies bifolia')
-    >>> normalizer.normalize('vulcan')  # nice try, nerds
+    >>> normalizer.normalize("vulcan")  # nice try, nerds
     (None, None, None)
     """
 
     #: The normalizers for each prefix
-    normalizers: List[Normalizer]
+    normalizers: list[Normalizer]
 
     @staticmethod
-    def from_prefixes(prefixes: List[str]) -> "MultiNormalizer":
+    def from_prefixes(prefixes: list[str]) -> "MultiNormalizer":
         """Instantiate normalizers based on the given prefixes, in preferred order.."""
         return MultiNormalizer([get_normalizer(prefix) for prefix in prefixes])
 

pyobo/obographs.py

@@ -1,6 +1,6 @@
 """Convert PyOBO into OBO Graph."""
 
-from typing import Iterable, List
+from collections.abc import Iterable
 
 import bioregistry
 import curies
@@ -35,8 +35,8 @@ def parse_results_from_obo(obo: Obo) -> ParseResults:
 
 def graph_from_obo(obo: Obo) -> Graph:
     """Get an OBO Graph object from a PyOBO object."""
-    nodes: List[Node] = []
-    edges: List[Edge] = []
+    nodes: list[Node] = []
+    edges: list[Edge] = []
     for term in obo:
         nodes.append(_get_class_node(term))
         edges.extend(_iter_edges(term))

pyobo/plugins.py

@@ -1,9 +1,8 @@
-# -*- coding: utf-8 -*-
-
 """Tools for loading entry points."""
 
+from collections.abc import Iterable, Mapping
 from functools import lru_cache
-from typing import Callable, Iterable, Mapping, Optional
+from typing import Callable, Optional
 
 from .struct import Obo
 
@@ -14,7 +13,7 @@ __all__ = [
 ]
 
 
-@lru_cache()
+@lru_cache
 def _get_nomenclature_plugins() -> Mapping[str, Callable[[], Obo]]:
     from .sources import ontology_resolver