API

This part of the documentation covers all the methods of Pymem. For parts where Pymem depends on external dlls, we document the most important right here and provide links to the canonical documentation.

Pymem

class pymem.Pymem(process_name=None)[source]

Initialize the Pymem class. If process_name is given, will open the process and retrieve a handle over it.

Parameters:process_name (str) – The name of the process to be opened
allocate(size)[source]

Allocate memory into the current opened process.

Parameters:

size (int) – The size of the region of memory to allocate, in bytes.

Raises:
  • ProcessError – If there is no process opened
  • TypeError – If size is not an integer
Returns:

The base address of the current process.

Return type:

HANDLE

base_address

Gets the memory address where the main module was loaded (ie address of exe file in memory)

Raises:
  • TypeError – If process_id is not an integer
  • ProcessError – If could not find process first module address
Returns:

Address of main module

Return type:

int

check_wow64()[source]

Check if a process is running under WoW64.

close_process()[source]

Close the current opened process

Raises:ProcessError – If there is no process opened
free(address)[source]

Free memory from the current opened process given an address.

Parameters:

address (int) – An address of the region of memory to be freed.

Raises:
  • ProcessError – If there is no process opened
  • TypeError – If address is not an integer
inject_python_interpreter(initsigs=1)[source]

Inject python interpreter into target process and call Py_InitializeEx.

inject_python_shellcode(shellcode)[source]

Inject a python shellcode into memory and execute it.

Parameters:shellcode (str) – A string with python instructions.
list_modules()[source]

List a process loaded modules.

Returns:List of process loaded modules
Return type:list(MODULEINFO)
main_thread

Retrieve ThreadEntry32 of main thread given its creation time.

Raises:ProcessError – If there is no process opened or could not list process thread
Returns:Process main thread
Return type:Thread
main_thread_id

Retrieve th32ThreadID from main thread

Raises:ProcessError – If there is no process opened or could not list process thread
Returns:Main thread identifier
Return type:int
open_process_from_id(process_id)[source]

Open process given it’s name and stores the handle into self.process_handle.

Parameters:

process_id (int) – The unique process identifier

Raises:
  • TypeError – If process identifier is not an integer
  • CouldNotOpenProcess – If process cannot be opened
open_process_from_name(process_name)[source]

Open process given it’s name and stores the handle into process_handle

Parameters:

process_name (str) – The name of the process to be opened

Raises:
process_base

Lookup process base Module.

Raises:
  • TypeError – If process_id is not an integer
  • ProcessError – If could not find process first module address
Returns:

Base module information

Return type:

MODULEINFO

read_bool(address)[source]

Reads 1 byte from an area of memory in a specified process.

Parameters:

address (int) – An address of the region of memory to be read.

Raises:
  • ProcessError – If there is no opened process
  • MemoryReadError – If ReadProcessMemory failed
  • TypeError – If address is not a valid integer
Returns:

returns the value read

Return type:

bool

read_bytes(address, length)[source]

Reads bytes from an area of memory in a specified process.

Parameters:
  • address (int) – An address of the region of memory to be read.
  • length (int) – Number of bytes to be read
Raises:
Returns:

the raw value read

Return type:

bytes

read_char(address)[source]

Reads 1 byte from an area of memory in a specified process.

Parameters:

address (int) – An address of the region of memory to be read.

Raises:
  • ProcessError – If there is no opened process
  • MemoryReadError – If ReadProcessMemory failed
  • TypeError – If address is not a valid integer
Returns:

returns the value read

Return type:

str

read_double(address)[source]

Reads 8 byte from an area of memory in a specified process.

Parameters:

address (int) – An address of the region of memory to be read.

Raises:
  • ProcessError – If there is no opened process
  • MemoryReadError – If ReadProcessMemory failed
  • TypeError – If address is not a valid integer
Returns:

returns the value read

Return type:

int

read_float(address)[source]

Reads 4 byte from an area of memory in a specified process.

Parameters:

address (int) – An address of the region of memory to be read.

Raises:
  • ProcessError – If there is no opened process
  • MemoryReadError – If ReadProcessMemory failed
  • TypeError – If address is not a valid integer
Returns:

returns the value read

Return type:

float

read_int(address)[source]

Reads 4 byte from an area of memory in a specified process.

