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

lamindb/curators/__init__.py

@@ -30,7 +30,7 @@ from __future__ import annotations
 import copy
 import re
 from itertools import chain
-from typing import TYPE_CHECKING, Any, Literal
+from typing import TYPE_CHECKING, Any, Callable, Literal
 
 import anndata as ad
 import lamindb_setup as ln_setup
@@ -65,7 +65,7 @@ from lamindb.models.artifact import (
     data_is_mudata,
     data_is_spatialdata,
 )
-from lamindb.models.feature import parse_dtype, parse_dtype_single_cat
+from lamindb.models.feature import parse_dtype, parse_cat_dtype
 from lamindb.models._from_values import _format_values
 
 from ..errors import InvalidArgument, ValidationError
@@ -106,16 +106,22 @@ class CatLookup:
         categoricals: dict[str, FieldAttr],
         slots: dict[str, FieldAttr] = None,
         public: bool = False,
+        organism: str | None = None,
+        sources: dict[str, Record] | None = None,
     ) -> None:
         slots = slots or {}
         self._categoricals = {**categoricals, **slots}
         self._public = public
+        self._organism = organism
+        self._sources = sources
 
     def __getattr__(self, name):
         if name in self._categoricals:
             registry = self._categoricals[name].field.model
             if self._public and hasattr(registry, "public"):
