lamindb 1.3.1__py3-none-any.whl → 1.4.0__py3-none-any.whl

lamindb/curators/__init__.py

@@ -42,6 +42,8 @@ from lamindb_setup.core import deprecated
 from lamindb_setup.core._docs import doc_args
 from lamindb_setup.core.upath import UPath
 
+from lamindb.core._compat import is_package_installed
+
 if TYPE_CHECKING:
     from lamindb_setup.core.types import UPathStr
     from mudata import MuData
@@ -103,25 +105,26 @@ class CatLookup:
 
     def __init__(
         self,
-        categoricals: dict[str, FieldAttr],
+        categoricals: list[Feature] | 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 {}
+        if isinstance(categoricals, list):
+            categoricals = {
+                feature.name: parse_dtype(feature.dtype)[0]["field"]
+                for feature in categoricals
+            }
         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(
-                    organism=self._organism, source=self._sources.get(name)
-                ).lookup()
+                return registry.public(source=self._sources.get(name)).lookup()
             else:
                 return registry.lookup()
         raise AttributeError(
@@ -132,9 +135,7 @@ class CatLookup:
         if name in self._categoricals:
             registry = self._categoricals[name].field.model
             if self._public and hasattr(registry, "public"):
-                return registry.public(
-                    organism=self._organism, source=self._sources.get(name)
-                ).lookup()
+                return registry.public(source=self._sources.get(name)).lookup()
             else:
                 return registry.lookup()
         raise AttributeError(
@@ -240,6 +241,7 @@ class Curator:
         pass  # pragma: no cover
 
 
+# default implementation for MuDataCurator and SpatialDataCurator
 class SlotsCurator(Curator):
     """Curator for a dataset with slots.
 
@@ -262,7 +264,7 @@ class SlotsCurator(Curator):
         # 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]] = {}
+        self._cat_columns: dict[str, dict[str, CatColumn]] = {}
 
     @property
     @doc_args(SLOTS_DOCSTRING)
@@ -273,7 +275,8 @@ class SlotsCurator(Curator):
     @doc_args(VALIDATE_DOCSTRING)
     def validate(self) -> None:
         """{}"""  # noqa: D415
-        for _, curator in self._slots.items():
+        for slot, curator in self._slots.items():
+            logger.info(f"validating slot {slot} ...")
             curator.validate()
 
     @doc_args(SAVE_ARTIFACT_DOCSTRING)
@@ -288,18 +291,34 @@ class SlotsCurator(Curator):
         """{}"""  # 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,
+        if self._artifact is None:
+            if data_is_mudata(self._dataset):
+                self._artifact = Artifact.from_mudata(
+                    self._dataset,
+                    key=key,
+                    description=description,
+                    revises=revises,
+                    run=run,
+                )
+            elif data_is_spatialdata(self._dataset):
+                self._artifact = Artifact.from_spatialdata(
+                    self._dataset,
+                    key=key,
+                    description=description,
+                    revises=revises,
+                    run=run,
+                )
+            self._artifact.schema = self._schema
+            self._artifact.save()
+        cat_columns = {}
+        for curator in self._slots.values():
+            for key, cat_column in curator._cat_manager._cat_columns.items():
+                cat_columns[key] = cat_column
+        return annotate_artifact(  # type: ignore
+            self._artifact,
             index_field=self._var_fields,
-            artifact=self._artifact,
-            revises=revises,
-            run=run,
             schema=self._schema,
+            cat_columns=cat_columns,
         )
 
 
@@ -373,11 +392,34 @@ class DataFrameCurator(Curator):
         schema: Schema,
     ) -> None:
         super().__init__(dataset=dataset, schema=schema)
-        categoricals = {}
+        categoricals = []
+        features = []
+        feature_ids: set[int] = set()
+        if schema.flexible and isinstance(self._dataset, pd.DataFrame):
+            features += Feature.filter(name__in=self._dataset.keys()).list()
+            feature_ids = {feature.id for feature in features}
         if schema.n > 0:
+            schema_features = schema.features.all().list()
+            if feature_ids:
+                features.extend(
+                    feature
+                    for feature in schema_features
+                    if feature.id not in feature_ids
+                )
+            else:
+                features.extend(schema_features)
+        else:
+            assert schema.itype is not None  # noqa: S101
+        if features:
             # populate features
             pandera_columns = {}
-            for feature in schema.features.all():
+            if schema.minimal_set:
+                optional_feature_uids = set(schema.optionals.get_uids())
+            for feature in features:
+                if schema.minimal_set:
+                    required = feature.uid not in optional_feature_uids
+                else:
+                    required = False
                 if feature.dtype in {"int", "float", "num"}:
                     dtype = (
                         self._dataset[feature.name].dtype
@@ -393,6 +435,7 @@ class DataFrameCurator(Curator):
                         ),
                         nullable=feature.nullable,
                         coerce=feature.coerce_dtype,
+                        required=required,
                     )
                 else:
                     pandera_dtype = (
@@ -404,14 +447,18 @@ class DataFrameCurator(Curator):
                         pandera_dtype,
                         nullable=feature.nullable,
                         coerce=feature.coerce_dtype,
+                        required=required,
                     )
                 if feature.dtype.startswith("cat"):
-                    categoricals[feature.name] = parse_dtype(feature.dtype)[0]["field"]
+                    # validate categoricals if the column is required or if the column is present
+                    if required or feature.name in self._dataset.columns:
+                        categoricals.append(feature)
             self._pandera_schema = pandera.DataFrameSchema(
-                pandera_columns, coerce=schema.coerce_dtype
+                pandera_columns,
+                coerce=schema.coerce_dtype,
+                strict=schema.maximal_set,
+                ordered=schema.ordered_set,
             )
-        else:
-            assert schema.itype is not None  # noqa: S101
         self._cat_manager = DataFrameCatManager(
             self._dataset,
             columns=parse_cat_dtype(schema.itype, is_itype=True)["field"],
@@ -504,16 +551,21 @@ class DataFrameCurator(Curator):
         if not self._is_validated:
             self.validate()  # raises ValidationError if doesn't validate
         result = parse_cat_dtype(self._schema.itype, is_itype=True)
-        return save_artifact(  # type: ignore
-            self._dataset,
-            description=description,
-            fields=self._cat_manager.categoricals,
+        if self._artifact is None:
+            self._artifact = Artifact.from_df(
+                self._dataset,
+                key=key,
+                description=description,
+                revises=revises,
+                run=run,
+            )
+            self._artifact.schema = self._schema
+            self._artifact.save()
+        return annotate_artifact(  # type: ignore
+            self._artifact,
             index_field=result["field"],
-            key=key,
-            artifact=self._artifact,
-            revises=revises,
-            run=run,
             schema=self._schema,
+            cat_columns=self._cat_manager._cat_columns,
         )
 
 
@@ -548,7 +600,7 @@ class AnnDataCurator(SlotsCurator):
                 ln.Feature(name="perturbation", dtype="cat[ULabel[Perturbation]]").save(),
                 ln.Feature(name="sample_note", dtype=str).save(),
                 ln.Feature(name="cell_type_by_expert", dtype=bt.CellType).save(),
-                ln.Feature(name="cell_type_by_model", dtype=bt.CellType").save(),
+                ln.Feature(name="cell_type_by_model", dtype=bt.CellType).save(),
             ],
         ).save()
 
@@ -596,6 +648,12 @@ class AnnDataCurator(SlotsCurator):
             for slot, slot_schema in schema.slots.items()
             if slot in {"obs", "var", "uns"}
         }
+        # TODO: better way to handle this!
+        if "var" in self._slots:
+            self._slots["var"]._cat_manager._cat_columns["var_index"] = self._slots[
+                "var"
+            ]._cat_manager._cat_columns.pop("columns")
+            self._slots["var"]._cat_manager._cat_columns["var_index"]._key = "var_index"
 
     @doc_args(SAVE_ARTIFACT_DOCSTRING)
     def save_artifact(
@@ -609,23 +667,28 @@ class AnnDataCurator(SlotsCurator):
         """{}"""  # 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=categoricals,
+        if self._artifact is None:
+            self._artifact = Artifact.from_anndata(
+                self._dataset,
+                key=key,
+                description=description,
+                revises=revises,
+                run=run,
+            )
+            self._artifact.schema = self._schema
+            self._artifact.save()
+        return annotate_artifact(  # type: ignore
+            self._artifact,
+            cat_columns=(
+                self.slots["obs"]._cat_manager._cat_columns
+                if "obs" in self.slots
+                else {}
+            ),
             index_field=(
                 parse_cat_dtype(self.slots["var"]._schema.itype, is_itype=True)["field"]
                 if "var" in self._slots
                 else None
             ),
-            key=key,
-            artifact=self._artifact,
-            revises=revises,
-            run=run,
             schema=self._schema,
         )
 
@@ -636,14 +699,14 @@ def _assign_var_fields_categoricals_multimodal(
     slot: str,
     slot_schema: Schema,
     var_fields: dict[str, FieldAttr],
-    categoricals: dict[str, dict[str, FieldAttr]],
+    cat_columns: dict[str, dict[str, CatColumn]],
     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] = {}
+        cat_columns[modality] = {}
 
     if slot_type == "var":
         var_field = parse_cat_dtype(slot_schema.itype, is_itype=True)["field"]
@@ -654,12 +717,12 @@ def _assign_var_fields_categoricals_multimodal(
             # 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
+        obs_fields = slots[slot]._cat_manager._cat_columns
         if modality is None:
-            categoricals[slot] = obs_fields
+            cat_columns[slot] = obs_fields
         else:
             # Note that this is NOT nested since the nested key is always "obs"
-            categoricals[modality] = obs_fields
+            cat_columns[modality] = obs_fields
 
 
 class MuDataCurator(SlotsCurator):
@@ -770,7 +833,7 @@ class MuDataCurator(SlotsCurator):
                 slot=slot,
                 slot_schema=slot_schema,
                 var_fields=self._var_fields,
-                categoricals=self._categoricals,
+                cat_columns=self._cat_columns,
                 slots=self._slots,
             )
 
@@ -890,7 +953,7 @@ class SpatialDataCurator(SlotsCurator):
                 slot=slot,
                 slot_schema=slot_schema,
                 var_fields=self._var_fields,
-                categoricals=self._categoricals,
+                cat_columns=self._cat_columns,
                 slots=self._slots,
             )
 
@@ -898,6 +961,296 @@ class SpatialDataCurator(SlotsCurator):
         self._columns_field = self._var_fields
 
 
+class CatColumn:
+    """Categorical column for `DataFrame`.
+
+    Args:
+        values_getter: A callable or iterable that returns the values to validate.
+        field: The field to validate against.
+        key: The name of the column to validate. Only used for logging.
+        values_setter: A callable that sets the values.
+        source: The source to validate against.
+    """
+
+    def __init__(
+        self,
+        values_getter: Callable | Iterable[str],
+        field: FieldAttr,
+        key: str,
+        values_setter: Callable | None = None,
+        source: Record | None = None,
+        feature: Feature | None = None,
+    ) -> None:
+        self._values_getter = values_getter
+        self._values_setter = values_setter
+        self._field = field
+        self._key = key
+        self._source = source
+        self._organism = None
+        self._validated: None | list[str] = None
+        self._non_validated: None | list[str] = None
+        self._synonyms: None | dict[str, str] = None
+        self.feature = feature
+        self.labels = None
+        if hasattr(field.field.model, "_name_field"):
+            label_ref_is_name = field.field.name == field.field.model._name_field
+        else:
+            label_ref_is_name = field.field.name == "name"
+        self.label_ref_is_name = label_ref_is_name
+
+    @property
+    def values(self):
+        """Get the current values using the getter function."""
+        if callable(self._values_getter):
+            return self._values_getter()
+        return self._values_getter
+
+    @values.setter
+    def values(self, new_values):
+        """Set new values using the setter function if available."""
+        if callable(self._values_setter):
+            self._values_setter(new_values)
+        else:
+            # If values_getter is not callable, it's a direct reference we can update
+            self._values_getter = new_values
+
+    @property
+    def is_validated(self) -> bool:
+        """Return whether the column is validated."""
+        return len(self._non_validated) == 0
+
+    def _replace_synonyms(self) -> list[str]:
+        """Replace synonyms in the column with standardized values."""
+        syn_mapper = self._synonyms
+        # replace the values in df
+        std_values = self.values.map(
+            lambda unstd_val: syn_mapper.get(unstd_val, unstd_val)
+        )
+        # remove the standardized values from self.non_validated
+        non_validated = [i for i in self._non_validated if i not in syn_mapper]
+        if len(non_validated) == 0:
+            self._non_validated = []
+        else:
+            self._non_validated = non_validated  # type: ignore
+        # logging
+        n = len(syn_mapper)
+        if n > 0:
+            syn_mapper_print = _format_values(
+                [f'"{k}" → "{v}"' for k, v in syn_mapper.items()], sep=""
+            )
+            s = "s" if n > 1 else ""
+            logger.success(
+                f'standardized {n} synonym{s} in "{self._key}": {colors.green(syn_mapper_print)}'
+            )
+        return std_values
+
+    def _add_validated(self) -> tuple[list, list]:
+        """Save features or labels records in the default instance."""
+        from lamindb.models.save import save as ln_save
+
+        registry = self._field.field.model
+        field_name = self._field.field.name
+        model_field = registry.__get_name_with_module__()
+        filter_kwargs = get_current_filter_kwargs(
+            registry, {"organism": self._organism, "source": self._source}
+        )
+        values = [i for i in self.values if isinstance(i, str) and i]
+        if not values:
+            return [], []
+
+        # inspect the default instance and save validated records from public
+        existing_and_public_records = registry.from_values(
+            list(values), field=self._field, **filter_kwargs, mute=True
+        )
+        existing_and_public_labels = [
+            getattr(r, 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 self._source:
+            public_records = [
+                r for r in public_records if r.source.uid == self._source.uid
+            ]
+        if len(public_records) > 0:
+            logger.info(f"saving validated records of '{self._key}'")
+            ln_save(public_records)
+            labels_saved_public = [getattr(r, field_name) for r in public_records]
+            # log the saved public labels
+            # the term "transferred" stresses that this is always in the context of transferring
+            # labels from a public ontology or a different instance to the present instance
+            if len(labels_saved_public) > 0:
+                s = "s" if len(labels_saved_public) > 1 else ""
+                logger.success(
+                    f'added {len(labels_saved_public)} record{s} {colors.green("from_public")} with {model_field} for "{self._key}": {_format_values(labels_saved_public)}'
+                )
+        self.labels = existing_and_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
+        ]
+
+        # validated, non-validated
+        return existing_and_public_labels, non_validated_labels
+
+    def _add_new(
+        self,
+        values: list[str],
+        df: pd.DataFrame | None = None,  # remove when all users use schema
+        dtype: str | None = None,
+        **create_kwargs,
+    ) -> None:
+        """Add new labels to the registry."""
+        from lamindb.models.save import save as ln_save
+
+        registry = self._field.field.model
+        field_name = self._field.field.name
+        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 (
+                self._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=self._organism)
+
+            for value in values:
+                init_kwargs = {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))
+        if len(non_validated_records) > 0:
+            ln_save(non_validated_records)
+            model_field = colors.italic(registry.__get_name_with_module__())
+            s = "s" if len(values) > 1 else ""
+            logger.success(
+                f'added {len(values)} record{s} with {model_field} for "{self._key}": {_format_values(values)}'
+            )
+
+    def _validate(
+        self,
+        values: list[str],
+        curator: CatManager | None = None,  # TODO: not yet used
+    ) -> tuple[list[str], dict]:
+        """Validate ontology terms using LaminDB registries."""
+        registry = self._field.field.model
+        field_name = self._field.field.name
+        model_field = f"{registry.__name__}.{field_name}"
+
+        def _log_mapping_info():
+            logger.indent = ""
+            logger.info(f'mapping "{self._key}" on {colors.italic(model_field)}')
+            logger.indent = "  "
+
+        kwargs_current = get_current_filter_kwargs(
+            registry, {"organism": self._organism, "source": self._source}
+        )
+
+        # inspect values from the default instance, excluding public
+        inspect_result = registry.inspect(
+            values, field=self._field, mute=True, from_source=False, **kwargs_current
+        )
+        non_validated = inspect_result.non_validated
+        syn_mapper = inspect_result.synonyms_mapper
+
+        # inspect the non-validated values from public (BioRecord only)
+        values_validated = []
+        if hasattr(registry, "public"):
+            public_records = registry.from_values(
+                non_validated,
+                field=self._field,
+                mute=True,
+                **kwargs_current,
+            )
+            values_validated += [getattr(r, field_name) for r in public_records]
+
+        # logging messages
+        non_validated_hint_print = f'.add_new_from("{self._key}")'
+        non_validated = [i for i in non_validated if i not in values_validated]
+        n_non_validated = len(non_validated)
+        if n_non_validated == 0:
+            logger.indent = ""
+            logger.success(
+                f'"{self._key}" is validated against {colors.italic(model_field)}'
+            )
+            return [], {}
+        else:
+            are = "is" if n_non_validated == 1 else "are"
+            s = "" if n_non_validated == 1 else "s"
+            print_values = _format_values(non_validated)
+            warning_message = f"{colors.red(f'{n_non_validated} term{s}')} {are} not validated: {colors.red(print_values)}\n"
+            if syn_mapper:
+                s = "" if len(syn_mapper) == 1 else "s"
+                syn_mapper_print = _format_values(
+                    [f'"{k}" → "{v}"' for k, v in syn_mapper.items()], sep=""
+                )
+                hint_msg = f'.standardize("{self._key}")'
+                warning_message += f"    {colors.yellow(f'{len(syn_mapper)} synonym{s}')} found: {colors.yellow(syn_mapper_print)}\n    → curate synonyms via {colors.cyan(hint_msg)}"
+            if n_non_validated > len(syn_mapper):
+                if syn_mapper:
+                    warning_message += "\n    for remaining terms:\n"
+                warning_message += f"    → fix typos, remove non-existent values, or save terms via {colors.cyan(non_validated_hint_print)}"
+
+            if logger.indent == "":
+                _log_mapping_info()
+            logger.warning(warning_message)
+            if curator is not None:
+                curator._validate_category_error_messages = strip_ansi_codes(
+                    warning_message
+                )
+            logger.indent = ""
+            return non_validated, syn_mapper
+
+    def validate(self) -> None:
+        """Validate the column."""
+        # add source-validated values to the registry
+        self._validated, self._non_validated = self._add_validated()
+        self._non_validated, self._synonyms = self._validate(values=self._non_validated)
+        # always register new Features if they are columns
+        if self._key == "columns" and self._field == Feature.name:
+            self.add_new()
+
+    def standardize(self) -> None:
+        """Standardize the column."""
+        registry = self._field.field.model
+        if not hasattr(registry, "standardize"):
+            return self.values
+        if self._synonyms is None:
+            self.validate()
+        # get standardized values
+        std_values = self._replace_synonyms()
+        # update non_validated values
+        self._non_validated = [
+            i for i in self._non_validated if i not in self._synonyms.keys()
+        ]
+        # remove synonyms since they are now standardized
+        self._synonyms = {}
+        # update the values with the standardized values
+        self.values = std_values
+
+    def add_new(self, **create_kwargs) -> None:
+        """Add new values to the registry."""
+        if self._non_validated is None:
+            self.validate()
+        if len(self._synonyms) > 0:
+            # raise error because .standardize modifies the input dataset
+            raise ValidationError(
+                "Please run `.standardize()` before adding new values."
+            )
+        self._add_new(
+            values=self._non_validated,
+            **create_kwargs,
+        )
+        # remove the non_validated values since they are now registered
+        self._non_validated = []
+
+
 class CatManager:
     """Manage categoricals by updating registries.
 
@@ -909,14 +1262,16 @@ class CatManager:
     - 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):
+    def __init__(self, *, dataset, categoricals, sources, 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
         if isinstance(self._dataset, Artifact):
             self._artifact = self._dataset
             if self._artifact.otype in {"DataFrame", "AnnData"}:
-                self._dataset = self._dataset.load()
+                self._dataset = self._dataset.load(
+                    is_run_input=False  # we already track this in the Curator constructor
+                )
         self._is_validated: bool = False
         # shared until here
         self._categoricals = categoricals or {}
@@ -924,49 +1279,24 @@ class CatManager:
         self._sources = sources 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
+        self._cat_columns: dict[str, CatColumn] = {}
 
     @property
     def non_validated(self) -> dict[str, list[str]]:
         """Return the non-validated features and labels."""
         if self._non_validated is None:
             raise ValidationError("Please run validate() first!")
-        return self._non_validated
+        return {
+            key: cat_column._non_validated
+            for key, cat_column in self._cat_columns.items()
+            if cat_column._non_validated and key != "columns"
+        }
 
     @property
     def categoricals(self) -> dict:
         """Return the columns fields to validate against."""
         return self._categoricals
 
-    def _replace_synonyms(
-        self, key: str, syn_mapper: dict, values: pd.Series | pd.Index
-    ):
-        # replace the values in df
-        std_values = values.map(lambda unstd_val: syn_mapper.get(unstd_val, unstd_val))
-        # remove the standardized values from self.non_validated
-        non_validated = [i for i in self.non_validated[key] if i not in syn_mapper]
-        if len(non_validated) == 0:
-            self._non_validated.pop(key, None)  # type: ignore
-        else:
-            self._non_validated[key] = non_validated  # type: ignore
-        # logging
-        n = len(syn_mapper)
-        if n > 0:
-            syn_mapper_print = _format_values(
-                [f'"{k}" → "{v}"' for k, v in syn_mapper.items()], sep=""
-            )
-            s = "s" if n > 1 else ""
-            logger.success(
-                f'standardized {n} synonym{s} in "{key}": {colors.green(syn_mapper_print)}'
-            )
-        return std_values
-
     def validate(self) -> bool:
         """Validate dataset.
 
@@ -1006,19 +1336,49 @@ class CatManager:
             if not self._is_validated:  # need to raise error manually
                 raise ValidationError("Dataset does not validate. Please curate.")
 
-        self._artifact = save_artifact(  # type: ignore
-            self._dataset,
-            key=key,
-            description=description,
-            fields=self.categoricals,
+        if self._artifact is None:
+            if isinstance(self._dataset, pd.DataFrame):
+                artifact = Artifact.from_df(
+                    self._dataset,
+                    key=key,
+                    description=description,
+                    revises=revises,
+                    run=run,
+                )
+            elif isinstance(self._dataset, AnnData):
+                artifact = Artifact.from_anndata(
+                    self._dataset,
+                    key=key,
+                    description=description,
+                    revises=revises,
+                    run=run,
+                )
+            elif data_is_mudata(self._dataset):
+                artifact = Artifact.from_mudata(
+                    self._dataset,
+                    key=key,
+                    description=description,
+                    revises=revises,
+                    run=run,
+                )
+            elif data_is_spatialdata(self._dataset):
+                artifact = Artifact.from_spatialdata(
+                    self._dataset,
+                    key=key,
+                    description=description,
+                    revises=revises,
+                    run=run,
+                )
+            else:
+                raise InvalidArgument(  # pragma: no cover
+                    "data must be one of pd.Dataframe, AnnData, MuData, SpatialData."
+                )
+            self._artifact = artifact.save()
+        annotate_artifact(  # type: ignore
+            self._artifact,
             index_field=self._columns_field,
-            artifact=self._artifact,
-            revises=revises,
-            run=run,
-            schema=None,
-            organism=self._organism,
+            cat_columns=self._cat_columns,
         )
-
         return self._artifact
 
 
@@ -1029,24 +1389,73 @@ class DataFrameCatManager(CatManager):
         self,
         df: pd.DataFrame | Artifact,
         columns: FieldAttr = Feature.name,
-        categoricals: dict[str, FieldAttr] | None = None,
-        verbosity: str = "hint",
-        organism: str | None = None,
+        categoricals: list[Feature] | dict[str, FieldAttr] | None = None,
         sources: dict[str, Record] | None = None,
     ) -> None:
-        if organism is not None and not isinstance(organism, str):
-            raise ValueError("organism must be a string such as 'human' or 'mouse'!")
-
-        settings.verbosity = verbosity
         self._non_validated = None
         super().__init__(
             dataset=df,
             columns_field=columns,
-            organism=organism,
             categoricals=categoricals,
             sources=sources,
         )
-        self._save_columns()
+        if columns == Feature.name:
+            if isinstance(self._categoricals, list):
+                values = [feature.name for feature in self._categoricals]
+            else:
+                values = list(self._categoricals.keys())
+            self._cat_columns["columns"] = CatColumn(
+                values_getter=values,
+                field=self._columns_field,
+                key="columns" if isinstance(self._dataset, pd.DataFrame) else "keys",
+                source=self._sources.get("columns"),
+            )
+            self._cat_columns["columns"].validate()
+        else:
+            # NOTE: for var_index right now
+            self._cat_columns["columns"] = CatColumn(
+                values_getter=lambda: self._dataset.columns,  # lambda ensures the inplace update
+                values_setter=lambda new_values: setattr(
+                    self._dataset, "columns", pd.Index(new_values)
+                ),
+                field=self._columns_field,
+                key="columns",
+                source=self._sources.get("columns"),
+            )
+        if isinstance(self._categoricals, list):
+            for feature in self._categoricals:
+                result = parse_dtype(feature.dtype)[
+                    0
+                ]  # TODO: support composite dtypes for categoricals
+                key = feature.name
+                field = result["field"]
+                self._cat_columns[key] = CatColumn(
+                    values_getter=lambda k=key: self._dataset[
+                        k
+                    ],  # Capture key as default argument
+                    values_setter=lambda new_values, k=key: self._dataset.__setitem__(
+                        k, new_values
+                    ),
+                    field=field,
+                    key=key,
+                    source=self._sources.get(key),
+                    feature=feature,
+                )
+        else:
+            # below is for backward compat of ln.Curator.from_df()
+            for key, field in self._categoricals.items():
+                self._cat_columns[key] = CatColumn(
+                    values_getter=lambda k=key: self._dataset[
+                        k
+                    ],  # Capture key as default argument
+                    values_setter=lambda new_values, k=key: self._dataset.__setitem__(
+                        k, new_values
+                    ),
+                    field=field,
+                    key=key,
+                    source=self._sources.get(key),
+                    feature=Feature.get(name=key),
+                )
 
     def lookup(self, public: bool = False) -> CatLookup:
         """Lookup categories.
@@ -1058,59 +1467,20 @@ class DataFrameCatManager(CatManager):
             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:
-        """Save column name records."""
-        # Always save features specified as the fields keys
-        update_registry(
-            values=list(self.categoricals.keys()),
-            field=self._columns_field,
-            key="columns" if isinstance(self._dataset, pd.DataFrame) else "keys",
-            validated_only=False,
-            source=self._sources.get("columns"),
-        )
-
-        # Save the rest of the columns based on validated_only
-        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" 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"),
-            )
-
-    @deprecated(new_name="is run by default")
-    def add_new_from_columns(self, organism: str | None = None, **kwargs):
-        pass  # pragma: no cover
-
     def validate(self) -> bool:
-        """Validate variables and categorical observations.
-
-        This method also registers the validated records in the current instance:
-        - from public sources
+        """Validate variables and categorical observations."""
+        self._validate_category_error_messages = ""  # reset the error messages
 
-        Args:
-            organism: The organism name.
+        validated = True
+        for _, cat_column in self._cat_columns.items():
+            cat_column.validate()
+            validated &= cat_column.is_validated
+        self._is_validated = validated
+        self._non_validated = {}  # so it's no longer None
 
-        Returns:
-            Whether the DataFrame is validated.
-        """
-        # add all validated records to the current instance
-        self._update_registry_all()
-        self._validate_category_error_messages = ""  # reset the error messages
-        self._is_validated, self._non_validated = validate_categories_in_df(  # type: ignore
-            self._dataset,
-            fields=self.categoricals,
-            sources=self._sources,
-            curator=self,
-            organism=self._organism,
-        )
         return self._is_validated
 
     def standardize(self, key: str) -> None:
@@ -1123,82 +1493,37 @@ class DataFrameCatManager(CatManager):
         """
         if self._artifact is not None:
             raise RuntimeError("can't mutate the dataset when an artifact is passed!")
-        # list is needed to avoid RuntimeError: dictionary changed size during iteration
-        avail_keys = list(self.non_validated.keys())
-        if len(avail_keys) == 0:
-            logger.warning("values are already standardized")
-            return
 
         if key == "all":
-            for k in avail_keys:
-                if k in self._categoricals:  # needed to exclude var_index
-                    syn_mapper = standardize_categories(
-                        self.non_validated[k],
-                        field=self._categoricals[k],
-                        source=self._sources.get(k),
-                    )
-                    self._dataset[k] = self._replace_synonyms(
-                        k, syn_mapper, self._dataset[k]
-                    )
-        else:
-            if key not in avail_keys:
-                if key in self._categoricals:
-                    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)}!"
-                    )
-            else:
-                if key in self._categoricals:  # needed to exclude var_index
-                    syn_mapper = standardize_categories(
-                        self.non_validated[key],
-                        field=self._categoricals[key],
-                        source=self._sources.get(key),
-                        organism=self._organism,
-                    )
-                    self._dataset[key] = self._replace_synonyms(
-                        key, syn_mapper, self._dataset[key]
-                    )
-
-    def _update_registry_all(self, validated_only: bool = True, **kwargs):
-        """Save labels for all features."""
-        for name in self.categoricals.keys():
-            self._update_registry(name, validated_only=validated_only, **kwargs)
-
-    def _update_registry(
-        self, categorical: str, validated_only: bool = True, **kwargs
-    ) -> None:
-        if categorical == "all":
-            self._update_registry_all(validated_only=validated_only, **kwargs)
-        else:
-            if categorical not in self.categoricals:
-                raise ValidationError(
-                    f"Feature {categorical} is not part of the fields!"
-                )
-            update_registry(
-                values=_flatten_unique(self._dataset[categorical]),
-                field=self.categoricals[categorical],
-                key=categorical,
-                validated_only=validated_only,
-                source=self._sources.get(categorical),
-                organism=self._organism,
+            logger.warning(
+                "'all' is deprecated, please pass a single key from `.non_validated.keys()` instead!"
             )
-            # adding new records removes them from non_validated
-            if not validated_only and self._non_validated:
-                self._non_validated.pop(categorical, None)  # type: ignore
+            for k in self.non_validated.keys():
+                self._cat_columns[k].standardize()
+        else:
+            self._cat_columns[key].standardize()
 
     def add_new_from(self, key: str, **kwargs):
         """Add validated & new categories.
 
         Args:
             key: The key referencing the slot in the DataFrame from which to draw terms.
-            organism: The organism name.
             **kwargs: Additional keyword arguments to pass to create new records
         """
         if len(kwargs) > 0 and key == "all":
             raise ValueError("Cannot pass additional arguments to 'all' key!")
-        self._update_registry(key, validated_only=False, **kwargs)
+        if key == "all":
+            logger.warning(
+                "'all' is deprecated, please pass a single key from `.non_validated.keys()` instead!"
+            )
+            for k in self.non_validated.keys():
+                self._cat_columns[k].add_new(**kwargs)
+        else:
+            self._cat_columns[key].add_new(**kwargs)
 
+    @deprecated(
+        new_name="Run.filter(transform=context.run.transform, output_artifacts=None)"
+    )
     def clean_up_failed_runs(self):
         """Clean up previous failed runs that don't save any outputs."""
         from lamindb.core._context import context
@@ -1218,8 +1543,6 @@ class AnnDataCatManager(CatManager):
         var_index: FieldAttr | None = None,
         categoricals: dict[str, FieldAttr] | None = None,
         obs_columns: FieldAttr = Feature.name,
-        verbosity: str = "hint",
-        organism: str | None = None,
         sources: dict[str, Record] | None = None,
     ) -> None:
         if isinstance(var_index, str):
