tacet 0.1.0__py3-none-any.whl

tacet/__init__.py

@@ -0,0 +1,57 @@
+"""Official Python client for the Tacet API."""
+
+from ._async_client import AsyncTacet
+from ._client import Tacet
+from ._errors import (
+    APIConnectionError,
+    APIError,
+    AuthenticationError,
+    InsufficientCreditError,
+    InvalidRequestError,
+    RateLimitError,
+    TacetError,
+)
+from ._models import (
+    Answer,
+    ChoiceAnswer,
+    DecideResult,
+    HealthStatus,
+    Model,
+    ModelList,
+    ModelPricing,
+    NoulAnswer,
+    ScoreAnswer,
+    Usage,
+)
+from ._questions import Question, choice, noul, score
+from ._version import __version__
+
+__all__ = [
+    "Tacet",
+    "AsyncTacet",
+    "__version__",
+    # question builders
+    "choice",
+    "score",
+    "noul",
+    "Question",
+    # result types
+    "DecideResult",
+    "Answer",
+    "ChoiceAnswer",
+    "ScoreAnswer",
+    "NoulAnswer",
+    "Usage",
+    "Model",
+    "ModelList",
+    "ModelPricing",
+    "HealthStatus",
+    # errors
+    "TacetError",
+    "AuthenticationError",
+    "InsufficientCreditError",
+    "RateLimitError",
+    "InvalidRequestError",
+    "APIError",
+    "APIConnectionError",
+]

tacet/_async_client.py

@@ -0,0 +1,121 @@
+"""Asynchronous Tacet client."""
+
+from __future__ import annotations
+
+import asyncio
+import os
+from typing import Any, Awaitable, Callable, Dict, Optional
+
+import httpx
+
+from ._base_client import (
+    DEFAULT_BASE_URL,
+    build_decide_payload,
+    build_headers,
+    compute_backoff_seconds,
+    error_from_response,
+    should_retry_status,
+)
+from ._errors import APIConnectionError
+from ._models import (
+    DecideResult,
+    HealthStatus,
+    ModelList,
+    decode_decide_response,
+    decode_health,
+    decode_model_list,
+)
+from ._questions import Question
+from ._version import __version__
+
+
+class AsyncTacet:
+    """Asynchronous client for the Tacet API."""
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        base_url: str = DEFAULT_BASE_URL,
+        timeout: float = 90.0,
+        max_retries: int = 2,
+        *,
+        http_client: Optional[httpx.AsyncClient] = None,
+        sleep_function: Callable[[float], Awaitable[None]] = asyncio.sleep,
+    ) -> None:
+        resolved_api_key = api_key or os.environ.get("TACET_API_KEY")
+        if not resolved_api_key:
+            raise ValueError(
+                "No Tacet API key provided. Pass api_key=... to AsyncTacet(), or set the "
+                "TACET_API_KEY environment variable."
+            )
+
+        self.api_key = resolved_api_key
+        self.base_url = base_url.rstrip("/")
+        self.max_retries = max_retries
+        self._sleep_function = sleep_function
+        self._http_client = http_client or httpx.AsyncClient(timeout=timeout)
+
+    async def close(self) -> None:
+        await self._http_client.aclose()
+
+    async def __aenter__(self) -> "AsyncTacet":
+        return self
+
+    async def __aexit__(self, *exception_info: object) -> None:
+        await self.close()
+
+    async def decide(
+        self,
+        state: Any,
+        questions: Dict[str, Question],
+        model: Optional[str] = "tacet-1",
+    ) -> DecideResult:
+        """Ask the model to answer ``questions`` about ``state``."""
+        payload = build_decide_payload(state, questions, model)
+        response = await self._request("POST", "/systemone", json_body=payload)
+        return decode_decide_response(response.json())
+
+    async def models(self) -> ModelList:
+        """List the models available through the API."""
+        response = await self._request("GET", "/models")
+        return decode_model_list(response.json())
+
+    async def health(self) -> HealthStatus:
+        """Check API health."""
+        response = await self._request("GET", "/health")
+        return decode_health(response.json())
+
+    async def _request(
+        self,
+        method: str,
+        path: str,
+        json_body: Optional[Dict[str, Any]] = None,
+    ) -> httpx.Response:
+        headers = build_headers(self.api_key, f"tacet-python/{__version__}")
+        url = f"{self.base_url}{path}"
+
+        attempt_number = 0
+        while True:
+            try:
+                response = await self._http_client.request(method, url, headers=headers, json=json_body)
+            except httpx.HTTPError as network_error:
+                if attempt_number >= self.max_retries:
+                    raise APIConnectionError(
+                        f"Connection to Tacet API failed: {network_error}"
+                    ) from network_error
+                await self._sleep_function(compute_backoff_seconds(attempt_number, None))
+                attempt_number += 1
+                continue
+
+            if response.status_code < 400:
+                return response
+
+            error = error_from_response(response)
+
+            if attempt_number < self.max_retries and should_retry_status(response.status_code):
+                retry_after_seconds = getattr(error, "retry_after", None)
+                await self._sleep_function(compute_backoff_seconds(attempt_number, retry_after_seconds))
+                attempt_number += 1
+                continue
+
+            raise error