-                return registry.public().lookup()
+                return registry.public(
+                    organism=self._organism, source=self._sources.get(name)
+                ).lookup()
             else:
                 return registry.lookup()
         raise AttributeError(
@@ -126,7 +132,9 @@ class CatLookup:
         if name in self._categoricals:
             registry = self._categoricals[name].field.model
             if self._public and hasattr(registry, "public"):
-                return registry.public().lookup()
+                return registry.public(
+                    organism=self._organism, source=self._sources.get(name)
+                ).lookup()
             else:
                 return registry.lookup()
         raise AttributeError(
@@ -229,7 +237,7 @@ class Curator:
         """{}"""  # noqa: D415
         # Note that this docstring has to be consistent with the Artifact()
         # constructor signature
-        pass
+        pass  # pragma: no cover
 
 
 class SlotsCurator(Curator):
@@ -295,6 +303,28 @@ class SlotsCurator(Curator):
         )
 
 
+def check_dtype(expected_type) -> Callable:
+    """Creates a check function for Pandera that validates a column's dtype.
+
+    Args:
+        expected_type: String identifier for the expected type ('int', 'float', or 'num')
+
+    Returns:
+        A function that checks if a series has the expected dtype
+    """
+
+    def check_function(series):
+        if expected_type == "int":
+            is_valid = pd.api.types.is_integer_dtype(series.dtype)
+        elif expected_type == "float":
+            is_valid = pd.api.types.is_float_dtype(series.dtype)
+        elif expected_type == "num":
+            is_valid = pd.api.types.is_numeric_dtype(series.dtype)
+        return is_valid
+
+    return check_function
+
+
 class DataFrameCurator(Curator):
     # the example in the docstring is tested in test_curators_quickstart_example
     """Curator for `DataFrame`.
@@ -348,14 +378,33 @@ class DataFrameCurator(Curator):
             # populate features
             pandera_columns = {}
             for feature in schema.features.all():
-                pandera_dtype = (
-                    feature.dtype if not feature.dtype.startswith("cat") else "category"
-                )
-                pandera_columns[feature.name] = pandera.Column(
-                    pandera_dtype,
-                    nullable=feature.nullable,
-                    coerce=feature.coerce_dtype,
-                )
+                if feature.dtype in {"int", "float", "num"}:
+                    dtype = (
+                        self._dataset[feature.name].dtype
+                        if feature.name in self._dataset.columns
+                        else None
+                    )
+                    pandera_columns[feature.name] = pandera.Column(
+                        dtype=None,
+                        checks=pandera.Check(
+                            check_dtype(feature.dtype),
+                            element_wise=False,
+                            error=f"Column '{feature.name}' failed dtype check for '{feature.dtype}': got {dtype}",
+                        ),
+                        nullable=feature.nullable,
+                        coerce=feature.coerce_dtype,
+                    )
+                else:
+                    pandera_dtype = (
+                        feature.dtype
+                        if not feature.dtype.startswith("cat")
+                        else "category"
+                    )
+                    pandera_columns[feature.name] = pandera.Column(
+                        pandera_dtype,
+                        nullable=feature.nullable,
+                        coerce=feature.coerce_dtype,
+                    )
                 if feature.dtype.startswith("cat"):
                     categoricals[feature.name] = parse_dtype(feature.dtype)[0]["field"]
             self._pandera_schema = pandera.DataFrameSchema(
@@ -365,7 +414,7 @@ class DataFrameCurator(Curator):
             assert schema.itype is not None  # noqa: S101
         self._cat_manager = DataFrameCatManager(
             self._dataset,
-            columns=parse_dtype_single_cat(schema.itype, is_itype=True)["field"],
+            columns=parse_cat_dtype(schema.itype, is_itype=True)["field"],
             categoricals=categoricals,
         )
 
@@ -454,7 +503,7 @@ class DataFrameCurator(Curator):
         """{}"""  # noqa: D415
         if not self._is_validated:
             self.validate()  # raises ValidationError if doesn't validate
-        result = parse_dtype_single_cat(self._schema.itype, is_itype=True)
+        result = parse_cat_dtype(self._schema.itype, is_itype=True)
         return save_artifact(  # type: ignore
             self._dataset,
             description=description,
@@ -545,7 +594,7 @@ class AnnDataCurator(SlotsCurator):
                 slot_schema,
             )
             for slot, slot_schema in schema.slots.items()
-            if slot in {"obs", "var"}
+            if slot in {"obs", "var", "uns"}
         }
 
     @doc_args(SAVE_ARTIFACT_DOCSTRING)
@@ -560,14 +609,16 @@ 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=self.slots["obs"]._cat_manager.categoricals,
+            fields=categoricals,
             index_field=(
-                parse_dtype_single_cat(self.slots["var"]._schema.itype, is_itype=True)[
-                    "field"
-                ]
+                parse_cat_dtype(self.slots["var"]._schema.itype, is_itype=True)["field"]
                 if "var" in self._slots
                 else None
             ),
@@ -595,7 +646,7 @@ def _assign_var_fields_categoricals_multimodal(
         categoricals[modality] = {}
 
     if slot_type == "var":
-        var_field = parse_dtype_single_cat(slot_schema.itype, is_itype=True)["field"]
+        var_field = parse_cat_dtype(slot_schema.itype, is_itype=True)["field"]
         if modality is None:
             # This should rarely/never be used since tables should have different var fields
             var_fields[slot] = var_field  # pragma: no cover
@@ -870,10 +921,16 @@ class CatManager:
         # shared until here
         self._categoricals = categoricals or {}
         self._non_validated = None
-        self._organism = organism
         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
 
     @property
     def non_validated(self) -> dict[str, list[str]]:
@@ -918,7 +975,7 @@ class CatManager:
         Returns:
             The boolean `True` if the dataset is validated. Otherwise, a string with the error message.
         """
-        pass
+        pass  # pragma: no cover
 
     def standardize(self, key: str) -> None:
         """Replace synonyms with standardized values.
@@ -943,31 +1000,24 @@ class CatManager:
         run: Run | None = None,
     ) -> Artifact:
         """{}"""  # noqa: D415
-        from lamindb.core._settings import settings
-
+        # Make sure all labels are saved in the current instance
         if not self._is_validated:
             self.validate()  # returns True or False
             if not self._is_validated:  # need to raise error manually
                 raise ValidationError("Dataset does not validate. Please curate.")
 
-        # Make sure all labels are saved in the current instance
-        verbosity = settings.verbosity
-        try:
-            settings.verbosity = "warning"
-            self._artifact = save_artifact(  # type: ignore
-                self._dataset,
-                key=key,
-                description=description,
-                fields=self.categoricals,
-                index_field=self._columns_field,
-                artifact=self._artifact,
-                revises=revises,
-                run=run,
-                schema=None,
-                organism=self._organism,
-            )
-        finally:
-            settings.verbosity = verbosity
+        self._artifact = save_artifact(  # type: ignore
+            self._dataset,
+            key=key,
+            description=description,
+            fields=self.categoricals,
+            index_field=self._columns_field,
+            artifact=self._artifact,
+            revises=revises,
+            run=run,
+            schema=None,
+            organism=self._organism,
+        )
 
         return self._artifact
 
@@ -984,8 +1034,6 @@ class DataFrameCatManager(CatManager):
         organism: str | None = None,
         sources: dict[str, Record] | None = None,
     ) -> None:
-        from lamindb.core._settings import settings
-
         if organism is not None and not isinstance(organism, str):
             raise ValueError("organism must be a string such as 'human' or 'mouse'!")
 
@@ -1010,6 +1058,8 @@ 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:
@@ -1018,18 +1068,18 @@ class DataFrameCatManager(CatManager):
         update_registry(
             values=list(self.categoricals.keys()),
             field=self._columns_field,
-            key="columns",
+            key="columns" if isinstance(self._dataset, pd.DataFrame) else "keys",
             validated_only=False,
             source=self._sources.get("columns"),
         )
 
         # Save the rest of the columns based on validated_only
-        additional_columns = set(self._dataset.columns) - set(self.categoricals.keys())
+        additional_columns = set(self._dataset.keys()) - set(self.categoricals.keys())
         if additional_columns:
             update_registry(
                 values=list(additional_columns),
                 field=self._columns_field,
-                key="columns",
+                key="columns" if isinstance(self._dataset, pd.DataFrame) else "keys",
                 validated_only=validated_only,
                 df=self._dataset,  # Get the Feature type from df
                 source=self._sources.get("columns"),
@@ -1037,7 +1087,7 @@ class DataFrameCatManager(CatManager):
 
     @deprecated(new_name="is run by default")
     def add_new_from_columns(self, organism: str | None = None, **kwargs):
-        pass
+        pass  # pragma: no cover
 
     def validate(self) -> bool:
         """Validate variables and categorical observations.
@@ -1093,7 +1143,7 @@ class DataFrameCatManager(CatManager):
         else:
             if key not in avail_keys:
                 if key in self._categoricals:
-                    logger.info(f"No unstandardized values found for {key!r}")
+                    logger.warning(f"No non-standardized values found for {key!r}")
                 else:
                     raise KeyError(
                         f"{key!r} is not a valid key, available keys are: {_format_values(avail_keys)}!"
@@ -1173,7 +1223,9 @@ class AnnDataCatManager(CatManager):
         sources: dict[str, Record] | None = None,
     ) -> None:
         if isinstance(var_index, str):
-            raise TypeError("var_index parameter has to be a bionty field")
+            raise TypeError(
+                "var_index parameter has to be a field, e.g. Gene.ensembl_gene_id"
+            )
 
         if not data_is_anndata(data):
             raise TypeError("data has to be an AnnData object")
@@ -1223,6 +1275,8 @@ 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(
@@ -1433,6 +1487,8 @@ 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")
@@ -1442,7 +1498,7 @@ class MuDataCatManager(CatManager):
         column_names: list[str] | None = None,
         **kwargs,
     ):
-        pass
+        pass  # pragma: no cover
 
     def add_new_from_var_index(self, modality: str, **kwargs):
         """Update variable records.
@@ -1487,13 +1543,7 @@ class MuDataCatManager(CatManager):
     def validate(self) -> bool:
         """Validate categories."""
         # add all validated records to the current instance
-        verbosity = settings.verbosity
-        try:
-            settings.verbosity = "error"
-            self._update_registry_all()
-        finally:
-            settings.verbosity = verbosity
-
+        self._update_registry_all()
         self._non_validated = {}  # type: ignore
 
         obs_validated = True
@@ -1684,6 +1734,8 @@ 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:
@@ -1799,12 +1851,7 @@ class SpatialDataCatManager(CatManager):
             Whether the SpatialData object is validated.
         """
         # add all validated records to the current instance
-        verbosity = settings.verbosity
-        try:
-            settings.verbosity = "error"
-            self._update_registry_all()
-        finally:
-            settings.verbosity = verbosity
+        self._update_registry_all()
 
         self._non_validated = {}  # type: ignore
 
@@ -1957,15 +2004,12 @@ class TiledbsomaCatManager(CatManager):
 
         # register obs columns' names
         register_columns = list(self._obs_fields.keys())
-        organism = configure_organism(
-            self._columns_field.field.model, self._organism
-        ).get("organism")
         update_registry(
             values=register_columns,
             field=self._columns_field,
             key="columns",
             validated_only=False,
-            organism=organism,
+            organism=self._organism,
             source=self._sources.get("columns"),
         )
         additional_columns = [k for k in valid_obs_keys if k not in register_columns]
@@ -1979,7 +2023,7 @@ class TiledbsomaCatManager(CatManager):
                 field=self._columns_field,
                 key="columns",
                 validated_only=True,
-                organism=organism,
+                organism=self._organism,
                 source=self._sources.get("columns"),
             )
 
