trainerbase 4.0.0__tar.gz → 4.0.2__tar.gz

{trainerbase-4.0.0 → trainerbase-4.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: trainerbase
-Version: 4.0.0
+Version: 4.0.2
 Summary: Framework for creating game trainers/mods
 Home-page: https://gitlab.com/python-trainers/trainer-base
 License: MIT

{trainerbase-4.0.0 → trainerbase-4.0.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "trainerbase"
-version = "4.0.0"
+version = "4.0.2"
 description = "Framework for creating game trainers/mods"
 authors = ["v01d <v01d@v01d.ru>", "doomayka <zd@doomayka.ru>"]
 license = "MIT"

{trainerbase-4.0.0 → trainerbase-4.0.2}/trainerbase/common/tapper.py

@@ -28,6 +28,8 @@ class TappingDevice(StrEnum):
 class Tapper(Switchable):
     def __init__(self, default_delay: float, tap_button: str = "left", device: TappingDevice = TappingDevice.MOUSE):
         self._delay = default_delay
+        self.button = tap_button
+        self.device = device
         self.tapper_script_engine: ScriptEngine | None = None
         self.tapper_function = partial(device.function, tap_button)
 

trainerbase-4.0.2/trainerbase/config.py

@@ -0,0 +1,15 @@
+from pathlib import Path
+from typing import Final
+
+from tomllib import load as load_toml
+
+
+CONFIG_FILE: Final[Path] = Path("./trainerbase.toml")
+
+
+with CONFIG_FILE.resolve().open("rb") as trainerbase_toml:
+    trainerbase_config = load_toml(trainerbase_toml)
+
+
+pymem_config = trainerbase_config["pymem"]
+logging_config = trainerbase_config.get("logging")

{trainerbase-4.0.0 → trainerbase-4.0.2}/trainerbase/gui/tapper.py

@@ -5,7 +5,7 @@ from dearpygui import dearpygui as dpg
 from trainerbase.common.keyboard import ReleaseHotkeySwitch
 from trainerbase.common.tapper import Tapper
 from trainerbase.gui.helpers import add_components
-from trainerbase.gui.misc import HotkeyHandlerUI
+from trainerbase.gui.misc import HotkeyHandlerUI, TextUI
 from trainerbase.gui.types import AbstractUIComponent
 
 
@@ -32,7 +32,10 @@ class TapperUI(AbstractUIComponent):
 
     @override
     def add_to_ui(self) -> None:
-        add_components(HotkeyHandlerUI(ReleaseHotkeySwitch(self.tapper, self.key), "Tapper"))
+        add_components(
+            TextUI(f"Tapper for {self.tapper.device} {self.tapper.button}"),
+            HotkeyHandlerUI(ReleaseHotkeySwitch(self.tapper, self.key), "Tapper"),
+        )
 
         dpg.add_input_double(
             tag=self.DPG_TAG_TAPPER_DELAY_INPUT,

trainerbase-4.0.2/trainerbase/logger.py

@@ -0,0 +1,40 @@
+from logging import ERROR, getLogger
+from logging.config import dictConfig
+
+from trainerbase.config import CONFIG_FILE, logging_config
+
+
+if logging_config is None:
+    logging_config = {
+        "version": 1,
+        "disable_existing_loggers": True,
+        "formatters": {
+            "default": {
+                "format": "[%(asctime)s] <%(levelname)s> %(funcName)s: %(message)s",
+                "datefmt": "%Y-%m-%d %H:%M:%S",
+            }
+        },
+        "handlers": {
+            "console": {
+                "formatter": "default",
+                "class": "logging.StreamHandler",
+                "stream": "ext://sys.stdout",
+            }
+        },
+        "root": {
+            "level": "INFO",
+            "handlers": ["console"],
+        },
+    }
+    display_no_logger_config_warning = True
+else:
+    display_no_logger_config_warning = False
+
+
+dictConfig(logging_config)
+getLogger("comtypes").setLevel(ERROR)
+
+logger = getLogger("TrainerBase")
+
+if display_no_logger_config_warning:
+    logger.warning(f"No logging config in {CONFIG_FILE}! Use updated trainer template.")

{trainerbase-4.0.0 → trainerbase-4.0.2}/trainerbase/main.py

@@ -7,6 +7,7 @@ from trainerbase.codeinjection import safely_eject_all_code_injections
 from trainerbase.common.rainbow import gradient_updater
 from trainerbase.gameobject import update_frozen_objects
 from trainerbase.gui.objects import update_displayed_objects
+from trainerbase.logger import logger
 from trainerbase.process import shutdown_if_process_exited
 from trainerbase.scriptengine import (
     enabled_by_default,
@@ -15,6 +16,7 @@ from trainerbase.scriptengine import (
     system_script_engine,
 )
 from trainerbase.speedhack import SpeedHack
+from trainerbase.tts import tts_manager
 
 
 type Callback = Callable[[], None]
@@ -26,34 +28,51 @@ def run(  # pylint: disable=too-complex
     on_shutdown_hook: Callback | None = None,
 ) -> NoReturn:
     def on_shutdown() -> NoReturn:
+        logger.debug("Shutting down. Stopping Script Engines.")
+
         rainbow_script_engine.stop()
         system_script_engine.stop()
         process_healthcheck_script_engine.stop()
 
+        logger.debug("Ejecting Code Injections.")
+
         safely_eject_all_code_injections()
+
+        logger.debug("Disabling SpeedHack")
+
         SpeedHack.disable()
 
         if on_shutdown_hook is not None:
+            logger.debug("on_shutdown_hook provided. Calling.")
             on_shutdown_hook()
 
         force_exit(0)
 
     def on_gui_initialized() -> None:
+        logger.debug("GUI has been initialized. Starting Script Engines.")
+
         system_script_engine.start()
         process_healthcheck_script_engine.start()
         rainbow_script_engine.start()
 
         if on_gui_initialized_hook is not None:
+            logger.debug("on_gui_initialized_hook provided. Calling.")
+
             try:
                 on_gui_initialized_hook()
             except Exception:
+                logger.error("Exception occurred while calling on_gui_initialized_hook. See stderr.")
                 print_exc()
                 on_shutdown()
 
+    logger.debug("Registering core scripts")
     system_script_engine.simple_script(update_frozen_objects, enabled=True)
     system_script_engine.simple_script(update_displayed_objects, enabled=True)
-    process_healthcheck_script_engine.simple_script(shutdown_if_process_exited, enabled=True)
+    system_script_engine.register_script(enabled_by_default(tts_manager))
     rainbow_script_engine.register_script(enabled_by_default(gradient_updater))
+    process_healthcheck_script_engine.simple_script(shutdown_if_process_exited, enabled=True)
+
+    logger.debug("Running GUI")
 
     try:
         run_gui(on_gui_initialized, on_shutdown)

{trainerbase-4.0.0 → trainerbase-4.0.2}/trainerbase/memory.py

@@ -9,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 trainerbase.logger import logger
 from trainerbase.process import _pm as pm
 
 
@@ -22,6 +23,9 @@ 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}")
+
+
 class AbstractAddress(ABC):
     @abstractmethod
     def resolve(self) -> int:
@@ -169,7 +173,10 @@ def ensure_address(obj: ConvertibleToAddress) -> AbstractAddress:
 
 
 def allocate(size: int = POINTER_SIZE, count: int = 1) -> int:
-    return pm.allocate(size * count)
+    total = size * count
+    logger.debug(f"Allocating {total} bytes.")
+
+    return pm.allocate(total)
 
 
 def get_module_address(module_name: str, *, delay: float = 2, retry_limit: int | None = 4) -> int:
@@ -181,15 +188,20 @@ 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}...")
+
     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 {module_info.lpBaseOfDll:x}")
             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}")
+
         sleep(delay)
 
     raise RuntimeError("This code must be unreachable!")

{trainerbase-4.0.0 → trainerbase-4.0.2}/trainerbase/process.py

@@ -8,6 +8,7 @@ from pymem import Pymem
 from pymem.exception import ProcessNotFound
 
 from trainerbase.config import pymem_config
+from trainerbase.logger import logger
 
 
 def attach_to_process() -> Pymem:
@@ -16,7 +17,7 @@ def attach_to_process() -> Pymem:
     if not process_names:
         raise ValueError("Empty process name list")
 
-    print("Waiting for process in:", process_names)
+    logger.info(f"Waiting for process in: {process_names}")
 
     with suppress(KeyboardInterrupt):
         for process_name in cycle(process_names):
@@ -29,7 +30,7 @@ def attach_to_process() -> Pymem:
             except ProcessNotFound:
                 continue
 
-            print(f"Found {process_name}, pid: {pm.process_id}")
+            logger.info(f"Found {process_name}, pid: {pm.process_id}")
 
             return pm
 
@@ -38,10 +39,12 @@ def attach_to_process() -> Pymem:
 
 def shutdown_if_process_exited():
     if not pid_exists(cast(int, _pm.process_id)):
+        logger.info("Game process exited. Shutting down.")
         force_exit(0)
 
 
 def kill_game_process():
+    logger.info("Killing game process.")
     Process(_pm.process_id).kill()
 
 

trainerbase-4.0.2/trainerbase/tts.py

@@ -0,0 +1,45 @@
+from collections import deque
+from typing import override
+
+from pyttsx3 import init as init_tts_engine
+
+from trainerbase.scriptengine import AbstractBaseScript
+
+
+class TTSManager(AbstractBaseScript):
+    def __init__(self, queue_length_limit: int = 5):
+        self.__engine = init_tts_engine()
+        self.__queue = deque(maxlen=queue_length_limit)
+
+    @override
+    def __call__(self):
+        if not self.__queue:
+            return
+
+        try:
+            self.__say_sync(*self.__queue[0])
+        except RuntimeError:
+            return
+
+        self.__queue.popleft()
+
+    def __say_sync(self, text: str, rate: int = 210, volume: float = 1.0):
+        self.__engine.setProperty("rate", rate)
+        self.__engine.setProperty("volume", volume)
+        self.__engine.say(text)
+        self.__engine.runAndWait()
+
+    @property
+    def queue_length_limit(self):
+        return self.__queue.maxlen
+
+    @queue_length_limit.setter
+    def queue_length_limit(self, limit: int):
+        self.__queue = deque(self.__queue, maxlen=limit)
+
+    def schedule(self, text: str, rate: int = 210, volume: float = 1.0):
+        self.__queue.append((text, rate, volume))
+
+
+tts_manager = TTSManager()
+say = say_sync = tts_manager.schedule

trainerbase-4.0.0/trainerbase/config.py

@@ -1,10 +0,0 @@
-from pathlib import Path
-
-from tomllib import load as load_toml
-
-
-with Path("./trainerbase.toml").resolve().open("rb") as trainerbase_toml:
-    trainerbase_config = load_toml(trainerbase_toml)
-
-
-pymem_config = trainerbase_config["pymem"]

trainerbase-4.0.0/trainerbase/tts.py

@@ -1,30 +0,0 @@
-from contextlib import suppress
-from threading import Thread
-
-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):
-    args = (text, rate, volume)
-
-    if sync:
-        say_sync(*args)
-    else:
-        Thread(target=say_sync, args=args).start()
-
-
-def say_sync(text: str, rate: int, volume: float):
-    engine.stop()
-
-    with suppress(RuntimeError):
-        engine.endLoop()
-
-    engine.setProperty("rate", rate)
-    engine.setProperty("volume", volume)
-    engine.say(text)
-
-    with suppress(RuntimeError):
-        engine.runAndWait()