lamindb 1.2a2__py3-none-any.whl → 1.3.1__py3-none-any.whl

lamindb/curators/__init__.py

@@ -1,25 +1,27 @@
 """Curators.
 
-.. versionadded:: 1.1.0
-
 .. autosummary::
    :toctree: .
 
-   Curator
    DataFrameCurator
    AnnDataCurator
+   MuDataCurator
+   SpatialDataCurator
 
-CatManager:
+Helper classes.
 
 .. autosummary::
    :toctree: .
 
+   Curator
+   SlotsCurator
    CatManager
+   CatLookup
    DataFrameCatManager
    AnnDataCatManager
    MuDataCatManager
+   SpatialDataCatManager
    TiledbsomaCatManager
-   CurateLookup
 
 """
 
@@ -27,9 +29,8 @@ from __future__ import annotations
 
 import copy
 import re
-from importlib import resources
 from itertools import chain
-from typing import TYPE_CHECKING, Any, Literal
+from typing import TYPE_CHECKING, Any, Callable, Literal
 
 import anndata as ad
 import lamindb_setup as ln_setup
@@ -37,45 +38,44 @@ import pandas as pd
 import pandera
 import pyarrow as pa
 from lamin_utils import colors, logger
-from lamindb_setup.core import deprecated, upath
+from lamindb_setup.core import deprecated
 from lamindb_setup.core._docs import doc_args
 from lamindb_setup.core.upath import UPath
 
-from lamindb.core.storage._backed_access import backed_access
-
-from ._cellxgene_schemas import _read_schema_versions
-
 if TYPE_CHECKING:
-    from anndata import AnnData
     from lamindb_setup.core.types import UPathStr
+    from mudata import MuData
+    from spatialdata import SpatialData
 
-    from lamindb.base.types import FieldAttr
+    from lamindb.core.types import ScverseDataStructures
     from lamindb.models import Record
 from lamindb.base.types import FieldAttr  # noqa
 from lamindb.core._settings import settings
 from lamindb.models import (
     Artifact,
-    Collection,
     Feature,
     Record,
     Run,
     Schema,
     ULabel,
 )
-from lamindb.models._feature_manager import parse_staged_feature_sets_from_anndata
-from lamindb.models.artifact import add_labels, data_is_anndata
-from lamindb.models.feature import parse_dtype, parse_dtype_single_cat
+from lamindb.models.artifact import (
+    add_labels,
+    data_is_anndata,
+    data_is_mudata,
+    data_is_spatialdata,
+)
+from lamindb.models.feature import parse_dtype, parse_cat_dtype
 from lamindb.models._from_values import _format_values
 
 from ..errors import InvalidArgument, ValidationError
+from anndata import AnnData
 
 if TYPE_CHECKING:
     from collections.abc import Iterable, MutableMapping
     from typing import Any
 
     from lamindb_setup.core.types import UPathStr
-    from mudata import MuData
-    from spatialdata import SpatialData
 
     from lamindb.models.query_set import RecordList
 
@@ -86,7 +86,7 @@ def strip_ansi_codes(text):
     return ansi_pattern.sub("", text)
 
 
-class CurateLookup:
+class CatLookup:
     """Lookup categories from the reference instance.
 
     Args:
@@ -94,10 +94,10 @@ class CurateLookup:
         slots: A dictionary of slot fields to lookup.
         public: Whether to lookup from the public instance. Defaults to False.
 
-    Example:
-        >>> curator = ln.Curator.from_df(...)
-        >>> curator.lookup()["cell_type"].alveolar_type_1_fibroblast_cell
-        <Category: alveolar_type_1_fibroblast_cell>
+    Example::
+
+        curator = ln.curators.DataFrameCurator(...)
+        curator.cat.lookup()["cell_type"].alveolar_type_1_fibroblast_cell
 
     """
 
@@ -106,16 +106,22 @@ class CurateLookup:
         categoricals: dict[str, FieldAttr],
         slots: dict[str, FieldAttr] = None,
         public: bool = False,
+        organism: str | None = None,
+        sources: dict[str, Record] | None = None,
     ) -> None:
         slots = slots or {}
         self._categoricals = {**categoricals, **slots}
         self._public = public
+        self._organism = organism
+        self._sources = sources
 
     def __getattr__(self, name):
         if name in self._categoricals:
             registry = self._categoricals[name].field.model
             if self._public and hasattr(registry, "public"):
-                return registry.public().lookup()
+                return registry.public(
+                    organism=self._organism, source=self._sources.get(name)
+                ).lookup()
             else:
                 return registry.lookup()
         raise AttributeError(
@@ -126,7 +132,9 @@ class CurateLookup:
         if name in self._categoricals:
             registry = self._categoricals[name].field.model
             if self._public and hasattr(registry, "public"):
-                return registry.public().lookup()
+                return registry.public(
+                    organism=self._organism, source=self._sources.get(name)
+                ).lookup()
             else:
                 return registry.lookup()
         raise AttributeError(
@@ -150,7 +158,7 @@ class CurateLookup:
                 "    → categories.alveolar_type_1_fibroblast_cell\n\n"
                 "To look up public ontologies, use .lookup(public=True)"
             )
-        else:  # pdagma: no cover
+        else:  # pragma: no cover
             return colors.warning("No fields are found!")
 
 
@@ -163,7 +171,7 @@ SLOTS_DOCSTRING = """Curator objects by slot.
 """
 
 
-VALIDATE_DOCSTRING = """Validate dataset.
+VALIDATE_DOCSTRING = """Validate dataset against Schema.
 
 Raises:
     lamindb.errors.ValidationError: If validation fails.
@@ -183,15 +191,17 @@ Returns:
 
 
 class Curator:
-    """Dataset curator.
+    """Curator base class.
 
     A `Curator` object makes it easy to validate, standardize & annotate datasets.
 
-    .. versionadded:: 1.1.0
-
     See:
         - :class:`~lamindb.curators.DataFrameCurator`
         - :class:`~lamindb.curators.AnnDataCurator`
+        - :class:`~lamindb.curators.MuDataCurator`
+        - :class:`~lamindb.curators.SpatialDataCurator`
+
+    .. versionadded:: 1.1.0
     """
 
     def __init__(self, dataset: Any, schema: Schema | None = None):
@@ -199,7 +209,12 @@ class Curator:
         self._dataset: Any = dataset  # pass the dataset as a UPathStr or data object
         if isinstance(self._dataset, Artifact):
             self._artifact = self._dataset
-            if self._artifact.otype in {"DataFrame", "AnnData"}:
+            if self._artifact.otype in {
+                "DataFrame",
+                "AnnData",
+                "MuData",
+                "SpatialData",
+            }:
                 self._dataset = self._dataset.load()
         self._schema: Schema | None = schema
         self._is_validated: bool = False
@@ -208,7 +223,7 @@ class Curator:
     @doc_args(VALIDATE_DOCSTRING)
     def validate(self) -> bool | str:
         """{}"""  # noqa: D415
-        pass  # pdagma: no cover
+        pass  # pragma: no cover
 
     @doc_args(SAVE_ARTIFACT_DOCSTRING)
     def save_artifact(
@@ -222,12 +237,97 @@ class Curator:
         """{}"""  # noqa: D415
         # Note that this docstring has to be consistent with the Artifact()
         # constructor signature
-        pass
+        pass  # pragma: no cover
+
+
+class SlotsCurator(Curator):
+    """Curator for a dataset with slots.
+
+    Args:
+        dataset: The dataset to validate & annotate.
+        schema: A `Schema` object that defines the validation constraints.
+
+    .. versionadded:: 1.3.0
+    """
+
+    def __init__(
+        self,
+        dataset: Any,
+        schema: Schema,
+    ) -> None:
+        super().__init__(dataset=dataset, schema=schema)
+        self._slots: dict[str, DataFrameCurator] = {}
+
+        # used in MuDataCurator and SpatialDataCurator
+        # in form of {table/modality_key: var_field}
+        self._var_fields: dict[str, FieldAttr] = {}
+        # in form of {table/modality_key: categoricals}
+        self._categoricals: dict[str, dict[str, FieldAttr]] = {}
+
+    @property
+    @doc_args(SLOTS_DOCSTRING)
+    def slots(self) -> dict[str, DataFrameCurator]:
+        """{}"""  # noqa: D415
+        return self._slots
+
+    @doc_args(VALIDATE_DOCSTRING)
+    def validate(self) -> None:
+        """{}"""  # noqa: D415
+        for _, curator in self._slots.items():
+            curator.validate()
+
+    @doc_args(SAVE_ARTIFACT_DOCSTRING)
+    def save_artifact(
+        self,
+        *,
+        key: str | None = None,
+        description: str | None = None,
+        revises: Artifact | None = None,
+        run: Run | None = None,
+    ) -> Artifact:
+        """{}"""  # noqa: D415
+        if not self._is_validated:
+            self.validate()
+
+        # default implementation for MuDataCurator and SpatialDataCurator
+        return save_artifact(  # type: ignore
+            self._dataset,
+            key=key,
+            description=description,
+            fields=self._categoricals,
+            index_field=self._var_fields,
+            artifact=self._artifact,
+            revises=revises,
+            run=run,
+            schema=self._schema,
+        )
+
+
+def check_dtype(expected_type) -> Callable:
+    """Creates a check function for Pandera that validates a column's dtype.
+
+    Args:
+        expected_type: String identifier for the expected type ('int', 'float', or 'num')
+
+    Returns:
+        A function that checks if a series has the expected dtype
+    """
+
+    def check_function(series):
+        if expected_type == "int":
+            is_valid = pd.api.types.is_integer_dtype(series.dtype)
+        elif expected_type == "float":
+            is_valid = pd.api.types.is_float_dtype(series.dtype)
+        elif expected_type == "num":
+            is_valid = pd.api.types.is_numeric_dtype(series.dtype)
+        return is_valid
+
+    return check_function
 
 
 class DataFrameCurator(Curator):
     # the example in the docstring is tested in test_curators_quickstart_example
-    """Curator for a DataFrame object.
+    """Curator for `DataFrame`.
 
     See also :class:`~lamindb.Curator` and :class:`~lamindb.Schema`.
 
@@ -278,12 +378,33 @@ class DataFrameCurator(Curator):
             # populate features
             pandera_columns = {}
             for feature in schema.features.all():
-                pandera_dtype = (
-                    feature.dtype if not feature.dtype.startswith("cat") else "category"
-                )
-                pandera_columns[feature.name] = pandera.Column(
-                    pandera_dtype, nullable=feature.nullable
-                )
+                if feature.dtype in {"int", "float", "num"}:
+                    dtype = (
+                        self._dataset[feature.name].dtype
+                        if feature.name in self._dataset.columns
+                        else None
+                    )
+                    pandera_columns[feature.name] = pandera.Column(
+                        dtype=None,
+                        checks=pandera.Check(
+                            check_dtype(feature.dtype),
+                            element_wise=False,
+                            error=f"Column '{feature.name}' failed dtype check for '{feature.dtype}': got {dtype}",
+                        ),
+                        nullable=feature.nullable,
+                        coerce=feature.coerce_dtype,
+                    )
+                else:
+                    pandera_dtype = (
+                        feature.dtype
+                        if not feature.dtype.startswith("cat")
+                        else "category"
+                    )
+                    pandera_columns[feature.name] = pandera.Column(
+                        pandera_dtype,
+                        nullable=feature.nullable,
+                        coerce=feature.coerce_dtype,
+                    )
                 if feature.dtype.startswith("cat"):
                     categoricals[feature.name] = parse_dtype(feature.dtype)[0]["field"]
             self._pandera_schema = pandera.DataFrameSchema(
@@ -293,7 +414,7 @@ class DataFrameCurator(Curator):
             assert schema.itype is not None  # noqa: S101
         self._cat_manager = DataFrameCatManager(
             self._dataset,
-            columns=parse_dtype_single_cat(schema.itype, is_itype=True)["field"],
+            columns=parse_cat_dtype(schema.itype, is_itype=True)["field"],
             categoricals=categoricals,
         )
 
@@ -378,16 +499,16 @@ class DataFrameCurator(Curator):
         description: str | None = None,
         revises: Artifact | None = None,
         run: Run | None = None,
-    ):
+    ) -> Artifact:
         """{}"""  # noqa: D415
         if not self._is_validated:
             self.validate()  # raises ValidationError if doesn't validate
-        result = parse_dtype_single_cat(self._schema.itype, is_itype=True)
+        result = parse_cat_dtype(self._schema.itype, is_itype=True)
         return save_artifact(  # type: ignore
             self._dataset,
             description=description,
             fields=self._cat_manager.categoricals,
-            columns_field=result["field"],
+            index_field=result["field"],
             key=key,
             artifact=self._artifact,
             revises=revises,
@@ -396,9 +517,9 @@ class DataFrameCurator(Curator):
         )
 
 
-class AnnDataCurator(Curator):
+class AnnDataCurator(SlotsCurator):
     # the example in the docstring is tested in test_curators_quickstart_example
-    """Curator for a DataFrame object.
+    """Curator for `AnnData`.
 
     See also :class:`~lamindb.Curator` and :class:`~lamindb.Schema`.
 
@@ -446,7 +567,7 @@ class AnnDataCurator(Curator):
         ).save()
 
         # curate an AnnData
-        adata = datasets.small_dataset1(otype="AnnData")
+        adata = ln.core.datasets.small_dataset1(otype="AnnData")
         curator = ln.curators.AnnDataCurator(adata, anndata_schema)
         artifact = curator.save_artifact(key="example_datasets/dataset1.h5ad")
         assert artifact.schema == anndata_schema
@@ -466,28 +587,16 @@ class AnnDataCurator(Curator):
         self._slots = {
             slot: DataFrameCurator(
                 (
-                    self._dataset.__getattribute__(slot).T
+                    getattr(self._dataset, slot).T
                     if slot == "var"
-                    else self._dataset.__getattribute__(slot)
+                    else getattr(self._dataset, slot)
                 ),
                 slot_schema,
             )
             for slot, slot_schema in schema.slots.items()
-            if slot in {"obs", "var"}
+            if slot in {"obs", "var", "uns"}
         }
 
-    @property
-    @doc_args(SLOTS_DOCSTRING)
-    def slots(self) -> dict[str, DataFrameCurator]:
-        """{}"""  # noqa: D415
-        return self._slots
-
-    @doc_args(VALIDATE_DOCSTRING)
-    def validate(self) -> None:
-        """{}"""  # noqa: D415
-        for _, curator in self._slots.items():
-            curator.validate()
-
     @doc_args(SAVE_ARTIFACT_DOCSTRING)
     def save_artifact(
         self,
@@ -496,18 +605,20 @@ class AnnDataCurator(Curator):
         description: str | None = None,
         revises: Artifact | None = None,
         run: Run | None = None,
-    ):
+    ) -> Artifact:
         """{}"""  # noqa: D415
         if not self._is_validated:
             self.validate()
+        if "obs" in self.slots:
+            categoricals = self.slots["obs"]._cat_manager.categoricals
+        else:
+            categoricals = {}
         return save_artifact(  # type: ignore
             self._dataset,
             description=description,
-            fields=self.slots["obs"]._cat_manager.categoricals,
-            columns_field=(
-                parse_dtype_single_cat(self.slots["var"]._schema.itype, is_itype=True)[
-                    "field"
-                ]
+            fields=categoricals,
+            index_field=(
+                parse_cat_dtype(self.slots["var"]._schema.itype, is_itype=True)["field"]
                 if "var" in self._slots
                 else None
             ),
@@ -519,34 +630,286 @@ class AnnDataCurator(Curator):
         )
 
 
-class CatManager:
-    """Manage valid categoricals by updating registries.
+def _assign_var_fields_categoricals_multimodal(
+    modality: str | None,
+    slot_type: str,
+    slot: str,
+    slot_schema: Schema,
+    var_fields: dict[str, FieldAttr],
+    categoricals: dict[str, dict[str, FieldAttr]],
+    slots: dict[str, DataFrameCurator],
+) -> None:
+    """Assigns var_fields and categoricals for multimodal data curators."""
+    if modality is not None:
+        # Makes sure that all tables are present
+        var_fields[modality] = None
+        categoricals[modality] = {}
+
+    if slot_type == "var":
+        var_field = parse_cat_dtype(slot_schema.itype, is_itype=True)["field"]
+        if modality is None:
+            # This should rarely/never be used since tables should have different var fields
+            var_fields[slot] = var_field  # pragma: no cover
+        else:
+            # Note that this is NOT nested since the nested key is always "var"
+            var_fields[modality] = var_field
+    else:
+        obs_fields = slots[slot]._cat_manager.categoricals
+        if modality is None:
+            categoricals[slot] = obs_fields
+        else:
+            # Note that this is NOT nested since the nested key is always "obs"
+            categoricals[modality] = obs_fields
+
+
+class MuDataCurator(SlotsCurator):
+    # the example in the docstring is tested in test_curators_quickstart_example
+    """Curator for `MuData`.
 
-    A `CatManager` object makes it easy to validate, standardize & annotate datasets.
+    See also :class:`~lamindb.Curator` and :class:`~lamindb.Schema`.
 
-    Example:
+    .. versionadded:: 1.3.0
 
-    >>> cat_manager = ln.CatManager(
-    >>>     dataset,
-    >>>     # define validation criteria as mappings
-    >>>     columns=Feature.name,  # map column names
-    >>>     categoricals={"perturbation": ULabel.name},  # map categories
-    >>> )
-    >>> cat_manager.validate()  # validate the dataframe
-    >>> artifact = cat_manager.save_artifact(description="my RNA-seq")
-    >>> artifact.describe()  # see annotations
+    Args:
+        dataset: The MuData-like object to validate & annotate.
+        schema: A `Schema` object that defines the validation constraints.
 
-    `cat_manager.validate()` maps values within `df` according to the mapping criteria and logs validated & problematic values.
+    Example::
 
-    If you find non-validated values, you have several options:
+        import lamindb as ln
+        import bionty as bt
+
+        # define the global obs schema
+        obs_schema = ln.Schema(
+            name="mudata_papalexi21_subset_obs_schema",
+            features=[
+                ln.Feature(name="perturbation", dtype="cat[ULabel[Perturbation]]").save(),
+                ln.Feature(name="replicate", dtype="cat[ULabel[Replicate]]").save(),
+            ],
+        ).save()
+
+        # define the ['rna'].obs schema
+        obs_schema_rna = ln.Schema(
+            name="mudata_papalexi21_subset_rna_obs_schema",
+            features=[
+                ln.Feature(name="nCount_RNA", dtype=int).save(),
+                ln.Feature(name="nFeature_RNA", dtype=int).save(),
+                ln.Feature(name="percent.mito", dtype=float).save(),
+            ],
+            coerce_dtype=True,
+        ).save()
+
+        # define the ['hto'].obs schema
+        obs_schema_hto = ln.Schema(
+            name="mudata_papalexi21_subset_hto_obs_schema",
+            features=[
+                ln.Feature(name="nCount_HTO", dtype=int).save(),
+                ln.Feature(name="nFeature_HTO", dtype=int).save(),
+                ln.Feature(name="technique", dtype=bt.ExperimentalFactor).save(),
+            ],
+            coerce_dtype=True,
+        ).save()
+
+        # define ['rna'].var schema
+        var_schema_rna = ln.Schema(
+            name="mudata_papalexi21_subset_rna_var_schema",
+            itype=bt.Gene.symbol,
+            dtype=float,
+        ).save()
 
-    - new values found in the data can be registered using :meth:`~lamindb.curators.DataFrameCatManager.add_new_from`
-    - non-validated values can be accessed using :meth:`~lamindb.curators.DataFrameCatManager.non_validated` and addressed manually
+        # define composite schema
+        mudata_schema = ln.Schema(
+            name="mudata_papalexi21_subset_mudata_schema",
+            otype="MuData",
+            components={
+                "obs": obs_schema,
+                "rna:obs": obs_schema_rna,
+                "hto:obs": obs_schema_hto,
+                "rna:var": var_schema_rna,
+            },
+        ).save()
+
+        # curate a MuData
+        mdata = ln.core.datasets.mudata_papalexi21_subset()
+        bt.settings.organism = "human" # set the organism
+        curator = ln.curators.MuDataCurator(mdata, mudata_schema)
+        artifact = curator.save_artifact(key="example_datasets/mudata_papalexi21_subset.h5mu")
+        assert artifact.schema == mudata_schema
     """
 
     def __init__(
-        self, *, dataset, categoricals, sources, organism, exclude, columns_field=None
-    ):
+        self,
+        dataset: MuData | Artifact,
+        schema: Schema,
+    ) -> None:
+        super().__init__(dataset=dataset, schema=schema)
+        if not data_is_mudata(self._dataset):
+            raise InvalidArgument("dataset must be MuData-like.")
+        if schema.otype != "MuData":
+            raise InvalidArgument("Schema otype must be 'MuData'.")
+
+        for slot, slot_schema in schema.slots.items():
+            # Assign to _slots
+            if ":" in slot:
+                modality, modality_slot = slot.split(":")
+                schema_dataset = self._dataset.__getitem__(modality)
+            else:
+                modality, modality_slot = None, slot
+                schema_dataset = self._dataset
+            self._slots[slot] = DataFrameCurator(
+                (
+                    getattr(schema_dataset, modality_slot).T
+                    if modality_slot == "var"
+                    else getattr(schema_dataset, modality_slot)
+                ),
+                slot_schema,
+            )
+            _assign_var_fields_categoricals_multimodal(
+                modality=modality,
+                slot_type=modality_slot,
+                slot=slot,
+                slot_schema=slot_schema,
+                var_fields=self._var_fields,
+                categoricals=self._categoricals,
+                slots=self._slots,
+            )
+
+        # for consistency with BaseCatManager
+        self._columns_field = self._var_fields
+
+
+class SpatialDataCurator(SlotsCurator):
+    # the example in the docstring is tested in test_curators_quickstart_example
+    """Curator for `SpatialData`.
+
+    See also :class:`~lamindb.Curator` and :class:`~lamindb.Schema`.
+
+    .. versionadded:: 1.3.0
+
+    Args:
+        dataset: The SpatialData-like object to validate & annotate.
+        schema: A `Schema` object that defines the validation constraints.
+
+    Example::
+
+        import lamindb as ln
+        import bionty as bt
+
+        # define sample schema
+        sample_schema = ln.Schema(
+            name="blobs_sample_level_metadata",
+            features=[
+                ln.Feature(name="assay", dtype=bt.ExperimentalFactor).save(),
+                ln.Feature(name="disease", dtype=bt.Disease).save(),
+                ln.Feature(name="development_stage", dtype=bt.DevelopmentalStage).save(),
+            ],
+            coerce_dtype=True
+        ).save()
+
+        # define table obs schema
+        blobs_obs_schema = ln.Schema(
+            name="blobs_obs_level_metadata",
+            features=[
+                ln.Feature(name="sample_region", dtype="str").save(),
+            ],
+            coerce_dtype=True
+        ).save()
+
+        # define table var schema
+        blobs_var_schema = ln.Schema(
+            name="blobs_var_schema",
+            itype=bt.Gene.ensembl_gene_id,
+            dtype=int
+        ).save()
+
+        # define composite schema
+        spatialdata_schema = ln.Schema(
+            name="blobs_spatialdata_schema",
+            otype="SpatialData",
+            components={
+                "sample": sample_schema,
+                "table:obs": blobs_obs_schema,
+                "table:var": blobs_var_schema,
+        }).save()
+
+        # curate a SpatialData
+        spatialdata = ln.core.datasets.spatialdata_blobs()
+        curator = ln.curators.SpatialDataCurator(spatialdata, spatialdata_schema)
+        try:
+            curator.validate()
+        except ln.errors.ValidationError as error:
+            print(error)
+
+        # validate again (must pass now) and save artifact
+        artifact = curator.save_artifact(key="example_datasets/spatialdata1.zarr")
+        assert artifact.schema == spatialdata_schema
+    """
+
+    def __init__(
+        self,
+        dataset: SpatialData | Artifact,
+        schema: Schema,
+        *,
+        sample_metadata_key: str | None = "sample",
+    ) -> None:
+        super().__init__(dataset=dataset, schema=schema)
+        if not data_is_spatialdata(self._dataset):
+            raise InvalidArgument("dataset must be SpatialData-like.")
+        if schema.otype != "SpatialData":
+            raise InvalidArgument("Schema otype must be 'SpatialData'.")
+
+        for slot, slot_schema in schema.slots.items():
+            # Assign to _slots
+            if ":" in slot:
+                table_key, table_slot = slot.split(":")
+                schema_dataset = self._dataset.tables.__getitem__(table_key)
+            # sample metadata (does not have a `:` separator)
+            else:
+                table_key = None
+                table_slot = slot
+                schema_dataset = self._dataset.get_attrs(
+                    key=sample_metadata_key, return_as="df", flatten=True
+                )
+
+            self._slots[slot] = DataFrameCurator(
+                (
+                    getattr(schema_dataset, table_slot).T
+                    if table_slot == "var"
+                    else (
+                        getattr(schema_dataset, table_slot)
+                        if table_slot != sample_metadata_key
+                        else schema_dataset
+                    )  # just take the schema_dataset if it's the sample metadata key
+                ),
+                slot_schema,
+            )
+
+            _assign_var_fields_categoricals_multimodal(
+                modality=table_key,
+                slot_type=table_slot,
+                slot=slot,
+                slot_schema=slot_schema,
+                var_fields=self._var_fields,
+                categoricals=self._categoricals,
+                slots=self._slots,
+            )
+
+        # for consistency with BaseCatManager
+        self._columns_field = self._var_fields
+
+
+class CatManager:
+    """Manage categoricals by updating registries.
+
+    This class is accessible from within a `DataFrameCurator` via the `.cat` attribute.
+
+    If you find non-validated values, you have several options:
+
+    - new values found in the data can be registered via `DataFrameCurator.cat.add_new_from()` :meth:`~lamindb.curators.DataFrameCatManager.add_new_from`
+    - non-validated values can be accessed via `DataFrameCurator.cat.add_new_from()` :meth:`~lamindb.curators.DataFrameCatManager.non_validated` and addressed manually
+    """
+
+    def __init__(self, *, dataset, categoricals, sources, organism, columns_field=None):
         # the below is shared with Curator
         self._artifact: Artifact = None  # pass the dataset as an artifact
         self._dataset: Any = dataset  # pass the dataset as a UPathStr or data object
@@ -558,11 +921,16 @@ class CatManager:
         # shared until here
         self._categoricals = categoricals or {}
         self._non_validated = None
-        self._organism = organism
         self._sources = sources or {}
-        self._exclude = exclude or {}
         self._columns_field = columns_field
         self._validate_category_error_messages: str = ""
+        # make sure to only fetch organism once at the beginning
+        if organism:
+            self._organism = organism
+        else:
+            fields = list(self._categoricals.values()) + [columns_field]
+            organisms = {get_organism_kwargs(field).get("organism") for field in fields}
+            self._organism = organisms.pop() if len(organisms) > 0 else None
 
     @property
     def non_validated(self) -> dict[str, list[str]]:
@@ -607,7 +975,7 @@ class CatManager:
         Returns:
             The boolean `True` if the dataset is validated. Otherwise, a string with the error message.
         """
-        pass
+        pass  # pragma: no cover
 
     def standardize(self, key: str) -> None:
         """Replace synonyms with standardized values.
@@ -620,7 +988,7 @@ class CatManager:
         Returns:
             None
         """
-        pass  # pdagma: no cover
+        pass  # pragma: no cover
 
     @doc_args(SAVE_ARTIFACT_DOCSTRING)
     def save_artifact(
@@ -632,64 +1000,30 @@ class CatManager:
         run: Run | None = None,
     ) -> Artifact:
         """{}"""  # noqa: D415
-        from lamindb.core._settings import settings
-
+        # Make sure all labels are saved in the current instance
         if not self._is_validated:
             self.validate()  # returns True or False
             if not self._is_validated:  # need to raise error manually
                 raise ValidationError("Dataset does not validate. Please curate.")
 
-        # Make sure all labels are saved in the current instance
-        verbosity = settings.verbosity
-        try:
-            settings.verbosity = "warning"
-            self._artifact = save_artifact(  # type: ignore
-                self._dataset,
-                description=description,
-                fields=self.categoricals,
-                columns_field=self._columns_field,
-                key=key,
-                artifact=self._artifact,
-                revises=revises,
-                run=run,
-                schema=None,
-                organism=self._organism,
-            )
-        finally:
-            settings.verbosity = verbosity
+        self._artifact = save_artifact(  # type: ignore
+            self._dataset,
+            key=key,
+            description=description,
+            fields=self.categoricals,
+            index_field=self._columns_field,
+            artifact=self._artifact,
+            revises=revises,
+            run=run,
+            schema=None,
+            organism=self._organism,
+        )
 
         return self._artifact
 
 
 class DataFrameCatManager(CatManager):
-    """Curation flow for a DataFrame object.
-
-    See also :class:`~lamindb.Curator`.
-
-    Args:
-        df: The DataFrame object to curate.
-        columns: The field attribute for the feature column.
-        categoricals: A dictionary mapping column names to registry_field.
-        verbosity: The verbosity level.
-        organism: The organism name.
-        sources: A dictionary mapping column names to Source records.
-        exclude: A dictionary mapping column names to values to exclude from validation.
-            When specific :class:`~bionty.Source` instances are pinned and may lack default values (e.g., "unknown" or "na"),
-            using the exclude parameter ensures they are not validated.
-
-    Returns:
-        A curator object.
-
-    Examples:
-        >>> import bionty as bt
-        >>> curator = ln.Curator.from_df(
-        ...     df,
-        ...     categoricals={
-        ...         "cell_type_ontology_id": bt.CellType.ontology_id,
-        ...         "donor_id": ULabel.name
-        ...     }
-        ... )
-    """
+    """Categorical manager for `DataFrame`."""
 
     def __init__(
         self,
@@ -699,10 +1033,7 @@ class DataFrameCatManager(CatManager):
         verbosity: str = "hint",
         organism: str | None = None,
         sources: dict[str, Record] | None = None,
-        exclude: dict | None = None,
     ) -> None:
-        from lamindb.core._settings import settings
-
         if organism is not None and not isinstance(organism, str):
             raise ValueError("organism must be a string such as 'human' or 'mouse'!")
 
@@ -714,20 +1045,21 @@ class DataFrameCatManager(CatManager):
             organism=organism,
             categoricals=categoricals,
             sources=sources,
-            exclude=exclude,
         )
         self._save_columns()
 
-    def lookup(self, public: bool = False) -> CurateLookup:
+    def lookup(self, public: bool = False) -> CatLookup:
         """Lookup categories.
 
         Args:
             public: If "public", the lookup is performed on the public reference.
         """
-        return CurateLookup(
+        return CatLookup(
             categoricals=self._categoricals,
             slots={"columns": self._columns_field},
             public=public,
+            organism=self._organism,
+            sources=self._sources,
         )
 
     def _save_columns(self, validated_only: bool = True) -> None:
@@ -736,28 +1068,26 @@ class DataFrameCatManager(CatManager):
         update_registry(
             values=list(self.categoricals.keys()),
             field=self._columns_field,
-            key="columns",
+            key="columns" if isinstance(self._dataset, pd.DataFrame) else "keys",
             validated_only=False,
             source=self._sources.get("columns"),
-            exclude=self._exclude.get("columns"),
         )
 
         # Save the rest of the columns based on validated_only
-        additional_columns = set(self._dataset.columns) - set(self.categoricals.keys())
+        additional_columns = set(self._dataset.keys()) - set(self.categoricals.keys())
         if additional_columns:
             update_registry(
                 values=list(additional_columns),
                 field=self._columns_field,
-                key="columns",
+                key="columns" if isinstance(self._dataset, pd.DataFrame) else "keys",
                 validated_only=validated_only,
                 df=self._dataset,  # Get the Feature type from df
                 source=self._sources.get("columns"),
-                exclude=self._exclude.get("columns"),
             )
 
     @deprecated(new_name="is run by default")
     def add_new_from_columns(self, organism: str | None = None, **kwargs):
-        pass
+        pass  # pragma: no cover
 
     def validate(self) -> bool:
         """Validate variables and categorical observations.
@@ -778,7 +1108,6 @@ class DataFrameCatManager(CatManager):
             self._dataset,
             fields=self.categoricals,
             sources=self._sources,
-            exclude=self._exclude,
             curator=self,
             organism=self._organism,
         )
@@ -814,7 +1143,7 @@ class DataFrameCatManager(CatManager):
         else:
             if key not in avail_keys:
                 if key in self._categoricals:
-                    logger.info(f"No unstandardized values found for {key!r}")
+                    logger.warning(f"No non-standardized values found for {key!r}")
                 else:
                     raise KeyError(
                         f"{key!r} is not a valid key, available keys are: {_format_values(avail_keys)}!"
@@ -852,7 +1181,6 @@ class DataFrameCatManager(CatManager):
                 key=categorical,
                 validated_only=validated_only,
                 source=self._sources.get(categorical),
-                exclude=self._exclude.get(categorical),
                 organism=self._organism,
             )
             # adding new records removes them from non_validated
@@ -882,32 +1210,7 @@ class DataFrameCatManager(CatManager):
 
 
 class AnnDataCatManager(CatManager):
-    """Manage categorical curation.
-
-    Args:
-        data: The AnnData object or an AnnData-like path.
-        var_index: The registry field for mapping the ``.var`` index.
-        categoricals: A dictionary mapping ``.obs.columns`` to a registry field.
-        obs_columns: The registry field for mapping the ``.obs.columns``.
-        verbosity: The verbosity level.
-        organism: The organism name.
-        sources: A dictionary mapping ``.obs.columns`` to Source records.
-        exclude: A dictionary mapping column names to values to exclude from validation.
-            When specific :class:`~bionty.Source` instances are pinned and may lack default values (e.g., "unknown" or "na"),
-            using the exclude parameter ensures they are not validated.
-
-    Examples:
-        >>> import bionty as bt
-        >>> curator = ln.Curator.from_anndata(
-        ...     adata,
-        ...     var_index=bt.Gene.ensembl_gene_id,
-        ...     categoricals={
-        ...         "cell_type_ontology_id": bt.CellType.ontology_id,
-        ...         "donor_id": ULabel.name
-        ...     },
-        ...     organism="human",
-        ... )
-    """
+    """Categorical manager for `AnnData`."""
 
     def __init__(
         self,
@@ -918,13 +1221,12 @@ class AnnDataCatManager(CatManager):
         verbosity: str = "hint",
         organism: str | None = None,
         sources: dict[str, Record] | None = None,
-        exclude: dict | None = None,
     ) -> None:
         if isinstance(var_index, str):
-            raise TypeError("var_index parameter has to be a bionty field")
+            raise TypeError(
+                "var_index parameter has to be a field, e.g. Gene.ensembl_gene_id"
+            )
 
-        if sources is None:
-            sources = {}
         if not data_is_anndata(data):
             raise TypeError("data has to be an AnnData object")
 
@@ -935,12 +1237,12 @@ class AnnDataCatManager(CatManager):
 
         self._obs_fields = categoricals or {}
         self._var_field = var_index
+        self._sources = sources or {}
         super().__init__(
             dataset=data,
             categoricals=categoricals,
-            sources=sources,
+            sources=self._sources,
             organism=organism,
-            exclude=exclude,
             columns_field=var_index,
         )
         self._adata = self._dataset
@@ -950,8 +1252,7 @@ class AnnDataCatManager(CatManager):
             columns=obs_columns,
             verbosity=verbosity,
             organism=None,
-            sources=sources,
-            exclude=exclude,
+            sources=self._sources,
         )
 
     @property
@@ -964,16 +1265,18 @@ class AnnDataCatManager(CatManager):
         """Return the obs fields to validate against."""
         return self._obs_fields
 
-    def lookup(self, public: bool = False) -> CurateLookup:
+    def lookup(self, public: bool = False) -> CatLookup:
         """Lookup categories.
 
         Args:
             public: If "public", the lookup is performed on the public reference.
         """
-        return CurateLookup(
+        return CatLookup(
             categoricals=self._obs_fields,
             slots={"columns": self._columns_field, "var_index": self._var_field},
             public=public,
+            organism=self._organism,
+            sources=self._sources,
         )
 
     def _save_from_var_index(
@@ -989,7 +1292,6 @@ class AnnDataCatManager(CatManager):
                 validated_only=validated_only,
                 organism=self._organism,
                 source=self._sources.get("var_index"),
-                exclude=self._exclude.get("var_index"),
             )
 
     def add_new_from(self, key: str, **kwargs):
@@ -1033,7 +1335,6 @@ class AnnDataCatManager(CatManager):
                 key="var_index",
                 source=self._sources.get("var_index"),
                 hint_print=".add_new_from_var_index()",
-                exclude=self._exclude.get("var_index"),
                 organism=self._organism,  # type: ignore
             )
         else:
@@ -1077,59 +1378,29 @@ class AnnDataCatManager(CatManager):
 
 
 class MuDataCatManager(CatManager):
-    """Curation flow for a ``MuData`` object.
-
-    Args:
-        mdata: The MuData object to curate.
-        var_index: The registry field for mapping the ``.var`` index for each modality.
-            For example:
-            ``{"modality_1": bt.Gene.ensembl_gene_id, "modality_2": CellMarker.name}``
-        categoricals: A dictionary mapping ``.obs.columns`` to a registry field.
-            Use modality keys to specify categoricals for MuData slots such as `"rna:cell_type": bt.CellType.name"`.
-        verbosity: The verbosity level.
-        organism: The organism name.
-        sources: A dictionary mapping ``.obs.columns`` to Source records.
-        exclude: A dictionary mapping column names to values to exclude from validation.
-            When specific :class:`~bionty.Source` instances are pinned and may lack default values (e.g., "unknown" or "na"),
-            using the exclude parameter ensures they are not validated.
-
-    Examples:
-        >>> import bionty as bt
-        >>> curator = ln.Curator.from_mudata(
-        ...     mdata,
-        ...     var_index={
-        ...         "rna": bt.Gene.ensembl_gene_id,
-        ...         "adt": CellMarker.name
-        ...     },
-        ...     categoricals={
-        ...         "cell_type_ontology_id": bt.CellType.ontology_id,
-        ...         "donor_id": ULabel.name
-        ...     },
-        ...     organism="human",
-        ... )
-    """
+    """Categorical manager for `MuData`."""
 
     def __init__(
         self,
         mdata: MuData | Artifact,
-        var_index: dict[str, FieldAttr],
+        var_index: dict[str, FieldAttr] | None = None,
         categoricals: dict[str, FieldAttr] | None = None,
         verbosity: str = "hint",
         organism: str | None = None,
         sources: dict[str, Record] | None = None,
-        exclude: dict | None = None,  # {modality: {field: [values]}}
     ) -> None:
         super().__init__(
             dataset=mdata,
             categoricals={},
             sources=sources,
             organism=organism,
-            exclude=exclude,
         )
-        self._columns_field = var_index  # this is for consistency with BaseCatManager
-        self._var_fields = var_index
+        self._columns_field = (
+            var_index or {}
+        )  # this is for consistency with BaseCatManager
+        self._var_fields = var_index or {}
         self._verify_modality(self._var_fields.keys())
-        self._obs_fields = self._parse_categoricals(categoricals)
+        self._obs_fields = self._parse_categoricals(categoricals or {})
         self._modalities = set(self._var_fields.keys()) | set(self._obs_fields.keys())
         self._verbosity = verbosity
         self._obs_df_curator = None
@@ -1140,7 +1411,6 @@ class MuDataCatManager(CatManager):
                 categoricals=self._obs_fields.get("obs", {}),
                 verbosity=verbosity,
                 sources=self._sources.get("obs"),
-                exclude=self._exclude.get("obs"),
                 organism=organism,
             )
         self._mod_adata_curators = {
@@ -1150,7 +1420,6 @@ class MuDataCatManager(CatManager):
                 categoricals=self._obs_fields.get(modality),
                 verbosity=verbosity,
                 sources=self._sources.get(modality),
-                exclude=self._exclude.get(modality),
                 organism=organism,
             )
             for modality in self._modalities
@@ -1199,7 +1468,7 @@ class MuDataCatManager(CatManager):
                 obs_fields["obs"][k] = v
         return obs_fields
 
-    def lookup(self, public: bool = False) -> CurateLookup:
+    def lookup(self, public: bool = False) -> CatLookup:
         """Lookup categories.
 
         Args:
@@ -1212,12 +1481,14 @@ class MuDataCatManager(CatManager):
                     obs_fields[k] = v
                 else:
                     obs_fields[f"{mod}:{k}"] = v
-        return CurateLookup(
+        return CatLookup(
             categoricals=obs_fields,
             slots={
                 **{f"{k}_var_index": v for k, v in self._var_fields.items()},
             },
             public=public,
+            organism=self._organism,
+            sources=self._sources,
         )
 
     @deprecated(new_name="is run by default")
@@ -1227,7 +1498,7 @@ class MuDataCatManager(CatManager):
         column_names: list[str] | None = None,
         **kwargs,
     ):
-        pass
+        pass  # pragma: no cover
 
     def add_new_from_var_index(self, modality: str, **kwargs):
         """Update variable records.
@@ -1271,16 +1542,8 @@ class MuDataCatManager(CatManager):
 
     def validate(self) -> bool:
         """Validate categories."""
-        from lamindb.core._settings import settings
-
         # add all validated records to the current instance
-        verbosity = settings.verbosity
-        try:
-            settings.verbosity = "error"
-            self._update_registry_all()
-        finally:
-            settings.verbosity = verbosity
-
+        self._update_registry_all()
         self._non_validated = {}  # type: ignore
 
         obs_validated = True
@@ -1329,393 +1592,287 @@ def _maybe_curation_keys_not_present(nonval_keys: list[str], name: str):
         )
 
 
-class TiledbsomaCatManager(CatManager):
-    """Curation flow for `tiledbsoma.Experiment`.
-
-    Args:
-        experiment_uri: A local or cloud path to a `tiledbsoma.Experiment`.
-        var_index: The registry fields for mapping the `.var` indices for measurements.
-            Should be in the form `{"measurement name": ("var column", field)}`.
-            These keys should be used in the flattened form (`'{measurement name}__{column name in .var}'`)
-            in `.standardize` or `.add_new_from`, see the output of `.var_index`.
-        categoricals: A dictionary mapping categorical `.obs` columns to a registry field.
-        obs_columns: The registry field for mapping the names of the `.obs` columns.
-        organism: The organism name.
-        sources: A dictionary mapping `.obs` columns to Source records.
-        exclude: A dictionary mapping column names to values to exclude from validation.
-            When specific :class:`~bionty.Source` instances are pinned and may lack default values (e.g., "unknown" or "na"),
-            using the exclude parameter ensures they are not validated.
-
-    Examples:
-        >>> import bionty as bt
-        >>> curator = ln.Curator.from_tiledbsoma(
-        ...     "./my_array_store.tiledbsoma",
-        ...     var_index={"RNA": ("var_id", bt.Gene.symbol)},
-        ...     categoricals={
-        ...         "cell_type_ontology_id": bt.CellType.ontology_id,
-        ...         "donor_id": ULabel.name
-        ...     },
-        ...     organism="human",
-        ... )
-    """
+class SpatialDataCatManager(CatManager):
+    """Categorical manager for `SpatialData`."""
 
     def __init__(
         self,
-        experiment_uri: UPathStr | Artifact,
-        var_index: dict[str, tuple[str, FieldAttr]],
-        categoricals: dict[str, FieldAttr] | None = None,
-        obs_columns: FieldAttr = Feature.name,
+        sdata: Any,
+        var_index: dict[str, FieldAttr],
+        categoricals: dict[str, dict[str, FieldAttr]] | None = None,
+        verbosity: str = "hint",
         organism: str | None = None,
-        sources: dict[str, Record] | None = None,
-        exclude: dict[str, str | list[str]] | None = None,
-    ):
-        self._obs_fields = categoricals or {}
-        self._var_fields = var_index
-        self._columns_field = obs_columns
-        if isinstance(experiment_uri, Artifact):
-            self._dataset = experiment_uri.path
-            self._artifact = experiment_uri
+        sources: dict[str, dict[str, Record]] | None = None,
+        *,
+        sample_metadata_key: str | None = "sample",
+    ) -> None:
+        super().__init__(
+            dataset=sdata,
+            categoricals={},
+            sources=sources,
+            organism=organism,
+        )
+        if isinstance(sdata, Artifact):
+            self._sdata = sdata.load()
         else:
-            self._dataset = UPath(experiment_uri)
-            self._artifact = None
-        self._organism = organism
-        self._sources = sources or {}
-        self._exclude = exclude or {}
-
-        self._is_validated: bool | None = False
-        self._non_validated_values: dict[str, list] | None = None
-        self._validated_values: dict[str, list] = {}
-        # filled by _check_save_keys
-        self._n_obs: int | None = None
-        self._valid_obs_keys: list[str] | None = None
-        self._obs_pa_schema: pa.lib.Schema | None = (
-            None  # this is needed to create the obs feature set
+            self._sdata = self._dataset
+        self._sample_metadata_key = sample_metadata_key
+        self._write_path = None
+        self._var_fields = var_index
+        self._verify_accessor_exists(self._var_fields.keys())
+        self._categoricals = categoricals
+        self._table_keys = set(self._var_fields.keys()) | set(
+            self._categoricals.keys() - {self._sample_metadata_key}
         )
-        self._valid_var_keys: list[str] | None = None
-        self._var_fields_flat: dict[str, FieldAttr] | None = None
-        self._check_save_keys()
-
-    # check that the provided keys in var_index and categoricals are available in the store
-    # and save features
-    def _check_save_keys(self):
-        from lamindb.core.storage._tiledbsoma import _open_tiledbsoma
-
-        with _open_tiledbsoma(self._dataset, mode="r") as experiment:
-            experiment_obs = experiment.obs
-            self._n_obs = len(experiment_obs)
-            self._obs_pa_schema = experiment_obs.schema
-            valid_obs_keys = [
-                k for k in self._obs_pa_schema.names if k != "soma_joinid"
-            ]
-            self._valid_obs_keys = valid_obs_keys
-
-            valid_var_keys = []
-            ms_list = []
-            for ms in experiment.ms.keys():
-                ms_list.append(ms)
-                var_ms = experiment.ms[ms].var
-                valid_var_keys += [
-                    f"{ms}__{k}" for k in var_ms.keys() if k != "soma_joinid"
-                ]
-            self._valid_var_keys = valid_var_keys
+        self._verbosity = verbosity
+        self._sample_df_curator = None
+        if self._sample_metadata_key is not None:
+            self._sample_metadata = self._sdata.get_attrs(
+                key=self._sample_metadata_key, return_as="df", flatten=True
+            )
+        self._is_validated = False
 
-        # check validity of keys in categoricals
+        # Check validity of keys in categoricals
         nonval_keys = []
-        for obs_key in self._obs_fields.keys():
-            if obs_key not in valid_obs_keys:
-                nonval_keys.append(obs_key)
+        for accessor, accessor_categoricals in self._categoricals.items():
+            if (
+                accessor == self._sample_metadata_key
+                and self._sample_metadata is not None
+            ):
+                for key in accessor_categoricals.keys():
+                    if key not in self._sample_metadata.columns:
+                        nonval_keys.append(key)
+            else:
+                for key in accessor_categoricals.keys():
+                    if key not in self._sdata[accessor].obs.columns:
+                        nonval_keys.append(key)
+
         _maybe_curation_keys_not_present(nonval_keys, "categoricals")
 
-        # check validity of keys in var_index
-        self._var_fields_flat = {}
+        # check validity of keys in sources
         nonval_keys = []
-        for ms_key in self._var_fields.keys():
-            var_key, var_field = self._var_fields[ms_key]
-            var_key_flat = f"{ms_key}__{var_key}"
-            if var_key_flat not in valid_var_keys:
-                nonval_keys.append(f"({ms_key}, {var_key})")
+        for accessor, accessor_sources in self._sources.items():
+            if (
+                accessor == self._sample_metadata_key
+                and self._sample_metadata is not None
+            ):
+                columns = self._sample_metadata.columns
+            elif accessor != self._sample_metadata_key:
+                columns = self._sdata[accessor].obs.columns
             else:
-                self._var_fields_flat[var_key_flat] = var_field
-        _maybe_curation_keys_not_present(nonval_keys, "var_index")
-
-        # check validity of keys in sources and exclude
-        valid_arg_keys = valid_obs_keys + valid_var_keys + ["columns"]
-        for name, dct in (("sources", self._sources), ("exclude", self._exclude)):
-            nonval_keys = []
-            for arg_key in dct.keys():
-                if arg_key not in valid_arg_keys:
-                    nonval_keys.append(arg_key)
-            _maybe_curation_keys_not_present(nonval_keys, name)
+                continue
+            for key in accessor_sources:
+                if key not in columns:
+                    nonval_keys.append(key)
+        _maybe_curation_keys_not_present(nonval_keys, "sources")
 
-        # register obs columns' names
-        register_columns = list(self._obs_fields.keys())
-        organism = check_registry_organism(
-            self._columns_field.field.model, self._organism
-        ).get("organism")
-        update_registry(
-            values=register_columns,
-            field=self._columns_field,
-            key="columns",
-            validated_only=False,
-            organism=organism,
-            source=self._sources.get("columns"),
-            exclude=self._exclude.get("columns"),
-        )
-        additional_columns = [k for k in valid_obs_keys if k not in register_columns]
-        # no need to register with validated_only=True if columns are features
+        # Set up sample level metadata and table Curator objects
         if (
-            len(additional_columns) > 0
-            and self._columns_field.field.model is not Feature
+            self._sample_metadata_key is not None
+            and self._sample_metadata_key in self._categoricals
         ):
-            update_registry(
-                values=additional_columns,
-                field=self._columns_field,
-                key="columns",
-                validated_only=True,
+            self._sample_df_curator = DataFrameCatManager(
+                df=self._sample_metadata,
+                columns=Feature.name,
+                categoricals=self._categoricals.get(self._sample_metadata_key, {}),
+                verbosity=verbosity,
+                sources=self._sources.get(self._sample_metadata_key),
+                organism=organism,
+            )
+        self._table_adata_curators = {
+            table: AnnDataCatManager(
+                data=self._sdata[table],
+                var_index=var_index.get(table),
+                categoricals=self._categoricals.get(table),
+                verbosity=verbosity,
+                sources=self._sources.get(table),
                 organism=organism,
-                source=self._sources.get("columns"),
-                exclude=self._exclude.get("columns"),
             )
+            for table in self._table_keys
+        }
 
-    def validate(self):
-        """Validate categories."""
-        from lamindb.core.storage._tiledbsoma import _open_tiledbsoma
+        self._non_validated = None
 
-        validated = True
-        self._non_validated_values = {}
-        with _open_tiledbsoma(self._dataset, mode="r") as experiment:
-            for ms, (key, field) in self._var_fields.items():
-                var_ms = experiment.ms[ms].var
-                var_ms_key = f"{ms}__{key}"
-                # it was already validated and cached
-                if var_ms_key in self._validated_values:
-                    continue
-                var_ms_values = (
-                    var_ms.read(column_names=[key]).concat()[key].to_pylist()
-                )
-                organism = check_registry_organism(
-                    field.field.model, self._organism
-                ).get("organism")
-                update_registry(
-                    values=var_ms_values,
-                    field=field,
-                    key=var_ms_key,
-                    validated_only=True,
-                    organism=organism,
-                    source=self._sources.get(var_ms_key),
-                    exclude=self._exclude.get(var_ms_key),
-                )
-                _, non_val = validate_categories(
-                    values=var_ms_values,
-                    field=field,
-                    key=var_ms_key,
-                    organism=organism,
-                    source=self._sources.get(var_ms_key),
-                    exclude=self._exclude.get(var_ms_key),
-                )
-                if len(non_val) > 0:
-                    validated = False
-                    self._non_validated_values[var_ms_key] = non_val
-                else:
-                    self._validated_values[var_ms_key] = var_ms_values
+    @property
+    def var_index(self) -> FieldAttr:
+        """Return the registry fields to validate variables indices against."""
+        return self._var_fields
 
-            obs = experiment.obs
-            for key, field in self._obs_fields.items():
-                # already validated and cached
-                if key in self._validated_values:
-                    continue
-                values = pa.compute.unique(
-                    obs.read(column_names=[key]).concat()[key]
-                ).to_pylist()
-                organism = check_registry_organism(
-                    field.field.model, self._organism
-                ).get("organism")
-                update_registry(
-                    values=values,
-                    field=field,
-                    key=key,
-                    validated_only=True,
-                    organism=organism,
-                    source=self._sources.get(key),
-                    exclude=self._exclude.get(key),
-                )
-                _, non_val = validate_categories(
-                    values=values,
-                    field=field,
-                    key=key,
-                    organism=organism,
-                    source=self._sources.get(key),
-                    exclude=self._exclude.get(key),
-                )
-                if len(non_val) > 0:
-                    validated = False
-                    self._non_validated_values[key] = non_val
-                else:
-                    self._validated_values[key] = values
-        self._is_validated = validated
-        return self._is_validated
+    @property
+    def categoricals(self) -> dict[str, dict[str, FieldAttr]]:
+        """Return the categorical keys and fields to validate against."""
+        return self._categoricals
 
-    def _non_validated_values_field(self, key: str) -> tuple[list, FieldAttr]:
-        assert self._non_validated_values is not None  # noqa: S101
+    @property
+    def non_validated(self) -> dict[str, dict[str, list[str]]]:  # type: ignore
+        """Return the non-validated features and labels."""
+        if self._non_validated is None:
+            raise ValidationError("Please run validate() first!")
+        return self._non_validated
 
-        if key in self._valid_obs_keys:
-            field = self._obs_fields[key]
-        elif key in self._valid_var_keys:
-            ms = key.partition("__")[0]
-            field = self._var_fields[ms][1]
-        else:
-            raise KeyError(f"key {key} is invalid!")
-        values = self._non_validated_values.get(key, [])
-        return values, field
+    def _verify_accessor_exists(self, accessors: Iterable[str]) -> None:
+        """Verify that the accessors exist (either a valid table or in attrs)."""
+        for acc in accessors:
+            is_present = False
+            try:
+                self._sdata.get_attrs(key=acc)
+                is_present = True
+            except KeyError:
+                if acc in self._sdata.tables.keys():
+                    is_present = True
+            if not is_present:
+                raise ValidationError(f"Accessor '{acc}' does not exist!")
 
-    def add_new_from(self, key: str, **kwargs) -> None:
-        """Add validated & new categories.
+    def lookup(self, public: bool = False) -> CatLookup:
+        """Look up categories.
 
         Args:
-            key: The key referencing the slot in the `tiledbsoma` store.
-                It should be `'{measurement name}__{column name in .var}'` for columns in `.var`
-                or a column name in `.obs`.
+            public: Whether the lookup is performed on the public reference.
         """
-        if self._non_validated_values is None:
-            raise ValidationError("Run .validate() first.")
-        if key == "all":
-            keys = list(self._non_validated_values.keys())
-        else:
-            avail_keys = list(
-                chain(self._non_validated_values.keys(), self._validated_values.keys())
-            )
-            if key not in avail_keys:
-                raise KeyError(
-                    f"'{key!r}' is not a valid key, available keys are: {_format_values(avail_keys + ['all'])}!"
-                )
-            keys = [key]
-        for k in keys:
-            values, field = self._non_validated_values_field(k)
-            if len(values) == 0:
-                continue
-            organism = check_registry_organism(field.field.model, self._organism).get(
-                "organism"
+        cat_values_dict = list(self.categoricals.values())[0]
+        return CatLookup(
+            categoricals=cat_values_dict,
+            slots={"accessors": cat_values_dict.keys()},
+            public=public,
+            organism=self._organism,
+            sources=self._sources,
+        )
+
+    def _update_registry_all(self) -> None:
+        """Saves labels of all features for sample and table metadata."""
+        if self._sample_df_curator is not None:
+            self._sample_df_curator._update_registry_all(
+                validated_only=True,
             )
-            update_registry(
-                values=values,
-                field=field,
-                key=k,
-                validated_only=False,
-                organism=organism,
-                source=self._sources.get(k),
-                exclude=self._exclude.get(k),
-                **kwargs,
+        for _, adata_curator in self._table_adata_curators.items():
+            adata_curator._obs_df_curator._update_registry_all(
+                validated_only=True,
             )
-            # update non-validated values list but keep the key there
-            # it will be removed by .validate()
-            if k in self._non_validated_values:
-                self._non_validated_values[k] = []
 
-    @property
-    def non_validated(self) -> dict[str, list]:
-        """Return the non-validated features and labels."""
-        non_val = {k: v for k, v in self._non_validated_values.items() if v != []}
-        return non_val
+    def add_new_from_var_index(self, table: str, **kwargs) -> None:
+        """Save new values from ``.var.index`` of table.
 
-    @property
-    def var_index(self) -> dict[str, FieldAttr]:
-        """Return the registry fields with flattened keys to validate variables indices against."""
-        return self._var_fields_flat
+        Args:
+            table: The table key.
+            organism: The organism name.
+            **kwargs: Additional keyword arguments to pass to create new records.
+        """
+        if self._non_validated is None:
+            raise ValidationError("Run .validate() first.")
+        self._table_adata_curators[table].add_new_from_var_index(**kwargs)
+        if table in self.non_validated.keys():
+            if "var_index" in self._non_validated[table]:
+                self._non_validated[table].pop("var_index")
 
-    @property
-    def categoricals(self) -> dict[str, FieldAttr]:
-        """Return the obs fields to validate against."""
-        return self._obs_fields
+            if len(self.non_validated[table].values()) == 0:
+                self.non_validated.pop(table)
 
-    def lookup(self, public: bool = False) -> CurateLookup:
-        """Lookup categories.
+    def add_new_from(
+        self,
+        key: str,
+        accessor: str | None = None,
+        **kwargs,
+    ) -> None:
+        """Save new values of categorical from sample level metadata or table.
 
         Args:
-            public: If "public", the lookup is performed on the public reference.
+            key: The key referencing the slot in the DataFrame.
+            accessor: The accessor key such as 'sample' or 'table x'.
+            organism: The organism name.
+            **kwargs: Additional keyword arguments to pass to create new records.
         """
-        return CurateLookup(
-            categoricals=self._obs_fields,
-            slots={"columns": self._columns_field, **self._var_fields_flat},
-            public=public,
-        )
+        if self._non_validated is None:
+            raise ValidationError("Run .validate() first.")
 
-    def standardize(self, key: str):
-        """Replace synonyms with standardized values.
+        if len(kwargs) > 0 and key == "all":
+            raise ValueError("Cannot pass additional arguments to 'all' key!")
+
+        if accessor not in self.categoricals:
+            raise ValueError(
+                f"Accessor {accessor} is not in 'categoricals'. Include it when creating the SpatialDataCatManager."
+            )
+
+        if accessor in self._table_adata_curators:
+            adata_curator = self._table_adata_curators[accessor]
+            adata_curator.add_new_from(key=key, **kwargs)
+        if accessor == self._sample_metadata_key:
+            self._sample_df_curator.add_new_from(key=key, **kwargs)
+
+        if accessor in self.non_validated.keys():
+            if len(self.non_validated[accessor].values()) == 0:
+                self.non_validated.pop(accessor)
+
+    def standardize(self, key: str, accessor: str | None = None) -> None:
+        """Replace synonyms with canonical values.
 
         Modifies the dataset inplace.
 
         Args:
-            key: The key referencing the slot in the `tiledbsoma` store.
-                It should be `'{measurement name}__{column name in .var}'` for columns in `.var`
-                or a column name in `.obs`.
+            key: The key referencing the slot in the table or sample metadata.
+            accessor: The accessor key such as 'sample_key' or 'table_key'.
         """
         if len(self.non_validated) == 0:
             logger.warning("values are already standardized")
             return
-        avail_keys = list(self._non_validated_values.keys())
-        if key == "all":
-            keys = avail_keys
+        if self._artifact is not None:
+            raise RuntimeError("can't mutate the dataset when an artifact is passed!")
+
+        if accessor == self._sample_metadata_key:
+            if key not in self._sample_metadata.columns:
+                raise ValueError(f"key '{key}' not present in '{accessor}'!")
         else:
-            if key not in avail_keys:
-                raise KeyError(
-                    f"'{key!r}' is not a valid key, available keys are: {_format_values(avail_keys + ['all'])}!"
-                )
-            keys = [key]
+            if (
+                key == "var_index" and self._sdata.tables[accessor].var.index is None
+            ) or (
+                key != "var_index"
+                and key not in self._sdata.tables[accessor].obs.columns
+            ):
+                raise ValueError(f"key '{key}' not present in '{accessor}'!")
 
-        for k in keys:
-            values, field = self._non_validated_values_field(k)
-            if len(values) == 0:
-                continue
-            if k in self._valid_var_keys:
-                ms, _, slot_key = k.partition("__")
-                slot = lambda experiment: experiment.ms[ms].var  # noqa: B023
-            else:
-                slot = lambda experiment: experiment.obs
-                slot_key = k
-            # errors if public ontology and the model has no organism
-            # has to be fixed in bionty
-            organism = check_registry_organism(field.field.model, self._organism).get(
-                "organism"
-            )
-            syn_mapper = standardize_categories(
-                values=values,
-                field=field,
-                source=self._sources.get(k),
-                organism=organism,
-            )
-            if (n_syn_mapper := len(syn_mapper)) == 0:
-                continue
+        if accessor in self._table_adata_curators.keys():
+            adata_curator = self._table_adata_curators[accessor]
+            adata_curator.standardize(key)
+        if accessor == self._sample_metadata_key:
+            self._sample_df_curator.standardize(key)
 
-            from lamindb.core.storage._tiledbsoma import _open_tiledbsoma
+        if len(self.non_validated[accessor].values()) == 0:
+            self.non_validated.pop(accessor)
 
-            with _open_tiledbsoma(self._dataset, mode="r") as experiment:
-                value_filter = f"{slot_key} in {list(syn_mapper.keys())}"
-                table = slot(experiment).read(value_filter=value_filter).concat()
+    def validate(self) -> bool:
+        """Validate variables and categorical observations.
 
-            if len(table) == 0:
-                continue
+        This method also registers the validated records in the current instance:
+        - from public sources
 
-            df = table.to_pandas()
-            # map values
-            df[slot_key] = df[slot_key].map(
-                lambda val: syn_mapper.get(val, val)  # noqa
-            )
-            # write the mapped values
-            with _open_tiledbsoma(self._dataset, mode="w") as experiment:
-                slot(experiment).write(pa.Table.from_pandas(df, schema=table.schema))
-            # update non_validated dict
-            non_val_k = [
-                nv for nv in self._non_validated_values[k] if nv not in syn_mapper
-            ]
-            self._non_validated_values[k] = non_val_k
+        Args:
+            organism: The organism name.
 
-            syn_mapper_print = _format_values(
-                [f'"{m_k}" → "{m_v}"' for m_k, m_v in syn_mapper.items()], sep=""
-            )
-            s = "s" if n_syn_mapper > 1 else ""
-            logger.success(
-                f'standardized {n_syn_mapper} synonym{s} in "{k}": {colors.green(syn_mapper_print)}'
-            )
+        Returns:
+            Whether the SpatialData object is validated.
+        """
+        # add all validated records to the current instance
+        self._update_registry_all()
+
+        self._non_validated = {}  # type: ignore
+
+        sample_validated = True
+        if self._sample_df_curator:
+            logger.info(f"validating categoricals of '{self._sample_metadata_key}' ...")
+            sample_validated &= self._sample_df_curator.validate()
+            if len(self._sample_df_curator.non_validated) > 0:
+                self._non_validated["sample"] = self._sample_df_curator.non_validated  # type: ignore
+            logger.print("")
+
+        mods_validated = True
+        for table, adata_curator in self._table_adata_curators.items():
+            logger.info(f"validating categoricals of table '{table}' ...")
+            mods_validated &= adata_curator.validate()
+            if len(adata_curator.non_validated) > 0:
+                self._non_validated[table] = adata_curator.non_validated  # type: ignore
+            logger.print("")
+
+        self._is_validated = sample_validated & mods_validated
+        return self._is_validated
 
     def save_artifact(
         self,
@@ -1725,424 +1882,373 @@ class TiledbsomaCatManager(CatManager):
         revises: Artifact | None = None,
         run: Run | None = None,
     ) -> Artifact:
-        """Save the validated `tiledbsoma` store and metadata.
+        """Save the validated SpatialData store and metadata.
 
         Args:
-            description: A description of the ``tiledbsoma`` store.
+            description: A description of the dataset.
             key: A path-like key to reference artifact in default storage,
-                e.g., `"myfolder/mystore.tiledbsoma"`. Artifacts with the same key form a version family.
+                e.g., `"myartifact.zarr"`. Artifacts with the same key form a version family.
             revises: Previous version of the artifact. Triggers a revision.
             run: The run that creates the artifact.
 
         Returns:
             A saved artifact record.
         """
-        from lamindb.models.artifact import add_labels
-
         if not self._is_validated:
             self.validate()
             if not self._is_validated:
                 raise ValidationError("Dataset does not validate. Please curate.")
 
-        if self._artifact is None:
-            artifact = Artifact(
-                self._dataset,
-                description=description,
-                key=key,
-                revises=revises,
-                run=run,
-            )
-            artifact.n_observations = self._n_obs
-            artifact.otype = "tiledbsoma"
-            artifact.save()
-        else:
-            artifact = self._artifact
-
-        feature_sets = {}
-        if len(self._obs_fields) > 0:
-            organism = check_registry_organism(
-                self._columns_field.field.model, self._organism
-            ).get("organism")
-            empty_dict = {field.name: [] for field in self._obs_pa_schema}  # type: ignore
-            mock_df = pa.Table.from_pydict(
-                empty_dict, schema=self._obs_pa_schema
-            ).to_pandas()
-            # in parallel to https://github.com/laminlabs/lamindb/blob/2a1709990b5736b480c6de49c0ada47fafc8b18d/lamindb/core/_feature_manager.py#L549-L554
-            feature_sets["obs"] = Schema.from_df(
-                df=mock_df,
-                field=self._columns_field,
-                mute=True,
-                organism=organism,
-            )
-        for ms in self._var_fields:
-            var_key, var_field = self._var_fields[ms]
-            organism = check_registry_organism(
-                var_field.field.model, self._organism
-            ).get("organism")
-            feature_sets[f"{ms}__var"] = Schema.from_values(
-                values=self._validated_values[f"{ms}__{var_key}"],
-                field=var_field,
-                organism=organism,
-                raise_validation_error=False,
-            )
-        artifact._staged_feature_sets = feature_sets
-
-        feature_ref_is_name = _ref_is_name(self._columns_field)
-        features = Feature.lookup().dict()
-        for key, field in self._obs_fields.items():
-            feature = features.get(key)
-            registry = field.field.model
-            organism = check_registry_organism(field.field.model, self._organism).get(
-                "organism"
-            )
-            labels = registry.from_values(
-                values=self._validated_values[key], field=field, organism=organism
-            )
-            if len(labels) == 0:
-                continue
-            if hasattr(registry, "_name_field"):
-                label_ref_is_name = field.field.name == registry._name_field
-                add_labels(
-                    artifact,
-                    records=labels,
-                    feature=feature,
-                    feature_ref_is_name=feature_ref_is_name,
-                    label_ref_is_name=label_ref_is_name,
-                    from_curator=True,
-                )
-
-        return artifact.save()
-
-
-class SpatialDataCatManager(CatManager):
-    """Curation flow for a ``Spatialdata`` object.
-
-    See also :class:`~lamindb.Curator`.
-
-    Note that if genes or other measurements are removed from the SpatialData object,
-    the object should be recreated.
-
-    In the following docstring, an accessor refers to either a ``.table`` key or the ``sample_metadata_key``.
+        return save_artifact(
+            self._sdata,
+            description=description,
+            fields=self.categoricals,
+            index_field=self.var_index,
+            key=key,
+            artifact=self._artifact,
+            revises=revises,
+            run=run,
+            schema=None,
+            organism=self._organism,
+            sample_metadata_key=self._sample_metadata_key,
+        )
 
-    Args:
-        sdata: The SpatialData object to curate.
-        var_index: A dictionary mapping table keys to the ``.var`` indices.
-        categoricals: A nested dictionary mapping an accessor to dictionaries that map columns to a registry field.
 
-        organism: The organism name.
-        sources: A dictionary mapping an accessor to dictionaries that map columns to Source records.
-        exclude: A dictionary mapping an accessor to dictionaries of column names to values to exclude from validation.
-            When specific :class:`~bionty.Source` instances are pinned and may lack default values (e.g., "unknown" or "na"),
-            using the exclude parameter ensures they are not validated.
-        verbosity: The verbosity level of the logger.
-        sample_metadata_key: The key in ``.attrs`` that stores the sample level metadata.
-
-    Examples:
-        >>> import bionty as bt
-        >>> curator = SpatialDataCatManager(
-        ...     sdata,
-        ...     var_index={
-        ...         "table_1": bt.Gene.ensembl_gene_id,
-        ...     },
-        ...     categoricals={
-        ...         "table1":
-        ...             {"cell_type_ontology_id": bt.CellType.ontology_id, "donor_id": ULabel.name},
-        ...         "sample":
-        ...             {"experimental_factor": bt.ExperimentalFactor.name},
-        ...     },
-        ...     organism="human",
-        ... )
-    """
+class TiledbsomaCatManager(CatManager):
+    """Categorical manager for `tiledbsoma.Experiment`."""
 
     def __init__(
         self,
-        sdata: Any,
-        var_index: dict[str, FieldAttr],
-        categoricals: dict[str, dict[str, FieldAttr]] | None = None,
-        verbosity: str = "hint",
+        experiment_uri: UPathStr | Artifact,
+        var_index: dict[str, tuple[str, FieldAttr]],
+        categoricals: dict[str, FieldAttr] | None = None,
+        obs_columns: FieldAttr = Feature.name,
         organism: str | None = None,
-        sources: dict[str, dict[str, Record]] | None = None,
-        exclude: dict[str, dict] | None = None,
-        *,
-        sample_metadata_key: str | None = "sample",
-    ) -> None:
-        super().__init__(
-            dataset=sdata,
-            categoricals={},
-            sources=sources,
-            organism=organism,
-            exclude=exclude,
-        )
-        if isinstance(sdata, Artifact):
-            # TODO: load() doesn't yet work
-            self._sdata = sdata.load()
-        else:
-            self._sdata = self._dataset
-        self._sample_metadata_key = sample_metadata_key
-        self._write_path = None
+        sources: dict[str, Record] | None = None,
+    ):
+        self._obs_fields = categoricals or {}
         self._var_fields = var_index
-        self._verify_accessor_exists(self._var_fields.keys())
-        self._categoricals = categoricals
-        self._table_keys = set(self._var_fields.keys()) | set(
-            self._categoricals.keys() - {self._sample_metadata_key}
-        )
-        self._verbosity = verbosity
-        self._sample_df_curator = None
-        if self._sample_metadata_key is not None:
-            self._sample_metadata = self._sdata.get_attrs(
-                key=self._sample_metadata_key, return_as="df", flatten=True
-            )
-        self._is_validated = False
-
-        # Check validity of keys in categoricals
-        nonval_keys = []
-        for accessor, accessor_categoricals in self._categoricals.items():
-            if (
-                accessor == self._sample_metadata_key
-                and self._sample_metadata is not None
-            ):
-                for key in accessor_categoricals.keys():
-                    if key not in self._sample_metadata.columns:
-                        nonval_keys.append(key)
-            else:
-                for key in accessor_categoricals.keys():
-                    if key not in self._sdata[accessor].obs.columns:
-                        nonval_keys.append(key)
-
-        _maybe_curation_keys_not_present(nonval_keys, "categoricals")
-
-        # check validity of keys in sources and exclude
-        for name, dct in (("sources", self._sources), ("exclude", self._exclude)):
-            nonval_keys = []
-            for accessor, accessor_sources in dct.items():
-                if (
-                    accessor == self._sample_metadata_key
-                    and self._sample_metadata is not None
-                ):
-                    columns = self._sample_metadata.columns
-                elif accessor != self._sample_metadata_key:
-                    columns = self._sdata[accessor].obs.columns
-                else:
-                    continue
-                for key in accessor_sources:
-                    if key not in columns:
-                        nonval_keys.append(key)
-            _maybe_curation_keys_not_present(nonval_keys, name)
+        self._columns_field = obs_columns
+        if isinstance(experiment_uri, Artifact):
+            self._dataset = experiment_uri.path
+            self._artifact = experiment_uri
+        else:
+            self._dataset = UPath(experiment_uri)
+            self._artifact = None
+        self._organism = organism
+        self._sources = sources or {}
 
-        # Set up sample level metadata and table Curator objects
-        if (
-            self._sample_metadata_key is not None
-            and self._sample_metadata_key in self._categoricals
-        ):
-            self._sample_df_curator = DataFrameCatManager(
-                df=self._sample_metadata,
-                columns=Feature.name,
-                categoricals=self._categoricals.get(self._sample_metadata_key, {}),
-                verbosity=verbosity,
-                sources=self._sources.get(self._sample_metadata_key),
-                exclude=self._exclude.get(self._sample_metadata_key),
-                organism=organism,
-            )
-        self._table_adata_curators = {
-            table: AnnDataCatManager(
-                data=self._sdata[table],
-                var_index=var_index.get(table),
-                categoricals=self._categoricals.get(table),
-                verbosity=verbosity,
-                sources=self._sources.get(table),
-                exclude=self._exclude.get(table),
-                organism=organism,
-            )
-            for table in self._table_keys
-        }
+        self._is_validated: bool | None = False
+        self._non_validated_values: dict[str, list] | None = None
+        self._validated_values: dict[str, list] = {}
+        # filled by _check_save_keys
+        self._n_obs: int | None = None
+        self._valid_obs_keys: list[str] | None = None
+        self._obs_pa_schema: pa.lib.Schema | None = (
+            None  # this is needed to create the obs feature set
+        )
+        self._valid_var_keys: list[str] | None = None
+        self._var_fields_flat: dict[str, FieldAttr] | None = None
+        self._check_save_keys()
 
-        self._non_validated = None
+    # check that the provided keys in var_index and categoricals are available in the store
+    # and save features
+    def _check_save_keys(self):
+        from lamindb.core.storage._tiledbsoma import _open_tiledbsoma
 
-    @property
-    def var_index(self) -> FieldAttr:
-        """Return the registry fields to validate variables indices against."""
-        return self._var_fields
+        with _open_tiledbsoma(self._dataset, mode="r") as experiment:
+            experiment_obs = experiment.obs
+            self._n_obs = len(experiment_obs)
+            self._obs_pa_schema = experiment_obs.schema
+            valid_obs_keys = [
+                k for k in self._obs_pa_schema.names if k != "soma_joinid"
+            ]
+            self._valid_obs_keys = valid_obs_keys
 
-    @property
-    def categoricals(self) -> dict[str, dict[str, FieldAttr]]:
-        """Return the categorical keys and fields to validate against."""
-        return self._categoricals
+            valid_var_keys = []
+            ms_list = []
+            for ms in experiment.ms.keys():
+                ms_list.append(ms)
+                var_ms = experiment.ms[ms].var
+                valid_var_keys += [
+                    f"{ms}__{k}" for k in var_ms.keys() if k != "soma_joinid"
+                ]
+            self._valid_var_keys = valid_var_keys
 
-    @property
-    def non_validated(self) -> dict[str, dict[str, list[str]]]:  # type: ignore
-        """Return the non-validated features and labels."""
-        if self._non_validated is None:
-            raise ValidationError("Please run validate() first!")
-        return self._non_validated
+        # check validity of keys in categoricals
+        nonval_keys = []
+        for obs_key in self._obs_fields.keys():
+            if obs_key not in valid_obs_keys:
+                nonval_keys.append(obs_key)
+        _maybe_curation_keys_not_present(nonval_keys, "categoricals")
 
-    def _verify_accessor_exists(self, accessors: Iterable[str]) -> None:
-        """Verify that the accessors exist (either a valid table or in attrs)."""
-        for acc in accessors:
-            is_present = False
-            try:
-                self._sdata.get_attrs(key=acc)
-                is_present = True
-            except KeyError:
-                if acc in self._sdata.tables.keys():
-                    is_present = True
-            if not is_present:
-                raise ValidationError(f"Accessor '{acc}' does not exist!")
+        # check validity of keys in var_index
+        self._var_fields_flat = {}
+        nonval_keys = []
+        for ms_key in self._var_fields.keys():
+            var_key, var_field = self._var_fields[ms_key]
+            var_key_flat = f"{ms_key}__{var_key}"
+            if var_key_flat not in valid_var_keys:
+                nonval_keys.append(f"({ms_key}, {var_key})")
+            else:
+                self._var_fields_flat[var_key_flat] = var_field
+        _maybe_curation_keys_not_present(nonval_keys, "var_index")
 
-    def lookup(self, public: bool = False) -> CurateLookup:
-        """Look up categories.
+        # check validity of keys in sources
+        valid_arg_keys = valid_obs_keys + valid_var_keys + ["columns"]
+        nonval_keys = []
+        for arg_key in self._sources.keys():
+            if arg_key not in valid_arg_keys:
+                nonval_keys.append(arg_key)
+        _maybe_curation_keys_not_present(nonval_keys, "sources")
 
-        Args:
-            public: Whether the lookup is performed on the public reference.
-        """
-        cat_values_dict = list(self.categoricals.values())[0]
-        return CurateLookup(
-            categoricals=cat_values_dict,
-            slots={"accessors": cat_values_dict.keys()},
-            public=public,
+        # register obs columns' names
+        register_columns = list(self._obs_fields.keys())
+        update_registry(
+            values=register_columns,
+            field=self._columns_field,
+            key="columns",
+            validated_only=False,
+            organism=self._organism,
+            source=self._sources.get("columns"),
         )
-
-    def _update_registry_all(self) -> None:
-        """Saves labels of all features for sample and table metadata."""
-        if self._sample_df_curator is not None:
-            self._sample_df_curator._update_registry_all(
-                validated_only=True,
-            )
-        for _, adata_curator in self._table_adata_curators.items():
-            adata_curator._obs_df_curator._update_registry_all(
+        additional_columns = [k for k in valid_obs_keys if k not in register_columns]
+        # no need to register with validated_only=True if columns are features
+        if (
+            len(additional_columns) > 0
+            and self._columns_field.field.model is not Feature
+        ):
+            update_registry(
+                values=additional_columns,
+                field=self._columns_field,
+                key="columns",
                 validated_only=True,
+                organism=self._organism,
+                source=self._sources.get("columns"),
             )
 
-    def add_new_from_var_index(self, table: str, **kwargs) -> None:
-        """Save new values from ``.var.index`` of table.
+    def validate(self):
+        """Validate categories."""
+        from lamindb.core.storage._tiledbsoma import _open_tiledbsoma
 
-        Args:
-            table: The table key.
-            organism: The organism name.
-            **kwargs: Additional keyword arguments to pass to create new records.
-        """
-        if self._non_validated is None:
-            raise ValidationError("Run .validate() first.")
-        self._table_adata_curators[table].add_new_from_var_index(**kwargs)
-        if table in self.non_validated.keys():
-            if "var_index" in self._non_validated[table]:
-                self._non_validated[table].pop("var_index")
+        validated = True
+        self._non_validated_values = {}
+        with _open_tiledbsoma(self._dataset, mode="r") as experiment:
+            for ms, (key, field) in self._var_fields.items():
+                var_ms = experiment.ms[ms].var
+                var_ms_key = f"{ms}__{key}"
+                # it was already validated and cached
+                if var_ms_key in self._validated_values:
+                    continue
+                var_ms_values = (
+                    var_ms.read(column_names=[key]).concat()[key].to_pylist()
+                )
+                update_registry(
+                    values=var_ms_values,
+                    field=field,
+                    key=var_ms_key,
+                    validated_only=True,
+                    organism=self._organism,
+                    source=self._sources.get(var_ms_key),
+                )
+                _, non_val = validate_categories(
+                    values=var_ms_values,
+                    field=field,
+                    key=var_ms_key,
+                    organism=self._organism,
+                    source=self._sources.get(var_ms_key),
+                )
+                if len(non_val) > 0:
+                    validated = False
+                    self._non_validated_values[var_ms_key] = non_val
+                else:
+                    self._validated_values[var_ms_key] = var_ms_values
+
+            obs = experiment.obs
+            for key, field in self._obs_fields.items():
+                # already validated and cached
+                if key in self._validated_values:
+                    continue
+                values = pa.compute.unique(
+                    obs.read(column_names=[key]).concat()[key]
+                ).to_pylist()
+                update_registry(
+                    values=values,
+                    field=field,
+                    key=key,
+                    validated_only=True,
+                    organism=self._organism,
+                    source=self._sources.get(key),
+                )
+                _, non_val = validate_categories(
+                    values=values,
+                    field=field,
+                    key=key,
+                    organism=self._organism,
+                    source=self._sources.get(key),
+                )
+                if len(non_val) > 0:
+                    validated = False
+                    self._non_validated_values[key] = non_val
+                else:
+                    self._validated_values[key] = values
+        self._is_validated = validated
+        return self._is_validated
+
+    def _non_validated_values_field(self, key: str) -> tuple[list, FieldAttr]:
+        assert self._non_validated_values is not None  # noqa: S101
 
-            if len(self.non_validated[table].values()) == 0:
-                self.non_validated.pop(table)
+        if key in self._valid_obs_keys:
+            field = self._obs_fields[key]
+        elif key in self._valid_var_keys:
+            ms = key.partition("__")[0]
+            field = self._var_fields[ms][1]
+        else:
+            raise KeyError(f"key {key} is invalid!")
+        values = self._non_validated_values.get(key, [])
+        return values, field
 
-    def add_new_from(
-        self,
-        key: str,
-        accessor: str | None = None,
-        **kwargs,
-    ) -> None:
-        """Save new values of categorical from sample level metadata or table.
+    def add_new_from(self, key: str, **kwargs) -> None:
+        """Add validated & new categories.
 
         Args:
-            key: The key referencing the slot in the DataFrame.
-            accessor: The accessor key such as 'sample' or 'table x'.
-            organism: The organism name.
-            **kwargs: Additional keyword arguments to pass to create new records.
+            key: The key referencing the slot in the `tiledbsoma` store.
+                It should be `'{measurement name}__{column name in .var}'` for columns in `.var`
+                or a column name in `.obs`.
         """
-        if self._non_validated is None:
+        if self._non_validated_values is None:
             raise ValidationError("Run .validate() first.")
+        if key == "all":
+            keys = list(self._non_validated_values.keys())
+        else:
+            avail_keys = list(
+                chain(self._non_validated_values.keys(), self._validated_values.keys())
+            )
+            if key not in avail_keys:
+                raise KeyError(
+                    f"'{key!r}' is not a valid key, available keys are: {_format_values(avail_keys + ['all'])}!"
+                )
+            keys = [key]
+        for k in keys:
+            values, field = self._non_validated_values_field(k)
+            if len(values) == 0:
+                continue
+            update_registry(
+                values=values,
+                field=field,
+                key=k,
+                validated_only=False,
+                organism=self._organism,
+                source=self._sources.get(k),
+                **kwargs,
+            )
+            # update non-validated values list but keep the key there
+            # it will be removed by .validate()
+            if k in self._non_validated_values:
+                self._non_validated_values[k] = []
 
-        if len(kwargs) > 0 and key == "all":
-            raise ValueError("Cannot pass additional arguments to 'all' key!")
+    @property
+    def non_validated(self) -> dict[str, list]:
+        """Return the non-validated features and labels."""
+        non_val = {k: v for k, v in self._non_validated_values.items() if v != []}
+        return non_val
 
-        if accessor not in self.categoricals:
-            raise ValueError(
-                f"Accessor {accessor} is not in 'categoricals'. Include it when creating the SpatialDataCatManager."
-            )
+    @property
+    def var_index(self) -> dict[str, FieldAttr]:
+        """Return the registry fields with flattened keys to validate variables indices against."""
+        return self._var_fields_flat
 
-        if accessor in self._table_adata_curators:
-            adata_curator = self._table_adata_curators[accessor]
-            adata_curator.add_new_from(key=key, **kwargs)
-        if accessor == self._sample_metadata_key:
-            self._sample_df_curator.add_new_from(key=key, **kwargs)
+    @property
+    def categoricals(self) -> dict[str, FieldAttr]:
+        """Return the obs fields to validate against."""
+        return self._obs_fields
 
-        if accessor in self.non_validated.keys():
-            if len(self.non_validated[accessor].values()) == 0:
-                self.non_validated.pop(accessor)
+    def lookup(self, public: bool = False) -> CatLookup:
+        """Lookup categories.
 
-    def standardize(self, key: str, accessor: str | None = None) -> None:
-        """Replace synonyms with canonical values.
+        Args:
+            public: If "public", the lookup is performed on the public reference.
+        """
+        return CatLookup(
+            categoricals=self._obs_fields,
+            slots={"columns": self._columns_field, **self._var_fields_flat},
+            public=public,
+            organism=self._organism,
+            sources=self._sources,
+        )
+
+    def standardize(self, key: str):
+        """Replace synonyms with standardized values.
 
         Modifies the dataset inplace.
 
         Args:
-            key: The key referencing the slot in the table or sample metadata.
-            accessor: The accessor key such as 'sample_key' or 'table_key'.
+            key: The key referencing the slot in the `tiledbsoma` store.
+                It should be `'{measurement name}__{column name in .var}'` for columns in `.var`
+                or a column name in `.obs`.
         """
         if len(self.non_validated) == 0:
             logger.warning("values are already standardized")
             return
-        if self._artifact is not None:
-            raise RuntimeError("can't mutate the dataset when an artifact is passed!")
-
-        if accessor == self._sample_metadata_key:
-            if key not in self._sample_metadata.columns:
-                raise ValueError(f"key '{key}' not present in '{accessor}'!")
+        avail_keys = list(self._non_validated_values.keys())
+        if key == "all":
+            keys = avail_keys
         else:
-            if (
-                key == "var_index" and self._sdata.tables[accessor].var.index is None
-            ) or (
-                key != "var_index"
-                and key not in self._sdata.tables[accessor].obs.columns
-            ):
-                raise ValueError(f"key '{key}' not present in '{accessor}'!")
-
-        if accessor in self._table_adata_curators.keys():
-            adata_curator = self._table_adata_curators[accessor]
-            adata_curator.standardize(key)
-        if accessor == self._sample_metadata_key:
-            self._sample_df_curator.standardize(key)
-
-        if len(self.non_validated[accessor].values()) == 0:
-            self.non_validated.pop(accessor)
-
-    def validate(self) -> bool:
-        """Validate variables and categorical observations.
-
-        This method also registers the validated records in the current instance:
-        - from public sources
-
-        Args:
-            organism: The organism name.
+            if key not in avail_keys:
+                raise KeyError(
+                    f"'{key!r}' is not a valid key, available keys are: {_format_values(avail_keys + ['all'])}!"
+                )
+            keys = [key]
 
-        Returns:
-            Whether the SpatialData object is validated.
-        """
-        from lamindb.core._settings import settings
+        for k in keys:
+            values, field = self._non_validated_values_field(k)
+            if len(values) == 0:
+                continue
+            if k in self._valid_var_keys:
+                ms, _, slot_key = k.partition("__")
+                slot = lambda experiment: experiment.ms[ms].var  # noqa: B023
+            else:
+                slot = lambda experiment: experiment.obs
+                slot_key = k
+            syn_mapper = standardize_categories(
+                values=values,
+                field=field,
+                source=self._sources.get(k),
+                organism=self._organism,
+            )
+            if (n_syn_mapper := len(syn_mapper)) == 0:
+                continue
 
-        # add all validated records to the current instance
-        verbosity = settings.verbosity
-        try:
-            settings.verbosity = "error"
-            self._update_registry_all()
-        finally:
-            settings.verbosity = verbosity
+            from lamindb.core.storage._tiledbsoma import _open_tiledbsoma
 
-        self._non_validated = {}  # type: ignore
+            with _open_tiledbsoma(self._dataset, mode="r") as experiment:
+                value_filter = f"{slot_key} in {list(syn_mapper.keys())}"
+                table = slot(experiment).read(value_filter=value_filter).concat()
 
-        sample_validated = True
-        if self._sample_df_curator:
-            logger.info(f"validating categoricals of '{self._sample_metadata_key}' ...")
-            sample_validated &= self._sample_df_curator.validate()
-            if len(self._sample_df_curator.non_validated) > 0:
-                self._non_validated["sample"] = self._sample_df_curator.non_validated  # type: ignore
-            logger.print("")
+            if len(table) == 0:
+                continue
 
-        mods_validated = True
-        for table, adata_curator in self._table_adata_curators.items():
-            logger.info(f"validating categoricals of table '{table}' ...")
-            mods_validated &= adata_curator.validate()
-            if len(adata_curator.non_validated) > 0:
-                self._non_validated[table] = adata_curator.non_validated  # type: ignore
-            logger.print("")
+            df = table.to_pandas()
+            # map values
+            df[slot_key] = df[slot_key].map(
+                lambda val: syn_mapper.get(val, val)  # noqa
+            )
+            # write the mapped values
+            with _open_tiledbsoma(self._dataset, mode="w") as experiment:
+                slot(experiment).write(pa.Table.from_pandas(df, schema=table.schema))
+            # update non_validated dict
+            non_val_k = [
+                nv for nv in self._non_validated_values[k] if nv not in syn_mapper
+            ]
+            self._non_validated_values[k] = non_val_k
 
-        self._is_validated = sample_validated & mods_validated
-        return self._is_validated
+            syn_mapper_print = _format_values(
+                [f'"{m_k}" → "{m_v}"' for m_k, m_v in syn_mapper.items()], sep=""
+            )
+            s = "s" if n_syn_mapper > 1 else ""
+            logger.success(
+                f'standardized {n_syn_mapper} synonym{s} in "{k}": {colors.green(syn_mapper_print)}'
+            )
 
     def save_artifact(
         self,
@@ -2152,217 +2258,112 @@ class SpatialDataCatManager(CatManager):
         revises: Artifact | None = None,
         run: Run | None = None,
     ) -> Artifact:
+        """Save the validated `tiledbsoma` store and metadata.
+
+        Args:
+            description: A description of the ``tiledbsoma`` store.
+            key: A path-like key to reference artifact in default storage,
+                e.g., `"myfolder/mystore.tiledbsoma"`. Artifacts with the same key form a version family.
+            revises: Previous version of the artifact. Triggers a revision.
+            run: The run that creates the artifact.
+
+        Returns:
+            A saved artifact record.
+        """
         if not self._is_validated:
             self.validate()
             if not self._is_validated:
                 raise ValidationError("Dataset does not validate. Please curate.")
 
-        verbosity = settings.verbosity
-        try:
-            settings.verbosity = "warning"
-
-            self._artifact = Artifact.from_spatialdata(
-                self._sdata,
-                key=key,
+        if self._artifact is None:
+            artifact = Artifact(
+                self._dataset,
                 description=description,
+                key=key,
                 revises=revises,
                 run=run,
             )
-            self._artifact.save()
+            artifact.n_observations = self._n_obs
+            artifact.otype = "tiledbsoma"
+            artifact.save()
+        else:
+            artifact = self._artifact
+
+        feature_sets = {}
+        if len(self._obs_fields) > 0:
+            empty_dict = {field.name: [] for field in self._obs_pa_schema}  # type: ignore
+            mock_df = pa.Table.from_pydict(
+                empty_dict, schema=self._obs_pa_schema
+            ).to_pandas()
+            # in parallel to https://github.com/laminlabs/lamindb/blob/2a1709990b5736b480c6de49c0ada47fafc8b18d/lamindb/core/_feature_manager.py#L549-L554
+            feature_sets["obs"] = Schema.from_df(
+                df=mock_df,
+                field=self._columns_field,
+                mute=True,
+                organism=self._organism,
+            )
+        for ms in self._var_fields:
+            var_key, var_field = self._var_fields[ms]
+            feature_sets[f"{ms}__var"] = Schema.from_values(
+                values=self._validated_values[f"{ms}__{var_key}"],
+                field=var_field,
+                organism=self._organism,
+                raise_validation_error=False,
+            )
+        artifact._staged_feature_sets = feature_sets
 
-            # Link schemas
-            feature_kwargs = check_registry_organism(
-                (list(self._var_fields.values())[0].field.model),
-                self._organism,
+        feature_ref_is_name = _ref_is_name(self._columns_field)
+        features = Feature.lookup().dict()
+        for key, field in self._obs_fields.items():
+            feature = features.get(key)
+            registry = field.field.model
+            labels = registry.from_values(
+                values=self._validated_values[key],
+                field=field,
+                organism=self._organism,
             )
-
-            def _add_set_from_spatialdata(
-                host: Artifact | Collection | Run,
-                var_fields: dict[str, FieldAttr],
-                obs_fields: dict[str, FieldAttr] = None,
-                mute: bool = False,
-                organism: str | Record | None = None,
-            ):
-                """Add Schemas from SpatialData."""
-                if obs_fields is None:
-                    obs_fields = {}
-                assert host.otype == "SpatialData"  # noqa: S101
-
-                feature_sets = {}
-
-                # sample features
-                sample_features = Feature.from_values(self._sample_metadata.columns)  # type: ignore
-                if len(sample_features) > 0:
-                    feature_sets[self._sample_metadata_key] = Schema(
-                        features=sample_features
-                    )
-
-                # table features
-                for table, field in var_fields.items():
-                    table_fs = parse_staged_feature_sets_from_anndata(
-                        self._sdata[table],
-                        var_field=field,
-                        obs_field=obs_fields.get(table, Feature.name),
-                        mute=mute,
-                        organism=organism,
-                    )
-                    for k, v in table_fs.items():
-                        feature_sets[f"['{table}'].{k}"] = v
-
-                def _unify_staged_feature_sets_by_hash(
-                    feature_sets: MutableMapping[str, Schema],
-                ):
-                    unique_values: dict[str, Any] = {}
-
-                    for key, value in feature_sets.items():
-                        value_hash = (
-                            value.hash
-                        )  # Assuming each value has a .hash attribute
-                        if value_hash in unique_values:
-                            feature_sets[key] = unique_values[value_hash]
-                        else:
-                            unique_values[value_hash] = value
-
-                    return feature_sets
-
-                # link feature sets
-                host._staged_feature_sets = _unify_staged_feature_sets_by_hash(
-                    feature_sets
+            if len(labels) == 0:
+                continue
+            if hasattr(registry, "_name_field"):
+                label_ref_is_name = field.field.name == registry._name_field
+                add_labels(
+                    artifact,
+                    records=labels,
+                    feature=feature,
+                    feature_ref_is_name=feature_ref_is_name,
+                    label_ref_is_name=label_ref_is_name,
+                    from_curator=True,
                 )
-                host.save()
-
-            _add_set_from_spatialdata(
-                self._artifact, var_fields=self._var_fields, **feature_kwargs
-            )
-
-            # Link labels
-            def _add_labels_from_spatialdata(
-                data,
-                artifact: Artifact,
-                fields: dict[str, FieldAttr],
-                feature_ref_is_name: bool | None = None,
-            ):
-                """Add Labels from SpatialData."""
-                features = Feature.lookup().dict()
-                for key, field in fields.items():
-                    feature = features.get(key)
-                    registry = field.field.model
-                    filter_kwargs = check_registry_organism(registry, self._organism)
-                    filter_kwargs_current = get_current_filter_kwargs(
-                        registry, filter_kwargs
-                    )
-                    df = data if isinstance(data, pd.DataFrame) else data.obs
-                    labels = registry.from_values(
-                        df[key],
-                        field=field,
-                        **filter_kwargs_current,
-                    )
-                    if len(labels) == 0:
-                        continue
 
-                    label_ref_is_name = None
-                    if hasattr(registry, "_name_field"):
-                        label_ref_is_name = field.field.name == registry._name_field
-                    add_labels(
-                        artifact,
-                        records=labels,
-                        feature=feature,
-                        feature_ref_is_name=feature_ref_is_name,
-                        label_ref_is_name=label_ref_is_name,
-                        from_curator=True,
-                    )
-
-            for accessor, accessor_fields in self._categoricals.items():
-                column_field = self._var_fields.get(accessor)
-                if accessor == self._sample_metadata_key:
-                    _add_labels_from_spatialdata(
-                        self._sample_metadata,
-                        self._artifact,
-                        accessor_fields,
-                        feature_ref_is_name=(
-                            None if column_field is None else _ref_is_name(column_field)
-                        ),
-                    )
-                else:
-                    _add_labels_from_spatialdata(
-                        self._sdata.tables[accessor],
-                        self._artifact,
-                        accessor_fields,
-                        feature_ref_is_name=(
-                            None if column_field is None else _ref_is_name(column_field)
-                        ),
-                    )
-
-        finally:
-            settings.verbosity = verbosity
-
-        slug = ln_setup.settings.instance.slug
-        if ln_setup.settings.instance.is_remote:  # pragma: no cover
-            logger.important(
-                f"go to https://lamin.ai/{slug}/artifact/{self._artifact.uid}"
-            )
-
-        return self._artifact
+        return artifact.save()
 
 
-def _restrict_obs_fields(
-    obs: pd.DataFrame, obs_fields: dict[str, FieldAttr]
-) -> dict[str, str]:
-    """Restrict the obs fields to name return only available obs fields.
+class CellxGeneAnnDataCatManager(AnnDataCatManager):
+    """Categorical manager for `AnnData` respecting the CELLxGENE schema.
 
-    To simplify the curation, we only validate against either name or ontology_id.
-    If both are available, we validate against ontology_id.
-    If none are available, we validate against name.
+    This will be superceded by a schema-based curation flow.
     """
-    obs_fields_unique = {k: v for k, v in obs_fields.items() if k in obs.columns}
-    for name, field in obs_fields.items():
-        if name.endswith("_ontology_term_id"):
-            continue
-        # if both the ontology id and the name are present, only validate on the ontology_id
-        if name in obs.columns and f"{name}_ontology_term_id" in obs.columns:
-            obs_fields_unique.pop(name)
-        # if the neither name nor ontology id are present, validate on the name
-        # this will raise error downstream, we just use name to be more readable
-        if name not in obs.columns and f"{name}_ontology_term_id" not in obs.columns:
-            obs_fields_unique[name] = field
-
-    # Only retain obs_fields_unique that have keys in adata.obs.columns
-    available_obs_fields = {
-        k: v for k, v in obs_fields_unique.items() if k in obs.columns
-    }
-
-    return available_obs_fields
-
-
-def _add_defaults_to_obs(
-    obs: pd.DataFrame,
-    defaults: dict[str, str],
-) -> None:
-    """Add default columns and values to obs DataFrame."""
-    added_defaults: dict = {}
-    for name, default in defaults.items():
-        if name not in obs.columns and f"{name}_ontology_term_id" not in obs.columns:
-            obs[name] = default
-            added_defaults[name] = default
-            logger.important(
-                f"added default value '{default}' to the adata.obs['{name}']"
-            )
-
-
-class CellxGeneAnnDataCatManager(AnnDataCatManager):
-    """Annotation flow of AnnData based on CELLxGENE schema."""
 
-    _controls_were_created: bool | None = None
+    cxg_categoricals_defaults = {
+        "cell_type": "unknown",
+        "development_stage": "unknown",
+        "disease": "normal",
+        "donor_id": "unknown",
+        "self_reported_ethnicity": "unknown",
+        "sex": "unknown",
+        "suspension_type": "cell",
+        "tissue_type": "tissue",
+    }
 
     def __init__(
         self,
-        adata: ad.AnnData | UPathStr,
+        adata: ad.AnnData,
         categoricals: dict[str, FieldAttr] | None = None,
         organism: Literal["human", "mouse"] = "human",
         *,
+        schema_version: Literal["4.0.0", "5.0.0", "5.1.0", "5.2.0"] = "5.2.0",
         defaults: dict[str, str] = None,
         extra_sources: dict[str, Record] = None,
-        schema_version: Literal["4.0.0", "5.0.0", "5.1.0"] = "5.1.0",
         verbosity: str = "hint",
     ) -> None:
         """CELLxGENE schema curator.
@@ -2372,304 +2373,85 @@ class CellxGeneAnnDataCatManager(AnnDataCatManager):
             categoricals: A dictionary mapping ``.obs.columns`` to a registry field.
                 The CELLxGENE Curator maps against the required CELLxGENE fields by default.
             organism: The organism name. CELLxGENE restricts it to 'human' and 'mouse'.
+            schema_version: The CELLxGENE schema version to curate against.
             defaults: Default values that are set if columns or column values are missing.
             extra_sources: A dictionary mapping ``.obs.columns`` to Source records.
                 These extra sources are joined with the CELLxGENE fixed sources.
                 Use this parameter when subclassing.
-            exclude: A dictionary mapping column names to values to exclude.
-            schema_version: The CELLxGENE schema version to curate against.
             verbosity: The verbosity level.
-
         """
         import bionty as bt
 
-        CellxGeneAnnDataCatManager._init_categoricals_additional_values()
+        from ._cellxgene_schemas import (
+            _add_defaults_to_obs,
+            _create_sources,
+            _init_categoricals_additional_values,
+            _restrict_obs_fields,
+        )
 
-        var_index: FieldAttr = bt.Gene.ensembl_gene_id
+        # Add defaults first to ensure that we fetch valid sources
+        if defaults:
+            _add_defaults_to_obs(adata.obs, defaults)
 
+        # Filter categoricals based on what's present in adata
         if categoricals is None:
-            categoricals = CellxGeneAnnDataCatManager._get_categoricals()
+            categoricals = self._get_cxg_categoricals()
+        categoricals = _restrict_obs_fields(adata.obs, categoricals)
 
-        self.organism = organism
-
-        VALID_SCHEMA_VERSIONS = {"4.0.0", "5.0.0", "5.1.0"}
-        if schema_version not in VALID_SCHEMA_VERSIONS:
-            valid_versions = ", ".join(sorted(VALID_SCHEMA_VERSIONS))
-            raise ValueError(
-                f"Invalid schema_version: {schema_version}. "
-                f"Valid versions are: {valid_versions}"
-            )
+        # Configure sources
+        sources = _create_sources(categoricals, schema_version, organism)
         self.schema_version = schema_version
         self.schema_reference = f"https://github.com/chanzuckerberg/single-cell-curation/blob/main/schema/{schema_version}/schema.md"
-        with resources.path(
-            "lamindb.curators._cellxgene_schemas", "schema_versions.yml"
-        ) as schema_versions_path:
-            self._pinned_ontologies = _read_schema_versions(schema_versions_path)[
-                self.schema_version
-            ]
-
-        # Fetch AnnData obs to be able to set defaults and get sources
-        if isinstance(adata, ad.AnnData):
-            self._adata_obs = adata.obs
-        else:
-            self._adata_obs = backed_access(upath.create_path(adata)).obs  # type: ignore
-
-        # Add defaults first to ensure that we fetch valid sources
-        if defaults:
-            _add_defaults_to_obs(self._adata_obs, defaults)
-
-        self.sources = self._create_sources(self._adata_obs)
-        self.sources = {
-            entity: source
-            for entity, source in self.sources.items()
-            if source is not None
-        }
-
         # These sources are not a part of the cellxgene schema but rather passed through.
         # This is useful when other Curators extend the CELLxGENE curator
         if extra_sources:
-            self.sources = self.sources | extra_sources
+            sources = sources | extra_sources
 
-        # Exclude default values from validation because they are not available in the pinned sources
-        exclude_keys = {
-            entity: default
-            for entity, default in CellxGeneAnnDataCatManager._get_categoricals_defaults().items()
-            if entity in self._adata_obs.columns  # type: ignore
-        }
+        _init_categoricals_additional_values()
 
         super().__init__(
             data=adata,
-            var_index=var_index,
-            categoricals=_restrict_obs_fields(self._adata_obs, categoricals),
+            var_index=bt.Gene.ensembl_gene_id,
+            categoricals=categoricals,
             verbosity=verbosity,
             organism=organism,
-            sources=self.sources,
-            exclude=exclude_keys,
+            sources=sources,
         )
 
     @classmethod
-    def _init_categoricals_additional_values(cls) -> None:
-        import bionty as bt
-
-        import lamindb as ln
-
-        # Note: if you add another control below, be mindful to change the if condition that
-        # triggers whether creating these records is re-considered
-        if cls._controls_were_created is None:
-            cls._controls_were_created = (
-                ln.ULabel.filter(name="SuspensionType", is_type=True).one_or_none()
-                is not None
-            )
-        if not cls._controls_were_created:
-            logger.important("Creating control labels in the CellxGene schema.")
-            bt.CellType(
-                ontology_id="unknown",
-                name="unknown",
-                description="From CellxGene schema.",
-            ).save()
-            pato = bt.Source.filter(name="pato", version="2024-03-28").one()
-            normal = bt.Phenotype.from_source(ontology_id="PATO:0000461", source=pato)
-            bt.Disease(
-                uid=normal.uid,
-                name=normal.name,
-                ontology_id=normal.ontology_id,
-                description=normal.description,
-                source=normal.source,
-            ).save()
-            bt.Ethnicity(
-                ontology_id="na", name="na", description="From CellxGene schema."
-            ).save()
-            bt.Ethnicity(
-                ontology_id="unknown",
-                name="unknown",
-                description="From CellxGene schema.",
-            ).save()
-            bt.DevelopmentalStage(
-                ontology_id="unknown",
-                name="unknown",
-                description="From CellxGene schema.",
-            ).save()
-            bt.Phenotype(
-                ontology_id="unknown",
-                name="unknown",
-                description="From CellxGene schema.",
-            ).save()
-
-            tissue_type = ln.ULabel(
-                name="TissueType",
-                is_type=True,
-                description='From CellxGene schema. Is "tissue", "organoid", or "cell culture".',
-            ).save()
-            ln.ULabel(
-                name="tissue", type=tissue_type, description="From CellxGene schema."
-            ).save()
-            ln.ULabel(
-                name="organoid", type=tissue_type, description="From CellxGene schema."
-            ).save()
-            ln.ULabel(
-                name="cell culture",
-                type=tissue_type,
-                description="From CellxGene schema.",
-            ).save()
-
-            suspension_type = ln.ULabel(
-                name="SuspensionType",
-                is_type=True,
-                description='From CellxGene schema. This MUST be "cell", "nucleus", or "na".',
-            ).save()
-            ln.ULabel(
-                name="cell", type=suspension_type, description="From CellxGene schema."
-            ).save()
-            ln.ULabel(
-                name="nucleus",
-                type=suspension_type,
-                description="From CellxGene schema.",
-            ).save()
-            ln.ULabel(name="na", type=suspension_type).save()
-
-    @classmethod
-    def _get_categoricals(cls) -> dict[str, FieldAttr]:
-        import bionty as bt
-
-        return {
-            "assay": bt.ExperimentalFactor.name,
-            "assay_ontology_term_id": bt.ExperimentalFactor.ontology_id,
-            "cell_type": bt.CellType.name,
-            "cell_type_ontology_term_id": bt.CellType.ontology_id,
-            "development_stage": bt.DevelopmentalStage.name,
-            "development_stage_ontology_term_id": bt.DevelopmentalStage.ontology_id,
-            "disease": bt.Disease.name,
-            "disease_ontology_term_id": bt.Disease.ontology_id,
-            # "donor_id": "str",  via pandera
-            "self_reported_ethnicity": bt.Ethnicity.name,
-            "self_reported_ethnicity_ontology_term_id": bt.Ethnicity.ontology_id,
-            "sex": bt.Phenotype.name,
-            "sex_ontology_term_id": bt.Phenotype.ontology_id,
-            "suspension_type": ULabel.name,
-            "tissue": bt.Tissue.name,
-            "tissue_ontology_term_id": bt.Tissue.ontology_id,
-            "tissue_type": ULabel.name,
-            "organism": bt.Organism.name,
-            "organism_ontology_term_id": bt.Organism.ontology_id,
-        }
-
-    @classmethod
+    @deprecated(new_name="cxg_categoricals_defaults")
     def _get_categoricals_defaults(cls) -> dict[str, str]:
-        return {
-            "cell_type": "unknown",
-            "development_stage": "unknown",
-            "disease": "normal",
-            "donor_id": "unknown",
-            "self_reported_ethnicity": "unknown",
-            "sex": "unknown",
-            "suspension_type": "cell",
-            "tissue_type": "tissue",
-        }
-
-    @property
-    def pinned_ontologies(self) -> pd.DataFrame:
-        return self._pinned_ontologies
-
-    @property
-    def adata(self) -> AnnData:
-        return self._adata
-
-    def _create_sources(self, obs: pd.DataFrame) -> dict[str, Record]:
-        """Creates a sources dictionary that can be passed to AnnDataCatManager."""
-        import bionty as bt
-
-        # fmt: off
-        def _fetch_bionty_source(
-            entity: str, organism: str, source: str
-        ) -> bt.Source | None:
-            """Fetch the Bionty source of the pinned ontology.
-
-            Returns None if the source does not exist.
-            """
-            version = self._pinned_ontologies.loc[(self._pinned_ontologies.index == entity) &
-                                                  (self._pinned_ontologies["organism"] == organism) &
-                                                  (self._pinned_ontologies["source"] == source), "version"].iloc[0]
-            return bt.Source.filter(organism=organism, entity=f"bionty.{entity}", version=version).first()
-
-        entity_mapping = {
-             "var_index": ("Gene", self.organism, "ensembl"),
-             "cell_type": ("CellType", "all", "cl"),
-             "assay": ("ExperimentalFactor", "all", "efo"),
-             "self_reported_ethnicity": ("Ethnicity", self.organism, "hancestro"),
-             "development_stage": ("DevelopmentalStage", self.organism, "hsapdv" if self.organism == "human" else "mmusdv"),
-             "disease": ("Disease", "all", "mondo"),
-             # "organism": ("Organism", "vertebrates", "ensembl"),
-             "sex": ("Phenotype", "all", "pato"),
-             "tissue": ("Tissue", "all", "uberon"),
-        }
-        # fmt: on
-
-        # Retain var_index and one of 'entity'/'entity_ontology_term_id' that is present in obs
-        entity_to_sources = {
-            entity: _fetch_bionty_source(*params)
-            for entity, params in entity_mapping.items()
-            if entity in obs.columns
-            or (f"{entity}_ontology_term_id" in obs.columns and entity != "var_index")
-            or entity == "var_index"
-        }
-
-        return entity_to_sources
+        return cls.cxg_categoricals_defaults
 
-    def _convert_name_to_ontology_id(self, values: pd.Series, field: FieldAttr):
-        """Converts a column that stores a name into a column that stores the ontology id.
+    @classmethod
+    def _get_cxg_categoricals(cls) -> dict[str, FieldAttr]:
+        """Returns the CELLxGENE schema mapped fields."""
+        from ._cellxgene_schemas import _get_cxg_categoricals
 
-        cellxgene expects the obs columns to be {entity}_ontology_id columns and disallows {entity} columns.
-        """
-        field_name = field.field.name
-        assert field_name == "name"  # noqa: S101
-        cols = ["name", "ontology_id"]
-        registry = field.field.model
-
-        if hasattr(registry, "ontology_id"):
-            validated_records = registry.filter(**{f"{field_name}__in": values})
-            mapper = (
-                pd.DataFrame(validated_records.values_list(*cols))
-                .set_index(0)
-                .to_dict()[1]
-            )
-            return values.map(mapper)
+        return _get_cxg_categoricals()
 
-    def validate(self) -> bool:  # type: ignore
+    def validate(self) -> bool:
         """Validates the AnnData object against most cellxgene requirements."""
+        from ._cellxgene_schemas import RESERVED_NAMES
+
         # Verify that all required obs columns are present
+        required_columns = list(self.cxg_categoricals_defaults.keys()) + ["donor_id"]
         missing_obs_fields = [
             name
-            for name in CellxGeneAnnDataCatManager._get_categoricals_defaults().keys()
+            for name in required_columns
             if name not in self._adata.obs.columns
             and f"{name}_ontology_term_id" not in self._adata.obs.columns
         ]
         if len(missing_obs_fields) > 0:
-            missing_obs_fields_str = ", ".join(list(missing_obs_fields))
-            logger.error(f"missing required obs columns {missing_obs_fields_str}")
-            logger.info(
-                "consider initializing a Curate object like 'Curate(adata, defaults=cxg.CellxGeneAnnDataCatManager._get_categoricals_defaults())'"
-                "to automatically add these columns with default values."
+            logger.error(
+                f"missing required obs columns {_format_values(missing_obs_fields)}\n"
+                "    → consider initializing a Curate object with `defaults=cxg.CellxGeneAnnDataCatManager.cxg_categoricals_defaults` to automatically add these columns with default values"
             )
             return False
 
         # Verify that no cellxgene reserved names are present
-        reserved_names = {
-            "ethnicity",
-            "ethnicity_ontology_term_id",
-            "X_normalization",
-            "default_field",
-            "layer_descriptions",
-            "tags",
-            "versions",
-            "contributors",
-            "preprint_doi",
-            "project_description",
-            "project_links",
-            "project_name",
-            "publication_doi",
-        }
         matched_columns = [
-            column for column in self._adata.obs.columns if column in reserved_names
+            column for column in self._adata.obs.columns if column in RESERVED_NAMES
         ]
         if len(matched_columns) > 0:
             raise ValueError(
@@ -2696,6 +2478,26 @@ class CellxGeneAnnDataCatManager(AnnDataCatManager):
         Returns:
             An AnnData object which adheres to the cellxgene-schema.
         """
+
+        def _convert_name_to_ontology_id(values: pd.Series, field: FieldAttr):
+            """Converts a column that stores a name into a column that stores the ontology id.
+
+            cellxgene expects the obs columns to be {entity}_ontology_id columns and disallows {entity} columns.
+            """
+            field_name = field.field.name
+            assert field_name == "name"  # noqa: S101
+            cols = ["name", "ontology_id"]
+            registry = field.field.model
+
+            if hasattr(registry, "ontology_id"):
+                validated_records = registry.filter(**{f"{field_name}__in": values})
+                mapper = (
+                    pd.DataFrame(validated_records.values_list(*cols))
+                    .set_index(0)
+                    .to_dict()[1]
+                )
+                return values.map(mapper)
+
         # Create a copy since we modify the AnnData object extensively
         adata_cxg = self._adata.copy()
 
@@ -2715,7 +2517,7 @@ class CellxGeneAnnDataCatManager(AnnDataCatManager):
         # convert name column to ontology_term_id column
         for column in adata_cxg.obs.columns:
             if column in self.categoricals and not column.endswith("_ontology_term_id"):
-                mapped_column = self._convert_name_to_ontology_id(
+                mapped_column = _convert_name_to_ontology_id(
                     adata_cxg.obs[column], field=self.categoricals.get(column)
                 )
                 if mapped_column is not None:
@@ -2881,7 +2683,7 @@ class TimeHandler:
 
 
 class PertAnnDataCatManager(CellxGeneAnnDataCatManager):
-    """Curator flow for Perturbation data."""
+    """Categorical manager for `AnnData` to manage perturbations."""
 
     PERT_COLUMNS = {"compound", "genetic", "biologic", "physical"}
 
@@ -2892,45 +2694,32 @@ class PertAnnDataCatManager(CellxGeneAnnDataCatManager):
         pert_dose: bool = True,
         pert_time: bool = True,
         *,
+        cxg_schema_version: Literal["5.0.0", "5.1.0", "5.2.0"] = "5.2.0",
         verbosity: str = "hint",
-        cxg_schema_version: Literal["5.0.0", "5.1.0"] = "5.1.0",
     ):
         """Initialize the curator with configuration and validation settings."""
-        import bionty as bt
-
         self._pert_time = pert_time
         self._pert_dose = pert_dose
 
         self._validate_initial_data(adata)
-        self._setup_configuration(adata)
-
-        self._setup_sources(adata)
-        self._setup_compound_source()
+        categoricals, categoricals_defaults = self._configure_categoricals(adata)
 
         super().__init__(
             adata=adata,
-            categoricals=self.PT_CATEGORICALS,
-            defaults=self.PT_DEFAULT_VALUES,
-            verbosity=verbosity,
+            categoricals=categoricals,
+            defaults=categoricals_defaults,
             organism=organism,
-            extra_sources=self.PT_SOURCES,
+            extra_sources=self._configure_sources(adata),
             schema_version=cxg_schema_version,
+            verbosity=verbosity,
         )
 
-    def _setup_configuration(self, adata: ad.AnnData):
+    def _configure_categoricals(self, adata: ad.AnnData):
         """Set up default configuration values."""
         import bionty as bt
         import wetlab as wl
 
-        self.PT_DEFAULT_VALUES = (
-            CellxGeneAnnDataCatManager._get_categoricals_defaults()
-            | {
-                "cell_line": "unknown",
-                "pert_target": "unknown",
-            }
-        )
-
-        self.PT_CATEGORICALS = CellxGeneAnnDataCatManager._get_categoricals() | {
+        categoricals = CellxGeneAnnDataCatManager._get_cxg_categoricals() | {
             k: v
             for k, v in {
                 "cell_line": bt.CellLine.name,
@@ -2942,22 +2731,41 @@ class PertAnnDataCatManager(CellxGeneAnnDataCatManager):
             }.items()
             if k in adata.obs.columns
         }
-        # if "donor_id" in self.PT_CATEGORICALS:
-        #     self.PT_CATEGORICALS["donor_id"] = Donor.name
+        # if "donor_id" in categoricals:
+        #     categoricals["donor_id"] = Donor.name
+
+        categoricals_defaults = CellxGeneAnnDataCatManager.cxg_categoricals_defaults | {
+            "cell_line": "unknown",
+            "pert_target": "unknown",
+        }
 
-    def _setup_sources(self, adata: ad.AnnData):
+        return categoricals, categoricals_defaults
+
+    def _configure_sources(self, adata: ad.AnnData):
         """Set up data sources."""
-        self.PT_SOURCES = {}
+        import bionty as bt
+        import wetlab as wl
+
+        sources = {}
+        # # do not yet specify cell_line source
         # if "cell_line" in adata.obs.columns:
-        #     self.PT_SOURCES["cell_line"] = (
-        #         bt.Source.filter(name="depmap").first()
-        #     )
+        #     sources["cell_line"] = bt.Source.filter(
+        #         entity="bionty.CellLine", name="depmap"
+        #     ).first()
         if "pert_compound" in adata.obs.columns:
-            import bionty as bt
+            with logger.mute():
+                chebi_source = bt.Source.filter(
+                    entity="wetlab.Compound", name="chebi"
+                ).first()
+                if not chebi_source:
+                    wl.Compound.add_source(
+                        bt.Source.filter(entity="Drug", name="chebi").first()
+                    )
 
-            self.PT_SOURCES["pert_compound"] = bt.Source.filter(
+            sources["pert_compound"] = bt.Source.filter(
                 entity="wetlab.Compound", name="chebi"
             ).first()
+        return sources
 
     def _validate_initial_data(self, adata: ad.AnnData):
         """Validate the initial data structure."""
@@ -3005,20 +2813,6 @@ class PertAnnDataCatManager(CellxGeneAnnDataCatManager):
                 adata.obs[col_name].cat.remove_unused_categories()
             logger.important(f"mapped 'pert_name' to '{col_name}'")
 
-    def _setup_compound_source(self):
-        """Set up the compound source with muted logging."""
-        import bionty as bt
-        import wetlab as wl
-
-        with logger.mute():
-            chebi_source = bt.Source.filter(
-                entity="wetlab.Compound", name="chebi"
-            ).first()
-            if not chebi_source:
-                wl.Compound.add_source(
-                    bt.Source.filter(entity="Drug", name="chebi").first()
-                )
-
     def validate(self) -> bool:  # type: ignore
         """Validate the AnnData object."""
         validated = super().validate()
@@ -3136,70 +2930,47 @@ class PertAnnDataCatManager(CellxGeneAnnDataCatManager):
 
 def get_current_filter_kwargs(registry: type[Record], kwargs: dict) -> dict:
     """Make sure the source and organism are saved in the same database as the registry."""
-    from lamindb.core._settings import settings
-
     db = registry.filter().db
     source = kwargs.get("source")
     organism = kwargs.get("organism")
     filter_kwargs = kwargs.copy()
-    try:
-        verbosity = settings.verbosity
-        settings.verbosity = "error"
-        if isinstance(organism, Record) and organism._state.db != "default":
-            if db is None or db == "default":
-                organism_default = copy.copy(organism)
-                # save the organism record in the default database
-                organism_default.save()
-                filter_kwargs["organism"] = organism_default
-        if isinstance(source, Record) and source._state.db != "default":
-            if db is None or db == "default":
-                source_default = copy.copy(source)
-                # save the source record in the default database
-                source_default.save()
-                filter_kwargs["source"] = source_default
-    finally:
-        settings.verbosity = verbosity
-    return filter_kwargs
-
 
-def inspect_instance(
-    values: Iterable[str],
-    field: FieldAttr,
-    registry: type[Record],
-    exclude: str | list | None = None,
-    **kwargs,
-):
-    """Inspect values using a registry."""
-    # inspect exclude values in the default instance
-    values = list(values)
-    include_validated = []
-    if exclude is not None:
-        exclude = [exclude] if isinstance(exclude, str) else exclude
-        exclude = [i for i in exclude if i in values]
-        if len(exclude) > 0:
-            # exclude values are validated without source and organism
-            inspect_result_exclude = registry.inspect(exclude, field=field, mute=True)
-            # if exclude values are validated, remove them from the values
-            values = [i for i in values if i not in inspect_result_exclude.validated]
-            include_validated = inspect_result_exclude.validated
-
-    inspect_result = registry.inspect(values, field=field, mute=True, **kwargs)
-    inspect_result._validated += include_validated
-    inspect_result._non_validated = [
-        i for i in inspect_result.non_validated if i not in include_validated
-    ]
+    if isinstance(organism, Record) and organism._state.db != "default":
+        if db is None or db == "default":
+            organism_default = copy.copy(organism)
+            # save the organism record in the default database
+            organism_default.save()
+            filter_kwargs["organism"] = organism_default
+    if isinstance(source, Record) and source._state.db != "default":
+        if db is None or db == "default":
+            source_default = copy.copy(source)
+            # save the source record in the default database
+            source_default.save()
+            filter_kwargs["source"] = source_default
 
-    return inspect_result
+    return filter_kwargs
 
 
-def check_registry_organism(registry: Record, organism: str | None = None) -> dict:
+def get_organism_kwargs(
+    field: FieldAttr, organism: str | None = None
+) -> dict[str, str]:
     """Check if a registry needs an organism and return the organism name."""
-    if hasattr(registry, "organism_id"):
+    registry = field.field.model
+    if registry.__base__.__name__ == "BioRecord":
         import bionty as bt
+        from bionty._organism import is_organism_required
 
-        if organism is None and bt.settings.organism is None:
-            return {}
-        return {"organism": organism or bt.settings.organism.name}
+        from ..models._from_values import get_organism_record_from_field
+
+        if is_organism_required(registry):
+            if organism is not None or bt.settings.organism is not None:
+                return {"organism": organism or bt.settings.organism.name}
+            else:
+                organism_record = get_organism_record_from_field(
+                    field, organism=organism
+                )
+                if organism_record is not None:
+                    return {"organism": organism_record.name}
     return {}
 
 
@@ -3209,7 +2980,6 @@ def validate_categories(
     key: str,
     organism: str | None = None,
     source: Record | None = None,
-    exclude: str | list | None = None,
     hint_print: str | None = None,
     curator: CatManager | None = None,
 ) -> tuple[bool, list[str]]:
@@ -3221,13 +2991,9 @@ def validate_categories(
         key: The key referencing the slot in the DataFrame.
         organism: The organism name.
         source: The source record.
-        exclude: Exclude specific values from validation.
         standardize: Whether to standardize the values.
         hint_print: The hint to print that suggests fixing non-validated values.
     """
-    from lamindb.core._settings import settings
-    from lamindb.models._from_values import _format_values
-
     model_field = f"{field.field.model.__name__}.{field.field.name}"
 
     def _log_mapping_info():
@@ -3237,36 +3003,25 @@ def validate_categories(
 
     registry = field.field.model
 
-    # {"organism": organism_name/organism_record}
-    kwargs = check_registry_organism(registry, organism)
-    kwargs.update({"source": source} if source else {})
-    kwargs_current = get_current_filter_kwargs(registry, kwargs)
+    kwargs_current = get_current_filter_kwargs(
+        registry, {"organism": organism, "source": source}
+    )
 
     # inspect values from the default instance
-    inspect_result = inspect_instance(
-        values=values,
-        field=field,
-        registry=registry,
-        exclude=exclude,
-        **kwargs_current,
-    )
+    inspect_result = registry.inspect(values, field=field, mute=True, **kwargs_current)
     non_validated = inspect_result.non_validated
     syn_mapper = inspect_result.synonyms_mapper
 
-    # inspect the non-validated values from public (bionty only)
+    # inspect the non-validated values from public (BioRecord only)
     values_validated = []
     if hasattr(registry, "public"):
-        verbosity = settings.verbosity
-        try:
-            settings.verbosity = "error"
-            public_records = registry.from_values(
-                non_validated,
-                field=field,
-                **kwargs_current,
-            )
-            values_validated += [getattr(r, field.field.name) for r in public_records]
-        finally:
-            settings.verbosity = verbosity
+        public_records = registry.from_values(
+            non_validated,
+            field=field,
+            mute=True,
+            **kwargs_current,
+        )
+        values_validated += [getattr(r, field.field.name) for r in public_records]
 
     # logging messages
     non_validated_hint_print = hint_print or f'.add_new_from("{key}")'
@@ -3330,7 +3085,6 @@ def validate_categories_in_df(
     df: pd.DataFrame,
     fields: dict[str, FieldAttr],
     sources: dict[str, Record] = None,
-    exclude: dict | None = None,
     curator: CatManager | None = None,
     **kwargs,
 ) -> tuple[bool, dict]:
@@ -3348,7 +3102,6 @@ def validate_categories_in_df(
             field=field,
             key=key,
             source=sources.get(key),
-            exclude=exclude.get(key) if exclude else None,
             curator=curator,
             **kwargs,
         )
@@ -3359,9 +3112,10 @@ def validate_categories_in_df(
 
 
 def save_artifact(
-    data: pd.DataFrame | ad.AnnData | MuData,
+    data: pd.DataFrame | ScverseDataStructures,
+    *,
     fields: dict[str, FieldAttr] | dict[str, dict[str, FieldAttr]],
-    columns_field: FieldAttr | dict[str, FieldAttr] | None = None,
+    index_field: FieldAttr | dict[str, FieldAttr] | None = None,
     description: str | None = None,
     organism: str | None = None,
     key: str | None = None,
@@ -3369,73 +3123,52 @@ def save_artifact(
     revises: Artifact | None = None,
     run: Run | None = None,
     schema: Schema | None = None,
+    **kwargs,
 ) -> Artifact:
     """Save all metadata with an Artifact.
 
     Args:
-        data: The DataFrame/AnnData/MuData object to save.
+        data: The object to save.
         fields: A dictionary mapping obs_column to registry_field.
-        columns_field: The registry field to validate variables index against.
+        index_field: The registry field to validate variables index against.
         description: A description of the artifact.
         organism: The organism name.
-        type: The artifact type.
         key: A path-like key to reference artifact in default storage, e.g., `"myfolder/myfile.fcs"`. Artifacts with the same key form a version family.
         artifact: A already registered artifact. Passing this will not save a new artifact from data.
         revises: Previous version of the artifact. Triggers a revision.
         run: The run that creates the artifact.
+        schema: The Schema to associate with the Artifact.
 
     Returns:
         The saved Artifact.
     """
-    from ..models.artifact import add_labels, data_is_anndata, data_is_mudata
+    from ..models.artifact import add_labels
 
     if artifact is None:
-        if data_is_anndata(data):
-            artifact = Artifact.from_anndata(
+        if isinstance(data, pd.DataFrame):
+            artifact = Artifact.from_df(
                 data, description=description, key=key, revises=revises, run=run
             )
-        elif isinstance(data, pd.DataFrame):
-            artifact = Artifact.from_df(
+        elif isinstance(data, AnnData):
+            artifact = Artifact.from_anndata(
                 data, description=description, key=key, revises=revises, run=run
             )
         elif data_is_mudata(data):
             artifact = Artifact.from_mudata(
-                data,
-                description=description,
-                key=key,
-                revises=revises,
-                run=run,
+                data, description=description, key=key, revises=revises, run=run
+            )
+        elif data_is_spatialdata(data):
+            artifact = Artifact.from_spatialdata(
+                data, description=description, key=key, revises=revises, run=run
+            )
+        else:
+            raise InvalidArgument(  # pragma: no cover
+                "data must be one of pd.Dataframe, AnnData, MuData, SpatialData."
             )
-    artifact.schema = schema
     artifact.save()
 
-    if organism is not None and columns_field is not None:
-        feature_kwargs = check_registry_organism(
-            (
-                list(columns_field.values())[0].field.model
-                if isinstance(columns_field, dict)
-                else columns_field.field.model
-            ),
-            organism,
-        )
-    else:
-        feature_kwargs = {}
-
-    if artifact.otype == "DataFrame":
-        artifact.features._add_set_from_df(field=columns_field, **feature_kwargs)  # type: ignore
-    elif artifact.otype == "AnnData":
-        artifact.features._add_set_from_anndata(  # type: ignore
-            var_field=columns_field, **feature_kwargs
-        )
-    elif artifact.otype == "MuData":
-        artifact.features._add_set_from_mudata(  # type: ignore
-            var_fields=columns_field, **feature_kwargs
-        )
-    else:
-        raise NotImplementedError
-
     def _add_labels(
-        data,
+        data: pd.DataFrame | ScverseDataStructures,
         artifact: Artifact,
         fields: dict[str, FieldAttr],
         feature_ref_is_name: bool | None = None,
@@ -3444,19 +3177,15 @@ def save_artifact(
         for key, field in fields.items():
             feature = features.get(key)
             registry = field.field.model
-            filter_kwargs = check_registry_organism(registry, organism)
-            filter_kwargs_current = get_current_filter_kwargs(registry, filter_kwargs)
+            # we don't need source here because all records are already in the DB
+            filter_kwargs = get_current_filter_kwargs(registry, {"organism": organism})
             df = data if isinstance(data, pd.DataFrame) else data.obs
             # multi-value columns are separated by "|"
             if not df[key].isna().all() and df[key].str.contains("|").any():
                 values = df[key].str.split("|").explode().unique()
             else:
                 values = df[key].unique()
-            labels = registry.from_values(
-                values,
-                field=field,
-                **filter_kwargs_current,
-            )
+            labels = registry.from_values(values, field=field, **filter_kwargs)
             if len(labels) == 0:
                 continue
             label_ref_is_name = None
@@ -3471,35 +3200,87 @@ def save_artifact(
                 from_curator=True,
             )
 
-    if artifact.otype == "MuData":
-        for modality, modality_fields in fields.items():
-            column_field_modality = columns_field.get(modality)
-            if modality == "obs":
-                _add_labels(
-                    data,
-                    artifact,
-                    modality_fields,
-                    feature_ref_is_name=(
-                        None
-                        if column_field_modality is None
-                        else _ref_is_name(column_field_modality)
-                    ),
-                )
+    match artifact.otype:
+        case "DataFrame":
+            artifact.features._add_set_from_df(field=index_field, organism=organism)  # type: ignore
+            _add_labels(
+                data, artifact, fields, feature_ref_is_name=_ref_is_name(index_field)
+            )
+        case "AnnData":
+            if schema is not None and "uns" in schema.slots:
+                uns_field = parse_cat_dtype(schema.slots["uns"].itype, is_itype=True)[
+                    "field"
+                ]
             else:
-                _add_labels(
-                    data[modality],
-                    artifact,
-                    modality_fields,
-                    feature_ref_is_name=(
-                        None
-                        if column_field_modality is None
-                        else _ref_is_name(column_field_modality)
-                    ),
-                )
-    else:
-        _add_labels(
-            data, artifact, fields, feature_ref_is_name=_ref_is_name(columns_field)
-        )
+                uns_field = None
+            artifact.features._add_set_from_anndata(  # type: ignore
+                var_field=index_field, uns_field=uns_field, organism=organism
+            )
+            _add_labels(
+                data, artifact, fields, feature_ref_is_name=_ref_is_name(index_field)
+            )
+        case "MuData":
+            artifact.features._add_set_from_mudata(  # type: ignore
+                var_fields=index_field, organism=organism
+            )
+            for modality, modality_fields in fields.items():
+                column_field_modality = index_field.get(modality)
+                if modality == "obs":
+                    _add_labels(
+                        data,
+                        artifact,
+                        modality_fields,
+                        feature_ref_is_name=(
+                            None
+                            if column_field_modality is None
+                            else _ref_is_name(column_field_modality)
+                        ),
+                    )
+                else:
+                    _add_labels(
+                        data[modality],
+                        artifact,
+                        modality_fields,
+                        feature_ref_is_name=(
+                            None
+                            if column_field_modality is None
+                            else _ref_is_name(column_field_modality)
+                        ),
+                    )
+        case "SpatialData":
+            artifact.features._add_set_from_spatialdata(  # type: ignore
+                sample_metadata_key=kwargs.get("sample_metadata_key", "sample"),
+                var_fields=index_field,
+                organism=organism,
+            )
+            sample_metadata_key = kwargs.get("sample_metadata_key", "sample")
+            for accessor, accessor_fields in fields.items():
+                column_field = index_field.get(accessor)
+                if accessor == sample_metadata_key:
+                    _add_labels(
+                        data.get_attrs(
+                            key=sample_metadata_key, return_as="df", flatten=True
+                        ),
+                        artifact,
+                        accessor_fields,
+                        feature_ref_is_name=(
+                            None if column_field is None else _ref_is_name(column_field)
+                        ),
+                    )
+                else:
+                    _add_labels(
+                        data.tables[accessor],
+                        artifact,
+                        accessor_fields,
+                        feature_ref_is_name=(
+                            None if column_field is None else _ref_is_name(column_field)
+                        ),
+                    )
+        case _:
+            raise NotImplementedError  # pragma: no cover
+
+    artifact.schema = schema
+    artifact.save()
 
     slug = ln_setup.settings.instance.slug
     if ln_setup.settings.instance.is_remote:  # pdagma: no cover
@@ -3529,8 +3310,7 @@ def update_registry(
     organism: str | None = None,
     dtype: str | None = None,
     source: Record | None = None,
-    exclude: str | list | None = None,
-    **kwargs,
+    **create_kwargs,
 ) -> None:
     """Save features or labels records in the default instance..
 
@@ -3543,82 +3323,68 @@ def update_registry(
         organism: The organism name.
         dtype: The type of the feature.
         source: The source record.
-        exclude: Values to exclude from inspect.
-        kwargs: Additional keyword arguments to pass to the registry model to create new records.
+        **create_kwargs: Additional keyword arguments to pass to the registry model to create new records.
     """
-    from lamindb.core._settings import settings
     from lamindb.models.save import save as ln_save
 
     registry = field.field.model
-    filter_kwargs = check_registry_organism(registry, organism)
-    filter_kwargs.update({"source": source} if source else {})
+    filter_kwargs = get_current_filter_kwargs(
+        registry, {"organism": organism, "source": source}
+    )
     values = [i for i in values if isinstance(i, str) and i]
     if not values:
         return
 
-    verbosity = settings.verbosity
-    try:
-        settings.verbosity = "error"
-        labels_saved: dict = {"from public": [], "new": []}
+    labels_saved: dict = {"from public": [], "new": []}
 
-        # inspect the default instance and save validated records from public
-        filter_kwargs_current = get_current_filter_kwargs(registry, filter_kwargs)
-        existing_and_public_records = registry.from_values(
-            list(values), field=field, **filter_kwargs_current
-        )
-        existing_and_public_labels = [
-            getattr(r, field.field.name) for r in existing_and_public_records
-        ]
-        # public records that are not already in the database
-        public_records = [r for r in existing_and_public_records if r._state.adding]
-        # here we check to only save the public records if they are from the specified source
-        # we check the uid because r.source and source can be from different instances
-        if source:
-            public_records = [r for r in public_records if r.source.uid == source.uid]
-        if len(public_records) > 0:
-            settings.verbosity = "info"
-            logger.info(f"saving validated records of '{key}'")
-            settings.verbosity = "error"
-            ln_save(public_records)
-            labels_saved["from public"] = [
-                getattr(r, field.field.name) for r in public_records
-            ]
-        # non-validated records from the default instance
-        non_validated_labels = [
-            i for i in values if i not in existing_and_public_labels
+    # inspect the default instance and save validated records from public
+    existing_and_public_records = registry.from_values(
+        list(values), field=field, **filter_kwargs, mute=True
+    )
+    existing_and_public_labels = [
+        getattr(r, field.field.name) for r in existing_and_public_records
+    ]
+    # public records that are not already in the database
+    public_records = [r for r in existing_and_public_records if r._state.adding]
+    # here we check to only save the public records if they are from the specified source
+    # we check the uid because r.source and source can be from different instances
+    if source:
+        public_records = [r for r in public_records if r.source.uid == source.uid]
+    if len(public_records) > 0:
+        logger.info(f"saving validated records of '{key}'")
+        ln_save(public_records)
+        labels_saved["from public"] = [
+            getattr(r, field.field.name) for r in public_records
         ]
+    # non-validated records from the default instance
+    non_validated_labels = [i for i in values if i not in existing_and_public_labels]
+
+    # save non-validated/new records
+    labels_saved["new"] = non_validated_labels
+    if not validated_only:
+        non_validated_records: RecordList[Any] = []  # type: ignore
+        if df is not None and registry == Feature:
+            nonval_columns = Feature.inspect(df.columns, mute=True).non_validated
+            non_validated_records = Feature.from_df(df.loc[:, nonval_columns])
+        else:
+            if (
+                organism
+                and hasattr(registry, "organism")
+                and registry._meta.get_field("organism").is_relation
+            ):
+                # make sure organism record is saved to the current instance
+                create_kwargs["organism"] = _save_organism(name=organism)
 
-        # save non-validated/new records
-        labels_saved["new"] = non_validated_labels
-        if not validated_only:
-            non_validated_records: RecordList[Any] = []  # type: ignore
-            if df is not None and registry == Feature:
-                nonval_columns = Feature.inspect(df.columns, mute=True).non_validated
-                non_validated_records = Feature.from_df(df.loc[:, nonval_columns])
-            else:
-                if "organism" in filter_kwargs:
-                    # make sure organism record is saved to the current instance
-                    filter_kwargs["organism"] = _save_organism(name=organism)
-                init_kwargs = {}
-                for value in labels_saved["new"]:
-                    init_kwargs[field.field.name] = value
-                    if registry == Feature:
-                        init_kwargs["dtype"] = "cat" if dtype is None else dtype
-                    non_validated_records.append(
-                        registry(
-                            **init_kwargs,
-                            **{k: v for k, v in filter_kwargs.items() if k != "source"},
-                            **{k: v for k, v in kwargs.items() if k != "sources"},
-                        )
-                    )
-            ln_save(non_validated_records)
-
-        # save parent labels for ulabels, for example a parent label "project" for label "project001"
-        if registry == ULabel and field.field.name == "name":
-            save_ulabels_parent(values, field=field, key=key)
+            for value in labels_saved["new"]:
+                init_kwargs = {field.field.name: value}
+                if registry == Feature:
+                    init_kwargs["dtype"] = "cat" if dtype is None else dtype
+                non_validated_records.append(registry(**init_kwargs, **create_kwargs))
+        ln_save(non_validated_records)
 
-    finally:
-        settings.verbosity = verbosity
+    # save parent labels for ulabels, for example a parent label "project" for label "project001"
+    if registry == ULabel and field.field.name == "name":
+        save_ulabels_type(values, field=field, key=key)
 
     log_saved_labels(
         labels_saved,
@@ -3653,16 +3419,18 @@ def log_saved_labels(
             )
 
 
-def save_ulabels_parent(values: list[str], field: FieldAttr, key: str) -> None:
-    """Save a parent label for the given labels."""
+def save_ulabels_type(values: list[str], field: FieldAttr, key: str) -> None:
+    """Save the ULabel type of the given labels."""
     registry = field.field.model
     assert registry == ULabel  # noqa: S101
-    all_records = registry.from_values(list(values), field=field)
-    is_feature = registry.filter(name=f"{key}").one_or_none()
-    if is_feature is None:
-        is_feature = registry(name=f"{key}").save()
-        logger.important(f"Created a parent ULabel: {is_feature}")
-    is_feature.children.add(*all_records)
+    all_records = registry.filter(**{field.field.name: list(values)}).all()
+    # so `tissue_type` becomes `TissueType`
+    type_name = "".join([i.capitalize() for i in key.lower().split("_")])
+    ulabel_type = registry.filter(name=type_name, is_type=True).one_or_none()
+    if ulabel_type is None:
+        ulabel_type = registry(name=type_name, is_type=True).save()
+        logger.important(f"Created a ULabel type: {ulabel_type}")
+    all_records.update(type=ulabel_type)
 
 
 def _save_organism(name: str):
@@ -3674,8 +3442,9 @@ def _save_organism(name: str):
         organism = bt.Organism.from_source(name=name)
         if organism is None:
             raise ValidationError(
-                f'Organism "{name}" not found\n'
-                f'      → please save it: bt.Organism(name="{name}").save()'
+                f'Organism "{name}" not found from public reference\n'
+                f'      → please save it from a different source: bt.Organism.from_source(name="{name}", source).save()'
+                f'      → or manually save it without source: bt.Organism(name="{name}").save()'
             )
         organism.save()
     return organism
@@ -3761,7 +3530,6 @@ def from_tiledbsoma(
     obs_columns: FieldAttr = Feature.name,
     organism: str | None = None,
     sources: dict[str, Record] | None = None,
-    exclude: dict[str, str | list[str]] | None = None,
 ) -> TiledbsomaCatManager:
     return TiledbsomaCatManager(
         experiment_uri=experiment_uri,
@@ -3770,7 +3538,6 @@ def from_tiledbsoma(
         obs_columns=obs_columns,
         organism=organism,
         sources=sources,
-        exclude=exclude,
     )
 
 
@@ -3782,7 +3549,6 @@ def from_spatialdata(
     categoricals: dict[str, dict[str, FieldAttr]] | None = None,
     organism: str | None = None,
     sources: dict[str, dict[str, Record]] | None = None,
-    exclude: dict[str, dict] | None = None,
     verbosity: str = "hint",
     *,
     sample_metadata_key: str = "sample",
@@ -3799,7 +3565,6 @@ def from_spatialdata(
         verbosity=verbosity,
         organism=organism,
         sources=sources,
-        exclude=exclude,
         sample_metadata_key=sample_metadata_key,
     )