`tauopt.engine.provenance`#

Suggestion provenance: enough identity to re-derive any served suggestion.

The identity triple: engine_version (release tag), engine_sha (canonical), deps_fingerprint – torch/BoTorch minor bumps move numerics, so a SHA alone under-specifies bit-repro.

Module Contents#

Classes#

`ProvenanceTimings`	Wall-clock split of the suggest step: GP hyperparameter-fit vs acquisition-optimization seconds, accumulated across every rung attempted in the ask. Measurement only, never identity – absent (None) when no rung recorded either phase (random/sobol), and never part of any canonical form, hash, or seed (P8: provenance is not canonicalized state).
`CenterRecord`	The center-in-bootstrap decision (the three-branch table): which branch classified and what the stream did – `skip` (branch 1, reason `ill_defined` \| `infeasible` \| `observed` \| `pending`), `shifted_stream` (branch 2), `emitted_slot0` / `slot0_consumed` (branch 3). A branch-1 observed/pending record is an EMISSION skip: on a center-capable space the engaged stream form (shift / walk law) continues unchanged. Field domains are closed (Literal) so a malformed record dies at construction, outside the never-fail net – fail-loud, never fail-open. Audit only, never identity – never part of any canonical form, hash, or seed (P8: provenance is not canonicalized state).
`IntentRefusal`	One refused duplicate-intent request: the request’s identity plus the boundary’s typed reason. Field domains are closed so a malformed record dies at construction (fail-loud, never fail-open). Audit only, never identity – never part of any canonical form, hash, or seed.
`QueueSlotRecord`	One queue-selection decision: horizon + source, progress, temperature, queue size, eligible count, selected rank, distance, fork label. `origin` closes the decision domain: `selected` (temperature draw), `argmax_t0` (the literal T=0 branch – no draw), `repair` (no eligible entry; the owner repair path filled the slot – no draw), `pass_through` (a rung without queue capability answered; exempt by construction, recorded). `u` is the drawn uniform (re-derivable from the fork label – audit convenience); `non_finite_scores` RETAINS the slot’s non-finite-score entries as canonical score strings (“nan”/”inf”/”-inf”, generation order; their rows are never decoded: coordinates of a poisoned endpoint prove nothing) with `non_finite_count` = its length. Rank and u are None exactly when no selection event occurred (repair / pass_through); `distance` is the fixed pipeline stage’s d_hat of the selected entry and is PRESENT on every selection event (selected AND argmax_t0 – lambda=0 and T=0 zero its weight, never the statistic), None on repair/pass_through. Audit only, never identity – never part of any canonical form, hash, or seed (P8: provenance is not canonicalized state).
`DedupRecord`	The dedup boundary’s per-ask audit record: collision count, repair path, and statuses in provenance (P6). Present on every dedup-flagged ask, zeros included, so receipts can verify the boundary actually ran; absent flag-off. Audit only, never identity – never part of any canonical form, hash, or seed (P8: provenance is not canonicalized state).
`TensorStat`	One fitted tensor’s exact identity: dtype + shape + a blake2b digest over the dtype-tagged raw little-endian bytes – payload-exact (float32 vs float64, signed zeros, and NaN payloads all distinguish; deliberately NOT normalized – a replica-side sign or dtype flip is exactly the computation divergence this digest exists to catch). `value` carries the number verbatim when the tensor is scalar AND finite (a non-finite scalar stays digest-only: receipts must never carry a non-finite float – the reader rejects NaN/Infinity as corruption, and identity still resolves from the digest). Audit only, never identity for any hash or seed (P8).
`GpFitRecord`	One COMPLETED GP hyperparameter fit (internal-state transparency): the fitted (MLL-optimized) leaf tensors by parameter name, the model class, the training-set geometry, and whether a fixed noise variance entered (`yvar_provided`). `fit_maxiter` is the L-BFGS iteration cap when one applied (the `mixed_capped` bundle) – None means fit-to-convergence. Emitted at the single fit seam (`make_and_fit_gp`), so every fit is recorded: failed rungs’ fits, gp_nehvi components, and mll_impute stage-1 fits included. The construct- only fixed-label GP never fits and is deliberately NOT recorded (its parameters are documented literals, deterministic in (d, labels)).
`WorkRecord`	One rung attempt’s acquisition work shape (work counters): the EFFECTIVE optimizer knobs at the point of use – post any bundle override, so the executed work shape is receipt-visible on its own (the config alone does not show effective values) – plus the acq optimizer family and the requested q. `n_pending` counts open suggestions entering as constant-liar/pending conditioning. Audit only, never identity for any hash or seed (P8).
`ConditioningEvent`	One retry of a GP strategy’s suggest attempt (the rung-level conditioning controller): emitted when retry attempt `attempt` (1..3 – an acq-class arming retry, when it fires, precedes up to `max_retries` floor escalations) STARTS, carrying the standardized-variance floor it runs at and the PRIOR attempt’s typed exception. `stage` is the phase the prior attempt last entered (fit \| fantasy \| acq). `armed` is True on retries that run with the armed finite-filtering ic_generator installed (gp_nehvi’s acq-stage cure): the arming retry keeps `floor_std` UNCHANGED – a variance floor cannot remove non-finite values the acquisition itself produces at its raw samples, so the cure filters them at initialization instead – recorded as the f0-resolved value at attempt 0 or the standing floor_k thereafter; later typed-set escalations while armed stay armed (sticky). Additive, default False: pre-cure receipts keep exact bytes. Audit only, never identity – never part of any canonical form, hash, or seed (P8: provenance is not canonicalized state).
`AcqInitFilterRecord`	One armed attempt’s finite-filter receipt (the armed finite-filtering ic_generator, 0.3.2): raw q-batch rows drawn, rows surviving the whole-row `isfinite` filter (NaN and +/-inf both drop; row = one q-batch, joint acq is one scalar per q-tuple – deliberately NOT member-exclusion), the support verdict, the restarts actually installed, and the RAW-BASE POSTCONDITION verdict at the returned candidates. `postcondition` is a receipt, never an absence-of-error inference; on zero support it is `"nonfinite"` BY LAW – the empty survivor set’s vacuous `isfinite(empty).all() == True` must never read finite (the validator below is that law’s tooth). Audit only, never identity – never part of any canonical form, hash, or seed (P8).
`AggregationRecord`	Duplicate-x aggregation at fit assembly: raw scored rows in vs aggregated group rows out, plus the canonical-key version that defined sameness. Raw observations remain untouched in state – aggregation is a fit transform; this record is how a receipt shows it ran. Audit only, never identity – never part of any canonical form, hash, or seed (P8).
`FallbackAttempt`	One FAILED rung attempt’s verbatim evidence, kept so a never-fail ladder descent (P6) preserves each failed rung’s own error rather than discarding or clobbering it. One record per failed rung, in ladder order; later rungs never overwrite earlier ones. `stage` is the phase the rung last entered (None when it died before any GP phase – e.g. config validation). `conditioning_attempts` are the conditioning- controller retries the rung burned before failing. The `*_delta` counters are the rung’s own contribution to the ask-level fits/work/acq_events records up to the failure point. Audit only, never identity (P8).
`EngineProvenance`	The per-suggestion receipt: the identity triple (engine_version, engine_sha, deps_fingerprint) plus strategy, config_hash, policy, and the resolved seed – together with the recorded experiment state, enough to re-derive and verify the served suggestion (P4; the receipt alone identifies the run, it does not carry the state). `fallback_from` names the originally routed strategy when a never-fail ladder descent answered instead (P6), None when the intended rung answered. Everything from `timings` down is an audit record, absent (None) unless its subsystem ran (drop-at-absent keeps older receipts byte-exact); audit records never enter any canonical form, hash, or seed (P8: provenance is not canonicalized state).

