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

lamindb/curators/__init__.py

@@ -1,5 +1,7 @@
 """Curators.
 
+.. versionadded:: 1.1.0
+
 .. autosummary::
    :toctree: .
 
@@ -7,12 +9,23 @@
    DataFrameCurator
    AnnDataCurator
 
+CatManager:
+
+.. autosummary::
+   :toctree: .
+
+   CatManager
+   DataFrameCatManager
+   AnnDataCatManager
+   MuDataCatManager
+   TiledbsomaCatManager
+   CurateLookup
+
 """
 
 from __future__ import annotations
 
 import copy
-import random
 import re
 from importlib import resources
 from itertools import chain
@@ -38,14 +51,10 @@ if TYPE_CHECKING:
 
     from lamindb.base.types import FieldAttr
     from lamindb.models import Record
-from lamindb._feature import parse_dtype, parse_dtype_single_cat
 from lamindb.base.types import FieldAttr  # noqa
-from lamindb.core._data import add_labels
-from lamindb.core._feature_manager import parse_staged_feature_sets_from_anndata
 from lamindb.core._settings import settings
 from lamindb.models import (
     Artifact,
-    CanCurate,
     Collection,
     Feature,
     Record,
@@ -53,9 +62,11 @@ from lamindb.models import (
     Schema,
     ULabel,
 )
+from lamindb.models._feature_manager import parse_staged_feature_sets_from_anndata
+from lamindb.models.artifact import add_labels, data_is_anndata
+from lamindb.models.feature import parse_dtype, parse_dtype_single_cat
+from lamindb.models._from_values import _format_values
 
-from .._artifact import data_is_anndata
-from .._from_values import _format_values
 from ..errors import InvalidArgument, ValidationError
 
 if TYPE_CHECKING:
@@ -66,7 +77,7 @@ if TYPE_CHECKING:
     from mudata import MuData
     from spatialdata import SpatialData
 
-    from lamindb._query_set import RecordList
+    from lamindb.models.query_set import RecordList
 
 
 def strip_ansi_codes(text):
@@ -146,6 +157,12 @@ class CurateLookup:
 CAT_MANAGER_DOCSTRING = """Manage categoricals by updating registries."""
 
 
+SLOTS_DOCSTRING = """Curator objects by slot.
+
+.. versionadded:: 1.1.1
+"""
+
+
 VALIDATE_DOCSTRING = """Validate dataset.
 
 Raises:
@@ -170,6 +187,8 @@ class Curator:
 
     A `Curator` object makes it easy to validate, standardize & annotate datasets.
 
+    .. versionadded:: 1.1.0
+
     See:
         - :class:`~lamindb.curators.DataFrameCurator`
         - :class:`~lamindb.curators.AnnDataCurator`
@@ -212,6 +231,8 @@ class DataFrameCurator(Curator):
 
     See also :class:`~lamindb.Curator` and :class:`~lamindb.Schema`.
 
+    .. versionadded:: 1.1.0
+
     Args:
         dataset: The DataFrame-like object to validate & annotate.
         schema: A `Schema` object that defines the validation constraints.
@@ -222,9 +243,9 @@ class DataFrameCurator(Curator):
         import bionty as bt
 
         # define valid labels
-        cell_medium = ln.ULabel(name="CellMedium", is_type=True).save()
-        ln.ULabel(name="DMSO", type=cell_medium).save()
-        ln.ULabel(name="IFNG", type=cell_medium).save()
+        perturbation = ln.ULabel(name="Perturbation", is_type=True).save()
+        ln.ULabel(name="DMSO", type=perturbation).save()
+        ln.ULabel(name="IFNG", type=perturbation).save()
         bt.CellType.from_source(name="B cell").save()
         bt.CellType.from_source(name="T cell").save()
 
@@ -232,7 +253,7 @@ class DataFrameCurator(Curator):
         schema = ln.Schema(
             name="small_dataset1_obs_level_metadata",
             features=[
-                ln.Feature(name="cell_medium", dtype="cat[ULabel[CellMedium]]").save(),
+                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(),
@@ -252,10 +273,10 @@ class DataFrameCurator(Curator):
         schema: Schema,
     ) -> None:
         super().__init__(dataset=dataset, schema=schema)
+        categoricals = {}
         if schema.n > 0:
             # populate features
             pandera_columns = {}
-            categoricals = {}
             for feature in schema.features.all():
                 pandera_dtype = (
                     feature.dtype if not feature.dtype.startswith("cat") else "category"
@@ -268,13 +289,13 @@ class DataFrameCurator(Curator):
             self._pandera_schema = pandera.DataFrameSchema(
                 pandera_columns, coerce=schema.coerce_dtype
             )
-            # now deal with detailed validation of categoricals
-            self._cat_manager = DataFrameCatManager(
-                self._dataset,
-                categoricals=categoricals,
-            )
         else:
             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"],
+            categoricals=categoricals,
+        )
 
     @property
     @doc_args(CAT_MANAGER_DOCSTRING)
@@ -285,16 +306,29 @@ class DataFrameCurator(Curator):
     def standardize(self) -> None:
         """Standardize the dataset.
 
-        - Adds missing columns if a default value for a feature is defined.
-        - Fills missing values with the default value if a default value for a feature is defined.
+        - Adds missing columns for features
+        - Fills missing values for features with default values
         """
         for feature in self._schema.members:
             if feature.name not in self._dataset.columns:
-                if feature.default_value is not None:
-                    self._dataset[feature.name] = feature.default_value
+                if feature.default_value is not None or feature.nullable:
+                    fill_value = (
+                        feature.default_value
+                        if feature.default_value is not None
+                        else pd.NA
+                    )
+                    if feature.dtype.startswith("cat"):
+                        self._dataset[feature.name] = pd.Categorical(
+                            [fill_value] * len(self._dataset)
+                        )
+                    else:
+                        self._dataset[feature.name] = fill_value
+                    logger.important(
+                        f"added column {feature.name} with fill value {fill_value}"
+                    )
                 else:
                     raise ValidationError(
-                        f"Missing column {feature.name} cannot be added because no default value is defined for this feature"
+                        f"Missing column {feature.name} cannot be added because is not nullable and has no default value"
                     )
             else:
                 if feature.default_value is not None:
@@ -312,46 +346,29 @@ class DataFrameCurator(Curator):
                         feature.default_value
                     )
 
+    def _cat_manager_validate(self) -> None:
+        self._cat_manager.validate()
+        if self._cat_manager._is_validated:
+            self._is_validated = True
+        else:
+            self._is_validated = False
+            raise ValidationError(self._cat_manager._validate_category_error_messages)
+
     @doc_args(VALIDATE_DOCSTRING)
     def validate(self) -> None:
         """{}"""  # noqa: D415
         if self._schema.n > 0:
-            self._cat_manager.validate()
             try:
+                # first validate through pandera
                 self._pandera_schema.validate(self._dataset)
-                if self._cat_manager._is_validated:
-                    self._is_validated = True
-                else:
-                    self._is_validated = False
-                    raise ValidationError(
-                        self._cat_manager._validate_category_error_messages
-                    )
+                # then validate lamindb categoricals
+                self._cat_manager_validate()
             except pandera.errors.SchemaError as err:
                 self._is_validated = False
                 # .exconly() doesn't exist on SchemaError
                 raise ValidationError(str(err)) from err
         else:
-            result = parse_dtype_single_cat(self._schema.itype, is_itype=True)
-            registry: CanCurate = result["registry"]
-            inspector = registry.inspect(
-                self._dataset.columns,
-                result["field"],
-                mute=True,
-            )
-            if len(inspector.non_validated) > 0:
-                # also check public ontology
-                if hasattr(registry, "public"):
-                    registry.from_values(
-                        inspector.non_validated, result["field"], mute=True
-                    ).save()
-                    inspector = registry.inspect(
-                        inspector.non_validated, result["field"], mute=True
-                    )
-                if len(inspector.non_validated) > 0:
-                    self._is_validated = False
-                    raise ValidationError(
-                        f"Invalid identifiers for {self._schema.itype}: {inspector.non_validated}"
-                    )
+            self._cat_manager_validate()
 
     @doc_args(SAVE_ARTIFACT_DOCSTRING)
     def save_artifact(
@@ -385,6 +402,8 @@ class AnnDataCurator(Curator):
 
     See also :class:`~lamindb.Curator` and :class:`~lamindb.Schema`.
 
+    .. versionadded:: 1.1.0
+
     Args:
         dataset: The AnnData-like object to validate & annotate.
         schema: A `Schema` object that defines the validation constraints.
@@ -395,9 +414,9 @@ class AnnDataCurator(Curator):
         import bionty as bt
 
         # define valid labels
-        cell_medium = ln.ULabel(name="CellMedium", is_type=True).save()
-        ln.ULabel(name="DMSO", type=cell_medium).save()
-        ln.ULabel(name="IFNG", type=cell_medium).save()
+        perturbation = ln.ULabel(name="Perturbation", is_type=True).save()
+        ln.ULabel(name="DMSO", type=perturbation).save()
+        ln.ULabel(name="IFNG", type=perturbation).save()
         bt.CellType.from_source(name="B cell").save()
         bt.CellType.from_source(name="T cell").save()
 
@@ -405,9 +424,9 @@ class AnnDataCurator(Curator):
         obs_schema = ln.Schema(
             name="small_dataset1_obs_level_metadata",
             features=[
-                ln.Feature(name="cell_medium", dtype="cat[ULabel[CellMedium]]").save(),
+                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_expert", dtype=bt.CellType).save(),
                 ln.Feature(name="cell_type_by_model", dtype=bt.CellType").save(),
             ],
         ).save()
@@ -416,7 +435,7 @@ class AnnDataCurator(Curator):
         var_schema = ln.Schema(
             name="scRNA_seq_var_schema",
             itype=bt.Gene.ensembl_gene_id,
-            dtype="num",
+            dtype=int,
         ).save()
 
         # define composite schema
@@ -443,31 +462,55 @@ class AnnDataCurator(Curator):
             raise InvalidArgument("dataset must be AnnData-like.")
         if schema.otype != "AnnData":
             raise InvalidArgument("Schema otype must be 'AnnData'.")
-        self._obs_curator = DataFrameCurator(
-            self._dataset.obs, schema._get_component("obs")
-        )
-        self._var_curator = DataFrameCurator(
-            self._dataset.var.T, schema._get_component("var")
-        )
+        # TODO: also support slots other than obs and var
+        self._slots = {
+            slot: DataFrameCurator(
+                (
+                    self._dataset.__getattribute__(slot).T
+                    if slot == "var"
+                    else self._dataset.__getattribute__(slot)
+                ),
+                slot_schema,
+            )
+            for slot, slot_schema in schema.slots.items()
+            if slot in {"obs", "var"}
+        }
+
+    @property
+    @doc_args(SLOTS_DOCSTRING)
+    def slots(self) -> dict[str, DataFrameCurator]:
+        """{}"""  # noqa: D415
+        return self._slots
 
     @doc_args(VALIDATE_DOCSTRING)
     def validate(self) -> None:
         """{}"""  # noqa: D415
-        self._obs_curator.validate()
-        self._var_curator.validate()
-        self._is_validated = True
+        for _, curator in self._slots.items():
+            curator.validate()
 
     @doc_args(SAVE_ARTIFACT_DOCSTRING)
-    def save_artifact(self, *, key=None, description=None, revises=None, run=None):
+    def save_artifact(
+        self,
+        *,
+        key: str | None = None,
+        description: str | None = None,
+        revises: Artifact | None = None,
+        run: Run | None = None,
+    ):
         """{}"""  # noqa: D415
         if not self._is_validated:
-            self.validate()  # raises ValidationError if doesn't validate
-        result = parse_dtype_single_cat(self._var_curator._schema.itype, is_itype=True)
+            self.validate()
         return save_artifact(  # type: ignore
             self._dataset,
             description=description,
-            fields=self._obs_curator._cat_manager.categoricals,
-            columns_field=result["field"],
+            fields=self.slots["obs"]._cat_manager.categoricals,
+            columns_field=(
+                parse_dtype_single_cat(self.slots["var"]._schema.itype, is_itype=True)[
+                    "field"
+                ]
+                if "var" in self._slots
+                else None
+            ),
             key=key,
             artifact=self._artifact,
             revises=revises,
@@ -497,8 +540,8 @@ class CatManager:
 
     If you find non-validated values, you have several options:
 
-    - new values found in the data can be registered using :meth:`~lamindb.core.DataFrameCatManager.add_new_from`
-    - non-validated values can be accessed using :meth:`~lamindb.core.DataFrameCatManager.non_validated` and addressed manually
+    - new values found in the data can be registered using :meth:`~lamindb.curators.DataFrameCatManager.add_new_from`
+    - non-validated values can be accessed using :meth:`~lamindb.curators.DataFrameCatManager.non_validated` and addressed manually
     """
 
     def __init__(
@@ -869,7 +912,7 @@ class AnnDataCatManager(CatManager):
     def __init__(
         self,
         data: ad.AnnData | Artifact,
-        var_index: FieldAttr,
+        var_index: FieldAttr | None = None,
         categoricals: dict[str, FieldAttr] | None = None,
         obs_columns: FieldAttr = Feature.name,
         verbosity: str = "hint",
@@ -938,15 +981,16 @@ class AnnDataCatManager(CatManager):
         validated_only: bool = True,
     ):
         """Save variable records."""
-        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"),
-            exclude=self._exclude.get("var_index"),
-        )
+        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"),
+                exclude=self._exclude.get("var_index"),
+            )
 
     def add_new_from(self, key: str, **kwargs):
         """Add validated & new categories.
@@ -982,15 +1026,19 @@ class AnnDataCatManager(CatManager):
 
         # add all validated records to the current instance
         self._save_from_var_index(validated_only=True)
-        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()",
-            exclude=self._exclude.get("var_index"),
-            organism=self._organism,  # type: ignore
-        )
+        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()",
+                exclude=self._exclude.get("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:
@@ -1031,11 +1079,6 @@ class AnnDataCatManager(CatManager):
 class MuDataCatManager(CatManager):
     """Curation flow for a ``MuData`` object.
 
