peter
82914b56ca
All three were measured before they were touched, and the diagnosis moved twice.
**Back from a Plex title played off Home landed on the Plex module's root.** One
click pushed three history entries: the page navigation, the sub-view opened by
the `jumpTo` hand-off, and — under StrictMode, whose effect body runs twice
before `setJumpTo(null)` re-renders — that same sub-view a second time. So the
first Back visibly did nothing and the second stranded the user on a Discover
page they had never visited.
A cross-module hand-off is the CONTINUATION of the navigation that brought you
there, not a second navigation, so it now REPLACES the page entry instead of
stacking on it (`useHistorySubview.open(view, {replace})`, asked for by the jump
target). Replacing is also idempotent, which is what disarms the StrictMode
double-run. The intent rides on `PlexJumpTarget` rather than being inferred,
because the header typeahead jumps from INSIDE the module, where the entry being
replaced would be a sub-view the user really was looking at.
**"Mást kérek" cycled nine cards and never left the resume tier.** Measured:
twelve presses, nine distinct titles, period nine, every one `tier: "resume"` —
the shelf and the surprise tier were unreachable by pressing the button. Two
causes multiplied: the tiers were tried in a fixed priority order over a 20-row
resume rail, so the button just walked down it; and the client's rolling
exclusion window of 8 guaranteed the wrap.
The press count now rotates which tier answers first (`start`), so each press
offers a different KIND of answer — the user's call, given the choice between
that, a wider window, and a surprise-only reroll. The fallthrough is kept, so a
press does not come back empty because the tier it led with had nothing. The
window is matched to the server's own cap rather than a smaller number of ours.
**A half-watched series on Home opened the show page.** A movie already went
straight to the player; only shows did not — and the comfort shelf and the hero
both resolved a show to its next episode while this rail alone did not, handing
back six seasons to choose between. The rail row now carries `next`, and the
client already played `next ?? card`, so this is a backend fix.
Affording it needed `queries.next_episode` to stop loading every episode of the
show into Python to pick one of them (236 rows for Friends, 227 for JAG) — three
ordered LIMIT 1 probes instead. The show→episode rule now lives in ONE function
(`rails.playable`), which is what the shelf, the hero and the rail all call; two
implementations are how they came to disagree.
Ten mutations run, all ten red for the right test — including a first pass where
the press count reached `api.discoverPick` and stopped there, invisible because
every Home test mocks that module. The slice now has its own URL test.
Verified in a clean browser tab against the live account: one Back returns to
Home, the rotation gives resume/comfort/surprise across nine presses with no
repeat, and Westworld opens at S1E1 rather than at its show page.
105 lines
4.9 KiB
Python
105 lines
4.9 KiB
Python
"""The hero: the single suggestion the Home surface leads with.
|
|
|
|
One rule, in one function, because the page's entire promise is that it answers rather than offers.
|
|
Three tiers, tried in order:
|
|
|
|
1. **resume** — something already started whose REMAINING time fits the budget. Almost always the
|
|
right answer: it is the thing the user themselves chose most recently, and finishing it costs no
|
|
decision at all.
|
|
2. **comfort** — a pinned shelf entry that fits. The user's own declared fallback, which beats
|
|
anything we could infer.
|
|
3. **surprise** — a seeded draw from what is unseen and fits.
|
|
|
|
That order is the PAGE's answer. "Mást kérek" rotates it (`start`), so each press offers a different
|
|
KIND of answer rather than the next row of the same list — the user's call, 2026-09-06, after the
|
|
button was measured cycling nine resume cards and never once reaching the shelf.
|
|
|
|
The tier travels with the card so the client can label it honestly ("Ott hagytad abba" vs "A
|
|
polcodról" vs "Meglepetés") instead of guessing from the shape of the payload — a kicker that says
|
|
"where you left off" over a film the user has never opened is exactly the kind of quiet lie the house
|
|
rules call a dishonest state.
|
|
|
|
Budgets are matched against REMAINING time throughout (`budget.remaining_seconds`, which equals the
|
|
runtime for anything not yet started): with eight minutes left, a 90-minute film is a ten-minute
|
|
answer.
|
|
"""
|
|
|
|
from sqlalchemy.orm import Session
|
|
|
|
from app.discover import cards, pins, rails
|
|
from app.discover.budget import fits
|
|
from app.models import User
|
|
|
|
HERO_TIERS = ("resume", "comfort", "surprise")
|
|
|
|
# How deep the surprise tier draws before giving up. Deliberately deeper than one, so an excluded
|
|
# pick moves the tier along instead of emptying it (the shuffle is seeded — the same seed always
|
|
# hands back the same order, so without the headroom "already shown" would mean "nothing left").
|
|
SURPRISE_DRAW = 12
|
|
|
|
|
|
def pick(
|
|
db: Session,
|
|
user: User,
|
|
budget: str,
|
|
seed: int,
|
|
*,
|
|
resume: list[dict] | None = None,
|
|
shelf: list[dict] | None = None,
|
|
exclude: set[str] | None = None,
|
|
start: int = 0,
|
|
) -> dict | None:
|
|
"""`{"tier": ..., "card": ...}`, or None when nothing at all fits.
|
|
|
|
`resume` and `shelf` may be passed pre-computed so the consolidated `/api/discover` response does
|
|
not build the same two rails twice; the reroll endpoint passes neither and pays only for what it
|
|
reaches.
|
|
|
|
`exclude` is what makes "Mást kérek" mean something. A new seed alone only re-draws the SURPRISE
|
|
tier: the resume tier deterministically returns the most recently progressed thing that fits, so
|
|
pressing reroll on a user who has something half-finished handed back the identical card and the
|
|
button looked dead (measured in the browser, 2026-09-06). Skipping the cards already shown makes
|
|
every press produce a different answer, at every tier.
|
|
|
|
`start` ROTATES which tier is tried first — 0 keeps the priority order (the page's own first
|
|
answer), 1 leads with comfort, 2 with surprise. Exclusion alone was not enough: the resume rail
|
|
holds up to 20 rows, so the button walked down it and never reached the shelf or a surprise at
|
|
all (measured, 2026-09-06: twelve presses returned nine cards, every one of them `resume`). The
|
|
fallthrough is kept, so a press does not come back empty just because the tier it led with has
|
|
nothing to offer."""
|
|
skip = exclude or set()
|
|
|
|
def _resume() -> dict | None:
|
|
for card in rails.continue_watching(db, user) if resume is None else resume:
|
|
playable = rails.playable(db, user.id, card)
|
|
# Excluded on the card the USER saw (the show), not only on what it resolves to, so a
|
|
# rerolled-past show does not come straight back as its own next episode.
|
|
if cards.key(card) in skip or (playable is not None and cards.key(playable) in skip):
|
|
continue
|
|
if playable is not None and fits(playable["remaining_seconds"], budget):
|
|
return playable
|
|
return None
|
|
|
|
def _comfort() -> dict | None:
|
|
for card in pins.playables(pins.shelf(db, user) if shelf is None else shelf):
|
|
if cards.key(card) not in skip and fits(card["remaining_seconds"], budget):
|
|
return card
|
|
return None
|
|
|
|
def _surprise() -> dict | None:
|
|
# A wider draw than the one card we need: the shuffle is seeded, so without the headroom an
|
|
# excluded pick would leave the tier empty rather than move past it.
|
|
for card in rails.surprise(db, user, budget, seed, limit=SURPRISE_DRAW):
|
|
if cards.key(card) not in skip:
|
|
return card
|
|
return None
|
|
|
|
tiers = {"resume": _resume, "comfort": _comfort, "surprise": _surprise}
|
|
offset = start % len(HERO_TIERS)
|
|
for tier in HERO_TIERS[offset:] + HERO_TIERS[:offset]:
|
|
card = tiers[tier]()
|
|
if card is not None:
|
|
return {"tier": tier, "card": card}
|
|
|
|
return None
|