lamindb 1.7a1__py3-none-any.whl → 1.8.0__py3-none-any.whl

lamindb/__init__.py

@@ -108,7 +108,7 @@ Backwards compatibility.
 
 # ruff: noqa: I001
 # denote a release candidate for 0.1.0 with 0.1rc1, 0.1a1, 0.1b1, etc.
-__version__ = "1.7a1"
+__version__ = "1.8.0"
 
 import warnings
 

lamindb/core/_context.py

@@ -17,20 +17,18 @@ from lamin_utils import logger
 from lamindb_setup.core import deprecated
 from lamindb_setup.core.hashing import hash_file
 
-from lamindb.base import ids
-from lamindb.base.ids import base62_12
-from lamindb.models import Run, Transform, format_field_value
-
-from ..core._settings import settings
+from ..base.ids import base62_12
 from ..errors import (
     InvalidArgument,
     TrackNotCalled,
     UpdateContext,
 )
+from ..models import Run, Transform, format_field_value
 from ..models._is_versioned import bump_version as bump_version_function
 from ..models._is_versioned import (
     increment_base62,
 )
+from ._settings import is_read_only_connection, settings
 from ._sync_git import get_transform_reference_from_git_repo
 from ._track_environment import track_python_environment
 
@@ -334,8 +332,8 @@ class Context:
         Args:
             transform: A transform (stem) `uid` (or record). If `None`, auto-creates a `transform` with its `uid`.
             project: A project (or its `name` or `uid`) for labeling entities.
-            space: A restricted space (or its `name` or `uid`) in which to store artifacts, collections, transforms, and runs.
-                Default: the `"All"` space.
+            space: A restricted space (or its `name` or `uid`) in which to store entities.
+                Default: the `"all"` space. Note that bionty entities ignore this setting and always get written to the `"all"` space.
                 If you want to manually move entities to a different space, set the `.space` field (:doc:`docs:access`).
             branch: A branch (or its `name` or `uid`) on which to store records.
             params: A dictionary of parameters to track for the run.
@@ -365,10 +363,8 @@ class Context:
             save_context_core,
         )
 
-        instance_settings = ln_setup.settings.instance
         # similar logic here: https://github.com/laminlabs/lamindb/pull/2527
-        # TODO: refactor upon new access management
-        if instance_settings.dialect == "postgresql" and "read" in instance_settings.db:
+        if is_read_only_connection():
             logger.warning("skipping track(), connected in read-only mode")
             return None
         if project is None:
@@ -856,7 +852,7 @@ class Context:
                 and not transform_was_saved
             ):
                 raise UpdateContext(
-                    f'{transform.created_by.name} ({transform.created_by.handle}) already works on this draft {transform.type}.\n\nPlease create a revision via `ln.track("{uid[:-4]}{increment_base62(uid[-4:])}")` or a new transform with a *different* key and `ln.track("{ids.base62_12()}0000")`.'
+                    f'{transform.created_by.name} ({transform.created_by.handle}) already works on this draft {transform.type}.\n\nPlease create a revision via `ln.track("{uid[:-4]}{increment_base62(uid[-4:])}")` or a new transform with a *different* key and `ln.track("{base62_12()}0000")`.'
                 )
             # check whether transform source code was already saved
             if transform_was_saved:

lamindb/core/_settings.py

@@ -1,12 +1,14 @@
 from __future__ import annotations
 
 import os
+import sys
 from typing import TYPE_CHECKING
 
 import lamindb_setup as ln_setup
 from lamin_utils import colors, logger
+from lamindb_setup import settings as setup_settings
 from lamindb_setup._set_managed_storage import set_managed_storage
-from lamindb_setup.core._settings import settings as setup_settings
+from lamindb_setup.core import deprecated
 from lamindb_setup.core._settings_instance import sanitize_git_repo_url
 
 from .subsettings._annotation_settings import AnnotationSettings, annotation_settings
@@ -19,6 +21,15 @@ if TYPE_CHECKING:
     from lamindb_setup.core._settings_storage import StorageSettings
     from upath import UPath
 
