lamindb 0.77.3__tar.gz → 0.77.4__tar.gz

{lamindb-0.77.3 → lamindb-0.77.4}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: lamindb
-Version: 0.77.3
+Version: 0.77.4
 Summary: A data framework for biology.
 Author-email: Lamin Labs <open-source@lamin.ai>
 Requires-Python: >=3.9,<3.13
@@ -12,7 +12,7 @@ Classifier: Programming Language :: Python :: 3.12
 Requires-Dist: lnschema_core==0.77.1
 Requires-Dist: lamin_utils==0.13.10
 Requires-Dist: lamin_cli==0.22.0
-Requires-Dist: lamindb_setup==0.81.3
+Requires-Dist: lamindb_setup==0.81.5
 Requires-Dist: pyarrow
 Requires-Dist: typing_extensions!=4.6.0
 Requires-Dist: python-dateutil

{lamindb-0.77.3 → lamindb-0.77.4}/lamindb/__init__.py

@@ -43,7 +43,7 @@ Modules and settings.
 """
 
 # denote a release candidate for 0.1.0 with 0.1rc1, 0.1a1, 0.1b1, etc.
-__version__ = "0.77.3"
+__version__ = "0.77.4"
 
 import os as _os
 

{lamindb-0.77.3 → lamindb-0.77.4}/pyproject.toml

@@ -19,7 +19,7 @@ dependencies = [
     "lnschema_core==0.77.1",
     "lamin_utils==0.13.10",
     "lamin_cli==0.22.0",
-    "lamindb_setup==0.81.3",
+    "lamindb_setup==0.81.5",
     # others
     "pyarrow",
     "typing_extensions!=4.6.0",

{lamindb-0.77.3 → lamindb-0.77.4}/sub/lamindb-setup/lamindb_setup/__init__.py

@@ -33,7 +33,7 @@ Modules & settings:
 
 """
 
-__version__ = "0.81.3"  # denote a release candidate for 0.1.0 with 0.1rc1
+__version__ = "0.81.5"  # denote a release candidate for 0.1.0 with 0.1rc1
 
 import os as _os
 import sys as _sys

{lamindb-0.77.3 → lamindb-0.77.4}/sub/lamindb-setup/lamindb_setup/_check_setup.py

@@ -52,6 +52,49 @@ def _get_current_instance_settings() -> InstanceSettings | None:
         return None
 
 
