PyMemoryEditor 3.3.2__py3-none-any.whl → 3.4.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.3.2"
+__version__ = "3.4.0"
 
 import logging
 import sys

PyMemoryEditor/app/_gc.py

@@ -0,0 +1,71 @@
+# -*- coding: utf-8 -*-
+
+"""Run Python's cyclic garbage collector on the GUI thread only.
+
+The automatic collector runs in whichever thread happens to allocate when a
+threshold is crossed -- in this app, often a ``QThread`` worker in the middle
+of a scan. If that collection frees a reference cycle holding Qt objects that
+belong to the GUI thread, they are destroyed from the worker, which crashes
+the process (a segfault on macOS, an access violation on Windows; seen on CI
+in the pointer-scan worker's ``_hand_over``).
+
+So while the app runs, automatic collection is switched off and a timer on the
+GUI thread collects instead, generation by generation, as the automatic
+collector would have. Plain reference counting still frees everything that is
+not in a cycle immediately, in any thread.
+"""
+
+import contextlib
+import gc
+from typing import Iterator, Optional
+
+from PySide6.QtCore import QObject, QTimer
+
+
+#: How often the GUI thread checks whether a collection is due.
+COLLECT_INTERVAL_MS = 500
+
+
+class MainThreadGarbageCollector(QObject):
+    """Disable automatic collection and collect from a GUI-thread timer.
+
+    Create it on the GUI thread; :meth:`stop` restores the collector's previous
+    state, so an embedder's own setting survives the app.
+    """
+
+    def __init__(
+        self, parent: Optional[QObject] = None, interval_ms: int = COLLECT_INTERVAL_MS
+    ) -> None:
+        super().__init__(parent)
+        self._was_enabled = gc.isenabled()
+        self._threshold = gc.get_threshold()
+        gc.disable()
+        self._timer = QTimer(self)
+        self._timer.timeout.connect(self.collect_if_due)
+        self._timer.start(interval_ms)
+
+    def collect_if_due(self) -> None:
+        """Collect each generation whose allocation count passed its threshold."""
+        count0, count1, count2 = gc.get_count()
+        if count0 > self._threshold[0]:
+            gc.collect(0)
+            if count1 > self._threshold[1]:
+                gc.collect(1)
+                if count2 > self._threshold[2]:
+                    gc.collect(2)
+
+    def stop(self) -> None:
+        """Stop the timer and give automatic collection back."""
+        self._timer.stop()
+        if self._was_enabled:
+            gc.enable()
+
+
+@contextlib.contextmanager
+def garbage_collected_on_gui_thread(parent: Optional[QObject] = None) -> Iterator[None]:
+    """Run the body with :class:`MainThreadGarbageCollector` in charge."""
+    collector = MainThreadGarbageCollector(parent)
+    try:
+        yield
+    finally:
+        collector.stop()

PyMemoryEditor/app/application.py

@@ -560,10 +560,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
-
+    from ._gc import garbage_collected_on_gui_thread
     from ._icon import app_icon
 
     app = QApplication.instance() or QApplication(argv)
@@ -577,6 +574,18 @@ def main(argv=None):
     saved_theme = str(QSettings().value("theme", DEFAULT_THEME_ID))
     apply_theme(app, saved_theme)
 
+    # Every dialog from here on runs QThread workers; see _gc for why the
+    # cyclic collector must not run inside them.
+    with garbage_collected_on_gui_thread(app):
+        _pick_process_and_run(app)
+
+
+def _pick_process_and_run(app) -> None:
+    """The picker, then the main window until the event loop exits."""
+    from ._widgets import detached_workers_running
+    from .main_window import MainWindow
+    from .open_process_dialog import OpenProcessDialog
+
     picker = OpenProcessDialog()
     if picker.exec() != picker.DialogCode.Accepted:
         return

PyMemoryEditor/linux/process.py

@@ -196,12 +196,14 @@ class LinuxProcess(AbstractProcess):
         bufflength: Optional[int] = None,
     ) -> T:
         self.__require_target(hot_path=True)