Parameters:

address (int) – An address of the region of memory to be read.

Raises:
  • ProcessError – If there is no opened process
  • MemoryReadError – If ReadProcessMemory failed
  • TypeError – If address is not a valid integer
Returns:

returns the value read

Return type:

int

read_long(address)[source]

Reads 4 byte from an area of memory in a specified process.

Parameters:

address (int) – An address of the region of memory to be read.

Raises:
  • ProcessError – If there is no opened process
  • MemoryReadError – If ReadProcessMemory failed
  • TypeError – If address is not a valid integer
Returns:

returns the value read

Return type:

int

read_longlong(address)[source]

Reads 8 byte from an area of memory in a specified process.

Parameters:

address (int) – An address of the region of memory to be read.

Raises:
  • ProcessError – If there is no opened process
  • MemoryReadError – If ReadProcessMemory failed
  • TypeError – If address is not a valid integer
Returns:

returns the value read

Return type:

int

read_short(address)[source]

Reads 2 byte from an area of memory in a specified process.

Parameters:

address (int) – An address of the region of memory to be read.

Raises:
  • ProcessError – If there is no opened process
  • MemoryReadError – If ReadProcessMemory failed
  • TypeError – If address is not a valid integer
Returns:

returns the value read

Return type:

int

read_string(address, byte=50)[source]

Reads n byte from an area of memory in a specified process.

Parameters:
  • address (int) – An address of the region of memory to be read.
  • byte (int) – Amount of bytes to be read
Raises:
  • ProcessError – If there is no opened process
  • MemoryReadError – If ReadProcessMemory failed
  • TypeError – If address is not a valid integer
Returns:

returns the value read

Return type:

str

read_uchar(address)[source]

Reads 1 byte from an area of memory in a specified process.

Parameters:

address (int) – An address of the region of memory to be read.

Raises:
  • ProcessError – If there is no opened process
  • MemoryReadError – If ReadProcessMemory failed
  • TypeError – If address is not a valid integer
Returns:

returns the value read

Return type:

str

read_uint(address)[source]

Reads 4 byte from an area of memory in a specified process.

Parameters:

address (int) – An address of the region of memory to be read.

Raises:
  • ProcessError – If there is no opened process
  • MemoryReadError – If ReadProcessMemory failed
  • TypeError – If address is not a valid integer
Returns:

returns the value read

Return type:

int

read_ulong(address)[source]

Reads 4 byte from an area of memory in a specified process.

Parameters:

address (int) – An address of the region of memory to be read.

Raises:
  • ProcessError – If there is no opened process
  • MemoryReadError – If ReadProcessMemory failed
  • TypeError – If address is not a valid integer
Returns:

returns the value read

Return type:

int

read_ulonglong(address)[source]

Reads 8 byte from an area of memory in a specified process.

Parameters:

address (int) – An address of the region of memory to be read.

Raises:
  • ProcessError – If there is no opened process
  • MemoryReadError – If ReadProcessMemory failed
  • TypeError – If address is not a valid integer
Returns:

returns the value read

Return type:

int

read_ushort(address)[source]

Reads 2 byte from an area of memory in a specified process.

Parameters:

address (int) – An address of the region of memory to be read.

Raises:
  • ProcessError – If there is no opened process
  • MemoryReadError – If ReadProcessMemory failed
  • TypeError – If address is not a valid integer
Returns:

returns the value read

Return type:

int

start_thread(address, params=None)[source]

Create a new thread within the current debugged process.

Parameters:
  • address (int) – An address from where the thread starts
  • params (int) – An optional address with thread parameters
Returns:

The new thread identifier

Return type:

int

write_bool(address, value)[source]

Write value to the given address into the current opened process.

Parameters:
  • address (int) – An address of the region of memory to be written.
  • value (bool) – the value to be written
Raises:
  • ProcessError – If there is no opened process
  • MemoryWriteError – If WriteProcessMemory failed
  • TypeError – If address is not a valid integer
write_bytes(address, value, length)[source]

Write value to the given address into the current opened process.

Parameters:
  • address (int) – An address of the region of memory to be written.
  • value (bytes) – the value to be written
  • length (int) – Number of bytes to be written
