trainerbase 4.8.2__tar.gz → 4.9.0__tar.gz

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

@@ -1,17 +1,17 @@
 Metadata-Version: 2.4
 Name: trainerbase
-Version: 4.8.2
+Version: 4.9.0
 Summary: Framework for creating game trainers/mods
 Author: v01d, doomayka
 Author-email: v01d <v01d@v01d.ru>, doomayka <doomaykaka@gmail.com>
 License-Expression: MIT
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: 3.14
-Requires-Dist: dearpygui>=2.2
+Requires-Dist: dearpygui>=2.3.1
 Requires-Dist: keyboard>=0.13.5
 Requires-Dist: mouse>=0.7.1
 Requires-Dist: psutil>=7.2.2
-Requires-Dist: pydantic>=2.12.5
+Requires-Dist: pydantic>=2.14.0
 Requires-Dist: pymem>=1.14.0
 Requires-Dist: pyttsx3>=2.99
 Requires-Dist: trainerbase-injector>=1.0.1

trainerbase-4.9.0/pyproject.toml

@@ -0,0 +1,92 @@
+[project]
+name = "trainerbase"
+version = "4.9.0"
+description = "Framework for creating game trainers/mods"
+license = "MIT"
+requires-python = ">=3.14"
+readme = "README.md"
+dependencies = [
+    "dearpygui>=2.3.1",
+    "keyboard>=0.13.5",
+    "mouse>=0.7.1",
+    "psutil>=7.2.2",
+    "pydantic>=2.14.0",
+    "pymem>=1.14.0",
+    "pyttsx3>=2.99",
+    "trainerbase-injector>=1.0.1",
+]
+classifiers = [
+    "Programming Language :: Python :: Implementation :: CPython",
+    "Programming Language :: Python :: 3.14",
+]
+
+[[project.authors]]
+name = "v01d"
+email = "v01d@v01d.ru"
+
+[[project.authors]]
+name = "doomayka"
+email = "doomaykaka@gmail.com"
+
+[project.urls]
+Homepage = "https://gitlab.com/python-trainers/"
+Repository = "https://gitlab.com/python-trainers/trainer-base"
+
+[tool.ruff]
+src = ["trainerbase"]
+line-length = 120
+
+[tool.ruff.lint]
+select = ["ALL"]
+ignore = [
+    "D",
+    "ANN",
+    "TC",
+    "EM",
+    "A005",
+    "FIX002",
+    "COM812",
+    "TC002",
+    "S607",
+    "BLE001",
+    "TRY003",
+    "RET504",
+    "PLR2004",
+    "PLR0913",
+    "PLW2901",
+    "TD002",
+    "TD003",
+    "CPY001",
+    "PLR0917",
+]
+
+[tool.ruff.lint.isort]
+lines-after-imports = 2
+
+[tool.ruff.format]
+line-ending = "lf"
+
+[tool.pyright]
+include = ["trainerbase"]
+typeCheckingMode = "standard"
+pythonPlatform = "All"
+pythonVersion = "3.14"
+
+[[tool.pyright.executionEnvironments]]
+root = "."
+extraPaths = ["src"]
+
+[tool.uv.build-backend]
+module-name = "trainerbase"
+module-root = ""
+
+[build-system]
+requires = ["uv_build>=0.11.3,<1.0.0"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = [
+    "invoke>=3.0.3",
+    "pyright>=1.1.414",
+    "ruff>=0.17.0",
+]

trainerbase-4.8.2/pyproject.toml → trainerbase-4.9.0/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "trainerbase"
-version = "4.8.2"
+version = "4.9.0"
 description = "Framework for creating game trainers/mods"
 license = "MIT"
 authors = [
@@ -10,11 +10,11 @@ authors = [
 requires-python = ">=3.14"
 readme = "README.md"
 dependencies = [
-    "dearpygui>=2.2",
+    "dearpygui>=2.3.1",
     "keyboard>=0.13.5",
     "mouse>=0.7.1",
     "psutil>=7.2.2",
-    "pydantic>=2.12.5",
+    "pydantic>=2.14.0",
     "pymem>=1.14.0",
     "pyttsx3>=2.99",
     "trainerbase-injector>=1.0.1",
@@ -53,6 +53,8 @@ ignore = [
     "PLW2901",
     "TD002",
     "TD003",
+    "CPY001",
+    "PLR0917",
 ]
 
 [tool.ruff.lint.isort]
@@ -80,7 +82,7 @@ build-backend = "uv_build"
 
 [dependency-groups]
 dev = [
-    "invoke>=2.2.1",
-    "pyright>=1.1.407",
-    "ruff>=0.15.9",
+    "invoke>=3.0.3",
+    "pyright>=1.1.414",
+    "ruff>=0.17.0",
 ]

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

@@ -11,7 +11,15 @@ 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.memory import (
+    ARCH,
+    REL32_JUMP_SIZE,
+    REL32_MAX_DISPLACEMENT,
+    REL32_MIN_DISPLACEMENT,
+    ConvertibleToAddress,
+    allocate,
+    ensure_address,
+)
 from trainerbase.process import pm
 
 
@@ -19,6 +27,7 @@ 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__"
+LONG_X64_JUMP_SIZE: Final[int] = 14
 
 
 type Code = bytes | str
@@ -56,6 +65,9 @@ class CodeInjection(AbstractCodeInjection):
 
     @override
     def inject(self):
+        if self._injected:
+            return
+
         self.injection_point = self.address.resolve()
         self.original_code = pm.read_bytes(self.injection_point, len(self.code_to_inject))
 
@@ -82,12 +94,9 @@ class AllocatingCodeInjection(AbstractCodeInjection):
         code_to_inject: Code,
         *,
         original_code_length: int = 0,
-        new_memory_size: int = 1024,
-        is_long_x64_jump_needed: bool | None = None,
+        new_memory_size: int | None = None,
+        is_long_x64_jump_needed: bool = False,
     ):
-        if is_long_x64_jump_needed is None:
-            is_long_x64_jump_needed = pm.is_64_bit
-
         self.is_long_x64_jump_needed = is_long_x64_jump_needed
         self.address = ensure_address(address)
         self.code_to_inject = code_to_inject
@@ -101,50 +110,61 @@ class AllocatingCodeInjection(AbstractCodeInjection):
 
     @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)
+        if self.new_memory_address:
+            return
 
+        injection_point = self.address.resolve()
+        original_code = pm.read_bytes(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,
+                original_code=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)
+        jumper_length = LONG_X64_JUMP_SIZE if self.is_long_x64_jump_needed else REL32_JUMP_SIZE
+        if jumper_length > self.original_code_length:
+            raise ValueError(f"Jumper length > original code length: {jumper_length} > {self.original_code_length}")
 
-        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
-            jump_back = compile_asm(get_long_x64_jump_back_code(jump_back_address))
-        else:
-            jump_to_new_mem = compile_asm(get_simple_jump_code(self.new_memory_address, self.injection_point))
-            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(code_to_inject)),
+        jump_back_address = injection_point + self.original_code_length
+        required_size = len(code_to_inject) + (LONG_X64_JUMP_SIZE if pm.is_64_bit else REL32_JUMP_SIZE)
+        memory_size = required_size if self.new_memory_size is None else self.new_memory_size
+        if memory_size < required_size:
+            raise ValueError(f"Injection size > allocated size: {required_size} > {memory_size}")
+
+        near = injection_point if pm.is_64_bit and not self.is_long_x64_jump_needed else None
+        new_memory_address = allocate(memory_size, near=near)
+        try:
+            jump_to_new_mem = compile_asm(
+                get_long_x64_jump_code(new_memory_address)
+                if self.is_long_x64_jump_needed
+                else get_simple_jump_code(new_memory_address, injection_point),
             )
-
-        if jumper_length < self.original_code_length:
             jump_to_new_mem += b"\x90" * (self.original_code_length - len(jump_to_new_mem))
-        elif jumper_length > self.original_code_length:
-            raise ValueError(f"Jumper length > original code length: {jumper_length} > {self.original_code_length}")
-
-        code_to_inject = code_to_inject + jump_back
-
-        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))
+            code_to_inject += compile_asm(
+                get_long_x64_jump_code(jump_back_address)
+                if pm.is_64_bit
+                else get_simple_jump_code(jump_back_address, new_memory_address + len(code_to_inject)),
+            )
 
