PyMemoryEditor 3.3.0__py3-none-any.whl → 3.3.2__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.3.0"
+__version__ = "3.3.2"
 
 import logging
 import sys

PyMemoryEditor/app/_auto_refresh_dialog.py

@@ -3,13 +3,12 @@
 Shared base for the read-only, auto-refreshing table dialogs (Memory Map,
 Modules, Threads).
 
-All three did the same dance — run a one-shot read off the UI thread, repopulate
+All three do the same dance — run a one-shot read off the UI thread, repopulate
 a sortable table when it returns, poll on a timer, and tear the worker down
-safely on close — each with its own near-identical ``_*Worker(QThread)`` and
-lifecycle boilerplate. That triplicated the fiddly bits (the in-flight guard
-that self-throttles the poll, the detach-on-shutdown safety) where a fix to one
-copy wouldn't reach the others. This owns the lifecycle once; subclasses provide
-only what differs: how to fetch the data, and how to render it.
+safely on close. This owns that lifecycle once, so the fiddly bits (the
+in-flight guard that self-throttles the poll, the detach-on-shutdown safety)
+live in one place; subclasses provide only what differs: how to fetch the
+data, and how to render it.
 
 It also owns *when* a failure is worth interrupting the user — see
 :meth:`AutoRefreshTableDialog._handle_failed`.
@@ -182,7 +181,7 @@ class AutoRefreshTableDialog(TearsDownOnClose, QDialog):
         Process) *every* tick fails, and ``_on_data_failed`` pops a **modal**
         dialog. A modal runs a nested event loop, so the timer fires again while
         it is up and the failures stack — hundreds of focus-stealing dialogs the