@@ -1242,7 +1565,6 @@ class AnnDataCatManager(CatManager):
             dataset=data,
             categoricals=categoricals,
             sources=self._sources,
-            organism=organism,
             columns_field=var_index,
         )
         self._adata = self._dataset
@@ -1250,10 +1572,19 @@ class AnnDataCatManager(CatManager):
             df=self._adata.obs,
             categoricals=self.categoricals,
             columns=obs_columns,
-            verbosity=verbosity,
-            organism=None,
             sources=self._sources,
         )
+        self._cat_columns = self._obs_df_curator._cat_columns.copy()
+        if var_index is not None:
+            self._cat_columns["var_index"] = CatColumn(
+                values_getter=lambda: self._adata.var.index,
+                values_setter=lambda new_values: setattr(
+                    self._adata.var, "index", pd.Index(new_values)
+                ),
+                field=self._var_field,
+                key="var_index",
+                source=self._sources.get("var_index"),
+            )
 
     @property
     def var_index(self) -> FieldAttr:
@@ -1275,76 +1606,51 @@ class AnnDataCatManager(CatManager):
             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(
-        self,
-        validated_only: bool = True,
-    ):
-        """Save variable records."""
-        if self.var_index is not None:
-            update_registry(
-                values=list(self._adata.var.index),
-                field=self.var_index,
-                key="var_index",
-                validated_only=validated_only,
-                organism=self._organism,
-                source=self._sources.get("var_index"),
-            )
-
     def add_new_from(self, key: str, **kwargs):
         """Add validated & new categories.
 
         Args:
             key: The key referencing the slot in the DataFrame from which to draw terms.
-            organism: The organism name.
             **kwargs: Additional keyword arguments to pass to create new records
         """
-        self._obs_df_curator.add_new_from(key, **kwargs)
+        if key == "all":
+            logger.warning(
+                "'all' is deprecated, please pass a single key from `.non_validated.keys()` instead!"
+            )
+            for k in self.non_validated.keys():
+                self._cat_columns[k].add_new(**kwargs)
+        else:
+            self._cat_columns[key].add_new(**kwargs)
 
+    @deprecated(new_name="add_new_from('var_index')")
     def add_new_from_var_index(self, **kwargs):
         """Update variable records.
 
         Args:
-            organism: The organism name.
             **kwargs: Additional keyword arguments to pass to create new records.
         """
-        self._save_from_var_index(validated_only=False, **kwargs)
+        self.add_new_from(key="var_index", **kwargs)
 
     def validate(self) -> bool:
         """Validate categories.
 
         This method also registers the validated records in the current instance.
 
-        Args:
-            organism: The organism name.
-
         Returns:
             Whether the AnnData object is validated.
         """
         self._validate_category_error_messages = ""  # reset the error messages
 
-        # add all validated records to the current instance
-        self._save_from_var_index(validated_only=True)
-        if self.var_index is not None:
-            validated_var, non_validated_var = validate_categories(
-                self._adata.var.index,
-                field=self._var_field,
-                key="var_index",
-                source=self._sources.get("var_index"),
-                hint_print=".add_new_from_var_index()",
-                organism=self._organism,  # type: ignore
-            )
-        else:
-            validated_var = True
-            non_validated_var = []
-        validated_obs = self._obs_df_curator.validate()
-        self._non_validated = self._obs_df_curator._non_validated  # type: ignore
-        if len(non_validated_var) > 0:
-            self._non_validated["var_index"] = non_validated_var  # type: ignore
-        self._is_validated = validated_var and validated_obs
+        validated = True
+        for _, cat_column in self._cat_columns.items():
+            cat_column.validate()
+            validated &= cat_column.is_validated
+
+        self._non_validated = {}  # so it's no longer None
+        self._is_validated = validated
         return self._is_validated
 
     def standardize(self, key: str):