tacet/_base_client.py

@@ -0,0 +1,148 @@
+"""Request/response plumbing shared by the sync and async Tacet clients.
+
+Kept free of any actual HTTP I/O so both ``Tacet`` and ``AsyncTacet`` can
+reuse it without duplicating the header, payload, error-decoding, and
+retry-timing logic.
+"""
+
+from __future__ import annotations
+
+import random
+from typing import Any, Dict, Optional
+
+import httpx
+
+from ._errors import (
+    APIError,
+    AuthenticationError,
+    InsufficientCreditError,
+    InvalidRequestError,
+    RateLimitError,
+    TacetError,
+)
+
+DEFAULT_BASE_URL = "https://tacet.codepawl.com/v1"
+
+_RETRYABLE_STATUS_CODES = frozenset({429, 500, 502, 503, 504})
+
+_DEFAULT_RETRY_AFTER_SECONDS = 1.0
+_MAX_BACKOFF_SECONDS = 30.0
+_JITTER_FRACTION = 0.1
+
+
+def build_headers(api_key: str, user_agent: str) -> Dict[str, str]:
+    return {
+        "Authorization": f"Bearer {api_key}",
+        "Content-Type": "application/json",
+        "User-Agent": user_agent,
+    }
+
+
+def build_decide_payload(
+    state: Any,
+    questions: Dict[str, Any],
+    model: Optional[str],
+) -> Dict[str, Any]:
+    payload: Dict[str, Any] = {"state": state, "questions": questions}
+    if model is not None:
+        payload["model"] = model
+    return payload
+
+
+def should_retry_status(status_code: int) -> bool:
+    return status_code in _RETRYABLE_STATUS_CODES
+
+
+def parse_retry_after_seconds(header_value: Optional[str]) -> float:
+    if header_value is None:
+        return _DEFAULT_RETRY_AFTER_SECONDS
+    try:
+        return float(header_value)
+    except ValueError:
+        return _DEFAULT_RETRY_AFTER_SECONDS
+
+
+def compute_backoff_seconds(attempt_number: int, retry_after_seconds: Optional[float]) -> float:
+    """Delay before the next attempt.
+
+    Honours the server's ``Retry-After`` when given; otherwise exponential
+    backoff with jitter, capped at ``_MAX_BACKOFF_SECONDS``.
+    """
+    if retry_after_seconds is not None:
+        return retry_after_seconds
+
+    base_delay_seconds = min(2**attempt_number, _MAX_BACKOFF_SECONDS)
+    jitter_seconds = random.uniform(0, base_delay_seconds * _JITTER_FRACTION)
+    return base_delay_seconds + jitter_seconds
+
+
+def error_from_response(response: httpx.Response) -> TacetError:
+    """Build the right ``TacetError`` subclass from a non-2xx response."""
+    status_code = response.status_code
+    request_id = response.headers.get("X-Request-Id")
+
+    message = f"Tacet API request failed with status {status_code}"
+    code: Optional[str] = None
+    error_type: Optional[str] = None
+    param: Optional[str] = None
+
+    try:
+        error_envelope = response.json().get("error", {})
+    except ValueError:
+        error_envelope = {}
+
+    message = error_envelope.get("message", message)
+    code = error_envelope.get("code")
+    error_type = error_envelope.get("type")
+    param = error_envelope.get("param")
+
+    if status_code == 401:
+        return AuthenticationError(
+            message,
+            status=status_code,
+            code=code,
+            error_type=error_type,
+            param=param,
+            request_id=request_id,
+        )
+
+    if status_code == 402:
+        return InsufficientCreditError(
+            message,
+            status=status_code,
+            code=code,
+            error_type=error_type,
+            param=param,
+            request_id=request_id,
+        )
+
+    if status_code == 429:
+        retry_after_seconds = parse_retry_after_seconds(response.headers.get("Retry-After"))
+        return RateLimitError(
+            message,
+            retry_after=retry_after_seconds,
+            status=status_code,
+            code=code,
+            error_type=error_type,
+            param=param,
+            request_id=request_id,
+        )
+
+    if status_code in (400, 404, 413):
+        return InvalidRequestError(
+            message,
+            status=status_code,
+            code=code,
+            error_type=error_type,
+            param=param,
+            request_id=request_id,
+        )
+
+    return APIError(
+        message,
+        status=status_code,
+        code=code,
+        error_type=error_type,
+        param=param,
+        request_id=request_id,
+    )

tacet/_client.py

@@ -0,0 +1,121 @@
+"""Synchronous Tacet client."""
+
+from __future__ import annotations
+
+import os
+import time
+from typing import Any, Callable, Dict, Optional
+
+import httpx
+
+from ._base_client import (
+    DEFAULT_BASE_URL,
+    build_decide_payload,
+    build_headers,
+    compute_backoff_seconds,
+    error_from_response,
+    should_retry_status,
+)
+from ._errors import APIConnectionError
+from ._models import (
+    DecideResult,
+    HealthStatus,
+    ModelList,
+    decode_decide_response,
+    decode_health,
+    decode_model_list,
+)
+from ._questions import Question
+from ._version import __version__
+
+
+class Tacet:
+    """Synchronous client for the Tacet API."""
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        base_url: str = DEFAULT_BASE_URL,
+        timeout: float = 90.0,
+        max_retries: int = 2,
+        *,
+        http_client: Optional[httpx.Client] = None,
+        sleep_function: Callable[[float], None] = time.sleep,
+    ) -> None:
+        resolved_api_key = api_key or os.environ.get("TACET_API_KEY")
+        if not resolved_api_key:
+            raise ValueError(
+                "No Tacet API key provided. Pass api_key=... to Tacet(), or set the "
+                "TACET_API_KEY environment variable."
+            )
+
+        self.api_key = resolved_api_key
+        self.base_url = base_url.rstrip("/")
+        self.max_retries = max_retries
+        self._sleep_function = sleep_function
+        self._http_client = http_client or httpx.Client(timeout=timeout)
+
+    def close(self) -> None:
+        self._http_client.close()
+
+    def __enter__(self) -> "Tacet":
+        return self
+
+    def __exit__(self, *exception_info: object) -> None:
+        self.close()
+
+    def decide(
+        self,
+        state: Any,
+        questions: Dict[str, Question],
+        model: Optional[str] = "tacet-1",
+    ) -> DecideResult:
+        """Ask the model to answer ``questions`` about ``state``."""
+        payload = build_decide_payload(state, questions, model)
+        response = self._request("POST", "/systemone", json_body=payload)
+        return decode_decide_response(response.json())
+
+    def models(self) -> ModelList:
+        """List the models available through the API."""
+        response = self._request("GET", "/models")
+        return decode_model_list(response.json())
+
+    def health(self) -> HealthStatus:
+        """Check API health."""
+        response = self._request("GET", "/health")
+        return decode_health(response.json())
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        json_body: Optional[Dict[str, Any]] = None,
+    ) -> httpx.Response:
+        headers = build_headers(self.api_key, f"tacet-python/{__version__}")
+        url = f"{self.base_url}{path}"
+
+        attempt_number = 0
+        while True:
+            try:
+                response = self._http_client.request(method, url, headers=headers, json=json_body)
+            except httpx.HTTPError as network_error:
+                if attempt_number >= self.max_retries:
+                    raise APIConnectionError(
+                        f"Connection to Tacet API failed: {network_error}"
+                    ) from network_error
+                self._sleep_function(compute_backoff_seconds(attempt_number, None))
+                attempt_number += 1
+                continue
+
+            if response.status_code < 400:
+                return response
+
+            error = error_from_response(response)
+
+            if attempt_number < self.max_retries and should_retry_status(response.status_code):
+                retry_after_seconds = getattr(error, "retry_after", None)
+                self._sleep_function(compute_backoff_seconds(attempt_number, retry_after_seconds))
+                attempt_number += 1
+                continue
+
+            raise error

tacet/_errors.py

@@ -0,0 +1,83 @@
+"""Exception hierarchy raised by the Tacet client."""
+
+from __future__ import annotations
+
+from typing import Optional, Union
+
+
+class TacetError(Exception):
+    """Base class for every error the Tacet client can raise.
+
+    Attributes mirror the fields Tacet's error envelope sends back, plus the
+    HTTP status and the request id from the ``X-Request-Id`` response header.
+    """
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        status: Optional[int] = None,
+        code: Optional[str] = None,
+        error_type: Optional[str] = None,
+        param: Optional[str] = None,
+        request_id: Optional[str] = None,
+    ) -> None:
+        super().__init__(message)
+        self.message = message
+        self.status = status
+        self.code = code
+        self.error_type = error_type
+        self.param = param
+        self.request_id = request_id
+
+    def __str__(self) -> str:
+        return self.message
+
+
+class AuthenticationError(TacetError):
+    """Raised for HTTP 401 responses (missing, invalid, or revoked API key)."""
+
+
+class InsufficientCreditError(TacetError):
+    """Raised for HTTP 402 responses when the account is out of credit."""
+
+
+class RateLimitError(TacetError):
+    """Raised for HTTP 429 responses.
+
+    ``retry_after`` is the number of seconds the server asked the caller to
+    wait, taken from the ``Retry-After`` response header.
+    """
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        retry_after: Union[int, float],
+        status: Optional[int] = None,
+        code: Optional[str] = None,
+        error_type: Optional[str] = None,
+        param: Optional[str] = None,
+        request_id: Optional[str] = None,
+    ) -> None:
+        super().__init__(
+            message,
+            status=status,
+            code=code,
+            error_type=error_type,
+            param=param,
+            request_id=request_id,
+        )
+        self.retry_after = retry_after
+
+
+class InvalidRequestError(TacetError):
+    """Raised for HTTP 400/404/413 responses that are not auth, credit, or rate-limit errors."""
+
+
+class APIError(TacetError):
+    """Raised for HTTP 5xx responses."""
+
+
+class APIConnectionError(TacetError):
+    """Raised when a request fails before a response is received (network or connection failure)."""

tacet/_models.py

