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

pyobo/api/xrefs.py

@@ -1,10 +1,9 @@
-# -*- coding: utf-8 -*-
-
 """High-level API for synonyms."""
 
 import logging
+from collections.abc import Mapping
 from functools import lru_cache
-from typing import List, Mapping, Optional, Tuple, Union
+from typing import Optional, Union
 
 import pandas as pd
 from tqdm.auto import tqdm
@@ -43,7 +42,7 @@ def get_xref(
     return filtered_xrefs.get(identifier)
 
 
-@lru_cache()
+@lru_cache
 @wrap_norm_prefix
 def get_filtered_xrefs(
     prefix: str,
@@ -147,7 +146,7 @@ def get_sssom_df(
         prefix = prefix.ontology
     else:
         df = get_xrefs_df(prefix=prefix, **kwargs)
-    rows: List[Tuple[str, ...]] = []
+    rows: list[tuple[str, ...]] = []
     with logging_redirect_tqdm():
         for source_id, target_prefix, target_id in tqdm(
             df.values, unit="mapping", unit_scale=True, desc=f"[{prefix}] SSSOM"

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
@@ -282,7 +280,7 @@ def ancestors(prefix: str, identifier: str, force: bool, version: Optional[str])
     """Look up ancestors."""
     curies = get_ancestors(prefix=prefix, identifier=identifier, force=force, version=version)
     for curie in sorted(curies or []):
-        click.echo(f"{curie}\t{get_name_by_curie(curie)}")
+        click.echo(f"{curie}\t{get_name_by_curie(curie, version=version)}")
 
 
 @lookup.command()
@@ -295,7 +293,7 @@ def descendants(prefix: str, identifier: str, force: bool, version: Optional[str
     """Look up descendants."""
     curies = get_descendants(prefix=prefix, identifier=identifier, force=force, version=version)
     for curie in sorted(curies or []):
-        click.echo(f"{curie}\t{get_name_by_curie(curie)}")
+        click.echo(f"{curie}\t{get_name_by_curie(curie, version=version)}")
 
 
 @lookup.command()

pyobo/cli/utils.py

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

pyobo/constants.py

@@ -1,5 +1,3 @@
-# -*- coding: utf-8 -*-
-
 """Constants for PyOBO."""
 
 import logging
@@ -80,7 +78,6 @@ TYPEDEFS_FILE = "typedefs.tsv.gz"
 SPECIES_RECORD = "5334738"
 SPECIES_FILE = "species.tsv.gz"
 
-
 NCBITAXON_PREFIX = "NCBITaxon"
 DATE_FORMAT = "%d:%m:%Y %H:%M"
 PROVENANCE_PREFIXES = {

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
@@ -15,13 +14,14 @@ from gilda.term import filter_out_duplicates
 from tqdm.auto import tqdm
 
 from pyobo import (
+    get_descendants,
     get_id_name_mapping,
     get_id_species_mapping,
     get_id_synonyms_mapping,
     get_ids,
     get_obsolete,
 )
-from pyobo.getters import NoBuild
+from pyobo.getters import NoBuildError
 from pyobo.utils.io import multidict
 
 __all__ = [
@@ -40,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
@@ -93,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,
@@ -114,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(
@@ -127,7 +127,7 @@ def get_grounder(
                     progress=progress,
                 )
             )
-        except (NoBuild, CalledProcessError):
+        except (NoBuildError, CalledProcessError):
             continue
         else:
             terms.extend(p_terms)
@@ -247,3 +247,23 @@ def get_gilda_terms(
             )
             if term is not None:
                 yield term
+
+
+def get_gilda_term_subset(
+    source: str, ancestors: Union[str, list[str]], **kwargs
+) -> Iterable[gilda.term.Term]:
+    """Get a subset of terms."""
+    subset = {
+        descendant
+        for parent_curie in _ensure_list(ancestors)
+        for descendant in get_descendants(*parent_curie.split(":")) or []
+    }
+    for term in get_gilda_terms(source, **kwargs):
+        if bioregistry.curie_to_str(term.db, term.id) in subset:
+            yield term
+
+
+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,12 @@
-# -*- 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
 
 from .registries import (
     curie_has_blacklisted_prefix,
@@ -25,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
@@ -47,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
 
@@ -61,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)
@@ -108,11 +111,25 @@ def wrap_norm_prefix(f):
     """Decorate a function that take in a prefix to auto-normalize, or return None if it can't be normalized."""
 
     @wraps(f)
-    def _wrapped(prefix, *args, **kwargs):
-        norm_prefix = bioregistry.normalize_prefix(prefix)
-        if norm_prefix is None:
-            raise ValueError(f"Invalid prefix: {prefix}")
-        return f(norm_prefix, *args, **kwargs)
+    def _wrapped(prefix: str | Reference | ReferenceTuple, *args, **kwargs):
+        if isinstance(prefix, str):
+            norm_prefix = bioregistry.normalize_prefix(prefix)
+            if norm_prefix is None:
+                raise ValueError(f"Invalid prefix: {prefix}")
+            prefix = norm_prefix
+        elif isinstance(prefix, Reference):
+            norm_prefix = bioregistry.normalize_prefix(prefix.prefix)
+            if norm_prefix is None:
+                raise ValueError(f"Invalid prefix: {prefix.prefix}")
+            prefix = Reference(prefix=norm_prefix, identifier=prefix.identifier)
+        elif isinstance(prefix, ReferenceTuple):
+            norm_prefix = bioregistry.normalize_prefix(prefix.prefix)
+            if norm_prefix is None:
+                raise ValueError(f"Invalid prefix: {prefix.prefix}")
+            prefix = ReferenceTuple(norm_prefix, prefix.identifier)
+        else:
+            raise TypeError
+        return f(prefix, *args, **kwargs)
 
     return _wrapped
 

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))