mirror of
https://github.com/kuhyx/screen-locker.git
synced 2026-07-04 16:23:02 +02:00
Krzysztof kuhy Rudnicki
74a8bd7529
- Refactor RunnerUp verification: extract RunnerUpDbMixin (_runnerup_db.py), split _scan_and_fill_week_runnerup into a helper _try_fill_runnerup_for_date to keep cyclomatic complexity ≤10 - Generalise TCX lookup to any date in the ISO week (was today-only); all gap days Mon→today auto-filled on every startup and 08:30 timer firing - Add _adjust_shutdown_time_by(): +1h per extra workout beyond the 4-workout minimum, capped at midnight (hour=24) - Add _shutdown_base.py: daily reset of shutdown config to a stored base so the bonus doesn't silently accumulate across days - Add _extra_benefits.py: streak tracking, skip credits (earn (n-4) credits for 5+ workout weeks), early-bird extension to 09:00 for eligible weeks - Add --status mode (_status.py): non-locking CLI view showing per-day breakdown (✓/✗), RunnerUp auto-scan, bonus status, shutdown time, streak, skip credits, and early-bird status - Hook carrot into _check_non_verify_exits: bonus applied whenever auto-fill pushes weekly count above the minimum - Pass all pre-commit hooks (ruff, mypy, pylint, bandit, shellcheck, codespell, max-file-length); 508 tests at 100% branch coverage Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_017auyHmf2ZwQcDAwXaSo7KX
329 lines
12 KiB
Python
Executable File
329 lines
12 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
"""Screen locker with workout verification for Arch Linux / i3wm.
|
|
|
|
Requires user to log their workout to unlock the screen.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import logging
|
|
from pathlib import Path
|
|
import sys
|
|
import tkinter as tk
|
|
from typing import TYPE_CHECKING
|
|
|
|
from gatelock import GateRoot, LockConfig, LockWindow
|
|
|
|
from screen_locker import _sick_tracker
|
|
from screen_locker._auto_upgrade import AutoUpgradeMixin
|
|
from screen_locker._constants import (
|
|
EARLY_BIRD_END_HOUR,
|
|
EARLY_BIRD_END_MINUTE,
|
|
EARLY_BIRD_START_HOUR,
|
|
EXTRA_BENEFITS_FILE,
|
|
HMAC_KEY_FILE,
|
|
MAX_CLOCK_SKEW_SECONDS,
|
|
MIN_WORKOUT_DURATION_MINUTES,
|
|
PHONE_PENALTY_DELAY_DEMO,
|
|
PHONE_PENALTY_DELAY_PRODUCTION,
|
|
SCHEDULED_SKIPS_FILE,
|
|
SHUTDOWN_BASE_FILE,
|
|
SICK_DAY_STATE_FILE,
|
|
SICK_LOCKOUT_SECONDS,
|
|
)
|
|
from screen_locker._early_bird import EarlyBirdMixin
|
|
from screen_locker._extra_benefits import (
|
|
consume_skip_credit,
|
|
current_streak,
|
|
has_skip_credit,
|
|
process_week_transition,
|
|
)
|
|
from screen_locker._log_mixin import LogMixin
|
|
from screen_locker._phone_verification import PhoneVerificationMixin
|
|
from screen_locker._runnerup_verification import RunnerUpVerificationMixin
|
|
from screen_locker._shutdown import ShutdownMixin
|
|
from screen_locker._shutdown_base import reset_to_base_if_new_day
|
|
from screen_locker._sick_dialog import SickDialogMixin
|
|
from screen_locker._ui_flows import UIFlowsMixin
|
|
from screen_locker._ui_flows_relaxed import UIFlowsRelaxedMixin
|
|
from screen_locker._ui_widgets import UIWidgetsMixin
|
|
from screen_locker._weekly_check import (
|
|
COUNTED_WORKOUT_TYPES,
|
|
WEEKLY_WORKOUT_MINIMUM,
|
|
count_weekly_workouts,
|
|
has_weekly_minimum,
|
|
is_relaxed_day,
|
|
)
|
|
from screen_locker._window_setup import WindowSetupMixin
|
|
|
|
if TYPE_CHECKING:
|
|
from collections.abc import Callable
|
|
from concurrent.futures import Future
|
|
|
|
__all__ = [
|
|
"EARLY_BIRD_END_HOUR",
|
|
"EARLY_BIRD_END_MINUTE",
|
|
"EARLY_BIRD_START_HOUR",
|
|
"HMAC_KEY_FILE",
|
|
"MAX_CLOCK_SKEW_SECONDS",
|
|
"MIN_WORKOUT_DURATION_MINUTES",
|
|
"PHONE_PENALTY_DELAY_DEMO",
|
|
"PHONE_PENALTY_DELAY_PRODUCTION",
|
|
"SCHEDULED_SKIPS_FILE",
|
|
"SICK_LOCKOUT_SECONDS",
|
|
"WEEKLY_WORKOUT_MINIMUM",
|
|
"ScreenLocker",
|
|
]
|
|
|
|
_logger = logging.getLogger(__name__)
|
|
|
|
|
|
def _assert_not_under_pytest() -> None:
|
|
"""Raise if the screen locker is being created inside a pytest run.
|
|
|
|
Defence-in-depth: prevents a real fullscreen Tk window from locking
|
|
the user's screen when tests forget to mock ``tk.Tk``.
|
|
The check is cheap (one dict lookup) and only fires during testing.
|
|
"""
|
|
if "pytest" in sys.modules and getattr(tk, "__name__", "") == "tkinter":
|
|
msg = (
|
|
"SAFETY: ScreenLocker.__init__ called under pytest with "
|
|
"real tkinter — tk.Tk is not mocked"
|
|
)
|
|
raise RuntimeError(msg)
|
|
|
|
|
|
class ScreenLocker(
|
|
AutoUpgradeMixin,
|
|
EarlyBirdMixin,
|
|
LogMixin,
|
|
WindowSetupMixin,
|
|
ShutdownMixin,
|
|
PhoneVerificationMixin,
|
|
RunnerUpVerificationMixin,
|
|
SickDialogMixin,
|
|
UIFlowsMixin,
|
|
UIFlowsRelaxedMixin,
|
|
UIWidgetsMixin,
|
|
):
|
|
"""Screen locker that requires workout logging to unlock."""
|
|
|
|
def __init__(
|
|
self,
|
|
*,
|
|
demo_mode: bool = True,
|
|
verify_only: bool = False,
|
|
) -> None:
|
|
"""Initialize screen locker with optional demo mode."""
|
|
_assert_not_under_pytest()
|
|
script_dir = Path(__file__).resolve().parent
|
|
self.log_file = script_dir / "workout_log.json"
|
|
self.verify_only = verify_only
|
|
self.workout_data: dict[str, str] = {}
|
|
self._relaxed_day_mode: bool = False
|
|
self._check_early_exits(verify_only=verify_only)
|
|
self.root = GateRoot()
|
|
self.root.on_callback_error = self.on_callback_error
|
|
title_suffix = (
|
|
" [VERIFY]" if verify_only else (" [DEMO MODE]" if demo_mode else "")
|
|
)
|
|
self.root.title("Workout Locker" + title_suffix)
|
|
self.demo_mode = demo_mode
|
|
self.lockout_time = 10 if demo_mode else 1800
|
|
self._lock: LockWindow | None = None
|
|
if verify_only:
|
|
self._setup_verify_window()
|
|
elif self._relaxed_day_mode:
|
|
self._setup_relaxed_day_window()
|
|
else:
|
|
config = LockConfig(
|
|
mode="hard",
|
|
grab="local" if demo_mode else "global",
|
|
disable_vt=not demo_mode,
|
|
)
|
|
self._lock = LockWindow(self.root, config, hooks=self)
|
|
self._lock.setup()
|
|
if demo_mode:
|
|
self._setup_demo_close_button()
|
|
self.container = tk.Frame(self.root, bg="#1a1a1a")
|
|
self.container.place(relx=0.5, rely=0.5, anchor="center")
|
|
self._phone_future: Future[tuple[str, str]] | None = None
|
|
self._runnerup_future: Future[tuple[str, str]] | None = None
|
|
self._runnerup_on_failure: Callable[[], None] | None = None
|
|
if verify_only:
|
|
self._start_verify_workout_check()
|
|
elif self._relaxed_day_mode:
|
|
self._start_relaxed_day_flow()
|
|
else:
|
|
self._start_phone_check()
|
|
# Always set on this branch; guard only for mypy (can't narrow
|
|
# across two separate if/elif/else statements).
|
|
if self._lock is not None: # pragma: no branch
|
|
self._lock.grab_input()
|
|
|
|
def _check_non_verify_exits(self) -> None:
|
|
"""Check all normal (non-verify) startup early-exit conditions."""
|
|
if self._is_scheduled_skip_today():
|
|
_logger.info("Today is a scheduled skip day. Skipping screen lock.")
|
|
sys.exit(0)
|
|
return
|
|
# Reset shutdown config to base (21:00) at the start of each new day
|
|
# so workout bonuses always layer on top of a known floor.
|
|
reset_to_base_if_new_day(
|
|
SHUTDOWN_BASE_FILE, self, sick_day_state_file=SICK_DAY_STATE_FILE
|
|
)
|
|
# Auto-fill any RunnerUp workouts from earlier in the current ISO week
|
|
# before any early-exit check, so gaps are closed regardless of today's
|
|
# logged state (early_bird, sick_day, etc.).
|
|
prev_count = count_weekly_workouts(self.log_file)
|
|
n_filled = self._scan_and_fill_week_runnerup(self.log_file)
|
|
if n_filled:
|
|
new_count = count_weekly_workouts(self.log_file)
|
|
_logger.info(
|
|
"Auto-filled %d RunnerUp workout(s) from TCX exports.", n_filled
|
|
)
|
|
# Award +1h for each newly auto-filled workout above the minimum.
|
|
bonus = max(0, new_count - max(WEEKLY_WORKOUT_MINIMUM, prev_count))
|
|
if bonus > 0 and self._adjust_shutdown_time_by(bonus):
|
|
_logger.info("Auto-fill extra bonus: +%dh shutdown time.", bonus)
|
|
# Award streak / skip-credit / EB-extension rewards from last week.
|
|
for reward_msg in process_week_transition(self.log_file, EXTRA_BENEFITS_FILE):
|
|
_logger.info("Weekly reward: %s", reward_msg)
|
|
if self._check_today_state_exits():
|
|
return
|
|
# Day-of-week routing: Tue/Wed/Thu relaxed (optional), Fri-Mon enforced.
|
|
if is_relaxed_day():
|
|
_logger.info("Relaxed day (Tue-Thu) - showing optional workout prompt.")
|
|
self._relaxed_day_mode = True
|
|
return
|
|
# Fri-Mon: skip lock when weekly minimum is already met.
|
|
if has_weekly_minimum(self.log_file):
|
|
_logger.info(
|
|
"Weekly minimum of %d workouts met. Skipping screen lock.",
|
|
WEEKLY_WORKOUT_MINIMUM,
|
|
)
|
|
sys.exit(0)
|
|
return
|
|
# Spend a banked skip credit if the minimum hasn't been reached yet.
|
|
if has_skip_credit(EXTRA_BENEFITS_FILE):
|
|
consume_skip_credit(EXTRA_BENEFITS_FILE)
|
|
_logger.info("Used a banked skip credit — no lock today.")
|
|
sys.exit(0)
|
|
return
|
|
|
|
def _try_adjust_shutdown_for_workout(self) -> bool:
|
|
"""Try to adjust shutdown time later for actual workouts."""
|
|
workout_type = self.workout_data.get("type", "")
|
|
if workout_type not in COUNTED_WORKOUT_TYPES:
|
|
return False
|
|
adjusted = self._adjust_shutdown_time_later()
|
|
if adjusted:
|
|
_logger.info("Shutdown time moved 2 hours later as workout reward")
|
|
return adjusted
|
|
|
|
def _clear_debt_on_verified_workout(self) -> int | None:
|
|
"""Decrement workout debt by one for a verified workout.
|
|
|
|
Returns the new debt count, or ``None`` when this wasn't a
|
|
phone-verified workout.
|
|
"""
|
|
if self.workout_data.get("type") not in ("phone_verified", "runnerup_verified"):
|
|
return None
|
|
history = _sick_tracker.load_history()
|
|
if history.debt <= 0:
|
|
return 0
|
|
new_debt = _sick_tracker.clear_one_debt(history)
|
|
_sick_tracker.save_history(history)
|
|
return new_debt
|
|
|
|
def unlock_screen(self) -> None:
|
|
"""Save workout log and display success message."""
|
|
self.save_workout_log()
|
|
shutdown_adjusted = self._try_adjust_shutdown_for_workout()
|
|
new_debt = self._clear_debt_on_verified_workout()
|
|
|
|
# Extra-workout bonus: +1h per workout above the weekly minimum.
|
|
extra_bonus_delta = 0
|
|
weekly_count = count_weekly_workouts(self.log_file)
|
|
if weekly_count > WEEKLY_WORKOUT_MINIMUM:
|
|
old_cfg = self._read_shutdown_config()
|
|
if old_cfg and self._adjust_shutdown_time_by(1):
|
|
new_cfg = self._read_shutdown_config()
|
|
if new_cfg:
|
|
extra_bonus_delta = new_cfg[1] - old_cfg[1]
|
|
|
|
self.clear_container()
|
|
self._label("Great job! 💪", font_size=48, color="#00ff00", pady=30)
|
|
if shutdown_adjusted:
|
|
self._text(
|
|
"Shutdown time +2h later! 🎁",
|
|
font_size=24,
|
|
color="#ffaa00",
|
|
)
|
|
if extra_bonus_delta > 0:
|
|
extra_n = weekly_count - WEEKLY_WORKOUT_MINIMUM
|
|
self._text(
|
|
f"Extra workout #{extra_n}! +{extra_bonus_delta}h tonight",
|
|
font_size=20,
|
|
color="#ffaa00",
|
|
)
|
|
if new_debt is not None:
|
|
self._text(
|
|
f"Workout debt: {new_debt}",
|
|
font_size=20,
|
|
color="#ffaa00" if new_debt > 0 else "#888888",
|
|
)
|
|
streak = current_streak(EXTRA_BENEFITS_FILE)
|
|
if streak >= 1:
|
|
self._text(
|
|
f"🔥 {streak}-week streak (5+ workouts each)",
|
|
font_size=14,
|
|
color="#888888",
|
|
)
|
|
self._text("Screen Unlocked!", font_size=36, pady=20)
|
|
if self.workout_data.get("type") in ("phone_verified", "runnerup_verified"):
|
|
self.root.after(
|
|
1500,
|
|
lambda: self._show_commitment_prompt(on_done=self.close),
|
|
)
|
|
else:
|
|
self.root.after(1500, self.close)
|
|
|
|
def close(self) -> None:
|
|
"""Close the application and exit."""
|
|
if self._lock is not None:
|
|
self._lock.close()
|
|
else:
|
|
self.root.destroy()
|
|
sys.exit(0)
|
|
|
|
def run(self) -> None:
|
|
"""Start the Tkinter main event loop."""
|
|
if self._lock is not None:
|
|
self._lock.run()
|
|
else:
|
|
self.root.mainloop()
|
|
|
|
|
|
if __name__ == "__main__":
|
|
if "--status" in sys.argv:
|
|
from screen_locker._status import run_status
|
|
|
|
# Bypass __init__ (no UI) — only log_file and workout_data are needed.
|
|
_sl = object.__new__(ScreenLocker)
|
|
_sl.log_file = Path(__file__).resolve().parent / "workout_log.json"
|
|
_sl.workout_data = {}
|
|
run_status(_sl)
|
|
|
|
demo_mode = True
|
|
verify_only = "--verify-workout" in sys.argv
|
|
|
|
if "--production" in sys.argv:
|
|
demo_mode = False
|
|
|
|
locker = ScreenLocker(
|
|
demo_mode=demo_mode,
|
|
verify_only=verify_only,
|
|
)
|
|
locker.run()
|