@@ -1360,23 +1666,17 @@ class AnnDataCatManager(CatManager):
         """
         if self._artifact is not None:
             raise RuntimeError("can't mutate the dataset when an artifact is passed!")
-        if key in self._adata.obs.columns or key == "all":
-            # standardize obs columns
-            self._obs_df_curator.standardize(key)
-        # in addition to the obs columns, standardize the var.index
-        if key == "var_index" or key == "all":
-            syn_mapper = standardize_categories(
-                self._adata.var.index,
-                field=self.var_index,
-                source=self._sources.get("var_index"),
-                organism=self._organism,
+        if key == "all":
+            logger.warning(
+                "'all' is deprecated, please pass a single key from `.non_validated.keys()` instead!"
             )
-            if "var_index" in self._non_validated:  # type: ignore
-                self._adata.var.index = self._replace_synonyms(
-                    "var_index", syn_mapper, self._adata.var.index
-                )
+            for k in self.non_validated.keys():
+                self._cat_columns[k].standardize()
+        else:
+            self._cat_columns[key].standardize()
 
 
+@deprecated(new_name="MuDataCurator")
 class MuDataCatManager(CatManager):
     """Categorical manager for `MuData`."""
 
@@ -1385,15 +1685,12 @@ class MuDataCatManager(CatManager):
         mdata: MuData | Artifact,
         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,
     ) -> None:
         super().__init__(
             dataset=mdata,
             categoricals={},
             sources=sources,
-            organism=organism,
         )
         self._columns_field = (
             var_index or {}
@@ -1402,25 +1699,20 @@ class MuDataCatManager(CatManager):
         self._verify_modality(self._var_fields.keys())
         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
         if "obs" in self._modalities:
             self._obs_df_curator = DataFrameCatManager(
                 df=self._dataset.obs,
                 columns=Feature.name,
                 categoricals=self._obs_fields.get("obs", {}),
-                verbosity=verbosity,
                 sources=self._sources.get("obs"),
-                organism=organism,
             )
         self._mod_adata_curators = {
             modality: AnnDataCatManager(
                 data=self._dataset[modality],
                 var_index=var_index.get(modality),
                 categoricals=self._obs_fields.get(modality),
-                verbosity=verbosity,
                 sources=self._sources.get(modality),
-                organism=organism,
             )
             for modality in self._modalities
             if modality != "obs"
@@ -1442,6 +1734,16 @@ class MuDataCatManager(CatManager):
         """Return the non-validated features and labels."""
         if self._non_validated is None:
             raise ValidationError("Please run validate() first!")
+        non_validated = {}
+        if (
+            self._obs_df_curator is not None
+            and len(self._obs_df_curator.non_validated) > 0
+        ):
+            non_validated["obs"] = self._obs_df_curator.non_validated
+        for modality, adata_curator in self._mod_adata_curators.items():
+            if len(adata_curator.non_validated) > 0:
+                non_validated[modality] = adata_curator.non_validated
+        self._non_validated = non_validated
         return self._non_validated
 
     def _verify_modality(self, modalities: Iterable[str]):
@@ -1487,35 +1789,18 @@ class MuDataCatManager(CatManager):
                 **{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")
-    def add_new_from_columns(
-        self,
-        modality: str,
-        column_names: list[str] | None = None,
-        **kwargs,
-    ):
-        pass  # pragma: no cover
-
+    @deprecated(new_name="add_new_from('var_index')")
     def add_new_from_var_index(self, modality: str, **kwargs):
         """Update variable records.
 
         Args:
             modality: The modality name.
