trainerbase 4.0.8__tar.gz → 4.1.0__tar.gz

{trainerbase-4.0.8 → trainerbase-4.1.0}/PKG-INFO

@@ -1,15 +1,16 @@
 Metadata-Version: 2.1
 Name: trainerbase
-Version: 4.0.8
+Version: 4.1.0
 Summary: Framework for creating game trainers/mods
 Home-page: https://gitlab.com/python-trainers/trainer-base
 License: MIT
 Author: v01d
 Author-email: v01d@v01d.ru
-Requires-Python: >=3.12,<3.14
+Requires-Python: >=3.12,<4.0
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: dearpygui (>=2.0.0,<3.0.0)
 Requires-Dist: keyboard (>=0.13.5,<0.14.0)
 Requires-Dist: mouse (>=0.7.1,<0.8.0)

{trainerbase-4.0.8 → trainerbase-4.1.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "trainerbase"
-version = "4.0.8"
+version = "4.1.0"
 description = "Framework for creating game trainers/mods"
 authors = ["v01d <v01d@v01d.ru>", "doomayka <zd@doomayka.ru>"]
 license = "MIT"
@@ -17,7 +17,7 @@ include = [
 ]
 
 [tool.poetry.group.dev.dependencies]
-ruff = "^0.7.0"
+ruff = "^0.7.1"
 
 [tool.ruff]
 src = ["trainerbase"]
@@ -47,7 +47,7 @@ lines-after-imports = 2
 line-ending = "lf"
 
 [tool.poetry.dependencies]
-python = ">=3.12,<3.14"
+python = "^3.12"
 pymem = "^1.13.3"
 keyboard = "^0.13.5"
 pyttsx3 = "^2.98"

trainerbase-4.1.0/trainerbase/common/tapper.py

@@ -0,0 +1,78 @@
+from enum import StrEnum, auto
+from time import sleep
+from typing import override
+
+from keyboard import press as press_keyboard_key
+from keyboard import release as release_keyboard_key
+from mouse import press as press_mouse_button
+from mouse import release as release_mouse_button
+
+from trainerbase.abc import Switchable
+from trainerbase.scriptengine import ScriptEngine
+
+
+class TappingDevice(StrEnum):
+    MOUSE = auto()
+    KEYBOARD = auto()
+
+
+class Tapper(Switchable):
+    def __init__(
+        self,
+        default_delay: float,
+        tap_button: str = "left",
+        device: TappingDevice = TappingDevice.MOUSE,
+        duration: float = 0.15,
+    ):
+        self._delay = default_delay
+        self._duration = duration
+        self.button = tap_button
+        self.device = device
+        self.tapper_script_engine: ScriptEngine | None = None
+        self.tapper_function = (
+            self._send_mouse_click_with_duration
+            if device is TappingDevice.MOUSE
+            else self._send_keyboard_press_and_release_with_duration
+        )
+
+    @override
+    def enable(self):
+        self.disable()
+
+        self.tapper_script_engine = ScriptEngine(self._delay)
+        self.tapper_script_engine.simple_script(self.tapper_function, enabled=True)
+        self.tapper_script_engine.start()
+
+    @override
+    def disable(self):
+        if self.tapper_script_engine is not None:
+            self.tapper_script_engine.stop()
+
+    def _send_mouse_click_with_duration(self):
+        press_mouse_button(self.button)
+        sleep(self._duration)
+        release_mouse_button(self.button)
+
+    def _send_keyboard_press_and_release_with_duration(self):
+        press_keyboard_key(self.button)
+        sleep(self._duration)
+        release_keyboard_key(self.button)
+
+    @property
+    def delay(self):
+        return self._delay
+
+    @delay.setter
+    def delay(self, new_delay: float):
+        if self.tapper_script_engine is not None:
+            self.tapper_script_engine.delay = new_delay
+
+        self._delay = new_delay
+
+    @property
+    def duration(self):
+        return self._duration
+
+    @duration.setter
+    def duration(self, new_duration: float):
+        self._duration = new_duration

trainerbase-4.1.0/trainerbase/gui/tapper.py

@@ -0,0 +1,120 @@
+from collections.abc import Sequence
+from typing import override
+from uuid import uuid4
+
+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, TextUI
+from trainerbase.gui.types import AbstractUIComponent
+
+
+class TapperUI(AbstractUIComponent):
+    DPG_TAG_TAPPER_DELAY_INPUT_PREFIX = "tag_tapper_delay_input"
+    DPG_TAG_TAPPER_DELAY_PRESET_INPUT_PREFIX = "tag_tapper_delay_preset_input"
+    DPG_TAG_TAPPER_DURATION_INPUT_PREFIX = "tag_tapper_duration_input"
+    DPG_TAG_TAPPER_DURATION_PRESET_INPUT_PREFIX = "tag_tapper_duration_preset_input"
+
+    DELAY_PRESETS: tuple[float, ...] = (0.05, 0.15, 0.25, 0.3, 0.5, 0.7, 1, 2, 5, 10)
+    DURATION_PRESETS: tuple[float, ...] = (0.0, 0.15, 0.3, 0.5, 0.75, 1, 1.5, 5.0)
+
+    def __init__(
+        self,
+        tapper: Tapper | None = None,
+        key: str = "PageUp",
+        default_delay: float = 0.15,
+        default_duration: float = 0.15,
+    ):
+        if tapper is None:
+            self.tapper = Tapper(default_delay, duration=default_duration)
+            self.default_delay = default_delay
+            self.default_duration = default_duration
+        else:
+            self.tapper = tapper
+            self.default_delay = tapper.delay
+            self.default_duration = tapper.duration
+
+        self.key = key
+        self.dpg_tag_tapper_delay_input = f"{self.DPG_TAG_TAPPER_DELAY_INPUT_PREFIX}_{uuid4()}"
+        self.dpg_tag_tapper_delay_preset_input = f"{self.DPG_TAG_TAPPER_DELAY_PRESET_INPUT_PREFIX}_{uuid4()}"
+        self.dpg_tag_tapper_duration_input = f"{self.DPG_TAG_TAPPER_DELAY_INPUT_PREFIX}_{uuid4()}"
+        self.dpg_tag_tapper_duration_preset_input = f"{self.DPG_TAG_TAPPER_DELAY_PRESET_INPUT_PREFIX}_{uuid4()}"
+
+    @override
+    def add_to_ui(self) -> None:
+        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,
+            label="Delay",
+            min_value=0.0,
+            max_value=60.0,
+            default_value=self.default_delay,
+            min_clamped=True,
+            max_clamped=True,
+            callback=self.on_delay_change,
+        )
+
+        dpg.add_slider_int(
+            tag=self.dpg_tag_tapper_delay_preset_input,
+            label="Delay Preset",
+            min_value=0,
+            max_value=len(self.DELAY_PRESETS) - 1,
+            clamped=True,
+            default_value=self.get_closest_preset_index(self.DELAY_PRESETS, self.default_delay),
+            callback=self.on_delay_preset_change,
+        )
+
+        dpg.add_separator()
+
+        dpg.add_input_double(
+            tag=self.dpg_tag_tapper_duration_input,
+            label="Duration",
+            min_value=0.0,
+            max_value=5.0,
+            default_value=self.default_duration,
+            min_clamped=True,
+            max_clamped=True,
+            callback=self.on_duration_change,
+        )
+
+        dpg.add_slider_int(
+            tag=self.dpg_tag_tapper_duration_preset_input,
+            label="Duration Preset",
+            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),
+            callback=self.on_duration_preset_change,
+        )
+
+    def on_delay_preset_change(self):
+        new_delay = self.DELAY_PRESETS[dpg.get_value(self.dpg_tag_tapper_delay_preset_input)]
+        self.tapper.delay = new_delay
+        dpg.set_value(self.dpg_tag_tapper_delay_input, new_delay)
+
+    def on_delay_change(self):
+        new_delay = dpg.get_value(self.dpg_tag_tapper_delay_input)
+        closest_preset_index = self.get_closest_preset_index(self.DELAY_PRESETS, new_delay)
+        self.tapper.delay = new_delay
+        dpg.set_value(self.dpg_tag_tapper_delay_preset_input, closest_preset_index)
+
+    def on_duration_preset_change(self):
+        new_duration = self.DURATION_PRESETS[dpg.get_value(self.dpg_tag_tapper_duration_preset_input)]
+        self.tapper.duration = new_duration
+        dpg.set_value(self.dpg_tag_tapper_duration_input, new_duration)
+
+    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)
+        self.tapper.duration = new_duration
+        dpg.set_value(self.dpg_tag_tapper_duration_preset_input, closest_preset_index)
+
+    def get_closest_preset_index(self, presests: Sequence[float], value: float) -> int:
+        closest_preset = min(presests, key=lambda preset: abs(preset - value))
+        return presests.index(closest_preset)

