PyMemoryEditor 3.2.0__py3-none-any.whl → 3.3.1__py3-none-any.whl

PyMemoryEditor/__init__.py

@@ -8,7 +8,7 @@ Supported platforms: Windows, Linux and macOS (32-bit and 64-bit).
 """
 
 __author__ = "Jean Loui Bernard Silva de Jesus"
-__version__ = "3.2.0"
+__version__ = "3.3.1"
 
 import logging
 import sys

PyMemoryEditor/app/_auto_refresh_dialog.py

@@ -3,13 +3,12 @@
 Shared base for the read-only, auto-refreshing table dialogs (Memory Map,
 Modules, Threads).
 
-All three did the same dance — run a one-shot read off the UI thread, repopulate
+All three do the same dance — run a one-shot read off the UI thread, repopulate
 a sortable table when it returns, poll on a timer, and tear the worker down
-safely on close — each with its own near-identical ``_*Worker(QThread)`` and
-lifecycle boilerplate. That triplicated the fiddly bits (the in-flight guard
-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.
+safely on close. This owns that lifecycle once, so the fiddly bits (the
+in-flight guard that self-throttles the poll, the detach-on-shutdown safety)
+live in one place; 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`.
@@ -182,7 +181,7 @@ class AutoRefreshTableDialog(TearsDownOnClose, QDialog):
         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).
+        user could only escape by killing the app from another TTY.
 
         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

PyMemoryEditor/app/_widgets.py

@@ -2,8 +2,8 @@
 
 """Small Qt widgets shared between dialogs.
 
-Centralises tiny helpers (numeric sort items, hex address parsing) that
-previously appeared duplicated across several dialog modules.
+Centralises tiny helpers (numeric sort items, hex address parsing) shared by
+several dialog modules.
 """
 
 import threading
@@ -46,9 +46,9 @@ def shutdown_worker_thread(worker: Optional[QThread], wait_ms: int = 2000) -> No
         cancel()
     try:
         # 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.
+        # raises TypeError in PySide6, 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
@@ -141,8 +141,8 @@ class TearsDownOnClose:
     ``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.
+    close event — so a teardown living in ``closeEvent`` would never run, and
+    the dialog would keep 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

PyMemoryEditor/app/application.py

@@ -542,8 +542,7 @@ def main(argv=None):
 
     ``argv`` defaults to ``sys.argv`` so packaging tools (which call
     ``main()`` with no arguments) keep working. Tests and embedders can pass
-    an explicit list — previously a positional ``*args`` was accepted but
-    ignored, which made the parameter meaningless.
+    an explicit list.
 
     Terminal users want Ctrl+C to kill the app, which takes a process-wide
     signal change — see :func:`main_cli`, the console-script entry point.
@@ -602,8 +601,8 @@ def main(argv=None):
                 # Change Process… released that one and attached the window
                 # to another.
                 window.process.close()
-            except Exception:
-                pass
+            except Exception:  # noqa: BLE001 — exiting anyway; keep the cause
+                _LOG.debug("Closing the process handle on exit failed", exc_info=True)
 
 
 def main_cli(argv=None):
@@ -611,9 +610,9 @@ def main_cli(argv=None):
     Entry point for the ``pymemoryeditor`` console script and ``python -m``.
 
     Qt's event loop blocks inside C++, so Python's default SIGINT handler only
-    runs once the interpreter next regains control. In practice it raised
+    runs once the interpreter next regains control. In practice it raises
     KeyboardInterrupt inside our own _PointerCursorFilter.eventFilter override,
-    where PySide6 swallows it and merely prints a traceback (#76). Hand SIGINT
+    where PySide6 swallows it and merely prints a traceback. Hand SIGINT
     back to the OS for the duration of the run so Ctrl+C from a terminal
     terminates the app immediately.
 

PyMemoryEditor/app/cheat_poll_worker.py

@@ -56,8 +56,8 @@ class _CheatPollWorker(QThread):
     with the current ``{key: "ErrorType: message"}`` map. The signal fires only
     when that set *changes* (a freeze starts or stops failing), so the UI gets a
     persistent cue without 10 Hz spam, and the first failure of each entry is
-    logged once. Previously the exception was swallowed silently, so a freeze
-    that never landed looked identical to one that did.
+    logged once. Swallowing the exception instead would make a freeze that
+    never landed look identical to one that did.
     """
 
     values_ready = Signal(object)  # list[tuple[int, type, int, Any]]
@@ -96,9 +96,9 @@ class _CheatPollWorker(QThread):
     ) -> None:
         """Queue a one-shot manual write to be performed on the worker thread.
 
-        The cheat table's inline value edits used to call
-        ``write_process_memory`` directly on the UI thread, freezing the UI when
-        the target was slow or the page faulted. Routing them here keeps the
+        The cheat table's inline value edits come through here: calling
+        ``write_process_memory`` directly on the UI thread would freeze the UI
+        when the target is slow or the page faults. Routing them here keeps the
         syscall off the UI thread; a write that fails comes back via the
         ``write_failed`` signal. Latency is at most one tick (~100 ms), which is
         imperceptible for a manual edit.
@@ -115,20 +115,21 @@ class _CheatPollWorker(QThread):
         with QMutexLocker(self._mutex):
             self._stop = True
 
-    def _drain_pending_writes(self) -> List[Tuple[int, type, int, str]]:
-        """Perform and clear every queued manual write.
+    def _take_pending_writes(self) -> List[Tuple[int, type, int, Any]]:
+        """Detach the queued writes. The caller holds ``self._mutex``."""
+        pending = self._pending_writes
+        self._pending_writes = []
+        return pending
+
+    def _perform_writes(
+        self, pending: List[Tuple[int, type, int, Any]]
+    ) -> List[Tuple[int, type, int, str]]:
+        """Perform manual writes taken with :meth:`_take_pending_writes`.
 
         Returns one ``(address, pytype, length, message)`` tuple per write that
-        failed, so ``run`` can surface it via ``write_failed``. Reads and clears
-        the queue under the lock, then runs the syscalls outside it so a slow
-        write never blocks a UI thread enqueuing the next edit.
+        failed, so ``run`` can surface it via ``write_failed``. Runs outside the
+        lock, so a slow write never blocks a UI thread enqueuing the next edit.
         """
-        with QMutexLocker(self._mutex):
-            if not self._pending_writes:
-                return []
-            pending = self._pending_writes
-            self._pending_writes = []
-
         failures: List[Tuple[int, type, int, str]] = []
         for address, pytype, length, value in pending:
             if self._stopping():
@@ -146,10 +147,15 @@ class _CheatPollWorker(QThread):
 
     def run(self) -> None:
         while True:
+            # Snapshot and queued writes are taken together, under one lock:
+            # an inline edit on a frozen row publishes the new frozen value and
+            # queues its write back to back, and a snapshot copied before that
+            # pair would re-freeze the old value over the write just drained.
             with QMutexLocker(self._mutex):
                 if self._stop:
                     return
                 snapshot = list(self._snapshot)
+                pending = self._take_pending_writes()
 
             # Never let an exception escape the loop body: a QThread whose
             # run() raises dies silently, and the table would then stop
@@ -158,7 +164,7 @@ class _CheatPollWorker(QThread):
             try:
                 # Apply queued manual writes before reading, so a just-typed
                 # value lands and is read back as the new current value this tick.
-                for failure in self._drain_pending_writes():
+                for failure in self._perform_writes(pending):
                     self.write_failed.emit(failure)
 
                 if snapshot:

PyMemoryEditor/app/cheat_table.py

@@ -12,8 +12,8 @@ stays fresh.
 This module hosts only the Qt widget; the dataclass and the worker thread
 live in ``cheat_entry.py`` and ``cheat_poll_worker.py`` respectively. The
 ``CheatEntry`` and ``_CheatPollWorker`` names are re-exported from here for
-backward compatibility with code (and tests) that imported them from this
-module before the split.
+backward compatibility with code (and tests) that import them from this
+module.
 """
 import copy
 import json
@@ -95,8 +95,8 @@ class CheatTable(QWidget):
         self._poller.start()
 
         # A short cadence to push fresh entry snapshots into the worker. This
-        # is far cheaper than the previous QTimer that did real syscalls — it
-        # only copies a small list of tuples.
+        # is cheap — it does no syscalls, it only copies a small list of
+        # tuples.
         self._publish_timer = QTimer(self)
         self._publish_timer.setInterval(TICK_INTERVAL_MS)
         self._publish_timer.timeout.connect(self._publish_snapshot_to_worker)
@@ -221,8 +221,8 @@ class CheatTable(QWidget):
         self._table.customContextMenuRequested.connect(self._show_context_menu)
         layout.addWidget(self._table, 1)
 
-        # Delete removes the selected rows — the standard gesture, previously
-        # only reachable through the context menu. Scoped to the table widget
+        # Delete removes the selected rows — the standard gesture, alongside
+        # the context menu. Scoped to the table widget
         # (WidgetShortcut) so Delete still edits text while a cell is in
         # inline-edit mode (the editor child, not the table, has focus then).
         delete_shortcut = QShortcut(QKeySequence(QKeySequence.Delete), self._table)
@@ -230,27 +230,48 @@ class CheatTable(QWidget):
         delete_shortcut.activated.connect(self._on_remove_selected)
 
     def add_entry(self, entry: CheatEntry) -> None:
-        # Every entry enters here, whichever way it was created — promoted from
-        # a scan, from a pointer dialog, added by hand, or loaded from JSON. A
-        # zero-width buffer reads back empty on every poll tick and can't be
-        # spotted from the table, so the floor is enforced once, at the door,
-        # rather than at each of those call sites. (The AOB pattern spec is the
-        # one whose declared length is 0 — the scanner derives its real width
-        # from the pattern.) The ceiling is the same one every other width
-        # field enforces (MAX_ENTRY_LENGTH); only a JSON import can carry more,
-        # and silently resizing its entry would alter what the user exports
-        # next, so that is refused -- the import loop reports and skips it.
-        length = int(entry.length)
-        if length > MAX_ENTRY_LENGTH:
-            raise ValueError(
-                "entry at 0x%X has length %d, over the %d-byte maximum"
-                % (entry.address, length, MAX_ENTRY_LENGTH)
-            )
-        entry.length = max(1, length)
+        self._add_entries([entry])
+
+    def _add_entries(self, new_entries: List[CheatEntry]) -> None:
+        """Merge ``new_entries`` into the table and rebuild it once.
+
+        Every entry enters here, whichever way it was created — promoted from
+        a scan, from a pointer dialog, added by hand, or loaded from JSON. A
+        zero-width buffer reads back empty on every poll tick and can't be
+        spotted from the table, so the floor is enforced once, at the door,
+        rather than at each of those call sites. (The AOB pattern spec is the
+        one whose declared length is 0 — the scanner derives its real width
+        from the pattern.) The ceiling is the same one every other width
+        field enforces (MAX_ENTRY_LENGTH); only a JSON import can carry more,
+        and silently resizing its entry would alter what the user exports
+        next, so that is refused -- the import loop reports and skips it.
+
+        Batched so a bulk promotion costs one address lookup per row and one
+        rebuild in total: one ``add_entry`` per row would do a linear
+        duplicate scan plus a full table rebuild each, quadratic in the
+        selection.
+
+        :raises ValueError: if an entry's length is over ``MAX_ENTRY_LENGTH``;
+            checked for every entry before any is added.
+        """
+        for entry in new_entries:
+            length = int(entry.length)
+            if length > MAX_ENTRY_LENGTH:
+                raise ValueError(
+                    "entry at 0x%X has length %d, over the %d-byte maximum"
+                    % (entry.address, length, MAX_ENTRY_LENGTH)
+                )
 
-        # If the address already exists, just refresh its description/type.
+        # First entry per address wins, should the table hold duplicates.
+        by_address: Dict[int, CheatEntry] = {}
         for existing in self._entries:
-            if existing.address == entry.address:
+            by_address.setdefault(existing.address, existing)
+
+        for entry in new_entries:
+            entry.length = max(1, int(entry.length))
+            # If the address already exists, just refresh its description/type.
+            existing = by_address.get(entry.address)
+            if existing is not None:
                 existing.description = entry.description or existing.description
                 # Re-promoting an address that is already in the table is the
                 # third place a spec_label changes, and the cached value has to
@@ -260,10 +281,10 @@ class CheatTable(QWidget):
                     _forget_value_read_as_another_type(existing)
                 existing.spec_label = entry.spec_label
                 existing.length = entry.length
-                self._rebuild()
-                return
+                continue
+            self._entries.append(entry)
+            by_address[entry.address] = entry
 
-        self._entries.append(entry)
         self._rebuild()
 
     def add_addresses(
@@ -283,15 +304,17 @@ class CheatTable(QWidget):
                 "length %d is over the %d-byte maximum for a cheat-table entry"
                 % (int(length), MAX_ENTRY_LENGTH)
             )
-        for addr in addresses:
-            self.add_entry(
+        self._add_entries(
+            [
                 CheatEntry(
                     description=description,
                     address=int(addr),
                     spec_label=spec.label,
                     length=int(length),
                 )
-            )
+                for addr in addresses
+            ]
+        )
 
     def entries(self) -> List[CheatEntry]:
         return list(self._entries)
@@ -325,8 +348,8 @@ class CheatTable(QWidget):
         type_label = entry.spec_label
         # Show the width whenever it belongs to the entry rather than to the
         # spec. An IDA pattern declares none (length 0) yet carries a real one
-        # here — writes are refused against it — so hiding it left the user
-        # told to "widen the entry" with no way to see what it holds.
+        # here — writes are refused against it — so hiding it would leave the
+        # user told to "widen the entry" with no way to see what it holds.
         if entry.spec.accepts_length_override or not entry.spec.length:
             type_label += f"  · {entry.length}B"
         type_item = QTableWidgetItem(type_label)
@@ -405,14 +428,30 @@ class CheatTable(QWidget):
             # Nothing to route it to once shutdown() handed the worker over,
             # and nothing to write to while the target is known to be gone.
             if self._poller_stopped or self._paused:
+                # Put the cell back and say so, as the bulk edit does —
+                # returning quietly would leave the typed text on screen as if
+                # it had been written.
+                self._suspend_signals = True
+                item.setText(self._value_text_for(entry))
+                self._suspend_signals = False
+                QMessageBox.warning(
+                    self,
+                    "Write value",
+                    f"0x{entry.address:X}: the target process is no longer available.",
+                )
                 return
-            self._poller.request_write(
-                entry.address, entry.spec.pytype, entry.length, value
-            )
 
             entry.last_value = value
             if entry.frozen:
                 entry.frozen_value = value
+                # Hand the worker the new frozen value *before* queuing the
+                # write: its snapshot otherwise still holds the old one until
+                # the next publish tick, and the freeze loop would write that
+                # stale value straight over the edit.
+                self._publish_snapshot_to_worker()
+            self._poller.request_write(
+                entry.address, entry.spec.pytype, entry.length, value
+            )
 
     def _publish_snapshot_to_worker(self) -> None:
         """Hand the worker a fresh immutable snapshot of every entry."""
@@ -487,7 +526,8 @@ class CheatTable(QWidget):
         against it here is cheap and keeps the cue in sync: a red value cell plus
         an explanatory tooltip while a freeze keeps failing, restored to normal
         the moment the write lands again. Without this, a frozen value that the
-        backend silently refuses to write looked identical to one that worked.
+        backend silently refuses to write would look identical to one that
+        worked.
         """
         rows_by_key: Dict[Tuple[int, type, int], int] = {}
         for row, entry in enumerate(self._entries):
@@ -873,7 +913,7 @@ class CheatTable(QWidget):
 
 
 # Ceiling for an entry's buffer width. Entries are promoted at the width of the
-# value scanned for, which the scanner doesn't cap, so 1024 was too tight — but
+# value scanned for, which the scanner doesn't cap, so 1024 is too tight — but
 # the poll worker allocates this many bytes per entry on every 100 ms tick, so
 # an unbounded field turns one typo into a multi-gigabyte allocation the tick's
 # blanket except swallows and retries forever. A megabyte is far past any real

PyMemoryEditor/app/main_window.py

@@ -383,11 +383,12 @@ class MainWindow(QMainWindow):
         # The worker builds the region snapshot off the UI thread; cache it here
         # for the refine/update scans that reuse it.
         worker.snapshot_ready.connect(self._on_snapshot_ready)
-        # Connection order matters: _cleanup_worker must clear self._worker
-        # before _fill_initial_values runs, otherwise the busy guard in
-        # _on_update_values rejects the auto-refresh.
-        worker.finished.connect(self._cleanup_worker)
-        worker.finished.connect(lambda: self._fill_initial_values(request))
+        # One slot, not two connections in a load-bearing order: it clears
+        # self._worker (via _cleanup_worker) before _fill_initial_values runs,
+        # otherwise the busy guard in _on_update_values rejects the
+        # auto-refresh — and it runs that refresh only after a scan that went
+        # through, not after Cancel or an error.
+        worker.finished.connect(lambda: self._on_first_scan_finished(request))
         self._worker = worker
         worker.start()
 
@@ -464,10 +465,25 @@ class MainWindow(QMainWindow):
         self._worker = worker
         worker.start()
 
+    def _on_first_scan_finished(self, request: ScanRequest) -> None:
+        worker = self._worker
+        completed = worker is not None and worker.completed()
+        self._cleanup_worker()
+        # A cancelled scan still emits finished_ok (with the partial count) and
+        # a failed one emits error; either way the user asked for no more
+        # work — otherwise Cancel would start "Updating values…", and a dead
+        # target would pop a second error dialog from the refresh.
+        if completed:
+            self._fill_initial_values(request)
+
     def _fill_initial_values(self, request: ScanRequest) -> None:
         # If the first-scan worker dropped or had zero hits, skip the refresh.
         if self._results_model.count() == 0:
             return
+        # The heartbeat locked the scanner while the scan ran: the target is
+        # gone, so a refresh could only fail.
+        if self._target_dead:
+            return
         # Don't recurse into another scan if the user has already triggered one.
         if self._worker is not None:
             return
@@ -529,7 +545,18 @@ class MainWindow(QMainWindow):
         self._status.showMessage(message)
 
     def _cleanup_worker(self) -> None:
+        # Runs from the worker's `finished`, and only one scan runs at a time,
+        # so self._worker is the worker that just finished. It is a child of
+        # this window: dropping the reference alone would keep every scan's
+        # QThread (and the address list / value map it was handed) alive until
+        # the window closed. `finished` is emitted as run() returns, so wait()
+        # comes back at once; it makes sure the thread is really over before
+        # deleteLater() (destroying a running QThread aborts the process).
+        worker = self._worker
         self._worker = None
+        if worker is not None:
+            worker.wait()
+            worker.deleteLater()
         # A scan that was running when the target exited finishes (with an
         # error) after the heartbeat locked the scanner; releasing the lock
         # here would hand the controls back against a dead handle.
@@ -570,7 +597,24 @@ class MainWindow(QMainWindow):
             snap = self._memory_map.snapshot()
             if snap:
                 self._region_snapshot = snap
-        self._memory_map = None
+        self._release_dialog("_memory_map")
+
+    def _release_dialog(self, attr: str) -> None:
+        """Forget a closed tool dialog and free it.
+
+        The dialogs are children of this window and are rebuilt on the next
+        open, so dropping the reference alone would keep every closed instance
+        (and the tables it held) alive for the life of the window. By the time
+        ``finished`` gets here the dialog's teardown has already run — it is
+        driven from ``done()`` — so its background worker is stopped, or
+        detached from it if it would not stop, and the delete can't take a
+        running thread down with it. deleteLater(), not delete: this runs
+        inside the dialog's own ``done()``.
+        """
+        dialog = getattr(self, attr, None)
+        setattr(self, attr, None)
+        if dialog is not None:
+            dialog.deleteLater()
 
     def _open_threads_dialog(self) -> None:
         if self._threads_dialog is None:
@@ -583,7 +627,7 @@ class MainWindow(QMainWindow):
         self._threads_dialog.activateWindow()
 
     def _on_threads_dialog_closed(self, _result: int) -> None:
-        self._threads_dialog = None
+        self._release_dialog("_threads_dialog")
 
     def _open_modules_dialog(self) -> None:
         if self._modules_dialog is None:
@@ -602,7 +646,7 @@ class MainWindow(QMainWindow):
         self._modules_dialog.activateWindow()
 
     def _on_modules_dialog_closed(self, _result: int) -> None:
-        self._modules_dialog = None
+        self._release_dialog("_modules_dialog")
 
     def _open_pointer_chain_dialog(self) -> None:
         if self._pointer_chain_dialog is None:
@@ -618,7 +662,7 @@ class MainWindow(QMainWindow):
         self._pointer_chain_dialog.activateWindow()
 
     def _on_pointer_chain_dialog_closed(self, _result: int) -> None:
-        self._pointer_chain_dialog = None
+        self._release_dialog("_pointer_chain_dialog")
 
     def _on_module_resolve_chain(self, base_address: int) -> None:
         """Open the Pointer Chain tool with a module's base address prefilled."""
@@ -675,7 +719,7 @@ class MainWindow(QMainWindow):
         self._pointer_scan_dialog.activateWindow()
 
     def _on_pointer_scan_dialog_closed(self, _result: int) -> None:
-        self._pointer_scan_dialog = None
+        self._release_dialog("_pointer_scan_dialog")
 
     def _on_pointer_scan_promote(
         self, address: int, spec_label: str, length: int
@@ -694,7 +738,7 @@ class MainWindow(QMainWindow):
         self._log_console_dialog.activateWindow()
 
     def _on_log_console_closed(self, _result: int) -> None:
-        self._log_console_dialog = None
+        self._release_dialog("_log_console_dialog")
 
     def _open_hex_viewer(self, address: int) -> None:
         self._open_hex_viewer_with_size(address, 256)
@@ -875,8 +919,8 @@ class MainWindow(QMainWindow):
 
         # Tear down auxiliary dialogs that hold a reference to the old
         # process — reopening them rebuilds against the new target. The Memory
-        # Map belongs here too: it polls on a timer, so leaving it open left it
-        # reading the handle closed just below (issue #74).
+        # Map belongs here too: it polls on a timer, so leaving it open would
+        # leave it reading the handle closed just below.
         for dialog_attr in (
             "_memory_map",
             "_threads_dialog",
@@ -908,8 +952,8 @@ class MainWindow(QMainWindow):
         # until GC. shutdown() is idempotent and joins the worker.
         try:
             old_cheat.shutdown()
-        except Exception:
-            pass
+        except Exception:  # noqa: BLE001 — teardown must go on; keep the cause
+            _LOG.debug("Old cheat table shutdown failed", exc_info=True)
         # A worker that blew its join is detached, not stopped, so it can still
         # be inside a syscall on the old handle. Release the handle only once
         # every detached worker has finished; closing it now could hand its
@@ -963,8 +1007,8 @@ class MainWindow(QMainWindow):
         # before the process handle goes away in `application.main`'s finally.
         try:
             self._cheat.shutdown()
-        except Exception:
-            pass
+        except Exception:  # noqa: BLE001 — teardown must go on; keep the cause
+            _LOG.debug("Cheat table shutdown failed", exc_info=True)
 
         self._shutdown_worker()
 
@@ -975,8 +1019,8 @@ class MainWindow(QMainWindow):
         """Ask before quitting with unsaved cheat entries. True = go ahead.
 
         The table is not persisted between runs (Export… is the way to keep
-        it), so a stray Cmd+Q / window close used to throw away every saved
-        address silently.
+        it), so a stray Cmd+Q / window close would otherwise throw away every
+        saved address silently.
         """
         count = self._cheat.entry_count()
         if count == 0 or not self.confirm_close_with_entries:
@@ -1018,16 +1062,26 @@ class MainWindow(QMainWindow):
             return
         self._worker = None
         worker.cancel()
-        try:
-            worker.chunk_ready.disconnect()
-            worker.progress.disconnect()
-            worker.status.disconnect()
-            worker.error.disconnect()
-            worker.finished_ok.disconnect()
-            worker.finished.disconnect()
-        except (RuntimeError, TypeError):
-            # Already disconnected / no slots — fine, we just want them gone.
-            pass
+        # Each signal on its own, so one that has no slots can't leave the
+        # rest connected. snapshot_ready exists on the first-scan worker only;
+        # a late one would cache a snapshot on a window that is going away.
+        for name in (
+            "chunk_ready",
+            "progress",
+            "status",
+            "error",
+            "finished_ok",
+            "snapshot_ready",
+            "finished",
+        ):
+            signal = getattr(worker, name, None)
+            if signal is None:
+                continue
+            try:
+                signal.disconnect()
+            except (RuntimeError, TypeError):
+                # Already disconnected / no slots — fine, we just want them gone.
+                pass
 
         # Pump queued cross-thread calls so any in-flight blocking emit is
         # dispatched (which releases the worker even though we just
@@ -1051,7 +1105,7 @@ def _close_quietly(process) -> None:
     try:
         process.close()
     except Exception:  # noqa: BLE001 — the target may already be gone
-        pass
+        _LOG.debug("Closing the previous process handle failed", exc_info=True)
 
 
 def _safe_for_json(value) -> object:

PyMemoryEditor/app/memory_viewer_dialog.py

@@ -151,9 +151,9 @@ class MemoryViewerDialog(TearsDownOnClose, QDialog):
         self._timer = QTimer(self)
         self._timer.timeout.connect(self.refresh)
 
-        # Failure bookkeeping, same shape as the auto-refresh dialogs: a dead
-        # target used to log a warning every tick forever (~20/s at the 50 ms
-        # floor). Keyed by (address, size, message) so moving the viewer to
+        # Failure bookkeeping, same shape as the auto-refresh dialogs: without
+        # it a dead target would log a warning every tick forever (~20/s at the
+        # 50 ms floor). Keyed by (address, size, message) so moving the viewer to
         # another failing range still gets logged.
         self._last_failure: Optional[tuple] = None
         self._failing_since: Optional[QElapsedTimer] = None
@@ -171,7 +171,7 @@ class MemoryViewerDialog(TearsDownOnClose, QDialog):
         # Skip if a read is still running. The auto-refresh timer fires this
         # repeatedly, and a large length (up to 65536) on a slow target
         # (notably macOS Mach-VM) takes long enough that running it on the UI
-        # thread froze input — so the read now runs on a worker, and this guard
+        # thread would freeze input — so the read runs on a worker, and this guard
         # self-throttles the cadence to the real read time instead of stacking
         # workers.
         if self._worker is not None and self._worker.isRunning():
@@ -188,7 +188,7 @@ class MemoryViewerDialog(TearsDownOnClose, QDialog):
             # travel back in the result so the rendered dump stays labelled with
             # the range actually read even if the user edits the fields mid-read.
             # Errors are returned (not raised) so the one result handler renders
-            # them with the same message/log the synchronous path produced.
+            # every outcome through a single message/log path.
             try:
                 data = process.read_process_memory(addr, bytes, size)
                 # A backend returning a non-buffer object would make bytes(data)

PyMemoryEditor/app/open_process_dialog.py

@@ -288,7 +288,7 @@ class OpenProcessDialog(TearsDownOnClose, QDialog):
         selected_pid = self._selected_pid()
 
         # Restoring the selection below re-triggers Qt's scrollTo(current), which
-        # jumped the list back to the selected row on every tick (#75). The
+        # would jump the list back to the selected row on every tick. The
         # rebuild is harmless on its own: Qt defers the scrollbar range update.
         scrollbar = self._table.verticalScrollBar()
         scroll_offset = scrollbar.value()