-        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))
+            logger.debug("Injecting %d byte(s) (INJECTION) at 0x%X", len(code_to_inject), new_memory_address)
+            pm.write_bytes(new_memory_address, code_to_inject, len(code_to_inject))
+        except Exception:
+            pm.free(new_memory_address)
+            raise
+
+        self.original_code = original_code
+        self.injection_point = injection_point
+        self.new_memory_address = new_memory_address
+        logger.debug("Injecting %d byte(s) (JUMPER) at 0x%X", len(jump_to_new_mem), injection_point)
+        try:
+            pm.write_bytes(injection_point, jump_to_new_mem, len(jump_to_new_mem))
+        except Exception:
+            self.eject()
+            raise
 
     @override
     def eject(self):
@@ -166,12 +186,22 @@ class MultipleCodeInjection(AbstractCodeInjection):
 
     @override
     def inject(self):
-        for injection in self._injections:
-            injection.inject()
+        injected = []
+        try:
+            for injection in self._injections:
+                injection.inject()
+                injected.append(injection)
+        except Exception:
+            for injection in reversed(injected):
+                try:
+                    injection.eject()
+                except Exception:
+                    logger.exception("Failed to roll back injection %r", injection)
+            raise
 
     @override
     def eject(self):
-        for injection in self._injections:
+        for injection in reversed(self._injections):
             injection.eject()
 
 