-    See also :class:`~lamindb.Curator`.
-
-    Note that if genes or other measurements are removed from the MuData object,
-    the object should be recreated using :meth:`~lamindb.Curator.from_mudata`.
-
     Args:
         mdata: The MuData object to curate.
         var_index: The registry field for mapping the ``.var`` index for each modality.
@@ -1289,8 +1332,6 @@ def _maybe_curation_keys_not_present(nonval_keys: list[str], name: str):
 class TiledbsomaCatManager(CatManager):
     """Curation flow for `tiledbsoma.Experiment`.
 
-    See also :class:`~lamindb.Curator`.
-
     Args:
         experiment_uri: A local or cloud path to a `tiledbsoma.Experiment`.
         var_index: The registry fields for mapping the `.var` indices for measurements.
@@ -1696,7 +1737,7 @@ class TiledbsomaCatManager(CatManager):
         Returns:
             A saved artifact record.
         """
-        from lamindb.core._data import add_labels
+        from lamindb.models.artifact import add_labels
 
         if not self._is_validated:
             self.validate()
@@ -1838,6 +1879,7 @@ class SpatialDataCatManager(CatManager):
         else:
             self._sdata = self._dataset
         self._sample_metadata_key = sample_metadata_key
+        self._write_path = None
         self._var_fields = var_index
         self._verify_accessor_exists(self._var_fields.keys())
         self._categoricals = categoricals
