mixle.experimental.typed_runtime.clocks module

Independent step/token/observation clocks for multi-rate update nodes.

class ClockDecision(node_id, due, triggers, progress, last_commit, commit_count)

Bases: object

Due/not-due decision and elapsed work since the last commit.

Parameters:

• node_id (str)

• due (bool)

• triggers (tuple[ClockTrigger, ...])

• progress (ClockProgress)

• last_commit (ClockProgress | None)

• commit_count (int)

as_dict()

Return a JSON-compatible clock decision.

Return type:

dict[str, Any]

class ClockProgress(step=0, tokens=0, observations=0.0, counter_semantics=CounterSemantics.CUMULATIVE)

Bases: object

Monotone run progress against which node cadences are evaluated.

Parameters:

• step (int)

• tokens (int)

• observations (float)

• counter_semantics (CounterSemantics)

as_dict()

Return a JSON-compatible progress vector.

Return type:

dict[str, int | float]

class ClockTrigger(*values)

Bases: StrEnum

Reason an update clock became due.

class MultiRateUpdateClocks(cadences)

Bases: object

Stateful cadence registry that never permits progress to move backward.

Parameters:

cadences (dict[str, UpdateCadence])

evaluate(progress, node_ids=None)

Evaluate selected or all registered clocks without marking a commit.

Parameters:

• progress (ClockProgress)

• node_ids (tuple[str, ...] | None)

Return type:

tuple[ClockDecision, …]

mark_committed(node_ids, progress)

Advance selected clocks after a successful transaction only.

Parameters:

• node_ids (tuple[str, ...])

• progress (ClockProgress)

Return type:

None

as_dict()

Return replay-relevant clock state.

Return type:

dict[str, Any]

class UpdateCadence(every_steps=None, every_tokens=None, every_observations=None, max_staleness_steps=None)

Bases: object

Any-trigger cadence with an optional hard staleness bound.

Parameters:

• every_steps (int | None)

• every_tokens (int | None)

• every_observations (float | None)

• max_staleness_steps (int | None)