mirror of
https://github.com/kuhyx/utils.git
synced 2026-11-17 21:45:08 +01:00
main was red on file length, the noqa ban, codespell, test naming and dart coverage; this change touches every one of those jobs. - sickdays: set_enabled is keyword-only; the panel test splits in two with shared probes; the sync wire format moves to DOCS-sync.md. - earned_time: _focus types the project as a Protocol, no noqa; the gate-maturity section moves to DOCS-maturity.md; codespell knows the `checkin` event name. - focus_project: real fixes for every noqa (local-day clocks, typed fakes, logged broad catches, split helpers). The public API that focus-guard calls keeps its signatures; their PLR0913 exemption lives in pyproject with the reason, not in noqa. - crdt-sync: pylint gets nacl/argon2, docstrings, and allows the public E2eLayout.of; _blobs moves to _e2e_blobs.py. - crdt_sync_dart: Argon2Params and the header errors move to e2e_params.dart (re-exported); tests split and reach 100% lines. - sql_drills: test helpers get a leading underscore, as in earned_time. Todo: fda71ed1 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
110 lines
3.9 KiB
Python
110 lines
3.9 KiB
Python
# Copyright (c) 2026 Krzysztof Rudnicki
|
|
"""Pluggable check sources for the auto-checked milestones, and latching.
|
|
|
|
A source is ``fn(project, now) -> True | False | None``; ``None`` means "could
|
|
not check" (logged) and counts as not done. Only ``phone`` is auto-checked
|
|
(the calendar slot check was dropped, 2026-11-10: ``slot`` is two taps).
|
|
|
|
:func:`run_checks` is the only place sources run: status()/milestones() stay
|
|
cheap and read the latched ``check`` rows it appends (only on a change).
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
from collections.abc import Callable
|
|
from datetime import datetime, timedelta
|
|
import logging
|
|
|
|
from focus_project import _milestones, _mutate, _store, evidence
|
|
from focus_project._model import Project
|
|
|
|
_logger = logging.getLogger(__name__)
|
|
CheckSource = Callable[[Project, datetime], bool | None]
|
|
DAY_MS = 24 * 3600 * 1000
|
|
# A phone check starts 24 h before the milestone is due.
|
|
WINDOW = timedelta(hours=24)
|
|
|
|
|
|
def _report_ok(value: object, report_ms: int) -> bool:
|
|
"""A plan exists, cards are due, the phone was seen <= 24 h before the report."""
|
|
if not isinstance(value, dict):
|
|
return False
|
|
try:
|
|
return bool(
|
|
value["plan"] is True
|
|
and int(value["due"]) > 0
|
|
and report_ms - int(value["seen_ms"]) <= DAY_MS
|
|
)
|
|
except KeyError, TypeError, ValueError:
|
|
return False
|
|
|
|
|
|
def phone_source(project: Project, now: datetime) -> bool | None:
|
|
"""Read tutor's latest ``phone_check`` report (<= 24 h old).
|
|
|
|
No report, a stale one or one stamped ahead of the clock = ``None``
|
|
(the worker is not reporting). A fresh one passes only if the plan
|
|
exists, cards are due and the phone was seen within 24 h of the report.
|
|
"""
|
|
report = evidence.last(evidence.read(project.id), "phone", "phone_check")
|
|
if report is None:
|
|
_logger.warning("phone check: no tutor report for %s", project.id)
|
|
return None
|
|
if not 0 <= evidence.to_ms(now) - report.ms <= DAY_MS:
|
|
_logger.warning(
|
|
"phone check: tutor report for %s is stale or ahead", project.id
|
|
)
|
|
return None
|
|
return _report_ok(report.value, report.ms)
|
|
|
|
|
|
SOURCES: dict[str, CheckSource] = {"phone": phone_source}
|
|
|
|
|
|
def register_source(name: str, source: CheckSource) -> None:
|
|
"""Replace the callable behind an auto check (``phone``)."""
|
|
if name not in SOURCES:
|
|
msg = f"unknown check source {name!r}; known: {sorted(SOURCES)}"
|
|
raise ValueError(msg)
|
|
SOURCES[name] = source
|
|
|
|
|
|
def _run(project: Project, now: datetime) -> bool | None:
|
|
try:
|
|
return SOURCES["phone"](project, now)
|
|
# Pluggable code: any failure means unknown, never a crash.
|
|
except Exception as exc: # pylint: disable=broad-exception-caught
|
|
_logger.warning("phone check source failed: %s", exc, exc_info=True)
|
|
return None
|
|
|
|
|
|
def run_checks(
|
|
project_id: str, *, now: datetime | None = None
|
|
) -> dict[str, bool | None]:
|
|
"""Run the auto checks of open phone milestones; latch what changed.
|
|
|
|
Returns milestone id -> verdict for the ones checked (inside their
|
|
24 h window, not yet done). KeyError for an unknown project; a focus
|
|
project has nothing to check.
|
|
"""
|
|
stamp = _mutate.local_now(now)
|
|
project = next((p for p in _store.read_all() if p.id == project_id), None)
|
|
if project is None:
|
|
raise KeyError(project_id)
|
|
open_ids = [
|
|
m.id
|
|
for m in _milestones.milestones(project, stamp)
|
|
if m.id.startswith("phone:")
|
|
and m.state not in {"done", "late_done"}
|
|
and stamp >= m.due - WINDOW
|
|
]
|
|
if not open_ids:
|
|
return {}
|
|
verdict = _run(project, stamp)
|
|
rows = evidence.read(project_id)
|
|
for mid in open_ids:
|
|
_, latest, seen = evidence.check_summary(rows, mid)
|
|
if verdict != latest and not (verdict is None and not seen):
|
|
evidence.append(project_id, mid, "check", verdict, stamp)
|
|
return dict.fromkeys(open_ids, verdict)
|