Dual device on weekend feature

2026-07-12 18:34:28 -04:00
parent 9e100d60d0
commit 31caa13c3d
6 changed files with 214 additions and 39 deletions
@@ -75,6 +75,8 @@ class CompileScheduleRequest(BaseModel):
 	start_date: str | None = Field(default=None, description="YYYY-MM-DD")
 	rule: str = ""
 	daytime_testing_today: bool = False
+	dual_device_weekend_start_enabled: bool = False
+	dual_device_weekend_start_dates: list[str] = Field(default_factory=list)
 	top_priority_tests: list[str] = Field(default_factory=list)
 	lowest_priority_tests: list[str] = Field(default_factory=list)

@@ -378,6 +380,8 @@ def compile_schedule_endpoint(request: CompileScheduleRequest) -> dict[str, Any]
 		start_date=request.start_date,
 		holiday_dates=holiday_dates,
 		daytime_testing_today=request.daytime_testing_today,
+		dual_device_weekend_start_enabled=request.dual_device_weekend_start_enabled,
+		dual_device_window_start_dates=set(item.strip() for item in request.dual_device_weekend_start_dates if item.strip()),
 	)

 	try:
@@ -2,8 +2,8 @@ from __future__ import annotations
 import os

 from dataclasses import dataclass
-from datetime import date
-from test_window import get_shift_sequence_with_capacity, next_window_start_date
+from datetime import date, timedelta
+from test_window import get_shift_sequence_with_capacity, is_off_day, next_window_start_date
 from test_bundle import Test, TestBundle, build_test_bundles, bundle_pair_lookup

 DUT = (os.getenv("DUT") or "DUT").strip()
@@ -36,6 +36,8 @@ class Scheduler:
        start_date: str | None = None,
        holiday_dates: set[str] = set(),
        daytime_testing_today: bool = False,
+        dual_device_weekend_start_enabled: bool = False,
+        dual_device_window_start_dates: set[str] | None = None,
        priority_weight: int = 100,
    ):
        self.top_priority_tests = top_priority_tests
@@ -45,6 +47,8 @@ class Scheduler:
        self.start_date = date.fromisoformat(start_date) if start_date else date.today()
        self.holiday_dates = holiday_dates
        self.daytime_testing_today = daytime_testing_today
+        self.dual_device_weekend_start_enabled = dual_device_weekend_start_enabled
+        self.dual_device_window_start_dates = dual_device_window_start_dates or set()
        self.priority_weight = priority_weight
        self.pending_dut_mirror: list[TestBundle] = []
        self.pending_ref_mirror: list[TestBundle] = []
@@ -102,6 +106,10 @@ class Scheduler:
                    active_unscheduled = dut_unscheduled if window_device == DUT else ref_unscheduled

                shifts, capacity = get_shift_sequence_with_capacity(cursor_date, self.holiday_dates, self.daytime_testing_today)
+                cursor_date_key = cursor_date.isoformat()
+                dual_device_window = cursor_date_key in self.dual_device_window_start_dates
+                if not dual_device_window and self.dual_device_weekend_start_enabled:
+                    dual_device_window = self._is_weekend_start_day(cursor_date)

                # Evaluate both devices without mutating queue state, then commit once.
                mirrored_bundles, knapsack_bundles, remaining_time = self._select_bundles(
@@ -114,6 +122,7 @@ class Scheduler:
                selected_bundles = mirrored_bundles + knapsack_bundles
                if len(selected_bundles) == 0:
                    window_device = REF if window_device == DUT else DUT
+                    active_unscheduled = dut_unscheduled if window_device == DUT else ref_unscheduled
                    mirrored_bundles, knapsack_bundles, remaining_time = self._select_bundles(
                        window_device,
                        capacity,
@@ -125,6 +134,20 @@ class Scheduler:
                    if len(selected_bundles) == 0:
                        break

+                primary_device = window_device
+
+                if dual_device_window and remaining_time > 0:
+                    secondary_device = REF if primary_device == DUT else DUT
+                    secondary_unscheduled = dut_unscheduled if secondary_device == DUT else ref_unscheduled
+                    secondary_mirrored, secondary_knapsack, remaining_time = self._select_bundles(
+                        secondary_device,
+                        remaining_time,
+                        secondary_unscheduled,
+                        tc,
+                        mutate=True,
+                    )
+                    selected_bundles.extend(secondary_mirrored + secondary_knapsack)
+
                # Create a mirror of the other device for the next window
                bundle_pairs = bundle_pair_lookup(knapsack_bundles, dut_unscheduled, ref_unscheduled)

@@ -134,9 +157,10 @@ class Scheduler:
                    pending_target = self.pending_dut_mirror

                existing_pending = {(b.index, b.device) for b in pending_target}
+                selected_bundle_keys = {(b.index, b.device) for b in selected_bundles}
                for pair_bundle in bundle_pairs:
                    pair_key = (pair_bundle.index, pair_bundle.device)
-                    if pair_key in self.scheduled_bundle_keys or pair_key in existing_pending:
+                    if pair_key in self.scheduled_bundle_keys or pair_key in existing_pending or pair_key in selected_bundle_keys:
                        continue
                    pending_target.append(pair_bundle)
                    existing_pending.add(pair_key)
@@ -148,7 +172,7 @@ class Scheduler:
                    capacity_minutes=capacity,
                    remaining_minutes=remaining_time,
                    assigned_config=tc,
-                    assigned_device=window_device,
+                    assigned_device=primary_device,
                )

                self._place_bundles_in_window(window, selected_bundles)
@@ -170,6 +194,11 @@ class Scheduler:

        return None

+    def _is_weekend_start_day(self, current_date: date) -> bool:
+        if is_off_day(current_date, self.holiday_dates):
+            return False
+        return is_off_day(current_date + timedelta(days=1), self.holiday_dates)
+
    def _select_bundles(
        self,
        device: str,
@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+from pathlib import Path
+import sys
+import unittest
+
+sys.path.append(str(Path(__file__).resolve().parent))
+
+from scheduler import DUT, REF, Scheduler
+from test_bundle import Test
+
+
+def _test_config() -> dict[str, dict[str, str | None]]:
+    return {
+        "Station 1": {
+            "test_point": "T1D",
+            "sta": "STA5",
+        }
+    }
+
+
+def _make_test(test_id: str, device: str, minutes: int) -> Test:
+    return Test(
+        test_id=test_id,
+        device=device,
+        test_type="P2P",
+        rotation=None,
+        rx_tx=None,
+        has_coe_pair=False,
+        coe_pairing=[],
+        config=_test_config(),
+        throttled=False,
+        estimated_minutes=minutes,
+    )
+
+
+class SchedulerDualDeviceWeekendStartTests(unittest.TestCase):
+    def _first_window_devices(self, entries, start_date: str) -> set[str]:
+        return {
+            entry.device
+            for entry in entries
+            if entry.scheduled_date == start_date and entry.shift_index == 3
+        }
+
+    def test_weekend_start_window_stays_single_device_when_disabled(self) -> None:
+        start_date = "2026-07-10"  # Friday
+        tests = [
+            _make_test("P2PRXAX001", DUT, 900),
+            _make_test("P2PRXAX001", REF, 300),
+        ]
+
+        scheduler = Scheduler(
+            tests=tests,
+            top_priority_tests=set(),
+            start_date=start_date,
+            holiday_dates=set(),
+            dual_device_weekend_start_enabled=False,
+        )
+
+        err = scheduler.compile_schedule()
+        self.assertIsNone(err)
+        entries = scheduler.get_schedule()
+
+        self.assertEqual(self._first_window_devices(entries, start_date), {DUT})
+
+    def test_weekend_start_window_runs_both_devices_when_enabled(self) -> None:
+        start_date = "2026-07-10"  # Friday
+        tests = [
+            _make_test("P2PRXAX001", DUT, 900),
+            _make_test("P2PRXAX001", REF, 300),
+        ]
+
+        scheduler = Scheduler(
+            tests=tests,
+            top_priority_tests=set(),
+            start_date=start_date,
+            holiday_dates=set(),
+            dual_device_weekend_start_enabled=True,
+        )
+
+        err = scheduler.compile_schedule()
+        self.assertIsNone(err)
+        entries = scheduler.get_schedule()
+
+        self.assertEqual(self._first_window_devices(entries, start_date), {DUT, REF})
+
+    def test_holiday_adjusted_weekend_start_runs_both_devices(self) -> None:
+        start_date = "2026-07-09"  # Thursday with Friday as holiday => weekend-start window
+        holidays = {"2026-07-10"}
+        tests = [
+            _make_test("P2PRXAX001", DUT, 700),
+            _make_test("P2PRXAX001", REF, 400),
+        ]
+
+        scheduler = Scheduler(
+            tests=tests,
+            top_priority_tests=set(),
+            start_date=start_date,
+            holiday_dates=holidays,
+            dual_device_weekend_start_enabled=True,
+        )
+
+        err = scheduler.compile_schedule()
+        self.assertIsNone(err)
+        entries = scheduler.get_schedule()
+
+        self.assertEqual(self._first_window_devices(entries, start_date), {DUT, REF})
+
+
+if __name__ == "__main__":
+    unittest.main()
@@ -37,6 +37,33 @@ function addDays(date, n) {
  return d
 }

+function parseHolidayDates(raw = '') {
+  return new Set(
+    String(raw)
+      .split(',')
+      .map((token) => token.trim())
+      .filter(Boolean),
+  )
+}
+
+function isOffDay(date, holidaySet) {
+  const weekday = date.getDay()
+  if (weekday === 0 || weekday === 6) return true
+  return holidaySet.has(toKey(date))
+}
+
+function getWeekendStartDatesForWeek(weekStart, holidaySet) {
+  const dates = []
+  for (let offset = 0; offset < 7; offset += 1) {
+    const current = addDays(weekStart, offset)
+    const nextDay = addDays(current, 1)
+    if (!isOffDay(current, holidaySet) && isOffDay(nextDay, holidaySet)) {
+      dates.push(toKey(current))
+    }
+  }
+  return dates
+}
+
 function getTonightWindowKeys() {
  const now = new Date()
  const hour = now.getHours()
@@ -120,7 +147,7 @@ function sanitizeSettings(saved = {}) {
 export default function App() {
  const [settingsOpen,   setSettingsOpen]   = useState(false)
  const [settings,       setSettings]       = useState(DEFAULT_SETTINGS)
-  const [daytimeEnabled, setDaytimeEnabled] = useState(false)
+  const [dualDeviceWeekendWeekSelections, setDualDeviceWeekendWeekSelections] = useState({})
  const [topPriority,    setTopPriority]    = useState('')
  const [lowestPriority, setLowestPriority] = useState('')
  const [startDateOverride, setStartDateOverride] = useState('')
@@ -148,6 +175,13 @@ export default function App() {
    () => scheduleWindows.find((windowDetails) => windowDetails.window_id === selectedWindowId) ?? null,
    [scheduleWindows, selectedWindowId],
  )
+  const holidaySet = useMemo(() => parseHolidayDates(settings.holidays), [settings.holidays])
+  const activeWeekKey = useMemo(() => toKey(weekStart), [weekStart])
+  const dualDeviceWeekendWeekEnabled = Boolean(dualDeviceWeekendWeekSelections[activeWeekKey])
+  const dualDeviceWindowStartDates = useMemo(() => {
+    if (!dualDeviceWeekendWeekEnabled) return []
+    return getWeekendStartDatesForWeek(weekStart, holidaySet)
+  }, [dualDeviceWeekendWeekEnabled, weekStart, holidaySet])

  // Fetch schedule for the given weekStart (Monday)
  const fetchSchedule = useCallback(async (start) => {
@@ -245,7 +279,7 @@ export default function App() {
      const effectiveStartDate = startDateOverride.trim()
      const result = await api.compileSchedule({
        start_date: effectiveStartDate || null,
-        daytime_testing_today: daytimeEnabled,
+        dual_device_weekend_start_dates: dualDeviceWindowStartDates,
        top_priority_tests: topPriority.split(',').map(s => s.trim()).filter(Boolean),
        lowest_priority_tests: lowestPriority.split(',').map(s => s.trim()).filter(Boolean),
        rule: settings.testExclusion ?? '',
@@ -273,17 +307,13 @@ export default function App() {
    }
  }

-  function handleRerunDecision(rerunDuringDay) {
-    const rerunIds = failedTests.map(t => t.test_id).join(', ')
+  function handleRerunDecision(_rerunDuringDay) {
    setTopPriority(prev => {
      const existing = prev.split(',').map(s => s.trim()).filter(Boolean)
      const incoming = failedTests.map(t => t.test_id)
      const merged = [...new Set([...existing, ...incoming])]
      return merged.join(', ')
    })
-    if (rerunDuringDay) {
-      setDaytimeEnabled(true)
-    }
    setFailedTests([])
  }

@@ -323,9 +353,16 @@ export default function App() {
        <div className="flex-1 min-w-0 flex flex-col">
          <Calendar
            scheduleData={scheduleData}
-            daytimeDateKey={daytimeEnabled ? toKey(new Date()) : null}
+            daytimeDateKey={null}
            weekStart={weekStart}
            onWeekChange={setWeekStart}
+            dualDeviceWeekendWeekEnabled={dualDeviceWeekendWeekEnabled}
+            onDualDeviceWeekendWeekEnabledChange={(enabled) => {
+              setDualDeviceWeekendWeekSelections((prev) => ({
+                ...prev,
+                [activeWeekKey]: enabled,
+              }))
+            }}
            windowLookup={windowLookup}
            onWindowSelect={handleWindowSelect}
          />
@@ -335,8 +372,6 @@ export default function App() {
          completionDate={completionDate}
          startDateOverride={startDateOverride}
          onStartDateOverrideChange={setStartDateOverride}
-          daytimeEnabled={daytimeEnabled}
-          onDaytimeEnabledChange={setDaytimeEnabled}
          topPriority={topPriority}
          onTopPriorityChange={setTopPriority}
          lowestPriority={lowestPriority}
@@ -53,6 +53,8 @@ export default function Calendar({
  daytimeDateKey = null,
  weekStart,
  onWeekChange,
+  dualDeviceWeekendWeekEnabled = false,
+  onDualDeviceWeekendWeekEnabledChange,
  windowLookup = new Map(),
  onWindowSelect,
 }) {
@@ -111,6 +113,25 @@ export default function Calendar({
        >
          Today
        </button>
+        <div className="ml-auto flex items-center gap-2 text-xs text-gray-300 select-none">
+          <span>Run both devices on weekend this week</span>
+          <button
+            type="button"
+            role="switch"
+            aria-checked={dualDeviceWeekendWeekEnabled}
+            onClick={() => onDualDeviceWeekendWeekEnabledChange?.(!dualDeviceWeekendWeekEnabled)}
+            className={`relative inline-flex h-5 w-9 shrink-0 cursor-pointer rounded-full border-2 border-transparent transition-colors focus:outline-none focus:ring-2 focus:ring-blue-500/70 ${
+              dualDeviceWeekendWeekEnabled ? 'bg-blue-600' : 'bg-gray-600'
+            }`}
+            title="Toggle dual-device weekend-start scheduling for this week"
+          >
+            <span
+              className={`pointer-events-none inline-block h-4 w-4 rounded-full bg-white shadow transform transition-transform ${
+                dualDeviceWeekendWeekEnabled ? 'translate-x-4' : 'translate-x-0'
+              }`}
+            />
+          </button>
+        </div>
      </div>

      {/* 7-day grid */}
@@ -16,8 +16,6 @@ export default function RightPanel({
  completionDate,
  startDateOverride,
  onStartDateOverrideChange,
-  daytimeEnabled,
-  onDaytimeEnabledChange,
  topPriority,
  onTopPriorityChange,
  lowestPriority,
@@ -40,29 +38,6 @@ export default function RightPanel({
        </p>
      </div>

-      {/* Daytime testing toggle */}
-      <div>
-        <div className="flex items-center justify-between">
-          <p className="text-[11px] font-semibold uppercase tracking-wider text-gray-500">
-            Day Time Testing (Today)
-          </p>
-          <button
-            role="switch"
-            aria-checked={daytimeEnabled}
-            onClick={() => onDaytimeEnabledChange(!daytimeEnabled)}
-            className={`relative inline-flex h-5 w-9 shrink-0 cursor-pointer rounded-full border-2 border-transparent transition-colors ${
-              daytimeEnabled ? 'bg-blue-600' : 'bg-gray-600'
-            }`}
-          >
-            <span
-              className={`pointer-events-none inline-block h-4 w-4 rounded-full bg-white shadow transform transition-transform ${
-                daytimeEnabled ? 'translate-x-4' : 'translate-x-0'
-              }`}
-            />
-          </button>
-        </div>
-      </div>
-
      {/* Top priority */}
      <div>
        <label className="block text-[11px] font-semibold uppercase tracking-wider text-gray-500 mb-1.5">