Functions#

`engine_version`	Installed TauOpt release tag (the identity triple’s version leg); “0.0.0+uninstalled” when the distribution is absent. Cached per process.
`engine_sha`	Canonical engine identity. Resolution: TAUOPT_ENGINE_SHA (set by release/service builds) -> the `tauopt._build_info` module hatch_build.py stamps into every wheel and sdist at build time -> git HEAD when this file sits inside a checkout of the engine repository (a source checkout or an editable install) -> “unknown”. The cache keys on the declared value: env set/change/unset inside one process is honored; the stamp and git legs still memoize.
`deps_fingerprint`	Dependency fingerprint. TAUOPT_DEPS_FINGERPRINT (service images stamp blake2b(uv.lock) at build) -> fingerprint of the installed versions of the numerics-relevant dists (local/dev runs). The cache keys on the declared value.

API#

class tauopt.engine.provenance.ProvenanceTimings(/, **data: Any)#

Bases: pydantic.BaseModel

Wall-clock split of the suggest step: GP hyperparameter-fit vs acquisition-optimization seconds, accumulated across every rung attempted in the ask. Measurement only, never identity – absent (None) when no rung recorded either phase (random/sobol), and never part of any canonical form, hash, or seed (P8: provenance is not canonicalized state).

Initialization

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

