chartwright 0.1.0__py3-none-any.whl

chartwright/mcp_server.py

@@ -0,0 +1,112 @@
+"""v2: MCP server over the same core, so any MCP client (Claude Desktop/Code,
+etc.) can drive the compiler. Tools mirror the CLI verbs 1:1; the server adds
+no behavior of its own; the guarantee stays in the core.
+
+Run: chartwright-mcp   (stdio transport; profiles + password env vars as for the CLI)
+"""
+
+from __future__ import annotations
+
+import json
+
+from mcp.server.fastmcp import FastMCP
+
+from .spec import json_schema, load_spec
+
+mcp = FastMCP("chartwright")
+
+
+def _parse_spec(spec_json: str):
+    from pydantic import ValidationError
+
+    try:
+        data = json.loads(spec_json)
+    except json.JSONDecodeError as e:
+        return None, {"ok": False, "stage": "parse", "errors": [{"code": "bad_json", "detail": str(e)}]}
+    try:
+        return load_spec(data), None
+    except ValidationError as e:
+        return None, {"ok": False, "stage": "schema", "errors": json.loads(e.json())}
+
+
+def _client(profile: str):
+    from .client import SupersetClient
+    from .profiles import load_profile
+
+    p = load_profile(profile)
+    c = SupersetClient(p.base_url, p.username, p.password, auth_provider=p.auth_provider,
+                       ca_bundle=p.ca_bundle, verify=p.verify)
+    c.login()
+    return c
+
+
+@mcp.tool()
+def get_spec_schema() -> str:
+    """The JSON Schema a dashboard spec must satisfy. Read this before writing a spec."""
+    return json.dumps(json_schema())
+
+
+@mcp.tool()
+def validate_spec(spec_json: str) -> str:
+    """Schema-validate a dashboard spec (offline). Returns ok or typed errors."""
+    _, err = _parse_spec(spec_json)
+    return json.dumps(err or {"ok": True, "stage": "schema"})
+
+
+@mcp.tool()
+def check_spec(spec_json: str, profile: str) -> str:
+    """Pre-flight referential resolution against the live Superset instance:
+    every dataset triple, column, and metric must exist. Returns typed errors."""
+    spec, err = _parse_spec(spec_json)
+    if err:
+        return json.dumps(err)
+    from .apply import check
+
+    res = check(spec, _client(profile))
+    return json.dumps({"ok": res.ok, "stage": "resolve", "errors": [e.as_dict() for e in res.errors]})
+
+
+@mcp.tool()
+def build_dashboard(spec_json: str, profile: str) -> str:
+    """Compile the spec and apply it to the live Superset instance
+    (resolve -> import -> linkage -> data smoke). Returns the full apply report
+    including the dashboard URL."""
+    spec, err = _parse_spec(spec_json)
+    if err:
+        return json.dumps(err)
+    from .apply import apply as run_apply
+
+    return run_apply(spec, _client(profile), profile).to_json()
+
+
+@mcp.tool()
+def plan_dashboard(spec_json: str, profile: str) -> str:
+    """Diff a spec against the live dashboard at its slug: what would apply
+    change? clean=true means no drift."""
+    spec, err = _parse_spec(spec_json)
+    if err:
+        return json.dumps(err)
+    from .dashdiff import plan as run_plan
+
+    return run_plan(spec, _client(profile)).to_json()
+
+
+@mcp.tool()
+def decompile_dashboard(dashboard: str, profile: str) -> str:
+    """Turn a live dashboard (slug or numeric id) into a spec + a named
+    lossiness report. Use to pull UI-born dashboards under spec control."""
+    from .decompile import decompile_live
+
+    try:
+        result = decompile_live(dashboard, _client(profile))
+    except ValueError as e:
+        return json.dumps({"ok": False, "stage": "decompile", "errors": [{"code": "decompile", "detail": str(e)}]})
+    return json.dumps({"ok": True, "spec": result.spec, "losses": result.losses_json()})
+
+
+def main() -> None:
+    mcp.run()
+
+
+if __name__ == "__main__":
+    main()

chartwright/profiles.py

@@ -0,0 +1,143 @@
+"""Per-instance connection profiles.
+
+Default file: ~/.config/chartwright/profiles.toml (override with CHARTWRIGHT_PROFILES env var,
+e.g. when the home dir is roaming/OneDrive-redirected).
+
+    [work]
+    base_url = "https://superset.example.com"
+    username = "jdoe"
+    # username_env = "MY_USER_VAR"                    # OR read the username from an env var
+    #                                                 # (keeps the identity out of the file too)
+    password_env = "MY_EXISTING_SECRET_VAR"          # ANY env var name you already use
+    # password_cmd = ["sops", "-d", "--extract", '["superset_password"]', "~/secrets.yaml"]
+    #                                                 # OR a command printing the password.
+    #                                                 # LIST form (recommended): no shell, no
+    #                                                 # quoting ambiguity, works identically on
+    #                                                 # bash/git-bash/PowerShell; ~ is expanded.
+    #                                                 # STRING form also accepted: parsed with
+    #                                                 # bash-style quoting on mac/linux, but runs
+    #                                                 # through cmd.exe on Windows (single quotes
+    #                                                 # are literal there) -- prefer the list.
+    #                                                 # (macOS keychain: ["security",
+    #                                                 #  "find-generic-password","-a","jdoe",
+    #                                                 #  "-s","superset","-w"]; 1Password:
+    #                                                 #  ["op","read","op://Work/superset/password"])
+    # auth_provider = "ldap"                          # "db" default; "ldap" for LDAP logins
+    # ca_bundle = "/path/to/corp-root-ca.pem"         # corporate TLS interception
+    # verify = false                                  # last resort, disables TLS verification
+
+Password resolution: password_env first (if set and non-empty), else
+password_cmd. Username resolution: literal `username` first, else
+`username_env` (first-listed source wins, same rule as passwords). No
+secrets ever live in the file itself.
+"""
+
+from __future__ import annotations
+
+import os
+import shlex
+import subprocess
+import tomllib
+from dataclasses import dataclass
+from pathlib import Path
+
+
+def profiles_path() -> Path:
+    override = os.environ.get("CHARTWRIGHT_PROFILES")
+    if override:
+        return Path(override)
+    return Path.home() / ".config" / "chartwright" / "profiles.toml"
+
+
+class ProfileError(RuntimeError):
+    pass
+
+
+@dataclass
+class Profile:
+    name: str
+    base_url: str
+    username: str
+    password: str
+    auth_provider: str = "db"
+    ca_bundle: str | None = None
+    verify: bool = True
+
+
+def _expand(token: str) -> str:
+    return os.path.expanduser(token) if token.startswith("~") else token
+
+
+def _resolve_password(name: str, p: dict) -> str:
+    env_name = p.get("password_env")
+    if env_name:
+        value = os.environ.get(env_name)
+        if value:
+            return value
+    cmd = p.get("password_cmd")
+    if cmd:
+        # List form (recommended): exec directly -- no shell, no quoting
+        # ambiguity, identical on bash / git bash / PowerShell. String form:
+        # bash-style split on posix; cmd.exe shell on Windows (documented caveat).
+        if isinstance(cmd, list):
+            argv = [_expand(str(t)) for t in cmd]
+            use_shell = False
+        elif os.name != "nt":
+            argv = [_expand(t) for t in shlex.split(cmd)]
+            use_shell = False
+        else:
+            argv = cmd
+            use_shell = True
+        try:
+            out = subprocess.run(
+                argv, capture_output=True, text=True, timeout=30, check=True, shell=use_shell,
+            ).stdout.strip()
+        except Exception as e:  # noqa: BLE001 - any failure means no credential
+            raise ProfileError(f"profile {name!r}: password_cmd failed: {e}") from e
+        if out:
+            return out
+        raise ProfileError(f"profile {name!r}: password_cmd produced no output")
+    if env_name:
+        raise ProfileError(
+            f"profile {name!r}: env var {env_name!r} is unset or empty; export it, "
+            f"or set password_cmd to fetch from your credential manager"
+        )
+    raise ProfileError(f"profile {name!r}: set password_env (any env var name) or password_cmd")
+
+
+def _resolve_username(name: str, p: dict) -> str:
+    if "username" in p:
+        return p["username"]
+    env_name = p.get("username_env")
+    if env_name:
+        value = os.environ.get(env_name)
+        if value:
+            return value
+        raise ProfileError(
+            f"profile {name!r}: env var {env_name!r} (username_env) is unset or empty"
+        )
+    raise ProfileError(f"profile {name!r}: set username or username_env")
+
+
+def load_profile(name: str, path: Path | None = None) -> Profile:
+    path = path or profiles_path()
+    if not path.exists():
+        raise ProfileError(
+            f"no profiles file at {path}; create it (see chartwright/profiles.py docstring) "
+            f"or point CHARTWRIGHT_PROFILES at yours"
+        )
+    data = tomllib.loads(path.read_text(encoding="utf-8"))  # TOML is UTF-8 by spec; never the locale codepage
+    if name not in data:
+        raise ProfileError(f"profile {name!r} not in {path}; have: {sorted(data)}")
+    p = data[name]
+    if "base_url" not in p:
+        raise ProfileError(f"profile {name!r} missing 'base_url'")
+    return Profile(
+        name=name,
+        base_url=p["base_url"],
+        username=_resolve_username(name, p),
+        password=_resolve_password(name, p),
+        auth_provider=p.get("auth_provider", "db"),
+        ca_bundle=p.get("ca_bundle"),
+        verify=p.get("verify", True),
+    )

chartwright/resolver.py

@@ -0,0 +1,196 @@
+"""Pre-flight referential resolution: where the correctness guarantee is earned.
+
+Every dataset triple, column, saved metric, and ad-hoc aggregate column in the
+spec is resolved against the live Superset metadata API. All failures are
+collected (not fail-fast) and surfaced as machine-readable errors BEFORE import.
+"""
+
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass, field
+
+from .client import SupersetClient
+from .spec import DashboardSpec, DatasetRef, parse_metric
+
+
+@dataclass
+class ResolvedDataset:
+    id: int
+    uuid: str
+    table: str
+    schema: str | None
+    database_name: str
+    columns: list[str]
+    metrics: list[str]
+    main_dttm_col: str | None = None
+
+
+@dataclass
+class ResolutionError:
+    code: str          # dataset_not_found | dataset_ambiguous | column_not_found | metric_not_found | bad_metric
+    chart: str | None
+    ref: str
+    detail: str
+
+    def as_dict(self) -> dict:
+        return asdict(self)
+
+
+@dataclass
+class Resolution:
+    datasets: dict[str, ResolvedDataset] = field(default_factory=dict)  # DatasetRef.key() -> resolved
+    errors: list[ResolutionError] = field(default_factory=list)
+
+    @property
+    def ok(self) -> bool:
+        return not self.errors
+
+    def for_chart(self, ref: DatasetRef) -> ResolvedDataset:
+        return self.datasets[ref.key()]
+
+
+def resolve(spec: DashboardSpec, client: SupersetClient) -> Resolution:
+    res = Resolution()
+    cache: dict[str, ResolvedDataset | None] = {}
+
+    def dataset_for(ref: DatasetRef) -> ResolvedDataset | None:
+        key = ref.key()
+        if key not in cache:
+            cache[key] = _resolve_dataset(ref, client, res)
+        if cache[key] is not None:
+            res.datasets[key] = cache[key]
+        return cache[key]
+
+    for chart in spec.charts:
+        ds = dataset_for(chart.dataset)
+        if ds is None:
+            continue
+        _check_chart_fields(chart, ds, res)
+        for f in chart.filters:
+            _check_column(f.column, chart.name, ds, res, "filter column")
+
+    for f in spec.filters:
+        if f.type in ("select", "range"):
+            ds = dataset_for(f.dataset)
+            if ds is not None:
+                _check_column(f.column, f"filter:{f.name}", ds, res, "native filter column")
+    return res
+
+
+def _resolve_dataset(ref: DatasetRef, client: SupersetClient, res: Resolution) -> ResolvedDataset | None:
+    candidates = client.find_datasets(ref.table)
+    matches = []
+    for c in candidates:
+        db_name = (c.get("database") or {}).get("database_name")
+        schema = c.get("schema") or None
+        if db_name != ref.database:
+            continue
+        if ref.schema_ is not None and schema != ref.schema_:
+            continue
+        matches.append(c)
+    if not matches:
+        near = [f"{(c.get('database') or {}).get('database_name')}/{c.get('schema') or ''}/{c['table_name']}" for c in candidates]
+        res.errors.append(ResolutionError(
+            "dataset_not_found", None, ref.key(),
+            f"no dataset {ref.table!r} in database {ref.database!r}"
+            + (f" schema {ref.schema_!r}" if ref.schema_ else "")
+            + (f"; same-named candidates: {near}" if near else ""),
+        ))
+        return None
+    if len(matches) > 1:
+        cands = [f"{(m.get('database') or {}).get('database_name')}/{m.get('schema') or ''}/{m['table_name']}" for m in matches]
+        res.errors.append(ResolutionError(
+            "dataset_ambiguous", None, ref.key(),
+            f"multiple datasets match; add a schema to disambiguate: {cands}",
+        ))
+        return None
+    m = matches[0]
+    detail = client.dataset_detail(m["id"])
+    return ResolvedDataset(
+        id=m["id"],
+        uuid=str(m["uuid"]),
+        table=m["table_name"],
+        schema=m.get("schema") or None,
+        database_name=(m.get("database") or {}).get("database_name"),
+        columns=[c["column_name"] for c in detail.get("columns", [])],
+        metrics=[x["metric_name"] for x in detail.get("metrics", [])],
+        main_dttm_col=detail.get("main_dttm_col") or None,
+    )
+
+
+def _check_metric(metric: str, chart_name: str, ds: ResolvedDataset, res: Resolution) -> None:
+    adhoc = parse_metric(metric)
+    if adhoc is None:
+        if metric not in ds.metrics:
+            res.errors.append(ResolutionError(
+                "metric_not_found", chart_name, metric,
+                f"not a saved metric on {ds.table!r} (has: {ds.metrics}) and not an "
+                f"ad-hoc aggregate of the form AGG(column), AGG in SUM/AVG/COUNT/COUNT_DISTINCT/MIN/MAX",
+            ))
+        return
+    col = adhoc["column"]
+    if col != "*" and col not in ds.columns:
+        res.errors.append(ResolutionError(
+            "column_not_found", chart_name, col,
+            f"ad-hoc metric {metric!r}: column {col!r} not on dataset {ds.table!r}",
+        ))
+
+
+def _check_column(col: str, chart_name: str, ds: ResolvedDataset, res: Resolution, what: str = "column") -> None:
+    if col not in ds.columns:
+        res.errors.append(ResolutionError(
+            "column_not_found", chart_name, col,
+            f"{what} {col!r} not on dataset {ds.table!r} (has {len(ds.columns)} columns)",
+        ))
+
+
+def _check_chart_fields(chart, ds: ResolvedDataset, res: Resolution) -> None:
+    t = chart.type
+    if t in ("big_number_total", "big_number_trend"):
+        _check_metric(chart.metric, chart.name, ds, res)
+        if t == "big_number_trend":
+            _check_column(chart.time_column, chart.name, ds, res, "time_column")
+    elif t in ("timeseries_line", "timeseries_bar", "timeseries_area", "timeseries_scatter"):
+        for m in chart.metrics:
+            _check_metric(m, chart.name, ds, res)
+        _check_column(chart.time_column, chart.name, ds, res, "time_column")
+        if chart.groupby:
+            _check_column(chart.groupby, chart.name, ds, res, "groupby")
+    elif t == "bar":
+        for m in chart.metrics:
+            _check_metric(m, chart.name, ds, res)
+        _check_column(chart.x_column, chart.name, ds, res, "x_column")
+        if chart.groupby:
+            _check_column(chart.groupby, chart.name, ds, res, "groupby")
+    elif t == "pie":
+        _check_metric(chart.metric, chart.name, ds, res)
+        _check_column(chart.groupby, chart.name, ds, res, "groupby")
+    elif t == "table":
+        for c in chart.columns or []:
+            _check_column(c, chart.name, ds, res)
+        for m in chart.metrics or []:
+            _check_metric(m, chart.name, ds, res)
+        for g in chart.groupby or []:
+            _check_column(g, chart.name, ds, res, "groupby")
+    elif t == "pivot_table":
+        for m in chart.metrics:
+            _check_metric(m, chart.name, ds, res)
+        for c in chart.rows:
+            _check_column(c, chart.name, ds, res, "pivot row")
+        for c in chart.columns:
+            _check_column(c, chart.name, ds, res, "pivot column")
+    elif t == "heatmap":
+        _check_metric(chart.metric, chart.name, ds, res)
+        _check_column(chart.x_column, chart.name, ds, res, "x_column")
+        _check_column(chart.y_column, chart.name, ds, res, "y_column")
+    elif t == "histogram":
+        _check_column(chart.column, chart.name, ds, res, "column")
+        if chart.groupby:
+            _check_column(chart.groupby, chart.name, ds, res, "groupby")
+    elif t == "funnel":
+        _check_metric(chart.metric, chart.name, ds, res)
+        _check_column(chart.groupby, chart.name, ds, res, "groupby")
+    elif t == "treemap":
+        _check_metric(chart.metric, chart.name, ds, res)
+        for g in chart.groupby:
+            _check_column(g, chart.name, ds, res, "groupby")

chartwright/sketch.py

@@ -0,0 +1,180 @@
+"""ASCII layout sketches: grid-template-areas for Superset's row/column tree.
+
+The user draws each tab as text; the compiler turns it into ROW / COLUMN /
+CHART geometry. Superset's real model (4.1 source): widths are TWELFTHS of the
+page (GRID_COLUMN_COUNT=12, responsive), heights are absolute 8-px units, and
+the layout is a strict tree: rows stack, a COLUMN stacks charts inside a row
+slot, and nothing deeper exists. A sketch therefore compiles iff it guillotines
+into rows of charts/columns; anything else is a named error.
+
+Semantics:
+- Spaces are cosmetic separators, stripped per line; after stripping every
+  line must have the SAME cell count (that count = the grid width, scaled to
+  12 columns by largest-remainder so each band sums to exactly 12).
+- Each sketch line adds `line_units` spec height units (1 unit = 40 px);
+  repeat a line to make its regions taller.
+- Every symbol's cells must form a solid rectangle.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+@dataclass
+class SketchChart:
+    name: str
+    width: int        # twelfths
+    height: int       # spec height units
+
+
+@dataclass
+class SketchColumn:
+    width: int        # twelfths
+    children: list[SketchChart] = field(default_factory=list)
+
+
+@dataclass
+class SketchRow:
+    children: list[SketchChart | SketchColumn] = field(default_factory=list)
+
+
+HOLE = "."  # reserved: a deliberately empty cell (grid-template-areas prior art)
+
+
+class SketchError(ValueError):
+    pass
+
+
+def _widths_to_twelfths(cell_counts: list[int], total_cells: int) -> list[int]:
+    """Largest-remainder scaling so each band sums to exactly 12 columns."""
+    raw = [c * 12 / total_cells for c in cell_counts]
+    floors = [max(1, int(r)) for r in raw]
+    while sum(floors) > 12:  # over-min floors: shave the largest
+        i = max(range(len(floors)), key=lambda k: floors[k])
+        if floors[i] == 1:
+            raise SketchError(f"too many charts side by side for a 12-column grid: {cell_counts}")
+        floors[i] -= 1
+    remainders = sorted(range(len(raw)), key=lambda k: raw[k] - int(raw[k]), reverse=True)
+    for i in remainders:
+        if sum(floors) == 12:
+            break
+        floors[i] += 1
+    return floors
+
+
+def parse_sketch(lines: list[str], legend: dict[str, str], line_units: int) -> list[SketchRow]:
+    if not lines:
+        raise SketchError("sketch is empty")
+    grid = [[ch for ch in line if ch != " "] for line in lines]
+    width = len(grid[0])
+    if width == 0:
+        raise SketchError("sketch line 1 is blank")
+    for i, row in enumerate(grid):
+        if len(row) != width:
+            raise SketchError(
+                f"sketch line {i + 1} has {len(row)} cells, line 1 has {width} "
+                "(spaces are separators; cell counts must match)"
+            )
+
+    if HOLE in legend:
+        raise SketchError(f"{HOLE!r} is a reserved sketch symbol (empty cell); pick another legend symbol")
+    symbols = {ch for row in grid for ch in row} - {HOLE}
+    unknown = sorted(symbols - set(legend))
+    if unknown:
+        raise SketchError(f"sketch symbols not in legend: {unknown}")
+    unused = sorted(set(legend) - symbols)
+    if unused:
+        raise SketchError(f"legend symbols never drawn: {unused}")
+
+    # every symbol must fill a solid rectangle
+    boxes: dict[str, tuple[int, int, int, int]] = {}  # r0, r1, c0, c1 inclusive
+    for s in symbols:
+        cells = [(r, c) for r, row in enumerate(grid) for c, ch in enumerate(row) if ch == s]
+        r0, r1 = min(r for r, _ in cells), max(r for r, _ in cells)
+        c0, c1 = min(c for _, c in cells), max(c for _, c in cells)
+        if len(cells) != (r1 - r0 + 1) * (c1 - c0 + 1):
+            raise SketchError(f"symbol {s!r} does not form a solid rectangle")
+        boxes[s] = (r0, r1, c0, c1)
+
+    # horizontal bands: cut where no rectangle spans the boundary
+    cuts = [0]
+    for r in range(1, len(grid)):
+        if all(not (b[0] < r <= b[1]) for b in boxes.values()):
+            cuts.append(r)
+    cuts.append(len(grid))
+
+    rows: list[SketchRow] = []
+    for b0, b1 in zip(cuts, cuts[1:]):
+        band = {s: box for s, box in boxes.items() if b0 <= box[0] and box[1] < b1}
+        if not band:
+            raise SketchError(
+                f"line {b0 + 1} is entirely empty: Superset has no vertical spacer; "
+                "use more lines on neighbors or a markdown block in rows mode"
+            )
+        # vertical slices: group symbols sharing column extents
+        slices: dict[tuple[int, int], list[str]] = {}
+        for s, (r0, r1, c0, c1) in sorted(band.items(), key=lambda kv: (kv[1][2], kv[1][0])):
+            for (sc0, sc1), members in slices.items():
+                if c0 <= sc1 and sc0 <= c1:  # overlaps an existing slice
+                    if (c0, c1) != (sc0, sc1):
+                        raise SketchError(
+                            f"symbol {s!r} partially overlaps the column span of {members}: "
+                            "Superset cannot nest a row inside a column; align the columns "
+                            "or split into separate full-width rows"
+                        )
+                    members.append(s)
+                    break
+            else:
+                slices[(c0, c1)] = [s]
+
+        # Holes ('.') are legal only where Superset can express absence:
+        # trailing right of the band (rows pack left) or at the BOTTOM of a
+        # slice (rows/columns pack upward; row height = tallest child).
+        cmax = max(c1 for (_, _, _, c1) in band.values())
+        spans = list(slices)
+        for r in range(b0, b1):
+            for c in range(cmax + 1):
+                if grid[r][c] == HOLE and not any(c0 <= c <= c1 for c0, c1 in spans):
+                    raise SketchError(
+                        f"empty column {c + 1} between charts (line {r + 1}): Superset "
+                        "rows pack left; empty space goes rightmost"
+                    )
+        trailing_holes = width - 1 - cmax
+
+        ordered = sorted(slices.items(), key=lambda kv: kv[0][0])
+        counts = [c1 - c0 + 1 for (c0, c1), _ in ordered]
+        if trailing_holes:
+            counts.append(trailing_holes)  # phantom entry scales real widths correctly
+        widths = _widths_to_twelfths(counts, width)
+
+        row = SketchRow()
+        for ((_, _), members), w in zip(ordered, widths):
+            if len(members) == 1:
+                s = members[0]
+                r0, r1 = boxes[s][0], boxes[s][1]
+                if r0 != b0:
+                    raise SketchError(
+                        f"empty space above chart {legend[s]!r} (line {b0 + 1}): Superset "
+                        "packs upward; empty cells in a column go at the bottom"
+                    )
+                row.children.append(SketchChart(legend[s], w, (r1 - r0 + 1) * line_units))
+            else:
+                members.sort(key=lambda s: boxes[s][0])
+                # stacked members must tile downward from the band top with no
+                # gaps; '.' may only end the stack early (bottom holes)
+                expect = b0
+                col = SketchColumn(width=w)
+                for s in members:
+                    r0, r1 = boxes[s][0], boxes[s][1]
+                    if r0 != expect:
+                        raise SketchError(
+                            f"symbols {members} must stack with no vertical gaps "
+                            f"(symbol {s!r} starts at line {r0 + 1}, expected {expect + 1}; "
+                            "empty cells may only end a stack, not interrupt it)"
+                        )
+                    expect = r1 + 1
+                    col.children.append(SketchChart(legend[s], w, (r1 - r0 + 1) * line_units))
+                row.children.append(col)
+        rows.append(row)
+    return rows