lamindb 1.6.1__py3-none-any.whl → 1.7.0__py3-none-any.whl

lamindb/models/__init__.py

@@ -41,7 +41,7 @@ from .sqlrecord import (
     record_repr,
     IsLink,
 )
-from .core import Storage
+from .storage import Storage
 from .transform import Transform
 from .run import Run, TracksRun, TracksUpdates, current_run, User
 from .feature import Feature, FeatureValue
@@ -73,10 +73,11 @@ from .project import (
     SchemaProject,
     ArtifactReference,
     CollectionReference,
-    SheetProject,
     RunProject,
     RecordProject,
     PersonProject,
+    RecordPerson,
+    RecordReference,
 )
 from .run import RunFeatureValue
 from .schema import (
@@ -89,12 +90,12 @@ from .ulabel import ArtifactULabel, TransformULabel, RunULabel, CollectionULabel
 
 from .record import (
     Record,
-    Sheet,
     RecordJson,
     RecordRecord,
     RecordULabel,
     RecordRun,
     RecordArtifact,
+    ArtifactRecord,
 )
 
 

lamindb/models/_describe.py

@@ -27,12 +27,12 @@ def highlight_time(iso: str):
         # raises ValueError: Invalid isoformat string: '<django.db.models.expressions.DatabaseDefault object at 0x1128ac440>'
         # but can't be caught with `isinstance(iso, DatabaseDefault)` for unkown reasons
         return Text("timestamp of unsaved record not available", style="dim")
-    return Text(res, style="dim")
+    return Text(res)
 
 
 # Define consistent column widths
-NAME_WIDTH = 25
-TYPE_WIDTH = 25
+NAME_WIDTH = 30
+TYPE_WIDTH = 35  # types can get long, e.g. cat[Record[Treatment]]
 VALUES_WIDTH = 40
 
 
@@ -97,8 +97,11 @@ def describe_header(self: Artifact | Collection | Run) -> Tree:
     # initialize tree
     suffix = self.suffix if hasattr(self, "suffix") and self.suffix else ""
     accessor = self.otype if hasattr(self, "otype") and self.otype else ""
+    kind = f" · {self.kind}" if hasattr(self, "kind") and self.kind else ""
     suffix_accessor = (
-        f"{suffix}/{accessor}" if suffix and accessor else suffix or accessor or ""
+        f"{suffix} · {accessor}{kind}"
+        if suffix and accessor
+        else suffix or accessor or ""
     )
 
     tree = Tree(
@@ -110,40 +113,59 @@ def describe_header(self: Artifact | Collection | Run) -> Tree:
     return tree
 
 
+def format_bytes(bytes_value):
+    """Convert bytes to human readable format."""
+    if bytes_value < 1024:
+        return f"{bytes_value} B"
+    elif bytes_value < 1024**2:
+        return f"{bytes_value / 1024:.1f} KB"
+    elif bytes_value < 1024**3:
+        return f"{bytes_value / (1024**2):.1f} MB"
+    elif bytes_value < 1024**4:
+        return f"{bytes_value / (1024**3):.1f} GB"
+    else:
+        return f"{bytes_value / (1024**4):.1f} TB"
+
+
 def describe_general(self: Artifact | Collection, tree: Tree | None = None) -> Tree:
     if tree is None:
         tree = describe_header(self)
 
     # add general information (order is the same as in API docs)
     general = tree.add(Text("General", style="bold bright_cyan"))
-    general.add(f".uid = '{self.uid}'")
-    if hasattr(self, "key") and self.key:
-        general.add(f".key = '{self.key}'")
-    if hasattr(self, "size") and self.size:
-        general.add(f".size = {self.size}")
+
+    # Two column items (short content)
+    two_column_items = []
+
+    two_column_items.append(Text.assemble(("uid: ", "dim"), f"{self.uid}"))
     if hasattr(self, "hash") and self.hash:
-        general.add(f".hash = '{self.hash}'")
+        two_column_items.append(Text.assemble(("hash: ", "dim"), f"{self.hash}"))
+    if hasattr(self, "size") and self.size:
+        two_column_items.append(
+            Text.assemble(("size: ", "dim"), f"{format_bytes(self.size)}")
+        )
     if hasattr(self, "n_files") and self.n_files:
-        general.add(f".n_files = {self.n_files}")
+        two_column_items.append(Text.assemble(("n_files: ", "dim"), f"{self.n_files}"))
     if hasattr(self, "n_observations") and self.n_observations:
-        general.add(Text(f".n_observations = {self.n_observations}"))
+        two_column_items.append(
+            Text.assemble(("n_observations: ", "dim"), f"{self.n_observations}")
+        )
     if hasattr(self, "version") and self.version:
-        general.add(Text(f".version = '{self.version}'"))
-
-    if hasattr(self, "storage"):
-        storage_root = self.storage.root
-        # general.add(f".storage = {storage_root}")
-        general.add(
-            Text.assemble(
-                ".path = ",
-                (storage_root, "dim"),
-                f"{str(self.path).removeprefix(storage_root)}",
-            )
+        two_column_items.append(Text.assemble(("version: ", "dim"), f"{self.version}"))
+    if hasattr(self, "space"):
+        two_column_items.append(Text.assemble(("space: ", "dim"), f"{self.space.name}"))
+    if hasattr(self, "branch"):
+        two_column_items.append(
+            Text.assemble(("branch: ", "dim"), f"{self.branch.name}")
+        )
+    if hasattr(self, "created_at") and self.created_at:
+        two_column_items.append(
+            Text.assemble(("created_at: ", "dim"), highlight_time(str(self.created_at)))
         )
     if hasattr(self, "created_by") and self.created_by:
-        general.add(
+        two_column_items.append(
             Text.assemble(
-                ".created_by = ",
+                ("created_by: ", "dim"),
                 (
                     self.created_by.handle
                     if self.created_by.name is None
@@ -151,15 +173,50 @@ def describe_general(self: Artifact | Collection, tree: Tree | None = None) -> T
                 ),
             )
         )
-    if hasattr(self, "created_at") and self.created_at:
+
+    # Add two-column items in pairs
+    for i in range(0, len(two_column_items), 2):
+        if i + 1 < len(two_column_items):
+            # Two items side by side
+            left_item = two_column_items[i]
+            right_item = two_column_items[i + 1]
+
+            # Create padded version by calculating the plain text length
+            left_plain_text = (
+                left_item.plain if hasattr(left_item, "plain") else str(left_item)
+            )
+            padding_needed = max(0, 35 - len(left_plain_text))
+            padding = " " * padding_needed
+
+            general.add(Text.assemble(left_item, padding, right_item))
+        else:
+            # Single item (odd number)
+            general.add(two_column_items[i])
+
+    # Single column items (long content)
+    if hasattr(self, "key") and self.key:
+        general.add(Text.assemble(("key: ", "dim"), f"{self.key}"))
+    if hasattr(self, "storage"):
+        storage_root = self.storage.root
         general.add(
-            Text.assemble(".created_at = ", highlight_time(str(self.created_at)))
+            Text.assemble(
+                ("storage location / path: ", "dim"),
+                (storage_root, "cyan3"),
+                f"{str(self.path).removeprefix(storage_root)}",
+            )
         )
-    if hasattr(self, "transform") and self.transform:
+    if hasattr(self, "description") and self.description is not None:
         general.add(
-            Text(
-                f".transform = '{self.transform.description}'",
-                style="cyan3",
+            Text.assemble(
+                ("description: ", "dim"),
+                f"{self.description}",
+            )
+        )
+    if hasattr(self, "transform") and self.transform is not None:
+        general.add(
+            Text.assemble(
+                ("transform: ", "dim"),
+                f"{self.transform.key}",
             )
         )