trainerbase-4.1.0/trainerbase/process.py

@@ -0,0 +1,87 @@
+from collections.abc import Iterable
+from contextlib import suppress
+from itertools import cycle
+from os import _exit as force_exit
+from typing import cast
+
+from psutil import Process, pid_exists, process_iter
+from pymem import Pymem
+
+from trainerbase.config import pymem_config
+from trainerbase.logger import logger
+
+
+def find_processes(process_name: str, *, exact_match: bool, ignore_case: bool) -> list[Process]:
+    if ignore_case:
+        process_name = process_name.lower()
+
+    result_process_list = []
+
+    for process in process_iter():
+        name = process.name()
+
+        if ignore_case:
+            name = name.lower()
+
+        condition = process_name == name if exact_match else process_name in name
+
+        if condition:
+            result_process_list.append(process)
+
+    return result_process_list
+
+
+def select_one_process(processes: Iterable[Process]) -> Process:
+    processes = sorted(processes, key=lambda process: process.memory_info().rss, reverse=True)
+
+    if not processes:
+        raise ValueError("Cannot select from empty sequence!")
+
+    if len(processes) > 1:
+        logger.debug("Multiple processes found! Selecting one with highest Resident Set Size.")
+
+    return next(iter(processes))
+
+
+def get_target_pid(process_names: Iterable[str], *, exact_match: bool, ignore_case: bool) -> int:
+    logger.info(f"Waiting for process in: {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}")
+
+            return pid
+
+    raise RuntimeError("This place must be unreachable! `process_names` is probably empty.")
+
+
+def attach_to_process() -> Pymem:
+    process_names = pymem_config["process_names"]
+    exact_match = pymem_config["exact_match"]
+    ignore_case = pymem_config["ignore_case"]
+
+    if not 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)
+        return Pymem(pid)
+
+    force_exit(0)
+
+
+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()
+
+
+_pm = attach_to_process()