+
+def is_read_only_connection() -> bool:
+    instance = setup_settings.instance
+    if instance.dialect == "postgresql":
+        db_url = instance.db
+        return "read" in db_url or "public" in db_url
+    return False
+
+
 VERBOSITY_TO_INT = {
     "error": 0,  # 40
     "warning": 1,  # 30
@@ -44,6 +55,9 @@ class Settings:
         self._sync_git_repo: str | None = None
 
     def __repr__(self) -> str:  # pragma: no cover
+        if "sphinx" in sys.modules:
+            return object.__repr__(self)
+
         cls_name = colors.green(self.__class__.__name__)
         verbosity_color = colors.yellow if self.verbosity == "warning" else colors.green
         verbosity_str = verbosity_color(self.verbosity)
@@ -181,6 +195,8 @@ class Settings:
     def storage(self, path_kwargs: str | Path | UPath | tuple[str | UPath, Mapping]):
         if isinstance(path_kwargs, tuple):
             path, kwargs = path_kwargs
+            if isinstance(kwargs, str):
+                kwargs = {"host": kwargs}
         else:
             path, kwargs = path_kwargs, {}
         set_managed_storage(path, **kwargs)
@@ -196,18 +212,28 @@ class Settings:
         return ln_setup.settings.cache_dir
 
     @property
-    def storage_local(self) -> StorageSettings:
+    def local_storage(self) -> StorageSettings:
         """An additional local default storage (a path to its root).
 
         Is only available if :attr:`~lamindb.setup.core.InstanceSettings.keep_artifacts_local` is enabled.
 
         Guide: :doc:`faq/keep-artifacts-local`
         """
-        return ln_setup.settings.instance.storage_local
+        return ln_setup.settings.instance.local_storage
+
+    @local_storage.setter
+    def local_storage(self, local_root: Path):
+        ln_setup.settings.instance.local_storage = local_root
+
+    @property
+    @deprecated("local_storage")
+    def storage_local(self) -> StorageSettings:
+        return self.local_storage
 
     @storage_local.setter
-    def storage_local(self, local_root: Path):
-        ln_setup.settings.instance.storage_local = local_root
+    @deprecated("local_storage")
+    def storage_local(self, local_root_host: tuple[Path | str, str]):
+        self.local_storage = local_root_host  # type: ignore
 
     @property
     def verbosity(self) -> str:

lamindb/core/storage/_backed_access.py

@@ -163,6 +163,11 @@ def _open_dataframe(
     engine: Literal["pyarrow", "polars"] = "pyarrow",
     **kwargs,
 ) -> PyArrowDataset | Iterator[PolarsLazyFrame]:
+    if engine not in {"pyarrow", "polars"}:
+        raise ValueError(
+            f"Unknown engine: {engine}. It should be 'pyarrow' or 'polars'."
+        )
+
     df_suffix: str
     if suffix is None:
         df_suffixes = _flat_suffixes(paths)
@@ -175,34 +180,37 @@ def _open_dataframe(
     else:
         df_suffix = suffix
 
-    if engine == "pyarrow":
-        if df_suffix not in PYARROW_SUFFIXES:
-            raise ValueError(
-                f"{df_suffix} files are not supported by pyarrow, "
-                f"they should have one of these formats: {', '.join(PYARROW_SUFFIXES)}."
-            )
-        # this checks that the filesystem is the same for all paths
-        # this is a requirement of pyarrow.dataset.dataset
-        if not isinstance(paths, Path):  # is a list then
-            fs = getattr(paths[0], "fs", None)
-            for path in paths[1:]:
-                # this assumes that the filesystems are cached by fsspec
-                if getattr(path, "fs", None) is not fs:
-                    raise ValueError(
-                        "The collection has artifacts with different filesystems, "
-                        "this is not supported by pyarrow."
-                    )
-        dataframe = _open_pyarrow_dataset(paths, **kwargs)
-    elif engine == "polars":
-        if df_suffix not in POLARS_SUFFIXES:
-            raise ValueError(
-                f"{df_suffix} files are not supported by polars, "
-                f"they should have one of these formats: {', '.join(POLARS_SUFFIXES)}."
-            )
-        dataframe = _open_polars_lazy_df(paths, **kwargs)
-    else:
+    if engine == "pyarrow" and df_suffix not in PYARROW_SUFFIXES:
         raise ValueError(
-            f"Unknown engine: {engine}. It should be 'pyarrow' or 'polars'."
+            f"{df_suffix} files are not supported by pyarrow, "
+            f"they should have one of these formats: {', '.join(PYARROW_SUFFIXES)}."
+        )
+    elif engine == "polars" and df_suffix not in POLARS_SUFFIXES:
+        raise ValueError(
+            f"{df_suffix} files are not supported by polars, "
+            f"they should have one of these formats: {', '.join(POLARS_SUFFIXES)}."
         )
 
-    return dataframe
+    polars_without_fsspec = engine == "polars" and not kwargs.get("use_fsspec", False)
+    if (engine == "pyarrow" or polars_without_fsspec) and not isinstance(paths, Path):
+        # this checks that the filesystem is the same for all paths
+        # this is a requirement of pyarrow.dataset.dataset
+        fs = getattr(paths[0], "fs", None)
+        for path in paths[1:]:
+            # this assumes that the filesystems are cached by fsspec
+            if getattr(path, "fs", None) is not fs:
+                engine_msg = (
+                    "polars engine without passing `use_fsspec=True`"
+                    if engine == "polars"
+                    else "pyarrow engine"
+                )
+                raise ValueError(
+                    "The collection has artifacts with different filesystems, "
+                    f"this is not supported for {engine_msg}."
+                )
+
+    return (
+        _open_pyarrow_dataset(paths, **kwargs)
+        if engine == "pyarrow"
+        else _open_polars_lazy_df(paths, **kwargs)
+    )

lamindb/core/storage/_polars_lazy_df.py

@@ -4,6 +4,8 @@ from contextlib import contextmanager
 from pathlib import Path
 from typing import TYPE_CHECKING
 
+from lamindb_setup.core._settings_storage import get_storage_region
+
 if TYPE_CHECKING:
     from collections.abc import Iterator
 
@@ -13,9 +15,35 @@ if TYPE_CHECKING:
 POLARS_SUFFIXES = (".parquet", ".csv", ".ndjson", ".ipc")
 
 
+def _polars_storage_options(storepath: UPath) -> dict[str, str | bool]:
+    storage_options: dict[str, str | bool] = {}
+    s3fs_options = storepath.storage_options
+
+    endpoint_url = s3fs_options.get("endpoint_url", None)
+    if endpoint_url is not None:
+        storage_options["aws_virtual_hosted_style_request"] = False
+        storage_options["aws_endpoint_url"] = endpoint_url
+        if endpoint_url.startswith("http://"):
+            storage_options["aws_allow_http"] = True
+    else:
+        storage_options["aws_region"] = get_storage_region(storepath)
+
+    if s3fs_options.get("anon", False):
+        storage_options["aws_skip_signature"] = True
+    else:
+        if "key" in s3fs_options:
+            storage_options["aws_access_key_id"] = s3fs_options["key"]
+        if "secret" in s3fs_options:
+            storage_options["aws_secret_access_key"] = s3fs_options["secret"]
+        if "token" in s3fs_options:
+            storage_options["aws_session_token"] = s3fs_options["token"]
+
+    return storage_options
+
+
 @contextmanager
 def _open_polars_lazy_df(
-    paths: UPath | list[UPath], **kwargs
+    paths: UPath | list[UPath], use_fsspec: bool = False, **kwargs
 ) -> Iterator[PolarsLazyFrame]:
     try:
         import polars as pl
@@ -38,14 +66,25 @@ def _open_polars_lazy_df(
             path_list += [p for p in path.rglob("*") if p.suffix != ""]
         else:
             path_list.append(path)
+    # assume the filesystem is the same for all
+    # it is checked in _open_dataframe
+    path0 = path_list[0]
+    storage_options = None
+    if not use_fsspec:
+        storage_options = kwargs.pop("storage_options", None)
+        if path0.protocol == "s3" and storage_options is None:
+            storage_options = _polars_storage_options(path0)
 
     open_files = []
 
     try:
         for path in path_list:
-            open_files.append(path.open(mode="rb"))
+            open_files.append(path.open(mode="rb") if use_fsspec else path.as_posix())
 
-        yield scans[path_list[0].suffix](open_files, **kwargs)
+        yield scans[path_list[0].suffix](
+            open_files, storage_options=storage_options, **kwargs
+        )
     finally:
-        for open_file in open_files:
-            open_file.close()
+        if use_fsspec:
+            for open_file in open_files:
+                open_file.close()

lamindb/curators/core.py

@@ -175,9 +175,18 @@ class Curator:
         - :class:`~lamindb.curators.AnnDataCurator`
         - :class:`~lamindb.curators.MuDataCurator`
         - :class:`~lamindb.curators.SpatialDataCurator`
+        - :class:`~lamindb.curators.TiledbsomaExperimentCurator`
     """
 
     def __init__(self, dataset: Any, schema: Schema | None = None):
+        if not isinstance(schema, Schema):
+            raise InvalidArgument("schema argument must be a Schema record.")
+
+        if schema.pk is None:
+            raise ValueError(
+                "Schema must be saved before curation. Please save it using '.save()'."
+            )
+
         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):
@@ -463,12 +472,15 @@ class DataFrameCurator(Curator):
         slot: str | None = None,
     ) -> None:
         super().__init__(dataset=dataset, schema=schema)
+
         categoricals = []
         features = []
         feature_ids: set[int] = set()
+
         if schema.flexible:
             features += Feature.filter(name__in=self._dataset.keys()).list()
             feature_ids = {feature.id for feature in features}
+
         if schema.n > 0:
             if schema._index_feature_uid is not None:
                 schema_features = [
@@ -488,6 +500,7 @@ class DataFrameCurator(Curator):
                 features.extend(schema_features)
         else:
             assert schema.itype is not None  # noqa: S101
+
         pandera_columns = {}
         if features or schema._index_feature_uid is not None:
             # populate features
@@ -640,8 +653,11 @@ class DataFrameCurator(Curator):
                 self._cat_manager_validate()
             except (pandera.errors.SchemaError, pandera.errors.SchemaErrors) as err:
                 self._is_validated = False
-                # .exconly() doesn't exist on SchemaError
-                raise ValidationError(str(err)) from err
+                has_dtype_error = "WRONG_DATATYPE" in str(err)
+                error_msg = str(err)
+                if has_dtype_error:
+                    error_msg += "   ▶ Hint: Consider setting 'coerce_datatype=True' to attempt coercing/converting values during validation to the pre-defined dtype."
+                raise ValidationError(error_msg) from err
         else:
             self._cat_manager_validate()
 

lamindb/migrations/0115_alter_space_uid.py

@@ -0,0 +1,52 @@
+# Generated by Django 5.2 on 2025-07-06 23:09
+
+from django.db import migrations
+
+import lamindb.base.fields
+
+
+def extenddefault_values(apps, schema_editor):
+    """Lowercase default values for Space and Branch models."""
+    Space = apps.get_model("lamindb", "Space")
+    Branch = apps.get_model("lamindb", "Branch")
+
+    space = Space.objects.get(uid="a")
+    space.uid = 12 * "a"
+    space.save()
+
+    trash_branch = Branch.objects.get(uid="t")
+    trash_branch.uid = 12 * "t"
+    trash_branch.save()
+
+    archive_branch = Branch.objects.get(uid="a")
+    archive_branch.uid = 12 * "a"
+    archive_branch.save()
+
+    main_branch = Branch.objects.get(uid="m")
+    main_branch.uid = 12 * "m"
+    main_branch.save()
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("lamindb", "0114_alter_run__status_code"),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name="space",
+            name="uid",
+            field=lamindb.base.fields.CharField(
+                blank=True,
+                db_default="aaaaaaaaaaaa",
+                db_index=True,
+                default="aaaaaaaaaaaaa",
+                editable=False,
+                max_length=12,
+                unique=True,
+            ),
+        ),
+        migrations.RunPython(
+            extenddefault_values,
+        ),
+    ]

lamindb/migrations/{0114_squashed.py → 0115_squashed.py}

@@ -136,6 +136,7 @@ class Migration(migrations.Migration):
         ("lamindb", "0112_alter_recordartifact_feature_and_more"),
         ("lamindb", "0113_lower_case_branch_and_space_names"),
         ("lamindb", "0114_alter_run__status_code"),
+        ("lamindb", "0115_alter_space_uid"),
     ]
 
     dependencies = []  # type: ignore
@@ -214,9 +215,9 @@ class Migration(migrations.Migration):
                     "uid",
                     lamindb.base.fields.CharField(
                         blank=True,
-                        db_default="A",
+                        db_default="aaaaaaaaaaaa",
                         db_index=True,
-                        default="A",
+                        default="aaaaaaaaaaaaa",
                         editable=False,
                         max_length=12,
                         unique=True,

lamindb/models/_django.py

@@ -21,12 +21,10 @@ if TYPE_CHECKING:
 def patch_many_to_many_descriptor() -> None:
     """Patches Django's `ManyToManyDescriptor.__get__` method to suggest better errors when saving relationships of an unsaved model.
 
-    Before this patch: Cryptic errors are raised when relationships of an unsaved
-    record are attempted to be modified.
+    Before this patch: Cryptic errors are raised when relationships of an unsaved record are attempted to be modified.
 
-    After this patch: Attempts to access M2M relationships on unsaved objects
-    will raise ValueError, suggesting explicit .save() of the record to be modified
-    before relationship creation.
+    After this patch: Attempts to access M2M relationships on unsaved objects will raise ValueError,
+    suggesting explicit .save() of the record to be modified before relationship creation.
     """
     from django.db.models.fields.related_descriptors import ManyToManyDescriptor
 
@@ -37,7 +35,28 @@ def patch_many_to_many_descriptor() -> None:
             raise ValueError(
                 f"You are trying to access the many-to-many relationships of an unsaved {instance.__class__.__name__} object. Please save it first using '.save()'."
             )
-        return original_get(self, instance, cls)
+
+        manager = original_get(self, instance, cls)
+        if manager is None or not hasattr(manager, "add"):
+            return manager
+
+        original_manager_add = manager.add
+
+        def patched_manager_add(*objs, **kwargs):
+            try:
+                return original_manager_add(*objs, **kwargs)
+            except ValueError as e:
+                if "Cannot add" in str(e) and "database" in str(e):
+                    source_db = manager.instance._state.db
+
+                    raise ValueError(
+                        f"Cannot label a record from instance '{source_db}'. "
+                        f"Please save the record first to your instance using '.save()'."
+                    ) from None
+                raise
+
+        manager.add = patched_manager_add
+        return manager
 
     ManyToManyDescriptor.__get__ = patched_get
 

lamindb/models/artifact.py

@@ -37,6 +37,7 @@ from lamindb.errors import FieldValidationError, UnknownStorageLocation
 from lamindb.models.query_set import QuerySet
 
 from ..base.users import current_user_id
+from ..core._settings import is_read_only_connection, settings
 from ..core.loaders import load_to_memory
 from ..core.storage import (
     LocalPathClasses,
@@ -279,8 +280,6 @@ def process_data(
 
     # in case we have an in-memory representation, we need to write it to disk
     if memory_rep is not None:
-        from lamindb import settings
-
         path = settings.cache_dir / f"{provisional_uid}{suffix}"
         if isinstance(format, dict):
             format.pop("suffix", None)
@@ -301,8 +300,6 @@ def get_stat_or_artifact(
 ) -> Union[tuple[int, str | None, str | None, int | None, Artifact | None], Artifact]:
     """Retrieves file statistics or an existing artifact based on the path, hash, and key."""
     n_files = None
-    from lamindb import settings
-
     if settings.creation.artifact_skip_size_hash:
         return None, None, None, n_files, None
     stat = path.stat()  # one network request
@@ -407,8 +404,6 @@ def get_artifact_kwargs_from_data(
     skip_check_exists: bool = False,
     overwrite_versions: bool | None = None,
 ):
-    from lamindb import settings
-
     run = get_run(run)
     memory_rep, path, suffix, storage, use_existing_storage_key = process_data(
         provisional_uid,
@@ -635,8 +630,6 @@ def _populate_subsequent_runs_(record: Union[Artifact, Collection], run: Run):
 
 # also see current_run() in core._data
 def get_run(run: Run | None) -> Run | None:
-    from lamindb import settings
-
     from .._tracked import get_current_tracked_run
     from ..core._context import context
 
@@ -645,11 +638,7 @@ def get_run(run: Run | None) -> Run | None:
         if run is None:
             run = context.run
         if run is None and not settings.creation.artifact_silence_missing_run_warning:
-            # here we check that this is not a read-only connection
-            # normally for our connection strings the read-only role name has "read" in it
-            # not absolutely safe but the worst case is that the warning is not shown
-            instance = setup_settings.instance
-            if instance.dialect != "postgresql" or "read" not in instance.db:
+            if not is_read_only_connection():
                 logger.warning(WARNING_RUN_TRANSFORM)
     # suppress run by passing False
     elif not run:
@@ -1388,7 +1377,7 @@ class Artifact(SQLRecord, IsVersioned, TracksRun, TracksUpdates):
             default_storage = kwargs.pop("default_storage")
         else:
             if setup_settings.instance.keep_artifacts_local:
-                default_storage = setup_settings.instance.storage_local.record
+                default_storage = setup_settings.instance.local_storage.record
             else:
                 default_storage = setup_settings.instance.storage.record
         using_key = kwargs.pop("using_key", None)
@@ -1568,15 +1557,11 @@ class Artifact(SQLRecord, IsVersioned, TracksRun, TracksUpdates):
             artifact.path
             #> PosixPath('/home/runner/work/lamindb/lamindb/docs/guide/mydata/myfile.csv')
         """
-        from lamindb import settings
-
         filepath, _ = filepath_from_artifact(self, using_key=settings._using_key)
         return filepath
 
     @property
     def _cache_path(self) -> UPath:
-        from lamindb import settings
-
         filepath, cache_key = filepath_cache_key_from_artifact(
             self, using_key=settings._using_key
         )
@@ -2061,8 +2046,6 @@ class Artifact(SQLRecord, IsVersioned, TracksRun, TracksUpdates):
             artifacts = ln.Artifact.from_dir(dir_path)
             ln.save(artifacts)
         """
-        from lamindb import settings
-
         folderpath: UPath = create_path(path)  # returns Path for local
         default_storage = settings.storage.record
         using_key = settings._using_key
@@ -2172,8 +2155,6 @@ class Artifact(SQLRecord, IsVersioned, TracksRun, TracksUpdates):
 
             However, it will update the suffix if it changes.
         """
-        from lamindb import settings
-
         default_storage = settings.storage.record
         kwargs, privates = get_artifact_kwargs_from_data(
             provisional_uid=self.uid,
@@ -2335,8 +2316,6 @@ class Artifact(SQLRecord, IsVersioned, TracksRun, TracksUpdates):
                 "Only a tiledbsoma store can be openened with `mode!='r'`."
             )
 
-        from lamindb import settings
-
         using_key = settings._using_key
         filepath, cache_key = filepath_cache_key_from_artifact(
             self, using_key=using_key
@@ -2441,8 +2420,6 @@ class Artifact(SQLRecord, IsVersioned, TracksRun, TracksUpdates):
             >>> artifact.load()
             PosixPath('/home/runner/work/lamindb/lamindb/docs/guide/mydata/.lamindb/jb7BY5UJoQVGMUOKiLcn.jpg')
         """
-        from lamindb import settings
-
         if self._overwrite_versions and not self.is_latest:
             raise ValueError(INCONSISTENT_STATE_MSG)
 
@@ -2508,8 +2485,6 @@ class Artifact(SQLRecord, IsVersioned, TracksRun, TracksUpdates):
             artifact.cache()
             #> PosixPath('/home/runner/work/Caches/lamindb/lamindb-ci/lndb-storage/pbmc68k.h5ad')
         """
-        from lamindb import settings
-
         if self._overwrite_versions and not self.is_latest:
             raise ValueError(INCONSISTENT_STATE_MSG)
 
@@ -2706,7 +2681,7 @@ class Artifact(SQLRecord, IsVersioned, TracksRun, TracksUpdates):
         if upload and setup_settings.instance.keep_artifacts_local:
             # switch local storage location to cloud
             local_path = self.path
-            self.storage_id = setup_settings.instance.storage.id
+            self.storage_id = setup_settings.instance.storage._id
             self._local_filepath = local_path
             # switch to virtual storage key upon upload
             # the local filepath is already cached at that point
@@ -2856,8 +2831,6 @@ def _track_run_input(
     if is_run_input is False:
         return
 
-    from lamindb import settings
-
     from .._tracked import get_current_tracked_run
     from ..core._context import context
     from .collection import Collection
@@ -2915,11 +2888,7 @@ def _track_run_input(
         # we don't have a run record
         if run is None:
             if settings.track_run_inputs:
-                # here we check that this is not a read-only connection
-                # normally for our connection strings the read-only role name has "read" in it
-                # not absolutely safe but the worst case is that the warning is not shown
-                instance = setup_settings.instance
-                if instance.dialect != "postgresql" or "read" not in instance.db:
+                if not is_read_only_connection():
                     logger.warning(WARNING_NO_INPUT)
         # assume we have a run record
         else:

lamindb/models/feature.py

@@ -535,38 +535,32 @@ class Feature(SQLRecord, CanCurate, TracksRun, TracksUpdates):
 
         A simple `"str"` feature.::
 
-        ln.Feature(
-            name="sample_note",
-            dtype="str",
-        ).save()
+            ln.Feature(name="sample_note", dtype=str).save()
 
         A dtype `"cat[ULabel]"` can be more easily passed as below.::
 
-        ln.Feature(
-            name="project",
-            dtype=ln.ULabel,
-        ).save()
+            ln.Feature(name="project", dtype=ln.ULabel).save()
 
         A dtype `"cat[ULabel|bionty.CellType]"` can be more easily passed as below.::
 
-        ln.Feature(
-            name="cell_type",
-            dtype=[ln.ULabel, bt.CellType],
-        ).save()
+            ln.Feature(
+                name="cell_type",
+                dtype=[ln.ULabel, bt.CellType],
+            ).save()
 
         A multivalue feature with a list of cell types.::
 
-        ln.Feature(
-            name="cell_types",
-            dtype=list[bt.CellType],  # or list[str] for a list of strings
-        ).save()
+            ln.Feature(
+                name="cell_types",
+                dtype=list[bt.CellType],  # or list[str] for a list of strings
+            ).save()
 
         A path feature.::
 
-        ln.Feature(
-            name="image_path",
-            dtype="path",   # will be validated as `str`
-        ).save()
+            ln.Feature(
+                name="image_path",
+                dtype="path",   # will be validated as `str`
+            ).save()
 
     Hint:
 

lamindb/models/sqlrecord.py

@@ -661,43 +661,53 @@ class BaseSQLRecord(models.Model, metaclass=Registry):
     def __init__(self, *args, **kwargs):
         skip_validation = kwargs.pop("_skip_validation", False)
         if not args:
-            if self.__class__.__name__ in {
-                "Artifact",
-                "Collection",
-                "Transform",
-                "Run",
-            }:
+            if (
+                issubclass(self.__class__, SQLRecord)
+                and self.__class__.__name__ != "Storage"
+                # do not save bionty entities in restricted spaces by default
+                and self.__class__.__module__ != "bionty.models"
+            ):
                 from lamindb import context as run_context
 
                 if run_context.space is not None:
+                    current_space = run_context.space
+                elif setup_settings.space is not None:
+                    current_space = setup_settings.space
+
+                if current_space is not None:
                     if "space_id" in kwargs:
                         # space_id takes precedence over space
                         # https://claude.ai/share/f045e5dc-0143-4bc5-b8a4-38309229f75e
                         if kwargs["space_id"] == 1:  # ignore default space
                             kwargs.pop("space_id")
-                            kwargs["space"] = run_context.space
+                            kwargs["space"] = current_space
                     elif "space" in kwargs:
                         if kwargs["space"] is None:
-                            kwargs["space"] = run_context.space
+                            kwargs["space"] = current_space
                     else:
-                        kwargs["space"] = run_context.space
+                        kwargs["space"] = current_space
             if issubclass(
                 self.__class__, SQLRecord
             ) and self.__class__.__name__ not in {"Storage", "Source"}:
                 from lamindb import context as run_context
 
                 if run_context.branch is not None:
+                    current_branch = run_context.branch
+                elif setup_settings.branch is not None:
+                    current_branch = setup_settings.branch
+
+                if current_branch is not None:
                     # branch_id takes precedence over branch
                     # https://claude.ai/share/f045e5dc-0143-4bc5-b8a4-38309229f75e
                     if "branch_id" in kwargs:
                         if kwargs["branch_id"] == 1:  # ignore default branch
                             kwargs.pop("branch_id")
-                            kwargs["branch"] = run_context.branch
+                            kwargs["branch"] = current_branch
                     elif "branch" in kwargs:
                         if kwargs["branch"] is None:
-                            kwargs["branch"] = run_context.branch
+                            kwargs["branch"] = current_branch
                     else:
-                        kwargs["branch"] = run_context.branch
+                        kwargs["branch"] = current_branch
             if skip_validation:
                 super().__init__(**kwargs)
             else:
@@ -952,8 +962,8 @@ class Space(BaseSQLRecord):
         editable=False,
         unique=True,
         max_length=12,
-        default="A",
-        db_default="A",
+        default="aaaaaaaaaaaaa",
+        db_default="aaaaaaaaaaaa",
         db_index=True,
     )
     """Universal id."""

lamindb/models/storage.py

@@ -12,7 +12,11 @@ from lamindb_setup.core._hub_core import (
     delete_storage_record,
     get_storage_records_for_instance,
 )
-from lamindb_setup.core._settings_storage import StorageSettings, init_storage
+from lamindb_setup.core._settings_storage import (
+    StorageSettings,
+    get_storage_type,
+    init_storage,
+)
 from lamindb_setup.core.upath import check_storage_is_empty, create_path
 
 from lamindb.base.fields import (
@@ -33,78 +37,88 @@ if TYPE_CHECKING:
 
 
 class Storage(SQLRecord, TracksRun, TracksUpdates):
-    """Storage locations of artifacts such as folders and S3 buckets.
+    """Storage locations of artifacts such as local directories or S3 buckets.
 
-    A storage location is either a folder (local or in the cloud) or
+    A storage location is either a directory (local or a folder in the cloud) or
     an entire S3/GCP bucket.
-
-    A LaminDB instance can manage and reference multiple storage locations. But any
+    A LaminDB instance can manage and read from multiple storage locations. But any
     storage location is managed by *at most one* LaminDB instance.
 
-    .. dropdown:: Managed vs. referenced storage locations
+    .. dropdown:: Managed vs. read-only storage locations
 
         A LaminDB instance can only write artifacts to its managed storage
-        locations and merely reads artifacts from its referenced storage locations.
+        locations.
 
-        The :attr:`~lamindb.Storage.instance_uid` field defines the managing LaminDB instance of a
-        storage location. Some storage locations may not be managed by any LaminDB
-        instance, in which case the `instance_uid` is `None`. If it matches the
-        :attr:`~lamindb.core.Settings.instance_uid` of the current instance, the storage location
-        is managed by the current instance.
+        The :attr:`~lamindb.Storage.instance_uid` field defines the managing LaminDB instance of a storage location.
+        You can access the `instance_uid` of your current instance through `ln.setup.settings.instance_uid`.
 
-        Here is an example based (`source <https://lamin.ai/laminlabs/lamindata/transform/dPco79GYgzag0000>`__):
+        Here is an example (`source <https://lamin.ai/laminlabs/lamindata/transform/dPco79GYgzag0000>`__).
 
         .. image:: https://lamin-site-assets.s3.amazonaws.com/.lamindb/eHDmIOAxLEoqZ2oK0000.png
            :width: 400px
 
+        Some public storage locations are not be managed by any LaminDB instance: their `instance_uid` is `None`.
+
     .. dropdown:: Managing access to storage locations across instances
 
-        You can low-level manage access through AWS policies that you attach to your S3 bucket
+        You can manage access through AWS policies that you attach to your S3 bucket
         or leverage LaminHub's fine-grained access management.
 
-        Head over to `https://lamin.ai/{account}/infrastructure` and you'll see a UI as in the screenshot below.
-        By clicking the green button that says "Connect S3 bucket", you enable LaminHub to issue federated S3 tokens
-        for a new S3 bucket so that your collaborators can access data in this bucket based on their permissions in LaminHub.
+        Head over to `https://lamin.ai/{account}/infrastructure`.
+        By clicking the green button that says "Connect S3 bucket", you enable Lamin to issue federated S3 tokens
+        for a bucket so that your collaborators can access data based on their permissions in LaminHub.
         :doc:`docs:access` has more details.
 
         .. image:: https://lamin-site-assets.s3.amazonaws.com/.lamindb/ze8hkgVxVptSSZEU0000.png
            :width: 800px
 
+        If you don't want to store data in the cloud, you can use local storage locations: :doc:`faq/keep-artifacts-local`.
+
     Args:
-        root: `str` The root path of the storage location, e.g., `"./myfolder"`, `"s3://my-bucket/myfolder"`, or `"gs://my-bucket/myfolder"`.
-        type: :class:`~lamindb.setup.types.StorageType` The type of storage.
-        description: `str | None = None` A description.
-        region: `str | None = None` Cloud storage region, if applicable. Auto-populated for AWS S3.
+        root: `str` The root path of the storage location, e.g., `"./mydir"`, `"s3://my-bucket"`, `"s3://my-bucket/myfolder"`, `"gs://my-bucket/myfolder"`, `"/nfs/shared/datasets/genomics"`, `"/weka/shared/models/"`, ...
+        description: `str | None = None` An optional description.
+        host: `str | None = None` For local storage locations, pass a globally unique host identifier, e.g. `"my-institute-cluster-1"`, `"my-server-abcd"`, ...
 
     See Also:
         :attr:`lamindb.core.Settings.storage`
             Current default storage location of your compute session for writing artifacts.
         :attr:`~lamindb.setup.core.StorageSettings`
             Storage settings.
+        :doc:`faq/keep-artifacts-local`
+            Avoid storing artifacts in the cloud, but keep them on local infrastructure.
 
     Examples:
 
         When you create a LaminDB instance, you configure its default storage location via `--storage`::
 
-            lamin init --storage ./myfolder  # or "s3://my-bucket/myfolder" or "gs://my-bucket/myfolder"
+            lamin init --storage ./mydatadir  # or "s3://my-bucket/myfolder", "gs://my-bucket/myfolder", ...
 
-        View the current default storage location in your compute session for writing artifacts::
+        View the current default storage location for writing artifacts::
 
             import lamindb as ln
 
             ln.settings.storage
 
-        Switch to another default storage location for writing artifacts::
+        Create a new cloud storage location::
 
-            ln.settings.storage = "./myfolder2"  # or "s3://my-bucket/my-folder2" or "gs://my-bucket/my-folder2"
+            ln.Storage(root="s3://our-bucket/our-folder").save()
 
-        View all storage locations used in your LaminDB instance::
+        Create a new local storage location::
 
-            ln.Storage.df()
+            ln.Storage(root="/dir/our-shared-dir", host="our-server-123").save()
 
-        Create a new storage location::
+        Switch to another storage location::
 
-            ln.Storage(root="./myfolder3").save()
+            ln.settings.storage = "/dir/our-shared-dir"  # or "s3://our-bucket/our-folder", "gs://our-bucket/our-folder", ...
+
+        If you're operating in `keep-artifacts-local` mode (:doc:`faq/keep-artifacts-local`), you can switch among additional local storage locations::
+
+            ln.Storage(root="/dir/our-other-shared-dir", host="our-server-123").save()  # create
+            ln.settings.local_storage = "/dir/our-other-shared-dir"  # switch
+
+        View all storage locations used in your LaminDB instance::
+
+            ln.Storage.df()
 
     Notes:
 
@@ -146,9 +160,9 @@ class Storage(SQLRecord, TracksRun, TracksUpdates):
     description: str | None = CharField(db_index=True, null=True)
     """A description of what the storage location is used for (optional)."""
     type: StorageType = CharField(max_length=30, db_index=True)
-    """Can be "local" vs. "s3" vs. "gs"."""
+    """Can be "local" vs. "s3" vs. "gs". Is auto-detected from the format of the `root` path."""
     region: str | None = CharField(max_length=64, db_index=True, null=True)
-    """Cloud storage region, if applicable."""
+    """Storage region for cloud storage locations. Host identifier for local storage locations."""
     instance_uid: str | None = CharField(max_length=12, db_index=True, null=True)
     """Instance that manages this storage location."""
     artifacts: Artifact
@@ -158,9 +172,9 @@ class Storage(SQLRecord, TracksRun, TracksUpdates):
     def __init__(
         self,
         root: str,
-        type: str,
+        *,
         description: str | None = None,
-        region: str | None = None,
+        host: str | None = None,
     ): ...
 
     @overload
@@ -177,7 +191,28 @@ class Storage(SQLRecord, TracksRun, TracksUpdates):
         if len(args) == len(self._meta.concrete_fields):
             super().__init__(*args)
             return None
-        storage_record = Storage.filter(root=kwargs["root"]).one_or_none()
+        if args:
+            assert len(args) == 1, (  # noqa: S101
+                "Storage can only be initialized with a single positional argument, the root path."
+            )
+            kwargs["root"] = args[0]
+        if "host" in kwargs:
+            if "type" in kwargs:
+                assert kwargs["type"] == "local", (  # noqa: S101
+                    "type needs to be 'local' if host is set"
+                )
+            else:
+                kwargs["type"] = "local"
+            assert get_storage_type(kwargs["root"]) == "local", (  # noqa: S101
+                "root must be a local path if host is set"
+            )
+            assert "region" not in kwargs, "region must not be set if host is set"  # noqa: S101
+            kwargs["region"] = kwargs.pop("host")
+            storage_record = Storage.filter(
+                root=kwargs["root"], region=kwargs["region"]
+            ).one_or_none()
+        else:
+            storage_record = Storage.filter(root=kwargs["root"]).one_or_none()
         if storage_record is not None:
             from .sqlrecord import init_self_from_db
 
@@ -196,7 +231,9 @@ class Storage(SQLRecord, TracksRun, TracksUpdates):
             kwargs["root"],
             instance_id=setup_settings.instance._id,
             instance_slug=setup_settings.instance.slug,
+            register_hub=setup_settings.instance.is_on_hub,
             prevent_register_hub=not setup_settings.instance.is_on_hub,
+            region=kwargs.get("region", None),  # host was renamed to region already
         )
         # ssettings performed validation and normalization of the root path
         kwargs["root"] = ssettings.root_as_str  # noqa: S101
@@ -238,6 +275,18 @@ class Storage(SQLRecord, TracksRun, TracksUpdates):
         )
         super().__init__(**kwargs)
 
+    @property
+    def host(self) -> str | None:
+        """Host identifier for local storage locations.
+
+        Is `None` for locations with `type != "local"`.
+
+        A globally unique user-defined host identifier (cluster, server, laptop, etc.).
+        """
+        if self.type != "local":
+            return None
+        return self.region
+
     @property
     def path(self) -> Path | UPath:
         """Path.

lamindb/setup/__init__.py

@@ -8,6 +8,7 @@ from lamindb_setup import (
 )
 
 from . import core, errors, types
+from ._switch import switch  # noqa: F401
 
 del connect  # we have this at the root level, hence, we don't want it here
 __doc__ = _lamindb_setup.__doc__.replace("lamindb_setup", "lamindb.setup")

lamindb/setup/_switch.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from lamindb_setup import settings
+
+if TYPE_CHECKING:
+    from lamindb.models import Branch, Space
+
+
+def switch(*, branch: str | Branch | None = None, space: str | Space | None = None):
+    """Switch to a branch or space, create if not exists."""
+    if branch is not None:
+        settings.branch = branch
+    if space is not None:
+        settings.space = space

{lamindb-1.7a1.dist-info → lamindb-1.8.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: lamindb
-Version: 1.7a1
+Version: 1.8.0
 Summary: A data framework for biology.
 Author-email: Lamin Labs <open-source@lamin.ai>
 Requires-Python: >=3.10,<3.14
@@ -10,8 +10,8 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: lamin_utils==0.15.0
-Requires-Dist: lamin_cli==1.5.1
-Requires-Dist: lamindb_setup[aws]==1.7.0
+Requires-Dist: lamin_cli==1.5.5
+Requires-Dist: lamindb_setup[aws]==1.8.1
 Requires-Dist: pyyaml
 Requires-Dist: pyarrow
 Requires-Dist: pandera>=0.24.0

{lamindb-1.7a1.dist-info → lamindb-1.8.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-lamindb/__init__.py,sha256=FzHtSn1eMOasSWUktr67iYTP9M5kqs1SF325l6orecQ,2904
+lamindb/__init__.py,sha256=187A6Y-iGQVzOl_cIiB0FvfeVeS0c9jisHbLAt3U6ak,2904
 lamindb/_finish.py,sha256=MZKXiGk_NFRyc693OXitqq7Qd9bGojcBe26JkingJGI,20859
 lamindb/_tracked.py,sha256=-wK7BJv30nf4v2_nH5qDCyxHvug7ih6duQNGxDrj3UE,4447
 lamindb/_view.py,sha256=cod1RnZoLyzMVJcjWjytg78Sf4qsR8IAdqpwzsi8FTw,4950
@@ -12,9 +12,9 @@ lamindb/base/uids.py,sha256=cLBi5mIlsf1ltkTb17r1FLzlOjlGmjvsCygoVJHQ-A8,2116
 lamindb/base/users.py,sha256=8MSmAvCKoUF15YsDE6BGLBXsFWpfoEEg8iDTKZ7kD48,848
 lamindb/core/__init__.py,sha256=aaBq0UVjNolMynbT1V5hB6UrJm1tK0M6WHu_r6em9_4,604
 lamindb/core/_compat.py,sha256=NLnKk1qk4xdgMV-QwFDnBnbio02ujjlF86icvhpdv4c,2029
-lamindb/core/_context.py,sha256=Lv6Ag5p7dQgIiAKlJM8VKPVIAOlBXxR_DeamVKq-vS4,39736
+lamindb/core/_context.py,sha256=46jUmSq5JiwRloriMNb3VT3mXCR4vo_KotbVSerBUfA,39606
 lamindb/core/_mapped_collection.py,sha256=osquwC6ee0wJ_I6O-8AZwnQUa_r9zqa0MN82Q-nBI3Y,25746
-lamindb/core/_settings.py,sha256=7Dw1SOtUCfyg3VyxgV696UYjJYmVogyiNM2P1ZL9RMk,7937
+lamindb/core/_settings.py,sha256=Dj44Xh5x3OEpTPvG0twREcIv6X6Er5NzDZO86i8Cq9g,8678
 lamindb/core/_sync_git.py,sha256=Z7keuyS5X7CAj285sEbZIFExZF9mtjGH8DzKwz3xhHw,5881
 lamindb/core/_track_environment.py,sha256=fa0-qKEe0BpL79_nsDUDtbg1iA3VpJTh0RCOGdc2XOA,974
 lamindb/core/exceptions.py,sha256=FMEoSvT3FvtLkxQAt2oDXPeaPem8V5x5UBbTsPFYU5w,53
@@ -27,8 +27,8 @@ lamindb/core/datasets/_small.py,sha256=HBzyTporAl-6Cr4DbDDEtzbU2ILKNxxiRM-GeZofq
 lamindb/core/datasets/mini_immuno.py,sha256=eAtRQ3_4cln5IFzTH0jNufbWcyQKrXmzizbSmvfS-FM,5707
 lamindb/core/storage/__init__.py,sha256=JOIMu_7unbyhndtH1j0Q-9AvY8knSuc1IJO9sQnyBAQ,498
 lamindb/core/storage/_anndata_accessor.py,sha256=jrKbRylkqgZ3opKcJCwilDhRGEnPcQsKt-X7EA9Isr8,26100
-lamindb/core/storage/_backed_access.py,sha256=LlpRDZ0skseZA5tBFu3-cH1wJwuXm7-NS2RgnTK7wgc,7382
-lamindb/core/storage/_polars_lazy_df.py,sha256=Z0KMp0OU5S36L5g8EuJk7V_nn-spgG1lFeEFnkTOLcw,1350
+lamindb/core/storage/_backed_access.py,sha256=6YczvbmcmwZsOHFyD0ArDrvysUUAEiYcwZ_8TyWi_r8,7674
+lamindb/core/storage/_polars_lazy_df.py,sha256=jqe06s2idUloi4FnOB1DJ6UMNWM_wltFzxuMrE-C2oU,2941
 lamindb/core/storage/_pyarrow_dataset.py,sha256=lRYYt7edUtwauhxd7RwFud6YPDbz2PFvYYgqLhfapfk,1398
 lamindb/core/storage/_tiledbsoma.py,sha256=kwf5zz8byZF5Lm-4Tt2ZE-hjUzwO8l07I9G7l2r68u0,11434
 lamindb/core/storage/_valid_suffixes.py,sha256=vUSeQ4s01rdhD_vSd6wKmFBsgMJAKkBMnL_T9Y1znMg,501
@@ -40,7 +40,7 @@ lamindb/core/subsettings/_annotation_settings.py,sha256=o-yTYw-NmjFmtehbKU8qnf7t
 lamindb/core/subsettings/_creation_settings.py,sha256=NGHWKqCFSzVNBxAr2VnmdYguiFdW29XUK7T9wRsVshg,906
 lamindb/curators/__init__.py,sha256=rv5Xrhv0jS1NMpuRVUHEMAsu6pXhBdDP8PBlO4FXrsE,662
 lamindb/curators/_legacy.py,sha256=vWA3CFryIXRG2RDHY7-paMFoG7bpu_gHti8V0sJLuYc,76280
-lamindb/curators/core.py,sha256=eZGd_PndfD68kb8Vjn0Beoz7fbut7v0OWvCs4Ar1Hng,66825
+lamindb/curators/core.py,sha256=5Z5TZ8g5s6d7kCdCcyyJPA4Q7063-KhyqKGeYD5C51w,67428
 lamindb/curators/_cellxgene_schemas/__init__.py,sha256=iw6PrzhBQpAR7aQ4_MXopSAVX2hdderHH3LRWeQy7Hk,7511
 lamindb/curators/_cellxgene_schemas/schema_versions.csv,sha256=X9rmO88TW1Fht1f5mJs0JdW-VPvyKSajpf8lHNeECj4,1680
 lamindb/examples/__init__.py,sha256=DGImiuWYDvwxh78p5FCwQWClEwsE3ODLU49i_NqbW0c,533
@@ -97,21 +97,22 @@ lamindb/migrations/0111_remove_record__sort_order.py,sha256=m5CC_VXupeUywupKQ74R
 lamindb/migrations/0112_alter_recordartifact_feature_and_more.py,sha256=19AothLLch_iY5W5YhH3G-paNFSlqTeGwVfYX78o8Hc,3458
 lamindb/migrations/0113_lower_case_branch_and_space_names.py,sha256=Xt2krstx3t30iTi2z0qTCBNteDA5Wy9L-thRXJSeUA8,1734
 lamindb/migrations/0114_alter_run__status_code.py,sha256=KkGecSBJElA3LBnhSK5_rFpcFridOuv6BhM8DCYqTKw,612
-lamindb/migrations/0114_squashed.py,sha256=O_iKRrE4wgcrcJjXuOIigE5EfunJeY03Ev9INsyaBus,162867
+lamindb/migrations/0115_alter_space_uid.py,sha256=18fCP8d31Ox1KxSSmfzU-W3lSpS3xtiaBNbPeHQiuTM,1332
+lamindb/migrations/0115_squashed.py,sha256=gDjKt5S-Uk5NK72JPnsB1zD_kyAVIXR5DFEBHNAUcr4,162935
 lamindb/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lamindb/models/__init__.py,sha256=mtjZH0x31aV463YaUef8ZvdQHlGa6SZr_thsrlbdkCg,2419
 lamindb/models/_describe.py,sha256=kxw7E_a5FqAI_GEH0QDGsBywQtmZ9DqQrJxnFmVJDt8,7717
-lamindb/models/_django.py,sha256=bBu1yBJcE7RvPWor1Fp2sU0IEyrgTHxJbrDILDAvVFM,9029
+lamindb/models/_django.py,sha256=49DtZuDtPa_R7FPJ47V6wh77gBDcGdILgotQsFZeRXE,9775
 lamindb/models/_feature_manager.py,sha256=YLhcNGQHWpKDzXR2SFoj0jAPkz0Iynw51_pcxJUSNCE,54854
 lamindb/models/_from_values.py,sha256=cCGPMDlAbBrdhFW-XrIQVZ10q1LNg4MycYPLOkF0fTc,13366
 lamindb/models/_is_versioned.py,sha256=Th2_cBf9UWh27E6ANxg6LGmjBOumXFy7AjH0GG4FoXA,7601
 lamindb/models/_label_manager.py,sha256=O3KaaTEVId5ky3h0aCGg1kDoFFfrovFYlV82YsZZyIs,12127
 lamindb/models/_relations.py,sha256=zHYLujy9vkuB9jVq5844TpzLSP__iYNCQcsl-FzK1Jw,3700
-lamindb/models/artifact.py,sha256=OR_dr4r72WQ_hzZPILYRx14xHDccggO7ZY0-jRn7Nh8,116972
+lamindb/models/artifact.py,sha256=UnNFkumf0FI1RlH_0KCR1lq5lTDi3xEA3U9LGGBg2hw,115932
 lamindb/models/artifact_set.py,sha256=VOZEGDo3m_9Yg_ftx3I2fwdydjHN61X_qV18N6xG4kM,4117
 lamindb/models/can_curate.py,sha256=ShEva1GGpJcCg7k95t99RzWfz28OFSorPFXLrGoXavE,29266
 lamindb/models/collection.py,sha256=zNiYzj0K_UgIobWzBY93rekVpZm76p9BJOw7Pz0i8ZE,28356
-lamindb/models/feature.py,sha256=ZQL5bOnNKyWHz3XXStXuk-pp9pvG8wa3yvW0gDkZZA0,37181
+lamindb/models/feature.py,sha256=csy8NZy10Z-ekPoYvEwT0Il4QS4jceq0To_QVRL41A8,37165
 lamindb/models/has_parents.py,sha256=NRNshrWCX7G3nnM3lnnHQ3Ho216T3EJfgakY6KlTvt8,20301
 lamindb/models/project.py,sha256=Za__zEzsShXmfCkKjg1wmlJ_UuGJur-mg6ALNslYJfw,17315
 lamindb/models/query_manager.py,sha256=EzbyNA5zWUbLYH5yJ7dIC90j1teVoQHrXpRLjCfBEao,11036
@@ -120,15 +121,16 @@ lamindb/models/record.py,sha256=syOBBefZhlqZpoVJD32uqzEzbwXiOboAOA3AlGaOkhE,1205
 lamindb/models/run.py,sha256=3xCAJnxK4iNeFlFz1bAxYDnRGU4HnRpDfxq4MwB6cPw,15565
 lamindb/models/save.py,sha256=jXha2jfY-pWsKuP2dwaEROhUGxhM8fTWQGWAzA_xsM0,16777
 lamindb/models/schema.py,sha256=oI3_eUYTYrMofOVJTCCKVkGr4L6VWpIxx5L4fauTtn8,48244
-lamindb/models/sqlrecord.py,sha256=bnsDXXqnfUMdhYwCPL82xLxR8JuJJUpzwsIbkYbuSl4,67588
-lamindb/models/storage.py,sha256=D5wVikrFiQqrDIOVB0nJvX2f5nicrFHIBlan7AMqDn0,11387
+lamindb/models/sqlrecord.py,sha256=FqtK9epCiFPhqr2DI0W6OmU621wU7FVh9rXouGK3_3w,68136
+lamindb/models/storage.py,sha256=0jvuQyJcIMdrZ9qq-vmKkI66libb2DqWjCXNFuvinIM,13518
 lamindb/models/transform.py,sha256=BceBz250AznWf85LefgS2nJNye_xJ0w_jce-mGJDN6Y,12474
 lamindb/models/ulabel.py,sha256=ocAMSKeQcq2Kr6Dq0mxGupOmW1K0pAs19vjDeTEb6vM,9335
-lamindb/setup/__init__.py,sha256=VOkMk9WVySxj0cHj9ASJnjpjhJiDOg2hA9HjNNzoxQE,425
+lamindb/setup/__init__.py,sha256=QZ-JF8IzO_ckDOU223lsJrdO5ay7cDFgvCbkLeAuxYA,467
+lamindb/setup/_switch.py,sha256=njZJN__JOhVrBFGClQG1wobdhJJp6l_XzPGKtKSCrfU,434
 lamindb/setup/core/__init__.py,sha256=SevlVrc2AZWL3uALbE5sopxBnIZPWZ1IB0NBDudiAL8,167
 lamindb/setup/errors/__init__.py,sha256=bAHTxOUJW1rm4zpF0Pvqkftn8W6iMGnQ-uyNBu13Nfg,171
 lamindb/setup/types/__init__.py,sha256=ATaosOi6q-cDWB52T69_sRmLMqj8cHfc-vljzZsrJNw,169
-lamindb-1.7a1.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-lamindb-1.7a1.dist-info/WHEEL,sha256=CpUCUxeHQbRN5UGRQHYRJorO5Af-Qy_fHMctcQ8DSGI,82
-lamindb-1.7a1.dist-info/METADATA,sha256=a12fDALiPF1EygwixlW206Yl0zTnPznU9BORJr5NMQs,2669
-lamindb-1.7a1.dist-info/RECORD,,
+lamindb-1.8.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+lamindb-1.8.0.dist-info/WHEEL,sha256=CpUCUxeHQbRN5UGRQHYRJorO5Af-Qy_fHMctcQ8DSGI,82
+lamindb-1.8.0.dist-info/METADATA,sha256=rHBLxF0dN8XsUC8W8_qNRg1GoQVyIg5NnbtaiD_gb6A,2669
+lamindb-1.8.0.dist-info/RECORD,,