chore: migrate type annotations to PEP 585 built-in generics

Closes #298. Follow-up to #292 (PEP 604). Now that fgpyo requires
Python 3.10+ (#261), annotation-site uses of typing.List/Dict/Tuple/
Set/FrozenSet/Type are migrated to the PEP 585 built-ins (list,
dict, tuple, set, frozenset, type).

Applied via `ruff check --select UP006,UP035 --fix --unsafe-fixes`
followed by `--select F401 --fix` to drop now-unused legacy imports.
Two spots needed manual follow-up where the bare `Type` alias was
equivalent to `Type[Any]` but `type` (the builtin) is stricter:
  - `fgpyo/util/inspect.py:311` — `cls: type` → `cls: type[Any]`
    to let mypy accept `cls._parsers()` on Metric subclasses.
  - `tests/fgpyo/util/test_metric.py:38` — `TypeVar("T", bound=type)`
    → `bound=type[Any]` to keep the decorator applicable to any class,
    not just metaclasses.

No runtime behavior changes. `NamedTuple`, `TypeVar`, `TypeGuard`,
`TypeAlias` are left as-is — no PEP 585 equivalent.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: msto

fgpyo/_requirements.py

@@ -1,6 +1,6 @@
 """Enforce requirements."""
 
-from typing import Callable
+from collections.abc import Callable
 
 
 class RequirementError(Exception):

fgpyo/collections/__init__.py

@@ -78,14 +78,13 @@
 iterable objects as well as iterators.
 """
 
+from collections.abc import Callable
+from collections.abc import Iterable
+from collections.abc import Iterator
 from itertools import pairwise
 from operator import le
 from typing import Any
-from typing import Callable
 from typing import Generic
-from typing import Iterable
-from typing import Iterator
-from typing import List
 from typing import Protocol
 from typing import TypeVar
 
@@ -144,7 +143,7 @@ def peek(self) -> IterType:
         else:
             raise StopIteration
 
-    def takewhile(self, pred: Callable[[IterType], bool]) -> List[IterType]:
+    def takewhile(self, pred: Callable[[IterType], bool]) -> list[IterType]:
         """
         Consumes from the iterator while pred is true, and returns the result as a List.
 
@@ -159,7 +158,7 @@ def takewhile(self, pred: Callable[[IterType], bool]) -> List[IterType]:
             List[V]: A list of the values from the iterator, in order, up until and excluding
             the first value that does not match the predicate.
         """
-        xs: List[IterType] = []
+        xs: list[IterType] = []
         while self.can_peek() and pred(self._peek):
             xs.append(next(self))
         return xs

fgpyo/fasta/builder.py

@@ -47,12 +47,11 @@
 """
 
 import textwrap
+from collections.abc import Iterator
 from contextlib import contextmanager
 from pathlib import Path
 from typing import TYPE_CHECKING
 from typing import Any
-from typing import Dict
-from typing import Iterator
 
 from pysam import FastaFile
 
@@ -179,7 +178,7 @@ def __init__(
         self.assembly: str = assembly
         self.species: str = species
         self.line_length: int = line_length
-        self.__contig_builders: Dict[str, ContigBuilder] = {}
+        self.__contig_builders: dict[str, ContigBuilder] = {}
 
     def __getitem__(self, key: str) -> ContigBuilder:
         """Access instance of ContigBuilder by name."""

fgpyo/fasta/sequence_dictionary.py

@@ -129,18 +129,16 @@
 import itertools
 import re
 import sys
+from collections.abc import Iterator
+from collections.abc import Mapping
+from collections.abc import MutableMapping
 from dataclasses import dataclass
 from dataclasses import field
 from dataclasses import replace
 from enum import unique
 from pathlib import Path
+from re import Pattern
 from typing import Any
-from typing import Dict
-from typing import Iterator
-from typing import List
-from typing import Mapping
-from typing import MutableMapping
-from typing import Pattern
 from typing import overload
 
 from fgpyo import sam
@@ -177,7 +175,7 @@ class Keys(StrEnum):
     URI = "UR"
 
     @staticmethod
-    def attributes() -> List[str]:
+    def attributes() -> list[str]:
         """
         The list of keys that are allowed to be attributes in `SequenceMetadata`.
 
@@ -253,7 +251,7 @@ class SequenceMetadata(MutableMapping[Keys | str, str]):
     name: str
     length: int
     index: int
-    attributes: Dict[Keys | str, str] = field(default_factory=dict)
+    attributes: dict[Keys | str, str] = field(default_factory=dict)
 
     def __post_init__(self) -> None:
         """Any post initialization validation should go here."""
@@ -267,13 +265,13 @@ def __post_init__(self) -> None:
             raise ValueError(f"'{Keys.SEQUENCE_LENGTH}' should not given in the list of attributes")
 
     @property
-    def aliases(self) -> List[str]:
+    def aliases(self) -> list[str]:
         """The aliases (not including the primary) name."""
         aliases = self.attributes.get(Keys.ALIASES)
         return [] if aliases is None else aliases.split(",")
 
     @property
-    def all_names(self) -> List[str]:
+    def all_names(self) -> list[str]:
         """A list of all names, including the primary name and aliases, in that order."""
         return [self.name] + self.aliases
 
@@ -344,14 +342,14 @@ def same_as(self, other: "SequenceMetadata") -> bool:
         else:
             return self_m5 == other_m5
 
-    def to_sam(self) -> Dict[str, Any]:
+    def to_sam(self) -> dict[str, Any]:
         """
         Converts the sequence metadata to a SAM-formatted dictionary.
 
         Equivalent to one item in the list of sequences from
         `pysam.AlignmentHeader#to_dict()["SQ"]`.
         """
-        meta_dict: Dict[str, Any] = {
+        meta_dict: dict[str, Any] = {
             f"{Keys.SEQUENCE_NAME}": self.name,
             f"{Keys.SEQUENCE_LENGTH}": self.length,
         }
@@ -361,7 +359,7 @@ def to_sam(self) -> Dict[str, Any]:
         return meta_dict
 
     @staticmethod
-    def from_sam(meta: Dict[Keys | str, Any], index: int) -> "SequenceMetadata":
+    def from_sam(meta: dict[Keys | str, Any], index: int) -> "SequenceMetadata":
         """
         Builds a `SequenceMetadata` from a dictionary.
 
@@ -436,13 +434,13 @@ class SequenceDictionary(Mapping[str | int, SequenceMetadata]):
         infos: the ordered collection of sequence metadata
     """
 
-    infos: List[SequenceMetadata]
-    _dict: Dict[str, SequenceMetadata] = field(init=False, repr=False)
+    infos: list[SequenceMetadata]
+    _dict: dict[str, SequenceMetadata] = field(init=False, repr=False)
 
     def __post_init__(self) -> None:
         """Builds the internal name-to-metadata lookup dictionary."""
         # Initialize a mapping from sequence name to the sequence metadata for all names
-        self_dict: Dict[str, SequenceMetadata] = {}
+        self_dict: dict[str, SequenceMetadata] = {}
         for index, info in enumerate(self.infos):
             if info.index != index:
                 raise ValueError(
@@ -466,13 +464,13 @@ def same_as(self, other: "SequenceDictionary") -> bool:
             return False
         return all(this.same_as(that) for this, that in zip(self.infos, other.infos, strict=True))
 
-    def to_sam(self) -> List[Dict[str, Any]]:
+    def to_sam(self) -> list[dict[str, Any]]:
         """Converts the list of dictionaries, one per sequence."""
         return [meta.to_sam() for meta in self.infos]
 
     def to_sam_header(
         self,
-        extra_header: Dict[str, Any] | None = None,
+        extra_header: dict[str, Any] | None = None,
     ) -> pysam.AlignmentHeader:
         """
         Converts the sequence dictionary to a `pysam.AlignmentHeader`.
@@ -481,7 +479,7 @@ def to_sam_header(
             extra_header: a dictionary of extra values to add to the header, None otherwise.  See
                           `:~pysam.AlignmentHeader` for more details.
         """
-        header_dict: Dict[str, Any] = {
+        header_dict: dict[str, Any] = {
             "HD": {"VN": "1.5"},
             "SQ": self.to_sam(),
         }
@@ -503,11 +501,11 @@ def from_sam(data: pysam.AlignmentHeader) -> "SequenceDictionary": ...
 
     @staticmethod
     @overload
-    def from_sam(data: List[Dict[str, Any]]) -> "SequenceDictionary": ...
+    def from_sam(data: list[dict[str, Any]]) -> "SequenceDictionary": ...
 
     @staticmethod
     def from_sam(
-        data: Path | pysam.AlignmentFile | pysam.AlignmentHeader | List[Dict[str, Any]],
+        data: Path | pysam.AlignmentFile | pysam.AlignmentHeader | list[dict[str, Any]],
     ) -> "SequenceDictionary":
         """
         Creates a `SequenceDictionary` from a SAM file or its header.
@@ -531,7 +529,7 @@ def from_sam(
                 seq_dict = SequenceDictionary.from_sam(fh.header)
         else:  # assuming `data` is a `list[dict[str, Any]]`
             try:
-                infos: List[SequenceMetadata] = [
+                infos: list[SequenceMetadata] = [
                     SequenceMetadata.from_sam(meta=meta, index=index)
                     for index, meta in enumerate(data)
                 ]

fgpyo/fastx/__init__.py

@@ -26,21 +26,18 @@
 
 """
 
+from collections.abc import Iterator
 from contextlib import AbstractContextManager
 from pathlib import Path
 from types import TracebackType
-from typing import Iterator
-from typing import List
-from typing import Tuple
-from typing import Type
 
 from pysam import FastxFile
 from pysam import FastxRecord
 
 from fgpyo.util.types import all_not_none
 
 
-class FastxZipped(AbstractContextManager, Iterator[Tuple[FastxRecord, ...]]):
+class FastxZipped(AbstractContextManager, Iterator[tuple[FastxRecord, ...]]):
     """
     A context manager that will lazily zip over any number of FASTA/FASTQ files.
 
@@ -55,22 +52,22 @@ def __init__(self, *paths: Path | str, persist: bool = False) -> None:
         if len(paths) <= 0:
             raise ValueError(f"Must provide at least one FASTX to {self.__class__.__name__}")
         self._persist: bool = persist
-        self._paths: Tuple[Path | str, ...] = paths
+        self._paths: tuple[Path | str, ...] = paths
         self._fastx = tuple(FastxFile(str(path), persist=self._persist) for path in self._paths)
 
     @staticmethod
     def _name_minus_ordinal(name: str) -> str:
         """Return the name of the FASTX record minus its ordinal suffix (e.g. "/1" or "/2")."""
         return name[: len(name) - 2] if len(name) >= 2 and name[-2] == "/" else name
 
-    def __next__(self) -> Tuple[FastxRecord, ...]:
+    def __next__(self) -> tuple[FastxRecord, ...]:
         """Return the next set of FASTX records from the zipped FASTX files."""
         records = tuple(next(handle, None) for handle in self._fastx)
 
         if all(record is None for record in records):
             raise StopIteration
         elif not all_not_none(records):
-            non_none_names: List[str | None] = [
+            non_none_names: list[str | None] = [
                 record.name for record in records if record is not None
             ]
             assert all_not_none(non_none_names)  # type narrowing
@@ -86,17 +83,17 @@ def __next__(self) -> Tuple[FastxRecord, ...]:
                 )
             )
 
-        names_with_ordinals: List[str | None] = [record.name for record in records]
+        names_with_ordinals: list[str | None] = [record.name for record in records]
         assert all_not_none(names_with_ordinals)  # type narrowing
-        record_names: List[str] = [self._name_minus_ordinal(name) for name in names_with_ordinals]
+        record_names: list[str] = [self._name_minus_ordinal(name) for name in names_with_ordinals]
         if len(set(record_names)) != 1:
             raise ValueError(f"FASTX record names do not all match, found: {record_names}")
 
         return records
 
     def __exit__(
         self,
-        exc_type: Type[BaseException] | None,
+        exc_type: type[BaseException] | None,
         exc_val: BaseException | None,
         exc_tb: TracebackType | None,
     ) -> bool | None:

fgpyo/io/__init__.py

@@ -63,21 +63,20 @@
 import os
 import sys
 import warnings
+from collections.abc import Generator
+from collections.abc import Iterable
+from collections.abc import Iterator
 from contextlib import contextmanager
 from io import TextIOWrapper
 from pathlib import Path
 from typing import IO
 from typing import Any
-from typing import Generator
-from typing import Iterable
-from typing import Iterator
-from typing import Set
 from typing import cast
 
 from zlib_ng import gzip_ng
 from zlib_ng import gzip_ng_threaded
 
-COMPRESSED_FILE_EXTENSIONS: Set[str] = {".gz", ".bgz"}
+COMPRESSED_FILE_EXTENSIONS: set[str] = {".gz", ".bgz"}
 
 
 def assert_path_is_readable(path: Path) -> None:

fgpyo/platform/illumina.py

@@ -9,15 +9,13 @@
 
 """
 
-from typing import Set
-
 from pysam import AlignedSegment
 
 SAM_UMI_DELIMITER: str = "-"
 """Multiple UMI delimiter, which SAM specification recommends should be a hyphen;
 see specification here: https://samtools.github.io/hts-specs/SAMtags.pdf"""
 
-_VALID_UMI_CHARACTERS: Set[str] = set("ACGTN")
+_VALID_UMI_CHARACTERS: set[str] = set("ACGTN")
 """Illumina's restricted UMI characters;
 https://support.illumina.com/help/BaseSpace_Sequence_Hub_OLH_009008_2/Source/Informatics/BS/FileFormat_FASTQ-files_swBS.htm."""  # noqa