From 292dd4c2232306fda4a802a662c2c19ba6eb926b Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Fri, 8 Sep 2023 11:37:04 +0000 Subject: [PATCH] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- anndata/__init__.py | 5 +- anndata/_core/access.py | 13 +- anndata/_core/aligned_mapping.py | 68 ++++--- anndata/_core/anndata.py | 176 +++++++++--------- anndata/_core/file_backing.py | 31 +-- anndata/_core/index.py | 27 ++- anndata/_core/merge.py | 49 ++--- anndata/_core/raw.py | 27 +-- anndata/_core/sparse_dataset.py | 33 ++-- anndata/_core/views.py | 29 +-- anndata/_io/__init__.py | 4 +- anndata/_io/h5ad.py | 44 +++-- anndata/_io/read.py | 42 +++-- anndata/_io/specs/__init__.py | 13 +- anndata/_io/specs/methods.py | 27 +-- anndata/_io/specs/registry.py | 21 +-- anndata/_io/utils.py | 5 +- anndata/_io/write.py | 15 +- anndata/_io/zarr.py | 22 ++- anndata/_types.py | 2 + anndata/_warnings.py | 3 + anndata/compat/__init__.py | 34 ++-- anndata/compat/exceptiongroups.py | 2 + anndata/core.py | 2 + anndata/experimental/__init__.py | 6 +- anndata/experimental/_dispatch_io.py | 12 +- anndata/experimental/merge.py | 59 +++--- anndata/experimental/multi_files/__init__.py | 2 + .../multi_files/_anncollection.py | 44 ++--- anndata/experimental/pytorch/__init__.py | 2 + anndata/experimental/pytorch/_annloader.py | 14 +- anndata/logging.py | 4 +- anndata/readwrite.py | 2 + anndata/tests/conftest.py | 3 +- anndata/tests/helpers.py | 37 ++-- anndata/tests/test_anncollection.py | 9 +- anndata/tests/test_annot.py | 7 +- anndata/tests/test_awkward.py | 13 +- anndata/tests/test_backed_sparse.py | 2 + anndata/tests/test_base.py | 7 +- anndata/tests/test_concatenate.py | 34 ++-- anndata/tests/test_concatenate_disk.py | 12 +- anndata/tests/test_dask.py | 22 ++- anndata/tests/test_dask_view_mem.py | 6 +- anndata/tests/test_deprecations.py | 7 +- anndata/tests/test_get_vector.py | 4 +- anndata/tests/test_gpu.py | 6 +- anndata/tests/test_hdf5_backing.py | 8 +- anndata/tests/test_helpers.py | 12 +- anndata/tests/test_inplace_subset.py | 4 +- anndata/tests/test_io_backwards_compat.py | 6 +- anndata/tests/test_io_conversion.py | 4 +- anndata/tests/test_io_dispatched.py | 10 +- anndata/tests/test_io_elementwise.py | 13 +- anndata/tests/test_io_partial.py | 16 +- anndata/tests/test_io_utils.py | 8 +- anndata/tests/test_io_warnings.py | 4 +- anndata/tests/test_layers.py | 8 +- anndata/tests/test_obsmvarm.py | 2 + anndata/tests/test_obspvarp.py | 2 + anndata/tests/test_raw.py | 5 +- anndata/tests/test_readwrite.py | 24 ++- anndata/tests/test_repr.py | 2 + anndata/tests/test_structured_arrays.py | 9 +- anndata/tests/test_transpose.py | 7 +- anndata/tests/test_uns.py | 3 +- anndata/tests/test_utils.py | 9 +- anndata/tests/test_views.py | 29 +-- anndata/tests/test_x.py | 8 +- anndata/utils.py | 15 +- benchmarks/benchmarks/readwrite.py | 10 +- benchmarks/benchmarks/utils.py | 16 +- conftest.py | 7 +- docs/conf.py | 8 +- 74 files changed, 708 insertions(+), 549 deletions(-) diff --git a/anndata/__init__.py b/anndata/__init__.py index 17289c6de..efc965273 100644 --- a/anndata/__init__.py +++ b/anndata/__init__.py @@ -1,4 +1,5 @@ """Annotated multivariate observation data.""" +from __future__ import annotations try: # See https://github.com/maresb/hatch-vcs-footgun-example from setuptools_scm import get_version @@ -34,10 +35,10 @@ read_zarr, ) from ._warnings import ( + ExperimentalFeatureWarning, + ImplicitModificationWarning, OldFormatWarning, WriteWarning, - ImplicitModificationWarning, - ExperimentalFeatureWarning, ) if True: # Bypass isort, this needs to come last diff --git a/anndata/_core/access.py b/anndata/_core/access.py index 7dacaa6dc..43e23932e 100644 --- a/anndata/_core/access.py +++ b/anndata/_core/access.py @@ -1,16 +1,19 @@ +from __future__ import annotations + from functools import reduce -from typing import NamedTuple, Tuple +from typing import TYPE_CHECKING, NamedTuple -from . import anndata +if TYPE_CHECKING: + from . import anndata class ElementRef(NamedTuple): - parent: "anndata.AnnData" + parent: anndata.AnnData attrname: str - keys: Tuple[str, ...] = () + keys: tuple[str, ...] = () def __str__(self) -> str: - return f".{self.attrname}" + "".join(map(lambda x: f"['{x}']", self.keys)) + return f".{self.attrname}" + "".join(f"['{x}']" for x in self.keys) @property def _parent_el(self): diff --git a/anndata/_core/aligned_mapping.py b/anndata/_core/aligned_mapping.py index 7d11262b5..5ad36deef 100644 --- a/anndata/_core/aligned_mapping.py +++ b/anndata/_core/aligned_mapping.py @@ -1,26 +1,34 @@ +from __future__ import annotations + +import warnings from abc import ABC, abstractmethod from collections import abc as cabc +from collections.abc import Iterator, Mapping, Sequence from copy import copy -from typing import Union, Optional, Type, ClassVar, TypeVar -from typing import Iterator, Mapping, Sequence -from typing import Tuple, List, Dict -import warnings +from typing import ( + TYPE_CHECKING, + ClassVar, + TypeVar, + Union, +) import numpy as np import pandas as pd from scipy.sparse import spmatrix -from ..utils import deprecated, ensure_df_homogeneous, dim_len -from . import raw, anndata -from .views import as_view, view_update +from anndata._warnings import ExperimentalFeatureWarning, ImplicitModificationWarning +from anndata.compat import AwkArray + +from ..utils import deprecated, dim_len, ensure_df_homogeneous from .access import ElementRef from .index import _subset -from anndata.compat import AwkArray -from anndata._warnings import ExperimentalFeatureWarning, ImplicitModificationWarning +from .views import as_view, view_update +if TYPE_CHECKING: + from . import anndata, raw OneDIdx = Union[Sequence[int], Sequence[bool], slice] -TwoDIdx = Tuple[OneDIdx, OneDIdx] +TwoDIdx = tuple[OneDIdx, OneDIdx] I = TypeVar("I", OneDIdx, TwoDIdx, covariant=True) # TODO: pd.DataFrame only allowed in AxisArrays? @@ -36,16 +44,16 @@ class AlignedMapping(cabc.MutableMapping, ABC): _allow_df: ClassVar[bool] """If this mapping supports heterogeneous DataFrames""" - _view_class: ClassVar[Type["AlignedViewMixin"]] + _view_class: ClassVar[type[AlignedViewMixin]] """The view class for this aligned mapping.""" - _actual_class: ClassVar[Type["AlignedActualMixin"]] + _actual_class: ClassVar[type[AlignedActualMixin]] """The actual class (which has it’s own data) for this aligned mapping.""" def __repr__(self): return f"{type(self).__name__} with keys: {', '.join(self.keys())}" - def _ipython_key_completions_(self) -> List[str]: + def _ipython_key_completions_(self) -> list[str]: return list(self.keys()) def _validate_value(self, val: V, key: str) -> V: @@ -94,7 +102,7 @@ def attrname(self) -> str: @property @abstractmethod - def axes(self) -> Tuple[int, ...]: + def axes(self) -> tuple[int, ...]: """Which axes of the parent is this aligned to?""" pass @@ -104,7 +112,7 @@ def is_view(self) -> bool: pass @property - def parent(self) -> Union["anndata.AnnData", "raw.Raw"]: + def parent(self) -> anndata.AnnData | raw.Raw: return self._parent def copy(self): @@ -117,7 +125,7 @@ def copy(self): d[k] = v.copy() return d - def _view(self, parent: "anndata.AnnData", subset_idx: I): + def _view(self, parent: anndata.AnnData, subset_idx: I): """Returns a subset copy-on-write view of the object.""" return self._view_class(self, parent, subset_idx) @@ -127,7 +135,7 @@ def as_dict(self) -> dict: class AlignedViewMixin: - parent: "anndata.AnnData" + parent: anndata.AnnData """Reference to parent AnnData view""" attrname: str @@ -177,7 +185,7 @@ def __len__(self) -> int: class AlignedActualMixin: - _data: Dict[str, V] + _data: dict[str, V] """Underlying mapping to the data""" is_view = False @@ -216,7 +224,7 @@ def attrname(self) -> str: return f"{self.dim}m" @property - def axes(self) -> Tuple[int]: + def axes(self) -> tuple[int]: """Axes of the parent this is aligned to""" return (self._axis,) @@ -225,7 +233,7 @@ def dim(self) -> str: """Name of the dimension this aligned to.""" return self._dimnames[self._axis] - def flipped(self) -> "AxisArraysBase": + def flipped(self) -> AxisArraysBase: """Transpose.""" new = self.copy() new.dimension = abs(self._axis - 1) @@ -265,9 +273,9 @@ def dim_names(self) -> pd.Index: class AxisArrays(AlignedActualMixin, AxisArraysBase): def __init__( self, - parent: Union["anndata.AnnData", "raw.Raw"], + parent: anndata.AnnData | raw.Raw, axis: int, - vals: Union[Mapping, AxisArraysBase, None] = None, + vals: Mapping | AxisArraysBase | None = None, ): self._parent = parent if axis not in (0, 1): @@ -282,7 +290,7 @@ class AxisArraysView(AlignedViewMixin, AxisArraysBase): def __init__( self, parent_mapping: AxisArraysBase, - parent_view: "anndata.AnnData", + parent_view: anndata.AnnData, subset_idx: OneDIdx, ): self.parent_mapping = parent_mapping @@ -306,7 +314,7 @@ class LayersBase(AlignedMapping): axes = (0, 1) # TODO: I thought I had a more elegant solution to overriding this... - def copy(self) -> "Layers": + def copy(self) -> Layers: d = self._actual_class(self.parent) for k, v in self.items(): d[k] = v.copy() @@ -314,7 +322,7 @@ def copy(self) -> "Layers": class Layers(AlignedActualMixin, LayersBase): - def __init__(self, parent: "anndata.AnnData", vals: Optional[Mapping] = None): + def __init__(self, parent: anndata.AnnData, vals: Mapping | None = None): self._parent = parent self._data = dict() if vals is not None: @@ -325,7 +333,7 @@ class LayersView(AlignedViewMixin, LayersBase): def __init__( self, parent_mapping: LayersBase, - parent_view: "anndata.AnnData", + parent_view: anndata.AnnData, subset_idx: TwoDIdx, ): self.parent_mapping = parent_mapping @@ -351,7 +359,7 @@ def attrname(self) -> str: return f"{self.dim}p" @property - def axes(self) -> Tuple[int, int]: + def axes(self) -> tuple[int, int]: """Axes of the parent this is aligned to""" return self._axis, self._axis @@ -364,9 +372,9 @@ def dim(self) -> str: class PairwiseArrays(AlignedActualMixin, PairwiseArraysBase): def __init__( self, - parent: "anndata.AnnData", + parent: anndata.AnnData, axis: int, - vals: Optional[Mapping] = None, + vals: Mapping | None = None, ): self._parent = parent if axis not in (0, 1): @@ -381,7 +389,7 @@ class PairwiseArraysView(AlignedViewMixin, PairwiseArraysBase): def __init__( self, parent_mapping: PairwiseArraysBase, - parent_view: "anndata.AnnData", + parent_view: anndata.AnnData, subset_idx: OneDIdx, ): self.parent_mapping = parent_mapping diff --git a/anndata/_core/anndata.py b/anndata/_core/anndata.py index 5fc1fae89..619e8732f 100644 --- a/anndata/_core/anndata.py +++ b/anndata/_core/anndata.py @@ -3,60 +3,66 @@ """ from __future__ import annotations -import warnings import collections.abc as cabc +import warnings from collections import OrderedDict +from collections.abc import Iterable, Mapping, MutableMapping, Sequence from copy import copy, deepcopy from enum import Enum from functools import partial, singledispatch from pathlib import Path -from os import PathLike from textwrap import dedent -from typing import Any, Union, Optional, Literal # Meta -from typing import Iterable, Sequence, Mapping, MutableMapping # Generic ABCs -from typing import Tuple, List # Generic +from typing import ( # Meta # Generic ABCs # Generic + TYPE_CHECKING, + Any, + Literal, +) import h5py -from natsort import natsorted import numpy as np -from numpy import ma import pandas as pd +from natsort import natsorted +from numpy import ma from pandas.api.types import infer_dtype, is_string_dtype from scipy import sparse -from scipy.sparse import issparse, csr_matrix +from scipy.sparse import csr_matrix, issparse from anndata._warnings import ImplicitModificationWarning -from .raw import Raw -from .index import _normalize_indices, _subset, Index, Index1D, get_vector -from .file_backing import AnnDataFileManager, to_memory + +from .. import utils +from ..compat import ( + CupyArray, + CupySparseMatrix, + DaskArray, + ZappyArray, + ZarrArray, + _move_adj_mtx, +) +from ..logging import anndata_logger as logger +from ..utils import convert_to_dict, dim_len, ensure_df_homogeneous from .access import ElementRef from .aligned_mapping import ( AxisArrays, AxisArraysView, - PairwiseArrays, - PairwiseArraysView, Layers, LayersView, + PairwiseArrays, + PairwiseArraysView, ) +from .file_backing import AnnDataFileManager, to_memory +from .index import Index, Index1D, _normalize_indices, _subset, get_vector +from .raw import Raw +from .sparse_dataset import SparseDataset from .views import ( ArrayView, - DictView, DataFrameView, - as_view, + DictView, _resolve_idxs, + as_view, ) -from .sparse_dataset import SparseDataset -from .. import utils -from ..utils import convert_to_dict, ensure_df_homogeneous, dim_len -from ..logging import anndata_logger as logger -from ..compat import ( - ZarrArray, - ZappyArray, - DaskArray, - CupyArray, - CupySparseMatrix, - _move_adj_mtx, -) + +if TYPE_CHECKING: + from os import PathLike class StorageType(Enum): @@ -328,22 +334,22 @@ class AnnData(metaclass=utils.DeprecationMixinMeta): def __init__( self, - X: Optional[Union[np.ndarray, sparse.spmatrix, pd.DataFrame]] = None, - obs: Optional[Union[pd.DataFrame, Mapping[str, Iterable[Any]]]] = None, - var: Optional[Union[pd.DataFrame, Mapping[str, Iterable[Any]]]] = None, - uns: Optional[Mapping[str, Any]] = None, - obsm: Optional[Union[np.ndarray, Mapping[str, Sequence[Any]]]] = None, - varm: Optional[Union[np.ndarray, Mapping[str, Sequence[Any]]]] = None, - layers: Optional[Mapping[str, Union[np.ndarray, sparse.spmatrix]]] = None, - raw: Optional[Mapping[str, Any]] = None, - dtype: Optional[Union[np.dtype, type, str]] = None, - shape: Optional[Tuple[int, int]] = None, - filename: Optional[PathLike] = None, - filemode: Optional[Literal["r", "r+"]] = None, + X: np.ndarray | sparse.spmatrix | pd.DataFrame | None = None, + obs: pd.DataFrame | Mapping[str, Iterable[Any]] | None = None, + var: pd.DataFrame | Mapping[str, Iterable[Any]] | None = None, + uns: Mapping[str, Any] | None = None, + obsm: np.ndarray | Mapping[str, Sequence[Any]] | None = None, + varm: np.ndarray | Mapping[str, Sequence[Any]] | None = None, + layers: Mapping[str, np.ndarray | sparse.spmatrix] | None = None, + raw: Mapping[str, Any] | None = None, + dtype: np.dtype | type | str | None = None, + shape: tuple[int, int] | None = None, + filename: PathLike | None = None, + filemode: Literal["r", "r+"] | None = None, asview: bool = False, *, - obsp: Optional[Union[np.ndarray, Mapping[str, Sequence[Any]]]] = None, - varp: Optional[Union[np.ndarray, Mapping[str, Sequence[Any]]]] = None, + obsp: np.ndarray | Mapping[str, Sequence[Any]] | None = None, + varp: np.ndarray | Mapping[str, Sequence[Any]] | None = None, oidx: Index1D = None, vidx: Index1D = None, ): @@ -369,7 +375,7 @@ def __init__( filemode=filemode, ) - def _init_as_view(self, adata_ref: "AnnData", oidx: Index, vidx: Index): + def _init_as_view(self, adata_ref: AnnData, oidx: Index, vidx: Index): if adata_ref.isbacked and adata_ref.is_view: raise ValueError( "Currently, you cannot index repeatedly into a backed AnnData, " @@ -594,8 +600,8 @@ def get_size(X): return X.__sizeof__() size = 0 - attrs = list(["_X", "_obs", "_var"]) - attrs_multi = list(["_uns", "_obsm", "_varm", "varp", "_obsp", "_layers"]) + attrs = ["_X", "_obs", "_var"] + attrs_multi = ["_uns", "_obsm", "_varm", "varp", "_obsp", "_layers"] for attr in attrs + attrs_multi: if attr in attrs_multi: keys = getattr(self, attr).keys() @@ -643,12 +649,12 @@ def __eq__(self, other): ) @property - def shape(self) -> Tuple[int, int]: + def shape(self) -> tuple[int, int]: """Shape of data matrix (:attr:`n_obs`, :attr:`n_vars`).""" return self.n_obs, self.n_vars @property - def X(self) -> Optional[Union[np.ndarray, sparse.spmatrix, ArrayView]]: + def X(self) -> np.ndarray | sparse.spmatrix | ArrayView | None: """Data matrix of shape :attr:`n_obs` × :attr:`n_vars`.""" if self.isbacked: if not self.file.is_open: @@ -679,7 +685,7 @@ def X(self) -> Optional[Union[np.ndarray, sparse.spmatrix, ArrayView]]: # return X @X.setter - def X(self, value: Optional[Union[np.ndarray, sparse.spmatrix]]): + def X(self, value: np.ndarray | sparse.spmatrix | None): if value is None: if self.isbacked: raise NotImplementedError( @@ -744,7 +750,7 @@ def X(self): self.X = None @property - def layers(self) -> Union[Layers, LayersView]: + def layers(self) -> Layers | LayersView: """\ Dictionary-like object with values of the same dimensions as :attr:`X`. @@ -811,7 +817,7 @@ def raw(self) -> Raw: return self._raw @raw.setter - def raw(self, value: "AnnData"): + def raw(self, value: AnnData): if value is None: del self.raw elif not isinstance(value, AnnData): @@ -881,7 +887,7 @@ def _prep_dim_index(self, value, attr: str) -> pd.Index: Inferred to be: {infer_dtype(value)} """ - ), # noqa + ), stacklevel=2, ) # fmt: on @@ -967,7 +973,7 @@ def uns(self): self.uns = OrderedDict() @property - def obsm(self) -> Union[AxisArrays, AxisArraysView]: + def obsm(self) -> AxisArrays | AxisArraysView: """\ Multi-dimensional annotation of observations (mutable structured :class:`~numpy.ndarray`). @@ -990,7 +996,7 @@ def obsm(self): self.obsm = dict() @property - def varm(self) -> Union[AxisArrays, AxisArraysView]: + def varm(self) -> AxisArrays | AxisArraysView: """\ Multi-dimensional annotation of variables/features (mutable structured :class:`~numpy.ndarray`). @@ -1013,7 +1019,7 @@ def varm(self): self.varm = dict() @property - def obsp(self) -> Union[PairwiseArrays, PairwiseArraysView]: + def obsp(self) -> PairwiseArrays | PairwiseArraysView: """\ Pairwise annotation of observations, a mutable mapping with array-like values. @@ -1036,7 +1042,7 @@ def obsp(self): self.obsp = dict() @property - def varp(self) -> Union[PairwiseArrays, PairwiseArraysView]: + def varp(self) -> PairwiseArrays | PairwiseArraysView: """\ Pairwise annotation of variables/features, a mutable mapping with array-like values. @@ -1058,25 +1064,25 @@ def varp(self, value): def varp(self): self.varp = dict() - def obs_keys(self) -> List[str]: + def obs_keys(self) -> list[str]: """List keys of observation annotation :attr:`obs`.""" return self._obs.keys().tolist() - def var_keys(self) -> List[str]: + def var_keys(self) -> list[str]: """List keys of variable annotation :attr:`var`.""" return self._var.keys().tolist() - def obsm_keys(self) -> List[str]: + def obsm_keys(self) -> list[str]: """List keys of observation annotation :attr:`obsm`.""" return list(self._obsm.keys()) - def varm_keys(self) -> List[str]: + def varm_keys(self) -> list[str]: """List keys of variable annotation :attr:`varm`.""" return list(self._varm.keys()) - def uns_keys(self) -> List[str]: + def uns_keys(self) -> list[str]: """List keys of unstructured annotation.""" - return sorted(list(self._uns.keys())) + return sorted(self._uns.keys()) @property def isbacked(self) -> bool: @@ -1089,7 +1095,7 @@ def is_view(self) -> bool: return self._is_view @property - def filename(self) -> Optional[Path]: + def filename(self) -> Path | None: """\ Change to backing mode by setting the filename of a `.h5ad` file. @@ -1101,7 +1107,7 @@ def filename(self) -> Optional[Path]: return self.file.filename @filename.setter - def filename(self, filename: Optional[PathLike]): + def filename(self, filename: PathLike | None): # convert early for later comparison filename = None if filename is None else Path(filename) # change from backing-mode back to full loading into memory @@ -1140,7 +1146,7 @@ def _set_backed(self, attr, value): write_attribute(self.file._file, attr, value) - def _normalize_indices(self, index: Optional[Index]) -> Tuple[slice, slice]: + def _normalize_indices(self, index: Index | None) -> tuple[slice, slice]: return _normalize_indices(index, self.obs_names, self.var_names) # TODO: this is not quite complete... @@ -1158,7 +1164,7 @@ def __delitem__(self, index: Index): if obs == slice(None): del self._var.iloc[var, :] - def __getitem__(self, index: Index) -> "AnnData": + def __getitem__(self, index: Index) -> AnnData: """Returns a sliced view of the object.""" oidx, vidx = self._normalize_indices(index) return AnnData(self, oidx=oidx, vidx=vidx, asview=True) @@ -1237,7 +1243,7 @@ def rename_categories(self, key: str, categories: Sequence[Any]): f"Omitting {k1}/{k2} as old categories do not match." ) - def strings_to_categoricals(self, df: Optional[pd.DataFrame] = None): + def strings_to_categoricals(self, df: pd.DataFrame | None = None): """\ Transform string annotations to categoricals. @@ -1309,7 +1315,7 @@ def _inplace_subset_obs(self, index: Index1D): # TODO: Update, possibly remove def __setitem__( - self, index: Index, val: Union[int, float, np.ndarray, sparse.spmatrix] + self, index: Index, val: int | float | np.ndarray | sparse.spmatrix ): if self.is_view: raise ValueError("Object is view and cannot be accessed with `[]`.") @@ -1324,7 +1330,7 @@ def __setitem__( def __len__(self) -> int: return self.shape[0] - def transpose(self) -> "AnnData": + def transpose(self) -> AnnData: """\ Transpose whole object. @@ -1407,7 +1413,7 @@ def _get_X(self, use_raw=False, layer=None): else: return self.X - def obs_vector(self, k: str, *, layer: Optional[str] = None) -> np.ndarray: + def obs_vector(self, k: str, *, layer: str | None = None) -> np.ndarray: """\ Convenience function for returning a 1 dimensional ndarray of values from :attr:`X`, :attr:`layers`\\ `[k]`, or :attr:`obs`. @@ -1439,7 +1445,7 @@ def obs_vector(self, k: str, *, layer: Optional[str] = None) -> np.ndarray: layer = None return get_vector(self, k, "obs", "var", layer=layer) - def var_vector(self, k, *, layer: Optional[str] = None) -> np.ndarray: + def var_vector(self, k, *, layer: str | None = None) -> np.ndarray: """\ Convenience function for returning a 1 dimensional ndarray of values from :attr:`X`, :attr:`layers`\\ `[k]`, or :attr:`obs`. @@ -1522,7 +1528,7 @@ def _mutated_copy(self, **kwargs): new["raw"] = self.raw.copy() return AnnData(**new) - def to_memory(self, copy=False) -> "AnnData": + def to_memory(self, copy=False) -> AnnData: """Return a new AnnData object with all backed arrays loaded into memory. Params @@ -1567,7 +1573,7 @@ def to_memory(self, copy=False) -> "AnnData": return AnnData(**new) - def copy(self, filename: Optional[PathLike] = None) -> "AnnData": + def copy(self, filename: PathLike | None = None) -> AnnData: """Full copy, optionally on disk.""" if not self.isbacked: if self.is_view and self._has_X(): @@ -1595,14 +1601,14 @@ def copy(self, filename: Optional[PathLike] = None) -> "AnnData": def concatenate( self, - *adatas: "AnnData", + *adatas: AnnData, join: str = "inner", batch_key: str = "batch", batch_categories: Sequence[Any] = None, - uns_merge: Optional[str] = None, - index_unique: Optional[str] = "-", + uns_merge: str | None = None, + index_unique: str | None = "-", fill_value=None, - ) -> "AnnData": + ) -> AnnData: """\ Concatenate along the observations axis. @@ -1814,7 +1820,7 @@ def concatenate( [0., 0., 2., 1.], [0., 6., 5., 0.]], dtype=float32) """ - from .merge import concat, merge_outer, merge_dataframes, merge_same + from .merge import concat, merge_dataframes, merge_outer, merge_same warnings.warn( "The AnnData.concatenate method is deprecated in favour of the " @@ -1908,7 +1914,7 @@ def _check_dimensions(self, key=None): if "obsm" in key: obsm = self._obsm if ( - not all([dim_len(o, 0) == self.n_obs for o in obsm.values()]) + not all(dim_len(o, 0) == self.n_obs for o in obsm.values()) and len(obsm.dim_names) != self.n_obs ): raise ValueError( @@ -1918,7 +1924,7 @@ def _check_dimensions(self, key=None): if "varm" in key: varm = self._varm if ( - not all([dim_len(v, 0) == self.n_vars for v in varm.values()]) + not all(dim_len(v, 0) == self.n_vars for v in varm.values()) and len(varm.dim_names) != self.n_vars ): raise ValueError( @@ -1928,9 +1934,9 @@ def _check_dimensions(self, key=None): def write_h5ad( self, - filename: Optional[PathLike] = None, - compression: Optional[Literal["gzip", "lzf"]] = None, - compression_opts: Union[int, Any] = None, + filename: PathLike | None = None, + compression: Literal["gzip", "lzf"] | None = None, + compression_opts: int | Any = None, as_dense: Sequence[str] = (), ): """\ @@ -2050,8 +2056,8 @@ def write_loom(self, filename: PathLike, write_obsm_varm: bool = False): def write_zarr( self, - store: Union[MutableMapping, PathLike], - chunks: Union[bool, int, Tuple[int, ...], None] = None, + store: MutableMapping | PathLike, + chunks: bool | int | tuple[int, ...] | None = None, ): """\ Write a hierarchical Zarr array store. @@ -2067,7 +2073,7 @@ def write_zarr( write_zarr(store, self, chunks=chunks) - def chunked_X(self, chunk_size: Optional[int] = None): + def chunked_X(self, chunk_size: int | None = None): """\ Return an iterator over the rows of the data matrix :attr:`X`. @@ -2090,7 +2096,7 @@ def chunked_X(self, chunk_size: Optional[int] = None): def chunk_X( self, - select: Union[int, Sequence[int], np.ndarray] = 1000, + select: int | Sequence[int] | np.ndarray = 1000, replace: bool = True, ): """\ diff --git a/anndata/_core/file_backing.py b/anndata/_core/file_backing.py index 02401873c..ecef53b9a 100644 --- a/anndata/_core/file_backing.py +++ b/anndata/_core/file_backing.py @@ -1,14 +1,19 @@ +from __future__ import annotations + +from collections.abc import Iterator, Mapping from functools import singledispatch -from os import PathLike from pathlib import Path -from typing import Optional, Union, Iterator, Literal -from collections.abc import Mapping +from typing import TYPE_CHECKING, Literal import h5py -from . import anndata +from ..compat import AwkArray, DaskArray, ZarrArray from .sparse_dataset import SparseDataset -from ..compat import ZarrArray, DaskArray, AwkArray + +if TYPE_CHECKING: + from os import PathLike + + from . import anndata class AnnDataFileManager: @@ -16,9 +21,9 @@ class AnnDataFileManager: def __init__( self, - adata: "anndata.AnnData", - filename: Optional[PathLike] = None, - filemode: Optional[Literal["r", "r+"]] = None, + adata: anndata.AnnData, + filename: PathLike | None = None, + filemode: Literal["r", "r+"] | None = None, ): self._adata = adata self.filename = filename @@ -39,11 +44,11 @@ def __contains__(self, x) -> bool: def __iter__(self) -> Iterator[str]: return iter(self._file) - def __getitem__(self, key: str) -> Union[h5py.Group, h5py.Dataset, SparseDataset]: + def __getitem__(self, key: str) -> h5py.Group | h5py.Dataset | SparseDataset: return self._file[key] def __setitem__( - self, key: str, value: Union[h5py.Group, h5py.Dataset, SparseDataset] + self, key: str, value: h5py.Group | h5py.Dataset | SparseDataset ): self._file[key] = value @@ -55,13 +60,13 @@ def filename(self) -> Path: return self._filename @filename.setter - def filename(self, filename: Optional[PathLike]): + def filename(self, filename: PathLike | None): self._filename = None if filename is None else Path(filename) def open( self, - filename: Optional[PathLike] = None, - filemode: Optional[Literal["r", "r+"]] = None, + filename: PathLike | None = None, + filemode: Literal["r", "r+"] | None = None, ): if filename is not None: self.filename = filename diff --git a/anndata/_core/index.py b/anndata/_core/index.py index 859c1bcdd..673ca2341 100644 --- a/anndata/_core/index.py +++ b/anndata/_core/index.py @@ -1,18 +1,21 @@ +from __future__ import annotations + import collections.abc as cabc +from collections.abc import Sequence from functools import singledispatch from itertools import repeat -from typing import Union, Sequence, Optional, Tuple import h5py import numpy as np import pandas as pd -from scipy.sparse import spmatrix, issparse +from scipy.sparse import issparse, spmatrix + from ..compat import AwkArray, DaskArray, Index, Index1D def _normalize_indices( - index: Optional[Index], names0: pd.Index, names1: pd.Index -) -> Tuple[slice, slice]: + index: Index | None, names0: pd.Index, names1: pd.Index +) -> tuple[slice, slice]: # deal with tuples of length 1 if isinstance(index, tuple) and len(index) == 1: index = index[0] @@ -35,17 +38,9 @@ def _normalize_indices( def _normalize_index( - indexer: Union[ - slice, - np.integer, - int, - str, - Sequence[Union[int, np.integer]], - np.ndarray, - pd.Index, - ], + indexer: slice | np.integer | int | str | Sequence[int | np.integer] | np.ndarray | pd.Index, index: pd.Index, -) -> Union[slice, int, np.ndarray]: # ndarray of int +) -> slice | int | np.ndarray: # ndarray of int if not isinstance(index, pd.RangeIndex): assert ( index.dtype != float and index.dtype != int @@ -104,7 +99,7 @@ def name_idx(i): raise IndexError(f"Unknown indexer {indexer!r} of type {type(indexer)}") -def unpack_index(index: Index) -> Tuple[Index1D, Index1D]: +def unpack_index(index: Index) -> tuple[Index1D, Index1D]: if not isinstance(index, tuple): return index, slice(None) elif len(index) == 2: @@ -116,7 +111,7 @@ def unpack_index(index: Index) -> Tuple[Index1D, Index1D]: @singledispatch -def _subset(a: Union[np.ndarray, pd.DataFrame], subset_idx: Index): +def _subset(a: np.ndarray | pd.DataFrame, subset_idx: Index): # Select as combination of indexes, not coordinates # Correcting for indexing behaviour of np.ndarray if all(isinstance(x, cabc.Iterable) for x in subset_idx): diff --git a/anndata/_core/merge.py b/anndata/_core/merge.py index dd193005f..552cdeb88 100644 --- a/anndata/_core/merge.py +++ b/anndata/_core/merge.py @@ -3,34 +3,37 @@ """ from __future__ import annotations +import typing from collections import OrderedDict from collections.abc import ( Callable, Collection, + Iterable, Mapping, MutableSet, - Iterable, Sequence, ) from functools import reduce, singledispatch from itertools import repeat from operator import and_, or_, sub -from typing import Any, Optional, TypeVar, Union, Literal -import typing -from warnings import warn, filterwarnings +from typing import Any, Literal, TypeVar +from warnings import filterwarnings, warn -from natsort import natsorted import numpy as np import pandas as pd -from pandas.api.extensions import ExtensionDtype +from natsort import natsorted from scipy import sparse -from scipy.sparse import spmatrix -from .anndata import AnnData -from ..compat import AwkArray, DaskArray, CupySparseMatrix, CupyArray, CupyCSRMatrix +from anndata._warnings import ExperimentalFeatureWarning + +from ..compat import AwkArray, CupyArray, CupyCSRMatrix, CupySparseMatrix, DaskArray from ..utils import asarray, dim_len +from .anndata import AnnData from .index import _subset, make_slice -from anndata._warnings import ExperimentalFeatureWarning + +if typing.TYPE_CHECKING: + from pandas.api.extensions import ExtensionDtype + from scipy.sparse import spmatrix T = TypeVar("T") @@ -62,14 +65,14 @@ def copy(self): def add(self, val): self.dict[val] = None - def union(self, *vals) -> "OrderedSet": + def union(self, *vals) -> OrderedSet: return reduce(or_, vals, self) def discard(self, val): if val in self: del self.dict[val] - def difference(self, *vals) -> "OrderedSet": + def difference(self, *vals) -> OrderedSet: return reduce(sub, vals, self) @@ -340,7 +343,7 @@ def _cpblock_diag(mats, format=None, dtype=None): ################### -def unique_value(vals: Collection[T]) -> Union[T, MissingVal]: +def unique_value(vals: Collection[T]) -> T | MissingVal: """ Given a collection vals, returns the unique value (if one exists), otherwise returns MissingValue. @@ -352,7 +355,7 @@ def unique_value(vals: Collection[T]) -> Union[T, MissingVal]: return unique_val -def first(vals: Collection[T]) -> Union[T, MissingVal]: +def first(vals: Collection[T]) -> T | MissingVal: """ Given a collection of vals, return the first non-missing one.If they're all missing, return MissingVal. @@ -363,7 +366,7 @@ def first(vals: Collection[T]) -> Union[T, MissingVal]: return MissingVal -def only(vals: Collection[T]) -> Union[T, MissingVal]: +def only(vals: Collection[T]) -> T | MissingVal: """Return the only value in the collection, otherwise MissingVal.""" if len(vals) == 1: return vals[0] @@ -436,7 +439,7 @@ def merge_only(ds: Collection[Mapping]) -> Mapping: def resolve_merge_strategy( - strategy: Union[str, Callable, None] + strategy: str | Callable | None ) -> Callable[[Collection[Mapping]], Mapping]: if not isinstance(strategy, Callable): strategy = MERGE_STRATEGIES[strategy] @@ -994,16 +997,16 @@ def concat_Xs(adatas, reindexers, axis, fill_value): def concat( - adatas: Union[Collection[AnnData], "typing.Mapping[str, AnnData]"], + adatas: Collection[AnnData] | typing.Mapping[str, AnnData], *, axis: Literal[0, 1] = 0, join: Literal["inner", "outer"] = "inner", - merge: Union[StrategiesLiteral, Callable, None] = None, - uns_merge: Union[StrategiesLiteral, Callable, None] = None, - label: Optional[str] = None, - keys: Optional[Collection] = None, - index_unique: Optional[str] = None, - fill_value: Optional[Any] = None, + merge: StrategiesLiteral | Callable | None = None, + uns_merge: StrategiesLiteral | Callable | None = None, + label: str | None = None, + keys: Collection | None = None, + index_unique: str | None = None, + fill_value: Any | None = None, pairwise: bool = False, ) -> AnnData: """Concatenates AnnData objects along an axis. diff --git a/anndata/_core/raw.py b/anndata/_core/raw.py index 058c9055c..4f361bf70 100644 --- a/anndata/_core/raw.py +++ b/anndata/_core/raw.py @@ -1,27 +1,32 @@ -from typing import Union, Mapping, Sequence, Tuple +from __future__ import annotations + +from typing import TYPE_CHECKING import h5py import numpy as np import pandas as pd -from scipy import sparse from scipy.sparse import issparse +from ..compat import CupyArray, CupySparseMatrix from . import anndata -from .index import _normalize_index, _subset, unpack_index, get_vector from .aligned_mapping import AxisArrays +from .index import _normalize_index, _subset, get_vector, unpack_index from .sparse_dataset import SparseDataset -from ..compat import CupyArray, CupySparseMatrix +if TYPE_CHECKING: + from collections.abc import Mapping, Sequence + + from scipy import sparse # TODO: Implement views for Raw class Raw: def __init__( self, - adata: "anndata.AnnData", - X: Union[np.ndarray, sparse.spmatrix, None] = None, - var: Union[pd.DataFrame, Mapping[str, Sequence], None] = None, - varm: Union[AxisArrays, Mapping[str, np.ndarray], None] = None, + adata: anndata.AnnData, + X: np.ndarray | sparse.spmatrix | None = None, + var: pd.DataFrame | Mapping[str, Sequence] | None = None, + varm: AxisArrays | Mapping[str, np.ndarray] | None = None, ): from .anndata import _gen_dataframe @@ -56,7 +61,7 @@ def _get_X(self, layer=None): return self.X @property - def X(self) -> Union[SparseDataset, np.ndarray, sparse.spmatrix]: + def X(self) -> SparseDataset | np.ndarray | sparse.spmatrix: # TODO: Handle unsorted array of integer indices for h5py.Datasets if not self._adata.isbacked: return self._X @@ -191,12 +196,12 @@ def obs_vector(self, k: str) -> np.ndarray: # This exists to accommodate AlignedMappings, # until we implement a proper RawView or get rid of Raw in favor of modes. class _RawViewHack: - def __init__(self, raw: Raw, vidx: Union[slice, np.ndarray]): + def __init__(self, raw: Raw, vidx: slice | np.ndarray): self.parent_raw = raw self.vidx = vidx @property - def shape(self) -> Tuple[int, int]: + def shape(self) -> tuple[int, int]: return self.parent_raw.n_obs, len(self.var_names) @property diff --git a/anndata/_core/sparse_dataset.py b/anndata/_core/sparse_dataset.py index 8654e8dd7..7741b196f 100644 --- a/anndata/_core/sparse_dataset.py +++ b/anndata/_core/sparse_dataset.py @@ -10,9 +10,11 @@ # TODO: # - think about supporting the COO format +from __future__ import annotations + import collections.abc as cabc from itertools import accumulate, chain -from typing import Union, NamedTuple, Tuple, Sequence, Iterable, Type +from typing import TYPE_CHECKING, NamedTuple from warnings import warn import h5py @@ -28,13 +30,16 @@ except ImportError: _cs_matrix = ss.spmatrix -from .index import unpack_index, Index, _subset +from .index import Index, _subset, unpack_index + +if TYPE_CHECKING: + from collections.abc import Iterable, Sequence class BackedFormat(NamedTuple): format_str: str - backed_type: Type["BackedSparseMatrix"] - memory_type: Type[ss.spmatrix] + backed_type: type[BackedSparseMatrix] + memory_type: type[ss.spmatrix] class BackedSparseMatrix(_cs_matrix): @@ -188,7 +193,7 @@ def slice_as_int(s: slice, l: int) -> int: def get_compressed_vectors( x: BackedSparseMatrix, row_idxs: Iterable[int] -) -> Tuple[Sequence, Sequence, Sequence]: +) -> tuple[Sequence, Sequence, Sequence]: slices = [slice(*(x.indptr[i : i + 2])) for i in row_idxs] data = np.concatenate([x.data[s] for s in slices]) indices = np.concatenate([x.indices[s] for s in slices]) @@ -198,7 +203,7 @@ def get_compressed_vectors( def get_compressed_vector( x: BackedSparseMatrix, idx: int -) -> Tuple[Sequence, Sequence, Sequence]: +) -> tuple[Sequence, Sequence, Sequence]: s = slice(*(x.indptr[idx : idx + 2])) data = x.data[s] indices = x.indices[s] @@ -213,14 +218,14 @@ def get_format_str(data: ss.spmatrix) -> str: raise ValueError(f"Data type {type(data)} is not supported.") -def get_memory_class(format_str: str) -> Type[ss.spmatrix]: +def get_memory_class(format_str: str) -> type[ss.spmatrix]: for fmt, _, memory_class in FORMATS: if format_str == fmt: return memory_class raise ValueError(f"Format string {format_str} is not supported.") -def get_backed_class(format_str: str) -> Type[BackedSparseMatrix]: +def get_backed_class(format_str: str) -> type[BackedSparseMatrix]: for fmt, backed_class, _ in FORMATS: if format_str == fmt: return backed_class @@ -263,7 +268,7 @@ def file(self) -> h5py.File: return self.group.file @property - def shape(self) -> Tuple[int, int]: + def shape(self) -> tuple[int, int]: shape = self.group.attrs.get("h5sparse_shape") return tuple(self.group.attrs["shape"] if shape is None else shape) @@ -278,7 +283,7 @@ def __repr__(self) -> str: f'type {self.group["data"].dtype.str!r}>' ) - def __getitem__(self, index: Union[Index, Tuple[()]]) -> Union[float, ss.spmatrix]: + def __getitem__(self, index: Index | tuple[()]) -> float | ss.spmatrix: row, col = self._normalize_index(index) mtx = self.to_backed() sub = mtx[row, col] @@ -289,14 +294,14 @@ def __getitem__(self, index: Union[Index, Tuple[()]]) -> Union[float, ss.spmatri else: return sub - def __setitem__(self, index: Union[Index, Tuple[()]], value): + def __setitem__(self, index: Index | tuple[()], value): row, col = self._normalize_index(index) mock_matrix = self.to_backed() mock_matrix[row, col] = value def _normalize_index( - self, index: Union[Index, Tuple[()]] - ) -> Tuple[np.ndarray, np.ndarray]: + self, index: Index | tuple[()] + ) -> tuple[np.ndarray, np.ndarray]: if index == (): index = slice(None) row, col = unpack_index(index) @@ -339,7 +344,7 @@ def append(self, sparse_matrix: ss.spmatrix): ), "CSC matrices must have same size of dimension 0 to be appended." new_shape = (shape[0], shape[1] + sparse_matrix.shape[1]) else: - assert False, "We forgot to update this branching to a new format" + raise AssertionError("We forgot to update this branching to a new format") if "h5sparse_shape" in self.group.attrs: del self.group.attrs["h5sparse_shape"] self.group.attrs["shape"] = new_shape diff --git a/anndata/_core/views.py b/anndata/_core/views.py index aa8dbb625..17aa2982c 100644 --- a/anndata/_core/views.py +++ b/anndata/_core/views.py @@ -1,28 +1,32 @@ from __future__ import annotations +import warnings from contextlib import contextmanager from copy import deepcopy -from collections.abc import Sequence, KeysView, Callable, Iterable from functools import reduce, singledispatch, wraps -from typing import Any, Literal -import warnings +from typing import TYPE_CHECKING, Any, Literal import numpy as np import pandas as pd from pandas.api.types import is_bool_dtype from scipy import sparse -import anndata from anndata._warnings import ImplicitModificationWarning -from .access import ElementRef + from ..compat import ( - ZappyArray, AwkArray, - DaskArray, CupyArray, CupyCSCMatrix, CupyCSRMatrix, + DaskArray, + ZappyArray, ) +from .access import ElementRef + +if TYPE_CHECKING: + from collections.abc import Callable, Iterable, KeysView, Sequence + + import anndata @contextmanager @@ -79,7 +83,7 @@ class _ViewMixin(_SetItemMixin): def __init__( self, *args, - view_args: tuple["anndata.AnnData", str, tuple[str, ...]] = None, + view_args: tuple[anndata.AnnData, str, tuple[str, ...]] = None, **kwargs, ): if view_args is not None: @@ -100,7 +104,7 @@ class ArrayView(_SetItemMixin, np.ndarray): def __new__( cls, input_array: Sequence[Any], - view_args: tuple["anndata.AnnData", str, tuple[str, ...]] = None, + view_args: tuple[anndata.AnnData, str, tuple[str, ...]] = None, ): arr = np.asanyarray(input_array).view(cls) @@ -172,7 +176,7 @@ class DaskArrayView(_SetItemMixin, DaskArray): def __new__( cls, input_array: DaskArray, - view_args: tuple["anndata.AnnData", str, tuple[str, ...]] = None, + view_args: tuple[anndata.AnnData, str, tuple[str, ...]] = None, ): arr = super().__new__( cls, @@ -226,7 +230,7 @@ class CupyArrayView(_ViewMixin, CupyArray): def __new__( cls, input_array: Sequence[Any], - view_args: tuple["anndata.AnnData", str, tuple[str, ...]] = None, + view_args: tuple[anndata.AnnData, str, tuple[str, ...]] = None, ): import cupy as cp @@ -316,9 +320,10 @@ def as_view_cupy_csc(mtx, view_args): try: - from ..compat import awkward as ak import weakref + from ..compat import awkward as ak + # Registry to store weak references from AwkwardArrayViews to their parent AnnData container _registry = weakref.WeakValueDictionary() _PARAM_NAME = "_view_args" diff --git a/anndata/_io/__init__.py b/anndata/_io/__init__.py index f305d42ab..7bb6ba506 100644 --- a/anndata/_io/__init__.py +++ b/anndata/_io/__init__.py @@ -1,3 +1,6 @@ +from __future__ import annotations + +from .h5ad import read_h5ad, write_h5ad from .read import ( read_csv, read_excel, @@ -8,7 +11,6 @@ read_umi_tools, read_zarr, ) -from .h5ad import read_h5ad, write_h5ad from .write import write_csvs, write_loom diff --git a/anndata/_io/h5ad.py b/anndata/_io/h5ad.py index 0ec1d81c3..cff340db7 100644 --- a/anndata/_io/h5ad.py +++ b/anndata/_io/h5ad.py @@ -1,41 +1,51 @@ +from __future__ import annotations + import re from functools import partial -from warnings import warn from pathlib import Path from types import MappingProxyType -from typing import Callable, Type, TypeVar, Union, Literal -from typing import Collection, Sequence, Mapping +from typing import ( + TYPE_CHECKING, + Callable, + Literal, + TypeVar, +) +from warnings import warn import h5py import numpy as np import pandas as pd from scipy import sparse -from .._core.sparse_dataset import SparseDataset -from .._core.file_backing import AnnDataFileManager +from anndata._warnings import OldFormatWarning + from .._core.anndata import AnnData +from .._core.sparse_dataset import SparseDataset from ..compat import ( - _from_fixed_length_strings, - _decode_structured_array, _clean_uns, + _decode_structured_array, + _from_fixed_length_strings, ) from ..experimental import read_dispatched +from .specs import read_elem, write_elem from .utils import ( H5PY_V3, + _read_legacy_raw, + idx_chunks_along_axis, report_read_key_on_error, report_write_key_on_error, - idx_chunks_along_axis, - _read_legacy_raw, ) -from .specs import read_elem, write_elem -from anndata._warnings import OldFormatWarning +if TYPE_CHECKING: + from collections.abc import Collection, Mapping, Sequence + + from .._core.file_backing import AnnDataFileManager T = TypeVar("T") def write_h5ad( - filepath: Union[Path, str], + filepath: Path | str, adata: AnnData, *, as_dense: Sequence[str] = (), @@ -121,7 +131,7 @@ def write_sparse_as_dense(f, key, value, dataset_kwargs=MappingProxyType({})): del f[key] -def read_h5ad_backed(filename: Union[str, Path], mode: Literal["r", "r+"]) -> AnnData: +def read_h5ad_backed(filename: str | Path, mode: Literal["r", "r+"]) -> AnnData: d = dict(filename=filename, filemode=mode) f = h5py.File(filename, mode) @@ -150,11 +160,11 @@ def read_h5ad_backed(filename: Union[str, Path], mode: Literal["r", "r+"]) -> An def read_h5ad( - filename: Union[str, Path], - backed: Union[Literal["r", "r+"], bool, None] = None, + filename: str | Path, + backed: Literal["r", "r+"] | bool | None = None, *, as_sparse: Sequence[str] = (), - as_sparse_fmt: Type[sparse.spmatrix] = sparse.csr_matrix, + as_sparse_fmt: type[sparse.spmatrix] = sparse.csr_matrix, chunk_size: int = 6000, # TODO, probably make this 2d chunks ) -> AnnData: """\ @@ -255,7 +265,7 @@ def callback(func, elem_name: str, elem, iospec): def _read_raw( - f: Union[h5py.File, AnnDataFileManager], + f: h5py.File | AnnDataFileManager, as_sparse: Collection[str] = (), rdasp: Callable[[h5py.Dataset], sparse.spmatrix] = None, *, diff --git a/anndata/_io/read.py b/anndata/_io/read.py index 91115a81b..fcf8bb668 100644 --- a/anndata/_io/read.py +++ b/anndata/_io/read.py @@ -1,11 +1,12 @@ -from pathlib import Path +from __future__ import annotations + +import bz2 +import gzip +from collections import OrderedDict from os import PathLike, fspath +from pathlib import Path from types import MappingProxyType -from typing import Union, Optional, Mapping, Tuple -from typing import Iterable, Iterator, Generator -from collections import OrderedDict -import gzip -import bz2 +from typing import TYPE_CHECKING from warnings import warn import h5py @@ -17,6 +18,9 @@ from ..compat import _deprecate_positional_args from .utils import is_float +if TYPE_CHECKING: + from collections.abc import Generator, Iterable, Iterator, Mapping + try: from .zarr import read_zarr except ImportError as _e: @@ -27,9 +31,9 @@ def read_zarr(*_, **__): def read_csv( - filename: Union[PathLike, Iterator[str]], - delimiter: Optional[str] = ",", - first_column_names: Optional[bool] = None, + filename: PathLike | Iterator[str], + delimiter: str | None = ",", + first_column_names: bool | None = None, dtype: str = "float32", ) -> AnnData: """\ @@ -54,7 +58,7 @@ def read_csv( def read_excel( - filename: PathLike, sheet: Union[str, int], dtype: str = "float32" + filename: PathLike, sheet: str | int, dtype: str = "float32" ) -> AnnData: """\ Read `.xlsx` (Excel) file. @@ -118,7 +122,7 @@ def read_hdf(filename: PathLike, key: str) -> AnnData: with h5py.File(filename, "r") as f: # the following is necessary in Python 3, because only # a view and not a list is returned - keys = [k for k in f.keys()] + keys = list(f.keys()) if key == "": raise ValueError( f"The file {filename} stores the following sheets:\n{keys}\n" @@ -137,7 +141,7 @@ def read_hdf(filename: PathLike, key: str) -> AnnData: def _fmt_loom_axis_attrs( input: Mapping, idx_name: str, dimm_mapping: Mapping[str, Iterable[str]] -) -> Tuple[pd.DataFrame, Mapping[str, np.ndarray]]: +) -> tuple[pd.DataFrame, Mapping[str, np.ndarray]]: axis_df = pd.DataFrame() axis_mapping = {} for key, names in dimm_mapping.items(): @@ -163,9 +167,9 @@ def read_loom( cleanup: bool = False, X_name: str = "spliced", obs_names: str = "CellID", - obsm_names: Optional[Mapping[str, Iterable[str]]] = None, + obsm_names: Mapping[str, Iterable[str]] | None = None, var_names: str = "Gene", - varm_names: Optional[Mapping[str, Iterable[str]]] = None, + varm_names: Mapping[str, Iterable[str]] | None = None, dtype: str = "float32", obsm_mapping: Mapping[str, Iterable[str]] = MappingProxyType({}), varm_mapping: Mapping[str, Iterable[str]] = MappingProxyType({}), @@ -320,9 +324,9 @@ def read_mtx(filename: PathLike, dtype: str = "float32") -> AnnData: def read_text( - filename: Union[PathLike, Iterator[str]], - delimiter: Optional[str] = None, - first_column_names: Optional[bool] = None, + filename: PathLike | Iterator[str], + delimiter: str | None = None, + first_column_names: bool | None = None, dtype: str = "float32", ) -> AnnData: """\ @@ -368,8 +372,8 @@ def _iter_lines(file_like: Iterable[str]) -> Generator[str, None, None]: def _read_text( f: Iterator[str], - delimiter: Optional[str], - first_column_names: Optional[bool], + delimiter: str | None, + first_column_names: bool | None, dtype: str, ) -> AnnData: comments = [] diff --git a/anndata/_io/specs/__init__.py b/anndata/_io/specs/__init__.py index 28281a1e0..ceff8b3d6 100644 --- a/anndata/_io/specs/__init__.py +++ b/anndata/_io/specs/__init__.py @@ -1,6 +1,15 @@ +from __future__ import annotations + from . import methods -from .registry import write_elem, get_spec, read_elem, Reader, Writer, IOSpec -from .registry import _REGISTRY # noqa: F401 +from .registry import ( + _REGISTRY, # noqa: F401 + IOSpec, + Reader, + Writer, + get_spec, + read_elem, + write_elem, +) __all__ = [ "methods", diff --git a/anndata/_io/specs/methods.py b/anndata/_io/specs/methods.py index 702b34b55..695d25292 100644 --- a/anndata/_io/specs/methods.py +++ b/anndata/_io/specs/methods.py @@ -1,11 +1,10 @@ from __future__ import annotations -from os import PathLike from collections.abc import Mapping -from itertools import product from functools import partial -from typing import Union, Literal +from itertools import product from types import MappingProxyType +from typing import TYPE_CHECKING, Literal from warnings import warn import h5py @@ -15,24 +14,30 @@ import anndata as ad from anndata import AnnData, Raw +from anndata._core import views from anndata._core.index import _normalize_indices from anndata._core.merge import intersect_keys from anndata._core.sparse_dataset import SparseDataset -from anndata._core import views +from anndata._io.utils import H5PY_V3, check_key +from anndata._warnings import OldFormatWarning from anndata.compat import ( + AwkArray, + CupyArray, + CupyCSCMatrix, + CupyCSRMatrix, + DaskArray, ZarrArray, ZarrGroup, - DaskArray, - _read_attr, - _from_fixed_length_strings, _decode_structured_array, + _from_fixed_length_strings, + _read_attr, ) -from anndata._io.utils import check_key, H5PY_V3 -from anndata._warnings import OldFormatWarning -from anndata.compat import AwkArray, CupyArray, CupyCSRMatrix, CupyCSCMatrix from .registry import _REGISTRY, IOSpec, read_elem, read_elem_partial +if TYPE_CHECKING: + from os import PathLike + H5Array = h5py.Dataset H5Group = h5py.Group H5File = h5py.File @@ -686,7 +691,7 @@ def read_dataframe_0_1_0(elem, _reader): return df -def read_series(dataset: h5py.Dataset) -> Union[np.ndarray, pd.Categorical]: +def read_series(dataset: h5py.Dataset) -> np.ndarray | pd.Categorical: # For reading older dataframes if "categories" in dataset.attrs: if isinstance(dataset, ZarrArray): diff --git a/anndata/_io/specs/registry.py b/anndata/_io/specs/registry.py index 07ddbb744..b30c3a740 100644 --- a/anndata/_io/specs/registry.py +++ b/anndata/_io/specs/registry.py @@ -1,14 +1,16 @@ from __future__ import annotations -from collections.abc import Mapping, Callable, Iterable +from collections.abc import Callable, Iterable, Mapping from dataclasses import dataclass from functools import singledispatch, wraps from types import MappingProxyType -from typing import Any, Union +from typing import TYPE_CHECKING, Any +from anndata._io.utils import report_read_key_on_error, report_write_key_on_error from anndata.compat import _read_attr -from anndata._types import StorageType, GroupStorageType -from anndata._io.utils import report_write_key_on_error, report_read_key_on_error + +if TYPE_CHECKING: + from anndata._types import GroupStorageType, StorageType # TODO: This probably should be replaced by a hashable Mapping due to conversion b/w "_" and "-" # TODO: Should filetype be included in the IOSpec if it changes the encoding? Or does the intent that these things be "the same" overrule that? @@ -66,7 +68,7 @@ def __init__(self): self.write: dict[ tuple[type, type | tuple[type, str], frozenset[str]], Callable ] = {} - self.write_specs: dict[Union[type, tuple[type, str]], IOSpec] = {} + self.write_specs: dict[type | tuple[type, str], IOSpec] = {} def register_write( self, @@ -213,7 +215,7 @@ def get_spec( class Reader: def __init__( - self, registry: IORegistry, callback: Union[Callable, None] = None + self, registry: IORegistry, callback: Callable | None = None ) -> None: self.registry = registry self.callback = callback @@ -241,8 +243,7 @@ class Writer: def __init__( self, registry: IORegistry, - callback: Union[ - Callable[ + callback: Callable[ [ GroupStorageType, str, @@ -250,9 +251,7 @@ def __init__( dict, ], None, - ], - None, - ] = None, + ] | None = None, ): self.registry = registry self.callback = callback diff --git a/anndata/_io/utils.py b/anndata/_io/utils.py index de2919626..02716da8e 100644 --- a/anndata/_io/utils.py +++ b/anndata/_io/utils.py @@ -4,12 +4,13 @@ from typing import Callable, Literal from warnings import warn -from packaging import version import h5py +from packaging import version -from .._core.sparse_dataset import SparseDataset from anndata.compat import H5Group, ZarrGroup, add_note +from .._core.sparse_dataset import SparseDataset + # For allowing h5py v3 # https://github.com/scverse/anndata/issues/442 H5PY_V3 = version.parse(h5py.__version__).major >= 3 diff --git a/anndata/_io/write.py b/anndata/_io/write.py index da801888e..c488743dc 100644 --- a/anndata/_io/write.py +++ b/anndata/_io/write.py @@ -1,15 +1,20 @@ +from __future__ import annotations + +import math import warnings -from pathlib import Path from os import PathLike, fspath +from pathlib import Path +from typing import TYPE_CHECKING -import pandas as pd -import math import numpy as np +import pandas as pd from scipy.sparse import issparse -from .. import AnnData -from ..logging import get_logger from .._warnings import WriteWarning +from ..logging import get_logger + +if TYPE_CHECKING: + from .. import AnnData logger = get_logger(__name__) diff --git a/anndata/_io/zarr.py b/anndata/_io/zarr.py index d85e1fc19..022ee8a1d 100644 --- a/anndata/_io/zarr.py +++ b/anndata/_io/zarr.py @@ -1,32 +1,36 @@ -from collections.abc import MutableMapping +from __future__ import annotations + from pathlib import Path -from typing import TypeVar, Union +from typing import TYPE_CHECKING, TypeVar from warnings import warn import numpy as np -from scipy import sparse import pandas as pd import zarr +from scipy import sparse + +from anndata._warnings import OldFormatWarning from .._core.anndata import AnnData from ..compat import ( - _from_fixed_length_strings, _clean_uns, + _from_fixed_length_strings, ) from ..experimental import read_dispatched, write_dispatched +from .specs import read_elem from .utils import ( - report_read_key_on_error, _read_legacy_raw, + report_read_key_on_error, ) -from .specs import read_elem -from anndata._warnings import OldFormatWarning +if TYPE_CHECKING: + from collections.abc import MutableMapping T = TypeVar("T") def write_zarr( - store: Union[MutableMapping, str, Path], + store: MutableMapping | str | Path, adata: AnnData, chunks=None, **ds_kwargs, @@ -50,7 +54,7 @@ def callback(func, s, k, elem, dataset_kwargs, iospec): write_dispatched(f, "/", adata, callback=callback, dataset_kwargs=ds_kwargs) -def read_zarr(store: Union[str, Path, MutableMapping, zarr.Group]) -> AnnData: +def read_zarr(store: str | Path | MutableMapping | zarr.Group) -> AnnData: """\ Read from a hierarchical Zarr array store. diff --git a/anndata/_types.py b/anndata/_types.py index d5b6b1c5c..7f57e380f 100644 --- a/anndata/_types.py +++ b/anndata/_types.py @@ -1,6 +1,8 @@ """ Defines some useful types for this library. Should probably be cleaned up before thinking about exporting. """ +from __future__ import annotations + from typing import Union from anndata.compat import H5Array, H5Group, ZarrArray, ZarrGroup diff --git a/anndata/_warnings.py b/anndata/_warnings.py index 5bc0c461c..1820a6d96 100644 --- a/anndata/_warnings.py +++ b/anndata/_warnings.py @@ -1,3 +1,6 @@ +from __future__ import annotations + + class WriteWarning(UserWarning): pass diff --git a/anndata/compat/__init__.py b/anndata/compat/__init__.py index f69276bff..7e2411f95 100644 --- a/anndata/compat/__init__.py +++ b/anndata/compat/__init__.py @@ -1,20 +1,20 @@ from __future__ import annotations +import os +from codecs import decode +from collections.abc import Mapping from contextlib import AbstractContextManager from dataclasses import dataclass, field - from functools import singledispatch, wraps -from codecs import decode -from inspect import signature, Parameter -import os +from inspect import Parameter, signature from pathlib import Path -from typing import Any, Tuple, Union, Mapping, Optional +from typing import Any, Union from warnings import warn import h5py -from scipy.sparse import spmatrix import numpy as np import pandas as pd +from scipy.sparse import spmatrix from .exceptiongroups import add_note # noqa: F401 @@ -24,7 +24,7 @@ class Empty: Index1D = Union[slice, int, str, np.int64, np.ndarray] -Index = Union[Index1D, Tuple[Index1D, Index1D], spmatrix] +Index = Union[Index1D, tuple[Index1D, Index1D], spmatrix] H5Group = h5py.Group H5Array = h5py.Dataset @@ -105,12 +105,16 @@ def __repr__(): try: + from cupy import ndarray as CupyArray from cupyx.scipy.sparse import ( - spmatrix as CupySparseMatrix, - csr_matrix as CupyCSRMatrix, csc_matrix as CupyCSCMatrix, ) - from cupy import ndarray as CupyArray + from cupyx.scipy.sparse import ( + csr_matrix as CupyCSRMatrix, + ) + from cupyx.scipy.sparse import ( + spmatrix as CupySparseMatrix, + ) except ImportError: class CupySparseMatrix: @@ -140,7 +144,7 @@ def __repr__(): @singledispatch -def _read_attr(attrs: Mapping, name: str, default: Optional[Any] = Empty): +def _read_attr(attrs: Mapping, name: str, default: Any | None = Empty): if default is Empty: return attrs[name] else: @@ -149,7 +153,7 @@ def _read_attr(attrs: Mapping, name: str, default: Optional[Any] = Empty): @_read_attr.register(h5py.AttributeManager) def _read_attr_hdf5( - attrs: h5py.AttributeManager, name: str, default: Optional[Any] = Empty + attrs: h5py.AttributeManager, name: str, default: Any | None = Empty ): """ Read an HDF5 attribute and perform all necessary conversions. @@ -200,7 +204,7 @@ def _from_fixed_length_strings(value): def _decode_structured_array( - arr: np.ndarray, dtype: Optional[np.dtype] = None, copy: bool = False + arr: np.ndarray, dtype: np.dtype | None = None, copy: bool = False ) -> np.ndarray: """ h5py 3.0 now reads all strings as bytes. There is a helper method which can convert these to strings, @@ -250,7 +254,7 @@ def _to_fixed_length_strings(value: np.ndarray) -> np.ndarray: ############################# -def _clean_uns(adata: "AnnData"): # noqa: F821 +def _clean_uns(adata: AnnData): # noqa: F821 """ Compat function for when categorical keys were stored in uns. This used to be buggy because when storing categorical columns in obs and var with @@ -342,7 +346,7 @@ def inner_f(*args, **kwargs): # extra_args > 0 args_msg = [ - "{}={}".format(name, arg) + f"{name}={arg}" for name, arg in zip(kwonly_args[:extra_args], args[-extra_args:]) ] args_msg = ", ".join(args_msg) diff --git a/anndata/compat/exceptiongroups.py b/anndata/compat/exceptiongroups.py index f64090017..49d6c3a65 100644 --- a/anndata/compat/exceptiongroups.py +++ b/anndata/compat/exceptiongroups.py @@ -1,3 +1,5 @@ +from __future__ import annotations + import sys diff --git a/anndata/core.py b/anndata/core.py index c4b254c0e..8e6ef0382 100644 --- a/anndata/core.py +++ b/anndata/core.py @@ -1,3 +1,5 @@ +from __future__ import annotations + from warnings import warn warn("Please only import from anndata, not anndata.core", DeprecationWarning) diff --git a/anndata/experimental/__init__.py b/anndata/experimental/__init__.py index b16d2cd32..289d33dcf 100644 --- a/anndata/experimental/__init__.py +++ b/anndata/experimental/__init__.py @@ -1,11 +1,11 @@ from __future__ import annotations -from .multi_files import AnnCollection -from .pytorch import AnnLoader +from anndata._io.specs import IOSpec, read_elem, write_elem -from anndata._io.specs import read_elem, write_elem, IOSpec from ._dispatch_io import read_dispatched, write_dispatched from .merge import concat_on_disk +from .multi_files import AnnCollection +from .pytorch import AnnLoader __all__ = [ "AnnCollection", diff --git a/anndata/experimental/_dispatch_io.py b/anndata/experimental/_dispatch_io.py index 2df14b4f1..4df4d417a 100644 --- a/anndata/experimental/_dispatch_io.py +++ b/anndata/experimental/_dispatch_io.py @@ -1,11 +1,11 @@ from __future__ import annotations from types import MappingProxyType -from typing import Callable, Any +from typing import TYPE_CHECKING, Any, Callable - -from anndata._io.specs import IOSpec -from anndata._types import StorageType, GroupStorageType +if TYPE_CHECKING: + from anndata._io.specs import IOSpec + from anndata._types import GroupStorageType, StorageType def read_dispatched( @@ -39,7 +39,7 @@ def read_dispatched( :doc:`/tutorials/notebooks/{read,write}_dispatched` """ - from anndata._io.specs import Reader, _REGISTRY + from anndata._io.specs import _REGISTRY, Reader reader = Reader(_REGISTRY, callback=callback) @@ -90,7 +90,7 @@ def write_dispatched( :doc:`/tutorials/notebooks/{read,write}_dispatched` """ - from anndata._io.specs import Writer, _REGISTRY + from anndata._io.specs import _REGISTRY, Writer writer = Writer(_REGISTRY, callback=callback) diff --git a/anndata/experimental/merge.py b/anndata/experimental/merge.py index 07e723fb2..db01d6a29 100644 --- a/anndata/experimental/merge.py +++ b/anndata/experimental/merge.py @@ -1,18 +1,14 @@ +from __future__ import annotations + import os import shutil +from collections.abc import Collection, Iterable, Mapping, MutableMapping, Sequence from functools import singledispatch from pathlib import Path from typing import ( Any, Callable, - Collection, - Iterable, Literal, - Mapping, - Optional, - Sequence, - Union, - MutableMapping, ) import numpy as np @@ -104,12 +100,12 @@ def _gen_slice_to_append( @singledispatch -def as_group(store, *args, **kwargs) -> Union[ZarrGroup, H5Group]: +def as_group(store, *args, **kwargs) -> ZarrGroup | H5Group: raise NotImplementedError("This is not yet implemented.") @as_group.register(os.PathLike) -def _(store: os.PathLike, *args, **kwargs) -> Union[ZarrGroup, H5Group]: +def _(store: os.PathLike, *args, **kwargs) -> ZarrGroup | H5Group: if store.suffix == ".h5ad": import h5py @@ -120,7 +116,7 @@ def _(store: os.PathLike, *args, **kwargs) -> Union[ZarrGroup, H5Group]: @as_group.register(str) -def _(store: str, *args, **kwargs) -> Union[ZarrGroup, H5Group]: +def _(store: str, *args, **kwargs) -> ZarrGroup | H5Group: return as_group(Path(store), *args, **kwargs) @@ -135,7 +131,7 @@ def _(store, *args, **kwargs): ################### -def read_as_backed(group: Union[ZarrGroup, H5Group]): +def read_as_backed(group: ZarrGroup | H5Group): """ Read the group until SparseDataset, Array or EAGER_TYPES are encountered. @@ -156,7 +152,7 @@ def callback(func, elem_name: str, elem, iospec): return read_dispatched(group, callback=callback) -def _df_index(df: Union[ZarrGroup, H5Group]) -> pd.Index: +def _df_index(df: ZarrGroup | H5Group) -> pd.Index: index_key = df.attrs["_index"] return pd.Index(read_elem(df[index_key])) @@ -167,9 +163,9 @@ def _df_index(df: Union[ZarrGroup, H5Group]) -> pd.Index: def write_concat_dense( - arrays: Sequence[Union[ZarrArray, H5Array]], - output_group: Union[ZarrGroup, H5Group], - output_path: Union[ZarrGroup, H5Group], + arrays: Sequence[ZarrArray | H5Array], + output_group: ZarrGroup | H5Group, + output_path: ZarrGroup | H5Group, axis: Literal[0, 1] = 0, reindexers: Reindexer = None, fill_value=None, @@ -196,8 +192,8 @@ def write_concat_dense( def write_concat_sparse( datasets: Sequence[SparseDataset], - output_group: Union[ZarrGroup, H5Group], - output_path: Union[ZarrGroup, H5Group], + output_group: ZarrGroup | H5Group, + output_path: ZarrGroup | H5Group, max_loaded_elems: int, axis: Literal[0, 1] = 0, reindexers: Reindexer = None, @@ -235,7 +231,7 @@ def write_concat_sparse( def _write_concat_mappings( mappings, - output_group: Union[ZarrGroup, H5Group], + output_group: ZarrGroup | H5Group, keys, path, max_loaded_elems, @@ -269,7 +265,7 @@ def _write_concat_mappings( def _write_concat_arrays( - arrays: Sequence[Union[ZarrArray, H5Array, SparseDataset]], + arrays: Sequence[ZarrArray | H5Array | SparseDataset], output_group, output_path, max_loaded_elems, @@ -314,7 +310,7 @@ def _write_concat_arrays( def _write_concat_sequence( - arrays: Sequence[Union[pd.DataFrame, SparseDataset, H5Array, ZarrArray]], + arrays: Sequence[pd.DataFrame | SparseDataset | H5Array | ZarrArray], output_group, output_path, max_loaded_elems, @@ -398,26 +394,19 @@ def _write_dim_annot(groups, output_group, dim, concat_indices, label, label_col def concat_on_disk( - in_files: Union[ - Collection[Union[str, os.PathLike]], - MutableMapping[str, Union[str, os.PathLike]], - ], - out_file: Union[str, os.PathLike], + in_files: Collection[str | os.PathLike] | MutableMapping[str, str | os.PathLike], + out_file: str | os.PathLike, *, overwrite: bool = False, max_loaded_elems: int = 100_000_000, axis: Literal[0, 1] = 0, join: Literal["inner", "outer"] = "inner", - merge: Union[ - StrategiesLiteral, Callable[[Collection[Mapping]], Mapping], None - ] = None, - uns_merge: Union[ - StrategiesLiteral, Callable[[Collection[Mapping]], Mapping], None - ] = None, - label: Optional[str] = None, - keys: Optional[Collection[str]] = None, - index_unique: Optional[str] = None, - fill_value: Optional[Any] = None, + merge: StrategiesLiteral | Callable[[Collection[Mapping]], Mapping] | None = None, + uns_merge: StrategiesLiteral | Callable[[Collection[Mapping]], Mapping] | None = None, + label: str | None = None, + keys: Collection[str] | None = None, + index_unique: str | None = None, + fill_value: Any | None = None, pairwise: bool = False, ) -> None: """Concatenates multiple AnnData objects along a specified axis using their diff --git a/anndata/experimental/multi_files/__init__.py b/anndata/experimental/multi_files/__init__.py index 86d4e8f44..956ebb8d2 100644 --- a/anndata/experimental/multi_files/__init__.py +++ b/anndata/experimental/multi_files/__init__.py @@ -1,3 +1,5 @@ +from __future__ import annotations + from ._anncollection import AnnCollection __all__ = ["AnnCollection"] diff --git a/anndata/experimental/multi_files/_anncollection.py b/anndata/experimental/multi_files/_anncollection.py index cbbb4247a..a3c660512 100644 --- a/anndata/experimental/multi_files/_anncollection.py +++ b/anndata/experimental/multi_files/_anncollection.py @@ -1,18 +1,20 @@ -from collections.abc import Mapping +from __future__ import annotations + +import warnings +from collections.abc import Mapping, Sequence from functools import reduce -from h5py import Dataset +from typing import Callable, Literal, Union + import numpy as np import pandas as pd -import warnings - -from typing import Dict, Union, Optional, Sequence, Callable, Literal +from h5py import Dataset +from ..._core.aligned_mapping import AxisArrays from ..._core.anndata import AnnData -from ..._core.index import _normalize_indices, _normalize_index, Index -from ..._core.views import _resolve_idx +from ..._core.index import Index, _normalize_index, _normalize_indices from ..._core.merge import concat_arrays, inner_concat_aligned_mapping from ..._core.sparse_dataset import SparseDataset -from ..._core.aligned_mapping import AxisArrays +from ..._core.views import _resolve_idx ATTRS = ["obs", "obsm", "layers"] @@ -571,8 +573,8 @@ def attrs_keys(self): return self.reference.attrs_keys -DictCallable = Dict[str, Callable] -ConvertType = Union[Callable, DictCallable, Dict[str, DictCallable]] +DictCallable = dict[str, Callable] +ConvertType = Union[Callable, DictCallable, dict[str, DictCallable]] class AnnCollection(_ConcatViewMixin, _IterateViewMixin): @@ -665,14 +667,14 @@ class AnnCollection(_ConcatViewMixin, _IterateViewMixin): def __init__( self, - adatas: Union[Sequence[AnnData], Dict[str, AnnData]], - join_obs: Optional[Literal["inner", "outer"]] = "inner", - join_obsm: Optional[Literal["inner"]] = None, - join_vars: Optional[Literal["inner"]] = None, - label: Optional[str] = None, - keys: Optional[Sequence[str]] = None, - index_unique: Optional[str] = None, - convert: Optional[ConvertType] = None, + adatas: Sequence[AnnData] | dict[str, AnnData], + join_obs: Literal["inner", "outer"] | None = "inner", + join_obsm: Literal["inner"] | None = None, + join_vars: Literal["inner"] | None = None, + label: str | None = None, + keys: Sequence[str] | None = None, + index_unique: str | None = None, + convert: ConvertType | None = None, harmonize_dtypes: bool = True, indices_strict: bool = True, ): @@ -689,7 +691,7 @@ def __init__( # check if the variables are the same in all adatas self.adatas_vidx = [None for adata in adatas] vars_names_list = [adata.var_names for adata in adatas] - vars_eq = all([adatas[0].var_names.equals(vrs) for vrs in vars_names_list[1:]]) + vars_eq = all(adatas[0].var_names.equals(vrs) for vrs in vars_names_list[1:]) if vars_eq: self.var_names = adatas[0].var_names elif join_vars == "inner": @@ -901,7 +903,7 @@ def lazy_attr(self, attr, key=None): @property def has_backed(self): """`True` if `adatas` have backed AnnData objects, `False` otherwise.""" - return any([adata.isbacked for adata in self.adatas]) + return any(adata.isbacked for adata in self.adatas) @property def attrs_keys(self): @@ -933,7 +935,7 @@ def __repr__(self): class LazyAttrData(_IterateViewMixin): - def __init__(self, adset: AnnCollection, attr: str, key: Optional[str] = None): + def __init__(self, adset: AnnCollection, attr: str, key: str | None = None): self.adset = adset self.attr = attr self.key = key diff --git a/anndata/experimental/pytorch/__init__.py b/anndata/experimental/pytorch/__init__.py index d4fbffce7..36c9441fe 100644 --- a/anndata/experimental/pytorch/__init__.py +++ b/anndata/experimental/pytorch/__init__.py @@ -1,3 +1,5 @@ +from __future__ import annotations + from ._annloader import AnnLoader __all__ = ["AnnLoader"] diff --git a/anndata/experimental/pytorch/_annloader.py b/anndata/experimental/pytorch/_annloader.py index 15ad53a52..8cc883921 100644 --- a/anndata/experimental/pytorch/_annloader.py +++ b/anndata/experimental/pytorch/_annloader.py @@ -1,18 +1,22 @@ -from scipy.sparse import issparse -from math import ceil +from __future__ import annotations + from copy import copy from functools import partial -from typing import Dict, Union, Sequence +from math import ceil +from typing import TYPE_CHECKING import numpy as np +from scipy.sparse import issparse from ..._core.anndata import AnnData from ..multi_files._anncollection import AnnCollection, _ConcatViewMixin +if TYPE_CHECKING: + from collections.abc import Sequence try: import torch - from torch.utils.data import Sampler, BatchSampler, DataLoader + from torch.utils.data import BatchSampler, DataLoader, Sampler except ImportError: Sampler, BatchSampler, DataLoader = object, object, object @@ -123,7 +127,7 @@ class AnnLoader(DataLoader): def __init__( self, - adatas: Union[Sequence[AnnData], Dict[str, AnnData]], + adatas: Sequence[AnnData] | dict[str, AnnData], batch_size: int = 1, shuffle: bool = False, use_default_converter: bool = True, diff --git a/anndata/logging.py b/anndata/logging.py index f5feac09c..a2a890c51 100644 --- a/anndata/logging.py +++ b/anndata/logging.py @@ -1,5 +1,7 @@ -import os +from __future__ import annotations + import logging +import os _previous_memory_usage = None diff --git a/anndata/readwrite.py b/anndata/readwrite.py index dfe5a7074..f3d07f732 100644 --- a/anndata/readwrite.py +++ b/anndata/readwrite.py @@ -1,3 +1,5 @@ +from __future__ import annotations + from warnings import warn warn("Please only import from anndata, not anndata.readwrite", DeprecationWarning) diff --git a/anndata/tests/conftest.py b/anndata/tests/conftest.py index ef8a3b50e..e16197cc7 100644 --- a/anndata/tests/conftest.py +++ b/anndata/tests/conftest.py @@ -1,3 +1,5 @@ +from __future__ import annotations + import warnings import pytest @@ -5,7 +7,6 @@ import anndata from anndata.tests.helpers import subset_func # noqa: F401 - # TODO: Should be done in pyproject.toml, see anndata/conftest.py warnings.filterwarnings("ignore", category=anndata.OldFormatWarning) diff --git a/anndata/tests/helpers.py b/anndata/tests/helpers.py index ef66b2a9d..492f76672 100644 --- a/anndata/tests/helpers.py +++ b/anndata/tests/helpers.py @@ -1,34 +1,33 @@ from __future__ import annotations -from contextlib import contextmanager -from functools import singledispatch, wraps, partial +import random import re -from string import ascii_letters -from typing import Tuple, Optional, Type -from collections.abc import Mapping, Collection import warnings +from collections.abc import Collection, Mapping +from contextlib import contextmanager +from functools import partial, singledispatch, wraps +from string import ascii_letters import h5py import numpy as np import pandas as pd -from pandas.api.types import is_numeric_dtype import pytest +from pandas.api.types import is_numeric_dtype from scipy import sparse -import random from anndata import AnnData, Raw -from anndata._core.views import ArrayView -from anndata._core.sparse_dataset import SparseDataset from anndata._core.aligned_mapping import AlignedMapping -from anndata.utils import asarray +from anndata._core.sparse_dataset import SparseDataset +from anndata._core.views import ArrayView from anndata.compat import ( AwkArray, - DaskArray, - CupySparseMatrix, CupyArray, CupyCSCMatrix, CupyCSRMatrix, + CupySparseMatrix, + DaskArray, ) +from anndata.utils import asarray # Give this to gen_adata when dask array support is expected. GEN_ADATA_DASK_ARGS = dict( @@ -156,24 +155,24 @@ def gen_typed_df_t2_size(m, n, index=None, columns=None) -> pd.DataFrame: # TODO: Use hypothesis for this? def gen_adata( - shape: Tuple[int, int], + shape: tuple[int, int], X_type=sparse.csr_matrix, X_dtype=np.float32, # obs_dtypes, # var_dtypes, - obsm_types: "Collection[Type]" = ( + obsm_types: Collection[type] = ( sparse.csr_matrix, np.ndarray, pd.DataFrame, AwkArray, ), - varm_types: "Collection[Type]" = ( + varm_types: Collection[type] = ( sparse.csr_matrix, np.ndarray, pd.DataFrame, AwkArray, ), - layers_types: "Collection[Type]" = (sparse.csr_matrix, np.ndarray, pd.DataFrame), + layers_types: Collection[type] = (sparse.csr_matrix, np.ndarray, pd.DataFrame), sparse_fmt: str = "csr", ) -> AnnData: """\ @@ -535,7 +534,7 @@ def assert_is_not_none(x): # can't put an assert in a lambda @assert_equal.register(AnnData) def assert_adata_equal( - a: AnnData, b: AnnData, exact: bool = False, elem_name: Optional[str] = None + a: AnnData, b: AnnData, exact: bool = False, elem_name: str | None = None ): """\ Check whether two AnnData objects are equivalent, @@ -660,16 +659,16 @@ def as_cupy_type(val, typ=None): val = val.toarray() return cp.array(val) elif issubclass(typ, CupyCSRMatrix): - import cupyx.scipy.sparse as cpsparse import cupy as cp + import cupyx.scipy.sparse as cpsparse if isinstance(val, np.ndarray): return cpsparse.csr_matrix(cp.array(val)) else: return cpsparse.csr_matrix(val) elif issubclass(typ, CupyCSCMatrix): - import cupyx.scipy.sparse as cpsparse import cupy as cp + import cupyx.scipy.sparse as cpsparse if isinstance(val, np.ndarray): return cpsparse.csc_matrix(cp.array(val)) diff --git a/anndata/tests/test_anncollection.py b/anndata/tests/test_anncollection.py index b8def9508..aaef199e7 100644 --- a/anndata/tests/test_anncollection.py +++ b/anndata/tests/test_anncollection.py @@ -1,10 +1,11 @@ -import pytest -import anndata as ad -import numpy as np +from __future__ import annotations +import numpy as np +import pytest from scipy.sparse import csr_matrix, issparse - from sklearn.preprocessing import LabelEncoder + +import anndata as ad from anndata.experimental.multi_files import AnnCollection _dense = lambda a: a.toarray() if issparse(a) else a diff --git a/anndata/tests/test_annot.py b/anndata/tests/test_annot.py index 025c7d5a6..0ea609906 100644 --- a/anndata/tests/test_annot.py +++ b/anndata/tests/test_annot.py @@ -1,12 +1,13 @@ """Test handling of values in `obs`/ `var`""" -from natsort import natsorted +from __future__ import annotations + import numpy as np import pandas as pd +import pytest +from natsort import natsorted import anndata as ad -import pytest - @pytest.mark.parametrize("dtype", [object, "string"]) def test_str_to_categorical(dtype): diff --git a/anndata/tests/test_awkward.py b/anndata/tests/test_awkward.py index 87280d5a2..993fb91de 100644 --- a/anndata/tests/test_awkward.py +++ b/anndata/tests/test_awkward.py @@ -1,15 +1,16 @@ """Tests related to awkward arrays""" -import pytest +from __future__ import annotations + import numpy as np import numpy.testing as npt +import pandas as pd +import pytest -from anndata.tests.helpers import assert_equal, gen_adata, gen_awkward +import anndata +from anndata import AnnData, ImplicitModificationWarning, read_h5ad from anndata.compat import awkward as ak -from anndata import ImplicitModificationWarning +from anndata.tests.helpers import assert_equal, gen_adata, gen_awkward from anndata.utils import dim_len -from anndata import AnnData, read_h5ad -import anndata -import pandas as pd @pytest.mark.parametrize( diff --git a/anndata/tests/test_backed_sparse.py b/anndata/tests/test_backed_sparse.py index 4d3eb72f6..6a21b6381 100644 --- a/anndata/tests/test_backed_sparse.py +++ b/anndata/tests/test_backed_sparse.py @@ -1,3 +1,5 @@ +from __future__ import annotations + import h5py import numpy as np import pytest diff --git a/anndata/tests/test_base.py b/anndata/tests/test_base.py index ffdc2a04d..90816b867 100644 --- a/anndata/tests/test_base.py +++ b/anndata/tests/test_base.py @@ -1,14 +1,14 @@ from __future__ import annotations -from functools import partial -from itertools import product import re import warnings +from functools import partial +from itertools import product import numpy as np -from numpy import ma import pandas as pd import pytest +from numpy import ma from scipy import sparse as sp from scipy.sparse import csr_matrix, issparse @@ -16,7 +16,6 @@ from anndata._core.raw import Raw from anndata.tests.helpers import assert_equal, gen_adata - # some test objects that we use below adata_dense = AnnData(np.array([[1, 2], [3, 4]])) adata_dense.layers["test"] = adata_dense.X diff --git a/anndata/tests/test_concatenate.py b/anndata/tests/test_concatenate.py index 19b917b9d..d719d017a 100644 --- a/anndata/tests/test_concatenate.py +++ b/anndata/tests/test_concatenate.py @@ -1,33 +1,34 @@ +from __future__ import annotations + +import warnings from collections.abc import Hashable from copy import deepcopy -from itertools import chain, product from functools import partial, singledispatch -from typing import Any, List, Callable -import warnings +from itertools import chain, product +from typing import Any, Callable import numpy as np -from numpy import ma import pandas as pd import pytest +from boltons.iterutils import default_exit, remap, research +from numpy import ma from scipy import sparse -from boltons.iterutils import research, remap, default_exit - from anndata import AnnData, Raw, concat -from anndata._core.index import _subset from anndata._core import merge +from anndata._core.index import _subset +from anndata.compat import AwkArray, DaskArray from anndata.tests import helpers from anndata.tests.helpers import ( - assert_equal, - as_dense_dask_array, - gen_adata, - GEN_ADATA_DASK_ARGS, BASE_MATRIX_PARAMS, - DASK_MATRIX_PARAMS, CUPY_MATRIX_PARAMS, + DASK_MATRIX_PARAMS, + GEN_ADATA_DASK_ARGS, + as_dense_dask_array, + assert_equal, + gen_adata, ) from anndata.utils import asarray -from anndata.compat import DaskArray, AwkArray @singledispatch @@ -960,7 +961,7 @@ def map_values(mapping, path, key, old_parent, new_parent, new_items): return ret -def permute_nested_values(dicts: "List[dict]", gen_val: "Callable[[int], Any]"): +def permute_nested_values(dicts: list[dict], gen_val: Callable[[int], Any]): """ This function permutes the values of a nested mapping, for testing that out merge method work regardless of the values types. @@ -1303,7 +1304,7 @@ def test_concat_size_0_dim(axis, join_type, merge_strategy, shape): check_filled_like(result.X[axis_idx], elem_name="X") check_filled_like(result.X[altaxis_idx], elem_name="X") - for k, elem in getattr(result, "layers").items(): + for k, elem in result.layers.items(): check_filled_like(elem[axis_idx], elem_name=f"layers/{k}") check_filled_like(elem[altaxis_idx], elem_name=f"layers/{k}") @@ -1386,9 +1387,10 @@ def test_concat_X_dtype(): # Tests how dask plays with other types on concatenation. def test_concat_different_types_dask(merge_strategy, array_type): + import dask.array as da from scipy import sparse + import anndata as ad - import dask.array as da varm_array = sparse.random(5, 20, density=0.5, format="csr") diff --git a/anndata/tests/test_concatenate_disk.py b/anndata/tests/test_concatenate_disk.py index 1ffbb63ef..0192df452 100644 --- a/anndata/tests/test_concatenate_disk.py +++ b/anndata/tests/test_concatenate_disk.py @@ -1,23 +1,21 @@ -from typing import Mapping +from __future__ import annotations + +from collections.abc import Mapping import numpy as np import pandas as pd import pytest from scipy import sparse -from anndata.experimental.merge import concat_on_disk, as_group -from anndata.experimental import write_elem, read_elem - from anndata import AnnData, concat +from anndata.experimental import read_elem, write_elem +from anndata.experimental.merge import as_group, concat_on_disk from anndata.tests.helpers import ( assert_equal, gen_adata, ) - - from anndata.utils import asarray - GEN_ADATA_OOC_CONCAT_ARGS = dict( obsm_types=( sparse.csr_matrix, diff --git a/anndata/tests/test_dask.py b/anndata/tests/test_dask.py index 21daf6898..c5c159c46 100644 --- a/anndata/tests/test_dask.py +++ b/anndata/tests/test_dask.py @@ -1,19 +1,22 @@ """ For tests using dask """ -import anndata as ad +from __future__ import annotations + import pandas as pd -from anndata._core.anndata import AnnData import pytest + +import anndata as ad +from anndata._core.anndata import AnnData +from anndata.compat import DaskArray +from anndata.experimental import read_elem, write_elem +from anndata.experimental.merge import as_group from anndata.tests.helpers import ( - as_dense_dask_array, GEN_ADATA_DASK_ARGS, - gen_adata, + as_dense_dask_array, assert_equal, + gen_adata, ) -from anndata.experimental import write_elem, read_elem -from anndata.experimental.merge import as_group -from anndata.compat import DaskArray pytest.importorskip("dask.array") @@ -243,6 +246,7 @@ def test_assign_X(adata): """Check if assignment works""" import dask.array as da import numpy as np + from anndata.compat import DaskArray adata.X = da.ones(adata.X.shape) @@ -306,8 +310,8 @@ def test_dask_to_memory_copy_unbacked(): def test_to_memory_raw(): - import numpy as np import dask.array as da + import numpy as np orig = gen_adata((20, 10), **GEN_ADATA_DASK_ARGS) orig.X = da.ones((20, 10)) @@ -327,8 +331,8 @@ def test_to_memory_raw(): def test_to_memory_copy_raw(): - import numpy as np import dask.array as da + import numpy as np orig = gen_adata((20, 10), **GEN_ADATA_DASK_ARGS) orig.X = da.ones((20, 10)) diff --git a/anndata/tests/test_dask_view_mem.py b/anndata/tests/test_dask_view_mem.py index 6d758477b..bb758a223 100644 --- a/anndata/tests/test_dask_view_mem.py +++ b/anndata/tests/test_dask_view_mem.py @@ -1,3 +1,5 @@ +from __future__ import annotations + import pytest import anndata as ad @@ -43,8 +45,8 @@ def alloc_cache(): **{ "layers": dict(m=da.random.random(*size)), "obsm": dict(m=da.random.random(*size)), - "obs": dict(m=da.random.random((N))), - "var": dict(m=da.random.random((N))), + "obs": dict(m=da.random.random(N)), + "var": dict(m=da.random.random(N)), "varm": dict(m=da.random.random(*size)), }, ) diff --git a/anndata/tests/test_deprecations.py b/anndata/tests/test_deprecations.py index 27ae920dd..e11f686fb 100644 --- a/anndata/tests/test_deprecations.py +++ b/anndata/tests/test_deprecations.py @@ -3,6 +3,8 @@ This includes correct behaviour as well as throwing warnings. """ +from __future__ import annotations + import warnings import h5py @@ -10,9 +12,8 @@ import pytest from scipy import sparse -from anndata import AnnData import anndata as ad - +from anndata import AnnData from anndata.tests.helpers import assert_equal @@ -101,8 +102,8 @@ def test_dtype_warning(): def test_deprecated_write_attribute(tmp_path): pth = tmp_path / "file.h5" A = np.random.randn(20, 10) - from anndata._io.utils import read_attribute, write_attribute from anndata._io.specs import read_elem + from anndata._io.utils import read_attribute, write_attribute with h5py.File(pth, "w") as f: with pytest.warns(DeprecationWarning, match="write_elem"): diff --git a/anndata/tests/test_get_vector.py b/anndata/tests/test_get_vector.py index ca2ce18a7..baf0fd7d6 100644 --- a/anndata/tests/test_get_vector.py +++ b/anndata/tests/test_get_vector.py @@ -1,7 +1,9 @@ +from __future__ import annotations + import numpy as np import pandas as pd -from scipy import sparse import pytest +from scipy import sparse import anndata as ad diff --git a/anndata/tests/test_gpu.py b/anndata/tests/test_gpu.py index 434567ca8..c6f49a696 100644 --- a/anndata/tests/test_gpu.py +++ b/anndata/tests/test_gpu.py @@ -1,3 +1,5 @@ +from __future__ import annotations + import pytest from scipy import sparse @@ -16,8 +18,8 @@ def test_gpu(): @pytest.mark.gpu def test_adata_raw_gpu(): - from cupyx.scipy import sparse as cupy_sparse import cupy as cp + from cupyx.scipy import sparse as cupy_sparse adata = AnnData( X=cupy_sparse.random(500, 50, density=0.01, format="csr", dtype=cp.float32) @@ -28,8 +30,8 @@ def test_adata_raw_gpu(): @pytest.mark.gpu def test_raw_gpu(): - from cupyx.scipy import sparse as cupy_sparse import cupy as cp + from cupyx.scipy import sparse as cupy_sparse adata = AnnData( X=cupy_sparse.random(500, 50, density=0.01, format="csr", dtype=cp.float32) diff --git a/anndata/tests/test_hdf5_backing.py b/anndata/tests/test_hdf5_backing.py index ab308e363..61c0c905c 100644 --- a/anndata/tests/test_hdf5_backing.py +++ b/anndata/tests/test_hdf5_backing.py @@ -1,16 +1,18 @@ +from __future__ import annotations + from pathlib import Path import joblib -import pytest import numpy as np +import pytest from scipy import sparse import anndata as ad from anndata.tests.helpers import ( - as_dense_dask_array, GEN_ADATA_DASK_ARGS, - gen_adata, + as_dense_dask_array, assert_equal, + gen_adata, subset_func, ) from anndata.utils import asarray diff --git a/anndata/tests/test_helpers.py b/anndata/tests/test_helpers.py index f540c43f4..52f1d6cb1 100644 --- a/anndata/tests/test_helpers.py +++ b/anndata/tests/test_helpers.py @@ -1,21 +1,23 @@ +from __future__ import annotations + from string import ascii_letters +import numpy as np import pandas as pd import pytest -import numpy as np from scipy import sparse import anndata as ad +from anndata.compat import add_note from anndata.tests.helpers import ( + asarray, assert_equal, - gen_awkward, - report_name, gen_adata, - asarray, + gen_awkward, pytest_8_raises, + report_name, ) from anndata.utils import dim_len -from anndata.compat import add_note # Testing to see if all error types can have the key name appended. # Currently fails for 22/118 since they have required arguments. Not sure what to do about that. diff --git a/anndata/tests/test_inplace_subset.py b/anndata/tests/test_inplace_subset.py index b90421965..110d2574a 100644 --- a/anndata/tests/test_inplace_subset.py +++ b/anndata/tests/test_inplace_subset.py @@ -1,11 +1,13 @@ +from __future__ import annotations + import numpy as np import pytest from scipy import sparse from anndata.tests.helpers import ( + as_dense_dask_array, assert_equal, gen_adata, - as_dense_dask_array, ) from anndata.utils import asarray diff --git a/anndata/tests/test_io_backwards_compat.py b/anndata/tests/test_io_backwards_compat.py index a060d1779..fb12c8161 100644 --- a/anndata/tests/test_io_backwards_compat.py +++ b/anndata/tests/test_io_backwards_compat.py @@ -1,10 +1,12 @@ +from __future__ import annotations + from pathlib import Path +import pandas as pd import pytest +from scipy import sparse import anndata as ad -import pandas as pd -from scipy import sparse from anndata.tests.helpers import assert_equal ARCHIVE_PTH = Path(__file__).parent / "data/archives" diff --git a/anndata/tests/test_io_conversion.py b/anndata/tests/test_io_conversion.py index dd5e9ab61..29a5d27e9 100644 --- a/anndata/tests/test_io_conversion.py +++ b/anndata/tests/test_io_conversion.py @@ -1,13 +1,15 @@ """\ This file contains tests for conversion made during io. """ +from __future__ import annotations + import h5py import numpy as np import pytest from scipy import sparse import anndata as ad -from anndata.tests.helpers import gen_adata, assert_equal +from anndata.tests.helpers import assert_equal, gen_adata @pytest.fixture( diff --git a/anndata/tests/test_io_dispatched.py b/anndata/tests/test_io_dispatched.py index b43eb67c2..511179d4c 100644 --- a/anndata/tests/test_io_dispatched.py +++ b/anndata/tests/test_io_dispatched.py @@ -1,17 +1,19 @@ +from __future__ import annotations + import re -from scipy import sparse import h5py import zarr +from scipy import sparse import anndata as ad from anndata.experimental import ( read_dispatched, - write_dispatched, read_elem, + write_dispatched, write_elem, ) -from anndata.tests.helpers import gen_adata, assert_equal +from anndata.tests.helpers import assert_equal, gen_adata def test_read_dispatched_w_regex(): @@ -79,7 +81,7 @@ def test_read_dispatched_null_case(): def test_write_dispatched_chunks(): - from itertools import repeat, chain + from itertools import chain, repeat def determine_chunks(elem_shape, specified_chunks): chunk_iterator = chain(specified_chunks, repeat(None)) diff --git a/anndata/tests/test_io_elementwise.py b/anndata/tests/test_io_elementwise.py index 48f93c405..579dcfc84 100644 --- a/anndata/tests/test_io_elementwise.py +++ b/anndata/tests/test_io_elementwise.py @@ -9,19 +9,18 @@ import numpy as np import pandas as pd import pytest -from scipy import sparse import zarr +from scipy import sparse import anndata as ad -from anndata._io.specs import _REGISTRY, get_spec, IOSpec +from anndata._io.specs import _REGISTRY, IOSpec, get_spec, read_elem, write_elem from anndata._io.specs.registry import IORegistryError -from anndata.compat import _read_attr, H5Group, ZarrGroup -from anndata._io.specs import write_elem, read_elem +from anndata.compat import H5Group, ZarrGroup, _read_attr from anndata.tests.helpers import ( - assert_equal, as_cupy_type, - pytest_8_raises, + assert_equal, gen_adata, + pytest_8_raises, ) @@ -38,7 +37,7 @@ def store(request, tmp_path) -> H5Group | ZarrGroup: elif request.param == "zarr": store = zarr.open(tmp_path / "test.zarr", "w") else: - assert False + raise AssertionError() try: yield store diff --git a/anndata/tests/test_io_partial.py b/anndata/tests/test_io_partial.py index b75e5ccf1..d43aaca1c 100644 --- a/anndata/tests/test_io_partial.py +++ b/anndata/tests/test_io_partial.py @@ -1,14 +1,18 @@ +from __future__ import annotations + from importlib.util import find_spec -from anndata import AnnData -from anndata._io.specs import read_elem -from anndata._io.specs.registry import read_elem_partial -from anndata._io import write_h5ad, write_zarr -from scipy.sparse import csr_matrix from pathlib import Path + +import h5py import numpy as np import pytest import zarr -import h5py +from scipy.sparse import csr_matrix + +from anndata import AnnData +from anndata._io import write_h5ad, write_zarr +from anndata._io.specs import read_elem +from anndata._io.specs.registry import read_elem_partial X = np.array([[1.0, 0.0, 3.0], [4.0, 0.0, 6.0], [0.0, 8.0, 0.0]], dtype="float32") X_check = np.array([[4.0, 0.0], [0.0, 8.0]], dtype="float32") diff --git a/anndata/tests/test_io_utils.py b/anndata/tests/test_io_utils.py index 637e7e5b5..9f7428900 100644 --- a/anndata/tests/test_io_utils.py +++ b/anndata/tests/test_io_utils.py @@ -1,16 +1,18 @@ +from __future__ import annotations + from contextlib import nullcontext -import pytest -import zarr import h5py import pandas as pd +import pytest +import zarr import anndata as ad from anndata._io.specs.registry import IORegistryError -from anndata.compat import _clean_uns from anndata._io.utils import ( report_read_key_on_error, ) +from anndata.compat import _clean_uns from anndata.experimental import read_elem, write_elem from anndata.tests.helpers import pytest_8_raises diff --git a/anndata/tests/test_io_warnings.py b/anndata/tests/test_io_warnings.py index 284d86ecc..dfc33ccf1 100644 --- a/anndata/tests/test_io_warnings.py +++ b/anndata/tests/test_io_warnings.py @@ -1,6 +1,8 @@ +from __future__ import annotations + +import warnings from importlib.util import find_spec from pathlib import Path -import warnings import pytest diff --git a/anndata/tests/test_layers.py b/anndata/tests/test_layers.py index 4f9f00973..4b6a7f287 100644 --- a/anndata/tests/test_layers.py +++ b/anndata/tests/test_layers.py @@ -1,11 +1,13 @@ -from importlib.util import find_spec +from __future__ import annotations + import warnings +from importlib.util import find_spec -import pytest import numpy as np import pandas as pd +import pytest -from anndata import AnnData, read_loom, read_h5ad +from anndata import AnnData, read_h5ad, read_loom from anndata.tests.helpers import gen_typed_df_t2_size X = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) diff --git a/anndata/tests/test_obsmvarm.py b/anndata/tests/test_obsmvarm.py index 1c08e7545..e1e802a9d 100644 --- a/anndata/tests/test_obsmvarm.py +++ b/anndata/tests/test_obsmvarm.py @@ -1,3 +1,5 @@ +from __future__ import annotations + import joblib import numpy as np import pandas as pd diff --git a/anndata/tests/test_obspvarp.py b/anndata/tests/test_obspvarp.py index 8ff025d76..5b3e063d3 100644 --- a/anndata/tests/test_obspvarp.py +++ b/anndata/tests/test_obspvarp.py @@ -1,4 +1,6 @@ # TODO: These tests should share code with test_layers, and test_obsmvarm +from __future__ import annotations + import warnings import joblib diff --git a/anndata/tests/test_raw.py b/anndata/tests/test_raw.py index 5686a4edc..7e4689d60 100644 --- a/anndata/tests/test_raw.py +++ b/anndata/tests/test_raw.py @@ -1,10 +1,11 @@ +from __future__ import annotations + import numpy as np import pytest import anndata as ad from anndata._core.anndata import ImplicitModificationWarning -from anndata.tests.helpers import assert_equal, gen_adata, GEN_ADATA_DASK_ARGS - +from anndata.tests.helpers import GEN_ADATA_DASK_ARGS, assert_equal, gen_adata # ------------------------------------------------------------------------------- # Some test data diff --git a/anndata/tests/test_readwrite.py b/anndata/tests/test_readwrite.py index c78d3833a..a9019f7fc 100644 --- a/anndata/tests/test_readwrite.py +++ b/anndata/tests/test_readwrite.py @@ -1,29 +1,33 @@ +from __future__ import annotations + +import re +import warnings from contextlib import contextmanager from importlib.util import find_spec -from os import PathLike from pathlib import Path -import re from string import ascii_letters -import warnings +from typing import TYPE_CHECKING import h5py import numpy as np import pandas as pd import pytest -from scipy.sparse import csr_matrix, csc_matrix import zarr +from scipy.sparse import csc_matrix, csr_matrix import anndata as ad from anndata._io.specs.registry import IORegistryError -from anndata.compat import _read_attr, DaskArray - +from anndata.compat import DaskArray, _read_attr from anndata.tests.helpers import ( - gen_adata, - assert_equal, as_dense_dask_array, + assert_equal, + gen_adata, pytest_8_raises, ) +if TYPE_CHECKING: + from os import PathLike + HERE = Path(__file__).parent @@ -489,7 +493,7 @@ def md5_path(pth: PathLike) -> bytes: checksum.update(buf) return checksum.digest() - def hash_dir_contents(dir: Path) -> "dict[str, bytes]": + def hash_dir_contents(dir: Path) -> dict[str, bytes]: root_pth = str(dir) return { str(k)[len(root_pth) :]: md5_path(k) for k in dir.rglob("*") if k.is_file() @@ -652,7 +656,7 @@ def test_write_string_types(tmp_path, diskfmt): with pytest_8_raises(TypeError, match=r"writing key 'obs'") as exc_info: write(adata_pth) - assert str("b'c'") in str(exc_info.value) + assert "b'c'" in str(exc_info.value) @pytest.mark.parametrize( diff --git a/anndata/tests/test_repr.py b/anndata/tests/test_repr.py index 862b9cd65..18fffb74f 100644 --- a/anndata/tests/test_repr.py +++ b/anndata/tests/test_repr.py @@ -1,3 +1,5 @@ +from __future__ import annotations + import re from string import ascii_letters diff --git a/anndata/tests/test_structured_arrays.py b/anndata/tests/test_structured_arrays.py index 580a72554..81b6be22f 100644 --- a/anndata/tests/test_structured_arrays.py +++ b/anndata/tests/test_structured_arrays.py @@ -1,12 +1,13 @@ -from itertools import product, combinations +from __future__ import annotations + +from itertools import combinations, product import numpy as np import pytest -from anndata.tests.helpers import gen_vstr_recarray - -from anndata import AnnData import anndata as ad +from anndata import AnnData +from anndata.tests.helpers import gen_vstr_recarray @pytest.fixture(params=["h5ad", "zarr"]) diff --git a/anndata/tests/test_transpose.py b/anndata/tests/test_transpose.py index a7c010b3e..64a8b0d42 100644 --- a/anndata/tests/test_transpose.py +++ b/anndata/tests/test_transpose.py @@ -1,8 +1,9 @@ -from scipy import sparse +from __future__ import annotations import pytest +from scipy import sparse -from anndata.tests.helpers import gen_adata, assert_equal +from anndata.tests.helpers import assert_equal, gen_adata def test_transpose_orig(): @@ -59,7 +60,7 @@ def test_transposed_contents(adata): assert adata.X is t.X is None assert_equal( - {k: v.T for k, v in adata.layers.items()}, {k: v for k, v in t.layers.items()} + {k: v.T for k, v in adata.layers.items()}, dict(t.layers.items()) ) assert_equal(adata.obs, t.var) assert_equal(adata.var, t.obs) diff --git a/anndata/tests/test_uns.py b/anndata/tests/test_uns.py index 013c0dea5..ef0f4f8fe 100644 --- a/anndata/tests/test_uns.py +++ b/anndata/tests/test_uns.py @@ -1,6 +1,7 @@ +from __future__ import annotations + import numpy as np import pandas as pd - import pytest from anndata import AnnData diff --git a/anndata/tests/test_utils.py b/anndata/tests/test_utils.py index 7d766f304..f57fc5d6e 100644 --- a/anndata/tests/test_utils.py +++ b/anndata/tests/test_utils.py @@ -1,11 +1,14 @@ -import pandas as pd -from scipy import sparse +from __future__ import annotations + from itertools import repeat + +import pandas as pd import pytest +from scipy import sparse import anndata as ad -from anndata.utils import make_index_unique from anndata.tests.helpers import gen_typed_df +from anndata.utils import make_index_unique def test_make_index_unique(): diff --git a/anndata/tests/test_views.py b/anndata/tests/test_views.py index 7945d17ad..efeb2a573 100644 --- a/anndata/tests/test_views.py +++ b/anndata/tests/test_views.py @@ -1,30 +1,31 @@ +from __future__ import annotations + from copy import deepcopy from operator import mul import joblib import numpy as np -from scipy import sparse import pandas as pd import pytest +from dask.base import normalize_token, tokenize +from scipy import sparse import anndata as ad from anndata._core.index import _normalize_index -from anndata._core.views import ArrayView, SparseCSRView, SparseCSCView +from anndata._core.views import ArrayView, SparseCSCView, SparseCSRView from anndata.compat import CupyCSCMatrix -from anndata.utils import asarray from anndata.tests.helpers import ( - gen_adata, - subset_func, - slice_subset, - single_subset, - assert_equal, - GEN_ADATA_DASK_ARGS, BASE_MATRIX_PARAMS, - DASK_MATRIX_PARAMS, CUPY_MATRIX_PARAMS, + DASK_MATRIX_PARAMS, + GEN_ADATA_DASK_ARGS, + assert_equal, + gen_adata, + single_subset, + slice_subset, + subset_func, ) -from dask.base import tokenize, normalize_token - +from anndata.utils import asarray # ------------------------------------------------------------------------------ # Some test data @@ -336,11 +337,11 @@ def test_set_scalar_subset_X(matrix_type, subset_func): if isinstance(adata.X, CupyCSCMatrix): # Comparison broken for CSC matrices # https://github.com/cupy/cupy/issues/7757 - assert asarray((orig_X_val.tocsr() != adata.X.tocsr())).sum() == mul( + assert asarray(orig_X_val.tocsr() != adata.X.tocsr()).sum() == mul( *adata_subset.shape ) else: - assert asarray((orig_X_val != adata.X)).sum() == mul(*adata_subset.shape) + assert asarray(orig_X_val != adata.X).sum() == mul(*adata_subset.shape) # TODO: Use different kind of subsetting for adata and view diff --git a/anndata/tests/test_x.py b/anndata/tests/test_x.py index 9ec8800e6..5f381c8c1 100644 --- a/anndata/tests/test_x.py +++ b/anndata/tests/test_x.py @@ -1,16 +1,16 @@ """Tests for the attribute .X""" +from __future__ import annotations + import numpy as np import pandas as pd +import pytest from scipy import sparse import anndata as ad from anndata import AnnData +from anndata.tests.helpers import assert_equal, gen_adata from anndata.utils import asarray -import pytest - -from anndata.tests.helpers import gen_adata, assert_equal - UNLABELLED_ARRAY_TYPES = [ pytest.param(sparse.csr_matrix, id="csr"), pytest.param(sparse.csc_matrix, id="csc"), diff --git a/anndata/utils.py b/anndata/utils.py index 09a6b7370..2198e9b29 100644 --- a/anndata/utils.py +++ b/anndata/utils.py @@ -1,15 +1,20 @@ +from __future__ import annotations + import warnings -from functools import wraps, singledispatch -from typing import Mapping, Any, Sequence, Union +from functools import singledispatch, wraps +from typing import TYPE_CHECKING, Any import h5py -import pandas as pd import numpy as np +import pandas as pd from scipy import sparse -from .logging import get_logger from ._core.sparse_dataset import SparseDataset from .compat import CupyArray, CupySparseMatrix +from .logging import get_logger + +if TYPE_CHECKING: + from collections.abc import Mapping, Sequence logger = get_logger(__name__) @@ -253,7 +258,7 @@ def warn_names_duplicates(attr: str): def ensure_df_homogeneous( df: pd.DataFrame, name: str -) -> Union[np.ndarray, sparse.csr_matrix]: +) -> np.ndarray | sparse.csr_matrix: # TODO: rename this function, I would not expect this to return a non-dataframe if all(isinstance(dt, pd.SparseDtype) for dt in df.dtypes): arr = df.sparse.to_coo().tocsr() diff --git a/benchmarks/benchmarks/readwrite.py b/benchmarks/benchmarks/readwrite.py index 8d9b88e81..c273a436b 100644 --- a/benchmarks/benchmarks/readwrite.py +++ b/benchmarks/benchmarks/readwrite.py @@ -19,20 +19,20 @@ * io for backed objects * Reading dense as sparse, writing sparse as dense """ +from __future__ import annotations + +import sys import tempfile from pathlib import Path -import sys -from memory_profiler import memory_usage import numpy as np import pooch - -from .utils import sedate, get_peak_mem, get_actualsize +from memory_profiler import memory_usage # from . import datasets - import anndata +from .utils import get_actualsize, get_peak_mem, sedate PBMC_3K_URL = "http://falexwolf.de/data/pbmc3k_raw.h5ad" diff --git a/benchmarks/benchmarks/utils.py b/benchmarks/benchmarks/utils.py index 75fd4505e..c44e7780a 100644 --- a/benchmarks/benchmarks/utils.py +++ b/benchmarks/benchmarks/utils.py @@ -1,12 +1,14 @@ +from __future__ import annotations + +import gc +import sys from string import ascii_lowercase from time import sleep -from memory_profiler import memory_usage import numpy as np import pandas as pd +from memory_profiler import memory_usage from scipy import sparse -import sys -import gc from anndata import AnnData @@ -95,14 +97,14 @@ def gen_indexer(adata, dim, index_kind, ratio): def take_view(adata, *, dim, index_kind, ratio=0.5, nviews=100): subset = gen_indexer(adata, dim, index_kind, ratio) views = [] - for i in range(nviews): + for _i in range(nviews): views.append(adata[subset]) def take_repeated_view(adata, *, dim, index_kind, ratio=0.9, nviews=10): v = adata views = [] - for i in range(nviews): + for _i in range(nviews): subset = gen_indexer(v, dim, index_kind, ratio) v = v[subset] views.append(v) @@ -121,10 +123,10 @@ def gen_adata(n_obs, n_var, attr_set): if "obs,var" in attr_set: adata.obs = pd.DataFrame( {k: np.random.randint(0, 100, n_obs) for k in ascii_lowercase}, - index=["cell{}".format(i) for i in range(n_obs)], + index=[f"cell{i}" for i in range(n_obs)], ) adata.var = pd.DataFrame( {k: np.random.randint(0, 100, n_var) for k in ascii_lowercase}, - index=["gene{}".format(i) for i in range(n_var)], + index=[f"gene{i}" for i in range(n_var)], ) return adata diff --git a/conftest.py b/conftest.py index fe4dace31..a98969b53 100644 --- a/conftest.py +++ b/conftest.py @@ -2,13 +2,16 @@ # 1. to allow ignoring warnings without test collection failing on CI # 2. as a pytest plugin/config that applies to doctests as well # TODO: Fix that, e.g. with the `pytest -p anndata.testing._pytest` pattern. +from __future__ import annotations -from pathlib import Path +from typing import TYPE_CHECKING import pytest from anndata.compat import chdir +if TYPE_CHECKING: + from pathlib import Path doctest_marker = pytest.mark.usefixtures("doctest_env") @@ -27,7 +30,7 @@ def pytest_itemcollected(item): """Define behavior of pytest.mark.gpu and doctests.""" from importlib.util import find_spec - is_gpu = len([mark for mark in item.iter_markers(name="gpu")]) > 0 + is_gpu = len(list(item.iter_markers(name="gpu"))) > 0 if is_gpu: item.add_marker( pytest.mark.skipif(not find_spec("cupy"), reason="Cupy not installed.") diff --git a/docs/conf.py b/docs/conf.py index 0e2c3f96a..a25b0f6cf 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -1,9 +1,13 @@ +from __future__ import annotations + import sys -from pathlib import Path from datetime import datetime from importlib import metadata +from pathlib import Path +from typing import TYPE_CHECKING -from sphinx.application import Sphinx +if TYPE_CHECKING: + from sphinx.application import Sphinx HERE = Path(__file__).parent sys.path[:0] = [str(HERE / "extensions")]