@@ -218,26 +248,18 @@ def compile_asm(code: Code) -> bytes:
 
 
 def get_simple_jump_code(address: int, ip: int) -> str:
+    if pm.is_64_bit and not REL32_MIN_DISPLACEMENT <= address - (ip + REL32_JUMP_SIZE) <= REL32_MAX_DISPLACEMENT:
+        raise ValueError(f"Jump from 0x{ip:X} to 0x{address:X} is out of rel32 range")
     return f"""
-        jmp {address - ip}
-    """
-
-
-def get_long_x64_jump_to_new_mem_code(address: int) -> str:
-    return f"""
-        push rax
-        mov rax, {address}
-        push rax
-        ret
-        pop rax
+        jmp near {address - ip}
     """
 
 
-def get_long_x64_jump_back_code(address: int) -> str:
+def get_long_x64_jump_code(address: int) -> str:
     return f"""
-        mov rax, {address}
-        push rax
-        ret
+        jmp qword [destination]
+        destination:
+        dq {address}
     """
 
 

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

@@ -19,7 +19,7 @@ class ASMArrayManager(Sequence):
         self,
         array_length: int,
         element_size: int,
-        offsets: None | list[int] = None,
+        offsets: list[int] | None = None,
         add: int = 0,
     ) -> None:
         if offsets and element_size != POINTER_SIZE:
@@ -46,13 +46,17 @@ class ASMArrayManager(Sequence):
         if isinstance(index, int):
             return self.get_address_of_element(index)
 
-        return [self.get_address_of_element(i) for i in range(index.start, index.stop, index.step)]
+        return [self.get_address_of_element(i) for i in range(*index.indices(len(self)))]
 
     def __iter__(self) -> Iterator[Address]:
         for index in range(len(self)):
             yield self[index]
 
     def get_pointer_to_element(self, index: int) -> int:
+        if index < 0:
+            index += len(self)
+        if not 0 <= index < len(self):
+            raise IndexError("Array index out of range")
         return self.array_address + self.element_size * index
 
     def get_address_of_element(self, index: int) -> Address:
@@ -123,8 +127,10 @@ def regenerate(
     percent: Number,
     min_value: Number = 1,
 ):
-    if current_value.value < max_value.value:
-        current_value.value += max(round(max_value.value * percent / 100), min_value)
+    current = current_value.value
+    maximum = max_value.value
+    if current < maximum:
+        current_value.value = min(current + max(round(maximum * percent / 100), min_value), maximum)
 
 
 def suppress_memory_exceptions[**P, T](callback: Callable[P, T]) -> Callable[P, T | None]:

{trainerbase-4.8.2 → trainerbase-4.9.0}/trainerbase/gameobject.py