-            organism: The organism name.
             **kwargs: Additional keyword arguments to pass to create new records.
         """
-        self._mod_adata_curators[modality].add_new_from_var_index(**kwargs)
-
-    def _update_registry_all(self):
-        """Update all registries."""
-        if self._obs_df_curator is not None:
-            self._obs_df_curator._update_registry_all(validated_only=True)
-        for _, adata_curator in self._mod_adata_curators.items():
-            adata_curator._obs_df_curator._update_registry_all(validated_only=True)
+        self._mod_adata_curators[modality].add_new_from(key="var_index", **kwargs)
 
     def add_new_from(
         self,
@@ -1528,39 +1813,30 @@ class MuDataCatManager(CatManager):
         Args:
             key: The key referencing the slot in the DataFrame.
             modality: The modality name.
-            organism: The organism name.
             **kwargs: Additional keyword arguments to pass to create new records.
         """
-        if len(kwargs) > 0 and key == "all":
-            raise ValueError("Cannot pass additional arguments to 'all' key!")
         modality = modality or "obs"
         if modality in self._mod_adata_curators:
             adata_curator = self._mod_adata_curators[modality]
             adata_curator.add_new_from(key=key, **kwargs)
         if modality == "obs":
             self._obs_df_curator.add_new_from(key=key, **kwargs)
