Domain package¶

Kind: reference. This page is generated from the docstrings of typevet.domain. The API index lists the other packages.

typevet.domain ¶

Pure domain types for typed generation and candidate scoring.

Examples:

from typevet.domain import GenerationRequest, compile_json_schema

schema = {
    "type": "object",
    "properties": {"ok": {"type": "boolean"}},
    "required": ["ok"],
}
req = GenerationRequest(
    prompt="Classify sentiment.",
    schema=schema,
    model="gemma-4-31b-24gib-kv11-decoder",
)
assert compile_json_schema(schema)[0].syntax == "Bool"

Attributes¶

Answer `module-attribute` ¶

Answer = NoulAnswer | ChoiceAnswer | ScoreAnswer

Union type for all judgment answers.

Question `module-attribute` ¶

Question = Noul | Choice | Score

A typed judgment question.

Classes¶

CalibrationMap `dataclass` ¶

CalibrationMap(
    method: str,
    parameters: CalibrationParameters,
    fitted_on: FittedOn,
    evaluation: CalibrationEvaluation,
    producer: str,
    sha256: str,
    levels: int | None = None,
)

One validated calibration map for one task and one question.

Attributes:

Name	Type	Description
`method`	`str`	`temperature`, `platt` or `isotonic`.
`parameters`	`CalibrationParameters`	Fitted parameters for `method`.
`fitted_on`	`FittedOn`	Task, receipt, model and backend of the fit.
`evaluation`	`CalibrationEvaluation`	Held-out metrics, recorded only.
`producer`	`str`	The `typevet_evals` version that wrote the map.
`sha256`	`str`	The sha256 of the map file bytes.
`levels`	`int \| None`	The level count of a Score map; `None` for a Noul map.

Examples:

cmap = calibration_map_from_mapping(document, sha256=digest)
assert 0.0 < cmap.apply(0.6) < 1.0

Methods:¶

apply ¶

apply(p: float) -> float

Map one probability through the fitted function.

Parameters:

Name	Type	Description	Default
`p`	`float`	A probability in `[0, 1]`.	required

Returns:

Type	Description
`float`	The calibrated probability, clipped to ``[CALIBRATION_CLIP,
`float`	1 - CALIBRATION_CLIP]``.

Raises:

Type	Description
`CalibrationMapError`	`p` is not a finite number in `[0, 1]`.

apply_levels ¶

apply_levels(probabilities: Mapping[int, float]) -> dict[int, float]

Map each level probability, then rescale the levels to sum to 1.

Parameters:

Name	Type	Description	Default
`probabilities`	`Mapping[int, float]`	The level probabilities of one Score answer.	required

Returns:

Type	Description
`dict[int, float]`	The calibrated level probabilities, keyed as the input.

Raises:

Type	Description
`CalibrationMapError`	A level probability is not a finite number in `[0, 1]`.

CalibrationRecord `dataclass` ¶

CalibrationRecord(
    raw: float,
    calibrated: float,
    method: str,
    map_sha256: str,
    raw_levels: dict[int, float] | None = None,
    calibrated_levels: dict[int, float] | None = None,
)

The raw and calibrated value of one Noul or Score answer.

Attributes:

Name	Type	Description
`raw`	`float`	The Noul probability or the Score score that the inner judgment returned.
`calibrated`	`float`	The Noul probability or the Score score after the map.
`method`	`str`	The map method.
`map_sha256`	`str`	The sha256 of the map file bytes.
`raw_levels`	`dict[int, float] \| None`	The level probabilities that the inner judgment returned; `None` for a Noul answer.
`calibrated_levels`	`dict[int, float] \| None`	The level probabilities after the map and the rescale; `None` for a Noul answer.

Examples:

record = CalibrationRecord(
    raw=0.6, calibrated=0.45, method="platt", map_sha256="0" * 64
)
assert record.raw == 0.6

CandidateScoringRequest `dataclass` ¶

CandidateScoringRequest(
    model: str,
    prefix: str,
    candidates: tuple[CandidateTokenSpec, ...],
    stage: ScoreStage = PRE_SAMPLING,
    media: tuple[ImageInput, ...] = (),
)

Identify model, prefix, candidates, and required score stage.

Complete candidate coverage is required: adapters must return a score for every requested label and must not invent scores for omitted labels.

prefix must hold exactly one MEDIA_MARKER for each entry in media. An empty media tuple is the text-only ask.

Attributes:

Name	Type	Description
`model`	`str`	Backend model id or alias.
`prefix`	`str`	Rendered prompt prefix ending before candidate tokens.
`candidates`	`tuple[CandidateTokenSpec, ...]`	Ordered candidate set.
`stage`	`ScoreStage`	Required logprob extraction stage.
`media`	`tuple[ImageInput, ...]`	Images the prefix marks, in order.

Examples:

request = CandidateScoringRequest(
    model="m",
    prefix="Q:",
    candidates=(CandidateTokenSpec("a", (1,)),),
)
assert request.stage is ScoreStage.PRE_SAMPLING

Methods:¶

__post_init__ ¶

__post_init__() -> None

Reject empty fields, duplicate ids, bad markers or non-image media.

Stores media as a tuple, so a list input becomes immutable.

Raises:

Type	Description
`ScoringValidationError`	When the ask violates coverage rules or the media marker count does not match `len(media)`.
`TypeError`	When a media item is not an `ImageInput`.

CandidateTokenSpec `dataclass` ¶

CandidateTokenSpec(label: str, token_ids: tuple[int, ...])

One labeled candidate as an ordered token-id sequence.

Attributes:

Name	Type	Description
`label`	`str`	Stable candidate id (for example an enum string).
`token_ids`	`tuple[int, ...]`	Encoded token ids for this candidate.

Examples:

spec = CandidateTokenSpec("yes", (42,))
assert spec.token_ids == (42,)

Methods:¶

__post_init__ ¶

__post_init__() -> None

Reject empty labels or invalid token-id sequences.

Raises:

Type	Description
`ScoringValidationError`	When label or token ids are invalid.

CandidateScoringResult `dataclass` ¶

CandidateScoringResult(
    model: str,
    stage: ScoreStage,
    candidates: tuple[ScoredCandidate, ...],
    usage: TokenUsage = TokenUsage(),
    termination: ScoringTermination | None = None,
    off_option_mass: float | None = None,
)

Complete identity-preserving scores for every requested candidate.

Attributes:

Name	Type	Description
`model`	`str`	Model id that produced the scores.
`stage`	`ScoreStage`	Stage used to obtain logprobs.
`candidates`	`tuple[ScoredCandidate, ...]`	Scores in request order.
`usage`	`TokenUsage`	Optional token usage metadata.
`termination`	`ScoringTermination \| None`	Optional stop metadata.
`off_option_mass`	`float \| None`	Probability mass that the model put outside the candidate tokens, in `[0, 1]`. It is `1 - sum(exp(logprob))` over the raw candidate logprobs. `None` means the backend did not return the full-vocabulary distribution, so the value is unavailable.