Raises:
  • ProcessError – If there is no opened process
  • MemoryWriteError – If WriteProcessMemory failed
  • TypeError – If address is not a valid integer
write_char(address, value)[source]

Write value to the given address into the current opened process.

Parameters:
  • address (int) – An address of the region of memory to be written.
  • value (str) – the value to be written
Raises:
  • ProcessError – If there is no opened process
  • MemoryWriteError – If WriteProcessMemory failed
  • TypeError – If address is not a valid integer
write_double(address, value)[source]

Write value to the given address into the current opened process.

Parameters:
  • address (int) – An address of the region of memory to be written.
  • value (float) – the value to be written
Raises:
  • ProcessError – If there is no opened process
  • MemoryWriteError – If WriteProcessMemory failed
  • TypeError – If address is not a valid integer
write_float(address, value)[source]

Write value to the given address into the current opened process.

Parameters:
  • address (int) – An address of the region of memory to be written.
  • value (float) – the value to be written
Raises:
  • ProcessError – If there is no opened process
  • MemoryWriteError – If WriteProcessMemory failed
  • TypeError – If address is not a valid integer
write_int(address, value)[source]

Write value to the given address into the current opened process.

Parameters:
  • address (int) – An address of the region of memory to be written.
  • value (int) – the value to be written
Raises:
  • ProcessError – If there is no opened process
  • MemoryWriteError – If WriteProcessMemory failed
  • TypeError – If address is not a valid integer
write_long(address, value)[source]

Write value to the given address into the current opened process.

Parameters:
  • address (int) – An address of the region of memory to be written.
  • value (int) – the value to be written
Raises:
  • ProcessError – If there is no opened process
  • MemoryWriteError – If WriteProcessMemory failed
  • TypeError – If address is not a valid integer
write_longlong(address, value)[source]

Write value to the given address into the current opened process.

Parameters:
  • address (int) – An address of the region of memory to be written.
  • value (int) – the value to be written
Raises:
  • ProcessError – If there is no opened process
  • MemoryWriteError – If WriteProcessMemory failed
  • TypeError – If address is not a valid integer
write_short(address, value)[source]

Write value to the given address into the current opened process.

Parameters:
  • address (int) – An address of the region of memory to be written.
  • value (int) – the value to be written
Raises:
  • ProcessError – If there is no opened process
  • MemoryWriteError – If WriteProcessMemory failed
  • TypeError – If address is not a valid integer
write_string(address, value)[source]

Write value to the given address into the current opened process.

Parameters:
  • address (int) – An address of the region of memory to be written.
  • value (str) – the value to be written
Raises:
  • ProcessError – If there is no opened process
  • MemoryWriteError – If WriteProcessMemory failed
  • TypeError – If address is not a valid integer
write_uchar(address, value)[source]

Write value to the given address into the current opened process.

Parameters:
  • address (int) – An address of the region of memory to be written.
  • value (int) – the value to be written
Raises:
  • ProcessError – If there is no opened process
  • MemoryWriteError – If WriteProcessMemory failed
  • TypeError – If address is not a valid integer
write_uint(address, value)[source]

Write value to the given address into the current opened process.

Parameters:
  • address (int) – An address of the region of memory to be written.
  • value (int) – the value to be written
Raises:
  • ProcessError – If there is no opened process
  • MemoryWriteError – If WriteProcessMemory failed
  • TypeError – If address is not a valid integer
write_ulong(address, value)[source]

Write value to the given address into the current opened process.

Parameters:
  • address (int) – An address of the region of memory to be written.
  • value (int) – the value to be written
Raises:
  • ProcessError – If there is no opened process
  • MemoryWriteError – If WriteProcessMemory failed
  • TypeError – If address is not a valid integer
write_ulonglong(address, value)[source]

Write value to the given address into the current opened process.

Parameters:
  • address (int) – An address of the region of memory to be written.
  • value (int) – the value to be written
Raises:
  • ProcessError – If there is no opened process
  • MemoryWriteError – If WriteProcessMemory failed
  • TypeError – If address is not a valid integer
write_ushort(address, value)[source]

Write value to the given address into the current opened process.

Parameters:
  • address (int) – An address of the region of memory to be written.
  • value (int) – the value to be written
Raises:
  • ProcessError – If there is no opened process
  • MemoryWriteError – If WriteProcessMemory failed
  • TypeError – If address is not a valid integer

Structures

class pymem.ressources.structure.CLIENT_ID[source]
class pymem.ressources.structure.EnumProcessModuleEX[source]

The following are the EnumProcessModuleEX flags

https://msdn.microsoft.com/ru-ru/library/windows/desktop/ms682633(v=vs.85).aspx

LIST_MODULES_32BIT = 1

List the 32-bit modules

LIST_MODULES_64BIT = 2

List the 64-bit modules.

LIST_MODULES_ALL = 3

List all modules.

LIST_MODULES_DEFAULT = 0

Use the default behavior.

class pymem.ressources.structure.FILETIME[source]
class pymem.ressources.structure.FLOATING_SAVE_AREA[source]

Undocumented ctypes.Structure used for ThreadContext.

pymem.ressources.structure.LPMODULEENTRY32

alias of pymem.ressources.structure.LP_ModuleEntry32

pymem.ressources.structure.LPSECURITY_ATTRIBUTES

alias of pymem.ressources.structure.LP_SECURITY_ATTRIBUTES

class pymem.ressources.structure.LUID[source]
class pymem.ressources.structure.LUID_AND_ATTRIBUTES[source]
pymem.ressources.structure.MEMORY_BASIC_INFORMATION

alias of pymem.ressources.structure.MEMORY_BASIC_INFORMATION64

class pymem.ressources.structure.MEMORY_BASIC_INFORMATION32[source]

Contains information about a range of pages in the virtual address space of a process. The VirtualQuery and VirtualQueryEx functions use this structure.

https://msdn.microsoft.com/en-us/library/windows/desktop/aa366775(v=vs.85).aspx

class pymem.ressources.structure.MEMORY_BASIC_INFORMATION64[source]
class pymem.ressources.structure.MEMORY_PROTECTION[source]

The following are the memory-protection options; you must specify one of the following values when allocating or protecting a page in memory https://msdn.microsoft.com/en-us/library/windows/desktop/aa366786(v=vs.85).aspx

PAGE_EXECUTE = 16

Enables execute access to the committed region of pages. An attempt to write to the committed region results in an access violation.

PAGE_EXECUTE_READ = 32

Enables execute or read-only access to the committed region of pages. An attempt to write to the committed region results in an access violation.

PAGE_EXECUTE_READWRITE = 64

Enables execute, read-only, or read/write access to the committed region of pages.

PAGE_EXECUTE_WRITECOPY = 128

Enables execute, read-only, or copy-on-write access to a mapped view of a file mapping object. An attempt to write to a committed copy-on-write page results in a private copy of the page being made for the process. The private page is marked as PAGE_EXECUTE_READWRITE, and the change is written to the new page.

PAGE_GUARD = 256

Pages in the region become guard pages. Any attempt to access a guard page causes the system to raise a STATUS_GUARD_PAGE_VIOLATION exception and turn off the guard page status. Guard pages thus act as a one-time access alarm. For more information, see Creating Guard Pages.

PAGE_NOACCESS = 1

Disables all access to the committed region of pages. An attempt to read from, write to, or execute the committed region results in an access violation.

PAGE_NOCACHE = 512

Sets all pages to be non-cachable. Applications should not use this attribute except when explicitly required for a device. Using the interlocked functions with memory that is mapped with SEC_NOCACHE can result in an EXCEPTION_ILLEGAL_INSTRUCTION exception.

PAGE_READONLY = 2

Enables read-only access to the committed region of pages. An attempt to write to the committed region results in an access violation. If Data Execution Prevention is enabled, an attempt to execute code in the committed region results in an access violation.

PAGE_READWRITE = 4

Enables read-only or read/write access to the committed region of pages. If Data Execution Prevention is enabled, attempting to execute code in the committed region results in an access violation.

PAGE_WRITECOMBINE = 1024

Sets all pages to be write-combined. Applications should not use this attribute except when explicitly required for a device. Using the interlocked functions with memory that is mapped as write-combined can result in an EXCEPTION_ILLEGAL_INSTRUCTION exception.

PAGE_WRITECOPY = 8

Enables read-only or copy-on-write access to a mapped view of a file mapping object. An attempt to write to a committed copy-on-write page results in a private copy of the page being made for the process. The private page is marked as PAGE_READWRITE, and the change is written to the new page. If Data Execution Prevention is enabled, attempting to execute code in the committed region results in an access violation.

class pymem.ressources.structure.MEMORY_STATE[source]

The type of memory allocation

MEM_COMMIT = 4096

Allocates memory charges (from the overall size of memory and the paging files on disk) for the specified reserved memory pages. The function also guarantees that when the caller later initially accesses the memory, the contents will be zero. Actual physical pages are not allocated unless/until the virtual addresses are actually accessed.

MEM_DECOMMIT = 16384

Decommits the specified region of committed pages. After the operation, the pages are in the reserved state. https://msdn.microsoft.com/en-us/library/windows/desktop/aa366894(v=vs.85).aspx

MEM_FREE = 65536

XXX

MEM_RELEASE = 32768

Releases the specified region of pages. After the operation, the pages are in the free state. https://msdn.microsoft.com/en-us/library/windows/desktop/aa366894(v=vs.85).aspx

MEM_RESERVE = 8192

XXX

class pymem.ressources.structure.MEMORY_TYPES[source]

An enumeration.

MEM_IMAGE = 16777216

XXX

MEM_MAPPED = 262144

XXX

MEM_PRIVATE = 131072

XXX

class pymem.ressources.structure.MODULEINFO(handle)[source]

Contains the module load address, size, and entry point.

lpBaseOfDll
SizeOfImage
EntryPoint

https://msdn.microsoft.com/en-us/library/windows/desktop/ms684229(v=vs.85).aspx

class pymem.ressources.structure.ModuleEntry32(*args, **kwds)[source]

Describes an entry from a list of the modules belonging to the specified process.

https://msdn.microsoft.com/en-us/library/windows/desktop/ms684225%28v=vs.85%29.aspx

class pymem.ressources.structure.NT_TIB[source]
class pymem.ressources.structure.PROCESS[source]

Process manipulation flags

DELETE = 65536

Required to delete the object.

PROCESS_ALL_ACCESS = 2035711

All possible access rights for a process object.

PROCESS_CREATE_PROCESS = 128

Required to create a process.

PROCESS_CREATE_THREAD = 2

Required to create a thread.

PROCESS_DUP_HANDLE = 64

PROCESS_DUP_HANDLE

PROCESS_QUERY_INFORMATION = 1024

Required to retrieve certain information about a process, such as its token, exit code, and priority class (see OpenProcessToken).

PROCESS_QUERY_LIMITED_INFORMATION = 4096

Required to retrieve certain information about a process (see GetExitCodeProcess, GetPriorityClass, IsProcessInJob, QueryFullProcessImageName).

PROCESS_SET_INFORMATION = 512

Required to set certain information about a process, such as its priority class (see SetPriorityClass).

PROCESS_SET_QUOTA = 256

Required to set memory limits using SetProcessWorkingSetSize.

PROCESS_SUSPEND_RESUME = 2048

Required to suspend or resume a process.

PROCESS_TERMINATE = 1

Required to terminate a process using TerminateProcess.

PROCESS_VM_OPERATION = 8

Required to perform an operation on the address space of a process (see VirtualProtectEx and WriteProcessMemory).

PROCESS_VM_READ = 16

Required to read memory in a process using ReadProcessMemory.

PROCESS_VM_WRITE = 32

Required to write to memory in a process using WriteProcessMemory.

READ_CONTROL = 131072

Required to read information in the security descriptor for the object, not including the information in the SACL. To read or write the SACL, you must request the ACCESS_SYSTEM_SECURITY access right. For more information see SACL Access Right.

STANDARD_RIGHTS_REQUIRED = 983040

Combines DELETE, READ_CONTROL, WRITE_DAC, and WRITE_OWNER access.

SYNCHRONIZE = 1048576

Required to wait for the process to terminate using the wait functions.

WRITE_DAC = 262144

Required to modify the DACL in the security descriptor for the object.

WRITE_OWNER = 524288

Required to change the owner in the security descriptor for the object.

pymem.ressources.structure.PTOKEN_PRIVILEGES

alias of pymem.ressources.structure.LP_TOKEN_PRIVILEGES

class pymem.ressources.structure.ProcessEntry32(*args, **kwds)[source]

Describes an entry from a list of the processes residing in the system address space when a snapshot was taken.

https://msdn.microsoft.com/en-us/library/windows/desktop/ms684839(v=vs.85).aspx

class pymem.ressources.structure.SECURITY_ATTRIBUTES[source]

The SECURITY_ATTRIBUTES structure contains the security descriptor for an object and specifies whether the handle retrieved by specifying this structure is inheritable.

https://msdn.microsoft.com/en-us/library/windows/desktop/aa379560(v=vs.85).aspx

class pymem.ressources.structure.SE_TOKEN_PRIVILEGE[source]

An access token contains the security information for a logon session. The system creates an access token when a user logs on, and every process executed on behalf of the user has a copy of the token.

class pymem.ressources.structure.SMALL_TEB[source]
class pymem.ressources.structure.SYSTEM_INFO[source]

Contains information about the current computer system. This includes the architecture and type of the processor, the number of processors in the system, the page size, and other such information.

https://msdn.microsoft.com/en-us/library/windows/desktop/ms724958(v=vs.85).aspx

class pymem.ressources.structure.THREAD_BASIC_INFORMATION[source]
class pymem.ressources.structure.TIB_UNION[source]
class pymem.ressources.structure.TOKEN[source]

An enumeration.

class pymem.ressources.structure.TOKEN_PRIVILEGES[source]
class pymem.ressources.structure.ThreadContext[source]

Represents a thread context

class pymem.ressources.structure.ThreadEntry32(*args, **kwds)[source]

Describes an entry from a list of the threads executing in the system when a snapshot was taken.

https://msdn.microsoft.com/en-us/library/windows/desktop/ms686735(v=vs.85).aspx

Pattern

pymem.pattern.pattern_scan_module(handle, module, pattern, *, return_multiple=False)[source]

Given a handle over an opened process and a module will scan memory after a byte pattern and return its corresponding memory address.

Parameters:
  • handle (HANDLE) – Handle to an open object
  • module (MODULEINFO) – An instance of a given module
  • pattern (bytes) – A regex byte pattern to search for
  • return_multiple (bool) – If multiple results should be returned instead of stopping on the first
Returns:

Memory address of given pattern, or None if one was not found or a list of found addresses in return_multiple is True

Return type:

Union[Optional[int], list]

Examples

>>> pm = pymem.Pymem("Notepad.exe")
# Here the "." means that the byte can be any byte; a "wildcard"
# also note that this pattern may be outdated
>>> character_count_pattern = b"."     ...                           b"....d"
>>> module = pymem.process.module_from_name(pm.process_handle, "Notepad.exe")
>>> character_count_address = pymem.pattern.pattern_scan_module(pm.process_handle, module, character_count_pattern)
pymem.pattern.scan_pattern_page(handle, address, pattern, *, return_multiple=False)[source]

Search a byte pattern given a memory location. Will query memory location information and search over until it reaches the length of the memory page. If nothing is found the function returns the next page location.

Parameters:
  • handle (HANDLE) – Handle to an open object
  • address (int) – An address to search from
  • pattern (bytes) – A regex byte pattern to search for
  • return_multiple (bool) – If multiple results should be returned instead of stopping on the first
Returns:

next_region, found address

found address may be None if one was not found or we didn’t have permission to scan the region

if return_multiple is True found address will instead be a list of found addresses or an empty list if no results

Return type:

tuple

Exceptions

exception pymem.exception.CouldNotOpenProcess(process_id)[source]
with_traceback()

Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

exception pymem.exception.MemoryReadError(address, length, error_code=None)[source]
with_traceback()

Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

exception pymem.exception.MemoryWriteError(address, value, error_code=None)[source]
with_traceback()

Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

exception pymem.exception.ProcessError(message)[source]
with_traceback()

Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

exception pymem.exception.ProcessNotFound(process_name)[source]
with_traceback()

Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

exception pymem.exception.PymemAlignmentError(message)[source]
with_traceback()

Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

exception pymem.exception.PymemError(message)[source]
with_traceback()

Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

exception pymem.exception.PymemMemoryError(message)[source]
with_traceback()

Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

exception pymem.exception.PymemTypeError(message)[source]
with_traceback()

Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

exception pymem.exception.WinAPIError(error_code)[source]
with_traceback()

Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.