fix(app): report an exited target once instead of spamming error dialogs

PyMemoryEditor/app/_auto_refresh_dialog.py

@@ -10,13 +10,24 @@
 that self-throttles the poll, the detach-on-shutdown safety) where a fix to one
 copy wouldn't reach the others. This owns the lifecycle once; subclasses provide
 only what differs: how to fetch the data, and how to render it.
+
+It also owns *when* a failure is worth interrupting the user — see
+:meth:`AutoRefreshTableDialog._handle_failed`.
 """
 from typing import Callable, Optional
 
-from PySide6.QtCore import QThread, QTimer, Signal
+from PySide6.QtCore import QElapsedTimer, QThread, QTimer, Signal
 from PySide6.QtWidgets import QDialog
 
-from ._widgets import shutdown_worker_thread
+from ._widgets import TearsDownOnClose, shutdown_worker_thread
+
+
+# How long a target may keep failing before the auto-refresh gives up. Not
+# every failure is terminal (``CreateToolhelp32Snapshot`` is documented to fail
+# transiently while a target loads images), so a blip must not freeze a window
+# that would recover next tick. In wall-clock, not ticks: the intervals differ
+# by more than 10x across the windows that share this budget.
+_FAILURE_GRACE_MS = 3000
 
 
 class _DataWorker(QThread):
@@ -38,7 +49,7 @@ def run(self) -> None:
  self.ready.emit(data)
 
 
-class AutoRefreshTableDialog(QDialog):
+class AutoRefreshTableDialog(TearsDownOnClose, QDialog):
  """Owns the fetch-worker lifecycle + auto-refresh timer for a table dialog.
 
  Subclasses must:
@@ -57,6 +68,13 @@ def __init__(self, process, *, refresh_interval_ms: int, parent=None):
  self._has_data = False
  self._refresh_interval_ms = refresh_interval_ms
  self._auto_timer: Optional[QTimer] = None
+ # Failure state, all reset by a success or an explicit refresh(). See
+ # _handle_failed for how they decide what reaches the user.
+ self._last_error: Optional[str] = None # doubles as "already reported"
+ self._failing_since: Optional[QElapsedTimer] = None # streak clock
+ # Read by subclasses that rebuild their status line on user input, so
+ # the "stopped" note isn't replaced by a count that looks live.
+ self._polling_gave_up = False
 
  def _start_auto_refresh(self) -> None:
  """Begin polling. Call once, after the first ``refresh()``.
@@ -67,7 +85,7 @@ def _start_auto_refresh(self) -> None:
  """
  self._auto_timer = QTimer(self)
  self._auto_timer.setInterval(self._refresh_interval_ms)
- self._auto_timer.timeout.connect(self.refresh)
+ self._auto_timer.timeout.connect(self._auto_refresh_tick)
  self._auto_timer.start()
 
  # ------------------------------------------------------------------ #
@@ -83,17 +101,55 @@ def _on_data_ready(self, data) -> None:
  raise NotImplementedError
 
  def _on_data_failed(self, message: str) -> None:
- """Report a failed fetch. Runs on the UI thread."""
+ """Report a failed fetch. Runs on the UI thread.
+
+ Called only for a failure the user needs to see — the first fetch, or
+ the one that makes the poll give up — and never twice for the same
+ error (see :meth:`_handle_failed`), so a modal is safe here.
+ """
  raise NotImplementedError
 
  def _set_loading_hint(self) -> None:
  """Optionally show a one-time loading message before the first fetch."""
 
+ def _on_polling_stopped(self) -> None:
+ """Note that the auto-refresh gave up. Runs on the UI thread.
+
+ Fires once, when a target has been failing for ``_FAILURE_GRACE_MS``.
+ The table is frozen on its last good data from here on, so subclasses
+ should say so. Optional.
+ """
+
  # ------------------------------------------------------------------ #
  # Lifecycle (shared)
  # ------------------------------------------------------------------ #
 
  def refresh(self) -> None:
+ """Fetch now, on the user's behalf.
+
+ Clears the error latch and restarts a poll that repeated failures
+ stopped. The timer goes through :meth:`_auto_refresh_tick` instead,
+ which must *not* re-arm — and neither may a dismissed dialog, whose
+ teardown latch is one-way.
+ """
+ if self._is_dismissed():
+ return
+ self._last_error = None
+ self._failing_since = None
+ self._polling_gave_up = False
+ if self._auto_timer is not None and not self._auto_timer.isActive():
+ self._auto_timer.start()
+ self._start_fetch()
+
+ def _auto_refresh_tick(self) -> None:
+ """Timer-driven fetch — never re-arms after a failure."""
+ self._start_fetch()
+
+ def _start_fetch(self) -> None:
+ # A worker started after the teardown could never be joined again.
+ if self._is_dismissed():
+ return
+
  # Skip if a fetch is already in flight — the timer would otherwise stack
  # workers on a slow target. This self-throttles to the real fetch time.
  if self._worker is not None and self._worker.isRunning():
@@ -106,26 +162,83 @@ def refresh(self) -> None:
 
  worker = _DataWorker(self._fetch_data, self)
  worker.ready.connect(self._handle_ready)
- worker.failed.connect(self._on_data_failed)
- worker.finished.connect(self._on_worker_finished)
+ worker.failed.connect(self._handle_failed)
+ worker.finished.connect(lambda w=worker: self._on_worker_finished(w))
  self._worker = worker
  worker.start()
 
  def _handle_ready(self, data) -> None:
+ if self._is_dismissed():
+ return
  self._has_data = True
+ self._last_error = None
+ self._failing_since = None
  self._on_data_ready(data)
 
- def _on_worker_finished(self) -> None:
- worker = self._worker
- self._worker = None
- if worker is not None:
- worker.deleteLater()
+ def _handle_failed(self, message: str) -> None:
+ """Handle a failed fetch: report it only when the user needs to know.
+
+ Once the target is gone (or its handle was closed by File → Change
+ Process) *every* tick fails, and ``_on_data_failed`` pops a **modal**
+ dialog. A modal runs a nested event loop, so the timer fires again while
+ it is up and the failures stack — hundreds of focus-stealing dialogs the
+ user could only escape by killing the app from another TTY (issue #74).
+
+ Reporting is therefore tied to the two moments where a failure changes
+ what the user sees: the **first** fetch (empty window) and the one that
+ makes the poll **give up** (frozen table). Everything in between heals
+ quietly — and that silence is load-bearing: reporting every failure
+ re-opens the spam, since a target failing on alternating ticks stacks a
+ modal per failure until the stack runs out.
+
+ A dismissed dialog reports nothing. The teardown disconnects the worker,
+ but a delivery already queued then must not raise a modal over a window
+ that is gone — during ``MainWindow.closeEvent`` that would be a nested
+ event loop in the middle of teardown.
+ """
+ if self._is_dismissed():
+ return
+
+ if self._failing_since is None:
+ self._failing_since = QElapsedTimer()
+ self._failing_since.start()
+ gave_up = False
+ else:
+ gave_up = (
+ self._failing_since.elapsed() >= _FAILURE_GRACE_MS
+ and self._auto_timer is not None
+ and self._auto_timer.isActive()
+ )
+
+ if gave_up and self._auto_timer is not None:
+ self._auto_timer.stop()
+ self._polling_gave_up = True
+
+ never_reported_yet = not self._has_data and self._last_error is None
+ if (gave_up or never_reported_yet) and message != self._last_error:
+ self._last_error = message
+ self._on_data_failed(message)
+
+ # After the report, so the "stopped" note is what stays on screen.
+ if gave_up:
+ self._on_polling_stopped()
+
+ def _on_worker_finished(self, worker) -> None:
+ """Retire the worker that just finished — and only that one.
+
+ ``finished`` is queued, so it can arrive after the next tick already
+ started a replacement. Clearing ``self._worker`` blindly would drop the
+ reference to that *running* worker and ``deleteLater()`` it — destroying
+ a live QThread aborts the process.
+ """
+ if worker is self._worker:
+ self._worker = None
+ worker.deleteLater()
 
- def closeEvent(self, event): # noqa: N802 — Qt naming
+ def _teardown(self) -> None:
  if self._auto_timer is not None:
  self._auto_timer.stop()
  # Unhook + join the worker; if it can't stop in time it's detached
  # rather than destroyed under us.
  shutdown_worker_thread(self._worker, wait_ms=1000)
  self._worker = None
- super().closeEvent(event)

PyMemoryEditor/app/_widgets.py

@@ -8,7 +8,7 @@
 
 from typing import Any, Callable, Iterable, List, Optional, Tuple
 
-from PySide6.QtCore import Qt, QThread
+from PySide6.QtCore import QObject, Qt, QThread
 from PySide6.QtGui import QStandardItem
 
 
@@ -44,27 +44,85 @@ def shutdown_worker_thread(worker: Optional[QThread], wait_ms: int = 2000) -> No
  if callable(cancel):
  cancel()
  try:
- worker.disconnect() # drop every outgoing connection at once
+ # The four-argument static form on purpose: bare `worker.disconnect()`
+ # raises TypeError in PySide6 (so this except swallowed it and nothing
+ # was disconnected), and `worker.disconnect(worker)` only drops
+ # connections whose *receiver* is the worker — ours belong to the dialog.
+ QObject.disconnect(worker, None, None, None)
  except (RuntimeError, TypeError):
  pass
 
  if worker.isRunning():
  worker.wait(wait_ms)
 
  if worker.isRunning():
- worker.setParent(None)
- _DETACHED_WORKERS.append(worker)
- worker.finished.connect(lambda: _reap_detached_worker(worker))
+ detach_worker(worker)
  else:
  worker.deleteLater()
 
 
+def detach_worker(worker: QThread) -> None:
+ """Park a worker that wouldn't stop, so its owner can be destroyed.
+
+ Reparents it away from the dying widget and holds it in the module-level
+ registry until it finishes on its own. Callers that stop workers their own
+ way park them here too, so threads that outlived their owner are all in one
+ place.
+ """
+ worker.setParent(None)
+ _DETACHED_WORKERS.append(worker)
+ worker.finished.connect(lambda: _reap_detached_worker(worker))
+ # A worker that finished before this connect already emitted, so the reaper
+ # would never run and it would sit here for good.
+ if worker.isFinished():
+ _reap_detached_worker(worker)
+
+
 def _reap_detached_worker(worker: QThread) -> None:
  if worker in _DETACHED_WORKERS:
  _DETACHED_WORKERS.remove(worker)
  worker.deleteLater()
 
 
+class TearsDownOnClose:
+ """Mixin that runs a dialog's teardown on *every* way out, not just close.
+
+ ``QDialog`` delivers a ``QCloseEvent`` only for a real close. The app's own
+ "Close" buttons call ``accept()`` and Esc reaches ``reject()``; both land in
+ ``done()``, which hides the dialog and emits ``finished`` *without* any
+ close event — so a teardown living in ``closeEvent`` never ran, and the
+ dialog kept polling, hidden and unreachable.
+
+ Subclasses implement :meth:`_teardown`; the mixin runs it exactly once,
+ whichever way the dialog is dismissed, and must precede ``QDialog`` in the
+ bases so its overrides win. Running once makes instances single-use, which
+ is what every caller here assumes.
+ """
+
+ def _teardown(self) -> None:
+ """Release timers and background threads. Runs exactly once."""
+ raise NotImplementedError
+
+ def _is_dismissed(self) -> bool:
+ """Whether the teardown has run. Guards live on this, not on a repeated
+ attribute lookup a typo could silently disable."""
+ return getattr(self, "_teardown_done", False)
+
+ def _run_teardown_once(self) -> None:
+ if self._is_dismissed():
+ return
+ self._teardown_done = True
+ self._teardown()
+
+ def done(self, result: int) -> None: # noqa: N802 — Qt naming
+ self._run_teardown_once()
+ super().done(result)
+
+ def closeEvent(self, event) -> None: # noqa: N802 — Qt naming
+ self._run_teardown_once()
+ super().closeEvent(event)
+
+
 class NumericItem(QStandardItem):
  """A QStandardItem that compares by its Qt.UserRole int payload.
 

PyMemoryEditor/app/application.py

@@ -539,7 +539,9 @@ def main(argv=None):
  app.exec()
  finally:
  try:
- process.close()
+ # `process` is only the handle the picker opened; File → Change
+ # Process… released that one and attached the window to another.
+ window.process.close()
  except Exception:
  pass
 

PyMemoryEditor/app/cheat_poll_worker.py

@@ -106,6 +106,11 @@ def request_write(
  with QMutexLocker(self._mutex):
  self._pending_writes.append((address, pytype, length, value))
 
+ def _stopping(self) -> bool:
+ """Whether ``stop`` was asked for. Cheap enough to check per entry."""
+ with QMutexLocker(self._mutex):
+ return self._stop
+
  def stop(self) -> None:
  with QMutexLocker(self._mutex):
  self._stop = True
@@ -126,6 +131,8 @@ def _drain_pending_writes(self) -> List[Tuple[int, type, int, str]]:
 
  failures: List[Tuple[int, type, int, str]] = []
  for address, pytype, length, value in pending:
+ if self._stopping():
+ break # the handle is about to go — see _poll_once
  try:
  self._process.write_process_memory(address, pytype, length, value)
  except Exception as exc: # noqa: BLE001
@@ -206,6 +213,11 @@ def _poll_once(
  values_by_address = None
 
  for address in addresses:
+ # Per entry, not per tick: shutdown() closes the handle right
+ # after stop(), and a write on a recycled one hits another
+ # process.
+ if self._stopping():
+ return results
  frozen_value, is_frozen = freeze_by_addr[(pytype, length, address)]
  if values_by_address is not None:
  current = values_by_address.get(address)

PyMemoryEditor/app/_auto_refresh_dialog.py

@@ -10,13 +10,24 @@
 that self-throttles the poll, the detach-on-shutdown safety) where a fix to one
 copy wouldn't reach the others. This owns the lifecycle once; subclasses provide
 only what differs: how to fetch the data, and how to render it.
+
+It also owns *when* a failure is worth interrupting the user — see
+:meth:`AutoRefreshTableDialog._handle_failed`.
 """
 from typing import Callable, Optional
 
