trainerbase 4.8.1__tar.gz → 4.9.0__tar.gz

{trainerbase-4.8.1 → trainerbase-4.9.0}/PKG-INFO

@@ -1,17 +1,17 @@
 Metadata-Version: 2.4
 Name: trainerbase
-Version: 4.8.1
+Version: 4.9.0
 Summary: Framework for creating game trainers/mods
 Author: v01d, doomayka
 Author-email: v01d <v01d@v01d.ru>, doomayka <doomaykaka@gmail.com>
 License-Expression: MIT
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: 3.14
-Requires-Dist: dearpygui>=2.2
+Requires-Dist: dearpygui>=2.3.1
 Requires-Dist: keyboard>=0.13.5
 Requires-Dist: mouse>=0.7.1
 Requires-Dist: psutil>=7.2.2
-Requires-Dist: pydantic>=2.12.5
+Requires-Dist: pydantic>=2.14.0
 Requires-Dist: pymem>=1.14.0
 Requires-Dist: pyttsx3>=2.99
 Requires-Dist: trainerbase-injector>=1.0.1

trainerbase-4.9.0/pyproject.toml

@@ -0,0 +1,92 @@
+[project]
+name = "trainerbase"
+version = "4.9.0"
+description = "Framework for creating game trainers/mods"
+license = "MIT"
+requires-python = ">=3.14"
+readme = "README.md"
+dependencies = [
+    "dearpygui>=2.3.1",
+    "keyboard>=0.13.5",
+    "mouse>=0.7.1",
+    "psutil>=7.2.2",
+    "pydantic>=2.14.0",
+    "pymem>=1.14.0",
+    "pyttsx3>=2.99",
+    "trainerbase-injector>=1.0.1",
+]
+classifiers = [
+    "Programming Language :: Python :: Implementation :: CPython",
+    "Programming Language :: Python :: 3.14",
+]
+
+[[project.authors]]
+name = "v01d"
+email = "v01d@v01d.ru"
+
+[[project.authors]]
+name = "doomayka"
+email = "doomaykaka@gmail.com"
+
+[project.urls]
+Homepage = "https://gitlab.com/python-trainers/"
+Repository = "https://gitlab.com/python-trainers/trainer-base"
+
+[tool.ruff]
+src = ["trainerbase"]
+line-length = 120
+
+[tool.ruff.lint]
+select = ["ALL"]
+ignore = [
+    "D",
+    "ANN",
+    "TC",
+    "EM",
+    "A005",
+    "FIX002",
+    "COM812",
+    "TC002",
+    "S607",
+    "BLE001",
+    "TRY003",
+    "RET504",
+    "PLR2004",
+    "PLR0913",
+    "PLW2901",
+    "TD002",
+    "TD003",
+    "CPY001",
+    "PLR0917",
+]
+
+[tool.ruff.lint.isort]
+lines-after-imports = 2
+
+[tool.ruff.format]
+line-ending = "lf"
+
+[tool.pyright]
+include = ["trainerbase"]
+typeCheckingMode = "standard"
+pythonPlatform = "All"
+pythonVersion = "3.14"
+
+[[tool.pyright.executionEnvironments]]
+root = "."
+extraPaths = ["src"]
+
+[tool.uv.build-backend]
+module-name = "trainerbase"
+module-root = ""
+
+[build-system]
+requires = ["uv_build>=0.11.3,<1.0.0"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = [
+    "invoke>=3.0.3",
+    "pyright>=1.1.414",
+    "ruff>=0.17.0",
+]

trainerbase-4.8.1/pyproject.toml → trainerbase-4.9.0/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "trainerbase"
-version = "4.8.1"
+version = "4.9.0"
 description = "Framework for creating game trainers/mods"
 license = "MIT"
 authors = [
@@ -10,11 +10,11 @@ authors = [
 requires-python = ">=3.14"
 readme = "README.md"
 dependencies = [
-    "dearpygui>=2.2",
+    "dearpygui>=2.3.1",
     "keyboard>=0.13.5",
     "mouse>=0.7.1",
     "psutil>=7.2.2",
-    "pydantic>=2.12.5",
+    "pydantic>=2.14.0",
     "pymem>=1.14.0",
     "pyttsx3>=2.99",
     "trainerbase-injector>=1.0.1",
@@ -34,20 +34,27 @@ src = ["trainerbase"]
 line-length = 120
 
 [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",
+select = ["ALL"]
+ignore = [
+    "D",
+    "ANN",
+    "TC",
+    "EM",
+    "A005",
+    "FIX002",
+    "COM812",
+    "TC002",
+    "S607",
+    "BLE001",
+    "TRY003",
+    "RET504",
+    "PLR2004",
+    "PLR0913",
+    "PLW2901",
+    "TD002",
+    "TD003",
+    "CPY001",
+    "PLR0917",
 ]
 
 [tool.ruff.lint.isort]
@@ -75,7 +82,7 @@ build-backend = "uv_build"
 
 [dependency-groups]
 dev = [
-    "invoke>=2.2.1",
-    "pyright>=1.1.407",
-    "ruff>=0.15.9",
+    "invoke>=3.0.3",
+    "pyright>=1.1.414",
+    "ruff>=0.17.0",
 ]

{trainerbase-4.8.1 → trainerbase-4.9.0}/trainerbase/codeinjection.py

@@ -11,7 +11,15 @@ from pymem.exception import MemoryWriteError
 
 from trainerbase.config import config
 from trainerbase.logger import logger
-from trainerbase.memory import ARCH, ConvertibleToAddress, allocate, ensure_address
+from trainerbase.memory import (
+    ARCH,
+    REL32_JUMP_SIZE,
+    REL32_MAX_DISPLACEMENT,
+    REL32_MIN_DISPLACEMENT,
+    ConvertibleToAddress,
+    allocate,
+    ensure_address,
+)
 from trainerbase.process import pm
 
 
@@ -19,6 +27,7 @@ FASM_EXECUTABLE_PATH: Final[Path] = config.vendor.folder / "FASM.EXE"
 ORIGINAL_CODE_PLACEHOLDER: Final[str] = "__original_code__"
 BASE_ADDRESS_PLACEHOLDER: Final[str] = "__base_address__"
 MOVE_X64_MACROS: Final[str] = "__move_x64__"
+LONG_X64_JUMP_SIZE: Final[int] = 14
 
 
 type Code = bytes | str
@@ -56,10 +65,13 @@ class CodeInjection(AbstractCodeInjection):
 
     @override
     def inject(self):
+        if self._injected:
+            return
+
         self.injection_point = self.address.resolve()
         self.original_code = pm.read_bytes(self.injection_point, len(self.code_to_inject))
 
-        logger.debug(f"Injecting {len(self.code_to_inject)} byte(s) at 0x{self.injection_point:X}")
+        logger.debug("Injecting %d byte(s) at 0x%X", len(self.code_to_inject), self.injection_point)
 
         pm.write_bytes(self.injection_point, self.code_to_inject, len(self.code_to_inject))
         self._injected = True
@@ -67,7 +79,7 @@ class CodeInjection(AbstractCodeInjection):
     @override
     def eject(self):
         if self._injected:
-            logger.debug(f"Ejecting {len(self.code_to_inject)} byte(s) from 0x{self.injection_point:X}")
+            logger.debug("Ejecting %d byte(s) from 0x%X", len(self.code_to_inject), self.injection_point)
 
             pm.write_bytes(self.injection_point, self.original_code, len(self.original_code))
             self._injected = False
@@ -82,12 +94,9 @@ class AllocatingCodeInjection(AbstractCodeInjection):
         code_to_inject: Code,
         *,
         original_code_length: int = 0,
-        new_memory_size: int = 1024,
-        is_long_x64_jump_needed: bool | None = None,
+        new_memory_size: int | None = None,
+        is_long_x64_jump_needed: bool = False,
     ):
-        if is_long_x64_jump_needed is None:
-            is_long_x64_jump_needed = pm.is_64_bit
-
         self.is_long_x64_jump_needed = is_long_x64_jump_needed
         self.address = ensure_address(address)
         self.code_to_inject = code_to_inject
@@ -101,58 +110,69 @@ class AllocatingCodeInjection(AbstractCodeInjection):
 
     @override
     def inject(self):
-        self.injection_point = self.address.resolve()
-        self.new_memory_address: int = allocate(self.new_memory_size)
-        self.original_code = pm.read_bytes(self.injection_point, self.original_code_length)
+        if self.new_memory_address:
+            return
 
+        injection_point = self.address.resolve()
+        original_code = pm.read_bytes(injection_point, self.original_code_length)
         code_to_inject = self.code_to_inject
 
         if isinstance(code_to_inject, str):
             code_to_inject = preprocess_asm(
                 code_to_inject,
-                original_code=self.original_code,
+                original_code=original_code,
                 base_address=pm.base_address,
             )
 
-        if isinstance(code_to_inject, bytearray):
-            raise TypeError("Code to inject must not be bytearray")
-
         code_to_inject = compile_asm(code_to_inject)
+        jumper_length = LONG_X64_JUMP_SIZE if self.is_long_x64_jump_needed else REL32_JUMP_SIZE
+        if jumper_length > self.original_code_length:
+            raise ValueError(f"Jumper length > original code length: {jumper_length} > {self.original_code_length}")
 
-        if self.is_long_x64_jump_needed:
-            code_to_inject = compile_asm("pop rax") + code_to_inject + compile_asm("push rax")
-            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 = 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, self.injection_point))
-            jumper_length = len(jump_to_new_mem)
-            jump_back_address = self.injection_point + jumper_length
-            jump_back = compile_asm(
-                get_simple_jump_code(jump_back_address, self.new_memory_address + len(code_to_inject)),
+        jump_back_address = injection_point + self.original_code_length
+        required_size = len(code_to_inject) + (LONG_X64_JUMP_SIZE if pm.is_64_bit else REL32_JUMP_SIZE)
+        memory_size = required_size if self.new_memory_size is None else self.new_memory_size
+        if memory_size < required_size:
+            raise ValueError(f"Injection size > allocated size: {required_size} > {memory_size}")
+
+        near = injection_point if pm.is_64_bit and not self.is_long_x64_jump_needed else None
+        new_memory_address = allocate(memory_size, near=near)
+        try:
+            jump_to_new_mem = compile_asm(
+                get_long_x64_jump_code(new_memory_address)
+                if self.is_long_x64_jump_needed
+                else get_simple_jump_code(new_memory_address, injection_point),
             )
-
-        if jumper_length < self.original_code_length:
             jump_to_new_mem += b"\x90" * (self.original_code_length - len(jump_to_new_mem))
-        elif jumper_length > self.original_code_length:
-            raise ValueError(f"Jumper length > original code length: {jumper_length} > {self.original_code_length}")
-
-        code_to_inject = code_to_inject + jump_back
-
-        logger.debug(f"Injecting {len(code_to_inject)} byte(s) (INJECTION) at 0x{self.new_memory_address:X}")
-        pm.write_bytes(self.new_memory_address, code_to_inject, len(code_to_inject))
+            code_to_inject += compile_asm(
+                get_long_x64_jump_code(jump_back_address)
+                if pm.is_64_bit
+                else get_simple_jump_code(jump_back_address, new_memory_address + len(code_to_inject)),
+            )
 
-        logger.debug(f"Injecting {len(jump_to_new_mem)} byte(s) (JUMPER) at 0x{self.injection_point:X}")
-        pm.write_bytes(self.injection_point, jump_to_new_mem, len(jump_to_new_mem))
+            logger.debug("Injecting %d byte(s) (INJECTION) at 0x%X", len(code_to_inject), new_memory_address)
+            pm.write_bytes(new_memory_address, code_to_inject, len(code_to_inject))
+        except Exception:
+            pm.free(new_memory_address)
+            raise
+
+        self.original_code = original_code
+        self.injection_point = injection_point
+        self.new_memory_address = new_memory_address
+        logger.debug("Injecting %d byte(s) (JUMPER) at 0x%X", len(jump_to_new_mem), injection_point)
+        try:
+            pm.write_bytes(injection_point, jump_to_new_mem, len(jump_to_new_mem))
+        except Exception:
+            self.eject()
+            raise
 
     @override
     def eject(self):
         if self.new_memory_address and self.injection_point:
-            logger.debug(f"Ejecting {self.original_code_length} byte(s) (JUMPER) from 0x{self.injection_point:X}")
+            logger.debug("Ejecting %d byte(s) (JUMPER) from 0x%X", self.original_code_length, self.injection_point)
             pm.write_bytes(self.injection_point, self.original_code, self.original_code_length)
 
-            logger.debug(f"Freeing memory at 0x{self.new_memory_address:X}")
+            logger.debug("Freeing memory at 0x%X", self.new_memory_address)
             pm.free(self.new_memory_address)
             self.new_memory_address = 0
             self.injection_point = 0
@@ -166,12 +186,22 @@ class MultipleCodeInjection(AbstractCodeInjection):
 
     @override
     def inject(self):
-        for injection in self._injections:
-            injection.inject()
+        injected = []
+        try:
+            for injection in self._injections:
+                injection.inject()
+                injected.append(injection)
+        except Exception:
+            for injection in reversed(injected):
+                try:
+                    injection.eject()
+                except Exception:
+                    logger.exception("Failed to roll back injection %r", injection)
+            raise
 
     @override
     def eject(self):
-        for injection in self._injections:
+        for injection in reversed(self._injections):
             injection.eject()
 
 
@@ -200,7 +230,7 @@ def preprocess_asm(code: str, *, original_code: bytes | None, base_address: int
 @lru_cache
 def compile_asm(code: Code) -> bytes:
     if isinstance(code, str):
-        logger.debug(f"Assembling for x{ARCH}:\n{code}")
+        logger.debug("Assembling for x%d:\n%s", ARCH, code)
 
         fasm_mode = f"use{ARCH}"
         with TemporaryDirectory() as tmp_dir:
@@ -208,7 +238,7 @@ def compile_asm(code: Code) -> bytes:
 
             asm_file.write_text(f"{fasm_mode}\n{code}", encoding="utf-8")
 
-            run_executable([FASM_EXECUTABLE_PATH, asm_file], stdout=DEVNULL, check=True)
+            run_executable([FASM_EXECUTABLE_PATH, asm_file], stdout=DEVNULL, check=True)  # noqa: S603
             code = asm_file.with_suffix(".bin").read_bytes()
 
     if not isinstance(code, bytes):
@@ -218,26 +248,18 @@ def compile_asm(code: Code) -> bytes:
 
 
 def get_simple_jump_code(address: int, ip: int) -> str:
+    if pm.is_64_bit and not REL32_MIN_DISPLACEMENT <= address - (ip + REL32_JUMP_SIZE) <= REL32_MAX_DISPLACEMENT:
+        raise ValueError(f"Jump from 0x{ip:X} to 0x{address:X} is out of rel32 range")
     return f"""
-        jmp {address - ip}
-    """
-
-
-def get_long_x64_jump_to_new_mem_code(address: int) -> str:
-    return f"""
-        push rax
-        mov rax, {address}
-        push rax
-        ret
-        pop rax
+        jmp near {address - ip}
     """
 
 
-def get_long_x64_jump_back_code(address: int) -> str:
+def get_long_x64_jump_code(address: int) -> str:
     return f"""
-        mov rax, {address}
-        push rax
-        ret
+        jmp qword [destination]
+        destination:
+        dq {address}
     """
 
 

{trainerbase-4.8.1 → trainerbase-4.9.0}/trainerbase/common/helpers.py

@@ -19,11 +19,11 @@ class ASMArrayManager(Sequence):
         self,
         array_length: int,
         element_size: int,
-        offsets: None | list[int] = None,
+        offsets: list[int] | None = None,
         add: int = 0,
     ) -> None:
-        if offsets:
-            assert element_size == POINTER_SIZE, "If `offsets` is not None, `element_size` must be `POINTER_SIZE`"
+        if offsets and element_size != POINTER_SIZE:
+            raise ValueError("If `offsets` is not None, `element_size` must be `POINTER_SIZE`")
 
         self.array_length = array_length
         self.element_size = element_size
@@ -46,13 +46,17 @@ class ASMArrayManager(Sequence):
         if isinstance(index, int):
             return self.get_address_of_element(index)
 
-        return [self.get_address_of_element(i) for i in range(index.start, index.stop, index.step)]
+        return [self.get_address_of_element(i) for i in range(*index.indices(len(self)))]
 
     def __iter__(self) -> Iterator[Address]:
         for index in range(len(self)):
             yield self[index]
 
     def get_pointer_to_element(self, index: int) -> int:
+        if index < 0:
+            index += len(self)
+        if not 0 <= index < len(self):
+            raise IndexError("Array index out of range")
         return self.array_address + self.element_size * index
 
     def get_address_of_element(self, index: int) -> Address:
@@ -72,7 +76,8 @@ class ASMArrayManager(Sequence):
         if from_register == array_index_register:
             array_index_register = reserve_register
 
-        assert len({from_register, array_address_register, array_index_register}) == 3, "Registers must be unique"
+        if len({from_register, array_address_register, array_index_register}) != 3:
+            raise RuntimeError("Registers must be unique")
 
         label_continue = f"__label_continue_{uuid4().hex}"
 
@@ -122,8 +127,10 @@ def regenerate(
     percent: Number,
     min_value: Number = 1,
 ):
-    if current_value.value < max_value.value:
-        current_value.value += max(round(max_value.value * percent / 100), min_value)
+    current = current_value.value
+    maximum = max_value.value
+    if current < maximum:
+        current_value.value = min(current + max(round(maximum * percent / 100), min_value), maximum)
 
 
 def suppress_memory_exceptions[**P, T](callback: Callable[P, T]) -> Callable[P, T | None]:

{trainerbase-4.8.1 → trainerbase-4.9.0}/trainerbase/common/rainbow.py

@@ -61,8 +61,7 @@ class GradientUpdater(AbstractBaseScript):
         colors = []
 
         for _ in range(length // 2):
-            for _ in range(self.color_length):
-                colors.append((red, green, blue))
+            colors.extend((red, green, blue) for _ in range(self.color_length))
 
             red, delta_red = self.next_color_channel_value(red, delta_red)
             green, delta_green = self.next_color_channel_value(green, delta_green)

{trainerbase-4.8.1 → trainerbase-4.9.0}/trainerbase/config.py

@@ -9,7 +9,7 @@ CONFIG_FILE: Final[Path] = Path("./trainerbase.toml")
 
 DEFAULT_VENDOR_FOLDER_PATHS: Final[list[Path]] = [
     Path(__file__).resolve().parent / "vendor",
-    Path().resolve() / "trainerbase_vendor",
+    Path.cwd() / "trainerbase_vendor",
 ]
 
 

{trainerbase-4.8.1 → trainerbase-4.9.0}/trainerbase/gameobject.py

@@ -39,7 +39,7 @@ class GameObject[PymemType, TrainerBaseType](AbstractReadableObject[TrainerBaseT
         *,
         frozen: TrainerBaseType | None = None,
         is_tracked: bool = True,
-        value_range: None | tuple[TrainerBaseType, TrainerBaseType] = None,
+        value_range: tuple[TrainerBaseType, TrainerBaseType] | None = None,
     ):
         if is_tracked:
             GameObject.tracked_objects.append(self)
@@ -186,11 +186,11 @@ class GameBool(GameObject[bool, bool], Switchable):
 
     @override
     def enable(self):
-        self.value = True  # pylint: disable=attribute-defined-outside-init
+        self.value = True
 
     @override
     def disable(self):
-        self.value = False  # pylint: disable=attribute-defined-outside-init
+        self.value = False
 
 
 class ReadonlyGameObjectSumGetter(AbstractReadableObject[int | float]):

{trainerbase-4.8.1 → trainerbase-4.9.0}/trainerbase/gui/helpers.py

@@ -40,7 +40,7 @@ def simple_trainerbase_menu(
             )
             dpg.setup_dearpygui()
 
-            with dpg.window(
+            with dpg.window(  # pyright: ignore[reportGeneralTypeIssues]
                 label=window_title,
                 tag="menu",
                 min_size=[width, height],

{trainerbase-4.8.1 → trainerbase-4.9.0}/trainerbase/gui/misc.py

@@ -89,7 +89,7 @@ class HorizontalUI(AbstractUIComponent):
 
     @override
     def add_to_ui(self) -> None:
-        with dpg.group(horizontal=True):
+        with dpg.group(horizontal=True):  # pyright: ignore[reportGeneralTypeIssues]
             add_components(*self.components)
 
         return super().add_to_ui()

{trainerbase-4.8.1 → trainerbase-4.9.0}/trainerbase/gui/objects.py

@@ -73,7 +73,7 @@ class GameObjectUI(AbstractUIComponent):
         if self.set_hotkey is not None:
             add_hotkey(self.set_hotkey, self.on_value_set)
 
-        with dpg.group(horizontal=True):
+        with dpg.group(horizontal=True):  # pyright: ignore[reportGeneralTypeIssues]
             if self.gameobject.is_tracked:
                 dpg.add_checkbox(tag=self.dpg_tag_frozen, callback=self.on_frozen_state_change)
 
@@ -123,15 +123,17 @@ class GameObjectUI(AbstractUIComponent):
                 | GameUnsignedLongLong()
             ):
                 # 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.  # noqa: FIX002
+                # TODO: Use better input component if it's already added to dpg. Remove this crutch.
+
+                if GameInt.value_range is None:
+                    raise RuntimeError("GameInt must have value_range")
 
-                assert GameInt.value_range is not None, "GameInt must have value_range"
                 min_value = default_kwargs.pop("min_value", GameInt.value_range[0])
                 max_value = default_kwargs.pop("max_value", GameInt.value_range[1])
 
                 if self.gameobject.value_range is not None:
-                    min_value = max(min_value, GameInt.value_range[0])  # type: ignore
-                    max_value = min(max_value, GameInt.value_range[1])  # type: ignore
+                    min_value = max(min_value, GameInt.value_range[0])
+                    max_value = min(max_value, GameInt.value_range[1])
 
                 dpg.add_input_int(min_value=min_value, max_value=max_value, **default_kwargs)
             case GameBool():

{trainerbase-4.8.1 → trainerbase-4.9.0}/trainerbase/gui/speedhack.py

@@ -55,7 +55,7 @@ class SpeedHackUI(AbstractUIComponent):
         add_components(HotkeyHandlerUI(self.handler, "SpeedHack"))
 
         if self.next_preset_hotkey is not None and self.previous_preset_hotkey is not None:
-            with dpg.group(horizontal=True):
+            with dpg.group(horizontal=True):  # pyright: ignore[reportGeneralTypeIssues]
                 add_components(
                     HotkeyHandlerUI(
                         SimpleHotkeyHandler(partial(self.change_preset, -1), self.previous_preset_hotkey),

{trainerbase-4.8.1 → trainerbase-4.9.0}/trainerbase/gui/tapper.py

@@ -89,7 +89,7 @@ class TapperUI(AbstractUIComponent):
             min_value=0,
             max_value=len(self.DURATION_PRESETS) - 1,
             clamped=True,
-            default_value=self.get_closest_preset_index(self.DURATION_PRESETS, self.default_delay),
+            default_value=self.get_closest_preset_index(self.DURATION_PRESETS, self.default_duration),
             callback=self.on_duration_preset_change,
         )
 
@@ -111,7 +111,7 @@ class TapperUI(AbstractUIComponent):
 
     def on_duration_change(self):
         new_duration = dpg.get_value(self.dpg_tag_tapper_duration_input)
-        closest_preset_index = self.get_closest_preset_index(self.DELAY_PRESETS, new_duration)
+        closest_preset_index = self.get_closest_preset_index(self.DURATION_PRESETS, new_duration)
         self.tapper.duration = new_duration
         dpg.set_value(self.dpg_tag_tapper_duration_preset_input, closest_preset_index)
 

{trainerbase-4.8.1 → trainerbase-4.9.0}/trainerbase/gui/teleport.py

@@ -127,7 +127,7 @@ class TeleportUI(AbstractUIComponent):
         if self.hotkey_dash is None:
             return
 
-        with dpg.group(horizontal=True):
+        with dpg.group(horizontal=True):  # pyright: ignore[reportGeneralTypeIssues]
             add_hotkey(self.hotkey_dash, self.on_hotkey_dash_press)
             dpg.add_text(f"[{self.hotkey_dash}] Dash")
 
@@ -147,7 +147,7 @@ class TeleportUI(AbstractUIComponent):
             callback=self._on_apply_filter,
         )
 
-        with dpg.group(horizontal=True):
+        with dpg.group(horizontal=True):  # pyright: ignore[reportGeneralTypeIssues]
             dpg.add_button(label="Go To", callback=self.on_goto_label)
             dpg.add_combo(label="Labels", tag=self.DPG_TAG_TELEPORT_LABELS)
 

{trainerbase-4.8.1 → trainerbase-4.9.0}/trainerbase/logger.py

@@ -38,7 +38,7 @@ getLogger("comtypes").setLevel(ERROR)
 
 logger = getLogger("TrainerBase")
 if using_default_config:
-    logger.debug(f"No logging config in {CONFIG_FILE}! Using default one.")
+    logger.debug("No logging config in %s! Using default one.", CONFIG_FILE)
 
 
 def _exception_hook(*args):

{trainerbase-4.8.1 → trainerbase-4.9.0}/trainerbase/main.py

@@ -22,7 +22,7 @@ from trainerbase.tts import tts_manager
 type Callback = Callable[[], None]
 
 
-def run(  # pylint: disable=too-complex
+def run(
     run_gui: Callable[[Callback, Callback], None],
     on_gui_initialized_hook: Callback | None = None,
     on_shutdown_hook: Callback | None = None,
@@ -80,6 +80,5 @@ def run(  # pylint: disable=too-complex
         print_exc()
     except KeyboardInterrupt:
         logger.info("KeyboardInterrupt (Ctrl+C)")
-        pass
 
     on_shutdown()

{trainerbase-4.8.1 → trainerbase-4.9.0}/trainerbase/memory.py

@@ -1,5 +1,6 @@
 from abc import ABC, abstractmethod
 from collections.abc import Callable
+from ctypes import Structure, WinDLL, addressof, byref, c_size_t, c_uint16, c_uint32, c_uint64, c_void_p, get_last_error
 from functools import partial
 from itertools import count
 from time import sleep
@@ -8,6 +9,7 @@ from typing import Final, Self, assert_never, cast, override
 
 from pymem.pattern import pattern_scan_all, pattern_scan_module
 from pymem.process import module_from_name
+from pymem.ressources.structure import MEMORY_PROTECTION, MEMORY_STATE
 
 from trainerbase.logger import logger
 from trainerbase.process import pm
@@ -15,7 +17,12 @@ from trainerbase.process import pm
 
 ARCH: Final[int] = 64 if pm.is_64_bit else 32
 POINTER_SIZE: Final[int] = 8 if pm.is_64_bit else 4
-DEFAULT_HARDCODED_ADDRESS_OFFSET_READER: Callable[[int], int] = cast(Callable[[int], int], pm.read_uint)
+DEFAULT_HARDCODED_ADDRESS_OFFSET_READER: Final[Callable[[int], int]] = cast(Callable[[int], int], pm.read_uint)
+ANY_BYTE_MARKER_HEX: Final[str] = "2E"  # 2E is hex(46), 46 is ord(".")
+REL32_JUMP_SIZE: Final[int] = 5
+REL32_MIN_DISPLACEMENT: Final[int] = -(2**31)
+REL32_MAX_DISPLACEMENT: Final[int] = 2**31 - 1
+MEM_EXTENDED_PARAMETER_ADDRESS_REQUIREMENTS: Final[int] = 1
 
 
 type ConvertibleToAddress = AbstractAddress | int | bytes | str
@@ -24,7 +31,7 @@ type ConvertibleToAddress = AbstractAddress | int | bytes | str
 read_pointer = cast(Callable[[int], int], pm.read_ulonglong if pm.is_64_bit else pm.read_uint)
 
 
-logger.debug(f"Process arch is {ARCH}")
+logger.debug("Process arch is %d", ARCH)
 
 
 class AbstractAddress(ABC):
@@ -51,9 +58,10 @@ class AOBScan(AbstractAddress):
     ):
         self._should_cache = should_cache
         self._saved_scan_result: int | None = None
+        self._any_byte_marker = any_byte_marker
 
         if isinstance(aob, str):
-            aob = bytes.fromhex(aob.replace(any_byte_marker, "2E"))  # 2E is hex(46), 46 is ord(".")
+            aob = bytes.fromhex(aob.replace(any_byte_marker, ANY_BYTE_MARKER_HEX))  # 2E is hex(46), 46 is ord(".")
 
         if should_escape:
             aob = self._escape_aob(aob)
@@ -88,7 +96,8 @@ class AOBScan(AbstractAddress):
         scan_result: list[int] | int | None = find_aob(self.aob, check_memory_protection=self.check_memory_protection)
 
         if not scan_result:
-            raise ValueError(f"AOB not found: {self.aob}")
+            aob_repr = self.aob.hex(" ").upper().replace(ANY_BYTE_MARKER_HEX, self._any_byte_marker)
+            raise ValueError(f"AOB not found: {aob_repr}")
 
         if isinstance(scan_result, list):
             result_address = scan_result[cast(int, self.multiple_result_index)]
@@ -174,14 +183,79 @@ def ensure_address(obj: ConvertibleToAddress) -> AbstractAddress:
         case bytes() | str():
             return AOBScan(obj)
         case _:
-            raise TypeError(f"Cannot create AbstractAddress from {type(obj)}")
+            assert_never(obj)
 
 
-def allocate(size: int = POINTER_SIZE, count: int = 1) -> int:
-    total = size * count
-    logger.debug(f"Allocating {total} bytes.")
+class _SystemInfo(Structure):
+    _fields_ = [
+        ("architecture", c_uint16),
+        ("reserved", c_uint16),
+        ("page_size", c_uint32),
+        ("minimum_address", c_void_p),
+        ("maximum_address", c_void_p),
+        ("processor_mask", c_size_t),
+        ("processor_count", c_uint32),
+        ("processor_type", c_uint32),
+        ("allocation_granularity", c_uint32),
+        ("processor_level", c_uint16),
+        ("processor_revision", c_uint16),
+    ]
+
+
+class _AddressRequirements(Structure):
+    _fields_ = [("lowest", c_void_p), ("highest", c_void_p), ("alignment", c_size_t)]
+
+
+class _ExtendedParameter(Structure):
+    _fields_ = [("type", c_uint64), ("pointer", c_uint64)]
 
-    return pm.allocate(total)
+
+_kernelbase = WinDLL("kernelbase", use_last_error=True)
+_get_system_info = _kernelbase.GetSystemInfo
+_get_system_info.argtypes = [c_void_p]
+_get_system_info.restype = None
+_virtual_alloc2 = _kernelbase.VirtualAlloc2
+_virtual_alloc2.argtypes = [c_void_p, c_void_p, c_size_t, c_uint32, c_uint32, c_void_p, c_uint32]
+_virtual_alloc2.restype = c_void_p
+_system_info = _SystemInfo()
+_get_system_info(byref(_system_info))
+
+
+def allocate(size: int = POINTER_SIZE, count: int = 1, *, near: ConvertibleToAddress | None = None) -> int:
+    total = size * count
+    logger.debug("Allocating %d bytes.", total)
+
+    if near is None:
+        return pm.allocate(total)
+
+    if total <= 0:
+        raise ValueError("Allocation size must be positive")
+
+    address = ensure_address(near).resolve()
+    granularity = _system_info.allocation_granularity
+    page_size = _system_info.page_size
+    lowest = max(_system_info.minimum_address, address + REL32_JUMP_SIZE + REL32_MIN_DISPLACEMENT)
+    highest = min(_system_info.maximum_address, address + REL32_JUMP_SIZE + REL32_MAX_DISPLACEMENT)
+    lowest = (lowest + granularity - 1) // granularity * granularity
+    highest = (highest + 1) // granularity * granularity - 1
+    total = (total + page_size - 1) // page_size * page_size
+    if highest - lowest + 1 < total:
+        raise ValueError(f"No allocation range near 0x{address:X}")
+
+    requirements = _AddressRequirements(lowest=lowest, highest=highest, alignment=granularity)
+    parameter = _ExtendedParameter(MEM_EXTENDED_PARAMETER_ADDRESS_REQUIREMENTS, addressof(requirements))
+    allocated = _virtual_alloc2(
+        pm.process_handle,
+        None,  # BaseAddress: let Windows choose an address within requirements.
+        total,
+        MEMORY_STATE.MEM_RESERVE | MEMORY_STATE.MEM_COMMIT,
+        MEMORY_PROTECTION.PAGE_EXECUTE_READWRITE,
+        byref(parameter),
+        1,  # ParameterCount: one address-requirements parameter.
+    )
+    if not allocated:
+        raise ValueError(f"Cannot allocate {total} bytes near 0x{address:X}: WinError {get_last_error()}")
+    return allocated
 
 
 def read_hardcoded_static_address(
@@ -239,19 +313,19 @@ def get_module_address(module_name: str, *, delay: float = 2, retry_limit: int |
     Set retry_limit to 0 if you want to disable retries.
     """
 
-    logger.info(f"Looking for {module_name}...")
+    logger.info("Looking for %s...", module_name)
 
     for try_counter in count():
         module_info = module_from_name(pm.process_handle, module_name)
 
         if module_info is not None:
-            logger.info(f"Successfully found {module_name} at 0x{module_info.lpBaseOfDll:X}")
+            logger.info("Successfully found %s at 0x%X", module_name, module_info.lpBaseOfDll)
             return module_info.lpBaseOfDll
 
         if try_counter == retry_limit:
             raise RuntimeError(f"Failed to find module: {module_name}, tried {try_counter + 1} time(s).")
 
-        logger.info(f"Failed to find {module_name}. I will retry in {delay} s. Retry limit is {retry_limit}")
+        logger.info("Failed to find %s. I will retry in %f s. Retry limit is %s", module_name, delay, retry_limit)
 
         sleep(delay)
 
@@ -273,7 +347,7 @@ def ensure_resolved(
     Set retry_limit to 0 if you want to disable retries.
     """
 
-    logger.info(f"Looking for {verbose_name}...")
+    logger.info("Looking for %s...", verbose_name)
 
     for try_counter in count():
         try:
@@ -282,12 +356,14 @@ def ensure_resolved(
             if try_counter == retry_limit:
                 raise RuntimeError(f"Failed to resolve {verbose_name}, tried {try_counter + 1} time(s).") from e
 
-            logger.info(f"Failed to resolve {verbose_name}. I will retry in {delay} s. Retry limit is {retry_limit}")
+            logger.info(
+                "Failed to resolve %s. I will retry in %f s. Retry limit is %s", verbose_name, delay, retry_limit
+            )
 
             sleep(delay)
             continue
 
-        logger.info(f"Successfully found {verbose_name} at 0x{resolved:X}")
+        logger.info("Successfully found %s at 0x%X", verbose_name, resolved)
         return resolved
 
     raise RuntimeError("This code must be unreachable!")

{trainerbase-4.8.1 → trainerbase-4.9.0}/trainerbase/process.py

@@ -46,17 +46,19 @@ def select_one_process(processes: Iterable[Process]) -> Process:
 
 
 def get_target_pid(process_names: Iterable[str], *, exact_match: bool, ignore_case: bool) -> int:
-    logger.info(f"Waiting for process in: {process_names}")
+    logger.info("Waiting for process in: %s", process_names)
 
     for process_name in cycle(process_names):
         found_processes = find_processes(process_name, exact_match=exact_match, ignore_case=ignore_case)
 
         if found_processes:
             pid = select_one_process(found_processes).pid
-            logger.info(f"Found {process_name}, pid: {pid}")
+            logger.info("Found %s, pid: %d", process_name, pid)
 
             return pid
 
+        sleep(0.1)
+
     raise RuntimeError("This place must be unreachable! `process_names` is probably empty.")
 
 

{trainerbase-4.8.1 → trainerbase-4.9.0}/trainerbase/scriptengine.py

@@ -1,14 +1,13 @@
 from abc import ABC, abstractmethod
 from collections.abc import Callable
-from contextlib import suppress
-from sys import stderr
-from threading import Thread
+from threading import Thread, current_thread
 from time import sleep
 from typing import Any, override
 
 from pymem.exception import MemoryReadError, MemoryWriteError
 
 from trainerbase.abc import Switchable
+from trainerbase.logger import logger
 
 
 class AbstractBaseScript(Switchable, ABC):
@@ -54,18 +53,23 @@ class ScriptEngine:
         return f"<ScriptEngine delay={self.delay} should_run={self.should_run} scripts={len(self.scripts)}>"
 
     def start(self):
+        if self.thread.is_alive():
+            return
+        self.thread = Thread(target=self.script_loop)
         self.should_run = True
         self.thread.start()
 
     def stop(self):
         self.should_run = False
 
-        with suppress(RuntimeError):
+        if self.thread.ident is not None and self.thread is not current_thread():
             self.thread.join()
 
     def script_loop(self):
         while self.should_run:
             for script in self.scripts:
+                if not self.should_run:
+                    return
                 if not script.enabled:
                     continue
 
@@ -73,9 +77,10 @@ class ScriptEngine:
                     script()
                 except MemoryReadError, MemoryWriteError:
                     continue
-                except Exception as e:  # pylint: disable=broad-exception-caught
-                    print(e, file=stderr)
+                except Exception:
+                    logger.exception("Error in script %r. Stopping Script Engine.", script)
                     self.stop()
+                    return
 
             sleep(self.delay)