lamindb 1.0.1__py3-none-any.whl → 1.0.3__py3-none-any.whl

lamindb/__init__.py

@@ -53,7 +53,7 @@ Modules and settings.
 """
 
 # denote a release candidate for 0.1.0 with 0.1rc1, 0.1a1, 0.1b1, etc.
-__version__ = "1.0.1"
+__version__ = "1.0.3"
 
 from lamindb_setup._check_setup import InstanceNotSetupError as _InstanceNotSetupError
 from lamindb_setup._check_setup import _check_instance_setup

lamindb/_finish.py

@@ -118,9 +118,8 @@ def notebook_to_script(
 def clean_r_notebook_html(file_path: Path) -> tuple[str | None, Path]:
     import re
 
-    cleaned_content = (
-        file_path.read_text()
-    )  # at this point cleaned_content is still raw
+    cleaned_content = file_path.read_text()
+    # remove title from content
     pattern_title = r"<title>(.*?)</title>"
     title_match = re.search(pattern_title, cleaned_content)
     title_text = None
@@ -129,9 +128,18 @@ def clean_r_notebook_html(file_path: Path) -> tuple[str | None, Path]:
         pattern_h1 = f"<h1[^>]*>{re.escape(title_text)}</h1>"
         cleaned_content = re.sub(pattern_title, "", cleaned_content)
         cleaned_content = re.sub(pattern_h1, "", cleaned_content)
-    cleaned_content = cleaned_content.replace(
-        f"NotebookNotSaved: {get_save_notebook_message()}", ""
-    )
+    # remove error message from content
+    if "NotebookNotSaved" in cleaned_content:
+        orig_error_message = f"NotebookNotSaved: {get_save_notebook_message()}"
+        # coming up with the regex for this is a bit tricky due to all the
+        # escape characters we'd need to insert into the message; hence,
+        # we do this with a replace() instead
+        cleaned_content = cleaned_content.replace(orig_error_message, "")
+        if "NotebookNotSaved" in cleaned_content:
+            orig_error_message = orig_error_message.replace(
+                " `finish()`", "\n`finish()`"
+            )  # RStudio might insert a newline
+            cleaned_content = cleaned_content.replace(orig_error_message, "")
     cleaned_path = file_path.parent / (f"{file_path.stem}.cleaned{file_path.suffix}")
     cleaned_path.write_text(cleaned_content)
     return title_text, cleaned_path
@@ -151,8 +159,6 @@ def save_context_core(
         format_field_value,  # needs to come after lamindb was imported because of CLI use
     )
 
-    from .core._context import context
-
     ln.settings.verbosity = "success"
 
     # for scripts, things are easy
@@ -202,7 +208,7 @@ def save_context_core(
             report_path = filepath.with_suffix(".html")
         else:
             logger.warning(
-                f"no {filepath.with_suffix('.nb.html')} found, save your manually rendered .html report via the CLI: lamin save {filepath}"
+                f"no html report found; to attach one, create an .html export for your {filepath.suffix} file and then run: lamin save {filepath}"
             )
     if report_path is not None and not from_cli:
         if get_seconds_since_modified(report_path) > 2 and not ln_setup._TESTING:
@@ -292,10 +298,13 @@ def save_context_core(
                 )
                 report_file.save(upload=True, print_progress=False)
                 run.report = report_file
+            if is_r_notebook:
+                # this is the "cleaned" report
+                report_path.unlink()
             logger.debug(
                 f"saved transform.latest_run.report: {transform.latest_run.report}"
             )
-        run.is_consecutive = is_consecutive
+        run._is_consecutive = is_consecutive
 
         # save both run & transform records if we arrive here
         run.save()
@@ -324,7 +333,4 @@ def save_context_core(
             logger.important(
                 f"if you want to update your {thing} without re-running it, use `lamin save {filepath}`"
             )
-    # because run & transform changed, update the global context
-    context._run = run
-    context._transform = transform
     return None

lamindb/core/_context.py

@@ -395,6 +395,11 @@ class Context:
             path = Path(module.__file__)
         else:
             path = Path(path)
+        # for Rmd and qmd, we could also extract the title
+        # we don't do this for now as we're setting the title upon `ln.finish()` or `lamin save`
+        # by extracting it from the html while cleaning it: see clean_r_notebook_html()
+        # also see the script_to_notebook() in the CLI _load.py where the title is extracted
+        # from the source code YAML and updated with the transform description
         transform_type = "notebook" if path.suffix in {".Rmd", ".qmd"} else "script"
         reference = None
         reference_type = None
@@ -489,14 +494,30 @@ class Context:
                     if aux_transform.key in self._path.as_posix():
                         key = aux_transform.key
                         if (
+                            # if the transform source code wasn't yet saved
                             aux_transform.source_code is None
-                            or aux_transform.hash == hash
+                            # if the transform source code is unchanged
+                            # if aux_transform.type == "notebook", we anticipate the user makes changes to the notebook source code
+                            # in an interactive session, hence we *pro-actively bump* the version number by setting `revises`
+                            # in the second part of the if condition even though the source code is unchanged at point of running track()
+                            or (
+                                aux_transform.hash == hash
+                                and aux_transform.type != "notebook"
+                            )
                         ):
                             uid = aux_transform.uid
                             target_transform = aux_transform
                         else:
                             uid = f"{aux_transform.uid[:-4]}{increment_base62(aux_transform.uid[-4:])}"
-                            message = f"there already is a transform with key '{aux_transform.key}', creating new version '{uid}'"
+                            message = f"there already is a {aux_transform.type} with `key` '{aux_transform.key}'"
+                            if (
+                                aux_transform.hash == hash
+                                and aux_transform.type == "notebook"
+                            ):
+                                message += " -- notebook source code is unchanged, but anticipating changes during this run"
+                            elif aux_transform.hash != hash:
+                                message += " -- source code changed"
+                            message += f", creating new version '{uid}'"
                             revises = aux_transform
                         found_key = True
                         break
@@ -508,7 +529,7 @@ class Context:
                             for transform in transforms
                         ]
                     )
-                    message = f"ignoring transform{plural_s} with same filedescription:\n{transforms_str}"
+                    message = f"ignoring transform{plural_s} with same filename:\n{transforms_str}"
                 if message != "":
                     logger.important(message)
             self.uid, transform = uid, target_transform
@@ -581,7 +602,7 @@ class Context:
             # check whether the transform.key is consistent
             if transform.key != key:
                 raise UpdateContext(get_key_clashing_message(transform, key))
-            elif transform.description != description:
+            elif transform.description != description and description is not None:
                 transform.description = description
                 transform.save()
                 self._logging_message_track += (
@@ -597,7 +618,9 @@ class Context:
             # check whether transform source code was already saved
             if transform_was_saved:
                 bump_revision = False
-                if is_run_from_ipython:
+                if transform.type == "notebook":
+                    # we anticipate the user makes changes to the notebook source code
+                    # in an interactive session, hence we pro-actively bump the version number
                     bump_revision = True
                 else:
                     hash, _ = hash_file(self._path)  # ignore hash_type for now
@@ -609,12 +632,12 @@ class Context:
                         )
                 if bump_revision:
                     change_type = (
-                        "re-running saved notebook"
-                        if is_run_from_ipython
+                        "re-running notebook with already-saved source code"
+                        if transform.type == "notebook"
                         else "source code changed"
                     )
                     raise UpdateContext(
-                        f'✗ {change_type}, run: ln.track("{uid[:-4]}{increment_base62(uid[-4:])}")'
+                        f'✗ {change_type}, please update the `uid` argument in `track()` to "{uid[:-4]}{increment_base62(uid[-4:])}"'
                     )
             else:
                 self._logging_message_track += f"loaded Transform('{transform.uid}')"
@@ -683,6 +706,13 @@ class Context:
         )
         if self.transform.type != "notebook":
             self._stream_tracker.finish()
+        # reset the context attributes so that somebody who runs `track()` after finish
+        # starts fresh
+        self._uid = None
+        self._run = None
+        self._transform = None
+        self._version = None
+        self._description = None
 
 
 context = Context()

lamindb/curators/__init__.py

@@ -13,6 +13,7 @@ from lamin_utils import colors, logger
 from lamindb_setup.core._docs import doc_args
 from lamindb_setup.core.upath import UPath
 
+from lamindb.base.types import FieldAttr  # noqa
 from lamindb.models import (
     Artifact,
     Feature,
@@ -31,11 +32,6 @@ if TYPE_CHECKING:
 
     from lamindb_setup.core.types import UPathStr
     from mudata import MuData
-    from spatialdata import SpatialData
-
-    from lamindb.base.types import FieldAttr
-
-    from ._spatial import SpatialDataCurator
 
 
 class CurateLookup:
@@ -1720,7 +1716,7 @@ class Curator(BaseCurator):
     @classmethod
     def from_spatialdata(
         cls,
-        sdata: SpatialData,
+        sdata,
         var_index: dict[str, FieldAttr],
         categoricals: dict[str, dict[str, FieldAttr]] | None = None,
         using_key: str | None = None,
@@ -1730,7 +1726,7 @@ class Curator(BaseCurator):
         verbosity: str = "hint",
         *,
         sample_metadata_key: str = "sample",
-    ) -> SpatialDataCurator:
+    ):
         """Curation flow for a ``Spatialdata`` object.
 
         See also :class:`~lamindb.Curator`.