@@ -0,0 +1,175 @@
+"""Typed result objects returned by the Tacet client, and their JSON decoders."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Dict, Iterator, List, Optional, Union
+
+
+@dataclass(frozen=True)
+class ChoiceAnswer:
+    """Answer to a "choice" question."""
+
+    choice: str
+    probabilities: Dict[str, float]
+    confidence: float
+    type: str = "choice"
+
+
+@dataclass(frozen=True)
+class ScoreAnswer:
+    """Answer to a "score" question. ``score`` is the expected value."""
+
+    score: float
+    probabilities: Dict[str, float]
+    confidence: float
+    type: str = "score"
+
+
+@dataclass(frozen=True)
+class NoulAnswer:
+    """Answer to a "noul" question. ``noul`` is a 0.0-1.0 value, no probabilities."""
+
+    noul: float
+    confidence: float
+    type: str = "noul"
+
+
+Answer = Union[ChoiceAnswer, ScoreAnswer, NoulAnswer]
+
+
+@dataclass(frozen=True)
+class Usage:
+    input_tokens: int
+    output_tokens: int
+    state_truncated: Optional[bool] = None
+    options_truncated: Optional[bool] = None
+
+
+@dataclass(frozen=True)
+class DecideResult:
+    """Result of a call to ``decide()``."""
+
+    model: str
+    answers: Dict[str, Answer]
+    usage: Usage
+
+
+@dataclass(frozen=True)
+class ModelPricing:
+    input_per_million_tokens_usd: float
+    output_per_million_tokens_usd: float
+
+
+@dataclass(frozen=True)
+class Model:
+    id: str
+    object: str
+    owned_by: str
+    name: str
+    context_length: int
+    max_output_tokens: int
+    pricing: ModelPricing
+    features: List[str] = field(default_factory=list)
+    datacenter: Optional[str] = None
+
+
+@dataclass(frozen=True)
+class ModelList:
+    """Result of a call to ``models()``."""
+
+    object: str
+    data: List[Model]
+
+    def __iter__(self) -> Iterator[Model]:
+        return iter(self.data)
+
+    def __len__(self) -> int:
+        return len(self.data)
+
+
+@dataclass(frozen=True)
+class HealthStatus:
+    """Result of a call to ``health()``."""
+
+    ok: bool
+    model: str
+
+
+def decode_answer(question_id: str, raw_answer: Dict[str, Any]) -> Answer:
+    answer_type = raw_answer.get("type")
+
+    if answer_type == "choice":
+        return ChoiceAnswer(
+            choice=raw_answer["choice"],
+            probabilities=raw_answer.get("probabilities", {}),
+            confidence=raw_answer["confidence"],
+        )
+
+    if answer_type == "score":
+        return ScoreAnswer(
+            score=raw_answer["score"],
+            probabilities=raw_answer.get("probabilities", {}),
+            confidence=raw_answer["confidence"],
+        )
+
+    if answer_type == "noul":
+        return NoulAnswer(
+            noul=raw_answer["noul"],
+            confidence=raw_answer["confidence"],
+        )
+
+    raise ValueError(f"Unknown answer type {answer_type!r} for question {question_id!r}")
+
+
+def decode_usage(raw_usage: Dict[str, Any]) -> Usage:
+    return Usage(
+        input_tokens=raw_usage["input_tokens"],
+        output_tokens=raw_usage["output_tokens"],
+        state_truncated=raw_usage.get("state_truncated"),
+        options_truncated=raw_usage.get("options_truncated"),
+    )
+
+
+def decode_decide_response(raw_response: Dict[str, Any]) -> DecideResult:
+    answers = {
+        question_id: decode_answer(question_id, raw_answer)
+        for question_id, raw_answer in raw_response.get("answers", {}).items()
+    }
+    return DecideResult(
+        model=raw_response["model"],
+        answers=answers,
+        usage=decode_usage(raw_response.get("usage", {})),
+    )
+
+
+def decode_model(raw_model: Dict[str, Any]) -> Model:
+    raw_pricing = raw_model.get("pricing", {})
+    return Model(
+        id=raw_model["id"],
+        object=raw_model["object"],
+        owned_by=raw_model["owned_by"],
+        name=raw_model["name"],
+        context_length=raw_model["context_length"],
+        max_output_tokens=raw_model["max_output_tokens"],
+        pricing=ModelPricing(
+            input_per_million_tokens_usd=raw_pricing.get("input_per_million_tokens_usd", 0.0),
+            output_per_million_tokens_usd=raw_pricing.get("output_per_million_tokens_usd", 0.0),
+        ),
+        features=raw_model.get("features", []),
+        datacenter=raw_model.get("datacenter"),
+    )
+
+
+def decode_model_list(raw_response: Dict[str, Any]) -> ModelList:
+    return ModelList(
+        object=raw_response["object"],
+        data=[decode_model(raw_model) for raw_model in raw_response.get("data", [])],
+    )
+
+
+def decode_health(raw_response: Dict[str, Any]) -> HealthStatus:
+    return HealthStatus(
+        ok=raw_response["ok"],
+        model=raw_response["model"],
+    )

tacet/_questions.py

@@ -0,0 +1,41 @@
+"""Convenience builders for the question shapes the Tacet API accepts.
+
+Each builder returns a plain dict matching the request body shape documented
+at https://tacet.codepawl.com/docs — callers can also build that dict by hand
+and pass it into ``decide(questions=...)`` directly.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Mapping, Optional
+
+Question = Dict[str, Any]
+
+
+def choice(instructions: str, options: Mapping[str, Any]) -> Question:
+    """Build a "choice" question: pick one option out of a named set."""
+    return {
+        "type": "choice",
+        "instructions": instructions,
+        "criteria": dict(options),
+    }
+
+
+def score(instructions: str, levels: List[Any]) -> Question:
+    """Build a "score" question: an expected value over an ordered list of levels."""
+    return {
+        "type": "score",
+        "instructions": instructions,
+        "criteria": list(levels),
+    }
+
+
+def noul(instructions: str, criteria: Optional[Mapping[str, Any]] = None) -> Question:
+    """Build a "noul" question: a 0.0-1.0 true/false-leaning judgment."""
+    question: Question = {
+        "type": "noul",
+        "instructions": instructions,
+    }
+    if criteria is not None:
+        question["criteria"] = dict(criteria)
+    return question

tacet/_version.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

tacet-0.1.0.dist-info/METADATA

