trainerbase 4.5.0__tar.gz → 4.6.0__tar.gz

{trainerbase-4.5.0 → trainerbase-4.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trainerbase
-Version: 4.5.0
+Version: 4.6.0
 Summary: Framework for creating game trainers/mods
 Project-URL: Homepage, https://gitlab.com/python-trainers/
 Project-URL: Repository, https://gitlab.com/python-trainers/trainer-base
@@ -13,7 +13,8 @@ Requires-Python: >=3.13
 Requires-Dist: dearpygui>=2.0.0
 Requires-Dist: keyboard>=0.13.5
 Requires-Dist: mouse>=0.7.1
-Requires-Dist: psutil>=6.1.1
+Requires-Dist: psutil>=7.0.0
+Requires-Dist: pydantic>=2.10.6
 Requires-Dist: pyinjector>=1.3.0
 Requires-Dist: pymem>=1.14.0
 Requires-Dist: pyttsx3>=2.98

{trainerbase-4.5.0 → trainerbase-4.6.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "trainerbase"
-version = "4.5.0"
+version = "4.6.0"
 description = "Framework for creating game trainers/mods"
 license = "MIT"
 authors = [
@@ -13,7 +13,8 @@ dependencies = [
     "dearpygui>=2.0.0",
     "keyboard>=0.13.5",
     "mouse>=0.7.1",
-    "psutil>=6.1.1",
+    "psutil>=7.0.0",
+    "pydantic>=2.10.6",
     "pyinjector>=1.3.0",
     "pymem>=1.14.0",
     "pyttsx3>=2.98",
@@ -73,5 +74,5 @@ build-backend = "hatchling.build"
 
 [dependency-groups]
 dev = [
-    "ruff>=0.8.6",
+    "ruff>=0.9.7",
 ]

{trainerbase-4.5.0 → trainerbase-4.6.0}/trainerbase/codeinjection.py

@@ -1,5 +1,6 @@
 from abc import ABC, abstractmethod
 from contextlib import suppress
+from functools import lru_cache
 from pathlib import Path
 from subprocess import DEVNULL
 from subprocess import run as run_executable
@@ -8,12 +9,16 @@ from typing import ClassVar, Final, Self, override
 
 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.process import pm
 
 
-FASM_EXECUTABLE_PATH: Final[Path] = Path(__file__).resolve().parent.parent / "trainerbase_vendor" / "FASM.EXE"
+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__"
 
 
 type Code = bytes | str
@@ -70,8 +75,8 @@ class CodeInjection(AbstractCodeInjection):
             logger.debug("Nothing to eject")
 
 
-class AllocatingCodeInjection(AbstractCodeInjection):  # pylint: disable=too-many-instance-attributes
-    def __init__(  # pylint: disable=too-many-arguments
+class AllocatingCodeInjection(AbstractCodeInjection):
+    def __init__(
         self,
         address: ConvertibleToAddress,
         code_to_inject: Code,
@@ -85,10 +90,7 @@ class AllocatingCodeInjection(AbstractCodeInjection):  # pylint: disable=too-man
 
         self.is_long_x64_jump_needed = is_long_x64_jump_needed
         self.address = ensure_address(address)
-        self.code_to_inject = compile_asm(code_to_inject)
-
-        if self.is_long_x64_jump_needed:
-            self.code_to_inject = compile_asm("pop rax") + self.code_to_inject + compile_asm("push rax")
+        self.code_to_inject = code_to_inject
 
         self.original_code: bytes = b""
 
@@ -100,12 +102,25 @@ class AllocatingCodeInjection(AbstractCodeInjection):  # pylint: disable=too-man
     @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)
 
+        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,
+                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)
+
         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
@@ -115,7 +130,7 @@ class AllocatingCodeInjection(AbstractCodeInjection):  # pylint: disable=too-man
             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(self.code_to_inject)),
+                get_simple_jump_code(jump_back_address, self.new_memory_address + len(code_to_inject)),
             )
 
         if jumper_length < self.original_code_length:
@@ -123,7 +138,7 @@ class AllocatingCodeInjection(AbstractCodeInjection):  # pylint: disable=too-man
         elif jumper_length > self.original_code_length:
             raise ValueError(f"Jumper length > original code length: {jumper_length} > {self.original_code_length}")
 
-        code_to_inject = self.code_to_inject + jump_back
+        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))
@@ -160,6 +175,29 @@ class MultipleCodeInjection(AbstractCodeInjection):
             injection.eject()
 
 