lamindb/migrations/0080_polish_lamindbv1.py

@@ -0,0 +1,534 @@
+# Generated by Django 5.2 on 2025-01-20 04:42
+
+import django.db.models.deletion
+import django.db.models.functions.datetime
+from django.db import migrations, models
+
+import lamindb.base.fields
+import lamindb.base.ids
+import lamindb.base.users
+import lamindb.models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("lamindb", "0079_alter_rundata_value_json_and_more"),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name="project",
+            name="persons",
+        ),
+        migrations.AddField(
+            model_name="project",
+            name="is_type",
+            field=lamindb.base.fields.BooleanField(
+                blank=True, db_index=True, default=None, null=True
+            ),
+        ),
+        migrations.AddField(
+            model_name="project",
+            name="predecessors",
+            field=models.ManyToManyField(
+                related_name="successors", to="lamindb.project"
+            ),
+        ),
+        migrations.AlterField(
+            model_name="artifact",
+            name="uid",
+            field=lamindb.base.fields.CharField(
+                blank=True,
+                db_index=True,
+                default=None,
+                editable=False,
+                max_length=20,
+                unique=True,
+            ),
+        ),
+        migrations.AlterField(
+            model_name="collection",
+            name="uid",
+            field=lamindb.base.fields.CharField(
+                blank=True,
+                db_index=True,
+                default=lamindb.base.ids.base62_20,
+                editable=False,
+                max_length=20,
+                unique=True,
+            ),
+        ),
+        migrations.AlterField(
+            model_name="feature",
+            name="uid",
+            field=lamindb.base.fields.CharField(
+                blank=True,
+                db_index=True,
+                default=lamindb.base.ids.base62_12,
+                editable=False,
+                max_length=12,
+                unique=True,
+            ),
+        ),
+        migrations.AlterField(
+            model_name="person",
+            name="uid",
+            field=lamindb.base.fields.CharField(
+                blank=True,
+                db_index=True,
+                default=lamindb.base.ids.base62_8,
+                editable=False,
+                max_length=8,
+                unique=True,
+            ),
+        ),
+        migrations.AlterField(
+            model_name="project",
+            name="type",
+            field=lamindb.base.fields.ForeignKey(
+                blank=True,
+                null=True,
+                on_delete=django.db.models.deletion.PROTECT,
+                related_name="records",
+                to="lamindb.project",
+            ),
+        ),
+        migrations.AlterField(
+            model_name="project",
+            name="uid",
+            field=lamindb.base.fields.CharField(
+                blank=True,
+                db_index=True,
+                default=lamindb.base.ids.base62_12,
+                editable=False,
+                max_length=12,
+                unique=True,
+            ),
+        ),
+        migrations.AlterField(
+            model_name="reference",
+            name="uid",
+            field=lamindb.base.fields.CharField(
+                blank=True,
+                db_index=True,
+                default=lamindb.base.ids.base62_12,
+                editable=False,
+                max_length=12,
+                unique=True,
+            ),
+        ),
+        migrations.AlterField(
+            model_name="run",
+            name="uid",
+            field=lamindb.base.fields.CharField(
+                blank=True,
+                db_index=True,
+                default=lamindb.base.ids.base62_20,
+                editable=False,
+                max_length=20,
+                unique=True,
+            ),
+        ),
+        migrations.AlterField(
+            model_name="schema",
+            name="uid",
+            field=lamindb.base.fields.CharField(
+                blank=True,
+                db_index=True,
+                default=None,
+                editable=False,
+                max_length=20,
+                unique=True,
+            ),
+        ),
+        migrations.AlterField(
+            model_name="space",
+            name="uid",
+            field=lamindb.base.fields.CharField(
+                blank=True,
+                db_default="00000000",
+                db_index=True,
+                default="00000000",
+                editable=False,
+                max_length=12,
+                unique=True,
+            ),
+        ),
+        migrations.AlterField(
+            model_name="storage",
+            name="uid",
+            field=lamindb.base.fields.CharField(
+                blank=True,
+                db_index=True,
+                default=lamindb.base.ids.base62_12,
+                editable=False,
+                max_length=12,
+                unique=True,
+            ),
+        ),
+        migrations.AlterField(
+            model_name="tidytable",
+            name="uid",
+            field=lamindb.base.fields.CharField(
+                blank=True,
+                db_index=True,
+                default=lamindb.base.ids.base62_12,
+                editable=False,
+                max_length=12,
+                unique=True,
+            ),
+        ),
+        migrations.AlterField(
+            model_name="transform",
+            name="uid",
+            field=lamindb.base.fields.CharField(
+                blank=True,
+                db_index=True,
+                default=None,
+                editable=False,
+                max_length=16,
+                unique=True,
+            ),
+        ),
+        migrations.AlterField(
+            model_name="ulabel",
+            name="uid",
+            field=lamindb.base.fields.CharField(
+                blank=True,
+                db_index=True,
+                default=lamindb.base.ids.base62_8,
+                editable=False,
+                max_length=8,
+                unique=True,
+            ),
+        ),
+        migrations.AlterField(
+            model_name="user",
+            name="uid",
+            field=lamindb.base.fields.CharField(
+                blank=True,
+                db_index=True,
+                default=None,
+                editable=False,
+                max_length=8,
+                unique=True,
+            ),
+        ),
+        migrations.CreateModel(
+            name="PersonProject",
+            fields=[
+                (
+                    "created_at",
+                    lamindb.base.fields.DateTimeField(
+                        blank=True,
+                        db_default=django.db.models.functions.datetime.Now(),
+                        db_index=True,
+                        editable=False,
+                    ),
+                ),
+                ("id", models.BigAutoField(primary_key=True, serialize=False)),
+                (
+                    "role",
+                    lamindb.base.fields.CharField(
+                        blank=True, default=None, max_length=255, null=True
+                    ),
+                ),
+                (
+                    "created_by",
+                    lamindb.base.fields.ForeignKey(
+                        blank=True,
+                        default=lamindb.base.users.current_user_id,
+                        editable=False,
+                        on_delete=django.db.models.deletion.PROTECT,
+                        related_name="+",
+                        to="lamindb.user",
+                    ),
+                ),
+                (
+                    "person",
+                    lamindb.base.fields.ForeignKey(
+                        blank=True,
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="links_project",
+                        to="lamindb.person",
+                    ),
+                ),
+                (
+                    "project",
+                    lamindb.base.fields.ForeignKey(
+                        blank=True,
+                        on_delete=django.db.models.deletion.PROTECT,
+                        related_name="links_person",
+                        to="lamindb.project",
+                    ),
+                ),
+                (
+                    "run",
+                    lamindb.base.fields.ForeignKey(
+                        blank=True,
+                        default=lamindb.models.current_run,
+                        null=True,
+                        on_delete=django.db.models.deletion.PROTECT,
+                        related_name="+",
+                        to="lamindb.run",
+                    ),
+                ),
+            ],
+            options={
+                "unique_together": {("person", "project")},
+            },
+            bases=(lamindb.models.LinkORM, models.Model),
+        ),
+        migrations.AddField(
+            model_name="project",
+            name="people",
+            field=models.ManyToManyField(
+                related_name="projects",
+                through="lamindb.PersonProject",
+                to="lamindb.person",
+            ),
+        ),
+        migrations.AlterField(
+            model_name="rundata",
+            name="run",
+            field=models.ForeignKey(
+                on_delete=django.db.models.deletion.CASCADE,
+                related_name="_rundata",
+                to="lamindb.run",
+            ),
+        ),
+        migrations.AddField(
+            model_name="schema",
+            name="description",
+            field=lamindb.base.fields.CharField(
+                blank=True, db_index=True, default=None, max_length=255, null=True
+            ),
+        ),
+        migrations.AlterField(
+            model_name="collection",
+            name="description",
+            field=lamindb.base.fields.CharField(
+                blank=True, db_index=True, default=None, max_length=255, null=True
+            ),
+        ),
+        migrations.AlterField(
+            model_name="feature",
+            name="description",
+            field=lamindb.base.fields.CharField(
+                blank=True, db_index=True, default=None, max_length=255, null=True
+            ),
+        ),
+        migrations.AlterField(
+            model_name="paramvalue",
+            name="created_at",
+            field=lamindb.base.fields.DateTimeField(
+                blank=True,
+                db_default=django.db.models.functions.datetime.Now(),
+                db_index=True,
+                editable=False,
+            ),
+        ),
+        migrations.AlterField(
+            model_name="reference",
+            name="description",
+            field=lamindb.base.fields.CharField(
+                blank=True, db_index=True, default=None, max_length=255, null=True
+            ),
+        ),
+        migrations.AlterField(
+            model_name="run",
+            name="created_at",
+            field=lamindb.base.fields.DateTimeField(
+                blank=True,
+                db_default=django.db.models.functions.datetime.Now(),
+                db_index=True,
+                editable=False,
+            ),
+        ),
+        migrations.AlterField(
+            model_name="run",
+            name="started_at",
+            field=lamindb.base.fields.DateTimeField(
+                blank=True,
+                db_default=django.db.models.functions.datetime.Now(),
+                db_index=True,
+                editable=False,
+            ),
+        ),
+        migrations.AlterField(
+            model_name="runparamvalue",
+            name="created_at",
+            field=lamindb.base.fields.DateTimeField(
+                blank=True,
+                db_default=django.db.models.functions.datetime.Now(),
+                db_index=True,
+                editable=False,
+            ),
+        ),
+        migrations.AlterField(
+            model_name="schema",
+            name="name",
+            field=lamindb.base.fields.CharField(
+                blank=True, db_index=True, default=None, max_length=150, null=True
+            ),
+        ),
+        migrations.AlterField(
+            model_name="space",
+            name="created_at",
+            field=lamindb.base.fields.DateTimeField(
+                blank=True,
+                db_default=django.db.models.functions.datetime.Now(),
+                db_index=True,
+                editable=False,
+            ),
+        ),
+        migrations.AlterField(
+            model_name="tidytable",
+            name="description",
+            field=lamindb.base.fields.CharField(
+                blank=True, db_index=True, default=None, max_length=255, null=True
+            ),
+        ),
+        migrations.AlterField(
+            model_name="transform",
+            name="created_at",
+            field=lamindb.base.fields.DateTimeField(
+                blank=True,
+                db_default=django.db.models.functions.datetime.Now(),
+                db_index=True,
+                editable=False,
+            ),
+        ),
+        migrations.AlterField(
+            model_name="transform",
+            name="updated_at",
+            field=lamindb.base.fields.DateTimeField(
+                blank=True,
+                db_default=django.db.models.functions.datetime.Now(),
+                db_index=True,
+                editable=False,
+            ),
+        ),
+        migrations.AlterField(
+            model_name="ulabel",
+            name="description",
+            field=lamindb.base.fields.CharField(
+                blank=True, db_index=True, default=None, max_length=255, null=True
+            ),
+        ),
+        migrations.AlterField(
+            model_name="user",
+            name="created_at",
+            field=lamindb.base.fields.DateTimeField(
+                blank=True,
+                db_default=django.db.models.functions.datetime.Now(),
+                db_index=True,
+                editable=False,
+            ),
+        ),
+        migrations.AlterField(
+            model_name="user",
+            name="updated_at",
+            field=lamindb.base.fields.DateTimeField(
+                blank=True,
+                db_default=django.db.models.functions.datetime.Now(),
+                db_index=True,
+                editable=False,
+            ),
+        ),
+        migrations.CreateModel(
+            name="RunULabel",
+            fields=[
+                ("id", models.BigAutoField(primary_key=True, serialize=False)),
+                (
+                    "created_at",
+                    lamindb.base.fields.DateTimeField(
+                        blank=True,
+                        db_default=django.db.models.functions.datetime.Now(),
+                        db_index=True,
+                        editable=False,
+                    ),
+                ),
+                (
+                    "created_by",
+                    lamindb.base.fields.ForeignKey(
+                        blank=True,
+                        default=lamindb.base.users.current_user_id,
+                        on_delete=django.db.models.deletion.PROTECT,
+                        related_name="+",
+                        to="lamindb.user",
+                    ),
+                ),
+                (
+                    "run",
+                    lamindb.base.fields.ForeignKey(
+                        blank=True,
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="links_ulabel",
+                        to="lamindb.run",
+                    ),
+                ),
+                (
+                    "ulabel",
+                    lamindb.base.fields.ForeignKey(
+                        blank=True,
+                        on_delete=django.db.models.deletion.PROTECT,
+                        related_name="links_run",
+                        to="lamindb.ulabel",
+                    ),
+                ),
+            ],
+            options={
+                "unique_together": {("run", "ulabel")},
+            },
+            bases=(models.Model, lamindb.models.LinkORM),
+        ),
+        migrations.AddField(
+            model_name="run",
+            name="ulabels",
+            field=models.ManyToManyField(
+                related_name="runs", through="lamindb.RunULabel", to="lamindb.ulabel"
+            ),
+        ),
+        migrations.RenameModel(
+            old_name="TidyTable",
+            new_name="FlexTable",
+        ),
+        migrations.RenameModel(
+            old_name="TidyTableData",
+            new_name="FlexTableData",
+        ),
+        migrations.RenameIndex(
+            model_name="flextable",
+            new_name="lamindb_fle_uid_e6f216_idx",
+            old_name="lamindb_tid_uid_3a6e54_idx",
+        ),
+        migrations.RenameIndex(
+            model_name="flextable",
+            new_name="lamindb_fle_name_568594_idx",
+            old_name="lamindb_tid_name_50c5de_idx",
+        ),
+        migrations.RenameIndex(
+            model_name="flextabledata",
+            new_name="lamindb_fle_tidytab_1674c1_idx",
+            old_name="lamindb_tid_tidytab_b35a4d_idx",
+        ),
+        migrations.RenameIndex(
+            model_name="flextabledata",
+            new_name="lamindb_fle_feature_830e49_idx",
+            old_name="lamindb_tid_feature_5a0b1f_idx",
+        ),
+        migrations.RenameIndex(
+            model_name="flextabledata",
+            new_name="lamindb_fle_param_i_4149cb_idx",
+            old_name="lamindb_tid_param_i_16c884_idx",
+        ),
+        migrations.RemoveField(
+            model_name="flextabledata",
+            name="value_upath",
+        ),
+        migrations.RemoveField(
+            model_name="rundata",
+            name="value_upath",
+        ),
+    ]

lamindb/models.py

@@ -824,6 +824,7 @@ class Space(BasicRecord):
     name: str = models.CharField(max_length=100, db_index=True)
     """Name of space."""
     uid: str = CharField(
+        editable=False,
         unique=True,
         max_length=12,
         default="00000000",
@@ -833,7 +834,9 @@ class Space(BasicRecord):
     """Universal id."""
     description: str | None = CharField(null=True)
     """Description of space."""
-    created_at: datetime = DateTimeField(auto_now_add=True, db_index=True)
+    created_at: datetime = DateTimeField(
+        editable=False, db_default=models.functions.Now(), db_index=True
+    )
     """Time of creation of record."""
     created_by: User = ForeignKey(
         "User", CASCADE, default=None, related_name="+", null=True
@@ -979,7 +982,7 @@ class User(BasicRecord, CanCurate):
 
     id: int = models.AutoField(primary_key=True)
     """Internal id, valid only in one DB instance."""
-    uid: str = CharField(unique=True, db_index=True, max_length=8)
+    uid: str = CharField(editable=False, unique=True, db_index=True, max_length=8)
     """Universal id, valid across DB instances."""
     handle: str = CharField(max_length=30, unique=True, db_index=True)
     """Universal handle, valid across DB instances (required)."""
@@ -991,9 +994,13 @@ class User(BasicRecord, CanCurate):
     """Transforms created by user."""
     created_runs: Run
     """Runs created by user."""
-    created_at: datetime = DateTimeField(auto_now_add=True, db_index=True)
+    created_at: datetime = DateTimeField(
+        editable=False, db_default=models.functions.Now(), db_index=True
+    )
     """Time of creation of record."""
-    updated_at: datetime = DateTimeField(auto_now=True, db_index=True)
+    updated_at: datetime = DateTimeField(
+        editable=False, db_default=models.functions.Now(), db_index=True
+    )
     """Time of last update to record."""
 
     @overload
@@ -1070,12 +1077,14 @@ class Storage(Record, TracksRun, TracksUpdates):
 
     id: int = models.AutoField(primary_key=True)
     """Internal id, valid only in one DB instance."""
-    uid: str = CharField(unique=True, max_length=12, default=base62_12, db_index=True)
+    uid: str = CharField(
+        editable=False, unique=True, max_length=12, default=base62_12, db_index=True
+    )
     """Universal id, valid across DB instances."""
     # we are very conservative here with 255 characters
-    root: str = CharField(max_length=255, db_index=True, unique=True)
+    root: str = CharField(db_index=True, unique=True)
     """Root path of storage. n s3 path.  local path, etc. (required)."""
-    description: str | None = CharField(max_length=255, db_index=True, null=True)
+    description: str | None = CharField(db_index=True, null=True)
     """A description of what the storage location is used for (optional)."""
     type: str = CharField(max_length=30, db_index=True)
     """Can be "local" vs. "s3" vs. "gs"."""
@@ -1198,7 +1207,9 @@ class Transform(Record, IsVersioned):
 
     id: int = models.AutoField(primary_key=True)
     """Internal id, valid only in one DB instance."""
-    uid: str = CharField(unique=True, db_index=True, max_length=_len_full_uid)
+    uid: str = CharField(
+        editable=False, unique=True, db_index=True, max_length=_len_full_uid
+    )
     """Universal id."""
     key: str | None = CharField(db_index=True, null=True)
     """A name or "/"-separated path-like string.
@@ -1259,9 +1270,17 @@ class Transform(Record, IsVersioned):
 
     If you're looking for the outputs of a single run, see :attr:`lamindb.Run.output_collections`.
     """
-    created_at: datetime = DateTimeField(auto_now_add=True, db_index=True)
+    projects: Project
+    """Associated projects."""
+    references: Reference
+    """Associated references."""
+    created_at: datetime = DateTimeField(
+        editable=False, db_default=models.functions.Now(), db_index=True
+    )
     """Time of creation of record."""
-    updated_at: datetime = DateTimeField(auto_now=True, db_index=True)
+    updated_at: datetime = DateTimeField(
+        editable=False, db_default=models.functions.Now(), db_index=True
+    )
     """Time of last update to record."""
     created_by: User = ForeignKey(
         User, PROTECT, default=current_user_id, related_name="created_transforms"
@@ -1381,7 +1400,9 @@ class ParamValue(Record):
     # hence, ParamValue does _not_ inherit from TracksRun but manually
     # adds created_at & created_by
     # because ParamValue cannot be updated, we don't need updated_at
-    created_at: datetime = DateTimeField(auto_now_add=True, db_index=True)
+    created_at: datetime = DateTimeField(
+        editable=False, db_default=models.functions.Now(), db_index=True
+    )
     """Time of creation of record."""
     created_by: User = ForeignKey(
         User, PROTECT, default=current_user_id, related_name="+"
@@ -1476,13 +1497,17 @@ class Run(Record):
 
     id: int = models.BigAutoField(primary_key=True)
     """Internal id, valid only in one DB instance."""
-    uid: str = CharField(unique=True, db_index=True, max_length=20, default=base62_20)
+    uid: str = CharField(
+        editable=False, unique=True, db_index=True, max_length=20, default=base62_20
+    )
     """Universal id, valid across DB instances."""
     name: str | None = CharField(max_length=150, null=True)
     """A name."""
     transform = ForeignKey(Transform, CASCADE, related_name="runs")
     """The transform :class:`~lamindb.Transform` that is being run."""
-    started_at: datetime = DateTimeField(auto_now_add=True, db_index=True)
+    started_at: datetime = DateTimeField(
+        editable=False, db_default=models.functions.Now(), db_index=True
+    )
     """Start time of run."""
     finished_at: datetime | None = DateTimeField(db_index=True, null=True, default=None)
     """Finished time of run."""
@@ -1525,12 +1550,18 @@ class Run(Record):
     """A reference like a URL or external ID (such as from a workflow manager)."""
     reference_type: str | None = CharField(max_length=25, db_index=True, null=True)
     """Type of reference such as a workflow manager execution ID."""
-    created_at: datetime = DateTimeField(auto_now_add=True, db_index=True)
+    created_at: datetime = DateTimeField(
+        editable=False, db_default=models.functions.Now(), db_index=True
+    )
     """Time of first creation. Mismatches ``started_at`` if the run is re-run."""
     created_by: User = ForeignKey(
         User, CASCADE, default=current_user_id, related_name="created_runs"
     )
     """Creator of run."""
+    ulabels: ULabel = models.ManyToManyField(
+        "ULabel", through="RunULabel", related_name="runs"
+    )
+    """ULabel annotations of this transform."""
     initiated_by_run: Run | None = ForeignKey(
         "Run", CASCADE, null=True, related_name="initiated_runs", default=None
     )
@@ -1542,8 +1573,8 @@ class Run(Record):
 
     Be careful with using this field at this point.
     """
-    children: Run
-    """The runs that are triggered by this run."""
+    initiated_runs: Run
+    """Runs that were initiated by this run."""
     _is_consecutive: bool | None = BooleanField(null=True)
     """Indicates whether code was consecutively executed. Is relevant for notebooks."""
     _status_code: int = models.SmallIntegerField(default=0, db_index=True)
@@ -1643,7 +1674,9 @@ class ULabel(Record, HasParents, CanCurate, TracksRun, TracksUpdates):
 
     id: int = models.AutoField(primary_key=True)
     """Internal id, valid only in one DB instance."""
-    uid: str = CharField(unique=True, db_index=True, max_length=8, default=base62_8)
+    uid: str = CharField(
+        editable=False, unique=True, db_index=True, max_length=8, default=base62_8
+    )
     """A universal random id, valid across DB instances."""
     name: str = CharField(max_length=150, db_index=True)
     """Name or title of ulabel (`unique=True`)."""
@@ -1659,7 +1692,7 @@ class ULabel(Record, HasParents, CanCurate, TracksRun, TracksUpdates):
 
     For example, a ulabel "Project" would be a type, and the actual projects "Project 1", "Project 2", would be records of that `type`.
     """
-    description: str | None = TextField(null=True)
+    description: str | None = CharField(null=True, db_index=True)
     """A description (optional)."""
     reference: str | None = CharField(max_length=255, db_index=True, null=True)
     """A reference like URL or external ID."""
@@ -1681,10 +1714,14 @@ class ULabel(Record, HasParents, CanCurate, TracksRun, TracksUpdates):
     """
     transforms: Transform
     """Transforms annotated with this ulabel."""
+    runs: Transform
+    """Runs annotated with this ulabel."""
     artifacts: Artifact
     """Artifacts annotated with this ulabel."""
     collections: Collection
     """Collections annotated with this ulabel."""
+    projects: Project
+    """Associated projects."""
 
     @overload
     def __init__(
@@ -1801,7 +1838,9 @@ class Feature(Record, CanCurate, TracksRun, TracksUpdates):
 
     id: int = models.AutoField(primary_key=True)
     """Internal id, valid only in one DB instance."""
-    uid: str = CharField(unique=True, db_index=True, max_length=12, default=base62_12)
+    uid: str = CharField(
+        editable=False, unique=True, db_index=True, max_length=12, default=base62_12
+    )
     """Universal id, valid across DB instances."""
     name: str = CharField(max_length=150, db_index=True, unique=True)
     """Name of feature (`unique=True`)."""
@@ -1825,7 +1864,7 @@ class Feature(Record, CanCurate, TracksRun, TracksUpdates):
     """Distinguish types from instances of the type."""
     unit: str | None = CharField(max_length=30, db_index=True, null=True)
     """Unit of measure, ideally SI (`m`, `s`, `kg`, etc.) or 'normalized' etc. (optional)."""
-    description: str | None = TextField(db_index=True, null=True)
+    description: str | None = CharField(db_index=True, null=True)
     """A description."""
     array_rank: int = models.SmallIntegerField(default=0, db_index=True)
     """Rank of feature.
@@ -2051,10 +2090,12 @@ class Schema(Record, CanCurate, TracksRun):
 
     id: int = models.AutoField(primary_key=True)
     """Internal id, valid only in one DB instance."""
-    uid: str = CharField(unique=True, db_index=True, max_length=20)
+    uid: str = CharField(editable=False, unique=True, db_index=True, max_length=20)
     """A universal id (hash of the set of feature values)."""
-    name: str | None = CharField(max_length=150, null=True)
+    name: str | None = CharField(max_length=150, null=True, db_index=True)
     """A name."""
+    description: str | None = CharField(null=True, db_index=True)
+    """A description."""
     n = IntegerField()
     """Number of features in the set."""
     dtype: str | None = CharField(max_length=64, null=True)
@@ -2398,7 +2439,9 @@ class Artifact(Record, IsVersioned, TracksRun, TracksUpdates):
 
     id: int = models.AutoField(primary_key=True)
     """Internal id, valid only in one DB instance."""
-    uid: str = CharField(unique=True, db_index=True, max_length=_len_full_uid)
+    uid: str = CharField(
+        editable=False, unique=True, db_index=True, max_length=_len_full_uid
+    )
     """A universal random id."""
     key: str | None = CharField(db_index=True, null=True)
     """A (virtual) relative file path within the artifact's storage location.
@@ -2411,10 +2454,7 @@ class Artifact(Record, IsVersioned, TracksRun, TracksUpdates):
     actual filepath on the underyling filesytem or object store.
     """
     description: str | None = CharField(db_index=True, null=True)
-    """A description.
-
-    LaminDB doesn't require you to pass a key, you can
-    """
+    """A description."""
     storage: Storage = ForeignKey(Storage, PROTECT, related_name="artifacts")
     """Storage location, e.g. an S3 or GCP bucket or a local directory."""
     suffix: str = CharField(max_length=30, db_index=True)
@@ -2510,6 +2550,10 @@ class Artifact(Record, IsVersioned, TracksRun, TracksUpdates):
 
     It defaults to False for file-like artifacts and to True for folder-like artifacts.
     """
+    projects: Project
+    """Associated projects."""
+    references: Reference
+    """Associated references."""
 
     @overload
     def __init__(
@@ -2955,12 +2999,16 @@ class Collection(Record, IsVersioned, TracksRun, TracksUpdates):
     id: int = models.AutoField(primary_key=True)
     """Internal id, valid only in one DB instance."""
     uid: str = CharField(
-        unique=True, db_index=True, max_length=_len_full_uid, default=base62_20
+        editable=False,
+        unique=True,
+        db_index=True,
+        max_length=_len_full_uid,
+        default=base62_20,
     )
     """Universal id, valid across DB instances."""
     key: str = CharField(db_index=True)
     """Name or path-like key."""
-    description: str | None = TextField(null=True)
+    description: str | None = CharField(null=True, db_index=True)
     """A description or title."""
     hash: str | None = CharField(max_length=HASH_LENGTH, db_index=True, null=True)
     """Hash of collection content. 86 base64 chars allow to store 64 bytes, 512 bits."""
@@ -3239,7 +3287,9 @@ class Person(Record, CanCurate, TracksRun, TracksUpdates, ValidateFields):
 
     id: int = models.AutoField(primary_key=True)
     """Internal id, valid only in one DB instance."""
-    uid: str = CharField(unique=True, max_length=8, db_index=True, default=base62_8)
+    uid: str = CharField(
+        editable=False, unique=True, max_length=8, db_index=True, default=base62_8
+    )
     """Universal id, valid across DB instances."""
     name: str = CharField(db_index=True)
     """Name of the person (forename(s) lastname)."""
@@ -3265,12 +3315,20 @@ class Project(Record, CanCurate, TracksRun, TracksUpdates, ValidateFields):
 
     id: int = models.AutoField(primary_key=True)
     """Internal id, valid only in one DB instance."""
-    uid: str = CharField(unique=True, max_length=12, db_index=True, default=base62_12)
+    uid: str = CharField(
+        editable=False, unique=True, max_length=12, db_index=True, default=base62_12
+    )
     """Universal id, valid across DB instances."""
     name: str = CharField(db_index=True)
     """Title or name of the Project."""
-    type: str | None = CharField(max_length=64, db_index=True, null=True)
-    """A free-form type."""
+    type: Project | None = ForeignKey(
+        "self", PROTECT, null=True, related_name="records"
+    )
+    """Type of project (e.g., 'Program', 'Project', 'GithubIssue', 'Task')."""
+    records: Project
+    """Records of this type."""
+    is_type: bool = BooleanField(default=None, db_index=True, null=True)
+    """Distinguish types from instances of the type."""
     abbr: str | None = CharField(max_length=32, db_index=True, null=True)
     """An abbreviation."""
     url: str | None = URLField(max_length=255, null=True, default=None)
@@ -3282,12 +3340,25 @@ class Project(Record, CanCurate, TracksRun, TracksUpdates, ValidateFields):
     parents: Project = models.ManyToManyField(
         "self", symmetrical=False, related_name="children"
     )
-    """Parent projects."""
+    """Parent projects, the super-projects owning this project."""
     children: Project
-    """Child projects.
+    """Child projects, the sub-projects owned by this project.
 
-    Reverse accessor for parents.
+    Reverse accessor for `.parents`.
+    """
+    predecessors: Project = models.ManyToManyField(
+        "self", symmetrical=False, related_name="successors"
+    )
+    """The preceding projects required by this project."""
+    successors: Project
+    """The succeeding projects requiring this project.
+
+    Reverse accessor for `.predecessors`.
     """
+    people: Person = models.ManyToManyField(
+        Person, through="PersonProject", related_name="projects"
+    )
+    """People associated with this project."""
     artifacts: Artifact = models.ManyToManyField(
         Artifact, through="ArtifactProject", related_name="projects"
     )
@@ -3312,8 +3383,6 @@ class Project(Record, CanCurate, TracksRun, TracksUpdates, ValidateFields):
         Collection, through="CollectionProject", related_name="projects"
     )
     """Collections associated with this project."""
-    persons: Person = models.ManyToManyField(Person, related_name="projects")
-    """Persons associated with this project."""
     references: Reference = models.ManyToManyField("Reference", related_name="projects")
     """References associated with this project."""
     _status_code: int = models.SmallIntegerField(default=0, db_index=True)
@@ -3341,7 +3410,9 @@ class Reference(Record, CanCurate, TracksRun, TracksUpdates, ValidateFields):
 
     id: int = models.AutoField(primary_key=True)
     """Internal id, valid only in one DB instance."""
-    uid: str = CharField(unique=True, max_length=12, db_index=True, default=base62_12)
+    uid: str = CharField(
+        editable=False, unique=True, max_length=12, db_index=True, default=base62_12
+    )
     """Universal id, valid across DB instances."""
     name: str = CharField(db_index=True)
     """Title or name of the reference document."""
@@ -3377,7 +3448,7 @@ class Reference(Record, CanCurate, TracksRun, TracksUpdates, ValidateFields):
         ],
     )
     """Digital Object Identifier (DOI) for the reference."""
-    description: str | None = TextField(null=True)
+    description: str | None = CharField(null=True, db_index=True)
     """Description of the reference."""
     text: str | None = TextField(null=True)
     """Abstract or full text of the reference to make it searchable."""
@@ -3421,7 +3492,6 @@ class DataMixin(models.Model):
     value_int = models.BigIntegerField(null=True, blank=True)
     value_float = models.FloatField(null=True, blank=True)
     value_str = models.TextField(null=True, blank=True)
-    value_upath = models.CharField(max_length=255, null=True, blank=True)
     value_datetime = models.DateTimeField(null=True, blank=True)
     value_ulabel = models.ForeignKey(
         ULabel, null=True, blank=True, on_delete=models.CASCADE, related_name="+"
@@ -3453,7 +3523,6 @@ class DataMixin(models.Model):
             self.value_int,
             self.value_float,
             self.value_str,
-            self.value_upath,
             self.value_datetime,
             self.value_ulabel,
             self.value_artifact,
@@ -3466,7 +3535,7 @@ class DataMixin(models.Model):
 
 
 class RunData(BasicRecord, DataMixin):
-    run = models.ForeignKey("Run", on_delete=models.CASCADE, related_name="data")
+    run = models.ForeignKey("Run", on_delete=models.CASCADE, related_name="_rundata")
 
     class Meta:
         constraints = [
@@ -3488,13 +3557,15 @@ class RunData(BasicRecord, DataMixin):
         ]
 
 
-class TidyTable(Record, TracksRun, TracksUpdates):
-    uid: str = CharField(unique=True, max_length=12, db_index=True, default=base62_12)
+class FlexTable(Record, TracksRun, TracksUpdates):
+    uid: str = CharField(
+        editable=False, unique=True, max_length=12, db_index=True, default=base62_12
+    )
     name = CharField()
     schema: Schema | None = ForeignKey(
         Schema, null=True, on_delete=models.SET_NULL, related_name="_tidytables"
     )
-    type: TidyTable | None = ForeignKey(
+    type: FlexTable | None = ForeignKey(
         "self", PROTECT, null=True, related_name="records"
     )
     """Type of tidy table, e.g., `Cell`, `SampleSheet`, etc."""
@@ -3502,7 +3573,8 @@ class TidyTable(Record, TracksRun, TracksUpdates):
     """Records of this type."""
     is_type: bool = BooleanField(default=None, db_index=True, null=True)
     """Distinguish types from instances of the type."""
-    description: str = TextField()
+    description: str = CharField(null=True, db_index=True)
+    """A description."""
     projects: Project = ManyToManyField(Project, related_name="_tidytables")
     ulabels: Project = ManyToManyField(ULabel, related_name="_tidytables")
 
@@ -3510,9 +3582,9 @@ class TidyTable(Record, TracksRun, TracksUpdates):
         indexes = [models.Index(fields=["uid"]), models.Index(fields=["name"])]
 
 
-class TidyTableData(BasicRecord, DataMixin):
+class FlexTableData(BasicRecord, DataMixin):
     tidytable = models.ForeignKey(
-        TidyTable, on_delete=models.CASCADE, related_name="data"
+        FlexTable, on_delete=models.CASCADE, related_name="data"
     )
 
     class Meta:
@@ -3612,6 +3684,23 @@ class TransformULabel(BasicRecord, LinkORM, TracksRun):
         unique_together = ("transform", "ulabel")
 
 
+class RunULabel(BasicRecord, LinkORM):
+    id: int = models.BigAutoField(primary_key=True)
+    run: Run = ForeignKey(Run, CASCADE, related_name="links_ulabel")
+    ulabel: ULabel = ForeignKey(ULabel, PROTECT, related_name="links_run")
+    created_at: datetime = DateTimeField(
+        editable=False, db_default=models.functions.Now(), db_index=True
+    )
+    """Time of creation of record."""
+    created_by: User = ForeignKey(
+        "lamindb.User", PROTECT, default=current_user_id, related_name="+"
+    )
+    """Creator of record."""
+
+    class Meta:
+        unique_together = ("run", "ulabel")
+
+
 class CollectionULabel(BasicRecord, LinkORM, TracksRun):
     id: int = models.BigAutoField(primary_key=True)
     collection: Collection = ForeignKey(
@@ -3643,7 +3732,9 @@ class RunParamValue(BasicRecord, LinkORM):
     run: Run = ForeignKey(Run, CASCADE, related_name="+")
     # we follow the lower() case convention rather than snake case for link models
     paramvalue: ParamValue = ForeignKey(ParamValue, PROTECT, related_name="+")
-    created_at: datetime = DateTimeField(auto_now_add=True, db_index=True)
+    created_at: datetime = DateTimeField(
+        editable=False, db_default=models.functions.Now(), db_index=True
+    )
     """Time of creation of record."""
     created_by: User = ForeignKey(
         "lamindb.User", PROTECT, default=current_user_id, related_name="+"
@@ -3716,6 +3807,16 @@ class ULabelProject(BasicRecord, LinkORM, TracksRun):
         unique_together = ("ulabel", "project")
 
 
+class PersonProject(BasicRecord, LinkORM, TracksRun):
+    id: int = models.BigAutoField(primary_key=True)
+    person: Transform = ForeignKey(Person, CASCADE, related_name="links_project")
+    project: Project = ForeignKey(Project, PROTECT, related_name="links_person")
+    role: str | None = CharField(null=True, default=None)
+
+    class Meta:
+        unique_together = ("person", "project")
+
+
 class FeatureProject(BasicRecord, LinkORM, TracksRun):
     id: int = models.BigAutoField(primary_key=True)
     feature: Feature = ForeignKey(Feature, CASCADE, related_name="links_project")

{lamindb-1.0.1.dist-info → lamindb-1.0.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: lamindb
-Version: 1.0.1
+Version: 1.0.3
 Summary: A data framework for biology.
 Author-email: Lamin Labs <open-source@lamin.ai>
 Requires-Python: >=3.10,<3.13
@@ -9,7 +9,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Requires-Dist: lamin_utils==0.13.10
-Requires-Dist: lamin_cli==1.0.2
+Requires-Dist: lamin_cli==1.0.4
 Requires-Dist: lamindb_setup[aws]==1.0.3
 Requires-Dist: pyarrow
 Requires-Dist: typing_extensions!=4.6.0

{lamindb-1.0.1.dist-info → lamindb-1.0.3.dist-info}/RECORD

@@ -1,9 +1,9 @@
-lamindb/__init__.py,sha256=zyukYAtc-MvRSctXlkUefaL7uppSiSuZIdTw7O9HFjQ,2255
+lamindb/__init__.py,sha256=uV_nFvYAz9x_edJcb9bqtnDx2C9wHhbDbnvMN2EIQHM,2255
 lamindb/_artifact.py,sha256=22pKCA05PoIAgP2xszCHUovZ1VbMGIyrQqNLs5xDG_s,46580
 lamindb/_can_curate.py,sha256=pIu9Ylgq5biUd_67rRbAHg9tkXSQrxMRM8TnVboL9YA,20341
 lamindb/_collection.py,sha256=j2yTfR9v-NGUI85JfQk7vOQNExkWE5H_ulsSlBh1AOI,14456
 lamindb/_feature.py,sha256=qpUZfmdxUpQFLq5GciTn6KgALL19tCs0raHhzJgm7Lo,6311
-lamindb/_finish.py,sha256=LjeGY9QsC9zbQxMr5K8YCYN-rtlzTqtZQVTtkWHHEp8,12832
+lamindb/_finish.py,sha256=aMN9CwTGAXeqWSDvCumVLztHtKttwI9z52mdz4ue5Uw,13362
 lamindb/_from_values.py,sha256=uO3IfYzAI8VDDTqlbLzsZtawSYFS-Qzd_ZWwKGhH90o,14231
 lamindb/_is_versioned.py,sha256=6_LBAKD_fng6BReqitJUIxTUaQok3AeIpNnE_D8kHnQ,1293
 lamindb/_parents.py,sha256=PA--_ZH3PNqIVW0PpuYk9d4DAVlHUBPN-dN0rFUKUN0,17238
@@ -18,7 +18,7 @@ lamindb/_transform.py,sha256=LYFf8gScJrYLMZJECLYZ5nrW2vLPObdzRP47md-Tq-s,5731
 lamindb/_ulabel.py,sha256=YTiUCYrcEqyUKD8nZO4iOqiyYnUP5bW_r7yry4KSeWA,2068
 lamindb/_utils.py,sha256=LGdiW4k3GClLz65vKAVRkL6Tw-Gkx9DWAdez1jyA5bE,428
 lamindb/_view.py,sha256=c4eN5hcBlg3TVnljKefbyWAq0eBncjMp2xQcb5OaGWg,4982
-lamindb/models.py,sha256=W3htUmj4R5YJ_bFM8wly57AxR5Ip8JuiAx7mRya9q1o,144513
+lamindb/models.py,sha256=85eBwsFmoKfZfefviUt8DmfW1n6kyFQO2VfP3pa-xUc,147536
 lamindb/base/__init__.py,sha256=J0UpYObi9hJBFyBpAXp4wB3DaJx48R2SaUeB4wjiFvc,267
 lamindb/base/fields.py,sha256=RdwYHQmB7B-jopD_K2QNL5vjhOelu7DWGgqQItXr3pg,8024
 lamindb/base/ids.py,sha256=WzHWiHZtlRUKqxz_p-76ks_JSW669ztvriE7Z3A0yHg,1736
@@ -26,7 +26,7 @@ lamindb/base/types.py,sha256=JfZk0xmhLsWusU0s4SNjhRnQ52mn-cSiG5Gf4SsACBs,1227
 lamindb/base/users.py,sha256=g4ZLQb6eey66FO9eEumbfDpJi_FZZsiLVe2Frz9JuLI,978
 lamindb/base/validation.py,sha256=Azz9y2-x0cPum4yULXMG3Yzra03mcVYzcKTiI23HgxE,2287
 lamindb/core/__init__.py,sha256=4AGZqt5g8k3jFX53IXdezQR4Gf7JmMBLZRyTJJzS4sI,1628
-lamindb/core/_context.py,sha256=FTeWD-Ku1apAzabPIzs2RU-pXkQk5Wl_vsrL0kph8rI,26461
+lamindb/core/_context.py,sha256=na1n_Lpj7Dvxjk1KB5Di4jEdhH-d6Jf757fvY1awEGM,28591
 lamindb/core/_data.py,sha256=xg_St591OPCzLhaZAlGxVd8QkDxZsxDc_yEwY8Kop8w,19017
 lamindb/core/_describe.py,sha256=3Z1xi9eKIBkYuPW9ctdWvFaGZym8mI9FcwyZF3a6YVo,4885
 lamindb/core/_django.py,sha256=vPY4wJ4bf3a1uz5bhukCCF_mngR_9w2Ot3nvWZpa204,7629
@@ -58,7 +58,7 @@ lamindb/core/storage/objects.py,sha256=5vM2T_upuzrXt2b7fQeQ2FUO710-FRbubxTzKzV2E
 lamindb/core/storage/paths.py,sha256=XXEy51qCw0z497y6ZEN_SULY3oXtA4XlanHo-TGK7jY,6302
 lamindb/core/subsettings/__init__.py,sha256=j6G9WAJLK-x9FzPSFw-HJUmOseZKGTbK-oLTKI_X_zs,126
 lamindb/core/subsettings/_creation_settings.py,sha256=54mfMH_osC753hpxcl7Dq1rwBD2LHnWveXtQpkLBITE,1194
-lamindb/curators/__init__.py,sha256=BVdmWVTC2wZq_mduxxhT-2z9uNKDEycNK-fbYSrIsrU,92475
+lamindb/curators/__init__.py,sha256=XGHnTEFB-Q4XphR0AWLXhITqhAZqkqEzuJJq1Ypb-zU,92357
 lamindb/curators/_spatial.py,sha256=JgveK3aC1kFEplumEwU4Yyj-2tgHGfSAO52lHniJq5s,21212
 lamindb/integrations/__init__.py,sha256=RWGMYYIzr8zvmNPyVB4m-p4gMDhxdRbjES2Ed23OItw,215
 lamindb/integrations/_vitessce.py,sha256=nbfOsEO-W4f0BVnpFBDaA45577cfdvQehVx1hAUP544,3978
@@ -91,10 +91,11 @@ lamindb/migrations/0076_lamindbv1_part6.py,sha256=G_Wgog-OgquE0-h_CykjiDWUyPdYlC
 lamindb/migrations/0077_lamindbv1_part6b.py,sha256=v7k8OZX9o5ppSJU_yhHlIXGTobTm30bo1dAIi8tUkEI,8211
 lamindb/migrations/0078_lamindbv1_part6c.py,sha256=RWRXBwyyQ_rFTN5kwstBziV6tqHJcGYI2vsFmuYCCz0,17084
 lamindb/migrations/0079_alter_rundata_value_json_and_more.py,sha256=yQmbs8yWrFLOVQJqAfzLNMZOqTSnXyG-mQgpO7ls1u8,995
+lamindb/migrations/0080_polish_lamindbv1.py,sha256=VfCwJtHlBsMPIyFQ2oh24oWkiRXjDvXRpKe5fBZ63aM,17660
 lamindb/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lamindb/setup/__init__.py,sha256=OwZpZzPDv5lPPGXZP7-zK6UdO4FHvvuBh439yZvIp3A,410
 lamindb/setup/core/__init__.py,sha256=SevlVrc2AZWL3uALbE5sopxBnIZPWZ1IB0NBDudiAL8,167
-lamindb-1.0.1.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-lamindb-1.0.1.dist-info/WHEEL,sha256=CpUCUxeHQbRN5UGRQHYRJorO5Af-Qy_fHMctcQ8DSGI,82
-lamindb-1.0.1.dist-info/METADATA,sha256=mDU_9jeyNkNgbADDIJ9H3AKUCSrevbvF0Sc8EXz2XlY,2611
-lamindb-1.0.1.dist-info/RECORD,,
+lamindb-1.0.3.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+lamindb-1.0.3.dist-info/WHEEL,sha256=CpUCUxeHQbRN5UGRQHYRJorO5Af-Qy_fHMctcQ8DSGI,82
+lamindb-1.0.3.dist-info/METADATA,sha256=SoOQz-aPtNZiT7IUmNBqKeoj9PZgedTPwNPl_iRyftY,2611
+lamindb-1.0.3.dist-info/RECORD,,