PyMemoryEditor 3.1.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.1.0"
+__version__ = "3.3.0"
 
 import logging
 import sys

PyMemoryEditor/app/_widgets.py

@@ -6,9 +6,10 @@ Centralises tiny helpers (numeric sort items, hex address parsing) that
 previously appeared duplicated across several dialog modules.
 """
 
+import threading
 from typing import Any, Callable, Iterable, List, Optional, Tuple
 
-from PySide6.QtCore import QObject, Qt, QThread
+from PySide6.QtCore import QCoreApplication, QObject, Qt, QThread, QTimer
 from PySide6.QtGui import QStandardItem
 
 
@@ -84,6 +85,56 @@ def _reap_detached_worker(worker: QThread) -> None:
     worker.deleteLater()
 
 
+def detached_workers_running() -> bool:
+    """Whether any worker that outlived its owner is still running."""
+    return any(worker.isRunning() for worker in _DETACHED_WORKERS)
+
+
+def run_after_detached_workers(callback: Callable[[], None]) -> None:
+    """Run ``callback`` once every currently detached worker has finished.
+
+    A detached worker can still be inside a backend syscall on the process it
+    was given, so releasing that process (``close()``) must wait for it: on
+    Windows the handle value can be recycled for an unrelated object the moment
+    it is closed, and a late write from the cheat poller would land there.
+    With no worker still running, ``callback`` runs immediately.
+    """
+    pending = [worker for worker in _DETACHED_WORKERS if worker.isRunning()]
+    if not pending:
+        callback()
+        return
+
+    remaining = set(pending)
+    done = False
+    # `finished` can be delivered from the worker's own thread while the
+    # isFinished() sweep below runs on this one: guard the bookkeeping so the
+    # callback (a handle close) runs exactly once.
+    guard = threading.Lock()
+    # Whichever thread notices the last worker finishing, the callback is
+    # posted to the GUI thread (the application object lives there), so it
+    # never runs concurrently with the GUI setting up the next process.
+    gui = QCoreApplication.instance()
+
+    def _on_finished(worker: QThread) -> None:
+        nonlocal done
+        with guard:
+            remaining.discard(worker)
+            if remaining or done:
+                return
+            done = True
+        if gui is None:
+            callback()
+        else:
+            QTimer.singleShot(0, gui, callback)
+
+    for worker in pending:
+        worker.finished.connect(lambda w=worker: _on_finished(w))
+    # Same race as detach_worker: one may have finished before its connect.
+    for worker in pending:
+        if worker.isFinished():
+            _on_finished(worker)
+
+
 class TearsDownOnClose:
     """Mixin that runs a dialog's teardown on *every* way out, not just close.
 

PyMemoryEditor/app/application.py

@@ -561,6 +561,7 @@ def main(argv=None):
     from PySide6.QtCore import QSettings
     from PySide6.QtWidgets import QApplication
 
+    from ._widgets import detached_workers_running
     from .main_window import MainWindow
     from .open_process_dialog import OpenProcessDialog
 
@@ -591,12 +592,18 @@ def main(argv=None):
         with _scoped_excepthook(_qt_excepthook):
             app.exec()
     finally:
-        try:
-            # `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
+        # A worker that blew its join on close is detached, not stopped, and
+        # may still be inside a syscall on this handle; closing it now could
+        # hand its value to an unrelated object mid-write. The process is
+        # exiting, so leave it to the OS, which releases every handle then.
+        if not detached_workers_running():
+            try:
+                # `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:  # 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

@@ -46,7 +46,7 @@ from PySide6.QtWidgets import (
 from PyMemoryEditor import AbstractProcess, __version__
 
 from ._icon import app_icon
-from ._widgets import detach_worker
+from ._widgets import detach_worker, run_after_detached_workers
 from .application import DEFAULT_THEME_ID, THEMES, apply_theme
 from .cheat_entry import CheatEntry
 from .cheat_table import CheatTable
@@ -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,15 +952,13 @@ class MainWindow(QMainWindow):
         # until GC. shutdown() is idempotent and joins the worker.
         try:
             old_cheat.shutdown()
-        except Exception:
-            pass
-        # Accepted window: a worker that blew its join is detached, not
-        # stopped, so it can still be inside a syscall here. The cheat poller
-        # writes, which is why it checks the stop flag per entry.
-        try:
-            old_process.close()
-        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
+        # value to an unrelated object while the cheat poller is mid-write.
+        run_after_detached_workers(lambda p=old_process: _close_quietly(p))
         old_index = self._right_splitter.indexOf(old_cheat)
         self._cheat = CheatTable(self._process)
         self._cheat.pointer_scan_for_address.connect(self._open_pointer_scan_dialog)
@@ -965,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()
 
@@ -1020,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
@@ -1049,6 +1101,13 @@ class MainWindow(QMainWindow):
             worker.deleteLater()
 
 
+def _close_quietly(process) -> None:
+    try:
+        process.close()
+    except Exception:  # noqa: BLE001 — the target may already be gone
+        _LOG.debug("Closing the previous process handle failed", exc_info=True)
+
+
 def _safe_for_json(value) -> object:
     if value is None or isinstance(value, (str, int, float, bool)):
         return value