figurestead 0.9.0a1__tar.gz

figurestead-0.9.0a1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Figurestead contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

figurestead-0.9.0a1/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.3
+Name: figurestead
+Version: 0.9.0a1
+License: MIT
+Requires-Python: >=3.10
+Project-URL: Homepage, https://github.com/CharlesMish/figurestead
+Project-URL: Repository, https://github.com/CharlesMish/figurestead
+Project-URL: Issues, https://github.com/CharlesMish/figurestead/issues

figurestead-0.9.0a1/README.md

@@ -0,0 +1,10 @@
+# Figurestead experimental public alpha
+
+Figurestead is a framework-free scientific figure system for deterministic,
+inspectable Python and browser output. This experimental alpha contains six
+curated themes and uses Slipware as the default. Presentation profiles are
+independent from themes. The `monograph` profile is available through
+`get_profile("monograph")` and remains unavailable through `get_theme`.
+
+Python package: `figurestead` 0.9.0a1. Browser package: `@figurestead/web`
+0.9.0-alpha.1. Source: <https://github.com/CharlesMish/figurestead>.

figurestead-0.9.0a1/THIRD_PARTY_NOTICES.md

@@ -0,0 +1,39 @@
+# Third-party factual notice inventory
+
+Status: `EXPERIMENTAL PUBLIC-ALPHA FACTUAL NOTICE`
+
+This inventory records the dependency evidence used for the Figurestead
+experimental alpha; it makes no legal conclusion. Runtime dependencies are not
+vendored into the wheel, sdist, or npm tarball. The canonical Figurestead MIT
+text is supplied separately as `LICENSE`.
+
+## Python dependency observations
+
+An external Python 3.14.6 evidence environment resolved the current declared
+constraints on 2026-08-05 to Matplotlib 3.11.1, NumPy 2.5.1, Pillow 12.3.0,
+PyYAML 6.0.3, and setuptools 82.0.1, plus contourpy 1.3.3, cycler 0.12.1,
+fonttools 4.63.0, kiwisolver 1.5.0, packaging 26.3, pyparsing 3.3.2,
+python-dateutil 2.9.0.post0, and six 1.17.0. These versions are an evidence
+snapshot, not an approved runtime lock.
+
+The static-site PNGs are first-party deterministic synthetic Figurestead render
+outputs produced through Matplotlib. No font file is embedded as a separate
+site member. Matplotlib's evidence distribution includes its own license plus
+DejaVu and STIX font notices; rendered glyph provenance remains a review
+consideration. Site CSS names
+only system font families and carries no downloaded font bytes or remote URL.
+
+## Browser tooling observations
+
+The alpha verification environment used Playwright 1.61.1 and
+playwright-core 1.61.1 as
+Apache-2.0 development/test tooling and optional fsevents 2.3.2 as MIT. These
+packages and downloaded browsers are not intended npm-tarball members or
+top-level archive members. They remain test-tool provenance only.
+
+## Placement and maintenance
+
+Each Figurestead wheel, sdist, npm package, static-site bundle, and composition
+archive carries this file and `TRADEMARKS.md` beside its canonical `LICENSE`.
+Any newly resolved dependency version, copied source, font, image, or other
+byte requires a corresponding inventory update and review.

figurestead-0.9.0a1/TRADEMARKS.md

@@ -0,0 +1,13 @@
+# Trademarks and names
+
+Figurestead is an independent project.
+
+Names of third-party products, services, organizations, and trademarks remain
+the property of their respective owners. Their appearance in factual dependency
+or compatibility notices does not imply affiliation, sponsorship, or
+endorsement.
+
+The experimental public-alpha distribution is intentionally limited to six
+curated Figurestead themes.
+Legacy or franchise-derived internal themes are not part of the public
+distribution.

figurestead-0.9.0a1/pyproject.toml

