lamindb 0.76.12__tar.gz → 0.76.13__tar.gz

{lamindb-0.76.12 → lamindb-0.76.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lamindb
-Version: 0.76.12
+Version: 0.76.13
 Summary: A data framework for biology.
 Author-email: Lamin Labs <open-source@lamin.ai>
 Requires-Python: >=3.9
@@ -10,7 +10,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Requires-Dist: lnschema_core==0.75.0
 Requires-Dist: lamin_utils==0.13.6
-Requires-Dist: lamin_cli==0.18.0
+Requires-Dist: lamin_cli==0.19.0
 Requires-Dist: lamindb_setup
 Requires-Dist: rapidfuzz
 Requires-Dist: pyarrow

{lamindb-0.76.12 → lamindb-0.76.13}/docs/faq/idempotency.ipynb

@@ -70,7 +70,6 @@
     "import lamindb as ln\n",
     "import pytest\n",
     "\n",
-    "ln.settings.verbosity = \"hint\"\n",
     "ln.track(\"ANW20Fr4eZgM0000\")"
    ]
   },
@@ -301,8 +300,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "artifact = ln.Artifact(filepath, description=\"My fcs artifact\")\n",
-    "artifact.save()"
+    "artifact = ln.Artifact(filepath, description=\"My fcs artifact\").save()"
    ]
   },
   {
@@ -316,7 +314,9 @@
    },
    "outputs": [],
    "source": [
-    "assert artifact.hash == \"KCEXRahJ-Ui9Y6nksQ8z1A\""
+    "assert artifact.hash == \"KCEXRahJ-Ui9Y6nksQ8z1A\"\n",
+    "assert artifact.run == ln.context.run\n",
+    "assert len(artifact._previous_runs.all()) == 0"
    ]
   },
   {
@@ -355,7 +355,8 @@
    "outputs": [],
    "source": [
     "assert artifact.id == artifact2.id\n",
-    "assert artifact.run == artifact2.run"
+    "assert artifact.run == artifact2.run\n",
+    "assert len(artifact._previous_runs.all()) == 0"
    ]
   },
   {
@@ -485,8 +486,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "artifact4 = ln.Artifact(filepath, description=\"My new fcs artifact\")\n",
-    "artifact4.save()"
+    "artifact4 = ln.Artifact(filepath, description=\"My new fcs artifact\").save()"
    ]
   },
   {
@@ -543,6 +543,7 @@
    },
    "outputs": [],
    "source": [
+    "!rm -rf ./test-idempotency\n",
     "!lamin delete --force test-idempotency"
    ]
   }

{lamindb-0.76.12 → lamindb-0.76.13}/docs/faq/setup.ipynb

@@ -100,7 +100,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "with pytest.raises(RuntimeError):\n",
+    "from lamindb_setup._init_instance import CannotSwitchDefaultInstance\n",
+    "\n",
+    "with pytest.raises(CannotSwitchDefaultInstance):\n",
     "    ln.setup.init(storage=\"./testsetup2\")"
    ]
   },

{lamindb-0.76.12 → lamindb-0.76.13}/docs/tutorial.ipynb

@@ -575,7 +575,6 @@
     "ln.Artifact.filter(\n",
     "    created_by=users.anonymous,\n",
     "    transform=transform,\n",
-    "    suffix=\".csv\",\n",
     ").df().head()"
    ]
   },
@@ -596,7 +595,7 @@
    },
    "outputs": [],
    "source": [
-    "ln.Artifact.filter(key__startswith=\"iris_studies/study0_raw_images/\").df().head()"
+    "ln.Artifact.filter(key__startswith=\"iris_studies/study0_raw_images\").df().head()"
    ]
   },
   {

{lamindb-0.76.12 → lamindb-0.76.13}/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.76.12"
+__version__ = "0.76.13"
 
 import os as _os
 

{lamindb-0.76.12 → lamindb-0.76.13}/lamindb/_artifact.py

@@ -331,9 +331,10 @@ def get_artifact_kwargs_from_data(
         artifact = stat_or_artifact
         # update the run of the existing artifact
         if run is not None:
-            # save the information that this artifact was previously
-            # produced by another run
-            if artifact.run is not None:
+            # save the information that this artifact was previously produced by
+            # another run
+            # note: same logic exists for _output_collections_with_later_updates
+            if artifact.run is not None and artifact.run != run:
                 artifact.run._output_artifacts_with_later_updates.add(artifact)
             # update the run of the artifact with the latest run
             stat_or_artifact.run = run

{lamindb-0.76.12 → lamindb-0.76.13}/lamindb/_collection.py

@@ -145,15 +145,16 @@ def __init__(
         logger.warning(
             f"returning existing collection with same hash: {existing_collection}"
         )
-        # update the run of the existing artifact
+        # update the run of the existing collection
         if run is not None:
-            # save the information that this artifact was previously
-            # produced by another run
-            if existing_collection.run is not None:
+            # save the information that this collection was previously produced
+            # by another run
+            # note: same logic exists for _output_artifacts_with_later_updates
+            if existing_collection.run is not None and existing_collection.run != run:
                 existing_collection.run._output_collections_with_later_updates.add(
                     existing_collection
                 )
-            # update the run of the artifact with the latest run
+            # update the run of the collection with the latest run
             existing_collection.run = run
             existing_collection.transform = run.transform
         init_self_from_db(collection, existing_collection)

{lamindb-0.76.12 → lamindb-0.76.13}/lamindb/_feature_set.py

@@ -216,7 +216,9 @@ def members(self) -> QuerySet:
 
 
 def _get_related_name(self: FeatureSet) -> str:
-    feature_sets_related_models = dict_related_model_to_related_name(self)
+    feature_sets_related_models = dict_related_model_to_related_name(
+        self, instance=self._state.db
+    )
     related_name = feature_sets_related_models.get(self.registry)
     return related_name
 

{lamindb-0.76.12 → lamindb-0.76.13}/lamindb/_parents.py

@@ -310,7 +310,12 @@ def _record_label(record: Record, field: str | None = None):
             rf' FACE="Monospace">uid={record.uid}<BR/>version={record.version}</FONT>>'
         )
     elif isinstance(record, Run):
-        name = f'{record.transform.name.replace("&", "&amp;")}'
+        if record.transform.name:
+            name = f'{record.transform.name.replace("&", "&amp;")}'
+        elif record.transform.key:
+            name = f'{record.transform.key.replace("&", "&amp;")}'
+        else:
+            name = f"{record.transform.uid}"
         user_display = (
             record.created_by.handle
             if record.created_by.name is None
@@ -365,7 +370,6 @@ def _get_all_parent_runs(data: Artifact | Collection) -> list:
                 inputs_run += (
                     r.input_collections.all().filter(visibility__in=[0, 1]).list()
                 )
-            run_inputs_outputs += [(inputs_run, r)]
             outputs_run = (
                 r.__getattribute__(f"output_{name}s")
                 .all()
@@ -376,7 +380,18 @@ def _get_all_parent_runs(data: Artifact | Collection) -> list:
                 outputs_run += (
                     r.output_collections.all().filter(visibility__in=[0, 1]).list()
                 )
-            run_inputs_outputs += [(r, outputs_run)]
+            # if inputs are outputs artifacts are the same, will result infinite loop
+            # so only show as outputs
+            overlap = set(inputs_run).intersection(outputs_run)
+            if overlap:
+                logger.warning(
+                    f"The following artifacts are both inputs and outputs of Run(uid={r.uid}): {overlap}\n   → Only showing as outputs."
+                )
+                inputs_run = list(set(inputs_run) - overlap)
+            if len(inputs_run) > 0:
+                run_inputs_outputs += [(inputs_run, r)]
+            if len(outputs_run) > 0:
+                run_inputs_outputs += [(r, outputs_run)]
             inputs += inputs_run
         runs = [f.run for f in inputs if f.run is not None]
     return run_inputs_outputs

{lamindb-0.76.12 → lamindb-0.76.13}/lamindb/_query_manager.py

@@ -98,26 +98,11 @@ class QueryManager(models.Manager):
 
         return _lookup(cls=self.all(), field=field, **kwargs)
 
-    def __getitem__(self, item: str):
-        try:
-            source_field_name = self.source_field_name
-            target_field_name = self.target_field_name
-
-            if (
-                source_field_name in {"artifact", "collection"}
-                and target_field_name == "feature_set"
-            ):
-                return get_feature_set_by_slot_(host=self.instance).get(item)
-
-        except Exception:  # pragma: no cover
-            return
-
 
 models.Manager.list = QueryManager.list
 models.Manager.df = QueryManager.df
 models.Manager.search = QueryManager.search
 models.Manager.lookup = QueryManager.lookup
-models.Manager.__getitem__ = QueryManager.__getitem__
 models.Manager._track_run_input_manager = QueryManager._track_run_input_manager
 # the two lines below would be easy if we could actually inherit; like this,
 # they're suboptimal

{lamindb-0.76.12 → lamindb-0.76.13}/lamindb/_query_set.py

@@ -115,7 +115,7 @@ def get(
     else:
         assert idlike is None  # noqa: S101
         expressions = process_expressions(registry, expressions)
-        return registry.objects.get(**expressions)
+        return registry.objects.using(qs.db).get(**expressions)
 
 
 class RecordsList(UserList):

{lamindb-0.76.12 → lamindb-0.76.13}/lamindb/_record.py

@@ -376,6 +376,8 @@ def using(
     instance: str | None,
 ) -> QuerySet:
     """{}"""  # noqa: D415
+    from ._query_set import QuerySet
+
     if instance is None:
         return QuerySet(model=cls, using=None)
     owner, name = get_owner_name_from_identifier(instance)
@@ -395,15 +397,15 @@ def using(
         if not source_schema.issubset(target_schema):
             missing_members = source_schema - target_schema
             logger.warning(
-                f"source schema has additional modules: {missing_members}\nconsider mounting these schema modules to not encounter errors"
+                f"source schema has additional modules: {missing_members}\nconsider mounting these schema modules to transfer all metadata"
             )
-        cache_filepath.write_text(iresult["lnid"])  # type: ignore
+        cache_filepath.write_text(f"{iresult['lnid']}\n{iresult['schema_str']}")  # type: ignore
         settings_file = instance_settings_file(name, owner)
         db = update_db_using_local(iresult, settings_file)
     else:
         isettings = load_instance_settings(settings_file)
         db = isettings.db
-        cache_filepath.write_text(isettings.uid)
+        cache_filepath.write_text(f"{isettings.uid}\n{','.join(isettings.schema)}")  # type: ignore
     add_db_connection(db, instance)
     return QuerySet(model=cls, using=instance)
 
@@ -470,7 +472,7 @@ def get_transfer_run(record) -> Run:
     cache_filepath = ln_setup.settings.cache_dir / f"instance--{owner}--{name}--uid.txt"
     if not cache_filepath.exists():
         raise SystemExit("Need to call .using() before")
-    instance_uid = cache_filepath.read_text()
+    instance_uid = cache_filepath.read_text().split("\n")[0]
     key = f"transfers/{instance_uid}"
     uid = instance_uid + "0000"
     transform = Transform.filter(uid=uid).one_or_none()

{lamindb-0.76.12 → lamindb-0.76.13}/lamindb/core/_context.py

@@ -438,7 +438,7 @@ class Context:
             )
             return (
                 f'Filename "{key}" clashes with the existing key "{transform.key}" for uid "{transform.uid[:-4]}...."\n\nEither init a new transform with a new uid:\n\n'
-                f'ln.track("{ids.base62_12()}0000)"\n\n{update_key_note}'
+                f'ln.track("{ids.base62_12()}0000")\n\n{update_key_note}'
             )
 
         # make a new transform record

{lamindb-0.76.12 → lamindb-0.76.13}/lamindb/core/_django.py

@@ -6,7 +6,7 @@ from django.db.models.fields.reverse_related import ManyToManyRel, ManyToOneRel
 from django.db.models.functions import JSONObject
 from lnschema_core.models import Artifact, FeatureSet, Record
 
-from .schema import dict_related_model_to_related_name
+from .schema import dict_related_model_to_related_name, get_schemas_modules
 
 
 def get_related_model(model, field_name):
@@ -35,22 +35,36 @@ def get_artifact_with_related(
     """Fetch an artifact with its related data."""
     from lamindb._can_validate import get_name_field
 
+    from ._label_manager import LABELS_EXCLUDE_SET
+
     model = artifact.__class__
-    foreign_key_fields = [f.name for f in model._meta.fields if f.is_relation]
+    schema_modules = get_schemas_modules(artifact._state.db)
+
+    foreign_key_fields = [
+        f.name
+        for f in model._meta.fields
+        if f.is_relation and f.related_model.__get_schema_name__() in schema_modules
+    ]
 
     m2m_relations = (
         []
         if not include_m2m
         else [
             v
-            for v in dict_related_model_to_related_name(model).values()
-            if not v.startswith("_")
+            for v in dict_related_model_to_related_name(
+                model, instance=artifact._state.db
+            ).values()
+            if not v.startswith("_") and v not in LABELS_EXCLUDE_SET
         ]
     )
     link_tables = (
         []
         if not include_feature_link
-        else list(dict_related_model_to_related_name(model, links=True).values())
+        else list(
+            dict_related_model_to_related_name(
+                model, links=True, instance=artifact._state.db
+            ).values()
+        )
     )
 
     # Clear previous queries

{lamindb-0.76.12 → lamindb-0.76.13}/lamindb/core/_feature_manager.py

@@ -216,9 +216,11 @@ def _print_categoricals(
     if not print_params:
         labels_msg = ""
         labels_by_feature = defaultdict(list)
-        for _, (_, links) in get_labels_as_dict(self, links=True).items():
+        for _, (_, links) in get_labels_as_dict(
+            self, links=True, instance=self._state.db
+        ).items():
             for link in links:
-                if link.feature_id is not None:
+                if hasattr(link, "feature_id") and link.feature_id is not None:
                     link_attr = get_link_attr(link, self)
                     labels_by_feature[link.feature_id].append(
                         getattr(link, link_attr).name

{lamindb-0.76.12 → lamindb-0.76.13}/lamindb/core/_label_manager.py

@@ -26,32 +26,19 @@ if TYPE_CHECKING:
 
     from lamindb._query_set import QuerySet
 
+LABELS_EXCLUDE_SET = {"feature_sets"}
 
-def get_labels_as_dict(self: Artifact | Collection, links: bool = False):
-    exclude_set = {
-        "feature_sets",
-        "artifacts",
-        "input_of_runs",
-        "collections",
-        "_source_code_artifact_of",
-        "_report_of",
-        "_environment_of",
-        "links_collection",
-        "links_artifact",
-        "links_feature_set",
-        "previous_runs",
-        "_feature_values",
-        "_action_targets",
-        "_lnschema_core_collection__actions_+",  # something seems off with this one
-        "_actions",
-    }
+
+def get_labels_as_dict(
+    self: Artifact | Collection, links: bool = False, instance: str | None = None
+) -> dict:
     labels = {}  # type: ignore
     if self.id is None:
         return labels
     for related_model_name, related_name in dict_related_model_to_related_name(
-        self.__class__, links=links
+        self.__class__, links=links, instance=instance
     ).items():
-        if related_name not in exclude_set:
+        if related_name not in LABELS_EXCLUDE_SET and not related_name.startswith("_"):
             labels[related_name] = (
                 related_model_name,
                 getattr(self, related_name).all(),
@@ -86,18 +73,15 @@ def print_labels(
         labels_msg = _print_labels_postgres(self, m2m_data, print_types)
     else:
         labels_msg = ""
-        for related_name, (related_model, labels) in get_labels_as_dict(self).items():
-            # there is a try except block here to deal with schema inconsistencies
-            # during transfer between instances
-            try:
-                field = get_name_field(labels)
-                labels_list = list(labels.values_list(field, flat=True))
-                if len(labels_list) > 0:
-                    print_values = _print_values(labels_list, n=10)
-                    type_str = f": {related_model}" if print_types else ""
-                    labels_msg += f"    .{related_name}{type_str} = {print_values}\n"
-            except Exception:  # noqa: S112
-                continue
+        for related_name, (related_model, labels) in get_labels_as_dict(
+            self, instance=self._state.db
+        ).items():
+            field = get_name_field(labels)
+            labels_list = list(labels.values_list(field, flat=True))
+            if len(labels_list) > 0:
+                print_values = _print_values(labels_list, n=10)
+                type_str = f": {related_model}" if print_types else ""
+                labels_msg += f"    .{related_name}{type_str} = {print_values}\n"
 
     msg = ""
     if labels_msg:
@@ -214,75 +198,68 @@ class LabelManager:
             >>> artifact1.ulabels.set(labels)
             >>> artifact2.labels.add_from(artifact1)
         """
-        from django.db.utils import ProgrammingError
-
         if transfer_logs is None:
             transfer_logs = {"mapped": [], "transferred": [], "run": None}
         using_key = settings._using_key
-        for related_name, (_, labels) in get_labels_as_dict(data).items():
+        for related_name, (_, labels) in get_labels_as_dict(
+            data, instance=self._host._state.db
+        ).items():
             labels = labels.all()
-            try:
-                if not labels.exists():
-                    continue
-                # look for features
-                data_name_lower = data.__class__.__name__.lower()
-                labels_by_features = defaultdict(list)
-                features = set()
-                _, new_labels = validate_labels(labels)
-                if len(new_labels) > 0:
-                    transfer_fk_to_default_db_bulk(
-                        new_labels, using_key, transfer_logs=transfer_logs
+            if not labels.exists():
+                continue
+            # look for features
+            data_name_lower = data.__class__.__name__.lower()
+            labels_by_features = defaultdict(list)
+            features = set()
+            _, new_labels = validate_labels(labels)
+            if len(new_labels) > 0:
+                transfer_fk_to_default_db_bulk(
+                    new_labels, using_key, transfer_logs=transfer_logs
+                )
+            for label in labels:
+                # if the link table doesn't follow this convention, we'll ignore it
+                if not hasattr(label, f"links_{data_name_lower}"):
+                    key = None
+                else:
+                    link = getattr(label, f"links_{data_name_lower}").get(
+                        **{f"{data_name_lower}_id": data.id}
                     )
-                for label in labels:
-                    # if the link table doesn't follow this convention, we'll ignore it
-                    if not hasattr(label, f"links_{data_name_lower}"):
-                        key = None
+                    if link.feature is not None:
+                        features.add(link.feature)
+                        key = link.feature.name
                     else:
-                        link = getattr(label, f"links_{data_name_lower}").get(
-                            **{f"{data_name_lower}_id": data.id}
-                        )
-                        if link.feature is not None:
-                            features.add(link.feature)
-                            key = link.feature.name
-                        else:
-                            key = None
-                    label_returned = transfer_to_default_db(
-                        label,
+                        key = None
+                label_returned = transfer_to_default_db(
+                    label,
+                    using_key,
+                    transfer_logs=transfer_logs,
+                    transfer_fk=False,
+                    save=True,
+                )
+                # TODO: refactor return value of transfer to default db
+                if label_returned is not None:
+                    label = label_returned
+                labels_by_features[key].append(label)
+            # treat features
+            _, new_features = validate_labels(list(features))
+            if len(new_features) > 0:
+                transfer_fk_to_default_db_bulk(
+                    new_features, using_key, transfer_logs=transfer_logs
+                )
+                for feature in new_features:
+                    transfer_to_default_db(
+                        feature,
                         using_key,
                         transfer_logs=transfer_logs,
                         transfer_fk=False,
-                        save=True,
                     )
-                    # TODO: refactor return value of transfer to default db
-                    if label_returned is not None:
-                        label = label_returned
-                    labels_by_features[key].append(label)
-                # treat features
-                _, new_features = validate_labels(list(features))
-                if len(new_features) > 0:
-                    transfer_fk_to_default_db_bulk(
-                        new_features, using_key, transfer_logs=transfer_logs
+                save(new_features)
+            if hasattr(self._host, related_name):
+                for feature_name, labels in labels_by_features.items():
+                    if feature_name is not None:
+                        feature_id = Feature.get(name=feature_name).id
+                    else:
+                        feature_id = None
+                    getattr(self._host, related_name).add(
+                        *labels, through_defaults={"feature_id": feature_id}
                     )
-                    for feature in new_features:
-                        transfer_to_default_db(
-                            feature,
-                            using_key,
-                            transfer_logs=transfer_logs,
-                            transfer_fk=False,
-                        )
-                    save(new_features)
-                if hasattr(self._host, related_name):
-                    for feature_name, labels in labels_by_features.items():
-                        if feature_name is not None:
-                            feature_id = Feature.get(name=feature_name).id
-                        else:
-                            feature_id = None
-                        getattr(self._host, related_name).add(
-                            *labels, through_defaults={"feature_id": feature_id}
-                        )
-            # ProgrammingError is raised when schemas don't match between source and target instances
-            except ProgrammingError:
-                logger.warning(
-                    f"{related_name} labels cannot be transferred because schema module does not exist in target instance: {labels}"
-                )
-                continue

lamindb-0.76.13/lamindb/core/schema.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+import lamindb_setup as ln_setup
+from django.db.models import ManyToManyField
+from lamindb_setup._connect_instance import (
+    get_owner_name_from_identifier,
+    load_instance_settings,
+)
+from lamindb_setup.core._settings_store import instance_settings_file
+from lnschema_core.models import Feature, FeatureSet, LinkORM, Record
+
+
+def get_schemas_modules(instance: str | None) -> set[str]:
+    if instance is None or instance == "default":
+        schema_modules = set(ln_setup.settings.instance.schema)
+        schema_modules.add("core")
+        return schema_modules
+    owner, name = get_owner_name_from_identifier(instance)
+    settings_file = instance_settings_file(name, owner)
+    if settings_file.exists():
+        schema = set(load_instance_settings(settings_file).schema)
+    else:
+        cache_filepath = (
+            ln_setup.settings.cache_dir / f"instance--{owner}--{name}--uid.txt"
+        )
+        if cache_filepath.exists():
+            schema = set(cache_filepath.read_text().split("\n")[1].split(","))
+        else:
+            raise ValueError(f"Instance {instance} not found")
+    shared_schema_modules = set(ln_setup.settings.instance.schema).intersection(schema)
+    shared_schema_modules.add("core")
+    return shared_schema_modules
+
+
+def dict_schema_name_to_model_name(
+    registry: type[Record], instance: str | None = None
+) -> dict[str, Record]:
+    schema_modules = get_schemas_modules(instance)
+    d: dict = {
+        i.related_model.__get_name_with_schema__(): i.related_model
+        for i in registry._meta.related_objects
+        if i.related_name is not None
+        and i.related_model.__get_schema_name__() in schema_modules
+    }
+    d.update(
+        {
+            i.related_model.__get_name_with_schema__(): i.related_model
+            for i in registry._meta.many_to_many
+            if i.name is not None
+            and i.related_model.__get_schema_name__() in schema_modules
+        }
+    )
+    return d
+
+
+def dict_related_model_to_related_name(
+    registry: type[Record], links: bool = False, instance: str | None = None
+) -> dict[str, str]:
+    def include(model: Record):
+        return not links != issubclass(model, LinkORM)
+
+    schema_modules = get_schemas_modules(instance)
+
+    related_objects = registry._meta.related_objects + registry._meta.many_to_many
+    d: dict = {
+        record.related_model.__get_name_with_schema__(): (
+            record.related_name
+            if not isinstance(record, ManyToManyField)
+            else record.name
+        )
+        for record in related_objects
+        if (
+            record.name is not None
+            and include(record.related_model)
+            and record.related_model.__get_schema_name__() in schema_modules
+        )
+    }
+    return d
+
+
+def get_related_name(features_type: type[Record]) -> str:
+    candidates = [
+        field.related_name
+        for field in FeatureSet._meta.related_objects
+        if field.related_model == features_type
+    ]
+    if not candidates:
+        raise ValueError(
+            f"Can't create feature sets from {features_type.__name__} because it's not"
+            " related to it!\nYou need to create a link model between FeatureSet and"
+            " your Record in your custom schema.\nTo do so, add a"
+            " line:\nfeature_sets = models.ManyToMany(FeatureSet,"
+            " related_name='mythings')\n"
+        )
+    return candidates[0]

{lamindb-0.76.12 → lamindb-0.76.13}/pyproject.toml

@@ -17,7 +17,7 @@ dependencies = [
     # Lamin PINNED packages
     "lnschema_core==0.75.0",
     "lamin_utils==0.13.6",
-    "lamin_cli==0.18.0",
+    "lamin_cli==0.19.0",
     # PINNED in lamin-cli
     "lamindb_setup",
     # others