PyMemoryEditor 3.2.0__py3-none-any.whl → 3.3.0__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.0"
 
 import logging
 import sys

PyMemoryEditor/app/application.py

@@ -602,8 +602,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):

PyMemoryEditor/app/cheat_poll_worker.py

@@ -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

@@ -230,27 +230,47 @@ 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 did 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, as the linear scan used to find.
+        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 +280,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 +303,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)
@@ -405,14 +427,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 left 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."""

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 — Cancel started "Updating values…", and a dead target popped
+        # 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 kept 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 kept 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)
@@ -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()
 
@@ -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/pointer_scan_dialog.py

@@ -24,6 +24,7 @@ so it survives into the freeze/refresh loop.
 """
 import json
 import logging
+import threading
 from dataclasses import dataclass
 from typing import List, Optional, Tuple
 
@@ -79,6 +80,13 @@ _MONO = MONOSPACE_FAMILY
 # thousands of paths updates the UI smoothly instead of one row at a time.
 _UI_BATCH = 200
 
+# Batches the scan worker may have handed to the UI before it has appended
+# them. Past this the worker waits, so a fast walk with "Unlimited" results
+# can't pile up an unbounded queue of rows behind a busy UI thread. A wait
+# loop rather than a BlockingQueuedConnection: it observes Stop/cancel on its
+# own, so the teardown's plain join never has to pump the event loop.
+_MAX_BATCHES_IN_FLIGHT = 4
+
 
 class _PointerScanCancelled(Exception):
     """Raised from the progress callback to abort a scan mid-map-build."""
@@ -120,10 +128,30 @@ class PointerScanWorker(QThread):
         self._process = process
         self._request = request
         self._cancelled = False
+        self._in_flight = 0
+        self._in_flight_lock = threading.Lock()
 
     def cancel(self) -> None:
         self._cancelled = True
 
+    def batch_consumed(self, *_args) -> None:
+        """Acknowledge one ``rows_ready`` batch; connect it after the slot
+        that appends the rows. Without it the worker stalls after
+        ``_MAX_BATCHES_IN_FLIGHT`` batches, until cancelled."""
+        with self._in_flight_lock:
+            self._in_flight -= 1
+
+    def _hand_over(self, batch: List[_ResultRow]) -> None:
+        """Emit ``batch`` and wait until the UI has room for the next one."""
+        with self._in_flight_lock:
+            self._in_flight += 1
+        self.rows_ready.emit(batch)
+        while not self._cancelled:
+            with self._in_flight_lock:
+                if self._in_flight < _MAX_BATCHES_IN_FLIGHT:
+                    return
+            QThread.msleep(5)
+
     def _on_map_progress(self, fraction: float) -> None:
         # Abort the (uninterruptible-from-outside) map build by raising; the
         # generator unwinds and run() catches the cancellation cleanly.
@@ -168,12 +196,12 @@ class PointerScanWorker(QThread):
                 count += 1
 
                 if len(batch) >= _UI_BATCH:
-                    self.rows_ready.emit(batch)
+                    self._hand_over(batch)
                     batch = []
                     self.status.emit(f"Found {count:,} pointer path(s)…")
 
             if batch:
-                self.rows_ready.emit(batch)
+                self._hand_over(batch)
 
             if self._cancelled:
                 self.status.emit(f"Stopped — {count:,} pointer path(s) found.")
@@ -322,6 +350,10 @@ _COL_OFFSETS = 3
 _COL_RESOLVED = 4
 _COL_VALUE = 5
 
+# Set on a Compare row whose module is not loaded now: the stashed path still
+# carries the previous run's absolute base, so it must not be resolved.
+_ROLE_NO_LIVE_BASE = Qt.UserRole + 1
+
 
 class PointerScanDialog(TearsDownOnClose, QDialog):
     """Reverse pointer scan with a Cheat-Engine-style result table."""
@@ -336,6 +368,8 @@ class PointerScanDialog(TearsDownOnClose, QDialog):
         super().__init__(parent)
         self._process = process
         self._worker: Optional[QThread] = None
+        # Set by Stop for the running worker, so its finish reads as stopped.
+        self._stop_requested = False
         self._target_address: Optional[int] = None
 
         self.setWindowTitle(f"Pointer Scan — PID {process.pid}")