trainerbase-4.0.8/trainerbase/common/tapper.py

@@ -1,58 +0,0 @@
-from collections.abc import Callable
-from enum import StrEnum, auto
-from functools import partial
-from typing import assert_never, override
-
-from keyboard import send
-from mouse import click
-
-from trainerbase.abc import Switchable
-from trainerbase.scriptengine import ScriptEngine
-
-
-class TappingDevice(StrEnum):
-    MOUSE = auto()
-    KEYBOARD = auto()
-
-    @property
-    def function(self) -> Callable[[str], None]:
-        match self:
-            case self.MOUSE:
-                return click
-            case self.KEYBOARD:
-                return send
-            case _:
-                assert_never(self)
-
-
-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)
-
-    @override
-    def enable(self):
-        self.disable()
-
-        self.tapper_script_engine = ScriptEngine(self._delay)
-        self.tapper_script_engine.simple_script(self.tapper_function, enabled=True)
-        self.tapper_script_engine.start()
-
-    @override
-    def disable(self):
-        if self.tapper_script_engine is not None:
-            self.tapper_script_engine.stop()
-
-    @property
-    def delay(self):
-        return self._delay
-
-    @delay.setter
-    def delay(self, new_delay: float):
-        if self.tapper_script_engine is not None:
-            self.tapper_script_engine.delay = new_delay
-
-        self._delay = new_delay