+def check_connecting_to_v1_instance(isettings: InstanceSettings):
+    from urllib.parse import urlparse
+
+    # we need to do this because the sqlite file should be already synced
+    # has no effect if not cloud sqlite
+    # errors if the sqlite file is not in the cloud and doesn't exist locally
+    # isettings.db syncs but doesn't error in this case due to error_no_origin=False
+    isettings._update_local_sqlite_file()
+
+    parsed_uri = urlparse(isettings.db)
+    db_type = parsed_uri.scheme
+
+    if db_type == "sqlite":
+        import sqlite3
+
+        conn = sqlite3.connect(parsed_uri.path)
+    elif db_type in ["postgresql", "postgres"]:
+        import psycopg2
+
+        conn = psycopg2.connect(isettings.db)
+    else:
+        raise ValueError("Unsupported database type. Use 'sqlite' or 'postgresql' URI.")
+
+    cur = conn.cursor()
+
+    if db_type == "sqlite":
+        cur.execute(
+            "SELECT name FROM sqlite_master WHERE type='table' AND name='lamindb_user'"
+        )
+        isv1 = cur.fetchone() is not None
+
+    else:  # postgres
+        cur.execute(
+            "SELECT EXISTS (SELECT FROM information_schema.tables WHERE table_name = 'lamindb_user')"
+        )
+        isv1 = cur.fetchone()[0]
+
+    if isv1:
+        raise SystemExit(
+            "This instance runs lamindb v1. Please run: pip install 'lamindb[bionty,wetlab,clinicore,ourprojects]'>1.0.0"
+        )
+
+
 # we make this a private function because in all the places it's used,
 # users should not see it
 def _check_instance_setup(
@@ -77,6 +120,7 @@ def _check_instance_setup(
     if isettings is not None:
         if reload_module and settings.auto_connect:
             if not django.IS_SETUP:
+                check_connecting_to_v1_instance(isettings)
                 django.setup_django(isettings)
                 if from_module is not None:
                     # this only reloads `from_module`

{lamindb-0.77.3 → lamindb-0.77.4}/sub/lamindb-setup/lamindb_setup/_migrate.py

@@ -28,14 +28,11 @@ def check_whether_migrations_in_sync(db_version_str: str):
         or installed_version.minor < db_version.minor
     ):
         db_version_lower = f"{db_version.major}.{db_version.minor}"
-        db_version_upper = f"{db_version.major}.{db_version.minor + 1}"
-        logger.warning(
-            f"the database ({db_version_str}) is ahead of your installed lamindb"
-            f" package ({installed_version_str})"
-        )
-        logger.important(
-            "please update lamindb: pip install"
-            f' "lamindb>={db_version_lower},<{db_version_upper}"'
+        raise SystemExit(
+            f"The database ({db_version_str}) is ahead of your installed lamindb"
+            f" package ({installed_version_str})\n"
+            "Please update lamindb: pip install"
+            f" 'lamindb[bionty,wetlab,clinicore,ourprojects]'>={db_version_lower}"
         )
     elif (
         installed_version.major > db_version.major

{lamindb-0.77.3 → lamindb-0.77.4}/sub/wetlab/wetlab/__init__.py

@@ -11,11 +11,11 @@ Import the package:
 
 Create records:
 
->>> compound_perturbation = wl.CompoundPerturbation(
-...    name="Aspirin treatment day 1",
+>>> biosample = wl.Biosample(
+...    name="Sample 1",
 ... ).save()
 
-Registries:
+Basic registries:
 
 .. autosummary::
    :toctree: .
@@ -23,18 +23,39 @@ Registries:
    Experiment
    Biosample
    Techsample
-   Well
    Donor
-   CombinationPerturbation
+
+Perturbation registries:
+
+.. autosummary::
+   :toctree: .
+
+   GeneticPerturbation
+   Biologic
+   Compound
    CompoundPerturbation
    EnvironmentalPerturbation
-   GeneticPerturbation
+   CombinationPerturbation
+
+Auxiliary registries:
+
+.. autosummary::
+   :toctree: .
+
+   Well
    PerturbationTarget
+
+Types:
+
+.. autosummary::
+   :toctree: .
+
    GeneticPerturbationSystem
+   BiologicType
 
 """
 
-__version__ = "0.38.0"
+__version__ = "0.39.1"
 
 from lamindb_setup import _check_instance_setup
 
@@ -50,6 +71,7 @@ if _check_instance_setup():
 
     del __getattr__  # delete so that imports work out
     from .models import (
+        Biologic,
         Biosample,
         CombinationPerturbation,
         Compound,
@@ -62,7 +84,7 @@ if _check_instance_setup():
         Techsample,
         Well,
     )
-    from .types import GeneticPerturbationSystem
+    from .types import BiologicType, GeneticPerturbationSystem
 
     # backwards compatibility
     CombinationTreatment = CombinationPerturbation

lamindb-0.77.4/sub/wetlab/wetlab/migrations/0029_artifactbiologic_biologic_artifactbiologic_biologic.py

@@ -0,0 +1,207 @@
+# Generated by Django 5.1.3 on 2024-12-16 21:49
+
+import django.db.models.deletion
+import lnschema_core.fields
+import lnschema_core.ids
+import lnschema_core.models
+import lnschema_core.users
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("bionty", "0041_squashed"),
+        ("lnschema_core", "0069_squashed"),
+        ("wetlab", "0028_remove_combinationperturbation_compounds_and_more"),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="ArtifactBiologic",
+            fields=[
+                (
+                    "created_at",
+                    lnschema_core.fields.DateTimeField(
+                        auto_now_add=True, db_index=True
+                    ),
+                ),
+                ("id", models.BigAutoField(primary_key=True, serialize=False)),
+                (
+                    "label_ref_is_name",
+                    lnschema_core.fields.BooleanField(
+                        blank=True, default=None, null=True
+                    ),
+                ),
+                (
+                    "feature_ref_is_name",
+                    lnschema_core.fields.BooleanField(
+                        blank=True, default=None, null=True
+                    ),
+                ),
+                (
+                    "artifact",
+                    lnschema_core.fields.ForeignKey(
+                        blank=True,
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="links_biologic",
+                        to="lnschema_core.artifact",
+                    ),
+                ),
+                (
+                    "created_by",
+                    lnschema_core.fields.ForeignKey(
+                        blank=True,
+                        default=lnschema_core.users.current_user_id,
+                        on_delete=django.db.models.deletion.PROTECT,
+                        related_name="+",
+                        to="lnschema_core.user",
+                    ),
+                ),
+                (
+                    "feature",
+                    lnschema_core.fields.ForeignKey(
+                        blank=True,
+                        default=None,
+                        null=True,
+                        on_delete=django.db.models.deletion.PROTECT,
+                        related_name="links_artifactbiologic",
+                        to="lnschema_core.feature",
+                    ),
+                ),
+                (
+                    "run",
+                    lnschema_core.fields.ForeignKey(
+                        blank=True,
+                        default=lnschema_core.models.current_run,
+                        null=True,
+                        on_delete=django.db.models.deletion.PROTECT,
+                        related_name="+",
+                        to="lnschema_core.run",
+                    ),
+                ),
+            ],
+            options={
+                "abstract": False,
+            },
+            bases=(lnschema_core.models.LinkORM, models.Model),
+        ),
+        migrations.CreateModel(
+            name="Biologic",
+            fields=[
+                (
+                    "created_at",
+                    lnschema_core.fields.DateTimeField(
+                        auto_now_add=True, db_index=True
+                    ),
+                ),
+                (
+                    "updated_at",
+                    lnschema_core.fields.DateTimeField(auto_now=True, db_index=True),
+                ),
+                ("id", models.AutoField(primary_key=True, serialize=False)),
+                (
+                    "uid",
+                    lnschema_core.fields.CharField(
+                        blank=True,
+                        default=lnschema_core.ids.base62_12,
+                        max_length=12,
+                        unique=True,
+                    ),
+                ),
+                (
+                    "name",
+                    lnschema_core.fields.CharField(
+                        blank=True,
+                        db_index=True,
+                        default=None,
+                        max_length=255,
+                        unique=True,
+                    ),
+                ),
+                (
+                    "type",
+                    lnschema_core.fields.CharField(
+                        blank=True, db_index=True, default=None, max_length=32
+                    ),
+                ),
+                (
+                    "abbr",
+                    lnschema_core.fields.CharField(
+                        blank=True,
+                        db_index=True,
+                        default=None,
+                        max_length=32,
+                        null=True,
+                        unique=True,
+                    ),
+                ),
+                (
+                    "synonyms",
+                    lnschema_core.fields.TextField(blank=True, default=None, null=True),
+                ),
+                (
+                    "description",
+                    lnschema_core.fields.TextField(blank=True, default=None, null=True),
+                ),
+                (
+                    "_previous_runs",
+                    models.ManyToManyField(related_name="+", to="lnschema_core.run"),
+                ),
+                (
+                    "artifacts",
+                    models.ManyToManyField(
+                        related_name="biologics",
+                        through="wetlab.ArtifactBiologic",
+                        to="lnschema_core.artifact",
+                    ),
+                ),
+                (
+                    "created_by",
+                    lnschema_core.fields.ForeignKey(
+                        blank=True,
+                        default=lnschema_core.users.current_user_id,
+                        on_delete=django.db.models.deletion.PROTECT,
+                        related_name="+",
+                        to="lnschema_core.user",
+                    ),
+                ),
+                (
+                    "proteins",
+                    models.ManyToManyField(
+                        related_name="biologics", to="bionty.protein"
+                    ),
+                ),
+                (
+                    "run",
+                    lnschema_core.fields.ForeignKey(
+                        blank=True,
+                        default=lnschema_core.models.current_run,
+                        null=True,
+                        on_delete=django.db.models.deletion.PROTECT,
+                        related_name="+",
+                        to="lnschema_core.run",
+                    ),
+                ),
+                (
+                    "targets",
+                    models.ManyToManyField(
+                        related_name="biologic_targets", to="wetlab.perturbationtarget"
+                    ),
+                ),
+            ],
+            options={
+                "abstract": False,
+            },
+            bases=(lnschema_core.models.CanCurate, models.Model),
+        ),
+        migrations.AddField(
+            model_name="artifactbiologic",
+            name="biologic",
+            field=lnschema_core.fields.ForeignKey(
+                blank=True,
+                on_delete=django.db.models.deletion.PROTECT,
+                related_name="links_artifact",
+                to="wetlab.biologic",
+            ),
+        ),
+    ]

{lamindb-0.77.3 → lamindb-0.77.4}/sub/wetlab/wetlab/models.py

@@ -41,7 +41,7 @@ from lnschema_core.models import (
     TracksUpdates,
 )
 
-from .types import GeneticPerturbationSystem  # noqa
+from .types import BiologicType, GeneticPerturbationSystem  # noqa
 
 # def _get_related_repr(instance, related_name: str) -> str:
 #     try:
@@ -389,6 +389,84 @@ class ArtifactGeneticPerturbation(Record, LinkORM, TracksRun):
     feature_ref_is_name: bool | None = BooleanField(null=True, default=None)
 
 
+class Biologic(Record, CanCurate, TracksRun, TracksUpdates):
+    """Proteins, peptides, antibodies, enzymes, growth factors, etc.
+
+    Examples:
+        >>> biologic = wl.Biologic(
+        ...    name="IFNG",
+        ...    type="cytokine",
+        ... ).save()
+    """
+
+    class Meta(BioRecord.Meta, TracksRun.Meta, TracksUpdates.Meta):
+        abstract = False
+
+    _name_field: str = "name"
+
+    id: int = models.AutoField(primary_key=True)
+    """Internal id, valid only in one DB instance."""
+    uid: str = CharField(unique=True, max_length=12, default=ids.base62_12)
+    """A universal id (hash of selected field)."""
+    name: str = CharField(unique=True, db_index=True)
+    """Name of the compound."""
+    type: BiologicType = CharField(max_length=32, db_index=True, default=None)
+    """The type."""
+    abbr: str | None = CharField(
+        max_length=32, db_index=True, unique=True, null=True, default=None
+    )
+    """A unique abbreviation."""
+    synonyms: str | None = TextField(null=True, default=None)
+    """Bar-separated (|) synonyms that correspond to this compound."""
+    description: str | None = TextField(null=True, default=None)
+    """Description of the compound."""
+    proteins: Protein = models.ManyToManyField(
+        "bionty.Protein", related_name="biologics"
+    )
+    """Proteins associated with this biologic."""
+    targets: PerturbationTarget = models.ManyToManyField(
+        PerturbationTarget, related_name="biologic_targets"
+    )
+    """Targets of the perturbation."""
+    artifacts: Artifact = models.ManyToManyField(
+        Artifact, through="ArtifactBiologic", related_name="biologics"
+    )
+    """Artifacts linked to the compound."""
+
+    @overload
+    def __init__(
+        self,
+        name: str,
+        abbr: str | None,
+        synonyms: str | None,
+        description: str | None,
+    ): ...
+
+    @overload
+    def __init__(
+        self,
+        *db_args,
+    ): ...
+
+    def __init__(
+        self,
+        *args,
+        **kwargs,
+    ):
+        super().__init__(*args, **kwargs)
+
+
+class ArtifactBiologic(Record, LinkORM, TracksRun):
+    id: int = models.BigAutoField(primary_key=True)
+    artifact: Artifact = ForeignKey(Artifact, CASCADE, related_name="links_biologic")
+    biologic: Biologic = ForeignKey(Biologic, PROTECT, related_name="links_artifact")
+    feature: Feature = ForeignKey(
+        Feature, PROTECT, null=True, default=None, related_name="links_artifactbiologic"
+    )
+    label_ref_is_name: bool | None = BooleanField(null=True, default=None)
+    feature_ref_is_name: bool | None = BooleanField(null=True, default=None)
+
+
 class CompoundPerturbation(Record, CanCurate, TracksRun, TracksUpdates):
     """Models compound perturbations such as drugs.
 

{lamindb-0.77.3 → lamindb-0.77.4}/sub/wetlab/wetlab/types.py

@@ -9,3 +9,15 @@ GeneticPerturbationSystem = Literal[
     "transgene",
     "transient-transfection",
 ]
+
+BiologicType = Literal[
+    "protein",
+    "peptide",
+    "antibody",
+    "enzyme",
+    "growth-factor",
+    "cytokine",
+    "hormone",
+    "vaccine",
+    "oligonucleotide",
+]