model_config#: ‘ConfigDict(…)’

fit_s: float#: None

acq_s: float#: None

class tauopt.engine.provenance.CenterRecord(/, **data: Any)#

Bases: pydantic.BaseModel

The center-in-bootstrap decision (the three-branch table): which branch classified and what the stream did – skip (branch 1, reason ill_defined | infeasible | observed | pending), shifted_stream (branch 2), emitted_slot0 / slot0_consumed (branch 3). A branch-1 observed/pending record is an EMISSION skip: on a center-capable space the engaged stream form (shift / walk law) continues unchanged. Field domains are closed (Literal) so a malformed record dies at construction, outside the never-fail net – fail-loud, never fail-open. Audit only, never identity – never part of any canonical form, hash, or seed (P8: provenance is not canonicalized state).

Initialization

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

model_config#: ‘ConfigDict(…)’

branch: Literal[1, 2, 3]#: None

action: Literal[skip, shifted_stream, emitted_slot0, slot0_consumed]#: None

reason: Literal[ill_defined, infeasible, observed, pending] | None#: None

class tauopt.engine.provenance.IntentRefusal(/, **data: Any)#

Bases: pydantic.BaseModel

One refused duplicate-intent request: the request’s identity plus the boundary’s typed reason. Field domains are closed so a malformed record dies at construction (fail-loud, never fail-open). Audit only, never identity – never part of any canonical form, hash, or seed.

Initialization

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

model_config#: ‘ConfigDict(…)’

kind: Literal[variance_replication, liar_verification]#: None

source_id: str#: None

ordinal: int#: None

reason: Literal[disabled, multimetric_inert, no_unfilled_slots, empty_q, source_not_in_q, source_not_policy_selected, ordinal_not_next, per_ask_limit]#: None

class tauopt.engine.provenance.QueueSlotRecord(/, **data: Any)#

Bases: pydantic.BaseModel

One queue-selection decision: horizon + source, progress, temperature, queue size, eligible count, selected rank, distance, fork label. origin closes the decision domain: selected (temperature draw), argmax_t0 (the literal T=0 branch – no draw), repair (no eligible entry; the owner repair path filled the slot – no draw), pass_through (a rung without queue capability answered; exempt by construction, recorded). u is the drawn uniform (re-derivable from the fork label – audit convenience); non_finite_scores RETAINS the slot’s non-finite-score entries as canonical score strings (“nan”/”inf”/”-inf”, generation order; their rows are never decoded: coordinates of a poisoned endpoint prove nothing) with non_finite_count = its length. Rank and u are None exactly when no selection event occurred (repair / pass_through); distance is the fixed pipeline stage’s d_hat of the selected entry and is PRESENT on every selection event (selected AND argmax_t0 – lambda=0 and T=0 zero its weight, never the statistic), None on repair/pass_through. Audit only, never identity – never part of any canonical form, hash, or seed (P8: provenance is not canonicalized state).

Initialization

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

model_config#: ‘ConfigDict(…)’

slot: int#: None

origin: Literal[selected, argmax_t0, repair, pass_through]#: None

horizon: int#: None

horizon_source: Literal[explicit, assumed_15d]#: None

progress: float#: None