Examples:

result = CandidateScoringResult(
    model="m",
    stage=ScoreStage.PRE_SAMPLING,
    candidates=(ScoredCandidate("a", (1,), -1.0),),
)
assert len(result.candidates) == 1
assert result.off_option_mass is None

ScoredCandidate `dataclass` ¶

ScoredCandidate(label: str, token_ids: tuple[int, ...], logprob: float)

One candidate label, token ids, and raw logprob.

Attributes:

Name	Type	Description
`label`	`str`	Candidate id matching the request label.
`token_ids`	`tuple[int, ...]`	Token sequence matching the request.
`logprob`	`float`	Raw pre-sampling logprob for this candidate.

Examples:

scored = ScoredCandidate("billing", (101,), -0.25)
assert scored.label == "billing"

ScoringTermination `dataclass` ¶

ScoringTermination(finish_reason: str | None = None)

Optional backend termination metadata for a scoring call.

Attributes:

Name	Type	Description
`finish_reason`	`str \| None`	Backend stop reason when reported.

Examples:

meta = ScoringTermination(finish_reason="length")
assert meta.finish_reason == "length"

CategoricalExecutionResult `dataclass` ¶

CategoricalExecutionResult(
    decision: Decision,
    value: Any,
    probabilities: tuple[tuple[Any, float], ...],
    logprobs: tuple[float, ...],
    model: str,
    usage: TokenUsage,
    off_option: OffOptionReceipt = OffOptionReceipt(),
)

Greedy categorical decision outcome with full softmax distribution.

Attributes:

Name	Type	Description
`decision`	`Decision`	The categorical field that was executed.
`value`	`Any`	Selected choice value from `decision.choices`.
`probabilities`	`tuple[tuple[Any, float], ...]`	Ordered choice/probability pairs aligned with `decision.choices` after softmax.
`logprobs`	`tuple[float, ...]`	Raw pre-sampling logprobs in choice order.
`model`	`str`	Model id from the scoring port result.
`usage`	`TokenUsage`	Token usage metadata from the scoring port.
`off_option`	`OffOptionReceipt`	Off-option mass, caller threshold and guard flag; execute sets no threshold, so the flag is `False`.

Examples:

# Constructed by execute_categorical_decision; not built by callers.

Decision `dataclass` ¶

Decision(
    name: str,
    question: str,
    choices: tuple[Any, ...],
    syntax: str = "Choice",
    numeric_type: str | None = None,
    minimum: int | float | None = None,
    maximum: int | float | None = None,
    text_type: bool = False,
    max_length: int | None = None,
    permutations: int | str = 1,
    return_probabilities: bool = False,
    depends_on: tuple[str, ...] | None = None,
    nullable: bool = False,
)

One tokenizer-independent field compiled from JSON Schema.

Attributes:

Name	Type	Description
`name`	`str`	Property name in the output object.
`question`	`str`	Model-facing prompt for this field.
`choices`	`tuple[Any, ...]`	Closed choices; empty for open numeric or text.
`syntax`	`str`	TypeLLM syntax label (Choice, Bool, Integer, Number, Text).
`numeric_type`	`str \| None`	`integer` or `number` when syntax is numeric.
`minimum`	`int \| float \| None`	Lower bound for open numeric fields.
`maximum`	`int \| float \| None`	Upper bound for open numeric fields.
`text_type`	`bool`	True when the field is open-ended text.
`max_length`	`int \| None`	Optional max string length for text fields.
`permutations`	`int \| str`	Enum permutation budget or `all`.
`return_probabilities`	`bool`	Whether to request choice probabilities.
`depends_on`	`tuple[str, ...] \| None`	Prior fields that must be set first.
`nullable`	`bool`	Whether JSON null is allowed for this field.

Examples:

from typevet.domain.decisions import Decision

Decision("x", "Pick one.", ("a", "b"), syntax="Choice")

SchemaError ¶

Bases: ValueError

The schema mapping is outside the supported compile subset.

Examples:

from typevet.domain import SchemaError, compile_json_schema

try:
    compile_json_schema({"type": "array"})
except SchemaError:
    pass

BackendBusyError ¶

BackendBusyError(
    message: str,
    *,
    status_code: int,
    body_snippet: str,
    retry_after_seconds: float | None = None,
    rate_limit: Mapping[str, str] | None = None,
    request_id: str | None = None,
)

Bases: BackendHttpError

A llama.cpp router refused to load the model while another model runs.