trainerbase-4.0.8/trainerbase/gui/tapper.py

@@ -1,77 +0,0 @@
-from typing import override
-from uuid import uuid4
-
-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, TextUI
-from trainerbase.gui.types import AbstractUIComponent
-
-
-class TapperUI(AbstractUIComponent):
-    DPG_TAG_TAPPER_DELAY_INPUT_PREFIX = "tag_tapper_delay_input"
-    DPG_TAG_TAPPER_PRESET_INPUT_PREFIX = "tag_tapper_preset_input"
-
-    PRESETS: tuple[float, ...] = (0.05, 0.15, 0.25, 0.3, 0.5, 0.7, 1, 2, 5, 10)
-
-    def __init__(
-        self,
-        tapper: Tapper | None = None,
-        key: str = "PageUp",
-        default_delay: float = 0.15,
-    ):
-        if tapper is None:
-            self.tapper = Tapper(default_delay)
-            self.default_delay = default_delay
-        else:
-            self.tapper = tapper
-            self.default_delay = tapper.delay
-
-        self.key = key
-        self.dpg_tag_tapper_delay_input = f"{self.DPG_TAG_TAPPER_DELAY_INPUT_PREFIX}_{uuid4()}"
-        self.dpg_tag_tapper_preset_input = f"{self.DPG_TAG_TAPPER_PRESET_INPUT_PREFIX}_{uuid4()}"
-
-    @override
-    def add_to_ui(self) -> None:
-        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,
-            label="Tapper Delay",
-            min_value=0.0,
-            max_value=60.0,
-            default_value=self.default_delay,
-            min_clamped=True,
-            max_clamped=True,
-            callback=self.on_delay_change,
-        )
-
-        dpg.add_slider_int(
-            tag=self.dpg_tag_tapper_preset_input,
-            label="Preset",
-            min_value=0,
-            max_value=len(self.PRESETS) - 1,
-            clamped=True,
-            default_value=self.get_closest_preset_index(self.default_delay),
-            callback=self.on_preset_change,
-        )
-
-    def on_preset_change(self):
-        new_delay = self.PRESETS[dpg.get_value(self.dpg_tag_tapper_preset_input)]
-        self.tapper.delay = new_delay
-        dpg.set_value(self.dpg_tag_tapper_delay_input, new_delay)
-
-    def on_delay_change(self):
-        new_delay = dpg.get_value(self.dpg_tag_tapper_delay_input)
-        closest_preset_index = self.get_closest_preset_index(new_delay)
-        self.tapper.delay = new_delay
-        dpg.set_value(self.dpg_tag_tapper_preset_input, closest_preset_index)
-
-    def get_closest_preset_index(self, delay: float) -> int:
-        closest_preset = min(self.PRESETS, key=lambda preset: abs(preset - delay))
-        return self.PRESETS.index(closest_preset)

trainerbase-4.0.8/trainerbase/process.py

@@ -1,51 +0,0 @@
-from contextlib import suppress
-from itertools import cycle
-from os import _exit as force_exit
-from typing import cast
-
-from psutil import Process, pid_exists
-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:
-    process_names = pymem_config["process_names"]
-
-    if not process_names:
-        raise ValueError("Empty process name list")
-
-    logger.info(f"Waiting for process in: {process_names}")
-
-    with suppress(KeyboardInterrupt):
-        for process_name in cycle(process_names):
-            try:
-                pm = Pymem(
-                    process_name,
-                    exact_match=pymem_config["exact_match"],
-                    ignore_case=pymem_config["ignore_case"],
-                )
-            except ProcessNotFound:
-                continue
-
-            logger.info(f"Found {process_name}, pid: {pm.process_id}")
-
-            return pm
-
-    force_exit(0)
-
-
-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()
-
-
-_pm = attach_to_process()