@@ -39,7 +39,7 @@ class GameObject[PymemType, TrainerBaseType](AbstractReadableObject[TrainerBaseT
         *,
         frozen: TrainerBaseType | None = None,
         is_tracked: bool = True,
-        value_range: None | tuple[TrainerBaseType, TrainerBaseType] = None,
+        value_range: tuple[TrainerBaseType, TrainerBaseType] | None = None,
     ):
         if is_tracked:
             GameObject.tracked_objects.append(self)

{trainerbase-4.8.2 → trainerbase-4.9.0}/trainerbase/gui/helpers.py

@@ -40,7 +40,7 @@ def simple_trainerbase_menu(
             )
             dpg.setup_dearpygui()
 
-            with dpg.window(
+            with dpg.window(  # pyright: ignore[reportGeneralTypeIssues]
                 label=window_title,
                 tag="menu",
                 min_size=[width, height],

{trainerbase-4.8.2 → trainerbase-4.9.0}/trainerbase/gui/misc.py

@@ -89,7 +89,7 @@ class HorizontalUI(AbstractUIComponent):
 
     @override
     def add_to_ui(self) -> None:
-        with dpg.group(horizontal=True):
+        with dpg.group(horizontal=True):  # pyright: ignore[reportGeneralTypeIssues]
             add_components(*self.components)
 
         return super().add_to_ui()

{trainerbase-4.8.2 → trainerbase-4.9.0}/trainerbase/gui/objects.py

@@ -73,7 +73,7 @@ class GameObjectUI(AbstractUIComponent):
         if self.set_hotkey is not None:
             add_hotkey(self.set_hotkey, self.on_value_set)
 
-        with dpg.group(horizontal=True):
+        with dpg.group(horizontal=True):  # pyright: ignore[reportGeneralTypeIssues]
             if self.gameobject.is_tracked:
                 dpg.add_checkbox(tag=self.dpg_tag_frozen, callback=self.on_frozen_state_change)
 

{trainerbase-4.8.2 → trainerbase-4.9.0}/trainerbase/gui/speedhack.py

@@ -55,7 +55,7 @@ class SpeedHackUI(AbstractUIComponent):
         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):
+            with dpg.group(horizontal=True):  # pyright: ignore[reportGeneralTypeIssues]
                 add_components(
                     HotkeyHandlerUI(
                         SimpleHotkeyHandler(partial(self.change_preset, -1), self.previous_preset_hotkey),

{trainerbase-4.8.2 → trainerbase-4.9.0}/trainerbase/gui/tapper.py

@@ -89,7 +89,7 @@ class TapperUI(AbstractUIComponent):
             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),
+            default_value=self.get_closest_preset_index(self.DURATION_PRESETS, self.default_duration),
             callback=self.on_duration_preset_change,
         )
 
@@ -111,7 +111,7 @@ class TapperUI(AbstractUIComponent):
 
     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)
+        closest_preset_index = self.get_closest_preset_index(self.DURATION_PRESETS, new_duration)
         self.tapper.duration = new_duration
         dpg.set_value(self.dpg_tag_tapper_duration_preset_input, closest_preset_index)
 

{trainerbase-4.8.2 → trainerbase-4.9.0}/trainerbase/gui/teleport.py

@@ -127,7 +127,7 @@ class TeleportUI(AbstractUIComponent):
         if self.hotkey_dash is None:
             return
 
-        with dpg.group(horizontal=True):
+        with dpg.group(horizontal=True):  # pyright: ignore[reportGeneralTypeIssues]
             add_hotkey(self.hotkey_dash, self.on_hotkey_dash_press)
             dpg.add_text(f"[{self.hotkey_dash}] Dash")
 
@@ -147,7 +147,7 @@ class TeleportUI(AbstractUIComponent):
             callback=self._on_apply_filter,
         )
 
-        with dpg.group(horizontal=True):
+        with dpg.group(horizontal=True):  # pyright: ignore[reportGeneralTypeIssues]
             dpg.add_button(label="Go To", callback=self.on_goto_label)
             dpg.add_combo(label="Labels", tag=self.DPG_TAG_TELEPORT_LABELS)
 

{trainerbase-4.8.2 → trainerbase-4.9.0}/trainerbase/memory.py

@@ -1,5 +1,6 @@
 from abc import ABC, abstractmethod
 from collections.abc import Callable
+from ctypes import Structure, WinDLL, addressof, byref, c_size_t, c_uint16, c_uint32, c_uint64, c_void_p, get_last_error
 from functools import partial
 from itertools import count
 from time import sleep
@@ -8,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 pymem.ressources.structure import MEMORY_PROTECTION, MEMORY_STATE
 
 from trainerbase.logger import logger
 from trainerbase.process import pm
@@ -17,6 +19,10 @@ 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: 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(".")
+REL32_JUMP_SIZE: Final[int] = 5
+REL32_MIN_DISPLACEMENT: Final[int] = -(2**31)
+REL32_MAX_DISPLACEMENT: Final[int] = 2**31 - 1
+MEM_EXTENDED_PARAMETER_ADDRESS_REQUIREMENTS: Final[int] = 1
 
 
 type ConvertibleToAddress = AbstractAddress | int | bytes | str
@@ -180,11 +186,76 @@ def ensure_address(obj: ConvertibleToAddress) -> AbstractAddress:
             assert_never(obj)
 
 
