anndata 0.12.0rc1__py3-none-any.whl → 0.12.0rc3__py3-none-any.whl

anndata/__init__.py

@@ -23,10 +23,10 @@ from .io import read_h5ad, read_zarr
 from .utils import module_get_attr_redirect
 
 # Submodules need to be imported last
-from . import abc, experimental, typing, io, types  # noqa: E402 isort: skip
+from . import abc, experimental, typing, io, types  # isort: skip
 
 # We use these in tests by attribute access
-from . import logging  # noqa: F401, E402 isort: skip
+from . import logging  # noqa: F401  # isort: skip
 
 _DEPRECATED_IO = (
     "read_loom",
@@ -37,7 +37,7 @@ _DEPRECATED_IO = (
     "read_text",
     "read_mtx",
 )
-_DEPRECATED = dict((method, f"io.{method}") for method in _DEPRECATED_IO)
+_DEPRECATED = {method: f"io.{method}" for method in _DEPRECATED_IO}
 
 
 def __getattr__(attr_name: str) -> Any:
@@ -45,26 +45,21 @@ def __getattr__(attr_name: str) -> Any:
 
 
 __all__ = [
-    # Attributes
+    "AnnData",
+    "ExperimentalFeatureWarning",
+    "ImplicitModificationWarning",
+    "OldFormatWarning",
+    "Raw",
+    "WriteWarning",
     "__version__",
-    "settings",
-    # Submodules
     "abc",
+    "concat",
     "experimental",
-    "typing",
-    "types",
     "io",
-    # Classes
-    "AnnData",
-    "Raw",
-    # Functions
-    "concat",
-    "read_zarr",
     "read_h5ad",
+    "read_zarr",
     "register_anndata_namespace",
-    # Warnings
-    "OldFormatWarning",
-    "WriteWarning",
-    "ImplicitModificationWarning",
-    "ExperimentalFeatureWarning",
+    "settings",
+    "types",
+    "typing",
 ]

anndata/_core/access.py

@@ -13,7 +13,7 @@ class ElementRef(NamedTuple):
     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!r}]" for x in self.keys)
 
     @property
     def _parent_el(self):

anndata/_core/aligned_df.py

@@ -9,6 +9,8 @@ import pandas as pd
 from pandas.api.types import is_string_dtype
 
 from .._warnings import ImplicitModificationWarning
+from ..compat import XDataset
+from .xarray import Dataset2D
 
 if TYPE_CHECKING:
     from collections.abc import Iterable
@@ -50,7 +52,7 @@ def _gen_dataframe_mapping(
         df = pd.DataFrame(
             anno,
             index=anno[index_name],
-            columns=[k for k in anno.keys() if k != index_name],
+            columns=[k for k in anno if k != index_name],
         )
         break
     else:
@@ -80,7 +82,8 @@ def _gen_dataframe_df(
         raise _mk_df_error(source, attr, length, len(anno))
     anno = anno.copy(deep=False)
     if not is_string_dtype(anno.index):
-        warnings.warn("Transforming to str index.", ImplicitModificationWarning)
+        msg = "Transforming to str index."
+        warnings.warn(msg, ImplicitModificationWarning, stacklevel=2)
         anno.index = anno.index.astype(str)
     if not len(anno.columns):
         anno.columns = anno.columns.astype(str)
@@ -107,8 +110,8 @@ def _mk_df_error(
     expected: int,
     actual: int,
 ):
+    what = "row" if attr == "obs" else "column"
     if source == "X":
-        what = "row" if attr == "obs" else "column"
         msg = (
             f"Observations annot. `{attr}` must have as many rows as `X` has {what}s "
             f"({expected}), but has {actual} rows."
@@ -116,6 +119,30 @@ def _mk_df_error(
     else:
         msg = (
             f"`shape` is inconsistent with `{attr}` "
-            "({actual} {what}s instead of {expected})"
+            f"({actual} {what}s instead of {expected})"
         )
     return ValueError(msg)
+
+
+@_gen_dataframe.register(Dataset2D)
+def _gen_dataframe_xr(
+    anno: Dataset2D,
+    index_names: Iterable[str],
+    *,
+    source: Literal["X", "shape"],
+    attr: Literal["obs", "var"],
+    length: int | None = None,
+):
+    return anno
+
+
+@_gen_dataframe.register(XDataset)
+def _gen_dataframe_xdataset(
+    anno: XDataset,
+    index_names: Iterable[str],
+    *,
+    source: Literal["X", "shape"],
+    attr: Literal["obs", "var"],
+    length: int | None = None,
+):
+    return Dataset2D(anno)

anndata/_core/aligned_mapping.py

@@ -11,7 +11,7 @@ import numpy as np
 import pandas as pd
 
 from .._warnings import ExperimentalFeatureWarning, ImplicitModificationWarning
-from ..compat import AwkArray, CSArray, CSMatrix
+from ..compat import AwkArray, CSArray, CSMatrix, CupyArray, XDataset
 from ..utils import (
     axis_len,
     convert_to_dict,
@@ -23,6 +23,7 @@ from .access import ElementRef
 from .index import _subset
 from .storage import coerce_array
 from .views import as_view, view_update
+from .xarray import Dataset2D
 
 if TYPE_CHECKING:
     from collections.abc import Callable, Iterable, Iterator, Mapping
@@ -75,6 +76,10 @@ class AlignedMappingBase(MutableMapping[str, Value], ABC):
                 ExperimentalFeatureWarning,
                 # stacklevel=3,
             )
+        elif isinstance(val, np.ndarray | CupyArray) and len(val.shape) == 1:
+            val = val.reshape((val.shape[0], 1))
+        elif isinstance(val, XDataset):
+            val = Dataset2D(data_vars=val.data_vars, coords=val.coords, attrs=val.attrs)
         for i, axis in enumerate(self.axes):
             if self.parent.shape[axis] == axis_len(val, i):
                 continue
@@ -94,7 +99,6 @@ class AlignedMappingBase(MutableMapping[str, Value], ABC):
                     f"Value had shape {actual_shape} while it should have had {right_shape}."
                 )
             raise ValueError(msg)
-
         name = f"{self.attrname.title().rstrip('s')} {key!r}"
         return coerce_array(val, name=name, allow_df=self._allow_df)
 
@@ -274,6 +278,9 @@ class AxisArraysBase(AlignedMappingBase):
                 else:
                     msg = "Index.equals and pd.testing.assert_index_equal disagree"
                     raise AssertionError(msg)
+            val.index.name = (
+                self.dim_names.name
+            )  # this is consistent with AnnData.obsm.setter and AnnData.varm.setter
         return super()._validate_value(val, key)
 
     @property

anndata/_core/anndata.py

@@ -8,7 +8,7 @@ import warnings
 from collections import OrderedDict
 from collections.abc import Mapping, MutableMapping, Sequence
 from copy import copy, deepcopy
-from functools import partial, singledispatch
+from functools import partial, singledispatchmethod
 from pathlib import Path
 from textwrap import dedent
 from typing import TYPE_CHECKING, cast
@@ -47,6 +47,7 @@ from .views import (
     _resolve_idxs,
     as_view,
 )
+from .xarray import Dataset2D
 
 if TYPE_CHECKING:
     from collections.abc import Iterable
@@ -55,7 +56,7 @@ if TYPE_CHECKING:
 
     from zarr.storage import StoreLike
 
-    from ..compat import Index1D
+    from ..compat import Index1D, XDataset
     from ..typing import XDataType
     from .aligned_mapping import AxisArraysView, LayersView, PairwiseArraysView
     from .index import Index
@@ -176,10 +177,10 @@ class AnnData(metaclass=utils.DeprecationMixinMeta):
     .. _scikit-learn: http://scikit-learn.org/
     """
 
-    _BACKED_ATTRS = ["X", "raw.X"]
+    _BACKED_ATTRS: ClassVar[list[str]] = ["X", "raw.X"]
 
     # backwards compat
-    _H5_ALIASES = dict(
+    _H5_ALIASES: ClassVar[dict[str, set[str]]] = dict(
         X={"X", "_X", "data", "_data"},
         obs={"obs", "_obs", "smp", "_smp"},
         var={"var", "_var"},
@@ -189,7 +190,7 @@ class AnnData(metaclass=utils.DeprecationMixinMeta):
         layers={"layers", "_layers"},
     )
 
-    _H5_ALIASES_NAMES = dict(
+    _H5_ALIASES_NAMES: ClassVar[dict[str, set[str]]] = dict(
         obs={"obs_names", "smp_names", "row_names", "index"},
         var={"var_names", "col_names", "index"},
     )
@@ -207,7 +208,7 @@ class AnnData(metaclass=utils.DeprecationMixinMeta):
         "filemode",
         "asview",
     )
-    def __init__(
+    def __init__(  # noqa: PLR0913
         self,
         X: XDataType | pd.DataFrame | None = None,
         obs: pd.DataFrame | Mapping[str, Iterable[Any]] | None = None,
@@ -310,9 +311,10 @@ class AnnData(metaclass=utils.DeprecationMixinMeta):
         else:
             self._raw = None
 
-    def _init_as_actual(
+    def _init_as_actual(  # noqa: PLR0912, PLR0913, PLR0915
         self,
         X=None,
+        *,
         obs=None,
         var=None,
         uns=None,
@@ -390,10 +392,10 @@ class AnnData(metaclass=utils.DeprecationMixinMeta):
             _check_2d_shape(X)
             # if type doesn’t match, a copy is made, otherwise, use a view
             if dtype is not None:
-                warnings.warn(
-                    "The dtype argument is deprecated and will be removed in late 2024.",
-                    FutureWarning,
+                msg = (
+                    "The dtype argument is deprecated and will be removed in late 2024."
                 )
+                warnings.warn(msg, FutureWarning, stacklevel=3)
                 if issparse(X) or isinstance(X, ma.MaskedArray):
                     # TODO: maybe use view on data attribute of sparse matrix
                     #       as in readwrite.read_10x_h5
@@ -412,7 +414,9 @@ class AnnData(metaclass=utils.DeprecationMixinMeta):
             n_obs, n_vars = (
                 shape
                 if shape is not None
-                else _infer_shape(obs, var, obsm, varm, layers, obsp, varp)
+                else _infer_shape(
+                    obs, var, obsm=obsm, varm=varm, layers=layers, obsp=obsp, varp=varp
+                )
             )
             source = "shape"
 
@@ -503,10 +507,7 @@ class AnnData(metaclass=utils.DeprecationMixinMeta):
         return sum(sizes.values())
 
     def _gen_repr(self, n_obs, n_vars) -> str:
-        if self.isbacked:
-            backed_at = f" backed at {str(self.filename)!r}"
-        else:
-            backed_at = ""
+        backed_at = f" backed at {str(self.filename)!r}" if self.isbacked else ""
         descr = f"AnnData object with n_obs × n_vars = {n_obs} × {n_vars}{backed_at}"
         for attr in [
             "obs",
@@ -574,7 +575,7 @@ class AnnData(metaclass=utils.DeprecationMixinMeta):
         #     return X
 
     @X.setter
-    def X(self, value: XDataType | None):
+    def X(self, value: XDataType | None):  # noqa: PLR0912
         if value is None:
             if self.isbacked:
                 msg = "Cannot currently remove data matrix from backed object."
@@ -627,34 +628,33 @@ class AnnData(metaclass=utils.DeprecationMixinMeta):
                     X[oidx, vidx] = value
                 else:
                     self._set_backed("X", value)
-            else:
-                if self.is_view:
-                    if sparse.issparse(self._adata_ref._X) and isinstance(
-                        value, np.ndarray
-                    ):
-                        if isinstance(self._adata_ref.X, CSArray):
-                            memory_class = sparse.coo_array
-                        else:
-                            memory_class = sparse.coo_matrix
-                        value = memory_class(value)
-                    elif sparse.issparse(value) and isinstance(
-                        self._adata_ref._X, np.ndarray
-                    ):
-                        warnings.warn(
-                            "Trying to set a dense array with a sparse array on a view."
-                            "Densifying the sparse array."
-                            "This may incur excessive memory usage",
-                            stacklevel=2,
-                        )
-                        value = value.toarray()
+            elif self.is_view:
+                if sparse.issparse(self._adata_ref._X) and isinstance(
+                    value, np.ndarray
+                ):
+                    if isinstance(self._adata_ref.X, CSArray):
+                        memory_class = sparse.coo_array
+                    else:
+                        memory_class = sparse.coo_matrix
+                    value = memory_class(value)
+                elif sparse.issparse(value) and isinstance(
+                    self._adata_ref._X, np.ndarray
+                ):
                     warnings.warn(
-                        "Modifying `X` on a view results in data being overridden",
-                        ImplicitModificationWarning,
+                        "Trying to set a dense array with a sparse array on a view."
+                        "Densifying the sparse array."
+                        "This may incur excessive memory usage",
                         stacklevel=2,
                     )
-                    self._adata_ref._X[oidx, vidx] = value
-                else:
-                    self._X = value
+                    value = value.toarray()
+                warnings.warn(
+                    "Modifying `X` on a view results in data being overridden",
+                    ImplicitModificationWarning,
+                    stacklevel=2,
+                )
+                self._adata_ref._X[oidx, vidx] = value
+            else:
+                self._X = value
         else:
             msg = f"Data matrix has wrong shape {value.shape}, need to be {self.shape}."
             raise ValueError(msg)
@@ -747,10 +747,14 @@ class AnnData(metaclass=utils.DeprecationMixinMeta):
         """Number of variables/features."""
         return len(self.var_names)
 
-    def _set_dim_df(self, value: pd.DataFrame, attr: Literal["obs", "var"]):
-        if not isinstance(value, pd.DataFrame):
-            msg = f"Can only assign pd.DataFrame to {attr}."
-            raise ValueError(msg)
+    def _set_dim_df(self, value: pd.DataFrame | XDataset, attr: Literal["obs", "var"]):
+        value = _gen_dataframe(
+            value,
+            [f"{attr}_names", f"{'row' if attr == 'obs' else 'col'}_names"],
+            source="shape",
+            attr=attr,
+            length=self.n_obs if attr == "obs" else self.n_vars,
+        )
         raise_value_error_if_multiindex_columns(value, attr)
         value_idx = self._prep_dim_index(value.index, attr)
         if self.is_view:
@@ -805,12 +809,12 @@ class AnnData(metaclass=utils.DeprecationMixinMeta):
                 v.index = value
 
     @property
-    def obs(self) -> pd.DataFrame:
+    def obs(self) -> pd.DataFrame | Dataset2D:
         """One-dimensional annotation of observations (`pd.DataFrame`)."""
         return self._obs
 
     @obs.setter
-    def obs(self, value: pd.DataFrame):
+    def obs(self, value: pd.DataFrame | XDataset):
         self._set_dim_df(value, "obs")
 
     @obs.deleter
@@ -828,12 +832,12 @@ class AnnData(metaclass=utils.DeprecationMixinMeta):
         self._set_dim_index(names, "obs")
 
     @property
-    def var(self) -> pd.DataFrame:
+    def var(self) -> pd.DataFrame | Dataset2D:
         """One-dimensional annotation of variables/ features (`pd.DataFrame`)."""
         return self._var
 
     @var.setter
-    def var(self, value: pd.DataFrame):
+    def var(self, value: pd.DataFrame | XDataset):
         self._set_dim_df(value, "var")
 
     @var.deleter
@@ -939,7 +943,7 @@ class AnnData(metaclass=utils.DeprecationMixinMeta):
 
     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:
@@ -988,10 +992,7 @@ class AnnData(metaclass=utils.DeprecationMixinMeta):
             else:
                 # change from memory to backing-mode
                 # write the content of self to disk
-                if self.raw is not None:
-                    as_dense = ("X", "raw/X")
-                else:
-                    as_dense = ("X",)
+                as_dense = ("X", "raw/X") if self.raw is not None else ("X",)
                 self.write(filename, as_dense=as_dense)
             # open new file for accessing
             self.file.open(filename, "r+")
@@ -1026,8 +1027,8 @@ class AnnData(metaclass=utils.DeprecationMixinMeta):
         oidx, vidx = self._normalize_indices(index)
         return AnnData(self, oidx=oidx, vidx=vidx, asview=True)
 
+    @singledispatchmethod
     @staticmethod
-    @singledispatch
     def _remove_unused_categories(
         df_full: pd.DataFrame, df_sub: pd.DataFrame, uns: dict[str, Any]
     ):
@@ -1129,6 +1130,8 @@ class AnnData(metaclass=utils.DeprecationMixinMeta):
                 dont_modify = True
         else:
             dfs = [df]
+        del df
+
         for df in dfs:
             string_cols = [
                 key for key in df.columns if infer_dtype(df[key]) == "string"
@@ -1202,10 +1205,7 @@ class AnnData(metaclass=utils.DeprecationMixinMeta):
         """
         from anndata.compat import _safe_transpose
 
-        if not self.isbacked:
-            X = self.X
-        else:
-            X = self.file["X"]
+        X = self.X if not self.isbacked else self.file["X"]
         if self.is_view:
             msg = (
                 "You’re trying to transpose a view of an `AnnData`, "
@@ -1305,11 +1305,11 @@ class AnnData(metaclass=utils.DeprecationMixinMeta):
             if "X" in self.layers:
                 pass
             else:
-                warnings.warn(
+                msg = (
                     "In a future version of AnnData, access to `.X` by passing"
-                    " `layer='X'` will be removed. Instead pass `layer=None`.",
-                    FutureWarning,
+                    " `layer='X'` will be removed. Instead pass `layer=None`."
                 )
+                warnings.warn(msg, FutureWarning, stacklevel=2)
                 layer = None
         return get_vector(self, k, "obs", "var", layer=layer)
 
@@ -1337,11 +1337,11 @@ class AnnData(metaclass=utils.DeprecationMixinMeta):
             if "X" in self.layers:
                 pass
             else:
-                warnings.warn(
+                msg = (
                     "In a future version of AnnData, access to `.X` by passing "
-                    "`layer='X'` will be removed. Instead pass `layer=None`.",
-                    FutureWarning,
+                    "`layer='X'` will be removed. Instead pass `layer=None`."
                 )
+                warnings.warn(msg, FutureWarning, stacklevel=2)
                 layer = None
         return get_vector(self, k, "var", "obs", layer=layer)
 
@@ -1369,13 +1369,14 @@ class AnnData(metaclass=utils.DeprecationMixinMeta):
 
     def _mutated_copy(self, **kwargs):
         """Creating AnnData with attributes optionally specified via kwargs."""
-        if self.isbacked:
-            if "X" not in kwargs or (self.raw is not None and "raw" not in kwargs):
-                msg = (
-                    "This function does not currently handle backed objects "
-                    "internally, this should be dealt with before."
-                )
-                raise NotImplementedError(msg)
+        if self.isbacked and (
+            "X" not in kwargs or (self.raw is not None and "raw" not in kwargs)
+        ):
+            msg = (
+                "This function does not currently handle backed objects "
+                "internally, this should be dealt with before."
+            )
+            raise NotImplementedError(msg)
         new = {}
 
         for key in ["obs", "var", "obsm", "varm", "obsp", "varp", "layers"]:
@@ -1481,7 +1482,7 @@ class AnnData(metaclass=utils.DeprecationMixinMeta):
         *adatas: AnnData,
         join: str = "inner",
         batch_key: str = "batch",
-        batch_categories: Sequence[Any] = None,
+        batch_categories: Sequence[Any] | None = None,
         uns_merge: str | None = None,
         index_unique: str | None = "-",
         fill_value=None,
@@ -1707,7 +1708,7 @@ class AnnData(metaclass=utils.DeprecationMixinMeta):
             return self.copy()
         elif len(adatas) == 1 and not isinstance(adatas[0], AnnData):
             adatas = adatas[0]  # backwards compatibility
-        all_adatas = (self,) + tuple(adatas)
+        all_adatas = (self, *adatas)
 
         out = concat(
             all_adatas,
@@ -1779,30 +1780,25 @@ class AnnData(metaclass=utils.DeprecationMixinMeta):
         raise AttributeError(msg)
 
     def _check_dimensions(self, key=None):
-        if key is None:
-            key = {"obsm", "varm"}
-        else:
-            key = {key}
-        if "obsm" in key:
-            if (
-                not all([axis_len(o, 0) == self.n_obs for o in self.obsm.values()])
-                and len(self.obsm.dim_names) != self.n_obs
-            ):
-                msg = (
-                    "Observations annot. `obsm` must have number of rows of `X`"
-                    f" ({self.n_obs}), but has {len(self.obsm)} rows."
-                )
-                raise ValueError(msg)
-        if "varm" in key:
-            if (
-                not all([axis_len(v, 0) == self.n_vars for v in self.varm.values()])
-                and len(self.varm.dim_names) != self.n_vars
-            ):
-                msg = (
-                    "Variables annot. `varm` must have number of columns of `X`"
-                    f" ({self.n_vars}), but has {len(self.varm)} rows."
-                )
-                raise ValueError(msg)
+        key = {"obsm", "varm"} if key is None else {key}
+        if "obsm" in key and (
+            not all(axis_len(o, 0) == self.n_obs for o in self.obsm.values())
+            and len(self.obsm.dim_names) != self.n_obs
+        ):
+            msg = (
+                "Observations annot. `obsm` must have number of rows of `X`"
+                f" ({self.n_obs}), but has {len(self.obsm)} rows."
+            )
+            raise ValueError(msg)
+        if "varm" in key and (
+            not all(axis_len(v, 0) == self.n_vars for v in self.varm.values())
+            and len(self.varm.dim_names) != self.n_vars
+        ):
+            msg = (
+                "Variables annot. `varm` must have number of columns of `X`"
+                f" ({self.n_vars}), but has {len(self.varm)} rows."
+            )
+            raise ValueError(msg)
 
     @old_positionals("compression", "compression_opts", "as_dense")
     def write_h5ad(
@@ -2082,15 +2078,20 @@ class AnnData(metaclass=utils.DeprecationMixinMeta):
                 m_attr[key] = self._get_and_delete_multicol_field(axis, key)
 
     def _get_and_delete_multicol_field(self, a, key_multicol):
-        keys = []
-        for k in getattr(self, a).columns:
-            if k.startswith(key_multicol):
-                keys.append(k)
+        keys = [k for k in getattr(self, a).columns if k.startswith(key_multicol)]
         values = getattr(self, a)[keys].values
         getattr(self, a).drop(keys, axis=1, inplace=True)
         return values
 
 
+@AnnData._remove_unused_categories.register(Dataset2D)
+@staticmethod
+def _remove_unused_categories_xr(
+    df_full: Dataset2D, df_sub: Dataset2D, uns: dict[str, Any]
+):
+    pass  # this is handled automatically by the categorical arrays themselves i.e., they dedup upon access.
+
+
 def _check_2d_shape(X):
     """\
     Check shape of array or sparse matrix.
@@ -2112,7 +2113,7 @@ def _infer_shape_for_axis(
     for elem in [xxx, xxxm, xxxp]:
         if elem is not None and hasattr(elem, "shape"):
             return elem.shape[0]
-    for elem, id in zip([layers, xxxm, xxxp], ["layers", "xxxm", "xxxp"]):
+    for elem, id in zip([layers, xxxm, xxxp], ["layers", "xxxm", "xxxp"], strict=True):
         if elem is not None:
             elem = cast("Mapping", elem)
             for sub_elem in elem.values():
@@ -2125,6 +2126,7 @@ def _infer_shape_for_axis(
 def _infer_shape(
     obs: pd.DataFrame | Mapping[str, Iterable[Any]] | None = None,
     var: pd.DataFrame | Mapping[str, Iterable[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,

anndata/_core/file_backing.py

@@ -10,6 +10,7 @@ import h5py
 
 from ..compat import AwkArray, DaskArray, ZarrArray, ZarrGroup
 from .sparse_dataset import BaseCompressedSparseDataset
+from .xarray import Dataset2D
 
 if TYPE_CHECKING:
     from collections.abc import Iterator
@@ -162,6 +163,11 @@ def _(x: AwkArray, *, copy: bool = False):
         return x
 
 
+@to_memory.register(Dataset2D)
+def _(x: Dataset2D, *, copy: bool = False):
+    return x.to_memory(copy=copy)
+
+
 @singledispatch
 def filename(x):
     msg = f"Not implemented for {type(x)}"