# Using uv (fast Python package installer)
uv venv
source .venv/bin/activate
uv pip install -e ".[dev]"

# Or with pip
python -m venv .venv
pip install -e ".[dev]"

# pytest example
import pytest

def test_addition():
    assert 1 + 1 == 2

@pytest.fixture
def sample_data():
    return {"key": "value"}

def test_with_fixture(sample_data):
    assert sample_data["key"] == "value"

"""
Demonstrate free-threaded Python 3.13+ with concurrent CPU work.

Run with: PYTHON_GIL=0 python examples/free_threading.py
Requires: Python 3.13+ built with --disable-gil (or 3.13t build)
"""
import sys
import threading
import time

def cpu_bound_task(n: int, results: list[int], index: int) -> None:
    """Compute sum of squares — pure CPU work."""
    total = sum(i * i for i in range(n))
    results[index] = total

def run_threaded(num_threads: int = 4, work_size: int = 1_000_000) -> float:
    results: list[int] = [0] * num_threads
    threads = [
        threading.Thread(target=cpu_bound_task, args=(work_size, results, i))
        for i in range(num_threads)
    ]
    start = time.perf_counter()
    for t in threads:
        t.start()
    for t in threads:
        t.join()
    elapsed = time.perf_counter() - start
    return elapsed

if __name__ == "__main__":
    gil_status = "disabled" if not sys._is_gil_enabled() else "enabled"  # type: ignore[attr-defined]
    print(f"GIL: {gil_status}")
    elapsed = run_threaded()
    print(f"4 threads, 1M work each: {elapsed:.3f}s")

"""
Template strings (PEP 750) — Python 3.14+.

t-strings return a Template object; the caller controls rendering,
enabling safe interpolation into SQL, HTML, or shell commands.
"""
import html as html_mod

# Standard library html module gains t-string support in 3.14
# This example shows the core pattern without stdlib t-string types.

def render_html(template) -> str:
    """Escape interpolated values for safe HTML output."""
    parts: list[str] = []
    for item in template:
        if isinstance(item, str):
            parts.append(item)
        else:
            # item.value is the runtime expression result
            parts.append(html_mod.escape(str(item.value)))
    return "".join(parts)

user_input = "<script>alert('xss')</script>"
# In Python 3.14: template = t"<p>Hello, {user_input}!</p>"
# safe_html = render_html(template)
# => "<p>Hello, &lt;script&gt;alert(&#x27;xss&#x27;)&lt;/script&gt;!</p>"
print("Template strings enable safe interpolation — escaping is caller-controlled.")

"""
Deferred annotation evaluation (PEP 649) — Python 3.14+.

Annotations are not evaluated at class/function definition time;
they are computed lazily. Forward references work without quotes.
"""
from __future__ import annotations  # backport shim; native in 3.14

from dataclasses import dataclass

@dataclass
class Node:
    value: int
    # Forward reference — works without quotes under PEP 649
    children: list[Node]

    def depth(self) -> int:
        if not self.children:
            return 0
        return 1 + max(child.depth() for child in self.children)

root = Node(value=1, children=[
    Node(value=2, children=[]),
    Node(value=3, children=[Node(value=4, children=[])]),
])
print(f"Tree depth: {root.depth()}")  # => 2

from mcp.server import FastMCP

mcp = FastMCP("my-tool-server")

@mcp.tool()
def search(query: str, limit: int = 10) -> list[dict]:
    """Full-text search over the knowledge base."""
    return perform_search(query, limit)

if __name__ == "__main__":
    mcp.run()  # stdio transport by default

from anthropic import Anthropic
from pydantic import BaseModel

class CodeReview(BaseModel):
    summary: str
    issues: list[str]
    severity: str  # "low" | "medium" | "high"
    approved: bool

client = Anthropic()
response = client.messages.create(
    model="claude-opus-4-5",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Review this diff: ..."}],
)
# Structured parsing with tool_use or beta structured output