-def allocate(size: int = POINTER_SIZE, count: int = 1) -> int:
+class _SystemInfo(Structure):
+    _fields_ = [
+        ("architecture", c_uint16),
+        ("reserved", c_uint16),
+        ("page_size", c_uint32),
+        ("minimum_address", c_void_p),
+        ("maximum_address", c_void_p),
+        ("processor_mask", c_size_t),
+        ("processor_count", c_uint32),
+        ("processor_type", c_uint32),
+        ("allocation_granularity", c_uint32),
+        ("processor_level", c_uint16),
+        ("processor_revision", c_uint16),
+    ]
+
+
+class _AddressRequirements(Structure):
+    _fields_ = [("lowest", c_void_p), ("highest", c_void_p), ("alignment", c_size_t)]
+
+
+class _ExtendedParameter(Structure):
+    _fields_ = [("type", c_uint64), ("pointer", c_uint64)]
+
+
+_kernelbase = WinDLL("kernelbase", use_last_error=True)
+_get_system_info = _kernelbase.GetSystemInfo
+_get_system_info.argtypes = [c_void_p]
+_get_system_info.restype = None
+_virtual_alloc2 = _kernelbase.VirtualAlloc2
+_virtual_alloc2.argtypes = [c_void_p, c_void_p, c_size_t, c_uint32, c_uint32, c_void_p, c_uint32]
+_virtual_alloc2.restype = c_void_p
+_system_info = _SystemInfo()
+_get_system_info(byref(_system_info))
+
+
+def allocate(size: int = POINTER_SIZE, count: int = 1, *, near: ConvertibleToAddress | None = None) -> int:
     total = size * count
     logger.debug("Allocating %d bytes.", total)
 
-    return pm.allocate(total)
+    if near is None:
+        return pm.allocate(total)
+
+    if total <= 0:
+        raise ValueError("Allocation size must be positive")
+
+    address = ensure_address(near).resolve()
+    granularity = _system_info.allocation_granularity
+    page_size = _system_info.page_size
+    lowest = max(_system_info.minimum_address, address + REL32_JUMP_SIZE + REL32_MIN_DISPLACEMENT)
+    highest = min(_system_info.maximum_address, address + REL32_JUMP_SIZE + REL32_MAX_DISPLACEMENT)
+    lowest = (lowest + granularity - 1) // granularity * granularity
+    highest = (highest + 1) // granularity * granularity - 1
+    total = (total + page_size - 1) // page_size * page_size
+    if highest - lowest + 1 < total:
+        raise ValueError(f"No allocation range near 0x{address:X}")
+
+    requirements = _AddressRequirements(lowest=lowest, highest=highest, alignment=granularity)
+    parameter = _ExtendedParameter(MEM_EXTENDED_PARAMETER_ADDRESS_REQUIREMENTS, addressof(requirements))
+    allocated = _virtual_alloc2(
+        pm.process_handle,
+        None,  # BaseAddress: let Windows choose an address within requirements.
+        total,
+        MEMORY_STATE.MEM_RESERVE | MEMORY_STATE.MEM_COMMIT,
+        MEMORY_PROTECTION.PAGE_EXECUTE_READWRITE,
+        byref(parameter),
+        1,  # ParameterCount: one address-requirements parameter.
+    )
+    if not allocated:
+        raise ValueError(f"Cannot allocate {total} bytes near 0x{address:X}: WinError {get_last_error()}")
+    return allocated
 
 
 def read_hardcoded_static_address(

{trainerbase-4.8.2 → trainerbase-4.9.0}/trainerbase/process.py

@@ -57,6 +57,8 @@ def get_target_pid(process_names: Iterable[str], *, exact_match: bool, ignore_ca
 
             return pid
 
+        sleep(0.1)
+
     raise RuntimeError("This place must be unreachable! `process_names` is probably empty.")
 
 

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

@@ -1,7 +1,6 @@
 from abc import ABC, abstractmethod
 from collections.abc import Callable
-from contextlib import suppress
-from threading import Thread
+from threading import Thread, current_thread
 from time import sleep
 from typing import Any, override
 
@@ -54,18 +53,23 @@ class ScriptEngine:
         return f"<ScriptEngine delay={self.delay} should_run={self.should_run} scripts={len(self.scripts)}>"
 
     def start(self):
+        if self.thread.is_alive():
+            return
+        self.thread = Thread(target=self.script_loop)
         self.should_run = True
         self.thread.start()
 
     def stop(self):
         self.should_run = False
 
-        with suppress(RuntimeError):
+        if self.thread.ident is not None and self.thread is not current_thread():
             self.thread.join()
 
     def script_loop(self):
         while self.should_run:
             for script in self.scripts:
+                if not self.should_run:
+                    return
                 if not script.enabled:
                     continue
 
@@ -76,6 +80,7 @@ class ScriptEngine:
                 except Exception:
                     logger.exception("Error in script %r. Stopping Script Engine.", script)
                     self.stop()
+                    return
 
             sleep(self.delay)