renderplan 0.1.0__py3-none-any.whl

renderplan/__init__.py

@@ -0,0 +1,77 @@
+from .codec import (
+    load_any,
+    load_manifest,
+    load_plan,
+    load_preflight,
+    load_profile,
+    save_manifest,
+    save_plan,
+    save_preflight,
+    save_profile,
+)
+from .errors import CodecError, RenderPlanError, ValidationError
+from .model import (
+    MANIFEST_FORMAT,
+    PLAN_FORMAT,
+    PREFLIGHT_FORMAT,
+    PROFILE_FORMAT,
+    AudioItem,
+    CapacityConstraint,
+    PauseItem,
+    PausePolicy,
+    PlanningPolicy,
+    PreflightCheck,
+    PreflightReport,
+    Producer,
+    RenderManifest,
+    RenderPlan,
+    RenderProfile,
+    ReplanRequest,
+    RoleProfile,
+    RoleRequirements,
+    SourceSpan,
+    SpeechArtifact,
+    SpeechControl,
+    SpeechItem,
+    TokenBundle,
+)
+from .version import __version__
+
+__all__ = [
+    "MANIFEST_FORMAT",
+    "PLAN_FORMAT",
+    "PREFLIGHT_FORMAT",
+    "PROFILE_FORMAT",
+    "AudioItem",
+    "CapacityConstraint",
+    "CodecError",
+    "PauseItem",
+    "PausePolicy",
+    "PlanningPolicy",
+    "PreflightCheck",
+    "PreflightReport",
+    "Producer",
+    "RenderManifest",
+    "RenderPlan",
+    "RenderPlanError",
+    "RenderProfile",
+    "ReplanRequest",
+    "RoleProfile",
+    "RoleRequirements",
+    "SourceSpan",
+    "SpeechArtifact",
+    "SpeechControl",
+    "SpeechItem",
+    "TokenBundle",
+    "ValidationError",
+    "__version__",
+    "load_any",
+    "load_manifest",
+    "load_plan",
+    "load_preflight",
+    "load_profile",
+    "save_manifest",
+    "save_plan",
+    "save_preflight",
+    "save_profile",
+]

renderplan/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+raise SystemExit(main())

renderplan/_toml.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+import json
+import re
+from collections.abc import Mapping, Sequence
+from typing import Any
+
+_BARE_KEY = re.compile(r"^[A-Za-z0-9_-]+$")
+
+
+def _key(value: str) -> str:
+    return value if _BARE_KEY.fullmatch(value) else json.dumps(value, ensure_ascii=False)
+
+
+def _path(parts: tuple[str, ...]) -> str:
+    return ".".join(_key(part) for part in parts)
+
+
+def _value(value: Any) -> str:
+    if isinstance(value, bool):
+        return "true" if value else "false"
+    if isinstance(value, str):
+        return json.dumps(value, ensure_ascii=False)
+    if isinstance(value, int):
+        return str(value)
+    if isinstance(value, float):
+        return repr(value)
+    if isinstance(value, Sequence) and not isinstance(value, (str, bytes, bytearray)):
+        return "[" + ", ".join(_value(item) for item in value) + "]"
+    raise TypeError(f"unsupported TOML scalar {type(value).__name__}")
+
+
+def _is_aot(value: Any) -> bool:
+    return (
+        isinstance(value, list)
+        and bool(value)
+        and all(isinstance(item, Mapping) for item in value)
+    )
+
+
+def _emit_mapping(
+    lines: list[str], mapping: Mapping[str, Any], prefix: tuple[str, ...], *, header: bool
+) -> None:
+    scalars: list[tuple[str, Any]] = []
+    tables: list[tuple[str, Mapping[str, Any]]] = []
+    arrays: list[tuple[str, list[Mapping[str, Any]]]] = []
+
+    for raw_key, value in sorted(mapping.items(), key=lambda entry: str(entry[0])):
+        key = str(raw_key)
+        if isinstance(value, Mapping):
+            tables.append((key, value))
+        elif _is_aot(value):
+            arrays.append((key, value))
+        else:
+            scalars.append((key, value))
+
+    if header:
+        if lines and lines[-1] != "":
+            lines.append("")
+        lines.append(f"[{_path(prefix)}]")
+
+    for key, value in scalars:
+        lines.append(f"{_key(key)} = {_value(value)}")
+
+    for key, table in tables:
+        _emit_mapping(lines, table, prefix + (key,), header=True)
+
+    for key, entries in arrays:
+        path = prefix + (key,)
+        for entry in entries:
+            if lines and lines[-1] != "":
+                lines.append("")
+            lines.append(f"[[{_path(path)}]]")
+            _emit_mapping(lines, entry, path, header=False)
+
+
+def dumps(mapping: Mapping[str, Any]) -> str:
+    lines: list[str] = []
+    _emit_mapping(lines, mapping, (), header=False)
+    while lines and lines[-1] == "":
+        lines.pop()
+    return "\n".join(lines) + "\n"

renderplan/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '0.1.0'
+__version_tuple__ = version_tuple = (0, 1, 0)
+
+__commit_id__ = commit_id = 'g7cf517359'

renderplan/cli.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+from .codec import load_any
+from .model import (
+    AudioItem,
+    PauseItem,
+    PreflightReport,
+    RenderManifest,
+    RenderPlan,
+    RenderProfile,
+)
+from .version import __version__
+
+
+def _summary(value: object) -> str:
+    if isinstance(value, RenderProfile):
+        fallbacks = ",".join(value.planning.capacity_fallback)
+        return (
+            f"renderprofile {value.profile_id or value.computed_id()} roles={len(value.roles)} "
+            f"split={value.planning.split} fallbacks={fallbacks}"
+        )
+    if isinstance(value, RenderPlan):
+        pauses = sum(isinstance(item, PauseItem) for item in value.flow)
+        audio = sum(isinstance(item, AudioItem) for item in value.flow)
+        return "\n".join(
+            (
+                f"renderplan {value.plan_id or value.computed_id()}",
+                f"  source_plan: {value.source_plan_id}",
+                f"  profile:     {value.render_profile_id}",
+                f"  speech:      {len(value.speech)}",
+                f"  pauses:      {pauses}",
+                f"  audio:       {audio}",
+            )
+        )
+    if isinstance(value, PreflightReport):
+        too_long = sum(check.status == "too_long" for check in value.checks)
+        return "\n".join(
+            (
+                f"renderplan-preflight {value.report_id or value.computed_id()}",
+                f"  plan:        {value.render_plan_id}",
+                f"  status:      {value.status}",
+                f"  checked:     {len(value.checks)}",
+                f"  too_long:    {too_long}",
+            )
+        )
+    if isinstance(value, RenderManifest):
+        return "\n".join(
+            (
+                f"render-manifest {value.manifest_id or value.computed_id()}",
+                f"  plan:        {value.render_plan_id}",
+                f"  complete:    {str(value.complete).lower()}",
+                f"  speech:      {len(value.speech)}",
+            )
+        )
+    raise AssertionError(type(value))
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(prog="renderplan")
+    parser.add_argument("--version", action="version", version=__version__)
+    sub = parser.add_subparsers(dest="command", required=True)
+    for name in ("validate", "inspect"):
+        command = sub.add_parser(name)
+        command.add_argument("file", type=Path)
+    args = parser.parse_args(argv)
+    value = load_any(args.file)
+    print(_summary(value))
+    return 0