lamindb 0.77.3__py3-none-any.whl → 1.0rc1__py3-none-any.whl

lamindb/core/types.py

@@ -1,27 +1,6 @@
-"""Types.
-
-Central object types.
-
-.. autosummary::
-   :toctree: .
-
-   ArtifactType
-   TransformType
-   FeatureDtype
-
-Basic types.
-
-.. autosummary::
-   :toctree: .
-
-   UPathStr
-   StrField
-   ListLike
-"""
-
 from lamindb_setup.core.types import UPathStr
-from lnschema_core.types import (
-    ArtifactType,
+
+from lamindb.base.types import (
     FeatureDtype,
     FieldAttr,
     ListLike,

lamindb/core/versioning.py

@@ -5,10 +5,11 @@ from typing import TYPE_CHECKING, Literal
 from lamin_utils import logger
 from lamin_utils._base62 import increment_base62
 from lamindb_setup.core.upath import LocalPathClasses, UPath
-from lnschema_core import ids
+
+from lamindb.base import ids
 
 if TYPE_CHECKING:
-    from lnschema_core.models import IsVersioned
+    from lamindb.models import IsVersioned
 
 
 def message_update_key_in_version_family(
@@ -132,15 +133,18 @@ def get_new_path_from_uid(old_path: UPath, old_uid: str, new_uid: str):
 def process_revises(
     revises: IsVersioned | None,
     version: str | None,
-    name: str | None,
+    key: str | None,
+    description: str | None,
     type: type[IsVersioned],
-) -> tuple[str, str, str, IsVersioned | None]:
+) -> tuple[str, str, str, str, IsVersioned | None]:
     if revises is not None and not isinstance(revises, type):
         raise TypeError(f"`revises` has to be of type `{type.__name__}`")
     uid, revises = create_uid(
         revises=revises, version=version, n_full_id=type._len_full_uid
     )
     if revises is not None:
-        if name is None:
-            name = revises.name
-    return uid, version, name, revises
+        if description is None:
+            description = revises.description
+        if key is None:
+            key = revises.key
+    return uid, version, key, description, revises

lamindb/{_curate.py → curators/__init__.py}

@@ -12,25 +12,30 @@ import pyarrow as pa
 from lamin_utils import colors, logger
 from lamindb_setup.core._docs import doc_args
 from lamindb_setup.core.upath import UPath
-from lnschema_core import (
+
+from lamindb.models import (
     Artifact,
     Feature,
-    FeatureSet,
     Record,
     Run,
+    Schema,
     ULabel,
 )
 
-from ._from_values import _format_values
-from .core.exceptions import ValidationError
+from .._from_values import _format_values
+from ..core.exceptions import ValidationError
 
 if TYPE_CHECKING:
     from collections.abc import Iterable
     from typing import Any
 
     from lamindb_setup.core.types import UPathStr
-    from lnschema_core.types import FieldAttr
     from mudata import MuData
+    from spatialdata import SpatialData
+
+    from lamindb.base.types import FieldAttr
+
+    from ._spatial import SpatialDataCurator
 
 
 class CurateLookup:
@@ -209,6 +214,9 @@ class DataFrameCurator(BaseCurator):
     ) -> 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'!")
+
         self._df = df
         self._fields = categoricals or {}
         self._columns_field = columns
@@ -557,7 +565,7 @@ class AnnDataCurator(DataFrameCurator):
         if isinstance(var_index, str):
             raise TypeError("var_index parameter has to be a bionty field")
 
-        from ._artifact import data_is_anndata
+        from .._artifact import data_is_anndata
 
         if sources is None:
             sources = {}
@@ -1156,6 +1164,9 @@ class SOMACurator(BaseCurator):
         # filled by _check_save_keys
         self._n_obs: int | None = None
         self._valid_obs_keys: list[str] | None = None
+        self._obs_pa_schema: pa.lib.Schema | None = (
+            None  # this is needed to create the obs feature set
+        )
         self._valid_var_keys: list[str] | None = None
         self._var_fields_flat: dict[str, FieldAttr] | None = None
         self._check_save_keys()
@@ -1168,7 +1179,10 @@ class SOMACurator(BaseCurator):
         with _open_tiledbsoma(self._experiment_uri, mode="r") as experiment:
             experiment_obs = experiment.obs
             self._n_obs = len(experiment_obs)
-            valid_obs_keys = [k for k in experiment_obs.keys() if k != "soma_joinid"]
+            self._obs_pa_schema = experiment_obs.schema
+            valid_obs_keys = [
+                k for k in self._obs_pa_schema.names if k != "soma_joinid"
+            ]
             self._valid_obs_keys = valid_obs_keys
 
             valid_var_keys = []
@@ -1525,34 +1539,39 @@ class SOMACurator(BaseCurator):
                 run=run,
             )
             artifact.n_observations = self._n_obs
-            artifact._accessor = "tiledbsoma"
+            artifact.otype = "tiledbsoma"
             artifact.save()
         else:
             artifact = self._artifact
 
-        feature_sets = {}
+        _schemas_m2m = {}
         if len(self._obs_fields) > 0:
             organism = check_registry_organism(
                 self._columns_field.field.model, self._organism
             ).get("organism")
-            feature_sets["obs"] = FeatureSet.from_values(
-                values=list(self._obs_fields.keys()),
+            empty_dict = {field.name: [] for field in self._obs_pa_schema}  # type: ignore
+            mock_df = pa.Table.from_pydict(
+                empty_dict, schema=self._obs_pa_schema
+            ).to_pandas()
+            # in parallel to https://github.com/laminlabs/lamindb/blob/2a1709990b5736b480c6de49c0ada47fafc8b18d/lamindb/core/_feature_manager.py#L549-L554
+            _schemas_m2m["obs"] = Schema.from_df(
+                df=mock_df,
                 field=self._columns_field,
+                mute=True,
                 organism=organism,
-                raise_validation_error=False,
             )
         for ms in self._var_fields:
             var_key, var_field = self._var_fields[ms]
             organism = check_registry_organism(
                 var_field.field.model, self._organism
             ).get("organism")
-            feature_sets[f"{ms}__var"] = FeatureSet.from_values(
+            _schemas_m2m[f"{ms}__var"] = Schema.from_values(
                 values=self._validated_values[f"{ms}__{var_key}"],
                 field=var_field,
                 organism=organism,
                 raise_validation_error=False,
             )
-        artifact._feature_sets = feature_sets
+        artifact._staged__schemas_m2m = _schemas_m2m
 
         feature_ref_is_name = _ref_is_name(self._columns_field)
         features = Feature.lookup().dict()
@@ -1698,6 +1717,80 @@ class Curator(BaseCurator):
             exclude=exclude,
         )
 
+    @classmethod
+    def from_spatialdata(
+        cls,
+        sdata: SpatialData,
+        var_index: dict[str, FieldAttr],
+        categoricals: dict[str, dict[str, FieldAttr]] | None = None,
+        using_key: str | None = None,
+        organism: str | None = None,
+        sources: dict[str, dict[str, Record]] | None = None,
+        exclude: dict[str, dict] | None = None,
+        verbosity: str = "hint",
+        *,
+        sample_metadata_key: str = "sample",
+    ) -> SpatialDataCurator:
+        """Curation flow for a ``Spatialdata`` object.
+
+        See also :class:`~lamindb.Curator`.
+
+        Note that if genes or other measurements are removed from the SpatialData object,
+        the object should be recreated.
+
+        In the following docstring, an accessor refers to either a ``.table`` key or the ``sample_metadata_key``.
+
+        Args:
+            sdata: The SpatialData object to curate.
+            var_index: A dictionary mapping table keys to the ``.var`` indices.
+            categoricals: A nested dictionary mapping an accessor to dictionaries that map columns to a registry field.
+            using_key: A reference LaminDB instance.
+            organism: The organism name.
+            sources: A dictionary mapping an accessor to dictionaries that map columns to Source records.
+            exclude: A dictionary mapping an accessor to dictionaries of column names to values to exclude from validation.
+                When specific :class:`~bionty.Source` instances are pinned and may lack default values (e.g., "unknown" or "na"),
+                using the exclude parameter ensures they are not validated.
+            verbosity: The verbosity level of the logger.
+            sample_metadata_key: The key in ``.attrs`` that stores the sample level metadata.
+
+        Examples:
+            >>> import lamindb as ln
+            >>> import bionty as bt
+            >>> curator = ln.Curator.from_spatialdata(
+            ...     sdata,
+            ...     var_index={
+            ...         "table_1": bt.Gene.ensembl_gene_id,
+            ...     },
+            ...     categoricals={
+            ...         "table1":
+            ...             {"cell_type_ontology_id": bt.CellType.ontology_id, "donor_id": ln.ULabel.name},
+            ...         "sample":
+            ...             {"experimental_factor": bt.ExperimentalFactor.name},
+            ...     },
+            ...     organism="human",
+            ... )
+        """
+        try:
+            import spatialdata
+        except ImportError as e:
+            raise ImportError(
+                "Please install spatialdata: pip install spatialdata"
+            ) from e
+
+        from ._spatial import SpatialDataCurator
+
+        return SpatialDataCurator(
+            sdata=sdata,
+            var_index=var_index,
+            categoricals=categoricals,
+            using_key=using_key,
+            verbosity=verbosity,
+            organism=organism,
+            sources=sources,
+            exclude=exclude,
+            sample_metadata_key=sample_metadata_key,
+        )
+
 
 def get_registry_instance(registry: Record, using_key: str | None = None) -> Record:
     """Get a registry instance using a specific instance."""
@@ -1988,8 +2081,8 @@ def save_artifact(
     Returns:
         The saved Artifact.
     """
-    from ._artifact import data_is_anndata
-    from .core._data import add_labels
+    from .._artifact import data_is_anndata
+    from ..core._data import add_labels
 
     artifact = None
     if data_is_anndata(data):
@@ -2032,13 +2125,13 @@ def save_artifact(
         organism,
     )
 
-    if artifact._accessor == "DataFrame":
+    if artifact.otype == "DataFrame":
         artifact.features._add_set_from_df(field=columns_field, **feature_kwargs)
-    elif artifact._accessor == "AnnData":
+    elif artifact.otype == "AnnData":
         artifact.features._add_set_from_anndata(
             var_field=columns_field, **feature_kwargs
         )
-    elif artifact._accessor == "MuData":
+    elif artifact.otype == "MuData":
         artifact.features._add_set_from_mudata(
             var_fields=columns_field, **feature_kwargs
         )
@@ -2058,8 +2151,13 @@ def save_artifact(
             filter_kwargs = check_registry_organism(registry, organism)
             filter_kwargs_current = get_current_filter_kwargs(registry, filter_kwargs)
             df = data if isinstance(data, pd.DataFrame) else data.obs
+            # multi-value columns are separated by "|"
+            if df[key].str.contains("|").any():
+                values = df[key].str.split("|").explode().unique()
+            else:
+                values = df[key].unique()
             labels = registry.from_values(
-                df[key],
+                values,
                 field=field,
                 **filter_kwargs_current,
             )
@@ -2077,7 +2175,7 @@ def save_artifact(
                 from_curator=True,
             )
 
-    if artifact._accessor == "MuData":
+    if artifact.otype == "MuData":
         for modality, modality_fields in fields.items():
             column_field_modality = columns_field.get(modality)
             if modality == "obs":
@@ -2160,6 +2258,7 @@ def update_registry(
     registry = field.field.model
     filter_kwargs = check_registry_organism(registry, organism)
     filter_kwargs.update({"source": source} if source else {})
+    values = [i for i in values if isinstance(i, str) and i]
     if not values:
         return
 
@@ -2254,7 +2353,7 @@ def log_saved_labels(
     validated_only: bool = True,
 ) -> None:
     """Log the saved labels."""
-    from ._from_values import _format_values
+    from .._from_values import _format_values
 
     model_field = colors.italic(model_field)
     for k, labels in labels_saved.items():
@@ -2344,7 +2443,7 @@ def _save_organism(name: str):
 
 def _ref_is_name(field: FieldAttr) -> bool | None:
     """Check if the reference field is a name field."""
-    from ._can_curate import get_name_field
+    from .._can_curate import get_name_field
 
     name_field = get_name_field(field.field.model)
     return field.field.name == name_field