jacobh2
f76de7ba04
A season preset in a two-parent household now means both parents, not either one — being off together is the point of the period. Within such a period the planner used to pick whoever had the most parental-benefit days left, date by date, so spending kept moving the lead and the funding flipped almost daily. Six weeks came out as a patchwork that costs nothing to hold but a great deal to request. The payer is now chosen once per half of the window, reusing the same split the swap strategy already uses: one parent on parental benefit while the other takes vacation, then they change over. Both are still off every day, and if one runs out mid-stretch the roles swap for the rest rather than day by day. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01Ei7gCZzdd751uZtPzb1Pep
2712 lines
117 KiB
Python
2712 lines
117 KiB
Python
"""Planning engine allocator.
|
|
|
|
See PLANNING_ENGINE_SPEC.md §3 for the full design. Split strictly in two, and
|
|
the split is the single most important property of this module:
|
|
|
|
- `AllocationInputLoader` — async. The ONLY part of the planning engine that
|
|
touches a repository or the wall clock. Assembles a frozen `AllocationInput`.
|
|
- `Allocator` — PURE. No `await`, no repository access, and above all no
|
|
`date.today()`. `today` arrives on `AllocationInput.today`. Same input must
|
|
always produce byte-identical output (§5 test #11) — this is what makes the
|
|
engine explainable, cheap to re-run on every edit, and unit-testable without
|
|
a database.
|
|
|
|
`PlanningEngineService` is a thin orchestrator gluing the two together for the
|
|
router (`POST /api/plan/propose`).
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
from dataclasses import dataclass, field
|
|
from datetime import date, timedelta
|
|
from uuid import UUID
|
|
|
|
from dateutil.relativedelta import relativedelta
|
|
|
|
from app.config import settings
|
|
from app.entities.child import Child
|
|
from app.entities.leave_wish import LeaveWish
|
|
from app.entities.planned_leave import PlannedLeaveDay
|
|
from app.repositories.child_repository import ChildRepository
|
|
from app.repositories.day_override_repository import DayOverrideRepository
|
|
from app.repositories.leave_wish_repository import LeaveWishRepository
|
|
from app.repositories.parental_leave_repository import ParentalLeaveRepository
|
|
from app.repositories.personal_data_repository import PersonalDataRepository
|
|
from app.repositories.planned_leave_repository import PlannedLeaveRepository
|
|
from app.repositories.vacation_days_repository import VacationDaysRepository
|
|
from app.repositories.workspace_repository import WorkspaceRepository
|
|
from app.utils.errors import NotFoundError, ValidationError
|
|
from app.utils.holidays import (
|
|
SUNDAY_HOLIDAY_NAME,
|
|
UncachedYearError,
|
|
cached_year_bounds,
|
|
get_swedish_holidays,
|
|
)
|
|
from app.utils.tip_predicates import (
|
|
days_left_at_age_4_projection,
|
|
default_tier_pool_share,
|
|
has_vacation_near_expiry,
|
|
resolve_age4_savable_cap,
|
|
)
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Reason codes (§3.5) — machine-readable so the UI can explain itself.
|
|
# ---------------------------------------------------------------------------
|
|
|
|
REASON_FREE_WEEKEND = "free_weekend"
|
|
REASON_FREE_RED_DAY = "free_red_day"
|
|
REASON_VACATION_WRAP_RED_DAY = "vacation_wrap_red_day"
|
|
REASON_VACATION_WRAP_WEEKEND = "vacation_wrap_weekend"
|
|
REASON_FP_INTERIOR = "fp_interior"
|
|
REASON_FP_LAGSTA_STRETCH = "fp_lagsta_stretch"
|
|
REASON_SWAP_FIRST_HALF = "swap_first_half"
|
|
REASON_SWAP_SECOND_HALF = "swap_second_half"
|
|
REASON_DUBBELDAG = "dubbeldag"
|
|
# §todo item 2 — a free day (Saturday, Sunday or public holiday) funded with a
|
|
# parental-benefit day instead of being left free, opted into per-workspace via
|
|
# `AllocationInput.take_pl_on_red_days` (default False — see `_fund_solo`/
|
|
# `_fund_both`). Vacation is deliberately never used here: Swedish law does not
|
|
# let you "take vacation" on a day that already isn't a working day, but FP is
|
|
# a benefit payment, not a scheduling construct, so it can still be drawn on a
|
|
# red day to replace the (unpaid) day off with a paid one — at the cost of
|
|
# spending a day the household would otherwise have kept.
|
|
REASON_FP_RED_DAY = "fp_red_day"
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Surplus advice kinds (§9.2) — the mirror of a shortfall remedy: emitted
|
|
# when a parent is forecast to *forfeit* days at the age-4 boundary rather
|
|
# than run short.
|
|
# ---------------------------------------------------------------------------
|
|
|
|
SURPLUS_WISH_MORE_LEAVE = "wish_more_leave"
|
|
SURPLUS_SHIFT_MIX_TO_FP = "shift_mix_to_fp"
|
|
SURPLUS_FRONT_LOAD_EARLY_YEARS = "front_load_early_years"
|
|
SURPLUS_USE_LESS_VACATION = "use_less_vacation"
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Shortfall remedy kinds (§3.6, §9.1) and plan warning kinds — named so their
|
|
# `message_key` (below) is derived rather than hand-typed a second time.
|
|
# ---------------------------------------------------------------------------
|
|
|
|
REMEDY_REDUCE_PRESCHOOL_RESERVE = "reduce_preschool_reserve"
|
|
REMEDY_CARRY_VACATION_FORWARD = "carry_vacation_forward"
|
|
REMEDY_LOWER_PRIORITY_WISH = "lower_priority_wish"
|
|
REMEDY_SHIFT_WINDOW_INTO_FREE_DAYS = "shift_window_into_free_days"
|
|
|
|
WARNING_DAYS_LOST_AT_AGE_4 = "days_lost_at_age_4"
|
|
WARNING_SGI_RISK = "sgi_risk"
|
|
WARNING_VACATION_EXPIRING = "vacation_expiring"
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# §10.4 — flexible ("när det passar bäst") wish outcome strategy. Added to
|
|
# the existing `WindowOutcome.strategy` value set ('solo' | 'parent_swap' |
|
|
# 'dubbeldag') — a bare str on both the dataclass and the wire model, so a
|
|
# new literal value is a behavior change, not a schema change.
|
|
#
|
|
# §Decision A/C (2026-09-18 co-leave fix) extended that set again:
|
|
# 'co_leave' — a `parent_mode == 'both'` window funded as PL (to whichever
|
|
# parent has the most FP left) + vacation (the other parent) on the SAME
|
|
# date, the new default for 'both' whenever dubbeldagar are not requested
|
|
# or not legally available. 'swap' — the true last resort within a 'both'
|
|
# window: a date neither co-leave resource could cover, handed to the same
|
|
# sequential-halves machinery 'parent_swap' uses. `strategy` always reports
|
|
# what actually happened, never what was merely hoped for; `requested_strategy`
|
|
# carries the latter, and `strategy_degraded` is true whenever they differ
|
|
# (see `WindowOutcome` below).
|
|
# ---------------------------------------------------------------------------
|
|
|
|
STRATEGY_UNPLACED = "unplaced"
|
|
STRATEGY_CO_LEAVE = "co_leave"
|
|
STRATEGY_SWAP = "swap"
|
|
|
|
# §3.5 — i18n message keys. Every UI-facing piece of text the (pure) allocator
|
|
# used to render as a full Swedish sentence is now a `message_key` + `data`
|
|
# pair instead (the pattern `tips_service.py` already uses for `Tip`), so the
|
|
# frontend can translate it in the caller's active locale rather than
|
|
# rendering backend-generated text verbatim regardless of locale. See
|
|
# `frontend/src/i18n/sv.ts` / `en.ts` for the corresponding copy and
|
|
# `frontend/src/components/planning/PlanResults.tsx` for the lookup tables
|
|
# that map these opaque keys to real `TranslationKey`s (same shape as
|
|
# `TipCard.tsx`'s `TIP_TRANSLATION_KEYS`).
|
|
MESSAGE_KEY_WINDOW_EXPLANATION = "planOutcomes.windowExplanation"
|
|
|
|
_SUNDAY_HOLIDAY_NAME = SUNDAY_HOLIDAY_NAME
|
|
_DUBBELDAGAR_MONTHS_LIMIT = settings.rules.dubbeldagar_months_limit
|
|
_MAX_DUBBELDAGAR = settings.rules.max_dubbeldagar
|
|
# NOTE: no module-level "_MAX_SAVABLE_AT_B4" here on purpose — which age-4 cap
|
|
# applies (96 per child vs. 48 per parent) depends purely on parent count, so
|
|
# it is resolved once per `propose()` run by `AllocationInputLoader` onto
|
|
# `AllocationInput.age4_savable_cap` and read from there
|
|
# (`self._input.age4_savable_cap`) everywhere `_Ledger` needs it — never as a
|
|
# constant computed at import time.
|
|
_SGI_MIN_DAYS_PER_WEEK = settings.rules.sgi_min_days_per_week_after_age_1
|
|
# A "week off" costs ~5 spendable weekdays (Sat/Sun are already free) — see
|
|
# §3.4: "a 6-week summer window is ~42 calendar days but only ~30 spendable
|
|
# ones". Used to turn a raw day count into an actionable week count.
|
|
_SPENDABLE_DAYS_PER_WEEK = 5
|
|
# A surplus is "large" enough to justify front-loading (spending more while
|
|
# the child is small, rather than trickling it out) once it clears roughly a
|
|
# month of FP days.
|
|
_LARGE_SURPLUS_THRESHOLD_DAYS = 4 * _SPENDABLE_DAYS_PER_WEEK
|
|
# "Small child" window for the front_load_early_years suggestion.
|
|
_FRONT_LOAD_CHILD_AGE_YEARS = 2
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# §3.1 Input
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@dataclass(frozen=True)
|
|
class ChildFacts:
|
|
id: UUID
|
|
birth_date: date
|
|
fourth_birthday: date
|
|
preschool_start_date: date | None
|
|
preschool_planning_days_per_year: int
|
|
|
|
|
|
@dataclass(frozen=True)
|
|
class ParentFacts:
|
|
uuid: UUID
|
|
name: str
|
|
salary_type: str # 'monthly' | 'hourly'
|
|
employment_status: str
|
|
# Semesterlagen floor (statutory 20; employer may set higher) — see
|
|
# PersonalData.min_vacation_days_per_year and PLANNING_ENGINE_SPEC §9.2.
|
|
# Only days above this per (parent, year) may be carried forward, and
|
|
# `use_less_vacation` surplus advice must never suggest dropping below it.
|
|
min_vacation_days_per_year: int = 20
|
|
|
|
|
|
@dataclass(frozen=True)
|
|
class DayPool:
|
|
"""Remaining (not yet used) FP days for one (parent, child) pair."""
|
|
|
|
sjukpenning_left: int
|
|
lagsta_left: int
|
|
dubbeldagar_left: int
|
|
|
|
|
|
@dataclass(frozen=True)
|
|
class VacationBudget:
|
|
total_days: int
|
|
saved_days_in: int
|
|
already_used: int
|
|
# True when no `vacation_days` row exists for this (parent, year) and
|
|
# `AllocationInputLoader` defaulted `total_days` to the statutory
|
|
# entitlement (§Task 2) rather than reading an entered value. A missing
|
|
# row means "not entered yet", never "zero days" — this flag is how that
|
|
# assumption stays visible in the report instead of silently passing for
|
|
# a real entry, so the UI can eventually prompt the user to confirm it.
|
|
is_assumed: bool = False
|
|
|
|
@property
|
|
def available(self) -> int:
|
|
return self.total_days + self.saved_days_in - self.already_used
|
|
|
|
|
|
@dataclass(frozen=True)
|
|
class AllocationInput:
|
|
today: date
|
|
horizon_end: date
|
|
# The age-4 savable-days ceiling that applies to THIS workspace, resolved
|
|
# once by the loader via `app.utils.tip_predicates.resolve_age4_savable_cap`
|
|
# (96 per child for a genuine single parent, or 48 per parent —
|
|
# non-poolable — as soon as the child has 2+ parents) — never re-derived
|
|
# inside the (pure) `_Ledger`.
|
|
age4_savable_cap: int
|
|
children: list[ChildFacts]
|
|
parents: list[ParentFacts]
|
|
pools: dict[tuple[UUID, UUID], DayPool] # (parent, child) -> pool
|
|
vacation: dict[tuple[UUID, int], VacationBudget] # (parent, year) -> budget
|
|
wishes: list[LeaveWish]
|
|
existing_planned: list[PlannedLeaveDay]
|
|
holidays: dict[date, str]
|
|
# Workspace-scoped calendar corrections (see DayOverride entity):
|
|
# True = must work this date despite the calendar, False = off this date
|
|
# despite the calendar. `is_free_day` is the single place these are
|
|
# merged on top of `holidays`.
|
|
day_overrides: dict[date, bool] = field(default_factory=dict)
|
|
# §todo item 2 — per-workspace opt-in (default False, byte-identical to
|
|
# pre-existing behaviour when unset): allow a free day (Saturday, Sunday,
|
|
# public holiday) inside a funded window to be paid with an FP day
|
|
# (never vacation — see `REASON_FP_RED_DAY`). Read only by `_fund_solo`/
|
|
# `_fund_both`; deliberately NOT consulted by `is_free_day` itself, which
|
|
# stays the single, opt-in-agnostic definition of "is this day free" (it
|
|
# is also used for costing/klämdag-cluster detection, where the day must
|
|
# stay classified as free regardless of whether it ends up FP-funded).
|
|
take_pl_on_red_days: bool = False
|
|
# §fix (parent-reassignment moves dates, decision B) — the FULL,
|
|
# never-filtered snapshot of every persisted `planned_leave_day` row for
|
|
# this workspace, independent of `existing_planned` above (which
|
|
# `only_pinned_existing=True` — see `AllocationInputLoader.load` —
|
|
# narrows to pinned/ad-hoc rows only, so `sync_plan`'s re-plan can
|
|
# legitimately re-derive an unpinned wish-attributed day). `None` (the
|
|
# default every hand-built `AllocationInput` in the test suite gets
|
|
# unless it opts in) means "same as `existing_planned`" — see
|
|
# `_Ledger.__init__`. Read ONLY by `_Ledger._persisted_by_wish` (via
|
|
# `_persisted_dates_for_wish`), which needs to find a flexible wish's
|
|
# own prior placement to reuse it (`_reuse_already_funded_window`) even
|
|
# when that placement is currently hidden from `existing_planned` and
|
|
# even when it was funded under a parent the wish no longer resolves to
|
|
# (the wish was reassigned) — matched by `wish_id`, not by parent, for
|
|
# exactly that reason. Never used for resource netting or `_existing_lookup`.
|
|
all_existing_planned: list[PlannedLeaveDay] | None = None
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# §3.7 Output
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@dataclass(frozen=True)
|
|
class ProposedDay:
|
|
date: date
|
|
parent_personal_data_uuid: UUID
|
|
child_id: UUID | None
|
|
day_type: str # 'sjukpenning' | 'lagsta' | 'vacation'
|
|
is_dubbeldag: bool
|
|
wish_id: UUID
|
|
reason: str
|
|
|
|
|
|
@dataclass(frozen=True)
|
|
class ShortfallRemedy:
|
|
kind: str
|
|
message_key: str # i18n key for frontend — see MESSAGE_KEY_WINDOW_EXPLANATION note above
|
|
data: dict[str, object]
|
|
days_freed: int
|
|
|
|
|
|
@dataclass(frozen=True)
|
|
class SurplusAdvice:
|
|
"""§9.2 — the mirror of a `ShortfallRemedy`: a concrete, ranked suggestion
|
|
|
|
emitted when a parent is forecast to *forfeit* FP days at the age-4
|
|
boundary rather than run short. Mirrors `ShortfallRemedy`'s
|
|
(kind, message_key/data, day-count) shape; `data` mirrors
|
|
`PlanWarning.data` so the UI can key the suggestion to the (parent,
|
|
child) it concerns.
|
|
"""
|
|
|
|
kind: str # 'wish_more_leave' | 'shift_mix_to_fp' | 'front_load_early_years' | 'use_less_vacation'
|
|
message_key: str # i18n key for frontend
|
|
days_involved: int
|
|
data: dict[str, object]
|
|
|
|
|
|
@dataclass(frozen=True)
|
|
class Age4Projection:
|
|
"""§3.3 part 2 — plan-aware age-4 projection for one (parent, child) pair.
|
|
|
|
The same `(projected_left_at_b4, expiring_at_b4)` numbers that drive
|
|
`_age4_warnings`/`build_surplus_advice`, but exposed unconditionally on
|
|
every proposal (not just when there is a warning) so the UI can show
|
|
"if this plan were applied, here's what's left / would expire at the
|
|
4th birthday" *before* the plan is committed. Mirrors the shape of
|
|
`app.utils.tip_predicates.days_left_at_age_4_projection`'s DB-backed
|
|
sibling in `AnalyticsService`, scoped to what a pure `PlanProposal` can
|
|
know (no `days_used` from persisted history beyond what's already
|
|
folded into the pool).
|
|
"""
|
|
|
|
parent_personal_data_uuid: UUID
|
|
child_id: UUID
|
|
fourth_birthday: date
|
|
projected_left_at_b4: int
|
|
savable_after_b4: int # min(projected_left_at_b4, savable_cap_at_b4)
|
|
expiring_at_b4: int # max(projected_left_at_b4 - savable_cap_at_b4, 0) — LOST if not used
|
|
# The cap actually applied — 96 (single parent) or 48 (non-poolable,
|
|
# 2+ parents) — see `app.utils.tip_predicates.resolve_age4_savable_cap`.
|
|
savable_cap_at_b4: int
|
|
|
|
|
|
@dataclass(frozen=True)
|
|
class WindowOutcome:
|
|
wish_id: UUID
|
|
wish_name: str
|
|
# i18n provenance of `wish_name` (see `app.entities.leave_wish.LeaveWish
|
|
# .name_message_key`) — carried alongside the literal so the frontend can
|
|
# re-translate a preset-created wish's name into the UI's current locale,
|
|
# exactly like `resolveWishName` already does for the wish editor. `None`
|
|
# for a free-typed/user-renamed wish, or any row predating this field.
|
|
wish_name_message_key: str | None
|
|
year: int
|
|
start_date: date
|
|
end_date: date
|
|
weeks_wished: int
|
|
weeks_funded: float
|
|
shortfall_days: int
|
|
# What actually happened: 'solo' | 'parent_swap' | 'dubbeldag' |
|
|
# 'co_leave' | 'swap' | 'unplaced'. Never lies — a 'both'-mode window
|
|
# that degrades from dubbeldagar/co-leave down to a sequential swap for
|
|
# some (or all) of its dates reports 'swap' or 'co_leave' here, not the
|
|
# requested-but-unachieved 'dubbeldag'. See `requested_strategy`.
|
|
strategy: str
|
|
# What `parent_mode` (+ `wants_dubbeldag`) asked for, independent of
|
|
# whether it was achieved: 'solo' | 'parent_swap' | 'dubbeldag' |
|
|
# 'co_leave'. Compare against `strategy` to tell "as requested" from
|
|
# "fell back" — the frontend surfaces this distinction (e.g. a banner
|
|
# when a 'both' wish couldn't keep both parents on every date).
|
|
requested_strategy: str
|
|
# True when `strategy != requested_strategy` for a 'both'-mode window:
|
|
# the whole-window comparison already computed by `requested_strategy`
|
|
# vs. `strategy`) sees a date that couldn't be reached this run.
|
|
strategy_degraded: bool
|
|
# Whether dubbeldagar were a legally available option for this window
|
|
# (child inside the 15-month limit, quota left, both parents held FP) —
|
|
# regardless of whether `wish.wants_dubbeldag` was set. Only meaningful
|
|
# for a 'both'-mode window (always False otherwise). The frontend's
|
|
# period editor uses this to decide whether to SHOW the dubbeldag
|
|
# opt-in checkbox at all.
|
|
dubbeldagar_legally_available: bool
|
|
message_key: str # i18n key for frontend — always MESSAGE_KEY_WINDOW_EXPLANATION today
|
|
data: dict[str, object]
|
|
cost_breakdown: dict[str, int]
|
|
remedies: list[ShortfallRemedy]
|
|
|
|
|
|
@dataclass(frozen=True)
|
|
class PlanWarning:
|
|
kind: str # 'sgi_risk' | 'days_lost_at_age_4' | 'vacation_expiring'
|
|
message_key: str # i18n key for frontend
|
|
data: dict[str, object]
|
|
|
|
|
|
@dataclass(frozen=True)
|
|
class PlanBalances:
|
|
pools_after: dict[tuple[UUID, UUID], DayPool]
|
|
vacation_after: dict[tuple[UUID, int], VacationBudget]
|
|
|
|
|
|
@dataclass(frozen=True)
|
|
class PlanProposal:
|
|
days: list[ProposedDay]
|
|
outcomes: list[WindowOutcome]
|
|
balances_after: PlanBalances
|
|
warnings: list[PlanWarning]
|
|
# §9.2 — ranked, concrete suggestions for parents forecast to forfeit FP
|
|
# days at the age-4 boundary. Empty when there is no surplus to advise on.
|
|
surplus_advice: list[SurplusAdvice] = field(default_factory=list)
|
|
# §3.3 part 2 — plan-aware age-4 projection per (parent, child), always
|
|
# present (unlike `surplus_advice`, which is empty absent a surplus).
|
|
age4_projections: list[Age4Projection] = field(default_factory=list)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Pure helpers (§3.4) — free-day classification and red-day clusters
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
def _dates_in(start: date, end: date) -> list[date]:
|
|
n = (end - start).days + 1
|
|
return [start + timedelta(days=i) for i in range(n)]
|
|
|
|
|
|
def is_free_day(
|
|
d: date, holidays_map: dict[date, str], overrides: dict[date, bool] | None = None
|
|
) -> bool:
|
|
"""§3.4 + DayOverride: the single definition of "is this day free".
|
|
|
|
A workspace `DayOverride` (if any) wins outright: `overrides[d] = True`
|
|
means the workspace must work `d` despite the calendar (removes
|
|
weekend/holiday-free status, even for a Saturday); `overrides[d] = False`
|
|
means the workspace is off `d` despite the calendar. Absent an override,
|
|
falls back to: Saturday, or present in the holiday set (which already
|
|
includes every Sunday as "Söndag" — verified against
|
|
`holidays.Sweden(language="sv")`). Do NOT special-case Sunday additionally.
|
|
"""
|
|
if overrides and d in overrides:
|
|
return not overrides[d]
|
|
return d.weekday() == 5 or d in holidays_map
|
|
|
|
|
|
def _is_real_red_day(d: date, holidays_map: dict[date, str]) -> bool:
|
|
"""A holiday-set entry that is not *only* the generic "Söndag" marker.
|
|
|
|
Used to detect genuine red-day clusters (Jul, Påsk, ...) without
|
|
conflating them with bare weekends, per the §3.4 gotcha.
|
|
"""
|
|
name = holidays_map.get(d)
|
|
return name is not None and name != _SUNDAY_HOLIDAY_NAME
|
|
|
|
|
|
def _red_day_cluster_dates(
|
|
start: date,
|
|
end: date,
|
|
holidays_map: dict[date, str],
|
|
overrides: dict[date, bool] | None = None,
|
|
) -> set[date]:
|
|
"""Dates belonging to a maximal free-day run that contains >=1 real holiday.
|
|
|
|
A bare weekend (Sat+Sun with no real holiday) is a free-day run too, but is
|
|
NOT a "red-day cluster" — only a run touched by an actual public holiday
|
|
counts, matching §3.3's distinction between tier-2 (red-day klämdagar,
|
|
goal-independent) and the tier-3 weekend-wrap choice (goal-dependent).
|
|
"""
|
|
scan_start = start - timedelta(days=3)
|
|
scan_end = end + timedelta(days=3)
|
|
scan_dates = _dates_in(scan_start, scan_end)
|
|
|
|
clusters: list[list[date]] = []
|
|
current: list[date] = []
|
|
for d in scan_dates:
|
|
if is_free_day(d, holidays_map, overrides):
|
|
current.append(d)
|
|
else:
|
|
if current:
|
|
clusters.append(current)
|
|
current = []
|
|
if current:
|
|
clusters.append(current)
|
|
|
|
result: set[date] = set()
|
|
for cluster in clusters:
|
|
if any(_is_real_red_day(d, holidays_map) for d in cluster):
|
|
result.update(cluster)
|
|
return result
|
|
|
|
|
|
def _preschool_reserve_days(child: ChildFacts, today: date, horizon_end: date) -> int:
|
|
"""§9.3: days reserved off the top for preschool planning-day closures."""
|
|
if child.preschool_start_date is None or child.preschool_start_date > horizon_end:
|
|
return 0
|
|
start_year = max(child.preschool_start_date.year, today.year)
|
|
end_year = horizon_end.year
|
|
if end_year < start_year:
|
|
return 0
|
|
years = end_year - start_year + 1
|
|
return child.preschool_planning_days_per_year * years
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Window expansion (§3.2)
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@dataclass(frozen=True)
|
|
class _WishWindow:
|
|
wish: LeaveWish
|
|
anchor_year: int
|
|
start: date
|
|
end: date
|
|
|
|
|
|
def _candidate_years(
|
|
wish: LeaveWish, alloc_input: AllocationInput, children_by_id: dict[UUID, ChildFacts]
|
|
) -> list[int]:
|
|
"""Anchor years a wish (fixed or flexible) might occur in, before
|
|
|
|
`applies_to_year`/horizon filtering. Shared by `_expand_all_windows` and
|
|
`_expand_flexible_wish_years` (§10.2) — identical for both, since
|
|
`window_mode` only changes how a year's `window_for_year()` result is
|
|
*used* (exact placement vs. bounding range), never which years are
|
|
considered.
|
|
"""
|
|
if wish.recurrence == "once":
|
|
return [wish.first_year]
|
|
if wish.last_year is not None:
|
|
end_year = wish.last_year
|
|
elif wish.child_id is not None and wish.child_id in children_by_id:
|
|
end_year = children_by_id[wish.child_id].fourth_birthday.year
|
|
else:
|
|
end_year = alloc_input.horizon_end.year
|
|
return list(range(wish.first_year, end_year + 1))
|
|
|
|
|
|
def _expand_all_windows(alloc_input: AllocationInput) -> list[_WishWindow]:
|
|
"""§3.2 — expand every `window_mode == 'fixed'` wish into concrete windows.
|
|
|
|
Flexible wishes (§10.2) are expanded separately by
|
|
`_expand_flexible_wish_years`, since their `window_for_year()` result is a
|
|
*bounding range* to search inside, not the final placement.
|
|
"""
|
|
children_by_id = {c.id: c for c in alloc_input.children}
|
|
windows: list[_WishWindow] = []
|
|
|
|
for wish in alloc_input.wishes:
|
|
if wish.window_mode != "fixed":
|
|
continue
|
|
for year in _candidate_years(wish, alloc_input, children_by_id):
|
|
if not wish.applies_to_year(year):
|
|
continue
|
|
start, end = wish.window_for_year(year)
|
|
if end < alloc_input.today or start > alloc_input.horizon_end:
|
|
continue
|
|
clipped_start = max(start, alloc_input.today)
|
|
clipped_end = min(end, alloc_input.horizon_end)
|
|
if clipped_start > clipped_end:
|
|
continue
|
|
windows.append(
|
|
_WishWindow(wish=wish, anchor_year=year, start=clipped_start, end=clipped_end)
|
|
)
|
|
|
|
return windows
|
|
|
|
|
|
@dataclass(frozen=True)
|
|
class _FlexibleWishYear:
|
|
"""One anchor-year occurrence of a `window_mode == 'flexible'` wish,
|
|
|
|
resolved down to its (horizon-clipped) bounding range — the range
|
|
`Allocator.propose()`'s pass 2 (§10.2) searches inside for the best-
|
|
costing placement, not the final window.
|
|
"""
|
|
|
|
wish: LeaveWish
|
|
anchor_year: int
|
|
bound_start: date
|
|
bound_end: date
|
|
|
|
|
|
def _expand_flexible_wish_years(alloc_input: AllocationInput) -> list[_FlexibleWishYear]:
|
|
"""§10.2 — the flexible-wish counterpart to `_expand_all_windows`.
|
|
|
|
Reuses `applies_to_year`, the horizon clip and the year-wrap rule
|
|
unchanged; the only difference is that `window_for_year()`'s result is
|
|
treated as a bound to search inside (§10.2 step 1), not the final window.
|
|
"""
|
|
children_by_id = {c.id: c for c in alloc_input.children}
|
|
wish_years: list[_FlexibleWishYear] = []
|
|
|
|
for wish in alloc_input.wishes:
|
|
if wish.window_mode != "flexible":
|
|
continue
|
|
for year in _candidate_years(wish, alloc_input, children_by_id):
|
|
if not wish.applies_to_year(year):
|
|
continue
|
|
bound_start, bound_end = wish.window_for_year(year)
|
|
if bound_end < alloc_input.today or bound_start > alloc_input.horizon_end:
|
|
continue
|
|
clipped_start = max(bound_start, alloc_input.today)
|
|
clipped_end = min(bound_end, alloc_input.horizon_end)
|
|
if clipped_start > clipped_end:
|
|
continue
|
|
wish_years.append(
|
|
_FlexibleWishYear(
|
|
wish=wish, anchor_year=year, bound_start=clipped_start, bound_end=clipped_end
|
|
)
|
|
)
|
|
|
|
return wish_years
|
|
|
|
|
|
def _candidate_windows(
|
|
bound_start: date, bound_end: date, length_days: int
|
|
) -> list[tuple[date, date]]:
|
|
"""§10.2 step 5 — every full-length `(start, end)` candidate (inclusive)
|
|
|
|
that fits entirely inside `[bound_start, bound_end]`, sliding one day at
|
|
a time (nothing requires a candidate to start on a Monday).
|
|
"""
|
|
candidates: list[tuple[date, date]] = []
|
|
last_start = bound_end - timedelta(days=length_days - 1)
|
|
s = bound_start
|
|
while s <= last_start:
|
|
candidates.append((s, s + timedelta(days=length_days - 1)))
|
|
s += timedelta(days=1)
|
|
return candidates
|
|
|
|
|
|
def _candidate_cost(
|
|
start: date, end: date, holidays_map: dict[date, str], overrides: dict[date, bool]
|
|
) -> int:
|
|
"""§10.2 step 6 — calendar-only cost: the count of spendable days in
|
|
|
|
`[start, end]`. Deliberately does not run tier-3/goal logic or simulate
|
|
which resource would be spent — see the spec's proof that this is exactly
|
|
"fewest paid days" for every goal and `parent_mode`.
|
|
"""
|
|
return sum(1 for d in _dates_in(start, end) if not is_free_day(d, holidays_map, overrides))
|
|
|
|
|
|
def _split_dates_by_spendable_cost(
|
|
dates: list[date],
|
|
holidays_map: dict[date, str],
|
|
overrides: dict[date, bool],
|
|
) -> tuple[list[date], list[date]]:
|
|
"""§fix (funding-fairness) — split a contiguous run of dates into two
|
|
|
|
contiguous halves balanced by *spendable* (non-free) day count rather
|
|
than raw calendar-day count. Free days (weekends, red days) cost neither
|
|
parent anything, so a calendar-midpoint split can hand one parent a
|
|
half that is mostly free days while the other gets nearly the whole
|
|
cost — an uneven split in the one dimension that actually matters.
|
|
Keeps the previous tie-break convention: the first half gets the extra
|
|
spendable day when the count is odd. Falls back to a calendar-midpoint
|
|
split when the range has no spendable days at all (nothing to balance,
|
|
and `target == 0` would otherwise degenerate to an all-or-nothing split).
|
|
"""
|
|
spendable_total = sum(1 for d in dates if not is_free_day(d, holidays_map, overrides))
|
|
if spendable_total == 0:
|
|
mid_index = (len(dates) + 1) // 2
|
|
return dates[:mid_index], dates[mid_index:]
|
|
|
|
target = (spendable_total + 1) // 2
|
|
count = 0
|
|
split_at = len(dates)
|
|
for i, d in enumerate(dates):
|
|
if not is_free_day(d, holidays_map, overrides):
|
|
count += 1
|
|
if count >= target:
|
|
split_at = i + 1
|
|
break
|
|
return dates[:split_at], dates[split_at:]
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Mutable working ledger — internal to a single `Allocator.propose()` call.
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@dataclass
|
|
class _MutablePool:
|
|
sjukpenning_left: int
|
|
lagsta_left: int
|
|
dubbeldagar_left: int
|
|
clamped_at_b4: bool = False
|
|
|
|
|
|
@dataclass
|
|
class _MutableVacation:
|
|
total_days: int
|
|
saved_days_in: int
|
|
already_used: int
|
|
is_assumed: bool = False
|
|
|
|
@property
|
|
def available(self) -> int:
|
|
return self.total_days + self.saved_days_in - self.already_used
|
|
|
|
|
|
@dataclass(frozen=True)
|
|
class _Responsible:
|
|
mode: str # 'solo' | 'swap' | 'dubbeldag'
|
|
parents: list[ParentFacts]
|
|
|
|
|
|
_EMPTY_COST: dict[str, int] = {"free": 0, "vacation": 0, "sjukpenning": 0, "lagsta": 0}
|
|
|
|
|
|
def _new_cost() -> dict[str, int]:
|
|
return dict(_EMPTY_COST)
|
|
|
|
|
|
def _shortfall_and_weeks_funded(
|
|
mode: str,
|
|
all_dates: list[date],
|
|
days: list["ProposedDay"],
|
|
cost: dict[str, int],
|
|
) -> tuple[int, float]:
|
|
"""Shared by `_Ledger.fund_window` (real) and `_Ledger._candidate_shortfall`
|
|
|
|
(§Decision C's budget-aware probe) so the two can never silently
|
|
disagree on what "funded" means for the same (mode, dates, days, cost).
|
|
|
|
'dubbeldag' mode (both parents, §Decision A) spends TWO resource units
|
|
per co-funded date (one per parent — dubbeldagar and co-leave both emit
|
|
2 `ProposedDay`s per date, see `_fund_both`), so the cost-dict-sum math
|
|
below (built for exactly one resource per calendar date) would
|
|
double-count every co-funded date. Counted by DATE instead there: a
|
|
date is "funded" once at least one parent has a non-free `ProposedDay`
|
|
for it.
|
|
|
|
Every other mode ('solo' | 'swap') counts via `cost` rather than
|
|
`days`, deliberately: `_fund_solo` skips emitting a `ProposedDay`
|
|
entirely for a date `_existing_lookup` already has (a previously
|
|
persisted/applied day — see its docstring), but still increments
|
|
`cost[existing_type]` for it. A `days`-based count would silently
|
|
treat every already-applied date as unfunded, which is exactly wrong
|
|
for `_candidate_shortfall`'s purpose: ranking a candidate that reuses
|
|
already-persisted dates (§fix, decision B) must see those dates as
|
|
funded, not missing.
|
|
"""
|
|
if mode == "dubbeldag":
|
|
funded_dates = {d.date for d in days if d.day_type != "free"}
|
|
free_dates = {d.date for d in days if d.day_type == "free"}
|
|
spendable_total = len(all_dates) - len(free_dates)
|
|
funded_spendable = len(funded_dates)
|
|
shortfall_days = spendable_total - funded_spendable
|
|
weeks_funded = round((len(free_dates) + len(funded_dates)) / 7, 2)
|
|
else:
|
|
funded_home_days = cost["free"] + cost["vacation"] + cost["sjukpenning"] + cost["lagsta"]
|
|
spendable_total = len(all_dates) - cost["free"]
|
|
funded_spendable = funded_home_days - cost["free"]
|
|
shortfall_days = spendable_total - funded_spendable
|
|
weeks_funded = round(funded_home_days / 7, 2)
|
|
return shortfall_days, weeks_funded
|
|
|
|
|
|
class _Ledger:
|
|
"""Mutable bookkeeping for a single, pure `Allocator.propose()` run."""
|
|
|
|
def __init__(self, alloc_input: AllocationInput) -> None:
|
|
self._input = alloc_input
|
|
self._children_by_id = {c.id: c for c in alloc_input.children}
|
|
self._parents_by_id = {p.uuid: p for p in alloc_input.parents}
|
|
|
|
self._pools: dict[tuple[UUID, UUID], _MutablePool] = {
|
|
key: _MutablePool(pool.sjukpenning_left, pool.lagsta_left, pool.dubbeldagar_left)
|
|
for key, pool in alloc_input.pools.items()
|
|
}
|
|
self._vacation: dict[tuple[UUID, int], _MutableVacation] = {
|
|
key: _MutableVacation(vb.total_days, vb.saved_days_in, vb.already_used, vb.is_assumed)
|
|
for key, vb in alloc_input.vacation.items()
|
|
}
|
|
self._dubbeldagar_used: dict[UUID, int] = {}
|
|
self._preschool_reserved: dict[UUID, int] = {}
|
|
|
|
self._existing_lookup: dict[tuple[UUID, UUID | None, date], str] = {
|
|
(p.parent_personal_data_uuid, p.child_id, p.date): p.day_type
|
|
for p in alloc_input.existing_planned
|
|
}
|
|
# §eviction-preview fix — the KEYS of `_existing_lookup` as of THIS
|
|
# point only, before `record_days()` (called after every
|
|
# `fund_window()`, see below) starts folding in this run's own
|
|
# freshly-computed placements. `_fund_solo`'s cost-crediting (below)
|
|
# consults this to tell "this date is already a genuinely pre-
|
|
# existing/pinned commitment -- count it toward THIS window's
|
|
# funded total" from "a DIFFERENT, earlier-processed wish just
|
|
# claimed this date THIS SAME RUN" -- the latter must never be
|
|
# credited to a later-processed wish's own `shortfall_days`
|
|
# (crediting it was the actual bug: a lower-priority wish's window
|
|
# silently reported `shortfall_days == 0` even though every one of
|
|
# its dates had actually gone to a different wish, which meant
|
|
# `_genuinely_evicted_rows` could never detect the eviction its own
|
|
# persisted rows were about to suffer).
|
|
self._pre_run_occupied: frozenset[tuple[UUID, UUID | None, date]] = frozenset(
|
|
self._existing_lookup
|
|
)
|
|
# §fix (double-booking on flexible re-propose; extended for §fix
|
|
# parent-reassignment, decision B) — an immutable snapshot of ONLY
|
|
# truly-persisted planned days, taken before `record_days()` ever
|
|
# folds in this run's freshly-computed (not-yet-applied) windows.
|
|
# `_existing_lookup` above is mutated by `record_days()` as pass 1/2
|
|
# proceed, so a fixed wish's just-computed placement would otherwise
|
|
# be indistinguishable from a flexible wish's own prior occurrence
|
|
# (see `TestFixedWishNeverDisplacedByFlexible`, which must still see
|
|
# an empty view here).
|
|
#
|
|
# Sourced from `all_existing_planned` when the caller provided one
|
|
# (production always does via `AllocationInputLoader`) — the FULL,
|
|
# never-`only_pinned_existing`-filtered snapshot — so this index
|
|
# still finds a wish's prior placement even when `existing_planned`
|
|
# itself has been narrowed down for a `sync_plan` re-plan. Falls
|
|
# back to `existing_planned` when `all_existing_planned` is `None`
|
|
# (every hand-built `AllocationInput` in the test suite that doesn't
|
|
# opt in) so the two stay equivalent absent that narrowing.
|
|
#
|
|
# Grouped by (wish_id, child_id) rather than by parent: matching by
|
|
# parent would silently stop finding a wish's own prior window the
|
|
# moment the wish is reassigned to a different parent — exactly the
|
|
# dates-move-on-reassignment regression this index exists to
|
|
# prevent. `_persisted_dates_for_wish` is the only reader.
|
|
persisted_source = (
|
|
alloc_input.all_existing_planned
|
|
if alloc_input.all_existing_planned is not None
|
|
else alloc_input.existing_planned
|
|
)
|
|
self._persisted_by_wish: dict[tuple[UUID, UUID | None], set[date]] = {}
|
|
for p in persisted_source:
|
|
if p.wish_id is None:
|
|
continue
|
|
key = (p.wish_id, p.child_id)
|
|
self._persisted_by_wish.setdefault(key, set()).add(p.date)
|
|
|
|
self._reserve_pinned_days()
|
|
self._reserve_preschool_days()
|
|
|
|
# -- setup ----------------------------------------------------------
|
|
|
|
def _reserve_pinned_days(self) -> None:
|
|
"""§Task 4 — debit a pinned day's cost off the top, before any
|
|
|
|
window is funded, exactly like `_reserve_preschool_days` below
|
|
reserves preschool closure days. A pinned `planned_leave_day` is a
|
|
hard, already-spent fact regardless of which mode loaded this input
|
|
(see `AllocationInputLoader.load`'s `only_pinned_existing`, which
|
|
never nets a pinned row out of the pools/vacation budgets itself —
|
|
this is the one place that happens). `_existing_lookup`/
|
|
`_persisted_lookup` (built above from the same `existing_planned`)
|
|
separately keep the Allocator from ever reassigning a pinned day's
|
|
type or parent — this method only handles the resource debit.
|
|
"""
|
|
for p in self._input.existing_planned:
|
|
if not p.is_pinned:
|
|
continue
|
|
if p.day_type == "vacation":
|
|
self._spend_vacation(p.parent_personal_data_uuid, p.date)
|
|
continue
|
|
pool = self._pools.get((p.parent_personal_data_uuid, p.child_id))
|
|
if pool is None:
|
|
continue
|
|
if p.day_type == "sjukpenning" and pool.sjukpenning_left > 0:
|
|
pool.sjukpenning_left -= 1
|
|
elif p.day_type == "lagsta" and pool.lagsta_left > 0:
|
|
pool.lagsta_left -= 1
|
|
|
|
def _reserve_preschool_days(self) -> None:
|
|
for child in self._input.children:
|
|
reserve = _preschool_reserve_days(child, self._input.today, self._input.horizon_end)
|
|
if reserve <= 0:
|
|
continue
|
|
self._preschool_reserved[child.id] = reserve
|
|
parent_keys = sorted(
|
|
(key for key in self._pools if key[1] == child.id),
|
|
key=lambda k: str(k[0]),
|
|
)
|
|
if not parent_keys:
|
|
continue
|
|
share, remainder = divmod(reserve, len(parent_keys))
|
|
for i, key in enumerate(parent_keys):
|
|
take = share + (1 if i < remainder else 0)
|
|
pool = self._pools[key]
|
|
from_sjuk = min(take, pool.sjukpenning_left)
|
|
pool.sjukpenning_left -= from_sjuk
|
|
take -= from_sjuk
|
|
from_lagsta = min(take, pool.lagsta_left)
|
|
pool.lagsta_left -= from_lagsta
|
|
|
|
# -- parent resolution (§3.3, parent_swap) ---------------------------
|
|
|
|
def _resolve_parents(self, wish: LeaveWish) -> _Responsible:
|
|
# Couple wish-assignment (swap/dubbeldag) kicks in purely on parent
|
|
# count — whether the workspace has a second parent at all. There is
|
|
# no separate "planning mode" flag any more: adding a partner to the
|
|
# workspace IS the signal.
|
|
parents = self._input.parents
|
|
if len(parents) < 2:
|
|
return _Responsible(mode="solo", parents=[self._pick_solo_parent(wish, parents)])
|
|
|
|
if wish.parent_mode == "specific":
|
|
specific = next(
|
|
(p for p in parents if p.uuid == wish.parent_personal_data_uuid), parents[0]
|
|
)
|
|
return _Responsible(mode="solo", parents=[specific])
|
|
|
|
if wish.parent_mode == "both":
|
|
return _Responsible(mode="dubbeldag", parents=list(parents[:2]))
|
|
|
|
# 'either'
|
|
if wish.target_weeks >= 2:
|
|
return _Responsible(mode="swap", parents=list(parents[:2]))
|
|
return _Responsible(mode="solo", parents=[parents[0]])
|
|
|
|
@staticmethod
|
|
def _pick_solo_parent(wish: LeaveWish, parents: list[ParentFacts]) -> ParentFacts:
|
|
if wish.parent_mode == "specific":
|
|
for p in parents:
|
|
if p.uuid == wish.parent_personal_data_uuid:
|
|
return p
|
|
return parents[0]
|
|
|
|
# -- child resolution (root cause of the FP-fallback bug) --------------
|
|
|
|
def _resolve_wish_child(self, wish: LeaveWish) -> ChildFacts | None:
|
|
"""Which child's FP pool this wish draws from, if any.
|
|
|
|
An explicit `wish.child_id` always wins (and, per prior behaviour, a
|
|
stale/unknown id resolves to "no pool" rather than guessing).
|
|
|
|
A **family-wide** wish (`child_id is None`) used to mean "no FP pool
|
|
to draw from, vacation or nothing" unconditionally. That was the bug:
|
|
for the overwhelmingly common case of a workspace with exactly one
|
|
child, "family-wide" is not actually ambiguous — there is only one
|
|
pool it could mean — yet the allocator refused to touch it and
|
|
reported a shortfall while the child's föräldrapenning pool sat
|
|
completely full (PLANNING_ENGINE_SPEC.md §3.5: FP is a legitimate
|
|
funding source for interior days under every planning goal).
|
|
|
|
With 0 or >=2 children a family-wide wish stays genuinely ambiguous
|
|
(which child's pool would even apply is a product decision, not
|
|
implemented here) — the historical vacation-only behaviour is
|
|
preserved for that case.
|
|
"""
|
|
if wish.child_id is not None:
|
|
return self._children_by_id.get(wish.child_id)
|
|
if len(self._input.children) == 1:
|
|
return self._input.children[0]
|
|
return None
|
|
|
|
# -- resource spending ------------------------------------------------
|
|
|
|
def _spend_vacation(self, parent_uuid: UUID, d: date) -> bool:
|
|
key = (parent_uuid, d.year)
|
|
budget = self._vacation.get(key)
|
|
if budget is None or budget.available <= 0:
|
|
return False
|
|
budget.already_used += 1
|
|
return True
|
|
|
|
def _spend_fp(self, pool_key: tuple[UUID, UUID], prefer: str) -> str | None:
|
|
pool = self._pools.get(pool_key)
|
|
if pool is None:
|
|
return None
|
|
order = ["lagsta", "sjukpenning"] if prefer == "lagsta" else ["sjukpenning", "lagsta"]
|
|
for tier in order:
|
|
if tier == "sjukpenning" and pool.sjukpenning_left > 0:
|
|
pool.sjukpenning_left -= 1
|
|
return "sjukpenning"
|
|
if tier == "lagsta" and pool.lagsta_left > 0:
|
|
pool.lagsta_left -= 1
|
|
return "lagsta"
|
|
return None
|
|
|
|
@staticmethod
|
|
def _peek_fp_tier(pool: _MutablePool) -> str | None:
|
|
if pool.sjukpenning_left > 0:
|
|
return "sjukpenning"
|
|
if pool.lagsta_left > 0:
|
|
return "lagsta"
|
|
return None
|
|
|
|
@staticmethod
|
|
def _commit_fp_tier(pool: _MutablePool, tier: str) -> None:
|
|
if tier == "sjukpenning":
|
|
pool.sjukpenning_left -= 1
|
|
else:
|
|
pool.lagsta_left -= 1
|
|
|
|
def _try_co_leave_pair(
|
|
self,
|
|
fp_parent: ParentFacts,
|
|
fp_pool: _MutablePool,
|
|
vacation_parent: ParentFacts,
|
|
d: date,
|
|
) -> tuple[ParentFacts, str, ParentFacts] | None:
|
|
"""§fix (long-chunk co-leave, 2026-09-19) — peek-then-commit a single
|
|
|
|
co-leave pairing (one parent on FP, the other on vacation) for `d`.
|
|
Returns `None` (spending NEITHER side) unless both can actually pay
|
|
— used by `_fund_both` to try its chunk-designated pairing first
|
|
and the swapped pairing as a same-date fallback.
|
|
"""
|
|
fp_tier = self._peek_fp_tier(fp_pool)
|
|
vacation_budget = self._vacation.get((vacation_parent.uuid, d.year))
|
|
vacation_can_pay = vacation_budget is not None and vacation_budget.available > 0
|
|
if fp_tier is None or not vacation_can_pay:
|
|
return None
|
|
self._commit_fp_tier(fp_pool, fp_tier)
|
|
self._spend_vacation(vacation_parent.uuid, d)
|
|
return fp_parent, fp_tier, vacation_parent
|
|
|
|
def _maybe_clamp_age4(self, pool_key: tuple[UUID, UUID] | None, window_start: date) -> None:
|
|
"""§9.1: from the 4th birthday onward, the FP pool is hard-capped at
|
|
min(remaining, `self._input.age4_savable_cap`). Applied once per
|
|
pool, the first time (in
|
|
priority-then-chronological processing order) a window starting on or
|
|
after the child's 4th birthday is funded from it.
|
|
|
|
Known limitation: because windows are funded in (priority,
|
|
chronological) order rather than pure chronological order, a
|
|
lower-priority window that starts *before* B4 but is processed *after*
|
|
a higher-priority window starting *after* B4 could see the clamp
|
|
applied earlier than strict chronology would. This does not affect any
|
|
of the §5 test-matrix scenarios and is documented rather than solved
|
|
with a full chronological two-pass scheduler.
|
|
"""
|
|
if pool_key is None:
|
|
return
|
|
child = self._children_by_id.get(pool_key[1])
|
|
if child is None or window_start < child.fourth_birthday:
|
|
return
|
|
pool = self._pools.get(pool_key)
|
|
if pool is None or pool.clamped_at_b4:
|
|
return
|
|
remaining = pool.sjukpenning_left + pool.lagsta_left
|
|
capped = min(remaining, self._input.age4_savable_cap)
|
|
excess = remaining - capped
|
|
if excess > 0:
|
|
cut_lagsta = min(excess, pool.lagsta_left)
|
|
pool.lagsta_left -= cut_lagsta
|
|
excess -= cut_lagsta
|
|
pool.sjukpenning_left -= excess
|
|
pool.clamped_at_b4 = True
|
|
|
|
# -- tier-3 goal-dependent interior resolution (§3.3) ------------------
|
|
|
|
def _assign_tier3(
|
|
self,
|
|
wish: LeaveWish,
|
|
d: date,
|
|
parent: ParentFacts,
|
|
child: ChildFacts | None,
|
|
pool_key: tuple[UUID, UUID] | None,
|
|
) -> tuple[str, str] | None:
|
|
"""§3.3 tier-3 interior resolution — the single policy: maximise the
|
|
value extracted from FP + vacation days combined. `salary_type` still
|
|
branches (not a goal): a monthly-salaried parent loses nothing by
|
|
spending a vacation day, so vacation goes first and FP (sjukpenning
|
|
preferred) fills the rest; an hourly parent would lose pay to a
|
|
vacation day, so FP goes first and vacation only backstops what FP
|
|
can't cover.
|
|
"""
|
|
if child is None or pool_key is None:
|
|
# No resolvable child (genuinely ambiguous family-wide wish, or a
|
|
# stale child_id) -> no FP pool to draw from. Vacation or nothing.
|
|
if self._spend_vacation(parent.uuid, d):
|
|
return "vacation", REASON_VACATION_WRAP_WEEKEND
|
|
return None
|
|
|
|
if parent.salary_type == "monthly":
|
|
if self._spend_vacation(parent.uuid, d):
|
|
return "vacation", REASON_VACATION_WRAP_WEEKEND
|
|
fp = self._spend_fp(pool_key, prefer="sjukpenning")
|
|
if fp:
|
|
return fp, (REASON_FP_INTERIOR if fp == "sjukpenning" else REASON_FP_LAGSTA_STRETCH)
|
|
return None
|
|
|
|
fp = self._spend_fp(pool_key, prefer="sjukpenning")
|
|
if fp:
|
|
return fp, (REASON_FP_INTERIOR if fp == "sjukpenning" else REASON_FP_LAGSTA_STRETCH)
|
|
if self._spend_vacation(parent.uuid, d):
|
|
return "vacation", REASON_VACATION_WRAP_WEEKEND
|
|
return None
|
|
|
|
# -- per-parent day resolution (tiers 1-3) -----------------------------
|
|
|
|
def _fund_solo(
|
|
self,
|
|
wish: LeaveWish,
|
|
dates: list[date],
|
|
red_cluster: set[date],
|
|
parent: ParentFacts,
|
|
free_reason_override: str | None,
|
|
) -> tuple[list[ProposedDay], dict[str, int]]:
|
|
days: list[ProposedDay] = []
|
|
cost = _new_cost()
|
|
child = self._resolve_wish_child(wish)
|
|
child_id = child.id if child is not None else None
|
|
pool_key = (parent.uuid, child_id) if child_id is not None else None
|
|
|
|
for d in dates:
|
|
key = (parent.uuid, child_id, d)
|
|
existing_type = self._existing_lookup.get(key)
|
|
if existing_type is not None:
|
|
# §eviction-preview fix — only a genuinely pre-existing/
|
|
# pinned commitment (present in `_existing_lookup` BEFORE
|
|
# this run's own `record_days()` calls started, see
|
|
# `_pre_run_occupied`) counts toward THIS window's funded
|
|
# total. A date claimed by a DIFFERENT, earlier-processed
|
|
# wish this same run is simply unavailable to this one --
|
|
# falling through unfunded (never `continue`d past without
|
|
# emitting a day) is what lets `shortfall_days` correctly
|
|
# reflect the loss instead of silently masking it.
|
|
if key in self._pre_run_occupied:
|
|
cost[existing_type] = cost.get(existing_type, 0) + 1
|
|
continue
|
|
|
|
if is_free_day(d, self._input.holidays, self._input.day_overrides):
|
|
fp_on_red_day = (
|
|
self._spend_fp(pool_key, prefer="sjukpenning")
|
|
if self._input.take_pl_on_red_days and pool_key is not None
|
|
else None
|
|
)
|
|
if fp_on_red_day is not None:
|
|
cost[fp_on_red_day] += 1
|
|
days.append(
|
|
ProposedDay(
|
|
d,
|
|
parent.uuid,
|
|
child_id,
|
|
fp_on_red_day,
|
|
False,
|
|
wish.id,
|
|
REASON_FP_RED_DAY,
|
|
)
|
|
)
|
|
continue
|
|
cost["free"] += 1
|
|
reason = free_reason_override or (
|
|
REASON_FREE_RED_DAY
|
|
if _is_real_red_day(d, self._input.holidays)
|
|
else REASON_FREE_WEEKEND
|
|
)
|
|
days.append(ProposedDay(d, parent.uuid, child_id, "free", False, wish.id, reason))
|
|
continue
|
|
|
|
resolved: tuple[str, str] | None = None
|
|
if (
|
|
d in red_cluster
|
|
or (d - timedelta(days=1)) in red_cluster
|
|
or (d + timedelta(days=1)) in red_cluster
|
|
):
|
|
# Tier 2 — dominant play: klämdag inside a red-day cluster.
|
|
# Fires regardless of goal or salary_type (§3.3).
|
|
if self._spend_vacation(parent.uuid, d):
|
|
resolved = ("vacation", REASON_VACATION_WRAP_RED_DAY)
|
|
|
|
if resolved is None:
|
|
resolved = self._assign_tier3(wish, d, parent, child, pool_key)
|
|
|
|
if resolved is None:
|
|
continue # unfunded — reflected in the window's shortfall_days
|
|
|
|
day_type, reason = resolved
|
|
cost[day_type] += 1
|
|
days.append(ProposedDay(d, parent.uuid, child_id, day_type, False, wish.id, reason))
|
|
|
|
return days, cost
|
|
|
|
def _fund_swap(
|
|
self,
|
|
wish: LeaveWish,
|
|
w: _WishWindow,
|
|
dates: list[date],
|
|
red_cluster: set[date],
|
|
responsible: _Responsible,
|
|
) -> tuple[list[ProposedDay], dict[str, int]]:
|
|
if not dates:
|
|
return [], _new_cost()
|
|
|
|
# §fix (funding-fairness) — split by *spendable* days, not calendar
|
|
# days: a free (weekend/red) day costs neither parent anything, so a
|
|
# raw date-count split can silently hand one parent a costlier half
|
|
# than the other even before either parent's own budget is checked.
|
|
first_half, second_half = _split_dates_by_spendable_cost(
|
|
dates, self._input.holidays, self._input.day_overrides
|
|
)
|
|
parent_a, parent_b = responsible.parents[0], responsible.parents[1]
|
|
|
|
resolved_child = self._resolve_wish_child(wish)
|
|
if resolved_child is not None:
|
|
self._maybe_clamp_age4((parent_a.uuid, resolved_child.id), w.start)
|
|
self._maybe_clamp_age4((parent_b.uuid, resolved_child.id), w.start)
|
|
|
|
days_a, cost_a = self._fund_solo(
|
|
wish, first_half, red_cluster, parent_a, REASON_SWAP_FIRST_HALF
|
|
)
|
|
days_b, cost_b = self._fund_solo(
|
|
wish, second_half, red_cluster, parent_b, REASON_SWAP_SECOND_HALF
|
|
)
|
|
|
|
# §fix (funding-fairness) — a parent's own half can still leave
|
|
# spendable days unfunded when THEIR resources (typically a per-year
|
|
# vacation budget) run out, even though the partner's half was fully
|
|
# funded with resources to spare. `_fund_solo` never raises for an
|
|
# unfunded day — it just omits it from the returned list (see its
|
|
# trailing `continue`) — so the gap is exactly "date in the half but
|
|
# missing from the funded-dates set". Rather than report those days
|
|
# as a shortfall while the partner's budget sits unused, hand each
|
|
# half's unfunded leftover to the OTHER parent, who has already
|
|
# picked up everything their own tier-3 resolution could reach and so
|
|
# cannot conflict with what's being offered. A leftover date is never
|
|
# a free/weekend/red day (those are always funded on the first pass,
|
|
# unconditionally, before tier-2/tier-3 even run) so the
|
|
# `free_reason_override` passed here is inert — kept `None` rather
|
|
# than a half-label that could never actually be stamped on anything.
|
|
# One hand-off per direction is enough: each parent's resources are
|
|
# independent per (parent, child)/(parent, year) key, so a second
|
|
# round could not free up anything the first round didn't already see.
|
|
funded_a_dates = {day.date for day in days_a}
|
|
funded_b_dates = {day.date for day in days_b}
|
|
leftover_from_a = [d for d in first_half if d not in funded_a_dates]
|
|
leftover_from_b = [d for d in second_half if d not in funded_b_dates]
|
|
|
|
if leftover_from_b:
|
|
extra_a, extra_cost_a = self._fund_solo(
|
|
wish, leftover_from_b, red_cluster, parent_a, None
|
|
)
|
|
days_a = days_a + extra_a
|
|
for k in cost_a:
|
|
cost_a[k] += extra_cost_a[k]
|
|
if leftover_from_a:
|
|
extra_b, extra_cost_b = self._fund_solo(
|
|
wish, leftover_from_a, red_cluster, parent_b, None
|
|
)
|
|
days_b = days_b + extra_b
|
|
for k in cost_b:
|
|
cost_b[k] += extra_cost_b[k]
|
|
|
|
merged_cost = {k: cost_a[k] + cost_b[k] for k in cost_a}
|
|
all_days = days_a + days_b
|
|
all_days.sort(key=lambda p: p.date)
|
|
return all_days, merged_cost
|
|
|
|
def _fund_both(
|
|
self,
|
|
wish: LeaveWish,
|
|
w: _WishWindow,
|
|
dates: list[date],
|
|
red_cluster: set[date],
|
|
responsible: _Responsible,
|
|
) -> tuple[list[ProposedDay], dict[str, int], dict[str, int | bool]]:
|
|
"""§Decision A (co-leave, 2026-09-18 correction) — both parents off
|
|
|
|
on the SAME dates. Three tiers, tried in order for every date:
|
|
|
|
1. Dubbeldagar — ONLY when `wish.wants_dubbeldag` is set (opt-in,
|
|
never automatic — see `LeaveWish.wants_dubbeldag`) AND the date
|
|
is inside the child's 15-month window AND quota remains AND
|
|
both parents currently hold FP (peeked, then committed
|
|
together — never a lone half-spend).
|
|
2. Co-leave (PL + vacation) — the default for every other date:
|
|
which parent PAYS with FP is decided per CHUNK, not per day —
|
|
§fix (long-chunk co-leave, 2026-09-19). The window's dates are
|
|
split into two contiguous halves with `_split_dates_by_
|
|
spendable_cost` (the same balanced-by-cost split `_fund_swap`
|
|
uses); `responsible.parents[0]` is the designated FP-payer for
|
|
the first half, `responsible.parents[1]` for the second — so a
|
|
long window reads as "parent A on PL while parent B is on
|
|
vacation for ~half the window, then they switch", not a
|
|
daily-alternating patchwork. Both parents are still off on
|
|
EVERY date regardless of chunk. If the chunk's designated
|
|
FP-payer has no FP left for a date (or their partner has no
|
|
vacation left), the roles are tried swapped for just that date
|
|
— since the exhausted resource stays exhausted, this sticks
|
|
for the rest of the chunk rather than flip-flopping day to
|
|
day. Each attempted pairing is peeked-then-committed together:
|
|
if either side can't pay, NEITHER is spent for that date.
|
|
3. Swap (last resort) — a date co-leave genuinely cannot fund
|
|
(the higher-FP parent has none left, or the other parent has
|
|
no vacation left) is handed to `_fund_swap` together with the
|
|
rest of that leftover run, which splits it into sequential
|
|
single-parent halves — surrendering the "both off" property
|
|
for just that date, not the whole window.
|
|
|
|
Returns a third element (`meta`) — dubbeldag/co_leave/swap DATE
|
|
counts (not day-instances: one per calendar date, however many
|
|
`ProposedDay`s it produced) plus whether dubbeldagar were legally
|
|
available at all — that `fund_window` uses to derive
|
|
`strategy`/`requested_strategy`/`strategy_degraded`/
|
|
`dubbeldagar_legally_available`.
|
|
"""
|
|
parent_a, parent_b = responsible.parents[0], responsible.parents[1]
|
|
child = self._resolve_wish_child(wish)
|
|
|
|
if child is None:
|
|
days, cost = self._fund_swap(wish, w, dates, red_cluster, responsible)
|
|
meta: dict[str, int | bool] = {
|
|
"dubbeldag_dates": 0,
|
|
"co_leave_dates": 0,
|
|
"swap_dates": len({d.date for d in days}),
|
|
"dubbeldagar_legally_available": False,
|
|
}
|
|
return days, cost, meta
|
|
|
|
self._maybe_clamp_age4((parent_a.uuid, child.id), w.start)
|
|
self._maybe_clamp_age4((parent_b.uuid, child.id), w.start)
|
|
|
|
pool_a = self._pools.get((parent_a.uuid, child.id))
|
|
pool_b = self._pools.get((parent_b.uuid, child.id))
|
|
|
|
eligible_end = child.birth_date + relativedelta(months=_DUBBELDAGAR_MONTHS_LIMIT)
|
|
used = self._dubbeldagar_used.get(child.id, 0)
|
|
dubbeldagar_legally_available = (
|
|
pool_a is not None
|
|
and pool_b is not None
|
|
and any(d <= eligible_end for d in dates)
|
|
and used < _MAX_DUBBELDAGAR
|
|
and self._peek_fp_tier(pool_a) is not None
|
|
and self._peek_fp_tier(pool_b) is not None
|
|
)
|
|
want_dubbeldag = wish.wants_dubbeldag
|
|
|
|
# §fix (long-chunk co-leave, 2026-09-19) — decide the FP-payer per
|
|
# CHUNK, not per day, so a long window reads as one switch instead
|
|
# of a daily-alternating patchwork (see the tier-2 docstring above).
|
|
# Reuses `_fund_swap`'s own balanced-by-spendable-cost split rather
|
|
# than a second splitter.
|
|
first_half, _second_half = _split_dates_by_spendable_cost(
|
|
dates, self._input.holidays, self._input.day_overrides
|
|
)
|
|
first_half_dates: frozenset[date] = frozenset(first_half)
|
|
|
|
days: list[ProposedDay] = []
|
|
cost = _new_cost()
|
|
dubbeldag_dates: set[date] = set()
|
|
co_leave_dates: set[date] = set()
|
|
leftover_for_swap: list[date] = []
|
|
|
|
for d in dates:
|
|
existing_a = self._existing_lookup.get((parent_a.uuid, child.id, d))
|
|
existing_b = self._existing_lookup.get((parent_b.uuid, child.id, d))
|
|
if existing_a is not None or existing_b is not None:
|
|
leftover_for_swap.append(d)
|
|
continue
|
|
|
|
if is_free_day(d, self._input.holidays, self._input.day_overrides):
|
|
# §todo item 2 — each parent's own FP pool is tried
|
|
# independently (never vacation, never a peeked-then-
|
|
# committed-together pair like dubbeldagar/co-leave above):
|
|
# one parent running out of FP must never stop the other
|
|
# from still getting paid for this same red day.
|
|
free_reason = (
|
|
REASON_FREE_RED_DAY
|
|
if _is_real_red_day(d, self._input.holidays)
|
|
else REASON_FREE_WEEKEND
|
|
)
|
|
for red_parent, red_pool in ((parent_a, pool_a), (parent_b, pool_b)):
|
|
fp_on_red_day = (
|
|
self._spend_fp((red_parent.uuid, child.id), prefer="sjukpenning")
|
|
if self._input.take_pl_on_red_days and red_pool is not None
|
|
else None
|
|
)
|
|
if fp_on_red_day is not None:
|
|
cost[fp_on_red_day] += 1
|
|
days.append(
|
|
ProposedDay(
|
|
d,
|
|
red_parent.uuid,
|
|
child.id,
|
|
fp_on_red_day,
|
|
False,
|
|
wish.id,
|
|
REASON_FP_RED_DAY,
|
|
)
|
|
)
|
|
else:
|
|
cost["free"] += 1
|
|
days.append(
|
|
ProposedDay(
|
|
d, red_parent.uuid, child.id, "free", False, wish.id, free_reason
|
|
)
|
|
)
|
|
continue
|
|
|
|
funded = False
|
|
|
|
if (
|
|
want_dubbeldag
|
|
and pool_a is not None
|
|
and pool_b is not None
|
|
and d <= eligible_end
|
|
and used < _MAX_DUBBELDAGAR
|
|
):
|
|
tier_a = self._peek_fp_tier(pool_a)
|
|
tier_b = self._peek_fp_tier(pool_b)
|
|
if tier_a is not None and tier_b is not None:
|
|
self._commit_fp_tier(pool_a, tier_a)
|
|
self._commit_fp_tier(pool_b, tier_b)
|
|
used += 1
|
|
cost[tier_a] += 1
|
|
cost[tier_b] += 1
|
|
days.append(
|
|
ProposedDay(
|
|
d, parent_a.uuid, child.id, tier_a, True, wish.id, REASON_DUBBELDAG
|
|
)
|
|
)
|
|
days.append(
|
|
ProposedDay(
|
|
d, parent_b.uuid, child.id, tier_b, True, wish.id, REASON_DUBBELDAG
|
|
)
|
|
)
|
|
dubbeldag_dates.add(d)
|
|
funded = True
|
|
|
|
if not funded and pool_a is not None and pool_b is not None:
|
|
# §fix (long-chunk co-leave, 2026-09-19) — the FP-payer is
|
|
# decided once per half of the window (`first_half_dates`),
|
|
# not by comparing live remaining balances on every date —
|
|
# that per-day comparison is exactly what made the payer
|
|
# flip almost daily as spending shifted the lead back and
|
|
# forth. `responsible.parents[0]` pays with FP across the
|
|
# first half, `responsible.parents[1]` across the second.
|
|
if d in first_half_dates:
|
|
primary, primary_pool = parent_a, pool_a
|
|
secondary, secondary_pool = parent_b, pool_b
|
|
else:
|
|
primary, primary_pool = parent_b, pool_b
|
|
secondary, secondary_pool = parent_a, pool_a
|
|
|
|
funded_pair = self._try_co_leave_pair(primary, primary_pool, secondary, d)
|
|
if funded_pair is None:
|
|
# Graceful fallback: the chunk's designated FP-payer
|
|
# can't afford THIS date (or their partner can't pay
|
|
# vacation) — try the pairing swapped for just this
|
|
# date rather than losing "both off" for it entirely.
|
|
# Because the exhausted resource (FP or vacation) stays
|
|
# exhausted, once this triggers it keeps triggering for
|
|
# the rest of the chunk instead of flip-flopping day to
|
|
# day.
|
|
funded_pair = self._try_co_leave_pair(secondary, secondary_pool, primary, d)
|
|
|
|
if funded_pair is not None:
|
|
fp_parent, fp_tier, vacation_parent = funded_pair
|
|
cost[fp_tier] += 1
|
|
cost["vacation"] += 1
|
|
fp_reason = (
|
|
REASON_FP_INTERIOR if fp_tier == "sjukpenning" else REASON_FP_LAGSTA_STRETCH
|
|
)
|
|
days.append(
|
|
ProposedDay(d, fp_parent.uuid, child.id, fp_tier, False, wish.id, fp_reason)
|
|
)
|
|
days.append(
|
|
ProposedDay(
|
|
d,
|
|
vacation_parent.uuid,
|
|
child.id,
|
|
"vacation",
|
|
False,
|
|
wish.id,
|
|
REASON_VACATION_WRAP_WEEKEND,
|
|
)
|
|
)
|
|
co_leave_dates.add(d)
|
|
funded = True
|
|
|
|
if not funded:
|
|
leftover_for_swap.append(d)
|
|
|
|
self._dubbeldagar_used[child.id] = used
|
|
|
|
swap_dates: set[date] = set()
|
|
if leftover_for_swap:
|
|
swap_days, swap_cost = self._fund_swap(
|
|
wish, w, sorted(leftover_for_swap), red_cluster, responsible
|
|
)
|
|
days.extend(swap_days)
|
|
for k in cost:
|
|
cost[k] += swap_cost[k]
|
|
swap_dates = {sd.date for sd in swap_days}
|
|
|
|
meta = {
|
|
"dubbeldag_dates": len(dubbeldag_dates),
|
|
"co_leave_dates": len(co_leave_dates),
|
|
"swap_dates": len(swap_dates),
|
|
"dubbeldagar_legally_available": dubbeldagar_legally_available,
|
|
}
|
|
return days, cost, meta
|
|
|
|
# -- per-window orchestration (§3.3-3.6) -------------------------------
|
|
|
|
def fund_window(self, w: _WishWindow) -> tuple[list[ProposedDay], WindowOutcome]:
|
|
wish = w.wish
|
|
responsible = self._resolve_parents(wish)
|
|
|
|
all_dates = _dates_in(w.start, w.end)
|
|
red_cluster = _red_day_cluster_dates(
|
|
w.start, w.end, self._input.holidays, self._input.day_overrides
|
|
)
|
|
|
|
dubbeldagar_legally_available = False
|
|
strategy_degraded = False
|
|
|
|
if responsible.mode == "dubbeldag":
|
|
days, cost, meta = self._fund_both(wish, w, all_dates, red_cluster, responsible)
|
|
dubbeldagar_legally_available = bool(meta["dubbeldagar_legally_available"])
|
|
requested_strategy = "dubbeldag" if wish.wants_dubbeldag else STRATEGY_CO_LEAVE
|
|
date_counts = {
|
|
"dubbeldag": int(meta["dubbeldag_dates"]),
|
|
"co_leave": int(meta["co_leave_dates"]),
|
|
"swap": int(meta["swap_dates"]),
|
|
}
|
|
if any(date_counts.values()):
|
|
# Dominant category by DATE count; ties broken by how
|
|
# "good" the outcome is (dubbeldag > co_leave > swap) so a
|
|
# mixed window never under-reports what mostly happened.
|
|
_tier_rank = {"dubbeldag": 2, "co_leave": 1, "swap": 0}
|
|
strategy = max(date_counts, key=lambda k: (date_counts[k], _tier_rank[k]))
|
|
else:
|
|
# Nothing needed real funding (e.g. an all-free-days window)
|
|
# -- nothing degraded, report the requested strategy as-is.
|
|
strategy = requested_strategy
|
|
strategy_degraded = bool(date_counts["swap"]) or (
|
|
requested_strategy == "dubbeldag" and date_counts["co_leave"] > 0
|
|
)
|
|
elif responsible.mode == "swap":
|
|
days, cost = self._fund_swap(wish, w, all_dates, red_cluster, responsible)
|
|
strategy = "parent_swap"
|
|
requested_strategy = "parent_swap"
|
|
else:
|
|
parent = responsible.parents[0]
|
|
resolved_child = self._resolve_wish_child(wish)
|
|
if resolved_child is not None:
|
|
self._maybe_clamp_age4((parent.uuid, resolved_child.id), w.start)
|
|
days, cost = self._fund_solo(wish, all_dates, red_cluster, parent, None)
|
|
strategy = "solo"
|
|
requested_strategy = "solo"
|
|
|
|
shortfall_days, weeks_funded = _shortfall_and_weeks_funded(
|
|
responsible.mode, all_dates, days, cost
|
|
)
|
|
|
|
remedies = self._build_remedies(wish, w, shortfall_days)
|
|
|
|
outcome = WindowOutcome(
|
|
wish_id=wish.id,
|
|
wish_name=wish.name,
|
|
wish_name_message_key=wish.name_message_key,
|
|
year=w.anchor_year,
|
|
start_date=w.start,
|
|
end_date=w.end,
|
|
weeks_wished=wish.target_weeks,
|
|
weeks_funded=weeks_funded,
|
|
shortfall_days=shortfall_days,
|
|
strategy=strategy,
|
|
requested_strategy=requested_strategy,
|
|
strategy_degraded=strategy_degraded,
|
|
dubbeldagar_legally_available=dubbeldagar_legally_available,
|
|
message_key=MESSAGE_KEY_WINDOW_EXPLANATION,
|
|
data={
|
|
"wish_name": wish.name,
|
|
"wish_name_message_key": wish.name_message_key,
|
|
"year": w.anchor_year,
|
|
"weeks_wished": wish.target_weeks,
|
|
"weeks_funded": weeks_funded,
|
|
"shortfall_days": shortfall_days,
|
|
},
|
|
cost_breakdown=cost,
|
|
remedies=remedies,
|
|
)
|
|
return days, outcome
|
|
|
|
# -- shortfall remedies (§3.6, §9.1) ------------------------------------
|
|
|
|
def _build_remedies(
|
|
self, wish: LeaveWish, w: _WishWindow, shortfall_days: int
|
|
) -> list[ShortfallRemedy]:
|
|
if shortfall_days <= 0:
|
|
return []
|
|
remedies: list[ShortfallRemedy] = []
|
|
remedies.extend(self._reduce_preschool_reserve_remedy(wish))
|
|
remedies.extend(self._carry_vacation_forward_remedy(wish, w))
|
|
remedies.extend(self._lower_priority_wish_remedy(wish))
|
|
remedies.extend(self._shift_window_into_free_days_remedy(wish, w))
|
|
return remedies
|
|
|
|
def _reduce_preschool_reserve_remedy(self, wish: LeaveWish) -> list[ShortfallRemedy]:
|
|
remedy_child = self._resolve_wish_child(wish)
|
|
if remedy_child is None:
|
|
return []
|
|
reserved = self._preschool_reserved.get(remedy_child.id, 0)
|
|
if reserved <= 0:
|
|
return []
|
|
return [
|
|
ShortfallRemedy(
|
|
kind=REMEDY_REDUCE_PRESCHOOL_RESERVE,
|
|
message_key=f"planRemedies.{REMEDY_REDUCE_PRESCHOOL_RESERVE}",
|
|
data={"reserved": reserved},
|
|
days_freed=reserved,
|
|
)
|
|
]
|
|
|
|
def _carry_vacation_forward_remedy(
|
|
self, wish: LeaveWish, w: _WishWindow
|
|
) -> list[ShortfallRemedy]:
|
|
responsible = self._resolve_parents(wish)
|
|
# §9.2 Task 1 consequence #2: only days *above* the parent's
|
|
# semesterlagen minimum for that year may be carried forward — the
|
|
# minimum itself must stay taken, not banked. (The 5-year expiry is
|
|
# a separate constraint, applied elsewhere.)
|
|
spare_total = 0
|
|
for (p_uuid, year), budget in self._vacation.items():
|
|
if year >= w.start.year or not any(p_uuid == p.uuid for p in responsible.parents):
|
|
continue
|
|
parent = self._parents_by_id.get(p_uuid)
|
|
min_days = parent.min_vacation_days_per_year if parent else 0
|
|
bankable_ceiling = max(budget.total_days - min_days, 0)
|
|
spare_total += min(max(budget.available, 0), bankable_ceiling)
|
|
if spare_total <= 0:
|
|
return []
|
|
return [
|
|
ShortfallRemedy(
|
|
kind=REMEDY_CARRY_VACATION_FORWARD,
|
|
message_key=f"planRemedies.{REMEDY_CARRY_VACATION_FORWARD}",
|
|
data={"spare_total": spare_total},
|
|
days_freed=spare_total,
|
|
)
|
|
]
|
|
|
|
def _lower_priority_wish_remedy(self, wish: LeaveWish) -> list[ShortfallRemedy]:
|
|
if wish.child_id is None:
|
|
return []
|
|
siblings = [
|
|
other
|
|
for other in self._input.wishes
|
|
if other.id != wish.id
|
|
and other.child_id == wish.child_id
|
|
and other.priority > wish.priority
|
|
]
|
|
if not siblings:
|
|
return []
|
|
other = min(siblings, key=lambda o: o.priority)
|
|
# A whole-week target can only be halved to a genuinely
|
|
# smaller whole week count when it's at least 2 weeks to
|
|
# begin with (`target_weeks` has a domain floor of 1 — see
|
|
# `LeaveWishCreate.target_weeks`). At exactly 1 week,
|
|
# `target_weeks // 2 == 0`, which used to get clamped back
|
|
# up to 1, producing a nonsensical "from 1 to 1 weeks"
|
|
# no-op remedy. Suppress the suggestion entirely rather
|
|
# than claim a change that isn't one — the planner works in
|
|
# whole days/weeks, so there's no fractional week to offer
|
|
# instead.
|
|
half_weeks = other.target_weeks // 2
|
|
if half_weeks < 1:
|
|
return []
|
|
other_start, other_end = other.window_for_year(other.first_year)
|
|
other_dates = _dates_in(other_start, other_end)
|
|
spendable = sum(
|
|
1
|
|
for d in other_dates
|
|
if not is_free_day(d, self._input.holidays, self._input.day_overrides)
|
|
)
|
|
freed_estimate = round(spendable / 2)
|
|
if freed_estimate <= 0:
|
|
return []
|
|
return [
|
|
ShortfallRemedy(
|
|
kind=REMEDY_LOWER_PRIORITY_WISH,
|
|
message_key=f"planRemedies.{REMEDY_LOWER_PRIORITY_WISH}",
|
|
data={
|
|
"wish_name": other.name,
|
|
"wish_name_message_key": other.name_message_key,
|
|
"from_weeks": other.target_weeks,
|
|
"to_weeks": half_weeks,
|
|
"freed_days": freed_estimate,
|
|
},
|
|
days_freed=freed_estimate,
|
|
)
|
|
]
|
|
|
|
def _shift_window_into_free_days_remedy(
|
|
self, wish: LeaveWish, w: _WishWindow
|
|
) -> list[ShortfallRemedy]:
|
|
shift_gain = 0
|
|
probe = w.start - timedelta(days=1)
|
|
for _ in range(3):
|
|
if is_free_day(probe, self._input.holidays, self._input.day_overrides):
|
|
shift_gain += 1
|
|
probe -= timedelta(days=1)
|
|
else:
|
|
break
|
|
probe = w.end + timedelta(days=1)
|
|
for _ in range(3):
|
|
if is_free_day(probe, self._input.holidays, self._input.day_overrides):
|
|
shift_gain += 1
|
|
probe += timedelta(days=1)
|
|
else:
|
|
break
|
|
if shift_gain <= 0:
|
|
return []
|
|
return [
|
|
ShortfallRemedy(
|
|
kind=REMEDY_SHIFT_WINDOW_INTO_FREE_DAYS,
|
|
message_key=f"planRemedies.{REMEDY_SHIFT_WINDOW_INTO_FREE_DAYS}",
|
|
data={
|
|
"wish_name": wish.name,
|
|
"wish_name_message_key": wish.name_message_key,
|
|
"shift_gain": shift_gain,
|
|
},
|
|
days_freed=shift_gain,
|
|
)
|
|
]
|
|
|
|
# -- flexible ("när det passar bäst") wish resolution (§10.2) ----------
|
|
|
|
def record_days(self, days: list[ProposedDay]) -> None:
|
|
"""§10.2 "Occupied dates" — fold a just-funded window's proposed days
|
|
|
|
into the same lookup `_fund_solo`/`_fund_both` already consult
|
|
(`_existing_lookup`, today: persisted `existing_planned` rows only),
|
|
so a later window (fixed or flexible) in this same `propose()` run
|
|
never lands a flexible candidate on a date another wish already
|
|
claimed. Called by `Allocator.propose()` after every `fund_window()`
|
|
call, fixed or flexible.
|
|
"""
|
|
for d in days:
|
|
self._existing_lookup[(d.parent_personal_data_uuid, d.child_id, d.date)] = d.day_type
|
|
|
|
def _candidate_occupied(
|
|
self,
|
|
start: date,
|
|
end: date,
|
|
parents: list[ParentFacts],
|
|
child_id: UUID | None,
|
|
exclude_dates: frozenset[date] = frozenset(),
|
|
) -> bool:
|
|
"""§10.2 step 5 — whether `[start, end]` collides with an
|
|
|
|
already-claimed date for any of `parents` (paired with `child_id`).
|
|
`exclude_dates` (§fix) lets a caller that already knows some of
|
|
those claimed dates are this very wish's own prior occurrence treat
|
|
them as expected, not a collision.
|
|
"""
|
|
for d in _dates_in(start, end):
|
|
if d in exclude_dates:
|
|
continue
|
|
for p in parents:
|
|
if (p.uuid, child_id, d) in self._existing_lookup:
|
|
return True
|
|
return False
|
|
|
|
def _persisted_dates_for_wish(
|
|
self,
|
|
wish: LeaveWish,
|
|
child_id: UUID | None,
|
|
bound_start: date,
|
|
bound_end: date,
|
|
) -> list[date]:
|
|
"""§fix — dates already persisted *before this `propose()` run*
|
|
|
|
(i.e. from a prior apply, via `_persisted_by_wish` — never the
|
|
mutable `_existing_lookup`) for THIS wish, inside its bound. The
|
|
read-only source is what keeps a fixed wish's in-session placement
|
|
from being mistaken for a flexible wish's own history (§10.3,
|
|
`TestFixedWishNeverDisplacedByFlexible`).
|
|
|
|
Matched by `wish_id`, deliberately NOT by the wish's currently
|
|
resolved parent(s) (§fix, decision B): a wish's prior placement must
|
|
still be found after the user reassigns its parent, so the caller
|
|
can reuse the SAME window rather than researching one from scratch
|
|
purely because a different parent has different (or no) occupied
|
|
dates — see `AllocationInput.all_existing_planned`'s docstring.
|
|
"""
|
|
dates = self._persisted_by_wish.get((wish.id, child_id), set())
|
|
return sorted(d for d in dates if bound_start <= d <= bound_end)
|
|
|
|
# -- §Decision C — budget-aware candidate ranking ----------------------
|
|
|
|
def _candidate_shortfall(
|
|
self,
|
|
wish: LeaveWish,
|
|
responsible: _Responsible,
|
|
candidate_start: date,
|
|
candidate_end: date,
|
|
) -> int:
|
|
"""§10.2 step 6, extended — how many of a candidate window's spendable
|
|
|
|
days the resolved parent(s) could NOT actually pay for, simulated
|
|
against a throwaway copy of the live pool/vacation state.
|
|
|
|
`_candidate_cost` alone only counts calendar days — it has no idea
|
|
whether the wish's resolved parent(s) can actually AFFORD them. A
|
|
window that is cheap by the calendar but leaves half its days
|
|
unfunded (vacation/FP already exhausted) is worse than a slightly
|
|
costlier one the parent(s) can fully pay for, so this must be
|
|
compared FIRST, with `_candidate_cost` only as the tie-break — see
|
|
`resolve_flexible_window`/`_reuse_already_funded_window`, which both
|
|
rank candidates by `(shortfall, calendar_cost, start, wish.id)`.
|
|
|
|
Runs the SAME `_fund_solo`/`_fund_swap`/`_fund_both` funding logic
|
|
every real window goes through, against a scratch copy of
|
|
`self._pools`/`self._vacation`/`self._dubbeldagar_used` swapped in
|
|
for the duration of the call and restored in a `finally` — `propose()`
|
|
must stay read-only and deterministic (§5 test #11), so no candidate
|
|
probe may leave a trace on the real ledger, win or lose. The winning
|
|
candidate is funded for real afterwards through the ordinary
|
|
`fund_window()` path, exactly as before this fix.
|
|
"""
|
|
dates = _dates_in(candidate_start, candidate_end)
|
|
red_cluster = _red_day_cluster_dates(
|
|
candidate_start, candidate_end, self._input.holidays, self._input.day_overrides
|
|
)
|
|
probe_window = _WishWindow(
|
|
wish=wish,
|
|
anchor_year=candidate_start.year,
|
|
start=candidate_start,
|
|
end=candidate_end,
|
|
)
|
|
|
|
real_pools, real_vacation = self._pools, self._vacation
|
|
real_dubbeldagar_used = dict(self._dubbeldagar_used)
|
|
self._pools = {
|
|
key: _MutablePool(
|
|
p.sjukpenning_left, p.lagsta_left, p.dubbeldagar_left, p.clamped_at_b4
|
|
)
|
|
for key, p in real_pools.items()
|
|
}
|
|
self._vacation = {
|
|
key: _MutableVacation(v.total_days, v.saved_days_in, v.already_used, v.is_assumed)
|
|
for key, v in real_vacation.items()
|
|
}
|
|
try:
|
|
if responsible.mode == "dubbeldag":
|
|
days, cost, _meta = self._fund_both(
|
|
wish, probe_window, dates, red_cluster, responsible
|
|
)
|
|
elif responsible.mode == "swap":
|
|
days, cost = self._fund_swap(wish, probe_window, dates, red_cluster, responsible)
|
|
else:
|
|
parent = responsible.parents[0]
|
|
resolved_child = self._resolve_wish_child(wish)
|
|
if resolved_child is not None:
|
|
self._maybe_clamp_age4((parent.uuid, resolved_child.id), candidate_start)
|
|
days, cost = self._fund_solo(wish, dates, red_cluster, parent, None)
|
|
finally:
|
|
self._pools, self._vacation = real_pools, real_vacation
|
|
self._dubbeldagar_used = real_dubbeldagar_used
|
|
|
|
shortfall_days, _weeks_funded = _shortfall_and_weeks_funded(
|
|
responsible.mode, dates, days, cost
|
|
)
|
|
return shortfall_days
|
|
|
|
def _rank_candidate(
|
|
self,
|
|
wish: LeaveWish,
|
|
responsible: _Responsible,
|
|
candidate: tuple[date, date],
|
|
) -> tuple[int, int, date, int]:
|
|
"""Sort key shared by `resolve_flexible_window` and
|
|
|
|
`_reuse_already_funded_window`: fewest unfundable days first (§Decision
|
|
C), THEN calendar cost, THEN start date, THEN wish id — the existing
|
|
priority ordering (§10.2 step 6) is otherwise unchanged.
|
|
"""
|
|
start, end = candidate
|
|
shortfall = self._candidate_shortfall(wish, responsible, start, end)
|
|
cost = _candidate_cost(start, end, self._input.holidays, self._input.day_overrides)
|
|
return (shortfall, cost, start, wish.id.int)
|
|
|
|
def _reuse_already_funded_window(
|
|
self,
|
|
wish: LeaveWish,
|
|
responsible: _Responsible,
|
|
child_id: UUID | None,
|
|
bound_start: date,
|
|
bound_end: date,
|
|
length_days: int,
|
|
) -> tuple[date, date] | None:
|
|
"""§fix — the double-booking-on-repropose fix, product-owner approved:
|
|
|
|
if this flexible wish-year already has planned days from a prior
|
|
apply inside its bounding range, reuse the full-length window they
|
|
belong to instead of searching for a new one. The caller then funds
|
|
that window through the ordinary `fund_window()` path exactly like
|
|
any other window; because `_fund_solo`/`_fund_swap`/`_fund_both` all
|
|
skip emitting a new `ProposedDay` for a date `_existing_lookup`
|
|
already has, this single mechanism handles both "fully funded"
|
|
(every spendable day in the window is already persisted -> zero new
|
|
days) and "partially funded" (only some are -> the remainder is
|
|
topped up) without a separate code path for either.
|
|
|
|
Known and accepted limitation (§10.2's "occupied dates" tradeoff,
|
|
now extended): a planned day belonging to a *different* wish that
|
|
happens to fall in this same bounding range cannot be told apart
|
|
from this wish's own prior occurrence, and may be mistaken for it.
|
|
|
|
Returns `None` — falls through to a fresh search — when: nothing is
|
|
persisted for this wish-year yet, the persisted dates don't fit
|
|
inside one `length_days` window (they can't be a single occurrence
|
|
of *this* wish), or every window that would contain them now
|
|
collides with something else already claimed this run (e.g. a
|
|
higher-priority fixed wish added since the last apply). That last
|
|
case is what keeps a genuinely-unsatisfied year free to move
|
|
(§10.3) rather than frozen to a window that no longer fits.
|
|
"""
|
|
persisted_dates = self._persisted_dates_for_wish(wish, child_id, bound_start, bound_end)
|
|
if not persisted_dates:
|
|
return None
|
|
|
|
span = (persisted_dates[-1] - persisted_dates[0]).days + 1
|
|
if span > length_days:
|
|
return None
|
|
|
|
own_dates = frozenset(persisted_dates)
|
|
candidates = [
|
|
(s, e)
|
|
for s, e in _candidate_windows(bound_start, bound_end, length_days)
|
|
if s <= persisted_dates[0]
|
|
and persisted_dates[-1] <= e
|
|
and not self._candidate_occupied(s, e, responsible.parents, child_id, own_dates)
|
|
]
|
|
if not candidates:
|
|
return None
|
|
|
|
return min(candidates, key=lambda c: self._rank_candidate(wish, responsible, c))
|
|
|
|
def resolve_flexible_window(
|
|
self, wish: LeaveWish, anchor_year: int, bound_start: date, bound_end: date
|
|
) -> _WishWindow | None:
|
|
"""§10.2 steps 2-9 — resolve one flexible wish-year's bound to a
|
|
|
|
concrete window to fund. Returns `None` when the bound is long
|
|
enough but every full-length candidate collides with an
|
|
already-claimed date — the 'unplaced' case (§10.4), for the caller
|
|
to report via `build_unplaced_outcome`.
|
|
"""
|
|
length_days = wish.target_span_days()
|
|
bound_length = (bound_end - bound_start).days + 1
|
|
|
|
if bound_length < length_days:
|
|
# Step 4: horizon clipping ate into the bound -> there is only one
|
|
# candidate, the clipped bound itself, funded as an ordinary
|
|
# partial shortfall (§3.6) — NOT the 'unplaced' case.
|
|
return _WishWindow(wish=wish, anchor_year=anchor_year, start=bound_start, end=bound_end)
|
|
|
|
responsible = self._resolve_parents(wish)
|
|
resolved_child = self._resolve_wish_child(wish)
|
|
child_id = resolved_child.id if resolved_child is not None else None
|
|
|
|
# §fix — an already (fully or partially) funded wish-year reuses its
|
|
# own prior window rather than being searched for fresh, which is
|
|
# what caused the double-booking regression.
|
|
reused = self._reuse_already_funded_window(
|
|
wish, responsible, child_id, bound_start, bound_end, length_days
|
|
)
|
|
if reused is not None:
|
|
winner_start, winner_end = reused
|
|
return _WishWindow(
|
|
wish=wish, anchor_year=anchor_year, start=winner_start, end=winner_end
|
|
)
|
|
|
|
candidates = [
|
|
(s, e)
|
|
for s, e in _candidate_windows(bound_start, bound_end, length_days)
|
|
if not self._candidate_occupied(s, e, responsible.parents, child_id)
|
|
]
|
|
if not candidates:
|
|
return None
|
|
|
|
winner_start, winner_end = min(
|
|
candidates, key=lambda c: self._rank_candidate(wish, responsible, c)
|
|
)
|
|
return _WishWindow(wish=wish, anchor_year=anchor_year, start=winner_start, end=winner_end)
|
|
|
|
def build_unplaced_outcome(
|
|
self, wish: LeaveWish, anchor_year: int, bound_start: date, bound_end: date
|
|
) -> WindowOutcome:
|
|
"""§10.4 — a flexible wish-year that could not be placed at all:
|
|
|
|
every full-length candidate inside a long-enough bound collided with
|
|
a date another wish already claimed. Reuses the shortfall vocabulary
|
|
(`WindowOutcome`) rather than inventing a new failure mode; the only
|
|
new value is `strategy = 'unplaced'`.
|
|
"""
|
|
length_days = wish.target_span_days()
|
|
bound_window = _WishWindow(
|
|
wish=wish, anchor_year=anchor_year, start=bound_start, end=bound_end
|
|
)
|
|
# §10.4: every remedy `_build_remedies` can generate still makes sense
|
|
# against the clipped bound EXCEPT shift_window_into_free_days — there
|
|
# is no single winning window edge left to shift.
|
|
remedies = [
|
|
r
|
|
for r in self._build_remedies(wish, bound_window, length_days)
|
|
if r.kind != REMEDY_SHIFT_WINDOW_INTO_FREE_DAYS
|
|
]
|
|
responsible = self._resolve_parents(wish)
|
|
if responsible.mode == "dubbeldag":
|
|
requested_strategy = "dubbeldag" if wish.wants_dubbeldag else STRATEGY_CO_LEAVE
|
|
elif responsible.mode == "swap":
|
|
requested_strategy = "parent_swap"
|
|
else:
|
|
requested_strategy = "solo"
|
|
return WindowOutcome(
|
|
wish_id=wish.id,
|
|
wish_name=wish.name,
|
|
wish_name_message_key=wish.name_message_key,
|
|
year=anchor_year,
|
|
start_date=bound_start,
|
|
end_date=bound_end,
|
|
weeks_wished=wish.target_weeks,
|
|
weeks_funded=0.0,
|
|
shortfall_days=length_days,
|
|
strategy=STRATEGY_UNPLACED,
|
|
requested_strategy=requested_strategy,
|
|
strategy_degraded=False,
|
|
dubbeldagar_legally_available=False,
|
|
message_key=MESSAGE_KEY_WINDOW_EXPLANATION,
|
|
data={
|
|
"wish_name": wish.name,
|
|
"wish_name_message_key": wish.name_message_key,
|
|
"year": anchor_year,
|
|
"weeks_wished": wish.target_weeks,
|
|
"weeks_funded": 0.0,
|
|
"shortfall_days": length_days,
|
|
},
|
|
cost_breakdown=_new_cost(),
|
|
remedies=remedies,
|
|
)
|
|
|
|
# -- warnings ------------------------------------------------------------
|
|
|
|
def build_warnings(self, all_days: list[ProposedDay]) -> list[PlanWarning]:
|
|
warnings: list[PlanWarning] = []
|
|
warnings.extend(self._age4_warnings(all_days))
|
|
warnings.extend(self._sgi_warnings(all_days))
|
|
warnings.extend(self._vacation_expiry_warnings())
|
|
return warnings
|
|
|
|
def _age4_projections(
|
|
self, all_days: list[ProposedDay]
|
|
) -> dict[tuple[UUID, UUID], tuple[int, int]]:
|
|
"""(parent, child) -> (projected_left_at_b4, expiring_at_b4).
|
|
|
|
Shared by `_age4_warnings` and `build_surplus_advice` (§9.2) so the
|
|
warning and the suggestions that mirror it are always computed from
|
|
the same numbers. Reuses the pure arithmetic already extracted for
|
|
AnalyticsService (`app.utils.tip_predicates.days_left_at_age_4_projection`)
|
|
rather than reimplementing the age-4 formula here.
|
|
"""
|
|
result: dict[tuple[UUID, UUID], tuple[int, int]] = {}
|
|
for (parent_uuid, child_id), original_pool in self._input.pools.items():
|
|
child = self._children_by_id.get(child_id)
|
|
if child is None:
|
|
continue
|
|
b4 = child.fourth_birthday
|
|
total_initial = original_pool.sjukpenning_left + original_pool.lagsta_left
|
|
|
|
existing_before = sum(
|
|
1
|
|
for d in self._input.existing_planned
|
|
if d.parent_personal_data_uuid == parent_uuid
|
|
and d.child_id == child_id
|
|
and d.day_type in ("sjukpenning", "lagsta")
|
|
and d.date < b4
|
|
)
|
|
new_before = sum(
|
|
1
|
|
for d in all_days
|
|
if d.parent_personal_data_uuid == parent_uuid
|
|
and d.child_id == child_id
|
|
and d.day_type in ("sjukpenning", "lagsta")
|
|
and d.date < b4
|
|
)
|
|
result[(parent_uuid, child_id)] = days_left_at_age_4_projection(
|
|
days_used=0,
|
|
planned_fp_before_b4=existing_before + new_before,
|
|
total_days=total_initial,
|
|
max_savable=self._input.age4_savable_cap,
|
|
)
|
|
return result
|
|
|
|
def _age4_warnings(self, all_days: list[ProposedDay]) -> list[PlanWarning]:
|
|
warnings: list[PlanWarning] = []
|
|
for (parent_uuid, child_id), (
|
|
projected_left,
|
|
expiring,
|
|
) in self._age4_projections(all_days).items():
|
|
if expiring <= 0:
|
|
continue
|
|
child = self._children_by_id[child_id]
|
|
b4 = child.fourth_birthday
|
|
warnings.append(
|
|
PlanWarning(
|
|
kind=WARNING_DAYS_LOST_AT_AGE_4,
|
|
message_key=f"planWarnings.{WARNING_DAYS_LOST_AT_AGE_4}",
|
|
data={
|
|
"parent_personal_data_uuid": parent_uuid,
|
|
"child_id": child_id,
|
|
"expiring_days": expiring,
|
|
"projected_left_at_b4": projected_left,
|
|
"fourth_birthday": b4.isoformat(),
|
|
},
|
|
)
|
|
)
|
|
return warnings
|
|
|
|
def build_age4_projections(self, all_days: list[ProposedDay]) -> list[Age4Projection]:
|
|
"""§3.3 part 2 — the plan-aware age-4 projection for every (parent,
|
|
child) pair, always populated (unlike `build_surplus_advice`, which
|
|
is empty when there's nothing to advise on) so the UI can show what
|
|
this proposal implies at the age-4 boundary before it's applied.
|
|
"""
|
|
projections: list[Age4Projection] = []
|
|
for (parent_uuid, child_id), (projected_left, expiring) in sorted(
|
|
self._age4_projections(all_days).items(), key=lambda kv: (str(kv[0][0]), str(kv[0][1]))
|
|
):
|
|
child = self._children_by_id.get(child_id)
|
|
if child is None:
|
|
continue
|
|
savable = min(projected_left, self._input.age4_savable_cap)
|
|
projections.append(
|
|
Age4Projection(
|
|
parent_personal_data_uuid=parent_uuid,
|
|
child_id=child_id,
|
|
fourth_birthday=child.fourth_birthday,
|
|
projected_left_at_b4=projected_left,
|
|
savable_after_b4=savable,
|
|
expiring_at_b4=expiring,
|
|
savable_cap_at_b4=self._input.age4_savable_cap,
|
|
)
|
|
)
|
|
return projections
|
|
|
|
# -- surplus advice (§9.2) — the mirror of a shortfall remedy --------
|
|
|
|
def build_surplus_advice(self, all_days: list[ProposedDay]) -> list[SurplusAdvice]:
|
|
"""Ranked, concrete suggestions for parents forecast to *forfeit* FP
|
|
days at the age-4 boundary — the mirror of `_build_remedies`'
|
|
shortfall handling. Empty when no (parent, child) pair has a surplus.
|
|
"""
|
|
advice: list[SurplusAdvice] = []
|
|
projections = self._age4_projections(all_days)
|
|
|
|
for (parent_uuid, child_id), (_projected_left, expiring) in sorted(
|
|
projections.items(), key=lambda kv: (str(kv[0][0]), str(kv[0][1]))
|
|
):
|
|
if expiring <= 0:
|
|
continue
|
|
parent = self._parents_by_id.get(parent_uuid)
|
|
child = self._children_by_id.get(child_id)
|
|
if parent is None or child is None:
|
|
continue
|
|
|
|
advice.extend(self._wish_more_leave_advice(parent, child, expiring))
|
|
advice.extend(self._shift_mix_to_fp_advice(parent, child, expiring, all_days))
|
|
advice.extend(self._front_load_advice(parent, child, expiring))
|
|
advice.extend(self._use_less_vacation_advice(parent, child, expiring))
|
|
|
|
return advice
|
|
|
|
def _wish_more_leave_advice(
|
|
self, parent: ParentFacts, child: ChildFacts, expiring: int
|
|
) -> list[SurplusAdvice]:
|
|
weeks = expiring // _SPENDABLE_DAYS_PER_WEEK
|
|
if weeks < 1:
|
|
return []
|
|
return [
|
|
SurplusAdvice(
|
|
kind=SURPLUS_WISH_MORE_LEAVE,
|
|
message_key=f"planSurplusAdvice.{SURPLUS_WISH_MORE_LEAVE}",
|
|
days_involved=expiring,
|
|
data={
|
|
"parent_personal_data_uuid": parent.uuid,
|
|
"child_id": child.id,
|
|
"weeks": weeks,
|
|
},
|
|
)
|
|
]
|
|
|
|
def _shift_mix_to_fp_advice(
|
|
self,
|
|
parent: ParentFacts,
|
|
child: ChildFacts,
|
|
expiring: int,
|
|
all_days: list[ProposedDay],
|
|
) -> list[SurplusAdvice]:
|
|
# Vacation days spent in the goal-dependent interior (tier 3, §3.3) —
|
|
# not a red-day-cluster wrap (tier 2, which stays vacation regardless
|
|
# of goal) — before this child's 4th birthday. These are the days
|
|
# that could instead have drawn on the (about-to-expire) FP pool,
|
|
# freeing semester for `use_less_vacation` or later years.
|
|
swappable = sum(
|
|
1
|
|
for d in all_days
|
|
if d.parent_personal_data_uuid == parent.uuid
|
|
and d.child_id == child.id
|
|
and d.day_type == "vacation"
|
|
and d.reason == REASON_VACATION_WRAP_WEEKEND
|
|
and d.date < child.fourth_birthday
|
|
)
|
|
days_involved = min(swappable, expiring)
|
|
if days_involved <= 0:
|
|
return []
|
|
return [
|
|
SurplusAdvice(
|
|
kind=SURPLUS_SHIFT_MIX_TO_FP,
|
|
message_key=f"planSurplusAdvice.{SURPLUS_SHIFT_MIX_TO_FP}",
|
|
days_involved=days_involved,
|
|
data={"parent_personal_data_uuid": parent.uuid, "child_id": child.id},
|
|
)
|
|
]
|
|
|
|
def _front_load_advice(
|
|
self, parent: ParentFacts, child: ChildFacts, expiring: int
|
|
) -> list[SurplusAdvice]:
|
|
if expiring < _LARGE_SURPLUS_THRESHOLD_DAYS:
|
|
return []
|
|
still_small = self._input.today < child.birth_date + relativedelta(
|
|
years=_FRONT_LOAD_CHILD_AGE_YEARS
|
|
)
|
|
if not still_small:
|
|
return []
|
|
return [
|
|
SurplusAdvice(
|
|
kind=SURPLUS_FRONT_LOAD_EARLY_YEARS,
|
|
message_key=f"planSurplusAdvice.{SURPLUS_FRONT_LOAD_EARLY_YEARS}",
|
|
days_involved=expiring,
|
|
data={"parent_personal_data_uuid": parent.uuid, "child_id": child.id},
|
|
)
|
|
]
|
|
|
|
def _use_less_vacation_advice(
|
|
self, parent: ParentFacts, child: ChildFacts, expiring: int
|
|
) -> list[SurplusAdvice]:
|
|
# Never advise below the semesterlagen minimum (Task 1) — only the
|
|
# portion of *already-planned* vacation usage above the floor is
|
|
# reducible, and only up to what the expiring FP surplus could cover.
|
|
remaining = expiring
|
|
total_reducible = 0
|
|
years_hit: list[int] = []
|
|
for year in sorted(
|
|
y
|
|
for (p_uuid, y) in self._vacation
|
|
if p_uuid == parent.uuid and y < child.fourth_birthday.year
|
|
):
|
|
if remaining <= 0:
|
|
break
|
|
budget = self._vacation[(parent.uuid, year)]
|
|
reducible = max(budget.already_used - parent.min_vacation_days_per_year, 0)
|
|
take = min(reducible, remaining)
|
|
if take > 0:
|
|
total_reducible += take
|
|
remaining -= take
|
|
years_hit.append(year)
|
|
|
|
if total_reducible <= 0:
|
|
return []
|
|
years_text = ", ".join(str(y) for y in years_hit)
|
|
return [
|
|
SurplusAdvice(
|
|
kind=SURPLUS_USE_LESS_VACATION,
|
|
message_key=f"planSurplusAdvice.{SURPLUS_USE_LESS_VACATION}",
|
|
days_involved=total_reducible,
|
|
data={
|
|
"parent_personal_data_uuid": parent.uuid,
|
|
"child_id": child.id,
|
|
"years_text": years_text,
|
|
"min_vacation_days_per_year": parent.min_vacation_days_per_year,
|
|
},
|
|
)
|
|
]
|
|
|
|
def _sgi_warnings(self, all_days: list[ProposedDay]) -> list[PlanWarning]:
|
|
warnings: list[PlanWarning] = []
|
|
by_parent_week: dict[tuple[UUID, tuple[int, int]], int] = {}
|
|
for d in all_days:
|
|
if d.day_type not in ("sjukpenning", "lagsta"):
|
|
continue
|
|
iso_year, iso_week, _ = d.date.isocalendar()
|
|
key = (d.parent_personal_data_uuid, (iso_year, iso_week))
|
|
by_parent_week[key] = by_parent_week.get(key, 0) + 1
|
|
|
|
flagged: set[UUID] = set()
|
|
for (parent_uuid, (iso_year, iso_week)), count in sorted(by_parent_week.items()):
|
|
if parent_uuid in flagged or count >= _SGI_MIN_DAYS_PER_WEEK:
|
|
continue
|
|
parent = self._parents_by_id.get(parent_uuid)
|
|
if parent is None or parent.employment_status in ("employed", "jobseeking"):
|
|
continue
|
|
week_monday = date.fromisocalendar(iso_year, iso_week, 1)
|
|
relevant_child = next(
|
|
(
|
|
c
|
|
for c in self._input.children
|
|
if week_monday >= c.birth_date + relativedelta(years=1)
|
|
and (parent_uuid, c.id) in self._input.pools
|
|
),
|
|
None,
|
|
)
|
|
if relevant_child is None:
|
|
continue
|
|
flagged.add(parent_uuid)
|
|
warnings.append(
|
|
PlanWarning(
|
|
kind=WARNING_SGI_RISK,
|
|
message_key=f"planWarnings.{WARNING_SGI_RISK}",
|
|
data={
|
|
"parent_personal_data_uuid": parent_uuid,
|
|
"week_start": week_monday.isoformat(),
|
|
"days_planned": count,
|
|
"min_days_per_week": _SGI_MIN_DAYS_PER_WEEK,
|
|
},
|
|
)
|
|
)
|
|
return warnings
|
|
|
|
def _vacation_expiry_warnings(self) -> list[PlanWarning]:
|
|
warnings: list[PlanWarning] = []
|
|
for (parent_uuid, year), budget in sorted(
|
|
self._vacation.items(), key=lambda kv: (str(kv[0][0]), kv[0][1])
|
|
):
|
|
if (
|
|
has_vacation_near_expiry(budget.total_days, budget.saved_days_in)
|
|
and budget.available > 0
|
|
):
|
|
warnings.append(
|
|
PlanWarning(
|
|
kind=WARNING_VACATION_EXPIRING,
|
|
message_key=f"planWarnings.{WARNING_VACATION_EXPIRING}",
|
|
data={
|
|
"parent_personal_data_uuid": parent_uuid,
|
|
"year": year,
|
|
"saved_days_in": budget.saved_days_in,
|
|
},
|
|
)
|
|
)
|
|
return warnings
|
|
|
|
# -- final snapshot --------------------------------------------------
|
|
|
|
def snapshot_balances(self) -> PlanBalances:
|
|
pools_after = {
|
|
key: DayPool(pool.sjukpenning_left, pool.lagsta_left, pool.dubbeldagar_left)
|
|
for key, pool in self._pools.items()
|
|
}
|
|
vacation_after = {
|
|
key: VacationBudget(v.total_days, v.saved_days_in, v.already_used, v.is_assumed)
|
|
for key, v in self._vacation.items()
|
|
}
|
|
return PlanBalances(pools_after=pools_after, vacation_after=vacation_after)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# The pure Allocator
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
class Allocator:
|
|
"""Pure allocation engine.
|
|
|
|
No `await`, no repository access, no `date.today()`. Given the same
|
|
`AllocationInput`, `propose()` always returns a byte-identical
|
|
`PlanProposal` (§5 test #11).
|
|
"""
|
|
|
|
def propose(self, alloc_input: AllocationInput) -> PlanProposal:
|
|
ledger = _Ledger(alloc_input)
|
|
|
|
all_days: list[ProposedDay] = []
|
|
outcomes: list[WindowOutcome] = []
|
|
|
|
# Pass 1 (§10.2, unchanged from §3.2/§3.3): every fixed-wish window is
|
|
# placed first, unconditionally — a flexible wish can never displace
|
|
# a fixed one.
|
|
fixed_windows = _expand_all_windows(alloc_input)
|
|
fixed_windows.sort(key=lambda w: (w.wish.priority, w.start, w.wish.id.int))
|
|
for w in fixed_windows:
|
|
days, outcome = ledger.fund_window(w)
|
|
all_days.extend(days)
|
|
outcomes.append(outcome)
|
|
ledger.record_days(days)
|
|
|
|
# Pass 2 (§10.2, new): flexible wish-years, processed in
|
|
# (priority, bound.start, wish.id) order, each searched for its
|
|
# best-costing placement and funded into whatever space pass 1 left.
|
|
flexible_wish_years = _expand_flexible_wish_years(alloc_input)
|
|
flexible_wish_years.sort(key=lambda fw: (fw.wish.priority, fw.bound_start, fw.wish.id.int))
|
|
for fw in flexible_wish_years:
|
|
window = ledger.resolve_flexible_window(
|
|
fw.wish, fw.anchor_year, fw.bound_start, fw.bound_end
|
|
)
|
|
if window is None:
|
|
outcomes.append(
|
|
ledger.build_unplaced_outcome(
|
|
fw.wish, fw.anchor_year, fw.bound_start, fw.bound_end
|
|
)
|
|
)
|
|
continue
|
|
days, outcome = ledger.fund_window(window)
|
|
all_days.extend(days)
|
|
outcomes.append(outcome)
|
|
ledger.record_days(days)
|
|
|
|
warnings = ledger.build_warnings(all_days)
|
|
surplus_advice = ledger.build_surplus_advice(all_days)
|
|
age4_projections = ledger.build_age4_projections(all_days)
|
|
balances = ledger.snapshot_balances()
|
|
|
|
return PlanProposal(
|
|
days=all_days,
|
|
outcomes=outcomes,
|
|
balances_after=balances,
|
|
warnings=warnings,
|
|
surplus_advice=surplus_advice,
|
|
age4_projections=age4_projections,
|
|
)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# AllocationInputLoader — the ONLY part that touches repositories / the clock
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
def _to_child_facts(c: Child) -> ChildFacts:
|
|
return ChildFacts(
|
|
id=c.id,
|
|
birth_date=c.birth_date,
|
|
fourth_birthday=c.birth_date + relativedelta(years=4),
|
|
preschool_start_date=c.preschool_start_date,
|
|
preschool_planning_days_per_year=c.preschool_planning_days_per_year,
|
|
)
|
|
|
|
|
|
def _compute_horizon_end(today: date, children: list[ChildFacts], wishes: list[LeaveWish]) -> date:
|
|
"""§9.1: max(last wish year-end, latest fourth_birthday), capped at age-12."""
|
|
candidates: list[date] = [c.fourth_birthday for c in children]
|
|
children_by_id = {c.id: c for c in children}
|
|
|
|
for wish in wishes:
|
|
if wish.recurrence == "once":
|
|
end_year = wish.first_year
|
|
elif wish.last_year is not None:
|
|
end_year = wish.last_year
|
|
elif wish.child_id is not None and wish.child_id in children_by_id:
|
|
end_year = children_by_id[wish.child_id].fourth_birthday.year
|
|
else:
|
|
end_year = today.year + 4
|
|
_, end = wish.window_for_year(end_year)
|
|
candidates.append(end)
|
|
|
|
if not candidates:
|
|
return today + relativedelta(years=4)
|
|
|
|
candidate_end = max(candidates)
|
|
if children:
|
|
hard_cap = max(c.birth_date + relativedelta(years=12) for c in children)
|
|
candidate_end = min(candidate_end, hard_cap)
|
|
return candidate_end
|
|
|
|
|
|
class AllocationInputLoader:
|
|
"""Assembles a frozen `AllocationInput` from the repositories.
|
|
|
|
This is the ONLY part of the planning engine that touches the database or
|
|
the wall clock (via the optional `today` override, which tests should
|
|
always pass explicitly).
|
|
"""
|
|
|
|
def __init__(
|
|
self,
|
|
workspace_repo: WorkspaceRepository,
|
|
child_repo: ChildRepository,
|
|
personal_data_repo: PersonalDataRepository,
|
|
parental_leave_repo: ParentalLeaveRepository,
|
|
vacation_repo: VacationDaysRepository,
|
|
planned_leave_repo: PlannedLeaveRepository,
|
|
leave_wish_repo: LeaveWishRepository,
|
|
day_override_repo: DayOverrideRepository | None = None,
|
|
) -> None:
|
|
self._workspace_repo = workspace_repo
|
|
self._children_repo = child_repo
|
|
self._personal_data_repo = personal_data_repo
|
|
self._parental_leave_repo = parental_leave_repo
|
|
self._vacation_repo = vacation_repo
|
|
self._planned_leave_repo = planned_leave_repo
|
|
self._leave_wish_repo = leave_wish_repo
|
|
self._day_override_repo = day_override_repo
|
|
|
|
async def load(
|
|
self,
|
|
workspace_id: UUID,
|
|
today: date | None = None,
|
|
*,
|
|
only_pinned_existing: bool = False,
|
|
) -> AllocationInput:
|
|
"""Assemble the pure `AllocationInput`.
|
|
|
|
`only_pinned_existing` (§Task 4, see `PlanningEngineService.propose`)
|
|
restricts `existing_planned` — and everything derived from it here
|
|
(pool/vacation netting) — to rows that must stay immovable: pinned
|
|
rows (`is_pinned`) and ad-hoc rows with no `wish_id`. Every other
|
|
(unpinned, wish-attributed) row is left out entirely, so the
|
|
allocator treats that date as open and re-derives it fresh. Pinned
|
|
rows are *never* netted out of the pools/vacation budgets here even
|
|
when `only_pinned_existing` is False — the pure `_Ledger` does that
|
|
itself (`_reserve_pinned_days`), matching how it reserves preschool
|
|
planning days off the top, so the debit happens in one place
|
|
regardless of which mode loaded the input.
|
|
"""
|
|
today = today or date.today()
|
|
|
|
ws = await self._workspace_repo.get_by_id(workspace_id)
|
|
if ws is None:
|
|
raise NotFoundError(f"Workspace {workspace_id} not found")
|
|
|
|
child_entities = await self._children_repo.list_by_workspace(workspace_id)
|
|
parent_entities = await self._personal_data_repo.list_by_workspace(workspace_id)
|
|
wishes = await self._leave_wish_repo.get_by_workspace(workspace_id)
|
|
|
|
children = [_to_child_facts(c) for c in child_entities]
|
|
parents = [
|
|
ParentFacts(
|
|
uuid=p.uuid,
|
|
name=p.name,
|
|
salary_type=p.salary_type,
|
|
employment_status=p.employment_status,
|
|
min_vacation_days_per_year=p.min_vacation_days_per_year,
|
|
)
|
|
for p in parent_entities
|
|
]
|
|
|
|
rules = settings.rules
|
|
pools: dict[tuple[UUID, UUID], DayPool] = {}
|
|
existing_planned: list[PlannedLeaveDay] = []
|
|
# §fix (parent-reassignment moves dates, decision B) — the FULL,
|
|
# never-`only_pinned_existing`-filtered snapshot, always populated
|
|
# regardless of the flag; see `AllocationInput.all_existing_planned`'s
|
|
# docstring. Equal to `existing_planned` when `only_pinned_existing`
|
|
# is False.
|
|
all_existing_planned: list[PlannedLeaveDay] = []
|
|
|
|
for child in child_entities:
|
|
planned_for_child = await self._planned_leave_repo.list_by_workspace_child(
|
|
workspace_id, child.id
|
|
)
|
|
all_existing_planned.extend(planned_for_child)
|
|
if only_pinned_existing:
|
|
# Hide unpinned, wish-attributed rows entirely -- see the
|
|
# docstring above. Pinned rows and ad-hoc (no wish_id) rows
|
|
# stay visible/immovable either way.
|
|
visible_for_child = [
|
|
d for d in planned_for_child if d.is_pinned or d.wish_id is None
|
|
]
|
|
else:
|
|
visible_for_child = planned_for_child
|
|
existing_planned.extend(visible_for_child)
|
|
|
|
for parent in parent_entities:
|
|
latest = await self._parental_leave_repo.get_latest_by_parent(parent.uuid, child.id)
|
|
if latest is not None:
|
|
tier = latest.tier_data
|
|
sjuk_left = tier.sjukpenning_left
|
|
lagsta_left = tier.lagsta_niva_left
|
|
dubbel_left = latest.dubbeldagar_left
|
|
else:
|
|
# No FK snapshot yet: default this parent's share via the
|
|
# shared helper (see `default_tier_pool_share` docstring —
|
|
# matches the manual-entry convention in
|
|
# scripts/seed_demo.py and `fk_scraper.py`'s
|
|
# "= rules.lagsta_niva_days/2" comment).
|
|
sjuk_left, lagsta_left = default_tier_pool_share(rules, len(parent_entities))
|
|
dubbel_left = rules.max_dubbeldagar
|
|
|
|
# Net out days already committed locally (planned_leave_day)
|
|
# that an FK snapshot (if any) doesn't yet reflect, so the pure
|
|
# allocator never double-books or over-spends a resource.
|
|
# Pinned days are excluded here — the pure `_Ledger` debits
|
|
# those itself (`_reserve_pinned_days`), so this loader-side
|
|
# netting only ever covers non-pinned commitments (whichever
|
|
# of those `visible_for_child` still includes).
|
|
committed = [
|
|
d
|
|
for d in visible_for_child
|
|
if d.parent_personal_data_uuid == parent.uuid
|
|
and d.day_type in ("sjukpenning", "lagsta")
|
|
and not d.is_pinned
|
|
]
|
|
sjuk_committed = sum(1 for d in committed if d.day_type == "sjukpenning")
|
|
lagsta_committed = sum(1 for d in committed if d.day_type == "lagsta")
|
|
|
|
pools[(parent.uuid, child.id)] = DayPool(
|
|
sjukpenning_left=max(sjuk_left - sjuk_committed, 0),
|
|
lagsta_left=max(lagsta_left - lagsta_committed, 0),
|
|
dubbeldagar_left=dubbel_left,
|
|
)
|
|
|
|
horizon_end = _compute_horizon_end(today, children, wishes)
|
|
|
|
def _already_used_vacation(parent_uuid: UUID, year: int) -> int:
|
|
# Pinned vacation days are excluded here for the same reason as
|
|
# the FP pools above: `_Ledger._reserve_pinned_days` debits them
|
|
# itself.
|
|
return sum(
|
|
1
|
|
for d in existing_planned
|
|
if d.parent_personal_data_uuid == parent_uuid
|
|
and d.day_type == "vacation"
|
|
and d.date.year == year
|
|
and not d.is_pinned
|
|
)
|
|
|
|
vacation: dict[tuple[UUID, int], VacationBudget] = {}
|
|
for parent in parent_entities:
|
|
vac_entries = await self._vacation_repo.list(
|
|
personal_data_uuid=parent.uuid, workspace_id=workspace_id
|
|
)
|
|
entered_years = {vd.year for vd in vac_entries}
|
|
for vd in vac_entries:
|
|
vacation[(parent.uuid, vd.year)] = VacationBudget(
|
|
total_days=vd.total_days,
|
|
saved_days_in=vd.saved_days_in,
|
|
already_used=_already_used_vacation(parent.uuid, vd.year),
|
|
)
|
|
|
|
# A year inside the planning horizon with no `vacation_days` row
|
|
# means "the user has not told us yet", not "this person gets no
|
|
# holiday" — defaulting a missing year to 0 was what let the
|
|
# allocator report a shortfall for want of semester while the
|
|
# child's FP pool sat untouched (the same run also needs Task 1's
|
|
# fix, since a real 0-budget year must still fall through to FP).
|
|
# Default to the statutory entitlement and flag it as assumed
|
|
# (`is_assumed=True`) so the UI can prompt the user to confirm or
|
|
# override it instead of silently treating it as an entered value.
|
|
for year in range(today.year, horizon_end.year + 1):
|
|
if year in entered_years:
|
|
continue
|
|
vacation[(parent.uuid, year)] = VacationBudget(
|
|
total_days=rules.statutory_vacation_days_per_year,
|
|
saved_days_in=0,
|
|
already_used=_already_used_vacation(parent.uuid, year),
|
|
is_assumed=True,
|
|
)
|
|
|
|
# `strict=True`: never silently fall back to the live `holidays`
|
|
# library for a year outside `swedish_calendar.json`'s cached range —
|
|
# that fallback is missing de facto days (Julafton/Nyårsafton/
|
|
# Midsommarafton) and previously caused those to be charged as
|
|
# working days once a plan's horizon ran past the cache (see
|
|
# `app.utils.holidays.UncachedYearError`). With the cache now ~30
|
|
# years deep this should never fire for a realistic horizon, but a
|
|
# wish with a far-out `last_year` (uncapped when the workspace has no
|
|
# children yet) can still in principle reach past it. Rather than
|
|
# silently clamping the horizon (which would contradict the §6
|
|
# decision to plan past B4 and show the squeeze), surface it as a
|
|
# `ValidationError` the router turns into a 422 the UI can explain,
|
|
# the same way `CalendarService` handles an out-of-range `start_year`.
|
|
holidays_map: dict[date, str] = {}
|
|
try:
|
|
for year in range(today.year, horizon_end.year + 2):
|
|
holidays_map.update(get_swedish_holidays(year, strict=True))
|
|
except UncachedYearError as exc:
|
|
bounds = cached_year_bounds()
|
|
where = f"{bounds[0]}-{bounds[1]}" if bounds is not None else "(cache missing)"
|
|
raise ValidationError(
|
|
f"Planning horizon ({horizon_end.isoformat()}) extends beyond the cached "
|
|
f"Swedish calendar {where}; shorten the wish's last_year or the plan's "
|
|
"horizon so it stays within the cached range."
|
|
) from exc
|
|
|
|
day_overrides: dict[date, bool] = {}
|
|
if self._day_override_repo is not None:
|
|
overrides = await self._day_override_repo.list_by_workspace(workspace_id)
|
|
day_overrides = {o.date: o.is_working_day for o in overrides}
|
|
|
|
return AllocationInput(
|
|
today=today,
|
|
horizon_end=horizon_end,
|
|
age4_savable_cap=resolve_age4_savable_cap(len(parents)),
|
|
children=children,
|
|
parents=parents,
|
|
pools=pools,
|
|
vacation=vacation,
|
|
wishes=wishes,
|
|
existing_planned=existing_planned,
|
|
holidays=holidays_map,
|
|
day_overrides=day_overrides,
|
|
take_pl_on_red_days=ws.take_pl_on_red_days,
|
|
all_existing_planned=all_existing_planned,
|
|
)
|
|
|
|
|
|
class PlanningEngineService:
|
|
"""Thin orchestrator gluing the loader and the pure allocator together.
|
|
|
|
This is what the router calls. It contains no allocation logic of its
|
|
own — that all lives in `Allocator`, which stays pure and independently
|
|
testable.
|
|
"""
|
|
|
|
def __init__(self, loader: AllocationInputLoader, allocator: Allocator | None = None) -> None:
|
|
self._loader = loader
|
|
self._allocator = allocator or Allocator()
|
|
|
|
async def propose(
|
|
self,
|
|
workspace_id: UUID,
|
|
today: date | None = None,
|
|
*,
|
|
only_pinned_existing: bool = False,
|
|
) -> PlanProposal:
|
|
"""Load fresh input and run the pure allocator over it.
|
|
|
|
`only_pinned_existing` (used by `PlanningService.sync_plan`, §Task 4)
|
|
makes the loader hide every *unpinned*, wish-attributed
|
|
`planned_leave_day` row from `AllocationInput.existing_planned` (and
|
|
stop netting it out of the pools/vacation budgets) so the allocator
|
|
re-derives that portion of the plan from scratch instead of treating
|
|
it as an immovable fact — this is what lets a re-plan legitimately
|
|
move/retype previously-auto-placed days. Pinned days and ad-hoc
|
|
(`wish_id is None`) days are unaffected either way: always visible,
|
|
always immovable. `POST /api/plan/propose` never sets this — it
|
|
keeps its historical, unconditional behaviour.
|
|
"""
|
|
alloc_input = await self._loader.load(
|
|
workspace_id, today=today, only_pinned_existing=only_pinned_existing
|
|
)
|
|
return self._allocator.propose(alloc_input)
|