PyMemoryEditor 3.0.2__py3-none-any.whl → 3.1.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.1.0"
 
 import logging
 import sys

PyMemoryEditor/app/_widgets.py

@@ -166,45 +166,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 +261,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
@@ -536,7 +588,8 @@ 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

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.

PyMemoryEditor/app/main_window.py

@@ -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
@@ -904,6 +930,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 +973,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.

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: