PyMemoryEditor 3.3.2__tar.gz → 3.4.0__tar.gz

{pymemoryeditor-3.3.2 → pymemoryeditor-3.4.0}/PKG-INFO

@@ -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 → pymemoryeditor-3.4.0}/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-3.4.0/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-3.3.2 → pymemoryeditor-3.4.0}/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-3.3.2 → pymemoryeditor-3.4.0}/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-3.3.2 → pymemoryeditor-3.4.0}/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-3.3.2 → pymemoryeditor-3.4.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-3.3.2 → pymemoryeditor-3.4.0}/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-3.3.2 → pymemoryeditor-3.4.0}/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-3.3.2 → pymemoryeditor-3.4.0}/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-3.3.2 → pymemoryeditor-3.4.0}/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 → pymemoryeditor-3.4.0}/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 → pymemoryeditor-3.4.0}/docs/conf.py

@@ -23,7 +23,7 @@ copyright = f"{datetime.now().year}, {author}"
 try:
     from PyMemoryEditor import __version__ as release
 except Exception:  # pragma: no cover - docs can build without the package installed
-    release = "3.3.2"
+    release = "3.4.0"
 
 version = ".".join(release.split(".")[:2])
 

{pymemoryeditor-3.3.2 → pymemoryeditor-3.4.0}/docs/guide/pointer-scan.md

@@ -43,8 +43,8 @@ It carries everything you need to reconstruct the chain in another run.
       (default — faster and usually correct).
    :param static_ranges: explicit ``(start, size)`` ranges to treat as valid
       chain bases. Defaults to the image range of every loaded module.
-   :param int max_results: stop after yielding this many paths.
-      Recommended for shallow exploration.
+   :param int max_results: stop after yielding this many paths (at least 1;
+      ``None`` for no cap). Recommended for shallow exploration.
    :param memory_regions: optional snapshot from
       :py:meth:`snapshot_memory_regions`.
    :param progress_callback: a callable ``callback(fraction)`` invoked as the
@@ -55,6 +55,12 @@ It carries everything you need to reconstruct the chain in another run.
       yielded. The search can run a long time between two paths, so this is
       how a deadline or a cancel button bounds it.
    :returns: a generator of :py:class:`PointerPath`.
+   :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.
+
+   Arguments are checked when you call the method; the pointer map is built
+   and walked lazily, as you iterate.
 ```
 
 ## Tuning the scan

{pymemoryeditor-3.3.2 → pymemoryeditor-3.4.0}/pyproject.toml

@@ -241,6 +241,7 @@ skip_empty = true
 [tool.pytest.ini_options]
 addopts = "-n auto --dist=loadfile"
 markers = [
+    "real_self_protection: MCP tests that check the real self/ancestor protection; the others see stand-in pids (tests/mcp_server/conftest.py)",
     "slow: integration tests that read/scan the current process's whole address space (minutes, not seconds)",
     "scan_heavy: tests that scan a *live* process's entire address space. Separated from `slow` because the cost is wildly platform-dependent: a macOS process exposes ~390 GiB across ~145 regions and a Windows one is not much better, so on a CI runner each scan is minutes rather than the ~1s it takes on a developer machine. CI runs these on Linux only (see the build-mcp job); the library's own live-scan coverage on the other two platforms comes from the build/build-macos jobs.",
 ]

pymemoryeditor-3.4.0/tests/app/conftest.py

@@ -0,0 +1,31 @@
+# -*- coding: utf-8 -*-
+
+"""Shared setup for the GUI app tests."""
+
+import gc
+
+import pytest
+
+
+@pytest.fixture(autouse=True)
+def _collect_garbage_on_the_test_thread():
+    """Keep the cyclic collector out of the tests' QThread workers.
+
+    The app does this with ``MainThreadGarbageCollector`` (``app/_gc.py``), but
+    the tests build widgets and workers without going through ``main()``. An
+    automatic collection inside a worker can free reference cycles that hold
+    the GUI thread's Qt objects -- left over from this or an earlier test --
+    and destroy them from the wrong thread, which crashed the pytest worker on
+    CI (segfault on macOS, access violation on Windows). So automatic
+    collection is off during each test, and the garbage is collected here, on
+    the test's own thread, at teardown.
+    """
+    was_enabled = gc.isenabled()
+    gc.collect()
+    gc.disable()
+    try:
+        yield
+    finally:
+        gc.collect()
+        if was_enabled:
+            gc.enable()

pymemoryeditor-3.4.0/tests/app/test_app_gc.py

@@ -0,0 +1,58 @@
+# -*- coding: utf-8 -*-
+
+"""``MainThreadGarbageCollector``: the cyclic collector runs on the GUI thread."""
+
+import gc
+import threading
+
+import pytest
+
+pytest.importorskip("PySide6")
+
+
+class _Cycle:
+    def __init__(self, sink):
+        self.self = self
+        self.sink = sink
+
+    def __del__(self):
+        self.sink.append(threading.current_thread() is threading.main_thread())
+
+
+def test_it_turns_automatic_collection_off_and_back_on(qtbot):
+    from PyMemoryEditor.app._gc import MainThreadGarbageCollector
+
+    gc.enable()
+    collector = MainThreadGarbageCollector()
+    try:
+        assert not gc.isenabled()
+    finally:
+        collector.stop()
+    assert gc.isenabled()
+
+
+def test_it_keeps_a_caller_disabled_collector_disabled(qtbot):
+    from PyMemoryEditor.app._gc import MainThreadGarbageCollector
+
+    gc.disable()
+    try:
+        MainThreadGarbageCollector().stop()
+        assert not gc.isenabled()
+    finally:
+        gc.enable()
+
+
+def test_its_timer_collects_cycles_on_the_gui_thread(qtbot, monkeypatch):
+    from PyMemoryEditor.app._gc import MainThreadGarbageCollector
+
+    gc.collect()
+    # Any allocation makes a collection due, so the first tick runs one.
+    monkeypatch.setattr(gc, "get_threshold", lambda: (0, 0, 0))
+    collector = MainThreadGarbageCollector(interval_ms=10)
+    try:
+        freed = []
+        _Cycle(freed)
+        qtbot.waitUntil(lambda: bool(freed), timeout=2000)
+        assert freed == [True]
+    finally:
+        collector.stop()

{pymemoryeditor-3.3.2 → pymemoryeditor-3.4.0}/tests/app/test_app_smoke.py

@@ -131,6 +131,36 @@ def test_main_cli_scopes_sig_dfl_to_the_run(monkeypatch):
         signal.signal(signal.SIGINT, original)
 
 
+def test_main_runs_the_cyclic_collector_on_the_gui_thread_only(monkeypatch):
+    """
+    While the app runs, automatic collection is off (a timer on the GUI thread
+    collects instead), so a collection never runs inside a QThread worker and
+    destroys GUI-thread Qt objects from there. It is back on afterwards.
+    """
+    import gc
+
+    from PyMemoryEditor.app import application, open_process_dialog
+
+    seen = {}
+
+    class _ProbingDialog:
+        class DialogCode:
+            Accepted = 1
+
+        def exec(self):
+            seen["inside"] = gc.isenabled()
+            return 0
+
+        process = None
+
+    monkeypatch.setattr(open_process_dialog, "OpenProcessDialog", _ProbingDialog)
+
+    gc.enable()
+    assert application.main(["pymemoryeditor"]) is None
+    assert seen["inside"] is False
+    assert gc.isenabled()
+
+
 def test_scoped_signal_handler_is_a_noop_off_the_main_thread():
     """
     ``signal.signal`` only works on the main thread. The helper must degrade to