PyMemoryEditor 3.4.0__tar.gz → 3.4.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: PyMemoryEditor
-Version: 3.4.0
+Version: 3.4.2
 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
@@ -38,7 +38,8 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.10
 Provides-Extra: app
 Requires-Dist: psutil<8,>=5.9; extra == 'app'
-Requires-Dist: pyside6<7,>=6.5; extra == 'app'
+Requires-Dist: pyside6<6.12,>=6.5; (python_version < '3.12') and extra == 'app'
+Requires-Dist: pyside6<7,>=6.5; (python_version >= '3.12') and extra == 'app'
 Provides-Extra: dev
 Requires-Dist: build; extra == 'dev'
 Requires-Dist: flake8; extra == 'dev'
@@ -46,7 +47,8 @@ Requires-Dist: hypothesis; extra == 'dev'
 Requires-Dist: mcp<3,>=2; extra == 'dev'
 Requires-Dist: mypy; extra == 'dev'
 Requires-Dist: psutil<8,>=5.9; extra == 'dev'
-Requires-Dist: pyside6<7,>=6.5; extra == 'dev'
+Requires-Dist: pyside6<6.12,>=6.5; (python_version < '3.12') and extra == 'dev'
+Requires-Dist: pyside6<7,>=6.5; (python_version >= '3.12') and extra == 'dev'
 Requires-Dist: pytest; extra == 'dev'
 Requires-Dist: pytest-cov; extra == 'dev'
 Requires-Dist: pytest-qt; extra == 'dev'
@@ -60,7 +62,8 @@ Provides-Extra: tests
 Requires-Dist: hypothesis; extra == 'tests'
 Requires-Dist: mcp<3,>=2; extra == 'tests'
 Requires-Dist: psutil<8,>=5.9; extra == 'tests'
-Requires-Dist: pyside6<7,>=6.5; extra == 'tests'
+Requires-Dist: pyside6<6.12,>=6.5; (python_version < '3.12') and extra == 'tests'
+Requires-Dist: pyside6<7,>=6.5; (python_version >= '3.12') and extra == 'tests'
 Requires-Dist: pytest; extra == 'tests'
 Requires-Dist: pytest-cov; extra == 'tests'
 Requires-Dist: pytest-qt; extra == 'tests'

{pymemoryeditor-3.4.0 → pymemoryeditor-3.4.2}/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.4.0"
+__version__ = "3.4.2"
 
 import logging
 import sys

{pymemoryeditor-3.4.0 → pymemoryeditor-3.4.2}/PyMemoryEditor/mcp/toolset.py

@@ -1946,9 +1946,13 @@ class MemoryToolset:
                     # per region, so one whole multi-gigabyte heap would be
                     # mapped however far past the budget that ran. Aligned
                     # seams cut no pointer slot, and the map merges adjacent
-                    # ranges back, so the result is unchanged.
+                    # ranges back, so the result is unchanged. Unreadable
+                    # regions are left out before cutting: the map skips them
+                    # anyway, and on Windows they are most of the address
+                    # space -- millions of pieces for nothing (#127).
                     memory_regions=split_regions(
-                        regions, self.config.scan_batch_bytes
+                        [region for region in regions if region.is_readable],
+                        self.config.scan_batch_bytes,
                     ),
                     progress_callback=progress,
                     should_stop=should_stop,
@@ -2247,6 +2251,15 @@ class MemoryToolset:
         truncated = False
         timed_out = False
 
