lamindb 1.5.3__py3-none-any.whl → 1.6.0__py3-none-any.whl

lamindb/migrations/0071_lamindbv1_migrate_schema.py

@@ -326,7 +326,7 @@ class Migration(migrations.Migration):
                 WHERE dtype = 'number'
             """
         ),
-        # an aux field on Record
+        # an aux field on SQLRecord
         migrations.AddField(
             model_name="artifact",
             name="aux",
@@ -547,7 +547,7 @@ class Migration(migrations.Migration):
             options={
                 "unique_together": {("transform", "ulabel")},
             },
-            bases=(lamindb.models.LinkORM, models.Model),
+            bases=(lamindb.models.IsLink, models.Model),
         ),
         migrations.RunSQL(
             sql="""
@@ -670,7 +670,7 @@ class Migration(migrations.Migration):
             old_name="n_objects",
             new_name="n_files",
         ),
-        # let feature value and paramvalue inherit from Record
+        # let feature value and paramvalue inherit from SQLRecord
         migrations.AddField(
             model_name="featurevalue",
             name="_branch_code",

lamindb/migrations/0073_merge_ourprojects.py

@@ -173,7 +173,7 @@ def migrate_data(apps, schema_editor):
             )
         else:
             cursor.execute("ROLLBACK")
-            raise Exception("Migration failed: Record count mismatch")
+            raise Exception("Migration failed: SQLRecord count mismatch")
 
     except Exception as e:
         cursor.execute("ROLLBACK")
@@ -248,7 +248,7 @@ class Migration(migrations.Migration):
                     ),
                 ),
             ],
-            bases=(lamindb.models.LinkORM, models.Model),
+            bases=(lamindb.models.IsLink, models.Model),
         ),
         migrations.CreateModel(
             name="ArtifactReference",
@@ -312,7 +312,7 @@ class Migration(migrations.Migration):
                     ),
                 ),
             ],
-            bases=(lamindb.models.LinkORM, models.Model),
+            bases=(lamindb.models.IsLink, models.Model),
         ),
         migrations.CreateModel(
             name="CollectionProject",
@@ -353,7 +353,7 @@ class Migration(migrations.Migration):
                     ),
                 ),
             ],
-            bases=(lamindb.models.LinkORM, models.Model),
+            bases=(lamindb.models.IsLink, models.Model),
         ),
         migrations.CreateModel(
             name="CollectionReference",
@@ -394,7 +394,7 @@ class Migration(migrations.Migration):
                     ),
                 ),
             ],