With autoload off, the router answers HTTP 400 model is not loaded. The adapter raises this error when another model holds a router slot and no slot is free, so it does not evict that model (#461).

Attributes:

Name	Type	Description
`status_code`	`int`	HTTP status from the router, 400.
`body_snippet`	`str`	Truncated response body text for diagnostics.

Examples:

from typevet.domain.errors import BackendBusyError

raise BackendBusyError(
    "llama.cpp HTTP 400: model is not loaded",
    status_code=400,
    body_snippet="model is not loaded",
)

BackendHttpError ¶

BackendHttpError(
    message: str,
    *,
    status_code: int,
    body_snippet: str,
    retry_after_seconds: float | None = None,
    rate_limit: Mapping[str, str] | None = None,
    request_id: str | None = None,
)

Bases: GenerationError

The backend returned an HTTP error status (400 or above) or a redirect.

The vLLM clients that backend_settings builds do not follow redirects; a 3xx raises this error with the 3xx status and no Location value.

Attributes:

Name	Type	Description
`status_code`	`int`	HTTP status from the router or the gateway.
`body_snippet`	`str`	Truncated response body text for diagnostics. Empty when the body is HTML, which a gateway error page often is.
`retry_after_seconds`	`float \| None`	Wait that `Retry-After` asks for, in seconds. `None` when the header is absent or invalid, and always `None` for llama.cpp. typevet does not retry.
`rate_limit`	`Mapping[str, str]`	Read-only `x-ratelimit-` and `ratelimit-` response headers, with lowercase names and verbatim values. Empty when there are none, and for llama.cpp.
`request_id`	`str \| None`	Request-id header value of the failed request (#356). `None` when no request-id header is configured, and always `None` for llama.cpp.

Examples:

from typevet.domain.errors import BackendHttpError

raise BackendHttpError(
    "llama.cpp HTTP 500: internal",
    status_code=500,
    body_snippet="internal",
)

Parameters:

Name	Type	Description	Default
`message`	`str`	Human-readable summary including status and snippet.	required
`status_code`	`int`	HTTP status from the backend or the gateway.	required
`body_snippet`	`str`	Truncated response body text.	required
`retry_after_seconds`	`float \| None`	Parsed `Retry-After` wait, or `None`.	`None`
`rate_limit`	`Mapping[str, str] \| None`	Rate-limit response headers; stored as a read-only copy.	`None`
`request_id`	`str \| None`	Request-id header value of the failed request.	`None`

Methods:¶

CalibrationDigestError ¶

Bases: CalibrationMapError

The sha256 of the map file is missing, malformed or does not match.

Examples:

from typevet.domain.errors import CalibrationDigestError

raise CalibrationDigestError("calibration map digest does not match")

CalibrationMapError ¶

Bases: JudgmentError

A calibration map is malformed or cannot apply to this judgment.

Messages name fields and rules only. They never carry a probability, a digest, a task id, a model id or a backend name.

Examples:

from typevet.domain.errors import CalibrationMapError

raise CalibrationMapError("calibration map field 'method' is invalid")

CalibrationModelMismatchError ¶

Bases: CalibrationMapError

The map was fitted on another model or another serving backend.

Examples:

from typevet.domain.errors import CalibrationModelMismatchError

raise CalibrationModelMismatchError("calibration map model does not match")

CalibrationTargetError ¶

Bases: CalibrationMapError

A map names a question that is not a Noul question.

Examples:

from typevet.domain.errors import CalibrationTargetError

raise CalibrationTargetError("calibration maps apply to Noul questions only")

CalibrationTaskMismatchError ¶

Bases: CalibrationMapError

The map was fitted for a task other than the wrapper task id.

Examples:

from typevet.domain.errors import CalibrationTaskMismatchError

raise CalibrationTaskMismatchError("calibration map task does not match")

DecisionExecutionError ¶

Bases: GenerationError

A categorical decision could not be executed in-domain.

Examples:

from typevet.domain.errors import DecisionExecutionError

raise DecisionExecutionError("nullable categorical decisions are unsupported")

GemmaTemplateError ¶

Bases: JudgmentError

Gemma served-template or answer-prefix rules were violated.

Examples:

from typevet.domain.errors import GemmaTemplateError

raise GemmaTemplateError("unsupported served template family")

GenerationError ¶

Bases: Exception

A typed generation call failed before a valid result existed.

Examples:

from typevet.domain.errors import GenerationError

raise GenerationError("transport failed")

GenerationUnsupportedCapabilityError ¶

Bases: GenerationError

The generation backend cannot honor a part of the request.

An adapter raises it before any HTTP call, for example when a request carries images the backend adapter cannot send. The adapter never drops the unsupported part silently.

Examples:

from typevet.domain.errors import GenerationUnsupportedCapabilityError

raise GenerationUnsupportedCapabilityError("images are not supported")

JudgmentError ¶

Bases: GenerationError

A typed judgment call failed before a valid response existed.

Examples:

from typevet.domain.errors import JudgmentError

raise JudgmentError("judgment failed")

JudgmentValidationError ¶

Bases: JudgmentError

An answer or option list failed judgment validation rules.

Examples:

from typevet.domain.errors import JudgmentValidationError

raise JudgmentValidationError("choice not in criteria")

SchemaValidationError ¶

SchemaValidationError(message: str, *, payload: object | None = None)

Bases: GenerationError

The model output did not validate against the requested schema.

Attributes:

Name	Type	Description
`payload`	`object \| None`	Parsed value that failed validation, when set.
`args`	`tuple`	Standard exception args (message first).

Examples:

from typevet.domain.errors import SchemaValidationError

raise SchemaValidationError("missing key", payload={})

Parameters:

Name	Type	Description	Default
`message`	`str`	Human-readable validation summary.	required
`payload`	`object \| None`	Parsed value that failed validation, when available.	`None`

Methods:¶

ScoringError ¶

Bases: GenerationError

A candidate scoring call failed before a valid result existed.

Examples:

from typevet.domain.errors import ScoringError

raise ScoringError("scoring failed")

ScoringUnsupportedCapabilityError ¶

Bases: ScoringError

The backend cannot honor the requested score stage or capability.

Examples:

from typevet.domain.errors import ScoringUnsupportedCapabilityError

raise ScoringUnsupportedCapabilityError("unsupported score stage")

ScoringValidationError ¶

Bases: ScoringError

Scores failed fail-closed coverage or finiteness rules.

Examples:

from typevet.domain.errors import ScoringValidationError

raise ScoringValidationError("missing scores for requested candidates")

TransportError ¶

TransportError(message: str, *, request_id: str | None = None)

Bases: GenerationError

The HTTP client failed before a usable llama.cpp response arrived.

Attributes:

Name	Type	Description
`status_code`	`None`	Always `None` for transport failures.
`body_snippet`	`None`	Always `None` when no response body was read.
`request_id`	`str \| None`	Request-id header value of the failed vLLM request, or `None` when no request-id header is configured.

Examples:

from typevet.domain.errors import TransportError

raise TransportError("llama.cpp request failed: connection refused")

Parameters:

Name	Type	Description	Default
`message`	`str`	Human-readable summary of the client failure.	required
`request_id`	`str \| None`	Request-id header value of the failed request.	`None`

Methods:¶

ChoiceAnswer `dataclass` ¶

ChoiceAnswer(
    choice: str,
    confidence: float,
    probabilities: dict[str, float],
    off_option_flag: bool = False,
)

A selected choice with probabilities and confidence.

Attributes:

Name	Type	Description
`choice`	`str`	The name of the selected option.
`confidence`	`float`	Confidence in the selected choice, from 0 to 1.
`probabilities`	`dict[str, float]`	Probability of each choice by name.
`off_option_flag`	`bool`	`True` when the off-option mass is above the caller threshold; `False` by default.

Examples:

answer = ChoiceAnswer(
    choice="yes",
    confidence=0.8,
    probabilities={"yes": 0.8, "no": 0.2},
)
assert answer.choice in answer.probabilities

Methods:¶

__post_init__ ¶

__post_init__() -> None

Reject invalid confidence, probabilities, or a missing choice key.

Raises:

Type	Description
`TypeError`	When numeric fields are not numeric types, or the flag is not a bool.
`ValueError`	When values are out of range or probabilities do not sum to one.

NoulAnswer `dataclass` ¶

NoulAnswer(noul: float, off_option_flag: bool = False)

A yes/no answer with probability of true.

Attributes:

Name	Type	Description
`noul`	`float`	Probability of a yes answer, from 0 to 1.
`off_option_flag`	`bool`	`True` when the off-option mass is above the caller threshold; `False` by default.

Examples:

answer = NoulAnswer(noul=0.75)
assert 0.0 <= answer.noul <= 1.0

Methods:¶

__post_init__ ¶

__post_init__() -> None

Reject non-finite or out-of-range noul values.

Raises:

Type	Description
`TypeError`	When `noul` is not a numeric type, or the flag is not a bool.
`ValueError`	When `noul` is not finite or not in `[0.0, 1.0]`.

ScoreAnswer `dataclass` ¶

ScoreAnswer(
    score: float,
    confidence: float,
    legend: dict[int, str],
    probabilities: dict[int, float],
    off_option_flag: bool = False,
)

A scored response with rubric and probabilities.

Attributes:

Name	Type	Description
`score`	`float`	Expected score within the legend range.
`confidence`	`float`	Confidence in the score, from 0 to 1.
`legend`	`dict[int, str]`	Rubric descriptions keyed by integer level.
`probabilities`	`dict[int, float]`	Probability of each level.
`off_option_flag`	`bool`	`True` when the off-option mass is above the caller threshold; `False` by default.

Examples:

answer = ScoreAnswer(
    score=2.0,
    confidence=0.9,
    legend={0: "poor", 1: "fair", 2: "good"},
    probabilities={0: 0.1, 1: 0.2, 2: 0.7},
)
assert set(answer.legend) == set(answer.probabilities)

Methods:¶

__post_init__ ¶

__post_init__() -> None

Reject mismatched legend keys, bad probabilities, or out-of-range score.

Raises:

Type	Description
`TypeError`	When numeric fields or dict keys have wrong types, or the flag is not a bool.
`ValueError`	When values are out of range or probabilities do not sum to one.

Choice ¶

Choice(
    *,
    criteria: Mapping[str, str | dict[str, Any] | Sequence[Any] | None],
    instructions: str | dict[str, Any] | Sequence[Any] | None = None,
)

A question that selects between named alternatives.

Construction is keyword-only.

Attributes:

Name	Type	Description
`criteria`	`Mapping[str, str \| dict \| Sequence \| None]`	Labels mapped to descriptions or `None` when undescribed.
`instructions`	`str \| dict \| Sequence \| None`	The question to ask.

Examples:

question = Choice(
    criteria={"a": "Option A", "b": "Option B"},
    instructions="Choose one:",
)
assert len(question.criteria) == 2

Parameters:

Name	Type	Description	Default
`criteria`	`Mapping[str, str \| dict[str, Any] \| Sequence[Any] \| None]`	Labels mapped to descriptions.	required
`instructions`	`str \| dict[str, Any] \| Sequence[Any] \| None`	The question to ask.	`None`

Methods:¶

repr ¶

__repr__() -> str

Return a debug representation.

Noul ¶

Noul(
    *,
    instructions: str | dict[str, Any] | Sequence[Any] | None = None,
    criteria: dict[str, Any] | None = None,
)

A yes/no question with optional descriptions for either outcome.

Construction is keyword-only.

Attributes:

Name	Type	Description
`instructions`	`str \| dict \| Sequence \| None`	Question or statement to evaluate.
`criteria`	`dict \| None`	Optional `true` and `false` outcome descriptions.

Examples:

question = Noul(
    instructions="Is this valid?",
    criteria={"true": "Valid", "false": "Invalid"},
)
assert question.instructions is not None

Parameters:

Name	Type	Description	Default
`instructions`	`str \| dict[str, Any] \| Sequence[Any] \| None`	The yes/no question or statement to evaluate.	`None`
`criteria`	`dict[str, Any] \| None`	Optional descriptions of the yes and no outcomes.	`None`

Methods:¶

repr ¶

__repr__() -> str

Return a debug representation.

Score ¶

Score(
    *,
    criteria: Sequence[str | dict[str, Any] | Sequence[Any]],
    instructions: str | dict[str, Any] | Sequence[Any] | None = None,
)

A question that assigns a score using an ordered rubric.

Construction is keyword-only.

Attributes:

Name	Type	Description
`criteria`	`Sequence[str \| dict \| Sequence]`	Ordered rubric descriptions.
`instructions`	`str \| dict \| Sequence \| None`	What the model should rate.

Examples:

question = Score(
    criteria=["Poor", "Fair", "Good"],
    instructions="Rate the response:",
)
assert len(question.criteria) >= 2

Parameters:

Name	Type	Description	Default
`criteria`	`Sequence[str \| dict[str, Any] \| Sequence[Any]]`	Ordered descriptions, one per score from zero.	required
`instructions`	`str \| dict[str, Any] \| Sequence[Any] \| None`	What the model should rate.	`None`

Methods:¶

repr ¶

__repr__() -> str

Return a debug representation.

JudgmentResponse `dataclass` ¶

JudgmentResponse(
    model: str,
    usage: TokenUsage = TokenUsage(),
    answers: dict[str, Answer] = dict(),
    off_option: dict[str, OffOptionReceipt] = dict(),
    calibration: dict[str, CalibrationRecord] = dict(),
    request_ids: dict[str, str | None] = dict(),
    text_parts: dict[str, str] = dict(),
)

Answers grouped by question type with model and optional usage metadata.

Attributes:

Name	Type	Description
`model`	`str`	The model id that produced the answers.
`usage`	`TokenUsage`	Token usage metadata for the call.
`answers`	`dict[str, Answer]`	Answer objects keyed by question name.
`off_option`	`dict[str, OffOptionReceipt]`	Off-option receipt keyed by question name; empty when the adapter does not report one.
`calibration`	`dict[str, CalibrationRecord]`	Raw and calibrated values keyed by question name, for each answer that a calibration map changed. Empty when no map applied.
`request_ids`	`dict[str, str \| None]`	Request-id header value of the scoring request for each question, keyed by question name (#356). When one question sends more than one request, the last one is kept. Empty when no request id was sent.
`text_parts`	`dict[str, str]`	The `text_parts` receipt block (#364): `option_block` and `context_template`, each the SHA-256 hex digest of the UTF-8 template text or `"default"` when unset. The scoring adapter sets it on every response. Empty when the adapter does not render the prompt.

Examples:

from typevet.domain.judgment_answers import NoulAnswer

response = JudgmentResponse(
    model="local-test",
    answers={"q1": NoulAnswer(noul=0.5)},
)
assert response.model == "local-test"

Attributes¶

nouls `property` ¶

nouls: dict[str, NoulAnswer]

Return yes/no answers keyed by question id.

Returns:

Type	Description
`dict[str, NoulAnswer]`	Subset of `answers` whose values are `NoulAnswer` instances.

choices `property` ¶

choices: dict[str, ChoiceAnswer]

Return choice answers keyed by question id.

Returns:

Type	Description
`dict[str, ChoiceAnswer]`	Subset of `answers` whose values are `ChoiceAnswer` instances.

scores `property` ¶

scores: dict[str, ScoreAnswer]

Return score answers keyed by question id.

Returns:

Type	Description
`dict[str, ScoreAnswer]`	Subset of `answers` whose values are `ScoreAnswer` instances.

OffOptionReceipt `dataclass` ¶

OffOptionReceipt(
    off_option_mass: float | None = None,
    off_option_threshold: float | None = None,
    off_option_flag: bool = False,
)

Off-option mass, the caller threshold and the guard flag for one answer.

The flag is True only when both values are known and the mass is above the threshold. A None mass never sets the flag.

Attributes:

Name	Type	Description
`off_option_mass`	`float \| None`	Probability mass outside the option set, or `None` when the scorer does not report it.
`off_option_threshold`	`float \| None`	Caller threshold, or `None` when the guard is off.
`off_option_flag`	`bool`	`True` when the mass is above the threshold.

Examples:

receipt = OffOptionReceipt.evaluate(mass=0.4, threshold=0.3)
assert receipt.off_option_flag is True
unknown = OffOptionReceipt.evaluate(mass=None, threshold=0.0)
assert unknown.off_option_flag is False

Methods:¶

evaluate `classmethod` ¶

evaluate(*, mass: float | None, threshold: float | None) -> OffOptionReceipt

Build a receipt and set the flag from the mass and the threshold.

Parameters:

Name	Type	Description	Default
`mass`	`float \| None`	Off-option mass from the scoring result, or `None`.	required
`threshold`	`float \| None`	Caller threshold, or `None` when the guard is off.	required

Returns:

Type	Description
`OffOptionReceipt`	Receipt whose flag is `True` only when `mass > threshold`.

as_dict ¶

as_dict() -> dict[str, float | bool | None]

Return the receipt as a JSON-ready mapping with explicit names.

Returns:

Type	Description
`dict[str, float \| bool \| None]`	`off_option_mass`, `off_option_threshold` and
`dict[str, float \| bool \| None]`	`off_option_flag`; an unknown value stays `None` (JSON null).

TokenUsage `dataclass` ¶

TokenUsage(input_tokens: int | None = None, output_tokens: int | None = None)

Token counts for one judgment call when an adapter reports them.

Attributes:

Name	Type	Description
`input_tokens`	`int \| None`	Prompt tokens, when known.
`output_tokens`	`int \| None`	Completion tokens, when known.

Examples:

usage = TokenUsage(input_tokens=12, output_tokens=3)
assert usage.input_tokens == 12

ImageInput `dataclass` ¶

ImageInput(data: bytes, mime_type: str)

One decoded image to condition a judgment on.

The domain holds bytes only. URL and file resolution belongs to an adapter at the edge.

Attributes:

Name	Type	Description
`data`	`bytes`	Encoded image bytes in `mime_type` format.
`mime_type`	`str`	One of `SUPPORTED_IMAGE_MIME_TYPES`, matched exactly.

Examples:

from typevet.domain.media import ImageInput

ImageInput(data=png_bytes, mime_type="image/png")

Methods:¶

__post_init__ ¶

__post_init__() -> None

Reject empty bytes and mime types outside the v1 set.

Raises:

Type	Description
`ScoringValidationError`	When bytes are empty or the mime type is not in `SUPPORTED_IMAGE_MIME_TYPES`.

GenerationRequest `dataclass` ¶

GenerationRequest(
    prompt: str,
    schema: Mapping[str, Any],
    model: str,
    media: tuple[ImageInput, ...] = (),
)

One typed generation ask.

Attributes:

Name	Type	Description
`prompt`	`str`	Natural-language instruction for the model.
`schema`	`Mapping[str, Any]`	JSON Schema object as a mapping.
`model`	`str`	Backend model id or alias.
`media`	`tuple[ImageInput, ...]`	Images the prompt marks, one `MEDIA_MARKER` each, in marker order. Empty for a text ask.

Examples:

from typevet.domain.models import GenerationRequest

GenerationRequest(
    prompt="Return JSON.",
    schema={"type": "object", "additionalProperties": False},
    model="fake",
)

Methods:¶

__post_init__ ¶

__post_init__() -> None

Reject a blank field, a non-object schema root or a marker mismatch.

Stores media as a tuple, so a list input becomes immutable.

Raises:

Type	Description
`ValueError`	When prompt or model is blank, schema type is not object, or the media marker count differs from `len(media)`.
`TypeError`	When schema is not a mapping, or a media item is not an `ImageInput`.

GenerationResult `dataclass` ¶

GenerationResult(value: Mapping[str, Any], model: str, raw_text: str | None = None)

A value that validated against the request schema.

Attributes:

Name	Type	Description
`value`	`Mapping[str, Any]`	Validated JSON-compatible mapping.
`model`	`str`	Model id that produced the value.
`raw_text`	`str \| None`	Optional raw model text before parse.

Examples:

from typevet.domain.models import GenerationResult

GenerationResult(value={"ok": True}, model="fake")

ScoreStage ¶

Bases: StrEnum

When logits are read relative to sampler state.

Attributes:

Name	Type	Description
`PRE_SAMPLING`	`ScoreStage`	Softmax over full pre-sample logits (#116).
`POST_SAMPLING`	`ScoreStage`	After sampler candidate list (not M1 stock).

Examples:

stage = ScoreStage.PRE_SAMPLING
assert stage == "pre_sampling"

TextParts `dataclass` ¶

TextParts(option_block: str | None = None, context_template: str | None = None)

Caller templates for the option block and the context, validated.

None keeps the default template for that part.

Attributes:

Name	Type	Description
`option_block`	`str \| None`	Option block template, or `None`.
`context_template`	`str \| None`	Context template, or `None`.

Examples:

TextParts().receipt()  # both parts are "default"

Methods:¶

__post_init__ ¶

__post_init__() -> None

Refuse a template that breaks a rule of its part.

Raises:

Type	Description
`JudgmentValidationError`	A set template breaks a rule. The message names the part and the rule, never the template text.

receipt ¶

receipt() -> dict[str, str]

Return the text_parts receipt block.

Returns:

Type	Description
`dict[str, str]`	One entry per part: the SHA-256 hex digest of the UTF-8 template
`dict[str, str]`	text, or `"default"` when the part is unset.

Functions:¶

calibration_map_from_mapping ¶

calibration_map_from_mapping(
    data: Mapping[str, object], *, sha256: str
) -> CalibrationMap

Validate a parsed map document and build a CalibrationMap.

An absent or null levels field gives a Noul map. An integer of 2 or more gives a Score map with that level count. The receipt digest is stored in lower case.

Parameters:

Name	Type	Description	Default
`data`	`Mapping[str, object]`	The parsed JSON document.	required
`sha256`	`str`	The verified sha256 of the file bytes.	required

Returns:

Type	Description
`CalibrationMap`	The validated map.

Raises:

Type	Description
`CalibrationDigestError`	`sha256` is missing or malformed.
`CalibrationMapError`	A required field is missing or invalid, or `levels` is present and is not an integer of 2 or more.

build_and_validate_result ¶

build_and_validate_result(
    request: CandidateScoringRequest,
    *,
    raw_logprobs: Mapping[str, float],
    model: str,
    stage: ScoreStage | None = None,
    usage: TokenUsage | None = None,
    termination: ScoringTermination | None = None,
    off_option_mass: float | None = None,
) -> CandidateScoringResult

Build a result with request order and fail-closed coverage checks.

Parameters:

Name	Type	Description	Default
`request`	`CandidateScoringRequest`	Original scoring ask.	required
`raw_logprobs`	`Mapping[str, float]`	Mapping from candidate label to raw logprob.	required
`model`	`str`	Model id recorded on the result.	required
`stage`	`ScoreStage \| None`	Stage recorded on the result; defaults to `request.stage`.	`None`
`usage`	`TokenUsage \| None`	Optional token usage metadata.	`None`
`termination`	`ScoringTermination \| None`	Optional termination metadata.	`None`
`off_option_mass`	`float \| None`	Probability mass outside the candidate tokens, or `None` when the backend cannot report it.	`None`

Returns:

Type	Description
`CandidateScoringResult`	Validated `CandidateScoringResult`.

Raises:

Type	Description
`ScoringValidationError`	Missing, duplicate, or unexpected labels, non-finite logprobs, a positive logprob above `1e-6`, or an off-option mass that is not finite, is outside `[0, 1]`, or makes the total mass go above 1.

compile_json_schema ¶

compile_json_schema(schema: Mapping[str, Any]) -> list[Decision]

Compile an ordered JSON Schema object into TypeLLM decisions.

Parameters:

Name	Type	Description	Default
`schema`	`Mapping[str, Any]`	Root object schema with `type`, `properties`, and optional `required`.	required

Returns:

Type	Description
`list[Decision]`	Decisions in property declaration order, with `depends_on` resolved
`list[Decision]`	and dependency layers validated.

Raises:

Type	Description
`SchemaError`	When the schema is invalid or unsupported.
`NotImplementedError`	For unsupported types without a finite enum.

Examples:

from typevet.domain.decision_compile import compile_json_schema

compile_json_schema(
    {
        "type": "object",
        "properties": {"n": {"type": "integer", "enum": [1, 2]}},
        "required": ["n"],
    }
)

apply_off_option_threshold ¶

apply_off_option_threshold(
    result: CategoricalExecutionResult, threshold: float | None
) -> CategoricalExecutionResult

Set the caller threshold on the receipt and flag a mass above it.

The guard flags and does not raise. A None mass never sets the flag. A None threshold keeps the guard off and the flag False.

Parameters:

Name	Type	Description	Default
`result`	`CategoricalExecutionResult`	Outcome from `execute_categorical_decision`.	required
`threshold`	`float \| None`	Caller threshold, or `None` to turn the guard off.	required

Returns:

Type	Description
`CategoricalExecutionResult`	A copy of `result` whose receipt holds the mass, the threshold and
`CategoricalExecutionResult`	the flag.

Raises:

Type	Description
`DecisionExecutionError`	`threshold` is not `None` or a number in `[0, 1]`.

check_off_option_threshold ¶

check_off_option_threshold(threshold: object) -> None

Reject a threshold that is not None or a number in [0, 1].

Parameters:

Name	Type	Description	Default
`threshold`	`object`	Caller threshold for the off-option mass.	required

Raises:

Type	Description
`DecisionExecutionError`	A bool, a non-number, NaN, or a value outside `[0, 1]`.

execute_categorical_decision ¶

execute_categorical_decision(
    decision: Decision,
    *,
    prefix: str,
    candidates: tuple[CandidateTokenSpec, ...],
    port: CandidateScoringPort,
    model: str,
    temperature: float = 1.0,
    media: tuple[ImageInput, ...] = (),
) -> CategoricalExecutionResult

Score candidates, softmax logprobs, and pick the greedy choice.

Probabilities are the conditional distribution over the declared candidate set at temperature temperature (default 1) via log-sum-exp softmax.

Parameters:

Name	Type	Description	Default
`decision`	`Decision`	Closed categorical field (`Choice` or `Bool` syntax).	required
`prefix`	`str`	Rendered prompt prefix before candidate tokens.	required
`candidates`	`tuple[CandidateTokenSpec, ...]`	Single-token specs aligned 1:1 with `decision.choices`.	required
`port`	`CandidateScoringPort`	Scoring port; `ScoreStage.PRE_SAMPLING` is required.	required
`model`	`str`	Model id forwarded to the scoring request.	required
`temperature`	`float`	Softmax temperature; must be finite and strictly positive.	`1.0`
`media`	`tuple[ImageInput, ...]`	Images the `prefix` marks, one `MEDIA_MARKER` each.	`()`

Returns:

Type	Description
`CategoricalExecutionResult`	`CategoricalExecutionResult` with the input `decision`, selected
`CategoricalExecutionResult`	value, full probability table, raw logprobs and off-option receipt.

Raises:

Type	Description
`DecisionExecutionError`	Unsupported syntax, nullable field, permutations other than `1`, alignment, candidate shape, or invalid temperature.
`ScoringValidationError`	Propagated when the port result does not match the exact request (stage, count, label order, token ids) or holds a non-finite logprob, or when `prefix` markers do not match `media`. The check runs before softmax normalization.

dependency_layers ¶

dependency_layers(decisions: Sequence[Decision]) -> list[list[Decision]]

Return stable topological layers and validate dependencies.

Parameters:

Name	Type	Description	Default
`decisions`	`Sequence[Decision]`	Compiled decisions, typically from `compile_json_schema`.	required

Returns:

Type	Description
`list[list[Decision]]`	Lists of decisions that may run in parallel within each layer.

Raises:

Type	Description
`SchemaError`	For unknown dependencies, self-deps, or cycles.

Examples:

from typevet.domain.decisions import Decision, dependency_layers

a = Decision("a", "q", ())
b = Decision("b", "q", (), depends_on=("a",))
dependency_layers([b, a])

bind_control_candidates ¶

bind_control_candidates(
    original_labels: Sequence[Any], tokenize_content: Callable[[str], Sequence[int]]
) -> tuple[CandidateTokenSpec, ...]

Bind ordinal control strings to original labels via tokenize_content.

Uses control_binding_pairs for ("0", label) … ordering, then attaches single-token ids from tokenize_content.

Parameters:

Name	Type	Description	Default
`original_labels`	`Sequence[Any]`	Labels preserved on each `CandidateTokenSpec`.	required
`tokenize_content`	`Callable[[str], Sequence[int]]`	Tokenizer hook; each control `"0"` … `"9"`, `"A"` … must encode to exactly one token id.	required

Returns:

Type	Description
`tuple[CandidateTokenSpec, ...]`	Single-token candidate specs in original-label order.

Raises:

Type	Description
`JudgmentValidationError`	Duplicate or empty labels, more than 36 labels, or multi-token controls. When leading controls are single tokens and a later one is not, the message states the tokenizer capacity: `native Choice supports N options on this tokenizer; got M`. The capacity message applies only when at least one control bound; a failure at control `"0"` keeps the per-control message.

judgment_original_labels ¶

judgment_original_labels(question: Question) -> tuple[str, ...]

Return ordered original labels for control binding.

Parameters:

Name	Type	Description	Default
`question`	`Question`	Native Noul, Choice, or Score question.	required

Returns:

Type	Description
`tuple[str, ...]`	Original label strings in scoring order.

Raises:

Type	Description
`JudgmentValidationError`	Empty or duplicate labels, or too few score levels.

normalize_choice ¶

normalize_choice(question: Choice, *, field_name: str) -> Decision

Map a Choice question to a Choice Decision preserving key order.

Parameters:

Name	Type	Description	Default
`question`	`Choice`	Multi-option judgment question.	required
`field_name`	`str`	Compiled property name on the output object.	required

Returns:

Type	Description
`Decision`	Executable Choice decision with criteria key order preserved.

Raises:

Type	Description
`JudgmentValidationError`	Invalid instructions or empty criteria.

normalize_noul ¶

normalize_noul(question: Noul, *, field_name: str) -> Decision

Map a Noul question to a Bool Decision with (False, True) choices.

Parameters:

Name	Type	Description	Default
`question`	`Noul`	Yes/no judgment question.	required
`field_name`	`str`	Compiled property name on the output object.	required

Returns:

Type	Description
`Decision`	Executable Bool decision with `return_probabilities=True`.

Raises:

Type	Description
`JudgmentValidationError`	When `instructions` is not a string or None.

normalize_question ¶

normalize_question(question: Question, *, field_name: str) -> Decision

Normalize any supported native question to an executable Decision.

Parameters:

Name	Type	Description	Default
`question`	`Question`	Native Noul, Choice, or Score question.	required
`field_name`	`str`	Compiled property name on the output object.	required

Returns:

Type	Description
`Decision`	Executable decision for categorical scoring.

Raises:

Type	Description
`JudgmentValidationError`	Unsupported question type or invalid payload.

normalize_score ¶

normalize_score(question: Score, *, field_name: str) -> Decision

Map a Score rubric to a Choice Decision over 0..n-1 levels.

Parameters:

Name	Type	Description	Default
`question`	`Score`	Ordered rubric judgment question.	required
`field_name`	`str`	Compiled property name on the output object.	required

Returns:

Type	Description
`Decision`	Executable Choice decision whose choices are integer rubric indices.

Raises:

Type	Description
`JudgmentValidationError`	Invalid instructions or fewer than two levels.

question_types ¶

question_types(questions: Mapping[str, Any]) -> dict[str, str | None]

Map each question id to its wire type name.

Typed questions map to noul, choice or score. Raw wire dictionaries map to their type value when that value is a string.

Parameters:

Name	Type	Description	Default
`questions`	`Mapping[str, Any]`	Question objects or raw wire dictionaries keyed by id.	required

Returns:

Type	Description
`dict[str, str \| None]`	The id to type mapping; `None` where a raw question has no string type.

count_media_markers ¶

count_media_markers(text: str) -> int

Count MEDIA_MARKER occurrences in a rendered prefix.

Parameters:

Name	Type	Description	Default
`text`	`str`	Rendered prompt prefix.	required

Returns:

Type	Description
`int`	Number of documented media markers in `text`.

Examples:

from typevet.domain.media import MEDIA_MARKER, count_media_markers

assert count_media_markers(f"{MEDIA_MARKER} caption") == 1

compile_question_records ¶

compile_question_records(
    records: Sequence[Mapping[str, Any]], *, additional_properties: bool = False
) -> list[Decision]

Compile question records to TypeLLM Decision values.

Parameters:

Name	Type	Description	Default
`records`	`Sequence[Mapping[str, Any]]`	Loader-shaped question list.	required
`additional_properties`	`bool`	Forwarded to `question_records_to_json_schema`.	`False`

Returns:

Type	Description
`list[Decision]`	Decisions from `compile_json_schema` in property order.

question_record_to_property ¶

question_record_to_property(record: Mapping[str, Any]) -> tuple[str, dict[str, Any]]

Map one System One-style question record to a JSON Schema property.

Parameters:

Name	Type	Description	Default
`record`	`Mapping[str, Any]`	Mapping with `name`, `syntax`, and `instructions`. Choice and Score require `labels`. Noul uses boolean when `labels` is omitted; two string labels yield a closed string enum (BoolQ-style).	required

Returns:

Type	Description
`tuple[str, dict[str, Any]]`	Field name and property schema object.

Raises:

Type	Description
`ValueError`	When the record shape or labels are invalid.
`TypeError`	When `record` or `labels` have the wrong type.

question_records_to_json_schema ¶

question_records_to_json_schema(
    records: Sequence[Mapping[str, Any]], *, additional_properties: bool = False
) -> dict[str, Any]

Build a root object schema from ordered question records.

Parameters:

Name	Type	Description	Default
`records`	`Sequence[Mapping[str, Any]]`	Non-empty sequence of question mappings (loader export order).	required
`additional_properties`	`bool`	Value for `additionalProperties` on the root.	`False`

Returns:

Type	Description
`dict[str, Any]`	Object schema with `properties`, `required`, and `type: object`.

Raises:

Type	Description
`ValueError`	When `records` is empty or contains duplicate names.

validate_context_template ¶

validate_context_template(template: str) -> None

Refuse a context_template template that breaks a rule.

Placeholders: {context} and {field_block} are both required, and each appears once.

Parameters:

Name	Type	Description	Default
`template`	`str`	Context template text.	required

Raises:

Type	Description
`JudgmentValidationError`	The template breaks a rule. The message names the part and the rule, never the template text.

validate_option_block ¶

validate_option_block(template: str) -> None

Refuse an option_block template that breaks a rule.

Placeholders: {question}, {control}, {label}, {description} and {answer_rule} are required; {name} is optional. Each appears at most once. {control}, {label} and {description} sit on one option line, which repeats once per option; the other placeholders sit off it.

Parameters:

Name	Type	Description	Default
`template`	`str`	Option block template text.	required

Raises:

Type	Description
`JudgmentValidationError`	The template breaks a rule. The message names the part and the rule, never the template text.

Name	Type	Description
`Decision`	`type`	One compiled TypeLLM field from JSON Schema.
`BackendBusyError`	`type`	llama.cpp router busy with another model.
`BackendHttpError`	`type`	llama.cpp HTTP status 400 or above.
`CandidateScoringRequest`	`type`	Prompt and candidate tokens to score.
`CALIBRATION_CLIP`	`float`	Clip bound for calibration map inputs and outputs.
`CALIBRATION_MAP_SCHEMA`	`str`	Schema id of a calibration map document.
`CalibrationMap`	`type`	One validated calibration map.
`CalibrationRecord`	`type`	Raw and calibrated value of one Noul answer.
`calibration_map_from_mapping`	`callable`	Validate a parsed map document.
`CalibrationMapError`	`type`	Calibration map is malformed or refused.
`CalibrationDigestError`	`type`	Map file digest is missing, malformed or wrong.
`CalibrationTaskMismatchError`	`type`	Map was fitted for another task.
`CalibrationModelMismatchError`	`type`	Map was fitted for another model or backend.
`CalibrationTargetError`	`type`	Map targets a Choice or Score question.
`ImageInput`	`type`	One image to condition a judgment on.
`MEDIA_MARKER`	`str`	Documented media placeholder in a scoring prefix.
`SUPPORTED_IMAGE_MIME_TYPES`	`frozenset`	Accepted v1 image mime types.
`count_media_markers`	`callable`	Count media markers in a prefix.
`CandidateScoringResult`	`type`	Fail-closed scored candidates.
`CategoricalExecutionResult`	`type`	Greedy categorical execute outcome.
`OffOptionReceipt`	`type`	Off-option mass, threshold and guard flag.
`apply_off_option_threshold`	`callable`	Flag a result whose off-option mass is above a caller threshold.
`check_off_option_threshold`	`callable`	Reject an invalid threshold.
`DecisionExecutionError`	`type`	Categorical execute rejected inputs.
`GemmaTemplateError`	`type`	Gemma served-template or answer-prefix violation.
`GenerationError`	`type`	Base failure for a generation call.
`GenerationUnsupportedCapabilityError`	`type`	Backend cannot honor the ask.
`TransportError`	`type`	HTTP client failure before a response.
`GenerationRequest`	`type`	Prompt, schema and model ask.
`GenerationResult`	`type`	Validated structured value.
`JudgmentResponse`	`type`	Typed answers from a judgment call.
`MAX_ENUM_CHOICES`	`int`	Upper bound on enum size when compiling.
`Noul`	`type`	Yes/no judgment question.
`Question`	`type`	Union of judgment question types.
`MAX_PERMUTATIONS`	`int`	Upper bound on enum permutation budget.
`SchemaError`	`type`	Invalid or unsupported schema for compilation.
`SchemaValidationError`	`type`	Output failed the requested schema.
`ScoringError`	`type`	Base failure for a candidate-scoring call.
`compile_json_schema`	`callable`	Compile object schema to decisions.
`dependency_layers`	`callable`	Topological layers for decision dependencies.
`execute_categorical_decision`	`callable`	Choice/Bool execution through the injected scoring port; no I/O of its own.
`bind_control_candidates`	`callable`	Ordinal control tokens for native labels.
`judgment_original_labels`	`callable`	Ordered labels for a native question.
`normalize_question`	`callable`	Native question to executable Decision.
`compile_question_records`	`callable`	Question records to decisions.
`question_record_to_property`	`callable`	One question record to a JSON Schema property.
`question_records_to_json_schema`	`callable`	Question records to an object schema.
`TextParts`	`type`	Validated option block and context templates; its `receipt()` pins both by digest.
`DEFAULT_OPTION_BLOCK`	`str`	Option block template used when unset.
`DEFAULT_CONTEXT_TEMPLATE`	`str`	Context template used when unset.
`validate_option_block`	`callable`	Refuse a bad option block template.
`validate_context_template`	`callable`	Refuse a bad context template.

Domain package¶

typevet.domain ¶

Attributes¶

Answer module-attribute ¶

Question module-attribute ¶

Classes¶

CalibrationMap dataclass ¶

Methods:¶

apply ¶

apply_levels ¶

CalibrationRecord dataclass ¶

CandidateScoringRequest dataclass ¶

Methods:¶

__post_init__ ¶

CandidateTokenSpec dataclass ¶

Methods:¶

__post_init__ ¶

CandidateScoringResult dataclass ¶

ScoredCandidate dataclass ¶

ScoringTermination dataclass ¶

CategoricalExecutionResult dataclass ¶

Decision dataclass ¶

SchemaError ¶

BackendBusyError ¶

BackendHttpError ¶

Methods:¶

CalibrationDigestError ¶

CalibrationMapError ¶

CalibrationModelMismatchError ¶

CalibrationTargetError ¶

CalibrationTaskMismatchError ¶

DecisionExecutionError ¶

GemmaTemplateError ¶

GenerationError ¶

GenerationUnsupportedCapabilityError ¶

JudgmentError ¶

JudgmentValidationError ¶

SchemaValidationError ¶

Methods:¶

ScoringError ¶

ScoringUnsupportedCapabilityError ¶

ScoringValidationError ¶

TransportError ¶

Methods:¶

ChoiceAnswer dataclass ¶

Methods:¶

__post_init__ ¶

NoulAnswer dataclass ¶

Methods:¶

__post_init__ ¶

ScoreAnswer dataclass ¶

Methods:¶

__post_init__ ¶

Choice ¶

Methods:¶

__repr__ ¶

Noul ¶

Methods:¶

__repr__ ¶

Score ¶

Methods:¶

__repr__ ¶

JudgmentResponse dataclass ¶

Attributes¶

nouls property ¶

choices property ¶

scores property ¶

OffOptionReceipt dataclass ¶

Methods:¶

evaluate classmethod ¶

as_dict ¶

TokenUsage dataclass ¶

ImageInput dataclass ¶

Methods:¶

__post_init__ ¶

GenerationRequest dataclass ¶

Methods:¶

__post_init__ ¶

GenerationResult dataclass ¶

ScoreStage ¶

Answer `module-attribute` ¶

Question `module-attribute` ¶

CalibrationMap `dataclass` ¶

CalibrationRecord `dataclass` ¶

CandidateScoringRequest `dataclass` ¶

CandidateTokenSpec `dataclass` ¶

CandidateScoringResult `dataclass` ¶

ScoredCandidate `dataclass` ¶

ScoringTermination `dataclass` ¶

CategoricalExecutionResult `dataclass` ¶

Decision `dataclass` ¶

ChoiceAnswer `dataclass` ¶

NoulAnswer `dataclass` ¶

ScoreAnswer `dataclass` ¶

repr ¶

repr ¶

repr ¶

JudgmentResponse `dataclass` ¶

nouls `property` ¶

choices `property` ¶

scores `property` ¶

OffOptionReceipt `dataclass` ¶

evaluate `classmethod` ¶

TokenUsage `dataclass` ¶

ImageInput `dataclass` ¶

GenerationRequest `dataclass` ¶

GenerationResult `dataclass` ¶

TextParts `dataclass` ¶