@@ -0,0 +1,32 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "figurestead"
+version = "0.9.0a1"
+description = "A framework-free scientific figure system for deterministic, inspectable Python and browser output."
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.10"
+dependencies = ["matplotlib>=3.7", "numpy>=1.24", "Pillow>=10"]
+
+[project.urls]
+Homepage = "https://github.com/CharlesMish/figurestead"
+Repository = "https://github.com/CharlesMish/figurestead"
+Issues = "https://github.com/CharlesMish/figurestead/issues"
+
+[project.optional-dependencies]
+themes = ["PyYAML>=6"]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+figurestead = ["themes/*.json"]
+
+[project.scripts]
+figurestead-gallery = "figurestead.gallery:main"
+figurestead-motion-gallery = "figurestead.motion_gallery:main"
+figurestead-portable = "figurestead.portable:main"
+figurestead-theme = "figurestead.theme_io:main"

figurestead-0.9.0a1/src/figurestead/__init__.py

@@ -0,0 +1,78 @@
+"""figurestead public API."""
+
+from .core import PlotSpec
+from .plots import heatmap, histogram, line, scatter, strip_summary
+from .motion import MotionStyle, MotionTimeline, animate_line, animate_scatter, animate_strip_summary
+from .portable import PORTABLE_SCHEMA_VERSION, RENDERER_API_VERSION, export_contract, export_figure, portable_schema
+from .profiles import PROFILES, Profile, get_profile
+from .registry import PLOTS, available_plots, render
+from .themes import THEMES, Theme, get_theme
+from .theme_io import (
+    THEME_PACK_VERSION, PALETTE_PACK_VERSION, ThemePack, PalettePack, PaletteResolution, ThemePackError, apply_theme, compile_theme_pack,
+    contrast_audit, load_authored_theme_pack, load_compiled_theme_pack, load_theme, load_theme_pack,
+    normalize_theme_pack_lenient, preview_theme_pack, theme_to_contract,
+    load_palette_pack, resolve_palette,
+)
+from .presentation import EvidenceFocusAnnotation, FocusAnnotation, SCIENTIFIC_POSE, ScientificPose, apply_evidence_pose, apply_scientific_pose, monotone_curve
+from .application import APPLICATION_PROFILE_VERSION, APPLICATION_PROFILES, ApplicationProfile, apply_application_profile, get_application_profile
+from .scene import TERMINAL_SCENE_VERSION, compile_terminal_scene
+
+__all__ = [
+    "PLOTS",
+    "PROFILES",
+    "THEMES",
+    "PlotSpec",
+    "MotionStyle",
+    "MotionTimeline",
+    "PORTABLE_SCHEMA_VERSION",
+    "RENDERER_API_VERSION",
+    "Profile",
+    "Theme",
+    "ThemePack",
+    "ThemePackError",
+    "FocusAnnotation",
+    "EvidenceFocusAnnotation",
+    "ScientificPose",
+    "SCIENTIFIC_POSE",
+    "APPLICATION_PROFILE_VERSION",
+    "APPLICATION_PROFILES",
+    "ApplicationProfile",
+    "TERMINAL_SCENE_VERSION",
+    "apply_application_profile",
+    "get_application_profile",
+    "compile_terminal_scene",
+    "apply_scientific_pose",
+    "apply_evidence_pose",
+    "THEME_PACK_VERSION",
+    "PALETTE_PACK_VERSION",
+    "PalettePack",
+    "PaletteResolution",
+    "available_plots",
+    "animate_line",
+    "animate_scatter",
+    "animate_strip_summary",
+    "export_contract",
+    "export_figure",
+    "get_profile",
+    "get_theme",
+    "load_theme",
+    "load_theme_pack",
+    "load_authored_theme_pack",
+    "load_compiled_theme_pack",
+    "normalize_theme_pack_lenient",
+    "load_palette_pack",
+    "resolve_palette",
+    "compile_theme_pack",
+    "apply_theme",
+    "contrast_audit",
+    "preview_theme_pack",
+    "theme_to_contract",
+    "heatmap",
+    "histogram",
+    "line",
+    "monotone_curve",
+    "portable_schema",
+    "render",
+    "scatter",
+    "strip_summary",
+]

figurestead-0.9.0a1/src/figurestead/adapters/__init__.py

@@ -0,0 +1 @@
+"""Strict, additive adapters for Figurestead portable contracts."""

figurestead-0.9.0a1/src/figurestead/adapters/tabular.py

