arrscope 0.2.0__tar.gz → 0.3.0__tar.gz

arrscope-0.3.0/PKG-INFO

@@ -0,0 +1,158 @@
+Metadata-Version: 2.4
+Name: arrscope
+Version: 0.3.0
+Summary: Beautiful n-dimensional array visualization for Python
+Project-URL: Homepage, https://github.com/vizarray/arrscope
+Project-URL: Repository, https://github.com/vizarray/arrscope
+Author: arrscope contributors
+License: MIT
+Keywords: arrays,data-science,machine-learning,numpy,visualization
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Visualization
+Requires-Python: >=3.11
+Requires-Dist: numpy>=1.24
+Requires-Dist: rich>=13.0
+Provides-Extra: jax
+Requires-Dist: jax>=0.4; extra == 'jax'
+Provides-Extra: tf
+Requires-Dist: tensorflow>=2.12; extra == 'tf'
+Provides-Extra: torch
+Requires-Dist: torch>=2.0; extra == 'torch'
+Description-Content-Type: text/markdown
+
+# arrscope
+
+Visualize n-dimensional arrays in the terminal and Jupyter — with structural trees, tiled mosaics, and color-coded value maps.
+
+```python
+from arrscope import scope
+import numpy as np
+
+scope(np.random.rand(3, 4, 5))
+```
+
+## Features
+
+- **1D → 6D+**: Tiered visual grammar — lists, grids, trees, nested layers
+- **Named axes**: Attach semantics (`batch`, `heads`, `h`, `w`)
+- **Three color modes**:
+  - `dtype` — semantic colors by data type (blue=float, green=int, …)
+  - `heatmap` — diverging colormap (red → light → blue) by value
+  - `sparsity` — zeros as `·`, non-zeros in bold
+- **Two render styles**:
+  - `tree` (default) — hierarchical branch view with colored guide lines
+  - `mosaic` — all 2D sub-slices tiled side by side as numeric tables
+- **Method chaining**: `scope(arr, mode="heatmap").tree().mosaic()` — switch styles without re-specifying
+- **Stats overlay**: min, max, mean, std, zero%, NaN count (always shown)
+- **Head/tail truncation**: large dims show first/last N slices with `…` (default 20)
+- **Smart precision**: auto-detects significant figures for floats
+- **Terminal + Jupyter**: Rich ANSI + static HTML/CSS with dark mode auto-detect
+- **Multi-framework**: NumPy, PyTorch, TensorFlow, JAX, tinygrad (lazy imports)
+- **Zero config**: color always on, stats always on, auto-detect terminal vs notebook
+
+## Install
+
+```bash
+pip install arrscope
+```
+
+Only requires `numpy` + `rich`. Torch/TF/JAX/tinygrad are optional.
+
+## Quick start
+
+```python
+from arrscope import scope
+import numpy as np
+
+# Auto-detect — last 2 dims form the grid
+scope(np.random.rand(3, 4, 5))
+
+# Named axes
+scope(
+    np.random.rand(2, 8, 32, 32),
+    axes=['batch', 'heads', 'h', 'w'],
+    grid=['h', 'w'],
+    title='Attention heads',
+)
+
+# Custom grid dims
+scope(data, axes=['a', 'b', 'c', 'd'], grid=['a', 'b'])
+```
+
+## Color modes
+
+```python
+scope(arr, mode='dtype')        # default
+scope(arr, mode='heatmap')      # diverging colormap
+scope(arr, mode='sparsity')     # · for zeros, bold for non-zeros
+```
+
+## Render styles
+
+```python
+scope(arr)                        # tree (default) — click-to-expand layers
+scope(arr, render_style='mosaic') # all sub-slices tiled side by side
+
+# Method chaining for switching styles
+r = scope(arr, mode='heatmap')
+print(r.tree())
+print(r.mosaic())
+```
+
+## CLI
+
+```bash
+arrscope 3x4x5
+arrscope 2x3x32x32 --axes batch heads h w --grid h w --mode heatmap
+arrscope 20x4x5 --max-height 6
+```
+
+## Framework support
+
+```python
+import torch
+scope(torch.randn(2, 3, 4))
+
+import tensorflow as tf
+scope(tf.random.uniform((2, 3, 4)))
+
+import jax.numpy as jnp
+scope(jnp.array([[1, 2], [3, 4]]))
+
+from tinygrad import Tensor
+scope(Tensor.randn(3, 4))
+```
+
+## API
+
+```python
+scope(
+    arr,
+    axes=None,            # list[str] — name each dimension
+    grid=None,            # list[str | int] — which dims form the leaf grid
+    title=None,           # str — heading above the visualization
+    max_height=20,        # int | None — rows before truncation, None disables
+    fmt=None,             # str — format spec like '.4f'
+    mode='dtype',         # 'dtype' | 'heatmap' | 'sparsity'
+    render_style='tree',  # 'tree' | 'mosaic'
+)
+```
+
+## Development
+
+```bash
+git clone https://github.com/vizarray/arrscope
+cd arrscope
+uv sync
+uv run pytest
+uv run python main.py
+```
+
+## License
+
+MIT

arrscope-0.3.0/README.md

@@ -0,0 +1,131 @@
+# arrscope
+
+Visualize n-dimensional arrays in the terminal and Jupyter — with structural trees, tiled mosaics, and color-coded value maps.
+
+```python
+from arrscope import scope
+import numpy as np
+
+scope(np.random.rand(3, 4, 5))
+```
+
+## Features
+
+- **1D → 6D+**: Tiered visual grammar — lists, grids, trees, nested layers
+- **Named axes**: Attach semantics (`batch`, `heads`, `h`, `w`)
+- **Three color modes**:
+  - `dtype` — semantic colors by data type (blue=float, green=int, …)
+  - `heatmap` — diverging colormap (red → light → blue) by value
+  - `sparsity` — zeros as `·`, non-zeros in bold
+- **Two render styles**:
+  - `tree` (default) — hierarchical branch view with colored guide lines
+  - `mosaic` — all 2D sub-slices tiled side by side as numeric tables
+- **Method chaining**: `scope(arr, mode="heatmap").tree().mosaic()` — switch styles without re-specifying
+- **Stats overlay**: min, max, mean, std, zero%, NaN count (always shown)
+- **Head/tail truncation**: large dims show first/last N slices with `…` (default 20)
+- **Smart precision**: auto-detects significant figures for floats
+- **Terminal + Jupyter**: Rich ANSI + static HTML/CSS with dark mode auto-detect
+- **Multi-framework**: NumPy, PyTorch, TensorFlow, JAX, tinygrad (lazy imports)
+- **Zero config**: color always on, stats always on, auto-detect terminal vs notebook
+
+## Install
+
+```bash
+pip install arrscope
+```
+
+Only requires `numpy` + `rich`. Torch/TF/JAX/tinygrad are optional.
+
+## Quick start
+
+```python
+from arrscope import scope
+import numpy as np
+
+# Auto-detect — last 2 dims form the grid
+scope(np.random.rand(3, 4, 5))
+
+# Named axes
+scope(
+    np.random.rand(2, 8, 32, 32),
+    axes=['batch', 'heads', 'h', 'w'],
+    grid=['h', 'w'],
+    title='Attention heads',
+)
+
+# Custom grid dims
+scope(data, axes=['a', 'b', 'c', 'd'], grid=['a', 'b'])
+```
+
+## Color modes
+
+```python
+scope(arr, mode='dtype')        # default
+scope(arr, mode='heatmap')      # diverging colormap
+scope(arr, mode='sparsity')     # · for zeros, bold for non-zeros
+```
+
+## Render styles
+
+```python
+scope(arr)                        # tree (default) — click-to-expand layers
+scope(arr, render_style='mosaic') # all sub-slices tiled side by side
+
+# Method chaining for switching styles
+r = scope(arr, mode='heatmap')
+print(r.tree())
+print(r.mosaic())
+```
+
+## CLI
+
+```bash
+arrscope 3x4x5
+arrscope 2x3x32x32 --axes batch heads h w --grid h w --mode heatmap
+arrscope 20x4x5 --max-height 6
+```
+
+## Framework support
+
+```python
+import torch
+scope(torch.randn(2, 3, 4))
+
+import tensorflow as tf
+scope(tf.random.uniform((2, 3, 4)))
+
+import jax.numpy as jnp
+scope(jnp.array([[1, 2], [3, 4]]))
+
+from tinygrad import Tensor
+scope(Tensor.randn(3, 4))
+```
+
+## API
+
+```python
+scope(
+    arr,
+    axes=None,            # list[str] — name each dimension
+    grid=None,            # list[str | int] — which dims form the leaf grid
+    title=None,           # str — heading above the visualization
+    max_height=20,        # int | None — rows before truncation, None disables
+    fmt=None,             # str — format spec like '.4f'
+    mode='dtype',         # 'dtype' | 'heatmap' | 'sparsity'
+    render_style='tree',  # 'tree' | 'mosaic'
+)
+```
+
+## Development
+
+```bash
+git clone https://github.com/vizarray/arrscope
+cd arrscope
+uv sync
+uv run pytest
+uv run python main.py
+```
+
+## License
+
+MIT

arrscope-0.3.0/examples/renders.py