+        if key == "var_index":
+            self._mod_adata_curators[modality].add_new_from(key=key, **kwargs)
 
     def validate(self) -> bool:
         """Validate categories."""
-        # add all validated records to the current instance
-        self._update_registry_all()
-        self._non_validated = {}  # type: ignore
-
         obs_validated = True
         if "obs" in self._modalities:
             logger.info('validating categoricals in "obs"...')
             obs_validated &= self._obs_df_curator.validate()
-            self._non_validated["obs"] = self._obs_df_curator.non_validated  # type: ignore
-            logger.print("")
 
         mods_validated = True
         for modality, adata_curator in self._mod_adata_curators.items():
             logger.info(f'validating categoricals in modality "{modality}"...')
             mods_validated &= adata_curator.validate()
-            if len(adata_curator.non_validated) > 0:
-                self._non_validated[modality] = adata_curator.non_validated  # type: ignore
-            logger.print("")
 
+        self._non_validated = {}  # so it's no longer None
         self._is_validated = obs_validated & mods_validated
         return self._is_validated
 
@@ -1592,6 +1868,7 @@ def _maybe_curation_keys_not_present(nonval_keys: list[str], name: str):
         )
 
 
+@deprecated(new_name="SpatialDataCurator")
 class SpatialDataCatManager(CatManager):
     """Categorical manager for `SpatialData`."""
 
@@ -1600,8 +1877,6 @@ class SpatialDataCatManager(CatManager):
         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, dict[str, Record]] | None = None,
         *,
         sample_metadata_key: str | None = "sample",
@@ -1610,7 +1885,6 @@ class SpatialDataCatManager(CatManager):
             dataset=sdata,
             categoricals={},
             sources=sources,
-            organism=organism,
         )
         if isinstance(sdata, Artifact):
             self._sdata = sdata.load()
@@ -1624,7 +1898,6 @@ class SpatialDataCatManager(CatManager):
         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(
@@ -1675,18 +1948,14 @@ class SpatialDataCatManager(CatManager):
                 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,
             )
             for table in self._table_keys
         }
@@ -1708,7 +1977,15 @@ class SpatialDataCatManager(CatManager):
         """Return the non-validated features and labels."""
         if self._non_validated is None:
             raise ValidationError("Please run validate() first!")
-        return self._non_validated
+        non_curated = {}
+        if len(self._sample_df_curator.non_validated) > 0:
+            non_curated[self._sample_metadata_key] = (
+                self._sample_df_curator.non_validated
+            )
+        for table, adata_curator in self._table_adata_curators.items():
+            if len(adata_curator.non_validated) > 0:
+                non_curated[table] = adata_curator.non_validated
+        return non_curated
 
     def _verify_accessor_exists(self, accessors: Iterable[str]) -> None:
         """Verify that the accessors exist (either a valid table or in attrs)."""
@@ -1734,38 +2011,19 @@ class SpatialDataCatManager(CatManager):
             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,
-            )
-        for _, adata_curator in self._table_adata_curators.items():
-            adata_curator._obs_df_curator._update_registry_all(
-                validated_only=True,
-            )
-
+    @deprecated(new_name="add_new_from('var_index')")
     def add_new_from_var_index(self, table: str, **kwargs) -> None:
         """Save new values from ``.var.index`` of table.
 
         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")
-
-            if len(self.non_validated[table].values()) == 0:
-                self.non_validated.pop(table)
+            self._table_adata_curators[table].add_new_from(key="var_index", **kwargs)
 
     def add_new_from(
         self,
@@ -1778,29 +2036,17 @@ class SpatialDataCatManager(CatManager):
         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.
         """
-        if self._non_validated is None:
-            raise ValidationError("Run .validate() first.")
-
-        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)
+            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 key == "var_index":
+            self._table_adata_curators[accessor].add_new_from(key=key, **kwargs)
 
     def standardize(self, key: str, accessor: str | None = None) -> None:
         """Replace synonyms with canonical values.
@@ -1835,42 +2081,27 @@ class SpatialDataCatManager(CatManager):
         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.
-
         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._non_validated = {}  # so it's no longer None
         self._is_validated = sample_validated & mods_validated
         return self._is_validated
 
@@ -1899,17 +2130,12 @@ class SpatialDataCatManager(CatManager):
             if not self._is_validated:
                 raise ValidationError("Dataset does not validate. Please curate.")
 
-        return save_artifact(
-            self._sdata,
-            description=description,
-            fields=self.categoricals,
+        self._artifact = Artifact.from_spatialdata(
+            self._dataset, key=key, description=description, revises=revises, run=run
+        ).save()
+        return annotate_artifact(
+            self._artifact,
             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,
         )
 
@@ -1923,7 +2149,6 @@ class TiledbsomaCatManager(CatManager):
         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, Record] | None = None,
     ):
         self._obs_fields = categoricals or {}
@@ -1935,7 +2160,6 @@ class TiledbsomaCatManager(CatManager):
         else:
             self._dataset = UPath(experiment_uri)
             self._artifact = None
-        self._organism = organism
         self._sources = sources or {}
 
         self._is_validated: bool | None = False
@@ -2004,28 +2228,14 @@ class TiledbsomaCatManager(CatManager):
 
         # register obs columns' names
         register_columns = list(self._obs_fields.keys())
-        update_registry(
-            values=register_columns,
+        # register categorical keys as features
+        cat_column = CatColumn(
+            values_getter=register_columns,
             field=self._columns_field,
             key="columns",
-            validated_only=False,
-            organism=self._organism,
             source=self._sources.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
-        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"),
-            )
+        cat_column.add_new()
 
     def validate(self):
         """Validate categories."""
@@ -2043,21 +2253,14 @@ class TiledbsomaCatManager(CatManager):
                 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,
+                cat_column = CatColumn(
+                    values_getter=var_ms_values,
                     field=field,
                     key=var_ms_key,
-                    organism=self._organism,
                     source=self._sources.get(var_ms_key),
                 )
+                cat_column.validate()
+                non_val = cat_column._non_validated
                 if len(non_val) > 0:
                     validated = False
                     self._non_validated_values[var_ms_key] = non_val
@@ -2072,21 +2275,14 @@ class TiledbsomaCatManager(CatManager):
                 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,
+                cat_column = CatColumn(
+                    values_getter=values,
                     field=field,
                     key=key,
-                    organism=self._organism,
                     source=self._sources.get(key),
                 )
+                cat_column.validate()
+                non_val = cat_column._non_validated
                 if len(non_val) > 0:
                     validated = False
                     self._non_validated_values[key] = non_val
@@ -2133,15 +2329,13 @@ class TiledbsomaCatManager(CatManager):
             values, field = self._non_validated_values_field(k)
             if len(values) == 0:
                 continue
-            update_registry(
-                values=values,
+            cat_column = CatColumn(
+                values_getter=values,
                 field=field,
                 key=k,
-                validated_only=False,
-                organism=self._organism,
                 source=self._sources.get(k),
-                **kwargs,
             )
+            cat_column.add_new()
             # update non-validated values list but keep the key there
             # it will be removed by .validate()
             if k in self._non_validated_values:
@@ -2173,7 +2367,6 @@ class TiledbsomaCatManager(CatManager):
             categoricals=self._obs_fields,
             slots={"columns": self._columns_field, **self._var_fields_flat},
             public=public,
-            organism=self._organism,
             sources=self._sources,
         )
 
@@ -2210,12 +2403,14 @@ class TiledbsomaCatManager(CatManager):
             else:
                 slot = lambda experiment: experiment.obs
                 slot_key = k
-            syn_mapper = standardize_categories(
-                values=values,
+            cat_column = CatColumn(
+                values_getter=values,
                 field=field,
+                key=k,
                 source=self._sources.get(k),
-                organism=self._organism,
             )
+            cat_column.validate()
+            syn_mapper = cat_column._synonyms
             if (n_syn_mapper := len(syn_mapper)) == 0:
                 continue
 
@@ -2300,14 +2495,12 @@ class TiledbsomaCatManager(CatManager):
                 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
@@ -2320,7 +2513,6 @@ class TiledbsomaCatManager(CatManager):
             labels = registry.from_values(
                 values=self._validated_values[key],
                 field=field,
-                organism=self._organism,
             )
             if len(labels) == 0:
                 continue
@@ -2359,12 +2551,10 @@ class CellxGeneAnnDataCatManager(AnnDataCatManager):
         self,
         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,
-        verbosity: str = "hint",
     ) -> None:
         """CELLxGENE schema curator.
 
