trainerbase 3.11.4__tar.gz → 3.12.0__tar.gz

trainerbase-3.12.0/PKG-INFO

@@ -0,0 +1,36 @@
+Metadata-Version: 2.1
+Name: trainerbase
+Version: 3.12.0
+Summary: Framework for creating game trainers/mods
+Home-page: https://gitlab.com/python-trainers/trainer-base
+License: MIT
+Author: v01d
+Author-email: v01d@v01d.ru
+Requires-Python: >=3.12,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: dearpygui (>=1.11.1,<2.0.0)
+Requires-Dist: keyboard (>=0.13.5,<0.14.0)
+Requires-Dist: psutil (>=5.9.8,<6.0.0)
+Requires-Dist: pyinjector (>=1.3.0,<2.0.0)
+Requires-Dist: pymem (>=1.13.1,<2.0.0)
+Requires-Dist: pyttsx3 (>=2.90,<3.0)
+Project-URL: Repository, https://gitlab.com/python-trainers/trainer-base
+Description-Content-Type: text/markdown
+
+# Trainer Base
+
+[![PyPI version](https://badge.fury.io/py/TrainerBase.svg)](https://badge.fury.io/py/TrainerBase)
+[![Downloads](https://static.pepy.tech/badge/trainerbase)](https://pepy.tech/project/trainerbase)
+
+## To create project from template using cookiecutter
+
+```bash
+cookiecutter https://gitlab.com/v01d-gl/basic-project-template.git --checkout trainerbase
+```
+
+## Examples
+
+[Python Trainers](https://gitlab.com/python-trainers)
+

trainerbase-3.12.0/README.md

@@ -0,0 +1,14 @@
+# Trainer Base
+
+[![PyPI version](https://badge.fury.io/py/TrainerBase.svg)](https://badge.fury.io/py/TrainerBase)
+[![Downloads](https://static.pepy.tech/badge/trainerbase)](https://pepy.tech/project/trainerbase)
+
+## To create project from template using cookiecutter
+
+```bash
+cookiecutter https://gitlab.com/v01d-gl/basic-project-template.git --checkout trainerbase
+```
+
+## Examples
+
+[Python Trainers](https://gitlab.com/python-trainers)

{trainerbase-3.11.4 → trainerbase-3.12.0}/pyproject.toml

@@ -1,10 +1,10 @@
 [tool.poetry]
 name = "trainerbase"
-version = "3.11.4"
+version = "3.12.0"
 description = "Framework for creating game trainers/mods"
 authors = ["v01d <v01d@v01d.ru>", "doomayka <zd@doomayka.ru>"]
 license = "MIT"
-readme = "README.rst"
+readme = "README.md"
 homepage = "https://gitlab.com/python-trainers/trainer-base"
 repository = "https://gitlab.com/python-trainers/trainer-base"
 
@@ -16,28 +16,44 @@ include = [
     { path = "trainerbase_vendor/", format = ["sdist", "wheel"] },
 ]
 
-[tool.black]
-target-version = ["py312"]
+[tool.poetry.group.dev.dependencies]
+ruff = "^0.4.4"
+
+[tool.ruff]
+src = ["trainerbase"]
 line-length = 120
 
-[tool.isort]
-lines_after_imports = 2
-skip = "trainerbase/template/"
+[tool.ruff.lint]
+select = [
+    "E",  # pycodestyle
+    "F",  # Pyflakes
+    "UP",  # pyupgrade
+    "B",  # flake8-bugbear
+    "SIM",  # flake8-simplify
+    "I",  # isort
+    "N",  # pep8-naming
+    "FIX",
+    "FBT",
+    "ARG",
+    "PTH",
+    "ERA",
+    "RUF",
+]
+
+[tool.ruff.lint.isort]
+lines-after-imports = 2
+
+[tool.ruff.format]
+line-ending = "lf"
 
 [tool.poetry.dependencies]
 python = "^3.12"
 pymem = "^1.13.1"
-dearpygui = "^1.10.1"
+dearpygui = "^1.11.1"
 keyboard = "^0.13.5"
 pyttsx3 = "^2.90"
 pyinjector = "^1.3.0"
-
-[tool.poetry.group.dev.dependencies]
-isort = "^5.13.2"
-black = "^23.12.1"
-pylint = "^3.0.3"
-docutils = "^0.20.1"
-pygments = "^2.16.1"
+psutil = "^5.9.8"
 
 [build-system]
 requires = ["poetry-core"]

{trainerbase-3.11.4 → trainerbase-3.12.0}/trainerbase/codeinjection.py

@@ -1,9 +1,10 @@
 from abc import ABC, abstractmethod
+from contextlib import suppress
 from pathlib import Path
 from subprocess import DEVNULL
 from subprocess import run as run_executable
 from tempfile import TemporaryDirectory
-from typing import Final, Never, Self, override
+from typing import ClassVar, Final, Never, Self, override
 
 from pymem.exception import MemoryWriteError
 
@@ -17,7 +18,7 @@ type Code = bytes | str
 
 
 class AbstractCodeInjection(ABC):
-    created_code_injections: list[Self] = []
+    created_code_injections: ClassVar[list[Self]] = []
 
     def __new__(cls, *_args, **_kwargs):
         instance = super().__new__(cls)
@@ -43,20 +44,21 @@ class CodeInjection(AbstractCodeInjection):
         self.address = ensure_address(address)
         self.code_to_inject = compile_asm(code_to_inject)
         self.original_code: bytes = b""
+        self.injection_point: int = 0
         self._injected = False
 
     @override
     def inject(self):
-        injection_point = self.address.resolve()
+        self.injection_point = self.address.resolve()
 
-        self.original_code = pm.read_bytes(injection_point, len(self.code_to_inject))
-        pm.write_bytes(injection_point, self.code_to_inject, len(self.code_to_inject))
+        self.original_code = pm.read_bytes(self.injection_point, len(self.code_to_inject))
+        pm.write_bytes(self.injection_point, self.code_to_inject, len(self.code_to_inject))
         self._injected = True
 
     @override
     def eject(self):
         if self._injected:
-            pm.write_bytes(self.address.resolve(), self.original_code, len(self.original_code))
+            pm.write_bytes(self.injection_point, self.original_code, len(self.original_code))
             self._injected = False
 
 
@@ -89,24 +91,25 @@ class AllocatingCodeInjection(AbstractCodeInjection):  # pylint: disable=too-man
         self.original_code_length = original_code_length
         self.new_memory_size = new_memory_size
         self.new_memory_address: int = 0
+        self.injection_point: int = 0
 
     @override
     def inject(self):
-        injection_point = self.address.resolve()
+        self.injection_point = self.address.resolve()
 
         self.new_memory_address: int = pm.allocate(self.new_memory_size)
 
-        self.original_code = pm.read_bytes(injection_point, self.original_code_length)
+        self.original_code = pm.read_bytes(self.injection_point, self.original_code_length)
 
         if pm.is_64_bit:
             jump_to_new_mem = compile_asm(get_long_x64_jump_to_new_mem_code(self.new_memory_address))
             jumper_length = len(jump_to_new_mem)
-            jump_back_address = injection_point + jumper_length - 1
+            jump_back_address = self.injection_point + jumper_length - 1
             jump_back = compile_asm(get_long_x64_jump_back_code(jump_back_address))
         else:
-            jump_to_new_mem = compile_asm(get_simple_jump_code(self.new_memory_address, injection_point))
+            jump_to_new_mem = compile_asm(get_simple_jump_code(self.new_memory_address, self.injection_point))
             jumper_length = len(jump_to_new_mem)
-            jump_back_address = injection_point + jumper_length
+            jump_back_address = self.injection_point + jumper_length
             jump_back = compile_asm(
                 get_simple_jump_code(jump_back_address, self.new_memory_address + len(self.code_to_inject)),
             )
@@ -119,14 +122,15 @@ class AllocatingCodeInjection(AbstractCodeInjection):  # pylint: disable=too-man
         code_to_inject = self.code_to_inject + jump_back
 
         pm.write_bytes(self.new_memory_address, code_to_inject, len(code_to_inject))
-        pm.write_bytes(injection_point, jump_to_new_mem, len(jump_to_new_mem))
+        pm.write_bytes(self.injection_point, jump_to_new_mem, len(jump_to_new_mem))
 
     @override
     def eject(self):
-        if self.new_memory_address:
-            pm.write_bytes(self.address.resolve(), self.original_code, self.original_code_length)
+        if self.new_memory_address and self.injection_point:
+            pm.write_bytes(self.injection_point, self.original_code, self.original_code_length)
             pm.free(self.new_memory_address)
             self.new_memory_address = 0
+            self.injection_point = 0
 
 
 class MultipleCodeInjection(AbstractCodeInjection):
@@ -186,8 +190,6 @@ def get_long_x64_jump_back_code(address: int) -> str:
 
 
 def safely_eject_all_code_injections() -> None:
-    try:
-        for injection in AbstractCodeInjection.created_code_injections:
+    for injection in AbstractCodeInjection.created_code_injections:
+        with suppress(MemoryWriteError):
             injection.eject()
-    except MemoryWriteError:  # Game process exited
-        return

{trainerbase-3.11.4 → trainerbase-3.12.0}/trainerbase/common/helpers.py

@@ -2,7 +2,7 @@ from collections.abc import Iterator, Sequence
 from uuid import uuid4
 
 from trainerbase.gameobject import AbstractReadableObject, GameObject
-from trainerbase.memory import POINTER_SIZE, Address, allocate_pointer, pm
+from trainerbase.memory import POINTER_SIZE, Address, allocate, pm
 
 
 type Number = int | float
@@ -24,13 +24,13 @@ class ASMArrayManager(Sequence):
         self.offsets = [] if offsets is None else offsets
         self.add = add
 
-        self.array_address = pm.allocate(array_length * element_size)
-        self.array_index_pointer = allocate_pointer()
+        self.array_address = allocate(element_size, array_length)
+        self.array_index_pointer = allocate()
 
     def __len__(self) -> int:
         return self.array_length
 
-    def __getitem__(self, index: int) -> Address:
+    def __getitem__(self, index: int) -> Address:  # type: ignore TODO: Support slices
         element_address = self.get_pointer_to_element(index)
         target_address = Address(element_address, self.offsets, self.add)
 

{trainerbase-3.11.4 → trainerbase-3.12.0}/trainerbase/common/teleport.py

@@ -84,6 +84,9 @@ class Teleport:
         return self.player_x.value, self.player_y.value, self.player_z.value
 
     def goto(self, label: str) -> None:
+        if label not in self.labels:
+            return
+
         self.set_coords(*self.labels[label])
 
     def save_position(self) -> None:

{trainerbase-3.11.4 → trainerbase-3.12.0}/trainerbase/config.py

@@ -1,4 +1,5 @@
 from pathlib import Path
+
 from tomllib import load as load_toml
 
 

{trainerbase-3.11.4 → trainerbase-3.12.0}/trainerbase/gameobject.py

@@ -1,5 +1,8 @@
 from abc import ABC, abstractmethod
-from typing import Self, override
+from collections.abc import Callable
+from contextlib import suppress
+from ctypes import c_bool, c_byte, c_double, c_float, c_int, c_longlong, c_short, sizeof
+from typing import ClassVar, Self, cast, override
 
 from pymem.exception import MemoryWriteError
 
@@ -15,22 +18,24 @@ class AbstractReadableObject[T](ABC):
 
 
 class GameObject[PymemType, TrainerBaseType](AbstractReadableObject[TrainerBaseType]):
-    tracked_objects: list[Self] = []
-    value_range: None | tuple[TrainerBaseType, TrainerBaseType] = None
+    tracked_objects: ClassVar[list[Self]] = []
+    value_range: tuple[TrainerBaseType, TrainerBaseType]
+    ctype_size: int
 
     @staticmethod
     @abstractmethod
-    def pm_read(address: int) -> PymemType:
+    def pm_read(address: int, /) -> PymemType:
         pass
 
     @staticmethod
     @abstractmethod
-    def pm_write(address: int, value: PymemType) -> None:
+    def pm_write(address: int, value: PymemType, /) -> None:
         pass
 
     def __init__(
         self,
         address: ConvertibleToAddress,
+        *,
         frozen: TrainerBaseType | None = None,
         is_tracked: bool = True,
         value_range: None | tuple[TrainerBaseType, TrainerBaseType] = None,
@@ -55,10 +60,10 @@ class GameObject[PymemType, TrainerBaseType](AbstractReadableObject[TrainerBaseT
         )
 
     def after_read(self, value: PymemType) -> TrainerBaseType:
-        return value  # type: ignore
+        return cast(TrainerBaseType, value)
 
     def before_write(self, value: TrainerBaseType) -> PymemType:
-        return value  # type: ignore
+        return cast(PymemType, value)
 
     def validate_range(self, value: TrainerBaseType) -> bool:
         if self.value_range is None:
@@ -69,7 +74,7 @@ class GameObject[PymemType, TrainerBaseType](AbstractReadableObject[TrainerBaseT
 
         min_value, max_value = self.value_range
 
-        return min_value <= value <= max_value  # type: ignore
+        return cast(int | float, min_value) <= value <= cast(int | float, max_value)
 
     @property
     @override
@@ -85,8 +90,9 @@ class GameObject[PymemType, TrainerBaseType](AbstractReadableObject[TrainerBaseT
 
 
 class GameFloat(GameObject[float, float]):
-    value_range: tuple[float, float] = (-3.4e38, 3.4e38)
-    pm_read = pm.read_float  # type: ignore
+    value_range = (-3.4e38, 3.4e38)
+    ctype_size = sizeof(c_float)
+    pm_read = cast(Callable[[int], float], pm.read_float)
     pm_write = pm.write_float
 
     @override
@@ -95,8 +101,9 @@ class GameFloat(GameObject[float, float]):
 
 
 class GameDouble(GameObject[float, float]):
-    value_range: tuple[float, float] = (-1.7e308, 1.7e308)
-    pm_read = pm.read_double  # type: ignore
+    value_range = (-1.7e308, 1.7e308)
+    ctype_size = sizeof(c_double)
+    pm_read = cast(Callable[[int], float], pm.read_double)
     pm_write = pm.write_double
 
     @override
@@ -105,7 +112,8 @@ class GameDouble(GameObject[float, float]):
 
 
 class GameByte(GameObject[bytes, int]):
-    value_range: tuple[int, int] = (0, 255)
+    value_range = (0, 255)
+    ctype_size = sizeof(c_byte)
 
     @staticmethod
     @override
@@ -127,51 +135,58 @@ class GameByte(GameObject[bytes, int]):
 
 
 class GameInt(GameObject[int, int]):
-    value_range: tuple[int, int] = (-2_147_483_648, 2_147_483_647)
+    value_range = (-2_147_483_648, 2_147_483_647)
+    ctype_size = sizeof(c_int)
 
-    pm_read = pm.read_int  # type: ignore
+    pm_read = cast(Callable[[int], int], pm.read_int)
     pm_write = pm.write_int
 
 
 class GameShort(GameObject[int, int]):
-    value_range: tuple[int, int] = (-32_768, 32_767)
+    value_range = (-32_768, 32_767)
+    ctype_size = sizeof(c_short)
 
-    pm_read = pm.read_short  # type: ignore
+    pm_read = cast(Callable[[int], int], pm.read_short)
     pm_write = pm.write_short
 
 
 class GameLongLong(GameObject[int, int]):
-    value_range: tuple[int, int] = (-(2**63), (2**63) - 1)
+    value_range = (-(2**63), (2**63) - 1)
+    ctype_size = sizeof(c_longlong)
 
-    pm_read = pm.read_longlong  # type: ignore
+    pm_read = cast(Callable[[int], int], pm.read_longlong)
     pm_write = pm.write_longlong
 
 
 class GameUnsignedInt(GameObject[int, int]):
-    value_range: tuple[int, int] = (0, 4_294_967_295)
+    value_range = (0, 4_294_967_295)
+    ctype_size = sizeof(c_int)
 
-    pm_read = pm.read_uint  # type: ignore
+    pm_read = cast(Callable[[int], int], pm.read_uint)
     pm_write = pm.write_uint
 
 
 class GameUnsignedShort(GameObject[int, int]):
-    value_range: tuple[int, int] = (0, 65_535)
+    value_range = (0, 65_535)
+    ctype_size = sizeof(c_short)
 
-    pm_read = pm.read_ushort  # type: ignore
+    pm_read = cast(Callable[[int], int], pm.read_ushort)
     pm_write = pm.write_ushort
 
 
 class GameUnsignedLongLong(GameObject[int, int]):
-    value_range: tuple[int, int] = (0, 18_446_744_073_709_551_615)
+    value_range = (0, 18_446_744_073_709_551_615)
+    ctype_size = sizeof(c_longlong)
 
-    pm_read = pm.read_ulonglong  # type: ignore
+    pm_read = cast(Callable[[int], int], pm.read_ulonglong)
     pm_write = pm.write_ulonglong
 
 
 class GameBool(GameObject[bool, bool], Switchable):
-    value_range: tuple[bool, bool] = (False, True)
+    value_range = (False, True)
+    ctype_size = sizeof(c_bool)
 
-    pm_read = pm.read_bool  # type: ignore
+    pm_read = cast(Callable[[int], bool], pm.read_bool)
     pm_write = pm.write_bool
 
     @override
@@ -194,8 +209,8 @@ class ReadonlyGameObjectSumGetter(AbstractReadableObject[int | float]):
 
 def update_frozen_objects():
     for game_object in GameObject.tracked_objects:
-        if game_object.frozen is not None:
-            try:
-                game_object.value = game_object.frozen
-            except (MemoryWriteError, ValueError):
-                continue
+        if game_object.frozen is None:
+            continue
+
+        with suppress(MemoryWriteError, ValueError):
+            game_object.value = game_object.frozen

{trainerbase-3.11.4 → trainerbase-3.12.0}/trainerbase/gui/injections.py

@@ -18,6 +18,7 @@ class CodeInjectionUI(AbstractUIComponent):
         injection: AbstractCodeInjection,
         label: str,
         hotkey: str | None = None,
+        *,
         tts_on_hotkey: bool = True,
     ):
         self.injection = injection
@@ -36,10 +37,7 @@ class CodeInjectionUI(AbstractUIComponent):
         dpg.add_checkbox(label=self.label_with_hotkey, tag=self.dpg_tag, callback=self.on_codeinjection_state_change)
 
     def on_codeinjection_state_change(self):
-        if dpg.get_value(self.dpg_tag):
-            change_codeinjection_state = self.injection.inject
-        else:
-            change_codeinjection_state = self.injection.eject
+        change_codeinjection_state = self.injection.inject if dpg.get_value(self.dpg_tag) else self.injection.eject
 
         try:
             change_codeinjection_state()

{trainerbase-3.11.4 → trainerbase-3.12.0}/trainerbase/gui/objects.py

@@ -1,5 +1,6 @@
 from collections.abc import Callable
-from typing import Any, Self, override
+from contextlib import suppress
+from typing import Any, ClassVar, Self, override
 from uuid import uuid4
 
 from dearpygui import dearpygui as dpg
@@ -29,7 +30,7 @@ class GameObjectUI(AbstractUIComponent):
     DPG_TAG_POSTFIX_GETTER = "__getter"
     DPG_TAG_POSTFIX_SETTER = "__setter"
 
-    displayed_objects: list[Self] = []
+    displayed_objects: ClassVar[list[Self]] = []
 
     def __init__(
         self,
@@ -37,6 +38,7 @@ class GameObjectUI(AbstractUIComponent):
         label: str,
         freeze_hotkey: str | None = None,
         set_hotkey: str | None = None,
+        *,
         default_setter_input_value: Any = 0,
         before_set: Callable | None = None,
         tts_on_hotkey: bool = True,
@@ -77,10 +79,7 @@ class GameObjectUI(AbstractUIComponent):
 
             self.add_setter_input()
 
-            if self.set_hotkey is None:
-                setter_button_text = "Set"
-            else:
-                setter_button_text = f"[{self.set_hotkey}] Set"
+            setter_button_text = "Set" if self.set_hotkey is None else f"[{self.set_hotkey}] Set"
 
             dpg.add_button(label=setter_button_text, callback=self.on_value_set)
 
@@ -117,12 +116,12 @@ class GameObjectUI(AbstractUIComponent):
                 # There is no input for integers that are not simple `signed long int`.
                 # TODO: Use better input component if it's already added to dpg. Remove this crutch.
 
-                min_value = default_kwargs.pop("min_value", GameInt.value_range[0])
-                max_value = default_kwargs.pop("max_value", GameInt.value_range[1])
+                min_value = default_kwargs.pop("min_value", GameInt.value_range[0])  # type: ignore
+                max_value = default_kwargs.pop("max_value", GameInt.value_range[1])  # type: ignore
 
                 if self.gameobject.value_range is not None:
-                    min_value = max(min_value, GameInt.value_range[0])
-                    max_value = min(max_value, GameInt.value_range[1])
+                    min_value = max(min_value, GameInt.value_range[0])  # type: ignore
+                    max_value = min(max_value, GameInt.value_range[1])  # type: ignore
 
                 dpg.add_input_int(min_value=min_value, max_value=max_value, **default_kwargs)
             case GameBool():
@@ -137,17 +136,15 @@ class GameObjectUI(AbstractUIComponent):
         try:
             self.gameobject.frozen = self.gameobject.value if dpg.get_value(self.dpg_tag_frozen) else None
         except MemoryReadError:
-            dpg.set_value(self.dpg_tag_frozen, False)
+            dpg.set_value(self.dpg_tag_frozen, value=False)
 
     def on_value_set(self):
         raw_new_value = dpg.get_value(self.dpg_tag_setter)
         new_value = raw_new_value if self.before_set is None else self.before_set(raw_new_value)
 
         if self.gameobject.frozen is None:
-            try:
+            with suppress(MemoryWriteError, ValueError):
                 self.gameobject.value = new_value
-            except (MemoryWriteError, ValueError):
-                pass
         else:
             self.gameobject.frozen = new_value
 

{trainerbase-3.11.4 → trainerbase-3.12.0}/trainerbase/gui/scripts.py

@@ -17,6 +17,7 @@ class ScriptUI(AbstractUIComponent):
         script: Script,
         label: str,
         hotkey: str | None = None,
+        *,
         tts_on_hotkey: bool = True,
     ):
         self.script = script

{trainerbase-3.11.4 → trainerbase-3.12.0}/trainerbase/gui/teleport.py

@@ -12,6 +12,7 @@ from trainerbase.tts import say
 
 class TeleportUI(AbstractUIComponent):
     DPG_TAG_TELEPORT_LABELS = "__teleport_labels"
+    DPG_TAG_TELEPORT_LABEL_FILTER_INPUT = "__dpg_tag_teleport_label_filter_input"
 
     def __init__(
         self,
@@ -19,6 +20,7 @@ class TeleportUI(AbstractUIComponent):
         hotkey_save_position: str | None = "Insert",
         hotkey_set_saved_position: str | None = "Home",
         hotkey_dash: str | None = "End",
+        *,
         tts_on_hotkey: bool = True,
     ):
         self.tp = tp
@@ -87,8 +89,26 @@ class TeleportUI(AbstractUIComponent):
         if not self.tp.labels:
             return
 
-        labels = sorted(self.tp.labels.keys())
+        dpg.add_input_text(
+            label="Search",
+            tag=self.DPG_TAG_TELEPORT_LABEL_FILTER_INPUT,
+            callback=self._on_apply_filter,
+        )
 
         with dpg.group(horizontal=True):
             dpg.add_button(label="Go To", callback=self.on_goto_label)
-            dpg.add_combo(label="Labels", tag=self.DPG_TAG_TELEPORT_LABELS, items=labels, default_value=labels[0])
+            dpg.add_combo(label="Labels", tag=self.DPG_TAG_TELEPORT_LABELS)
+
+        self._on_apply_filter()
+
+    def _on_apply_filter(self):
+        label_name_part = dpg.get_value(self.DPG_TAG_TELEPORT_LABEL_FILTER_INPUT)
+        new_labels = {
+            label: coords for label, coords in self.tp.labels.items() if label_name_part.lower() in label.lower()
+        }
+
+        new_label_names = sorted(new_labels.keys())
+
+        default_value = new_label_names[0] if new_label_names else "<No results!>"
+
+        dpg.configure_item(self.DPG_TAG_TELEPORT_LABELS, items=new_label_names, default_value=default_value)

{trainerbase-3.11.4 → trainerbase-3.12.0}/trainerbase/main.py

@@ -6,8 +6,9 @@ from typing import NoReturn
 
 from trainerbase.codeinjection import safely_eject_all_code_injections
 from trainerbase.gameobject import update_frozen_objects
-from trainerbase.gui import update_displayed_objects
-from trainerbase.scriptengine import Script, system_script_engine
+from trainerbase.gui.objects import update_displayed_objects
+from trainerbase.process import show_message_and_shutdown_if_process_exited
+from trainerbase.scriptengine import Script, process_healthcheck_script_engine, system_script_engine
 from trainerbase.speedhack import SpeedHack
 
 
@@ -18,6 +19,7 @@ def run(  # pylint: disable=too-complex
 ) -> NoReturn:
     def on_shutdown() -> NoReturn:
         system_script_engine.stop()
+        process_healthcheck_script_engine.stop()
         safely_eject_all_code_injections()
         SpeedHack.disable()
 
@@ -28,20 +30,22 @@ def run(  # pylint: disable=too-complex
 
     def on_gui_initialized() -> None:
         system_script_engine.start()
+        process_healthcheck_script_engine.start()
 
         if on_gui_initialized_hook is not None:
             try:
                 on_gui_initialized_hook()
-            except:  # pylint: disable=bare-except
+            except Exception:
                 print(format_exc(), file=stderr)
                 on_shutdown()
 
     system_script_engine.register_script(Script(update_frozen_objects, enabled=True))
     system_script_engine.register_script(Script(update_displayed_objects, enabled=True))
+    process_healthcheck_script_engine.register_script(Script(show_message_and_shutdown_if_process_exited, enabled=True))
 
     try:
         run_gui(on_gui_initialized)
-    except:  # pylint: disable=bare-except
+    except Exception:
         print(format_exc(), file=stderr)
 
     on_shutdown()

{trainerbase-3.11.4 → trainerbase-3.12.0}/trainerbase/memory.py

@@ -1,24 +1,13 @@
 from abc import ABC, abstractmethod
 from collections.abc import Callable
 from functools import partial
-from typing import Final, Self, assert_never, override
+from types import MappingProxyType
+from typing import Final, Self, assert_never, cast, override
 
-from pymem import Pymem
-from pymem.exception import ProcessNotFound
 from pymem.pattern import pattern_scan_all, pattern_scan_module
 from pymem.process import module_from_name
 
-from trainerbase.config import pymem_config
-
-
-for process_name in pymem_config["process_names"]:
-    try:
-        pm = Pymem(process_name, exact_match=pymem_config["exact_match"], ignore_case=pymem_config["ignore_case"])
-    except ProcessNotFound:
-        continue
-    break
-else:
-    raise ProcessNotFound(f"not any: {pymem_config['process_names']}")
+from trainerbase.process import _pm as pm
 
 
 ARCH: Final[int] = 64 if pm.is_64_bit else 32
@@ -28,7 +17,7 @@ POINTER_SIZE: Final[int] = 8 if pm.is_64_bit else 4
 type ConvertibleToAddress = AbstractAddress | int | bytes | str
 
 
-read_pointer: Callable[[int], int] = pm.read_ulonglong if pm.is_64_bit else pm.read_uint  # type: ignore
+read_pointer = cast(Callable[[int], int], pm.read_ulonglong if pm.is_64_bit else pm.read_uint)
 
 
 class AbstractAddress(ABC):
@@ -39,7 +28,7 @@ class AbstractAddress(ABC):
 
 class AOBScan(AbstractAddress):
     # Constant from re. Like re._special_chars_map, but without dot (`.`).
-    _SPECIAL_CHARS_MAP = {i: "\\" + chr(i) for i in b"()[]{}?*+-|^$\\&~# \t\n\r\v\f"}
+    _SPECIAL_CHARS_MAP = MappingProxyType({i: "\\" + chr(i) for i in b"()[]{}?*+-|^$\\&~# \t\n\r\v\f"})
 
     def __init__(
         self,
@@ -93,7 +82,7 @@ class AOBScan(AbstractAddress):
             raise ValueError(f"AOB not found: {self.aob}")
 
         if isinstance(scan_result, list):
-            result_address = scan_result[self.multiple_result_index]  # type: ignore
+            result_address = scan_result[cast(int, self.multiple_result_index)]
         else:
             result_address = scan_result
 
@@ -177,5 +166,18 @@ def ensure_address(obj: ConvertibleToAddress) -> AbstractAddress:
             raise TypeError(f"Cannot create AbstractAddress from {type(obj)}")
 
 
-def allocate_pointer(size: int = 1) -> int:
-    return pm.allocate(size * POINTER_SIZE)
+def allocate(size: int = POINTER_SIZE, count: int = 1) -> int:
+    return pm.allocate(size * count)
+
+
+def get_module_address(module_name: str) -> int:
+    """
+    Returns 0 if module is not found else module address
+    """
+
+    module_info = module_from_name(pm.process_handle, module_name)
+
+    if module_info is None:
+        return 0
+
+    return module_info.lpBaseOfDll

trainerbase-3.12.0/trainerbase/process.py

@@ -0,0 +1,49 @@
+from itertools import cycle
+from os import _exit as force_exit
+from typing import cast
+
+from psutil import pid_exists
+from pymem import Pymem
+from pymem.exception import ProcessNotFound
+from win32api import MessageBox
+from win32con import MB_ICONERROR, MB_OK
+
+from trainerbase.config import pymem_config
+
+
+def attach_to_process() -> Pymem:
+    process_names = pymem_config["process_names"]
+
+    if not process_names:
+        raise ValueError("Empty process name list")
+
+    print("Waiting for process in:", process_names)
+
+    for process_name in cycle(process_names):
+        try:
+            pm = Pymem(process_name, exact_match=pymem_config["exact_match"], ignore_case=pymem_config["ignore_case"])
+        except ProcessNotFound:
+            continue
+
+        print(f"Found {process_name}, pid: {pm.process_id}")
+
+        return pm
+
+    raise RuntimeError("Code should be unreachable")
+
+
+def show_message_and_shutdown_if_process_exited():
+    if pid_exists(cast(int, _pm.process_id)):
+        return
+
+    MessageBox(
+        None,
+        "Shut down trainer?",
+        "Process Exited!",
+        MB_ICONERROR | MB_OK,
+    )
+
+    force_exit(0)
+
+
+_pm = attach_to_process()

{trainerbase-3.11.4 → trainerbase-3.12.0}/trainerbase/scriptengine.py

@@ -7,7 +7,7 @@ from pymem.exception import MemoryReadError, MemoryWriteError
 
 
 class Script:
-    def __init__(self, callback: Callable, enabled: bool = False):
+    def __init__(self, callback: Callable, *, enabled: bool = False):
         self.callback = callback
         self.enabled = enabled
 
@@ -68,3 +68,4 @@ def enabled_by_default(script: Script) -> Script:
 
 
 system_script_engine = ScriptEngine()
+process_healthcheck_script_engine = ScriptEngine(delay=3)

{trainerbase-3.11.4 → trainerbase-3.12.0}/trainerbase/speedhack.py

@@ -1,9 +1,11 @@
+from contextlib import suppress
 from pathlib import Path
-from typing import Final, Self
+from typing import Final, Self, cast
 
 from pyinjector import inject
 from pymem.exception import MemoryWriteError
 from pymem.process import module_from_name
+from pymem.ressources.structure import MODULEINFO
 
 from trainerbase.gameobject import GameDouble
 from trainerbase.memory import ARCH, pm
@@ -32,9 +34,9 @@ class SpeedHack:
         self.factor = 1.0
 
     def _inject(self) -> int:
-        inject(pm.process_id, str(SPEEDHACK_DLL_PATH))  # type: ignore
+        inject(cast(int, pm.process_id), str(SPEEDHACK_DLL_PATH))
 
-        speedhack_address = module_from_name(pm.process_handle, SPEEDHACK_DLL_MODULE_NAME).lpBaseOfDll  # type: ignore
+        speedhack_address = cast(MODULEINFO, module_from_name(pm.process_handle, SPEEDHACK_DLL_MODULE_NAME)).lpBaseOfDll
 
         return speedhack_address
 
@@ -51,7 +53,5 @@ class SpeedHack:
         if cls._instance is None:
             return
 
-        try:
+        with suppress(MemoryWriteError):
             cls._instance.factor = 1.0
-        except MemoryWriteError:
-            pass

{trainerbase-3.11.4 → trainerbase-3.12.0}/trainerbase/tts.py

@@ -1,3 +1,4 @@
+from contextlib import suppress
 from threading import Thread
 
 from pyttsx3 import init as init_tts_engine
@@ -6,7 +7,7 @@ from pyttsx3 import init as init_tts_engine
 engine = init_tts_engine()
 
 
-def say(text: str, rate: int = 210, volume: float = 1.0, sync=False):
+def say(text: str, rate: int = 210, volume: float = 1.0, *, sync=False):
     args = (text, rate, volume)
 
     if sync:
@@ -18,16 +19,12 @@ def say(text: str, rate: int = 210, volume: float = 1.0, sync=False):
 def say_sync(text: str, rate: int, volume: float):
     engine.stop()
 
-    try:
+    with suppress(RuntimeError):
         engine.endLoop()
-    except RuntimeError:
-        pass
 
     engine.setProperty("rate", rate)
     engine.setProperty("volume", volume)
     engine.say(text)
 
-    try:
+    with suppress(RuntimeError):
         engine.runAndWait()
-    except RuntimeError:
-        pass

trainerbase-3.11.4/PKG-INFO

@@ -1,44 +0,0 @@
-Metadata-Version: 2.1
-Name: trainerbase
-Version: 3.11.4
-Summary: Framework for creating game trainers/mods
-Home-page: https://gitlab.com/python-trainers/trainer-base
-License: MIT
-Author: v01d
-Author-email: v01d@v01d.ru
-Requires-Python: >=3.12,<4.0
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.12
-Requires-Dist: dearpygui (>=1.10.1,<2.0.0)
-Requires-Dist: keyboard (>=0.13.5,<0.14.0)
-Requires-Dist: pyinjector (>=1.3.0,<2.0.0)
-Requires-Dist: pymem (>=1.13.1,<2.0.0)
-Requires-Dist: pyttsx3 (>=2.90,<3.0)
-Project-URL: Repository, https://gitlab.com/python-trainers/trainer-base
-Description-Content-Type: text/x-rst
-
-============
-Trainer Base
-============
-
-.. image:: https://badge.fury.io/py/TrainerBase.svg
-    :target: https://badge.fury.io/py/TrainerBase
-    :alt: PyPI version
-
-.. image:: https://static.pepy.tech/badge/trainerbase
-    :target: https://pepy.tech/project/trainerbase
-    :alt: Downloads
-
-To create project from template using cookiecutter
-==================================================
-
-.. code-block:: bash
-
-    cookiecutter https://gitlab.com/v01d-gl/basic-project-template.git --checkout trainerbase
-
-Examples
-========
-
-`Python Trainers <https://gitlab.com/python-trainers>`__
-

trainerbase-3.11.4/README.rst

@@ -1,23 +0,0 @@
-============
-Trainer Base
-============
-
-.. image:: https://badge.fury.io/py/TrainerBase.svg
-    :target: https://badge.fury.io/py/TrainerBase
-    :alt: PyPI version
-
-.. image:: https://static.pepy.tech/badge/trainerbase
-    :target: https://pepy.tech/project/trainerbase
-    :alt: Downloads
-
-To create project from template using cookiecutter
-==================================================
-
-.. code-block:: bash
-
-    cookiecutter https://gitlab.com/v01d-gl/basic-project-template.git --checkout trainerbase
-
-Examples
-========
-
-`Python Trainers <https://gitlab.com/python-trainers>`__

trainerbase-3.11.4/trainerbase/gui/__init__.py

@@ -1,8 +0,0 @@
-from .helpers import *
-from .injections import *
-from .misc import *
-from .objects import *
-from .scripts import *
-from .speedhack import *
-from .teleport import *
-from .types import *