PyMemoryEditor 3.3.2__py3-none-any.whl → 3.3.3__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.3.3"
 
 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/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/process/abstract.py

@@ -1303,6 +1303,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 +1325,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 +1354,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-3.3.2.dist-info → pymemoryeditor-3.3.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: PyMemoryEditor
-Version: 3.3.2
+Version: 3.3.3
 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.3.3.dist-info}/RECORD

@@ -1,11 +1,12 @@
-PyMemoryEditor/__init__.py,sha256=8avktxpgstr25QlSa_QUiTFYqDRD29h3KhvNQQ0qKD0,3234
+PyMemoryEditor/__init__.py,sha256=bwjUj-mN7Qc2d8r-9cSsNJr4SmKgq8tHIYAFauTtf9Y,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
@@ -35,14 +36,14 @@ PyMemoryEditor/macos/types.py,sha256=pYVGpROHKt8-s1C-sFsG8xEk1vmBVdh5_5-BIqtsSak
 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/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=JbgKqR6tBPb6aCyuI2onLH-_9g9pICGxrv-PI-Yi6mk,74035
 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,10 +55,10 @@ 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/functions.py,sha256=mzgo1DZDFGgK0gFFaw3Hc2ljPDWjeEBzfqmac4F233U,47972
 PyMemoryEditor/win32/process.py,sha256=9t9xtmW_rBIWh6-Jdr3CPLshmmuBNBonBgzQA3bZGc8,13562
 PyMemoryEditor/win32/types.py,sha256=QkFRFKviS-7DNGgsK2eCTeiinYm2BZdxsPh_pw6I570,5177
 PyMemoryEditor/win32/enums/__init__.py,sha256=RZXhXb-yCGHVDEi0OxV27w0g2l6b68BIbKhHXyTM3cw,301
@@ -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.3.3.dist-info/METADATA,sha256=6Pm1UqVnlDrzaK1VWVPqPvWAOLmwujsaw9iZlv56fps,11037
+pymemoryeditor-3.3.3.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+pymemoryeditor-3.3.3.dist-info/entry_points.txt,sha256=qxto0CWCXsjLmE0jClEgz1Xriljr6IV6d3AySjIlw7E,127
+pymemoryeditor-3.3.3.dist-info/licenses/LICENSE,sha256=YkOx6Nvkavq36bgiAc3eF85SBG0Qu14KMAvxmv6Ssjc,1089
+pymemoryeditor-3.3.3.dist-info/RECORD,,