PyMemoryEditor 3.3.1__tar.gz → 3.3.3__tar.gz

{pymemoryeditor-3.3.1 → pymemoryeditor-3.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: PyMemoryEditor
-Version: 3.3.1
+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.1 → pymemoryeditor-3.3.3}/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.1"
+__version__ = "3.3.3"
 
 import logging
 import sys

pymemoryeditor-3.3.3/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.1 → pymemoryeditor-3.3.3}/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.1 → pymemoryeditor-3.3.3}/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.1 → pymemoryeditor-3.3.3}/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-3.3.1 → pymemoryeditor-3.3.3}/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.1 → pymemoryeditor-3.3.3}/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.1 → pymemoryeditor-3.3.3}/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.1"
+    release = "3.3.3"
 
 version = ".".join(release.split(".")[:2])
 

{pymemoryeditor-3.3.1 → pymemoryeditor-3.3.3}/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.1 → pymemoryeditor-3.3.3}/pyproject.toml

@@ -191,7 +191,6 @@ exclude = [
     "/codecov.yml",
     "/.coveragerc-lib",
     "/.coveragerc-mcp",
-    "/.coveragerc-app",
     "/scripts",
     "/server.json",
 ]
@@ -242,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.3.3/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.3.3/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.1 → pymemoryeditor-3.3.3}/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

{pymemoryeditor-3.3.1 → pymemoryeditor-3.3.3}/tests/core/test_abstract_process.py

@@ -9,6 +9,8 @@ keep its own implementations.
 
 import os
 
+import pytest
+
 from PyMemoryEditor import AbstractProcess
 
 
@@ -69,6 +71,22 @@ def test_a_subclass_of_the_earlier_contract_still_instantiates_and_runs_its_own_
     assert list(process.search_by_addresses(int, addresses=[7])) == [(7, "own")]
     assert list(process.get_memory_regions()) == []
     assert process.main_thread is None
+    # Built on the methods above only: no _require_open needed.
+    assert list(process.scan_pointer_paths(0x1000)) == []
+    with pytest.raises(ValueError, match="ptr_size"):
+        process.scan_pointer_paths(0x1000, ptr_size=3)
+
+
+def test_scan_pointer_paths_runs_an_earlier_contract_subclass_own_scanning_check():
+    """A 3.3-contract subclass that adds its own _require_scanning (but no
+    _require_open) still has it run by scan_pointer_paths."""
+
+    class _ChecksScanning(_ContractV3Process):
+        def _require_scanning(self):
+            raise PermissionError("no read access")
+
+    with pytest.raises(PermissionError, match="read access"):
+        _ChecksScanning().scan_pointer_paths(0x1000)
 
 
 def test_every_backend_implements_every_raw_hook():

{pymemoryeditor-3.3.1 → pymemoryeditor-3.3.3}/tests/mcp_server/conftest.py

@@ -46,6 +46,7 @@ import pytest
 
 from PyMemoryEditor.enums import ScanTypesEnum
 from PyMemoryEditor.mcp import MemoryToolset, ServerConfig
+from PyMemoryEditor.mcp import policy as policy_module
 from PyMemoryEditor.process.module_info import ModuleInfo
 from PyMemoryEditor.process.region import MemoryRegion, MemoryRegionSnapshot
 from PyMemoryEditor.process.thread_info import ThreadInfo
@@ -424,3 +425,47 @@ def make_toolset(fake_process: FakeProcess):
 def session(toolset: MemoryToolset) -> Dict[str, Any]:
     """An open session on the fake target."""
     return toolset.open_process(pid=4242)
+
+
+#: The real chain, captured at import -- before the session fixture swaps it.
+_REAL_SELF_AND_ANCESTOR_PIDS = policy_module._self_and_ancestor_pids
+
+#: Stand-ins for this process's ancestors: far above any pid a test makes up,
+#: and above the Linux and macOS pid ranges (Windows pids reach this high only
+#: in theory), so a fake pid never collides with one.
+FAKE_ANCESTOR_PIDS = frozenset({0x7FFF_FF01, 0x7FFF_FF02})
+
+
+@pytest.fixture(scope="session", autouse=True)
+def _fake_ancestor_chain():
+    """Keep made-up pids clear of the real ancestor chain.
+
+    ``ProcessPolicy`` refuses this process and every ancestor. Tests use fixed
+    fake pids (1000, 4242, 5000, ...), and when a real ancestor happens to own
+    one -- a CI runner process at pid 1001 did -- the fake is refused and the
+    test fails for reasons unrelated to the code. So the ancestors are swapped
+    for stand-ins; this process itself stays protected, as a safety net for a
+    test that reaches the real opener.
+
+    Session-scoped so policies built by module-scoped fixtures (the fidelity
+    suite's shared attach) see the stand-ins too. Tests about the protection
+    itself opt back into the real chain with
+    ``@pytest.mark.real_self_protection`` -- a new one must carry it, or it
+    checks the stand-ins.
+    """
+    import os
+
+    with pytest.MonkeyPatch.context() as patch:
+        patch.setattr(
+            policy_module,
+            "_self_and_ancestor_pids",
+            lambda: frozenset({os.getpid()}) | FAKE_ANCESTOR_PIDS,
+        )
+        yield
+
+
+@pytest.fixture(autouse=True)
+def _real_self_protection(request, monkeypatch):
+    """Give ``@pytest.mark.real_self_protection`` tests the real chain back."""
+    if request.node.get_closest_marker("real_self_protection") is not None:
+        monkeypatch.setattr(policy_module, "_self_and_ancestor_pids", _REAL_SELF_AND_ANCESTOR_PIDS)

