jarvisplot 1.3.2__tar.gz → 1.3.3__tar.gz

{jarvisplot-1.3.2 → jarvisplot-1.3.3}/JarvisPLOT.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: JarvisPLOT
-Version: 1.3.2
+Version: 1.3.3
 Summary: Jarvis-PLOT: YAML-driven plotting engine
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown

{jarvisplot-1.3.2 → jarvisplot-1.3.3}/JarvisPLOT.egg-info/SOURCES.txt

@@ -67,5 +67,6 @@ jarvisplot/utils/pathing.py
 tests/test_data_loader_contracts.py
 tests/test_docs_status_labels.py
 tests/test_figure_contracts.py
+tests/test_parse_data_metadata.py
 tests/test_pathing_contracts.py
 tests/test_template_json.py

{jarvisplot-1.3.2 → jarvisplot-1.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: JarvisPLOT
-Version: 1.3.2
+Version: 1.3.3
 Summary: Jarvis-PLOT: YAML-driven plotting engine
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown

{jarvisplot-1.3.2 → jarvisplot-1.3.3}/jarvisplot/Figure/config_runtime.py

@@ -39,11 +39,12 @@ def apply_figure_config(fig, info: Mapping) -> bool:
             return False
 
         if "style" in info:
-            fig.style = info["style"]
+            style_tokens = info["style"]
         else:
-            fig.style = ["a4paper_2x1"]
+            style_tokens = ["a4paper_2x1"]
+        fig.style = style_tokens
         fig.logger.debug("Figure style loaded")
-        if fig.style and "gambit" in str(fig.style[0]).lower():
+        if style_tokens and "gambit" in str(style_tokens[0]).lower():
             fig.mode = "gambit"
 
         if "frame" in info:

{jarvisplot-1.3.2 → jarvisplot-1.3.3}/jarvisplot/Figure/load_data.py

@@ -6,6 +6,28 @@ from ..utils.expression import eval_dataframe_expression
 from .profile_runtime import eval_series, grid_profiling, profiling, _preprofiling
 
 
+def _normalize_column_list(spec):
+    if spec is None:
+        return []
+    if isinstance(spec, dict):
+        for key in ("columns", "keep", "drop", "select", "retain", "value"):
+            if key in spec:
+                return _normalize_column_list(spec.get(key))
+        return []
+    if isinstance(spec, str):
+        text = spec.strip()
+        return [text] if text else []
+    if isinstance(spec, (list, tuple, set)):
+        out = []
+        for item in spec:
+            sval = str(item).strip()
+            if sval:
+                out.append(sval)
+        return out
+    sval = str(spec).strip()
+    return [sval] if sval else []
+
+
 def filter(df, condition, logger):
     try:
         if isinstance(condition, bool):
@@ -55,6 +77,53 @@ def addcolumn(df, adds, logger):
             )
         )
         return df               
+
+
+def keep_columns(df, spec, logger):
+    try:
+        cols = _normalize_column_list(spec)
+        if not cols:
+            return df
+        if isinstance(df, pd.DataFrame):
+            keep = [c for c in cols if c in df.columns]
+            missing = [c for c in cols if c not in df.columns]
+            if missing and logger:
+                logger.warning(f"keep_columns missing columns ignored -> {missing}")
+            if not keep:
+                return df.iloc[0:0].copy()
+            return df.loc[:, keep].copy(deep=False)
+        if hasattr(df, "select"):
+            try:
+                return df.select(cols)
+            except Exception:
+                return df
+        return df
+    except Exception as e:
+        if logger:
+            logger.warning(f"keep_columns failed for spec={spec}: {e}")
+        return df
+
+
+def drop_columns(df, spec, logger):
+    try:
+        cols = _normalize_column_list(spec)
+        if not cols:
+            return df
+        if isinstance(df, pd.DataFrame):
+            existing = [c for c in cols if c in df.columns]
+            if not existing:
+                return df
+            return df.drop(columns=existing, errors="ignore")
+        if hasattr(df, "drop"):
+            try:
+                return df.drop(cols)
+            except Exception:
+                return df
+        return df
+    except Exception as e:
+        if logger:
+            logger.warning(f"drop_columns failed for spec={spec}: {e}")
+        return df
         
 def sortby(df, expr, logger):
     try:

{jarvisplot-1.3.2 → jarvisplot-1.3.3}/jarvisplot/Figure/preprocessor_runtime.py