+        # Only readable memory can hold a match, and the library drops the
+        # rest itself -- but only once a batch reaches it, after the cutting
+        # and batching here have been paid for. On Windows the snapshot spans
+        # the whole address space, MEM_FREE and MEM_RESERVE included (~128 TiB
+        # on a 64-bit target): cut into 64 MiB pieces, that was ~2 million
+        # batches, and the scan spent its whole budget on them before it
+        # reached the heap (#127).
+        regions = [region for region in regions if region.is_readable]
+
         if split_overlap is not None:
             regions = split_regions(
                 regions, self.config.scan_batch_bytes, overlap=split_overlap

{pymemoryeditor-3.4.0 → pymemoryeditor-3.4.2}/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.4.0"
+    release = "3.4.2"
 
 version = ".".join(release.split(".")[:2])
 

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

@@ -87,8 +87,18 @@ tests = [
 # psutil 7 removed nothing the app uses (Process.name/create_time,
 # pid_exists, process_iter with pid/name/username, and the three exceptions);
 # the app suite passes on 7.2.2.
+#
+# PySide6 6.12.0 is excluded below Python 3.12: its Linux wheels drop a
+# reference to ``None`` on ordinary void Qt calls (upstream PYSIDE-3474), so
+# a long enough session -- a CI worker that has run the app suite -- aborts
+# with ``Fatal Python error: none_dealloc: deallocating None``. On 3.12+ the
+# singletons are immortal (PEP 683) and the leak is harmless, which is why
+# only the 3.10/3.11 cells of the matrix were exposed. The crash took the
+# xdist worker down, and the session then hung until the job's 20-minute
+# timeout. Lift the cap once a 6.12.x release passes the app suite on 3.11.
 app = [
-  "PySide6>=6.5,<7",
+  "PySide6>=6.5,<6.12; python_version < '3.12'",
+  "PySide6>=6.5,<7; python_version >= '3.12'",
   "psutil>=5.9,<8",
 ]
 # The Model Context Protocol server (PyMemoryEditor.mcp), which lets an AI

{pymemoryeditor-3.4.0 → pymemoryeditor-3.4.2}/tests/mcp_server/test_toolset.py

@@ -2656,6 +2656,76 @@ class TestHugeRegionsAreScannedInPieces:
         sizes = [region.size for region in seen["regions"]]
         assert max(sizes) == 0x400 and len(sizes) == 8  # two 4 KiB regions
 
+    @staticmethod
+    def _with_unreadable_space(fake_process, size):
+        """Put a large unreadable region below the fake's two, the way the
+        Windows backend reports MEM_FREE and MEM_RESERVE ranges."""
+        from PyMemoryEditor.process.region import MemoryRegion
+
+        readable = fake_process.get_memory_regions
+
+        def regions():
+            yield MemoryRegion(address=0x1_0000, size=size)  # not readable
+            yield from readable()
+
+        fake_process.get_memory_regions = regions
+
+    def test_unreadable_regions_never_become_batches(
+        self, make_toolset, fake_process, monkeypatch
+    ):
+        """On Windows the snapshot spans the whole address space, MEM_FREE and
+        MEM_RESERVE included. Cut into pieces, that was ~2 million batches on a
+        64-bit target, and scan_value spent its whole budget on them before it
+        reached the heap (#127)."""
+        from PyMemoryEditor.mcp import session as session_module
+
+        monkeypatch.setattr(session_module, "SPLIT_ALIGNMENT", 0x100)
+        monkeypatch.setattr(session_module, "MIN_SPLIT_BYTES", 0x100)
+        self._with_unreadable_space(fake_process, 0x10_0000)
+        address = fake_process.poke(WRITABLE_BASE + 0x40, int, 31337)
+        batches = []
+        original = fake_process.search_by_value
+
+        def counting(*args, **kwargs):
+            batches.append(kwargs["memory_regions"])
+            return original(*args, **kwargs)
+
+        fake_process.search_by_value = counting
+        toolset = make_toolset(config(scan_batch_bytes=0x1000))
+        session_id = toolset.open_process(pid=4242)["session_id"]
+        scan = toolset.scan_value(session_id, "int", "31337", bufflength=4)
+
+        assert scan["count"] == 1 and not scan.get("partial")
+        assert scan["sample"][0]["address"] == "0x%X" % address
+        # One batch per 4 KiB readable region, none for the unreadable 1 MiB
+        # (256 pieces of 4 KiB before the fix).
+        assert len(batches) == 2
+        assert all(region.is_readable for batch in batches for region in batch)
+
+    def test_unreadable_regions_are_not_cut_for_the_pointer_map(
+        self, make_toolset, fake_process, monkeypatch
+    ):
+        """The map skips unreadable regions itself, so cutting them first only
+        cost time and memory -- millions of pieces on Windows (#127)."""
+        from PyMemoryEditor.mcp import session as session_module
+
+        monkeypatch.setattr(session_module, "SPLIT_ALIGNMENT", 0x100)
+        monkeypatch.setattr(session_module, "MIN_SPLIT_BYTES", 0x100)
+        self._with_unreadable_space(fake_process, 0x10_0000)
+        seen = {}
+
+        def capture(target_address, **kwargs):
+            seen["regions"] = kwargs["memory_regions"]
+            return iter(())
+
+        fake_process.scan_pointer_paths = capture
+        toolset = make_toolset(config(scan_batch_bytes=0x400))
+        opened = toolset.open_process(pid=4242)
+        toolset.find_pointer_paths(opened["session_id"], hex(WRITABLE_BASE))
+
+        assert len(seen["regions"]) == 8  # the two 4 KiB regions, as before
+        assert all(region.is_readable for region in seen["regions"])
+
     def test_the_library_does_not_swallow_a_progress_abort(self):
         """find_pointer_paths stops the map by raising from progress_callback;
         that only works if the library lets the exception through."""