thunc 0.1.0__tar.gz

thunc-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,23 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.10", "3.11", "3.12", "3.13", "3.14"]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - run: pip install -e ".[anthropic,dev]"
+      - run: pytest            # offline tests only; live_tests need a model and are not run in CI
+      - run: ruff check .
+      - run: ruff format --check .
+      - run: mypy --strict thunc

thunc-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,36 @@
+name: Publish to PyPI
+
+# Runs when you publish a GitHub release (e.g. tag v0.1.0). Uses PyPI Trusted Publishing:
+# no API token is stored anywhere; PyPI trusts this workflow in this repo.
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.13"
+      - run: pip install build
+      - run: python -m build
+      - uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+  publish:
+    needs: build
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write   # lets PyPI verify this workflow; required for Trusted Publishing
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist/
+      - uses: pypa/gh-action-pypi-publish@release/v1

thunc-0.1.0/.gitignore

@@ -0,0 +1,9 @@
+.venv/
+__pycache__/
+*.egg-info/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+dist/
+.env
+*.jsonl

thunc-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Hussein Eltarras
+
+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.

thunc-0.1.0/PKG-INFO

@@ -0,0 +1,159 @@
+Metadata-Version: 2.5
+Name: thunc
+Version: 0.1.0
+Summary: think + function: call an LLM like a typed Python function.
+Project-URL: Repository, https://github.com/Eltarras/thunc
+Project-URL: Issues, https://github.com/Eltarras/thunc/issues
+Author: Hussein Eltarras
+License-Expression: MIT
+License-File: LICENSE
+Keywords: ai,claude,llm,prompt,structured-output,typed
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Provides-Extra: anthropic
+Requires-Dist: anthropic; extra == 'anthropic'
+Provides-Extra: dev
+Requires-Dist: basedpyright; extra == 'dev'
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# thunc
+
+[![CI](https://github.com/Eltarras/thunc/actions/workflows/ci.yml/badge.svg)](https://github.com/Eltarras/thunc/actions/workflows/ci.yml)
+
+**think + function.** Call an LLM like a typed Python function.
+
+> **Status: beta (v0.1).** Expect bugs; the API may change. Feedback and issues are welcome.
+
+```python
+import thunc
+
+thunc.configure(backend="claude-code")
+
+
+@thunc.function
+def urgency(ticket: str) -> int:
+    """Rate how urgent this ticket is, from 1 (can wait) to 5 (customer is blocked)."""
+    ...
+
+
+urgency("I was charged twice!")  # -> 4, a checked int
+```
+
+The answer is parsed into the declared type. If it doesn't fit, the model is asked again, and
+after that `thunc.ThuncError` is raised. The library uses the standard library only and needs
+Python 3.10+.
+
+## Install
+
+```bash
+pip install thunc               # standard library only
+pip install "thunc[anthropic]"  # adds the Claude API backend
+```
+
+## Try it
+
+Clone the repo and run the examples from its root. No install is needed; the examples run through
+your local [Claude Code](https://claude.com/claude-code) login:
+
+```bash
+git clone https://github.com/Eltarras/thunc && cd thunc
+python3 -m examples.hello
+python3 -m examples.support_inbox
+THUNC_BACKEND=codex python3 -m examples.log_triage
+```
+
+## Two ways to write a prompt
+
+| | When | |
+|---|---|---|
+| `@thunc.function` | The prompt is fixed and should read like code | The docstring is the prompt, the parameters are the inputs, the return annotation is the type |
+| `thunc.call(...)` | The prompt is built in code (from config, in a loop, loaded from a file) | `thunc.call(f"Translate into {lang}.", {"text": note})` |
+
+`@thunc.function(instructions=some_string)` combines the two: a typed, reusable function whose
+prompt is generated.
+
+**Keep user data out of the instructions.** Your own text can go in the instructions string.
+Anything from users, files or the web goes in the inputs:
+
+- `@thunc.function` does this automatically.
+- With `thunc.call` it's up to you. In a live test, a hostile email pasted in with an f-string
+  tricked the model 3 out of 3 times. Passed as an input, it failed 3 out of 3 times.
+
+## API
+
+| | |
+|---|---|
+| `@thunc.function` | Turns a signature + docstring into an AI-backed function. Options: `instructions=`, `ensure=`, `retries=`, `backend=`, `model=`. The body must be empty (`...`); real code raises `TypeError`. `async def` works |
+| `thunc.call(instructions, inputs=None, *, returns=str, ensure=None, retries=2, backend=None, model=None)` | One prompt. Inputs are sent separately from the instructions |
+| `thunc.map(func, items, workers=8)` | Runs calls in parallel, keeping the input order. Each call takes 4–8s, so this is the main speed lever |
+| `thunc.configure(backend=, api_key=, model=, timeout=, trace=)` | Process-wide settings. `trace="calls.jsonl"` logs every call |
+| `thunc.ThuncError` | Raised when no valid answer arrives after the retries |
+
+**Return types:** `str`, `bool`, `int`, `float`, `Literal[...]`, `list[T]`, `dict[str, T]`,
+`T | None`, and dataclasses (built into real instances).
+
+**`ensure=`** adds your own check, for example `ensure=lambda n: 1 <= n <= 5`. A failed check is
+sent back to the model and retried.
+
+**Backends:**
+- `anthropic` is the Claude API: `configure(api_key=...)` or `ANTHROPIC_API_KEY`, plus
+  `pip install anthropic`.
+- `claude-code` and `codex` call your local CLI login, and are meant for cheap testing.
+
+The backend can also be set with `THUNC_BACKEND`.
+
+**Type checking:** signatures and return types are visible to mypy and Pyright. mypy reports
+empty bodies; turn that off with `disable_error_code = ["empty-body"]`.
+
+## Examples
+
+| | |
+|---|---|
+| [hello.py](https://github.com/Eltarras/thunc/blob/main/examples/hello.py) | The smallest call |
+| [support_inbox.py](https://github.com/Eltarras/thunc/blob/main/examples/support_inbox.py) | Docstring functions returning a `Literal`, an `int` with `ensure=`, a dataclass, and a reply; tickets processed in parallel |
+| [dynamic_prompts.py](https://github.com/Eltarras/thunc/blob/main/examples/dynamic_prompts.py) | Prompts built from a style guide with `thunc.call`, and a grading function generated from a rubric |
+| [log_triage.py](https://github.com/Eltarras/thunc/blob/main/examples/log_triage.py) | Plain Python and AI functions mixed, with tracing |
+
+## Code
+
+```
+thunc/
+  __init__.py    public API
+  decorator.py   @thunc.function
+  core.py        thunc.call, thunc.map, tracing
+  schema.py      return types: describe, parse, validate
+  config.py      settings and backend selection
+  backends.py    anthropic, claude-code, codex
+  errors.py      ThuncError
+tests/           offline: a fake backend, never a real model
+live_tests/      against a real model: hello, a yes/no decision, messy text to a dict
+examples/
+```
+
+## Limitations
+
+- **There's no caching and no record/replay yet**, so repeated calls cost again.
+- **The API-key backend hasn't been run live yet.** It's only checked against the SDK's types.
+- **`Literal` results from `thunc.call` are typed as `Any`.** `@thunc.function` has no such gap.
+- **Docstrings disappear under `python -OO`.** Use `instructions=` there.
+
+## Development
+
+```bash
+python3 -m venv .venv && .venv/bin/pip install -e ".[anthropic,dev]"
+.venv/bin/pytest                    # offline tests (these run in CI)
+.venv/bin/pytest live_tests         # real model calls through your Claude Code login; costs quota
+.venv/bin/ruff check . && .venv/bin/mypy --strict thunc
+```
+
+## License
+
+[MIT](https://github.com/Eltarras/thunc/blob/main/LICENSE)

thunc-0.1.0/README.md

@@ -0,0 +1,133 @@
+# thunc
+
+[![CI](https://github.com/Eltarras/thunc/actions/workflows/ci.yml/badge.svg)](https://github.com/Eltarras/thunc/actions/workflows/ci.yml)
+
+**think + function.** Call an LLM like a typed Python function.
+
+> **Status: beta (v0.1).** Expect bugs; the API may change. Feedback and issues are welcome.
+
+```python
+import thunc
+
+thunc.configure(backend="claude-code")
+
+
+@thunc.function
+def urgency(ticket: str) -> int:
+    """Rate how urgent this ticket is, from 1 (can wait) to 5 (customer is blocked)."""
+    ...
+
+
+urgency("I was charged twice!")  # -> 4, a checked int
+```
+
+The answer is parsed into the declared type. If it doesn't fit, the model is asked again, and
+after that `thunc.ThuncError` is raised. The library uses the standard library only and needs
+Python 3.10+.
+
+## Install
+
+```bash
+pip install thunc               # standard library only
+pip install "thunc[anthropic]"  # adds the Claude API backend
+```
+
+## Try it
+
+Clone the repo and run the examples from its root. No install is needed; the examples run through
+your local [Claude Code](https://claude.com/claude-code) login:
+
+```bash
+git clone https://github.com/Eltarras/thunc && cd thunc
+python3 -m examples.hello
+python3 -m examples.support_inbox
+THUNC_BACKEND=codex python3 -m examples.log_triage
+```
+
+## Two ways to write a prompt
+
+| | When | |
+|---|---|---|
+| `@thunc.function` | The prompt is fixed and should read like code | The docstring is the prompt, the parameters are the inputs, the return annotation is the type |
+| `thunc.call(...)` | The prompt is built in code (from config, in a loop, loaded from a file) | `thunc.call(f"Translate into {lang}.", {"text": note})` |
+
+`@thunc.function(instructions=some_string)` combines the two: a typed, reusable function whose
+prompt is generated.
+
+**Keep user data out of the instructions.** Your own text can go in the instructions string.
+Anything from users, files or the web goes in the inputs:
+
+- `@thunc.function` does this automatically.
+- With `thunc.call` it's up to you. In a live test, a hostile email pasted in with an f-string
+  tricked the model 3 out of 3 times. Passed as an input, it failed 3 out of 3 times.
+
+## API
+
+| | |
+|---|---|
+| `@thunc.function` | Turns a signature + docstring into an AI-backed function. Options: `instructions=`, `ensure=`, `retries=`, `backend=`, `model=`. The body must be empty (`...`); real code raises `TypeError`. `async def` works |
+| `thunc.call(instructions, inputs=None, *, returns=str, ensure=None, retries=2, backend=None, model=None)` | One prompt. Inputs are sent separately from the instructions |
+| `thunc.map(func, items, workers=8)` | Runs calls in parallel, keeping the input order. Each call takes 4–8s, so this is the main speed lever |
+| `thunc.configure(backend=, api_key=, model=, timeout=, trace=)` | Process-wide settings. `trace="calls.jsonl"` logs every call |
+| `thunc.ThuncError` | Raised when no valid answer arrives after the retries |
+
+**Return types:** `str`, `bool`, `int`, `float`, `Literal[...]`, `list[T]`, `dict[str, T]`,
+`T | None`, and dataclasses (built into real instances).
+
+**`ensure=`** adds your own check, for example `ensure=lambda n: 1 <= n <= 5`. A failed check is
+sent back to the model and retried.
+
+**Backends:**
+- `anthropic` is the Claude API: `configure(api_key=...)` or `ANTHROPIC_API_KEY`, plus
+  `pip install anthropic`.
+- `claude-code` and `codex` call your local CLI login, and are meant for cheap testing.
+
+The backend can also be set with `THUNC_BACKEND`.
+
+**Type checking:** signatures and return types are visible to mypy and Pyright. mypy reports
+empty bodies; turn that off with `disable_error_code = ["empty-body"]`.
+
+## Examples
+
+| | |
+|---|---|
+| [hello.py](https://github.com/Eltarras/thunc/blob/main/examples/hello.py) | The smallest call |
+| [support_inbox.py](https://github.com/Eltarras/thunc/blob/main/examples/support_inbox.py) | Docstring functions returning a `Literal`, an `int` with `ensure=`, a dataclass, and a reply; tickets processed in parallel |
+| [dynamic_prompts.py](https://github.com/Eltarras/thunc/blob/main/examples/dynamic_prompts.py) | Prompts built from a style guide with `thunc.call`, and a grading function generated from a rubric |
+| [log_triage.py](https://github.com/Eltarras/thunc/blob/main/examples/log_triage.py) | Plain Python and AI functions mixed, with tracing |
+
+## Code
+
+```
+thunc/
+  __init__.py    public API
+  decorator.py   @thunc.function
+  core.py        thunc.call, thunc.map, tracing
+  schema.py      return types: describe, parse, validate
+  config.py      settings and backend selection
+  backends.py    anthropic, claude-code, codex
+  errors.py      ThuncError
+tests/           offline: a fake backend, never a real model
+live_tests/      against a real model: hello, a yes/no decision, messy text to a dict
+examples/
+```
+
+## Limitations
+
+- **There's no caching and no record/replay yet**, so repeated calls cost again.
+- **The API-key backend hasn't been run live yet.** It's only checked against the SDK's types.
+- **`Literal` results from `thunc.call` are typed as `Any`.** `@thunc.function` has no such gap.
+- **Docstrings disappear under `python -OO`.** Use `instructions=` there.
+
+## Development
+
+```bash
+python3 -m venv .venv && .venv/bin/pip install -e ".[anthropic,dev]"
+.venv/bin/pytest                    # offline tests (these run in CI)
+.venv/bin/pytest live_tests         # real model calls through your Claude Code login; costs quota
+.venv/bin/ruff check . && .venv/bin/mypy --strict thunc
+```
+
+## License
+
+[MIT](https://github.com/Eltarras/thunc/blob/main/LICENSE)

thunc-0.1.0/examples/dynamic_prompts.py

@@ -0,0 +1,63 @@
+"""String prompts: instructions built in code from data.
+
+Rule of thumb: your own text (config, rubric) may go in the instructions; user content goes in
+the inputs, never into the instructions through an f-string.
+
+Run from the repo root:  python3 -m examples.dynamic_prompts
+"""
+
+import os
+from dataclasses import dataclass
+
+import thunc
+
+thunc.configure(backend=os.environ.get("THUNC_BACKEND", "claude-code"))
+
+# 1. thunc.call: one prompt per target language, assembled from a style guide.
+
+STYLE_GUIDES = {
+    "Dutch": "Use informal 'je', not 'u'. Keep product names in English.",
+    "German": "Use formal 'Sie'. Keep product names in English.",
+    "French": "Use 'vous'. Put a non-breaking space before ! and ?.",
+}
+release_note = "New: export your dashboards to PDF! Find it under Share → Export."
+
+for language, rules in STYLE_GUIDES.items():
+    translated = thunc.call(
+        f"Translate the release note into {language}. Style rules: {rules}", {"release_note": release_note}
+    )
+    print(f"{language:7} {translated}")
+
+
+# 2. @thunc.function(instructions=...): a typed, reusable function whose prompt comes from data.
+
+
+@dataclass
+class Grade:
+    score: int
+    feedback: str
+
+
+QUESTION = "Why does HTTPS protect against eavesdropping?"
+CRITERIA = [
+    "mentions encryption of the traffic",
+    "mentions that the server's identity is verified with a certificate",
+    "is at most three sentences",
+]
+rubric = "\n".join(f"- {c}" for c in CRITERIA)
+
+
+@thunc.function(
+    instructions=f"Grade the student's answer to: {QUESTION}\nAward one point per criterion met:\n{rubric}\n"
+    "Give one sentence of feedback naming what is missing, if anything.",
+    ensure=lambda g: 0 <= g.score <= len(CRITERIA),
+)
+def grade(answer: str) -> Grade: ...
+
+
+answers = [
+    "Because the data is encrypted so nobody in between can read it.",
+    "TLS encrypts traffic, and the certificate proves you're talking to the real server.",
+]
+for answer, result in zip(answers, thunc.map(grade, answers), strict=True):
+    print(f"\n{result.score}/{len(CRITERIA)}  {answer}\n     {result.feedback}")

thunc-0.1.0/examples/hello.py

@@ -0,0 +1,6 @@
+"""The smallest call.  Run from the repo root:  python3 -m examples.hello"""
+
+import thunc
+
+thunc.configure(backend="claude-code")
+print(thunc.call("Say hello in five words or fewer."))

thunc-0.1.0/examples/log_triage.py

@@ -0,0 +1,60 @@
+"""Plain Python and AI functions together: triage the errors in a service log, with tracing on.
+
+Run from the repo root:  python3 -m examples.log_triage
+"""
+
+import json
+import os
+import re
+import tempfile
+from collections import Counter
+from typing import Literal
+
+import thunc
+
+trace_file = os.path.join(tempfile.gettempdir(), "thunc_log_triage.jsonl")
+if os.path.exists(trace_file):
+    os.remove(trace_file)
+thunc.configure(backend=os.environ.get("THUNC_BACKEND", "claude-code"), trace=trace_file)
+
+LOG = """\
+2026-10-03 09:12:01 INFO  api    request GET /health 200
+2026-10-03 09:12:04 ERROR api    psycopg.OperationalError: connection to server at "10.0.3.7", port 5432 failed: timeout
+2026-10-03 09:12:09 ERROR api    psycopg.OperationalError: connection to server at "10.0.3.7", port 5432 failed: timeout
+2026-10-03 09:13:30 ERROR worker KeyError: 'customer_id' in invoices/render.py line 88
+2026-10-03 09:15:47 ERROR api    ssl.SSLCertVerificationError: certificate has expired (hostname='payments.example.com')
+2026-10-03 09:16:12 ERROR worker KeyError: 'customer_id' in invoices/render.py line 88
+"""
+
+
+@thunc.function
+def owner(error: str) -> Literal["database", "application-code", "certificates", "network", "unknown"]:
+    """Which area most likely needs to act on this production error?"""
+    ...
+
+
+@thunc.function
+def first_step(error: str, owner: str) -> str:
+    """Suggest the single most useful first debugging step for this error, in one sentence."""
+    ...
+
+
+# Plain Python does the cheap part: find and count the unique errors.
+errors = Counter(m[1] for m in re.finditer(r"ERROR \w+\s+(.*)", LOG))
+
+
+def analyse(error: str) -> tuple[str, str]:
+    area = owner(error)
+    return area, first_step(error, area)
+
+
+for error, (area, step) in zip(errors, thunc.map(analyse, list(errors)), strict=True):
+    print(f"{errors[error]}x [{area}] {error[:70]}\n     → {step}")
+
+# The trace has one JSON line per call: inputs, raw answers, attempts, timing.
+calls = [json.loads(line) for line in open(trace_file, encoding="utf-8")]
+retried = sum(c["attempts"] > 1 for c in calls)
+print(
+    f"\n{len(calls)} calls traced to {trace_file}; {retried} needed a retry; "
+    f"slowest {max(c['seconds'] for c in calls):.1f}s"
+)

thunc-0.1.0/examples/support_inbox.py

@@ -0,0 +1,63 @@
+"""Docstring prompts: triage a support inbox.
+
+Run from the repo root:  python3 -m examples.support_inbox
+"""
+
+import os
+from dataclasses import dataclass
+from typing import Literal
+
+import thunc
+
+thunc.configure(backend=os.environ.get("THUNC_BACKEND", "claude-code"))
+
+
+@dataclass
+class Order:
+    order_id: str
+    product: str | None = None
+    amount_eur: float | None = None
+
+
+@thunc.function
+def category(ticket: str) -> Literal["bug", "billing", "feature-request", "other"]:
+    """Classify this customer support ticket."""
+    ...
+
+
+@thunc.function(ensure=lambda n: 1 <= n <= 5)
+def urgency(ticket: str) -> int:
+    """Rate how urgent this ticket is, from 1 (can wait a week) to 5 (customer is blocked right now)."""
+    ...
+
+
+@thunc.function
+def find_order(ticket: str) -> Order | None:
+    """Extract the order this ticket is about, or null if it doesn't mention one."""
+    ...
+
+
+@thunc.function
+def draft_reply(ticket: str, tone: str = "friendly and concise") -> str:
+    """Write a short first reply to this ticket in the given tone. Never promise a refund."""
+    ...
+
+
+tickets = [
+    "I was charged twice for order #A-1042 (Pro plan, €49). Please fix this today!",
+    "It would be great if the dashboard had a dark mode.",
+    "Export to CSV crashes with 'unexpected token' since this morning's update.",
+]
+
+
+def triage(ticket: str) -> tuple[str, int, Order | None]:
+    return category(ticket), urgency(ticket), find_order(ticket)
+
+
+# The tickets are triaged in parallel; each ticket's three calls run in sequence.
+for ticket, (kind, level, order) in zip(tickets, thunc.map(triage, tickets), strict=True):
+    print(f"[{kind:15}] urgency {level}  {ticket}")
+    if order:
+        print(f"{'':19}order: {order}")
+
+print("\nDraft reply to the first ticket:\n" + draft_reply(tickets[0]))

thunc-0.1.0/live_tests/conftest.py

@@ -0,0 +1,25 @@
+"""Live tests call a real model, so they cost quota and answers can vary. Plain `pytest` skips them.
+
+pytest live_tests                          # through your local Claude Code login
+THUNC_BACKEND=codex pytest live_tests
+THUNC_BACKEND=anthropic pytest live_tests  # needs ANTHROPIC_API_KEY and `pip install anthropic`
+"""
+
+import os
+import shutil
+
+import pytest
+
+import thunc
+
+BACKEND = os.environ.get("THUNC_BACKEND", "claude-code")
+CLI = {"claude-code": "claude", "codex": "codex"}
+
+
+@pytest.fixture(autouse=True, scope="session")
+def live_backend():
+    if BACKEND in CLI and shutil.which(CLI[BACKEND]) is None:
+        pytest.skip(f"the `{CLI[BACKEND]}` CLI is not installed")
+    if BACKEND == "anthropic" and not os.environ.get("ANTHROPIC_API_KEY"):
+        pytest.skip("ANTHROPIC_API_KEY is not set")
+    thunc.configure(backend=BACKEND)

thunc-0.1.0/live_tests/test_bool_decision.py

@@ -0,0 +1,22 @@
+import thunc
+
+
+@thunc.function
+def bool_decision() -> bool:
+    """is 1 =3?"""
+    ...
+
+
+@thunc.function
+def is_true(statement: str) -> bool:
+    """Is this statement true?"""
+    ...
+
+
+def test_false_statement():
+    assert bool_decision() is False
+
+
+def test_true_statement():
+    # Without a true case, a model that always answers False would pass.
+    assert is_true("2 + 2 = 4") is True

thunc-0.1.0/live_tests/test_dict_output.py

@@ -0,0 +1,35 @@
+"""Raw, messy text in; a dict out. The log mixes decimal commas (42,50), "€134,-" for 134.00,
+a "2x ... each" multiplication, and several date and currency spellings."""
+
+import pytest
+
+import thunc
+
+RAW_EXPENSES = """\
+03/09 - Uber airport -> hotel  €42,50 (Sara)
+lunch @ Bistro Amsterdam: 18.90 EUR - Tom
+2026-09-03 coffee x3 7.20
+Sept 4th, train tickets AMS-RTM 2x €16.80 each
+hotel 2 nights 289.00 eur  paid by company card
+4/9 dinner w/ client  €134,-
+taxi back 38 euro (receipt lost)
+coffee 2,40
+Train RTM-AMS €33.60 total
+04-09 snacks for the booth: €12.35
+"""
+
+# transport: 42.50 + 2 x 16.80 + 38.00 + 33.60
+# food:      18.90 + 7.20 + 134.00 + 2.40 + 12.35
+# lodging:   289.00
+EXPECTED = {"transport": 147.70, "food": 174.85, "lodging": 289.00}
+
+
+@thunc.function(ensure=lambda d: set(d) == {"transport", "food", "lodging"})
+def totals_by_category(expenses: str) -> dict[str, float]:
+    """Total these trip expenses per category: transport, food and lodging. All amounts are in euros."""
+    ...
+
+
+def test_totals_by_category():
+    totals = totals_by_category(RAW_EXPENSES)
+    assert totals == pytest.approx(EXPECTED, abs=0.01)

thunc-0.1.0/live_tests/test_hello.py

@@ -0,0 +1,13 @@
+import thunc
+
+
+@thunc.function
+def hello():
+    """Hello"""
+    ...
+
+
+def test_hello_returns_text():
+    reply = hello()
+    assert isinstance(reply, str)
+    assert reply.strip()