jdZddlmZddlZddlZddlZddlmZdZdZ dZ d d dZ d Z d!d Z d"d Zd Zd ZdZdZdZdZdZed d#dZedd$dZd%dZdddded d&dZGddZGddZy)'u Which race is ON AIR — the broadcast's hand-over policy. A competition runs races back-to-back: the operator arms the next heat while the current one is still sailing. Two rules follow, and they are the whole of this module: 1. **Finish the race when the schedule permits it.** The broadcast stays with the race it is showing until the last boat finishes, or until fifteen presented race-seconds after the penultimate finisher. A server-side close remains the authority/fallback. 1a. **A permanently overlapping schedule may not create an ever-growing backlog.** A race that starts while another ordinary race is being followed to its finish is deliberately skipped, not shown late afterwards. When the current race ends, the programme takes the next race whose gun is still in the future. A fresh producer prefers that next future start over races already missed; if nothing is armed ahead, it falls back to the most recently started open race. 1b. **When there is time, the next future race is the one that starts next.** The ordinary queue is ordered by gun, not by the order races happened to be reported in. A race is not dropped merely because its fleet has not resolved yet or it is handed back unpresentable. 1c. **An isolated finish gets room to breathe.** If the last boat finishes with no other race running or armed, the completed race remains on air for one presented minute. A newly armed race may replace it as soon as its gun is within three minutes; otherwise the minute ends on the waiting presentation, which retains that same T−3 gate for the next race. 2. **Moving on is not restarting.** The producer rebuilds the presentation for the next race on the SAME server and the SAME SSE connection; the renderer swaps the race in place (`live/web/live_feed.js` → `onRaceChange`). No process restart, no page reload, no black screen. 3. **The next race goes up with its recent past already on the wire** (`coverage_window`). The renderer presents a fixed delay behind the data frontier, so a race published only from the join gives its cursor nothing to sit on and the picture holds one frame for the whole delay. Not a "restart", but indistinguishable from one to a viewer — which is what rule 2 is actually for. One caveat this module does not solve: the renderer fixes its world anchor, boat class and hull livery when the scene is CONSTRUCTED (`core/web/scene.js`), from the first race it is given. Every race of one regatta day shares those, so a day-long follow session is fine; a session handed a race at a different course centre would keep the first race's anchor. Both the production live producer (`serve_v3_live.py --follow`) and the sim's operator-driven bridge (`v3/sim/bridge_3d.py`) use this — one policy, so the sim exercises what production does. Pure over injected callables and an injected clock: the whole hand-over runs in tests with no servers, sockets or sleeps. ) annotationsN)Callablei i'`c<|xsgDcgc]9}|jd&|jd|jddvr|;}}tfd|Ddd}|rs|d }t|d t|d}}|xsij|} t |t z| t| t zn|t z} | kr i|d | | d Stfd |Dd} | r%| d } i| dt| dz dkrdiSdiSddiScc}w)anSelect the race identity the start-vessel camera should show. This is deliberately separate from the on-air queue: a new fleet can be starting while the main programme stays with the previous fleet through its finish. `rows` are the race plane's scoped open races. `all_started_utc_ms` is observed GNSS evidence, never an operator or clock guess. gunstopstate abandoned cancelledc3FK|]}t|dks|ywrNint.0rownow_mss =/srv/vr/releases/25f455cc4e75/v3/broadcast/live/race_queue.py z-select_start_camera_status..Fs E33s5z?f+D3E!!ct|dSNrrrs rz,select_start_camera_status..Gs#c%j/T)keyreverser instanceIdstarted)mode expiresUtcMsallStartedUtcMsc3FK|]}t|dkDs|ywrrrs rrz-select_start_camera_status..Ss FSSU_v-ESFrct|dSrrrs rrz,select_start_camera_status..TsCE Orrr!r countdownnextawaiting)getsortedstrrminSTART_CAMERA_POST_GUN_MAX_MS START_CAMERA_ALL_STARTED_HOLD_MS) rowsrall_started_utc_msrvalidpastlatestridrall_atexpiryfuturechosens ` rselect_start_camera_statusr:;sz"ZR ES*swwv/F!)CC EE E E%E14 AD avl+,c&-.@S$*//4S77*[#CC036R0RT F?/f/i'-/ /FEF35F \&\F5M(:V(Cv(M\ \SY\ \ J - Es>D) )zAnd now, back to the racing.zOch nu tillbaka till seglingen.)zWelcome back to the racing.u"Välkomna tillbaka till seglingen.)zWe are back with the racing.uVi är tillbaka med seglingen.)z-Now, let's return to the action on the water.u1Nu återvänder vi till händelserna på vattnet.)z#Welcome back. We rejoin the racing.u3Välkomna tillbaka. Vi återvänder till seglingen.)z/Back to the course now, and the race continues.u,Tillbaka till banan, där racet fortsätter.)zWe return now to the racing.u"Nu återvänder vi till seglingen.)z,Let's head back to the boats and the action.u0Vi går tillbaka till båtarna och händelserna.)z1Back on the water now, with the race in progress.u)Tillbaka på vattnet, där racet pågår.)z%Welcome back. Let's pick up the race.u,Välkomna tillbaka. Vi följer racet vidare.c TtDcgc]\}}d|||dddddc}}Scc}}w)zLThe ten short, neural-ready bridges used after an external programme insert.programme_returnensvlead structurereturn)typetexti18ncommentaryRoleclaimprogrammeAnchor)PROGRAMME_RETURN_COMMENTARYr=s rprogramme_return_commentaryrJms?6 7B(Bb=Q% PX Z 77 7s$cB|stStdt|dzS)u)When a race goes on air, as a lead on its gun — the start-countdown trigger. Derived from the event's own sequence rather than stated, because the length is an event fact (root `CLAUDE.md`): TRWC and the GSYS rehearsal sail four minutes, a club Saturday commonly three, and the hooter presets run to ten. The race office's ARM writes that future gun at the beginning of this window. That edge is the programme transition: before it the model is in its waiting presentation; from it the full opening, course guide and first race run from race-second zero. Delaying the picture until the preparatory signal classified a four-minute start as a late join and suppressed the very opening the waiting state exists to lead into. Boat cameras may still need their first minute to become available. The opening and course guide occupy that part of the programme and do not depend on a boat-camera tile; camera availability is advertised separately, so it must not delay the entire broadcast state machine. `None` (the event publishes no length) ⇒ `PRE_START_MS`. Unlike an ARM, a lead-in has a safe default: joining a race three minutes before its gun is at worst early or late coverage, never a wrong gun, so this is not the case that must refuse rather than guess. r) PRE_START_MSmaxr) pre_start_ss rannounce_lead_msrPss$&  q#k"T) **ri-<tail_sc t|}td|xsgD}|dks|syt ||k\r||dz S|dk\r%t ||dz k\r||dz t |zSy#ttf$rYywxYw)aSThe presented race second at which on-water coverage may end. The last verified finisher ends it at her crossing. If the last tracker or boat does not arrive, the penultimate crossing starts a bounded tail. The rule is fleet-size independent and returns ``None`` until enough boats have finished to make either statement. Nc3K|]C}t|ttfr+tjt|r t|EywN) isinstancerfloatmathisfinite)rsecs rrz&finish_handover_sec..s:T3!#U|4uSz9R#JTsA A r)r TypeError ValueErrorr+lenr\) finish_secsexpected_finishersrWexpectedvaluess rfinish_handover_secris)*T;+<"TTF1}F 6{hhl##1}V1 4hl#eFm33  z "s A,,A>=A>lag_scLtdt|t|z }||fS)u`(coverage_start_sec, first_published_sec)` for a race joined `elapsed_s` seconds in. `coverage_start_sec` is where the VIEWER's coverage of this race begins — the cursor's second at the moment the hand-over lands — and is what the opening beats and the line-up are paced from (`v3/scoring/programme.py` `race_open_beats(at_sec=…)`, `score_race.build_prestart_script( coverage_from_sec=…)`). `first_published_sec` is the first elapsed second to put on the wire. They are the same second: publishing from the coverage start is exactly what gives the cursor real data to sit on. Returned as a pair anyway, because the two are DIFFERENT questions — one is editorial, one is transport — and a future lag/back-fill split must not silently conflate them. r)rNr) elapsed_srkfirsts rcoverage_windowros' 3y>CJ. /E %<rctjdt|xsd}|rt|j dSdS)uJThe race's NUMBER for the opening beat ("Race 4. Ireland against Japan."), or None. Read off the race office's own label (`meta.raceName`) — the number the paperwork and the radio use — rather than counted by the producer, because a broadcast that started mid-day, or one following a course whose races are sailed out of order, would count something the audience does not recognise. A trailing integer is the number; anything else ("Heat A", a name with no digits) has none, and the opening says who is racing without numbering it instead of inventing one. z (\d+)\s*$r`N)researchr,rgroup) race_namems rrace_number_ofrws6 ,IO 45A3qwwqz?)T)rTF)ru first_raceleaving_race_nameresuming_from_waitingrkct||\}}t|}|t|xsdjxsd|t|xsdjxsdt|t |t d} |rd| d<| S)uThe `meta.programme` block a producer stamps on a race going on air. What the production layer needs in order to OPEN the race — which race this is, which race the broadcast is LEAVING to get here, whether the audience has been welcomed yet, and which second this broadcast's coverage of it begins (`v3/scoring/programme.py` `programme_beats`, and the line-up's pacing in `score_race.build_prestart_script`). `leaving_race_name` is the race that was on air until this moment. Only a producer knows it — the incoming feed has no memory of what preceded it — and without it the hand-over can only announce an arrival, never a departure: "Race 1007: Great Britain against Ireland" leaves a viewer who was following 1006 to work out for themselves that it has gone. None on the first race of a session, which leaves nothing. It rides the FEED's meta rather than a producer's boot configuration because every field is a fact about THIS hand-over: a producer built once at start-up cannot know which second the next race will be joined at. Built here so the production producer and the simulator's bridge stamp the same block — the opening is part of the hand-over policy, not of either driver. A race hand-over never requests a route tour. Periodic course orientation belongs to the waiting programme, where its narrated chapters have time to run and yield to an approaching start instead of producing an unreadable transition sweep.rjrqN)coverageStartSec raceLabel raceNumberleavingRaceLabelleavingRaceNumber firstRacereturnCommentaryTresumingFromWaiting)rorwr,stripboolrJ) rmrurxryrzrk coverage_sec_ race_numberouts rprogramme_metars2&iu=OL! +K+Y_"-335=% #$5$; < B B D L!/0A!Bj) ; = ?C%) !" Jrc eZdZdZedeeeee e jd ddZ e ddZ ddZddZddZdd Zdd Zdd Zdd Zdd ZddddZd dZd dZddddZddd!dZy)" OnAirQueueu The race currently ON AIR, and the ones waiting. Releases (a race whose start signal has gone) are `offer`ed as they happen; `take_next` returns the race to put up, or None to stay with the one on air. Structured scorer progress keeps it on air until the last finisher or bounded penultimate tail reaches the delayed viewer cursor. A legacy winner-only producer retains `winner_hold_s`; a server-close without a finish retains `min_air_s`, so an abandoned or unobservable race cannot wedge the programme. With nothing waiting, a complete last-boat finish stays up for one minute and then yields to the waiting presentation — the broadcast is never blank. A race newly armed inside T−3 takes over directly; an earlier arm remains behind the waiting presentation until that threshold. **The one exception: a PRIORITISED race.** The race office marks a final, a decider or a medal race, and that race takes the air at `PRIORITY_LEAD_MS` before its gun even if another race is showing. The interrupted race returns to its start-ordered queue place; priority changes which race is shown now, never which accepted races are silently discarded. Among prioritised races the LATER gun wins the immediate cut and the earlier one remains queued.N) winner_hold_s min_air_spresentation_lag_s finish_tail_sresult_visible_sisolated_finish_hold_spost_finish_next_lead_msnow_fnct||_t||n||_t||_t||_t||_t||_t||_||_ g|_ d|_ d|_ d|_ d|_d|_d|_d|_d|_i|_d|_y)NgF)r\rrrrrrrr_now_pending_on_air _on_air_at_won_at_structured_progress _finish_ready_finish_ready_at_isolated_full_finish_wait_for_close_start _priority _on_air_gun) selfrrrrrrrrs r__init__zOnAirQueue.__init__:s#=1 0A}yQ"'(:";"=1 %&6 7&+,B&C#(+,D(E% %' #' !$%) $)!".2&+"&+" +-'+rc|jSrZ)rrs ron_airzOnAirQueue.on_air]s ||rc4t||j|<y)uThe race office's `priority` flag for a race, as of this tick. Called every tick from the operator's rows, not only when a race is offered, because the flag is set on the water while racing is under way: a race marked at T−5 is already pending, and one UNmarked mid-race must stop being protected at once. A queue that learned the flag only at `offer` would honour a decision the race office had already changed its mind about.N)rr)rinstanceprioritys r set_priorityzOnAirQueue.set_priorityas$(>x rct|jdz}d}|jD]_}|d|d}}||jj |s+|t|t z krA|t|t|dkDs^|}a|y|j V|jj |j r1|j%t|dt|jkry|S)uThe prioritised race that may take the air *right now*, or None. Checked before the ordinary hand-over and independently of `done()` — that is the whole of what priority means. Three conditions, in order: the race is flagged and its T−2 has come; among several such it is the one with the LATEST gun; and if the race already on air is itself prioritised, only a strictly later gun may cut it. An unprioritised race on air is cut by any of them.rLNrr`)rrrrr*PRIORITY_LEAD_MSrr)rrbestprrs r _preemptorzOnAirQueue._preemptorjsTYY[4'( AaD!A$cH{$.."4"4X">C#333|s3x#d1g,6  < LL $););DLL)I$$0Sa\SIYIYEZ5Z rc|jDcgc] }|d|k7s |c}|_|jj||g||jjd|jduxr||jk7Scc}w)uA released race joins the queue **in start order** (`rest` is carried through to `take_next` untouched — e.g. the sim's release base). Returns True if it has to WAIT because something else is on air. A re-arm of an already-waiting race supersedes its earlier release. THE ORDER IS THE GUN'S, NOT THE QUEUE'S. This used to append, so the order was whichever order races happened to be *reported* in — and two things reorder that against the racing: a race handed back because it was not ready yet (no fleet resolved) went to the BACK, behind races that started after it; and a race armed out of order, or re-armed to an earlier gun, arrived late and stayed late. Either way the broadcast could move from one race to a race that started after the one it skipped, which is not following the regatta. Sorting on every offer is trivially cheap (a queue is a handful of races) and it means the invariant holds by construction rather than by every caller remembering it.rc"|ddu|dxsdfSNr`rrs rrz"OnAirQueue.offer..s!A$$,! )Brr&N)rappendsortr)rrrrestrs rofferzOnAirQueue.offers|%)MMFqQqTX5EF  h3d34 BC||4'DH ,DD Gs BBcF|jDcgc]}|d c}Scc}w)Nr)r)rrs rwaitingzOnAirQueue.waitings"mm,!,,,s ct|jdz}|jD]%} t|d}||z |j ks%yy#ttf$rY:wxYw)zXWhether any queued race is already running or no farther away than the post-finish lead.rLr`TF)rrrrbrcr)rrpendingrs r_has_close_startzOnAirQueue._has_close_startsqTYY[4'(}} G '!*oV|t<<<   z*  sAA$#A$c|jDcgc] }|d|k7s |c}|_|jj|dycc}w)u_Forget a pending race entirely — for a race the RACE PLANE no longer lists. `offer` files and `take_next` pops, but nothing ever removed a race that stopped existing: an operator pruning instances under a running producer left the deleted race's entry at the head of a start-ordered queue (oldest gun first), where the hand-back loop re-offered it every poll — silently, its NO-BOATS refusal long since logged once — and every race behind it starved. Measured 2026-08-10: a producer that "waited" for hours behind a race that had been deleted at 08:05.rN)rrpop)rrrs rdropzOnAirQueue.drops?%)MMFqQqTX5EF  8T*Gs AAcN|r#|j|j|_yyy)a Legacy result-only input used by old simulations and callers. Production supplies structured finisher progress through :meth:`note_finish_progress`; this boolean remains as an availability fallback for a scorer that cannot name its finishers. N)rr)r has_winners r note_resultzOnAirQueue.note_results$ $,,.99;DL/:rc|t|tsyd|_|j|j |_|j dxsgDcgc]#}t|tr|j d%}} t |j dxsd}|Dcgc]8}t|t tfr tjt|r|:}}t|||j}|t|t tfrtjt|rnt||jz |k\rR|js>|j |_|dkDxrt#||k\xr |j$ |_d|_yyyyycc}w#ttf$rd}YwxYwcc}w)aaUpdate the lag-aware last/penultimate hand-over gate from the scorer's live result. ``frontier_sec`` is source race-time. The viewer presents ``frontier - lag``; requiring it to reach the target is what prevents a 15-second source-side timeout from cutting away before the audience has even seen the penultimate finish. NT finishers finishSecexpectedFinishersrrV)r[dictrrrr*rrbrcr\r]r^rirrrrrdrr) rresult frontier_secrrergr_verified_finisherstargets rnote_finish_progresszOnAirQueue.note_finish_progresss&$' $(! << 99;DL8> ;8O8USU1$S$/ww{+1 1 6::&9:?a@H.9^c!+C#u!>4==QVWZQ[C\"^^$ $*<*<>  :lS%L#IMM% "56,'$*A*AAVK%%(, %qL^S);%<%H^QUQ^Q^M^*!%D  L7$J 1:& H ^s(F<F!=F9!F65F6Foverc`|jy|j}|jry|jy||jz }|jrB|j r||j k\S|t|j |jk\S||j k\S|jr9t|xr,|jduxr||jz |jk\S|j||jz |jk\S|xr||jz |jk\S)uHas the race on air finished its story — a scored winner plus the hold on the finish, or it closed without one (`over`) and has had its minimum airtime? Answered whether or not anything is waiting, because the two cases differ: with a race queued the producer hands over to it; with NOTHING queued it must return to the waiting presentation rather than sit frozen on the result for ever (`release()`). Nothing on air ⇒ trivially done.NTF)rrrrrrrrNrrrrrrr)rrnowelapseds rdonezOnAirQueue.dones& << iik   $$,D111G))((*"d&;&;;;#d&;&;T=X=X"YYYd333 3  $ $ET!9E$,,.$2D2DDF F << #%););; ;?doo-??rctd|_d|_d|_d|_d|_d|_d|_d|_y)uNothing is on air any more — the producer went back to the waiting presentation. The next release goes up immediately instead of queueing behind a race that is no longer showing.NF)rrrrrrrrrs rreleasezOnAirQueue.releasesB  $)!" $%*"%*"rcJ|j}|j||_y)uVRelease an expired isolated finish while retaining its T−3 gate in the waiting view.N)rrr)rkeep_close_start_gates rrelease_to_waitingzOnAirQueue.release_to_waitings $ : : %:"rc|j|j|sy|jsy|jxr|j S)uWhether the completed on-air race should yield to the waiting presentation now. An ordinary completed race does so only when no race is queued. An isolated full finish also does so when its minute has expired but every newly armed race is still outside T−3. rFT)rrrrr)rrs rwaiting_view_duezOnAirQueue.waiting_view_due sE << tyydy';}}))I$2G2G2I.IIrc|j}||jj||jl|j|dk7rZ|jN|jj |j|jf|jj d|d|dc|_|_|jdc|_|_ d\|_ |_ d|_ d|_ d|_|S|j$|jr|jsyd|_|jr|j!|sy|j|jr|jsyt#|jd z}|jx|jDcgc]}|d t#|d|ks|}}|rEt%|d }|jj||jj'd||jj)d}|d|dc|_|_|jdc|_|_ d\|_ |_ d|_ d|_ d|_|Scc}w) uKThe race that started NEXT, or None to stay put. `over` = the on-air race closed WITHOUT a scored winner. Always the head of a start-ordered queue, so the broadcast follows the regatta in the order it is sailed and never steps over a race. A race the caller then finds it cannot present yet must be handed back with `release()` + `offer()`, which returns it to its own place — NOT to the back of the queue, and never simply dropped. **A prioritised race jumps this entirely** (`_preemptor`), whether or not the race on air is done. The interrupted race is re-queued at its original gun: the flag means "show this now", not "erase the programme item currently showing". Once the producer has accepted a race into its live programme, no later gun may silently erase it.Nrc"|ddu|dxsdfSrrrs rrz&OnAirQueue.take_next...s!A$$,! 1Jrr&r`)FFFrrLct|dSNr`rrs rrz&OnAirQueue.take_next..LsC!Ir)rrremoverrrrrrrrrrrrrrrr-insertr)rrprerrr oldestnxts r take_nextzOnAirQueue.take_nextsBoo ? MM  % (T\\SV-C((4 $$dllD4D4D%EF ""'J"K-0VSV *DL$*,0IIK )DOT\$>((*).D &}}DII4I$8 << #(B(B4K`K`KbTYY[4'( <<  #'--\Q1Q43CAaD U[H[q\G\W*=> $$V, $$Q/mm"),QQ& d&(, T%8D5!4#5 $%*"%*" ]s, J 7J  J )rr\r float | Nonerr\rr\rr\rr\rrrzCallable[[], float]rBNone)rB str | None)rr,rrrBr)rB tuple | None)rr,rBr)rBz list[str])rBr)rr,rBr)rrrBr)rz dict | NonerrrBr)rrrBr)rBr)rrrBr)__name__ __module__ __qualname____doc__ RESULT_HOLD_SPRESENTATION_LAG_S FINISH_TAIL_SRESULT_VISIBLE_SISOLATED_FINISH_HOLD_SPOST_FINISH_NEXT_LEAD_MStimerpropertyrrrrrrrrrrrrrrrrrrr'sP$2?Z^-?(5+;1G1I/3yy !,%*!, %!,$)!,*/ !, ,/ !, - !, >B !,F22E*-  +'&>$)@> +; 05 J).>rrc eZdZdZdddddddd d d Zd d ed d d  ddZddZeddZ ddZ ddZ d dZ d!dZ d"dZddZddZd#dZd$dZd%dZy )& StartedRacesuThe operator's races on one course, reported as they GO OFF. `list_instances()` returns the management rows (`store.list_race_instances(...)` or the wire rows of `GET /v3/manage/instances`); `poll()` returns every race whose START SEQUENCE has begun since the last call — gun set, no stop, not abandoned or cancelled, and now within `lead_ms` of the gun — oldest gun first, so the queue airs them in the order they are sailed. `closed()` answers the other half of the hand-over: whether the race on air has been stopped or abandoned by the operator. A race goes on air DURING its pre-start rather than at its gun: the sequence IS broadcast material (the opening, course guide, countdown, fleet setting up and line approach), and waiting for the gun would put the race on screen already started. Specifically it joins on the race office's start-countdown trigger (`announce_lead_ms`) at the beginning of the event's declared sequence. A race scheduled further out than that simply waits until its sequence reaches that point. A race whose gun is MOVED after it was reported is reported again (the operator re-armed it); one that is stopped and re-armed likewise. That is what makes it safe to leave the producer running for a whole regatta day.)r instance_idid)officialStartUtcMsofficial_start_utc_ms)officialStopUtcMsofficial_stop_utc_ms) raceState race_state)courseId course_id) ownerUserId owner_user_id ownerUsername)name)r)preliminaryWinnerTeamIdpreliminary_winner_team_id) rrrr courseownerrr preliminaryN)rrlead_ms pre_start_forrc||_|xsd|_|xsd|_t||_||_i|_|xsd|_i|_i|_ dddd|_ y)NcBttjdzS)NrL)rrrrrrz'StartedRaces.__init__..s#diikD.@*Arr)listedin_scopeeligible) _listrrrr _pre_start_for_pre_start_cache_now_ms _reported_rows last_stats)rlist_instancesrrr r rs rrzStartedRaces.__init__sn$ #*d]d 7| ,79B"A )+&( &'A1Erc|j |jS||jvr |j||j|<|j|}|r t |S|jS#t$r|jcYSwxYw)uhThis race's own lead-in — `announce_lead_ms` of its event's sequence, else `lead_ms`. Per race rather than per producer: a broadcast following an operator can see races from more than one event, and their sequences need not agree. Memoised because a race does not change event, and this is asked of every race on every poll. )rr r ExceptionrP)rrrs rlead_forzStartedRaces.lead_fors    &<<  d33 3 $595H5H5U%%k2##K0(+$== $||# $sA..BBc|j|D]8}t|tr ||vs||cSt||s,t ||cSyrZ)_FIELDSr[rhasattrgetattr)clsrrrs r_getzStartedRaces._getsQKK$ *D#t$3;t9$d#sD))  * rc ni}d}|jxsgD]}|j|d}||dz }|j!|j|dd|jfvrJ|j!|j|dd|jfvrw|j|d|j|d|j|d|j|d t |j|d |j|d d ||<||j d <t ||j d<||_|S)Nrrr`rrrrr rrr )rrr rrr rr)rr!rrrrrdr)rr0rrr5s r _snapshotzStartedRaces._snapshots1JJL&B GC))C&C{ aKF~~)diiX.FtUYUcUcNd.dzz%$))C*A$PTPZPZI[*[ $ #u 5tyyf?U"&))C"9499SRXCY%)$))C*D%E(, #}(EGDI G%+!&)$i #  rc||jvS)uDoes the race plane still LIST this race (as of the last snapshot)? The other half of `OnAirQueue.drop`: the queue cannot know a race was deleted — only the watcher reads the plane — so the follow loop asks here before re-offering a race it had to hand back. Distinct from `closed()`: a stopped race existed and is over; a vanished race was deleted out from under the broadcast (an operator's prune) and must simply be let go.)r)rrs rlistszStartedRaces.listssdjj((rc|j}g}d}|jjD]\}}|d|d|d}}}|||dvs||j|z |kDr5|dz }|jj ||k(rY||j|<|j |t|f||jd<t|d S) zv`[(instance_id, gun_ms)]` for every race whose start sequence has begun since the last poll, oldest gun first.rrrr r r`rc |dSrrrs rrz#StartedRaces.poll..s 1rr&) rr#itemsrrr*rrrr+) rrrrr5rrrr s rpollzStartedRaces.pollslln(..0 (HC"5z3v;G uC t/5@Dzz?O?O?QR83T#''*-..RRRs%Ac|jjDcgc]\}}d|it|c}}Scc}}w)zIScoped race-plane rows for the independent start-vessel overlay selector.r)rr(rr+s rstart_camera_rowszStartedRaces.start_camera_rowss5AEAQAQASTXS#s0d3i0TTTs;c^|jj|}|y|dduxs|ddvS)zUTrue once the operator has stopped or abandoned this race (the last snapshot's view).NFrr r rr*rrrs rclosedzStartedRaces.closeds:jjnn[) ;6{$&T#g,:T*TTrcd|jj|}t|duxr|ddvS)aTrue only when the race plane explicitly says this race must not be presented. A stop timestamp is deliberately *not* cancellation. Normal completed races receive the same timestamp, and an overlapping race may finish while it waits behind the programme race. Removing every stopped pending race silently skipped that completed race. Only the race office's explicit abandoned/cancelled state authorises dropping it from the broadcast queue. Nr r )rr*rr1s rr zStartedRaces.cancelled s4jjnn[)CtORG 8R(RSSrc|jj|xsi}|jd|jdfS)zLThe race plane's preliminary winner and stop time from the current snapshot.r rr0r1s rpreliminary_resultzStartedRaces.preliminary_results5jjnn[)/Rww}%swwv66rc|j}|jjDcgc] }|d|d|kDr|d |ddvr|d"}}|rtt |SdScc}w)aThe earliest FUTURE gun on the plane (last snapshot): a race ARMED and counting down, None when nothing is. This is both the waiting picture's recall signal and the programme transition: the same ARM that recalls an idle excursion starts the full race presentation.rNrr r )rrrhrr-)rrrgunss r next_gun_mszStartedRaces.next_gun_msslln&*jj&7&7&9\su:)c%j3.>K'CL@Z,ZE \\"&s3t9~/4/\s%A,cJ|jj|}|r|dSdS)Nrr0r1s rname_ofzStartedRaces.name_of$s%jjnn[)!s6{+t+r)rzCallable[[], list]rrrrr rr z"Callable[[str], int | None] | NonerzCallable[[], int] | NonerBr)rr,rBr)rr,)rBzdict[str, dict])rr,rBr)rBzlist[tuple[str, int]])rBzdict[str, bool]rB list[dict])rr,rBztuple[str | None, int | None])rB int | None)rr,rBr)rrrrrrMrr classmethodr!r#r%r)r,r.r2r r5r8r:rrrrrYs<9ED3?XIS\(W YGW[%),EI48F"F47F BF2F>BF@>"*)/:SUU T7 0,rrrZ)r0r<rrr1zdict[str, int] | NonerBrr;)rOr=rBr)rezlist[float] | tuple[float, ...]rfrrWr\rBr)rmrrkrrBztuple[int, int])rurrBr=)rmrrurrxrryrrzrrkrrBr)r __future__rr]rrrcollections.abcrrMr/r.r:rIrJrPrrrrrrrrirorwrrrrrrrAs'P# $ $* %LP 3H TX H 7 +<      #,9#(=I.5G  *?CW[3716 2*&0**.**8<*Zood M,M,r