Make .info more uniform throughout all classes that have it

Author: FrancescAlted

src/blosc2/b2view/model.py

@@ -341,8 +341,8 @@ def object_metadata(obj: Any) -> dict[str, Any]:
             return dict(obj.info_items)
         except Exception:
             return {
-                "rows": getattr(obj, "nrows", len(obj)),
-                "columns": getattr(obj, "ncols", len(getattr(obj, "col_names", []))),
+                "nrows": getattr(obj, "nrows", len(obj)),
+                "ncols": getattr(obj, "ncols", len(getattr(obj, "col_names", []))),
                 "schema": {
                     name: str(getattr(obj[name], "dtype", None)) for name in getattr(obj, "col_names", [])
                 },

src/blosc2/batch_array.py

@@ -948,7 +948,7 @@ def info_items(self) -> list:
             ("nitems", sum(batch_sizes)),
             ("nbytes", format_nbytes_info(self.nbytes)),
             ("cbytes", format_nbytes_info(self.cbytes)),
-            ("cratio", f"{self.cratio:.2f}"),
+            ("cratio", f"{self.cratio:.2f}x"),
             ("cparams", self.cparams),
             ("dparams", self.dparams),
         ]

src/blosc2/c2array.py

@@ -477,7 +477,7 @@ def info_items(self) -> list:
         items += [("dtype", self.dtype)]
         items += [("nbytes", format_nbytes_info(self.nbytes))]
         items += [("cbytes", format_nbytes_info(self.cbytes))]
-        items += [("cratio", f"{self.cratio:.2f}")]
+        items += [("cratio", f"{self.cratio:.2f}x")]
         items += [("cparams", self.cparams)]
         # items += [("dparams", self.dparams)]
         return items

src/blosc2/ctable.py

@@ -1207,33 +1207,41 @@ def info_items(self) -> list[tuple[str, object]]:
         spec = col_meta.spec if col_meta is not None else None
         chunks = getattr(raw, "chunks", None)
         blocks = getattr(raw, "blocks", None)
+
+        if self.is_list:
+            backend = "list"
+        elif self.is_varlen_scalar:
+            backend = "variable-length scalar"
+        elif self.is_dictionary:
+            backend = "dictionary"
+        else:
+            backend = "NDArray" if isinstance(raw, blosc2.NDArray) else type(raw).__name__
+
+        # Virtual computed columns are not stored; otherwise report the table's
+        # storage kind, mirroring CTable.info's persistent/in-memory wording.
+        if self.is_computed:
+            storage = "computed"
+        elif isinstance(table._storage, FileTableStorage):
+            storage = "persistent"
+        else:
+            storage = "in-memory"
+
+        # Block order mirrors CTable.info: identity, shape/grid, sizes, content,
+        # then compression params.
         items: list[tuple[str, object]] = [
             ("type", self.__class__.__name__),
             ("name", self._col_name),
-            ("nrows", len(self)),
-            ("shape", self.shape),
+            ("dtype", table._dtype_info_label(self.dtype, spec)),
+            ("backend", backend),
+            ("storage", storage),
         ]
+
+        items.append(("nrows", len(self)))
+        items.append(("shape", self.shape))
         if chunks is not None:
             items.append(("chunks", chunks))
         if blocks is not None:
             items.append(("blocks", blocks))
-        items.extend(
-            [
-                ("dtype", table._dtype_info_label(self.dtype, spec)),
-                ("computed", self.is_computed),
-                ("nullable", self.null_value is not None or getattr(spec, "nullable", False)),
-            ]
-        )
-
-        if self.is_list:
-            items.append(("storage", "list"))
-        elif self.is_varlen_scalar:
-            items.append(("storage", "variable-length scalar"))
-        elif self.is_dictionary:
-            items.append(("storage", "dictionary"))
-            items.append(("dictionary_size", len(raw.dictionary)))
-        else:
-            items.append(("storage", "ndarray" if isinstance(raw, blosc2.NDArray) else type(raw).__name__))
 
         nbytes = getattr(raw, "nbytes", None)
         cbytes = getattr(raw, "cbytes", None)
@@ -1243,11 +1251,12 @@ def info_items(self) -> list[tuple[str, object]]:
         if cbytes is not None:
             items.append(("cbytes", format_nbytes_info(cbytes)))
         if cratio is not None:
-            items.append(("cratio", f"{cratio:.2f}"))
+            items.append(("cratio", f"{cratio:.2f}x"))
+
+        items.append(("nullable", self.null_value is not None or getattr(spec, "nullable", False)))
+        if self.is_dictionary:
+            items.append(("dictionary_size", len(raw.dictionary)))
 
-        urlpath = getattr(raw, "urlpath", None)
-        if urlpath is not None:
-            items.append(("urlpath", urlpath))
         cparams = getattr(raw, "cparams", None)
         dparams = getattr(raw, "dparams", None)
         if cparams is not None:
@@ -2568,7 +2577,7 @@ def info_items(self) -> list[tuple[str, object]]:
             ("nrows", self.nrows),
             ("nbytes", format_nbytes_info(self.nbytes)),
             ("cbytes", format_nbytes_info(self.cbytes)),
-            ("cratio", f"{self.cratio:.1f}x"),
+            ("cratio", f"{self.cratio:.2f}x"),
             ("schema", schema_summary),
         ]
 
@@ -9303,17 +9312,15 @@ def info_items(self) -> list[tuple[str, object]]:
         items = [
             ("type", self.__class__.__name__),
             ("storage", storage_type),
-            ("rows", self.nrows),
-            ("columns", self.ncols),
             ("view", self.base is not None),
+            ("nrows", self.nrows),
+            ("ncols", self.ncols),
+            ("chunks", self.chunks if self.chunks is not None else "none (no fixed-size columns)"),
+            ("blocks", self.blocks if self.blocks is not None else "none (no fixed-size columns)"),
             ("nbytes", format_nbytes_info(self.nbytes)),
             ("cbytes", format_nbytes_info(self.cbytes)),
-            ("cratio", f"{self.cratio:.1f}x"),
+            ("cratio", f"{self.cratio:.2f}x"),
             ("schema", schema_summary),
-            (
-                "valid_rows_mask",
-                f"cbytes={format_nbytes_info(self._valid_rows.cbytes)}",
-            ),
             ("indexes", index_summary if index_summary else "none"),
         ]
         if urlpath is not None:

src/blosc2/list_array.py

@@ -649,7 +649,7 @@ def info_items(self) -> list:
             ("pending_rows", len(self._pending_cells) if self.spec.storage == "batch" else 0),
             ("nbytes", format_nbytes_info(self.nbytes)),
             ("cbytes", format_nbytes_info(self.cbytes)),
-            ("cratio", f"{self.cratio:.2f}"),
+            ("cratio", f"{self.cratio:.2f}x"),
         ]
 
     def to_cframe(self) -> bytes:

src/blosc2/ndarray.py

@@ -3935,7 +3935,7 @@ def info(self) -> InfoReporter:
         chunks  : (10,)
         blocks  : (10,)
         dtype   : int64
-        cratio  : 0.73
+        cratio  : 0.73x
         cparams : {'blocksize': 80,
         'clevel': 1,
         'codec': <Codec.ZSTD: 5>,
@@ -3968,7 +3968,7 @@ def info_items(self) -> list:
         items += [("dtype", self.dtype)]
         items += [("nbytes", format_nbytes_info(self.nbytes))]
         items += [("cbytes", format_nbytes_info(self.cbytes))]
-        items += [("cratio", f"{self.cratio:.2f}")]
+        items += [("cratio", f"{self.cratio:.2f}x")]
         items += [("cparams", self.cparams)]
         items += [("dparams", self.dparams)]
         return items

src/blosc2/objectarray.py

@@ -384,7 +384,7 @@ def info_items(self) -> list:
             ("chunk_cbytes_avg", f"{avg_chunk_cbytes:.2f}"),
             ("nbytes", format_nbytes_info(self.nbytes)),
             ("cbytes", format_nbytes_info(self.cbytes)),
-            ("cratio", f"{self.cratio:.2f}"),
+            ("cratio", f"{self.cratio:.2f}x"),
             ("cparams", self.cparams),
             ("dparams", self.dparams),
         ]

