lamindb 1.3.2__py3-none-any.whl → 1.5.0__py3-none-any.whl

lamindb/models/run.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any, overload
 
+import numpy as np
 from django.db import models
 from django.db.models import (
     CASCADE,
@@ -19,7 +20,7 @@ from lamindb.base.fields import (
     ForeignKey,
 )
 from lamindb.base.users import current_user_id
-from lamindb.errors import ValidationError
+from lamindb.errors import InvalidArgument, ValidationError
 
 from ..base.ids import base62_20
 from .can_curate import CanCurate
@@ -33,6 +34,7 @@ if TYPE_CHECKING:
     from .artifact import Artifact
     from .collection import Collection
     from .project import Project
+    from .query_set import QuerySet
     from .schema import Schema
     from .transform import Transform
     from .ulabel import ULabel
@@ -345,7 +347,7 @@ class ParamValue(Record):
 
 
 class Run(Record):
-    """Runs.
+    """Runs of transforms such as the execution of a script.
 
     A registry to store runs of transforms, such as an executation of a script.
 
@@ -538,6 +540,56 @@ class Run(Record):
         delete_run_artifacts(self)
         super().delete()
 
+    @classmethod
+    def filter(
+        cls,
+        *queries,
+        **expressions,
+    ) -> QuerySet:
+        """Query a set of artifacts.
+
+        Args:
+            *queries: `Q` expressions.
+            **expressions: Params, fields, and values passed via the Django query syntax.
+
+        See Also:
+            - Guide: :doc:`docs:registries`
+
+        Examples:
+
+            Query by fields::
+
+                ln.Run.filter(key="examples/my_file.parquet")
+
+            Query by params::
+
+                ln.Run.filter(hyperparam_x=100)
+        """
+        from ._feature_manager import filter_base
+        from .query_set import QuerySet
+
+        if expressions:
+            keys_normalized = [key.split("__")[0] for key in expressions]
+            field_or_feature_or_param = keys_normalized[0].split("__")[0]
+            if field_or_feature_or_param in Run.__get_available_fields__():
+                return QuerySet(model=cls).filter(*queries, **expressions)
+            elif all(
+                params_validated := Param.validate(
+                    keys_normalized, field="name", mute=True
+                )
+            ):
+                return filter_base(ParamManagerRun, **expressions)
+            else:
+                params = ", ".join(sorted(np.array(keys_normalized)[~params_validated]))
+                message = f"param names: {params}"
+                fields = ", ".join(sorted(cls.__get_available_fields__()))
+                raise InvalidArgument(
+                    f"You can query either by available fields: {fields}\n"
+                    f"Or fix invalid {message}"
+                )
+        else:
+            return QuerySet(model=cls).filter(*queries, **expressions)
+
 
 def delete_run_artifacts(run: Run) -> None:
     environment = None
@@ -555,14 +607,16 @@ def delete_run_artifacts(run: Run) -> None:
         if environment._environment_of.count() == 0:
             environment.delete(permanent=True)
     if report is not None:
-        report.delete(permanent=True)
+        # only delete if there are no other runs attached to this environment
+        if report._report_of.count() == 0:
+            report.delete(permanent=True)
 
 
 class RunParamValue(BasicRecord, LinkORM):
     id: int = models.BigAutoField(primary_key=True)
-    run: Run = ForeignKey(Run, CASCADE, related_name="+")
+    run: Run = ForeignKey(Run, CASCADE, related_name="links_paramvalue")
     # we follow the lower() case convention rather than snake case for link models
-    paramvalue: ParamValue = ForeignKey(ParamValue, PROTECT, related_name="+")
+    paramvalue: ParamValue = ForeignKey(ParamValue, PROTECT, related_name="links_run")
     created_at: datetime = DateTimeField(
         editable=False, db_default=models.functions.Now(), db_index=True
     )

lamindb/models/save.py

@@ -30,7 +30,7 @@ if TYPE_CHECKING:
 
 
 def save(records: Iterable[Record], ignore_conflicts: bool | None = False) -> None:
-    """Bulk save to registries & storage.
+    """Bulk save records.
 
     Note:
 
@@ -157,7 +157,13 @@ def check_and_attempt_upload(
             return exception
         # copies (if on-disk) or moves the temporary file (if in-memory) to the cache
         if os.getenv("LAMINDB_MULTI_INSTANCE") is None:
-            copy_or_move_to_cache(artifact, storage_path, cache_path)
+            # this happens only after the actual upload was performed
+            # we avoid failing here in case any problems happen in copy_or_move_to_cache
+            # because the cache copying or cleanup is not absolutely necessary
+            try:
+                copy_or_move_to_cache(artifact, storage_path, cache_path)
+            except Exception as e:
+                logger.warning(f"A problem with cache on saving: {e}")
         # after successful upload, we should remove the attribute so that another call
         # call to save won't upload again, the user should call replace() then
         del artifact._local_filepath
@@ -192,9 +198,7 @@ def copy_or_move_to_cache(
     # non-local storage_path further
     if local_path != cache_path:
         if cache_path.exists():
-            logger.warning(
-                f"The cache path {cache_path.as_posix()} already exists, replacing it."
-            )
+            logger.warning(f"replacing the existing cache path {cache_path.as_posix()}")
             if cache_path.is_dir():
                 shutil.rmtree(cache_path)
             else: