lamindb 1.3.1__py3-none-any.whl → 1.4.0__py3-none-any.whl

lamindb/models/feature.py

@@ -332,7 +332,7 @@ class Feature(Record, CanCurate, TracksRun, TracksUpdates):
 
     _name_field: str = "name"
     _aux_fields: dict[str, tuple[str, type]] = {
-        "0": ("default_value", bool),
+        "0": ("default_value", Any),  # type: ignore
         "1": ("nullable", bool),
         "2": ("coerce_dtype", bool),
     }
@@ -499,24 +499,11 @@ class Feature(Record, CanCurate, TracksRun, TracksUpdates):
         super().save(*args, **kwargs)
         return self
 
-    @property
-    def coerce_dtype(self) -> bool:
-        """Whether dtypes should be coerced during validation.
-
-        For example, a `objects`-dtyped pandas column can be coerced to `categorical` and would pass validation if this is true.
-        """
-        if self._aux is not None and "af" in self._aux and "2" in self._aux["af"]:  # type: ignore
-            return self._aux["af"]["2"]  # type: ignore
-        else:
-            return False
-
-    @coerce_dtype.setter
-    def coerce_dtype(self, value: bool) -> None:
-        if self._aux is None:  # type: ignore
-            self._aux = {}  # type: ignore
-        if "af" not in self._aux:
-            self._aux["af"] = {}
-        self._aux["af"]["2"] = value
+    def with_config(self, optional: bool | None = None) -> tuple[Feature, dict]:
+        """Pass addtional configurations to the schema."""
+        if optional is not None:
+            return self, {"optional": optional}
+        return self, {}
 
     @property
     def default_value(self) -> Any:
@@ -532,12 +519,9 @@ class Feature(Record, CanCurate, TracksRun, TracksUpdates):
             return None
 
     @default_value.setter
-    def default_value(self, value: bool) -> None:
-        if self._aux is None:  # type: ignore
-            self._aux = {}  # type: ignore
-        if "af" not in self._aux:
-            self._aux["af"] = {}
-        self._aux["af"]["0"] = value
+    def default_value(self, value: str | None) -> None:
+        self._aux = self._aux or {}
+        self._aux.setdefault("af", {})["0"] = value
 
     @property
     def nullable(self) -> bool:
@@ -568,11 +552,24 @@ class Feature(Record, CanCurate, TracksRun, TracksUpdates):
     @nullable.setter
     def nullable(self, value: bool) -> None:
         assert isinstance(value, bool), value  # noqa: S101
-        if self._aux is None:
-            self._aux = {}
-        if "af" not in self._aux:
-            self._aux["af"] = {}
-        self._aux["af"]["1"] = value
+        self._aux = self._aux or {}
+        self._aux.setdefault("af", {})["1"] = value
+
+    @property
+    def coerce_dtype(self) -> bool:
+        """Whether dtypes should be coerced during validation.
+
+        For example, a `objects`-dtyped pandas column can be coerced to `categorical` and would pass validation if this is true.
+        """
+        if self._aux is not None and "af" in self._aux and "2" in self._aux["af"]:  # type: ignore
+            return self._aux["af"]["2"]  # type: ignore
+        else:
+            return False
+
+    @coerce_dtype.setter
+    def coerce_dtype(self, value: bool) -> None:
+        self._aux = self._aux or {}
+        self._aux.setdefault("af", {})["2"] = value
 
 
 class FeatureValue(Record, TracksRun):

lamindb/models/has_parents.py

@@ -4,12 +4,15 @@ from __future__ import annotations
 import builtins
 from typing import TYPE_CHECKING, Literal
 
+import lamindb_setup as ln_setup
 from lamin_utils import logger
 
 from .record import format_field_value, get_name_field
 from .run import Run
 
 if TYPE_CHECKING:
+    from graphviz import Digraph
+
     from lamindb.base.types import StrField
 
     from .artifact import Artifact
@@ -78,7 +81,7 @@ class HasParents:
         if not isinstance(field, str):
             field = field.field.name
 