-from PySide6.QtCore import QThread, QTimer, Signal
+from PySide6.QtCore import QElapsedTimer, QThread, QTimer, Signal
 from PySide6.QtWidgets import QDialog
 
-from ._widgets import shutdown_worker_thread
+from ._widgets import TearsDownOnClose, shutdown_worker_thread
+
+
+# How long a target may keep failing before the auto-refresh gives up. Not
+# every failure is terminal (``CreateToolhelp32Snapshot`` is documented to fail
+# transiently while a target loads images), so a blip must not freeze a window
+# that would recover next tick. In wall-clock, not ticks: the intervals differ
+# by more than 10x across the windows that share this budget.
+_FAILURE_GRACE_MS = 3000
 
 
 class _DataWorker(QThread):
@@ -38,7 +49,7 @@ def run(self) -> None:
  self.ready.emit(data)
 
 
-class AutoRefreshTableDialog(QDialog):
+class AutoRefreshTableDialog(TearsDownOnClose, QDialog):
  """Owns the fetch-worker lifecycle + auto-refresh timer for a table dialog.
 
  Subclasses must:
@@ -57,6 +68,13 @@ def __init__(self, process, *, refresh_interval_ms: int, parent=None):
  self._has_data = False
  self._refresh_interval_ms = refresh_interval_ms
  self._auto_timer: Optional[QTimer] = None
+ # Failure state, all reset by a success or an explicit refresh(). See
+ # _handle_failed for how they decide what reaches the user.
+ self._last_error: Optional[str] = None # doubles as "already reported"
+ self._failing_since: Optional[QElapsedTimer] = None # streak clock
+ # Read by subclasses that rebuild their status line on user input, so
+ # the "stopped" note isn't replaced by a count that looks live.
+ self._polling_gave_up = False
 
  def _start_auto_refresh(self) -> None:
  """Begin polling. Call once, after the first ``refresh()``.