@@ -2372,13 +2562,11 @@ class CellxGeneAnnDataCatManager(AnnDataCatManager):
             adata: Path to or AnnData object to curate against the CELLxGENE schema.
             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.
-            verbosity: The verbosity level.
         """
         import bionty as bt
 
@@ -2399,6 +2587,7 @@ class CellxGeneAnnDataCatManager(AnnDataCatManager):
         categoricals = _restrict_obs_fields(adata.obs, categoricals)
 
         # Configure sources
+        organism: Literal["human", "mouse"] = "human"
         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"
@@ -2413,16 +2602,9 @@ class CellxGeneAnnDataCatManager(AnnDataCatManager):
             data=adata,
             var_index=bt.Gene.ensembl_gene_id,
             categoricals=categoricals,
-            verbosity=verbosity,
-            organism=organism,
             sources=sources,
         )
 
-    @classmethod
-    @deprecated(new_name="cxg_categoricals_defaults")
-    def _get_categoricals_defaults(cls) -> dict[str, str]:
-        return cls.cxg_categoricals_defaults
-
     @classmethod
     def _get_cxg_categoricals(cls) -> dict[str, FieldAttr]:
         """Returns the CELLxGENE schema mapped fields."""
@@ -2695,7 +2877,6 @@ class PertAnnDataCatManager(CellxGeneAnnDataCatManager):
         pert_time: bool = True,
         *,
         cxg_schema_version: Literal["5.0.0", "5.1.0", "5.2.0"] = "5.2.0",
-        verbosity: str = "hint",
     ):
         """Initialize the curator with configuration and validation settings."""
         self._pert_time = pert_time
@@ -2708,10 +2889,8 @@ class PertAnnDataCatManager(CellxGeneAnnDataCatManager):
             adata=adata,
             categoricals=categoricals,
             defaults=categoricals_defaults,
-            organism=organism,
             extra_sources=self._configure_sources(adata),
             schema_version=cxg_schema_version,
-            verbosity=verbosity,
         )
 
     def _configure_categoricals(self, adata: ad.AnnData):
@@ -2952,7 +3131,7 @@ def get_current_filter_kwargs(registry: type[Record], kwargs: dict) -> dict:
 
 
 def get_organism_kwargs(
-    field: FieldAttr, organism: str | None = None
+    field: FieldAttr, organism: str | None = None, values: Any = None
 ) -> dict[str, str]:
     """Check if a registry needs an organism and return the organism name."""
     registry = field.field.model
@@ -2967,245 +3146,47 @@ def get_organism_kwargs(
                 return {"organism": organism or bt.settings.organism.name}
             else:
                 organism_record = get_organism_record_from_field(
-                    field, organism=organism
+                    field, organism=organism, values=values
                 )
                 if organism_record is not None:
                     return {"organism": organism_record.name}
     return {}
 
 
-def validate_categories(
-    values: Iterable[str],
-    field: FieldAttr,
-    key: str,
-    organism: str | None = None,
-    source: Record | None = None,
-    hint_print: str | None = None,
-    curator: CatManager | None = None,
-) -> tuple[bool, list[str]]:
-    """Validate ontology terms using LaminDB registries.
-
-    Args:
-        values: The values to validate.
-        field: The field attribute.
-        key: The key referencing the slot in the DataFrame.
-        organism: The organism name.
-        source: The source record.
-        standardize: Whether to standardize the values.
-        hint_print: The hint to print that suggests fixing non-validated values.
-    """
-    model_field = f"{field.field.model.__name__}.{field.field.name}"
-
-    def _log_mapping_info():
-        logger.indent = ""
-        logger.info(f'mapping "{key}" on {colors.italic(model_field)}')
-        logger.indent = "  "
-
-    registry = field.field.model
-
-    kwargs_current = get_current_filter_kwargs(
-        registry, {"organism": organism, "source": source}
-    )
-
-    # inspect values from the default instance
-    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 (BioRecord only)
-    values_validated = []
-    if hasattr(registry, "public"):
-        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}")'
-    non_validated = [i for i in non_validated if i not in values_validated]
-    n_non_validated = len(non_validated)
-    if n_non_validated == 0:
-        logger.indent = ""
-        logger.success(f'"{key}" is validated against {colors.italic(model_field)}')
-        return True, []
-    else:
-        are = "is" if n_non_validated == 1 else "are"
-        s = "" if n_non_validated == 1 else "s"
-        print_values = _format_values(non_validated)
-        warning_message = f"{colors.red(f'{n_non_validated} term{s}')} {are} not validated: {colors.red(print_values)}\n"
-        if syn_mapper:
-            s = "" if len(syn_mapper) == 1 else "s"
-            syn_mapper_print = _format_values(
-                [f'"{k}" → "{v}"' for k, v in syn_mapper.items()], sep=""
-            )
-            hint_msg = f'.standardize("{key}")'
-            warning_message += f"    {colors.yellow(f'{len(syn_mapper)} synonym{s}')} found: {colors.yellow(syn_mapper_print)}\n    → curate synonyms via {colors.cyan(hint_msg)}"
-        if n_non_validated > len(syn_mapper):
-            if syn_mapper:
-                warning_message += "\n    for remaining terms:\n"
-            warning_message += f"    → fix typos, remove non-existent values, or save terms via {colors.cyan(non_validated_hint_print)}"
-
-        if logger.indent == "":
-            _log_mapping_info()
-        logger.warning(warning_message)
-        if curator is not None:
-            curator._validate_category_error_messages = strip_ansi_codes(
-                warning_message
-            )
-        logger.indent = ""
-        return False, non_validated
-
-
-def standardize_categories(
-    values: Iterable[str],
-    field: FieldAttr,
-    organism: str | None = None,
-    source: Record | None = None,
-) -> dict:
-    """Get a synonym mapper."""
-    registry = field.field.model
-    if not hasattr(registry, "standardize"):
-        return {}
-    # standardize values using the default instance
-    syn_mapper = registry.standardize(
-        values,
-        field=field.field.name,
-        organism=organism,
-        source=source,
-        mute=True,
-        return_mapper=True,
-    )
-    return syn_mapper
-
-
-def validate_categories_in_df(
-    df: pd.DataFrame,
-    fields: dict[str, FieldAttr],
-    sources: dict[str, Record] = None,
-    curator: CatManager | None = None,
-    **kwargs,
-) -> tuple[bool, dict]:
-    """Validate categories in DataFrame columns using LaminDB registries."""
-    if not fields:
-        return True, {}
-
-    if sources is None:
-        sources = {}
-    validated = True
-    non_validated = {}
-    for key, field in fields.items():
-        is_val, non_val = validate_categories(
-            df[key],
-            field=field,
-            key=key,
-            source=sources.get(key),
-            curator=curator,
-            **kwargs,
-        )
-        validated &= is_val
-        if len(non_val) > 0:
-            non_validated[key] = non_val
-    return validated, non_validated
-
-
-def save_artifact(
-    data: pd.DataFrame | ScverseDataStructures,
+def annotate_artifact(
+    artifact: Artifact,
     *,
-    fields: dict[str, FieldAttr] | dict[str, dict[str, FieldAttr]],
-    index_field: FieldAttr | dict[str, FieldAttr] | None = None,
-    description: str | None = None,
-    organism: str | None = None,
-    key: str | None = None,
-    artifact: Artifact | None = None,
-    revises: Artifact | None = None,
-    run: Run | None = None,
     schema: Schema | None = None,
+    cat_columns: dict[str, CatColumn] | None = None,
+    index_field: FieldAttr | dict[str, FieldAttr] | None = None,
     **kwargs,
 ) -> Artifact:
-    """Save all metadata with an Artifact.
-
-    Args:
-        data: The object to save.
-        fields: A dictionary mapping obs_column to registry_field.
-        index_field: The registry field to validate variables index against.
-        description: A description of the artifact.
-        organism: The organism name.
-        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
 