src/blosc2/schunk.py

@@ -535,7 +535,7 @@ def info(self) -> InfoReporter:
         typesize  : 1
         nbytes    : 24000
         cbytes    : 82
-        cratio    : 292.68
+        cratio    : 292.68x
         cparams   : CParams(codec=<Codec.ZSTD: 5>, codec_meta=0, clevel=1, use_dict=False, typesize=1,
                   : nthreads=8, blocksize=0, splitmode=<SplitMode.AUTO_SPLIT: 3>,
                   : filters=[<Filter.NOFILTER: 0>, <Filter.NOFILTER: 0>, <Filter.NOFILTER: 0>,
@@ -557,7 +557,7 @@ def info_items(self) -> list:
         items += [("typesize", self.typesize)]
         items += [("nbytes", format_nbytes_info(self.nbytes))]
         items += [("cbytes", format_nbytes_info(self.cbytes))]
-        items += [("cratio", f"{self.cratio:.2f}")]
+        items += [("cratio", f"{self.cratio:.2f}x")]
         items += [("cparams", self.cparams)]
         items += [("dparams", self.dparams)]
         return items

tests/ctable/test_column.py

@@ -5,6 +5,7 @@
 # SPDX-License-Identifier: BSD-3-Clause
 #######################################################################
 
+import re
 from dataclasses import dataclass
 
 import numpy as np
@@ -91,7 +92,7 @@ def test_column_info():
     assert "physical_length" not in text
     assert "logical_shape" not in text
     assert "table_physical_length" not in text
-    assert "storage" in text
+    assert "backend" in text
 
 
 def test_dictionary_column_info():
@@ -814,7 +815,7 @@ def test_info_shows_open_mode_for_persistent_table(tmp_path):
     info = repr(opened.info)
     assert "capacity" not in info
     assert "read_only" not in info
-    assert "open_mode       : r" in info
+    assert "open_mode : r" in info
     opened.close()
 
 
@@ -824,13 +825,6 @@ def test_info_schema_expands_unicode_dtype_labels():
     assert "U16 (Unicode)" 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:
@@ -843,17 +837,18 @@ class IndexedRow:
     t.create_index("id", kind=blosc2.IndexKind.FULL)
 
     info = repr(t.info)
-    index_block = info.split("indexes         :", 1)[1]
+    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():
+def test_info_cratio_uses_two_decimals_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"))
+    assert "cratio  :" in info
+    cratio_line = next(line for line in info.splitlines() if line.startswith("cratio"))
+    assert re.search(r"cratio\s+:\s+\d+\.\d{2}x", cratio_line)
 
 
 # -------------------------------------------------------------------

tests/test_b2view_model.py

@@ -65,7 +65,7 @@ def test_store_browser_metadata_and_previews(tmp_path):
 
         table_info = browser.get_info("/table")
         assert table_info.kind == "ctable"
-        assert table_info.metadata["rows"] == 6
+        assert table_info.metadata["nrows"] == 6
         preview = browser.preview("/table", max_rows=3, max_cols=1)
         assert preview["columns"] == ["x"]
         assert preview["hidden_columns"] == 1
@@ -83,7 +83,7 @@ def test_store_browser_supports_standalone_ctable(tmp_path):
         assert browser.list_children("/") == []
         info = browser.get_info("/")
         assert info.kind == "ctable"
-        assert info.metadata["rows"] == 4
+        assert info.metadata["nrows"] == 4
         preview = browser.preview("/", max_rows=2)
         np.testing.assert_array_equal(preview["data"]["x"], np.array([0, 1]))