@@ -0,0 +1,71 @@
+"""arrscope render style examples.
+
+Run this file to see both render styles in action.
+Use method chaining to switch styles without re-specifying params.
+
+Usage:
+    uv run python examples/renders.py
+"""
+
+import numpy as np
+
+from arrscope import scope
+
+# ── data ──────────────────────────────────────────────────────────────
+arr_3d = np.arange(60).reshape(3, 4, 5).astype(float)
+eye = np.eye(8)
+sparse = np.zeros((6, 8), dtype=float)
+sparse[0, 0] = 1.5
+sparse[2, 3] = -2.3
+sparse[4, 5] = 42.0
+sparse[5, 7] = 0.7
+
+
+# ── individual calls ──────────────────────────────────────────────────
+print("=" * 56)
+print("1  tree  — hierarchical branch view (default)")
+print("=" * 56)
+print(scope(arr_3d, render_style="tree"))
+
+print("=" * 56)
+print("2  mosaic  — numeric tables tiled side by side")
+print("=" * 56)
+print(scope(arr_3d, render_style="mosaic"))
+
+
+# ── method chaining ───────────────────────────────────────────────────
+print("=" * 56)
+print("3  method chaining  —  scope().tree() / .mosaic()")
+print("=" * 56)
+
+r = scope(eye, title="Identity", mode="heatmap")
+
+print("--- .tree() ---")
+print(r.tree())
+
+print("--- .mosaic() ---")
+print(r.mosaic())
+
+
+# ── all three modes with mosaic ──────────────────────────────────────
+print("=" * 56)
+print("4  mosaic + all three color modes")
+print("=" * 56)
+
+print("--- dtype ---")
+print(scope(sparse, render_style="mosaic", mode="dtype"))
+
+print("--- heatmap ---")
+print(scope(sparse, render_style="mosaic", mode="heatmap"))
+
+print("--- sparsity ---")
+print(scope(sparse, render_style="mosaic", mode="sparsity"))
+
+
+# ── large array in mosaic ────────────────────────────────────────────
+print("=" * 56)
+print("5  large array —  (8, 8, 8)  as mosaic + heatmap")
+print("=" * 56)
+print(scope(np.random.rand(8, 8, 8), render_style="mosaic", mode="heatmap"))
+
+print("\nDone!")

{arrscope-0.2.0 → arrscope-0.3.0}/main.py

@@ -62,8 +62,8 @@ print(scope(sparse, mode="sparsity"))
 print("\n1️⃣2️⃣  HEATMAP + 3D + global stats")
 print(scope(np.random.rand(2, 3, 4), mode="heatmap"))
 
-print("\n1️⃣3️⃣  STATS OFF")
-print(scope(np.eye(5), stats=False))
+print("\n1️⃣3️⃣  TRUNCATION OFF (max_height=None)")
+print(scope(np.arange(60).reshape(3, 4, 5).astype(float), max_height=None))
 
 print("\n1️⃣4️⃣  MOSAIC — 3×4×5 tiled (no tree)")
 arr = np.arange(60).reshape(3, 4, 5).astype(float)

