prettyplay 0.0.0__py3-none-any.whl

prettyplay/scenario.py

@@ -0,0 +1,291 @@
+"""The integrator-facing object: one PrettyTest per test owns the addressing and the page."""
+
+from __future__ import annotations
+
+import types
+from pathlib import Path
+from types import TracebackType
+
+from .cache import StepCache
+from .config import PrettyConfig, load_config
+from .driver import PageFacade
+from .engine import StepGenerator, StepHealer
+from .executor import StepExecutor
+from .failures.errors import PrettyplayError
+from .reporting import StepHooks, StepReporter
+from .runtime import PrettyplayRuntime
+
+
+def _raise_folded(error: PrettyplayError) -> types.NoReturn:
+    """Re-raise a library failure with its traceback folded to this boundary.
+
+    The head link of the caught traceback is the facade method's own frame;
+    the folded traceback keeps exactly that link, so the internal library
+    frames (engine, healing, provider) never appear in what the runner shows.
+    The same exception object is re-raised — never a copy — keeping identity
+    for hook consumers and ``except`` clauses, and adding no context nesting.
+    The chained exceptions (``__context__``/``__cause__``) keep their identity
+    and messages — the original step failure stays visible for debugging —
+    but their tracebacks are folded away too: a runner that renders the chain
+    shows no internal frames either.
+
+    Args:
+        error: the library failure leaving ``action``/``assertion``.
+
+    Raises:
+        Always: the given error with the folded traceback attached.
+    """
+    tb = error.__traceback__
+    _fold_chain_tracebacks(error)
+
+    folded = types.TracebackType(
+        tb_next=None,
+        tb_frame=tb.tb_frame,
+        tb_lasti=tb.tb_lasti,
+        tb_lineno=tb.tb_lineno,
+    )
+
+    raise error.with_traceback(folded)
+
+
+def _fold_chain_tracebacks(error: BaseException) -> None:
+    """Drop the tracebacks of the chained exceptions, keeping the chains themselves.
+
+    Args:
+        error: the exception whose ``__context__``/``__cause__`` chains are folded.
+    """
+    pending = [error]
+    seen: set[int] = set()
+
+    while pending:
+        current = pending.pop()
+
+        if id(current) in seen:
+            continue
+
+        seen.add(id(current))
+
+        for link in (current.__context__, current.__cause__):
+            if link is not None:
+                link.__traceback__ = None
+                pending.append(link)
+
+
+class PrettyTest:
+    """The main object of the integrator: one instance per UI test.
+
+    The test writes its scenario in plain sentences — :meth:`action` and
+    :meth:`assertion` — and this object does the rest: addressing of the
+    cached steps by the context key, the isolated page of the test, and the
+    full step cycle delegated to the executor. Construction is cheap: the
+    page opens lazily on the first step and no LLM credential is needed.
+    Every test composes its own runtime here — no process-wide state, no
+    state leaks between tests; two tests in one process hold two runtimes,
+    two attempt registries and two browser sessions.
+
+    Attributes:
+        _runtime: the composition root owned by this one test.
+        _reporter: the visibility point of this test.
+        _cache: the step cache of this test.
+        _generator: the generation engine of this test.
+        _healer: the healing engine of this test.
+        _executor: the owner of the step cycle of this test.
+        _page: the isolated page of this test; ``None`` until the first step.
+    """
+
+    def __init__(self, cache_key: str, cache_path: str | None = None, config: PrettyConfig | None = None) -> None:
+        """Compose the per-test objects over the runtime this test owns.
+
+        Args:
+            cache_key: the context key of the test; the addressing part of
+                every cached step of this scenario.
+            cache_path: the optional subdirectory inside the cache; part of
+                the address, so steps of different subdirectories never
+                collide.
+            config: the programmatic settings layer; explicitly set values
+                win over the pyproject+env file layer, unset and empty
+                fields resolve from it. ``None`` resolves everything from
+                the file layer, as before.
+        """
+        effective = load_config(None, config)
+        self._runtime = PrettyplayRuntime(effective)
+        self._reporter = StepReporter(hooks=[])
+        self._cache = StepCache(self._runtime.config, cache_path, self._reporter)
+
+        self._generator = StepGenerator(
+            self._runtime.config,
+            self._runtime.provider,
+            self._cache,
+            self._runtime.budgets,
+            self._reporter,
+        )
+        self._healer = StepHealer(
+            self._runtime.config,
+            self._runtime.provider,
+            self._generator,
+            self._cache,
+            self._runtime.budgets,
+            self._reporter,
+        )
+        self._executor = StepExecutor(
+            cache_key,
+            self._cache,
+            self._generator,
+            self._healer,
+            self._runtime.budgets,
+            self._reporter,
+        )
+        self._page: PageFacade | None = None
+
+    @property
+    def cache_key(self) -> str:
+        """The context key of this test, for diagnostics."""
+        return self._executor.cache_key
+
+    def _ensure_page(self) -> PageFacade:
+        """Open the isolated page of this test lazily, exactly once.
+
+        Returns:
+            The page facade of this test.
+        """
+        if self._page is None:
+            self._page = self._runtime.open_page()
+        return self._page
+
+    def action(self, text: str) -> None:
+        """Execute one action step sentence through the step cycle.
+
+        A library failure leaving this method carries its traceback folded to
+        this boundary: the runner sees the test frame and the boundary frame
+        with the rendered message, never the internal engine frames.
+
+        Args:
+            text: the sentence of the action as written by the engineer.
+
+        Raises:
+            ProductDefectError: the step expectation is genuinely broken in the product.
+            IncurableStepError: the step never generated successfully, or the verdict
+                says regeneration cannot help.
+            LlmUnavailableError: the provider service failed; no retry.
+        """
+        try:
+            self._executor.execute(text, "action", self._ensure_page())
+        except PrettyplayError as error:
+            _raise_folded(error)
+
+    def assertion(self, text: str) -> None:
+        """Execute one assertion step sentence through the step cycle.
+
+        A library failure leaving this method carries its traceback folded to
+        this boundary, exactly as :meth:`action` does.
+
+        Args:
+            text: the sentence of the assertion as written by the engineer.
+
+        Raises:
+            ProductDefectError: the step expectation is genuinely broken in the product.
+            IncurableStepError: the step never generated successfully, or the verdict
+                says regeneration cannot help.
+            LlmUnavailableError: the provider service failed; no retry.
+        """
+        try:
+            self._executor.execute(text, "assertion", self._ensure_page())
+        except PrettyplayError as error:
+            _raise_folded(error)
+
+    def get_screenshot(self) -> bytes:
+        """Return a full-page PNG screenshot of the current test page.
+
+        The decision to take a screenshot belongs to the author: nothing is
+        captured automatically on step failures.
+
+        Returns:
+            The PNG image bytes of the page.
+
+        Raises:
+            PrettyplayError: no test page exists yet — run a step first.
+        """
+        if self._page is None:
+            raise PrettyplayError("no test page yet: run a step first — the page opens lazily on the first step")
+
+        return self._page.screenshot()
+
+    def save_screenshot(self, filepath: str) -> None:
+        """Save a full-page PNG screenshot of the current test page to a file.
+
+        Parent directories are not created: nothing is created silently —
+        a missing directory is a loud failure.
+
+        Args:
+            filepath: the destination path of the PNG file.
+
+        Raises:
+            PrettyplayError: no test page exists yet, or the file cannot be
+                written; the original ``OSError`` is chained.
+        """
+        if self._page is None:
+            raise PrettyplayError("no test page yet: run a step first — the page opens lazily on the first step")
+
+        image = self._page.screenshot()
+
+        try:
+            Path(filepath).write_bytes(image)
+        except OSError as error:
+            raise PrettyplayError(f"cannot write the screenshot to {filepath}: {error}") from error
+
+    def add_hooks(self, hooks: StepHooks) -> None:
+        """Register integrator hooks for the events of this test.
+
+        Args:
+            hooks: the hooks object; register before the first step to see
+                every event of the scenario.
+        """
+        self._reporter.hooks.append(hooks)
+
+    def close(self) -> None:
+        """Close the page and the whole runtime of this test.
+
+        The isolated page context closes first, then the runtime stops
+        unconditionally — a failing page close (e.g. after a browser crash)
+        never keeps the browser of the test alive; its error still propagates.
+        The browser of this test does not outlive the test.
+
+        Idempotent and safe before the first step: nothing was opened —
+        nothing is closed beyond the no-op runtime close. The page reference
+        drops before its close runs, so even a failing page close never
+        repeats on a retried ``close``.
+        """
+        page = self._page
+        self._page = None
+
+        try:
+            if page is not None:
+                page.close()
+        finally:
+            self._runtime.close()
+
+    def __enter__(self) -> PrettyTest:
+        """Enter the scenario block of one test.
+
+        Returns:
+            This test object.
+        """
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None:
+        """Leave the scenario block: close the test and never suppress.
+
+        Args:
+            exc_type: the type of the block exception, if any.
+            exc_value: the block exception, if any.
+            traceback: the traceback of the block exception, if any.
+
+        Returns:
+            Nothing — a falsy return keeps the exception propagating.
+        """
+        self.close()