-    if artifact is None:
-        if isinstance(data, pd.DataFrame):
-            artifact = Artifact.from_df(
-                data, description=description, key=key, revises=revises, run=run
-            )
-        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
-            )
-        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.save()
+    if cat_columns is None:
+        cat_columns = {}
 
-    def _add_labels(
-        data: pd.DataFrame | ScverseDataStructures,
-        artifact: Artifact,
-        fields: dict[str, FieldAttr],
-        feature_ref_is_name: bool | None = None,
-    ):
-        features = Feature.lookup().dict()
-        for key, field in fields.items():
-            feature = features.get(key)
-            registry = field.field.model
-            # 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)
-            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,
-            )
+    # annotate with labels
+    for key, cat_column in cat_columns.items():
+        if (
+            cat_column._field.field.model == Feature
+            or key == "columns"
+            or key == "var_index"
+        ):
+            continue
+        add_labels(
+            artifact,
+            records=cat_column.labels,
+            feature=cat_column.feature,
+            feature_ref_is_name=None,  # do not need anymore
+            label_ref_is_name=cat_column.label_ref_is_name,
+            from_curator=True,
+        )
 
+    # annotate with inferred feature sets
     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)
-            )
+            artifact.features._add_set_from_df(field=index_field)  # type: ignore
         case "AnnData":
             if schema is not None and "uns" in schema.slots:
                 uns_field = parse_cat_dtype(schema.slots["uns"].itype, is_itype=True)[
@@ -3214,80 +3195,25 @@ def save_artifact(
             else:
                 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)
+                var_field=index_field, uns_field=uns_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)
-                        ),
-                    )
+            artifact.features._add_set_from_mudata(var_fields=index_field)  # type: ignore
         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
         logger.important(f"go to https://lamin.ai/{slug}/artifact/{artifact.uid}")
     return artifact
 
 
+# TODO: need this function to support mutli-value columns
 def _flatten_unique(series: pd.Series[list[Any] | Any]) -> list[Any]:
     """Flatten a Pandas series containing lists or single items into a unique list of elements."""
     result = set()
@@ -3301,138 +3227,6 @@ def _flatten_unique(series: pd.Series[list[Any] | Any]) -> list[Any]:
     return list(result)
 
 
-def update_registry(
-    values: list[str],
-    field: FieldAttr,
-    key: str,
-    validated_only: bool = True,
-    df: pd.DataFrame | None = None,
-    organism: str | None = None,
-    dtype: str | None = None,
-    source: Record | None = None,
-    **create_kwargs,
-) -> None:
-    """Save features or labels records in the default instance..
-
-    Args:
-        values: A list of values to be saved as labels.
-        field: The FieldAttr object representing the field for which labels are being saved.
-        key: The name of the feature to save.
-        validated_only: If True, only save validated labels.
-        df: A DataFrame to save labels from.
-        organism: The organism name.
-        dtype: The type of the feature.
-        source: The source record.
-        **create_kwargs: Additional keyword arguments to pass to the registry model to create new records.
-    """
-    from lamindb.models.save import save as ln_save
-
-    registry = field.field.model
-    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
-
-    labels_saved: dict = {"from public": [], "new": []}
-
-    # 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)
-
-            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)
-
-    # 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,
-        key=key,
-        model_field=f"{registry.__name__}.{field.field.name}",
-        validated_only=validated_only,
-    )
-
-
-def log_saved_labels(
-    labels_saved: dict,
-    key: str,
-    model_field: str,
-    validated_only: bool = True,
-) -> None:
-    """Log the saved labels."""
-    from ..models._from_values import _format_values
-
-    model_field = colors.italic(model_field)
-    for k, labels in labels_saved.items():
-        if not labels:
-            continue
-        if k == "new" and validated_only:
-            continue
-        else:
-            k = "" if k == "new" else f"{colors.green(k)} "
-            # the term "transferred" stresses that this is always in the context of transferring
-            # labels from a public ontology or a different instance to the present instance
-            s = "s" if len(labels) > 1 else ""
-            logger.success(
-                f'added {len(labels)} record{s} {k}with {model_field} for "{key}": {_format_values(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.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):
     """Save an organism record."""
     import bionty as bt
@@ -3469,15 +3263,14 @@ def from_df(
     df: pd.DataFrame,
     categoricals: dict[str, FieldAttr] | None = None,
     columns: FieldAttr = Feature.name,
-    verbosity: str = "hint",
     organism: str | None = None,
 ) -> DataFrameCatManager:
+    if organism is not None:
+        logger.warning("organism is ignored, define it on the dtype level")
     return DataFrameCatManager(
         df=df,
         categoricals=categoricals,
         columns=columns,
-        verbosity=verbosity,
-        organism=organism,
     )
 
 
@@ -3488,17 +3281,16 @@ def from_anndata(
     var_index: FieldAttr,
     categoricals: dict[str, FieldAttr] | None = None,
     obs_columns: FieldAttr = Feature.name,
-    verbosity: str = "hint",
     organism: str | None = None,
     sources: dict[str, Record] | None = None,
 ) -> AnnDataCatManager:
+    if organism is not None:
+        logger.warning("organism is ignored, define it on the dtype level")
     return AnnDataCatManager(
         data=data,
         var_index=var_index,
         categoricals=categoricals,
         obs_columns=obs_columns,
-        verbosity=verbosity,
-        organism=organism,
         sources=sources,
     )
 
@@ -3509,15 +3301,16 @@ def from_mudata(
     mdata: MuData | UPathStr,
     var_index: dict[str, dict[str, FieldAttr]],
     categoricals: dict[str, FieldAttr] | None = None,
-    verbosity: str = "hint",
     organism: str | None = None,
 ) -> MuDataCatManager:
+    if not is_package_installed("mudata"):
+        raise ImportError("Please install mudata: pip install mudata")
+    if organism is not None:
+        logger.warning("organism is ignored, define it on the dtype level")
     return MuDataCatManager(
         mdata=mdata,
         var_index=var_index,
         categoricals=categoricals,
-        verbosity=verbosity,
-        organism=organism,
     )
 
 
@@ -3531,12 +3324,13 @@ def from_tiledbsoma(
     organism: str | None = None,
     sources: dict[str, Record] | None = None,
 ) -> TiledbsomaCatManager:
+    if organism is not None:
+        logger.warning("organism is ignored, define it on the dtype level")
     return TiledbsomaCatManager(
         experiment_uri=experiment_uri,
         var_index=var_index,
         categoricals=categoricals,
         obs_columns=obs_columns,
-        organism=organism,
         sources=sources,
     )
 
@@ -3549,21 +3343,17 @@ def from_spatialdata(
     categoricals: dict[str, dict[str, FieldAttr]] | None = None,
     organism: str | None = None,
     sources: dict[str, dict[str, Record]] | None = None,
-    verbosity: str = "hint",
     *,
     sample_metadata_key: str = "sample",
 ):
-    try:
-        import spatialdata
-    except ImportError as e:
-        raise ImportError("Please install spatialdata: pip install spatialdata") from e
-
+    if not is_package_installed("spatialdata"):
+        raise ImportError("Please install spatialdata: pip install spatialdata")
+    if organism is not None:
+        logger.warning("organism is ignored, define it on the dtype level")
     return SpatialDataCatManager(
         sdata=sdata,
         var_index=var_index,
         categoricals=categoricals,
-        verbosity=verbosity,
-        organism=organism,
         sources=sources,
         sample_metadata_key=sample_metadata_key,
     )