|

self.browser = await self.playwright.chromium.connect_over_cdp("http://127.0.0.1:9222")
self.context = self.browser.contexts[0]      # reuse the logged-in context

sem = asyncio.Semaphore(max_concurrent)      # parallel pages in that same context
await asyncio.gather(*[self._process_spu(spu, sem) for spu in spu_list])

The time never goes into “which button do I click” — it goes into the page not responding the way you expect. A React re-render detaches the element you just resolved. A value written with fill() gets reset by the component a moment later. The color picker gets a click on “add” and simply doesn’t open. So every layer has to catch itself.

Anything that exhausts its retries gets written to a failure log and surfaced in the app’s failed list, ready to re-queue or export — so one stuck item doesn’t invalidate a whole batch. The other recurring problem was matching: spec names in the console mix full-width and half-width characters, Chinese and English, with stray spaces. Plain string comparison was guaranteed to miss. Normalizing both sides with NFKC + whitespace stripping + casefold before comparing made the “Chinese SKU never matches” bug disappear.

async def _fill_number_with_retry(self, loc, target: str, label: str):
  for retry in range(1, 6):
      await loc.click()
      await loc.fill(target)
      await loc.press("Tab")
      try:
          await expect(loc).to_have_value(target, timeout=3000)   # read back
          return
      except Exception:
          if retry == 5:
              raise ValueError(f"[{label}] fill failed after max retries")
          await asyncio.sleep(0.5 * retry)                        # back off, refill

The automation core is pure asyncio; the interface is Qt. Each has its own event loop. Every job runs on its own QThread with a fresh event loop inside it, and print from the coroutines is turned into Qt signals by swapping out sys.stdout — which meant the entire command-line era’s output became a live log pane without editing a single line of core code.

Force stop works by stopping the worker’s event loop from the main thread via call_soon_threadsafe. The subtlety is teardown: cancelled Playwright coroutines occasionally park inside a native call, and without a time-boxed cleanup the thread never returns — so the exit path has a deadline on it. The task table itself is a state machine (pending / running / done / failed / skipped), so stopping and restarting simply passes over what already succeeded. Resumability comes for free.

It started as a command-line script, but the moment the audience is the operations team, the command line is the barrier. The shipped version is compiled with Nuitka into macOS and Windows executables, alongside launcher scripts that find Chrome themselves and start it in debugging mode, downloadable spreadsheet templates, and config that seeds itself into the user data directory on first run. On startup it validates a license against an internal service and shows an “authorized” badge in the status bar. The tool stores no platform credentials of its own — it only ever uses the browser the person is already signed into.