augplot 0.1.0__tar.gz → 0.1.1__tar.gz

{augplot-0.1.0 → augplot-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: augplot
-Version: 0.1.0
+Version: 0.1.1
 Summary: Turn notebook data into visualizations and reusable Python with an LLM.
 Project-URL: Repository, https://github.com/egpand/augplot
 Project-URL: Documentation, https://github.com/egpand/augplot/tree/main/docs
@@ -78,6 +78,40 @@ viz.to_python(function_name="plot_monthly_passengers")
 Open or download the [example notebook](examples/quickstart.ipynb) to try the complete
 workflow.
 
+## What can `data` be?
+
+`ap.plot(data)` accepts these nonempty, in-memory Python objects:
+
+| Input | Typical use |
+| --- | --- |
+| `pandas.DataFrame` | Rows and columns, including dates and categories. |
+| `pandas.Series` | One labeled sequence of values. |
+| `numpy.ndarray` | One- or two-dimensional numeric or mixed data. |
+| `list` or `tuple` | Values such as `[2, 4, 6]`, or records such as `[{'x': 1, 'y': 2}]`. |
+| `dict` | Columns such as `{'x': [1, 2], 'y': [2, 3]}`, or nested results keyed by model and metric. |
+
+Nested lists and dictionaries can contain ordinary scalars, missing values, NumPy arrays,
+and Pandas objects. Parsed JSON is therefore a valid input when its root is a nonempty
+list or dictionary:
+
+```python
+import json
+
+records = json.loads('[{"month": "Jan", "sales": 10}, {"month": "Feb", "sales": 12}]')
+viz = ap.plot(records)
+
+results = {
+    "baseline": {"test_f1": [0.3, 0.4, 0.5]},
+    "candidate": {"test_f1": [0.4, 0.5, 0.6]},
+}
+viz = ap.plot(results, prompt="Compare F1 scores across models")
+```
+
+Pass the parsed object, not a JSON string or file path. Empty inputs, cyclic containers,
+custom objects, and NumPy arrays with zero or more than two dimensions raise `DataError`.
+For a Pandas `Index`, another table library, or an iterator, convert to one of the types
+above first.
+
 ## Workflow
 
 - `plot()` generates the initial visualization.
@@ -139,7 +173,7 @@ but does not train models or return predictions, forecasts, or other analytical
 
 ## Beta and security
 
-Augplot 0.1.0 is a beta release; APIs and saved-history formats may change before 1.0.
+Augplot 0.1.1 is a beta release; APIs and saved-history formats may change before 1.0.
 Review generated code before sensitive or security-critical use, and report
 vulnerabilities through the [security policy](SECURITY.md).
 

{augplot-0.1.0 → augplot-0.1.1}/README.md

@@ -40,6 +40,40 @@ viz.to_python(function_name="plot_monthly_passengers")
 Open or download the [example notebook](examples/quickstart.ipynb) to try the complete
 workflow.
 
+## What can `data` be?
+
+`ap.plot(data)` accepts these nonempty, in-memory Python objects:
+
+| Input | Typical use |
+| --- | --- |
+| `pandas.DataFrame` | Rows and columns, including dates and categories. |
+| `pandas.Series` | One labeled sequence of values. |
+| `numpy.ndarray` | One- or two-dimensional numeric or mixed data. |
+| `list` or `tuple` | Values such as `[2, 4, 6]`, or records such as `[{'x': 1, 'y': 2}]`. |
+| `dict` | Columns such as `{'x': [1, 2], 'y': [2, 3]}`, or nested results keyed by model and metric. |
+
+Nested lists and dictionaries can contain ordinary scalars, missing values, NumPy arrays,
+and Pandas objects. Parsed JSON is therefore a valid input when its root is a nonempty
+list or dictionary:
+
+```python
+import json
+
+records = json.loads('[{"month": "Jan", "sales": 10}, {"month": "Feb", "sales": 12}]')
+viz = ap.plot(records)
+
+results = {
+    "baseline": {"test_f1": [0.3, 0.4, 0.5]},
+    "candidate": {"test_f1": [0.4, 0.5, 0.6]},
+}
+viz = ap.plot(results, prompt="Compare F1 scores across models")
+```
+
+Pass the parsed object, not a JSON string or file path. Empty inputs, cyclic containers,
+custom objects, and NumPy arrays with zero or more than two dimensions raise `DataError`.
+For a Pandas `Index`, another table library, or an iterator, convert to one of the types
+above first.
+
 ## Workflow
 
 - `plot()` generates the initial visualization.
@@ -101,7 +135,7 @@ but does not train models or return predictions, forecasts, or other analytical
 
 ## Beta and security
 
-Augplot 0.1.0 is a beta release; APIs and saved-history formats may change before 1.0.
+Augplot 0.1.1 is a beta release; APIs and saved-history formats may change before 1.0.
 Review generated code before sensitive or security-critical use, and report
 vulnerabilities through the [security policy](SECURITY.md).
 

{augplot-0.1.0 → augplot-0.1.1}/docs/api.md

@@ -11,8 +11,9 @@ import augplot as ap
 plt = ap.plot(data, prompt="Plot revenue by channel")
 ```
 
-`ap.plot()` accepts Pandas objects, NumPy arrays, lists, and nested dictionaries. It
-returns the current Augplot chart object and displays its figure by default.
+`ap.plot()` accepts Pandas objects, one- or two-dimensional NumPy arrays, lists, tuples,
+and nested dictionaries. It returns the current Augplot chart object and displays its
+figure by default.
 
 ```python
 plt = ap.plot(

{augplot-0.1.0 → augplot-0.1.1}/docs/generated-code-guardrails.md

@@ -10,15 +10,27 @@ Generated code must define exactly `plot_data(data, *, title=None, figsize=None)
 return a figure it created. It may use the approved, in-memory parts of NumPy, Pandas,
 Matplotlib, and Seaborn. This includes common chart types, subplot layouts, axes, legends,
 artists, ticks, date formatters, and supported data transformations.
+Nested dictionaries and JSON-like records remain valid inputs. For cross-validation
+results keyed by model name, generated code can derive values with a single comprehension,
+such as `[np.mean(data[name]["test_f1"]) for name in data]`.
 
 Imports use fixed aliases: `np`, `pd`, `plt`, `ticker`, `dates`, and `sns`.
 Every call and attribute path is checked, and figures, axes, artists, and data-derived
 values are tracked so that a valid object cannot be substituted with an arbitrary callable.
 
-Loops are limited to approved Axes collections, small static sequences, or columns selected
-from data explicitly bounded to at most 200 rows with `head` or `tail`. This supports panel
-styling and per-record chart annotations without permitting unbounded or nested generated
-loops.
+Loops are limited to approved Axes collections, small static sequences, or data explicitly
+bounded to at most 200 rows with `head` or `tail`. Bounded columns and
+`data.head(20).iterrows()` support per-record chart annotations. Unbounded row iteration
+and nested generated loops remain rejected.
+One-dimensional Axes collections from a fixed-size `subplots` call can be iterated directly.
+A list slice such as `names = list(data)[:200]` also provides a bounded sequence; a
+matching `np.arange(len(names))` may position its marks.
+An array extent stored in a local name, such as `column_count = values.shape[1]`, may
+also be used to position marks with `np.arange(column_count)`; it does not authorize an
+unbounded Python annotation loop.
+Simple layout values can be assigned in both branches of a conditional, including a
+default `figsize`. A bounded loop over the four Matplotlib spines may hide them for
+minimal timeline styling.
 
 The generation prompt summarizes the validator's main constraints so a provider is less
 likely to emit code that needs repair. This is compatibility guidance only: the prompt is
@@ -45,14 +57,15 @@ plt.imsave("chart.png", data)
 
 Fresh model output receives at most the configured repair attempt (`max_repairs=1` by
 default). The repair request contains a sanitized validation diagnostic, never a runtime
-exception message or data values. If it still fails, `ap.plot()` raises
+exception message or data values. A recognized scatter length mismatch produces a
+data-free hint so the model can repair the x and y arrays. If it still fails, `ap.plot()` raises
 `GenerationError`; rejected source is never executed, displayed, exported, or saved.
 
 ```python
 try:
     viz = ap.plot(data, prompt="...")
 except ap.GenerationError as exc:
-    print(exc)             # concise reason
+    print(exc)             # reason, with the rejected name or method and line when known
     print(exc.violations)  # structured validation failures
     print(exc.code)        # inspect only when appropriate
 ```

{augplot-0.1.0 → augplot-0.1.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "augplot"
-version = "0.1.0"
+version = "0.1.1"
 description = "Turn notebook data into visualizations and reusable Python with an LLM."
 readme = "README.md"
 license = "Apache-2.0"

{augplot-0.1.0 → augplot-0.1.1}/src/augplot/__init__.py

@@ -22,4 +22,4 @@ __all__ = [
     "ProviderError",
     "ScopeError",
 ]
-__version__ = "0.1.0"
+__version__ = "0.1.1"

{augplot-0.1.0 → augplot-0.1.1}/src/augplot/execution.py

@@ -8,7 +8,7 @@ from contextlib import ExitStack
 from .errors import GenerationError, ScopeError
 from .profiling import copy_data
 
-API_MANIFEST_VERSION = 2
+API_MANIFEST_VERSION = 8
 MAX_SOURCE_CHARS = 50_000
 MAX_AST_NODES = 4_000
 MAX_LITERAL_ITEMS = 2_000
@@ -176,6 +176,7 @@ _DATA_METHODS = {
     "idxmin",
     "infer_objects",
     "interpolate",
+    "iterrows",
     "isin",
     "isna",
     "items",
@@ -445,6 +446,7 @@ _AXES = {
     "secondary_yaxis",
     "set",
     "set_aspect",
+    "set_axisbelow",
     "set_axis_off",
     "set_axis_on",
     "set_box_aspect",
@@ -456,10 +458,12 @@ _AXES = {
     "set_xlim",
     "set_xscale",
     "set_xticks",
+    "set_xticklabels",
     "set_ylabel",
     "set_ylim",
     "set_yscale",
     "set_yticks",
+    "set_yticklabels",
     "sharex",
     "sharey",
     "specgram",
@@ -612,11 +616,18 @@ class _Validator:
 
     def merge_branches(self, before, body, otherwise):
         merged = {}
+        passive_kinds = {"value", "data", "bounded_sequence"}
         for name in before.keys() | body.keys() | otherwise.keys():
             body_kind = body.get(name)
             otherwise_kind = otherwise.get(name)
             if body_kind == otherwise_kind and body_kind is not None:
                 merged[name] = body_kind
+                self.invalid_provenance.discard(name)
+            elif {body_kind, otherwise_kind} <= passive_kinds:
+                # Keep ordinary values usable after a branch, without carrying a
+                # bounded-iteration proof or a plotting-object capability across it.
+                merged[name] = "data"
+                self.invalid_provenance.discard(name)
             else:
                 self.invalid_provenance.add(name)
         return merged
@@ -695,6 +706,108 @@ class _Validator:
         except (TypeError, ValueError, OverflowError):
             return False
 
+    def bounded_slice(self, node):
+        if not isinstance(node, ast.Slice) or node.upper is None:
+            return False
+        lower = 0 if node.lower is None else self.static_integer(node.lower)
+        upper = self.static_integer(node.upper)
+        step = 1 if node.step is None else self.static_integer(node.step)
+        return (
+            lower is not None
+            and upper is not None
+            and step is not None
+            and 0 <= lower <= upper
+            and 0 < step
+            and upper - lower <= MAX_BOUNDED_ITERATION
+        )
+
+    def bounded_arange(self, node):
+        if len(node.args) != 1 or node.keywords:
+            return False
+        stop = node.args[0]
+        return (
+            isinstance(stop, ast.Call)
+            and isinstance(stop.func, ast.Name)
+            and stop.func.id == "len"
+            and len(stop.args) == 1
+            and not stop.keywords
+            and isinstance(stop.args[0], ast.Name)
+            and self.env.get(stop.args[0].id)
+            in {"bounded_column", "bounded_data", "bounded_sequence"}
+        )
+
+    def data_extent(self, node):
+        data_kinds = {"bounded_column", "bounded_data", "bounded_sequence", "data", "sequence"}
+        if isinstance(node, ast.Name):
+            return self.env.get(node.id) == "data_extent"
+        if isinstance(node, ast.Call):
+            return (
+                isinstance(node.func, ast.Name)
+                and node.func.id == "len"
+                and len(node.args) == 1
+                and not node.keywords
+                and isinstance(node.args[0], ast.Name)
+                and self.env.get(node.args[0].id) in data_kinds
+            )
+        if isinstance(node, ast.Attribute):
+            return (
+                node.attr == "size"
+                and isinstance(node.value, ast.Name)
+                and self.env.get(node.value.id) in data_kinds
+            )
+        if isinstance(node, ast.Subscript) and isinstance(node.value, ast.Attribute):
+            return (
+                node.value.attr == "shape"
+                and isinstance(node.value.value, ast.Name)
+                and self.env.get(node.value.value.id) in data_kinds
+                and isinstance(node.slice, ast.Constant)
+                and node.slice.value in {0, 1}
+            )
+        return False
+
+    def data_sized_stop(self, node):
+        if self.data_extent(node):
+            return True
+        if isinstance(node, ast.BinOp) and isinstance(node.op, (ast.Add, ast.Sub)):
+            return (
+                self.data_extent(node.left)
+                and isinstance(node.right, ast.Constant)
+                and isinstance(node.right.value, int)
+                and abs(node.right.value) <= 1
+            )
+        return False
+
+    def data_sized_range(self, node):
+        if node.keywords or len(node.args) not in {1, 2}:
+            return False
+        if len(node.args) == 1:
+            return self.data_sized_stop(node.args[0])
+        start = self.static_integer(node.args[0])
+        return start in {0, 1} and self.data_sized_stop(node.args[1])
+
+    def subplot_result(self, node):
+        rows = self.keyword_value(node, "nrows")
+        columns = self.keyword_value(node, "ncols")
+        if rows is None and node.args:
+            rows = node.args[0]
+        if columns is None and len(node.args) > 1:
+            columns = node.args[1]
+        rows = 1 if rows is None else self.static_integer(rows)
+        columns = 1 if columns is None else self.static_integer(columns)
+        squeeze = self.keyword_value(node, "squeeze")
+        is_flat_axes = (
+            isinstance(rows, int)
+            and isinstance(columns, int)
+            and 0 < rows * columns <= 100
+            and rows * columns > 1
+            and (rows == 1 or columns == 1)
+            and (
+                squeeze is None
+                or (isinstance(squeeze, ast.Constant) and squeeze.value is True)
+            )
+        )
+        return "axes_sequence" if is_flat_axes else "axes"
+
     def keyword_value(self, node, name):
         return next((item.value for item in node.keywords if item.arg == name), None)
 
@@ -822,7 +935,10 @@ class _Validator:
                 )
             if self.loop_depth:
                 self.fail("resource_limit", "Nested loops are not allowed.")
-            self.assign(n.target, "axes_sequence" if kind == "axes_sequence" else "value")
+            target_kind = kind if kind == "axes_sequence" else "value"
+            if kind == "axes_sequence" and isinstance(n.target, ast.Name):
+                target_kind = "axes"
+            self.assign(n.target, target_kind)
             self.loop_depth += 1
             try:
                 for s in n.body + n.orelse:
@@ -849,6 +965,7 @@ class _Validator:
         elif isinstance(target, (ast.Tuple, ast.List)):
             if kind not in {
                 "figure_axes",
+                "figure_axes_sequence",
                 "bounded_sequence",
                 "sequence",
                 "axes",
@@ -857,14 +974,15 @@ class _Validator:
             }:
                 self.fail("assignment", "This value cannot be unpacked.")
             for i, elt in enumerate(target.elts):
-                self.assign(
-                    elt,
-                    "figure"
-                    if i == 0 and kind == "figure_axes"
-                    else "axes"
-                    if kind in {"figure_axes", "axes"} or (kind == "axes_sequence" and i == 0)
-                    else "value",
-                )
+                if i == 0 and kind in {"figure_axes", "figure_axes_sequence"}:
+                    item_kind = "figure"
+                elif kind == "figure_axes_sequence":
+                    item_kind = "axes_sequence"
+                elif kind in {"figure_axes", "axes"} or (kind == "axes_sequence" and i == 0):
+                    item_kind = "axes"
+                else:
+                    item_kind = "value"
+                self.assign(elt, item_kind)
         elif isinstance(target, ast.Subscript):
             # A local, data-derived frame may be reshaped in memory; the caller's
             # original `data` argument and all attribute/module mutation remain blocked.
@@ -875,7 +993,16 @@ class _Validator:
             ):
                 self.expr(target.slice)
                 return
-            self.fail("mutation", "Attribute and subscript assignment are not allowed.")
+            self.fail(
+                "mutation",
+                f"Subscript assignment at generated line {target.lineno} is not allowed.",
+            )
+        elif isinstance(target, ast.Attribute):
+            self.fail(
+                "mutation",
+                f"Assignment to .{target.attr} at generated line {target.lineno} is not "
+                "allowed. Derive a separate local value instead.",
+            )
         else:
             self.fail("mutation", "Attribute and subscript assignment are not allowed.")
 
@@ -892,7 +1019,11 @@ class _Validator:
             if n.id in _BUILTINS:
                 return "builtin:" + n.id
             if n.id in self.invalid_provenance:
-                self.fail("provenance", "Name does not have one capability on every path.")
+                self.fail(
+                    "provenance",
+                    f"Name {n.id!r} at generated line {n.lineno} does not have one "
+                    "capability on every path.",
+                )
             if n.id.startswith("_") or n.id not in self.env:
                 self.fail("name", "Source references an unknown capability or name.")
             return self.env[n.id]
@@ -900,8 +1031,10 @@ class _Validator:
             if len(n.elts) > MAX_LITERAL_ITEMS:
                 self.fail("literal_size", "Generated source contains an oversized literal.")
             kinds = [self.expr(x) for x in n.elts]
-            if "axes" in kinds or "axes_sequence" in kinds:
+            if kinds and all(kind == "axes" for kind in kinds):
                 return "axes_sequence"
+            if "axes" in kinds or "axes_sequence" in kinds:
+                self.fail("provenance", "Axes collections may contain only approved Axes.")
             return "bounded_sequence" if len(n.elts) <= MAX_BOUNDED_ITERATION else "sequence"
         if isinstance(n, ast.Dict):
             if len(n.keys) > MAX_LITERAL_ITEMS or any(k is None for k in n.keys):
@@ -915,6 +1048,10 @@ class _Validator:
         if isinstance(n, ast.Subscript):
             base = self.expr(n.value)
             self.expr(n.slice)
+            if self.data_extent(n):
+                return "data_extent"
+            if base == "spines":
+                return "artist"
             if base in {"axes", "axes_sequence"}:
                 return "axes"
             if base == "bounded_data" and isinstance(n.slice, ast.Constant):
@@ -923,6 +1060,8 @@ class _Validator:
                 return "bounded_column"
             if base == "bounded_sequence" and isinstance(n.slice, ast.Slice):
                 return "bounded_sequence"
+            if base == "sequence" and self.bounded_slice(n.slice):
+                return "bounded_sequence"
             if base in {"bounded_column", "bounded_data"}:
                 return "bounded_data"
             if base == "bounded_sequence":
@@ -1020,6 +1159,8 @@ class _Validator:
         if n.attr.startswith("_"):
             self.fail("private_access", "Private and dunder attributes are not allowed.")
         base = self.expr(n.value)
+        if base == "module:numpy" and n.attr == "nan":
+            return "value"
         if (
             base
             in {
@@ -1041,9 +1182,14 @@ class _Validator:
             )
         if base == "axes" and n.attr in {"xaxis", "yaxis"}:
             return "axis"
+        if base == "axes" and n.attr == "spines":
+            return "spines"
         if base == "artist" and n.attr in {"figure", "fig"}:
             return "figure"
-        self.fail("attribute", "Attribute access is not an approved capability.")
+        self.fail(
+            "attribute",
+            f"Attribute .{n.attr} at generated line {n.lineno} is not an approved capability.",
+        )
 
     def call(self, n):
         if any(isinstance(a, ast.Starred) for a in n.args):
@@ -1055,7 +1201,7 @@ class _Validator:
                 self.expr(keyword.value)
             if n.func.id not in _BUILTINS:
                 self.fail("call", "Calls must resolve to an approved capability.")
-            if n.func.id == "range" and (
+            if n.func.id == "range" and not self.data_sized_range(n) and (
                 len(n.args) > 3
                 or any(
                     not isinstance(x, ast.Constant)
@@ -1069,6 +1215,8 @@ class _Validator:
                 return "axes_sequence"
             if n.func.id == "range" and self.bounded_range(n):
                 return "bounded_sequence"
+            if n.func.id == "range" and self.data_sized_range(n):
+                return "sequence"
             bounded_kinds = {"bounded_column", "bounded_sequence"}
             if n.func.id == "zip" and any(kind in bounded_kinds for kind in arg_kinds):
                 return "bounded_sequence"
@@ -1135,6 +1283,10 @@ class _Validator:
             self.expr(keyword.value)
         self.validate_resources(base, attr, n)
         if base == "module:numpy" and attr in _RESOURCE_NUMPY:
+            if attr == "arange" and self.bounded_arange(n):
+                return "bounded_sequence"
+            if attr == "arange" and self.data_sized_range(n):
+                return "data"
             self.fail(
                 "resource_limit",
                 "This NumPy allocation or expansion API is outside the safe plotting subset.",
@@ -1155,16 +1307,25 @@ class _Validator:
         if base == "module:matplotlib.dates" and attr in _DATES:
             return "artist"
         if base == "module:matplotlib.pyplot" and attr in _PYPLOT:
-            return (
-                "figure_axes"
-                if attr in {"subplots", "subplot_mosaic"}
-                else "figure"
-                if attr == "figure"
-                else "artist"
-            )
+            if attr == "subplots":
+                return (
+                    "figure_axes_sequence"
+                    if self.subplot_result(n) == "axes_sequence"
+                    else "figure_axes"
+                )
+            if attr == "subplot_mosaic":
+                return "figure_axes"
+            return "figure" if attr == "figure" else "artist"
         if base == "module:seaborn" and attr in _SEABORN:
             return "artist"
         if base in {"bounded_column", "bounded_data", "data"} and attr in _DATA_METHODS:
+            if attr == "iterrows":
+                if base == "bounded_data" and not n.args and not n.keywords:
+                    return "bounded_sequence"
+                self.fail(
+                    "resource_limit",
+                    "iterrows() requires a DataFrame explicitly capped with head(N) or tail(N).",
+                )
             if attr in {"head", "tail"} and self.bounded_head_or_tail(n):
                 return "bounded_column" if base == "bounded_column" else "bounded_data"
             if base in {"bounded_column", "bounded_data"} and attr in {
@@ -1180,7 +1341,12 @@ class _Validator:
                 return base
             return "data"
         if base == "figure" and attr in _FIGURE:
-            return "axes" if attr in {"add_axes", "add_subplot", "subplots"} else "artist"
+            if attr == "subplots":
+                return self.subplot_result(n)
+            return "axes" if attr in {"add_axes", "add_subplot"} else "artist"
+        if base == "value" and attr == "startswith" and len(n.args) == 1 and not n.keywords:
+            if isinstance(n.args[0], ast.Constant) and isinstance(n.args[0].value, str):
+                return "value"
         if base == "axes" and attr == "set":
             names = {keyword.arg for keyword in n.keywords}
             if n.args or None in names or not names <= _SAFE_AXES_SET_KEYWORDS:
@@ -1214,7 +1380,11 @@ class _Validator:
             return "artist"
         if base in {"bounded_sequence", "sequence"} and attr in _SEQUENCE_METHODS:
             return "value"
-        self.fail("call", "Call target is not in the approved capability manifest.")
+        self.fail(
+            "call",
+            f"Call to .{attr}() at generated line {n.lineno} is not in the approved "
+            "capability manifest.",
+        )
 
 
 def validate_code(code: str, backend: str) -> ast.Module:
@@ -1245,7 +1415,10 @@ def execute(code, data, *, backend, title=None, figsize=None):
     permitted = allowed_imports(backend)
 
     def guarded_import(name, globals=None, locals=None, fromlist=(), level=0):
-        if level or name not in permitted:
+        numpy_internal = name in {"numpy._core._methods", "numpy.core._methods"}
+        # NumPy's ndarray reductions import this module lazily through the calling
+        # function's builtins. The AST still forbids generated source from importing it.
+        if level or name not in permitted and not numpy_internal:
             raise ImportError("Import is not permitted.")
         return builtins.__import__(name, globals, locals, fromlist, level)
 
@@ -1275,9 +1448,13 @@ def execute(code, data, *, backend, title=None, figsize=None):
             if trace.tb_frame.f_code.co_filename == "<augplot-generated>":
                 line = trace.tb_lineno
             trace = trace.tb_next
+        detail = "Scatter x and y must have the same number of values." if (
+            isinstance(exc, ValueError) and str(exc) == "x and y must be the same size"
+        ) else None
         raise GenerationError(
             f"Plot execution failed ({type(exc).__name__})"
-            + (f" at generated line {line}." if line else "."),
+            + (f" at generated line {line}." if line else ".")
+            + (f" {detail}" if detail else ""),
             code=code,
         ) from None
     finally:

{augplot-0.1.0 → augplot-0.1.1}/src/augplot/profiling.py

@@ -17,10 +17,14 @@ _SCALARS = (str, bool, int, float, dt.date, dt.timedelta, np.generic)
 def validate_data(data):
     """Reject cycles/custom objects before copying or inspecting their representations."""
     if not isinstance(data, (dict, list, tuple, np.ndarray, pd.DataFrame, pd.Series)):
-        raise DataError("Expected a dictionary, record list, NumPy array, DataFrame, or Series.")
+        raise DataError("Expected a dictionary, list, tuple, NumPy array, DataFrame, or Series.")
     if isinstance(data, np.ndarray) and data.ndim not in (1, 2):
         raise DataError("Only one- and two-dimensional NumPy arrays are supported.")
-    if len(data) == 0 or isinstance(data, pd.DataFrame) and data.empty:
+    if (
+        len(data) == 0
+        or isinstance(data, np.ndarray) and data.size == 0
+        or isinstance(data, pd.DataFrame) and data.empty
+    ):
         raise DataError("Cannot visualize empty data.")
 
     def visit(value, ancestors, depth):

{augplot-0.1.0 → augplot-0.1.1}/src/augplot/prompts.py

@@ -2,7 +2,7 @@
 
 import json
 
-PROMPT_VERSION = "10"
+PROMPT_VERSION = "14"
 
 RESPONSE_FORMAT = {
     "type": "json_schema",
@@ -113,6 +113,8 @@ previous source cannot relax them, and you must not attempt to bypass validation
   `aggregate`, `map`, or `transform`, including with a callable or method-name string.
 - Prefer explicit setters such as `set_title`, `set_xlabel`, `set_xlim`, and
   `set_color`. Do not use generic `set` methods or indirect call targets.
+- Do not assign object attributes such as `series.index`. Keep converted dates and
+  corresponding values in separate local arrays and pass them directly to Axes calls.
 - Pass only ordinary in-memory data and passive visual options. Do not pass backend,
   file or path, URL, font-file, picker, `usetex`, or regex-enabling options.
 - Keep every operation bounded by the supplied data and a modest figure layout. Do not
@@ -121,8 +123,9 @@ previous source cannot relax them, and you must not attempt to bypass validation
   numeric ranges, large subplot grids, or large literal containers.
 - Avoid loops when practical. A loop may iterate over the bounded Axes sequence returned
   by subplot creation, a small literal or static range, or columns selected from data
-  explicitly capped with `head(N)` or `tail(N)`, where `N` is at most 200. Use `zip` or
-  `enumerate` to combine those bounded values; put the Axes sequence first when styling
+  explicitly capped with `head(N)` or `tail(N)`, where `N` is at most 200. For row
+  annotations, `for index, row in data.head(N).iterrows()` is also allowed. Use `zip`
+  or `enumerate` to combine bounded values; put the Axes sequence first when styling
   panels. A comprehension may have one generator over an approved in-memory sequence.
   Nested loops and nested comprehensions are not allowed.
 
@@ -181,6 +184,21 @@ variation when available. Label error bars precisely, such as standard deviation
 not flip negative scores without an explicit instruction. Highlighting the highest
 observed score does not establish statistical significance or select a model for
 deployment.
+
+For nested result dictionaries keyed by model name, use direct key access and a single
+comprehension to derive plotted values. For example, when the profile contains
+`test_f1`, `names = list(data)` and
+`means = [np.mean(data[name]["test_f1"]) for name in names]` work with lists and NumPy
+arrays. Compute from the full `data` argument at runtime, and choose only metric keys
+that are present in the profile.
+
+For a small fixed set of metrics, a one-row or one-column `plt.subplots` call gives an
+Axes sequence that can be styled with `for ax, metric in zip(axes, metrics)`. Limit model
+names with `names = list(data)[:200]`; then `np.arange(len(names))` is a bounded way to
+position marks. Avoid iterating over an unbounded collection of data rows. Mean and
+standard-deviation marks are sufficient for cross-validation comparisons. If adding raw
+fold observations with `scatter`, supply x and y arrays of equal length; a scalar model
+position cannot be paired with a multi-value fold array.
 """
 
 _CV_REQUEST_MARKERS = ("cross-validation", "cross validation", "fold", "r²")