+        self._require_address(address)
         return read_process_memory(
             self.pid, address, pytype, resolve_bufflength(pytype, bufflength)
         )
 
     def read_process_memory_into(self, address: int, buffer: object) -> int:
         self.__require_target(hot_path=True)
+        self._require_address(address)
         return read_process_memory_into(self.pid, address, buffer)
 
     def _scan_addresses(
@@ -270,6 +272,7 @@ class LinuxProcess(AbstractProcess):
         value: Union[bool, int, float, str, bytes] = UNSET,
     ) -> Union[bool, int, float, str, bytes]:
         self.__require_target()
+        self._require_address(address)
         w_pytype, w_length, w_value = prepare_write(pytype, bufflength, value)
         write_process_memory(self.pid, address, w_pytype, w_length, w_value)
         return value

PyMemoryEditor/macos/process.py

@@ -255,12 +255,14 @@ class MacProcess(AbstractProcess):
         bufflength: Optional[int] = None,
     ) -> T:
         self._require_open()
+        self._require_address(address)
         return read_process_memory(
             self.__task, address, pytype, resolve_bufflength(pytype, bufflength)
         )
 
     def read_process_memory_into(self, address: int, buffer: object) -> int:
         self._require_open()
+        self._require_address(address)
         return read_process_memory_into(self.__task, address, buffer)
 
     def write_process_memory(
@@ -296,6 +298,7 @@ class MacProcess(AbstractProcess):
         :param value: value to be written.
         """
         self._require_open()
+        self._require_address(address)
         w_pytype, w_length, w_value = prepare_write(pytype, bufflength, value)
         write_process_memory(self.__task, address, w_pytype, w_length, w_value)
         return value
@@ -308,6 +311,7 @@ class MacProcess(AbstractProcess):
 
     def free_memory(self, address: int, size: int = 0) -> bool:
         self._require_open()
+        self._require_address(address)
         # mach_vm_deallocate needs the exact size. Reuse the tracked size when
         # the caller doesn't supply one.
         actual_size = size or self.__allocations.get(address, 0)

PyMemoryEditor/mcp/policy.py

@@ -218,6 +218,12 @@ class AccessDecision:
     needs_approval: bool = False
 
 
+def _self_and_ancestor_pids() -> FrozenSet[int]:
+    """This process, its parent and every ancestor: what ``protect_self``
+    refuses. A function of its own so tests can swap the real chain out."""
+    return frozenset({os.getpid(), os.getppid()}) | ancestor_pids()
+
+
 class ProcessPolicy:
     """Decides whether a given ``(pid, name)`` may be attached to.
 
@@ -282,9 +288,7 @@ class ProcessPolicy:
         # further up. Taken once: the chain that launched the server does not
         # change while it runs.
         self._protected: FrozenSet[int] = (
-            frozenset({os.getpid(), os.getppid()}) | ancestor_pids()
-            if protect_self
-            else frozenset()
+            _self_and_ancestor_pids() if protect_self else frozenset()
         )
         self._identify = identify
         # Only Linux truncates names; applying the rule elsewhere would let a

PyMemoryEditor/mcp/toolset.py

@@ -424,6 +424,10 @@ def _parse_signed_int(raw: Any, field: str) -> int:
     negative = text.startswith("-")
     body = text[1:] if negative else text
     try:
+        # int() accepts a sign of its own, so "--5" would strip to "-5" and
+        # the two minuses cancel: a write of "--5" stored +5. One sign only.
+        if negative and body.lstrip()[:1] in ("-", "+"):
+            raise ValueError(body)
         value = int(body, 16) if body[:2].lower() == "0x" else int(body, 10)
     except (ValueError, IndexError):
         raise ToolError(

PyMemoryEditor/process/abstract.py

@@ -53,15 +53,22 @@ _POINTER_SCAN_FORMAT = "pymemoryeditor-pointerscan"
 _POINTER_SCAN_VERSION = 1
 
 
-class _PointerOutOfRangeError(ValueError, OSError):
-    """A pointer chain step landed outside the address space.
+class _AddressOutOfRangeError(ValueError, OSError):
+    """An address (or a pointer chain step) lies outside the address space.
 
     A ``ValueError`` as documented, and also an ``OSError`` because the failed
     read of the wrapped address it replaces raised one: callers that guard a
-    stale chain with ``except OSError`` keep working.
+    stale chain or a bad address with ``except OSError`` keep working.
     """
 
 
+# One past the highest address this host can pass to the OS. ctypes masks an
+# address argument to the width of the C type it is converted to instead of
+# rejecting it, so a 32-bit Python would turn 0x1_0000_1000 into 0x1000 just as
+# a 64-bit one turns 2**64 + 0x1000 into 0x1000.
+_HOST_ADDRESS_END = min(ADDRESS_SPACE_END, 1 << (8 * ctypes.sizeof(ctypes.c_void_p)))
+
+
 class AbstractProcess(ABC):
     """
     Abstract class to represent a process.
@@ -205,6 +212,23 @@ class AbstractProcess(ABC):
         if not self._target_alive():
             raise ProcessIDNotExistsError(self.pid)
 
+    @staticmethod
+    def _require_address(address: int) -> None:
+        """
+        Refuse an address outside ``[0, host address space)`` before it
+        reaches ctypes, which would mask it to the C type's width and read,
+        write or free a *different*, wrapped address instead of failing.
+        """
+        if not 0 <= address < _HOST_ADDRESS_END:
+            raise _AddressOutOfRangeError(
+                "address %s is outside the %d-bit address space; it would "
+                "wrap around to a different address."
+                % (
+                    ("-0x%X" % -address) if address < 0 else ("0x%X" % address),
+                    _HOST_ADDRESS_END.bit_length() - 1,
+                )
+            )
+
     @abstractmethod
     def _detect_is_64bit(self) -> Optional[bool]:
         """
@@ -736,7 +760,9 @@ class AbstractProcess(ABC):
            and ``convert_from_byte_array``. Callers that need the original
            bytes verbatim (no decoding) should pass ``pytype=bytes``.
 
-        :raises ValueError: if ``pytype`` is unsupported.
+        :raises ValueError: if ``pytype`` is unsupported, or ``address`` is
+            negative or past the end of the address space (also an
+            ``OSError``, so ``except OSError`` still catches it).
         :raises OSError: if the read fails, or returns fewer bytes than
             requested (e.g. the range crosses an unreadable/freed page).
         """
@@ -770,7 +796,9 @@ class AbstractProcess(ABC):
 
         :raises TypeError: if ``buffer`` is not a writable buffer (e.g. an
             immutable ``bytes`` object).
-        :raises ValueError: if ``buffer`` is empty or not contiguous.
+        :raises ValueError: if ``buffer`` is empty or not contiguous, or
+            ``address`` is outside the address space (as in
+            :meth:`read_process_memory`).
         :raises OSError: if the read fails, or returns fewer bytes than
             requested (e.g. the range crosses an unreadable/freed page).
 
@@ -821,7 +849,8 @@ class AbstractProcess(ABC):
             (``write_process_memory(address, int, 4, 99)``).
         :raises ValueError: if ``pytype`` is unsupported, or if an ``int``
             ``value`` does not fit in ``bufflength`` bytes (rejected up front
-            rather than silently truncated).
+            rather than silently truncated), or if ``address`` is outside the
+            address space (as in :meth:`read_process_memory`).
         :raises OSError: if the write fails, or fewer bytes than requested are
             written (e.g. the range crosses an unwritable/freed page).
         :return: the original ``value`` passed in.
@@ -1080,7 +1109,8 @@ class AbstractProcess(ABC):
         :return: ``True`` on success.
 
         :raises ValueError: on macOS and Windows, for a region this object did
-            not allocate when no ``size`` is given.
+            not allocate when no ``size`` is given, or for an ``address``
+            outside the address space.
         :raises NotImplementedError: on Linux (see :meth:`allocate_memory`).
         """
         raise NotImplementedError()
@@ -1190,7 +1220,7 @@ class AbstractProcess(ABC):
             # it, so `ptr + offset` below zero or past 2**64 would silently
             # read a *different*, wrapped address. Refuse it by name instead.
             if not 0 <= addr < ADDRESS_SPACE_END:
-                raise _PointerOutOfRangeError(
+                raise _AddressOutOfRangeError(
                     "pointer chain step produced address %s, outside the "
                     "64-bit address space; the chain is stale (a hop read "
                     "NULL or garbage) or an offset is wrong."
@@ -1303,6 +1333,15 @@ class AbstractProcess(ABC):
             bounds it. (To abort the map-building phase, raise from
             ``progress_callback``.)
 
+        :raises ValueError: ``ptr_size`` other than 4 or 8, ``max_depth`` or
+            ``max_results`` below 1, or a negative ``max_offset``.
+        :raises ClosedProcess: the process was closed (also raised by the
+            returned generator once it is).
+
+        Arguments and access are checked at the call, like every ``search_*``
+        method; the pointer map is built and walked lazily, as the generator
+        is consumed.
+
         Example
         -------
         ::
@@ -1316,11 +1355,26 @@ class AbstractProcess(ABC):
             live = path.rebase(process).to_pointer(process, pytype=int, bufflength=4)
             live.value = 9999
         """
-        from .pointer_scan import (
-            AddressRanges,
-            build_pointer_map,
-            find_pointer_paths,
-        )
+        # Validate eagerly, like every search_* method: a bad argument or a
+        # closed process raises here, at the call, not on the first next().
+        # The map build and path search stay lazy in _iter_pointer_paths.
+        #
+        # A subclass written against the 3.3 contract implements the listings
+        # itself and need not define these hooks (see __init_subclass__): each
+        # check runs only where the subclass provides it, instead of hitting
+        # the NotImplementedError of the base _require_open.
+        cls = type(self)
+        guarded = cls._require_open is not AbstractProcess._require_open
+        if guarded or cls._require_scanning is not AbstractProcess._require_scanning:
+            self._require_scanning()
+
+        if max_depth < 1:
+            raise ValueError("max_depth must be at least 1.")
+        if max_offset < 0:
+            raise ValueError("max_offset must not be negative.")
+        if max_results is not None and max_results < 1:
+            # 0 would build the whole pointer map only to yield nothing.
+            raise ValueError("max_results must be at least 1 (or None for no cap).")
 
         if ptr_size is None:
             ptr_size = self.pointer_size
@@ -1330,6 +1384,44 @@ class AbstractProcess(ABC):
                 "ptr_size must be 4 (32-bit target) or 8 (64-bit target)."
             )
 