-            bases=(lamindb.models.LinkORM, models.Model),
+            bases=(lamindb.models.IsLink, models.Model),
         ),
         migrations.CreateModel(
             name="Person",
@@ -851,7 +851,7 @@ class Migration(migrations.Migration):
             options={
                 "unique_together": {("transform", "project")},
             },
-            bases=(lamindb.models.LinkORM, models.Model),
+            bases=(lamindb.models.IsLink, models.Model),
         ),
         migrations.AddField(
             model_name="project",
@@ -913,7 +913,7 @@ class Migration(migrations.Migration):
             options={
                 "unique_together": {("transform", "reference")},
             },
-            bases=(lamindb.models.LinkORM, models.Model),
+            bases=(lamindb.models.IsLink, models.Model),
         ),
         migrations.AddField(
             model_name="reference",

lamindb/migrations/0075_lamindbv1_part5.py

@@ -243,7 +243,7 @@ class Migration(migrations.Migration):
             options={
                 "unique_together": {("schema", "param")},
             },
-            bases=(models.Model, lamindb.models.LinkORM),
+            bases=(models.Model, lamindb.models.IsLink),
         ),
         migrations.AddField(
             model_name="param",

lamindb/migrations/0077_lamindbv1_part6b.py

@@ -78,7 +78,7 @@ class Migration(migrations.Migration):
             options={
                 "unique_together": {("feature", "project")},
             },
-            bases=(lamindb.models.LinkORM, models.Model),
+            bases=(lamindb.models.IsLink, models.Model),
         ),
         migrations.AddField(
             model_name="project",
@@ -146,7 +146,7 @@ class Migration(migrations.Migration):
             options={
                 "unique_together": {("schema", "project")},
             },
-            bases=(lamindb.models.LinkORM, models.Model),
+            bases=(lamindb.models.IsLink, models.Model),
         ),
         migrations.AddField(
             model_name="project",
@@ -214,7 +214,7 @@ class Migration(migrations.Migration):
             options={
                 "unique_together": {("ulabel", "project")},
             },
-            bases=(lamindb.models.LinkORM, models.Model),
+            bases=(lamindb.models.IsLink, models.Model),
         ),
         migrations.AddField(
             model_name="project",

lamindb/migrations/0080_polish_lamindbv1.py

@@ -277,7 +277,7 @@ class Migration(migrations.Migration):
             options={
                 "unique_together": {("person", "project")},
             },
-            bases=(lamindb.models.LinkORM, models.Model),
+            bases=(lamindb.models.IsLink, models.Model),
         ),
         migrations.AddField(
             model_name="project",
@@ -481,7 +481,7 @@ class Migration(migrations.Migration):
             options={
                 "unique_together": {("run", "ulabel")},
             },
-            bases=(models.Model, lamindb.models.LinkORM),
+            bases=(models.Model, lamindb.models.IsLink),
         ),
         migrations.AddField(
             model_name="run",

lamindb/migrations/0088_schema_components.py

@@ -97,7 +97,7 @@ class Migration(migrations.Migration):
             options={
                 "unique_together": {("composite", "component")},
             },
-            bases=(lamindb.models.LinkORM, models.Model),
+            bases=(lamindb.models.IsLink, models.Model),
         ),
         migrations.AddField(
             model_name="schema",

lamindb/migrations/0090_runproject_project_runs.py

@@ -6,7 +6,7 @@ from django.db import migrations, models
 
 import lamindb.base.fields
 import lamindb.base.users
-import lamindb.models.record
+import lamindb.models.sqlrecord
 
 
 class Migration(migrations.Migration):
@@ -61,7 +61,7 @@ class Migration(migrations.Migration):
             options={
                 "unique_together": {("run", "project")},
             },
-            bases=(models.Model, lamindb.models.record.LinkORM),
+            bases=(models.Model, lamindb.models.sqlrecord.IsLink),
         ),
         migrations.AddField(
             model_name="project",

lamindb/migrations/0091_alter_featurevalue_options_alter_space_options_and_more.py

@@ -5,7 +5,7 @@ from django.db import migrations
 
 class Migration(migrations.Migration):
     dependencies = [
-        ("lamindb", "0090_squashed"),
+        ("lamindb", "0090_runproject_project_runs"),
     ]
 
     operations = [

lamindb/migrations/0094_writeloglock_writelogmigrationstate_and_more.py

@@ -0,0 +1,84 @@
+# Generated by Django 5.1.7 on 2025-05-10 00:32
+
+import django.db.models.deletion
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("lamindb", "0093_alter_schemacomponent_unique_together"),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="WriteLogLock",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                ("locked", models.BooleanField()),
+            ],
+        ),
+        migrations.CreateModel(
+            name="MigrationState",
+            fields=[
+                ("id", models.SmallAutoField(primary_key=True, serialize=False)),
+                ("migration_state_id", models.JSONField()),
+            ],
+        ),
+        migrations.CreateModel(
+            name="TableState",
+            fields=[
+                ("id", models.SmallAutoField(primary_key=True, serialize=False)),
+                ("table_name", models.CharField(max_length=255)),
+                ("backfilled", models.BooleanField()),
+            ],
+        ),
+        migrations.CreateModel(
+            name="WriteLog",
+            fields=[
+                ("seqno", models.AutoField(primary_key=True, serialize=False)),
+                (
+                    "uid",
+                    models.CharField(
+                        db_index=True, editable=False, max_length=18, unique=True
+                    ),
+                ),
+                ("space_uid", models.CharField(max_length=12, null=True)),
+                ("created_by_uid", models.CharField(default="00000000", max_length=8)),
+                ("branch_code", models.IntegerField(default=1)),
+                (
+                    "run_uid",
+                    models.CharField(default="0000000000000000", max_length=16),
+                ),
+                ("record_uid", models.JSONField(null=True)),
+                ("record_data", models.JSONField(null=True)),
+                ("event_type", models.PositiveSmallIntegerField()),
+                ("created_at", models.DateTimeField()),
+                (
+                    "migration_state",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.PROTECT,
+                        to="lamindb.migrationstate",
+                    ),
+                ),
+                (
+                    "table",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.PROTECT,
+                        to="lamindb.tablestate",
+                    ),
+                ),
+            ],
+            options={
+                "verbose_name": "Write Log",
+                "verbose_name_plural": "Write Logs",
+            },
+        ),
+    ]

lamindb/migrations/0095_remove_rundata_flextable.py

@@ -0,0 +1,155 @@
+# Generated by Django 5.2 on 2025-05-11 18: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.users
+import lamindb.models.sqlrecord
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("lamindb", "0094_writeloglock_writelogmigrationstate_and_more"),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="RunFeatureValue",
+            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",
+                    ),
+                ),
+                (
+                    "featurevalue",
+                    lamindb.base.fields.ForeignKey(
+                        blank=True,
+                        on_delete=django.db.models.deletion.PROTECT,
+                        related_name="links_run",
+                        to="lamindb.featurevalue",
+                    ),
+                ),
+                (
+                    "run",
+                    lamindb.base.fields.ForeignKey(
+                        blank=True,
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="links_featurevalue",
+                        to="lamindb.run",
+                    ),
+                ),
+            ],
+            options={
+                "unique_together": {("run", "featurevalue")},
+            },
+            bases=(models.Model, lamindb.models.sqlrecord.IsLink),
+        ),
+        migrations.AddField(
+            model_name="run",
+            name="_feature_values",
+            field=models.ManyToManyField(
+                related_name="runs",
+                through="lamindb.RunFeatureValue",
+                to="lamindb.featurevalue",
+            ),
+        ),
+        migrations.RemoveField(
+            model_name="flextable",
+            name="created_by",
+        ),
+        migrations.RemoveField(
+            model_name="flextable",
+            name="projects",
+        ),
+        migrations.RemoveField(
+            model_name="flextable",
+            name="schema",
+        ),
+        migrations.RemoveField(
+            model_name="flextable",
+            name="space",
+        ),
+        migrations.RemoveField(
+            model_name="flextable",
+            name="type",
+        ),
+        migrations.RemoveField(
+            model_name="flextable",
+            name="ulabels",
+        ),
+        migrations.RemoveField(
+            model_name="flextabledata",
+            name="space",
+        ),
+        migrations.RemoveField(
+            model_name="flextabledata",
+            name="value_artifact",
+        ),
+        migrations.RemoveField(
+            model_name="flextabledata",
+            name="value_collection",
+        ),
+        migrations.RemoveField(
+            model_name="flextabledata",
+            name="value_person",
+        ),
+        migrations.RemoveField(
+            model_name="flextabledata",
+            name="value_project",
+        ),
+        migrations.RemoveField(
+            model_name="flextabledata",
+            name="value_ulabel",
+        ),
+        migrations.RemoveField(
+            model_name="rundata",
+            name="space",
+        ),
+        migrations.RemoveField(
+            model_name="rundata",
+            name="value_artifact",
+        ),
+        migrations.RemoveField(
+            model_name="rundata",
+            name="value_collection",
+        ),
+        migrations.RemoveField(
+            model_name="rundata",
+            name="value_person",
+        ),
+        migrations.RemoveField(
+            model_name="rundata",
+            name="value_project",
+        ),
+        migrations.RemoveField(
+            model_name="rundata",
+            name="value_ulabel",
+        ),
+        migrations.DeleteModel(
+            name="FlexTable",
+        ),
+        migrations.DeleteModel(
+            name="FlexTableData",
+        ),
+        migrations.DeleteModel(
+            name="RunData",
+        ),
+    ]

lamindb/migrations/0096_remove_artifact__param_values_and_more.py

@@ -0,0 +1,266 @@
+# Generated by Django 5.2 on 2025-05-11 18:50
+
+import random
+import string
+
+from django.db import migrations
+
+
+def generate_base62_uid():
+    """Generate a 12-character base62 UID."""
+    charset = string.ascii_uppercase + string.ascii_lowercase + string.digits
+    return "".join(random.choice(charset) for _ in range(12))
+
+
+def copy_params_to_features(apps, schema_editor):
+    """Copy data from Param to Feature with generated UIDs."""
+    Param = apps.get_model("lamindb", "Param")
+    Feature = apps.get_model("lamindb", "Feature")
+
+    # Create features from params with generated UIDs
+    name_to_feature = {}
+
+    # First pass: create all Features
+    for param in Param.objects.all():
+        feature = Feature.objects.create(
+            uid=generate_base62_uid(),
+            name=param.name,
+            dtype=param.dtype,
+            is_type=param.is_type,
+            _expect_many=param._expect_many,
+            created_at=param.created_at,
+            updated_at=param.updated_at,
+            created_by_id=param.created_by_id,
+            run_id=param.run_id,
+        )
+        name_to_feature[param.name] = feature
+
+    # Second pass: set up type relationships
+    for param in Param.objects.all():
+        if param.type_id is not None:
+            try:
+                # Find the parameter that is the type
+                type_param = Param.objects.get(id=param.type_id)
+
+                # Set the type relationship
+                feature = name_to_feature[param.name]
+                feature.type = name_to_feature[type_param.name]
+                feature.save()
+            except (Param.DoesNotExist, KeyError):
+                # Handle case where the referenced type doesn't exist
+                print(f"Warning: Could not set type for feature {param.name}")
+
+
+def copy_param_values(apps, schema_editor):
+    """Copy data from ParamValue to FeatureValue."""
+    Param = apps.get_model("lamindb", "Param")
+    Feature = apps.get_model("lamindb", "Feature")
+    ParamValue = apps.get_model("lamindb", "ParamValue")
+    FeatureValue = apps.get_model("lamindb", "FeatureValue")
+
+    # Create a mapping from param ID to feature ID
+    param_to_feature = {
+        param.id: Feature.objects.get(name=param.name).id
+        for param in Param.objects.all()
+    }
+
+    # Create FeatureValues from ParamValues
+    pv_to_fv = {}
+
+    for pv in ParamValue.objects.all():
+        try:
+            feature_id = param_to_feature[pv.param_id]
+
+            # Create the FeatureValue
+            fv = FeatureValue.objects.create(
+                feature_id=feature_id,
+                value=pv.value,
+                hash=pv.hash,
+                created_at=pv.created_at,
+                created_by_id=pv.created_by_id,
+            )
+
+            # Remember the mapping
+            pv_to_fv[pv.id] = fv.id
+
+        except KeyError:
+            print(f"Warning: Could not map ParamValue {pv.id} to a FeatureValue")
+
+    return pv_to_fv
+
+
+def copy_run_param_values(apps, schema_editor):
+    """Copy data from RunParamValue to RunFeatureValue."""
+    ParamValue = apps.get_model("lamindb", "ParamValue")
+    FeatureValue = apps.get_model("lamindb", "FeatureValue")
+    RunParamValue = apps.get_model("lamindb", "RunParamValue")
+    RunFeatureValue = apps.get_model("lamindb", "RunFeatureValue")
+
+    # Create a mapping from ParamValue ID to FeatureValue ID
+    # This is complex because we need to match based on param->feature and value
+    pv_to_fv = {}
+
+    for pv in ParamValue.objects.all():
+        try:
+            # Find the corresponding Feature for this Param
+            feature = apps.get_model("lamindb", "Feature").objects.get(
+                name=apps.get_model("lamindb", "Param").objects.get(id=pv.param_id).name
+            )
+
+            # Find the corresponding FeatureValue
+            if pv.hash is None:
+                fv = FeatureValue.objects.get(
+                    feature=feature, value=pv.value, hash__isnull=True
+                )
+            else:
+                fv = FeatureValue.objects.get(feature=feature, hash=pv.hash)
+
+            pv_to_fv[pv.id] = fv.id
+        except Exception as e:
+            print(f"Warning: Could not map ParamValue {pv.id} to a FeatureValue: {e}")
+
+    # Copy RunParamValues to RunFeatureValues
+    for rpv in RunParamValue.objects.all():
+        try:
+            featurevalue_id = pv_to_fv[rpv.paramvalue_id]
+
+            RunFeatureValue.objects.create(
+                run_id=rpv.run_id,
+                featurevalue_id=featurevalue_id,
+                created_at=rpv.created_at,
+                created_by_id=rpv.created_by_id,
+            )
+        except KeyError:
+            print(f"Warning: Could not map RunParamValue {rpv.id} to a RunFeatureValue")
+
+
+def copy_artifact_param_values(apps, schema_editor):
+    """Copy data from ArtifactParamValue to ArtifactFeatureValue."""
+    ParamValue = apps.get_model("lamindb", "ParamValue")
+    FeatureValue = apps.get_model("lamindb", "FeatureValue")
+    ArtifactParamValue = apps.get_model("lamindb", "ArtifactParamValue")
+    ArtifactFeatureValue = apps.get_model("lamindb", "ArtifactFeatureValue")
+
+    # Create a mapping from ParamValue ID to FeatureValue ID
+    # This is complex because we need to match based on param->feature and value
+    pv_to_fv = {}
+
+    for pv in ParamValue.objects.all():
+        try:
+            # Find the corresponding Feature for this Param
+            feature = apps.get_model("lamindb", "Feature").objects.get(
+                name=apps.get_model("lamindb", "Param").objects.get(id=pv.param_id).name
+            )
+
+            # Find the corresponding FeatureValue
+            if pv.hash is None:
+                fv = FeatureValue.objects.get(
+                    feature=feature, value=pv.value, hash__isnull=True
+                )
+            else:
+                fv = FeatureValue.objects.get(feature=feature, hash=pv.hash)
+
+            pv_to_fv[pv.id] = fv.id
+        except Exception as e:
+            print(f"Warning: Could not map ParamValue {pv.id} to a FeatureValue: {e}")
+
+    # Copy ArtifactParamValues to ArtifactFeatureValues
+    for apv in ArtifactParamValue.objects.all():
+        try:
+            featurevalue_id = pv_to_fv[apv.paramvalue_id]
+
+            ArtifactFeatureValue.objects.create(
+                artifact_id=apv.artifact_id,
+                featurevalue_id=featurevalue_id,
+                created_at=apv.created_at,
+                created_by_id=apv.created_by_id,
+                run_id=apv.run_id,
+            )
+        except KeyError:
+            print(
+                f"Warning: Could not map ArtifactParamValue {apv.id} to an ArtifactFeatureValue"
+            )
+
+
+def get_features_count(apps, schema_editor):
+    Feature = apps.get_model("lamindb", "Feature")
+    FeatureValue = apps.get_model("lamindb", "FeatureValue")
+    RunFeatureValue = apps.get_model("lamindb", "RunFeatureValue")
+    ArtifactFeatureValue = apps.get_model("lamindb", "ArtifactFeatureValue")
+
+    print("Features are now")
+    print(f"Feature count: {Feature.objects.count()}")
+    print(f"FeatureValue count: {FeatureValue.objects.count()}")
+    print(f"RunFeatureValue count: {RunFeatureValue.objects.count()}")
+    print(f"ArtifactFeatureValue count: {ArtifactFeatureValue.objects.count()}")
+
+
+def get_params_count(apps, schema_editor):
+    Param = apps.get_model("lamindb", "Param")
+    ParamValue = apps.get_model("lamindb", "ParamValue")
+    RunParamValue = apps.get_model("lamindb", "RunParamValue")
+    ArtifactParamValue = apps.get_model("lamindb", "ArtifactParamValue")
+
+    print("Moving params into features and deleting the params table")
+    print(f"Param count: {Param.objects.count()}")
+    print(f"ParamValue count: {ParamValue.objects.count()}")
+    print(f"RunParamValue count: {RunParamValue.objects.count()}")
+    print(f"ArtifactParamValue count: {ArtifactParamValue.objects.count()}")
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("lamindb", "0095_remove_rundata_flextable"),
+    ]
+
+    operations = [
+        # Step 0: Report the results
+        migrations.RunPython(get_params_count),
+        migrations.RunPython(get_features_count),
+        # Step 1: Copy from Param to Feature
+        migrations.RunPython(copy_params_to_features),
+        # Step 2: Copy from ParamValue to FeatureValue
+        migrations.RunPython(copy_param_values),
+        # Step 3: Copy from RunParamValue to RunFeatureValue
+        migrations.RunPython(copy_run_param_values),
+        # Step 4: Copy from ArtifactParamValue to ArtifactFeatureValue
+        migrations.RunPython(copy_artifact_param_values),
+        # Step 5: Report the results
+        migrations.RunPython(get_features_count),
+        migrations.RemoveField(
+            model_name="artifact",
+            name="_param_values",
+        ),
+        migrations.RemoveField(
+            model_name="param",
+            name="created_by",
+        ),
+        migrations.RemoveField(
+            model_name="param",
+            name="run",
+        ),
+        migrations.RemoveField(
+            model_name="param",
+            name="schemas",
+        ),
+        migrations.RemoveField(
+            model_name="param",
+            name="space",
+        ),
+        migrations.RemoveField(
+            model_name="param",
+            name="type",
+        ),
+        migrations.RemoveField(
+            model_name="run",
+            name="_param_values",
+        ),
+        migrations.AlterUniqueTogether(
+            name="schemaparam",
+            unique_together=None,
+        ),
+        migrations.RemoveField(
+            model_name="schemaparam",
+            name="schema",
+        ),
+    ]