mirror of
https://github.com/kuhyx/utils.git
synced 2026-11-22 19:12:28 +01:00
A gate can now sign "done N of target M for day D" and resolve() pays a no-answer that share of a yes (60 * 1 // 3 = 20), floored, for shutdown, gaming and sick days. A yes still pays full; "could not check" still pays nothing. With no progress row anywhere every output is 0.23.0's, pinned by a digest grid and, when installed, the real 0.23.0 as oracle. Every failure reads as no progress, so the day pays by its yes/no rule and never more: - no row, a bad or missing signature, an edited row - another day or another gate's source - numbers typed as ints, floats, signed, padded, empty, non-ASCII or huge - a zero target (no plan, no share) - an unreadable key or ledger (logged, never raised) - the gate being off today - an earner with no progress source (tutor, focus) A bad row beside a good one is skipped. Done above target is capped. The focus earner now uses the same share arithmetic, same floor. A progress row is not a credit: maturity and the done answers never see it. The floor helpers moved to _floor.py and the tutor row contract to DOCS-tutor.md to stay under the 250-line cap. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01WzxdWVfmEXxPymCs5bo3Zs
72 lines
2.6 KiB
Python
72 lines
2.6 KiB
Python
# Copyright (c) 2026 Krzysztof Rudnicki
|
|
"""The floor's parts: what a penalty cuts, when it bites, the shutdown floor.
|
|
|
|
Split from :mod:`earned_time._resolve` (0.24.0) to keep both under the line
|
|
cap; :func:`earned_time.base_for` is still defined there.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
from typing import TYPE_CHECKING
|
|
|
|
from earned_time._focus import FocusEarner
|
|
from earned_time._ladder import on_ladder, shutdown_ceiling_for
|
|
from earned_time._maturity import confirmed_start, penalty_start
|
|
from earned_time._policy import SHUTDOWN_BASE_MINUTES
|
|
|
|
if TYPE_CHECKING:
|
|
from collections.abc import Mapping
|
|
from datetime import date
|
|
|
|
from earned_time._policy import Earner
|
|
|
|
|
|
def gaming_cut(item: Earner) -> int:
|
|
"""What a penalty in force takes off the gaming base: all ``item`` can pay.
|
|
|
|
A focus earner cuts what the gates it replaced paid; it pays more (0.21.0).
|
|
"""
|
|
if isinstance(item, FocusEarner):
|
|
return item.cut_gaming_minutes
|
|
return item.max_gaming_minutes
|
|
|
|
|
|
def is_penalised(
|
|
item: Earner, day: date, first_credits: Mapping[str, date | None] | None
|
|
) -> bool:
|
|
"""Whether ``item``'s cut is in force on ``day``.
|
|
|
|
Without ``first_credits``: ``penalty_from`` alone, as in 0.5.0. With it:
|
|
:func:`penalty_start` of the earner's first real credit (``None`` -- never
|
|
paid out, or could not check -- is not penalised unless ``confirmed_on``
|
|
is set: fail closed); an earner missing from it still waits for the day
|
|
after its ``confirmed_on``.
|
|
"""
|
|
if first_credits is None:
|
|
return item.penalised_on(day)
|
|
start = (
|
|
penalty_start(item, first_credits[item.name])
|
|
if item.name in first_credits
|
|
else confirmed_start(item)
|
|
)
|
|
return start is not None and day >= start
|
|
|
|
|
|
def shutdown_floor(day: date, earners: tuple[Earner, ...], cut: list[Earner]) -> int:
|
|
"""Shutdown of a day that earned nothing; ``cut``: the penalties in force.
|
|
|
|
On the ladder: the ceiling minus the most each earner can pay (all of a
|
|
capped earner's units), so doing everything lands exactly on the ceiling
|
|
-- but only a pure bonus (no ``penalty_from``) or an earner in ``cut``: a
|
|
gate whose penalty has not started cannot lower the floor (0.6.1), nor can
|
|
a top-up (0.23.0). Before it: the old base minus the penalties in force.
|
|
"""
|
|
if on_ladder(day):
|
|
rungs = (
|
|
e for e in earners if not e.topup and (e.penalty_from is None or e in cut)
|
|
)
|
|
return shutdown_ceiling_for(day) - sum(
|
|
e.shutdown_for(e.max_units or 1, day) for e in rungs
|
|
)
|
|
return SHUTDOWN_BASE_MINUTES - sum(e.shutdown_minutes for e in cut)
|