-        user could only escape by killing the app from another TTY (issue #74).
+        user could only escape by killing the app from another TTY.
 
         Reporting is therefore tied to the two moments where a failure changes
         what the user sees: the **first** fetch (empty window) and the one that

PyMemoryEditor/app/_widgets.py

@@ -2,8 +2,8 @@
 
 """Small Qt widgets shared between dialogs.
 
-Centralises tiny helpers (numeric sort items, hex address parsing) that
-previously appeared duplicated across several dialog modules.
+Centralises tiny helpers (numeric sort items, hex address parsing) shared by
+several dialog modules.
 """
 
 import threading
@@ -46,9 +46,9 @@ def shutdown_worker_thread(worker: Optional[QThread], wait_ms: int = 2000) -> No
         cancel()
     try:
         # The four-argument static form on purpose: bare `worker.disconnect()`
-        # raises TypeError in PySide6 (so this except swallowed it and nothing
-        # was disconnected), and `worker.disconnect(worker)` only drops
-        # connections whose *receiver* is the worker — ours belong to the dialog.
+        # raises TypeError in PySide6, and `worker.disconnect(worker)` only
+        # drops connections whose *receiver* is the worker — ours belong to the
+        # dialog.
         QObject.disconnect(worker, None, None, None)
     except (RuntimeError, TypeError):
         pass
@@ -141,8 +141,8 @@ class TearsDownOnClose:
     ``QDialog`` delivers a ``QCloseEvent`` only for a real close. The app's own
     "Close" buttons call ``accept()`` and Esc reaches ``reject()``; both land in
     ``done()``, which hides the dialog and emits ``finished`` *without* any
-    close event — so a teardown living in ``closeEvent`` never ran, and the
-    dialog kept polling, hidden and unreachable.
+    close event — so a teardown living in ``closeEvent`` would never run, and
+    the dialog would keep polling, hidden and unreachable.
 
     Subclasses implement :meth:`_teardown`; the mixin runs it exactly once,
     whichever way the dialog is dismissed, and must precede ``QDialog`` in the

PyMemoryEditor/app/application.py

@@ -542,8 +542,7 @@ def main(argv=None):
 
     ``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
-    ignored, which made the parameter meaningless.
+    an explicit list.
 
     Terminal users want Ctrl+C to kill the app, which takes a process-wide
     signal change — see :func:`main_cli`, the console-script entry point.
@@ -611,9 +610,9 @@ def main_cli(argv=None):
     Entry point for the ``pymemoryeditor`` console script and ``python -m``.
 
     Qt's event loop blocks inside C++, so Python's default SIGINT handler only
-    runs once the interpreter next regains control. In practice it raised
+    runs once the interpreter next regains control. In practice it raises
     KeyboardInterrupt inside our own _PointerCursorFilter.eventFilter override,
-    where PySide6 swallows it and merely prints a traceback (#76). Hand SIGINT
+    where PySide6 swallows it and merely prints a traceback. Hand SIGINT
     back to the OS for the duration of the run so Ctrl+C from a terminal
     terminates the app immediately.
 

PyMemoryEditor/app/cheat_poll_worker.py

@@ -56,8 +56,8 @@ class _CheatPollWorker(QThread):
     with the current ``{key: "ErrorType: message"}`` map. The signal fires only
     when that set *changes* (a freeze starts or stops failing), so the UI gets a
     persistent cue without 10 Hz spam, and the first failure of each entry is
-    logged once. Previously the exception was swallowed silently, so a freeze
-    that never landed looked identical to one that did.
+    logged once. Swallowing the exception instead would make a freeze that
+    never landed look identical to one that did.
     """
 
     values_ready = Signal(object)  # list[tuple[int, type, int, Any]]
@@ -96,9 +96,9 @@ class _CheatPollWorker(QThread):
     ) -> None:
         """Queue a one-shot manual write to be performed on the worker thread.
 
-        The cheat table's inline value edits used to call
-        ``write_process_memory`` directly on the UI thread, freezing the UI when
-        the target was slow or the page faulted. Routing them here keeps the
+        The cheat table's inline value edits come through here: calling
+        ``write_process_memory`` directly on the UI thread would freeze the UI
+        when the target is slow or the page faults. Routing them here keeps the
         syscall off the UI thread; a write that fails comes back via the
         ``write_failed`` signal. Latency is at most one tick (~100 ms), which is
         imperceptible for a manual edit.

PyMemoryEditor/app/cheat_table.py

@@ -12,8 +12,8 @@ stays fresh.
 This module hosts only the Qt widget; the dataclass and the worker thread
 live in ``cheat_entry.py`` and ``cheat_poll_worker.py`` respectively. The
 ``CheatEntry`` and ``_CheatPollWorker`` names are re-exported from here for
-backward compatibility with code (and tests) that imported them from this
-module before the split.
+backward compatibility with code (and tests) that import them from this
+module.
 """
 import copy
 import json
@@ -95,8 +95,8 @@ class CheatTable(QWidget):
         self._poller.start()
 
         # A short cadence to push fresh entry snapshots into the worker. This
-        # is far cheaper than the previous QTimer that did real syscalls — it
-        # only copies a small list of tuples.
+        # is cheap — it does no syscalls, it only copies a small list of
+        # tuples.
         self._publish_timer = QTimer(self)
         self._publish_timer.setInterval(TICK_INTERVAL_MS)
         self._publish_timer.timeout.connect(self._publish_snapshot_to_worker)
@@ -221,8 +221,8 @@ class CheatTable(QWidget):
         self._table.customContextMenuRequested.connect(self._show_context_menu)
         layout.addWidget(self._table, 1)
 
-        # Delete removes the selected rows — the standard gesture, previously
-        # only reachable through the context menu. Scoped to the table widget
+        # Delete removes the selected rows — the standard gesture, alongside
+        # the context menu. Scoped to the table widget
         # (WidgetShortcut) so Delete still edits text while a cell is in
         # inline-edit mode (the editor child, not the table, has focus then).
         delete_shortcut = QShortcut(QKeySequence(QKeySequence.Delete), self._table)
@@ -247,8 +247,9 @@ class CheatTable(QWidget):
         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.
+        rebuild in total: one ``add_entry`` per row would do 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.
@@ -261,7 +262,7 @@ class CheatTable(QWidget):
                     % (entry.address, length, MAX_ENTRY_LENGTH)
                 )
 
-        # First entry per address, as the linear scan used to find.
+        # First entry per address wins, should the table hold duplicates.
         by_address: Dict[int, CheatEntry] = {}
         for existing in self._entries:
             by_address.setdefault(existing.address, existing)
@@ -347,8 +348,8 @@ class CheatTable(QWidget):
         type_label = entry.spec_label
         # Show the width whenever it belongs to the entry rather than to the
         # spec. An IDA pattern declares none (length 0) yet carries a real one
-        # here — writes are refused against it — so hiding it left the user
-        # told to "widen the entry" with no way to see what it holds.
+        # here — writes are refused against it — so hiding it would leave the
+        # user told to "widen the entry" with no way to see what it holds.
         if entry.spec.accepts_length_override or not entry.spec.length:
             type_label += f"  · {entry.length}B"
         type_item = QTableWidgetItem(type_label)
@@ -428,8 +429,8 @@ class CheatTable(QWidget):
             # 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.
+                # returning quietly would leave 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
@@ -525,7 +526,8 @@ class CheatTable(QWidget):
         against it here is cheap and keeps the cue in sync: a red value cell plus
         an explanatory tooltip while a freeze keeps failing, restored to normal
         the moment the write lands again. Without this, a frozen value that the
-        backend silently refuses to write looked identical to one that worked.
+        backend silently refuses to write would look identical to one that
+        worked.
         """
         rows_by_key: Dict[Tuple[int, type, int], int] = {}
         for row, entry in enumerate(self._entries):
@@ -911,7 +913,7 @@ class CheatTable(QWidget):
 
 
 # Ceiling for an entry's buffer width. Entries are promoted at the width of the
-# value scanned for, which the scanner doesn't cap, so 1024 was too tight — but
+# value scanned for, which the scanner doesn't cap, so 1024 is too tight — but
 # the poll worker allocates this many bytes per entry on every 100 ms tick, so
 # an unbounded field turns one typo into a multi-gigabyte allocation the tick's
 # blanket except swallows and retries forever. A megabyte is far past any real

PyMemoryEditor/app/main_window.py

@@ -471,8 +471,8 @@ class MainWindow(QMainWindow):
         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.
+        # work — otherwise Cancel would start "Updating values…", and a dead
+        # target would pop a second error dialog from the refresh.
         if completed:
             self._fill_initial_values(request)
 
@@ -547,9 +547,9 @@ class MainWindow(QMainWindow):
     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()
+        # this window: dropping the reference alone would keep 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
@@ -603,8 +603,8 @@ class MainWindow(QMainWindow):
         """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
+        open, so dropping the reference alone would keep 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
@@ -919,8 +919,8 @@ class MainWindow(QMainWindow):
 
         # Tear down auxiliary dialogs that hold a reference to the old
         # process — reopening them rebuilds against the new target. The Memory
-        # Map belongs here too: it polls on a timer, so leaving it open left it
-        # reading the handle closed just below (issue #74).
+        # Map belongs here too: it polls on a timer, so leaving it open would
+        # leave it reading the handle closed just below.
         for dialog_attr in (
             "_memory_map",
             "_threads_dialog",
@@ -1019,8 +1019,8 @@ class MainWindow(QMainWindow):
         """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.
+        it), so a stray Cmd+Q / window close would otherwise throw away every
+        saved address silently.
         """
         count = self._cheat.entry_count()
         if count == 0 or not self.confirm_close_with_entries:

PyMemoryEditor/app/memory_viewer_dialog.py

@@ -151,9 +151,9 @@ class MemoryViewerDialog(TearsDownOnClose, QDialog):
         self._timer = QTimer(self)
         self._timer.timeout.connect(self.refresh)
 
-        # Failure bookkeeping, same shape as the auto-refresh dialogs: a dead
-        # target used to log a warning every tick forever (~20/s at the 50 ms
-        # floor). Keyed by (address, size, message) so moving the viewer to
+        # Failure bookkeeping, same shape as the auto-refresh dialogs: without
+        # it a dead target would log a warning every tick forever (~20/s at the
+        # 50 ms floor). Keyed by (address, size, message) so moving the viewer to
         # another failing range still gets logged.
         self._last_failure: Optional[tuple] = None
         self._failing_since: Optional[QElapsedTimer] = None
@@ -171,7 +171,7 @@ class MemoryViewerDialog(TearsDownOnClose, QDialog):
         # Skip if a read is still running. The auto-refresh timer fires this
         # repeatedly, and a large length (up to 65536) on a slow target
         # (notably macOS Mach-VM) takes long enough that running it on the UI
-        # thread froze input — so the read now runs on a worker, and this guard
+        # thread would freeze input — so the read runs on a worker, and this guard
         # self-throttles the cadence to the real read time instead of stacking
         # workers.
         if self._worker is not None and self._worker.isRunning():
@@ -188,7 +188,7 @@ class MemoryViewerDialog(TearsDownOnClose, QDialog):
             # travel back in the result so the rendered dump stays labelled with
             # the range actually read even if the user edits the fields mid-read.
             # Errors are returned (not raised) so the one result handler renders
-            # them with the same message/log the synchronous path produced.
+            # every outcome through a single message/log path.
             try:
                 data = process.read_process_memory(addr, bytes, size)
                 # A backend returning a non-buffer object would make bytes(data)

PyMemoryEditor/app/open_process_dialog.py

@@ -288,7 +288,7 @@ class OpenProcessDialog(TearsDownOnClose, QDialog):
         selected_pid = self._selected_pid()
 
         # Restoring the selection below re-triggers Qt's scrollTo(current), which
-        # jumped the list back to the selected row on every tick (#75). The
+        # would jump the list back to the selected row on every tick. The
         # rebuild is harmless on its own: Qt defers the scrollbar range update.
         scrollbar = self._table.verticalScrollBar()
         scroll_offset = scrollbar.value()

PyMemoryEditor/app/pointer_chain_dialog.py

@@ -45,6 +45,7 @@ from PySide6.QtWidgets import (
 )
 
 from PyMemoryEditor import AbstractProcess
+from PyMemoryEditor.process.region import ADDRESS_SPACE_END
 
 from ._widgets import (
     MONOSPACE_FAMILY,
@@ -469,7 +470,7 @@ class PointerChainDialog(QDialog):
         # and formatted as hex; a negative or >= 2**64 value (raw mode with
         # large/negative offsets) would raise OverflowError/ValueError. Reject
         # it cleanly instead of crashing.
-        if not 0 <= resolved < 2 ** 64:
+        if not 0 <= resolved < ADDRESS_SPACE_END:
             self._resolved_address = None
             self._output_label.setText("Resolved address: <out of 64-bit range>")
             self._value_label.setText("Value: —")

PyMemoryEditor/app/pointer_scan_dialog.py

@@ -1059,9 +1059,9 @@ class PointerScanDialog(TearsDownOnClose, QDialog):
         for saved in survivors:
             # Survivors are all module paths (the intersection drops the
             # rest). One whose module isn't loaded now has no live base: the
-            # rescan drops it, and falling back to its saved absolute base (as
-            # this used to) walked the previous run's addresses and could show
-            # a value read from unrelated memory as if the path resolved. Its
+            # rescan drops it, and falling back to its saved absolute base
+            # would walk the previous run's addresses and could show a value
+            # read from unrelated memory as if the path resolved. Its
             # membership is already decided, so it stays, shown unresolved.
             live = saved._rebased_onto(module_bases)
             if live is None:
@@ -1090,8 +1090,8 @@ class PointerScanDialog(TearsDownOnClose, QDialog):
         self._export_btn.setEnabled(True)
 
     def _teardown(self) -> None:
-        # Unhook every signal (the previous code missed `error`/`finished`, so
-        # a late emit could land on a destroyed dialog) and join the worker; if
+        # Unhook every signal (`error`/`finished` included, or a late emit
+        # could land on a destroyed dialog) and join the worker; if
         # it can't stop in time it's detached rather than destroyed under us.
         shutdown_worker_thread(self._worker, wait_ms=2000)
         self._worker = None

PyMemoryEditor/app/results_view.py

@@ -67,7 +67,7 @@ class ResultsModel(QAbstractTableModel):
         # row). Rows dropped since then are listed, ascending, in ``_removed``:
         # an address's current row is its base minus the dropped rows above it
         # (see ``_row_of``). Rebuilding the whole dict after every refine chunk
-        # made a refine quadratic in the result count.
+        # would make a refine quadratic in the result count.
         self._index: Dict[int, int] = {}
         self._removed: List[int] = []
         # Set when an address was appended twice: the base-row bookkeeping
@@ -201,8 +201,8 @@ class ResultsModel(QAbstractTableModel):
 
         # One dataChanged per contiguous run of patched rows rather than one
         # per row: the view repaints on every emit, and a refine chunk is a
-        # few thousand rows, so per-row emits turned each chunk into a redraw
-        # storm.
+        # few thousand rows, so per-row emits would turn each chunk into a
+        # redraw storm.
         for first, last in _contiguous_runs(sorted(set(rows_changed))):
             self.dataChanged.emit(
                 self.index(first, COL_VALUE), self.index(last, COL_PREVIOUS)
@@ -219,9 +219,9 @@ class ResultsModel(QAbstractTableModel):
         a block of neighbours costs one signal, not one per row. Past
         ``_RESET_RUN_THRESHOLD`` runs (a refine that keeps a sparse scatter of
         a huge result set) the model is reset instead: one O(n) rebuild and
-        one repaint, at the price of the view's selection. The previous shape
-        (one pair plus a mid-list ``list.pop`` per row) was quadratic: a
-        refine dropping 900k of 1M rows did 900k pops and fired 900k signals.
+        one repaint, at the price of the view's selection. One pair plus a
+        mid-list ``list.pop`` per row would be quadratic: a refine dropping
+        900k of 1M rows would do 900k pops and fire 900k signals.
         """
         count = len(self._addresses)
         rows = [row for row in rows if 0 <= row < count]

PyMemoryEditor/app/scanner_panel.py

@@ -558,7 +558,7 @@ class ScannerPanel(QWidget):
         # its own width, and there is no earlier width to fall back on. Dropping
         # it would send the next Changed/Unchanged refine to the spec default —
         # 16 for a String scanned at 4 — which is the failure this whole branch
-        # exists to fix. _has_results tells the two apart: a first scan only
+        # exists to prevent. _has_results tells the two apart: a first scan only
         # runs when there are none yet.
         if self._has_results:
             self._pending_scan_length = None

PyMemoryEditor/app/value_types.py

@@ -469,9 +469,9 @@ def parse_value_for_write(
     # One guard for every path that reaches an address. An entry's length is a
     # *byte* width — it is the bufflength each poll tick reads — while
     # prepare_write treats it as a hard cap and truncates past it, counting
-    # characters for str. So a wider value was written short with no word said
-    # while the cell kept showing all of it, and a multibyte str could slip the
-    # other way: "ábc" is 3 characters but 4 bytes, one past a 3-byte entry.
+    # characters for str. So a wider value would be written short with no word
+    # said while the cell kept showing all of it, and a multibyte str could slip
+    # the other way: "ábc" is 3 characters but 4 bytes, one past a 3-byte entry.
     # Measuring what actually goes on the wire covers both.
     written = _written_width(value)
     if length_override is not None and written > length_override:

PyMemoryEditor/linux/functions.py

@@ -12,7 +12,7 @@ import logging
 import os
 import signal
 from ctypes import addressof, sizeof
-from typing import Dict, Generator, Optional, Sequence, Tuple, Type, TypeVar, Union
+from typing import Dict, Generator, Optional, Pattern, Sequence, Tuple, Type, TypeVar, Union, cast
 
 from ..enums import ScanTypesEnum
 from ..process.errors import ProcessIDNotExistsError
@@ -60,9 +60,9 @@ class _LinuxPartialIOError(OSError):
 
     In practice this happens when the target range straddles a freed or
     inaccessible page — the kernel transfers what it can and reports the
-    short count. The previous behavior was to silently accept the short
-    result, leaving the caller's buffer half-filled with real bytes and
-    half with zeros (which downstream decoding would treat as valid).
+    short count. Accepting the short result would leave the caller's buffer
+    half-filled with real bytes and half with zeros (which downstream
+    decoding would treat as valid), so it raises instead.
     Mirrors the partial-read/write check the Win32 backend already does
     against ``ReadProcessMemory`` / ``WriteProcessMemory``.
     """
@@ -181,10 +181,9 @@ def _make_read_chunk(pid: int):
     """
     Build a `read_chunk(address, size)` closure bound to ``pid``.
 
-    Each backend used to define this closure inline three times
+    One closure per backend, shared by its three scan entry points
     (``search_addresses_by_value``, ``search_addresses_by_pattern``,
-    ``search_values_by_addresses``) — drift between them was a recurring source
-    of subtle bugs. Owning it once per backend keeps the trio in lockstep.
+    ``search_values_by_addresses``) so they cannot drift.
     """
     def read_chunk(address: int, size: int):
         buffer = (ctypes.c_byte * size)()
@@ -249,7 +248,7 @@ def get_memory_regions(pid: int) -> Generator["MemoryRegion", None, None]:
             region_information = line.split(maxsplit=5)
 
             try:
-                addressing_range, privileges, offset, device, inode = (
+                addressing_range, privileges, raw_offset, device, raw_inode = (
                     region_information[0:5]
                 )
                 path = region_information[5].strip() if len(region_information) >= 6 else b""
@@ -259,8 +258,8 @@ def get_memory_regions(pid: int) -> Generator["MemoryRegion", None, None]:
                 ]
                 major_id, minor_id = [int(_id, 16) for _id in device.split(b":")]
 
-                offset = int(offset, 16)
-                inode = int(inode)  # /proc/<pid>/maps formats the inode as decimal.
+                offset = int(raw_offset, 16)
+                inode = int(raw_inode)  # /proc/<pid>/maps formats the inode as decimal.
             except (ValueError, IndexError) as exc:
                 # A single malformed line (kernel quirk, racing teardown) must
                 # not abort the whole region walk — skip it and keep going, the
@@ -437,9 +436,9 @@ def read_process_memory(pid: int, address: int, pytype: Type[T], bufflength: int
     _process_vm_readv(pid, addressof(data), address, bufflength)
 
     if pytype is str:
-        return bytes(data).decode("utf-8", errors="replace")
+        return cast(T, bytes(data).decode("utf-8", errors="replace"))
     elif pytype is bytes:
-        return bytes(data)
+        return cast(T, bytes(data))
     else:
         # Narrow widths pad with zeroes, which reads a signed value as
         # unsigned -- and a scan for the same bytes is signed.
@@ -463,23 +462,28 @@ def search_addresses_by_value(
     pid: int,
     pytype: Type[T],
     bufflength: int,
-    value: Union[bool, int, float, str, bytes, tuple],
+    value: Optional[Union[bool, int, float, str, bytes, tuple]],
     scan_type: ScanTypesEnum = ScanTypesEnum.EXACT_VALUE,
     progress_information: bool = False,
     writeable_only: bool = False,
     *,
     memory_regions: Optional[Sequence[MemoryRegion]] = None,
     aligned: bool = True,
+    target_value_bytes: Optional[Union[bytes, Tuple[bytes, ...]]] = None,
 ) -> Generator[Union[int, Tuple[int, dict]], None, None]:
     """
     Search the whole memory space, accessible to the process,
     for the provided value, returning the found addresses.
 
     Passing a `memory_regions` snapshot skips region enumeration.
+    ``target_value_bytes`` is ``value`` already encoded (see
+    :func:`~PyMemoryEditor.util.prepare_search_target`); when it is given,
+    ``value`` is not used and may be ``None``.
     """
     _validate_pytype(pytype)
 
-    target_value_bytes = values_to_bytes(pytype, bufflength, value)
+    if target_value_bytes is None:
+        target_value_bytes = values_to_bytes(pytype, bufflength, value)
 
     source_regions = (
         memory_regions if memory_regions is not None else get_memory_regions(pid)
@@ -512,12 +516,19 @@ def search_addresses_by_pattern(
     byte_length: int = 0,
     progress_information: bool = False,
     memory_regions: Optional[Sequence[MemoryRegion]] = None,
+    compiled_pattern: Optional[Tuple[Pattern[bytes], int]] = None,
 ) -> Generator[Union[int, Tuple[int, dict]], None, None]:
     """
     AOB scan against every readable, non-shared region of the target. See
-    :meth:`AbstractProcess.search_by_pattern`.
-    """
-    compiled, length = compile_pattern(pattern, byte_length=byte_length)
+    :meth:`AbstractProcess.search_by_pattern`. ``compiled_pattern`` is what
+    :func:`~PyMemoryEditor.util.pattern.compile_pattern` returned for
+    ``pattern``, when the caller already compiled it.
+    """
+    compiled, length = (
+        compiled_pattern
+        if compiled_pattern is not None
+        else compile_pattern(pattern, byte_length=byte_length)
+    )
 
     source_regions = (
         memory_regions if memory_regions is not None else get_memory_regions(pid)
@@ -703,7 +714,7 @@ def get_processes() -> Generator[Tuple[int, str], None, None]:
 
     ``comm`` is raw bytes a process can set to anything (``prctl(PR_SET_NAME)``),
     so it is decoded as UTF-8 with replacement characters, independent of the
-    locale: one process with a non-UTF-8 name used to raise
+    locale, so one process with a non-UTF-8 name cannot raise
     ``UnicodeDecodeError`` here and break ``OpenProcess(name=...)`` for every
     other process.
     """

PyMemoryEditor/linux/libc.py

@@ -21,9 +21,8 @@ libc = ctypes.CDLL(find_library("c"), use_errno=True)
 # Configuring `argtypes` is not cosmetic: without it, ctypes passes Python ints
 # through the platform's default C-int width. On a 32-bit Linux build (or any
 # host where the default int is narrower than the iovec pointer's representation)
-# the address gets silently truncated before the kernel sees it — the same class
-# of bug that motivated the v2 audit of the Win32 backend, where every API now
-# declares argtypes/restype explicitly.
+# the address gets silently truncated before the kernel sees it. The Win32
+# backend declares argtypes/restype explicitly on every API for the same reason.
 _PROCESS_VM_ARGTYPES = (
     ctypes.c_int,              # pid_t
     ctypes.POINTER(iovec),     # local_iov