PyMemoryEditor 2.0.0__py3-none-any.whl → 2.0.1__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__ = "2.0.0"
+__version__ = "2.0.1"
 
 import logging
 import sys

PyMemoryEditor/linux/functions.py

@@ -30,6 +30,7 @@ from ..process.scanning import (
 from ..process.thread_info import ThreadInfo
 from ..util import (
     _validate_pytype,
+    as_writable_c_buffer,
     get_c_type_of,
     values_to_bytes,
 )
@@ -187,13 +188,13 @@ def get_memory_regions(pid: int) -> Generator["MemoryRegion", None, None]:
 
     with mapping_file:
         for line in mapping_file:
-            region_information = line.split()
+            region_information = line.split(maxsplit=5)
 
             try:
                 addressing_range, privileges, offset, device, inode = (
                     region_information[0:5]
                 )
-                path = region_information[5] if len(region_information) >= 6 else ""
+                path = region_information[5].strip() if len(region_information) >= 6 else ""
 
                 start_address, end_address = [
                     int(addr, 16) for addr in addressing_range.split("-")
@@ -378,6 +379,18 @@ def read_process_memory(pid: int, address: int, pytype: Type[T], bufflength: int
         return data.value
 
 
+def read_process_memory_into(pid: int, address: int, buffer) -> int:
+    """
+    Read ``len(buffer)`` bytes from ``address`` directly into the writable
+    ``buffer``, with no intermediate allocation. Returns the number of bytes
+    read (always the buffer's byte length on success; a short read raises
+    ``_LinuxPartialIOError``).
+    """
+    c_buffer = as_writable_c_buffer(buffer)
+    size = len(c_buffer)
+    return _process_vm_readv(pid, addressof(c_buffer), address, size)
+
+
 def search_addresses_by_value(
     pid: int,
     pytype: Type[T],

PyMemoryEditor/linux/process.py

@@ -21,6 +21,7 @@ from .functions import (
     get_modules,
     get_threads,
     read_process_memory,
+    read_process_memory_into,
     search_addresses_by_pattern,
     search_addresses_by_value,
     search_values_by_addresses,
@@ -117,6 +118,10 @@ class LinuxProcess(AbstractProcess):
             self.pid, address, pytype, resolve_bufflength(pytype, bufflength)
         )
 
+    def read_process_memory_into(self, address: int, buffer: object) -> int:
+        self.__require_open()
+        return read_process_memory_into(self.pid, address, buffer)
+
     def search_by_addresses(
         self,
         pytype: Type[T],

PyMemoryEditor/macos/functions.py

@@ -28,6 +28,7 @@ from ..process.scanning import (
 from ..process.thread_info import ThreadInfo
 from ..util import (
     _validate_pytype,
+    as_writable_c_buffer,
     get_c_type_of,
     values_to_bytes,
 )
@@ -545,6 +546,18 @@ def read_process_memory(
         return data.value
 
 
+def read_process_memory_into(task: int, address: int, buffer) -> int:
+    """
+    Read ``len(buffer)`` bytes from ``address`` directly into the writable
+    ``buffer``, with no intermediate allocation. Returns the number of bytes
+    read (always the buffer's byte length on success; a short read raises
+    ``MachPartialReadError``).
+    """
+    c_buffer = as_writable_c_buffer(buffer)
+    size = len(c_buffer)
+    return _mach_read(task, address, ctypes.addressof(c_buffer), size)
+
+
 def write_process_memory(
     task: int,
     address: int,

PyMemoryEditor/macos/process.py

@@ -25,6 +25,7 @@ from .functions import (
     get_task_for_pid,
     get_threads,
     read_process_memory,
+    read_process_memory_into,
     release_task,
     search_addresses_by_pattern,
     search_addresses_by_value,
@@ -292,6 +293,10 @@ class MacProcess(AbstractProcess):
             self.__task, address, pytype, resolve_bufflength(pytype, bufflength)
         )
 
+    def read_process_memory_into(self, address: int, buffer: object) -> int:
+        self.__require_open()
+        return read_process_memory_into(self.__task, address, buffer)
+
     def write_process_memory(
         self,
         address: int,

PyMemoryEditor/process/abstract.py

@@ -449,6 +449,49 @@ class AbstractProcess(ABC):
         """
         raise NotImplementedError()
 
+    @abstractmethod
+    def read_process_memory_into(self, address: int, buffer: object) -> int:
+        """
+        Read ``len(buffer)`` bytes from ``address`` directly into a
+        pre-allocated, writable ``buffer`` and return the number of bytes read.
+
+        This is the zero-copy counterpart of :meth:`read_process_memory`: where
+        that method allocates a fresh object on every call, this one fills a
+        buffer you own and reuse. In a tight polling / recording loop that reads
+        the same-sized region over and over, reusing one buffer keeps memory use
+        constant instead of producing a stream of short-lived objects for the
+        garbage collector to reclaim.
+
+        :param address: target memory address (ex: 0x006A9EC0).
+        :param buffer: any writable, contiguous buffer-protocol object — a
+            ``bytearray``, a ``ctypes`` array, a writable ``memoryview``, a
+            ``numpy`` array, etc. Its byte length determines how many bytes are
+            read; an element-typed buffer (e.g. a ``numpy`` ``int32`` array) is
+            sized in **bytes**, not elements. The bytes are written in place; no
+            decoding is performed (this is the raw-``bytes`` read path). Decode
+            or reinterpret them yourself afterwards
+            (``int.from_bytes`` / ``struct.unpack`` / ``numpy`` views / ...).
+        :return: the number of bytes read — always equal to the buffer's byte
+            length on success (a short read raises instead, mirroring
+            :meth:`read_process_memory`).
+
+        :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 OSError: if the read fails, or returns fewer bytes than
+            requested (e.g. the range crosses an unreadable/freed page).
+
+        Example
+        -------
+        ::
+
+            buffer = bytearray(16)
+            while recording:
+                process.read_process_memory_into(addr, buffer)
+                handle(buffer)        # same buffer reused every iteration
+        """
+        raise NotImplementedError()
+
     @abstractmethod
     def write_process_memory(
         self,

PyMemoryEditor/util/__init__.py

@@ -4,6 +4,7 @@ from .convert import (
     UNSET,
     _check_int_fits,
     _validate_pytype,
+    as_writable_c_buffer,
     convert_from_byte_array,
     get_c_type_of,
     prepare_write,

PyMemoryEditor/util/convert.py

@@ -209,6 +209,54 @@ def prepare_write(
     return pytype, length, value
 
 
+def as_writable_c_buffer(buffer: Any) -> "ctypes.Array":
+    """
+    Wrap a writable buffer-protocol object as a ``ctypes`` ``c_char`` array
+    that shares the same underlying storage, so a backend can read process
+    memory *directly into the caller's buffer* with no intermediate
+    allocation. Returning the ``ctypes`` array (rather than a bare address)
+    keeps a reference to the source alive for as long as the caller holds it,
+    which is what makes the address safe to pass to the OS read call.
+
+    Accepts anything exposing a writable, contiguous buffer — ``bytearray``,
+    a ``ctypes`` array, a writable ``memoryview``, a ``numpy`` array, etc. The
+    array's byte length is taken from the buffer itself (``memoryview.nbytes``),
+    so element-typed buffers like a ``numpy`` ``int32`` array are sized in
+    bytes, not elements.
+
+    :raises TypeError: if ``buffer`` does not support the buffer protocol or is
+        read-only (e.g. ``bytes`` — use ``bytearray`` instead).
+    :raises ValueError: if ``buffer`` is empty or not contiguous.
+    """
+    try:
+        view = memoryview(buffer)
+    except TypeError:
+        raise TypeError(
+            "buffer must support the writable buffer protocol "
+            "(e.g. bytearray, a ctypes array, or a numpy array), got %s."
+            % type(buffer).__name__
+        )
+
+    try:
+        if view.readonly:
+            raise TypeError(
+                "buffer must be writable; got a read-only buffer "
+                "(e.g. bytes). Use bytearray or another writable buffer."
+            )
+        if not view.contiguous:
+            raise ValueError("buffer must be contiguous.")
+        nbytes = view.nbytes
+    finally:
+        # Release the inspection view promptly so it never lingers as an extra
+        # export on the source object (e.g. blocking a later bytearray resize).
+        view.release()
+
+    if nbytes == 0:
+        raise ValueError("buffer must have a non-zero length.")
+
+    return (ctypes.c_char * nbytes).from_buffer(buffer)
+
+
 def convert_from_byte_array(
     byte_array: ctypes.Array, pytype: Type[T], length: int
 ) -> T:

PyMemoryEditor/win32/functions.py

@@ -27,6 +27,7 @@ from ..process.scanning import (
 from ..process.thread_info import ThreadInfo
 from ..util import (
     _validate_pytype,
+    as_writable_c_buffer,
     get_c_type_of,
     values_to_bytes,
 )
@@ -501,6 +502,40 @@ def ReadProcessMemory(
         return data.value
 
 
+def ReadProcessMemoryInto(process_handle: int, address: int, buffer) -> int:
+    """
+    Read ``len(buffer)`` bytes from ``address`` directly into the writable
+    ``buffer``, with no intermediate allocation. Returns the number of bytes
+    read.
+
+    Raises OSError if the read fails or returns fewer bytes than requested
+    (same partial-read guard as :func:`ReadProcessMemory`).
+    """
+    c_buffer = as_writable_c_buffer(buffer)
+    size = len(c_buffer)
+    bytes_read = ctypes.c_size_t(0)
+
+    ctypes.set_last_error(0)
+    success = kernel32.ReadProcessMemory(
+        process_handle,
+        ctypes.c_void_p(address),
+        ctypes.byref(c_buffer),
+        size,
+        ctypes.byref(bytes_read),
+    )
+
+    if not success:
+        _raise_last_error("ReadProcessMemory")
+
+    if bytes_read.value != size:
+        raise OSError(
+            "ReadProcessMemory partial read at 0x%X: %d of %d bytes read."
+            % (address, bytes_read.value, size)
+        )
+
+    return bytes_read.value
+
+
 def _read_region(process_handle: int, address: int, size: int):
     """Read a memory region; returns the byte buffer or None on failure."""
     region_data = (ctypes.c_byte * size)()

PyMemoryEditor/win32/process.py

@@ -27,6 +27,7 @@ from .functions import (
     GetProcessHandle,
     GetThreads,
     ReadProcessMemory,
+    ReadProcessMemoryInto,
     SearchAddressesByPattern,
     SearchAddressesByValue,
     SearchValuesByAddresses,
@@ -313,6 +314,11 @@ class WindowsProcess(AbstractProcess):
             resolve_bufflength(pytype, bufflength),
         )
 
+    def read_process_memory_into(self, address: int, buffer: object) -> int:
+        self.__require_open()
+        self.__require_read()
+        return ReadProcessMemoryInto(self.__process_handle, address, buffer)
+
     def write_process_memory(
         self,
         address: int,

{pymemoryeditor-2.0.0.dist-info → pymemoryeditor-2.0.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyMemoryEditor
-Version: 2.0.0
+Version: 2.0.1
 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-2.0.0.dist-info → pymemoryeditor-2.0.1.dist-info}/RECORD

@@ -1,4 +1,4 @@
-PyMemoryEditor/__init__.py,sha256=V3znWAe0ZF3a0Y_LxPTHwWkPqyelQSPzv7M9BUT8aWU,3234
+PyMemoryEditor/__init__.py,sha256=t0Ni85aNdANRY5CtAi4ULjQbERLIDnZjbo0rAGI-9JQ,3234
 PyMemoryEditor/__main__.py,sha256=Xon0BV6VbHEIGM1L0RfMJRHIgfSCrI7uxbKsWdp8XbQ,87
 PyMemoryEditor/enums.py,sha256=q_SWQYgh4F7yyAa7sZvNo2Sw91TSm3aTqPfTA7OqldM,322
 PyMemoryEditor/app/__init__.py,sha256=raiaXlRdMUZLMlWIpLHZvDmFf3pIUnbhuMKWQUYmo3Y,226
@@ -23,17 +23,17 @@ PyMemoryEditor/app/scan_worker.py,sha256=Tf_87Ad__OimeUDzTnBSKYMnlrVxomGOGQh6NnD
 PyMemoryEditor/app/scanner_panel.py,sha256=Z4BcN4WYL8_LVZ_7lUGZcqsCSCcTgAR3PNo-FNw8wjQ,18381
 PyMemoryEditor/app/threads_dialog.py,sha256=rZMrxNZ8-uJrBwK8zvkubNsigoBrN36buSyWVhiXOUU,6469
 PyMemoryEditor/app/value_types.py,sha256=3Yq5ms7mb31nLKsvVO8VyyxpEdp6pTdsK1j3ul8ayek,10621
-PyMemoryEditor/linux/functions.py,sha256=jhP9N_eOOkAkVH2_Alx_Cz4yqtnsRoooPu7LAsC0ea8,21154
+PyMemoryEditor/linux/functions.py,sha256=raBILyavPlliEzM4r3z6qEcOWG_G7GUd_d1aWHF9K5U,21681
 PyMemoryEditor/linux/libc.py,sha256=U4yOpHJ48OAaDxcVk_s57GGXlvmyakInwM2liegf3OA,1431
-PyMemoryEditor/linux/process.py,sha256=13RSUUMLCLblFvzfaaqVKlqU6dwxJtsicrEsvj72SdE,8431
+PyMemoryEditor/linux/process.py,sha256=_PafbkQHAcwsQlbwcUFd6ERHN_c4wQ3Qcgyt82Gz2Zw,8636
 PyMemoryEditor/linux/types.py,sha256=sOgO-s9oqKrKKCHMG4N-Pe7sNw49V06PeMENSNnNFl8,1924
 PyMemoryEditor/macos/__init__.py,sha256=85mOA4U5i9EW2r1ggKqRJkqRq0e9bV3I2HdfHIvox10,72
-PyMemoryEditor/macos/functions.py,sha256=MsudOJK85s_eVrLqQZTexuDwjoAPaihyozRFTTVNqug,41768
+PyMemoryEditor/macos/functions.py,sha256=C9_Cg4njd_1pCz-6cDNosnLN1DSRIeF4AK58WNyyNNc,42279
 PyMemoryEditor/macos/libsystem.py,sha256=H9p72IqO0C5CrMFCAjnY_iQCzi_AQgw6ZN6CXsopceo,8683
-PyMemoryEditor/macos/process.py,sha256=2yhFneMQAbBZm-Mhxvs5XpDjENS6wogSJ__bxk6CTzQ,13051
+PyMemoryEditor/macos/process.py,sha256=06zgLaTKIyc1DQZFgS-9lqT2imB_IYFTOs4xEfSgftg,13259
 PyMemoryEditor/macos/types.py,sha256=gttewVsWwwQKzhOhMkkjUTg0_ipH3kKkkQhxmv7oiUE,4855
 PyMemoryEditor/process/__init__.py,sha256=Xh5jngBqZyNIA9y3uwE49LxK8uH8YYsu6qotx1mP_WE,213
-PyMemoryEditor/process/abstract.py,sha256=JU0df3YM17ST2YjSzRX5rkecZEzr5orw5GZZcJFVSGM,51023
+PyMemoryEditor/process/abstract.py,sha256=Q-6_nDssx4zNX0xYiww5K9TX8HFOb35I3U3DQrG8TVE,53205
 PyMemoryEditor/process/errors.py,sha256=485SXkidg9_E_KjuhuF6AsQNuFZlY-Ag-sG1C6NsGMw,2054
 PyMemoryEditor/process/info.py,sha256=p1LXc6tMdf2KAjlHY8d1wNqx1Zo3yqwa3LscWGT2RQg,1317
 PyMemoryEditor/process/module_info.py,sha256=D7qAoBymhe6vrL0IYc2R6ZhWE-OPmYQzf6hSp_f2KmA,2365
@@ -43,13 +43,13 @@ PyMemoryEditor/process/remote_pointer.py,sha256=y2OiBrocmCnDi2Sv1BF7N6UX_AdQKHPA
 PyMemoryEditor/process/scanning.py,sha256=iMzrxrRJf7bc1PXACiiZq0DX4DsSx7IFAgJrNSGHHI4,17384
 PyMemoryEditor/process/thread_info.py,sha256=GeIpfL9TD0YVV75vlBlCUlseCDUNsTDKmxzmCjizjyc,2209
 PyMemoryEditor/process/util.py,sha256=qwh3agrj8B_EDu5LsfMxKFhFSp9YDafXkoUuOUV7owI,3160
-PyMemoryEditor/util/__init__.py,sha256=7j0RoeqBzUD9TtnhglaCBCqIK9qZtse1ETATIABjjm4,486
-PyMemoryEditor/util/convert.py,sha256=41aWtlc3rg1ZUXLFWDeiq7vTCPi0-5AInN2I0iAD15U,12377
+PyMemoryEditor/util/__init__.py,sha256=Lux1_4twAhkzdWDV4xt4INmshKXZAHje_NU2WuwQhoE,512
+PyMemoryEditor/util/convert.py,sha256=CnnJ0wTc8oN5kliAaH4IZJtxI1J0_hS7YKFyVuNyMWU,14399
 PyMemoryEditor/util/pattern.py,sha256=d8PLbTCMwpPiO1HF0tJ0WNXHQ0VG33dJvqAHLGMExf0,4321
 PyMemoryEditor/util/scan.py,sha256=ZCQP2g_ANFdHNmhXf2CayV8zB44IAqHsG2lA7REMKF0,19811
 PyMemoryEditor/util/scan_numpy.py,sha256=osqZh7hfu9meKGXJPROLqzQ-UdSrCduqkv7EzUfVDp4,5889
-PyMemoryEditor/win32/functions.py,sha256=U_eubUCHLwWvv4oiJLDTrAjWhCs71UBjP9QUu8EF-XA,33177
-PyMemoryEditor/win32/process.py,sha256=EzsACFRuDrObc06mjmZD8QO8Jwq9Pfj38n_nbG6JjfE,12464
+PyMemoryEditor/win32/functions.py,sha256=v-OAHBJZEcmLTCbRuqPpprik_CuvYVEuyVH-POAXlM0,34204
+PyMemoryEditor/win32/process.py,sha256=jpBuzMAdOqiwD9peGbQ3d7xZU7Gpp9IDhWrfTmMnXzw,12706
 PyMemoryEditor/win32/types.py,sha256=yzSO2Ojzn7f10G_mS3sJRQO8co3CBYtlVCiKYRrCD5Y,4632
 PyMemoryEditor/win32/enums/__init__.py,sha256=RZXhXb-yCGHVDEi0OxV27w0g2l6b68BIbKhHXyTM3cw,301
 PyMemoryEditor/win32/enums/memory_allocation_states.py,sha256=NTwC9XkUqlCjoSalwykEG2OZUiqXVylcLP2nYSd39zI,953
@@ -59,8 +59,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-2.0.0.dist-info/METADATA,sha256=lM1_4LbJbTQFx_mdmohkxQBemqLYe5euavMws6smLUo,9622
-pymemoryeditor-2.0.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
-pymemoryeditor-2.0.0.dist-info/entry_points.txt,sha256=DHldxZSlpukln94QwxXYiJIuSzVjltYA0MAk3vRkWQk,71
-pymemoryeditor-2.0.0.dist-info/licenses/LICENSE,sha256=YkOx6Nvkavq36bgiAc3eF85SBG0Qu14KMAvxmv6Ssjc,1089
-pymemoryeditor-2.0.0.dist-info/RECORD,,
+pymemoryeditor-2.0.1.dist-info/METADATA,sha256=dY5Py_y0FnxH9sB9kweRMxrTs7Reeu5SquvHsZs1oUg,9622
+pymemoryeditor-2.0.1.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+pymemoryeditor-2.0.1.dist-info/entry_points.txt,sha256=DHldxZSlpukln94QwxXYiJIuSzVjltYA0MAk3vRkWQk,71
+pymemoryeditor-2.0.1.dist-info/licenses/LICENSE,sha256=YkOx6Nvkavq36bgiAc3eF85SBG0Qu14KMAvxmv6Ssjc,1089
+pymemoryeditor-2.0.1.dist-info/RECORD,,