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

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
@@ -78,11 +78,19 @@ class MainWindow(QMainWindow):
 
     closing = Signal()
 
+    # Ask before closing a window whose cheat table has entries. Tests that
+    # build and tear down windows set this to False on the class.
+    confirm_close_with_entries = True
+
     def __init__(self, process: AbstractProcess):
         super().__init__()
         self._process = process
         self._worker: Optional[Union[FirstScanWorker, RefineScanWorker]] = None
         self._region_snapshot: Optional[list] = None
+        # Set by the heartbeat once the target is gone. Everything that would
+        # re-enable the scanner (a worker finishing, in particular) checks it,
+        # so the lock _check_process_alive takes holds until Change Process.
+        self._target_dead = False
         self._memory_map: Optional[MemoryMapDialog] = None
         self._hex_viewers: List[MemoryViewerDialog] = []
 
@@ -242,12 +250,14 @@ class MainWindow(QMainWindow):
 
         tools_menu = menu_bar.addMenu("&Tools")
         memory_map_action = QAction("Memory Map…", self)
-        memory_map_action.setShortcut(QKeySequence("Ctrl+M"))
+        # Not Ctrl+M / Ctrl+H: Qt maps Ctrl to Cmd on macOS, where those are
+        # the system-wide Minimize and Hide shortcuts.
+        memory_map_action.setShortcut(QKeySequence("Ctrl+R"))
         memory_map_action.triggered.connect(self._open_memory_map)
         tools_menu.addAction(memory_map_action)
 
         hex_viewer_action = QAction("Hex Viewer…", self)
-        hex_viewer_action.setShortcut(QKeySequence("Ctrl+H"))
+        hex_viewer_action.setShortcut(QKeySequence("Ctrl+Shift+H"))
         hex_viewer_action.triggered.connect(lambda: self._open_hex_viewer(0))
         tools_menu.addAction(hex_viewer_action)
 
@@ -520,7 +530,11 @@ class MainWindow(QMainWindow):
 
     def _cleanup_worker(self) -> None:
         self._worker = None
-        self._set_busy(False)
+        # 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.
+        if not self._target_dead:
+            self._set_busy(False)
 
     def _set_busy(self, busy: bool) -> None:
         self._scanner.set_busy(busy)
@@ -529,7 +543,13 @@ class MainWindow(QMainWindow):
         if not addresses:
             return
         spec, length = self._scanner.current_spec_and_length()
-        self._cheat.add_addresses(addresses, spec, length, description="")
+        try:
+            self._cheat.add_addresses(addresses, spec, length, description="")
+        except ValueError as exc:
+            # The scanner's width field allows more than the cheat table's
+            # MAX_ENTRY_LENGTH; add_entry refuses such a width.
+            QMessageBox.warning(self, "Cheat Table", str(exc))
+            return
         self._status.showMessage(f"Added {len(addresses)} address(es) to cheat table.")
 
     def _open_memory_map(self) -> None:
@@ -609,15 +629,25 @@ class MainWindow(QMainWindow):
         self, address: int, spec_label: str, length: int
     ) -> None:
         """Promote a resolved pointer-chain address into the cheat table."""
+        self._promote_resolved_address(address, spec_label, length, "pointer chain")
+
+    def _promote_resolved_address(
+        self, address: int, spec_label: str, length: int, source: str
+    ) -> None:
+        """Add an address resolved by a pointer tool to the cheat table."""
         entry = CheatEntry(
             description="",
             address=int(address),
             spec_label=spec_label,
             length=int(length),
         )
-        self._cheat.add_entry(entry)
+        try:
+            self._cheat.add_entry(entry)
+        except ValueError as exc:
+            QMessageBox.warning(self, "Cheat Table", str(exc))
+            return
         self._status.showMessage(
-            f"Added 0x{address:X} to cheat table (from pointer chain)."
+            f"Added 0x{address:X} to cheat table (from {source})."
         )
 
     def _open_pointer_scan_dialog(self, address: int = 0) -> None:
@@ -651,16 +681,7 @@ class MainWindow(QMainWindow):
         self, address: int, spec_label: str, length: int
     ) -> None:
         """Promote a resolved pointer-scan path's address into the cheat table."""
-        entry = CheatEntry(
-            description="",
-            address=int(address),
-            spec_label=spec_label,
-            length=int(length),
-        )
-        self._cheat.add_entry(entry)
-        self._status.showMessage(
-            f"Added 0x{address:X} to cheat table (from pointer scan)."
-        )
+        self._promote_resolved_address(address, spec_label, length, "pointer scan")
 
     def _open_log_console(self) -> None:
         if self._log_console_dialog is None:
@@ -809,7 +830,11 @@ class MainWindow(QMainWindow):
     def _check_process_alive(self) -> None:
         if not self._target_is_alive():
             self._heartbeat.stop()
+            self._target_dead = True
             self._scanner.set_busy(True)
+            # The cheat poller would otherwise keep reading (and, for frozen
+            # rows, writing) the dead handle ten times a second.
+            self._cheat.set_polling_paused(True)
             self._status.showMessage("Target process exited — operations disabled.")
             QMessageBox.warning(
                 self,
@@ -845,6 +870,7 @@ class MainWindow(QMainWindow):
         # If the previous target exited, _check_process_alive locked the scanner
         # via set_busy(True). Switching to a live process must release that lock,
         # otherwise the scan controls stay disabled against the new target.
+        self._target_dead = False
         self._scanner.set_busy(False)
 
         # Tear down auxiliary dialogs that hold a reference to the old
@@ -884,13 +910,11 @@ class MainWindow(QMainWindow):
             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
+        # 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)
@@ -904,6 +928,10 @@ class MainWindow(QMainWindow):
         self._status.showMessage(f"Now targeting PID {self._process.pid}.")
 
     def closeEvent(self, event: QCloseEvent) -> None:
+        if not self._confirm_discard_cheat_table():
+            event.ignore()
+            return
+
         # Stop the heartbeat *first*: _shutdown_worker pumps the event loop
         # below, and a heartbeat firing during that pump could pop a modal
         # dialog mid-teardown.
@@ -943,6 +971,26 @@ class MainWindow(QMainWindow):
         self.closing.emit()
         super().closeEvent(event)
 
+    def _confirm_discard_cheat_table(self) -> bool:
+        """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.
+        """
+        count = self._cheat.entry_count()
+        if count == 0 or not self.confirm_close_with_entries:
+            return True
+        answer = QMessageBox.question(
+            self,
+            "Quit",
+            f"The cheat table has {count} entr{'y' if count == 1 else 'ies'} "
+            "that will be lost (use Export… to keep them).\n\nQuit anyway?",
+            QMessageBox.StandardButton.Discard | QMessageBox.StandardButton.Cancel,
+            QMessageBox.StandardButton.Cancel,
+        )
+        return answer == QMessageBox.StandardButton.Discard
+
     def _shutdown_worker(self) -> None:
         """
         Stop the active scan worker safely.
@@ -999,6 +1047,13 @@ class MainWindow(QMainWindow):
             worker.deleteLater()
 
 
+def _close_quietly(process) -> None:
+    try:
+        process.close()
+    except Exception:  # noqa: BLE001 — the target may already be gone
+        pass
+
+
 def _safe_for_json(value) -> object:
     if value is None or isinstance(value, (str, int, float, bool)):
         return value

PyMemoryEditor/app/memory_map_dialog.py

@@ -37,17 +37,7 @@ from PySide6.QtWidgets import (
 from PyMemoryEditor import AbstractProcess, MemoryRegion, MemoryRegionSnapshot
 
 from ._auto_refresh_dialog import AutoRefreshTableDialog
-from ._widgets import MONOSPACE_FAMILY, NumericItem
-
-
-def _format_size(size: int) -> str:
-    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"
+from ._widgets import MONOSPACE_FAMILY, NumericItem, format_size
 
 
 # Unit multipliers for the allocate size selector (binary, 1 KB = 1024 B).
@@ -396,7 +386,7 @@ class MemoryMapDialog(AutoRefreshTableDialog):
             addr_item.setFont(mono_font)
             addr_item.setData(addr, Qt.UserRole)
 
-            size_item = NumericItem(_format_size(size))
+            size_item = NumericItem(format_size(size))
             size_item.setData(size, Qt.UserRole)
             size_item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
 
@@ -416,12 +406,12 @@ class MemoryMapDialog(AutoRefreshTableDialog):
         if needle:
             count_text = (
                 f"{shown:,} of {total:,} regions shown · "
-                f"{_format_size(total_bytes)} mapped"
+                f"{format_size(total_bytes)} mapped"
             )
         else:
             count_text = (
                 f"{total:,} regions · "
-                f"{_format_size(total_bytes)} of virtual address space mapped"
+                f"{format_size(total_bytes)} of virtual address space mapped"
             )
         # A filter keystroke rebuilds this line long after the poll gave up.
         if self._polling_gave_up:

PyMemoryEditor/app/memory_viewer_dialog.py

@@ -25,7 +25,12 @@ from PySide6.QtWidgets import (
 from PyMemoryEditor import AbstractProcess
 
 from ._auto_refresh_dialog import _FAILURE_GRACE_MS, _DataWorker
-from ._widgets import TearsDownOnClose, parse_hex_address, shutdown_worker_thread
+from ._widgets import (
+    MONOSPACE_FAMILY,
+    TearsDownOnClose,
+    parse_hex_address,
+    shutdown_worker_thread,
+)
 
 
 # Child of the "PyMemoryEditor" logger, so the Log Console (which attaches a
@@ -125,7 +130,7 @@ class MemoryViewerDialog(TearsDownOnClose, QDialog):
 
         self._dump = QPlainTextEdit()
         self._dump.setReadOnly(True)
-        self._dump.setFont(QFont("Menlo, Consolas, Courier New", 11))
+        self._dump.setFont(QFont(MONOSPACE_FAMILY, 11))
         self._dump.setLineWrapMode(QPlainTextEdit.NoWrap)
         layout.addWidget(self._dump, 1)
 
@@ -135,7 +140,7 @@ class MemoryViewerDialog(TearsDownOnClose, QDialog):
         )
         self._write_edit = QLineEdit()
         self._write_edit.setPlaceholderText("e.g. DE AD BE EF")
-        self._write_edit.setFont(QFont("Menlo, Consolas, Courier New", 11))
+        self._write_edit.setFont(QFont(MONOSPACE_FAMILY, 11))
         edit_row.addWidget(self._write_edit, 1)
         layout.addLayout(edit_row)
 
@@ -157,15 +162,10 @@ class MemoryViewerDialog(TearsDownOnClose, QDialog):
         text = self._addr_edit.text().strip()
         if not text:
             return None
-        # Try hex first (with or without `0x`); fall back to decimal so callers
-        # that paste a plain integer still work.
-        addr = parse_hex_address(text)
-        if addr is not None:
-            return addr
-        try:
-            return int(text)
-        except (TypeError, ValueError):
-            return None
+        # Hex, with or without `0x` — the field is hex throughout, like every
+        # other address field in the app. (A decimal fallback here could never
+        # run: every decimal string is also a valid hex string.)
+        return parse_hex_address(text)
 
     def refresh(self) -> None:
         # Skip if a read is still running. The auto-refresh timer fires this
@@ -273,9 +273,8 @@ class MemoryViewerDialog(TearsDownOnClose, QDialog):
 
     def _sync_timer(self) -> None:
         self._timer.setInterval(int(self._interval_spin.value()))
-        if self._auto_btn.isChecked() and not self._timer.isActive():
-            self._timer.start()
-        elif self._auto_btn.isChecked():
+        # start() on a running QTimer restarts it at the new interval.
+        if self._auto_btn.isChecked():
             self._timer.start()
 
     def _write_bytes(self) -> None:

PyMemoryEditor/app/modules_dialog.py

@@ -38,8 +38,7 @@ from PySide6.QtWidgets import (
 from PyMemoryEditor import AbstractProcess, ModuleInfo
 
 from ._auto_refresh_dialog import AutoRefreshTableDialog
-from ._widgets import MONOSPACE_FAMILY, NumericItem
-from .memory_map_dialog import _format_size
+from ._widgets import MONOSPACE_FAMILY, NumericItem, format_size
 
 
 class ModulesDialog(AutoRefreshTableDialog):
@@ -173,7 +172,7 @@ class ModulesDialog(AutoRefreshTableDialog):
             base_item.setData(base, Qt.UserRole)
 
             size = int(module.size)
-            size_item = NumericItem(_format_size(size))
+            size_item = NumericItem(format_size(size))
             size_item.setData(size, Qt.UserRole)
             size_item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
 

PyMemoryEditor/app/open_process_dialog.py

@@ -40,7 +40,7 @@ from PyMemoryEditor import (
 )
 
 from ._icon import app_icon
-from ._widgets import NumericItem, TearsDownOnClose, shutdown_worker_thread
+from ._widgets import NumericItem, TearsDownOnClose, format_size, shutdown_worker_thread
 
 
 if sys.platform == "win32":
@@ -88,18 +88,6 @@ def _open_kwargs():
     return {"permission": _APP_PERMISSION} if _APP_PERMISSION is not None else {}
 
 
-def _human_kb(size_bytes: int) -> str:
-    if size_bytes < 1024:
-        return f"{size_bytes} B"
-    units = ["KB", "MB", "GB", "TB"]
-    n = float(size_bytes)
-    for unit in units:
-        n /= 1024
-        if n < 1024:
-            return f"{n:,.1f} {unit}"
-    return f"{n:,.1f} PB"
-
-
 # How long the auto-refresh waits between process-list re-enumerations.
 _REFRESH_INTERVAL_MS = 3000
 
@@ -314,7 +302,7 @@ class OpenProcessDialog(TearsDownOnClose, QDialog):
             name_item = QStandardItem(name)
             name_item.setData(pid, Qt.UserRole)
 
-            mem_item = NumericItem(_human_kb(mem) if mem else "—")
+            mem_item = NumericItem(format_size(mem) if mem else "—")
             mem_item.setData(mem, Qt.UserRole)
             mem_item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
 

PyMemoryEditor/app/pointer_chain_dialog.py

@@ -46,7 +46,12 @@ from PySide6.QtWidgets import (
 
 from PyMemoryEditor import AbstractProcess
 
-from ._widgets import parse_hex_address, parse_offsets, resolve_base_address
+from ._widgets import (
+    MONOSPACE_FAMILY,
+    parse_hex_offset,
+    parse_offsets,
+    resolve_base_address,
+)
 from .value_types import (
     VALUE_TYPES,
     ValueTypeSpec,
@@ -84,7 +89,7 @@ class _OffsetField(QWidget):
         self.edit = QLineEdit()
         self.edit.setPlaceholderText("0")
         self.edit.setFixedWidth(80)
-        self.edit.setFont(QFont("Menlo, Consolas, Courier New", 10))
+        self.edit.setFont(QFont(MONOSPACE_FAMILY, 10))
         layout.addWidget(self.edit)
 
         suffix = QLabel("]")
@@ -159,7 +164,7 @@ class PointerChainDialog(QDialog):
         self._module_offset_edit.setPlaceholderText(
             "optional — added to base (e.g. 0x4A0C68 from a pointer-scan path)"
         )
-        self._module_offset_edit.setFont(QFont("Menlo, Consolas, Courier New", 10))
+        self._module_offset_edit.setFont(QFont(MONOSPACE_FAMILY, 10))
         form.addRow("Module offset:", self._module_offset_edit)
 
         # Offsets row — a chain of "[+ hex ]" slots with a
@@ -277,14 +282,14 @@ class PointerChainDialog(QDialog):
 
         self._output_label = QLabel("Resolved address: —")
         self._output_label.setObjectName("hint")
-        self._output_label.setFont(QFont("Menlo, Consolas, Courier New", 11))
+        self._output_label.setFont(QFont(MONOSPACE_FAMILY, 11))
         self._output_label.setTextInteractionFlags(
             Qt.TextInteractionFlag.TextSelectableByMouse
         )
         layout.addWidget(self._output_label)
 
         self._value_label = QLabel("Value: —")
-        self._value_label.setFont(QFont("Menlo, Consolas, Courier New", 11))
+        self._value_label.setFont(QFont(MONOSPACE_FAMILY, 11))
         self._value_label.setTextInteractionFlags(
             Qt.TextInteractionFlag.TextSelectableByMouse
         )
@@ -396,18 +401,15 @@ class PointerChainDialog(QDialog):
         # dereference (it locates the static slot — it is NOT a chain offset).
         module_offset_text = self._module_offset_edit.text().strip()
         if module_offset_text:
-            module_offset = parse_hex_address(module_offset_text)
+            module_offset = parse_hex_offset(module_offset_text)
             if module_offset is None:
-                try:
-                    module_offset = int(module_offset_text, 16)
-                except ValueError:
-                    QMessageBox.warning(
-                        self,
-                        "Resolve",
-                        "Module offset must be hex (e.g. 0x4A0C68). Leave it "
-                        "empty if your base address already includes it.",
-                    )
-                    return
+                QMessageBox.warning(
+                    self,
+                    "Resolve",
+                    "Module offset must be hex (e.g. 0x4A0C68). Leave it "
+                    "empty if your base address already includes it.",
+                )
+                return
             base += module_offset
 
         offsets = self._read_offsets()

PyMemoryEditor/app/pointer_scan_dialog.py

@@ -50,7 +50,10 @@ from PySide6.QtWidgets import (
 )
 
 from PyMemoryEditor import AbstractProcess, PointerPath
-from PyMemoryEditor.process.pointer_scan import intersect_pointer_paths
+from PyMemoryEditor.process.pointer_scan import (
+    first_module_bases,
+    intersect_pointer_paths,
+)
 
 from ._widgets import (
     MONOSPACE_FAMILY,
@@ -141,6 +144,9 @@ class PointerScanWorker(QThread):
                 writable_only=req.writable_only,
                 max_results=req.max_results,
                 progress_callback=self._on_map_progress,
+                # The walk can run a long time between two paths; this lets
+                # Stop end it there too, not only at the next yield.
+                should_stop=lambda: self._cancelled,
             )
 
             batch: List[_ResultRow] = []
@@ -246,7 +252,7 @@ class PointerRescanWorker(QThread):
     def run(self) -> None:
         try:
             # One name→base lookup so rebasing each saved path is O(1).
-            module_bases = {m.name: m.base_address for m in self._process.get_modules()}
+            module_bases = first_module_bases(self._process.get_modules())
 
             batch: List[_ResultRow] = []
             total = len(self._paths) or 1
@@ -284,16 +290,8 @@ class PointerRescanWorker(QThread):
     def _rebase(self, saved: PointerPath, module_bases: dict) -> Optional[PointerPath]:
         """Move a saved path onto the live module base, or None if not rebasable."""
         if saved.module is not None and saved.module_offset is not None:
-            base = module_bases.get(saved.module)
-            if base is None:
-                return None  # module not loaded in this run — drop the path
-            return PointerPath(
-                base_address=base + saved.module_offset,
-                offsets=saved.offsets,
-                module=saved.module,
-                module_offset=saved.module_offset,
-                ptr_size=saved.ptr_size,
-            )
+            # None when the module isn't loaded in this run — drop the path.
+            return saved._rebased_onto(module_bases)
         # No module: the absolute base is only a best-effort guess post-restart.
         return saved
 
@@ -979,23 +977,23 @@ class PointerScanDialog(TearsDownOnClose, QDialog):
         # For display, rebase each survivor onto the current process and read its
         # value — best effort; a path that can't resolve now is still a valid
         # member of the intersection and is kept (shown dimmed / "—").
-        module_bases = {m.name: m.base_address for m in self._process.get_modules()}
+        unavailable = ""
+        try:
+            module_bases = first_module_bases(self._process.get_modules())
+        except Exception as exc:  # noqa: BLE001 — display only; the target may be gone
+            # Without the module list every survivor is shown unresolved ("—"),
+            # which is what the per-path guard below does for a single one —
+            # but say why, or a table of dimmed rows reads as "nothing works".
+            module_bases = {}
+            unavailable = (
+                f" Values not shown: the target's modules could not be listed "
+                f"({type(exc).__name__}: {exc})."
+            )
         spec, length = self._current_spec()
 
         rows: List[_ResultRow] = []
         for saved in survivors:
-            base = module_bases.get(saved.module)
-            live = (
-                PointerPath(
-                    base_address=base + saved.module_offset,
-                    offsets=saved.offsets,
-                    module=saved.module,
-                    module_offset=saved.module_offset,
-                    ptr_size=saved.ptr_size,
-                )
-                if base is not None and saved.module_offset is not None
-                else saved
-            )
+            live = saved._rebased_onto(module_bases) or saved
             try:
                 resolved = live.resolve(self._process)
                 value = self._process.read_process_memory(resolved, spec.pytype, length)
@@ -1008,6 +1006,7 @@ class PointerScanDialog(TearsDownOnClose, QDialog):
         self._append_rows(rows)
         self._count_label.setText(
             f"{len(survivors):,} path(s) common to {len(filenames)} scans."
+            + unavailable
         )
         self._export_btn.setEnabled(True)