{pymemoryeditor-3.3.1 → pymemoryeditor-3.3.3}/tests/mcp_server/test_parsing.py

@@ -864,6 +864,7 @@ class TestHttpTransportsRefuseWritesByDefault:
 
 
 class TestServerConfigProtectsItself:
+    @pytest.mark.real_self_protection
     def test_default_policy_refuses_the_server_pid(self):
         import os
 

{pymemoryeditor-3.3.1 → pymemoryeditor-3.3.3}/tests/mcp_server/test_policy.py

@@ -228,6 +228,7 @@ class TestFilterAndDescribe:
         assert described["denied_system_process_count"] > 0
 
 
+@pytest.mark.real_self_protection
 class TestSelfProtection:
     """The server never opens itself or the client that launched it."""
 
@@ -272,8 +273,10 @@ class TestSelfProtection:
         import os
 
         policy = ProcessPolicy(platform="linux", allow_any=True)
-        kept = policy.filter([(os.getpid(), "python"), (5000, "game.exe")])
-        assert kept == [(5000, "game.exe")]
+        # Any pid outside the real chain: this class runs against it.
+        other = next(pid for pid in range(5000, 6000) if pid not in policy.protected_pids)
+        kept = policy.filter([(os.getpid(), "python"), (other, "game.exe")])
+        assert kept == [(other, "game.exe")]
 
     def test_describe_reports_it(self):
         assert ProcessPolicy(platform="linux").describe()["self_protected"] is True
@@ -336,6 +339,7 @@ class TestTruncatedNamesMatchTheAllowlist:
         assert policy.check(5000, "my-very-long-ga").needs_approval is True
 
 
+@pytest.mark.real_self_protection
 class TestTheWholeLaunchChainIsProtected:
     """Under ``uvx`` the server's parent is ``uv``; the client is further up."""
 

{pymemoryeditor-3.3.1 → pymemoryeditor-3.3.3}/tests/mcp_server/test_toolset.py

@@ -1809,6 +1809,7 @@ class TestAttachRechecksTheTargetsIdentity:
         toolset._name_for_pid = lambda pid: next(names)
         assert toolset.open_process(pid=4242)["opened"] is True
 
+    @pytest.mark.real_self_protection
     def test_the_server_refuses_its_own_pid(self, make_toolset):
         import os
 

{pymemoryeditor-3.3.1 → pymemoryeditor-3.3.3}/tests/platforms/test_bitness_fallback_warns.py

@@ -5,10 +5,9 @@ Regression guard: the bitness detectors must *warn* when they can't read the
 target's header and fall back to a guess, instead of mis-detecting silently.
 
 A wrong bitness silently poisons the pointer-width default used by the pointer
-APIs (resolve_pointer_chain / RemotePointer / scan_pointer_paths). The Windows
-path (``IsProcess64Bit``) already warned on the
-``IsWow64Process`` failure; these tests lock the same contract on the macOS and
-Linux fallbacks so a refactor can't drop the warning unnoticed.
+APIs (resolve_pointer_chain / RemotePointer / scan_pointer_paths). These tests
+lock that contract on the Windows (``IsProcess64Bit``), macOS and Linux
+fallbacks so a refactor can't drop the warning unnoticed.
 
 Each test forces the no-header fallback via monkeypatch (no special process or
 permission needed) and asserts a WARNING reaches the ``PyMemoryEditor`` logger.
@@ -74,3 +73,23 @@ def test_is_process_64bit_warns_when_elf_class_unknown(monkeypatch, warning_reco
         r.levelno == logging.WARNING and "is_process_64bit" in r.getMessage()
         for r in warning_records
     )
+
+
+@pytest.mark.skipif(sys.platform != "win32", reason="Windows backend only")
+@pytest.mark.parametrize("host_is_64bit", [False, True])
+def test_is_process_64bit_win32_falls_back_to_host_bitness(
+    monkeypatch, warning_records, host_is_64bit
+):
+    """When IsWow64Process fails the answer is the host's bitness, as the
+    warning says -- not a hardcoded 64-bit, which is wrong from a 32-bit
+    Python."""
+    from PyMemoryEditor.win32 import functions as win
+
+    monkeypatch.setattr(win, "_detect_process_64bit", lambda handle: None)
+    monkeypatch.setattr(win, "_HOST_IS_64BIT", host_is_64bit)
+
+    assert win.IsProcess64Bit(0) is host_is_64bit
+    assert any(
+        r.levelno == logging.WARNING and "IsWow64Process" in r.getMessage()
+        for r in warning_records
+    )