PyMemoryEditor 1.0.1__tar.gz → 1.0.3__tar.gz

PyMemoryEditor-1.0.3/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Jean Loui Bernard Silva de Jesus
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

PyMemoryEditor-1.0.3/PKG-INFO

@@ -0,0 +1,64 @@
+Metadata-Version: 2.1
+Name: PyMemoryEditor
+Version: 1.0.3
+Summary: Process memory reader and writer.
+Home-page: https://github.com/JeanExtreme002/PyMemoryEditor
+Author: Jean Loui Bernard Silva de Jesus
+License: MIT
+Keywords: memory writer reader
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Intended Audience :: Developers
+Classifier: Environment :: Win32 (MS Windows)
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# PyMemoryEditor
+
+A Python library developed with [ctypes](https://docs.python.org/3/library/ctypes.html) to manipulate Windows processes (32 bits and 64 bits), <br>
+reading and writing values in the process memory.
+
+[![Python Package](https://github.com/JeanExtreme002/PyMemoryEditor/actions/workflows/python-package.yml/badge.svg)](https://github.com/JeanExtreme002/PyMemoryEditor/actions/workflows/python-package.yml)
+[![Pypi](https://img.shields.io/pypi/v/PyMemoryEditor)](https://pypi.org/project/PyMemoryEditor/)
+[![License](https://img.shields.io/pypi/l/PyMemoryEditor)](https://pypi.org/project/PyMemoryEditor/)
+[![Python Version](https://img.shields.io/badge/python-3.6%20%7C%203.7%20%7C%203.8%20%7C%203.9%20%7C%203.10%20%7C%203.11-blue)](https://pypi.org/project/PyMemoryEditor/)
+[![Downloads](https://static.pepy.tech/personalized-badge/pymemoryeditor?period=total&units=international_system&left_color=grey&right_color=orange&left_text=Downloads)](https://pypi.org/project/PyMemoryEditor/)
+
+# Installing PyMemoryEditor:
+```
+pip3 install PyMemoryEditor
+```
+
+# Basic Usage:
+
+Import `PyMemoryEditor` and open a process using the `OpenProcess` class, passing a window title, process name <br>
+or PID as an argument. You can use the context manager to do this.
+
+```
+from PyMemoryEditor import OpenProcess
+
+with OpenProcess(process_name = "example.exe") as process:
+    # Do something...
+```
+
+After that, use the methods `read_process_memory` and `write_process_memory` to manipulate the process <br>
+memory, passing in the function call the memory address, data type and its size. See the example below:
+
+```
+from PyMemoryEditor import OpenProcess
+
+title = "Window title of an example program"
+address = 0x0005000C
+
+with OpenProcess(window_title = title) as process:
+
+    # Getting value from the process memory.
+    value = process.read_process_memory(address, int, 4)
+
+    # Writing to the process memory.
+    process.write_process_memory(address, int, 4, value + 7)
+```

{PyMemoryEditor-1.0.1 → PyMemoryEditor-1.0.3}/PyMemoryEditor/__init__.py

@@ -6,22 +6,46 @@ reading and writing values in the process memory.
 """
 
 __author__ = "Jean Loui Bernard Silva de Jesus"
-__version__ = "1.0.1"
+__version__ = "1.0.3"
 
 from .process import Process
 from .win32.constants import PROCESS_ALL_ACCESS, PROCESS_VM_OPERATION, PROCESS_VM_READ, PROCESS_VM_WRITE
 from .win32.functions import CloseHandle, GetProcessHandle, ReadProcessMemory, WriteProcessMemory
 
-__all__ = ("OpenProcess", "PROCESS_ALL_ACCESS", "PROCESS_VM_OPERATION", "PROCESS_VM_READ", "PROCESS_VM_WRITE")
+from typing import Optional, Type, Union
 
-class OpenProcess(object):
-
-    def __enter__(self): return self
-
-    def __exit__(self, exc_type, exc_value, exc_traceback): self.close()
+__all__ = (
+    "OpenProcess",
+    "PROCESS_ALL_ACCESS",
+    "PROCESS_VM_OPERATION",
+    "PROCESS_VM_READ",
+    "PROCESS_VM_WRITE"
+)
 
-    def __init__(self, window_title = None, process_name = None, pid = None, permission = PROCESS_ALL_ACCESS):
 
+class OpenProcess(object):
+    """
+    Class to open a process for reading or writing memory.
+    """
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_value, exc_traceback):
+        self.close()
+
+    def __init__(
+        self,
+        window_title: Optional[str] = None,
+        process_name: Optional[str] = None,
+        pid: Optional[int] = None,
+        permission: int = PROCESS_ALL_ACCESS
+    ):
+        """
+        :param window_title: window title of the target program.
+        :param process_name: name of the target process.
+        :param pid: process ID.
+        :param permission: access mode to the process.
+        """
         # Instantiate the permission argument.
         self.__permission = permission
 
@@ -45,40 +69,45 @@ class OpenProcess(object):
         self.__process_handle = GetProcessHandle(permission, False, self.__process.pid)
 
     def close(self):
-
         """
         Close the process handle.
         """
-
         return CloseHandle(self.__process_handle)
 
-    def read_process_memory(self, address, pytype, bufflength):
-
+    def read_process_memory(
+        self,
+        address: int,
+        pytype: Type,
+        bufflength: int
+    ) -> Union[str, int, float]:
         """
         Return a value from a memory address.
 
-        @param address: Target memory address (ex: 0x006A9EC0).
-        @param type_: Type of the value to be received (str, int or float).
-        @param bufflength: Value size in bytes (1, 2, 4, 8).
+        :param address: target memory address (ex: 0x006A9EC0).
+        :param pytype: type of the value to be received (str, int or float).
+        :param bufflength: value size in bytes (1, 2, 4, 8).
         """
-
-        if not self.__permission in [PROCESS_ALL_ACCESS, PROCESS_VM_READ]:
+        if self.__permission not in [PROCESS_ALL_ACCESS, PROCESS_VM_READ]:
             raise PermissionError("The handle does not have permission to read the process memory.")
 
         return win32.functions.ReadProcessMemory(self.__process_handle, address, pytype, bufflength)
 
-    def write_process_memory(self, address, pytype, bufflength, value):
-
+    def write_process_memory(
+        self,
+        address: int,
+        pytype: Type,
+        bufflength: int,
+        value: Union[str, int, float]
+    ) -> Union[str, int, float]:
         """
         Write a value to a memory address.
 
-        @param address: Target memory address (ex: 0x006A9EC0).
-        @param pytype: Type of value to be written into memory (str, int or float).
-        @param bufflength: Value size in bytes (1, 2, 4, 8).
-        @param value: Value to be written (str, int or float).
+        :param address: target memory address (ex: 0x006A9EC0).
+        :param pytype: type of value to be written into memory (str, int or float).
+        :param bufflength: value size in bytes (1, 2, 4, 8).
+        :param value: value to be written (str, int or float).
         """
-
-        if not self.__permission in [PROCESS_ALL_ACCESS, PROCESS_VM_OPERATION | PROCESS_VM_WRITE]:
+        if self.__permission not in [PROCESS_ALL_ACCESS, PROCESS_VM_OPERATION | PROCESS_VM_WRITE]:
             raise PermissionError("The handle does not have permission to write to the process memory.")
 
         return WriteProcessMemory(self.__process_handle, address, pytype, bufflength, value)

{PyMemoryEditor-1.0.1 → PyMemoryEditor-1.0.3}/PyMemoryEditor/process/__init__.py

@@ -3,18 +3,22 @@
 from .errors import ProcessIDNotExistsError, ProcessNotFoundError, WindowNotFoundError
 from .util import get_process_id_by_process_name, get_process_id_by_window_title, pid_exists
 
+
 class Process(object):
+    """
+    Class representing a process.
+    """
 
     __pid = 0
     __process_name = ""
     __window_title = ""
 
     @property
-    def pid(self):
+    def pid(self) -> int:
         return self.__pid
 
     @pid.setter
-    def pid(self, pid):
+    def pid(self, pid: int) -> None:
 
         # Check if the value is an integer.
         if not isinstance(pid, int):
@@ -25,11 +29,11 @@ class Process(object):
         else: raise ProcessIDNotExistsError(pid)
 
     @property
-    def process_name(self):
+    def process_name(self) -> str:
         return self.__process_name
 
     @process_name.setter
-    def process_name(self, process_name):
+    def process_name(self, process_name: str) -> None:
 
         # Get the process ID.
         pid = get_process_id_by_process_name(process_name)
@@ -40,11 +44,11 @@ class Process(object):
         self.__process_name = process_name
 
     @property
-    def window_title(self):
+    def window_title(self) -> str:
         return self.__window_title
 
     @window_title.setter
-    def window_title(self, window_title):
+    def window_title(self, window_title: str) -> None:
 
         # Get the process ID.
         pid = get_process_id_by_window_title(window_title)

{PyMemoryEditor-1.0.1 → PyMemoryEditor-1.0.3}/PyMemoryEditor/process/errors.py

@@ -2,24 +2,26 @@
 
 class ProcessIDNotExistsError(Exception):
 
-    def __init__(self, pid):
+    def __init__(self, pid: int):
         self.__pid = pid
 
-    def __str__(self):
+    def __str__(self) -> str:
         return "The process ID \"%i\" does not exist." % self.__pid
 
+
 class ProcessNotFoundError(Exception):
 
-    def __init__(self, process_name):
+    def __init__(self, process_name: str):
         self.__process_name = process_name
 
-    def __str__(self):
+    def __str__(self) -> str:
         return "Could not find the process \"%s\"." % self.__process_name
 
+
 class WindowNotFoundError(Exception):
 
-    def __init__(self, window_title):
+    def __init__(self, window_title: str):
         self.__window_title = window_title
 
-    def __str__(self):
+    def __str__(self) -> str:
         return "Could not find the window \"%s\"." % self.__window_title

{PyMemoryEditor-1.0.1 → PyMemoryEditor-1.0.3}/PyMemoryEditor/process/util.py

@@ -4,28 +4,24 @@ from win32gui import FindWindow
 from win32process import GetWindowThreadProcessId
 import psutil
 
-def get_process_id_by_process_name(process_name) -> int:
 
+def get_process_id_by_process_name(process_name: str) -> int:
     """
     Get a process name and return its process ID.
     """
-
     for process in psutil.process_iter():
-        if process.name() == process_name: return process.pid
-
-def get_process_id_by_window_title(window_title) -> int:
+        if process.name() == process_name:
+            return process.pid
 
+def get_process_id_by_window_title(window_title: str) -> int:
     """
     Get a window title and return its process ID.
     """
-
     hwnd = FindWindow(None, window_title)
     return GetWindowThreadProcessId(hwnd)[1] if hwnd else 0
 
-def pid_exists(pid) -> bool:
-
+def pid_exists(pid: int) -> bool:
     """
     Check if the process ID exists.
     """
-
     return psutil.pid_exists(pid)

{PyMemoryEditor-1.0.1 → PyMemoryEditor-1.0.3}/PyMemoryEditor/win32/functions.py

@@ -5,28 +5,25 @@ from ctypes import byref, windll, c_void_p
 
 kernel32 = windll.LoadLibrary("kernel32.dll")
 
-def CloseHandle(handle) -> int:
 
+def CloseHandle(handle) -> int:
     """
     Close the process handle.
     """
-
     return kernel32.CloseHandle(handle)
 
-def GetProcessHandle(access_right, inherit, pid) -> int:
 
+def GetProcessHandle(access_right, inherit, pid) -> int:
     """
     Get a process ID and return its process handle.
     """
-
     return kernel32.OpenProcess(access_right, inherit, pid)
 
-def ReadProcessMemory(process_handle, address, pytype, bufflength):
 
+def ReadProcessMemory(process_handle, address, pytype, bufflength):
     """
     Return a value from a memory address.
     """
-
     if not pytype in [str, int, float]: raise ValueError("The type must be string, int or float.")
 
     data = get_c_type_of(pytype, int(bufflength))
@@ -34,12 +31,11 @@ def ReadProcessMemory(process_handle, address, pytype, bufflength):
 
     return data.value
 
-def WriteProcessMemory(process_handle, address, pytype, bufflength, value):
 
+def WriteProcessMemory(process_handle, address, pytype, bufflength, value):
     """
     Write a value to a memory address.
     """
-
     if not pytype in [str, int, float]: raise ValueError("The type must be string, int or float.")
 
     data = get_c_type_of(pytype, int(bufflength))

PyMemoryEditor-1.0.3/PyMemoryEditor/win32/util.py

@@ -0,0 +1,26 @@
+# -*- coding: utf-8 -*-
+
+from typing import Type
+import ctypes
+
+
+def get_c_type_of(pytype: Type, length: int = 1) -> ctypes._SimpleCData:
+    """
+    Return a C type of a primitive type of the Python language.
+    """
+    if pytype is str: return ctypes.create_string_buffer(length)
+
+    elif pytype is int:
+
+        if length == 1: return ctypes.c_int8()      # 1 Byte
+        if length == 2: return ctypes.c_int16()     # 2 Bytes
+        if length <= 4: return ctypes.c_int32()     # 4 Bytes
+        return ctypes.c_int64()                     # 8 Bytes
+
+    # Float values lose their precision when converted to c_float. For that reason,
+    # any float value will be converted to double.
+    elif pytype is float: return ctypes.c_double()  # 8 Bytes
+
+    elif pytype is bool: return ctypes.c_bool()
+
+    else: raise ValueError("The type must be string, int, float or bool.")

PyMemoryEditor-1.0.3/PyMemoryEditor.egg-info/PKG-INFO

@@ -0,0 +1,64 @@
+Metadata-Version: 2.1
+Name: PyMemoryEditor
+Version: 1.0.3
+Summary: Process memory reader and writer.
+Home-page: https://github.com/JeanExtreme002/PyMemoryEditor
+Author: Jean Loui Bernard Silva de Jesus
+License: MIT
+Keywords: memory writer reader
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Intended Audience :: Developers
+Classifier: Environment :: Win32 (MS Windows)
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# PyMemoryEditor
+
+A Python library developed with [ctypes](https://docs.python.org/3/library/ctypes.html) to manipulate Windows processes (32 bits and 64 bits), <br>
+reading and writing values in the process memory.
+
+[![Python Package](https://github.com/JeanExtreme002/PyMemoryEditor/actions/workflows/python-package.yml/badge.svg)](https://github.com/JeanExtreme002/PyMemoryEditor/actions/workflows/python-package.yml)
+[![Pypi](https://img.shields.io/pypi/v/PyMemoryEditor)](https://pypi.org/project/PyMemoryEditor/)
+[![License](https://img.shields.io/pypi/l/PyMemoryEditor)](https://pypi.org/project/PyMemoryEditor/)
+[![Python Version](https://img.shields.io/badge/python-3.6%20%7C%203.7%20%7C%203.8%20%7C%203.9%20%7C%203.10%20%7C%203.11-blue)](https://pypi.org/project/PyMemoryEditor/)
+[![Downloads](https://static.pepy.tech/personalized-badge/pymemoryeditor?period=total&units=international_system&left_color=grey&right_color=orange&left_text=Downloads)](https://pypi.org/project/PyMemoryEditor/)
+
+# Installing PyMemoryEditor:
+```
+pip3 install PyMemoryEditor
+```
+
+# Basic Usage:
+
+Import `PyMemoryEditor` and open a process using the `OpenProcess` class, passing a window title, process name <br>
+or PID as an argument. You can use the context manager to do this.
+
+```
+from PyMemoryEditor import OpenProcess
+
+with OpenProcess(process_name = "example.exe") as process:
+    # Do something...
+```
+
+After that, use the methods `read_process_memory` and `write_process_memory` to manipulate the process <br>
+memory, passing in the function call the memory address, data type and its size. See the example below:
+
+```
+from PyMemoryEditor import OpenProcess
+
+title = "Window title of an example program"
+address = 0x0005000C
+
+with OpenProcess(window_title = title) as process:
+
+    # Getting value from the process memory.
+    value = process.read_process_memory(address, int, 4)
+
+    # Writing to the process memory.
+    process.write_process_memory(address, int, 4, value + 7)
+```

{PyMemoryEditor-1.0.1 → PyMemoryEditor-1.0.3}/PyMemoryEditor.egg-info/SOURCES.txt

@@ -1,3 +1,4 @@
+LICENSE
 README.md
 setup.py
 PyMemoryEditor/__init__.py

{PyMemoryEditor-1.0.1 → PyMemoryEditor-1.0.3}/README.md

@@ -6,7 +6,8 @@ reading and writing values in the process memory.
 [![Python Package](https://github.com/JeanExtreme002/PyMemoryEditor/actions/workflows/python-package.yml/badge.svg)](https://github.com/JeanExtreme002/PyMemoryEditor/actions/workflows/python-package.yml)
 [![Pypi](https://img.shields.io/pypi/v/PyMemoryEditor)](https://pypi.org/project/PyMemoryEditor/)
 [![License](https://img.shields.io/pypi/l/PyMemoryEditor)](https://pypi.org/project/PyMemoryEditor/)
-[![Python Version](https://img.shields.io/badge/python-3.6%20%7C%203.7%20%7C%203.8-blue)](https://pypi.org/project/PyMemoryEditor/)
+[![Python Version](https://img.shields.io/badge/python-3.6%20%7C%203.7%20%7C%203.8%20%7C%203.9%20%7C%203.10%20%7C%203.11-blue)](https://pypi.org/project/PyMemoryEditor/)
+[![Downloads](https://static.pepy.tech/personalized-badge/pymemoryeditor?period=total&units=international_system&left_color=grey&right_color=orange&left_text=Downloads)](https://pypi.org/project/PyMemoryEditor/)
 
 # Installing PyMemoryEditor:
 ```
@@ -25,7 +26,7 @@ with OpenProcess(process_name = "example.exe") as process:
     # Do something...
 ```
 
-After that, use the functions `read_process_memory` and `write_process_memory` to manipulate the process <br>
+After that, use the methods `read_process_memory` and `write_process_memory` to manipulate the process <br>
 memory, passing in the function call the memory address, data type and its size. See the example below:
 
 ```

PyMemoryEditor-1.0.1/PKG-INFO

@@ -1,63 +0,0 @@
-Metadata-Version: 2.1
-Name: PyMemoryEditor
-Version: 1.0.1
-Summary: Process memory reader and writer.
-Home-page: https://github.com/JeanExtreme002/PyMemoryEditor
-Author: Jean Loui Bernard Silva de Jesus
-License: MIT
-Description: # PyMemoryEditor
-        
-        A Python library developed with [ctypes](https://docs.python.org/3/library/ctypes.html) to manipulate Windows processes (32 bits and 64 bits), <br>
-        reading and writing values in the process memory.
-        
-        [![Python Package](https://github.com/JeanExtreme002/PyMemoryEditor/actions/workflows/python-package.yml/badge.svg)](https://github.com/JeanExtreme002/PyMemoryEditor/actions/workflows/python-package.yml)
-        [![Pypi](https://img.shields.io/pypi/v/PyMemoryEditor)](https://pypi.org/project/PyMemoryEditor/)
-        [![License](https://img.shields.io/pypi/l/PyMemoryEditor)](https://pypi.org/project/PyMemoryEditor/)
-        [![Python Version](https://img.shields.io/badge/python-3.6%20%7C%203.7%20%7C%203.8-blue)](https://pypi.org/project/PyMemoryEditor/)
-        
-        # Installing PyMemoryEditor:
-        ```
-        pip3 install PyMemoryEditor
-        ```
-        
-        # Basic Usage:
-        
-        Import `PyMemoryEditor` and open a process using the `OpenProcess` class, passing a window title, process name <br>
-        or PID as an argument. You can use the context manager to do this.
-        
-        ```
-        from PyMemoryEditor import OpenProcess
-        
-        with OpenProcess(process_name = "example.exe") as process:
-            # Do something...
-        ```
-        
-        After that, use the functions `read_process_memory` and `write_process_memory` to manipulate the process <br>
-        memory, passing in the function call the memory address, data type and its size. See the example below:
-        
-        ```
-        from PyMemoryEditor import OpenProcess
-        
-        title = "Window title of an example program"
-        address = 0x0005000C
-        
-        with OpenProcess(window_title = title) as process:
-        
-            # Getting value from the process memory.
-            value = process.read_process_memory(address, int, 4)
-        
-            # Writing to the process memory.
-            process.write_process_memory(address, int, 4, value + 7)
-        ```
-        
-Keywords: memory writer reader
-Platform: UNKNOWN
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Intended Audience :: Developers
-Classifier: Environment :: Win32 (MS Windows)
-Classifier: Operating System :: Microsoft :: Windows
-Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.6
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Description-Content-Type: text/markdown

PyMemoryEditor-1.0.1/PyMemoryEditor/win32/util.py

@@ -1,26 +0,0 @@
-# -*- coding: utf-8 -*-
-
-import ctypes
-
-def get_c_type_of(pytype, length = 1) -> ctypes._SimpleCData:
-
-    """
-    Return a C type of a primitive type of the Python language.
-    """
-
-    if pytype is str: return ctypes.create_string_buffer(length)
-
-    elif pytype is int:
-
-        if length == 1: return ctypes.c_int8()     # 1 Byte
-        if length == 2: return ctypes.c_int16()    # 2 Bytes
-        if length <= 4: return ctypes.c_int32()    # 4 Bytes
-        return ctypes.c_int64()                    # 8 Bytes
-
-    # Float values ​​lose their precision when converted to c_float. For that reason,
-    # any float value will be converted to double.
-    elif pytype is float: return ctypes.c_double()        # 8 Bytes
-
-    elif pytype is bool: return ctypes.c_bool()
-
-    else: raise ValueError("The type must be string, int, float or bool.")

PyMemoryEditor-1.0.1/PyMemoryEditor.egg-info/PKG-INFO

@@ -1,63 +0,0 @@
-Metadata-Version: 2.1
-Name: PyMemoryEditor
-Version: 1.0.1
-Summary: Process memory reader and writer.
-Home-page: https://github.com/JeanExtreme002/PyMemoryEditor
-Author: Jean Loui Bernard Silva de Jesus
-License: MIT
-Description: # PyMemoryEditor
-        
-        A Python library developed with [ctypes](https://docs.python.org/3/library/ctypes.html) to manipulate Windows processes (32 bits and 64 bits), <br>
-        reading and writing values in the process memory.
-        
-        [![Python Package](https://github.com/JeanExtreme002/PyMemoryEditor/actions/workflows/python-package.yml/badge.svg)](https://github.com/JeanExtreme002/PyMemoryEditor/actions/workflows/python-package.yml)
-        [![Pypi](https://img.shields.io/pypi/v/PyMemoryEditor)](https://pypi.org/project/PyMemoryEditor/)
-        [![License](https://img.shields.io/pypi/l/PyMemoryEditor)](https://pypi.org/project/PyMemoryEditor/)
-        [![Python Version](https://img.shields.io/badge/python-3.6%20%7C%203.7%20%7C%203.8-blue)](https://pypi.org/project/PyMemoryEditor/)
-        
-        # Installing PyMemoryEditor:
-        ```
-        pip3 install PyMemoryEditor
-        ```
-        
-        # Basic Usage:
-        
-        Import `PyMemoryEditor` and open a process using the `OpenProcess` class, passing a window title, process name <br>
-        or PID as an argument. You can use the context manager to do this.
-        
-        ```
-        from PyMemoryEditor import OpenProcess
-        
-        with OpenProcess(process_name = "example.exe") as process:
-            # Do something...
-        ```
-        
-        After that, use the functions `read_process_memory` and `write_process_memory` to manipulate the process <br>
-        memory, passing in the function call the memory address, data type and its size. See the example below:
-        
-        ```
-        from PyMemoryEditor import OpenProcess
-        
-        title = "Window title of an example program"
-        address = 0x0005000C
-        
-        with OpenProcess(window_title = title) as process:
-        
-            # Getting value from the process memory.
-            value = process.read_process_memory(address, int, 4)
-        
-            # Writing to the process memory.
-            process.write_process_memory(address, int, 4, value + 7)
-        ```
-        
-Keywords: memory writer reader
-Platform: UNKNOWN
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Intended Audience :: Developers
-Classifier: Environment :: Win32 (MS Windows)
-Classifier: Operating System :: Microsoft :: Windows
-Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.6
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Description-Content-Type: text/markdown