@@ -0,0 +1,108 @@
+Metadata-Version: 2.5
+Name: tacet
+Version: 0.1.0
+Summary: Official Python client for the Tacet API
+Project-URL: Homepage, https://tacet.codepawl.com
+Project-URL: Documentation, https://tacet.codepawl.com/docs
+Author-email: CodePawl <hello@codepawl.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: api client,classification,llm,tacet,typed decisions
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+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: Typing :: Typed
+Requires-Python: >=3.9
+Requires-Dist: httpx>=0.23
+Description-Content-Type: text/markdown
+
+# tacet
+
+Official Python client for the [Tacet API](https://tacet.codepawl.com/docs).
+
+## Install
+
+```bash
+pip install tacet
+# or
+uv add tacet
+```
+
+## Quickstart
+
+```python
+from tacet import Tacet, choice, score, noul
+
+client = Tacet(api_key="tacet_sk_...")  # or set TACET_API_KEY
+
+result = client.decide(
+    state="Customer says their export has been stuck at 'processing' for two days.",
+    questions={
+        "routing_team": choice(
+            "Which team should own this ticket?",
+            {"billing": "Payment or invoicing issues", "support": "Product or account issues"},
+        ),
+        "urgency": score(
+            "How urgent is this ticket?",
+            ["low", "medium", "high", "critical"],
+        ),
+        "needs_human": noul("Does this ticket need a human to step in?"),
+    },
+)
+
+print(result.answers["routing_team"].choice)
+print(result.answers["urgency"].score)
+print(result.answers["needs_human"].noul)
+print(result.usage.input_tokens)
+```
+
+An `AsyncTacet` client with the same methods, `await`ed, is available for
+async code.
+
+## Question types
+
+- **choice**: pick one option out of a named set. `criteria` maps option
+  names to descriptions. The answer carries `choice`, `probabilities` (one
+  per option), and `confidence`.
+- **score**: an expected level over an ordered list of levels. `criteria`
+  is that list. The answer carries `score`, `probabilities` (one per level
+  index), and `confidence`.
+- **noul**: yes or no. `noul` is the probability of yes, from 0 to 1, and
+  an optional `criteria` object says what "true" and "false" mean. The answer
+  carries `noul` and `confidence`, no probabilities.
+
+The `choice`, `score`, and `noul` helpers build the question dict for you;
+you can also pass the dict shape directly.
+
+## Errors and retries
+
+Every non-2xx response raises a subclass of `TacetError`, which carries
+`status`, `code`, `error_type`, `param`, `request_id`, and `message`:
+
+- `AuthenticationError`: 401 (missing, invalid, or revoked API key)
+- `InsufficientCreditError`: 402 (out of credit)
+- `RateLimitError`: 429, also carries `retry_after` seconds
+- `InvalidRequestError`: 400/404/413 (bad request, unknown model, state too large, etc.)
+- `APIError`: 5xx
+- `APIConnectionError`: the request failed before a response came back
+
+The client retries 429s (honoring the `Retry-After` header) and 500/502/503/504
+responses and connection failures, with exponential backoff and jitter, up to
+`max_retries` times (default 2). Other 4xx errors fail immediately and are
+never retried.
+
+## Idle starts
+
+If the API hasn't been called in a while, the first request after that idle
+period can take tens of seconds while it starts back up. The default timeout
+(90 seconds) accounts for this; don't lower it unless you know your traffic
+is steady.
+
+## Pricing
+
+$0.042 per 1M input tokens, and output is free. Details are in the
+[API docs](https://tacet.codepawl.com/docs).

tacet-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+tacet/__init__.py,sha256=tFUrEuKPUGb2bK-f5xXmxguskcLkPVgJ3hhMya1OeP0,1076
+tacet/_async_client.py,sha256=VwnOWS_QFsY8E3JUwxlG_ZPUZIX-ZwvSz1WSY5ldKs0,3949
+tacet/_base_client.py,sha256=t4-lI6EEDLEmBJux-uTrN397w62XowlrvFl8OMuWziU,4102
+tacet/_client.py,sha256=qS14gV2sdsIndtu-ibsFd5iRAAbzIwVLJjsUP16t9As,3801
+tacet/_errors.py,sha256=b5zm_sQDbG1iU5NMlBLK6RmKu9AbI-p08bETSPenmXI,2303
+tacet/_models.py,sha256=YtkwA3Yy_DUzmyuoQt2hI9K3X3-H4qB28YOI6hxhbVY,4736
+tacet/_questions.py,sha256=ScqFQblG7v9xgO8bHQx3dkO_w_xzpsGAD6dtb15N19c,1286
+tacet/_version.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+tacet/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tacet-0.1.0.dist-info/METADATA,sha256=-4EtY8RJkBc-51PIG-LinctdL2RFjhoBm3qFYWQ0yqk,3745
+tacet-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+tacet-0.1.0.dist-info/licenses/LICENSE,sha256=YU_PGB_Yd5Yj8eOtpG9WxLmz8V3zf5QtkhV392fJnGk,1065
+tacet-0.1.0.dist-info/RECORD,,

tacet-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

tacet-0.1.0.dist-info/licenses/LICENSE

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