trainerbase 4.8.1__tar.gz → 4.8.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trainerbase
-Version: 4.8.1
+Version: 4.8.2
 Summary: Framework for creating game trainers/mods
 Author: v01d, doomayka
 Author-email: v01d <v01d@v01d.ru>, doomayka <doomaykaka@gmail.com>

{trainerbase-4.8.1 → trainerbase-4.8.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "trainerbase"
-version = "4.8.1"
+version = "4.8.2"
 description = "Framework for creating game trainers/mods"
 license = "MIT"
 authors = [
@@ -34,20 +34,25 @@ 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",
 ]
 
 [tool.ruff.lint.isort]

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

@@ -59,7 +59,7 @@ class CodeInjection(AbstractCodeInjection):
         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 +67,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
@@ -140,19 +140,19 @@ class AllocatingCodeInjection(AbstractCodeInjection):
 
         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}")
+        logger.debug("Injecting %d byte(s) (INJECTION) at 0x%X", len(code_to_inject), self.new_memory_address)
         pm.write_bytes(self.new_memory_address, code_to_inject, len(code_to_inject))
 
-        logger.debug(f"Injecting {len(jump_to_new_mem)} byte(s) (JUMPER) at 0x{self.injection_point:X}")
+        logger.debug("Injecting %d byte(s) (JUMPER) at 0x%X", len(jump_to_new_mem), self.injection_point)
         pm.write_bytes(self.injection_point, jump_to_new_mem, len(jump_to_new_mem))
 
     @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
@@ -200,7 +200,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 +208,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):

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

@@ -22,8 +22,8 @@ class ASMArrayManager(Sequence):
         offsets: None | list[int] = 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
@@ -72,7 +72,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}"
 

{trainerbase-4.8.1 → trainerbase-4.8.2}/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.8.2}/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.8.2}/trainerbase/gameobject.py

@@ -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.8.2}/trainerbase/gui/objects.py

@@ -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.8.2}/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.8.2}/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.8.2}/trainerbase/memory.py

@@ -15,7 +15,8 @@ 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(".")
 
 
 type ConvertibleToAddress = AbstractAddress | int | bytes | str
@@ -24,7 +25,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 +52,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 +90,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,12 +177,12 @@ 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.")
+    logger.debug("Allocating %d bytes.", total)
 
     return pm.allocate(total)
 
@@ -239,19 +242,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 +276,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 +285,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.8.2}/trainerbase/process.py

@@ -46,14 +46,14 @@ 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
 

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

@@ -1,7 +1,6 @@
 from abc import ABC, abstractmethod
 from collections.abc import Callable
 from contextlib import suppress
-from sys import stderr
 from threading import Thread
 from time import sleep
 from typing import Any, override
@@ -9,6 +8,7 @@ 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):
@@ -73,8 +73,8 @@ 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()
 
             sleep(self.delay)