@@ -67,7 +85,7 @@ def _start_auto_refresh(self) -> None:
  """
  self._auto_timer = QTimer(self)
  self._auto_timer.setInterval(self._refresh_interval_ms)
- self._auto_timer.timeout.connect(self.refresh)
+ self._auto_timer.timeout.connect(self._auto_refresh_tick)
  self._auto_timer.start()
 
  # ------------------------------------------------------------------ #
@@ -83,17 +101,55 @@ def _on_data_ready(self, data) -> None:
  raise NotImplementedError
 
  def _on_data_failed(self, message: str) -> None:
- """Report a failed fetch. Runs on the UI thread."""
+ """Report a failed fetch. Runs on the UI thread.
+
+ Called only for a failure the user needs to see — the first fetch, or
+ the one that makes the poll give up — and never twice for the same
+ error (see :meth:`_handle_failed`), so a modal is safe here.
+ """
  raise NotImplementedError
 
  def _set_loading_hint(self) -> None:
  """Optionally show a one-time loading message before the first fetch."""
 
+ def _on_polling_stopped(self) -> None:
+ """Note that the auto-refresh gave up. Runs on the UI thread.
+
+ Fires once, when a target has been failing for ``_FAILURE_GRACE_MS``.
+ The table is frozen on its last good data from here on, so subclasses
+ should say so. Optional.
+ """
+
  # ------------------------------------------------------------------ #
  # Lifecycle (shared)
  # ------------------------------------------------------------------ #
 
  def refresh(self) -> None:
+ """Fetch now, on the user's behalf.
+
+ Clears the error latch and restarts a poll that repeated failures
+ stopped. The timer goes through :meth:`_auto_refresh_tick` instead,
+ which must *not* re-arm — and neither may a dismissed dialog, whose
+ teardown latch is one-way.
+ """
+ if self._is_dismissed():
+ return
+ self._last_error = None
+ self._failing_since = None
+ self._polling_gave_up = False
+ if self._auto_timer is not None and not self._auto_timer.isActive():
+ self._auto_timer.start()
+ self._start_fetch()
+
+ def _auto_refresh_tick(self) -> None:
+ """Timer-driven fetch — never re-arms after a failure."""
+ self._start_fetch()
+
+ def _start_fetch(self) -> None:
+ # A worker started after the teardown could never be joined again.
+ if self._is_dismissed():
+ return
+
  # Skip if a fetch is already in flight — the timer would otherwise stack
  # workers on a slow target. This self-throttles to the real fetch time.
  if self._worker is not None and self._worker.isRunning():
@@ -106,26 +162,83 @@ def refresh(self) -> None:
 
  worker = _DataWorker(self._fetch_data, self)
  worker.ready.connect(self._handle_ready)
- worker.failed.connect(self._on_data_failed)
- worker.finished.connect(self._on_worker_finished)
+ worker.failed.connect(self._handle_failed)
+ worker.finished.connect(lambda w=worker: self._on_worker_finished(w))
  self._worker = worker
  worker.start()
 
  def _handle_ready(self, data) -> None:
+ if self._is_dismissed():
+ return
  self._has_data = True
+ self._last_error = None
+ self._failing_since = None
  self._on_data_ready(data)
 
- def _on_worker_finished(self) -> None:
- worker = self._worker
- self._worker = None
- if worker is not None:
- worker.deleteLater()
+ def _handle_failed(self, message: str) -> None:
+ """Handle a failed fetch: report it only when the user needs to know.
+
+ Once the target is gone (or its handle was closed by File → Change
+ Process) *every* tick fails, and ``_on_data_failed`` pops a **modal**
+ dialog. A modal runs a nested event loop, so the timer fires again while
+ it is up and the failures stack — hundreds of focus-stealing dialogs the
+ user could only escape by killing the app from another TTY (issue #74).
+
+ Reporting is therefore tied to the two moments where a failure changes
+ what the user sees: the **first** fetch (empty window) and the one that
+ makes the poll **give up** (frozen table). Everything in between heals
+ quietly — and that silence is load-bearing: reporting every failure
+ re-opens the spam, since a target failing on alternating ticks stacks a
+ modal per failure until the stack runs out.
+
+ A dismissed dialog reports nothing. The teardown disconnects the worker,
+ but a delivery already queued then must not raise a modal over a window
+ that is gone — during ``MainWindow.closeEvent`` that would be a nested
+ event loop in the middle of teardown.
+ """
+ if self._is_dismissed():
+ return
+
+ if self._failing_since is None:
+ self._failing_since = QElapsedTimer()
+ self._failing_since.start()
+ gave_up = False
+ else:
+ gave_up = (
+ self._failing_since.elapsed() >= _FAILURE_GRACE_MS
+ and self._auto_timer is not None
+ and self._auto_timer.isActive()
+ )
+
+ if gave_up and self._auto_timer is not None:
+ self._auto_timer.stop()
+ self._polling_gave_up = True
+
+ never_reported_yet = not self._has_data and self._last_error is None
+ if (gave_up or never_reported_yet) and message != self._last_error:
+ self._last_error = message
+ self._on_data_failed(message)
+
+ # After the report, so the "stopped" note is what stays on screen.
+ if gave_up:
+ self._on_polling_stopped()
+
+ def _on_worker_finished(self, worker) -> None:
+ """Retire the worker that just finished — and only that one.
+
+ ``finished`` is queued, so it can arrive after the next tick already
+ started a replacement. Clearing ``self._worker`` blindly would drop the
+ reference to that *running* worker and ``deleteLater()`` it — destroying
+ a live QThread aborts the process.
+ """
+ if worker is self._worker:
+ self._worker = None
+ worker.deleteLater()
 
- def closeEvent(self, event): # noqa: N802 — Qt naming
+ def _teardown(self) -> None:
  if self._auto_timer is not None:
  self._auto_timer.stop()
  # Unhook + join the worker; if it can't stop in time it's detached
  # rather than destroyed under us.
  shutdown_worker_thread(self._worker, wait_ms=1000)
  self._worker = None
- super().closeEvent(event)

PyMemoryEditor/app/_widgets.py

@@ -8,7 +8,7 @@
 
 from typing import Any, Callable, Iterable, List, Optional, Tuple
 
-from PySide6.QtCore import Qt, QThread
+from PySide6.QtCore import QObject, Qt, QThread
 from PySide6.QtGui import QStandardItem
 
 
@@ -44,27 +44,85 @@ def shutdown_worker_thread(worker: Optional[QThread], wait_ms: int = 2000) -> No
  if callable(cancel):
  cancel()
  try:
- worker.disconnect() # drop every outgoing connection at once
+ # The four-argument static form on purpose: bare `worker.disconnect()`
+ # raises TypeError in PySide6 (so this except swallowed it and nothing
+ # was disconnected), and `worker.disconnect(worker)` only drops
+ # connections whose *receiver* is the worker — ours belong to the dialog.
+ QObject.disconnect(worker, None, None, None)
  except (RuntimeError, TypeError):
  pass
 
  if worker.isRunning():
  worker.wait(wait_ms)
 
  if worker.isRunning():
- worker.setParent(None)
- _DETACHED_WORKERS.append(worker)
- worker.finished.connect(lambda: _reap_detached_worker(worker))
+ detach_worker(worker)
  else:
  worker.deleteLater()
 
 
+def detach_worker(worker: QThread) -> None:
+ """Park a worker that wouldn't stop, so its owner can be destroyed.
+
+ Reparents it away from the dying widget and holds it in the module-level
+ registry until it finishes on its own. Callers that stop workers their own
+ way park them here too, so threads that outlived their owner are all in one
+ place.
+ """
+ worker.setParent(None)
+ _DETACHED_WORKERS.append(worker)
+ worker.finished.connect(lambda: _reap_detached_worker(worker))
+ # A worker that finished before this connect already emitted, so the reaper
+ # would never run and it would sit here for good.
+ if worker.isFinished():
+ _reap_detached_worker(worker)
+
+
 def _reap_detached_worker(worker: QThread) -> None:
  if worker in _DETACHED_WORKERS:
  _DETACHED_WORKERS.remove(worker)
  worker.deleteLater()
 
 
+class TearsDownOnClose:
+ """Mixin that runs a dialog's teardown on *every* way out, not just close.
+
+ ``QDialog`` delivers a ``QCloseEvent`` only for a real close. The app's own
+ "Close" buttons call ``accept()`` and Esc reaches ``reject()``; both land in
+ ``done()``, which hides the dialog and emits ``finished`` *without* any
+ close event — so a teardown living in ``closeEvent`` never ran, and the
+ dialog kept polling, hidden and unreachable.
+
+ Subclasses implement :meth:`_teardown`; the mixin runs it exactly once,
+ whichever way the dialog is dismissed, and must precede ``QDialog`` in the
+ bases so its overrides win. Running once makes instances single-use, which
+ is what every caller here assumes.
+ """
+
+ def _teardown(self) -> None:
+ """Release timers and background threads. Runs exactly once."""
+ raise NotImplementedError
+
+ def _is_dismissed(self) -> bool:
+ """Whether the teardown has run. Guards live on this, not on a repeated
+ attribute lookup a typo could silently disable."""
+ return getattr(self, "_teardown_done", False)
+
+ def _run_teardown_once(self) -> None:
+ if self._is_dismissed():
+ return
+ self._teardown_done = True
+ self._teardown()
+
+ def done(self, result: int) -> None: # noqa: N802 — Qt naming
+ self._run_teardown_once()
+ super().done(result)
+
+ def closeEvent(self, event) -> None: # noqa: N802 — Qt naming
+ self._run_teardown_once()
+ super().closeEvent(event)
+
+
 class NumericItem(QStandardItem):
  """A QStandardItem that compares by its Qt.UserRole int payload.
 

PyMemoryEditor/app/application.py

@@ -539,7 +539,9 @@ def main(argv=None):
  app.exec()
  finally:
  try:
- process.close()
+ # `process` is only the handle the picker opened; File → Change
+ # Process… released that one and attached the window to another.
+ window.process.close()
  except Exception:
  pass
 

PyMemoryEditor/app/cheat_poll_worker.py

@@ -106,6 +106,11 @@ def request_write(
  with QMutexLocker(self._mutex):
  self._pending_writes.append((address, pytype, length, value))
 
+ def _stopping(self) -> bool:
+ """Whether ``stop`` was asked for. Cheap enough to check per entry."""
+ with QMutexLocker(self._mutex):
+ return self._stop
+
  def stop(self) -> None:
  with QMutexLocker(self._mutex):
  self._stop = True
@@ -126,6 +131,8 @@ def _drain_pending_writes(self) -> List[Tuple[int, type, int, str]]:
 
  failures: List[Tuple[int, type, int, str]] = []
  for address, pytype, length, value in pending:
+ if self._stopping():
+ break # the handle is about to go — see _poll_once
  try:
  self._process.write_process_memory(address, pytype, length, value)
  except Exception as exc: # noqa: BLE001
@@ -206,6 +213,11 @@ def _poll_once(
  values_by_address = None
 
  for address in addresses:
+ # Per entry, not per tick: shutdown() closes the handle right
+ # after stop(), and a write on a recycled one hits another
+ # process.
+ if self._stopping():
+ return results
  frozen_value, is_frozen = freeze_by_addr[(pytype, length, address)]
  if values_by_address is not None:
  current = values_by_address.get(address)

PyMemoryEditor/app/_auto_refresh_dialog.py

@@ -10,13 +10,24 @@
 that self-throttles the poll, the detach-on-shutdown safety) where a fix to one
 copy wouldn't reach the others. This owns the lifecycle once; subclasses provide
 only what differs: how to fetch the data, and how to render it.
+
+It also owns *when* a failure is worth interrupting the user — see
+:meth:`AutoRefreshTableDialog._handle_failed`.
 """
 from typing import Callable, Optional
 
-from PySide6.QtCore import QThread, QTimer, Signal
+from PySide6.QtCore import QElapsedTimer, QThread, QTimer, Signal
 from PySide6.QtWidgets import QDialog
 
-from ._widgets import shutdown_worker_thread
+from ._widgets import TearsDownOnClose, shutdown_worker_thread
+
+
+# How long a target may keep failing before the auto-refresh gives up. Not
+# every failure is terminal (``CreateToolhelp32Snapshot`` is documented to fail
+# transiently while a target loads images), so a blip must not freeze a window
+# that would recover next tick. In wall-clock, not ticks: the intervals differ
+# by more than 10x across the windows that share this budget.
+_FAILURE_GRACE_MS = 3000
 
 
 class _DataWorker(QThread):
@@ -38,7 +49,7 @@ def run(self) -> None:
  self.ready.emit(data)
 
 
-class AutoRefreshTableDialog(QDialog):
+class AutoRefreshTableDialog(TearsDownOnClose, QDialog):
  """Owns the fetch-worker lifecycle + auto-refresh timer for a table dialog.
 
  Subclasses must:
@@ -57,6 +68,13 @@ def __init__(self, process, *, refresh_interval_ms: int, parent=None):
  self._has_data = False
  self._refresh_interval_ms = refresh_interval_ms
  self._auto_timer: Optional[QTimer] = None
+ # Failure state, all reset by a success or an explicit refresh(). See
+ # _handle_failed for how they decide what reaches the user.
+ self._last_error: Optional[str] = None # doubles as "already reported"
+ self._failing_since: Optional[QElapsedTimer] = None # streak clock
+ # Read by subclasses that rebuild their status line on user input, so
+ # the "stopped" note isn't replaced by a count that looks live.
+ self._polling_gave_up = False
 
  def _start_auto_refresh(self) -> None:
  """Begin polling. Call once, after the first ``refresh()``.
@@ -67,7 +85,7 @@ def _start_auto_refresh(self) -> None:
  """
  self._auto_timer = QTimer(self)
  self._auto_timer.setInterval(self._refresh_interval_ms)
- self._auto_timer.timeout.connect(self.refresh)
+ self._auto_timer.timeout.connect(self._auto_refresh_tick)
  self._auto_timer.start()
 
  # ------------------------------------------------------------------ #
@@ -83,17 +101,55 @@ def _on_data_ready(self, data) -> None:
  raise NotImplementedError
 
  def _on_data_failed(self, message: str) -> None:
- """Report a failed fetch. Runs on the UI thread."""
+ """Report a failed fetch. Runs on the UI thread.
+
+ Called only for a failure the user needs to see — the first fetch, or
+ the one that makes the poll give up — and never twice for the same
+ error (see :meth:`_handle_failed`), so a modal is safe here.
+ """
  raise NotImplementedError
 
  def _set_loading_hint(self) -> None:
  """Optionally show a one-time loading message before the first fetch."""
 
+ def _on_polling_stopped(self) -> None:
+ """Note that the auto-refresh gave up. Runs on the UI thread.
+
+ Fires once, when a target has been failing for ``_FAILURE_GRACE_MS``.
+ The table is frozen on its last good data from here on, so subclasses
+ should say so. Optional.
+ """
+
  # ------------------------------------------------------------------ #
  # Lifecycle (shared)
  # ------------------------------------------------------------------ #
 
  def refresh(self) -> None:
+ """Fetch now, on the user's behalf.
+
+ Clears the error latch and restarts a poll that repeated failures
+ stopped. The timer goes through :meth:`_auto_refresh_tick` instead,
+ which must *not* re-arm — and neither may a dismissed dialog, whose
+ teardown latch is one-way.
+ """
+ if self._is_dismissed():
+ return
+ self._last_error = None
+ self._failing_since = None
+ self._polling_gave_up = False
+ if self._auto_timer is not None and not self._auto_timer.isActive():
+ self._auto_timer.start()
+ self._start_fetch()
+
+ def _auto_refresh_tick(self) -> None:
+ """Timer-driven fetch — never re-arms after a failure."""
+ self._start_fetch()
+
+ def _start_fetch(self) -> None:
+ # A worker started after the teardown could never be joined again.
+ if self._is_dismissed():
+ return
+
  # Skip if a fetch is already in flight — the timer would otherwise stack
  # workers on a slow target. This self-throttles to the real fetch time.
  if self._worker is not None and self._worker.isRunning():
@@ -106,26 +162,83 @@ def refresh(self) -> None:
 
  worker = _DataWorker(self._fetch_data, self)
  worker.ready.connect(self._handle_ready)
- worker.failed.connect(self._on_data_failed)
- worker.finished.connect(self._on_worker_finished)
+ worker.failed.connect(self._handle_failed)
+ worker.finished.connect(lambda w=worker: self._on_worker_finished(w))
  self._worker = worker
  worker.start()
 
  def _handle_ready(self, data) -> None:
+ if self._is_dismissed():
+ return
  self._has_data = True
+ self._last_error = None
+ self._failing_since = None
  self._on_data_ready(data)
 
- def _on_worker_finished(self) -> None:
- worker = self._worker
- self._worker = None
- if worker is not None:
- worker.deleteLater()
+ def _handle_failed(self, message: str) -> None:
+ """Handle a failed fetch: report it only when the user needs to know.
+
+ Once the target is gone (or its handle was closed by File → Change
+ Process) *every* tick fails, and ``_on_data_failed`` pops a **modal**
+ dialog. A modal runs a nested event loop, so the timer fires again while
+ it is up and the failures stack — hundreds of focus-stealing dialogs the
+ user could only escape by killing the app from another TTY (issue #74).
+
+ Reporting is therefore tied to the two moments where a failure changes
+ what the user sees: the **first** fetch (empty window) and the one that
+ makes the poll **give up** (frozen table). Everything in between heals
+ quietly — and that silence is load-bearing: reporting every failure
+ re-opens the spam, since a target failing on alternating ticks stacks a
+ modal per failure until the stack runs out.
+
+ A dismissed dialog reports nothing. The teardown disconnects the worker,
+ but a delivery already queued then must not raise a modal over a window
+ that is gone — during ``MainWindow.closeEvent`` that would be a nested
+ event loop in the middle of teardown.
+ """
+ if self._is_dismissed():
+ return
+
+ if self._failing_since is None:
+ self._failing_since = QElapsedTimer()
+ self._failing_since.start()
+ gave_up = False
+ else:
+ gave_up = (
+ self._failing_since.elapsed() >= _FAILURE_GRACE_MS
+ and self._auto_timer is not None
+ and self._auto_timer.isActive()
+ )
+
+ if gave_up and self._auto_timer is not None:
+ self._auto_timer.stop()
+ self._polling_gave_up = True
+
+ never_reported_yet = not self._has_data and self._last_error is None
+ if (gave_up or never_reported_yet) and message != self._last_error:
+ self._last_error = message
+ self._on_data_failed(message)
+
+ # After the report, so the "stopped" note is what stays on screen.
+ if gave_up:
+ self._on_polling_stopped()
+
+ def _on_worker_finished(self, worker) -> None:
+ """Retire the worker that just finished — and only that one.
+
+ ``finished`` is queued, so it can arrive after the next tick already
+ started a replacement. Clearing ``self._worker`` blindly would drop the
+ reference to that *running* worker and ``deleteLater()`` it — destroying
+ a live QThread aborts the process.
+ """
+ if worker is self._worker:
+ self._worker = None
+ worker.deleteLater()
 
- def closeEvent(self, event): # noqa: N802 — Qt naming
+ def _teardown(self) -> None:
  if self._auto_timer is not None:
  self._auto_timer.stop()
  # Unhook + join the worker; if it can't stop in time it's detached
  # rather than destroyed under us.
  shutdown_worker_thread(self._worker, wait_ms=1000)
  self._worker = None
- super().closeEvent(event)

PyMemoryEditor/app/_widgets.py

@@ -8,7 +8,7 @@
 
 from typing import Any, Callable, Iterable, List, Optional, Tuple
 
-from PySide6.QtCore import Qt, QThread
+from PySide6.QtCore import QObject, Qt, QThread
 from PySide6.QtGui import QStandardItem
 
 
@@ -44,27 +44,85 @@ def shutdown_worker_thread(worker: Optional[QThread], wait_ms: int = 2000) -> No
  if callable(cancel):
  cancel()
  try:
- worker.disconnect() # drop every outgoing connection at once
+ # The four-argument static form on purpose: bare `worker.disconnect()`
+ # raises TypeError in PySide6 (so this except swallowed it and nothing
+ # was disconnected), and `worker.disconnect(worker)` only drops
+ # connections whose *receiver* is the worker — ours belong to the dialog.
+ QObject.disconnect(worker, None, None, None)
  except (RuntimeError, TypeError):
  pass
 
  if worker.isRunning():
  worker.wait(wait_ms)
 
  if worker.isRunning():
- worker.setParent(None)
- _DETACHED_WORKERS.append(worker)
- worker.finished.connect(lambda: _reap_detached_worker(worker))
+ detach_worker(worker)
  else:
  worker.deleteLater()
 
 
+def detach_worker(worker: QThread) -> None:
+ """Park a worker that wouldn't stop, so its owner can be destroyed.
+
+ Reparents it away from the dying widget and holds it in the module-level
+ registry until it finishes on its own. Callers that stop workers their own
+ way park them here too, so threads that outlived their owner are all in one
+ place.
+ """
+ worker.setParent(None)
+ _DETACHED_WORKERS.append(worker)
+ worker.finished.connect(lambda: _reap_detached_worker(worker))
+ # A worker that finished before this connect already emitted, so the reaper
+ # would never run and it would sit here for good.
+ if worker.isFinished():
+ _reap_detached_worker(worker)
+
+
 def _reap_detached_worker(worker: QThread) -> None:
  if worker in _DETACHED_WORKERS:
  _DETACHED_WORKERS.remove(worker)
  worker.deleteLater()
 
 
+class TearsDownOnClose:
+ """Mixin that runs a dialog's teardown on *every* way out, not just close.
+
+ ``QDialog`` delivers a ``QCloseEvent`` only for a real close. The app's own
+ "Close" buttons call ``accept()`` and Esc reaches ``reject()``; both land in
+ ``done()``, which hides the dialog and emits ``finished`` *without* any
+ close event — so a teardown living in ``closeEvent`` never ran, and the
+ dialog kept polling, hidden and unreachable.
+
+ Subclasses implement :meth:`_teardown`; the mixin runs it exactly once,
+ whichever way the dialog is dismissed, and must precede ``QDialog`` in the
+ bases so its overrides win. Running once makes instances single-use, which
+ is what every caller here assumes.
+ """
+
+ def _teardown(self) -> None:
+ """Release timers and background threads. Runs exactly once."""
+ raise NotImplementedError
+
+ def _is_dismissed(self) -> bool:
+ """Whether the teardown has run. Guards live on this, not on a repeated
+ attribute lookup a typo could silently disable."""
+ return getattr(self, "_teardown_done", False)
+
+ def _run_teardown_once(self) -> None:
+ if self._is_dismissed():
+ return
+ self._teardown_done = True
+ self._teardown()
+
+ def done(self, result: int) -> None: # noqa: N802 — Qt naming
+ self._run_teardown_once()
+ super().done(result)
+
+ def closeEvent(self, event) -> None: # noqa: N802 — Qt naming
+ self._run_teardown_once()
+ super().closeEvent(event)
+
+
 class NumericItem(QStandardItem):
  """A QStandardItem that compares by its Qt.UserRole int payload.
 

PyMemoryEditor/app/application.py

@@ -539,7 +539,9 @@ def main(argv=None):
  app.exec()
  finally:
  try:
- process.close()
+ # `process` is only the handle the picker opened; File → Change
+ # Process… released that one and attached the window to another.
+ window.process.close()
  except Exception:
  pass
 

PyMemoryEditor/app/cheat_poll_worker.py

@@ -106,6 +106,11 @@ def request_write(
  with QMutexLocker(self._mutex):
  self._pending_writes.append((address, pytype, length, value))
 
+ def _stopping(self) -> bool:
+ """Whether ``stop`` was asked for. Cheap enough to check per entry."""
+ with QMutexLocker(self._mutex):
+ return self._stop
+
  def stop(self) -> None:
  with QMutexLocker(self._mutex):
  self._stop = True
@@ -126,6 +131,8 @@ def _drain_pending_writes(self) -> List[Tuple[int, type, int, str]]:
 
  failures: List[Tuple[int, type, int, str]] = []
  for address, pytype, length, value in pending:
+ if self._stopping():
+ break # the handle is about to go — see _poll_once
  try:
  self._process.write_process_memory(address, pytype, length, value)
  except Exception as exc: # noqa: BLE001
@@ -206,6 +213,11 @@ def _poll_once(
  values_by_address = None
 
  for address in addresses:
+ # Per entry, not per tick: shutdown() closes the handle right
+ # after stop(), and a write on a recycled one hits another
+ # process.
+ if self._stopping():
+ return results
  frozen_value, is_frozen = freeze_by_addr[(pytype, length, address)]
  if values_by_address is not None:
  current = values_by_address.get(address)

PyMemoryEditor/app/_auto_refresh_dialog.py

@@ -10,13 +10,24 @@
 that self-throttles the poll, the detach-on-shutdown safety) where a fix to one
 copy wouldn't reach the others. This owns the lifecycle once; subclasses provide
 only what differs: how to fetch the data, and how to render it.
+
+It also owns *when* a failure is worth interrupting the user — see
+:meth:`AutoRefreshTableDialog._handle_failed`.
 """
 from typing import Callable, Optional
 
-from PySide6.QtCore import QThread, QTimer, Signal
+from PySide6.QtCore import QElapsedTimer, QThread, QTimer, Signal
 from PySide6.QtWidgets import QDialog
 
-from ._widgets import shutdown_worker_thread
+from ._widgets import TearsDownOnClose, shutdown_worker_thread
+
+
+# How long a target may keep failing before the auto-refresh gives up. Not
+# every failure is terminal (``CreateToolhelp32Snapshot`` is documented to fail
+# transiently while a target loads images), so a blip must not freeze a window
+# that would recover next tick. In wall-clock, not ticks: the intervals differ
+# by more than 10x across the windows that share this budget.
+_FAILURE_GRACE_MS = 3000
 
 
 class _DataWorker(QThread):
@@ -38,7 +49,7 @@ def run(self) -> None:
  self.ready.emit(data)
 
 
-class AutoRefreshTableDialog(QDialog):
+class AutoRefreshTableDialog(TearsDownOnClose, QDialog):
  """Owns the fetch-worker lifecycle + auto-refresh timer for a table dialog.
 
  Subclasses must:
@@ -57,6 +68,13 @@ def __init__(self, process, *, refresh_interval_ms: int, parent=None):
  self._has_data = False
  self._refresh_interval_ms = refresh_interval_ms
  self._auto_timer: Optional[QTimer] = None
+ # Failure state, all reset by a success or an explicit refresh(). See
+ # _handle_failed for how they decide what reaches the user.
+ self._last_error: Optional[str] = None # doubles as "already reported"
+ self._failing_since: Optional[QElapsedTimer] = None # streak clock
+ # Read by subclasses that rebuild their status line on user input, so
+ # the "stopped" note isn't replaced by a count that looks live.
+ self._polling_gave_up = False
 
  def _start_auto_refresh(self) -> None:
  """Begin polling. Call once, after the first ``refresh()``.
@@ -67,7 +85,7 @@ def _start_auto_refresh(self) -> None:
  """
  self._auto_timer = QTimer(self)
  self._auto_timer.setInterval(self._refresh_interval_ms)
- self._auto_timer.timeout.connect(self.refresh)
+ self._auto_timer.timeout.connect(self._auto_refresh_tick)
  self._auto_timer.start()
 
  # ------------------------------------------------------------------ #
@@ -83,17 +101,55 @@ def _on_data_ready(self, data) -> None:
  raise NotImplementedError
 
  def _on_data_failed(self, message: str) -> None:
- """Report a failed fetch. Runs on the UI thread."""
+ """Report a failed fetch. Runs on the UI thread.
+
+ Called only for a failure the user needs to see — the first fetch, or
+ the one that makes the poll give up — and never twice for the same
+ error (see :meth:`_handle_failed`), so a modal is safe here.
+ """
  raise NotImplementedError
 
  def _set_loading_hint(self) -> None:
  """Optionally show a one-time loading message before the first fetch."""
 
+ def _on_polling_stopped(self) -> None:
+ """Note that the auto-refresh gave up. Runs on the UI thread.
+
+ Fires once, when a target has been failing for ``_FAILURE_GRACE_MS``.
+ The table is frozen on its last good data from here on, so subclasses
+ should say so. Optional.
+ """
+
  # ------------------------------------------------------------------ #
  # Lifecycle (shared)
  # ------------------------------------------------------------------ #
 
  def refresh(self) -> None:
+ """Fetch now, on the user's behalf.
+
+ Clears the error latch and restarts a poll that repeated failures
+ stopped. The timer goes through :meth:`_auto_refresh_tick` instead,
+ which must *not* re-arm — and neither may a dismissed dialog, whose
+ teardown latch is one-way.
+ """
+ if self._is_dismissed():
+ return
+ self._last_error = None
+ self._failing_since = None
+ self._polling_gave_up = False
+ if self._auto_timer is not None and not self._auto_timer.isActive():
+ self._auto_timer.start()
+ self._start_fetch()
+
+ def _auto_refresh_tick(self) -> None:
+ """Timer-driven fetch — never re-arms after a failure."""
+ self._start_fetch()
+
+ def _start_fetch(self) -> None:
+ # A worker started after the teardown could never be joined again.
+ if self._is_dismissed():
+ return
+
  # Skip if a fetch is already in flight — the timer would otherwise stack
  # workers on a slow target. This self-throttles to the real fetch time.
  if self._worker is not None and self._worker.isRunning():
@@ -106,26 +162,83 @@ def refresh(self) -> None:
 
  worker = _DataWorker(self._fetch_data, self)
  worker.ready.connect(self._handle_ready)
- worker.failed.connect(self._on_data_failed)
- worker.finished.connect(self._on_worker_finished)
+ worker.failed.connect(self._handle_failed)
+ worker.finished.connect(lambda w=worker: self._on_worker_finished(w))
  self._worker = worker
  worker.start()
 
  def _handle_ready(self, data) -> None:
+ if self._is_dismissed():
+ return
  self._has_data = True
+ self._last_error = None
+ self._failing_since = None
  self._on_data_ready(data)
 
- def _on_worker_finished(self) -> None:
- worker = self._worker
- self._worker = None
- if worker is not None:
- worker.deleteLater()
+ def _handle_failed(self, message: str) -> None:
+ """Handle a failed fetch: report it only when the user needs to know.
+
+ Once the target is gone (or its handle was closed by File → Change
+ Process) *every* tick fails, and ``_on_data_failed`` pops a **modal**
+ dialog. A modal runs a nested event loop, so the timer fires again while
+ it is up and the failures stack — hundreds of focus-stealing dialogs the
+ user could only escape by killing the app from another TTY (issue #74).
+
+ Reporting is therefore tied to the two moments where a failure changes
+ what the user sees: the **first** fetch (empty window) and the one that
+ makes the poll **give up** (frozen table). Everything in between heals
+ quietly — and that silence is load-bearing: reporting every failure
+ re-opens the spam, since a target failing on alternating ticks stacks a
+ modal per failure until the stack runs out.
+
+ A dismissed dialog reports nothing. The teardown disconnects the worker,
+ but a delivery already queued then must not raise a modal over a window
+ that is gone — during ``MainWindow.closeEvent`` that would be a nested
+ event loop in the middle of teardown.
+ """
+ if self._is_dismissed():
+ return
+
+ if self._failing_since is None:
+ self._failing_since = QElapsedTimer()
+ self._failing_since.start()
+ gave_up = False
+ else:
+ gave_up = (
+ self._failing_since.elapsed() >= _FAILURE_GRACE_MS
+ and self._auto_timer is not None
+ and self._auto_timer.isActive()
+ )
+
+ if gave_up and self._auto_timer is not None:
+ self._auto_timer.stop()
+ self._polling_gave_up = True
+
+ never_reported_yet = not self._has_data and self._last_error is None
+ if (gave_up or never_reported_yet) and message != self._last_error:
+ self._last_error = message
+ self._on_data_failed(message)
+
+ # After the report, so the "stopped" note is what stays on screen.
+ if gave_up:
+ self._on_polling_stopped()
+
+ def _on_worker_finished(self, worker) -> None:
+ """Retire the worker that just finished — and only that one.
+
+ ``finished`` is queued, so it can arrive after the next tick already
+ started a replacement. Clearing ``self._worker`` blindly would drop the
+ reference to that *running* worker and ``deleteLater()`` it — destroying
+ a live QThread aborts the process.
+ """
+ if worker is self._worker:
+ self._worker = None
+ worker.deleteLater()
 
- def closeEvent(self, event): # noqa: N802 — Qt naming
+ def _teardown(self) -> None:
  if self._auto_timer is not None:
  self._auto_timer.stop()
  # Unhook + join the worker; if it can't stop in time it's detached
  # rather than destroyed under us.
  shutdown_worker_thread(self._worker, wait_ms=1000)
  self._worker = None
- super().closeEvent(event)

PyMemoryEditor/app/_widgets.py

@@ -8,7 +8,7 @@
 
 from typing import Any, Callable, Iterable, List, Optional, Tuple
 
-from PySide6.QtCore import Qt, QThread
+from PySide6.QtCore import QObject, Qt, QThread
 from PySide6.QtGui import QStandardItem
 
 
@@ -44,27 +44,85 @@ def shutdown_worker_thread(worker: Optional[QThread], wait_ms: int = 2000) -> No
  if callable(cancel):
  cancel()
  try:
- worker.disconnect() # drop every outgoing connection at once
+ # The four-argument static form on purpose: bare `worker.disconnect()`
+ # raises TypeError in PySide6 (so this except swallowed it and nothing
+ # was disconnected), and `worker.disconnect(worker)` only drops
+ # connections whose *receiver* is the worker — ours belong to the dialog.
+ QObject.disconnect(worker, None, None, None)
  except (RuntimeError, TypeError):
  pass
 
  if worker.isRunning():
  worker.wait(wait_ms)
 
  if worker.isRunning():
- worker.setParent(None)
- _DETACHED_WORKERS.append(worker)
- worker.finished.connect(lambda: _reap_detached_worker(worker))
+ detach_worker(worker)
  else:
  worker.deleteLater()
 
 
+def detach_worker(worker: QThread) -> None:
+ """Park a worker that wouldn't stop, so its owner can be destroyed.
+
+ Reparents it away from the dying widget and holds it in the module-level
+ registry until it finishes on its own. Callers that stop workers their own
+ way park them here too, so threads that outlived their owner are all in one
+ place.
+ """
+ worker.setParent(None)
+ _DETACHED_WORKERS.append(worker)
+ worker.finished.connect(lambda: _reap_detached_worker(worker))
+ # A worker that finished before this connect already emitted, so the reaper
+ # would never run and it would sit here for good.
+ if worker.isFinished():
+ _reap_detached_worker(worker)
+
+
 def _reap_detached_worker(worker: QThread) -> None:
  if worker in _DETACHED_WORKERS:
  _DETACHED_WORKERS.remove(worker)
  worker.deleteLater()
 
 
+class TearsDownOnClose:
+ """Mixin that runs a dialog's teardown on *every* way out, not just close.
+
+ ``QDialog`` delivers a ``QCloseEvent`` only for a real close. The app's own
+ "Close" buttons call ``accept()`` and Esc reaches ``reject()``; both land in
+ ``done()``, which hides the dialog and emits ``finished`` *without* any
+ close event — so a teardown living in ``closeEvent`` never ran, and the
+ dialog kept polling, hidden and unreachable.
+
+ Subclasses implement :meth:`_teardown`; the mixin runs it exactly once,
+ whichever way the dialog is dismissed, and must precede ``QDialog`` in the
+ bases so its overrides win. Running once makes instances single-use, which
+ is what every caller here assumes.
+ """
+
+ def _teardown(self) -> None:
+ """Release timers and background threads. Runs exactly once."""
+ raise NotImplementedError
+
+ def _is_dismissed(self) -> bool:
+ """Whether the teardown has run. Guards live on this, not on a repeated
+ attribute lookup a typo could silently disable."""
+ return getattr(self, "_teardown_done", False)
+
+ def _run_teardown_once(self) -> None:
+ if self._is_dismissed():
+ return
+ self._teardown_done = True
+ self._teardown()
+
+ def done(self, result: int) -> None: # noqa: N802 — Qt naming
+ self._run_teardown_once()
+ super().done(result)
+
+ def closeEvent(self, event) -> None: # noqa: N802 — Qt naming
+ self._run_teardown_once()
+ super().closeEvent(event)
+
+
 class NumericItem(QStandardItem):
  """A QStandardItem that compares by its Qt.UserRole int payload.
 

PyMemoryEditor/app/application.py

@@ -539,7 +539,9 @@ def main(argv=None):
  app.exec()
  finally:
  try:
- process.close()
+ # `process` is only the handle the picker opened; File → Change
+ # Process… released that one and attached the window to another.
+ window.process.close()
  except Exception:
  pass
 

PyMemoryEditor/app/cheat_poll_worker.py

@@ -106,6 +106,11 @@ def request_write(
  with QMutexLocker(self._mutex):
  self._pending_writes.append((address, pytype, length, value))
 
+ def _stopping(self) -> bool:
+ """Whether ``stop`` was asked for. Cheap enough to check per entry."""
+ with QMutexLocker(self._mutex):
+ return self._stop
+
  def stop(self) -> None:
  with QMutexLocker(self._mutex):
  self._stop = True
@@ -126,6 +131,8 @@ def _drain_pending_writes(self) -> List[Tuple[int, type, int, str]]:
 
  failures: List[Tuple[int, type, int, str]] = []
  for address, pytype, length, value in pending:
+ if self._stopping():
+ break # the handle is about to go — see _poll_once
  try:
  self._process.write_process_memory(address, pytype, length, value)
  except Exception as exc: # noqa: BLE001
@@ -206,6 +213,11 @@ def _poll_once(
  values_by_address = None
 
  for address in addresses:
+ # Per entry, not per tick: shutdown() closes the handle right
+ # after stop(), and a write on a recycled one hits another
+ # process.
+ if self._stopping():
+ return results
  frozen_value, is_frozen = freeze_by_addr[(pytype, length, address)]
  if values_by_address is not None:
  current = values_by_address.get(address)

PyMemoryEditor/app/_auto_refresh_dialog.py

@@ -10,13 +10,24 @@
 that self-throttles the poll, the detach-on-shutdown safety) where a fix to one
 copy wouldn't reach the others. This owns the lifecycle once; subclasses provide
 only what differs: how to fetch the data, and how to render it.
+
+It also owns *when* a failure is worth interrupting the user — see
+:meth:`AutoRefreshTableDialog._handle_failed`.
 """
 from typing import Callable, Optional
 
-from PySide6.QtCore import QThread, QTimer, Signal
+from PySide6.QtCore import QElapsedTimer, QThread, QTimer, Signal
 from PySide6.QtWidgets import QDialog
 
-from ._widgets import shutdown_worker_thread
+from ._widgets import TearsDownOnClose, shutdown_worker_thread
+
+
+# How long a target may keep failing before the auto-refresh gives up. Not
+# every failure is terminal (``CreateToolhelp32Snapshot`` is documented to fail
+# transiently while a target loads images), so a blip must not freeze a window
+# that would recover next tick. In wall-clock, not ticks: the intervals differ
+# by more than 10x across the windows that share this budget.
+_FAILURE_GRACE_MS = 3000
 
 
 class _DataWorker(QThread):
@@ -38,7 +49,7 @@ def run(self) -> None:
  self.ready.emit(data)
 
 
-class AutoRefreshTableDialog(QDialog):
+class AutoRefreshTableDialog(TearsDownOnClose, QDialog):
  """Owns the fetch-worker lifecycle + auto-refresh timer for a table dialog.
 
  Subclasses must:
@@ -57,6 +68,13 @@ def __init__(self, process, *, refresh_interval_ms: int, parent=None):
  self._has_data = False
  self._refresh_interval_ms = refresh_interval_ms
  self._auto_timer: Optional[QTimer] = None
+ # Failure state, all reset by a success or an explicit refresh(). See
+ # _handle_failed for how they decide what reaches the user.
+ self._last_error: Optional[str] = None # doubles as "already reported"
+ self._failing_since: Optional[QElapsedTimer] = None # streak clock
+ # Read by subclasses that rebuild their status line on user input, so
+ # the "stopped" note isn't replaced by a count that looks live.
+ self._polling_gave_up = False
 
  def _start_auto_refresh(self) -> None:
  """Begin polling. Call once, after the first ``refresh()``.
@@ -67,7 +85,7 @@ def _start_auto_refresh(self) -> None:
  """
  self._auto_timer = QTimer(self)
  self._auto_timer.setInterval(self._refresh_interval_ms)
- self._auto_timer.timeout.connect(self.refresh)
+ self._auto_timer.timeout.connect(self._auto_refresh_tick)
  self._auto_timer.start()
 
  # ------------------------------------------------------------------ #
@@ -83,17 +101,55 @@ def _on_data_ready(self, data) -> None:
  raise NotImplementedError
 
  def _on_data_failed(self, message: str) -> None:
- """Report a failed fetch. Runs on the UI thread."""
+ """Report a failed fetch. Runs on the UI thread.
+
+ Called only for a failure the user needs to see — the first fetch, or
+ the one that makes the poll give up — and never twice for the same
+ error (see :meth:`_handle_failed`), so a modal is safe here.
+ """
  raise NotImplementedError
 
  def _set_loading_hint(self) -> None:
  """Optionally show a one-time loading message before the first fetch."""
 
+ def _on_polling_stopped(self) -> None:
+ """Note that the auto-refresh gave up. Runs on the UI thread.
+
+ Fires once, when a target has been failing for ``_FAILURE_GRACE_MS``.
+ The table is frozen on its last good data from here on, so subclasses
+ should say so. Optional.
+ """
+
  # ------------------------------------------------------------------ #
  # Lifecycle (shared)
  # ------------------------------------------------------------------ #
 
  def refresh(self) -> None:
+ """Fetch now, on the user's behalf.
+
+ Clears the error latch and restarts a poll that repeated failures
+ stopped. The timer goes through :meth:`_auto_refresh_tick` instead,
+ which must *not* re-arm — and neither may a dismissed dialog, whose
+ teardown latch is one-way.
+ """
+ if self._is_dismissed():
+ return
+ self._last_error = None
+ self._failing_since = None
+ self._polling_gave_up = False
+ if self._auto_timer is not None and not self._auto_timer.isActive():
+ self._auto_timer.start()
+ self._start_fetch()
+
+ def _auto_refresh_tick(self) -> None:
+ """Timer-driven fetch — never re-arms after a failure."""
+ self._start_fetch()
+
+ def _start_fetch(self) -> None:
+ # A worker started after the teardown could never be joined again.
+ if self._is_dismissed():
+ return
+
  # Skip if a fetch is already in flight — the timer would otherwise stack
  # workers on a slow target. This self-throttles to the real fetch time.
  if self._worker is not None and self._worker.isRunning():
@@ -106,26 +162,83 @@ def refresh(self) -> None:
 
  worker = _DataWorker(self._fetch_data, self)
  worker.ready.connect(self._handle_ready)
- worker.failed.connect(self._on_data_failed)
- worker.finished.connect(self._on_worker_finished)
+ worker.failed.connect(self._handle_failed)
+ worker.finished.connect(lambda w=worker: self._on_worker_finished(w))
  self._worker = worker
  worker.start()
 
  def _handle_ready(self, data) -> None:
+ if self._is_dismissed():
+ return
  self._has_data = True
+ self._last_error = None
+ self._failing_since = None
  self._on_data_ready(data)
 
- def _on_worker_finished(self) -> None:
- worker = self._worker
- self._worker = None
- if worker is not None:
- worker.deleteLater()
+ def _handle_failed(self, message: str) -> None:
+ """Handle a failed fetch: report it only when the user needs to know.
+
+ Once the target is gone (or its handle was closed by File → Change
+ Process) *every* tick fails, and ``_on_data_failed`` pops a **modal**
+ dialog. A modal runs a nested event loop, so the timer fires again while
+ it is up and the failures stack — hundreds of focus-stealing dialogs the
+ user could only escape by killing the app from another TTY (issue #74).
+
+ Reporting is therefore tied to the two moments where a failure changes
+ what the user sees: the **first** fetch (empty window) and the one that
+ makes the poll **give up** (frozen table). Everything in between heals
+ quietly — and that silence is load-bearing: reporting every failure
+ re-opens the spam, since a target failing on alternating ticks stacks a
+ modal per failure until the stack runs out.
+
+ A dismissed dialog reports nothing. The teardown disconnects the worker,
+ but a delivery already queued then must not raise a modal over a window
+ that is gone — during ``MainWindow.closeEvent`` that would be a nested
+ event loop in the middle of teardown.
+ """
+ if self._is_dismissed():
+ return
+
+ if self._failing_since is None:
+ self._failing_since = QElapsedTimer()
+ self._failing_since.start()
+ gave_up = False
+ else:
+ gave_up = (
+ self._failing_since.elapsed() >= _FAILURE_GRACE_MS
+ and self._auto_timer is not None
+ and self._auto_timer.isActive()
+ )
+
+ if gave_up and self._auto_timer is not None:
+ self._auto_timer.stop()
+ self._polling_gave_up = True
+
+ never_reported_yet = not self._has_data and self._last_error is None
+ if (gave_up or never_reported_yet) and message != self._last_error:
+ self._last_error = message
+ self._on_data_failed(message)
+
+ # After the report, so the "stopped" note is what stays on screen.
+ if gave_up:
+ self._on_polling_stopped()
+
+ def _on_worker_finished(self, worker) -> None:
+ """Retire the worker that just finished — and only that one.
+
+ ``finished`` is queued, so it can arrive after the next tick already
+ started a replacement. Clearing ``self._worker`` blindly would drop the
+ reference to that *running* worker and ``deleteLater()`` it — destroying
+ a live QThread aborts the process.
+ """
+ if worker is self._worker:
+ self._worker = None
+ worker.deleteLater()
 
- def closeEvent(self, event): # noqa: N802 — Qt naming
+ def _teardown(self) -> None:
  if self._auto_timer is not None:
  self._auto_timer.stop()
  # Unhook + join the worker; if it can't stop in time it's detached
  # rather than destroyed under us.
  shutdown_worker_thread(self._worker, wait_ms=1000)
  self._worker = None
- super().closeEvent(event)

PyMemoryEditor/app/_widgets.py

@@ -8,7 +8,7 @@
 
 from typing import Any, Callable, Iterable, List, Optional, Tuple
 
-from PySide6.QtCore import Qt, QThread
+from PySide6.QtCore import QObject, Qt, QThread
 from PySide6.QtGui import QStandardItem
 
 
@@ -44,27 +44,85 @@ def shutdown_worker_thread(worker: Optional[QThread], wait_ms: int = 2000) -> No
  if callable(cancel):
  cancel()
  try:
- worker.disconnect() # drop every outgoing connection at once
+ # The four-argument static form on purpose: bare `worker.disconnect()`
+ # raises TypeError in PySide6 (so this except swallowed it and nothing
+ # was disconnected), and `worker.disconnect(worker)` only drops
+ # connections whose *receiver* is the worker — ours belong to the dialog.
+ QObject.disconnect(worker, None, None, None)
  except (RuntimeError, TypeError):
  pass
 
  if worker.isRunning():
  worker.wait(wait_ms)
 
  if worker.isRunning():
- worker.setParent(None)
- _DETACHED_WORKERS.append(worker)
- worker.finished.connect(lambda: _reap_detached_worker(worker))
+ detach_worker(worker)
  else:
  worker.deleteLater()
 
 
+def detach_worker(worker: QThread) -> None:
+ """Park a worker that wouldn't stop, so its owner can be destroyed.
+
+ Reparents it away from the dying widget and holds it in the module-level
+ registry until it finishes on its own. Callers that stop workers their own
+ way park them here too, so threads that outlived their owner are all in one
+ place.
+ """
+ worker.setParent(None)
+ _DETACHED_WORKERS.append(worker)
+ worker.finished.connect(lambda: _reap_detached_worker(worker))
+ # A worker that finished before this connect already emitted, so the reaper
+ # would never run and it would sit here for good.
+ if worker.isFinished():
+ _reap_detached_worker(worker)
+
+
 def _reap_detached_worker(worker: QThread) -> None:
  if worker in _DETACHED_WORKERS:
  _DETACHED_WORKERS.remove(worker)
  worker.deleteLater()
 
 
+class TearsDownOnClose:
+ """Mixin that runs a dialog's teardown on *every* way out, not just close.
+
+ ``QDialog`` delivers a ``QCloseEvent`` only for a real close. The app's own
+ "Close" buttons call ``accept()`` and Esc reaches ``reject()``; both land in
+ ``done()``, which hides the dialog and emits ``finished`` *without* any
+ close event — so a teardown living in ``closeEvent`` never ran, and the
+ dialog kept polling, hidden and unreachable.
+
+ Subclasses implement :meth:`_teardown`; the mixin runs it exactly once,
+ whichever way the dialog is dismissed, and must precede ``QDialog`` in the
+ bases so its overrides win. Running once makes instances single-use, which
+ is what every caller here assumes.
+ """
+
+ def _teardown(self) -> None:
+ """Release timers and background threads. Runs exactly once."""
+ raise NotImplementedError
+
+ def _is_dismissed(self) -> bool:
+ """Whether the teardown has run. Guards live on this, not on a repeated
+ attribute lookup a typo could silently disable."""
+ return getattr(self, "_teardown_done", False)
+
+ def _run_teardown_once(self) -> None:
+ if self._is_dismissed():
+ return
+ self._teardown_done = True
+ self._teardown()
+
+ def done(self, result: int) -> None: # noqa: N802 — Qt naming
+ self._run_teardown_once()
+ super().done(result)
+
+ def closeEvent(self, event) -> None: # noqa: N802 — Qt naming
+ self._run_teardown_once()
+ super().closeEvent(event)
+
+
 class NumericItem(QStandardItem):
  """A QStandardItem that compares by its Qt.UserRole int payload.
 

PyMemoryEditor/app/application.py

@@ -539,7 +539,9 @@ def main(argv=None):
  app.exec()
  finally:
  try:
- process.close()
+ # `process` is only the handle the picker opened; File → Change
+ # Process… released that one and attached the window to another.
+ window.process.close()
  except Exception:
  pass
 

PyMemoryEditor/app/cheat_poll_worker.py

@@ -106,6 +106,11 @@ def request_write(
  with QMutexLocker(self._mutex):
  self._pending_writes.append((address, pytype, length, value))
 
+ def _stopping(self) -> bool:
+ """Whether ``stop`` was asked for. Cheap enough to check per entry."""
+ with QMutexLocker(self._mutex):
+ return self._stop
+
  def stop(self) -> None:
  with QMutexLocker(self._mutex):
  self._stop = True
@@ -126,6 +131,8 @@ def _drain_pending_writes(self) -> List[Tuple[int, type, int, str]]:
 
  failures: List[Tuple[int, type, int, str]] = []
  for address, pytype, length, value in pending:
+ if self._stopping():
+ break # the handle is about to go — see _poll_once
  try:
  self._process.write_process_memory(address, pytype, length, value)
  except Exception as exc: # noqa: BLE001
@@ -206,6 +213,11 @@ def _poll_once(
  values_by_address = None
 
  for address in addresses:
+ # Per entry, not per tick: shutdown() closes the handle right
+ # after stop(), and a write on a recycled one hits another
+ # process.
+ if self._stopping():
+ return results
  frozen_value, is_frozen = freeze_by_addr[(pytype, length, address)]
  if values_by_address is not None:
  current = values_by_address.get(address)

PyMemoryEditor/app/_auto_refresh_dialog.py

@@ -10,13 +10,24 @@
 that self-throttles the poll, the detach-on-shutdown safety) where a fix to one
 copy wouldn't reach the others. This owns the lifecycle once; subclasses provide
 only what differs: how to fetch the data, and how to render it.
+
+It also owns *when* a failure is worth interrupting the user — see
+:meth:`AutoRefreshTableDialog._handle_failed`.
 """
 from typing import Callable, Optional
 
-from PySide6.QtCore import QThread, QTimer, Signal
+from PySide6.QtCore import QElapsedTimer, QThread, QTimer, Signal
 from PySide6.QtWidgets import QDialog
 
-from ._widgets import shutdown_worker_thread
+from ._widgets import TearsDownOnClose, shutdown_worker_thread
+
+
+# How long a target may keep failing before the auto-refresh gives up. Not
+# every failure is terminal (``CreateToolhelp32Snapshot`` is documented to fail
+# transiently while a target loads images), so a blip must not freeze a window
+# that would recover next tick. In wall-clock, not ticks: the intervals differ
+# by more than 10x across the windows that share this budget.
+_FAILURE_GRACE_MS = 3000
 
 
 class _DataWorker(QThread):
@@ -38,7 +49,7 @@ def run(self) -> None:
  self.ready.emit(data)
 
 
-class AutoRefreshTableDialog(QDialog):
+class AutoRefreshTableDialog(TearsDownOnClose, QDialog):
  """Owns the fetch-worker lifecycle + auto-refresh timer for a table dialog.
 
  Subclasses must:
@@ -57,6 +68,13 @@ def __init__(self, process, *, refresh_interval_ms: int, parent=None):
  self._has_data = False
  self._refresh_interval_ms = refresh_interval_ms
  self._auto_timer: Optional[QTimer] = None
+ # Failure state, all reset by a success or an explicit refresh(). See
+ # _handle_failed for how they decide what reaches the user.
+ self._last_error: Optional[str] = None # doubles as "already reported"
+ self._failing_since: Optional[QElapsedTimer] = None # streak clock
+ # Read by subclasses that rebuild their status line on user input, so
+ # the "stopped" note isn't replaced by a count that looks live.
+ self._polling_gave_up = False
 
  def _start_auto_refresh(self) -> None:
  """Begin polling. Call once, after the first ``refresh()``.
@@ -67,7 +85,7 @@ def _start_auto_refresh(self) -> None:
  """
  self._auto_timer = QTimer(self)
  self._auto_timer.setInterval(self._refresh_interval_ms)
- self._auto_timer.timeout.connect(self.refresh)
+ self._auto_timer.timeout.connect(self._auto_refresh_tick)
  self._auto_timer.start()
 
  # ------------------------------------------------------------------ #
@@ -83,17 +101,55 @@ def _on_data_ready(self, data) -> None:
  raise NotImplementedError
 
  def _on_data_failed(self, message: str) -> None:
- """Report a failed fetch. Runs on the UI thread."""
+ """Report a failed fetch. Runs on the UI thread.
+
+ Called only for a failure the user needs to see — the first fetch, or
+ the one that makes the poll give up — and never twice for the same
+ error (see :meth:`_handle_failed`), so a modal is safe here.
+ """
  raise NotImplementedError
 
  def _set_loading_hint(self) -> None:
  """Optionally show a one-time loading message before the first fetch."""
 
+ def _on_polling_stopped(self) -> None:
+ """Note that the auto-refresh gave up. Runs on the UI thread.
+
+ Fires once, when a target has been failing for ``_FAILURE_GRACE_MS``.
+ The table is frozen on its last good data from here on, so subclasses
+ should say so. Optional.
+ """
+
  # ------------------------------------------------------------------ #
  # Lifecycle (shared)
  # ------------------------------------------------------------------ #
 
  def refresh(self) -> None:
+ """Fetch now, on the user's behalf.
+
+ Clears the error latch and restarts a poll that repeated failures
+ stopped. The timer goes through :meth:`_auto_refresh_tick` instead,
+ which must *not* re-arm — and neither may a dismissed dialog, whose
+ teardown latch is one-way.
+ """
+ if self._is_dismissed():
+ return
+ self._last_error = None
+ self._failing_since = None
+ self._polling_gave_up = False
+ if self._auto_timer is not None and not self._auto_timer.isActive():
+ self._auto_timer.start()
+ self._start_fetch()
+
+ def _auto_refresh_tick(self) -> None:
+ """Timer-driven fetch — never re-arms after a failure."""
+ self._start_fetch()
+
+ def _start_fetch(self) -> None:
+ # A worker started after the teardown could never be joined again.
+ if self._is_dismissed():
+ return
+
  # Skip if a fetch is already in flight — the timer would otherwise stack
  # workers on a slow target. This self-throttles to the real fetch time.
  if self._worker is not None and self._worker.isRunning():
@@ -106,26 +162,83 @@ def refresh(self) -> None:
 
  worker = _DataWorker(self._fetch_data, self)
  worker.ready.connect(self._handle_ready)
- worker.failed.connect(self._on_data_failed)
- worker.finished.connect(self._on_worker_finished)
+ worker.failed.connect(self._handle_failed)
+ worker.finished.connect(lambda w=worker: self._on_worker_finished(w))
  self._worker = worker
  worker.start()
 
  def _handle_ready(self, data) -> None:
+ if self._is_dismissed():
+ return
  self._has_data = True
+ self._last_error = None
+ self._failing_since = None
  self._on_data_ready(data)
 
- def _on_worker_finished(self) -> None:
- worker = self._worker
- self._worker = None
- if worker is not None:
- worker.deleteLater()
+ def _handle_failed(self, message: str) -> None:
+ """Handle a failed fetch: report it only when the user needs to know.
+
+ Once the target is gone (or its handle was closed by File → Change
+ Process) *every* tick fails, and ``_on_data_failed`` pops a **modal**
+ dialog. A modal runs a nested event loop, so the timer fires again while
+ it is up and the failures stack — hundreds of focus-stealing dialogs the
+ user could only escape by killing the app from another TTY (issue #74).
+
+ Reporting is therefore tied to the two moments where a failure changes
+ what the user sees: the **first** fetch (empty window) and the one that
+ makes the poll **give up** (frozen table). Everything in between heals
+ quietly — and that silence is load-bearing: reporting every failure
+ re-opens the spam, since a target failing on alternating ticks stacks a
+ modal per failure until the stack runs out.
+
+ A dismissed dialog reports nothing. The teardown disconnects the worker,
+ but a delivery already queued then must not raise a modal over a window
+ that is gone — during ``MainWindow.closeEvent`` that would be a nested
+ event loop in the middle of teardown.
+ """
+ if self._is_dismissed():
+ return
+
+ if self._failing_since is None:
+ self._failing_since = QElapsedTimer()
+ self._failing_since.start()
+ gave_up = False
+ else:
+ gave_up = (
+ self._failing_since.elapsed() >= _FAILURE_GRACE_MS
+ and self._auto_timer is not None
+ and self._auto_timer.isActive()
+ )
+
+ if gave_up and self._auto_timer is not None:
+ self._auto_timer.stop()
+ self._polling_gave_up = True
+
+ never_reported_yet = not self._has_data and self._last_error is None
+ if (gave_up or never_reported_yet) and message != self._last_error:
+ self._last_error = message
+ self._on_data_failed(message)
+
+ # After the report, so the "stopped" note is what stays on screen.
+ if gave_up:
+ self._on_polling_stopped()
+
+ def _on_worker_finished(self, worker) -> None:
+ """Retire the worker that just finished — and only that one.
+
+ ``finished`` is queued, so it can arrive after the next tick already
+ started a replacement. Clearing ``self._worker`` blindly would drop the
+ reference to that *running* worker and ``deleteLater()`` it — destroying
+ a live QThread aborts the process.
+ """
+ if worker is self._worker:
+ self._worker = None
+ worker.deleteLater()
 
- def closeEvent(self, event): # noqa: N802 — Qt naming
+ def _teardown(self) -> None:
  if self._auto_timer is not None:
  self._auto_timer.stop()
  # Unhook + join the worker; if it can't stop in time it's detached
  # rather than destroyed under us.
  shutdown_worker_thread(self._worker, wait_ms=1000)
  self._worker = None
- super().closeEvent(event)

PyMemoryEditor/app/_widgets.py

@@ -8,7 +8,7 @@
 
 from typing import Any, Callable, Iterable, List, Optional, Tuple
 
-from PySide6.QtCore import Qt, QThread
+from PySide6.QtCore import QObject, Qt, QThread
 from PySide6.QtGui import QStandardItem
 
 
@@ -44,27 +44,85 @@ def shutdown_worker_thread(worker: Optional[QThread], wait_ms: int = 2000) -> No
  if callable(cancel):
  cancel()
  try:
- worker.disconnect() # drop every outgoing connection at once
+ # The four-argument static form on purpose: bare `worker.disconnect()`
+ # raises TypeError in PySide6 (so this except swallowed it and nothing
+ # was disconnected), and `worker.disconnect(worker)` only drops
+ # connections whose *receiver* is the worker — ours belong to the dialog.
+ QObject.disconnect(worker, None, None, None)
  except (RuntimeError, TypeError):
  pass
 
  if worker.isRunning():
  worker.wait(wait_ms)
 
  if worker.isRunning():
- worker.setParent(None)
- _DETACHED_WORKERS.append(worker)
- worker.finished.connect(lambda: _reap_detached_worker(worker))
+ detach_worker(worker)
  else:
  worker.deleteLater()
 
 
+def detach_worker(worker: QThread) -> None:
+ """Park a worker that wouldn't stop, so its owner can be destroyed.
+
+ Reparents it away from the dying widget and holds it in the module-level
+ registry until it finishes on its own. Callers that stop workers their own
+ way park them here too, so threads that outlived their owner are all in one
+ place.
+ """
+ worker.setParent(None)
+ _DETACHED_WORKERS.append(worker)
+ worker.finished.connect(lambda: _reap_detached_worker(worker))
+ # A worker that finished before this connect already emitted, so the reaper
+ # would never run and it would sit here for good.
+ if worker.isFinished():
+ _reap_detached_worker(worker)
+
+
 def _reap_detached_worker(worker: QThread) -> None:
  if worker in _DETACHED_WORKERS:
  _DETACHED_WORKERS.remove(worker)
  worker.deleteLater()
 
 
+class TearsDownOnClose:
+ """Mixin that runs a dialog's teardown on *every* way out, not just close.
+
+ ``QDialog`` delivers a ``QCloseEvent`` only for a real close. The app's own
+ "Close" buttons call ``accept()`` and Esc reaches ``reject()``; both land in
+ ``done()``, which hides the dialog and emits ``finished`` *without* any
+ close event — so a teardown living in ``closeEvent`` never ran, and the
+ dialog kept polling, hidden and unreachable.
+
+ Subclasses implement :meth:`_teardown`; the mixin runs it exactly once,
+ whichever way the dialog is dismissed, and must precede ``QDialog`` in the
+ bases so its overrides win. Running once makes instances single-use, which
+ is what every caller here assumes.
+ """
+
+ def _teardown(self) -> None:
+ """Release timers and background threads. Runs exactly once."""
+ raise NotImplementedError
+
+ def _is_dismissed(self) -> bool:
+ """Whether the teardown has run. Guards live on this, not on a repeated
+ attribute lookup a typo could silently disable."""
+ return getattr(self, "_teardown_done", False)
+
+ def _run_teardown_once(self) -> None:
+ if self._is_dismissed():
+ return
+ self._teardown_done = True
+ self._teardown()
+
+ def done(self, result: int) -> None: # noqa: N802 — Qt naming
+ self._run_teardown_once()
+ super().done(result)
+
+ def closeEvent(self, event) -> None: # noqa: N802 — Qt naming
+ self._run_teardown_once()
+ super().closeEvent(event)
+
+
 class NumericItem(QStandardItem):
  """A QStandardItem that compares by its Qt.UserRole int payload.
 

PyMemoryEditor/app/application.py

@@ -539,7 +539,9 @@ def main(argv=None):
  app.exec()
  finally:
  try:
- process.close()
+ # `process` is only the handle the picker opened; File → Change
+ # Process… released that one and attached the window to another.
+ window.process.close()
  except Exception:
  pass
 

PyMemoryEditor/app/cheat_poll_worker.py

@@ -106,6 +106,11 @@ def request_write(
  with QMutexLocker(self._mutex):
  self._pending_writes.append((address, pytype, length, value))
 
+ def _stopping(self) -> bool:
+ """Whether ``stop`` was asked for. Cheap enough to check per entry."""
+ with QMutexLocker(self._mutex):
+ return self._stop
+
  def stop(self) -> None:
  with QMutexLocker(self._mutex):
  self._stop = True
@@ -126,6 +131,8 @@ def _drain_pending_writes(self) -> List[Tuple[int, type, int, str]]:
 
  failures: List[Tuple[int, type, int, str]] = []
  for address, pytype, length, value in pending:
+ if self._stopping():
+ break # the handle is about to go — see _poll_once
  try:
  self._process.write_process_memory(address, pytype, length, value)
  except Exception as exc: # noqa: BLE001
@@ -206,6 +213,11 @@ def _poll_once(
  values_by_address = None
 
  for address in addresses:
+ # Per entry, not per tick: shutdown() closes the handle right
+ # after stop(), and a write on a recycled one hits another
+ # process.
+ if self._stopping():
+ return results
  frozen_value, is_frozen = freeze_by_addr[(pytype, length, address)]
  if values_by_address is not None:
  current = values_by_address.get(address)

PyMemoryEditor/app/_auto_refresh_dialog.py

@@ -10,13 +10,24 @@
 that self-throttles the poll, the detach-on-shutdown safety) where a fix to one
 copy wouldn't reach the others. This owns the lifecycle once; subclasses provide
 only what differs: how to fetch the data, and how to render it.
+
+It also owns *when* a failure is worth interrupting the user — see
+:meth:`AutoRefreshTableDialog._handle_failed`.
 """
 from typing import Callable, Optional
 
-from PySide6.QtCore import QThread, QTimer, Signal
+from PySide6.QtCore import QElapsedTimer, QThread, QTimer, Signal
 from PySide6.QtWidgets import QDialog
 
-from ._widgets import shutdown_worker_thread
+from ._widgets import TearsDownOnClose, shutdown_worker_thread
+
+
+# How long a target may keep failing before the auto-refresh gives up. Not
+# every failure is terminal (``CreateToolhelp32Snapshot`` is documented to fail
+# transiently while a target loads images), so a blip must not freeze a window
+# that would recover next tick. In wall-clock, not ticks: the intervals differ
+# by more than 10x across the windows that share this budget.
+_FAILURE_GRACE_MS = 3000
 
 
 class _DataWorker(QThread):
@@ -38,7 +49,7 @@ def run(self) -> None:
  self.ready.emit(data)
 
 
-class AutoRefreshTableDialog(QDialog):
+class AutoRefreshTableDialog(TearsDownOnClose, QDialog):
  """Owns the fetch-worker lifecycle + auto-refresh timer for a table dialog.
 
  Subclasses must:
@@ -57,6 +68,13 @@ def __init__(self, process, *, refresh_interval_ms: int, parent=None):
  self._has_data = False
  self._refresh_interval_ms = refresh_interval_ms
  self._auto_timer: Optional[QTimer] = None
+ # Failure state, all reset by a success or an explicit refresh(). See
+ # _handle_failed for how they decide what reaches the user.
+ self._last_error: Optional[str] = None # doubles as "already reported"
+ self._failing_since: Optional[QElapsedTimer] = None # streak clock
+ # Read by subclasses that rebuild their status line on user input, so
+ # the "stopped" note isn't replaced by a count that looks live.
+ self._polling_gave_up = False
 
  def _start_auto_refresh(self) -> None:
  """Begin polling. Call once, after the first ``refresh()``.
@@ -67,7 +85,7 @@ def _start_auto_refresh(self) -> None:
  """
  self._auto_timer = QTimer(self)
  self._auto_timer.setInterval(self._refresh_interval_ms)
- self._auto_timer.timeout.connect(self.refresh)
+ self._auto_timer.timeout.connect(self._auto_refresh_tick)
  self._auto_timer.start()
 
  # ------------------------------------------------------------------ #
@@ -83,17 +101,55 @@ def _on_data_ready(self, data) -> None:
  raise NotImplementedError
 
  def _on_data_failed(self, message: str) -> None:
- """Report a failed fetch. Runs on the UI thread."""
+ """Report a failed fetch. Runs on the UI thread.
+
+ Called only for a failure the user needs to see — the first fetch, or
+ the one that makes the poll give up — and never twice for the same
+ error (see :meth:`_handle_failed`), so a modal is safe here.
+ """
  raise NotImplementedError
 
  def _set_loading_hint(self) -> None:
  """Optionally show a one-time loading message before the first fetch."""
 
+ def _on_polling_stopped(self) -> None:
+ """Note that the auto-refresh gave up. Runs on the UI thread.
+
+ Fires once, when a target has been failing for ``_FAILURE_GRACE_MS``.
+ The table is frozen on its last good data from here on, so subclasses
+ should say so. Optional.
+ """
+
  # ------------------------------------------------------------------ #
  # Lifecycle (shared)
  # ------------------------------------------------------------------ #
 
  def refresh(self) -> None:
+ """Fetch now, on the user's behalf.
+
+ Clears the error latch and restarts a poll that repeated failures
+ stopped. The timer goes through :meth:`_auto_refresh_tick` instead,
+ which must *not* re-arm — and neither may a dismissed dialog, whose
+ teardown latch is one-way.
+ """
+ if self._is_dismissed():
+ return
+ self._last_error = None
+ self._failing_since = None
+ self._polling_gave_up = False
+ if self._auto_timer is not None and not self._auto_timer.isActive():
+ self._auto_timer.start()
+ self._start_fetch()
+
+ def _auto_refresh_tick(self) -> None:
+ """Timer-driven fetch — never re-arms after a failure."""
+ self._start_fetch()
+
+ def _start_fetch(self) -> None:
+ # A worker started after the teardown could never be joined again.
+ if self._is_dismissed():
+ return
+
  # Skip if a fetch is already in flight — the timer would otherwise stack
  # workers on a slow target. This self-throttles to the real fetch time.
  if self._worker is not None and self._worker.isRunning():
@@ -106,26 +162,83 @@ def refresh(self) -> None:
 
  worker = _DataWorker(self._fetch_data, self)
  worker.ready.connect(self._handle_ready)
- worker.failed.connect(self._on_data_failed)
- worker.finished.connect(self._on_worker_finished)
+ worker.failed.connect(self._handle_failed)
+ worker.finished.connect(lambda w=worker: self._on_worker_finished(w))
  self._worker = worker
  worker.start()
 
  def _handle_ready(self, data) -> None:
+ if self._is_dismissed():
+ return
  self._has_data = True
+ self._last_error = None
+ self._failing_since = None
  self._on_data_ready(data)
 
- def _on_worker_finished(self) -> None:
- worker = self._worker
- self._worker = None
- if worker is not None:
- worker.deleteLater()
+ def _handle_failed(self, message: str) -> None:
+ """Handle a failed fetch: report it only when the user needs to know.
+
+ Once the target is gone (or its handle was closed by File → Change
+ Process) *every* tick fails, and ``_on_data_failed`` pops a **modal**
+ dialog. A modal runs a nested event loop, so the timer fires again while
+ it is up and the failures stack — hundreds of focus-stealing dialogs the
+ user could only escape by killing the app from another TTY (issue #74).
+
+ Reporting is therefore tied to the two moments where a failure changes
+ what the user sees: the **first** fetch (empty window) and the one that
+ makes the poll **give up** (frozen table). Everything in between heals
+ quietly — and that silence is load-bearing: reporting every failure
+ re-opens the spam, since a target failing on alternating ticks stacks a
+ modal per failure until the stack runs out.
+
+ A dismissed dialog reports nothing. The teardown disconnects the worker,
+ but a delivery already queued then must not raise a modal over a window
+ that is gone — during ``MainWindow.closeEvent`` that would be a nested
+ event loop in the middle of teardown.
+ """
+ if self._is_dismissed():
+ return
+
+ if self._failing_since is None:
+ self._failing_since = QElapsedTimer()
+ self._failing_since.start()
+ gave_up = False
+ else:
+ gave_up = (
+ self._failing_since.elapsed() >= _FAILURE_GRACE_MS
+ and self._auto_timer is not None
+ and self._auto_timer.isActive()
+ )
+
+ if gave_up and self._auto_timer is not None:
+ self._auto_timer.stop()
+ self._polling_gave_up = True
+
+ never_reported_yet = not self._has_data and self._last_error is None
+ if (gave_up or never_reported_yet) and message != self._last_error:
+ self._last_error = message
+ self._on_data_failed(message)
+
+ # After the report, so the "stopped" note is what stays on screen.
+ if gave_up:
+ self._on_polling_stopped()
+
+ def _on_worker_finished(self, worker) -> None:
+ """Retire the worker that just finished — and only that one.
+
+ ``finished`` is queued, so it can arrive after the next tick already
+ started a replacement. Clearing ``self._worker`` blindly would drop the
+ reference to that *running* worker and ``deleteLater()`` it — destroying
+ a live QThread aborts the process.
+ """
+ if worker is self._worker:
+ self._worker = None
+ worker.deleteLater()
 
- def closeEvent(self, event): # noqa: N802 — Qt naming
+ def _teardown(self) -> None:
  if self._auto_timer is not None:
  self._auto_timer.stop()
  # Unhook + join the worker; if it can't stop in time it's detached
  # rather than destroyed under us.
  shutdown_worker_thread(self._worker, wait_ms=1000)
  self._worker = None
- super().closeEvent(event)

PyMemoryEditor/app/_widgets.py

@@ -8,7 +8,7 @@
 
 from typing import Any, Callable, Iterable, List, Optional, Tuple
 
-from PySide6.QtCore import Qt, QThread
+from PySide6.QtCore import QObject, Qt, QThread
 from PySide6.QtGui import QStandardItem
 
 
@@ -44,27 +44,85 @@ def shutdown_worker_thread(worker: Optional[QThread], wait_ms: int = 2000) -> No
  if callable(cancel):
  cancel()
  try:
- worker.disconnect() # drop every outgoing connection at once
+ # The four-argument static form on purpose: bare `worker.disconnect()`
+ # raises TypeError in PySide6 (so this except swallowed it and nothing
+ # was disconnected), and `worker.disconnect(worker)` only drops
+ # connections whose *receiver* is the worker — ours belong to the dialog.
+ QObject.disconnect(worker, None, None, None)
  except (RuntimeError, TypeError):
  pass
 
  if worker.isRunning():
  worker.wait(wait_ms)
 
  if worker.isRunning():
- worker.setParent(None)
- _DETACHED_WORKERS.append(worker)
- worker.finished.connect(lambda: _reap_detached_worker(worker))
+ detach_worker(worker)
  else:
  worker.deleteLater()
 
 
+def detach_worker(worker: QThread) -> None:
+ """Park a worker that wouldn't stop, so its owner can be destroyed.
+
+ Reparents it away from the dying widget and holds it in the module-level
+ registry until it finishes on its own. Callers that stop workers their own
+ way park them here too, so threads that outlived their owner are all in one
+ place.
+ """
+ worker.setParent(None)
+ _DETACHED_WORKERS.append(worker)
+ worker.finished.connect(lambda: _reap_detached_worker(worker))
+ # A worker that finished before this connect already emitted, so the reaper
+ # would never run and it would sit here for good.
+ if worker.isFinished():
+ _reap_detached_worker(worker)
+
+
 def _reap_detached_worker(worker: QThread) -> None:
  if worker in _DETACHED_WORKERS:
  _DETACHED_WORKERS.remove(worker)
  worker.deleteLater()
 
 
+class TearsDownOnClose:
+ """Mixin that runs a dialog's teardown on *every* way out, not just close.
+
+ ``QDialog`` delivers a ``QCloseEvent`` only for a real close. The app's own
+ "Close" buttons call ``accept()`` and Esc reaches ``reject()``; both land in
+ ``done()``, which hides the dialog and emits ``finished`` *without* any
+ close event — so a teardown living in ``closeEvent`` never ran, and the
+ dialog kept polling, hidden and unreachable.
+
+ Subclasses implement :meth:`_teardown`; the mixin runs it exactly once,
+ whichever way the dialog is dismissed, and must precede ``QDialog`` in the
+ bases so its overrides win. Running once makes instances single-use, which
+ is what every caller here assumes.
+ """
+
+ def _teardown(self) -> None:
+ """Release timers and background threads. Runs exactly once."""
+ raise NotImplementedError
+
+ def _is_dismissed(self) -> bool:
+ """Whether the teardown has run. Guards live on this, not on a repeated
+ attribute lookup a typo could silently disable."""
+ return getattr(self, "_teardown_done", False)
+
+ def _run_teardown_once(self) -> None:
+ if self._is_dismissed():
+ return
+ self._teardown_done = True
+ self._teardown()
+
+ def done(self, result: int) -> None: # noqa: N802 — Qt naming
+ self._run_teardown_once()
+ super().done(result)
+
+ def closeEvent(self, event) -> None: # noqa: N802 — Qt naming
+ self._run_teardown_once()
+ super().closeEvent(event)
+
+
 class NumericItem(QStandardItem):
  """A QStandardItem that compares by its Qt.UserRole int payload.
 

PyMemoryEditor/app/application.py

@@ -539,7 +539,9 @@ def main(argv=None):
  app.exec()
  finally:
  try:
- process.close()
+ # `process` is only the handle the picker opened; File → Change
+ # Process… released that one and attached the window to another.
+ window.process.close()
  except Exception:
  pass
 

PyMemoryEditor/app/cheat_poll_worker.py

@@ -106,6 +106,11 @@ def request_write(
  with QMutexLocker(self._mutex):
  self._pending_writes.append((address, pytype, length, value))
 
+ def _stopping(self) -> bool:
+ """Whether ``stop`` was asked for. Cheap enough to check per entry."""
+ with QMutexLocker(self._mutex):
+ return self._stop
+
  def stop(self) -> None:
  with QMutexLocker(self._mutex):
  self._stop = True
@@ -126,6 +131,8 @@ def _drain_pending_writes(self) -> List[Tuple[int, type, int, str]]:
 
  failures: List[Tuple[int, type, int, str]] = []
  for address, pytype, length, value in pending:
+ if self._stopping():
+ break # the handle is about to go — see _poll_once
  try:
  self._process.write_process_memory(address, pytype, length, value)
  except Exception as exc: # noqa: BLE001
@@ -206,6 +213,11 @@ def _poll_once(
  values_by_address = None
 
  for address in addresses:
+ # Per entry, not per tick: shutdown() closes the handle right
+ # after stop(), and a write on a recycled one hits another
+ # process.
+ if self._stopping():
+ return results
  frozen_value, is_frozen = freeze_by_addr[(pytype, length, address)]
  if values_by_address is not None:
  current = values_by_address.get(address)

PyMemoryEditor/app/_auto_refresh_dialog.py

@@ -10,13 +10,24 @@
 that self-throttles the poll, the detach-on-shutdown safety) where a fix to one
 copy wouldn't reach the others. This owns the lifecycle once; subclasses provide
 only what differs: how to fetch the data, and how to render it.
+
+It also owns *when* a failure is worth interrupting the user — see
+:meth:`AutoRefreshTableDialog._handle_failed`.
 """
 from typing import Callable, Optional
 
-from PySide6.QtCore import QThread, QTimer, Signal
+from PySide6.QtCore import QElapsedTimer, QThread, QTimer, Signal
 from PySide6.QtWidgets import QDialog
 
-from ._widgets import shutdown_worker_thread
+from ._widgets import TearsDownOnClose, shutdown_worker_thread
+
+
+# How long a target may keep failing before the auto-refresh gives up. Not
+# every failure is terminal (``CreateToolhelp32Snapshot`` is documented to fail
+# transiently while a target loads images), so a blip must not freeze a window
+# that would recover next tick. In wall-clock, not ticks: the intervals differ
+# by more than 10x across the windows that share this budget.
+_FAILURE_GRACE_MS = 3000
 
 
 class _DataWorker(QThread):
@@ -38,7 +49,7 @@ def run(self) -> None:
  self.ready.emit(data)
 
 
-class AutoRefreshTableDialog(QDialog):
+class AutoRefreshTableDialog(TearsDownOnClose, QDialog):
  """Owns the fetch-worker lifecycle + auto-refresh timer for a table dialog.
 
  Subclasses must:
@@ -57,6 +68,13 @@ def __init__(self, process, *, refresh_interval_ms: int, parent=None):
  self._has_data = False
  self._refresh_interval_ms = refresh_interval_ms
  self._auto_timer: Optional[QTimer] = None
+ # Failure state, all reset by a success or an explicit refresh(). See
+ # _handle_failed for how they decide what reaches the user.
+ self._last_error: Optional[str] = None # doubles as "already reported"
+ self._failing_since: Optional[QElapsedTimer] = None # streak clock
+ # Read by subclasses that rebuild their status line on user input, so
+ # the "stopped" note isn't replaced by a count that looks live.
+ self._polling_gave_up = False
 
  def _start_auto_refresh(self) -> None:
  """Begin polling. Call once, after the first ``refresh()``.
@@ -67,7 +85,7 @@ def _start_auto_refresh(self) -> None:
  """
  self._auto_timer = QTimer(self)
  self._auto_timer.setInterval(self._refresh_interval_ms)
- self._auto_timer.timeout.connect(self.refresh)
+ self._auto_timer.timeout.connect(self._auto_refresh_tick)
  self._auto_timer.start()
 
  # ------------------------------------------------------------------ #
@@ -83,17 +101,55 @@ def _on_data_ready(self, data) -> None:
  raise NotImplementedError
 
  def _on_data_failed(self, message: str) -> None:
- """Report a failed fetch. Runs on the UI thread."""
+ """Report a failed fetch. Runs on the UI thread.
+
+ Called only for a failure the user needs to see — the first fetch, or
+ the one that makes the poll give up — and never twice for the same
+ error (see :meth:`_handle_failed`), so a modal is safe here.
+ """
  raise NotImplementedError
 
  def _set_loading_hint(self) -> None:
  """Optionally show a one-time loading message before the first fetch."""
 
+ def _on_polling_stopped(self) -> None:
+ """Note that the auto-refresh gave up. Runs on the UI thread.
+
+ Fires once, when a target has been failing for ``_FAILURE_GRACE_MS``.
+ The table is frozen on its last good data from here on, so subclasses
+ should say so. Optional.
+ """
+
  # ------------------------------------------------------------------ #
  # Lifecycle (shared)
  # ------------------------------------------------------------------ #
 
  def refresh(self) -> None:
+ """Fetch now, on the user's behalf.
+
+ Clears the error latch and restarts a poll that repeated failures
+ stopped. The timer goes through :meth:`_auto_refresh_tick` instead,
+ which must *not* re-arm — and neither may a dismissed dialog, whose
+ teardown latch is one-way.
+ """
+ if self._is_dismissed():
+ return
+ self._last_error = None
+ self._failing_since = None
+ self._polling_gave_up = False
+ if self._auto_timer is not None and not self._auto_timer.isActive():
+ self._auto_timer.start()
+ self._start_fetch()
+
+ def _auto_refresh_tick(self) -> None:
+ """Timer-driven fetch — never re-arms after a failure."""
+ self._start_fetch()
+
+ def _start_fetch(self) -> None:
+ # A worker started after the teardown could never be joined again.
+ if self._is_dismissed():
+ return
+
  # Skip if a fetch is already in flight — the timer would otherwise stack
  # workers on a slow target. This self-throttles to the real fetch time.
  if self._worker is not None and self._worker.isRunning():
@@ -106,26 +162,83 @@ def refresh(self) -> None:
 
  worker = _DataWorker(self._fetch_data, self)
  worker.ready.connect(self._handle_ready)
- worker.failed.connect(self._on_data_failed)
- worker.finished.connect(self._on_worker_finished)
+ worker.failed.connect(self._handle_failed)
+ worker.finished.connect(lambda w=worker: self._on_worker_finished(w))
  self._worker = worker
  worker.start()
 
  def _handle_ready(self, data) -> None:
+ if self._is_dismissed():
+ return
  self._has_data = True
+ self._last_error = None
+ self._failing_since = None
  self._on_data_ready(data)
 
- def _on_worker_finished(self) -> None:
- worker = self._worker
- self._worker = None
- if worker is not None:
- worker.deleteLater()
+ def _handle_failed(self, message: str) -> None:
+ """Handle a failed fetch: report it only when the user needs to know.
+
+ Once the target is gone (or its handle was closed by File → Change
+ Process) *every* tick fails, and ``_on_data_failed`` pops a **modal**
+ dialog. A modal runs a nested event loop, so the timer fires again while
+ it is up and the failures stack — hundreds of focus-stealing dialogs the
+ user could only escape by killing the app from another TTY (issue #74).
+
+ Reporting is therefore tied to the two moments where a failure changes
+ what the user sees: the **first** fetch (empty window) and the one that
+ makes the poll **give up** (frozen table). Everything in between heals
+ quietly — and that silence is load-bearing: reporting every failure
+ re-opens the spam, since a target failing on alternating ticks stacks a
+ modal per failure until the stack runs out.
+
+ A dismissed dialog reports nothing. The teardown disconnects the worker,
+ but a delivery already queued then must not raise a modal over a window
+ that is gone — during ``MainWindow.closeEvent`` that would be a nested
+ event loop in the middle of teardown.
+ """
+ if self._is_dismissed():
+ return
+
+ if self._failing_since is None:
+ self._failing_since = QElapsedTimer()
+ self._failing_since.start()
+ gave_up = False
+ else:
+ gave_up = (
+ self._failing_since.elapsed() >= _FAILURE_GRACE_MS
+ and self._auto_timer is not None
+ and self._auto_timer.isActive()
+ )
+
+ if gave_up and self._auto_timer is not None:
+ self._auto_timer.stop()
+ self._polling_gave_up = True
+
+ never_reported_yet = not self._has_data and self._last_error is None
+ if (gave_up or never_reported_yet) and message != self._last_error:
+ self._last_error = message
+ self._on_data_failed(message)
+
+ # After the report, so the "stopped" note is what stays on screen.
+ if gave_up:
+ self._on_polling_stopped()
+
+ def _on_worker_finished(self, worker) -> None:
+ """Retire the worker that just finished — and only that one.
+
+ ``finished`` is queued, so it can arrive after the next tick already
+ started a replacement. Clearing ``self._worker`` blindly would drop the
+ reference to that *running* worker and ``deleteLater()`` it — destroying
+ a live QThread aborts the process.
+ """
+ if worker is self._worker:
+ self._worker = None
+ worker.deleteLater()
 
- def closeEvent(self, event): # noqa: N802 — Qt naming
+ def _teardown(self) -> None:
  if self._auto_timer is not None:
  self._auto_timer.stop()
  # Unhook + join the worker; if it can't stop in time it's detached
  # rather than destroyed under us.
  shutdown_worker_thread(self._worker, wait_ms=1000)
  self._worker = None
- super().closeEvent(event)

PyMemoryEditor/app/_widgets.py

@@ -8,7 +8,7 @@
 
 from typing import Any, Callable, Iterable, List, Optional, Tuple
 
-from PySide6.QtCore import Qt, QThread
+from PySide6.QtCore import QObject, Qt, QThread
 from PySide6.QtGui import QStandardItem
 
 
@@ -44,27 +44,85 @@ def shutdown_worker_thread(worker: Optional[QThread], wait_ms: int = 2000) -> No
  if callable(cancel):
  cancel()
  try:
- worker.disconnect() # drop every outgoing connection at once
+ # The four-argument static form on purpose: bare `worker.disconnect()`
+ # raises TypeError in PySide6 (so this except swallowed it and nothing
+ # was disconnected), and `worker.disconnect(worker)` only drops
+ # connections whose *receiver* is the worker — ours belong to the dialog.
+ QObject.disconnect(worker, None, None, None)
  except (RuntimeError, TypeError):
  pass
 
  if worker.isRunning():
  worker.wait(wait_ms)
 
  if worker.isRunning():
- worker.setParent(None)
- _DETACHED_WORKERS.append(worker)
- worker.finished.connect(lambda: _reap_detached_worker(worker))
+ detach_worker(worker)
  else:
  worker.deleteLater()
 
 
+def detach_worker(worker: QThread) -> None:
+ """Park a worker that wouldn't stop, so its owner can be destroyed.
+
+ Reparents it away from the dying widget and holds it in the module-level
+ registry until it finishes on its own. Callers that stop workers their own
+ way park them here too, so threads that outlived their owner are all in one
+ place.
+ """
+ worker.setParent(None)
+ _DETACHED_WORKERS.append(worker)
+ worker.finished.connect(lambda: _reap_detached_worker(worker))
+ # A worker that finished before this connect already emitted, so the reaper
+ # would never run and it would sit here for good.
+ if worker.isFinished():
+ _reap_detached_worker(worker)
+
+
 def _reap_detached_worker(worker: QThread) -> None:
  if worker in _DETACHED_WORKERS:
  _DETACHED_WORKERS.remove(worker)
  worker.deleteLater()
 
 
+class TearsDownOnClose:
+ """Mixin that runs a dialog's teardown on *every* way out, not just close.
+
+ ``QDialog`` delivers a ``QCloseEvent`` only for a real close. The app's own
+ "Close" buttons call ``accept()`` and Esc reaches ``reject()``; both land in
+ ``done()``, which hides the dialog and emits ``finished`` *without* any
+ close event — so a teardown living in ``closeEvent`` never ran, and the
+ dialog kept polling, hidden and unreachable.
+
+ Subclasses implement :meth:`_teardown`; the mixin runs it exactly once,
+ whichever way the dialog is dismissed, and must precede ``QDialog`` in the
+ bases so its overrides win. Running once makes instances single-use, which
+ is what every caller here assumes.
+ """
+
+ def _teardown(self) -> None:
+ """Release timers and background threads. Runs exactly once."""
+ raise NotImplementedError
+
+ def _is_dismissed(self) -> bool:
+ """Whether the teardown has run. Guards live on this, not on a repeated
+ attribute lookup a typo could silently disable."""
+ return getattr(self, "_teardown_done", False)
+
+ def _run_teardown_once(self) -> None:
+ if self._is_dismissed():
+ return
+ self._teardown_done = True
+ self._teardown()
+
+ def done(self, result: int) -> None: # noqa: N802 — Qt naming
+ self._run_teardown_once()
+ super().done(result)
+
+ def closeEvent(self, event) -> None: # noqa: N802 — Qt naming
+ self._run_teardown_once()
+ super().closeEvent(event)
+
+
 class NumericItem(QStandardItem):
  """A QStandardItem that compares by its Qt.UserRole int payload.
 

PyMemoryEditor/app/application.py

@@ -539,7 +539,9 @@ def main(argv=None):
  app.exec()
  finally:
  try:
- process.close()
+ # `process` is only the handle the picker opened; File → Change
+ # Process… released that one and attached the window to another.
+ window.process.close()
  except Exception:
  pass
 

PyMemoryEditor/app/cheat_poll_worker.py

@@ -106,6 +106,11 @@ def request_write(
  with QMutexLocker(self._mutex):
  self._pending_writes.append((address, pytype, length, value))
 
+ def _stopping(self) -> bool:
+ """Whether ``stop`` was asked for. Cheap enough to check per entry."""
+ with QMutexLocker(self._mutex):
+ return self._stop
+
  def stop(self) -> None:
  with QMutexLocker(self._mutex):
  self._stop = True
@@ -126,6 +131,8 @@ def _drain_pending_writes(self) -> List[Tuple[int, type, int, str]]:
 
  failures: List[Tuple[int, type, int, str]] = []
  for address, pytype, length, value in pending:
+ if self._stopping():
+ break # the handle is about to go — see _poll_once
  try:
  self._process.write_process_memory(address, pytype, length, value)
  except Exception as exc: # noqa: BLE001
@@ -206,6 +213,11 @@ def _poll_once(
  values_by_address = None
 
  for address in addresses:
+ # Per entry, not per tick: shutdown() closes the handle right
+ # after stop(), and a write on a recycled one hits another
+ # process.
+ if self._stopping():
+ return results
  frozen_value, is_frozen = freeze_by_addr[(pytype, length, address)]
  if values_by_address is not None:
  current = values_by_address.get(address)