PyMemoryEditor 3.0.2__py3-none-any.whl → 3.2.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.0.2"
+__version__ = "3.2.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.
 
@@ -166,45 +217,76 @@ class NumericItem(QStandardItem):
             return self.text() < other.text()
 
 
+_HEX_DIGITS = frozenset("0123456789abcdefABCDEF")
+
+
+def _parse_hex_digits(text: str) -> Optional[int]:
+    """``text`` as an unsigned hex number, or None. Accepts a ``0x`` prefix."""
+    cleaned = text.strip()
+    if cleaned[:2].lower() == "0x":
+        cleaned = cleaned[2:]
+    # Explicit digit check rather than relying on int(): int(x, 16) also takes
+    # "1_0" (underscore separators) and leading sign/whitespace, none of which
+    # is a hex address a user meant to type.
+    if not cleaned or not _HEX_DIGITS.issuperset(cleaned):
+        return None
+    return int(cleaned, 16)
+
+
 def parse_hex_address(text: str) -> Optional[int]:
     """Parse a hex address string (with or without 0x prefix) into an int.
 
-    Returns None on any parse error. Whitespace is tolerated.
+    Addresses are unsigned: a leading sign makes the string invalid. Returns
+    None on any parse error. Surrounding whitespace is tolerated.
     """
     if not text:
         return None
-    cleaned = text.strip()
-    if not cleaned:
+    return _parse_hex_digits(text)
+
+
+def parse_hex_offset(text: str) -> Optional[int]:
+    """Parse a hex pointer-chain offset, which unlike an address may be negative.
+
+    ``"-0x10"`` → -16, ``"10"`` → 16. Returns None on any parse error.
+    """
+    if not text:
         return None
-    if cleaned.lower().startswith("0x"):
-        cleaned = cleaned[2:]
-    try:
-        return int(cleaned, 16)
-    except (TypeError, ValueError):
+    cleaned = text.strip()
+    negative = cleaned.startswith("-")
+    if negative or cleaned.startswith("+"):
+        cleaned = cleaned[1:]
+    parsed = _parse_hex_digits(cleaned)
+    if parsed is None:
         return None
+    return -parsed if negative else parsed
+
+
+def format_size(size: int) -> str:
+    """Human-readable byte count (``1536`` → ``"1.5 KB"``), binary units."""
+    units = ["B", "KB", "MB", "GB", "TB"]
+    s = float(size)
+    for unit in units:
+        if s < 1024 or unit == units[-1]:
+            return f"{s:,.1f} {unit}" if unit != "B" else f"{int(s):,} B"
+        s /= 1024
+    return f"{size:,} B"
 
 
 def parse_offsets(texts: Iterable[str]) -> Optional[List[int]]:
     """Parse pointer-chain offset tokens (in order) from raw field strings.
 
     Empty tokens are skipped; every remaining token is read as hex (with or
-    without ``0x``). Returns ``None`` if any non-empty token can't be parsed —
-    the caller treats that as "invalid chain, do nothing". Pure (no Qt) so it
-    can be unit-tested directly.
+    without ``0x``, optionally negative). Returns ``None`` if any non-empty
+    token can't be parsed — the caller treats that as "invalid chain, do
+    nothing". Pure (no Qt) so it can be unit-tested directly.
     """
     offsets: List[int] = []
     for text in texts:
         if not text:
             continue
-        parsed = parse_hex_address(text)
+        parsed = parse_hex_offset(text)
         if parsed is None:
-            # parse_hex_address handles the 0x form; fall back to a plain hex
-            # int for ambiguous tokens like "10" (the dialog treats offsets as
-            # hex throughout).
-            try:
-                parsed = int(text, 16)
-            except ValueError:
-                return None
+            return None
         offsets.append(parsed)
     return offsets
 
