fix(vegas): stop the heaviest plugin doubling across the cycle seam

Smooth Weighted Round-Robin spaces repeats well within a pass, but it
schedules the heaviest item first and usually last as well. The strip
loops, so those two are neighbours: the marquee showed the same plugin
twice running at exactly the one join a within-cycle check cannot see.
Observed on a live rig at 28 slots -- gaps of 6, 7, 7, 7 and then 1.

Rotating the list does not fix it. Rotation preserves the cyclic order
exactly, so it moves where the seam is drawn rather than the adjacency
itself; the trailing entry has to be swapped with one from the middle.

The first version swapped with the first slot that merely fitted, which
undid the spacing this exists to protect -- it moved a repeat from a gap
of 7 into a gap of 2, more clumped than the seam had ever been. It now
picks the candidate furthest from any other appearance, so the repeat
lands in the widest gap.

Left alone when no candidate exists. A plugin holding most of the slots
has to neighbour itself, and scheduling it is better than refusing to.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Udr6MfaFLUPhX5Fgo67Jf5

README.md

@@ -600,14 +600,6 @@ These settings are typically only needed for non-standard panels or custom confi
   - Leave empty unless you need custom mapping
   - See rpi-rgb-led-matrix documentation for full options
 
-- **`orientation`** (string, default: "normal")
-  - Rotates the rendered image to match how the panel is physically mounted
-  - Set to `"180"` (or use the "Upside Down" option in the web UI's Display
-    settings) if the panel is mounted upside down — useful for optimizing
-    where the Raspberry Pi and wiring sit relative to the mounting location
-  - Applied independently of `pixel_mapper_config` (appended as a trailing
-    `Rotate:180` mapper), so custom mapper configs keep working alongside it
-
 - **`row_address_type`** (integer, default: 0)
   - How rows are addressed on the panel
   - Most panels use 0 (direct addressing)

config/config.template.json

@@ -112,7 +112,6 @@
             "led_rgb_sequence": "RGB",
             "limit_refresh_rate_hz": 100,
             "pixel_mapper_config": "",
-            "orientation": "normal",
             "row_address_type": 0,
             "multiplexing": 0,
             "panel_type": ""
@@ -130,6 +129,9 @@
         "plugin_rotation_order": [],
         "use_short_date_format": true,
         "vegas_scroll": {
+      "live_in_ticker": false,
+      "live_weight": 3,
+      "favorite_live_weight": 5,
             "enabled": false,
             "scroll_speed": 50,
             "separator_width": 32,

docs/ADVANCED_FEATURES.md

@@ -64,10 +64,98 @@ JSON is optional.
 | `target_fps` | `125` | Target frame rate |
 | `buffer_ahead` | `2` | Number of plugins buffered ahead |
 
-This table is a subset — `display.vegas_scroll` supports 26 keys in
+This table is a subset — `display.vegas_scroll` supports 30 keys in
 total. See the full list in
 [CONFIG_REFERENCE.md](CONFIG_REFERENCE.md#displayvegas_scroll--continuous-scroll-mode).
 
+### Live Content in the Ticker
+
+By default, live content **preempts** Vegas mode: while any plugin reports
+live priority, the display controller refuses to run the ticker and shows
+that plugin's full-screen display instead. You get a big readable scoreboard,
+but the marquee stops entirely for the duration of the game.
+
+Set `live_in_ticker` to keep the ticker running and let live content take
+**extra turns inside it** instead:
+
+```json
+"vegas_scroll": {
+  "live_in_ticker": true,
+  "live_weight": 3,
+  "favorite_live_weight": 5
+}
+```
+
+#### Why weights exist
+
+The rotation is otherwise a strict round robin — every plugin appears exactly
+once per cycle. With a dozen plugins enabled, a live score comes round once a
+lap and can be minutes old by the time you see it. A weight of *N* gives a
+plugin *N* slots per cycle.
+
+The slots are placed by **Smooth Weighted Round-Robin**, the same scheduler
+the sports plugins use internally to rotate their own games. The important
+property is that repeats are *spread through the cycle* rather than clumped:
+three appearances in a row followed by a long silence would be worse than not
+boosting at all.
+
+Twelve plugins, with a favorite's baseball game and an ordinary live hockey
+game (`live_weight: 3`, `favorite_live_weight: 5`):
+
+```
+baseball > hockey > weather  > clock  > baseball
+stocks   > news   > flights  > baseball > hockey
+calendar > f1     > music    > baseball > tides
+birds    > hockey > baseball
+```
+
+18 slots for 12 plugins. Baseball appears 5 times, hockey 3, everything else
+once, and no plugin ever appears twice in a row — **including across the seam**
+where the cycle loops back on itself. Smooth Weighted Round-Robin schedules the
+heaviest item first and usually last as well, so the strip would otherwise show
+it twice running at exactly the one join a within-cycle check cannot see. The
+trailing repeat is moved into the widest remaining gap. Where a double is
+unavoidable — a plugin holding most of the slots has to neighbour itself — the
+schedule is left as it is.
+
+#### Where the weight comes from
+
+For each plugin in the rotation, in order:
+
+1. **The plugin's own answer.** If it implements
+   `get_vegas_priority_weight()` and returns a number, that wins. This is the
+   only route for favorite-team awareness — the core can see *that* a game is
+   live, but not *whose*, so a scoreboard has to say so itself.
+2. **The core's default.** When the plugin returns `None` (the base-class
+   default), a plugin where both `has_live_priority()` and `has_live_content()`
+   are true gets `live_weight`.
+3. **Everything else** gets 1.
+
+Because of step 2, **existing plugins need no changes** — any scoreboard with
+`live_priority` enabled already gets extra turns. Step 1 is opt-in, for
+plugins that want to distinguish a favorite's game from any other live game.
+
+Weights are clamped to 1–10. A weight of 1 is no boost; a weight below 1 would
+drop the plugin from the rotation entirely, which is never what is meant.
+
+#### Things worth knowing
+
+- **Weights are per plugin, not per game.** A scoreboard showing four live
+  games still occupies one slot at a time, rotating its own games within that
+  slot using its own `favorite_live_boost`. This controls how often the
+  *plugin* comes round.
+- **The ticker is zero-sum.** Giving baseball 5 slots does not make the cycle
+  faster; it makes the cycle *longer* and everything else proportionally
+  rarer. If you want live scores sooner in wall-clock terms, pair this with a
+  smaller `plugins_per_cycle`.
+- **Frequency is not freshness.** Each appearance redraws from the plugin's
+  current data (`refresh_updated_plugins()` drops cached content when a
+  plugin's data changes), but how current that data is depends on the
+  plugin's own `live_update_interval`. Showing a stale score five times a lap
+  is no better than showing it once.
+- **Everything still appears.** A boost never starves another plugin out of
+  the cycle; low-weight plugins keep their single slot.
+
 ### Per-Plugin Configuration
 
 Override Vegas behavior for specific plugins:

docs/CONFIG_REFERENCE.md

@@ -66,7 +66,6 @@ in `DisplayManager` (`src/display_manager.py`, ~lines 270–295).
 | `led_rgb_sequence` | string, `"RGB"` |
 | `limit_refresh_rate_hz` | int, `100` (code default 90) |
 | `pixel_mapper_config` | string, `""` — e.g. `"U-mapper"` / `"Rotate:90"` |
-| `orientation` | string, `"normal"` — `"180"` rotates the rendered image 180° for panels physically mounted upside down (e.g. to move the Pi/wiring to a more convenient side); composed onto `pixel_mapper_config` as a trailing `Rotate:180` mapper, so it stays independent of any custom `pixel_mapper_config` value |
 | `row_address_type` | int, `0` — non-standard panel row addressing |
 | `multiplexing` | int, `0` — panel multiplexing scheme |
 | `panel_type` | string, `""` — set to `"FM6126A"` or `"FM6127"` for panels needing init |
@@ -104,7 +103,8 @@ logical image to multiple chained physical panels.
 ## `display.vegas_scroll` — continuous scroll mode
 
 Read by `src/vegas_mode/config.py` (`VegasScrollConfig.from_config`). See
-[ADVANCED_FEATURES.md](ADVANCED_FEATURES.md) for behavior details.
+[ADVANCED_FEATURES.md](ADVANCED_FEATURES.md) for behavior details, including
+[live content in the ticker](ADVANCED_FEATURES.md#live-content-in-the-ticker).
 
 | Key | Type / default |
 |---|---|
@@ -135,6 +135,9 @@ Read by `src/vegas_mode/config.py` (`VegasScrollConfig.from_config`). See
 | `max_cycle_duration` | int, `240` |
 | `frame_based_scrolling` | bool, `true` — frame-count-based scroll stepping |
 | `scroll_delay` | float, `0.02` — seconds between scroll updates (~50 FPS) |
+| `live_in_ticker` | bool, `false` — keep scrolling during live games instead of handing the display to a full-screen scoreboard |
+| `live_weight` | int, `3` (1–10) — slots per cycle for a plugin with live content |
+| `favorite_live_weight` | int, `5` (1–10) — slots per cycle when a plugin reports a favorite team is live |
 
 ## `sync` — multi-display synchronization
 

docs/PLUGIN_API_REFERENCE.md

@@ -170,6 +170,47 @@ Default returns `False`.
 List of display modes to show during a live takeover. Default returns the
 plugin's `display_modes` from its manifest.
 
+#### `get_vegas_priority_weight() -> Optional[int]`
+
+How many slots per Vegas cycle this plugin should get. Default returns
+`None`, which defers to the core.
+
+The Vegas ticker is otherwise a strict round robin — every plugin appears
+exactly once per cycle — so with a dozen plugins enabled a live score can be
+minutes stale by the time it comes round. A weight of *N* gives the plugin
+*N* slots per cycle, spread evenly through it rather than clumped.
+
+**You usually do not need this.** When the hook returns `None`, the core
+already gives a plugin `vegas_scroll.live_weight` whenever
+`has_live_priority()` and `has_live_content()` are both true. Live sports get
+extra turns with no code at all.
+
+Implement it only when the plugin knows something the core cannot. The
+motivating case is favorite teams — the core can see *that* a game is live,
+but not *whose*:
+
+```python
+def get_vegas_priority_weight(self):
+    if not (self.has_live_priority() and self.has_live_content()):
+        return None                       # let the core decide
+    vegas = self.global_config.get('display', {}).get('vegas_scroll', {})
+    if self._favorite_is_live():
+        return vegas.get('favorite_live_weight', 5)
+    return vegas.get('live_weight', 3)
+```
+
+The weight is per *plugin*, not per game: a scoreboard showing four live games
+still occupies one slot at a time and rotates its own games within it. Values
+are clamped to 1–10 by the caller. An exception here is caught and logged, and
+the core then falls back to its own live-content check — so a plugin whose
+weight calculation is broken still gets `live_weight` for a game that really
+is live, rather than being demoted to 1.
+
+Only consulted when the user has set `vegas_scroll.live_in_ticker`. With the
+default (`false`) live content preempts Vegas entirely and there is no ticker
+to be weighted within. See
+[ADVANCED_FEATURES.md](ADVANCED_FEATURES.md#live-content-in-the-ticker).
+
 ### Vegas scroll hooks
 
 Vegas mode shows multiple plugins as a single continuous scroll instead of

src/base_odds_manager.py

@@ -44,24 +44,6 @@ class BaseOddsManager:
         self.config_manager = config_manager
         self.logger = logging.getLogger(__name__)
         self.base_url = "https://sports.core.api.espn.com/v2/sports"
-
-        # This path used a bare requests.get, so it identified itself as
-        # python-requests/x.y -- the one thing ESPN is known to reject. Around
-        # 2026-08-04 it began 403ing browser strings and bare custom tokens
-        # alike; what it accepts is a token with a URL that says who is
-        # calling. Every other ESPN caller in the tree already sends this
-        # (src/common/api_helper.py, src/base_classes/data_sources.py); the
-        # odds path was simply missed, and it is the one whose failures cost
-        # the caller its whole update budget.
-        #
-        # Deliberately no retry adapter, unlike api_helper: retries multiply
-        # request_timeout, which is set to 5s precisely to stay inside that
-        # budget. One try, then the cooldown below.
-        self.session = requests.Session()
-        self.session.headers.update({
-            'User-Agent': 'LEDMatrix/1.0 (+https://github.com/ChuckBuilds/LEDMatrix)',
-            'Accept': 'application/json',
-        })
         
         # Configuration with defaults
         self.update_interval = 3600  # 1 hour default
@@ -162,7 +144,7 @@ class BaseOddsManager:
             url = f"{self.base_url}/{sport}/leagues/{espn_league}/events/{event_id}/competitions/{event_id}/odds"
             self.logger.info(f"Requesting odds from URL: {url}")
             
-            response = self.session.get(url, timeout=self.request_timeout)
+            response = requests.get(url, timeout=self.request_timeout)
             response.raise_for_status()
             raw_data = response.json()
 

src/cache/disk_cache.py

@@ -14,13 +14,6 @@ import zlib
 from typing import Dict, Any, Optional, Protocol
 from datetime import datetime
 
-# How old an abandoned write's temp file must be before the sweep removes it.
-# A real write holds its temp file for milliseconds, so an hour is far beyond
-# any in-flight write while still clearing the same day's debris. Deliberately
-# not tied to the retention policies: those describe how long data stays
-# useful, and a half-written file was never useful.
-_ORPHAN_TEMP_MAX_AGE_SECONDS = 3600
-
 
 
 class CacheStrategyProtocol(Protocol):
@@ -354,23 +347,6 @@ class DiskCache:
         """Get the cache directory path."""
         return self.cache_dir
     
-    @staticmethod
-    def _is_orphaned_temp(filename: str) -> bool:
-        """Whether a name is one of set()'s temp files rather than real data.
-
-        Matches only what this class creates: mkstemp with a prefix of
-        ".<cache filename>." , so ".weather.json.a1b2c3d4". The shape is
-        checked rather than just the leading dot, because this predicate
-        deletes things -- a stray dotfile someone left in the cache directory
-        is not ours to remove, and a completed ".json" never is either.
-        """
-        if not filename.startswith('.') or filename.endswith('.json'):
-            return False
-        head, sep, suffix = filename.rpartition('.json.')
-        # head is the key (non-empty after the leading dot), suffix is
-        # mkstemp's random component.
-        return bool(sep) and len(head) > 1 and bool(suffix)
-
     def cleanup_expired_files(self, cache_strategy: CacheStrategyProtocol, retention_policies: Dict[str, int]) -> Dict[str, Any]:
         """
         Clean up expired cache files based on retention policies.
@@ -405,50 +381,11 @@ class DiskCache:
             try:
                 with self._lock:
                     # Get snapshot of files while holding lock briefly
-                    entries = os.listdir(self.cache_dir)
+                    filenames = [f for f in os.listdir(self.cache_dir) if f.endswith('.json')]
             except OSError as list_error:
                 self.logger.error("Error listing cache directory %s: %s", self.cache_dir, list_error, exc_info=True)
                 stats['errors'] += 1
                 return stats
-
-            filenames = [f for f in entries if f.endswith('.json')]
-
-            # Sweep temp files abandoned by a write that never finished. set()
-            # removes its own in a finally, so these are the ones where the
-            # process died between mkstemp and os.replace -- a SIGKILL, a lost
-            # restart race, a power cut. Nothing ever collected them: they are
-            # named ".<key>.json.<random>", and the scan above only matches
-            # names ending in .json, so they accumulated indefinitely. Measured
-            # on a live rig: 76 files, 1,050 MB, 81% of the whole cache
-            # directory, the oldest six months old.
-            stats['orphan_temp_files_deleted'] = 0
-            for filename in (f for f in entries if self._is_orphaned_temp(f)):
-                # Counted as scanned like any other candidate, so files_deleted
-                # can never exceed files_scanned and the summary line reads
-                # honestly ("77/8864", not "77/0").
-                stats['files_scanned'] += 1
-                path = os.path.join(self.cache_dir, filename)
-                try:
-                    # An in-flight write lives for milliseconds, so anything
-                    # this old is certainly abandoned rather than in progress.
-                    if (current_time - os.path.getmtime(path)) <= _ORPHAN_TEMP_MAX_AGE_SECONDS:
-                        continue
-                    with self._lock:
-                        size = os.path.getsize(path)
-                        os.remove(path)
-                    stats['files_deleted'] += 1
-                    stats['orphan_temp_files_deleted'] += 1
-                    stats['space_freed_bytes'] += size
-                except FileNotFoundError:
-                    continue          # another sweep got there first
-                except OSError as e:
-                    stats['errors'] += 1
-                    self.logger.warning("Error deleting orphaned temp file %s: %s", filename, e)
-
-            if stats['orphan_temp_files_deleted']:
-                self.logger.info(
-                    "Removed %d abandoned cache temp file(s)",
-                    stats['orphan_temp_files_deleted'])
             
             # Process files outside the lock to avoid blocking get/set operations
             for filename in filenames:

src/cache_manager.py

@@ -46,21 +46,7 @@ from src.cache.disk_cache import DateTimeEncoder  # noqa: F401 - deliberate re-e
 
 class CacheManager:
     """Manages caching of API responses to reduce API calls."""
-
-    # Which cache directories already have a cleanup thread in this process.
-    #
-    # The sweep is directory-scoped work -- it lists a directory and deletes
-    # from it -- so one per directory is the right number no matter how many
-    # managers exist. Nothing enforced that before: every instance started its
-    # own, and because the loop closes over `self`, a discarded manager could
-    # never be collected and its thread woke to re-scan the same directory
-    # every 24 hours for the life of the process. Startup validation runs
-    # twice and built a throwaway manager each time, so a display process
-    # carried three threads for one cache.
-    _cleanup_owners: Dict[str, 'CacheManager'] = {}
-    _cleanup_owners_lock = threading.Lock()
-
-
+    
     def __init__(self) -> None:
         # Initialize logger first
         self.logger: logging.Logger = get_logger(__name__)
@@ -732,29 +718,11 @@ class CacheManager:
             }
     
     def start_cleanup_thread(self) -> None:
-        """Start background thread for periodic disk cache cleanup.
-
-        At most one thread per cache directory per process: the sweep is
-        directory-scoped, so a second one only duplicates the scan.
-        """
+        """Start background thread for periodic disk cache cleanup."""
         if self._cleanup_thread and self._cleanup_thread.is_alive():
             self.logger.debug("Cleanup thread already running")
             return
-
-        with CacheManager._cleanup_owners_lock:
-            owner = CacheManager._cleanup_owners.get(self.cache_dir)
-            if owner is not None and owner is not self:
-                thread = owner._cleanup_thread
-                if thread is not None and thread.is_alive():
-                    self.logger.debug(
-                        "Cleanup thread for %s already owned by another cache "
-                        "manager in this process; not starting a second",
-                        self.cache_dir)
-                    return
-                # The owner's thread died or was stopped -- take over.
-            CacheManager._cleanup_owners[self.cache_dir] = self
-
-
+        
         def cleanup_loop():
             """Background loop that runs cleanup periodically."""
             self.logger.info("Disk cache cleanup thread started (interval: %d hours)", 
@@ -802,17 +770,10 @@ class CacheManager:
         Signals the thread to stop and waits for it to finish (with timeout).
         This allows for clean shutdown during testing or application termination.
         """
-        # Release ownership first and unconditionally, so a manager that never
-        # started a thread (or whose thread already exited) cannot keep the
-        # directory claimed and block a live manager from sweeping it.
-        with CacheManager._cleanup_owners_lock:
-            if CacheManager._cleanup_owners.get(self.cache_dir) is self:
-                del CacheManager._cleanup_owners[self.cache_dir]
-
         if not self._cleanup_thread or not self._cleanup_thread.is_alive():
             self.logger.debug("Cleanup thread not running")
             return
-
+        
         self.logger.info("Stopping disk cache cleanup thread...")
         self._cleanup_stop_event.set()  # Signal thread to stop
         

src/display_controller.py

@@ -44,20 +44,6 @@ from src.common.sync_manager import DisplaySyncManager, SyncRole
 # Get logger with consistent configuration
 logger = get_logger(__name__)
 
-# How long startup will wait for plugins to fetch their first data before
-# showing anything. Each plugin's update blocks for up to the executor's 30s
-# timeout and they run one after another, so the uncapped total is the sum of
-# every slow plugin: 82 seconds on the worst boot measured, with a blank panel
-# throughout. Whatever does not finish in time is picked up by the scheduled
-# update tick moments later, with the display already running.
-_INITIAL_UPDATE_BUDGET_SECONDS = 20.0
-
-# The least budget worth starting a plugin with. Below this the plugin is
-# deferred instead: granting it a floor would let the pass run past its
-# deadline, and granting it the true remainder would record a timeout for a
-# slot it never had a chance to use.
-_MIN_INITIAL_UPDATE_TIMEOUT_SECONDS = 2.0
-
 # Vegas mode import (lazy loaded to avoid circular imports)
 _vegas_mode_imported = False
 VegasModeCoordinator = None
@@ -104,8 +90,7 @@ class DisplayController:
         # Validate startup configuration
         try:
             from src.startup_validator import StartupValidator
-            validator = StartupValidator(self.config_manager,
-                                         cache_manager=self.cache_manager)
+            validator = StartupValidator(self.config_manager)
             is_valid, errors, warnings = validator.validate_all()
             
             if warnings:
@@ -273,8 +258,7 @@ class DisplayController:
             # Validate plugins after plugin manager is created
             try:
                 from src.startup_validator import StartupValidator
-                validator = StartupValidator(self.config_manager, self.plugin_manager,
-                                             cache_manager=self.cache_manager)
+                validator = StartupValidator(self.config_manager, self.plugin_manager)
                 is_valid, errors, warnings = validator.validate_all()
                 
                 if warnings:
@@ -477,7 +461,7 @@ class DisplayController:
         # Initial data update for plugins (ensures data available on first display)
         logger.info("Performing initial plugin data update...")
         update_start = time.time()
-        self._update_modules(deadline=update_start + _INITIAL_UPDATE_BUDGET_SECONDS)
+        self._update_modules()
         logger.info("Initial plugin update completed in %.3f seconds", time.time() - update_start)
 
         # Initialize Vegas mode coordinator
@@ -833,42 +817,14 @@ class DisplayController:
             self._cached_target_brightness = normal_brightness  # persist for minute-gate
             return normal_brightness
 
-    def _update_modules(self, deadline: Optional[float] = None):
-        """Update all plugin modules.
-
-        Args:
-            deadline: Wall-clock time after which remaining plugins are left
-                for the scheduled update tick instead of being waited on. Each
-                update blocks this thread for up to the executor's timeout, and
-                they run one after another, so without a bound the total is the
-                sum of every slow plugin on the system. Measured at startup on
-                a live rig: 82 seconds, 55 and 26 on the two boots before -- all
-                of it with nothing on the panel.
-        """
+    def _update_modules(self):
+        """Update all plugin modules."""
         if not self.plugin_manager:
             return
-
+            
         # Update all loaded plugins
         plugins_dict = getattr(self.plugin_manager, 'loaded_plugins', None) or getattr(self.plugin_manager, 'plugins', {})
-        deferred = []
         for plugin_id, plugin_instance in plugins_dict.items():
-            update_timeout = None
-            if deadline is not None:
-                update_timeout = deadline - time.time()
-                if update_timeout < _MIN_INITIAL_UPDATE_TIMEOUT_SECONDS:
-                    # Too little left to be worth starting. Deferring rather
-                    # than granting a floor keeps the budget a real ceiling --
-                    # clamping up to a minimum let a plugin that began with a
-                    # sliver left run on past the deadline -- and a plugin
-                    # handed a slot it cannot use would just be recorded as
-                    # having timed out.
-                    #
-                    # Nothing is lost either way: a plugin that has never
-                    # updated is immediately due, so run_scheduled_updates()
-                    # picks it up within seconds, with the display already
-                    # running.
-                    deferred.append(plugin_id)
-                    continue
             # Check circuit breaker before attempting update
             if hasattr(self.plugin_manager, 'health_tracker') and self.plugin_manager.health_tracker:
                 if self.plugin_manager.health_tracker.should_skip_plugin(plugin_id):
@@ -877,13 +833,7 @@ class DisplayController:
             
             # Use PluginExecutor if available for safe execution
             if hasattr(self.plugin_manager, 'plugin_executor'):
-                # The remaining budget is the timeout, so the pass cannot
-                # run past its deadline. Bounding the loop alone did not do
-                # it: the last plugin to start could still block for the
-                # executor's full 30s, which turned a 20s budget into a 31.8s
-                # pass on the rig.
-                success = self.plugin_manager.plugin_executor.execute_update(
-                    plugin_instance, plugin_id, timeout=update_timeout)
+                success = self.plugin_manager.plugin_executor.execute_update(plugin_instance, plugin_id)
                 if success and hasattr(self.plugin_manager, 'plugin_last_update'):
                     self.plugin_manager.plugin_last_update[plugin_id] = time.time()
             else:
@@ -902,12 +852,6 @@ class DisplayController:
                     if hasattr(self.plugin_manager, 'health_tracker') and self.plugin_manager.health_tracker:
                         self.plugin_manager.health_tracker.record_failure(plugin_id, exc)
 
-        if deferred:
-            logger.info(
-                "Initial update budget spent; %d plugin(s) left to the update "
-                "tick so the display can start: %s",
-                len(deferred), ", ".join(deferred))
-
     def _tick_plugin_updates_for_vegas(self) -> None:
         """Run scheduled plugin updates and tell Vegas mode which plugins
         actually got fresh data, so it can hot-swap them into the scroll
@@ -1694,6 +1638,12 @@ class DisplayController:
                 logger.warning("Error checking live priority for %s: %s", mode_name, e)
         return live
 
+    def _vegas_keeps_live_in_ticker(self) -> bool:
+        """Whether live content should stay in the ticker instead of preempting it."""
+        coordinator = getattr(self, 'vegas_coordinator', None)
+        config = getattr(coordinator, 'vegas_config', None)
+        return bool(getattr(config, 'live_in_ticker', False))
+
     def _check_live_priority(self, advance=False):
         """Return the live-priority mode to display, or None if nothing is live.
 
@@ -1907,14 +1857,24 @@ class DisplayController:
                 # Check for live priority content and switch to it immediately.
                 # advance=True so multiple simultaneously-live games take turns
                 # (round-robin) instead of pinning to the first plugin.
-                if not self.on_demand_active and not wifi_status_data:
+                # Skipped when the ticker is keeping live content: switching
+                # the rotation underneath Vegas would move current_mode_index
+                # and stash a resume point for a takeover that never happens.
+                if (not self.on_demand_active and not wifi_status_data
+                        and not (self._is_vegas_mode_active()
+                                 and self._vegas_keeps_live_in_ticker())):
                     live_priority_mode = self._check_live_priority(advance=True)
                     self._apply_live_priority(live_priority_mode)
 
                 # Vegas scroll mode - continuous ticker across all plugins
                 # Priority: on-demand > wifi-status > live-priority > vegas > normal rotation
                 if self._is_vegas_mode_active() and not wifi_status_data:
-                    live_mode = self._check_live_priority()
+                    # Live content normally preempts the ticker entirely. With
+                    # vegas_scroll.live_in_ticker the marquee keeps running and
+                    # the live plugin takes extra turns inside it instead --
+                    # see StreamManager._apply_priority_weights.
+                    live_mode = (None if self._vegas_keeps_live_in_ticker()
+                                 else self._check_live_priority())
                     if not live_mode:
                         try:
                             # Run Vegas mode iteration

src/display_manager.py

@@ -25,7 +25,6 @@ the same object.
 
 import json
 import os
-import socket
 import tempfile
 if os.getenv("EMULATOR", "false") == "true":
     from RGBMatrixEmulator import RGBMatrix, RGBMatrixOptions
@@ -259,26 +258,6 @@ class DisplayManager:
         # Initialize managers
         # Calendar manager is now initialized by DisplayController
         
-    # Orientation setting -> rpi-rgb-led-matrix "Rotate:<deg>" pixel-mapper suffix.
-    # "normal" needs no suffix since 0 degrees is the identity transform.
-    _ORIENTATION_ROTATE_DEGREES = {'normal': None, '90': 90, '180': 180, '270': 270}
-
-    def _build_pixel_mapper_config(self, hardware_config: dict) -> str:
-        """Compose the raw pixel_mapper_config string with the orientation setting.
-
-        `pixel_mapper_config` stays available as a free-form advanced field (e.g.
-        for "U-mapper" chain layouts); `orientation` is the user-facing dropdown
-        for physical mounting (e.g. panels mounted upside down) and is appended as
-        a "Rotate:<deg>" mapper rather than overwriting any existing config.
-        """
-        base_mapper = (hardware_config.get('pixel_mapper_config') or '').strip()
-        orientation = hardware_config.get('orientation', 'normal')
-        degrees = self._ORIENTATION_ROTATE_DEGREES.get(orientation)
-        if degrees is None:
-            return base_mapper
-        rotate_mapper = f'Rotate:{degrees}'
-        return f'{base_mapper};{rotate_mapper}' if base_mapper else rotate_mapper
-
     def _setup_matrix(self):
         """Initialize the RGB matrix with configuration settings."""
         _init_error_str = None
@@ -304,7 +283,7 @@ class DisplayManager:
             options.pwm_bits = hardware_config.get('pwm_bits', 10)
             options.pwm_lsb_nanoseconds = hardware_config.get('pwm_lsb_nanoseconds', 150)
             options.led_rgb_sequence = hardware_config.get('led_rgb_sequence', 'RGB')
-            options.pixel_mapper_config = self._build_pixel_mapper_config(hardware_config)
+            options.pixel_mapper_config = hardware_config.get('pixel_mapper_config', '')
             options.row_address_type = hardware_config.get('row_address_type', 0)
             options.multiplexing = hardware_config.get('multiplexing', 0)
             options.panel_type = hardware_config.get('panel_type', '')
@@ -518,91 +497,6 @@ class DisplayManager:
             logger.warning(f"[BRIGHTNESS] Matrix does not support brightness property: {e}", exc_info=True)
             return -1
 
-    @staticmethod
-    def _local_ip() -> Optional[str]:
-        """This device's address on the network it routes through, or None.
-
-        Deliberately not `hostname -I` or a systemctl probe for AP mode, which
-        is how the web launcher does it: both spawn processes with multi-second
-        timeouts, and this runs on the startup path the rest of this change
-        exists to shorten. Connecting a UDP socket sends no packets -- it only
-        asks the kernel which source address it would use -- so it costs
-        microseconds and works with the network down, as long as a route
-        exists.
-        """
-        sock = None
-        try:
-            sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-            sock.settimeout(0.2)
-            sock.connect(("8.8.8.8", 80))  # nosec B104 - no traffic; selects a route
-            ip = sock.getsockname()[0]
-            return ip if ip and not ip.startswith("127.") else None
-        except OSError:
-            return None
-        finally:
-            if sock is not None:
-                try:
-                    sock.close()
-                except OSError:
-                    pass
-
-    def _fitting_font(self, lines, width):
-        """The largest font from the usual ladder that fits every line."""
-        candidates = [self.font,
-                      ("assets/fonts/4x6-font.ttf", 6)]
-        for candidate in candidates:
-            try:
-                font = candidate
-                if isinstance(candidate, tuple):
-                    font = ImageFont.truetype(candidate[0], candidate[1])
-                if all(self.draw.textlength(t, font=font) <= width for t in lines):
-                    return font
-            except (OSError, ValueError, AttributeError):
-                continue
-        return self.font
-
-    def _draw_startup_banner(self, lines, width: int, height: int) -> None:
-        """Centre `lines` over whatever the test pattern already drew.
-
-        This screen stays on the panel for the whole initial plugin update, and
-        on a headless Pi it is the only place the device's address appears
-        without going looking for it -- so it has to be readable off a wall,
-        not merely present.
-
-        The font is chosen to fit rather than fixed at 8px: "Initializing" is
-        96px in PressStart2P, which ran off the side of a 64px panel even
-        before an address was added. And the pattern is punched out behind the
-        text, because the diagonal runs through the middle of the panel, which
-        is exactly where this sits.
-
-        The text stays blue. It is not decoration: the pattern draws one pure
-        channel per element -- red border, green diagonal, blue text -- so that
-        a glance at the panel says whether led_rgb_sequence is right. Swap the
-        wiring to BGR and the border comes up blue and this text red. Drawing
-        it white would light all three channels and destroy the only blue
-        reference on the screen, which is why it is worth a comment rather
-        than a quiet preference.
-        """
-        if not lines:
-            return
-        font = self._fitting_font(lines, width - 2)
-        line_height = self.draw.textbbox((0, 0), "Ag", font=font)[3] + 1
-        block_height = line_height * len(lines)
-        block_top = max(1, (height - block_height) // 2)
-        block_width = max(self.draw.textlength(t, font=font) for t in lines)
-        block_left = max(0, (width - block_width) // 2)
-
-        self.draw.rectangle(
-            [block_left - 2, block_top - 1,
-             block_left + block_width + 1, block_top + block_height],
-            fill=(0, 0, 0))
-
-        for row, line in enumerate(lines):
-            line_width = self.draw.textlength(line, font=font)
-            self.draw.text(
-                (max(0, (width - line_width) // 2), block_top + row * line_height),
-                line, font=font, fill=(0, 0, 255))
-
     def _draw_test_pattern(self):
         """Draw a test pattern to verify the display is working."""
         try:
@@ -622,11 +516,8 @@ class DisplayManager:
             # Draw a diagonal line
             self.draw.line([0, 0, self.matrix.width-1, self.matrix.height-1], fill=(0, 255, 0))
             
-            lines = ["Initializing"]
-            ip = self._local_ip()
-            if ip:
-                lines.append(ip)
-            self._draw_startup_banner(lines, self.matrix.width, self.matrix.height)
+            # Draw some text - changed from "TEST" to "Initializing" with smaller font
+            self.draw.text((10, 10), "Initializing", font=self.font, fill=(0, 0, 255))
             
             # Update the display once after everything is drawn
             self.update_display()

src/plugin_system/base_plugin.py

@@ -555,6 +555,48 @@ class BasePlugin(ABC):
         """
         return False
 
+    def get_vegas_priority_weight(self) -> Optional[int]:
+        """How many slots per Vegas cycle this plugin should get, or None.
+
+        The Vegas ticker is otherwise a strict round robin: every plugin
+        appears exactly once per cycle. With a dozen plugins enabled that puts
+        minutes between a live score and its next appearance. A weight of N
+        gives the plugin N slots per cycle, spread evenly through it rather
+        than clumped together.
+
+        Return ``None`` (the default) to let the core decide. It gives a
+        plugin ``vegas_scroll.live_weight`` when ``has_live_priority()`` and
+        ``has_live_content()`` are both true, and 1 otherwise -- so live sports
+        already get extra turns without implementing this at all.
+
+        Implement it only when the plugin knows something the core cannot. The
+        motivating case is favorite teams: the core can see *that* a game is
+        live but not *whose*, so a scoreboard that wants its favorite's game
+        shown more often than other live games has to say so::
+
+            def get_vegas_priority_weight(self):
+                if not (self.has_live_priority() and self.has_live_content()):
+                    return None                      # let the core decide
+                cfg = self.global_config.get('display', {}).get('vegas_scroll', {})
+                if self._favorite_is_live():
+                    return cfg.get('favorite_live_weight', 5)
+                return cfg.get('live_weight', 3)
+
+        The weight is per *plugin*, not per game. A scoreboard showing four
+        live games still occupies one slot at a time and rotates its own games
+        within that slot; this controls how often the plugin itself comes
+        round.
+
+        Raising is safe: the core logs it and falls back to its own
+        live-content check, so a broken weight calculation costs the plugin
+        the favorite distinction but not the live boost.
+
+        Returns:
+            Slots per cycle (clamped to 1..10 by the caller), or None to
+            defer to the core's own live-content weighting.
+        """
+        return None
+
     def get_live_modes(self) -> List[str]:
         """
         Get list of display modes that should be used during live priority takeover.

src/startup_validator.py

@@ -15,23 +15,16 @@ from src.logging_config import get_logger
 class StartupValidator:
     """Validates system state on startup."""
     
-    def __init__(self, config_manager: Any, plugin_manager: Optional[Any] = None,
-                 cache_manager: Optional[Any] = None) -> None:
+    def __init__(self, config_manager: Any, plugin_manager: Optional[Any] = None) -> None:
         """
         Initialize the startup validator.
-
+        
         Args:
             config_manager: ConfigManager instance
             plugin_manager: Optional PluginManager instance
-            cache_manager: The CacheManager the application will actually use.
-                Pass it. Without one this validator builds its own just to read
-                a directory path, which reports on a cache the app does not
-                use and leaves behind a cleanup thread that nothing stops --
-                validation runs twice per startup, so that was two of them.
         """
         self.config_manager = config_manager
         self.plugin_manager = plugin_manager
-        self.cache_manager = cache_manager
         self.logger = get_logger(__name__)
         self.errors: List[str] = []
         self.warnings: List[str] = []
@@ -98,21 +91,9 @@ class StartupValidator:
     def _validate_cache_directory(self) -> None:
         """Validate cache directory permissions."""
         try:
-            cache_manager = self.cache_manager
-            if cache_manager is None:
-                # No caller supplied one (older embedders, direct use in a
-                # script). Build one, but do not leave its cleanup thread
-                # running behind us -- this instance is discarded on the next
-                # line but the thread is a closure over it, so it would never
-                # be collected.
-                from src.cache_manager import CacheManager
-                cache_manager = CacheManager()
-                try:
-                    cache_dir = cache_manager.get_cache_dir()
-                finally:
-                    cache_manager.stop_cleanup_thread()
-            else:
-                cache_dir = cache_manager.get_cache_dir()
+            from src.cache_manager import CacheManager
+            cache_manager = CacheManager()
+            cache_dir = cache_manager.get_cache_dir()
             
             if not cache_dir:
                 self.warnings.append("Cache directory not available - caching will be disabled")

src/vegas_mode/config.py

@@ -125,6 +125,32 @@ class VegasModeConfig:
     plugin_order: List[str] = field(default_factory=list)
     excluded_plugins: Set[str] = field(default_factory=set)
 
+    # --- Live content in the ticker -------------------------------------
+    #
+    # By default a live game preempts Vegas entirely: the display controller
+    # refuses to run the ticker while any plugin reports live priority, and you
+    # get the full-screen scoreboard instead. Set live_in_ticker to keep the
+    # marquee running and let live content take extra turns within it.
+    #
+    # The rotation is otherwise a strict round robin -- every plugin appears
+    # exactly once per cycle -- so with a dozen plugins enabled a live score
+    # comes round once a lap and can be minutes old on screen. Weighting lets a
+    # plugin claim several slots per cycle instead.
+    #
+    # Weights are per plugin, not per game: a scoreboard showing four live
+    # games still occupies one slot at a time, and rotates its own games within
+    # that slot using its own favorite_live_boost.
+    live_in_ticker: bool = False
+
+    # Slots per cycle for a plugin reporting live content. 1 disables the boost
+    # and restores the plain round robin.
+    live_weight: int = 3
+
+    # Slots per cycle for a plugin whose live content involves a favorite team.
+    # Only plugins implementing get_vegas_priority_weight() can claim this --
+    # the core cannot tell whose game is on, so the plugin reports it.
+    favorite_live_weight: int = 5
+
     # Performance settings
     target_fps: int = 125  # Target frame rate
     buffer_ahead: int = 2  # Number of plugins to buffer ahead
@@ -175,6 +201,12 @@ class VegasModeConfig:
             overflow_mode=str(vegas_config.get('overflow_mode', 'rotate')),
             plugin_order=list(vegas_config.get('plugin_order', [])),
             excluded_plugins=set(vegas_config.get('excluded_plugins', [])),
+            live_in_ticker=bool(vegas_config.get('live_in_ticker', False)),
+            # Clamped: a weight below 1 would drop the plugin from the rotation
+            # entirely, and a very large one starves everything else.
+            live_weight=max(1, min(10, int(vegas_config.get('live_weight', 3)))),
+            favorite_live_weight=max(
+                1, min(10, int(vegas_config.get('favorite_live_weight', 5)))),
             target_fps=int(vegas_config.get('target_fps', 125)),
             buffer_ahead=int(vegas_config.get('buffer_ahead', 2)),
             frame_based_scrolling=vegas_config.get('frame_based_scrolling', True),
@@ -204,6 +236,9 @@ class VegasModeConfig:
             'lead_in_width': self.lead_in_width,
             'plugins_per_cycle': self.plugins_per_cycle,
             'max_plugin_width_ratio': self.max_plugin_width_ratio,
+            'live_in_ticker': self.live_in_ticker,
+            'live_weight': self.live_weight,
+            'favorite_live_weight': self.favorite_live_weight,
             'overflow_mode': self.overflow_mode,
             'plugin_order': self.plugin_order,
             'excluded_plugins': list(self.excluded_plugins),
@@ -371,6 +406,15 @@ class VegasModeConfig:
 
         if 'enabled' in vegas_config:
             self.enabled = vegas_config['enabled']
+        if 'live_in_ticker' in vegas_config:
+            self.live_in_ticker = bool(vegas_config['live_in_ticker'])
+        # Clamped exactly as from_config does: a weight below 1 would drop the
+        # plugin from the rotation, and a huge one starves everything else.
+        if 'live_weight' in vegas_config:
+            self.live_weight = max(1, min(10, int(vegas_config['live_weight'])))
+        if 'favorite_live_weight' in vegas_config:
+            self.favorite_live_weight = max(
+                1, min(10, int(vegas_config['favorite_live_weight'])))
         if 'scroll_speed' in vegas_config:
             self.scroll_speed = float(vegas_config['scroll_speed'])
         if 'separator_width' in vegas_config:

src/vegas_mode/coordinator.py

@@ -12,7 +12,6 @@ Supports three display modes per plugin:
 """
 
 import logging
-import math
 import time
 import threading
 from typing import Optional, Dict, Any, List, Callable, TYPE_CHECKING
@@ -31,21 +30,6 @@ if TYPE_CHECKING:
 logger = logging.getLogger(__name__)
 
 
-def _percentile(ordered: List[float], fraction: float) -> float:
-    """Nearest-rank percentile of an already-sorted list.
-
-    Index ceil(n * fraction) - 1, so 100 samples at 0.99 give the 99th-ranked
-    value. The obvious int(n * fraction) is off by one and, at exactly 100
-    samples, lands on the maximum -- which is the number already reported
-    alongside this one as the worst frame, so the two columns would agree
-    precisely when the sample was smallest.
-    """
-    if not ordered:
-        return 0.0
-    index = math.ceil(len(ordered) * fraction) - 1
-    return ordered[min(len(ordered) - 1, max(0, index))]
-
-
 class VegasModeCoordinator:
     """
     Orchestrates Vegas scroll mode operation.
@@ -398,12 +382,6 @@ class VegasModeCoordinator:
         fps_log_interval = 5.0  # Log FPS every 5 seconds
         last_fps_log_time = start_time
         fps_frame_count = 0
-        # A mean hides stutter completely. At 120fps a five-second window is
-        # ~600 frames, so a 200ms freeze -- plainly visible on a marquee --
-        # moves the average from 120.0 to 115.4 and reads as healthy. What a
-        # viewer actually notices is the worst frame, so track that too.
-        frame_worst = 0.0
-        frame_times: List[float] = []
 
         logger.info("Starting Vegas iteration for %.1fs", duration)
 
@@ -439,11 +417,6 @@ class VegasModeCoordinator:
             frame_elapsed = time.time() - frame_started
             time.sleep(max(0.0, frame_interval - frame_elapsed))
 
-            # Measured before the sleep: time spent working, not pacing.
-            if frame_elapsed > frame_worst:
-                frame_worst = frame_elapsed
-            frame_times.append(frame_elapsed)
-
             # Increment frame count and check for interrupt periodically
             frame_count += 1
             fps_frame_count += 1
@@ -452,16 +425,12 @@ class VegasModeCoordinator:
             current_time = time.time()
             if current_time - last_fps_log_time >= fps_log_interval:
                 fps = fps_frame_count / (current_time - last_fps_log_time)
-                p99 = _percentile(sorted(frame_times), 0.99)
                 logger.info(
-                    "Vegas FPS: %.1f (target: %d, frames: %d) p99 %.1fms worst %.1fms",
-                    fps, self.vegas_config.target_fps, fps_frame_count,
-                    p99 * 1000.0, frame_worst * 1000.0
+                    "Vegas FPS: %.1f (target: %d, frames: %d)",
+                    fps, self.vegas_config.target_fps, fps_frame_count
                 )
                 last_fps_log_time = current_time
                 fps_frame_count = 0
-                frame_worst = 0.0
-                frame_times.clear()
 
             if (self._interrupt_check and
                     frame_count % self._interrupt_check_interval == 0):
@@ -528,6 +497,12 @@ class VegasModeCoordinator:
         if not self._live_priority_check:
             return False
 
+        if self.vegas_config.live_in_ticker:
+            # The ticker keeps live content rather than yielding to it; the
+            # extra turns are arranged in the rotation itself, so there is
+            # nothing to pause for.
+            return False
+
         try:
             live_mode = self._live_priority_check()
             if live_mode:

src/vegas_mode/stream_manager.py

@@ -406,6 +406,8 @@ class StreamManager:
         )
         logger.info("Ordered plugins: %s", ordered_plugins)
 
+        ordered_plugins = self._apply_priority_weights(ordered_plugins)
+
         # Atomically update shared state under lock to avoid races with prefetchers
         with self._buffer_lock:
             self._ordered_plugins = ordered_plugins
@@ -417,6 +419,130 @@ class StreamManager:
 
         logger.info("=" * 60)
 
+    def _plugin_weight(self, plugin_id: str) -> int:
+        """Slots per cycle for one plugin.
+
+        A plugin may answer for itself via get_vegas_priority_weight() -- the
+        only way favorite-team awareness can reach here, since the core can see
+        that a game is live but not whose. When it declines (returns None, the
+        default), live content earns ``live_weight`` and everything else 1.
+        """
+        plugin = None
+        try:
+            plugin = self.plugin_manager.plugins.get(plugin_id)
+        except (AttributeError, TypeError):
+            return 1
+        if plugin is None:
+            return 1
+
+        try:
+            if hasattr(plugin, 'get_vegas_priority_weight'):
+                declared = plugin.get_vegas_priority_weight()
+                if declared is not None:
+                    return max(1, min(10, int(declared)))
+        except Exception:
+            # Deliberately falls through to the core's own live check rather
+            # than demoting to 1. The plugin's weight calculation is broken,
+            # but has_live_priority() and has_live_content() are separate
+            # methods guarded separately below -- a plugin that genuinely has
+            # a live game should still get live_weight for it.
+            logger.exception("[%s] get_vegas_priority_weight() failed", plugin_id)
+
+        try:
+            if (hasattr(plugin, 'has_live_priority')
+                    and hasattr(plugin, 'has_live_content')
+                    and plugin.has_live_priority()
+                    and plugin.has_live_content()):
+                return self.config.live_weight
+        except Exception:
+            logger.exception("[%s] live-content check failed", plugin_id)
+        return 1
+
+    def _apply_priority_weights(self, ordered: List[str]) -> List[str]:
+        """Expand the rotation so weighted plugins take several turns per cycle.
+
+        Smooth Weighted Round-Robin, the same scheduler the sports plugins use
+        to rotate their own games: a plugin of weight N appears N times per
+        cycle, and the repeats are spaced through the cycle rather than
+        clumped, so a live score is never three-in-a-row followed by a long
+        silence.
+
+        Returns the input unchanged when nothing is weighted, which is both the
+        common case and the pre-existing behaviour.
+        """
+        if not ordered or not self.config.live_in_ticker:
+            return ordered
+
+        weights = {pid: self._plugin_weight(pid) for pid in ordered}
+        total = sum(weights.values())
+        if total <= len(ordered):
+            return ordered          # nothing boosted; plain round robin
+
+        current = {pid: 0 for pid in ordered}
+        schedule: List[str] = []
+        for _ in range(total):
+            for pid in ordered:
+                current[pid] += weights[pid]
+            picked = max(current, key=lambda p: current[p])
+            current[picked] -= total
+            schedule.append(picked)
+
+        schedule = self._unclump_seam(schedule)
+
+        boosted = {p: w for p, w in weights.items() if w > 1}
+        logger.info(
+            "Vegas rotation weighted: %d slots for %d plugins (boosted: %s)",
+            len(schedule), len(ordered), boosted)
+        return schedule
+
+    @staticmethod
+    def _unclump_seam(schedule: List[str]) -> List[str]:
+        """Stop the heaviest plugin sitting on both ends of the cycle.
+
+        Smooth Weighted Round-Robin spaces repeats well *within* a pass, but
+        it schedules the heaviest item first and often last too. The strip
+        loops, so those two are neighbours: the one place the marquee shows
+        the same plugin twice running is the seam between cycles.
+
+        Rotating the list cannot fix this. Rotation preserves the cyclic order
+        exactly, so it only moves where the seam is drawn, not the adjacency
+        itself. The trailing entry has to be swapped with one from the middle
+        whose neighbours differ from it, which breaks the pair without
+        creating another.
+
+        Left alone when no such position exists -- a rotation short enough or
+        lopsided enough to have none is one where the plugin is unavoidably
+        adjacent to itself anyway.
+        """
+        if len(schedule) < 3 or schedule[0] != schedule[-1]:
+            return schedule
+
+        repeated = schedule[-1]
+        size = len(schedule)
+        elsewhere = [i for i, p in enumerate(schedule[:-1]) if p == repeated]
+
+        def clearance(j: int) -> int:
+            """Cyclic distance from j to the nearest other appearance."""
+            return min(min((i - j) % size, (j - i) % size) for i in elsewhere)
+
+        candidates = [
+            j for j in range(1, size - 1)
+            if schedule[j] != repeated
+            and schedule[j - 1] != repeated
+            and schedule[j + 1] != repeated
+        ]
+        if not candidates:
+            return schedule
+
+        # Drop it into the widest gap rather than the first slot that fits.
+        # Taking the first one undoes the spacing this whole function exists
+        # to protect: on a 28-slot rotation it moved a repeat from a gap of 7
+        # to a gap of 2, which is more clumped than the seam ever was.
+        best = max(candidates, key=clearance) if elsewhere else candidates[0]
+        schedule = list(schedule)
+        schedule[best], schedule[-1] = schedule[-1], schedule[best]
+        return schedule
+
     def _prefetch_content(self, count: int = 1) -> None:
         """
         Prefetch content for upcoming plugins.

test/test_base_odds_manager.py

@@ -8,9 +8,7 @@ is_odds_available's ML-blind truth table, the fixed format_odds_summary
 gate (money-line-only odds now format), get_odds_for_games, and
 configuration loading.
 
-No real network: requests.Session.get is always patched. The odds path sends
-its requests through a session so it can identify itself to ESPN, so patching
-the module-level requests.get would no longer intercept anything.
+No real network: src.base_odds_manager.requests.get is always patched.
 """
 
 from unittest.mock import MagicMock, patch
@@ -61,7 +59,7 @@ def manager(cache_manager):
 
 @pytest.fixture
 def mock_get():
-    with patch('src.base_odds_manager.requests.Session.get') as m:
+    with patch('src.base_odds_manager.requests.get') as m:
         m.return_value = _make_response({'items': [dict(FULL_ITEM)]})
         yield m
 

test/test_cache_cleanup_thread_ownership.py

@@ -1,146 +0,0 @@
-"""Tests that one cache directory gets one cleanup thread per process.
-
-The sweep lists a directory and deletes from it, so a second thread over the
-same directory only duplicates the scan. Nothing enforced that: every
-CacheManager started its own, and since the loop closes over `self`, a
-discarded manager could never be collected -- its thread stayed alive and
-re-scanned the same directory every 24 hours for the life of the process.
-
-On the dev rig a display process carried three, for one cache directory:
-
-    14:22:59.954  display_controller       (the real one)
-    14:22:59.973  startup validation, run 1  (discarded)
-    14:23:01.055  startup validation, run 2  (discarded)
-
-Startup validation runs twice and built a throwaway manager each time, purely
-to read a directory path.
-"""
-
-import threading
-
-import pytest
-
-from src.cache_manager import CacheManager
-
-
-@pytest.fixture(autouse=True)
-def _clean_registry():
-    CacheManager._cleanup_owners.clear()
-    yield
-    for owner in list(CacheManager._cleanup_owners.values()):
-        owner.stop_cleanup_thread()
-    CacheManager._cleanup_owners.clear()
-
-
-def _live_cleanup_threads():
-    return [t for t in threading.enumerate()
-            if t.name == 'DiskCacheCleanup' and t.is_alive()]
-
-
-@pytest.fixture
-def manager(tmp_path, monkeypatch):
-    """A CacheManager pinned to a temp dir, so tests never touch the real one."""
-    monkeypatch.setattr(CacheManager, '_get_writable_cache_dir',
-                        lambda self: str(tmp_path))
-    return CacheManager
-
-
-class TestOneThreadPerDirectory:
-    def test_a_single_manager_starts_one(self, manager):
-        before = len(_live_cleanup_threads())
-        m = manager()
-        try:
-            assert len(_live_cleanup_threads()) == before + 1
-        finally:
-            m.stop_cleanup_thread()
-
-    def test_three_managers_still_start_one(self, manager):
-        # Exactly the rig's shape: the real manager plus two throwaways.
-        before = len(_live_cleanup_threads())
-        managers = [manager() for _ in range(3)]
-        try:
-            assert len(_live_cleanup_threads()) == before + 1
-        finally:
-            for m in managers:
-                m.stop_cleanup_thread()
-
-    def test_the_first_one_owns_it(self, manager):
-        first, second = manager(), manager()
-        try:
-            assert CacheManager._cleanup_owners[first.cache_dir] is first
-            assert second._cleanup_thread is None
-        finally:
-            first.stop_cleanup_thread()
-            second.stop_cleanup_thread()
-
-    def test_the_survivor_can_take_over(self, manager):
-        first = manager()
-        first.stop_cleanup_thread()
-        assert not _live_cleanup_threads()
-
-        second = manager()
-        try:
-            # Ownership was released, so the directory is swept again rather
-            # than being left permanently unclaimed by a dead owner.
-            assert len(_live_cleanup_threads()) == 1
-            assert CacheManager._cleanup_owners[second.cache_dir] is second
-        finally:
-            second.stop_cleanup_thread()
-
-    def test_stopping_a_non_owner_does_not_unclaim_the_directory(self, manager):
-        first, second = manager(), manager()
-        try:
-            second.stop_cleanup_thread()      # never owned it
-            assert CacheManager._cleanup_owners[first.cache_dir] is first
-            assert len(_live_cleanup_threads()) == 1
-        finally:
-            first.stop_cleanup_thread()
-
-    def test_separate_directories_get_separate_threads(self, tmp_path, monkeypatch):
-        a, b = tmp_path / 'a', tmp_path / 'b'
-        a.mkdir()
-        b.mkdir()
-        dirs = iter([str(a), str(b)])
-        monkeypatch.setattr(CacheManager, '_get_writable_cache_dir',
-                            lambda self: next(dirs))
-        first, second = CacheManager(), CacheManager()
-        try:
-            assert first.cache_dir != second.cache_dir
-            assert len(_live_cleanup_threads()) == 2
-        finally:
-            first.stop_cleanup_thread()
-            second.stop_cleanup_thread()
-
-    def test_no_thread_leaks_across_many_constructions(self, manager):
-        before = len(_live_cleanup_threads())
-        made = [manager() for _ in range(12)]
-        try:
-            assert len(_live_cleanup_threads()) == before + 1
-        finally:
-            for m in made:
-                m.stop_cleanup_thread()
-        assert len(_live_cleanup_threads()) == before
-
-
-class TestValidatorDoesNotBuildItsOwn:
-    def test_it_uses_the_cache_manager_it_is_given(self, manager):
-        from src.startup_validator import StartupValidator
-
-        shared = manager()
-        try:
-            before = len(_live_cleanup_threads())
-            v = StartupValidator(config_manager=object(), cache_manager=shared)
-            v._validate_cache_directory()
-            assert len(_live_cleanup_threads()) == before, (
-                "validation started another cleanup thread")
-        finally:
-            shared.stop_cleanup_thread()
-
-    def test_without_one_it_cleans_up_after_itself(self, manager):
-        from src.startup_validator import StartupValidator
-
-        before = len(_live_cleanup_threads())
-        v = StartupValidator(config_manager=object())
-        v._validate_cache_directory()
-        assert len(_live_cleanup_threads()) == before, (
-            "the fallback manager left its cleanup thread running")

test/test_cache_orphan_temp_sweep.py

@@ -1,188 +0,0 @@
-"""Tests that abandoned cache temp files get collected.
-
-DiskCache.set() writes through tempfile.mkstemp and os.replace, removing its
-own temp file in a finally. That covers a failed write, but not a process that
-dies between the two -- a SIGKILL, a lost restart race, a power cut, all
-ordinary on a Pi. Nothing collected what was left behind: the temp names are
-".<key>.json.<random>", and the expiry sweep only listed names ending in
-.json, so they accumulated for as long as the card had been in service.
-
-Measured on a live rig before this fix: 76 orphans totalling 1,050 MB -- 81%
-of the entire cache directory -- the oldest six months old.
-
-The predicate that decides what to delete is tested harder than the sweep
-itself, because a false positive here destroys real data.
-"""
-
-import os
-import time
-
-import pytest
-
-from src.cache.disk_cache import DiskCache, _ORPHAN_TEMP_MAX_AGE_SECONDS
-
-
-class FakeStrategy:
-    @staticmethod
-    def get_data_type_from_key(key):
-        return 'default'
-
-
-POLICIES = {'default': 30}
-
-
-@pytest.fixture
-def cache(tmp_path):
-    return DiskCache(str(tmp_path))
-
-
-def _age(path, seconds):
-    old = time.time() - seconds
-    os.utime(path, (old, old))
-
-
-def _write(tmp_path, name, body='{}'):
-    p = tmp_path / name
-    p.write_text(body, encoding='utf-8')
-    return p
-
-
-class TestWhatCountsAsAnOrphan:
-    @pytest.mark.parametrize('name', [
-        '.weather.json.a1b2c3d4',
-        '.odds_espn_football_nfl_401.json.xyz00000',
-        '.a.json.b',
-    ])
-    def test_our_temp_files_are_orphans(self, name):
-        assert DiskCache._is_orphaned_temp(name)
-
-    @pytest.mark.parametrize('name', [
-        'weather.json',            # real data
-        '.weather.json',           # a dotted key that completed
-        '.gitignore',              # not ours
-        '.hidden',                 # not ours
-        'weather.json.bak',        # no leading dot: someone else's
-        '.json.abc',               # no key between the dot and .json.
-        '.weather.json.',          # no random component
-        'notes.txt',
-    ])
-    def test_everything_else_is_left_alone(self, name):
-        assert not DiskCache._is_orphaned_temp(name)
-
-    def test_the_names_set_actually_creates_are_matched(self, cache, tmp_path):
-        """Guard against the predicate and the writer drifting apart."""
-        created = []
-        real = os.replace
-
-        def capture(src, dst):
-            created.append(os.path.basename(src))
-            return real(src, dst)
-
-        import src.cache.disk_cache as mod
-        mod.os.replace = capture
-        try:
-            cache.set('weather', {'v': 1})
-        finally:
-            mod.os.replace = real
-
-        assert created, "set() did not go through the temp-file path"
-        assert all(DiskCache._is_orphaned_temp(n) for n in created), created
-
-
-class TestTheSweep:
-    def test_an_old_orphan_is_removed(self, cache, tmp_path):
-        p = _write(tmp_path, '.weather.json.a1b2c3d4', 'x' * 5000)
-        _age(p, _ORPHAN_TEMP_MAX_AGE_SECONDS + 60)
-
-        stats = cache.cleanup_expired_files(FakeStrategy(), POLICIES)
-
-        assert not p.exists()
-        assert stats['orphan_temp_files_deleted'] == 1
-        assert stats['space_freed_bytes'] >= 5000
-
-    def test_an_in_flight_write_is_not_snatched_away(self, cache, tmp_path):
-        # The whole risk of this sweep: deleting a temp file another thread is
-        # about to os.replace into place.
-        p = _write(tmp_path, '.weather.json.inflight')
-
-        cache.cleanup_expired_files(FakeStrategy(), POLICIES)
-
-        assert p.exists()
-
-    def test_real_cache_files_survive(self, cache, tmp_path):
-        fresh = _write(tmp_path, 'weather.json')
-        dotted = _write(tmp_path, '.weather.json')
-        _age(dotted, _ORPHAN_TEMP_MAX_AGE_SECONDS + 60)
-
-        cache.cleanup_expired_files(FakeStrategy(), POLICIES)
-
-        assert fresh.exists()
-        assert dotted.exists(), "a completed .json was treated as a temp file"
-
-    def test_unrelated_dotfiles_survive(self, cache, tmp_path):
-        keep = _write(tmp_path, '.gitignore')
-        _age(keep, 400 * 86400)
-
-        cache.cleanup_expired_files(FakeStrategy(), POLICIES)
-
-        assert keep.exists()
-
-    def test_expiry_still_works_alongside_it(self, cache, tmp_path):
-        stale = _write(tmp_path, 'old.json')
-        _age(stale, 40 * 86400)          # past the 30-day default
-        orphan = _write(tmp_path, '.old.json.zz999999')
-        _age(orphan, _ORPHAN_TEMP_MAX_AGE_SECONDS + 60)
-
-        stats = cache.cleanup_expired_files(FakeStrategy(), POLICIES)
-
-        assert not stale.exists()
-        assert not orphan.exists()
-        assert stats['files_deleted'] == 2
-        assert stats['orphan_temp_files_deleted'] == 1
-
-    def test_the_rig_scenario(self, cache, tmp_path):
-        """76 orphans of assorted ages, none of them reachable before."""
-        for i in range(76):
-            p = _write(tmp_path, '.sched_%d.json.r%06d' % (i, i), 'x' * 1000)
-            _age(p, (i + 2) * 86400)
-        keep = _write(tmp_path, 'sched.json')
-
-        stats = cache.cleanup_expired_files(FakeStrategy(), POLICIES)
-
-        assert stats['orphan_temp_files_deleted'] == 76
-        assert keep.exists()
-        assert not list(tmp_path.glob('.sched_*'))
-        # The summary line is "<deleted>/<scanned>", so an orphan that is
-        # deleted but never counted as scanned renders as "76/1".
-        assert stats['files_scanned'] == 77
-        assert stats['files_deleted'] <= stats['files_scanned']
-
-    def test_deleted_never_exceeds_scanned(self, cache, tmp_path):
-        p = _write(tmp_path, '.only.json.a1b2c3d4')
-        _age(p, _ORPHAN_TEMP_MAX_AGE_SECONDS + 60)
-
-        stats = cache.cleanup_expired_files(FakeStrategy(), POLICIES)
-
-        assert stats['files_deleted'] == 1
-        assert stats['files_scanned'] == 1
-
-    def test_a_missing_file_mid_sweep_is_not_an_error(self, cache, tmp_path):
-        p = _write(tmp_path, '.weather.json.a1b2c3d4')
-        _age(p, _ORPHAN_TEMP_MAX_AGE_SECONDS + 60)
-
-        import src.cache.disk_cache as mod
-        real = mod.os.path.getsize
-
-        def vanish(path):
-            if path.endswith('.a1b2c3d4'):
-                os.remove(path)
-                raise FileNotFoundError(path)
-            return real(path)
-
-        mod.os.path.getsize = vanish
-        try:
-            stats = cache.cleanup_expired_files(FakeStrategy(), POLICIES)
-        finally:
-            mod.os.path.getsize = real
-
-        assert stats['errors'] == 0

test/test_display_manager.py

@@ -237,45 +237,3 @@ class TestDisplayManagerDoubleSided:
                                 suppress_test_pattern=True)
             assert dm.set_brightness(70) is True
             assert mock_rgb_matrix['matrix_instance'].brightness == 70
-
-
-class TestDisplayManagerOrientation:
-    """The orientation setting composes onto pixel_mapper_config for panels
-    mounted upside down, without disturbing a custom pixel_mapper_config."""
-
-    def _config(self, **hardware_overrides):
-        config = {
-            'display': {
-                'hardware': {
-                    'rows': 32, 'cols': 64, 'chain_length': 2, 'parallel': 1,
-                    'hardware_mapping': 'adafruit-hat-pwm', 'brightness': 90,
-                },
-                'runtime': {'gpio_slowdown': 2},
-            },
-            'timezone': 'UTC',
-            'plugin_system': {'plugins_directory': 'plugins'},
-        }
-        config['display']['hardware'].update(hardware_overrides)
-        return config
-
-    def test_default_orientation_leaves_pixel_mapper_config_untouched(self, mock_rgb_matrix):
-        DisplayManager._instance = None
-        with patch.dict('os.environ', {'EMULATOR': 'false'}):
-            DisplayManager(self._config(), suppress_test_pattern=True)
-            options = mock_rgb_matrix['options_class'].return_value
-            assert options.pixel_mapper_config == ''
-
-    def test_orientation_180_appends_rotate_mapper(self, mock_rgb_matrix):
-        DisplayManager._instance = None
-        with patch.dict('os.environ', {'EMULATOR': 'false'}):
-            DisplayManager(self._config(orientation='180'), suppress_test_pattern=True)
-            options = mock_rgb_matrix['options_class'].return_value
-            assert options.pixel_mapper_config == 'Rotate:180'
-
-    def test_orientation_180_composes_with_existing_pixel_mapper_config(self, mock_rgb_matrix):
-        DisplayManager._instance = None
-        with patch.dict('os.environ', {'EMULATOR': 'false'}):
-            DisplayManager(self._config(orientation='180', pixel_mapper_config='U-mapper'),
-                           suppress_test_pattern=True)
-            options = mock_rgb_matrix['options_class'].return_value
-            assert options.pixel_mapper_config == 'U-mapper;Rotate:180'

test/test_initial_update_budget.py

@@ -1,224 +0,0 @@
-"""Tests that startup does not wait indefinitely for plugins to fetch data.
-
-DisplayController.__init__ calls _update_modules() once, to populate plugin
-data before the first frame. It walks every loaded plugin in turn, and each
-update blocks the calling thread for up to the executor's 30s timeout, so the
-uncapped total is the sum of every slow plugin on the system.
-
-Profiled on a live rig with py-spy, the main thread sat 9.34s in
-
-    display_controller._update_modules
-      -> plugin_executor.execute_update
-        -> execute_with_timeout -> threading.join
-
-and the controller's own log put the full pass at 82 seconds on the worst
-boot measured (55 and 26 on the two before). The panel shows nothing for all
-of it.
-
-Nothing is lost by stopping early: a plugin that has never updated is
-immediately due, so run_scheduled_updates() collects it seconds later with the
-display already running.
-"""
-
-import os
-import time
-from unittest.mock import Mock
-
-import pytest
-
-# display_controller imports display_manager, which binds the hardware
-# rgbmatrix module unless EMULATOR=true is set before import (same convention
-# as test_display_controller_vegas_tick.py).
-os.environ.setdefault("EMULATOR", "true")
-
-from src.display_controller import (  # noqa: E402
-    DisplayController, _INITIAL_UPDATE_BUDGET_SECONDS,
-    _MIN_INITIAL_UPDATE_TIMEOUT_SECONDS)
-
-
-class FakeExecutor:
-    """Records which plugins were updated, and can make some of them slow."""
-
-    def __init__(self, cost=0.0, slow=()):
-        self.updated = []
-        self.cost = cost
-        self.slow = set(slow)
-
-    def execute_update(self, plugin, plugin_id, timeout=None):
-        self.updated.append(plugin_id)
-        if plugin_id in self.slow:
-            time.sleep(self.cost)
-        return True
-
-
-@pytest.fixture
-def tiny_floor(monkeypatch):
-    """Shrink the "worth starting" floor so timing tests stay quick."""
-    import src.display_controller as mod
-    monkeypatch.setattr(mod, "_MIN_INITIAL_UPDATE_TIMEOUT_SECONDS", 0.01)
-
-
-def _controller(plugin_ids, executor):
-    c = DisplayController.__new__(DisplayController)
-    c.plugin_manager = Mock()
-    # Both attributes, because _update_modules reads
-    # `loaded_plugins or plugins` and an empty dict is falsy.
-    c.plugin_manager.loaded_plugins = {pid: Mock() for pid in plugin_ids}
-    c.plugin_manager.plugins = dict(c.plugin_manager.loaded_plugins)
-    c.plugin_manager.plugin_executor = executor
-    c.plugin_manager.plugin_last_update = {}
-    c.plugin_manager.health_tracker = None
-    return c
-
-
-class TestTheBudgetIsRespected:
-    def test_without_a_deadline_every_plugin_is_updated(self):
-        ex = FakeExecutor()
-        _controller(['a', 'b', 'c'], ex)._update_modules()
-        assert ex.updated == ['a', 'b', 'c']
-
-    def test_a_passed_deadline_stops_the_pass(self):
-        ex = FakeExecutor()
-        _controller(['a', 'b', 'c'], ex)._update_modules(deadline=time.time() - 1)
-        assert ex.updated == [], "updated %r after the deadline" % ex.updated
-
-    def test_slow_plugins_do_not_drag_in_the_rest(self, tiny_floor):
-        # One plugin burns the whole budget; the remainder must be left alone
-        # rather than each adding its own wait.
-        ex = FakeExecutor(cost=0.3, slow={'slow'})
-        c = _controller(['slow'] + ['p%d' % i for i in range(20)], ex)
-        started = time.time()
-        c._update_modules(deadline=started + 0.2)
-        elapsed = time.time() - started
-
-        assert ex.updated == ['slow'], "updated %r" % ex.updated
-        # Bounded by the one in-flight update, not by twenty more.
-        assert elapsed < 1.0, "%.2fs" % elapsed
-
-    def test_a_generous_deadline_still_gets_everything(self):
-        ex = FakeExecutor()
-        c = _controller(['a', 'b', 'c'], ex)
-        c._update_modules(deadline=time.time() + 30)
-        assert ex.updated == ['a', 'b', 'c']
-
-    def test_the_deadline_is_checked_before_each_plugin(self, tiny_floor):
-        # Not just once up front: the budget can be spent partway through.
-        ex = FakeExecutor(cost=0.15, slow={'a', 'b', 'c', 'd'})
-        c = _controller(['a', 'b', 'c', 'd'], ex)
-        c._update_modules(deadline=time.time() + 0.2)
-        assert 0 < len(ex.updated) < 4, "updated %r" % ex.updated
-
-
-class TestThePassIsBoundedInPractice:
-    def test_the_last_plugin_cannot_overrun_the_budget(self):
-        # Checking the deadline before each plugin is not enough on its own:
-        # one that starts with a moment left could still block for the
-        # executor's full timeout. On the rig that turned a 20s budget into a
-        # 31.8s pass, so the remaining budget is passed down as the timeout.
-        seen = []
-
-        class Executor:
-            def execute_update(self, plugin, plugin_id, timeout=None):
-                seen.append(timeout)
-                return True
-
-        c = _controller(['a', 'b', 'c'], Executor())
-        deadline = time.time() + 5
-        c._update_modules(deadline=deadline)
-
-        assert seen and all(t is not None for t in seen), seen
-        assert all(t <= 5.01 for t in seen), seen
-        # The exact remainder, never clamped up: clamping would let the pass
-        # run past its deadline. Anything below the floor is deferred instead,
-        # so what does start always has a usable slot.
-        assert all(t >= _MIN_INITIAL_UPDATE_TIMEOUT_SECONDS for t in seen), seen
-
-    def test_without_a_deadline_the_executor_default_is_left_alone(self):
-        seen = []
-
-        class Executor:
-            def execute_update(self, plugin, plugin_id, timeout=None):
-                seen.append(timeout)
-                return True
-
-        _controller(['a'], Executor())._update_modules()
-        assert seen == [None], seen
-
-
-class TestTheBudgetItself:
-    def test_it_is_short_enough_to_be_worth_having(self):
-        # The measured uncapped worst case was 82s; a budget near that would
-        # not bound anything.
-        assert _INITIAL_UPDATE_BUDGET_SECONDS <= 30
-
-    def test_it_is_long_enough_for_a_quick_plugin_or_two(self):
-        assert _INITIAL_UPDATE_BUDGET_SECONDS >= 5
-
-
-class TestNothingIsSilentlyDropped:
-    def test_deferred_plugins_are_named_in_the_log(self, caplog):
-        ex = FakeExecutor()
-        c = _controller(['a', 'b'], ex)
-        with caplog.at_level('INFO'):
-            c._update_modules(deadline=time.time() - 1)
-        text = "\n".join(r.getMessage() for r in caplog.records)
-        assert 'a' in text and 'b' in text, text
-        assert 'budget' in text.lower(), text
-
-    def test_nothing_is_logged_when_all_of_them_ran(self, caplog):
-        ex = FakeExecutor()
-        c = _controller(['a'], ex)
-        with caplog.at_level('INFO'):
-            c._update_modules(deadline=time.time() + 30)
-        assert not any('budget' in r.getMessage().lower() for r in caplog.records)
-
-
-class TestItDoesNotBreakTheOrdinaryPaths:
-    def test_no_plugin_manager_is_harmless(self):
-        c = DisplayController.__new__(DisplayController)
-        c.plugin_manager = None
-        c._update_modules(deadline=time.time() - 1)      # must not raise
-
-    def test_an_empty_plugin_set_is_harmless(self):
-        ex = FakeExecutor()
-        _controller([], ex)._update_modules(deadline=time.time() + 5)
-        assert ex.updated == []
-
-
-class TestTooLittleBudgetDefersRatherThanClamps:
-    def test_a_plugin_starting_below_the_floor_is_deferred(self):
-        ex = FakeExecutor()
-        c = _controller(['a'], ex)
-        # Just under the floor: previously this was clamped up to the floor and
-        # run anyway, which pushed the pass past its deadline.
-        c._update_modules(
-            deadline=time.time() + _MIN_INITIAL_UPDATE_TIMEOUT_SECONDS - 0.05)
-        assert ex.updated == [], "started a plugin it could not give a slot to"
-
-    def test_a_plugin_starting_above_the_floor_still_runs(self):
-        ex = FakeExecutor()
-        c = _controller(['a'], ex)
-        c._update_modules(
-            deadline=time.time() + _MIN_INITIAL_UPDATE_TIMEOUT_SECONDS + 1)
-        assert ex.updated == ['a']
-
-    def test_the_timeout_is_the_remainder_not_the_floor(self):
-        seen = []
-
-        class Executor:
-            def execute_update(self, plugin, plugin_id, timeout=None):
-                seen.append(timeout)
-                return True
-
-        c = _controller(['a'], Executor())
-        c._update_modules(deadline=time.time() + 9)
-        assert seen and 8.5 <= seen[0] <= 9.01, seen
-
-    def test_the_pass_cannot_outlast_its_deadline(self, tiny_floor):
-        # Every plugin sleeps well past the budget; the deferral keeps the
-        # whole pass inside it rather than overrunning by a floor's worth.
-        ex = FakeExecutor(cost=0.4, slow={'a', 'b', 'c', 'd', 'e'})
-        c = _controller(['a', 'b', 'c', 'd', 'e'], ex)
-        started = time.time()
-        c._update_modules(deadline=started + 0.5)
-        assert time.time() - started < 1.2, "%.2fs" % (time.time() - started)

test/test_initializing_screen.py

@@ -1,190 +0,0 @@
-"""Tests the startup screen that shows while plugins fetch their first data.
-
-That screen is on the panel for the whole initial-update window, and on a
-headless Pi it is the only place the device's address appears without going
-looking for it -- so it now carries the address as well as "Initializing".
-
-Two things have to hold. It must fit every supported panel: the old fixed
-8px PressStart2P drew "Initializing" 96px wide at x=10, which ran off the
-side of a 64px panel before an address was ever added. And the lookup must be
-cheap, because this runs on the startup path that the rest of this change
-exists to shorten.
-"""
-
-import os
-import time
-
-from PIL import Image, ImageDraw, ImageFont
-import pytest
-
-os.environ.setdefault("EMULATOR", "true")
-
-from src.display_manager import DisplayManager  # noqa: E402
-
-SIZES = [(64, 32), (128, 32), (128, 64), (256, 32), (512, 64)]
-
-
-class FakeMatrix:
-    def __init__(self, width, height):
-        self.width, self.height = width, height
-
-
-def _manager(width, height):
-    dm = DisplayManager.__new__(DisplayManager)
-    dm.image = Image.new('RGB', (width, height))
-    dm.draw = ImageDraw.Draw(dm.image)
-    dm.matrix = FakeMatrix(width, height)
-    dm.font = ImageFont.truetype('assets/fonts/PressStart2P-Regular.ttf', 8)
-    return dm
-
-
-def _layout(dm, lines):
-    """The geometry _draw_startup_banner uses."""
-    font = dm._fitting_font(lines, dm.matrix.width - 2)
-    line_height = dm.draw.textbbox((0, 0), "Ag", font=font)[3] + 1
-    top = max(1, (dm.matrix.height - line_height * len(lines)) // 2)
-    widths = [dm.draw.textlength(t, font=font) for t in lines]
-    return font, widths, top, top + line_height * len(lines)
-
-
-def _render_over_pattern(width, height, lines):
-    """Draw the test pattern, then the banner over it, as startup does."""
-    dm = _manager(width, height)
-    dm.draw.rectangle([0, 0, width - 1, height - 1], outline=(255, 0, 0))
-    dm.draw.line([0, 0, width - 1, height - 1], fill=(0, 255, 0))
-    dm._draw_startup_banner(lines, width, height)
-    return dm
-
-
-class TestTheAddressLookup:
-    def test_it_never_reports_loopback(self):
-        # A loopback address on the panel would be actively misleading -- it is
-        # not something anyone can browse to.
-        ip = DisplayManager._local_ip()
-        assert ip is None or not ip.startswith("127."), ip
-
-    def test_it_looks_like_an_address_when_there_is_one(self):
-        ip = DisplayManager._local_ip()
-        if ip is None:
-            pytest.skip("host has no routable address")
-        parts = ip.split(".")
-        assert len(parts) == 4 and all(p.isdigit() for p in parts), ip
-
-    def test_it_is_cheap_enough_for_the_startup_path(self):
-        DisplayManager._local_ip()          # warm anything cacheable
-        started = time.perf_counter()
-        for _ in range(20):
-            DisplayManager._local_ip()
-        per_call = (time.perf_counter() - started) / 20
-        # `hostname -I` with its 2s timeout, which the web launcher uses, would
-        # be thousands of times this.
-        assert per_call < 0.05, "%.1f ms per call" % (per_call * 1000)
-
-    def test_it_returns_none_rather_than_raising(self, monkeypatch):
-        import src.display_manager as mod
-
-        def no_network(*a, **k):
-            raise OSError("network is unreachable")
-
-        monkeypatch.setattr(mod.socket, "socket", no_network)
-        assert DisplayManager._local_ip() is None
-
-
-class TestItFitsEveryPanel:
-    @pytest.mark.parametrize("width,height", SIZES)
-    def test_both_lines_fit_with_an_address(self, width, height):
-        dm = _manager(width, height)
-        _font, widths, top, bottom = _layout(dm, ["Initializing", "255.255.255.255"])
-        assert all(w <= width - 2 for w in widths), (width, widths)
-        assert bottom <= height and top >= 0, (top, bottom, height)
-
-    @pytest.mark.parametrize("width,height", SIZES)
-    def test_it_still_fits_with_no_address(self, width, height):
-        dm = _manager(width, height)
-        _font, widths, _top, bottom = _layout(dm, ["Initializing"])
-        assert all(w <= width - 2 for w in widths), (width, widths)
-        assert bottom <= height, (bottom, height)
-
-    def test_the_smallest_panel_drops_to_a_narrower_font(self):
-        # The regression this guards: PressStart2P at 8px is 96px wide for
-        # "Initializing", which does not fit 64px however it is positioned.
-        dm = _manager(64, 32)
-        font, widths, _t, _b = _layout(dm, ["Initializing", "10.0.20.104"])
-        assert font is not dm.font, "kept a font that cannot fit"
-        assert max(widths) <= 62, widths
-
-    def test_a_roomy_panel_keeps_the_larger_font(self):
-        dm = _manager(256, 32)
-        font, _w, _t, _b = _layout(dm, ["Initializing", "10.0.20.104"])
-        assert font is dm.font, "needlessly shrank on a panel with room"
-
-
-class TestPlacement:
-    @pytest.mark.parametrize("width,height", SIZES)
-    def test_the_lines_are_centred(self, width, height):
-        dm = _manager(width, height)
-        lines = ["Initializing", "10.0.20.104"]
-        _font, widths, _t, _b = _layout(dm, lines)
-        for w in widths:
-            left = max(0, (width - w) // 2)
-            assert abs((left + (left + w)) - width) <= 2, (left, w, width)
-
-    def test_the_address_sits_under_the_word(self):
-        dm = _manager(128, 64)
-        font, _w, top, bottom = _layout(dm, ["Initializing", "10.0.20.104"])
-        line_height = dm.draw.textbbox((0, 0), "Ag", font=font)[3] + 1
-        assert bottom - top == line_height * 2
-
-
-class TestItIsActuallyReadable:
-    """The point of the address is that someone can read it off the wall."""
-
-    @pytest.mark.parametrize("width,height", SIZES)
-    def test_the_diagonal_does_not_cross_the_text(self, width, height):
-        lines = ["Initializing", "10.0.20.104"]
-        dm = _render_over_pattern(width, height, lines)
-        _font, widths, top, bottom = _layout(dm, lines)
-        # textlength returns a float, so these must be floored before they
-        # can index pixels.
-        block_width = int(max(widths))
-        left = int(max(0, (width - block_width) // 2))
-
-        px = dm.image.load()
-        green = 0
-        for y in range(int(top), min(int(bottom), height)):
-            for x in range(left, min(left + block_width, width)):
-                r, g, b = px[x, y]
-                if g > 128 and r < 128 and b < 128:
-                    green += 1
-        assert green == 0, "%d green pixels behind the text at %dx%d" % (
-            green, width, height)
-
-    @pytest.mark.parametrize("width,height", SIZES)
-    def test_the_text_stays_pure_blue(self, width, height):
-        # Not a style choice. The pattern lights one channel per element --
-        # red border, green diagonal, blue text -- so a glance says whether
-        # led_rgb_sequence is right: wire it BGR and the border comes up blue
-        # and this text red. White text would light all three and destroy the
-        # only blue reference on the screen.
-        dm = _render_over_pattern(width, height, ["Initializing", "10.0.20.104"])
-        px = dm.image.load()
-        blue = sum(1 for y in range(height) for x in range(width)
-                   if px[x, y] == (0, 0, 255))
-        assert blue > 20, "only %d blue pixels at %dx%d" % (blue, width, height)
-        white = sum(1 for y in range(height) for x in range(width)
-                    if px[x, y] == (255, 255, 255))
-        assert white == 0, "%d white pixels would muddy the channel check" % white
-
-    def test_each_element_lights_one_channel(self):
-        # The whole point of the pattern: three pure primaries on screen.
-        dm = _render_over_pattern(128, 64, ["Initializing", "10.0.20.104"])
-        seen = set(dm.image.getdata())
-        assert (255, 0, 0) in seen, "no pure red border"
-        assert (0, 255, 0) in seen, "no pure green diagonal"
-        assert (0, 0, 255) in seen, "no pure blue text"
-
-    def test_nothing_is_drawn_for_no_lines(self):
-        dm = _manager(128, 64)
-        before = dm.image.tobytes()
-        dm._draw_startup_banner([], 128, 64)
-        assert dm.image.tobytes() == before

test/test_odds_request_budget.py

@@ -10,15 +10,10 @@ and the update carrying every game's score was killed:
 
 Invisible out of season -- preseason week 1 returns a single game -- and a
 Sunday slate is around sixteen.
-
-The request now goes through a session that identifies the caller, so the
-tests patch `manager.session.get` rather than the module's `requests.get`.
 """
 
 from unittest.mock import Mock
 
-import requests
-
 from src.base_odds_manager import BaseOddsManager
 
 PLUGIN_BUDGET = 30.0   # PluginExecutor(default_timeout=30.0)
@@ -30,83 +25,43 @@ def _manager(cache=None):
     return BaseOddsManager(cache_manager=cache, config_manager=None)
 
 
-def _timing_out(manager):
-    """Point the manager's session at a request that always times out."""
-    manager.session.get = Mock(side_effect=requests.exceptions.Timeout("x"))
-    return manager.session.get
-
-
-def _returning(manager, payload):
-    resp = Mock()
-    resp.json.return_value = payload
-    resp.raise_for_status.return_value = None
-    manager.session.get = Mock(return_value=resp)
-    return manager.session.get
-
-
 class TestRequestTimeout:
     def test_leaves_room_in_the_operation_budget(self):
         assert _manager().request_timeout < PLUGIN_BUDGET / 2
 
     def test_the_timeout_is_the_one_actually_used(self):
         m = _manager()
-        get = _timing_out(m)
-        m.get_odds("football", "nfl", "401")
-        assert get.call_args.kwargs["timeout"] == m.request_timeout
-
-
-class TestIdentifiesItselfToEspn:
-    """ESPN 403s python-requests' default agent, and bare custom tokens.
-
-    What it accepts is a token carrying a URL that says who is calling. This
-    path used a bare requests.get and so sent the default -- the one thing
-    known to be rejected. Everything else in the tree that talks to ESPN
-    already sends the header below.
-    """
-
-    def test_the_user_agent_names_the_project_and_links_to_it(self):
-        ua = _manager().session.headers["User-Agent"]
-        assert "python-requests" not in ua
-        assert "LEDMatrix" in ua
-        assert "github.com/ChuckBuilds/LEDMatrix" in ua
-
-    def test_it_is_the_same_agent_the_rest_of_the_tree_sends(self):
-        # Compared against the live value rather than a copied literal, so the
-        # two cannot drift apart the next time ESPN moves the goalposts.
-        from src.common.api_helper import APIHelper
-        assert (_manager().session.headers["User-Agent"]
-                == APIHelper().session.headers["User-Agent"])
-
-    def test_the_header_reaches_the_request(self):
-        m = _manager()
-        get = _returning(m, {})
-        m._extract_espn_data = Mock(return_value=None)
-        m.get_odds("football", "nfl", "401")
-        # Sent via the session, so it applies without being passed per-call.
-        assert get.call_count == 1
-        assert "User-Agent" in m.session.headers
-
-    def test_no_retry_adapter_multiplies_the_timeout(self):
-        # api_helper mounts a retrying adapter; this path must not, or a 5s
-        # timeout becomes 15s and the budget fix is undone.
-        m = _manager()
-        for adapter in m.session.adapters.values():
-            retries = getattr(adapter, "max_retries", None)
-            assert getattr(retries, "total", 0) in (0, None), (
-                "odds session mounts a retrying adapter (total=%r); retries "
-                "multiply request_timeout" % getattr(retries, "total", None))
+        import src.base_odds_manager as mod
+        real = mod.requests.get
+        try:
+            mod.requests.get = Mock(side_effect=mod.requests.exceptions.Timeout("x"))
+            m.get_odds("football", "nfl", "401")
+            assert mod.requests.get.call_args.kwargs["timeout"] == m.request_timeout
+        finally:
+            mod.requests.get = real
 
 
 class TestSlowEspnCannotKillTheUpdate:
     def test_one_failure_stops_the_rest_of_the_slate_hitting_the_network(self):
         m = _manager()
-        get = _timing_out(m)
-        for i in range(16):          # a full slate, one game at a time
-            m.get_odds("football", "nfl", "4018730%02d" % i)
+        import src.base_odds_manager as mod
+        real = mod.requests.get
+        calls = {"n": 0}
 
-        assert get.call_count == 1, (
+        def timeout(*a, **k):
+            calls["n"] += 1
+            raise mod.requests.exceptions.Timeout("timed out")
+
+        try:
+            mod.requests.get = timeout
+            for i in range(16):          # a full slate, one game at a time
+                m.get_odds("football", "nfl", "4018730%02d" % i)
+        finally:
+            mod.requests.get = real
+
+        assert calls["n"] == 1, (
             "%d games each paid the timeout; the breaker should have stopped "
-            "after the first" % get.call_count)
+            "after the first" % calls["n"])
 
     def test_worst_case_slate_stays_inside_the_budget(self):
         m = _manager()
@@ -115,48 +70,53 @@ class TestSlowEspnCannotKillTheUpdate:
     def test_recovery_is_automatic(self):
         m = _manager()
         import src.base_odds_manager as mod
-        real_monotonic = mod.time.monotonic
+        real_get, real_monotonic = mod.requests.get, mod.time.monotonic
         clock = {"t": 1000.0}
         try:
             mod.time.monotonic = lambda: clock["t"]
-            get = _timing_out(m)
+            mod.requests.get = Mock(
+                side_effect=mod.requests.exceptions.Timeout("timed out"))
             m.get_odds("football", "nfl", "401")
             assert m._skip_network_until > clock["t"], "breaker did not open"
 
             clock["t"] += 1
-            before = get.call_count
+            before = mod.requests.get.call_count
             m.get_odds("football", "nfl", "402")
-            assert get.call_count == before, "should not have retried"
+            assert mod.requests.get.call_count == before, "should not have retried"
 
             clock["t"] += m._FAILURE_COOLDOWN
             m.get_odds("football", "nfl", "403")
-            assert get.call_count > before, "never retried"
+            assert mod.requests.get.call_count > before, "never retried"
         finally:
-            mod.time.monotonic = real_monotonic
+            mod.requests.get, mod.time.monotonic = real_get, real_monotonic
 
     def test_a_healthy_fetch_clears_the_breaker(self):
         m = _manager()
         m._skip_network_until = 0.0
         m._extract_espn_data = Mock(return_value=None)
-        _returning(m, {})
-        m.get_odds("football", "nfl", "401")
+        import src.base_odds_manager as mod
+        real = mod.requests.get
+        try:
+            resp = Mock()
+            resp.json.return_value = {}
+            resp.raise_for_status.return_value = None
+            mod.requests.get = Mock(return_value=resp)
+            m.get_odds("football", "nfl", "401")
+        finally:
+            mod.requests.get = real
         assert m._skip_network_until == 0.0
 
-    def test_a_403_opens_the_breaker_rather_than_hammering(self):
-        # raise_for_status raises HTTPError, a RequestException -- so a wrong
-        # or missing agent backs off instead of 403ing once per game.
-        m = _manager()
-        resp = Mock()
-        resp.raise_for_status.side_effect = requests.exceptions.HTTPError("403")
-        m.session.get = Mock(return_value=resp)
-        m.get_odds("football", "nfl", "401")
-        assert m._skip_network_until > 0.0
-
     def test_the_stale_cache_fallback_still_works(self):
         # The failing request must still hand back whatever was cached; only
         # the *subsequent* games skip the network.
         cache = Mock()
         cache.get_with_auto_strategy.side_effect = [None, {"details": "stale"}]
         m = BaseOddsManager(cache_manager=cache, config_manager=None)
-        _timing_out(m)
-        assert m.get_odds("football", "nfl", "401") == {"details": "stale"}
+        import src.base_odds_manager as mod
+        real = mod.requests.get
+        try:
+            mod.requests.get = Mock(
+                side_effect=mod.requests.exceptions.Timeout("timed out"))
+            assert m.get_odds("football", "nfl", "401") == {"details": "stale"}
+        finally:
+            mod.requests.get = real

test/test_vegas_frame_percentile.py

@@ -1,64 +0,0 @@
-"""Tests the percentile used by the Vegas frame-time log line.
-
-The FPS line reports p99 next to the worst frame, and the point of having both
-is that they say different things: p99 is the bad-but-ordinary frame, worst is
-the outlier. The obvious index, int(n * 0.99), is off by one and at exactly
-100 samples selects the maximum -- so the two columns would report the same
-number precisely when the sample was smallest.
-"""
-
-import math
-
-import pytest
-
-from src.vegas_mode.coordinator import _percentile
-
-
-class TestNearestRank:
-    def test_a_hundred_samples_do_not_return_the_maximum(self):
-        ordered = [float(i) for i in range(100)]      # 0..99
-        assert _percentile(ordered, 0.99) == 98.0
-        assert _percentile(ordered, 0.99) != max(ordered)
-
-    def test_it_matches_the_nearest_rank_definition(self):
-        for n in (1, 2, 3, 10, 99, 100, 101, 600, 1000):
-            ordered = [float(i) for i in range(n)]
-            expected = ordered[min(n - 1, max(0, math.ceil(n * 0.99) - 1))]
-            assert _percentile(ordered, 0.99) == expected, n
-
-    @pytest.mark.parametrize('fraction,expected', [
-        (0.0, 0.0),      # first
-        (0.5, 49.0),     # median, nearest-rank
-        (1.0, 99.0),     # last
-    ])
-    def test_other_fractions(self, fraction, expected):
-        assert _percentile([float(i) for i in range(100)], fraction) == expected
-
-
-class TestEdges:
-    def test_empty_is_zero_not_an_error(self):
-        # The loop calls this before any frame has been timed.
-        assert _percentile([], 0.99) == 0.0
-
-    def test_a_single_sample_is_itself(self):
-        assert _percentile([4.2], 0.99) == 4.2
-
-    def test_it_never_indexes_past_the_end(self):
-        for n in range(1, 50):
-            _percentile([float(i) for i in range(n)], 1.0)   # must not raise
-
-
-class TestItSaysSomethingUsefulAboutFrames:
-    def test_one_freeze_does_not_drag_p99_up(self):
-        # 599 healthy frames and one 3.2s freeze: p99 should still describe
-        # the healthy population, while the worst frame is reported separately.
-        frames = [0.0083] * 599 + [3.2]
-        p99 = _percentile(sorted(frames), 0.99)
-        assert p99 == pytest.approx(0.0083), p99
-        assert max(frames) == 3.2
-
-    def test_sustained_slowness_does_move_it(self):
-        # Ten percent of frames slow is not an outlier, it is the shape of the
-        # distribution, and p99 must reflect that.
-        frames = [0.0083] * 540 + [0.05] * 60
-        assert _percentile(sorted(frames), 0.99) == pytest.approx(0.05)

test/test_vegas_live_weighting.py

@@ -0,0 +1,262 @@
+"""Tests that live content can take extra turns inside the Vegas ticker.
+
+Vegas was a strict round robin -- every plugin exactly once per cycle -- and
+live content did not appear in it at all, because the display controller
+refused to run the ticker while anything was live. With a dozen plugins
+enabled that left a live score either absent or minutes stale.
+
+Two things change, both off by default. `live_in_ticker` keeps the marquee
+running instead of yielding to a full-screen takeover, and the rotation is
+expanded by Smooth Weighted Round-Robin so a weighted plugin gets several
+slots per cycle, spaced through it rather than clumped.
+
+Weights are per plugin, not per game: a scoreboard showing four live games
+still occupies one slot at a time and rotates its own games within it.
+"""
+
+from unittest.mock import Mock
+
+import pytest
+
+from src.vegas_mode.config import VegasModeConfig
+from src.vegas_mode.stream_manager import StreamManager
+
+
+class FakePlugin:
+    """A plugin that can fail in each place independently.
+
+    hook_raises and live_raises are separate because they mean different
+    things: a broken weight calculation should still leave the core's own
+    live-content check usable, while a plugin that cannot answer whether it is
+    live at all has nothing left to fall back on.
+    """
+
+    def __init__(self, live=False, declared=None, raises=False,
+                 hook_raises=False, live_raises=False):
+        self._live = live
+        self._declared = declared
+        self._hook_raises = hook_raises or raises
+        self._live_raises = live_raises or raises
+        self.enabled = True
+
+    def has_live_priority(self):
+        if self._live_raises:
+            raise RuntimeError("cannot say whether I am live")
+        return self._live
+
+    def has_live_content(self):
+        return self._live
+
+    def get_vegas_priority_weight(self):
+        if self._hook_raises:
+            raise RuntimeError("weight calculation blew up")
+        return self._declared
+
+
+def _manager(plugins, **cfg):
+    config = VegasModeConfig(live_in_ticker=cfg.pop('live_in_ticker', True), **cfg)
+    pm = Mock()
+    pm.plugins = plugins
+    sm = StreamManager.__new__(StreamManager)
+    sm.config = config
+    sm.plugin_manager = pm
+    return sm
+
+
+def _counts(schedule):
+    return {p: schedule.count(p) for p in set(schedule)}
+
+
+def _max_gap(schedule, plugin_id):
+    """Largest gap between consecutive appearances, wrapping around."""
+    at = [i for i, p in enumerate(schedule) if p == plugin_id]
+    if len(at) < 2:
+        return len(schedule)
+    gaps = [b - a for a, b in zip(at, at[1:])]
+    gaps.append(len(schedule) - at[-1] + at[0])
+    return max(gaps)
+
+
+class TestWeightsComeFromTheRightPlace:
+    def test_a_quiet_plugin_gets_one_slot(self):
+        sm = _manager({'clock': FakePlugin()})
+        assert sm._plugin_weight('clock') == 1
+
+    def test_live_content_earns_the_configured_weight(self):
+        sm = _manager({'mlb': FakePlugin(live=True)}, live_weight=4)
+        assert sm._plugin_weight('mlb') == 4
+
+    def test_a_plugin_may_answer_for_itself(self):
+        # The only route for favorite-team awareness: the core can see that a
+        # game is live, not whose.
+        sm = _manager({'mlb': FakePlugin(live=True, declared=7)}, live_weight=3)
+        assert sm._plugin_weight('mlb') == 7
+
+    def test_declaring_none_defers_to_the_core(self):
+        sm = _manager({'mlb': FakePlugin(live=True, declared=None)}, live_weight=3)
+        assert sm._plugin_weight('mlb') == 3
+
+    def test_a_declared_weight_is_clamped(self):
+        sm = _manager({'a': FakePlugin(declared=99), 'b': FakePlugin(declared=0)})
+        assert sm._plugin_weight('a') == 10
+        assert sm._plugin_weight('b') == 1
+
+    def test_a_plugin_that_raises_everywhere_weighs_one(self):
+        sm = _manager({'bad': FakePlugin(raises=True)})
+        assert sm._plugin_weight('bad') == 1
+
+    def test_a_broken_hook_still_earns_the_live_boost(self):
+        # The hook is only how a plugin asks for *more* than live_weight.
+        # Losing it should cost the favorite distinction, not the live boost:
+        # has_live_priority/has_live_content are separate and still work.
+        sm = _manager({'mlb': FakePlugin(live=True, hook_raises=True)},
+                      live_weight=4)
+        assert sm._plugin_weight('mlb') == 4
+
+    def test_a_broken_hook_on_a_quiet_plugin_weighs_one(self):
+        sm = _manager({'clock': FakePlugin(live=False, hook_raises=True)},
+                      live_weight=4)
+        assert sm._plugin_weight('clock') == 1
+
+    def test_a_plugin_that_cannot_say_whether_it_is_live_weighs_one(self):
+        # Nothing left to fall back on, so no boost.
+        sm = _manager({'mlb': FakePlugin(live=True, live_raises=True)},
+                      live_weight=4)
+        assert sm._plugin_weight('mlb') == 1
+
+    def test_an_unknown_plugin_weighs_one(self):
+        assert _manager({})._plugin_weight('ghost') == 1
+
+
+class TestTheSchedule:
+    def test_nothing_weighted_leaves_the_order_untouched(self):
+        order = ['weather', 'clock', 'news']
+        sm = _manager({p: FakePlugin() for p in order})
+        assert sm._apply_priority_weights(order) == order
+
+    def test_off_by_default_the_order_is_untouched(self):
+        order = ['weather', 'mlb', 'news']
+        sm = _manager({'weather': FakePlugin(), 'mlb': FakePlugin(live=True),
+                       'news': FakePlugin()}, live_in_ticker=False, live_weight=3)
+        assert sm._apply_priority_weights(order) == order
+
+    def test_a_live_plugin_takes_its_share_of_slots(self):
+        order = ['weather', 'mlb', 'news', 'clock']
+        sm = _manager({'weather': FakePlugin(), 'mlb': FakePlugin(live=True),
+                       'news': FakePlugin(), 'clock': FakePlugin()},
+                      live_weight=3)
+        schedule = sm._apply_priority_weights(order)
+        counts = _counts(schedule)
+        assert counts['mlb'] == 3, counts
+        assert counts['weather'] == counts['news'] == counts['clock'] == 1, counts
+        assert len(schedule) == 6
+
+    def test_every_plugin_still_appears(self):
+        # A boost must not starve anything out of the cycle.
+        order = ['a', 'b', 'c', 'd', 'e', 'f']
+        plugins = {p: FakePlugin() for p in order}
+        plugins['a'] = FakePlugin(live=True, declared=10)
+        sm = _manager(plugins)
+        schedule = sm._apply_priority_weights(order)
+        assert set(schedule) == set(order), set(order) - set(schedule)
+
+    def test_nothing_doubles_across_the_cycle_seam(self):
+        # The strip loops, so the last slot neighbours the first. Smooth
+        # Weighted Round-Robin schedules the heaviest item first and often
+        # last too, which put the one clump the algorithm exists to avoid at
+        # the one place a within-cycle check cannot see.
+        order = ['baseball', 'weather', 'geochron', 'flights', 'stocks',
+                 'oftheday', 'youtube', 'stocknews', 'leaderboard',
+                 'countdown', 'odds', 'f1', 'football', 'music']
+        plugins = {p: FakePlugin() for p in order}
+        plugins['baseball'] = FakePlugin(live=True, declared=5)
+        plugins['football'] = FakePlugin(live=True, declared=3)
+        schedule = _manager(plugins)._apply_priority_weights(order)
+
+        n = len(schedule)
+        doubles = [schedule[i] for i in range(n)
+                   if schedule[i] == schedule[(i + 1) % n]]
+        assert not doubles, "%r repeats across the seam in %r" % (doubles, schedule)
+
+    def test_the_seam_repair_keeps_every_slot(self):
+        order = ['a', 'b', 'c', 'd', 'e', 'f']
+        plugins = {p: FakePlugin() for p in order}
+        plugins['a'] = FakePlugin(live=True, declared=4)
+        schedule = _manager(plugins)._apply_priority_weights(order)
+        assert _counts(schedule)['a'] == 4, _counts(schedule)
+        assert sorted(schedule) == sorted(
+            ['a'] * 4 + ['b', 'c', 'd', 'e', 'f']), schedule
+
+    def test_the_repair_uses_the_widest_gap(self):
+        # Moving the trailing repeat into the first slot that merely fits
+        # undoes the spacing: on a 28-slot rotation that turned a gap of 7
+        # into a gap of 2, which is more clumped than the seam ever was.
+        order = ['a'] + ['p%d' % i for i in range(13)]
+        plugins = {p: FakePlugin() for p in order}
+        plugins['a'] = FakePlugin(live=True, declared=4)
+        schedule = _manager(plugins)._apply_priority_weights(order)
+        at = [i for i, p in enumerate(schedule) if p == 'a']
+        gaps = [b - a for a, b in zip(at, at[1:])]
+        gaps.append(len(schedule) - at[-1] + at[0])
+        ideal = len(schedule) / len(at)
+        assert min(gaps) >= ideal / 2, "gaps %r for ideal %.1f" % (gaps, ideal)
+
+    def test_an_unavoidable_double_is_left_alone(self):
+        # Five of seven slots are the same plugin, so it must neighbour
+        # itself. Better to schedule it than to refuse or loop forever.
+        order = ['a', 'b', 'c']
+        plugins = {p: FakePlugin() for p in order}
+        plugins['a'] = FakePlugin(live=True, declared=5)
+        schedule = _manager(plugins)._apply_priority_weights(order)
+        assert _counts(schedule) == {'a': 5, 'b': 1, 'c': 1}, _counts(schedule)
+        assert set(schedule) == {'a', 'b', 'c'}
+
+    def test_a_schedule_too_short_to_repair_is_returned_as_is(self):
+        sm = _manager({})
+        assert sm._unclump_seam(['a', 'a']) == ['a', 'a']
+        assert sm._unclump_seam(['a']) == ['a']
+        assert sm._unclump_seam([]) == []
+
+    def test_a_schedule_with_no_seam_clash_is_untouched(self):
+        sm = _manager({})
+        plain = ['a', 'b', 'c', 'a', 'd']
+        assert sm._unclump_seam(plain) == plain
+
+    def test_repeats_are_spread_not_clumped(self):
+        # The point of Smooth Weighted Round-Robin. Three-in-a-row followed by
+        # a long silence would be worse than not boosting at all.
+        order = ['weather', 'mlb', 'news', 'clock', 'stocks', 'f1']
+        plugins = {p: FakePlugin() for p in order}
+        plugins['mlb'] = FakePlugin(live=True)
+        sm = _manager(plugins, live_weight=3)
+        schedule = sm._apply_priority_weights(order)
+
+        assert _counts(schedule)['mlb'] == 3
+        # Evenly spread over 8 slots means a gap of about 3, never 6.
+        assert _max_gap(schedule, 'mlb') <= 4, schedule
+        # And never twice running.
+        assert not any(a == b == 'mlb' for a, b in zip(schedule, schedule[1:])), schedule
+
+    def test_a_favorite_outranks_another_live_game(self):
+        order = ['weather', 'mlb', 'nhl']
+        sm = _manager({'weather': FakePlugin(),
+                       'mlb': FakePlugin(live=True, declared=5),
+                       'nhl': FakePlugin(live=True)}, live_weight=2)
+        counts = _counts(sm._apply_priority_weights(order))
+        assert counts['mlb'] == 5 and counts['nhl'] == 2 and counts['weather'] == 1, counts
+
+    def test_an_empty_rotation_is_harmless(self):
+        assert _manager({})._apply_priority_weights([]) == []
+
+
+class TestConfigParsing:
+    def test_defaults_preserve_todays_behaviour(self):
+        cfg = VegasModeConfig.from_config({})
+        assert cfg.live_in_ticker is False
+        assert cfg.live_weight == 3 and cfg.favorite_live_weight == 5
+
+    @pytest.mark.parametrize("given,expected", [(0, 1), (-4, 1), (99, 10), (4, 4)])
+    def test_weights_are_clamped(self, given, expected):
+        cfg = VegasModeConfig.from_config(
+            {'display': {'vegas_scroll': {'live_weight': given}}})
+        assert cfg.live_weight == expected

web_interface/blueprints/api_v3.py

@@ -796,7 +796,7 @@ def save_main_config():
                          'gpio_slowdown', 'rp1_rio', 'scan_mode', 'disable_hardware_pulsing', 'inverse_colors', 'show_refresh_rate',
                          'pwm_bits', 'pwm_dither_bits', 'pwm_lsb_nanoseconds', 'limit_refresh_rate_hz', 'use_short_date_format',
                          'max_dynamic_duration_seconds', 'led_rgb_sequence', 'multiplexing', 'panel_type',
-                         'row_address_type', 'pixel_mapper_config', 'orientation']
+                         'row_address_type', 'pixel_mapper_config']
 
         if any(k in data for k in display_fields):
             if 'display' not in current_config:
@@ -831,11 +831,6 @@ def save_main_config():
             if 'pixel_mapper_config' in data and not isinstance(data['pixel_mapper_config'], str):
                 return jsonify({'status': 'error', 'message': 'pixel_mapper_config must be a string (e.g. "U-mapper;Rotate:90" or empty)'}), 400
 
-            # Validate orientation (physical mounting rotation; composed onto pixel_mapper_config at runtime)
-            ORIENTATION_ALLOWED = {'normal', '180'}
-            if 'orientation' in data and data['orientation'] not in ORIENTATION_ALLOWED:
-                return jsonify({'status': 'error', 'message': f"Invalid orientation '{data['orientation']}'. Allowed values: {', '.join(sorted(ORIENTATION_ALLOWED))}"}), 400
-
             # Validate row_address_type
             if 'row_address_type' in data:
                 try:
@@ -849,7 +844,7 @@ def save_main_config():
             for field in ['rows', 'cols', 'chain_length', 'parallel', 'brightness', 'hardware_mapping', 'scan_mode',
                          'pwm_bits', 'pwm_dither_bits', 'pwm_lsb_nanoseconds', 'limit_refresh_rate_hz',
                          'led_rgb_sequence', 'multiplexing', 'panel_type', 'row_address_type',
-                         'pixel_mapper_config', 'orientation']:
+                         'pixel_mapper_config']:
                 if field in data:
                     if field in ['rows', 'cols', 'chain_length', 'parallel', 'brightness', 'scan_mode',
                                'pwm_bits', 'pwm_dither_bits', 'pwm_lsb_nanoseconds', 'limit_refresh_rate_hz',

web_interface/templates/v3/partials/display.html

@@ -117,14 +117,6 @@
                     </select>
                 </div>
 
-                <div class="form-group" id="setting-display-orientation" data-setting-key="display.hardware.orientation">
-                    <label for="orientation" class="block text-sm font-medium text-gray-700">Panel Orientation{{ ui.help_tip('Rotates the rendered image to match how the panel is physically mounted.\nUse "Upside Down" if you flipped the panel 180° to move the Raspberry Pi / wiring to a more convenient side.', 'Panel Orientation') }}</label>
-                    <select id="orientation" name="orientation" class="form-control">
-                        <option value="normal" {% if main_config.display.hardware.get('orientation', 'normal') == "normal" %}selected{% endif %}>Normal</option>
-                        <option value="180" {% if main_config.display.hardware.get('orientation', 'normal') == "180" %}selected{% endif %}>Upside Down (180°)</option>
-                    </select>
-                </div>
-
                 <div class="form-group" id="setting-display-led_rgb_sequence" data-setting-key="display.hardware.led_rgb_sequence">
                     <label for="led_rgb_sequence" class="block text-sm font-medium text-gray-700">LED RGB Sequence{{ ui.help_tip('Order the panel expects color channels in.\nChange this only if reds/greens/blues look swapped. Default: RGB.', 'LED RGB Sequence') }}</label>
                     <select id="led_rgb_sequence" name="led_rgb_sequence" class="form-control">