trainerbase 4.2.5__tar.gz → 4.4.0__tar.gz

{trainerbase-4.2.5 → trainerbase-4.4.0}/LICENSE

@@ -1,7 +1,7 @@
 MIT License
 
-Copyright (c) 2021 - 2024 v01d
-Copyright (c) 2022 - 2024 doomayka
+Copyright (c) 2021 - 2025 v01d
+Copyright (c) 2022 - 2025 doomayka
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

{trainerbase-4.2.5 → trainerbase-4.4.0}/PKG-INFO

@@ -1,19 +1,19 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: trainerbase
-Version: 4.2.5
+Version: 4.4.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
 Author-email: v01d <v01d@v01d.ru>, doomayka <zd@doomayka.ru>
-License: MIT
-Classifier: Programming Language :: Python :: 3.12
+License-Expression: MIT
+License-File: LICENSE
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: Implementation :: CPython
 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.0
+Requires-Dist: psutil>=6.1.1
 Requires-Dist: pyinjector>=1.3.0
 Requires-Dist: pymem>=1.14.0
 Requires-Dist: pyttsx3>=2.98

{trainerbase-4.2.5 → trainerbase-4.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "trainerbase"
-version = "4.2.5"
+version = "4.4.0"
 description = "Framework for creating game trainers/mods"
 license = "MIT"
 authors = [
@@ -13,7 +13,7 @@ dependencies = [
     "dearpygui>=2.0.0",
     "keyboard>=0.13.5",
     "mouse>=0.7.1",
-    "psutil>=6.1.0",
+    "psutil>=6.1.1",
     "pyinjector>=1.3.0",
     "pymem>=1.14.0",
     "pyttsx3>=2.98",
@@ -21,7 +21,6 @@ dependencies = [
 
 classifiers = [
     "Programming Language :: Python :: Implementation :: CPython",
-    "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
 ]
 
@@ -74,5 +73,5 @@ build-backend = "hatchling.build"
 
 [dependency-groups]
 dev = [
-    "ruff>=0.8.2",
+    "ruff>=0.8.6",
 ]

{trainerbase-4.2.5 → trainerbase-4.4.0}/trainerbase/gameobject.py

@@ -52,13 +52,7 @@ class GameObject[PymemType, TrainerBaseType](AbstractReadableObject[TrainerBaseT
             self.value_range = value_range
 
     def __repr__(self):
-        return (
-            f"<{self.__class__.__name__}"
-            f" at {hex(self.address.resolve())}:"
-            f" value={self.value},"
-            f" frozen={self.frozen}"
-            ">"
-        )
+        return f"<{self.__class__.__name__} at {hex(self.address.resolve())}: value={self.value}, frozen={self.frozen}>"
 
     def after_read(self, value: PymemType) -> TrainerBaseType:
         return cast(TrainerBaseType, value)

trainerbase-4.4.0/trainerbase/gui/misc.py

@@ -0,0 +1,143 @@
+from collections.abc import Callable
+from typing import Any, override
+
+from dearpygui import dearpygui as dpg
+
+from trainerbase.common.keyboard import (
+    AbstractKeyboardHandler,
+    GameBoolReleaseHotkeySwitch,
+    ReleaseHotkeySwitch,
+    ShortLongHotkeyPressSwitch,
+    SimpleHotkeyHandler,
+)
+from trainerbase.gameobject import GameBool
+from trainerbase.gui.helpers import add_components
+from trainerbase.gui.objects import GameObjectUI
+from trainerbase.gui.types import AbstractUIComponent
+
+
+class SeparatorUI(AbstractUIComponent):
+    def __init__(self, empty_lines_before: int = 1, empty_lines_after: int = 0):
+        self._empty_lines_before = empty_lines_before
+        self._empty_lines_after = empty_lines_after
+
+    @override
+    def add_to_ui(self) -> None:
+        for _ in range(self._empty_lines_before):
+            dpg.add_text()
+
+        dpg.add_separator()
+
+        for _ in range(self._empty_lines_after):
+            dpg.add_text()
+
+
+class TextUI(AbstractUIComponent):
+    def __init__(self, text: str = ""):
+        self.text = text
+
+    @override
+    def add_to_ui(self) -> None:
+        dpg.add_text(self.text)
+
+
+class HotkeyHandlerUI(AbstractUIComponent):
+    def __init__(
+        self,
+        handler: AbstractKeyboardHandler,
+        label: str,
+    ):
+        self.handler = handler
+        self.label = label
+
+    @override
+    def add_to_ui(self) -> None:
+        match self.handler:
+            case ShortLongHotkeyPressSwitch():
+                dpg.add_text(f"Press/Hold [{self.handler.hotkey}] Toggle/Enable {self.label}")
+            case ReleaseHotkeySwitch():
+                dpg.add_text(f"[{self.handler.hotkey}] Toggle {self.label}")
+            case SimpleHotkeyHandler():
+                dpg.add_button(
+                    label=f"[{self.handler.hotkey}] {self.label}",
+                    callback=self._ensure_callable_has_dunder_code(self.handler.callback),
+                )
+            case _:
+                dpg.add_text(f"[{self.handler.hotkey}] {self.label}")
+
+        self.handler.handle()
+
+    @staticmethod
+    def _ensure_callable_has_dunder_code(callable_object: Callable[[], None]) -> Callable[[], None]:
+        """
+        DPG add_button has `callback` arg. In this case `callback.__code__` is required.
+        """
+
+        if hasattr(callable, "__code__"):
+            callback_with_dunder_code = callable_object
+        else:
+
+            def callback_with_dunder_code():
+                callable_object()
+
+        return callback_with_dunder_code
+
+
+class HorizontalUI(AbstractUIComponent):
+    def __init__(self, *components: AbstractUIComponent):
+        self.components = components
+
+    @override
+    def add_to_ui(self) -> None:
+        with dpg.group(horizontal=True):
+            add_components(*self.components)
+
+        return super().add_to_ui()
+
+
+class SwitchableGameBoolUI(AbstractUIComponent):
+    def __init__(
+        self,
+        gameobject: GameBool,
+        toggle_hotkey: str,
+        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,
+        setter_input_width: int = 220,
+        toggle_text: str = "Toggle",
+    ):
+        self.gameobject = gameobject
+        self.toggle_hotkey = toggle_hotkey
+        self.toggle_text = toggle_text
+
+        self.pure_label = label
+        self.freeze_hotkey = freeze_hotkey
+        self.set_hotkey = set_hotkey
+        self.default_setter_input_value = default_setter_input_value
+        self.before_set = before_set
+        self.tts_on_hotkey = tts_on_hotkey
+        self.setter_input_width = setter_input_width
+
+    @override
+    def add_to_ui(self) -> None:
+        add_components(
+            HorizontalUI(
+                HotkeyHandlerUI(GameBoolReleaseHotkeySwitch(self.gameobject, self.toggle_hotkey), self.toggle_text),
+                GameObjectUI(
+                    self.gameobject,
+                    self.pure_label,
+                    self.freeze_hotkey,
+                    self.set_hotkey,
+                    default_setter_input_value=self.default_setter_input_value,
+                    before_set=self.before_set,
+                    tts_on_hotkey=self.tts_on_hotkey,
+                    setter_input_width=self.setter_input_width,
+                ),
+            )
+        )
+
+        return super().add_to_ui()

{trainerbase-4.2.5 → trainerbase-4.4.0}/trainerbase/gui/speedhack.py

@@ -1,8 +1,9 @@
+from functools import partial
 from typing import override
 
 from dearpygui import dearpygui as dpg
 
-from trainerbase.common.keyboard import ShortLongHotkeyPressSwitch, Switchable
+from trainerbase.common.keyboard import ShortLongHotkeyPressSwitch, SimpleHotkeyHandler, Switchable
 from trainerbase.gui.helpers import add_components
 from trainerbase.gui.misc import HotkeyHandlerUI
 from trainerbase.gui.types import AbstractUIComponent
@@ -34,9 +35,15 @@ class SpeedHackUI(AbstractUIComponent):
         speedhack: SpeedHack | None = None,
         key: str = "Delete",
         default_factor_input_value: float = 3.0,
+        next_preset_hotkey: str | None = "Shift+PageUp",
+        previous_preset_hotkey: str | None = "Shift+PageDown",
     ):
         self.speedhack = SpeedHack() if speedhack is None else speedhack
+
         self.key = key
+        self.next_preset_hotkey = next_preset_hotkey
+        self.previous_preset_hotkey = previous_preset_hotkey
+
         self.default_factor_input_value = default_factor_input_value
         self.handler = ShortLongHotkeyPressSwitch(
             SpeedHackUISwitch(self.speedhack, self.DPG_TAG_SPEEDHACK_FACTOR_INPUT),
@@ -47,6 +54,19 @@ class SpeedHackUI(AbstractUIComponent):
     def add_to_ui(self) -> None:
         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):
+                add_components(
+                    HotkeyHandlerUI(
+                        SimpleHotkeyHandler(partial(self.change_preset, -1), self.previous_preset_hotkey),
+                        "Preset -",
+                    ),
+                    HotkeyHandlerUI(
+                        SimpleHotkeyHandler(partial(self.change_preset, 1), self.next_preset_hotkey),
+                        "Preset +",
+                    ),
+                )
+
         dpg.add_input_double(
             tag=self.DPG_TAG_SPEEDHACK_FACTOR_INPUT,
             label="SpeedHack Factor",
@@ -68,6 +88,15 @@ class SpeedHackUI(AbstractUIComponent):
             callback=self.on_preset_change,
         )
 
+    def change_preset(self, diff: int):
+        new_preset_index = dpg.get_value(self.DPG_TAG_SPEEDHACK_PRESET_INPUT) + diff
+
+        if not (0 <= new_preset_index < len(self.PRESETS)):
+            return
+
+        dpg.set_value(self.DPG_TAG_SPEEDHACK_PRESET_INPUT, new_preset_index)
+        self.on_preset_change()
+
     def on_preset_change(self):
         new_factor = self.PRESETS[dpg.get_value(self.DPG_TAG_SPEEDHACK_PRESET_INPUT)]
         dpg.set_value(self.DPG_TAG_SPEEDHACK_FACTOR_INPUT, new_factor)

{trainerbase-4.2.5 → trainerbase-4.4.0}/trainerbase/scriptengine.py

@@ -36,7 +36,7 @@ class SimpleScript(AbstractBaseScript):
         self.enabled = enabled
 
     def __repr__(self):
-        return f"<Script {getattr(self._callback, "__name__", "Anon function-based script")}: enabled={self.enabled}>"
+        return f"<Script {getattr(self._callback, '__name__', 'Anon function-based script')}: enabled={self.enabled}>"
 
     @override
     def __call__(self):

{trainerbase-4.2.5 → trainerbase-4.4.0}/trainerbase/speedhack.py

@@ -4,11 +4,9 @@ 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
+from trainerbase.memory import ARCH, get_module_address
 from trainerbase.process import pm
 
 
@@ -36,10 +34,7 @@ class SpeedHack:
 
     def _inject(self) -> int:
         inject(cast(int, pm.process_id), str(SPEEDHACK_DLL_PATH))
-
-        speedhack_address = cast(MODULEINFO, module_from_name(pm.process_handle, SPEEDHACK_DLL_MODULE_NAME)).lpBaseOfDll
-
-        return speedhack_address
+        return get_module_address(SPEEDHACK_DLL_MODULE_NAME)
 
     @property
     def factor(self):

trainerbase-4.2.5/trainerbase/gui/misc.py

@@ -1,80 +0,0 @@
-from collections.abc import Callable
-from typing import override
-
-from dearpygui import dearpygui as dpg
-
-from trainerbase.common.keyboard import (
-    AbstractKeyboardHandler,
-    ReleaseHotkeySwitch,
-    ShortLongHotkeyPressSwitch,
-    SimpleHotkeyHandler,
-)
-from trainerbase.gui.types import AbstractUIComponent
-
-
-class SeparatorUI(AbstractUIComponent):
-    def __init__(self, empty_lines_before: int = 1, empty_lines_after: int = 0):
-        self._empty_lines_before = empty_lines_before
-        self._empty_lines_after = empty_lines_after
-
-    @override
-    def add_to_ui(self) -> None:
-        for _ in range(self._empty_lines_before):
-            dpg.add_text()
-
-        dpg.add_separator()
-
-        for _ in range(self._empty_lines_after):
-            dpg.add_text()
-
-
-class TextUI(AbstractUIComponent):
-    def __init__(self, text: str = ""):
-        self.text = text
-
-    @override
-    def add_to_ui(self) -> None:
-        dpg.add_text(self.text)
-
-
-class HotkeyHandlerUI(AbstractUIComponent):
-    def __init__(
-        self,
-        handler: AbstractKeyboardHandler,
-        label: str,
-    ):
-        self.handler = handler
-        self.label = label
-
-    @override
-    def add_to_ui(self) -> None:
-        match self.handler:
-            case ShortLongHotkeyPressSwitch():
-                dpg.add_text(f"Hold [{self.handler.hotkey}] Enable {self.label}")
-                dpg.add_text(f"Press [{self.handler.hotkey}] Toggle {self.label}")
-            case ReleaseHotkeySwitch():
-                dpg.add_text(f"[{self.handler.hotkey}] Toggle {self.label}")
-            case SimpleHotkeyHandler():
-                dpg.add_button(
-                    label=f"[{self.handler.hotkey}] {self.label}",
-                    callback=self._ensure_callable_has_dunder_code(self.handler.callback),
-                )
-            case _:
-                dpg.add_text(f"[{self.handler.hotkey}] {self.label}")
-
-        self.handler.handle()
-
-    @staticmethod
-    def _ensure_callable_has_dunder_code(callable_object: Callable[[], None]) -> Callable[[], None]:
-        """
-        DPG add_button has `callback` arg. In this case `callback.__code__` is required.
-        """
-
-        if hasattr(callable, "__code__"):
-            callback_with_dunder_code = callable_object
-        else:
-
-            def callback_with_dunder_code():
-                callable_object()
-
-        return callback_with_dunder_code