@@ -230,13 +312,10 @@ def resolve_base_address(
         module_name = name_part.strip().strip('"').strip("'").strip()
         offset = parse_hex_address(offset_part)
         if offset is None:
-            try:
-                offset = int(offset_part.strip(), 16)
-            except ValueError:
-                return None, (
-                    "The offset after '+' must be hex "
-                    '(e.g. "game.exe"+0x10F4F4).'
-                )
+            return None, (
+                "The offset after '+' must be hex "
+                '(e.g. "game.exe"+0x10F4F4).'
+            )
         module_base = module_lookup(module_name)
         if module_base is None:
             return None, (

PyMemoryEditor/app/application.py

@@ -5,6 +5,7 @@ Entry point for the PyMemoryEditor App.
 A Cheat-Engine-inspired memory scanner built on PySide6 (Qt for Python),
 working on Windows, Linux and macOS.
 """
+import logging
 import sys
 import signal
 import contextlib
@@ -266,11 +267,6 @@ def apply_theme(app, theme_id: str = DEFAULT_THEME_ID) -> None:
     )
 
 
-def apply_dark_theme(app) -> None:
-    """Backward-compatible shim that applies the default dark theme."""
-    apply_theme(app, DEFAULT_THEME_ID)
-
-
 STYLE_SHEET = """
 QToolTip {
     color: %(text)s;
@@ -484,10 +480,66 @@ def _scoped_signal_handler(signalnum, handler):
             signal.signal(signalnum, previous_handler)
 
 
+_LOG = logging.getLogger(__name__)
+
+
+def _qt_excepthook(exc_type, exc_value, exc_tb) -> None:
+    """``sys.excepthook`` for the duration of the Qt event loop.
+
+    PySide6 catches an exception raised inside a slot, hands it to
+    ``sys.excepthook`` and carries on — with the default hook that is a
+    traceback on stderr the user never sees, and the action they clicked
+    silently does nothing. Log it (so the Log Console gets it) and show it.
+    KeyboardInterrupt is left to the interpreter's hook: it is the host's
+    signal, not an app bug.
+    """
+    if issubclass(exc_type, KeyboardInterrupt):
+        sys.__excepthook__(exc_type, exc_value, exc_tb)
+        return
+    _LOG.error(
+        "Unhandled exception in the UI", exc_info=(exc_type, exc_value, exc_tb)
+    )
+    try:
+        from PySide6.QtCore import QThread
+        from PySide6.QtWidgets import QApplication, QMessageBox
+
+        app = QApplication.instance()
+        # Widgets may only be created on the GUI thread. PySide6 routes an
+        # exception escaping a QThread.run() through this same hook, from
+        # that worker thread, so a dialog there would be undefined behaviour.
+        # The log line above is the whole report in that case.
+        if app is None or QThread.currentThread() != app.thread():
+            return
+        QMessageBox.critical(
+            None,
+            "Unexpected error",
+            "%s: %s\n\nThe full traceback is in Tools → Log Console."
+            % (exc_type.__name__, exc_value),
+        )
+    except Exception:  # noqa: BLE001 — a hook must never raise
+        pass
+
+
+@contextlib.contextmanager
+def _scoped_excepthook(hook):
+    """Install ``hook`` as ``sys.excepthook`` for the block, then restore."""
+    previous = sys.excepthook
+    sys.excepthook = hook
+    try:
+        yield
+    finally:
+        sys.excepthook = previous
+
+
 def main(argv=None):
     """
     Run the app. Safe to call in-process: it installs no signal handler.
 
+    While the event loop runs, ``sys.excepthook`` is swapped for one that logs
+    and shows slot exceptions (PySide6 routes them there and continues), and
+    restored on the way out — the loop owns the thread for that time, so an
+    embedder's own hook is not observable from inside it anyway.
+
     ``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
@@ -509,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
 
@@ -536,14 +589,21 @@ def main(argv=None):
     window = MainWindow(process)
     window.show()
     try:
-        app.exec()
+        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:
+                pass
 
 
 def main_cli(argv=None):

PyMemoryEditor/app/cheat_table.py

@@ -56,11 +56,6 @@ from .value_types import (
 )
 
 
-# Re-exported for backward compatibility with callers that imported the
-# poll-interval constant from this module before the split.
-_TICK_INTERVAL_MS = TICK_INTERVAL_MS
-
-
 class CheatTable(QWidget):
     """Bottom pane: saved addresses, freezing, manual edits."""
 
@@ -80,6 +75,14 @@ class CheatTable(QWidget):
         self._suspend_signals = False
         # Before _build_ui(), which connects cellChanged — a path that reads it.
         self._poller_stopped = False
+        # Set while the owner knows the target is gone (see set_polling_paused):
+        # the poller idles on an empty snapshot and edits are refused instead
+        # of being queued against a dead handle.
+        self._paused = False
+        # Write failures reported by the poller since the last flush. They are
+        # shown in one dialog per event-loop burst, so a bulk edit whose every
+        # row fails (target exited) produces one message, not one per row.
+        self._pending_write_failures: List[Tuple[int, str]] = []
 
         self._build_ui()
 
@@ -130,6 +133,31 @@ class CheatTable(QWidget):
         self.shutdown()
         super().closeEvent(event)
 
+    def set_polling_paused(self, paused: bool) -> None:
+        """Idle the poll loop while the target is known to be gone.
+
+        The owning window's heartbeat calls this when the process exits. The
+        publish timer stops and the worker is handed an empty snapshot, so it
+        sleeps through its ticks instead of hitting a dead handle ten times a
+        second (and, on a recycled PID, a stranger's memory). Entries are kept:
+        the table still shows the last values read. Resuming re-publishes.
+        """
+        if self._poller_stopped or paused == self._paused:
+            return
+        self._paused = paused
+        if paused:
+            self._publish_timer.stop()
+            self._poller.update_snapshot([])
+        else:
+            self._publish_snapshot_to_worker()
+            self._publish_timer.start()
+
+    def is_polling_paused(self) -> bool:
+        return self._paused
+
+    def entry_count(self) -> int:
+        return len(self._entries)
+
     def _build_ui(self) -> None:
         layout = QVBoxLayout(self)
         # Small top inset so the toolbar buttons don't sit flush against the
@@ -208,8 +236,17 @@ class CheatTable(QWidget):
         # 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.)
-        entry.length = max(1, int(entry.length))
+        # 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)
 
         # If the address already exists, just refresh its description/type.
         for existing in self._entries:
@@ -236,7 +273,16 @@ class CheatTable(QWidget):
         length: int,
         description: str = "",
     ) -> None:
-        """Convenience used by the scanner panel to bulk-promote rows."""
+        """Convenience used by the scanner panel to bulk-promote rows.
+
+        :raises ValueError: if ``length`` is over ``MAX_ENTRY_LENGTH`` -- checked
+            once up front so a refusal adds none of the rows rather than some.
+        """
+        if int(length) > MAX_ENTRY_LENGTH:
+            raise ValueError(
+                "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(
                 CheatEntry(
@@ -356,8 +402,9 @@ class CheatTable(QWidget):
             # next poll tick reads the value back and corrects the cell if the
             # write didn't take, and an outright failure returns via
             # write_failed → _on_write_failed.
-            # Nothing to route it to once shutdown() handed the worker over.
-            if self._poller_stopped:
+            # 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:
                 return
             self._poller.request_write(
                 entry.address, entry.spec.pytype, entry.length, value
@@ -469,13 +516,33 @@ class CheatTable(QWidget):
     def _on_write_failed(self, failure) -> None:
         """Surface a manual value write that failed on the worker thread.
 
-        The write is now async (queued onto the poll worker), so its failure
-        arrives here via the ``write_failed`` signal rather than inline. The
-        optimistic cell update made when the edit was queued is corrected by the
-        next poll tick, which reads back the unchanged value.
+        Writes are async (queued onto the poll worker), so a failure arrives
+        here via the ``write_failed`` signal rather than inline. The optimistic
+        cell update made when the edit was queued is corrected by the next poll
+        tick, which reads back the unchanged value.
+
+        Failures are collected and shown by ``_flush_write_failures`` on the
+        next event-loop pass: the worker drains a bulk edit's queue in one
+        tick, so its failures land here back to back and read as one report.
         """
-        _address, _pytype, _length, message = failure
-        QMessageBox.critical(self, "Write Failed", message)
+        address, _pytype, _length, message = failure
+        if not self._pending_write_failures:
+            QTimer.singleShot(0, self._flush_write_failures)
+        self._pending_write_failures.append((address, message))
+
+    def _flush_write_failures(self) -> None:
+        failures = self._pending_write_failures
+        self._pending_write_failures = []
+        if not failures:
+            return
+        if len(failures) == 1:
+            QMessageBox.critical(self, "Write Failed", failures[0][1])
+            return
+        preview = "\n".join(f"0x{addr:X}: {msg}" for addr, msg in failures[:10])
+        extra = "" if len(failures) <= 10 else f"\n…and {len(failures) - 10} more."
+        QMessageBox.critical(
+            self, "Write Failed", f"{len(failures)} write(s) failed:\n\n{preview}{extra}"
+        )
 
     def _editing_row(self) -> int:
         """Return the row currently being edited, or -1 if none."""
@@ -603,15 +670,20 @@ class CheatTable(QWidget):
                     if spec.accepts_length_override:
                         entry.length = effective_length
 
-                    try:
-                        self._process.write_process_memory(
-                            entry.address, spec.pytype, entry.length, value
-                        )
-                    except Exception as exc:  # noqa: BLE001
+                    # Same path as an inline edit: the syscall runs on the poll
+                    # worker, never on the UI thread (a slow target or a page
+                    # fault would freeze the interface for every row). A write
+                    # that fails comes back via write_failed → one coalesced
+                    # dialog; the optimistic update below is corrected by the
+                    # next tick's read-back.
+                    if self._poller_stopped or self._paused:
                         failures.append(
-                            (entry.address, f"{type(exc).__name__}: {exc}")
+                            (entry.address, "the target process is no longer available")
                         )
                         continue
+                    self._poller.request_write(
+                        entry.address, spec.pytype, entry.length, value
+                    )
 
                     entry.last_value = value
                     if entry.frozen:
@@ -873,7 +945,7 @@ def prompt_for_manual_entry(parent) -> Optional[CheatEntry]:
             "Buffer length (bytes):",
             value=spec.length or 4,
             minValue=1,
-            maxValue=1024,
+            maxValue=MAX_ENTRY_LENGTH,
         )
         if not ok:
             return None

PyMemoryEditor/app/log_console_dialog.py

@@ -31,7 +31,7 @@ from PySide6.QtWidgets import (
     QVBoxLayout,
 )
 
-from ._widgets import TearsDownOnClose
+from ._widgets import MONOSPACE_FAMILY, TearsDownOnClose
 
 
 _LOGGER_NAME = "PyMemoryEditor"
@@ -146,7 +146,7 @@ class LogConsoleDialog(TearsDownOnClose, QDialog):
 
         self._console = QPlainTextEdit()
         self._console.setReadOnly(True)
-        self._console.setFont(QFont("Menlo, Consolas, Courier New", 10))
+        self._console.setFont(QFont(MONOSPACE_FAMILY, 10))
         self._console.setLineWrapMode(QPlainTextEdit.NoWrap)
         # Cap the buffer so a long-running auto-scan doesn't grow the dialog
         # memory unboundedly. ~5000 lines is plenty for live debugging.