@@ -0,0 +1,399 @@
+"""Strict records and CSV ingress for existing portable contracts.
+
+This module deliberately performs no inference, coercion, aggregation, sorting,
+interpolation, or imputation.  Validation completes before ``export_contract``
+is called so rejected input cannot produce partial Figurestead evidence.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+import csv
+import math
+import os
+from pathlib import Path
+import re
+from typing import Any
+
+from figurestead import portable
+
+
+_CSV_NUMBER = re.compile(r"^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$")
+
+
+class TabularIngressError(ValueError):
+    """Raised when tabular input cannot be converted without ambiguity."""
+
+
+def _error(path: str, message: str) -> TabularIngressError:
+    return TabularIngressError(f"{path}: {message}")
+
+
+def _column_name(value: Any, argument: str) -> str:
+    if not isinstance(value, str) or not value.strip():
+        raise _error(argument, "must be a nonblank column-name string")
+    return value
+
+
+def _validate_dataframe_columns(source: Any) -> None:
+    try:
+        columns = source.columns
+    except AttributeError:
+        return
+    except Exception as exc:
+        raise _error("header", f"DataFrame-like column metadata could not be read: {exc}") from exc
+    if isinstance(columns, (str, bytes, bytearray)):
+        raise _error("header", "DataFrame-like columns must be an iterable of unique labels")
+    try:
+        labels = list(columns)
+    except TypeError as exc:
+        raise _error("header", "DataFrame-like columns must be an iterable of unique labels") from exc
+    seen: set[Any] = set()
+    for index, label in enumerate(labels):
+        try:
+            duplicate = label in seen
+            seen.add(label)
+        except TypeError as exc:
+            raise _error(f"header[{index}]", "DataFrame-like column labels must be hashable") from exc
+        if duplicate:
+            path = f"header.{label}" if isinstance(label, str) and label else f"header[{index}]"
+            raise _error(path, "duplicate column name")
+
+
+def _record_rows(source: Any, required: set[str]) -> list[dict[str, Any]]:
+    if isinstance(source, (str, bytes, bytearray, Mapping)):
+        raise _error("source", "must be a non-string sequence of mappings or DataFrame-like object")
+    if hasattr(source, "to_dict"):
+        _validate_dataframe_columns(source)
+        try:
+            source = source.to_dict(orient="records")
+        except Exception as exc:  # the foreign object owns the concrete failure
+            raise _error("source", f"to_dict(orient='records') failed: {exc}") from exc
+    if not isinstance(source, Sequence) or isinstance(source, (str, bytes, bytearray)):
+        raise _error("source", "must be a non-string sequence of mappings or DataFrame-like object")
+    rows: list[dict[str, Any]] = []
+    for index, row in enumerate(source, 1):
+        if not isinstance(row, Mapping):
+            raise _error(f"row {index}", "must be a mapping")
+        copied = dict(row)
+        missing = sorted(required - copied.keys())
+        if missing:
+            raise _error(f"row {index}.{missing[0]}", "required column is missing")
+        rows.append(copied)
+    if not rows:
+        raise _error("source", "must contain at least one data row")
+    return rows
+
+
+def _reject_url(value: str) -> None:
+    if re.match(r"^[A-Za-z][A-Za-z0-9+.-]*://", value):
+        raise _error("source", "network URLs are not accepted")
+
+
+def _csv_text(source: Any) -> str:
+    if isinstance(source, str):
+        _reject_url(source)
+        if "\n" in source or "\r" in source:
+            raise _error("source", "inline CSV strings are not accepted; use a path or text stream")
+        path = Path(source)
+        try:
+            return path.read_text(encoding="utf-8")
+        except (OSError, UnicodeError) as exc:
+            raise _error("source", f"CSV path could not be read: {exc}") from exc
+    if isinstance(source, os.PathLike):
+        path = Path(source)
+        try:
+            return path.read_text(encoding="utf-8")
+        except (OSError, UnicodeError) as exc:
+            raise _error("source", f"CSV path could not be read: {exc}") from exc
+    if isinstance(source, (bytes, bytearray)):
+        raise _error("source", "binary CSV input is not accepted")
+    reader = getattr(source, "read", None)
+    if not callable(reader):
+        raise _error("source", "must be a filesystem path or readable text stream")
+    try:
+        text = reader()
+    except Exception as exc:
+        raise _error("source", f"text stream could not be read: {exc}") from exc
+    if not isinstance(text, str):
+        raise _error("source", "binary streams are not accepted")
+    return text
+
+
+def _csv_rows(source: Any, required: set[str]) -> list[dict[str, str]]:
+    text = _csv_text(source)
+    try:
+        parsed = list(csv.reader(text.splitlines(), strict=True))
+    except csv.Error as exc:
+        raise _error("source", f"malformed CSV: {exc}") from exc
+    if not parsed:
+        raise _error("header", "CSV header is required")
+    header = parsed[0]
+    if not header:
+        raise _error("header", "CSV header is required")
+    seen: set[str] = set()
+    for name in header:
+        if not name:
+            raise _error("header", "column names must be nonblank")
+        if name in seen:
+            raise _error(f"header.{name}", "duplicate column name")
+        seen.add(name)
+    missing = sorted(required - seen)
+    if missing:
+        raise _error(f"header.{missing[0]}", "required column is missing")
+    rows: list[dict[str, str]] = []
+    for index, values in enumerate(parsed[1:], 1):
+        if len(values) != len(header):
+            raise _error(f"row {index}", f"expected {len(header)} columns, found {len(values)}")
+        rows.append(dict(zip(header, values, strict=True)))
+    if not rows:
+        raise _error("source", "must contain at least one data row")
+    return rows
+
+
+def _record_number(row: Mapping[str, Any], row_index: int, column: str) -> float:
+    value = row[column]
+    if isinstance(value, bool) or not isinstance(value, (int, float)) or not math.isfinite(value):
+        raise _error(f"row {row_index}.{column}", "must be a finite int or float (bool and numeric strings are rejected)")
+    return float(value)
+
+
+def _csv_number(row: Mapping[str, str], row_index: int, column: str) -> float:
+    value = row[column]
+    if value != value.strip() or not _CSV_NUMBER.fullmatch(value):
+        raise _error(f"row {row_index}.{column}", "must exactly match the finite CSV numeric grammar")
+    result = float(value)
+    if not math.isfinite(result):
+        raise _error(f"row {row_index}.{column}", "must parse to a finite number")
+    return result
+
+
+def _category(row: Mapping[str, Any], row_index: int, column: str) -> str:
+    value = row[column]
+    if not isinstance(value, str) or not value.strip():
+        raise _error(f"row {row_index}.{column}", "must be a nonblank string")
+    return value
+
+
+def _numeric_order(value: Any, argument: str) -> list[float]:
+    if not isinstance(value, Sequence) or isinstance(value, (str, bytes, bytearray)) or not value:
+        raise _error(argument, "must be a nonempty sequence of unique finite numbers")
+    result: list[float] = []
+    for index, item in enumerate(value):
+        if isinstance(item, bool) or not isinstance(item, (int, float)) or not math.isfinite(item):
+            raise _error(f"{argument}[{index}]", "must be a finite number")
+        number = float(item)
+        if number in result:
+            raise _error(f"{argument}[{index}]", "duplicate order member")
+        result.append(number)
+    return result
+
+
+def _string_order(value: Any, argument: str) -> list[str]:
+    if not isinstance(value, Sequence) or isinstance(value, (str, bytes, bytearray)) or not value:
+        raise _error(argument, "must be a nonempty sequence of unique nonblank strings")
+    result: list[str] = []
+    for index, item in enumerate(value):
+        if not isinstance(item, str) or not item.strip():
+            raise _error(f"{argument}[{index}]", "must be a nonblank string")
+        if item in result:
+            raise _error(f"{argument}[{index}]", "duplicate order member")
+        result.append(item)
+    return result
+
+
+def _domain(value: Any, argument: str) -> list[float] | None:
+    if value is None:
+        return None
+    if not isinstance(value, Sequence) or isinstance(value, (str, bytes, bytearray)) or len(value) != 2:
+        raise _error(argument, "must contain exactly two finite increasing numbers")
+    result = []
+    for index, item in enumerate(value):
+        if isinstance(item, bool) or not isinstance(item, (int, float)) or not math.isfinite(item):
+            raise _error(f"{argument}[{index}]", "must be a finite number")
+        result.append(float(item))
+    if result[0] >= result[1]:
+        raise _error(argument, "must be strictly increasing")
+    return result
+
+
+def _require_members(observed: list[Any], order: list[Any], argument: str, column: str) -> None:
+    unknown = [item for item in observed if item not in order]
+    if unknown:
+        raise _error(column, f"observed member {unknown[0]!r} is absent from {argument}")
+    extras = [item for item in order if item not in observed]
+    if extras:
+        raise _error(argument, f"member {extras[0]!r} is not observed")
+
+
+def _common_columns(*values: tuple[Any, str]) -> set[str]:
+    return {_column_name(value, argument) for value, argument in values}
+
+
+def _line(rows: list[Mapping[str, Any]], *, numeric, spec, x: str, series: str,
+          value: str, x_order, series_order, x_domain, y_domain, reveal_order,
+          theme, profile, timeline, motion, application_profile):
+    x_values = _numeric_order(x_order, "x_order")
+    series_values = _string_order(series_order, "series_order")
+    if reveal_order not in {"random", "x"}:
+        raise _error("reveal_order", "must be 'random' or 'x'")
+    cells: dict[tuple[float, str], float] = {}
+    observed_x: list[float] = []
+    observed_series: list[str] = []
+    for index, row in enumerate(rows, 1):
+        row_x = numeric(row, index, x)
+        row_series = _category(row, index, series)
+        row_value = numeric(row, index, value)
+        if row_x not in observed_x:
+            observed_x.append(row_x)
+        if row_series not in observed_series:
+            observed_series.append(row_series)
+        cell = (row_x, row_series)
+        if cell in cells:
+            raise _error(f"row {index}.{value}", f"duplicate line cell for x={row_x!r}, series={row_series!r}")
+        cells[cell] = row_value
+    _require_members(observed_x, x_values, "x_order", x)
+    _require_members(observed_series, series_values, "series_order", series)
+    missing = [(row_x, row_series) for row_x in x_values for row_series in series_values if (row_x, row_series) not in cells]
+    if missing:
+        raise _error("data", f"incomplete line grid; missing x={missing[0][0]!r}, series={missing[0][1]!r}")
+    data: dict[str, Any] = {
+        "x": x_values,
+        "series": [{"key": key, "label": key, "y": [cells[(row_x, key)] for row_x in x_values]} for key in series_values],
+        "revealOrder": reveal_order,
+    }
+    if (domain := _domain(x_domain, "x_domain")) is not None:
+        data["xDomain"] = domain
+    if (domain := _domain(y_domain, "y_domain")) is not None:
+        data["yDomain"] = domain
+    return portable.export_contract(renderer="line", spec=spec, data=data, theme=theme,
+                                    profile=profile, timeline=timeline, motion=motion,
+                                    application_profile=application_profile)
+
+
+def _scatter(rows: list[Mapping[str, Any]], *, numeric, spec, x: str, y: str,
+             series: str | None, x_domain, y_domain, summary, theme, profile,
+             timeline, motion, application_profile):
+    if series is not None:
+        _column_name(series, "series")
+    xs, ys, identities = [], [], []
+    for index, row in enumerate(rows, 1):
+        xs.append(numeric(row, index, x))
+        ys.append(numeric(row, index, y))
+        identities.append(_category(row, index, series) if series is not None else "series")
+    labels = {key: key for key in dict.fromkeys(identities)}
+    data: dict[str, Any] = {"x": xs, "y": ys, "series": identities, "seriesLabels": labels}
+    if summary is not None:
+        data["summary"] = summary
+    if (domain := _domain(x_domain, "x_domain")) is not None:
+        data["xDomain"] = domain
+    if (domain := _domain(y_domain, "y_domain")) is not None:
+        data["yDomain"] = domain
+    return portable.export_contract(renderer="scatter", spec=spec, data=data, theme=theme,
+                                    profile=profile, timeline=timeline, motion=motion,
+                                    application_profile=application_profile)
+
+
+def _strip(rows: list[Mapping[str, Any]], *, numeric, spec, value: str, group: str,
+           group_order, series: str | None, summary, y_domain, theme, profile,
+           timeline, motion, application_profile):
+    groups = _string_order(group_order, "group_order")
+    if series is not None:
+        _column_name(series, "series")
+    values, assignments, identities = [], [], []
+    for index, row in enumerate(rows, 1):
+        values.append(numeric(row, index, value))
+        assignments.append(_category(row, index, group))
+        identities.append(_category(row, index, series) if series is not None else "series")
+    _require_members(list(dict.fromkeys(assignments)), groups, "group_order", group)
+    labels = {key: key for key in dict.fromkeys(identities)}
+    data: dict[str, Any] = {
+        "values": values, "groups": groups, "group": assignments,
+        "series": identities, "seriesLabels": labels,
+    }
+    if summary is not None:
+        data["summary"] = summary
+    if (domain := _domain(y_domain, "y_domain")) is not None:
+        data["yDomain"] = domain
+    return portable.export_contract(renderer="strip_summary", spec=spec, data=data,
+                                    theme=theme, profile=profile, timeline=timeline,
+                                    motion=motion, application_profile=application_profile)
+
+
+def line_from_records(records_or_dataframe_like, *, spec, x, series, value,
+                      x_order, series_order, x_domain=None, y_domain=None,
+                      reveal_order="random", theme="slipware",
+                      profile="deep_scope", timeline=None, motion=None,
+                      application_profile="atlas"):
+    required = _common_columns((x, "x"), (series, "series"), (value, "value"))
+    rows = _record_rows(records_or_dataframe_like, required)
+    return _line(rows, numeric=_record_number, spec=spec, x=x, series=series,
+                 value=value, x_order=x_order, series_order=series_order,
+                 x_domain=x_domain, y_domain=y_domain, reveal_order=reveal_order,
+                 theme=theme, profile=profile, timeline=timeline, motion=motion,
+                 application_profile=application_profile)
+
+
+def line_from_csv(source, *, spec, x, series, value, x_order, series_order,
+                  x_domain=None, y_domain=None, reveal_order="random",
+                  theme="slipware", profile="deep_scope", timeline=None,
+                  motion=None, application_profile="atlas"):
+    required = _common_columns((x, "x"), (series, "series"), (value, "value"))
+    rows = _csv_rows(source, required)
+    return _line(rows, numeric=_csv_number, spec=spec, x=x, series=series,
+                 value=value, x_order=x_order, series_order=series_order,
+                 x_domain=x_domain, y_domain=y_domain, reveal_order=reveal_order,
+                 theme=theme, profile=profile, timeline=timeline, motion=motion,
+                 application_profile=application_profile)
+
+
+def scatter_from_records(records_or_dataframe_like, *, spec, x, y, series=None,
+                         x_domain=None, y_domain=None, summary=None,
+                         theme="slipware", profile="deep_scope", timeline=None,
+                         motion=None, application_profile="atlas"):
+    required = _common_columns((x, "x"), (y, "y"), *((series, "series"),) if series is not None else ())
+    rows = _record_rows(records_or_dataframe_like, required)
+    return _scatter(rows, numeric=_record_number, spec=spec, x=x, y=y,
+                    series=series, x_domain=x_domain, y_domain=y_domain,
+                    summary=summary, theme=theme, profile=profile,
+                    timeline=timeline, motion=motion,
+                    application_profile=application_profile)
+
+
+def scatter_from_csv(source, *, spec, x, y, series=None, x_domain=None,
+                     y_domain=None, summary=None, theme="slipware",
+                     profile="deep_scope", timeline=None, motion=None,
+                     application_profile="atlas"):
+    required = _common_columns((x, "x"), (y, "y"), *((series, "series"),) if series is not None else ())
+    rows = _csv_rows(source, required)
+    return _scatter(rows, numeric=_csv_number, spec=spec, x=x, y=y,
+                    series=series, x_domain=x_domain, y_domain=y_domain,
+                    summary=summary, theme=theme, profile=profile,
+                    timeline=timeline, motion=motion,
+                    application_profile=application_profile)
+
+
+def strip_from_records(records_or_dataframe_like, *, spec, value, group,
+                       group_order, series=None, summary=None, y_domain=None,
+                       theme="slipware", profile="deep_scope", timeline=None,
+                       motion=None, application_profile="atlas"):
+    required = _common_columns((value, "value"), (group, "group"), *((series, "series"),) if series is not None else ())
+    rows = _record_rows(records_or_dataframe_like, required)
+    return _strip(rows, numeric=_record_number, spec=spec, value=value,
+                  group=group, group_order=group_order, series=series,
+                  summary=summary, y_domain=y_domain, theme=theme,
+                  profile=profile, timeline=timeline, motion=motion,
+                  application_profile=application_profile)
+
+
+def strip_from_csv(source, *, spec, value, group, group_order, series=None,
+                   summary=None, y_domain=None, theme="slipware",
+                   profile="deep_scope", timeline=None, motion=None,
+                   application_profile="atlas"):
+    required = _common_columns((value, "value"), (group, "group"), *((series, "series"),) if series is not None else ())
+    rows = _csv_rows(source, required)
+    return _strip(rows, numeric=_csv_number, spec=spec, value=value,
+                  group=group, group_order=group_order, series=series,
+                  summary=summary, y_domain=y_domain, theme=theme,
+                  profile=profile, timeline=timeline, motion=motion,
+                  application_profile=application_profile)

figurestead-0.9.0a1/src/figurestead/application.py

@@ -0,0 +1,63 @@
+"""Application profiles for publication, atlas, and presentation output."""
+
+from __future__ import annotations
+
+from copy import deepcopy
+from dataclasses import dataclass
+from typing import Any, Mapping
+
+
+APPLICATION_PROFILE_VERSION = "figurestead.application-profile/1"
+
+
+@dataclass(frozen=True)
+class ApplicationProfile:
+    key: str
+    name: str
+    surface: str
+    density: str
+    typography: str
+    legend: str
+    ambient: str
+    motion: str
+    line_width: float
+    marker_scale: float
+    panel_surface: bool
+    frame: bool
+
+
+APPLICATION_PROFILES = {
+    "paper": ApplicationProfile("paper", "Paper", "neutral", "compact", "publication", "outside", "none", "none", 1.55, .92, False, False),
+    "atlas": ApplicationProfile("atlas", "Atlas", "themed", "balanced", "scientific", "auto", "none", "semantic", 2.15, 1.12, True, True),
+    "talk": ApplicationProfile("talk", "Talk", "themed", "open", "display", "auto", "none", "semantic", 2.75, 1.34, True, True),
+}
+
+
+def get_application_profile(profile: str | ApplicationProfile = "atlas") -> ApplicationProfile:
+    if isinstance(profile, ApplicationProfile):
+        return profile
+    try:
+        return APPLICATION_PROFILES[profile]
+    except KeyError as exc:
+        raise ValueError(f"Unknown application profile {profile!r}; choose: {', '.join(APPLICATION_PROFILES)}") from exc
+
+
+def apply_application_profile(contract: Mapping[str, Any], profile: str | ApplicationProfile = "atlas", *, motion: str | None = None, ambient: str | None = None) -> dict[str, Any]:
+    result = deepcopy(dict(contract))
+    value = get_application_profile(profile)
+    previous = get_application_profile(result.get("view", {}).get("profile", "atlas"))
+    previous_presentation = {
+        "panelSurface": previous.panel_surface, "frame": previous.frame,
+        "legend": "outside-right" if previous.legend == "outside" else "auto" if previous.legend == "auto" else "bottom-right",
+        "lineWidth": previous.line_width, "markerScale": previous.marker_scale,
+    }
+    result["view"] = {"profile": value.key, "motion": motion or value.motion, "ambient": ambient or value.ambient, "strategy": "auto" if (motion or value.motion) == "semantic" else "none"}
+    for panel in result.get("panels", []):
+        overrides = {key: item for key, item in dict(panel.get("presentation", {})).items() if previous_presentation.get(key) != item}
+        panel["presentation"] = {
+            "panelSurface": value.panel_surface, "frame": value.frame,
+            "legend": "outside-right" if value.legend == "outside" else "auto" if value.legend == "auto" else "bottom-right",
+            "lineWidth": value.line_width, "markerScale": value.marker_scale,
+            **overrides,
+        }
+    return result