temperature: float#: None

queue_size: int#: 0

eligible_count: int#: 0

non_finite_count: int#: 0

non_finite_scores: tuple[Literal[nan, inf, -inf], ...]#: ()

selected_rank: int | None#: None

distance: float | None#: None

fork_label: str | None#: None

u: float | None#: None

class tauopt.engine.provenance.DedupRecord(/, **data: Any)#

Bases: pydantic.BaseModel

The dedup boundary’s per-ask audit record: collision count, repair path, and statuses in provenance (P6). Present on every dedup-flagged ask, zeros included, so receipts can verify the boundary actually ran; absent flag-off. Audit only, never identity – never part of any canonical form, hash, or seed (P8: provenance is not canonicalized state).

Counter semantics: collision_count counts refused PROPOSALS – a slot’s natural candidate, a re-optimize result, or a boundary-caught strategy draft (boundary_collisions is that last subset, a strategy-bug signal, since repair should have prevented them). Queue-walk examinations are NOT proposals and are deliberately uncounted. boundary_invalid counts drafts the boundary dropped for failing key computation or validation – distinct from collisions by construction. per_draft_origin names each returned draft’s producer (a ladder rung, exhaust_enum, or intent_grant). uniqueness_status and the four slot counters mirror the AskResult so every RECEIPT is self-contained (the ask surface does not cross the driver).

Initialization

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

model_config#: ‘ConfigDict(…)’

collision_count: int#: None

boundary_collisions: int#: 0

boundary_invalid: int#: 0

queue_fills: int#: 0

reoptimize_attempts: int#: 0

advances: int#: 0

ladder_hops: tuple[str, ...]#: ()

per_draft_origin: tuple[str, ...]#: ()

exhaust_proof: bool#: False

universe_size: int | None#: None

proof_method: Literal[enumeration, cardinality] | None#: None

matched: int | None#: None

intent_refusals: tuple[tauopt.engine.provenance.IntentRefusal, ...]#: ()

uniqueness_status: Literal[space_exhausted, unique_candidate_unavailable] | None#: None

requested_q: int#: 0

unique_count: int#: 0

authorized_replica_count: int#: 0

unfilled_count: int#: 0

class tauopt.engine.provenance.TensorStat(/, **data: Any)#

Bases: pydantic.BaseModel

One fitted tensor’s exact identity: dtype + shape + a blake2b digest over the dtype-tagged raw little-endian bytes – payload-exact (float32 vs float64, signed zeros, and NaN payloads all distinguish; deliberately NOT normalized – a replica-side sign or dtype flip is exactly the computation divergence this digest exists to catch). value carries the number verbatim when the tensor is scalar AND finite (a non-finite scalar stays digest-only: receipts must never carry a non-finite float – the reader rejects NaN/Infinity as corruption, and identity still resolves from the digest). Audit only, never identity for any hash or seed (P8).

Initialization

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

model_config#: ‘ConfigDict(…)’

dtype: str#: None

shape: tuple[int, ...]#: None

blake2b: str#: None

value: float | None#: None

class tauopt.engine.provenance.GpFitRecord(/, **data: Any)#

Bases: pydantic.BaseModel

One COMPLETED GP hyperparameter fit (internal-state transparency): the fitted (MLL-optimized) leaf tensors by parameter name, the model class, the training-set geometry, and whether a fixed noise variance entered (yvar_provided). fit_maxiter is the L-BFGS iteration cap when one applied (the mixed_capped bundle) – None means fit-to-convergence. Emitted at the single fit seam (make_and_fit_gp), so every fit is recorded: failed rungs’ fits, gp_nehvi components, and mll_impute stage-1 fits included. The construct- only fixed-label GP never fits and is deliberately NOT recorded (its parameters are documented literals, deterministic in (d, labels)).

Distinguishes “same bytes by synchronization” from “same computation”: two replicas serving identical suggestions with different fitted state now disagree receipt-visibly. Audit only, never identity for any engine hash or seed (P8: provenance is not canonicalized state) – but CANONICAL in bench receipts, where cross-replica EQUALITY is the obligation (zero-mismatch; exposure without agreement passes nothing).