+        scan = self._iter_pointer_paths(
+            target_address,
+            max_depth=max_depth,
+            max_offset=max_offset,
+            ptr_size=ptr_size,
+            aligned=aligned,
+            writable_only=writable_only,
+            static_ranges=static_ranges,
+            max_results=max_results,
+            memory_regions=memory_regions,
+            progress_callback=progress_callback,
+            should_stop=should_stop,
+        )
+        return guard_generator(scan, self._require_open) if guarded else scan
+
+    def _iter_pointer_paths(
+        self,
+        target_address: int,
+        *,
+        max_depth: int,
+        max_offset: int,
+        ptr_size: int,
+        aligned: bool,
+        writable_only: bool,
+        static_ranges: Optional[Sequence[Tuple[int, int]]],
+        max_results: Optional[int],
+        memory_regions: Optional[Sequence[MemoryRegion]],
+        progress_callback: Optional["Callable[[float], None]"],
+        should_stop: Optional["Callable[[], bool]"],
+    ) -> Generator["PointerPath", None, None]:
+        """The lazy body of :meth:`scan_pointer_paths`, run once arguments are
+        validated."""
+        from .pointer_scan import (
+            AddressRanges,
+            build_pointer_map,
+            find_pointer_paths,
+        )
+
         if memory_regions is None:
             memory_regions = list(self.get_memory_regions())
 