@@ -1999,22 +2043,19 @@ class TiledbsomaCatManager(CatManager):
                 var_ms_values = (
                     var_ms.read(column_names=[key]).concat()[key].to_pylist()
                 )
-                organism = configure_organism(field.field.model, self._organism).get(
-                    "organism"
-                )
                 update_registry(
                     values=var_ms_values,
                     field=field,
                     key=var_ms_key,
                     validated_only=True,
-                    organism=organism,
+                    organism=self._organism,
                     source=self._sources.get(var_ms_key),
                 )
                 _, non_val = validate_categories(
                     values=var_ms_values,
                     field=field,
                     key=var_ms_key,
-                    organism=organism,
+                    organism=self._organism,
                     source=self._sources.get(var_ms_key),
                 )
                 if len(non_val) > 0:
@@ -2031,22 +2072,19 @@ class TiledbsomaCatManager(CatManager):
                 values = pa.compute.unique(
                     obs.read(column_names=[key]).concat()[key]
                 ).to_pylist()
-                organism = configure_organism(field.field.model, self._organism).get(
-                    "organism"
-                )
                 update_registry(
                     values=values,
                     field=field,
                     key=key,
                     validated_only=True,
-                    organism=organism,
+                    organism=self._organism,
                     source=self._sources.get(key),
                 )
                 _, non_val = validate_categories(
                     values=values,
                     field=field,
                     key=key,
-                    organism=organism,
+                    organism=self._organism,
                     source=self._sources.get(key),
                 )
                 if len(non_val) > 0:
@@ -2095,15 +2133,12 @@ class TiledbsomaCatManager(CatManager):
             values, field = self._non_validated_values_field(k)
             if len(values) == 0:
                 continue
-            organism = configure_organism(field.field.model, self._organism).get(
-                "organism"
-            )
             update_registry(
                 values=values,
                 field=field,
                 key=k,
                 validated_only=False,
-                organism=organism,
+                organism=self._organism,
                 source=self._sources.get(k),
                 **kwargs,
             )
@@ -2138,6 +2173,8 @@ class TiledbsomaCatManager(CatManager):
             categoricals=self._obs_fields,
             slots={"columns": self._columns_field, **self._var_fields_flat},
             public=public,
+            organism=self._organism,
+            sources=self._sources,
         )
 
     def standardize(self, key: str):
@@ -2173,16 +2210,11 @@ class TiledbsomaCatManager(CatManager):
             else:
                 slot = lambda experiment: experiment.obs
                 slot_key = k
-            # errors if public ontology and the model has no organism
-            # has to be fixed in bionty
-            organism = configure_organism(field.field.model, self._organism).get(
-                "organism"
-            )
             syn_mapper = standardize_categories(
                 values=values,
                 field=field,
                 source=self._sources.get(k),
-                organism=organism,
+                organism=self._organism,
             )
             if (n_syn_mapper := len(syn_mapper)) == 0:
                 continue
@@ -2259,9 +2291,6 @@ class TiledbsomaCatManager(CatManager):
 
         feature_sets = {}
         if len(self._obs_fields) > 0:
-            organism = configure_organism(
-                self._columns_field.field.model, self._organism
-            ).get("organism")
             empty_dict = {field.name: [] for field in self._obs_pa_schema}  # type: ignore
             mock_df = pa.Table.from_pydict(
                 empty_dict, schema=self._obs_pa_schema
@@ -2271,17 +2300,14 @@ class TiledbsomaCatManager(CatManager):
                 df=mock_df,
                 field=self._columns_field,
                 mute=True,
-                organism=organism,
+                organism=self._organism,
             )
         for ms in self._var_fields:
             var_key, var_field = self._var_fields[ms]
-            organism = configure_organism(var_field.field.model, self._organism).get(
-                "organism"
-            )
             feature_sets[f"{ms}__var"] = Schema.from_values(
                 values=self._validated_values[f"{ms}__{var_key}"],
                 field=var_field,
-                organism=organism,
+                organism=self._organism,
                 raise_validation_error=False,
             )
         artifact._staged_feature_sets = feature_sets
@@ -2291,11 +2317,10 @@ class TiledbsomaCatManager(CatManager):
         for key, field in self._obs_fields.items():
             feature = features.get(key)
             registry = field.field.model
-            organism = configure_organism(field.field.model, self._organism).get(
-                "organism"
-            )
             labels = registry.from_values(
-                values=self._validated_values[key], field=field, organism=organism
+                values=self._validated_values[key],
+                field=field,
+                organism=self._organism,
             )
             if len(labels) == 0:
                 continue
@@ -2722,10 +2747,11 @@ class PertAnnDataCatManager(CellxGeneAnnDataCatManager):
         import wetlab as wl
 
         sources = {}
-        if "cell_line" in adata.obs.columns:
-            sources["cell_line"] = bt.Source.filter(
-                entity="bionty.CellLine", name="depmap"
-            ).first()
+        # # do not yet specify cell_line source
+        # if "cell_line" in adata.obs.columns:
+        #     sources["cell_line"] = bt.Source.filter(
+        #         entity="bionty.CellLine", name="depmap"
+        #     ).first()
         if "pert_compound" in adata.obs.columns:
             with logger.mute():
                 chebi_source = bt.Source.filter(
@@ -2908,35 +2934,43 @@ def get_current_filter_kwargs(registry: type[Record], kwargs: dict) -> dict:
     source = kwargs.get("source")
     organism = kwargs.get("organism")
     filter_kwargs = kwargs.copy()
-    try:
-        verbosity = settings.verbosity
-        settings.verbosity = "error"
-        if isinstance(organism, Record) and organism._state.db != "default":
-            if db is None or db == "default":
-                organism_default = copy.copy(organism)
-                # save the organism record in the default database
-                organism_default.save()
-                filter_kwargs["organism"] = organism_default
-        if isinstance(source, Record) and source._state.db != "default":
-            if db is None or db == "default":
-                source_default = copy.copy(source)
-                # save the source record in the default database
-                source_default.save()
-                filter_kwargs["source"] = source_default
-    finally:
-        settings.verbosity = verbosity
+
+    if isinstance(organism, Record) and organism._state.db != "default":
+        if db is None or db == "default":
+            organism_default = copy.copy(organism)
+            # save the organism record in the default database
+            organism_default.save()
+            filter_kwargs["organism"] = organism_default
+    if isinstance(source, Record) and source._state.db != "default":
+        if db is None or db == "default":
+            source_default = copy.copy(source)
+            # save the source record in the default database
+            source_default.save()
+            filter_kwargs["source"] = source_default
+
     return filter_kwargs
 
 
-def configure_organism(registry: Record, organism: str | None = None) -> dict[str, str]:
+def get_organism_kwargs(
+    field: FieldAttr, organism: str | None = None
+) -> dict[str, str]:
     """Check if a registry needs an organism and return the organism name."""
-    from ..models._from_values import _is_organism_required
-
-    if _is_organism_required(registry):
+    registry = field.field.model
+    if registry.__base__.__name__ == "BioRecord":
         import bionty as bt
+        from bionty._organism import is_organism_required
 
-        if organism is not None or bt.settings.organism is not None:
-            return {"organism": organism or bt.settings.organism.name}
+        from ..models._from_values import get_organism_record_from_field
+
+        if is_organism_required(registry):
+            if organism is not None or bt.settings.organism is not None:
+                return {"organism": organism or bt.settings.organism.name}
+            else:
+                organism_record = get_organism_record_from_field(
+                    field, organism=organism
+                )
+                if organism_record is not None:
+                    return {"organism": organism_record.name}
     return {}
 
 
@@ -2969,17 +3003,16 @@ def validate_categories(
 
     registry = field.field.model
 
-    # {"organism": organism_name}
-    kwargs = configure_organism(registry, organism)
-    kwargs.update({"source": source} if source else {})
-    kwargs_current = get_current_filter_kwargs(registry, kwargs)
+    kwargs_current = get_current_filter_kwargs(
+        registry, {"organism": organism, "source": source}
+    )
 
     # inspect values from the default instance
     inspect_result = registry.inspect(values, field=field, mute=True, **kwargs_current)
     non_validated = inspect_result.non_validated
     syn_mapper = inspect_result.synonyms_mapper
 
-    # inspect the non-validated values from public (bionty only)
+    # inspect the non-validated values from public (BioRecord only)
     values_validated = []
     if hasattr(registry, "public"):
         public_records = registry.from_values(
@@ -3134,18 +3167,6 @@ def save_artifact(
             )
     artifact.save()
 
-    if organism is not None and index_field is not None:
-        feature_kwargs = configure_organism(
-            (
-                list(index_field.values())[0].field.model
-                if isinstance(index_field, dict)
-                else index_field.field.model
-            ),
-            organism,
-        )
-    else:
-        feature_kwargs = {}
-
     def _add_labels(
         data: pd.DataFrame | ScverseDataStructures,
         artifact: Artifact,
@@ -3156,19 +3177,15 @@ def save_artifact(
         for key, field in fields.items():
             feature = features.get(key)
             registry = field.field.model
-            filter_kwargs = configure_organism(registry, organism)
-            filter_kwargs_current = get_current_filter_kwargs(registry, filter_kwargs)
+            # we don't need source here because all records are already in the DB
+            filter_kwargs = get_current_filter_kwargs(registry, {"organism": organism})
             df = data if isinstance(data, pd.DataFrame) else data.obs
             # multi-value columns are separated by "|"
             if not df[key].isna().all() and df[key].str.contains("|").any():
                 values = df[key].str.split("|").explode().unique()
             else:
                 values = df[key].unique()
-            labels = registry.from_values(
-                values,
-                field=field,
-                **filter_kwargs_current,
-            )
+            labels = registry.from_values(values, field=field, **filter_kwargs)
             if len(labels) == 0:
                 continue
             label_ref_is_name = None
@@ -3185,20 +3202,26 @@ def save_artifact(
 
     match artifact.otype:
         case "DataFrame":
-            artifact.features._add_set_from_df(field=index_field, **feature_kwargs)  # type: ignore
+            artifact.features._add_set_from_df(field=index_field, organism=organism)  # type: ignore
             _add_labels(
                 data, artifact, fields, feature_ref_is_name=_ref_is_name(index_field)
             )
         case "AnnData":
+            if schema is not None and "uns" in schema.slots:
+                uns_field = parse_cat_dtype(schema.slots["uns"].itype, is_itype=True)[
+                    "field"
+                ]
+            else:
+                uns_field = None
             artifact.features._add_set_from_anndata(  # type: ignore
-                var_field=index_field, **feature_kwargs
+                var_field=index_field, uns_field=uns_field, organism=organism
             )
             _add_labels(
                 data, artifact, fields, feature_ref_is_name=_ref_is_name(index_field)
             )
         case "MuData":
             artifact.features._add_set_from_mudata(  # type: ignore
-                var_fields=index_field, **feature_kwargs
+                var_fields=index_field, organism=organism
             )
             for modality, modality_fields in fields.items():
                 column_field_modality = index_field.get(modality)
@@ -3228,7 +3251,7 @@ def save_artifact(
             artifact.features._add_set_from_spatialdata(  # type: ignore
                 sample_metadata_key=kwargs.get("sample_metadata_key", "sample"),
                 var_fields=index_field,
-                **feature_kwargs,
+                organism=organism,
             )
             sample_metadata_key = kwargs.get("sample_metadata_key", "sample")
             for accessor, accessor_fields in fields.items():
@@ -3305,77 +3328,63 @@ def update_registry(
     from lamindb.models.save import save as ln_save
 
     registry = field.field.model
-    filter_kwargs = configure_organism(registry, organism)
-    filter_kwargs.update({"source": source} if source else {})
+    filter_kwargs = get_current_filter_kwargs(
+        registry, {"organism": organism, "source": source}
+    )
     values = [i for i in values if isinstance(i, str) and i]
     if not values:
         return
 
-    verbosity = settings.verbosity
-    try:
-        settings.verbosity = "error"
-        labels_saved: dict = {"from public": [], "new": []}
+    labels_saved: dict = {"from public": [], "new": []}
 
-        # inspect the default instance and save validated records from public
-        filter_kwargs_current = get_current_filter_kwargs(registry, filter_kwargs)
-        existing_and_public_records = registry.from_values(
-            list(values), field=field, **filter_kwargs_current
-        )
-        existing_and_public_labels = [
-            getattr(r, field.field.name) for r in existing_and_public_records
-        ]
-        # public records that are not already in the database
-        public_records = [r for r in existing_and_public_records if r._state.adding]
-        # here we check to only save the public records if they are from the specified source
-        # we check the uid because r.source and source can be from different instances
-        if source:
-            public_records = [r for r in public_records if r.source.uid == source.uid]
-        if len(public_records) > 0:
-            settings.verbosity = "info"
-            logger.info(f"saving validated records of '{key}'")
-            settings.verbosity = "error"
-            ln_save(public_records)
-            labels_saved["from public"] = [
-                getattr(r, field.field.name) for r in public_records
-            ]
-        # non-validated records from the default instance
-        non_validated_labels = [
-            i for i in values if i not in existing_and_public_labels
+    # inspect the default instance and save validated records from public
+    existing_and_public_records = registry.from_values(
+        list(values), field=field, **filter_kwargs, mute=True
+    )
+    existing_and_public_labels = [
+        getattr(r, field.field.name) for r in existing_and_public_records
+    ]
+    # public records that are not already in the database
+    public_records = [r for r in existing_and_public_records if r._state.adding]
+    # here we check to only save the public records if they are from the specified source
+    # we check the uid because r.source and source can be from different instances
+    if source:
+        public_records = [r for r in public_records if r.source.uid == source.uid]
+    if len(public_records) > 0:
+        logger.info(f"saving validated records of '{key}'")
+        ln_save(public_records)
+        labels_saved["from public"] = [
+            getattr(r, field.field.name) for r in public_records
         ]
+    # non-validated records from the default instance
+    non_validated_labels = [i for i in values if i not in existing_and_public_labels]
+
+    # save non-validated/new records
+    labels_saved["new"] = non_validated_labels
+    if not validated_only:
+        non_validated_records: RecordList[Any] = []  # type: ignore
+        if df is not None and registry == Feature:
+            nonval_columns = Feature.inspect(df.columns, mute=True).non_validated
+            non_validated_records = Feature.from_df(df.loc[:, nonval_columns])
+        else:
+            if (
+                organism
+                and hasattr(registry, "organism")
+                and registry._meta.get_field("organism").is_relation
+            ):
+                # make sure organism record is saved to the current instance
+                create_kwargs["organism"] = _save_organism(name=organism)
 
-        # save non-validated/new records
-        labels_saved["new"] = non_validated_labels
-        if not validated_only:
-            non_validated_records: RecordList[Any] = []  # type: ignore
-            if df is not None and registry == Feature:
-                nonval_columns = Feature.inspect(df.columns, mute=True).non_validated
-                non_validated_records = Feature.from_df(df.loc[:, nonval_columns])
-            else:
-                if "organism" in filter_kwargs:
-                    # make sure organism record is saved to the current instance
-                    filter_kwargs["organism"] = _save_organism(name=organism)
-                init_kwargs = {}
-                for value in labels_saved["new"]:
-                    init_kwargs[field.field.name] = value
-                    if registry == Feature:
-                        init_kwargs["dtype"] = "cat" if dtype is None else dtype
-                    non_validated_records.append(
-                        registry(
-                            **init_kwargs,
-                            **{k: v for k, v in filter_kwargs.items() if k != "source"},
-                            **{
-                                k: v for k, v in create_kwargs.items() if k != "sources"
-                            },
-                        )
-                    )
-            ln_save(non_validated_records)
-
-        # save parent labels for ulabels, for example a parent label "project" for label "project001"
-        if registry == ULabel and field.field.name == "name":
-            save_ulabels_type(values, field=field, key=key)
+            for value in labels_saved["new"]:
+                init_kwargs = {field.field.name: value}
+                if registry == Feature:
+                    init_kwargs["dtype"] = "cat" if dtype is None else dtype
+                non_validated_records.append(registry(**init_kwargs, **create_kwargs))
+        ln_save(non_validated_records)
 
-    finally:
-        settings.verbosity = verbosity
+    # save parent labels for ulabels, for example a parent label "project" for label "project001"
+    if registry == ULabel and field.field.name == "name":
+        save_ulabels_type(values, field=field, key=key)
 
     log_saved_labels(
         labels_saved,
@@ -3433,8 +3442,9 @@ def _save_organism(name: str):
         organism = bt.Organism.from_source(name=name)
         if organism is None:
             raise ValidationError(
-                f'Organism "{name}" not found\n'
-                f'      → please save it: bt.Organism(name="{name}").save()'
+                f'Organism "{name}" not found from public reference\n'
+                f'      → please save it from a different source: bt.Organism.from_source(name="{name}", source).save()'
+                f'      → or manually save it without source: bt.Organism(name="{name}").save()'
             )
         organism.save()
     return organism