Initialization

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

model_config#: ‘ConfigDict(…)’

rung: str#: None

model_class: str#: None

n_train: int#: None

d_model: int#: None

yvar_provided: bool#: None

fit_maxiter: int | None#: None

noise_floor_std: float | None#: None

noise_floor_raw: float | None#: None

params: dict[str, tauopt.engine.provenance.TensorStat]#: None

class tauopt.engine.provenance.WorkRecord(/, **data: Any)#

Bases: pydantic.BaseModel

One rung attempt’s acquisition work shape (work counters): the EFFECTIVE optimizer knobs at the point of use – post any bundle override, so the executed work shape is receipt-visible on its own (the config alone does not show effective values) – plus the acq optimizer family and the requested q. n_pending counts open suggestions entering as constant-liar/pending conditioning. Audit only, never identity for any hash or seed (P8).

Initialization

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

model_config#: ‘ConfigDict(…)’

rung: str#: None

acq_path: Literal[optimize_acqf, mixed_alternating]#: None

q: int#: None

num_restarts: int#: None

raw_samples: int#: None

maxiter_alternating: int | None#: None

acq_maxiter: int | None#: None

n_pending: int#: 0

class tauopt.engine.provenance.ConditioningEvent(/, **data: Any)#

Bases: pydantic.BaseModel

One retry of a GP strategy’s suggest attempt (the rung-level conditioning controller): emitted when retry attempt attempt (1..3 – an acq-class arming retry, when it fires, precedes up to max_retries floor escalations) STARTS, carrying the standardized-variance floor it runs at and the PRIOR attempt’s typed exception. stage is the phase the prior attempt last entered (fit | fantasy | acq). armed is True on retries that run with the armed finite-filtering ic_generator installed (gp_nehvi’s acq-stage cure): the arming retry keeps floor_std UNCHANGED – a variance floor cannot remove non-finite values the acquisition itself produces at its raw samples, so the cure filters them at initialization instead – recorded as the f0-resolved value at attempt 0 or the standing floor_k thereafter; later typed-set escalations while armed stay armed (sticky). Additive, default False: pre-cure receipts keep exact bytes. Audit only, never identity – never part of any canonical form, hash, or seed (P8: provenance is not canonicalized state).

Initialization

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

model_config#: ‘ConfigDict(…)’

rung: str#: None

attempt: int#: None

floor_std: float#: None

stage: Literal[fit, fantasy, acq] | None#: None

exception_type: str#: None

exception_text: str#: None

armed: bool#: False

class tauopt.engine.provenance.AcqInitFilterRecord(/, **data: Any)#

Bases: pydantic.BaseModel

One armed attempt’s finite-filter receipt (the armed finite-filtering ic_generator, 0.3.2): raw q-batch rows drawn, rows surviving the whole-row isfinite filter (NaN and +/-inf both drop; row = one q-batch, joint acq is one scalar per q-tuple – deliberately NOT member-exclusion), the support verdict, the restarts actually installed, and the RAW-BASE POSTCONDITION verdict at the returned candidates. postcondition is a receipt, never an absence-of-error inference; on zero support it is "nonfinite" BY LAW – the empty survivor set’s vacuous isfinite(empty).all() == True must never read finite (the validator below is that law’s tooth). Audit only, never identity – never part of any canonical form, hash, or seed (P8).

Initialization

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

model_config#: ‘ConfigDict(…)’

rung: str#: None

n_raw: int#: None

n_finite: int#: None

n_dropped: int#: None

support: Literal[full, reduced, zero]#: None

n_restarts_used: int#: None

postcondition: Literal[finite, nonfinite]#: None

num_restarts: int#: None

class tauopt.engine.provenance.AggregationRecord(/, **data: Any)#

Bases: pydantic.BaseModel

Duplicate-x aggregation at fit assembly: raw scored rows in vs aggregated group rows out, plus the canonical-key version that defined sameness. Raw observations remain untouched in state – aggregation is a fit transform; this record is how a receipt shows it ran. Audit only, never identity – never part of any canonical form, hash, or seed (P8).

Initialization

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