+def preprocess_asm(code: str, *, original_code: bytes | None, base_address: int | None) -> str:
+    new_lines = []
+
+    for line in code.splitlines():
+        if original_code is not None:
+            formatted_bytes = ", ".join(map(hex, original_code))
+            formatted_original_code = f"db {formatted_bytes}"
+
+            line = line.replace(ORIGINAL_CODE_PLACEHOLDER, formatted_original_code)
+
+        if base_address is not None:
+            line = line.replace(BASE_ADDRESS_PLACEHOLDER, hex(base_address))
+
+        if MOVE_X64_MACROS in line:
+            _, address, register = line.strip().split()
+            line = get_move_x64_register_to_memory_code(address, register)
+
+        new_lines.append(line)
+
+    return "\n".join(new_lines)
+
+
+@lru_cache
 def compile_asm(code: Code) -> bytes:
     if isinstance(code, str):
         logger.debug(f"Assembling for x{ARCH}:\n{code}")
@@ -203,6 +241,18 @@ def get_long_x64_jump_back_code(address: int) -> str:
     """
 
 
+def get_move_x64_register_to_memory_code(address: int | str, register: str) -> str:
+    temporary_register = "rbx" if register == "rax" else "rax"
+    code = f"""
+        push {temporary_register}
+        mov {temporary_register}, {address}
+        mov [{temporary_register}], {register}
+        pop {temporary_register}
+    """
+
+    return code
+
+
 def safely_eject_all_code_injections() -> None:
     for injection in AbstractCodeInjection.created_code_injections:
         with suppress(MemoryWriteError):

trainerbase-4.6.0/trainerbase/config.py

@@ -0,0 +1,56 @@
+from pathlib import Path
+from tomllib import load as load_toml
+from typing import Any, Final
+
+from pydantic import AliasChoices, BaseModel, Field
+
+
+CONFIG_FILE: Final[Path] = Path("./trainerbase.toml")
+
+DEFAULT_VENDOR_FOLDER_PATHS: Final[list[Path]] = [
+    Path(__file__).resolve().parent.parent / "trainerbase_vendor",
+    Path().resolve() / "trainerbase_vendor",
+]
+
+
+class Process(BaseModel):
+    names: list[str] = Field(validation_alias=AliasChoices("names", "process_names"))
+    exact_match: bool = True
+    ignore_case: bool = False
+
+
+class SpeedhackConfig(BaseModel):
+    offset_x64: int = 0x47098
+    offset_x32: int = 0x40058
+
+
+class Vendor(BaseModel):
+    extra_search_paths: list[Path] | None = None
+    speedhack: SpeedhackConfig = SpeedhackConfig()
+
+    @property
+    def folder(self) -> Path:
+        search_paths = DEFAULT_VENDOR_FOLDER_PATHS.copy()
+
+        if self.extra_search_paths is not None:
+            search_paths.extend(self.extra_search_paths)
+
+        try:
+            path = next(filter(Path.is_dir, search_paths))
+        except StopIteration as e:
+            raise ValueError("Failed to find Trainer Base vendor folder") from e
+
+        return path.resolve()
+
+
+class Config(BaseModel):
+    process: Process = Field(validation_alias=AliasChoices("process", "pymem"))
+    vendor: Vendor = Vendor()
+    logging: dict[str, Any] | None = None  # Must be managed by logging.dictConfig
+
+
+with CONFIG_FILE.resolve().open("rb") as trainerbase_toml:
+    trainerbase_config = load_toml(trainerbase_toml)
+
+
+config = Config.model_validate(trainerbase_config)

{trainerbase-4.5.0 → trainerbase-4.6.0}/trainerbase/logger.py

@@ -1,10 +1,10 @@
 from logging import ERROR, getLogger
 from logging.config import dictConfig
 
-from trainerbase.config import CONFIG_FILE, config_warnings, logging_config
+from trainerbase.config import CONFIG_FILE, config
 
 
-if logging_config is None:
+if config.logging is None:
     logging_config = {
         "version": 1,
         "disable_existing_loggers": True,
@@ -28,9 +28,9 @@ if logging_config is None:
     }
     using_default_config = True
 else:
+    logging_config = config.logging
     using_default_config = False
 
-
 dictConfig(logging_config)
 getLogger("comtypes").setLevel(ERROR)
 
@@ -38,6 +38,3 @@ logger = getLogger("TrainerBase")
 
 if using_default_config:
     logger.debug(f"No logging config in {CONFIG_FILE}! Using default one.")
-
-for warning_message in config_warnings:
-    logger.warning(warning_message)

{trainerbase-4.5.0 → trainerbase-4.6.0}/trainerbase/memory.py

@@ -207,3 +207,41 @@ def get_module_address(module_name: str, *, delay: float = 2, retry_limit: int |
         sleep(delay)
 
     raise RuntimeError("This code must be unreachable!")
+
+
+def ensure_resolved(
+    address: AbstractAddress,
+    verbose_name: str,
+    *,
+    delay: float = 2,
+    retry_limit: int | None = 4,
+) -> int:
+    """
+    Returns resolved address.
+    Raises RuntimeError if the address was not found and retry_limit is reached.
+
+    Set retry_limit to None or negative value if you need infinite retry cycle.
+    Set retry_limit to 0 if you want to disable retries.
+    """
+
+    logger.info(f"Looking for {verbose_name}...")
+
+    for try_counter in count():
+        try:
+            resolved = address.resolve()
+        except ValueError as e:
+            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}")
+
+            sleep(delay)
+            continue
+
+        logger.info(f"Successfully found {verbose_name} at 0x{resolved:X}")
+        return resolved
+
+    raise RuntimeError("This code must be unreachable!")
+
+
+mainaob = partial(AOBScan, module_name=pm.process_base.name)

{trainerbase-4.5.0 → trainerbase-4.6.0}/trainerbase/process.py

@@ -9,7 +9,7 @@ from psutil import Process, pid_exists, process_iter
 from pymem import Pymem
 from pymem.exception import ProcessError
 
-from trainerbase.config import process_config
+from trainerbase.config import config
 from trainerbase.logger import logger
 
 
@@ -70,15 +70,15 @@ def ensure_main_module_is_initialized(pm: Pymem) -> int:
 
 
 def attach_to_process() -> Pymem:
-    process_names = process_config["names"]
-    exact_match = process_config["exact_match"]
-    ignore_case = process_config["ignore_case"]
-
-    if not process_names:
+    if not config.process.names:
         raise ValueError("Empty process name list")
 
     with suppress(KeyboardInterrupt):
-        pid = get_target_pid(process_names, exact_match=exact_match, ignore_case=ignore_case)
+        pid = get_target_pid(
+            config.process.names,
+            exact_match=config.process.exact_match,
+            ignore_case=config.process.ignore_case,
+        )
 
         pm = Pymem(pid)
         ensure_main_module_is_initialized(pm)

{trainerbase-4.5.0 → trainerbase-4.6.0}/trainerbase/speedhack.py

@@ -5,16 +5,17 @@ from typing import Final, Self, cast
 from pyinjector import inject
 from pymem.exception import MemoryWriteError
 
+from trainerbase.config import config
 from trainerbase.gameobject import GameDouble
 from trainerbase.memory import ARCH, get_module_address
 from trainerbase.process import pm
 
 
 SPEEDHACK_DLL_MODULE_NAME: Final[str] = f"speedhack{ARCH}.dll"
-SPEEDHACK_DLL_PATH: Final[Path] = (
-    Path(__file__).resolve().parent.parent / "trainerbase_vendor" / SPEEDHACK_DLL_MODULE_NAME
+SPEEDHACK_DLL_PATH: Final[Path] = config.vendor.folder / SPEEDHACK_DLL_MODULE_NAME
+SPEED_MODIFIER_OFFSET: Final[int] = (
+    config.vendor.speedhack.offset_x32 if ARCH == 32 else config.vendor.speedhack.offset_x64
 )
-SPEED_MODIFIER_OFFSET: Final[int] = 0x40058 if ARCH == 32 else 0x47098
 
 
 class SpeedHack:

trainerbase-4.5.0/trainerbase/config.py

@@ -1,29 +0,0 @@
-from pathlib import Path
-from tomllib import load as load_toml
-from typing import Final
-
-
-CONFIG_FILE: Final[Path] = Path("./trainerbase.toml")
-
-
-with CONFIG_FILE.resolve().open("rb") as trainerbase_toml:
-    trainerbase_config = load_toml(trainerbase_toml)
-
-
-config_warnings = []
-
-
-try:
-    process_config = trainerbase_config["process"]
-except KeyError:
-    # Legacy section support
-    process_config = trainerbase_config["pymem"]
-    process_config["names"] = process_config["process_names"]
-    del trainerbase_config["pymem"]
-
-    config_warnings.append(
-        "Deprecated config! Use [process] section with field `names` instead of [pymem] with `process_names`"
-    )
-
-
-logging_config = trainerbase_config.get("logging")