@@ -2119,26 +2161,14 @@ class SpatialDataCatManager(CatManager):
         try:
             settings.verbosity = "warning"
 
-            if self._artifact is None:
-                # Write the SpatialData object to a random path in tmp directory
-                # The Artifact constructor will move it to the cache
-                write_path = (
-                    f"{settings.cache_dir}/{random.randint(10**7, 10**8 - 1)}.zarr"
-                )
-                self._sdata.write(write_path)
-
-                # Create the Artifact and associate Artifact metadata
-                self._artifact = Artifact(
-                    write_path,
-                    description=description,
-                    key=key,
-                    revises=revises,
-                    run=run,
-                )
-                # According to Tim it is not easy to calculate the number of observations.
-                # We would have to write custom code to iterate over labels (which might not even exist at that point)
-                self._artifact.otype = "spatialdata"
-                self._artifact.save()
+            self._artifact = Artifact.from_spatialdata(
+                self._sdata,
+                key=key,
+                description=description,
+                revises=revises,
+                run=run,
+            )
+            self._artifact.save()
 
             # Link schemas
             feature_kwargs = check_registry_organism(
@@ -2156,7 +2186,7 @@ class SpatialDataCatManager(CatManager):
                 """Add Schemas from SpatialData."""
                 if obs_fields is None:
                     obs_fields = {}
-                assert host.otype == "spatialdata"  # noqa: S101
+                assert host.otype == "SpatialData"  # noqa: S101
 
                 feature_sets = {}
 
@@ -2784,7 +2814,7 @@ class DoseHandler:
         return cls.UNIT_MAP.get(unit, unit)
 
     @classmethod
-    def validate_values(cls, values: pd.Series) -> list:
+    def validate_values(cls, values: pd.Series) -> list[str]:
         """Validate pert_dose values with strict case checking."""
         errors = []
 
@@ -2828,7 +2858,7 @@ class TimeHandler:
         return unit[0].lower()
 
     @classmethod
-    def validate_values(cls, values: pd.Series) -> list:
+    def validate_values(cls, values: pd.Series) -> list[str]:
         """Validate pert_time values."""
         errors = []
 
@@ -3168,10 +3198,7 @@ def check_registry_organism(registry: Record, organism: str | None = None) -> di
         import bionty as bt
 
         if organism is None and bt.settings.organism is None:
-            raise ValidationError(
-                f"{registry.__name__} registry requires an organism!\n"
-                "      → please pass an organism name via organism="
-            )
+            return {}
         return {"organism": organism or bt.settings.organism.name}
     return {}
 
@@ -3185,8 +3212,8 @@ def validate_categories(
     exclude: str | list | None = None,
     hint_print: str | None = None,
     curator: CatManager | None = None,
-) -> tuple[bool, list]:
-    """Validate ontology terms in a pandas series using LaminDB registries.
+) -> tuple[bool, list[str]]:
+    """Validate ontology terms using LaminDB registries.
 
     Args:
         values: The values to validate.
@@ -3198,8 +3225,8 @@ def validate_categories(
         standardize: Whether to standardize the values.
         hint_print: The hint to print that suggests fixing non-validated values.
     """
-    from lamindb._from_values import _format_values
     from lamindb.core._settings import settings
+    from lamindb.models._from_values import _format_values
 
     model_field = f"{field.field.model.__name__}.{field.field.name}"
 
@@ -3263,7 +3290,7 @@ def validate_categories(
             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 += "    for remaining terms:\n"
+                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 == "":
@@ -3334,7 +3361,7 @@ def validate_categories_in_df(
 def save_artifact(
     data: pd.DataFrame | ad.AnnData | MuData,
     fields: dict[str, FieldAttr] | dict[str, dict[str, FieldAttr]],
-    columns_field: FieldAttr | dict[str, FieldAttr],
+    columns_field: FieldAttr | dict[str, FieldAttr] | None = None,
     description: str | None = None,
     organism: str | None = None,
     key: str | None = None,
@@ -3360,8 +3387,7 @@ def save_artifact(
     Returns:
         The saved Artifact.
     """
-    from .._artifact import data_is_anndata, data_is_mudata
-    from ..core._data import add_labels
+    from ..models.artifact import add_labels, data_is_anndata, data_is_mudata
 
     if artifact is None:
         if data_is_anndata(data):
@@ -3383,7 +3409,7 @@ def save_artifact(
     artifact.schema = schema
     artifact.save()
 
-    if organism is not None:
+    if organism is not None and columns_field is not None:
         feature_kwargs = check_registry_organism(
             (
                 list(columns_field.values())[0].field.model
@@ -3422,7 +3448,7 @@ def save_artifact(
             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():
+            if not df[key].isna().all() and df[key].str.contains("|").any():
                 values = df[key].str.split("|").explode().unique()
             else:
                 values = df[key].unique()
@@ -3520,8 +3546,8 @@ def update_registry(
         exclude: Values to exclude from inspect.
         kwargs: Additional keyword arguments to pass to the registry model to create new records.
     """
-    from lamindb._save import save as ln_save
     from lamindb.core._settings import settings
+    from lamindb.models.save import save as ln_save
 
     registry = field.field.model
     filter_kwargs = check_registry_organism(registry, organism)
@@ -3609,7 +3635,7 @@ def log_saved_labels(
     validated_only: bool = True,
 ) -> None:
     """Log the saved labels."""
-    from .._from_values import _format_values
+    from ..models._from_values import _format_values
 
     model_field = colors.italic(model_field)
     for k, labels in labels_saved.items():
@@ -3655,12 +3681,14 @@ def _save_organism(name: str):
     return organism
 
 
-def _ref_is_name(field: FieldAttr) -> bool | None:
+def _ref_is_name(field: FieldAttr | None) -> bool | None:
     """Check if the reference field is a name field."""
-    from .._can_curate import get_name_field
+    from ..models.can_curate import get_name_field
 
-    name_field = get_name_field(field.field.model)
-    return field.field.name == name_field
+    if field is not None:
+        name_field = get_name_field(field.field.model)
+        return field.field.name == name_field
+    return None
 
 
 # backward compat constructors ------------------
@@ -3709,7 +3737,7 @@ def from_anndata(
 @classmethod  # type: ignore
 def from_mudata(
     cls,
-    mdata: MuData,
+    mdata: MuData | UPathStr,
     var_index: dict[str, dict[str, FieldAttr]],
     categoricals: dict[str, FieldAttr] | None = None,
     verbosity: str = "hint",
@@ -3749,7 +3777,7 @@ def from_tiledbsoma(
 @classmethod  # type: ignore
 def from_spatialdata(
     cls,
-    sdata,
+    sdata: SpatialData | UPathStr,
     var_index: dict[str, FieldAttr],
     categoricals: dict[str, dict[str, FieldAttr]] | None = None,
     organism: str | None = None,

lamindb/errors.py

@@ -1,4 +1,4 @@
-"""Exceptions.
+"""Errors.
 
 .. autosummary::
    :toctree: .

lamindb/integrations/_vitessce.py

@@ -7,10 +7,10 @@ from typing import TYPE_CHECKING
 import lamindb_setup as ln_setup
 from lamin_utils import logger
 
-from lamindb._artifact import Artifact
-from lamindb._collection import Collection
-from lamindb._run import Run
-from lamindb._transform import Transform
+from lamindb.models.artifact import Artifact
+from lamindb.models.collection import Collection
+from lamindb.models.run import Run
+from lamindb.models.transform import Transform
 
 if TYPE_CHECKING:
     from vitessce import VitessceConfig