model_config#: ‘ConfigDict(…)’

n_raw: int#: None

n_agg: int#: None

key_version: str#: None

class tauopt.engine.provenance.FallbackAttempt(/, **data: Any)#

Bases: pydantic.BaseModel

One FAILED rung attempt’s verbatim evidence, kept so a never-fail ladder descent (P6) preserves each failed rung’s own error rather than discarding or clobbering it. One record per failed rung, in ladder order; later rungs never overwrite earlier ones. stage is the phase the rung last entered (None when it died before any GP phase – e.g. config validation). conditioning_attempts are the conditioning- controller retries the rung burned before failing. The *_delta counters are the rung’s own contribution to the ask-level fits/work/acq_events records up to the failure point. Audit only, never identity (P8).

Initialization

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

model_config#: ‘ConfigDict(…)’

rung: str#: None

stage: Literal[fit, fantasy, acq] | None#: None

exception_type: str#: None

exception_text: str#: None

conditioning_attempts: tuple[tauopt.engine.provenance.ConditioningEvent, ...]#: ()

fits_delta: int#: 0

work_delta: int#: 0

acq_events_delta: int#: 0

class tauopt.engine.provenance.EngineProvenance(/, **data: Any)#

Bases: pydantic.BaseModel

The per-suggestion receipt: the identity triple (engine_version, engine_sha, deps_fingerprint) plus strategy, config_hash, policy, and the resolved seed – together with the recorded experiment state, enough to re-derive and verify the served suggestion (P4; the receipt alone identifies the run, it does not carry the state). fallback_from names the originally routed strategy when a never-fail ladder descent answered instead (P6), None when the intended rung answered. Everything from timings down is an audit record, absent (None) unless its subsystem ran (drop-at-absent keeps older receipts byte-exact); audit records never enter any canonical form, hash, or seed (P8: provenance is not canonicalized state).

Initialization

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

model_config#: ‘ConfigDict(…)’

engine_version: str#: None

engine_sha: str#: None

deps_fingerprint: str#: None

strategy: str#: None

config_hash: str#: None

policy: str | None#: None

seed: int#: None

fallback_from: str | None#: None

timings: tauopt.engine.provenance.ProvenanceTimings | None#: None

center: tauopt.engine.provenance.CenterRecord | None#: None

dedup: tauopt.engine.provenance.DedupRecord | None#: None

selection: tuple[tauopt.engine.provenance.QueueSlotRecord, ...] | None#: None

fits: tuple[tauopt.engine.provenance.GpFitRecord, ...] | None#: None

work: tuple[tauopt.engine.provenance.WorkRecord, ...] | None#: None

acq_events: int | None#: None

aggregation: tauopt.engine.provenance.AggregationRecord | None#: None

conditioning_events: tuple[tauopt.engine.provenance.ConditioningEvent, ...] | None#: None

acq_init_filters: tuple[tauopt.engine.provenance.AcqInitFilterRecord, ...] | None#: None

fallback_attempts: tuple[tauopt.engine.provenance.FallbackAttempt, ...] | None#: None

base_noise: float | None#: None

tauopt.engine.provenance.engine_version() → str#: Installed TauOpt release tag (the identity triple’s version leg); “0.0.0+uninstalled” when the distribution is absent. Cached per process.

tauopt.engine.provenance.engine_sha() → str#: Canonical engine identity. Resolution: TAUOPT_ENGINE_SHA (set by release/service builds) -> the tauopt._build_info module hatch_build.py stamps into every wheel and sdist at build time -> git HEAD when this file sits inside a checkout of the engine repository (a source checkout or an editable install) -> “unknown”. The cache keys on the declared value: env set/change/unset inside one process is honored; the stamp and git legs still memoize.

tauopt.engine.provenance.deps_fingerprint() → str#: Dependency fingerprint. TAUOPT_DEPS_FINGERPRINT (service images stamp blake2b(uv.lock) at build) -> fingerprint of the installed versions of the numerics-relevant dists (local/dev runs). The cache keys on the declared value.

tauopt.engine.provenance#

Module Contents#

Classes#

Functions#

API#

`tauopt.engine.provenance`#