prettyplay-0.0.0.dist-info/METADATA

@@ -0,0 +1,236 @@
+Metadata-Version: 2.4
+Name: prettyplay
+Version: 0.0.0
+Summary: AI-powered UI test generation tool
+License: BSD-3-Clause
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pydantic>=2.7
+Requires-Dist: playwright>=1.49
+Requires-Dist: openai>=1.30
+Requires-Dist: anthropic>=0.28
+Requires-Dist: tomli>=2.0; python_version < "3.11"
+Provides-Extra: test
+Requires-Dist: pytest>=8.0; extra == "test"
+Requires-Dist: pytest-cov>=5.0; extra == "test"
+Requires-Dist: pytest-mock>=3.10; extra == "test"
+Requires-Dist: ruff>=0.15.0; extra == "test"
+Provides-Extra: docs
+Requires-Dist: mkdocs>=1.6.0; extra == "docs"
+Requires-Dist: mkdocs-material>=9.5.0; extra == "docs"
+Dynamic: license-file
+
+# prettyplay
+
+UI tests written as plain sentences. Each step sentence is turned into executable
+code once — by an LLM, against the live page — and cached in the repository.
+Every later run replays the cached code with no LLM involvement at all.
+
+## Installation
+
+```bash
+pip install prettyplay
+playwright install            # browser binaries for the driver
+```
+
+Requires Python 3.10+.
+
+## Quick start
+
+```python
+from prettyplay import PrettyTest
+
+
+def test_login():
+    t = PrettyTest("login-flow")
+    t.action("открыть страницу логина")
+    t.action("ввести логин и пароль")
+    t.action("нажать «Войти»")
+    t.assertion("появилась надпись «Добро пожаловать»")
+    t.close()
+```
+
+Or with the context manager:
+
+```python
+with PrettyTest("login-flow") as t:
+    t.action("открыть страницу логина")
+```
+
+Each `PrettyTest` is fully self-contained: it owns its settings, its attempt
+budgets and its own browser session. `close()` (or leaving the `with` block)
+closes the page and stops the whole browser of that test, and every test
+starts with fresh attempt budgets. The old process-wide
+`prettyplay.get_runtime()` singleton was removed — build
+`prettyplay.PrettyplayRuntime(config)` directly if you composed objects over
+it.
+
+The constructor arguments form the cache address: `cache_key` (mandatory) and
+`cache_path` (optional subdirectory). Equal keys in the shared root reuse one
+cached step across tests; a different language, step type or key is a
+different step.
+
+The third argument overrides settings per test — only the fields you pass
+count: explicitly set values win over pyproject.toml and the environment,
+everything else resolves from the file layer as before:
+
+```python
+from prettyplay import PrettyConfig
+
+t = PrettyTest("login-flow", config=PrettyConfig(browser="firefox"))
+```
+
+Screenshots belong to the author — nothing is captured automatically. Both
+methods need a step to have run (the page opens lazily):
+
+```python
+png = t.get_screenshot()                  # full-page PNG bytes
+t.save_screenshot("artifacts/home.png")   # write full-page PNG to a file
+```
+
+## What happens on a step
+
+- **cache hit** — the cached code runs; no LLM is contacted
+- **cache miss** — the step code is generated (a candidate that must actually
+  work on the page), then cached; only successes are cached. A candidate
+  assertion that legitimately fails stops the retries at once and is
+  classified: a real defect fails as `product_defect` instead of burning the
+  attempt budget
+- **cached failure** — the failure is classified:
+  - `rot` (the UI changed) — the step is regenerated and the cache rewritten
+  - `product_defect` — the test fails loudly; nothing is regenerated
+  - `incurable` — the step fails with an explanation and a recommendation
+
+## Seeing the scenario
+
+Step sentences go to the `prettyplay` logger at info level. The library
+configures no handlers — enable logging to see the scenario in the output:
+
+```python
+import logging
+
+logging.basicConfig(level=logging.INFO)          # plain unittest runs
+```
+
+```ini
+# pytest: --log-cli-level=INFO
+```
+
+## Configuration
+
+The `[tool.prettyplay]` section of pyproject.toml:
+
+```toml
+[tool.prettyplay]
+provider = "openai"              # openai | anthropic
+browser = "chromium"             # chromium | firefox | webkit | chrome | msedge
+model = "gpt-5"
+generation_model = ""            # optional: empty -> model
+classification_model = ""        # optional: empty -> model
+base_url = ""
+cache_root = ""                  # empty -> <repo>/.prettyplay/cache/
+generation_prompt = ""           # user instructions for generation; empty -> no instructions block
+browser_endpoint = ""            # ws:// endpoint of a remote browser; empty -> local launch
+generation_attempts = 3
+healing_attempts = 2
+send_screenshots = false
+headless = true                  # false -> run with a visible browser window
+```
+
+`chrome` and `msedge` launch the locally installed browser through the
+chromium engine; the browser must be installed on the machine.
+
+A non-empty `generation_prompt` is sent verbatim as a `USER INSTRUCTIONS`
+block with every generation and regeneration request — it steers the style of
+the generated code (e.g. `prefer data-test-id attributes`), never the failure
+classification. The instructions are not part of the cache address: changing
+them never invalidates cached steps — a cached step runs unchanged.
+
+A non-empty `browser_endpoint` (e.g. `ws://ci-grid:3000/playwright/chromium`)
+connects to a remote Playwright Server or browser grid instead of launching
+locally: `headless` does not apply to a connect (window visibility belongs to
+the endpoint server) and `chrome`/`msedge` map to the chromium engine —
+channels are a local-launch concept. A non-empty endpoint must be a valid
+ws/wss URL (otherwise `ConfigurationError` names the setting), and a failed
+connect fails loudly with the endpoint in the message.
+
+Every setting has a `PRETTYPLAY_<SETTING_UPPER>` environment override for CI,
+except the browser (`PRETTYPLAY_BROWSER_NAME`) and headless
+(`PRETTYPLAY_BROWSER_HEADLESS`). The removed legacy name `PRETTYPLAY_BROWSER`
+fails immediately with a hint to use `PRETTYPLAY_BROWSER_NAME`.
+
+An invalid setting fails loudly with a `ConfigurationError`: one line per
+setting — the name, the received value and the allowed values.
+
+LLM API keys are never stored in the config file: they come only from the
+environment — `OPENAI_API_KEY` for openai, `ANTHROPIC_API_KEY` for anthropic —
+and are read lazily on the first request.
+
+## Failure taxonomy
+
+Every library failure derives from `PrettyplayError`:
+
+| Exception | Meaning | Recommended reaction |
+|---|---|---|
+| ProductDefectError | real product regression | treat as a bug: this failure is the value of the suite |
+| IncurableStepError | the step cannot be (re)generated | follow `recommendation`: reword the step or refresh the cache |
+| LlmUnavailableError | LLM infrastructure down | restore provider access; cached steps are unaffected |
+| ConfigurationError | invalid `[tool.prettyplay]` settings | fix the named setting — the message lists received and allowed values |
+
+`ProductDefectError` and `IncurableStepError` carry a verdict — `category`,
+`explanation`, `recommendation` from the failure classification — appended to
+the exception message and delivered through the `on_step_verdict` hook.
+`ProductDefectError` also derives from `AssertionError`, so any runner counts
+it as a failed test, never an error. Tracebacks of library failures are folded
+at the `t.action(...)` / `t.assertion(...)` call site: internal engine frames
+never appear in what the runner shows.
+
+A healed run never turns a `ProductDefectError` into a green test.
+
+## Hooks
+
+```python
+from prettyplay.reporting import StepHooks
+
+
+class Reporter(StepHooks):
+    def on_step_started(self, step_text: str, step_type: str) -> None: ...
+    def on_step_passed(self, step_text: str, step_type: str) -> None: ...
+    def on_step_failed(self, step_text: str, step_type: str, error: str) -> None: ...
+    def on_step_verdict(self, step_text: str, category: str, explanation: str, recommendation: str) -> None: ...
+    def on_generation_started(self, step_text: str, attempt: int) -> None: ...
+    def on_healing_started(self, step_text: str, category: str) -> None: ...
+    def on_healed(self, step_text: str, explanation: str) -> None: ...
+    def on_cache_saved(self, step_text: str, filename: str) -> None: ...
+    def on_cache_skipped(self, step_text: str, reason: str) -> None: ...
+
+
+t = PrettyTest("login-flow")
+t.add_hooks(Reporter())
+```
+
+A raising hook never fails the run; the failure is logged. `on_step_verdict`
+fires after `on_step_failed`, only when the terminal failure carried a verdict.
+
+## Cache and CI workflow
+
+The cache lives under `.prettyplay/cache/` as plain Python files — one per
+step, carrying its metadata (step sentence, cache key, step type, creation
+date) and the step code.
+
+Generate locally where the LLM is reachable → commit the cache directory →
+CI runs the whole suite from the cache with no LLM keys at all.
+
+## Limitations
+
+Step sentences land in the repository cache, the logs and the LLM requests:
+never put secrets or personal data into a step.

prettyplay-0.0.0.dist-info/RECORD

@@ -0,0 +1,58 @@
+prettyplay/CODEMANIFEST,sha256=J8KN00rNtkG7hA70qLSvxhBoCRiMVjH1l_kouZu5X1g,9781
+prettyplay/__init__.py,sha256=pjAKVu2otS-4MqnTlIyXjoM54_L4TkwwMVd8bkhrRYs,393
+prettyplay/executor.py,sha256=AJ5JApn24yop2e9mFEgC03qqZ2amAnYH-Hh4KQMakpU,4825
+prettyplay/runtime.py,sha256=-HvXhykBa8MoLa7Tq-TWFG0I8X8u9Ql9SX6T2iC6qyQ,4203
+prettyplay/scenario.py,sha256=dtmP4ol_QeHE5ia2LV9NG3AzfLLlfwLBbXlnLQPtlis,10691
+prettyplay/.usages/lifecycle.md,sha256=XRHXkSef2tQU-901F6bPQFDYN981zBBic4B6uiP6-KY,3561
+prettyplay/.usages/steps.md,sha256=okTZ8Gmf7AY2hOcw4TqL_c8Oq3mphNY8myuuaU2mWM4,1903
+prettyplay/cache/CODEMANIFEST,sha256=fvCVBwA1hmYWbjps3x_4rh6agPMo_bmqkFCLtrzJhUk,6897
+prettyplay/cache/__init__.py,sha256=GYhRRVLAlRCdbKuzo-bMqmaBd4UqQXwch7RUG9zbDO0,318
+prettyplay/cache/budgets.py,sha256=Q2BDNknt309G-2oXY2IL0NxxpgFoIDDuEJC_yr7t8Ac,2819
+prettyplay/cache/models.py,sha256=Qkj8re-CUVD68NUdTZdc1UyvcagDRFCLobs4GL_Erjs,1987
+prettyplay/cache/store.py,sha256=tjwyTioi1zu-SNzBMMWPtThuJUWsh__BASvm15x5y5g,9168
+prettyplay/cache/text.py,sha256=a1dd-ZrMIdykihxNcInC8a3zGkSis5dfxechxcfvvSo,1199
+prettyplay/cache/.usages/addressing.md,sha256=9h2Fv-KIPQamvKmHE1PGLX0vKuqs6IQqJiKWCPxMibY,1327
+prettyplay/cache/.usages/budgets.md,sha256=6mihnbXUNxZCKRYguofu5y1ied5ytJ8d2pxMgdxMPWE,889
+prettyplay/cache/.usages/storage.md,sha256=QlOU8Z5lQ8R8jBwBklNula79ERxtkftt5iP-KC6Cnuo,1320
+prettyplay/config/CODEMANIFEST,sha256=xTA3y3pQ1zbvRVvpDRbHT4ASIze9-nZDmHYhbaWPf28,7912
+prettyplay/config/__init__.py,sha256=I9vREkOLZpoWJnk36OlrEgyCPmlgTgTBGTWSXG1mhPU,241
+prettyplay/config/loader.py,sha256=MGHEDJg6CMMhrqIQXIEuO_C0Xsc8VCT6bwxyfnvtJCE,7065
+prettyplay/config/models.py,sha256=hM8sJAxxHXn11Crx-3dZ0VpBWi8E6yh6by-iZPfSwa4,3658
+prettyplay/config/.usages/configuration.md,sha256=dWmyTyrYAgtBD4_ytzKJIbRK0HNuZzqmAsZxTp7pj5c,3978
+prettyplay/driver/CODEMANIFEST,sha256=GferPW_EXtC_-04vqqBGYaCktskfhAwvVjZvHK2Ac9o,9430
+prettyplay/driver/__init__.py,sha256=AkT-oLEjL_xb9Xi-h_Qvx7oHzkeyiAgm4dowMmo3PKk,226
+prettyplay/driver/page.py,sha256=lI1JkOh6KD0Lj-6z2dw8y-SgDzrTaDACTi0_Swukpzg,12365
+prettyplay/driver/session.py,sha256=V-2nI_EKuxv2ygmGw8Pthqh2UW9qC8btQsP7oxlegfE,10506
+prettyplay/driver/.usages/facade.md,sha256=ZVEmIBJY4LXSUmMr16PnQCtGs-fdr5dDWtHCSz1EqwI,3376
+prettyplay/engine/CODEMANIFEST,sha256=I6ZX1sle9z58T_ncD4kJfUrYiFTGZ-1F-v5Wa_9-JsM,14059
+prettyplay/engine/__init__.py,sha256=4TXAo9CJxkg1MgcE5IuuP8yFI980tPn4orEPf9ZUMeU,333
+prettyplay/engine/classification.py,sha256=MGTgWKIHtH6DXPGZ2LGhqr2neYJ4j-av2SY2_5R0Mh4,2704
+prettyplay/engine/execution.py,sha256=L8OmLw8oeoaOO2Jg_lL-9WuEvntO6qWsGp7eDDxvJcc,1076
+prettyplay/engine/generator.py,sha256=K_VFJqWklCNt17dhXMFDsBE8p7FUvzlGS9a23HmZX50,14469
+prettyplay/engine/healer.py,sha256=5lf8NEunNQY7499n2XmUf9m2zMy_05GiAhwqAFcfYko,5212
+prettyplay/engine/text.py,sha256=OhS7oR1wbUfMYk74GKMV7AtWIN5BcZ9fxNgq1SRorOg,718
+prettyplay/engine/.usages/generation.md,sha256=80rON1oqAAu2U--fJd2qDYcpmGmLVg2oAjW7KkS9Wmc,2865
+prettyplay/engine/.usages/healing.md,sha256=-rV17c7udKUx1WTVJgm8XzkDuM42nwvNs2YVNDjLlmM,1591
+prettyplay/failures/CODEMANIFEST,sha256=OAg5FA0Wz9wUMAYt058TiEsvEoTCb30G0USQFt92cPg,5998
+prettyplay/failures/__init__.py,sha256=nUhcscgBJsPZroIabB8_pFJxAgBBU6DPHNzp85C1CzI,361
+prettyplay/failures/errors.py,sha256=hJz8czDaClKpeY6pwZbxerZB0UrmkKVv3iCVAqtF6Zw,5222
+prettyplay/failures/.usages/taxonomy.md,sha256=gpi8v4UEqtOnFrigvoswIOL3QnSBtKKs2uKUEBnQbUo,2483
+prettyplay/llm/CODEMANIFEST,sha256=jhsBkhi8EXRLspX8Y1ErTLylVG09irz1SaRBY1Y7HWE,7235
+prettyplay/llm/__init__.py,sha256=BwjZpXIc4K11GuVw4UDgQAgkihqb7kYSS7eIOGFlt8A,377
+prettyplay/llm/_request.py,sha256=F-iLnGyEdlwL0PnqMFCRZukiW4kwv2DCFEHEEExc5KE,7528
+prettyplay/llm/anthropic_provider.py,sha256=V-OPAk8uCcDOHq5vkfqZMm4ne8L0EP0GmaNALZuMFOE,8349
+prettyplay/llm/models.py,sha256=26aM3-JJzkJj9t5PXRi9RbmXXyDwWKvwZb2bW8N8gyA,638
+prettyplay/llm/openai_provider.py,sha256=rjG6UJi8ljQecjQpIHjpPz932NTpnXYQY90z_Ruy9x0,7420
+prettyplay/llm/provider.py,sha256=jjtB5YVO1w5FyYMdY0pPFiQJ8JtgNlO3St2ymZjrHbs,4714
+prettyplay/llm/.usages/classification.md,sha256=Ue-q8PZoJndKS0BIpea0iMTfZSCk9LCEhVPaOFyH0lA,994
+prettyplay/llm/.usages/providers.md,sha256=EJ6lk-imG0WmOPq3wXprvVYYI-0S3P5w4GPkzBFhDzw,1540
+prettyplay/reporting/CODEMANIFEST,sha256=D2zwoqvIg-ZXXzt_rozjFjvpd0LBPXtbiict-9P_akY,4153
+prettyplay/reporting/__init__.py,sha256=_dmLcKn7WDDqBWNAHT0VTRHPZu2-nrMpfux60gASTU0,187
+prettyplay/reporting/hooks.py,sha256=KqnmYgvy_2oZv3swSCCOL7hLkA5UI17cOaifqWSCgxU,1867
+prettyplay/reporting/reporter.py,sha256=TlOdgCIrmUZCobxAhUzmq1qs2ycjiNMR9HOaiwfxFXM,2325
+prettyplay/reporting/.usages/hooks.md,sha256=u5I0vExr-1CoNXUz7J7yVOfugAIhaKSFEYFS7Ou5NUg,2315
+prettyplay-0.0.0.dist-info/licenses/LICENSE,sha256=3fteeL9wFLa2P6MykXx6RkApbO0N9NUrSs9rVH8gxnc,1493
+prettyplay-0.0.0.dist-info/METADATA,sha256=N-jueIY0iyqXYHzNUCBNlKS-_L2FclcGJLQFwRdPfCM,9466
+prettyplay-0.0.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+prettyplay-0.0.0.dist-info/top_level.txt,sha256=ZByeTYDEYyWHvSGaI4cQYCrh1oiDpK5bTfnwv_ogWUg,11
+prettyplay-0.0.0.dist-info/RECORD,,

prettyplay-0.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

prettyplay-0.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, qarium
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

prettyplay-0.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+prettyplay