@@ -632,15 +666,21 @@ class PointerScanDialog(TearsDownOnClose, QDialog):
         worker.progress.connect(lambda p: self._progress.setValue(int(p)))
         worker.status.connect(self._count_label.setText)
         worker.rows_ready.connect(self._append_rows)
+        # After _append_rows, so a batch is acknowledged once it is drawn.
+        batch_consumed = getattr(worker, "batch_consumed", None)
+        if batch_consumed is not None:
+            worker.rows_ready.connect(batch_consumed)
         worker.error.connect(self._on_error)
         worker.finished_ok.connect(self._on_finished_ok)
         worker.finished.connect(self._on_worker_finished)
         self._worker = worker
+        self._stop_requested = False
         worker.start()
 
     def _on_stop(self) -> None:
         if self._worker is not None:
             self._worker.cancel()
+            self._stop_requested = True
             self._count_label.setText("Stopping…")
 
     def _set_scanning(self, scanning: bool) -> None:
@@ -738,7 +778,12 @@ class PointerScanDialog(TearsDownOnClose, QDialog):
     def _on_finished_ok(self, count: int) -> None:
         self._progress.setValue(100)
         shown = self._model.rowCount()
-        if count == 0 and shown == 0:
+        if self._stop_requested:
+            # Stopped (possibly while the map was still being built, which
+            # reports 0): "no paths found, try a higher depth" would misread a
+            # scan that never got to look.
+            self._count_label.setText(f"Stopped — {shown:,} pointer path(s) found.")
+        elif count == 0 and shown == 0:
             self._count_label.setText(
                 "No pointer paths found. Try a higher depth or max offset, or "
                 "uncheck “Writable memory only”."
@@ -756,6 +801,13 @@ class PointerScanDialog(TearsDownOnClose, QDialog):
 
     # ----------------------------------------------------------- actions --- #
 
+    def _selected_has_no_live_base(self) -> bool:
+        rows = self._table.selectionModel().selectedRows()
+        if not rows:
+            return False
+        item = self._model.item(rows[0].row(), _COL_PATH)
+        return bool(item is not None and item.data(_ROLE_NO_LIVE_BASE))
+
     def _selected_path(self) -> Optional[PointerPath]:
         rows = self._table.selectionModel().selectedRows()
         if not rows:
@@ -796,6 +848,17 @@ class PointerScanDialog(TearsDownOnClose, QDialog):
         path = self._selected_path()
         if path is None:
             return None
+        if self._selected_has_no_live_base():
+            # A Compare survivor whose module is not loaded now: it keeps the
+            # saved path, and walking that path's absolute base would read the
+            # previous run's addresses -- possibly unrelated memory that maps.
+            QMessageBox.warning(
+                self,
+                "Pointer Scan",
+                f"Could not resolve this path now — its module "
+                f"{path.module!r} is not loaded in the target.",
+            )
+            return None
         try:
             return path.resolve(self._process)
         except Exception as exc:  # noqa: BLE001
@@ -992,8 +1055,19 @@ class PointerScanDialog(TearsDownOnClose, QDialog):
         spec, length = self._current_spec()
 
         rows: List[_ResultRow] = []
+        no_live_base: List[int] = []
         for saved in survivors:
-            live = saved._rebased_onto(module_bases) or saved
+            # Survivors are all module paths (the intersection drops the
+            # rest). One whose module isn't loaded now has no live base: the
+            # rescan drops it, and falling back to its saved absolute base (as
+            # this used to) walked the previous run's addresses and could show
+            # a value read from unrelated memory as if the path resolved. Its
+            # membership is already decided, so it stays, shown unresolved.
+            live = saved._rebased_onto(module_bases)
+            if live is None:
+                no_live_base.append(len(rows))
+                rows.append((saved, None, "—", False))
+                continue
             try:
                 resolved = live.resolve(self._process)
                 value = self._process.read_process_memory(resolved, spec.pytype, length)
@@ -1003,7 +1077,12 @@ class PointerScanDialog(TearsDownOnClose, QDialog):
                 resolved, text, valid = None, "—", False
             rows.append((live, resolved, text, valid))
 
+        first_row = self._model.rowCount()
         self._append_rows(rows)
+        for index in no_live_base:
+            item = self._model.item(first_row + index, _COL_PATH)
+            if item is not None:
+                item.setData(True, _ROLE_NO_LIVE_BASE)
         self._count_label.setText(
             f"{len(survivors):,} path(s) common to {len(filenames)} scans."
             + unavailable