{arrscope-0.2.0 → arrscope-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "arrscope"
-version = "0.2.0"
+version = "0.3.0"
 description = "Beautiful n-dimensional array visualization for Python"
 readme = "README.md"
 license = { text = "MIT" }

{arrscope-0.2.0 → arrscope-0.3.0}/src/arrscope/_api.py

@@ -1,8 +1,5 @@
-from __future__ import annotations
-
 from typing import Literal
 
-from arrscope._config import config
 from arrscope._format import format_value
 from arrscope._layout import build_layout, compute_stats
 from arrscope._types import VizOutput
@@ -19,14 +16,10 @@ def scope(
     axes: list[str] | None = None,
     grid: list[str | int] | None = None,
     title: str | None = None,
-    max_width: int | None = None,
-    max_height: int | None = None,
+    max_height: int | None = 20,
     fmt: str | None = None,
-    color: bool | None = None,
-    style: Literal["auto", "terminal", "html"] = "auto",
     mode: Mode | None = None,
     render_style: RenderStyle | None = None,
-    stats: bool | None = None,
 ) -> VizOutput:
     """Visualize an n-dimensional array in the terminal and/or Jupyter.
 
@@ -45,41 +38,30 @@ def scope(
         title: Optional heading displayed above the visualization.
         max_height: Max tree rows before truncation. The first half and
             last half of children are shown with ``... (N more)`` in between.
-        max_width: Max character width (terminal only). Not yet enforced.
+            Defaults to 20. Set to ``None`` to disable truncation.
         fmt: Format spec for float values, e.g. ``".4f"``, ``".2e"``.
             Auto-detected from value range when not set.
-        color: Enable or disable ANSI / CSS color output.
-            Defaults to ``True``.
-        style: Output target. ``"auto"`` detects Jupyter and renders
-            HTML there, ANSI elsewhere. ``"terminal"`` forces ANSI,
-            ``"html"`` forces HTML.
         mode: Colorization strategy:
 
-            - ``"dtype"`` — Semantic colors by data type (blue=float,
-              green=int, magenta=bool, yellow=str, red=complex).
+            - ``"dtype"`` (default) — Semantic colors by data type
+              (blue=float, green=int, magenta=bool, yellow=str).
               Negative values tinted red, positive tinted blue.
             - ``"heatmap"`` — Diverging colormap (red → light → blue)
-              scaled to the array's global min/max range. Best for
-              spotting value patterns.
+              scaled to the array's global min/max range.
             - ``"sparsity"`` — Zeros rendered as dim ``·``, non-zero
-              values in bold. Best for inspecting sparse or masked arrays.
-
-        render_style: Visual layout style:
+              values in bold.
 
-            - ``"tree"`` (default) — Hierarchical branch view with 2D
-              grids nested at the leaves. Each depth level gets a
-              distinct branch color for readability.
-            - ``"mosaic"`` — All 2D sub-slices tiled side by side in a
-              contact-sheet grid. Best for comparing slices in 3D/4D
-              arrays (batches, attention heads, channels).
+        render_style: Visual layout:
 
-        stats: Show summary statistics below the tree (min, max, mean,
-            std, zeros %, NaN count). Defaults to ``True``.
+            - ``"tree"`` (default) — Hierarchical branch view with
+              click-to-expand nested layers.
+            - ``"mosaic"`` — All 2D sub-slices tiled side by side as
+              numeric tables.
 
     Returns:
-        A ``VizOutput`` object with ``.ansi`` (str) and ``.html`` (str)
-        attributes. In Jupyter it auto-displays via ``_repr_html_``.
-        In the terminal, ``print()`` or ``str()`` renders the ANSI output.
+        A ``VizOutput`` with ``.ansi`` and ``.html`` attributes.
+        Use ``.tree()`` or ``.mosaic()`` to switch render styles
+        without re-specifying parameters.
 
     Examples:
         >>> import numpy as np
@@ -96,12 +78,8 @@ def scope(
     """
     arr_np = to_numpy(arr)
 
-    color = config.color if color is None else color
-    max_width = max_width or config.max_width
-    max_height = max_height or config.max_height
-    mode = mode or config.mode
-    rs = render_style or config.render_style
-    show_stats = config.stats if stats is None else stats
+    mode = mode or "dtype"
+    rs = render_style or "tree"
 
     if mode not in ("dtype", "heatmap", "sparsity"):
         raise ValueError(f"Unknown mode '{mode}'. Expected one of: dtype, heatmap, sparsity")
@@ -110,37 +88,25 @@ def scope(
         raise ValueError(f"Unknown render_style '{rs}'. Expected one of: tree, mosaic")
 
     grid_dims = _resolve_grid_dims(arr_np, axes, grid)
+    use_html = _in_jupyter()
 
-    node = build_layout(
-        arr_np,
-        grid_dims=grid_dims,
-        max_height=max_height,
-    )
-
-    global_stats = compute_stats(arr_np) if (show_stats or mode == "heatmap") else None
-    if global_stats and show_stats:
-        node.stats = global_stats
-
-    use_html = _use_html(style)
-    use_terminal = _use_terminal(style)
+    def _render(style: str) -> VizOutput:
+        node = build_layout(arr_np, grid_dims=grid_dims, max_height=max_height)
+        gs = compute_stats(arr_np)
+        if gs:
+            node.stats = gs
 
-    output = VizOutput()
+        out = VizOutput(_rerender=_render)
+        if use_html:
+            out.html = _wrap_html(render_html(node, mode=mode, global_stats=gs, render_style=style), title)
+        out.ansi = _wrap_ansi(render_terminal(node, mode=mode, global_stats=gs, render_style=style), title)
+        return out
 
-    if use_html:
-        output.html = _wrap_html(
-            render_html(node, color=color, mode=mode, global_stats=global_stats, render_style=rs), title
-        )
-
-    if use_terminal:
-        output.ansi = _wrap_ansi(
-            render_terminal(node, color=color, mode=mode, global_stats=global_stats, render_style=rs), title
-        )
-
-    return output
+    return _render(rs)
 
 
 def _resolve_grid_dims(
-    arr: np.ndarray,
+    arr,
     axes: list[str] | None,
     grid: list[str | int] | None,
 ) -> list[int] | None:
@@ -166,22 +132,6 @@ def _resolve_grid_dims(
     return resolved
 
 
-def _use_html(style: str) -> bool:
-    if style == "html":
-        return True
-    if style == "terminal":
-        return False
-    return _in_jupyter()
-
-
-def _use_terminal(style: str) -> bool:
-    if style == "terminal":
-        return True
-    if style == "html":
-        return False
-    return True
-
-
 def _in_jupyter() -> bool:
     try:
         from IPython import get_ipython

arrscope-0.3.0/src/arrscope/_config.py

@@ -0,0 +1,10 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class Config:
+    mode: str = "dtype"
+    render_style: str = "tree"  # tree | mosaic
+
+
+config: Config = Config()

{arrscope-0.2.0 → arrscope-0.3.0}/src/arrscope/_types.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from collections.abc import Callable
 from dataclasses import dataclass, field
 
 import numpy as np
@@ -18,11 +19,15 @@ class VizNode:
     stats: dict | None = None
 
 
+_RerenderFn = Callable[[str], "VizOutput"]
+
+
 @dataclass
 class VizOutput:
     html: str = ""
     ansi: str = ""
     metadata: dict = field(default_factory=dict)
+    _rerender: _RerenderFn | None = None
 
     def _repr_html_(self) -> str:
         return self.html
@@ -37,3 +42,9 @@ class VizOutput:
 
     def __repr__(self) -> str:
         return self.ansi
+
+    def tree(self) -> VizOutput:
+        return self._rerender("tree") if self._rerender else self
+
+    def mosaic(self) -> VizOutput:
+        return self._rerender("mosaic") if self._rerender else self

{arrscope-0.2.0 → arrscope-0.3.0}/src/arrscope/renderers/html.py

@@ -10,7 +10,6 @@ from arrscope._types import VizNode
 
 def render_html(
     node: VizNode,
-    color: bool = True,
     mode: str = "dtype",
     global_stats: dict | None = None,
     render_style: str = "tree",
@@ -94,13 +93,6 @@ def _css() -> str:
 }
 .arrscope-row { display: flex; flex-wrap: wrap; gap: 12px; }
 .arrscope-tree { margin-left: 16px; }
-.arrscope-level-0 { }
-.arrscope-level-1 { border-left: 2px solid #00bcd4; padding-left: 8px; }
-.arrscope-level-2 { border-left: 2px solid #4caf50; padding-left: 8px; }
-.arrscope-level-3 { border-left: 2px solid #ffc107; padding-left: 8px; }
-.arrscope-level-4 { border-left: 2px solid #e91e63; padding-left: 8px; }
-.arrscope-level-5 { border-left: 2px solid #9c27b0; padding-left: 8px; }
-.arrscope-level-6 { border-left: 2px solid #2196f3; padding-left: 8px; }
 .arrscope-ellipsis { color: #999; font-style: italic; margin: 2px 0; }
 .arrscope-header {
     font-weight: 600;
@@ -133,12 +125,6 @@ details.arrscope-details[open] > summary {
     .arrscope-shape { color: #777; }
     .arrscope-stats { color: #999; }
     .arrscope-header { border-bottom-color: #444; }
-    .arrscope-level-1 { border-left-color: #26c6da; }
-    .arrscope-level-2 { border-left-color: #66bb6a; }
-    .arrscope-level-3 { border-left-color: #ffd54f; }
-    .arrscope-level-4 { border-left-color: #f06292; }
-    .arrscope-level-5 { border-left-color: #ab47bc; }
-    .arrscope-level-6 { border-left-color: #42a5f5; }
 }
 """
 
@@ -169,7 +155,7 @@ def _render_node_html(
     if not node.children and node.truncated:
         return f'<div class="arrscope-ellipsis">{html_mod.escape(node.label)}</div>'
 
-    is_large_tree = depth > 0 and len(node.children) > 4
+    is_large_tree = depth > 0 and len(node.children) > 0
 
     parts: list[str] = []
     if depth == 0:
@@ -184,8 +170,7 @@ def _render_node_html(
         parts.append(
             f"<summary>{html_mod.escape(node.label or _format_header(node))}</summary>"
         )
-        level_class = f"arrscope-level-{(depth + 1) % 7}"
-        parts.append(f'<div class="arrscope-tree {level_class}">')
+        parts.append('<div class="arrscope-tree">')
 
     for child in node.children:
         parts.append(_render_node_html(child, depth + 1, mode, global_stats))

{arrscope-0.2.0 → arrscope-0.3.0}/src/arrscope/renderers/terminal.py

@@ -17,24 +17,23 @@ BRANCH_COLORS = ["grey50", "cyan", "green", "yellow", "magenta", "blue"]
 
 def render_terminal(
     node: VizNode,
-    color: bool = True,
     mode: str = "dtype",
     global_stats: dict | None = None,
     render_style: str = "tree",
 ) -> str:
     from rich.console import Console
 
-    console = Console(width=120, color_system="truecolor" if color else None)
+    console = Console(width=120, color_system="truecolor")
     parts: list = []
 
     if render_style == "mosaic":
-        body = _render_mosaic(node, color, mode, global_stats)
+        body = _render_mosaic(node, mode, global_stats)
     else:
-        body = _render_node(node, 0, color, mode, global_stats)
+        body = _render_node(node, 0, mode, global_stats)
     parts.append(body)
 
     if global_stats and node.stats:
-        parts.append(_stats_text(global_stats, color))
+        parts.append(_stats_text(global_stats))
 
     with console.capture() as capture:
         for p in parts:
@@ -53,7 +52,6 @@ def _collect_leaves(node: VizNode) -> list[VizNode]:
 
 def _render_mosaic(
     node: VizNode,
-    color: bool,
     mode: str,
     global_stats: dict | None,
 ) -> Columns | Text:
@@ -64,14 +62,14 @@ def _render_mosaic(
     tables: list[Table] = []
     for leaf in leaves:
         if leaf.grid_data is not None:
-            t = _render_grid(leaf.grid_data, leaf.label, color, mode, global_stats)
+            t = _render_grid(leaf.grid_data, leaf.label, mode, global_stats)
             tables.append(t)
 
     return Columns(tables, equal=True, expand=False)
 
 
-def _stats_text(stats: dict, color: bool) -> Text:
-    dim = Style(dim=True, color="grey50") if color else Style(dim=True)
+def _stats_text(stats: dict) -> Text:
+    dim = Style(dim=True, color="grey50")
     t = Text()
     fmt = ".4f" if stats.get("dtype", "").startswith(("float", "int")) else ".4f"
 
@@ -99,12 +97,11 @@ def _stats_text(stats: dict, color: bool) -> Text:
 def _render_node(
     node: VizNode,
     depth: int,
-    color: bool,
     mode: str,
     global_stats: dict | None,
 ) -> Tree | Table | Text:
     if node.grid_data is not None:
-        return _render_grid(node.grid_data, node.label, color, mode, global_stats)
+        return _render_grid(node.grid_data, node.label, mode, global_stats)
 
     if not node.children and node.truncated:
         t = Text(f"  {node.label}")
@@ -112,25 +109,22 @@ def _render_node(
         return t
 
     guide_color = BRANCH_COLORS[(depth) % len(BRANCH_COLORS)]
-    guide = Style(dim=True, color=guide_color) if color else Style(dim=True)
+    guide = Style(dim=True, color=guide_color)
 
-    tree = Tree(
-        _make_header(node, color),
-        guide_style=guide,
-    )
+    tree = Tree(_make_header(node), guide_style=guide)
     for child in node.children:
-        child_renderable = _render_node(child, depth + 1, color, mode, global_stats)
+        child_renderable = _render_node(child, depth + 1, mode, global_stats)
         tree.add(child_renderable)
     return tree
 
 
-def _make_header(node: VizNode, color: bool) -> Text:
+def _make_header(node: VizNode) -> Text:
     parts = []
     if node.label:
-        parts.append((node.label, "bold" if color else ""))
+        parts.append((node.label, "bold"))
     shape_str = " × ".join(str(s) for s in node.shape)
     if shape_str:
-        dim_style = Style(dim=True, color="grey50") if color else Style(dim=True)
+        dim_style = Style(dim=True, color="grey50")
         parts.append((f" ({shape_str})", dim_style))
     t = Text()
     for text, style in parts:
@@ -141,7 +135,6 @@ def _make_header(node: VizNode, color: bool) -> Text:
 def _render_grid(
     data: np.ndarray,
     label: str,
-    color: bool,
     mode: str,
     global_stats: dict | None,
 ) -> Text | Table:
@@ -149,21 +142,20 @@ def _render_grid(
         return Text(format_value(data.item()))
 
     if data.ndim == 1:
-        return _render_1d(data, color, mode, global_stats)
+        return _render_1d(data, mode, global_stats)
 
-    return _render_2d(data, label, color, mode, global_stats)
+    return _render_2d(data, label, mode, global_stats)
 
 
 def _render_1d(
     data: np.ndarray,
-    color: bool,
     mode: str,
     global_stats: dict | None,
 ) -> Text:
     items = []
     for v in data:
         text = _format_cell(v, mode)
-        items.append(_style_value(text, v, color, mode, global_stats))
+        items.append(_style_value(text, v, mode, global_stats))
 
     t = Text("[")
     for i, item in enumerate(items):
@@ -177,7 +169,6 @@ def _render_1d(
 def _render_2d(
     data: np.ndarray,
     label: str,
-    color: bool,
     mode: str,
     global_stats: dict | None,
 ) -> Table:
@@ -199,7 +190,6 @@ def _render_2d(
             _style_value(
                 _format_cell(data[row_idx, col_idx], mode),
                 data[row_idx, col_idx],
-                color,
                 mode,
                 global_stats,
             )
@@ -229,13 +219,9 @@ def _is_zero(val) -> bool:
 def _style_value(
     text: str,
     val,
-    color: bool,
     mode: str,
     global_stats: dict | None,
 ) -> Text:
-    if not color:
-        return Text(text)
-
     if mode == "heatmap":
         cell_style = _heatmap_color(val, global_stats)
     elif mode == "sparsity":

{arrscope-0.2.0 → arrscope-0.3.0}/uv.lock

@@ -18,7 +18,7 @@ wheels = [
 
 [[package]]
 name = "arrscope"
-version = "0.1.0"
+version = "0.2.0"
 source = { editable = "." }
 dependencies = [
     { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.12'" },

arrscope-0.2.0/PKG-INFO

@@ -1,185 +0,0 @@
-Metadata-Version: 2.4
-Name: arrscope
-Version: 0.2.0
-Summary: Beautiful n-dimensional array visualization for Python
-Project-URL: Homepage, https://github.com/vizarray/arrscope
-Project-URL: Repository, https://github.com/vizarray/arrscope
-Author: arrscope contributors
-License: MIT
-Keywords: arrays,data-science,machine-learning,numpy,visualization
-Classifier: Development Status :: 3 - Alpha
-Classifier: Intended Audience :: Science/Research
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Topic :: Scientific/Engineering :: Visualization
-Requires-Python: >=3.11
-Requires-Dist: numpy>=1.24
-Requires-Dist: rich>=13.0
-Provides-Extra: jax
-Requires-Dist: jax>=0.4; extra == 'jax'
-Provides-Extra: tf
-Requires-Dist: tensorflow>=2.12; extra == 'tf'
-Provides-Extra: torch
-Requires-Dist: torch>=2.0; extra == 'torch'
-Description-Content-Type: text/markdown
-
-# arrscope
-
-Beautiful n-dimensional array visualization for Python — in the terminal and Jupyter.
-
-```python
-from arrscope import scope
-import numpy as np
-
-scope(np.random.rand(2, 3, 8, 8), axes=['batch', 'heads', 'h', 'w'])
-```
-
-```
-├── [0] (3, 8, 8)
-│   ├── [0,0]: 8×8 grid
-│   ├── [0,1]: 8×8 grid
-│   └── [0,2]: 8×8 grid
-└── [1] (3, 8, 8)
-    ...
-  min=0.001  max=0.999  mean=0.5  std=0.29  zeros=0.0%
-```
-
-## Features
-
-- **1D → 6D+**: Tiered visual grammar — lists, grids, trees, collapsed hierarchies
-- **Named axes**: Attach semantics to dimensions (`batch`, `heads`, `h`, `w`)
-- **Configurable grid**: Pick which axes form the leaf 2D matrix
-- **Three color modes**:
-  - `dtype` — semantic colors by data type (float=blue, int=green, bool=magenta, …)
-  - `heatmap` — diverging colormap (red→light→blue) by value magnitude
-  - `sparsity` — zeros as `·`, non-zeros highlighted in bold
-- **Stats overlay**: min, max, mean, std, zero%, NaN count
-- **Head/tail truncation**: large dimensions show first/last N slices with `…`
-- **Smart precision**: auto-detects significant figures for floats
-- **Terminal + Jupyter**: Rich ANSI output + static HTML/CSS with dark mode
-- **Multi-framework**: NumPy, PyTorch, TensorFlow, JAX (lazy imports, no hard deps)
-
-## Install
-
-```bash
-pip install arrscope
-```
-
-Only requires `numpy` + `rich`. Torch/TF/JAX are optional — pass any array type, it just works.
-
-## Quick start
-
-```python
-from arrscope import scope
-import numpy as np
-
-# Auto-detect — last 2 dims form the grid
-scope(np.random.rand(3, 4, 5))
-
-# Named axes for clarity
-scope(
-    np.random.rand(2, 8, 32, 32),
-    axes=['batch', 'heads', 'h', 'w'],
-    grid=['h', 'w'],
-    title='Attention heads',
-)
-
-# Pick any dims as the leaf grid
-scope(data, axes=['a', 'b', 'c', 'd'], grid=['a', 'b'])
-```
-
-## Color modes
-
-```python
-scope(arr, mode='dtype')        # default — blue floats, green ints, etc.
-scope(arr, mode='heatmap')      # diverging colormap by value
-scope(arr, mode='sparsity')     # · for zeros, bold for non-zeros
-```
-
-## Stats overlay
-
-Stats are shown by default. Hide with:
-
-```python
-scope(arr, stats=False)
-```
-
-Shows: `min=0.0  max=1.0  mean=0.5  std=0.29  zeros=12.5%`
-
-## Truncation
-
-```python
-scope(np.random.rand(100, 32, 32), max_height=8)
-```
-
-Shows first 4 + last 4 slices with `… (92 more)` in between.
-
-## Custom formatting
-
-```python
-scope(arr, fmt='.2f')          # fixed precision
-scope(arr, color=False)        # monochrome
-scope(arr, style='html')       # force HTML output in terminal
-```
-
-## CLI
-
-```bash
-# Install globally (ships with the library)
-pip install arrscope
-
-# Use from anywhere
-arrscope 3x4x5
-arrscope 2x3x32x32 --axes batch heads h w --grid h w --mode heatmap
-arrscope 20x4x5 --max-height 6 --no-stats
-```
-
-## Framework support
-
-Pass any array-like — conversion is automatic:
-
-```python
-import torch
-scope(torch.randn(2, 3, 4))          # PyTorch
-
-import tensorflow as tf
-scope(tf.random.uniform((2, 3, 4)))  # TensorFlow
-
-import jax.numpy as jnp
-scope(jnp.array([[1, 2], [3, 4]]))  # JAX
-```
-
-## API
-
-```python
-scope(
-    arr,                          # np.ndarray | torch.Tensor | tf.Tensor | jax.Array
-    axes=None,                    # list[str] — name each dimension
-    grid=None,                    # list[str | int] — which dims form the leaf grid
-    title=None,                   # str — heading above the visualization
-    max_width=None,               # int — max characters wide
-    max_height=None,              # int — max rows before truncation
-    fmt=None,                     # str — format spec like '.4f'
-    color=True,                   # bool — enable/disable color
-    mode='dtype',                 # 'dtype' | 'heatmap' | 'sparsity'
-    stats=True,                   # bool — show min/max/mean/std/zeros
-    style='auto',                 # 'auto' | 'terminal' | 'html'
-)
-```
-
-## Development
-
-```bash
-git clone https://github.com/vizarray/arrscope
-cd arrscope
-uv sync
-uv run pytest
-uv run python main.py          # demo script
-uv run jupyter notebook test.ipynb  # notebook demo
-```
-
-## License
-
-MIT

arrscope-0.2.0/README.md

@@ -1,158 +0,0 @@
-# arrscope
-
-Beautiful n-dimensional array visualization for Python — in the terminal and Jupyter.
-
-```python
-from arrscope import scope
-import numpy as np
-
-scope(np.random.rand(2, 3, 8, 8), axes=['batch', 'heads', 'h', 'w'])
-```
-
-```
-├── [0] (3, 8, 8)
-│   ├── [0,0]: 8×8 grid
-│   ├── [0,1]: 8×8 grid
-│   └── [0,2]: 8×8 grid
-└── [1] (3, 8, 8)
-    ...
-  min=0.001  max=0.999  mean=0.5  std=0.29  zeros=0.0%
-```
-
-## Features
-
-- **1D → 6D+**: Tiered visual grammar — lists, grids, trees, collapsed hierarchies
-- **Named axes**: Attach semantics to dimensions (`batch`, `heads`, `h`, `w`)
-- **Configurable grid**: Pick which axes form the leaf 2D matrix
-- **Three color modes**:
-  - `dtype` — semantic colors by data type (float=blue, int=green, bool=magenta, …)
-  - `heatmap` — diverging colormap (red→light→blue) by value magnitude
-  - `sparsity` — zeros as `·`, non-zeros highlighted in bold
-- **Stats overlay**: min, max, mean, std, zero%, NaN count
-- **Head/tail truncation**: large dimensions show first/last N slices with `…`
-- **Smart precision**: auto-detects significant figures for floats
-- **Terminal + Jupyter**: Rich ANSI output + static HTML/CSS with dark mode
-- **Multi-framework**: NumPy, PyTorch, TensorFlow, JAX (lazy imports, no hard deps)
-
-## Install
-
-```bash
-pip install arrscope
-```
-
-Only requires `numpy` + `rich`. Torch/TF/JAX are optional — pass any array type, it just works.
-
-## Quick start
-
-```python
-from arrscope import scope
-import numpy as np
-
-# Auto-detect — last 2 dims form the grid
-scope(np.random.rand(3, 4, 5))
-
-# Named axes for clarity
-scope(
-    np.random.rand(2, 8, 32, 32),
-    axes=['batch', 'heads', 'h', 'w'],
-    grid=['h', 'w'],
-    title='Attention heads',
-)
-
-# Pick any dims as the leaf grid
-scope(data, axes=['a', 'b', 'c', 'd'], grid=['a', 'b'])
-```
-
-## Color modes
-
-```python
-scope(arr, mode='dtype')        # default — blue floats, green ints, etc.
-scope(arr, mode='heatmap')      # diverging colormap by value
-scope(arr, mode='sparsity')     # · for zeros, bold for non-zeros
-```
-
-## Stats overlay
-
-Stats are shown by default. Hide with:
-
-```python
-scope(arr, stats=False)
-```
-
-Shows: `min=0.0  max=1.0  mean=0.5  std=0.29  zeros=12.5%`
-
-## Truncation
-
-```python
-scope(np.random.rand(100, 32, 32), max_height=8)
-```
-
-Shows first 4 + last 4 slices with `… (92 more)` in between.
-
-## Custom formatting
-
-```python
-scope(arr, fmt='.2f')          # fixed precision
-scope(arr, color=False)        # monochrome
-scope(arr, style='html')       # force HTML output in terminal
-```
-
-## CLI
-
-```bash
-# Install globally (ships with the library)
-pip install arrscope
-
-# Use from anywhere
-arrscope 3x4x5
-arrscope 2x3x32x32 --axes batch heads h w --grid h w --mode heatmap
-arrscope 20x4x5 --max-height 6 --no-stats
-```
-
-## Framework support
-
-Pass any array-like — conversion is automatic:
-
-```python
-import torch
-scope(torch.randn(2, 3, 4))          # PyTorch
-
-import tensorflow as tf
-scope(tf.random.uniform((2, 3, 4)))  # TensorFlow
-
-import jax.numpy as jnp
-scope(jnp.array([[1, 2], [3, 4]]))  # JAX
-```
-
-## API
-
-```python
-scope(
-    arr,                          # np.ndarray | torch.Tensor | tf.Tensor | jax.Array
-    axes=None,                    # list[str] — name each dimension
-    grid=None,                    # list[str | int] — which dims form the leaf grid
-    title=None,                   # str — heading above the visualization
-    max_width=None,               # int — max characters wide
-    max_height=None,              # int — max rows before truncation
-    fmt=None,                     # str — format spec like '.4f'
-    color=True,                   # bool — enable/disable color
-    mode='dtype',                 # 'dtype' | 'heatmap' | 'sparsity'
-    stats=True,                   # bool — show min/max/mean/std/zeros
-    style='auto',                 # 'auto' | 'terminal' | 'html'
-)
-```
-
-## Development
-
-```bash
-git clone https://github.com/vizarray/arrscope
-cd arrscope
-uv sync
-uv run pytest
-uv run python main.py          # demo script
-uv run jupyter notebook test.ipynb  # notebook demo
-```
-
-## License
-
-MIT

arrscope-0.2.0/src/arrscope/_config.py

@@ -1,15 +0,0 @@
-from dataclasses import dataclass
-
-
-@dataclass
-class Config:
-    max_width: int | None = None
-    max_height: int | None = None
-    color: bool = True
-    precision: int | None = None
-    mode: str = "dtype"
-    render_style: str = "tree"
-    stats: bool = True
-
-
-config: Config = Config()