@@ -13,7 +13,7 @@ except Exception:
     pl = None
 
 from ..memtrace import memtrace_checkpoint, memtrace_object_inventory
-from .load_data import _preprofiling, addcolumn, filter as filter_df, grid_profiling, profiling, sortby
+from .load_data import _preprofiling, addcolumn, drop_columns, filter as filter_df, grid_profiling, keep_columns, profiling, sortby
 
 def resolve_source_data(preprocessor, source: Any, combine: str = "concat"):
     if isinstance(source, str):
@@ -130,7 +130,7 @@ def apply_transforms_impl(
                     method = str(profile_cfg.get("method", "bridson")).lower()
                     if "bin" in profile_cfg:
                         binv = profile_cfg.get("bin")
-                preprocessor._warn(
+                preprocessor._info(
                     "Runtime profile START:\n\t source \t-> {}\n\t step \t\t-> profile, \n\t method \t-> {}\n\t bin \t\t-> {}\n\t rows_before \t-> {}".format(
                         source_label or "<unknown>",
                         method,
@@ -183,7 +183,7 @@ def apply_transforms_impl(
                 profile_cfg = {"method": "grid"}
             before_rows = preprocessor._safe_nrows(df)
             binv = profile_cfg.get("bin", "default")
-            preprocessor._warn(
+            preprocessor._info(
                 "Runtime profile START: source \t-> {}\n\t step \t-> 'grid_profile,\n\t method \t-> 'grid',\n\t bin \t-> {},\n\t rows_before \t-> {}".format(
                     source_label or "<unknown>",
                     binv,
@@ -227,6 +227,10 @@ def apply_transforms_impl(
             df = sortby(df, trans["sortby"], preprocessor.logger)
         elif "add_column" in trans:
             df = addcolumn(df, trans["add_column"], preprocessor.logger)
+        elif "keep_columns" in trans:
+            df = keep_columns(df, trans.get("keep_columns"), preprocessor.logger)
+        elif "drop_columns" in trans:
+            df = drop_columns(df, trans.get("drop_columns"), preprocessor.logger)
 
         if prev_df is not df:
             collect_prev = preprocessor._should_collect_dataframe(prev_df)
@@ -384,7 +388,7 @@ def run_pipeline(preprocessor,
         src_label = preprocessor._runtime_source_label(source)
         if isinstance(source, str) and source in preprocessor._preprofile_alias_meta:
             meta = preprocessor._preprofile_alias_meta.get(source, {})
-            preprocessor._warn(
+            preprocessor._info(
                 "Runtime profile input:\n\t source \t-> {},\n uses preprofile alias:\n\t key \t\t-> {},\n\t origin \t-> {},\n\t cache_file \t-> {},\n\t rows_in \t-> {}.".format(
                     src_label,
                     meta.get("pre_key", "<unknown>")[:16] if isinstance(meta.get("pre_key"), str) else "<unknown>",
@@ -457,7 +461,7 @@ def run_pipeline(preprocessor,
                 cache_file = str((preprocessor.cache.data_dir / f"{key}.pkl").resolve())
             except Exception:
                 pass
-            preprocessor._warn(
+            preprocessor._info(
                 "Runtime profile cache STORE:\n\t source \t-> {},\n\t key \t\t-> {},\n\t cache_file \t-> {},\n\t rows \t\t-> {}.".format(
                     preprocessor._runtime_source_label(source),
                     key[:16],

{jarvisplot-1.3.2 → jarvisplot-1.3.3}/jarvisplot/cache_store.py

@@ -62,6 +62,13 @@ class ProjectCache:
             except Exception:
                 pass
 
+    def _info(self, msg: str) -> None:
+        if self.logger:
+            try:
+                self.logger.info(msg)
+            except Exception:
+                pass
+
     @staticmethod
     def _load_json(path: Path, default: Dict[str, Any]) -> Dict[str, Any]:
         try:

{jarvisplot-1.3.2 → jarvisplot-1.3.3}/jarvisplot/core.py

@@ -23,10 +23,17 @@ from .core_runtime import (
     plan_dataset_required_columns as runtime_plan_dataset_required_columns,
     prepare_project_layout as runtime_prepare_project_layout,
     prepare_usage_plan as runtime_prepare_usage_plan,
+    parse_hdf5_metadata_and_renew_yaml as runtime_parse_hdf5_metadata_and_renew_yaml,
     rename_hdf5_and_renew_yaml as runtime_rename_hdf5_and_renew_yaml,
 )
 
 
+def _format_console_record(record):
+    module = record["extra"].get("module", "No module")
+    message = str(record["message"]).replace("{", "{{").replace("}", "}}").replace("<", "\\<")
+    return f"\n\n<cyan>{module}</cyan> \n\t-> <green>{record['time']:MM-DD HH:mm:ss.SSS}</green> - [<level>{record['level']}</level>] >>> \n<level>{message}</level> "
+
+
 class JarvisPLOT():
     def __init__(self) -> None:
         self.variables  =   {}
@@ -53,7 +60,6 @@ class JarvisPLOT():
         self.load_cmaps()
 
         self.load_yaml()
-        self.prepare_project_layout()
 
         # sys.exit()
         if self.args.parse_data:
@@ -64,9 +70,10 @@ class JarvisPLOT():
             elif self.args.out is not None and self.args.inplace:
                 self.logger.error("Conflicting arguments: --out and --inplace. Please choose only one.")
                 sys.exit(2)
-            self.load_dataset(eager=True)
-            self.rename_hdf5_and_renew_yaml()
+            self.parse_hdf5_metadata_and_renew_yaml()
+            return
         else:
+            self.prepare_project_layout()
             self.load_dataset(eager=False)
             self.plan_dataset_required_columns()
             if self.shared is None:
@@ -316,7 +323,15 @@ class JarvisPLOT():
             except Exception:
                 pass
             return
-        self.parser_yaml(os.path.abspath(yaml_path))
+        resolved = os.path.abspath(yaml_path)
+        try:
+            self.parser_yaml(resolved)
+        except FileNotFoundError:
+            self.logger.error(f"YAML file not found: {resolved}")
+            sys.exit(2)
+        except OSError as e:
+            self.logger.error(f"Failed to open YAML file '{resolved}': {e}")
+            sys.exit(2)
 
     def init_logger(self) -> None:
         from datetime import datetime
@@ -335,8 +350,7 @@ class JarvisPLOT():
             return record["extra"].get("to_console", False)
 
         def custom_format(record):
-            module = record["extra"].get("module", "No module")
-            return f"\n\n<cyan>{module}</cyan> \n\t-> <green>{record['time']:MM-DD HH:mm:ss.SSS}</green> - [<level>{record['level']}</level>] >>> \n<level>{record['message']}</level> "
+            return _format_console_record(record)
 
         logger.add(
             sys.stdout,
@@ -368,3 +382,6 @@ class JarvisPLOT():
 
     def rename_hdf5_and_renew_yaml(self):
         return runtime_rename_hdf5_and_renew_yaml(self)
+
+    def parse_hdf5_metadata_and_renew_yaml(self):
+        return runtime_parse_hdf5_metadata_and_renew_yaml(self)

{jarvisplot-1.3.2 → jarvisplot-1.3.3}/jarvisplot/core_runtime.py

@@ -7,6 +7,7 @@ import yaml
 
 from .cache_store import ProjectCache
 from .data_loader import JP_ROW_IDX
+from .data_loader_hdf5 import scan_hdf5_leaf_metadata
 from .utils.pathing import resolve_project_path
 
 
@@ -130,7 +131,7 @@ def plan_dataset_required_columns(core) -> None:
         dts.set_required_columns(required if required else None, retained=retained if retained else None)
         if core.logger:
             sample = ", ".join(sorted(list(retained))[:12]) if retained else "<none>"
-            core.logger.warning(
+            core.logger.info(
                 "Dataset required columns planned:\n\t dataset \t-> {}\n\t required \t-> {}\n\t retained \t-> {}\n\t sample \t-> {}".format(
                     name,
                     len(required),
@@ -237,3 +238,82 @@ def rename_hdf5_and_renew_yaml(core):
             allow_unicode=True,
             width=100000,
         )
+
+
+def parse_hdf5_metadata_and_renew_yaml(core):
+    def _as_quoted_str(value: Any) -> _QuotedString:
+        return _QuotedString(str(value))
+
+    def _normalize_whitelist_as_quoted(raw):
+        if isinstance(raw, list):
+            return [_as_quoted_str(v) for v in raw if v is not None and str(v).strip()]
+        if isinstance(raw, str):
+            sval = raw.strip()
+            if sval:
+                return _as_quoted_str(sval)
+        return []
+
+    for dcfg in core.yaml.config.get("DataSet", []):
+        if isinstance(dcfg, dict):
+            dcfg.pop("is_gambit", None)
+            dcfg.pop("columnmap", None)
+
+    for dcfg in core.yaml.config.get("DataSet", []):
+        if not isinstance(dcfg, dict):
+            continue
+        if str(dcfg.get("type", "")).strip().lower() != "hdf5":
+            continue
+
+        name = str(dcfg.get("name", "")).strip()
+        project_cfg = core.yaml.config.get("project", {})
+        if not isinstance(project_cfg, dict):
+            project_cfg = {}
+        workdir = project_cfg.get("workdir", core.yaml.dir)
+        path = resolve_project_path(str(dcfg.get("path", "")).strip(), base_dir=workdir or core.yaml.dir)
+        group = str(dcfg.get("dataset", "")).strip() or None
+        old_columns = dcfg.get("columns", {})
+        if not isinstance(old_columns, dict):
+            old_columns = {}
+
+        metadata = scan_hdf5_leaf_metadata(str(path), group=group)
+        usable = [item for item in metadata if not str(item.get("path", "")).endswith("_isvalid")]
+        if not usable:
+            raise RuntimeError(
+                "No usable leaf datasets found for HDF5 parse-data: "
+                f"dataset='{name}', path='{path}', group='{group or '<root>'}'."
+            )
+
+        vmap_list = []
+        for ii, item in enumerate(usable):
+            source = str(item["path"])
+            target = f"Var{ii}@{name}"
+            vmap_list.append(
+                {
+                    "source": _as_quoted_str(source),
+                    "target": target,
+                }
+            )
+
+        columns_payload = {}
+        for k, v in old_columns.items():
+            if k in {"rename", "load_whitelist"}:
+                continue
+            columns_payload[k] = v
+        columns_payload["rename"] = vmap_list
+
+        if "load_whitelist" in old_columns:
+            columns_payload["load_whitelist"] = _normalize_whitelist_as_quoted(old_columns.get("load_whitelist"))
+
+        core.yaml.update_dataset(name, {"columns": columns_payload})
+
+    with open(core.args.out, "w", encoding="utf-8") as f1:
+        yaml.dump(
+            core.yaml.config,
+            f1,
+            Dumper=_QuotedDumper,
+            sort_keys=False,
+            default_flow_style=False,
+            indent=2,
+            allow_unicode=True,
+            width=100000,
+        )

{jarvisplot-1.3.2 → jarvisplot-1.3.3}/jarvisplot/data_loader.py

@@ -64,6 +64,7 @@ class DataSet():
     def __init__(self):
         self._file: Optional[str]   = None
         self.path:  Optional[str]   = None 
+        self.rootpath: Optional[str] = None
         self._type:  Optional[str]  = None
         self.base:  Optional[str]   = None
         self.keys:  Optional[List[str]]  = None 
@@ -86,6 +87,7 @@ class DataSet():
        
     def setinfo(self, dtinfo, rootpath, eager: bool = False, cache=None):
         self.cache = cache
+        self.rootpath = str(rootpath) if rootpath is not None else None
         raw_path = str(dtinfo['path'])
         resolved = resolve_project_path(raw_path, base_dir=rootpath or ".")
         self.file = str(resolved)
@@ -142,6 +144,18 @@ class DataSet():
             except Exception as e:
                 if self.logger:
                     self.logger.warning(f"Dataset '{self.name}' lazy metadata failed: {e}")
+        elif self.type == "parquet":
+            if pl is not None:
+                try:
+                    scan = pl.scan_parquet(self.path)
+                    self.keys = list(scan.collect_schema().names())
+                    if self.logger:
+                        self.logger.debug(
+                            f"Dataset '{self.name}' registered in lazy mode (parquet columns={len(self.keys)})."
+                        )
+                except Exception as e:
+                    if self.logger:
+                        self.logger.warning(f"Dataset '{self.name}' lazy metadata failed: {e}")
         else:
             if self.logger:
                 self.logger.debug(f"Dataset '{self.name}' registered in lazy mode.")
@@ -175,6 +189,8 @@ class DataSet():
             return self.data
         if self.type == "csv":
             self.load_csv()
+        elif self.type == "parquet":
+            self.load_parquet()
         elif self.type == "hdf5":
             self.load_hdf5()
         else:
@@ -240,6 +256,8 @@ class DataSet():
     def _summary_name(self) -> str:
         if self.type == "hdf5":
             return f" HDF5 loaded!\n\t name  -> {self.name}\n\t group -> {self.group}\n\t path  -> {self.path}"
+        if self.type == "parquet":
+            return f" Parquet loaded!\n\t name  -> {self.name}\n\t path  -> {self.path}"
         return f" CSV loaded!\n\t name  -> {self.name}\n\t path  -> {self.path}"
 
     def _debug_enabled(self) -> bool:
@@ -279,12 +297,18 @@ class DataSet():
         if self.data is not None:
             try:
                 if isinstance(self._materialized_manifest, dict):
-                    msg = self._materialized_summary(self._materialized_manifest)
+                    msg = self._materialized_summary(
+                        self._materialized_manifest,
+                        stats=self._materialized_numeric_bounds(),
+                    )
                 else:
                     msg = summary.dataframe_summary(self.data, name=self._summary_name())
             except Exception:
                 if isinstance(self._materialized_manifest, dict):
-                    msg = self._materialized_summary(self._materialized_manifest)
+                    msg = self._materialized_summary(
+                        self._materialized_manifest,
+                        stats=self._materialized_numeric_bounds(),
+                    )
                 else:
                     msg = f"Data backend: {type(self.data).__name__}"
             if self.cache is not None:
@@ -369,8 +393,11 @@ class DataSet():
     def _materialized_source_fingerprint(self):
         return hdf5.materialized_source_fingerprint(self)
 
-    def _materialized_summary(self, manifest: Dict[str, Any]) -> str:
-        return hdf5.materialized_summary(self, manifest)
+    def _materialized_summary(self, manifest: Dict[str, Any], stats: Optional[Dict[str, Dict[str, Any]]] = None) -> str:
+        return hdf5.materialized_summary(self, manifest, stats=stats)
+
+    def _materialized_numeric_bounds(self):
+        return runtime.materialized_numeric_bounds(self)
 
     @staticmethod
     def _sql_bool_ops(expr: Any) -> str:
@@ -430,6 +457,9 @@ class DataSet():
     def load_hdf5(self):
         return runtime.load_hdf5(self)
 
+    def load_parquet(self):
+        return runtime.load_parquet(self)
+
     def apply_is_valid_policy(self, kkeys): 
         if self.data is None:
             self.load(force=False)
@@ -473,7 +503,7 @@ class DataSet():
             sps = self.data.shape
             mask = self.data[isvalids].all(axis=1)
             self.data = self.data[mask]
-            self.logger.warning(
+            self.logger.info(
                 "DataSet Shape: \n\t Before filtering -> {}\n\t  After filtering -> {}".format(
                     sps, self.data.shape
                 )

{jarvisplot-1.3.2 → jarvisplot-1.3.3}/jarvisplot/data_loader_hdf5.py

@@ -3,7 +3,9 @@ from __future__ import annotations
 import os
 from typing import Any, Dict, List, Optional
 
-from .data_loader_summary import dataframe_summary_human_bytes
+import h5py
+
+from .data_loader_summary import dataframe_summary_human_bytes, format_table
 
 try:
     import polars as pl
@@ -118,6 +120,50 @@ def build_hdf5_whitelist(dataset) -> Optional[set[str]]:
     return with_isvalid
 
 
+def scan_hdf5_leaf_metadata(path: str, group: Optional[str] = None) -> List[Dict[str, Any]]:
+    """Return lightweight metadata for leaf datasets without reading dataset bodies."""
+
+    def _walk(node, prefix: str = "") -> None:
+        for name, child in node.items():
+            child_path = f"{prefix}/{name}" if prefix else name
+            if isinstance(child, h5py.Dataset):
+                metadata.append(
+                    {
+                        "path": child_path,
+                        "shape": tuple(getattr(child, "shape", ()) or ()),
+                        "dtype": str(getattr(child, "dtype", "NA")),
+                    }
+                )
+            elif isinstance(child, h5py.Group):
+                _walk(child, child_path)
+
+    group_name = str(group).strip() if group is not None else ""
+    metadata: List[Dict[str, Any]] = []
+
+    try:
+        with h5py.File(path, "r") as h5f:
+            if group_name:
+                if group_name not in h5f:
+                    raise RuntimeError(f"HDF5 group '{group_name}' not found in '{path}'.")
+                root = h5f[group_name]
+                if not isinstance(root, h5py.Group):
+                    raise RuntimeError(f"HDF5 group '{group_name}' in '{path}' is not a group.")
+                _walk(root, group_name)
+            else:
+                _walk(h5f, "")
+    except FileNotFoundError as e:
+        raise RuntimeError(f"HDF5 file not found: {path}") from e
+    except OSError as e:
+        raise RuntimeError(f"Unable to open HDF5 file '{path}': {e}") from e
+
+    if not metadata:
+        if group_name:
+            raise RuntimeError(f"HDF5 group '{group_name}' in '{path}' contains no leaf datasets.")
+        raise RuntimeError(f"No leaf datasets found in HDF5 file '{path}'.")
+
+    return metadata
+
+
 def shape_token(df) -> str:
     import pandas as pd
 
@@ -169,7 +215,7 @@ def materialized_cache_key(dataset):
     return dataset.cache.cache_key({"kind": "hdf5-polars-materialized", "source": source_fp})
 
 
-def materialized_summary(dataset, manifest: Dict[str, Any]) -> str:
+def materialized_summary(dataset, manifest: Dict[str, Any], stats: Optional[Dict[str, Dict[str, Any]]] = None) -> str:
     rows = manifest.get("rows", "NA")
     cols = manifest.get("cols", len(manifest.get("columns", [])))
     parts = manifest.get("parts", 0)
@@ -187,6 +233,71 @@ def materialized_summary(dataset, manifest: Dict[str, Any]) -> str:
     if manifest.get("columns"):
         lines.append("=== Materialized Columns ===")
         lines.append(", ".join(str(c) for c in manifest.get("columns", [])))
+    if isinstance(stats, dict) and stats:
+        lines.append("=== Materialized Stats ===")
+        stat_rows = []
+        df = getattr(dataset, "data", None)
+        schema_names = None
+        schema_dtypes = {}
+        if pl is not None and isinstance(df, pl.LazyFrame):
+            try:
+                schema = df.collect_schema()
+                if hasattr(schema, "names"):
+                    schema_names = set(str(x) for x in schema.names())
+                elif isinstance(schema, dict):
+                    schema_names = set(str(x) for x in schema.keys())
+                    schema_dtypes = {str(k): str(v) for k, v in schema.items()}
+                elif hasattr(schema, "items"):
+                    schema_names = set(str(x) for x in schema.keys())
+                    schema_dtypes = {str(k): str(v) for k, v in schema.items()}
+            except Exception:
+                schema_names = set()
+        elif pl is not None and isinstance(df, pl.DataFrame):
+            try:
+                schema_names = set(str(x) for x in df.columns)
+            except Exception:
+                schema_names = set()
+        elif hasattr(df, "columns"):
+            try:
+                schema_names = set(str(x) for x in getattr(df, "columns", []))
+            except Exception:
+                schema_names = set()
+        for col in manifest.get("columns", []):
+            if col not in stats:
+                continue
+            bounds = stats.get(col, {})
+            dtype = "NA"
+            nonnull_text = "NA"
+            if pl is not None and isinstance(df, pl.LazyFrame):
+                dtype = schema_dtypes.get(col, "NA")
+            elif schema_names is not None and col in schema_names and hasattr(df, "__getitem__"):
+                series = df[col]
+                dtype = str(series.dtype)
+                try:
+                    nonnull_pct = (float(series.notna().sum()) / float(len(series)) * 100.0) if len(series) else 0.0
+                except Exception:
+                    nonnull_pct = 0.0
+                nonnull_text = f"{nonnull_pct:.1f}%"
+            else:
+                dtype = str(type(bounds.get("min", None)).__name__)
+            stat_rows.append(
+                (
+                    str(col),
+                    dtype,
+                    nonnull_text,
+                    bounds.get("min", None),
+                    bounds.get("max", None),
+                )
+            )
+
+        if stat_rows:
+            lines.append(
+                format_table(
+                    ["name", "dtype", "nonnull%", "[min]", "[max]"],
+                    stat_rows,
+                    aligns=["left", "left", "right", "right", "right"],
+                )
+            )
     return "\n".join(lines)
 def sql_bool_ops(expr: Any) -> str:
     return str(expr).replace("&&", " AND ").replace("||", " OR ")