Fancier CTable.info printed representation

Author: FrancescAlted

src/blosc2/ctable.py

@@ -3099,40 +3099,39 @@ def info_items(self) -> list[tuple[str, object]]:
             if stats is None:
                 suffix = "size=n/a (sidecars not directly addressable)"
             else:
-                nbytes, cbytes, cratio = stats
-                suffix = (
-                    f"nbytes={format_nbytes_info(nbytes)}, "
-                    f"cbytes={format_nbytes_info(cbytes)}, cratio={cratio:.2f}x"
-                )
+                _, cbytes, _ = stats
+                suffix = f"cbytes={format_nbytes_info(cbytes)}"
             index_summary[idx.col_name] = f"[{idx.kind}{stale}{label}] {suffix}"
 
         items = [
             ("type", self.__class__.__name__),
             ("storage", storage_type),
             ("rows", self.nrows),
             ("columns", self.ncols),
-            ("capacity", len(self._valid_rows)),
             ("view", self.base is not None),
-            ("read_only", self._read_only),
             ("nbytes", format_nbytes_info(self.nbytes)),
             ("cbytes", format_nbytes_info(self.cbytes)),
-            ("cratio", f"{self.cratio:.2f}"),
+            ("cratio", f"{self.cratio:.1f}x"),
             ("schema", schema_summary),
             (
                 "valid_rows_mask",
-                f"nbytes={format_nbytes_info(self._valid_rows.nbytes)}, cbytes={format_nbytes_info(self._valid_rows.cbytes)}",
+                f"cbytes={format_nbytes_info(self._valid_rows.cbytes)}",
             ),
             ("indexes", index_summary if index_summary else "none"),
         ]
         if urlpath is not None:
             items.insert(2, ("urlpath", urlpath))
+            open_mode = self._storage.open_mode()
+            if open_mode is not None:
+                items.insert(3, ("open_mode", open_mode))
         return items
 
     @staticmethod
     def _dtype_info_label(dtype: np.dtype) -> str:
         """Return a compact dtype label for info reports."""
         if dtype.kind == "U":
-            return f"U{dtype.itemsize // 4}"
+            nchars = dtype.itemsize // 4
+            return f"U{nchars} (Unicode, max {nchars} chars)"
         if dtype.kind == "S":
             return f"S{dtype.itemsize}"
         return str(dtype)

src/blosc2/ctable_storage.py

@@ -80,6 +80,9 @@ def table_exists(self) -> bool:
     def is_read_only(self) -> bool:
         raise NotImplementedError
 
+    def open_mode(self) -> str | None:
+        raise NotImplementedError
+
     def delete_column(self, name: str) -> None:
         raise NotImplementedError
 
@@ -162,6 +165,9 @@ def table_exists(self):
     def is_read_only(self):
         return False
 
+    def open_mode(self) -> str | None:
+        return None
+
     def delete_column(self, name):
         raise RuntimeError("In-memory tables have no on-disk representation to mutate.")
 
@@ -269,6 +275,9 @@ def table_exists(self) -> bool:
     def is_read_only(self) -> bool:
         return self._mode == "r"
 
+    def open_mode(self) -> str | None:
+        return self._mode
+
     def create_column(self, name, *, dtype, shape, chunks, blocks, cparams, dparams):
         kwargs: dict[str, Any] = {
             "chunks": chunks,

tests/ctable/test_column.py

@@ -685,5 +685,64 @@ def test_column_repr_shows_preview_values():
     assert "..." in r
 
 
+def test_info_omits_capacity_and_read_only_for_in_memory_table():
+    t = CTable(Row, new_data=DATA20)
+    info = repr(t.info)
+    assert "capacity" not in info
+    assert "read_only" not in info
+    assert "open_mode" not in info
+
+
+def test_info_shows_open_mode_for_persistent_table(tmp_path):
+    path = str(tmp_path / "table.b2d")
+    t = CTable(Row, new_data=DATA20, urlpath=path, mode="w")
+    t.close()
+
+    opened = CTable.open(path)
+    info = repr(opened.info)
+    assert "capacity" not in info
+    assert "read_only" not in info
+    assert "open_mode       : r" in info
+    opened.close()
+
+
+def test_info_schema_expands_unicode_dtype_labels():
+    t = CTable(StrRow, new_data=[("alpha",), ("beta",)])
+    info = repr(t.info)
+    assert "U16 (Unicode, max 16 chars)" in info
+
+
+def test_info_valid_rows_mask_only_reports_cbytes():
+    t = CTable(Row, new_data=DATA20)
+    info = repr(t.info)
+    assert "valid_rows_mask : cbytes=" in info
+    assert "valid_rows_mask : nbytes=" not in info
+
+
+def test_info_indexes_only_report_cbytes(tmp_path):
+    @dataclass
+    class IndexedRow:
+        id: int = blosc2.field(blosc2.int32())
+        active: bool = blosc2.field(blosc2.bool(), default=True)
+
+    data = [(i, i % 2 == 0) for i in range(32)]
+    path = str(tmp_path / "indexed.b2d")
+    t = CTable(IndexedRow, new_data=data, urlpath=path, mode="w")
+    t.create_index("id", kind=blosc2.IndexKind.FULL)
+
+    info = repr(t.info)
+    index_block = info.split("indexes         :", 1)[1]
+    assert "cbytes=" in index_block
+    assert "nbytes=" not in index_block
+    assert "cratio=" not in index_block
+
+
+def test_info_cratio_uses_one_decimal_with_suffix():
+    t = CTable(Row, new_data=DATA20)
+    info = repr(t.info)
+    assert "cratio          :" in info
+    assert "x" in next(line for line in info.splitlines() if line.startswith("cratio"))
+
+
 if __name__ == "__main__":
     pytest.main(["-v", __file__])