-        return _view_parents(
+        return view_parents(
             record=self,  # type: ignore
             field=field,
             with_children=with_children,
@@ -101,7 +104,7 @@ def _transform_emoji(transform: Transform):
         return TRANSFORM_EMOJIS["pipeline"]
 
 
-def _view(u):
+def view_digraph(u: Digraph):
     from graphviz.backend import ExecutableNotFound
 
     try:
@@ -117,7 +120,7 @@ def _view(u):
                 # call to display()
                 display(u._repr_mimebundle_(), raw=True)
         else:
-            return u
+            return u.view()
     except (FileNotFoundError, RuntimeError, ExecutableNotFound):  # pragma: no cover
         logger.error(
             "please install the graphviz executable on your system:\n  - Ubuntu: `sudo"
@@ -126,7 +129,9 @@ def _view(u):
         )
 
 
-def view_lineage(data: Artifact | Collection, with_children: bool = True) -> None:
+def view_lineage(
+    data: Artifact | Collection, with_children: bool = True, return_graph: bool = False
+) -> Digraph | None:
     """Graph of data flow.
 
     Notes:
@@ -136,6 +141,13 @@ def view_lineage(data: Artifact | Collection, with_children: bool = True) -> Non
         >>> collection.view_lineage()
         >>> artifact.view_lineage()
     """
+    if ln_setup.settings.instance.is_on_hub:
+        instance_slug = ln_setup.settings.instance.slug
+        entity_slug = data.__class__.__name__.lower()
+        logger.important(
+            f"explore at: https://lamin.ai/{instance_slug}/{entity_slug}/{data.uid}"
+        )
+
     import graphviz
 
     df_values = _get_all_parent_runs(data)
@@ -189,10 +201,13 @@ def view_lineage(data: Artifact | Collection, with_children: bool = True) -> Non
         shape="box",
     )
 
-    _view(u)
+    if return_graph:
+        return u
+    else:
+        return view_digraph(u)
 
 
-def _view_parents(
+def view_parents(
     record: Record,
     field: str,
     with_children: bool = False,
@@ -258,7 +273,7 @@ def _view_parents(
             u.node(row["target"], label=row["target_label"])
             u.edge(row["source"], row["target"], color="dimgrey")
 
-    _view(u)
+    view_digraph(u)
 
 
 def _get_parents(

lamindb/models/project.py

@@ -366,7 +366,7 @@ class CollectionProject(BasicRecord, LinkORM, TracksRun):
 
 class ULabelProject(BasicRecord, LinkORM, TracksRun):
     id: int = models.BigAutoField(primary_key=True)
-    ulabel: Transform = ForeignKey(ULabel, CASCADE, related_name="links_project")
+    ulabel: ULabel = ForeignKey(ULabel, CASCADE, related_name="links_project")
     project: Project = ForeignKey(Project, PROTECT, related_name="links_ulabel")
 
     class Meta:
@@ -375,7 +375,7 @@ class ULabelProject(BasicRecord, LinkORM, TracksRun):
 
 class PersonProject(BasicRecord, LinkORM, TracksRun):
     id: int = models.BigAutoField(primary_key=True)
-    person: Transform = ForeignKey(Person, CASCADE, related_name="links_project")
+    person: Person = ForeignKey(Person, CASCADE, related_name="links_project")
     project: Project = ForeignKey(Project, PROTECT, related_name="links_person")
     role: str | None = CharField(null=True, default=None)
 

lamindb/models/query_set.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import re
-import warnings
 from collections import UserList
 from collections.abc import Iterable
 from collections.abc import Iterable as IterableType
@@ -75,49 +74,28 @@ def get_backward_compat_filter_kwargs(queryset, expressions):
     from lamindb.models import (
         Artifact,
         Collection,
-        Schema,
         Transform,
     )
 
     if queryset.model in {Collection, Transform}:
         name_mappings = {
-            "name": "key",
-            "visibility": "_branch_code",  # for convenience (and backward compat <1.0)
+            "visibility": "_branch_code",
         }
     elif queryset.model == Artifact:
         name_mappings = {
-            "n_objects": "n_files",
-            "visibility": "_branch_code",  # for convenience (and backward compat <1.0)
-            "transform": "run__transform",  # for convenience (and backward compat <1.0)
-            "type": "kind",
-            "_accessor": "otype",
-        }
-    elif queryset.model == Schema:
-        name_mappings = {
-            "registry": "itype",
+            "visibility": "_branch_code",
+            "transform": "run__transform",
         }
     else:
         return expressions
     was_list = False
     if isinstance(expressions, list):
-        # make a dummy dictionary
         was_list = True
         expressions = {field: True for field in expressions}
     mapped = {}
     for field, value in expressions.items():
         parts = field.split("__")
         if parts[0] in name_mappings:
-            if parts[0] not in {
-                "transform",
-                "visibility",
-                "schemas",
-                "artifacts",
-            }:
-                warnings.warn(
-                    f"{name_mappings[parts[0]]} is deprecated, please query for {parts[0]} instead",
-                    DeprecationWarning,
-                    stacklevel=2,
-                )
             new_field = name_mappings[parts[0]] + (
                 "__" + "__".join(parts[1:]) if len(parts) > 1 else ""
             )
@@ -631,15 +609,7 @@ class QuerySet(models.QuerySet):
         """Suggest available fields if an unknown field was passed."""
         if "Cannot resolve keyword" in str(error):
             field = str(error).split("'")[1]
-            fields = ", ".join(
-                sorted(
-                    f.name
-                    for f in self.model._meta.get_fields()
-                    if not f.name.startswith("_")
-                    and not f.name.startswith("links_")
-                    and not f.name.endswith("_id")
-                )
-            )
+            fields = ", ".join(sorted(self.model.__get_available_fields__()))
             raise FieldError(
                 f"Unknown field '{field}'. Available fields: {fields}"
             ) from None
@@ -680,7 +650,8 @@ class QuerySet(models.QuerySet):
                     )
 
         expressions = process_expressions(self, expressions)
-        if len(expressions) > 0:
+        # need to run a query if queries or expressions are not empty
+        if queries or expressions:
             try:
                 return super().filter(*queries, **expressions)
             except FieldError as e: