pyintent 0.1.0__py3-none-any.whl

pyintent/verifier/examples.py

@@ -0,0 +1,142 @@
+"""Examples verifier — run every ``ex`` case against the real implementation.
+
+Runnable in v0.1 for module-level functions, ``@staticmethod`` and
+``@classmethod``. Instance methods and properties need an instance and are
+skipped with a clear reason (planned for v0.2).
+"""
+
+from __future__ import annotations
+
+import asyncio
+from typing import Any
+
+from .._errors import PyIntentSpecError
+from .._parser import Example, Raises, ReturnsValue, _Wildcard
+from .._spec import SpecLevel
+from .._discovery import SpecTarget
+from ._result import CheckResult, Status
+
+_RUNNABLE = {SpecLevel.FUNCTION, SpecLevel.STATICMETHOD, SpecLevel.CLASSMETHOD}
+
+
+def _safe_eq(a: object, b: object) -> bool:
+    try:
+        return bool(a == b)
+    except Exception:
+        return repr(a) == repr(b)
+
+
+def _call(fn: Any, args: tuple, is_async: bool) -> Any:
+    if is_async:
+        return asyncio.run(fn(*args))
+    return fn(*args)
+
+
+def _fmt_args(args: tuple) -> str:
+    inner = ", ".join(repr(a) for a in args)
+    if len(args) == 1:
+        inner += ","
+    return f"({inner})"
+
+
+def verify_example_case(target: SpecTarget, ex: Example) -> CheckResult:
+    """Run exactly one example case (the function executes once)."""
+    sp = target.spec
+    if sp.level not in _RUNNABLE or target.invoke is None:
+        reason = f"{sp.level.value} examples require an instance (v0.2)"
+        return CheckResult("examples", sp.target_name, Status.SKIPPED, summary=reason, label=ex.raw)
+    return _run_one(target, ex)
+
+
+def verify_examples(target: SpecTarget) -> list[CheckResult]:
+    if not target.spec.examples:
+        return []
+    return [verify_example_case(target, ex) for ex in target.spec.examples]
+
+
+def _run_one(target: SpecTarget, ex: Example) -> CheckResult:
+    sp = target.spec
+    name = sp.target_name
+    globalns = target.globalns
+    try:
+        args = ex.eval_args(globalns)
+    except PyIntentSpecError as e:
+        return CheckResult("examples", name, Status.ERROR, summary=str(e), label=ex.raw)
+
+    try:
+        outcome = _call(target.invoke, args, sp.is_async)
+    except BaseException as exc:  # noqa: BLE001 - we classify it below
+        return _check_raised(name, ex, exc, args, globalns)
+    return _check_returned(name, ex, outcome, args, globalns)
+
+
+def _check_raised(name, ex: Example, exc, args, globalns) -> CheckResult:
+    if isinstance(ex.expected, Raises):
+        try:
+            want = ex.expected.resolve(globalns)
+        except PyIntentSpecError as e:
+            return CheckResult("examples", name, Status.ERROR, summary=str(e), label=ex.raw)
+        if isinstance(exc, want):
+            return CheckResult("examples", name, Status.PASS, label=ex.raw)
+        detail = (
+            f"{name}{_fmt_args(args)}\n"
+            f"  expected: raises {ex.expected.exc_name}\n"
+            f"  actual:   raised {type(exc).__name__}: {exc}"
+        )
+        return CheckResult(
+            "examples", name, Status.FAIL,
+            summary=f"raised {type(exc).__name__}, expected {ex.expected.exc_name}",
+            detail=detail, label=ex.raw,
+        )
+
+    expected_desc = (
+        "_ (returns without raising)"
+        if isinstance(ex.expected, _Wildcard)
+        else ex.expected.value_src
+    )
+    detail = (
+        f"{name}{_fmt_args(args)}\n"
+        f"  expected: {expected_desc}\n"
+        f"  actual:   raised {type(exc).__name__}: {exc}"
+    )
+    return CheckResult(
+        "examples", name, Status.FAIL,
+        summary=f"unexpected {type(exc).__name__}: {exc}",
+        detail=detail, label=ex.raw,
+    )
+
+
+def _check_returned(name, ex: Example, outcome, args, globalns) -> CheckResult:
+    if isinstance(ex.expected, _Wildcard):
+        return CheckResult("examples", name, Status.PASS, label=ex.raw)
+
+    if isinstance(ex.expected, Raises):
+        detail = (
+            f"{name}{_fmt_args(args)}\n"
+            f"  expected: raises {ex.expected.exc_name}\n"
+            f"  actual:   returned {outcome!r}"
+        )
+        return CheckResult(
+            "examples", name, Status.FAIL,
+            summary=f"returned {outcome!r}, expected raise {ex.expected.exc_name}",
+            detail=detail, label=ex.raw,
+        )
+
+    assert isinstance(ex.expected, ReturnsValue)
+    try:
+        expected_value = ex.expected.resolve(globalns)
+    except PyIntentSpecError as e:
+        return CheckResult("examples", name, Status.ERROR, summary=str(e), label=ex.raw)
+
+    if _safe_eq(outcome, expected_value):
+        return CheckResult("examples", name, Status.PASS, label=ex.raw)
+    detail = (
+        f"{name}{_fmt_args(args)}\n"
+        f"  expected: {expected_value!r}\n"
+        f"  actual:   {outcome!r}"
+    )
+    return CheckResult(
+        "examples", name, Status.FAIL,
+        summary=f"returned {outcome!r}, expected {expected_value!r}",
+        detail=detail, label=ex.raw,
+    )

pyintent/verifier/properties.py

@@ -0,0 +1,196 @@
+"""Properties verifier — hypothesis-generate inputs and check ``ensures``.
+
+Only runs for pure, runnable callables (module functions / staticmethods /
+classmethods with no impure declared effects). Effectful callables, instance
+methods, and callables whose parameter types can't be mapped to a strategy are
+skipped with a reason.
+"""
+
+from __future__ import annotations
+
+import builtins as _builtins
+import inspect
+import types
+import typing
+from typing import Any, get_args, get_origin
+
+_BUILTINS_DICT = vars(_builtins)
+
+from hypothesis import HealthCheck, given, settings
+from hypothesis import strategies as st
+from hypothesis.errors import UnsatisfiedAssumption
+
+from .._spec import SpecLevel
+from .._discovery import SpecTarget
+from ._result import CheckResult, Status
+
+_RUNNABLE = {SpecLevel.FUNCTION, SpecLevel.STATICMETHOD, SpecLevel.CLASSMETHOD}
+_MAX_EXAMPLES = 50
+
+
+class _Unsupported(Exception):
+    def __init__(self, tp: Any) -> None:
+        super().__init__(str(tp))
+        self.tp = tp
+
+
+def _strategy_for(tp: Any):
+    if tp is int:
+        return st.integers()
+    if tp is bool:
+        return st.booleans()
+    if tp is float:
+        return st.floats(allow_nan=False, allow_infinity=False)
+    if tp is str:
+        return st.text()
+    if tp is bytes:
+        return st.binary()
+    if tp is type(None):
+        return st.none()
+
+    origin = get_origin(tp)
+    args = get_args(tp)
+    if origin is list:
+        return st.lists(_strategy_for(args[0]) if args else st.integers())
+    if origin is set:
+        return st.sets(_strategy_for(args[0]) if args else st.integers())
+    if origin is frozenset:
+        return st.frozensets(_strategy_for(args[0]) if args else st.integers())
+    if origin is tuple:
+        if len(args) == 2 and args[1] is Ellipsis:
+            return st.lists(_strategy_for(args[0])).map(tuple)
+        return st.tuples(*[_strategy_for(a) for a in args])
+    if origin is dict:
+        k = _strategy_for(args[0]) if args else st.text()
+        v = _strategy_for(args[1]) if len(args) > 1 else st.integers()
+        return st.dictionaries(k, v)
+    if origin is typing.Union or origin is types.UnionType:
+        return st.one_of(*[_strategy_for(a) for a in args])
+    raise _Unsupported(tp)
+
+
+def _skip(name: str, reason: str) -> list[CheckResult]:
+    return [CheckResult("properties", name, Status.SKIPPED, summary=reason)]
+
+
+def verify_properties(target: SpecTarget) -> list[CheckResult]:
+    sp = target.spec
+    name = sp.target_name
+
+    if not sp.ensures:
+        return []
+    if sp.level not in _RUNNABLE or target.invoke is None:
+        return _skip(name, f"{sp.level.value} property tests need an instance (v0.2)")
+    if not sp.is_verifiable_pure:
+        return _skip(name, "effectful — property testing only runs on pure functions")
+    if sp.is_async:
+        return _skip(name, "async property testing deferred to v0.2")
+
+    fn = target.invoke
+    try:
+        sig = inspect.signature(fn)
+    except (TypeError, ValueError):
+        return _skip(name, "could not introspect signature")
+
+    params = [
+        p for p in sig.parameters.values()
+        if p.name not in ("self", "cls")
+    ]
+    for p in params:
+        if p.kind in (p.VAR_POSITIONAL, p.VAR_KEYWORD):
+            return _skip(name, "*args/**kwargs not supported for property testing")
+        if p.kind is p.POSITIONAL_ONLY:
+            return _skip(name, "positional-only parameters not supported")
+
+    try:
+        hints = typing.get_type_hints(fn)
+    except Exception:
+        return _skip(name, "could not resolve type hints")
+
+    strategies = {}
+    for p in params:
+        if p.name not in hints:
+            return _skip(name, f"parameter '{p.name}' has no type annotation")
+        try:
+            strategies[p.name] = _strategy_for(hints[p.name])
+        except _Unsupported as u:
+            return _skip(name, f"no strategy for type {u.tp!r} (parameter '{p.name}')")
+
+    return [_run(target, strategies)]
+
+
+def _run(target: SpecTarget, strategies: dict) -> CheckResult:
+    sp = target.spec
+    name = sp.target_name
+    fn = target.invoke
+    assert fn is not None  # guaranteed by verify_properties
+    globalns = target.globalns
+    failure: dict[str, Any] = {}
+
+    arg_strategy = st.fixed_dictionaries(strategies) if strategies else st.just({})
+
+    @settings(max_examples=_MAX_EXAMPLES, deadline=None,
+              suppress_health_check=list(HealthCheck))
+    @given(kwargs=arg_strategy)
+    def run(kwargs: dict) -> None:
+        for cond in sp.where:
+            try:
+                ok = bool(eval(cond, {"__builtins__": _BUILTINS_DICT, **globalns, **kwargs}))
+            except Exception:
+                ok = False
+            if not ok:
+                raise UnsatisfiedAssumption()
+        try:
+            result = fn(**kwargs)
+        except Exception as exc:
+            failure.update(kwargs=kwargs, result="<raised>", cond="(function call)", error=exc)
+            raise AssertionError(
+                f"function raised {type(exc).__name__}: {exc}"
+            ) from exc
+        env = {**kwargs, "result": result}
+        for cond in sp.ensures:
+            try:
+                holds = bool(eval(cond, {"__builtins__": _BUILTINS_DICT, **globalns, **env}))
+            except Exception as e:
+                failure.update(kwargs=kwargs, result=result, cond=cond, error=e)
+                raise AssertionError(
+                    f"ensures {cond!r} raised {type(e).__name__}: {e}"
+                ) from e
+            if not holds:
+                failure.update(kwargs=kwargs, result=result, cond=cond, error=None)
+                raise AssertionError(f"ensures {cond!r} is False")
+
+    try:
+        run()
+    except AssertionError:
+        kwargs = failure.get("kwargs", {})
+        call = ", ".join(f"{k}={v!r}" for k, v in kwargs.items())
+        cond = failure.get("cond", "?")
+        result = failure.get("result", "?")
+        err = failure.get("error")
+        if err:
+            line = (
+                f"function raised {type(err).__name__}: {err}"
+                if cond == "(function call)"
+                else f"ensures {cond!r} raised {type(err).__name__}: {err}"
+            )
+        else:
+            line = f"ensures {cond!r} is False"
+        detail = (
+            f"{name}({call})\n"
+            f"  returned: {result!r}\n"
+            f"  {line}"
+        )
+        return CheckResult(
+            "properties", name, Status.FAIL,
+            summary=f"falsified: {line}", detail=detail,
+        )
+    except Exception as e:  # noqa: BLE001
+        return CheckResult(
+            "properties", name, Status.ERROR,
+            summary=f"property run errored: {e}", detail=str(e),
+        )
+    return CheckResult(
+        "properties", name, Status.PASS,
+        summary=f"{len(sp.ensures)} ensures held over {_MAX_EXAMPLES} examples",
+    )

pyintent/verifier/types.py

@@ -0,0 +1,50 @@
+"""Types verifier — run mypy over a file (optional).
+
+Runs once per file, not per function. If mypy is not installed the check is
+skipped (not failed), so mypy stays an optional dependency.
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import subprocess
+import sys
+
+from ._result import CheckResult, Status
+
+_MYPY_AVAILABLE: bool | None = None
+
+
+def _mypy_available() -> bool:
+    global _MYPY_AVAILABLE
+    if _MYPY_AVAILABLE is None:
+        _MYPY_AVAILABLE = importlib.util.find_spec("mypy") is not None
+    return _MYPY_AVAILABLE
+
+
+def verify_types(filename: str) -> list[CheckResult]:
+    target = filename
+    if not _mypy_available():
+        return [CheckResult("types", target, Status.SKIPPED,
+                            summary="mypy not installed (pip install pyintent[types])")]
+    try:
+        proc = subprocess.run(
+            [sys.executable, "-m", "mypy",
+             "--no-error-summary", "--hide-error-context",
+             "--no-color-output", "--follow-imports=silent",
+             "--ignore-missing-imports", filename],
+            capture_output=True, text=True, timeout=120,
+        )
+    except subprocess.TimeoutExpired:
+        return [CheckResult("types", target, Status.ERROR, summary="mypy timed out")]
+    except Exception as e:  # noqa: BLE001
+        return [CheckResult("types", target, Status.ERROR, summary=f"mypy failed to run: {e}")]
+
+    out = (proc.stdout + proc.stderr).strip()
+    if proc.returncode == 0:
+        return [CheckResult("types", target, Status.PASS, summary="mypy clean")]
+    if proc.returncode == 1:
+        return [CheckResult("types", target, Status.FAIL,
+                            summary="mypy reported type errors", detail=out)]
+    return [CheckResult("types", target, Status.ERROR,
+                        summary="mypy usage error", detail=out)]

pyintent-0.1.0.dist-info/METADATA

@@ -0,0 +1,255 @@
+Metadata-Version: 2.4
+Name: pyintent
+Version: 0.1.0
+Summary: Verify that implementations satisfy intent specifications. A pure verifier for AI-generated Python code — it checks, it never generates.
+Author: pyintent contributors
+License: MIT
+Project-URL: Homepage, https://github.com/cshaley/pyintent
+Project-URL: Repository, https://github.com/cshaley/pyintent
+Project-URL: Bug Tracker, https://github.com/cshaley/pyintent/issues
+Project-URL: Changelog, https://github.com/cshaley/pyintent/blob/main/CHANGELOG.md
+Keywords: verification,specification,ai,codegen,contracts,testing
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Testing
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: click>=8.0
+Requires-Dist: hypothesis>=6.0
+Requires-Dist: pytest>=7.0
+Provides-Extra: types
+Requires-Dist: mypy>=1.0; extra == "types"
+Provides-Extra: async
+Requires-Dist: pytest-asyncio>=0.21; extra == "async"
+Provides-Extra: dev
+Requires-Dist: mypy>=1.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21; extra == "dev"
+Provides-Extra: evals
+Requires-Dist: openai>=1.40; extra == "evals"
+Dynamic: license-file
+
+# pyintent
+
+Write your intent as a specification. Let any AI coding tool write the implementation. **pyintent verifies the implementation actually satisfies the intent.**
+
+pyintent is a *pure verifier*. It never calls an LLM. Like `mypy` checks types without generating code, pyintent checks that an implementation matches its declared intent — examples, pre/post-conditions, effects, and types.
+
+```python
+from pyintent import spec, reads, throws
+
+@spec(
+    intent  = "Return the order with the given id from the database.",
+    where   = ["order_id > 0"],
+    ensures = ["result.id == order_id"],
+    effects = [reads("db"), throws(NotFoundError)],
+    ex      = [
+        "(42,)  -> _",
+        "(999,) -> raises NotFoundError",
+        "(0,)   -> raises ValueError",
+    ],
+)
+def find_order(order_id: int) -> Order:
+    ...   # implemented by Claude Code / Copilot / Devin / you
+```
+
+Then:
+
+```bash
+pyintent verify myapp/orders.py     # run all verifiers, human-readable report
+pytest --pyintent                   # specs become pytest items automatically
+```
+
+## Install
+
+```bash
+pip install pyintent           # core (examples, properties, effects)
+pip install pyintent[types]    # + mypy integration
+pip install pyintent[dev]      # + mypy + pytest-asyncio
+```
+
+## Quick start
+
+```python
+from pyintent import spec, pure
+
+@spec(
+    intent  = "Return the absolute value of x.",
+    effects = [pure],
+    ensures = ["result >= 0", "result == x or result == -x"],
+    ex      = ["(3,) -> 3", "(-4,) -> 4", "(0,) -> 0"],
+)
+def my_abs(x: int) -> int:
+    return x if x >= 0 else -x
+```
+
+```bash
+$ pyintent verify mymodule.py
+[PASS] examples    my_abs  (3,) -> 3
+[PASS] examples    my_abs  (-4,) -> 4
+[PASS] examples    my_abs  (0,) -> 0
+[PASS] properties  my_abs
+[PASS] effects     my_abs  pure
+[PASS] types       mymodule.py
+
+3 passed  0 failed  0 errored  0 skipped
+```
+
+## The `@spec` decorator
+
+`@spec` accepts these fields:
+
+| Field        | Type                | Description |
+|--------------|---------------------|-------------|
+| `intent`     | `str` (required)    | One-line description of what the function does and why. |
+| `where`      | `list[str]`         | Preconditions — Python expressions that must hold over the inputs. |
+| `ensures`    | `list[str]`         | Postconditions — Python expressions over inputs and `result`. |
+| `effects`    | `list[Effect]`      | Declared side-effects (see below). |
+| `ex`         | `list[str]`         | Runnable examples in `"(args) -> expected"` format. |
+| `perf`       | `Perf`              | Advisory complexity, e.g. `Perf(time="O(n)")`. |
+| `invariants` | `list[str]`         | Class/module-level invariants (plain strings or expressions). |
+
+`@spec` must be the **outermost** decorator and returns the target **unchanged** — it only attaches metadata, so there is zero runtime overhead.
+
+## Verifiers
+
+### `examples` — run concrete cases
+
+Each `ex` string has the format `"(args) -> expected"`:
+
+```python
+ex = [
+    "(1, 2)  -> 3",              # must return 3
+    "(0,)    -> raises ValueError",  # must raise ValueError
+    "('hi',) -> _",              # wildcard: any return without raising
+]
+```
+
+- The left side is a tuple literal (single-arg tuples need a trailing comma: `(42,)`).
+- `raises ExcType` matches if the call raises that type or a subclass.
+- `_` matches any non-raising return.
+- Values are evaluated in the module's global namespace, so domain objects and enums resolve correctly.
+
+### `properties` — hypothesis-based postcondition testing
+
+For functions with `ensures` and no impure effects, pyintent generates inputs from type hints using [Hypothesis](https://hypothesis.readthedocs.io/), filters them through `where`, and asserts every `ensures` expression:
+
+```python
+@spec(
+    intent  = "Sort a list of integers in ascending order.",
+    effects = [pure],
+    where   = ["len(xs) < 1000"],
+    ensures = [
+        "len(result) == len(xs)",
+        "all(result[i] <= result[i+1] for i in range(len(result)-1))",
+    ],
+)
+def sort_ints(xs: list[int]) -> list[int]:
+    return sorted(xs)
+```
+
+`ensures` expressions may reference input parameters and `result` (the return value).
+
+### `types` — mypy integration
+
+Runs `mypy` over the target file. Skipped gracefully if mypy is not installed. Install it with `pip install pyintent[types]`.
+
+### `effects` — AST-based effect checking
+
+Three effects are actively verified in v0.1:
+
+| Effect | What is checked |
+|--------|----------------|
+| `pure` | No calls to impure builtins (`print`, `open`, …) or modules (`os`, `sys`, `random`, `requests`, …), no `global`/`nonlocal` writes. |
+| `async_` | The function must be defined with `async def`. |
+| `throws(ExcA, ExcB)` | Every explicitly raised exception type is declared. |
+
+These effects are **declaration-only** (recorded but not verified):
+`reads("db")`, `writes("cache")`, `network("stripe")`, `io`
+
+A function may combine multiple effects:
+```python
+effects = [reads("db"), throws(NotFoundError, ValueError)]
+```
+
+## CLI usage
+
+```bash
+# Write the spec-authoring guide into your AI tool's prompt files
+# (AGENTS.md, CLAUDE.md, .github/copilot-instructions.md, etc.)
+pyintent init
+
+# Print the spec-authoring guide to stdout
+pyintent prompt
+
+# Validate spec structure by importing files (no execution)
+pyintent check myapp/
+
+# Require every public function to have a @spec
+pyintent check --require-specs myapp/
+
+# Run all verifiers and report results
+pyintent verify myapp/orders.py
+pyintent verify myapp/
+
+# Machine-readable JSON output
+pyintent verify --json myapp/ > results.json
+
+# Run only specific verifiers
+pyintent verify --only examples --only properties myapp/
+```
+
+Exit codes: `0` all good, `1` verification failures, `2` usage or load error.
+
+## pytest plugin
+
+The pytest plugin is opt-in — installing pyintent does not change how existing `pytest` runs behave.
+
+Enable it on the command line:
+
+```bash
+pytest --pyintent
+```
+
+Or permanently in `pyproject.toml`:
+
+```toml
+[tool.pytest.ini_options]
+pyintent = true
+```
+
+Each spec becomes one or more pytest items:
+
+- One item per `ex` case
+- One item for property testing (if `ensures` is set)
+- One item for the type check per file
+
+## pyproject.toml configuration
+
+```toml
+[tool.pyintent]
+require_specs = true   # or "all" to also require class/module specs
+exclude = ["migrations", "tests"]
+```
+
+## Safety
+
+pyintent's `examples` and `properties` verifiers **execute the code under test** in the current Python process. That is fine for your own code — but pyintent's whole premise is checking code written by an AI tool, so treat that code as untrusted: review it, or run `pyintent verify` in a sandbox (container, VM, or restricted user), before running it on your machine.
+
+## Status
+
+v0.1. The following are planned for v0.2: generator/async-generator specs, `@overload`, instance-method example execution, Liskov enforcement of abstract-method contracts, performance measurement.
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md).
+
+## License
+
+[MIT](LICENSE)

pyintent-0.1.0.dist-info/RECORD

@@ -0,0 +1,25 @@
+pyintent/__init__.py,sha256=b3S-xTB6Oz7WApkBjGmbS4av6rpbjODGozp3vue6xMU,989
+pyintent/_discovery.py,sha256=AmbCN1MLkMlU75sWjiPq1x1-Ku0L5lBAeaG0PRqcESg,3382
+pyintent/_effects.py,sha256=n8NM63eEjyPxm50pINFR7Mb-phXu9Oe37NJ4pfF6lSE,5185
+pyintent/_errors.py,sha256=vJ0U94AoY-M9cc6kuNXJIrsxVUI42aDQaeZUDYTpeRc,390
+pyintent/_loader.py,sha256=dgfjuGg8VTV1h4pYdoLw3hB7OKYgpYRUldXseObPptU,1963
+pyintent/_module_spec.py,sha256=_RGBWyR9h48x2ll7UpUMoSPPTAglWKbKU-mqOc6LCDI,1953
+pyintent/_parser.py,sha256=W7qQrfs28HYyIBcrr2FqCVCWCMwtyNl9LjMIZKoKlTg,6734
+pyintent/_perf.py,sha256=iRqeUQ2mHA29otofwiE2jb-lYSdW974LLB0SCoQ51oA,1714
+pyintent/_spec.py,sha256=wj_q2Fdr_qGXXBhOBSBK4Rjn0nr-tuTCuiKE7eOT-og,12740
+pyintent/cli.py,sha256=wwNv6qZO0ixIOUz3GWEOhueLS8E5Tkvc4ZZZoboQMA0,9048
+pyintent/plugin.py,sha256=UulqBG4EprdniZTs4TMvJRsZIuj7UfOCdSTH_PwYu_s,5062
+pyintent/prompt.py,sha256=N19AJW85PeKR6zM_cxf3Qyem_vIVBeVAdEUUIl4C_e4,5639
+pyintent/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyintent/verifier/__init__.py,sha256=PbJq44_hq72adTpfxr8Nk9-AGwsJyz15IBwdW_pCBwA,1861
+pyintent/verifier/_result.py,sha256=oicuvu82gNYy6Wmfg3iYtlg1YQTRZRWckaRR6O4PQtU,1177
+pyintent/verifier/effects.py,sha256=vdss3N-FvXgEWfbK_vuOTFZsb9GCqHQIJWPHkTfFGzk,6116
+pyintent/verifier/examples.py,sha256=gplxv4XUe5j_CAAacHKQgeyBPydd2YKUcB3ZmTsUH9w,4836
+pyintent/verifier/properties.py,sha256=yjOc6drKyZZ8QZRF5MSnQ4NdDeo7TvdP5dugBMkT97w,6848
+pyintent/verifier/types.py,sha256=K_fm_8cWQVLkUn1dHgoxx-2EYJA4sQ9wjES3GBzdIK8,1838
+pyintent-0.1.0.dist-info/licenses/LICENSE,sha256=ZzxQUeFTwIbKJdbV9IvI7MkFcvQnYTnQfWV6fjeQnJA,1078
+pyintent-0.1.0.dist-info/METADATA,sha256=62fSIjCyxJhGBAxRlyfdrfLPbgCJf5w-aarRQjitTLE,8599
+pyintent-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+pyintent-0.1.0.dist-info/entry_points.txt,sha256=d6yq9D480QpMIOMeQGsgooieLSj7zYW2vbclE6c44So,86
+pyintent-0.1.0.dist-info/top_level.txt,sha256=RTfkCed7A1J1TuH7z-LrL-8gsDoJqLhC9opv2cKZfuI,9
+pyintent-0.1.0.dist-info/RECORD,,

pyintent-0.1.0.dist-info/WHEEL

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

pyintent-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,5 @@
+[console_scripts]
+pyintent = pyintent.cli:main
+
+[pytest11]
+pyintent = pyintent.plugin