PyMemoryEditor/util/pattern.py

@@ -71,9 +71,18 @@ def compile_pattern(
     :raises ValueError: malformed IDA-style token, or ``byte_length`` omitted
         for a regex / pre-compiled pattern.
     :raises TypeError: if ``pattern`` is not a ``str``, ``bytes`` or
-        ``re.Pattern[bytes]``.
+        ``re.Pattern[bytes]`` — a compiled ``str`` regex included, as it can
+        never match process memory.
     """
     if isinstance(pattern, re.Pattern):
+        # A str pattern can't match process memory: it would only fail later,
+        # deep inside the scan, with "cannot use a string pattern on a
+        # bytes-like object".
+        if not isinstance(pattern.pattern, bytes):
+            raise TypeError(
+                "Pattern must be a compiled bytes regex (re.compile(rb'...')), "
+                "not a str one."
+            )
         if byte_length <= 0:
             raise ValueError(
                 "byte_length= is required when passing a pre-compiled regex "

PyMemoryEditor/win32/functions.py

@@ -251,6 +251,8 @@ _PROCESSOR_ARCHITECTURE_64BIT = (6, 9, 12)
 _OS_IS_64BIT = (
     _native_system_information.wProcessorArchitecture in _PROCESSOR_ARCHITECTURE_64BIT
 )
+# The running Python's bitness: the fallback guess when a target's can't be read.
+_HOST_IS_64BIT = ctypes.sizeof(ctypes.c_void_p) == 8
 
 
 def mbi_class_for_handle(process_handle: int):
@@ -318,12 +320,13 @@ def IsProcess64Bit(process_handle: int) -> bool:
         return detected
 
     _logger.warning(
-        "IsWow64Process failed (err=%d); assuming the target is 64-bit "
-        "(host bitness). Pointer-width detection may be wrong if the target "
-        "is actually a 32-bit (WOW64) process.",
+        "IsWow64Process failed (err=%d); assuming the target matches the "
+        "host bitness (%d-bit). Pointer-width detection may be wrong if it "
+        "does not.",
         ctypes.get_last_error(),
+        64 if _HOST_IS_64BIT else 32,
     )
-    return True
+    return _HOST_IS_64BIT
 
 
 T = TypeVar("T")

PyMemoryEditor/win32/process.py

@@ -303,6 +303,7 @@ class WindowsProcess(AbstractProcess):
     ) -> T:
         self._require_open()
         self.__require_read()
+        self._require_address(address)
         return ReadProcessMemory(
             self.__process_handle,
             address,
@@ -313,6 +314,7 @@ class WindowsProcess(AbstractProcess):
     def read_process_memory_into(self, address: int, buffer: object) -> int:
         self._require_open()
         self.__require_read()
+        self._require_address(address)
         return ReadProcessMemoryInto(self.__process_handle, address, buffer)
 
     def write_process_memory(
@@ -324,6 +326,7 @@ class WindowsProcess(AbstractProcess):
     ) -> Union[bool, int, float, str, bytes]:
         self._require_open()
         self.__require_write()
+        self._require_address(address)
         w_pytype, w_length, w_value = prepare_write(pytype, bufflength, value)
         WriteProcessMemory(
             self.__process_handle,
@@ -344,6 +347,7 @@ class WindowsProcess(AbstractProcess):
     def free_memory(self, address: int, size: int = 0) -> bool:
         self._require_open()
         self.__require_operation()
+        self._require_address(address)
         # MEM_RELEASE tears down whatever VirtualAlloc'd block starts at
         # `address` -- a heap segment or a thread stack just as readily as one
         # of ours -- so an address this object did not allocate is refused

{pymemoryeditor-3.3.2.dist-info → pymemoryeditor-3.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: PyMemoryEditor
-Version: 3.3.2
+Version: 3.4.0
 Summary: Read, write and scan process memory in a few lines of Python — Cheat Engine-style scans, pointer chains and AOB search on Windows, Linux and macOS.
 Project-URL: Homepage, https://github.com/JeanExtreme002/PyMemoryEditor
 Project-URL: Documentation, https://pymemoryeditor.readthedocs.io

{pymemoryeditor-3.3.2.dist-info → pymemoryeditor-3.4.0.dist-info}/RECORD

@@ -1,11 +1,12 @@
-PyMemoryEditor/__init__.py,sha256=8avktxpgstr25QlSa_QUiTFYqDRD29h3KhvNQQ0qKD0,3234
+PyMemoryEditor/__init__.py,sha256=xLgUi2R-C4CS8imhiSFr5bOQrYjqc-P1amRkKBBXChQ,3234
 PyMemoryEditor/__main__.py,sha256=xukvvLjQ0BnYnnxMZda1cvyZ-BurSUk8dAGQybIqMD4,95
 PyMemoryEditor/enums.py,sha256=q_SWQYgh4F7yyAa7sZvNo2Sw91TSm3aTqPfTA7OqldM,322
 PyMemoryEditor/app/__init__.py,sha256=DGCYWpqGKPSeBa7cvzL7GmmhIfDDgF6vtim0VtLcfOo,357
 PyMemoryEditor/app/_auto_refresh_dialog.py,sha256=ktvsOaXUooQ9Hvfw2Y__IzWNZby0sW_0QlhNGrPseoE,10048
+PyMemoryEditor/app/_gc.py,sha256=ulvh129qptIBxzFjfbIDQm4DMPt6WwDEniiRngv3FQ8,2533
 PyMemoryEditor/app/_icon.py,sha256=1HaaMX3HRCUD2EVIRwj_0BwPkdfj1nsVjwoTRwriJ_k,1447
 PyMemoryEditor/app/_widgets.py,sha256=vMqBfOHylEHB0jlxWmfbILEIRzjj7d6EIAFG5f7oxE0,12639
-PyMemoryEditor/app/application.py,sha256=Ew0KYFhIBafr7vLA1QrYU9PDpG-W645TMaG22GsJFWg,19907
+PyMemoryEditor/app/application.py,sha256=RzPAPKmMmXjT6La5O_lSyqPWont6xM356DjDkWFttmY,20278
 PyMemoryEditor/app/cheat_entry.py,sha256=KOLcams-xkVEkV7rfrzhEI7IrsVvmGwsIr8cGcWdLM0,2841
 PyMemoryEditor/app/cheat_poll_worker.py,sha256=ZhDOXAGI9ObAEBSgkZLLOySUTekhlwICIfuA1XOp2Rw,12716
 PyMemoryEditor/app/cheat_table.py,sha256=FK0ZUkuEvvuXXOB64-hpxSDoGFlHNKhMFyFGgpsyXU0,46278
@@ -25,24 +26,24 @@ PyMemoryEditor/app/threads_dialog.py,sha256=HnPS7Mte6CboM0DaoqkTqnEg8Ck65L1FKW-e
 PyMemoryEditor/app/value_types.py,sha256=Ya8_n8OTkvRqeG1Zwfzsh5y990PBsjcOOfF4ZPrzlhs,18388
 PyMemoryEditor/linux/functions.py,sha256=aNFgbTBzt3U9nIBhtyKHEvWdlCRQQJhhTAmFBsu0l5Q,31766
 PyMemoryEditor/linux/libc.py,sha256=kF2GCckU5lFEOQNis29tfKzBhvafFjhtiUIBotFScZg,1385
-PyMemoryEditor/linux/process.py,sha256=9H6o3Nx3S9Sg4uOt4u_L6hRz7nRzM888F5VEb7O59N0,11031
+PyMemoryEditor/linux/process.py,sha256=TwKlzw5hJWIV_CirLndMJbW75tndgvqApTKgf1HLR1Y,11148
 PyMemoryEditor/linux/types.py,sha256=sOgO-s9oqKrKKCHMG4N-Pe7sNw49V06PeMENSNnNFl8,1924
 PyMemoryEditor/macos/__init__.py,sha256=85mOA4U5i9EW2r1ggKqRJkqRq0e9bV3I2HdfHIvox10,72
 PyMemoryEditor/macos/functions.py,sha256=eEawTDM3i_EocxU2ENvRm2XwdrecdZ5Uigt8UdFYxMc,61157
 PyMemoryEditor/macos/libsystem.py,sha256=1MDSrp3oC5Ay1CSDt7TGEEGcScBhHGbK3aZxNKj8qTM,9245
-PyMemoryEditor/macos/process.py,sha256=kd_k2ZPYRGTDLEIoppT8z3D4GjHTAc1lSklxh9ooKr0,12525
+PyMemoryEditor/macos/process.py,sha256=fcOkFyolK9S3ebiG83MyMQ-dOae-E1vMNXDayI3MgQo,12681
 PyMemoryEditor/macos/types.py,sha256=pYVGpROHKt8-s1C-sFsG8xEk1vmBVdh5_5-BIqtsSak,7577
 PyMemoryEditor/mcp/__init__.py,sha256=g30FgXeR3_eHq5hsGSGsPEJQlMPQ3A0jstD-MAFbU2M,2393
 PyMemoryEditor/mcp/__main__.py,sha256=GXMMDJMMZfFMjzYnRcw20wRRb3v_IKxvv_-ZOyxkK1U,475
 PyMemoryEditor/mcp/config.py,sha256=bpqkaWMI314byflMrMnySdLuuyqQJT3XTbuKIDgVLME,15862
-PyMemoryEditor/mcp/policy.py,sha256=QDu4I2gZRMyA6WvpzJKMNhKc9NwiUOsDSjQuqEwVKmw,25630
+PyMemoryEditor/mcp/policy.py,sha256=cfG1A-IR1kTe_neLZFtd-JAqkZ_vcE4QYrPgNUv3yb0,25844
 PyMemoryEditor/mcp/procinfo.py,sha256=ufT07yoffyfA7KiBrdaQm7Hkf1WbpGveZMwcSmR8NQQ,10136
 PyMemoryEditor/mcp/server.py,sha256=YBJDMM2pXaavG_o-CnO8yL6aFecdsNfv6wEIqqard-o,33564
 PyMemoryEditor/mcp/session.py,sha256=0gy629j8lJrq4VxqUTMbxJ-D-D1IJo47T-UwtAIEzZE,31645
-PyMemoryEditor/mcp/toolset.py,sha256=kxkByx5YUowX7ldj1o1k0VXCPMoRNR4kxH1NHn3Z8ts,118338
+PyMemoryEditor/mcp/toolset.py,sha256=Po_qLROe9WfACNHoyn1OvmHKkzEOvNhZeP8R89PDqYg,118583
 PyMemoryEditor/process/__init__.py,sha256=Xh5jngBqZyNIA9y3uwE49LxK8uH8YYsu6qotx1mP_WE,213
 PyMemoryEditor/process/_guard.py,sha256=91TKDEpFthFn99QNOioMD9hp2kzAOHA_qtkEgW9tJtI,1471
-PyMemoryEditor/process/abstract.py,sha256=_e9y8-4Te3VQYWwjH1ogw4KJ1FNZcKMhXR06QCF8zyc,71287
+PyMemoryEditor/process/abstract.py,sha256=1cmPkKqZgb4RCZGlvEgYbL4D_RJUq6PXrB9v5YCGgoQ,75572
 PyMemoryEditor/process/errors.py,sha256=485SXkidg9_E_KjuhuF6AsQNuFZlY-Ag-sG1C6NsGMw,2054
 PyMemoryEditor/process/info.py,sha256=yF7kE-wMEs_h3rpn2dPgBpuwn2EhhVq3lfl5u7GwCfY,1484
 PyMemoryEditor/process/module_info.py,sha256=D7qAoBymhe6vrL0IYc2R6ZhWE-OPmYQzf6hSp_f2KmA,2365
@@ -54,11 +55,11 @@ PyMemoryEditor/process/thread_info.py,sha256=vwTDd3Yg2gOidU7I630Nsut-iryE5imSXnX
 PyMemoryEditor/process/util.py,sha256=QHwwjX79nygYB9ochCXtXCa8wYZ8CwU57q-cIhNajvQ,4014
 PyMemoryEditor/util/__init__.py,sha256=QI_tG9V3HA68IP-BA2-C-rLZWAADhZrbpxXGypBc69s,611
 PyMemoryEditor/util/convert.py,sha256=L-jhVBhmedd6g9IO0rL4KMKU8EZpxMNbB4eiRQkevZc,21954
-PyMemoryEditor/util/pattern.py,sha256=tO-4uaNIpm8tM1H0TS1qqGnDN_NTZd_yVBgm3z1wrK8,7253
+PyMemoryEditor/util/pattern.py,sha256=ONRljRxGYhiElQG1E5D5LusgyZR_YLLdFtZrHFjYYkE,7724
 PyMemoryEditor/util/scan.py,sha256=-VZdwrBeXB7CQ_DKePUWjb-h-ox6_ogwYrloGkw0v6A,28752
 PyMemoryEditor/util/scan_numpy.py,sha256=SRTuhrhYP5azSab3k8FBTPVCMK9_1vZHogSSofkFCAA,6940
-PyMemoryEditor/win32/functions.py,sha256=35zNISzpVZmQuBY5QM_6BlLlyycWThV8ml0XPzLEhdQ,47816
-PyMemoryEditor/win32/process.py,sha256=9t9xtmW_rBIWh6-Jdr3CPLshmmuBNBonBgzQA3bZGc8,13562
+PyMemoryEditor/win32/functions.py,sha256=mzgo1DZDFGgK0gFFaw3Hc2ljPDWjeEBzfqmac4F233U,47972
+PyMemoryEditor/win32/process.py,sha256=LzTcp439esldptdAht5ZPVo0QIVqzk4pcUfGm8ktdO0,13718
 PyMemoryEditor/win32/types.py,sha256=QkFRFKviS-7DNGgsK2eCTeiinYm2BZdxsPh_pw6I570,5177
 PyMemoryEditor/win32/enums/__init__.py,sha256=RZXhXb-yCGHVDEi0OxV27w0g2l6b68BIbKhHXyTM3cw,301
 PyMemoryEditor/win32/enums/memory_allocation_states.py,sha256=NTwC9XkUqlCjoSalwykEG2OZUiqXVylcLP2nYSd39zI,953
@@ -68,8 +69,8 @@ PyMemoryEditor/win32/enums/process_operations.py,sha256=wn-aMl01VVg-2rFavR9szBNR
 PyMemoryEditor/win32/enums/standard_access_rights.py,sha256=VGWlTagW4hvbm2AjZ4NK56ZrQwRmEl9Kz9GSCG8o-HI,738
 PyMemoryEditor/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 PyMemoryEditor/app/assets/icon.svg,sha256=T7OqR7ldqC_dK2Ib2ntsH2rWO-Z5RzNK4WdD1wFwgM4,7132
-pymemoryeditor-3.3.2.dist-info/METADATA,sha256=cH3qLkLOMOVvz73bw1jFV9zgn27si1eDzapY0zs5tEw,11037
-pymemoryeditor-3.3.2.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-pymemoryeditor-3.3.2.dist-info/entry_points.txt,sha256=qxto0CWCXsjLmE0jClEgz1Xriljr6IV6d3AySjIlw7E,127
-pymemoryeditor-3.3.2.dist-info/licenses/LICENSE,sha256=YkOx6Nvkavq36bgiAc3eF85SBG0Qu14KMAvxmv6Ssjc,1089
-pymemoryeditor-3.3.2.dist-info/RECORD,,
+pymemoryeditor-3.4.0.dist-info/METADATA,sha256=ol6qiQvMO8L2cJBK-YAwXI1x6lwkvHnxxX8NzZeX6S4,11037
+pymemoryeditor-3.4.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+pymemoryeditor-3.4.0.dist-info/entry_points.txt,sha256=qxto0CWCXsjLmE0jClEgz1Xriljr6IV6d3AySjIlw7E,127
+pymemoryeditor-3.4.0.dist-info/licenses/LICENSE,sha256=YkOx6Nvkavq36bgiAc3eF85SBG0Qu14KMAvxmv6Ssjc,1089
+pymemoryeditor-3.4.0.dist-info/RECORD,,