PyAlgoEngine 0.7.5.post2__tar.gz → 0.7.6.post1__tar.gz

{pyalgoengine-0.7.5.post2 → pyalgoengine-0.7.6.post1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PyAlgoEngine
-Version: 0.7.5.post2
+Version: 0.7.6.post1
 Summary: Basic algo engine
 Home-page: https://github.com/BolunHan/PyAlgoEngine
 Author: Bolun.Han

{pyalgoengine-0.7.5.post2 → pyalgoengine-0.7.6.post1}/PyAlgoEngine.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PyAlgoEngine
-Version: 0.7.5.post2
+Version: 0.7.6.post1
 Summary: Basic algo engine
 Home-page: https://github.com/BolunHan/PyAlgoEngine
 Author: Bolun.Han

{pyalgoengine-0.7.5.post2 → pyalgoengine-0.7.6.post1}/PyAlgoEngine.egg-info/SOURCES.txt

@@ -15,6 +15,11 @@ algo_engine/apps/backtest/tester.py
 algo_engine/apps/backtest/web_app.py
 algo_engine/apps/demo/__init__.py
 algo_engine/apps/demo/test.py
+algo_engine/apps/sim_input/__init__.py
+algo_engine/apps/sim_input/client.py
+algo_engine/apps/sim_input/sim_keyboard.py
+algo_engine/apps/sim_input/sim_mouse.py
+algo_engine/apps/sim_input/window.py
 algo_engine/backtest/__init__.py
 algo_engine/backtest/__main__.py
 algo_engine/backtest/metrics.py

{pyalgoengine-0.7.5.post2 → pyalgoengine-0.7.6.post1}/algo_engine/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.7.5.post2"
+__version__ = "0.7.6.post1"
 
 import logging
 import os

pyalgoengine-0.7.6.post1/algo_engine/apps/sim_input/__init__.py

@@ -0,0 +1,23 @@
+import platform
+
+from .. import LOGGER
+
+
+def check_windows_version(min_version=(6, 1)):
+    """
+    Ensure the script is running on a compatible Windows version.
+    :param min_version: Minimum required version as a tuple (major, minor).
+                        Default is (6, 1) for Windows 7 (major=6, minor=1).
+    """
+    # Get the Windows version
+    if not platform.system() == "Windows":
+        raise EnvironmentError("This script only works on Windows.")
+
+    version_str = platform.version()
+    version_tuple = tuple(map(int, platform.win32_ver()[1].split('.')))
+
+    if version_tuple < min_version:
+        raise EnvironmentError(f"Unsupported Windows version: {version_str}. Minimum required is {min_version[0]}.{min_version[1]}.")
+
+
+LOGGER = LOGGER.getChild('SimInput')

pyalgoengine-0.7.6.post1/algo_engine/apps/sim_input/client.py

@@ -0,0 +1,244 @@
+__package__ = 'algo_engine.apps.sim_input'
+
+import abc
+import threading
+import time
+import tkinter
+from collections.abc import Callable, Iterable
+from tkinter import ttk
+from typing import TypedDict, NotRequired, Any
+
+from . import LOGGER
+
+LOGGER.getChild('Client')
+
+
+class Action(object):
+    class Step(TypedDict):
+        name: str
+        procedure: Callable
+        args: NotRequired[Iterable]
+        kwargs: NotRequired[dict[str, Any]]
+        comments: NotRequired[str]
+
+    def __init__(self, name: str):
+        self.name = name
+        self.steps: list[Action.Step] = []
+
+    def append(self, name: str, action: Callable[[..., ...], None], args=None, kwargs=None, comments: str = None) -> None:
+        step = Action.Step(name=name, procedure=action)
+
+        if args is not None:
+            step['args'] = args
+
+        if kwargs is not None:
+            step['kwargs'] = kwargs
+
+        if comments is not None:
+            step['comments'] = comments
+
+        self.steps.append(step)
+
+    def __call__(self, ignore_error: bool = False) -> None:
+        n = len(self.steps)
+        for i, step in enumerate(self.steps, start=1):
+            procedure = step['procedure']
+            args = step.get('args', [])
+            kwargs = step.get('kwargs', {})
+            comments = step.get('comments', '')
+            try:
+                procedure(*args, **kwargs)
+            except Exception as e:
+                LOGGER.error(f'<Action {self.name}> <step {comments}>({i} / {n}) Failed!')
+
+                if not ignore_error:
+                    raise e
+
+            LOGGER.debug(f'<Action {self.name}> <step {comments}>({i} / {n}) Completed!')
+
+        LOGGER.info(f'<Action {self.name}> completed!')
+
+    def __len__(self):
+        return len(self.steps)
+
+
+class AutoWorkClient(object, metaclass=abc.ABCMeta):
+    def __init__(self, root=None):
+        self.root = root if root is not None else tkinter.Tk()
+        self.root.title("Structured GUI Client")
+        self.root.geometry("600x500")
+
+        # State variables
+        self.worker_thread = None
+        self.running = False
+
+        # Create button
+        self.button = ttk.Button(root, text="Takeover Input", command=self.toggle_auto_work)
+        self.button.pack(pady=10)
+
+        # Create table
+        self.table = ttk.Treeview(
+            root,
+            columns=("Action", "Status", "Comments"),
+            show="tree headings",
+            height=20
+        )
+        self.table.heading("Action", text="Action")
+        self.table.heading("Status", text="Status")
+        self.table.heading("Comments", text="Comments")
+        self.table.pack(padx=10, pady=10, fill="both", expand=True)
+
+        self.actions: dict[int, list[Action]] = {}
+
+        # self.style = ttk.Style()
+        # self.style.theme_use("vista")  # Choose a modern theme like 'clam', 'vista', or 'alt'
+
+    @abc.abstractmethod
+    def listen_signal(self) -> int:
+        ...
+
+    def register_action(self, action: Action, signal: int):
+        if signal in self.actions:
+            self.actions[signal].append(action)
+        else:
+            self.actions[signal] = [action]
+
+    def toggle_auto_work(self):
+        """Toggle the daemon thread to start or stop auto work."""
+        if not self.running:
+            self.running = True
+            self.button.config(text="Release Control")
+            self.worker_thread = threading.Thread(target=self.auto_work, daemon=True)
+            self.worker_thread.start()
+        else:
+            self.running = False
+            self.button.config(text="Takeover Input")
+
+    def auto_work(self):
+        """Generate data for the table in a loop."""
+        while self.running:
+            signal = self.listen_signal()
+            actions = self.actions.get(signal, [])
+
+            # Update table for the current signal
+            self.update_table(actions)
+
+            for action_idx, action in enumerate(actions):
+                # Update action status to "Executing"
+                self.update_status(parent_id=action_idx, status="Executing")
+
+                for step_idx, step in enumerate(action.steps):
+                    # Update step status to "Executing"
+                    self.update_status(parent_id=action_idx, child_id=step_idx, status="Executing")
+
+                    # Execute the step
+                    step["procedure"](*step.get("args", []), **step.get("kwargs", {}))
+
+                    # Mark step as "Done"
+                    self.update_status(parent_id=action_idx, child_id=step_idx, status="Done")
+
+                # Mark action as "Done" after all steps
+                self.update_status(parent_id=action_idx, status="Done")
+
+    def update_table(self, actions: list[Action]):
+        """Render the table based on the provided actions."""
+        self.table.delete(*self.table.get_children())  # Clear existing rows
+
+        for action_idx, action in enumerate(actions):
+            prefix = chr(0x250C)
+            # Insert the parent row
+            parent_id = self.table.insert(
+                "", "end", iid=action_idx, values=(f"{prefix} {action.name}", "Pending", "")
+            )
+
+            # Insert child rows for steps
+            for step_idx, step in enumerate(action.steps):
+                prefix = f'{chr(0x251C) if step_idx < len(action.steps) - 1 else chr(0x2514)}{chr(0x2500)}'
+                self.table.insert(
+                    parent_id,
+                    "end",
+                    iid=f"{action_idx}-{step_idx}",
+                    text=f"Step {step_idx + 1}",
+                    values=(f"{prefix} Step {step_idx + 1}", "Pending", step.get("comments", "")),
+                )
+
+            # Expand parent row by default
+            self.table.item(parent_id, open=True)
+
+        # Auto-adjust column widths
+        self.adjust_column_widths()
+
+    def update_status(self, parent_id: int, child_id: int = None, status: str = "Pending"):
+        """Update the status of the specified row."""
+        row_id = f"{parent_id}" if child_id is None else f"{parent_id}-{child_id}"
+        values = self.table.item(row_id, "values")
+
+        # Select the row if the status is "Executing"
+        match status:
+            case "Executing":
+                self.table.selection_set(row_id)
+                self.table.see(row_id)  # Ensure the row is visible
+
+        self.table.item(row_id, values=(values[0], status, values[2]))
+
+    def adjust_column_widths(self):
+        """Automatically adjust column widths based on content."""
+
+        self.table.column("#0", width=30, minwidth=30, stretch=False)
+
+        for col in self.table["columns"]:
+            max_width = max(
+                [len(str(self.table.set(item, col))) for item in self.table.get_children()] + [len(col)]
+            )
+            self.table.column(col, width=max_width * 10, minwidth=30, stretch=True)  # Scale width for readability
+
+
+class ExampleClient(AutoWorkClient):
+    """An example implementation of the AutoWorkClient."""
+    dummy_signal = 0
+    is_init = False
+
+    @staticmethod
+    def dummy_action(name: str, msg: str) -> None:
+        LOGGER.info(f'start working on {name}, {msg}')
+        time.sleep(2)
+        LOGGER.info('working completed!')
+
+    def listen_signal(self) -> int:
+        """Simulate listening for a signal (e.g., return random signal)."""
+        import random
+        if self.is_init:
+            delay = 5 + 5 * random.random()
+            time.sleep(delay)
+        self.dummy_signal += 1
+        self.is_init = True
+        return 1 + self.dummy_signal % 2
+
+
+def main():
+    client = ExampleClient()
+
+    # Example usage: Register actions for signal 1
+    action1 = Action("Example Action 1")
+    action1.append(name='S1A1s1', action=ExampleClient.dummy_action, args=("Signal 1 Action 1", "Step 1"))
+    action1.append(name='S1A1s2', action=ExampleClient.dummy_action, args=("Signal 1 Action 1", "Step 2"))
+
+    action2 = Action("Example Action 2")
+    action2.append(name='S1A2s1', action=ExampleClient.dummy_action, args=("Signal 1 Action 2", "Step 1"))
+    action2.append(name='S1A2s2', action=ExampleClient.dummy_action, args=("Signal 1 Action 2", "Step 2"))
+
+    client.register_action(action1, signal=1)
+    client.register_action(action2, signal=1)
+
+    action3 = Action("Example Action 3")
+    action3.append(name='S2A1s1', action=ExampleClient.dummy_action, args=("Signal 2 Action 1", "Step 1"))
+    action3.append(name='S2A1s2', action=ExampleClient.dummy_action, args=("Signal 2 Action 1", "Step 2"))
+    action3.append(name='S2A1s3', action=ExampleClient.dummy_action, args=("Signal 2 Action 1", "Step 3"))
+
+    client.register_action(action3, signal=2)
+
+    client.root.mainloop()
+
+
+if __name__ == "__main__":
+    main()

pyalgoengine-0.7.6.post1/algo_engine/apps/sim_input/sim_keyboard.py

@@ -0,0 +1,88 @@
+__package__ = 'algo_engine.apps.sim_input'
+
+import ctypes
+import enum
+import time
+
+from . import LOGGER, check_windows_version
+
+check_windows_version((6, 1))
+LOGGER.getChild('Keyboard')
+
+
+# Constants for key event types
+class KeyEvent(enum.IntEnum):
+    F_KEYDOWN = 0x0000
+    F_KEYUP = 0x0002
+
+
+# Windows API functions
+user32 = ctypes.windll.user32
+
+
+# Map character to virtual key code and shift state
+def get_keycode(char: str):
+    """
+    Get the virtual key code (VK_CODE) and shift state for a given character.
+
+    Returns:
+        tuple: (VK_CODE, needs_shift)
+    """
+    vk_combo = user32.VkKeyScanW(ord(char))
+    vk_code = vk_combo & 0xFF  # Lower byte is VK_CODE
+    shift_state = (vk_combo >> 8) & 0xFF  # Higher byte indicates shift state
+    needs_shift = shift_state & 0x01  # Check if Shift key is required
+    return vk_code, needs_shift
+
+
+# Simulate key press
+def press_key(vk_code):
+    """Press a key using its VK_CODE."""
+    ctypes.windll.user32.keybd_event(vk_code, 0, KeyEvent.F_KEYDOWN, 0)
+
+
+# Simulate key release
+def release_key(vk_code):
+    """Release a key using its VK_CODE."""
+    ctypes.windll.user32.keybd_event(vk_code, 0, KeyEvent.F_KEYUP, 0)
+
+
+# Advanced function to simulate a key press for a given duration
+def simulate_keypress(char, ts=0.1):
+    """
+    Simulate pressing a key for a given duration.
+
+    Args:
+        char (str): The character to simulate key press for.
+        ts (float): The duration (in seconds) to hold the key. Default is 0.1s.
+    """
+    vk_code, needs_shift = get_keycode(char)  # Get VK_CODE and shift state
+    if vk_code == 0xFF:
+        raise ValueError(f"Invalid character '{char}'. Cannot map to a virtual key code.")
+
+    # If the character needs Shift, press Shift first
+    if needs_shift:
+        press_key(0x10)  # VK_CODE for Shift
+
+    press_key(vk_code)  # Press the key
+    time.sleep(ts)  # Hold the key for the given duration
+    release_key(vk_code)  # Release the key
+
+    # If Shift was pressed, release it
+    if needs_shift:
+        release_key(0x10)  # VK_CODE for Shift
+
+
+def main():
+    LOGGER.info('Staring sim input sequence in 5 seconds...')
+    time.sleep(5)
+    key_strikes = list('hellow world!')
+    for char in key_strikes:
+        LOGGER.info(f'Pressing {char}...')
+        simulate_keypress(char=char, ts=.5)
+        time.sleep(.5)
+
+
+# Example usage
+if __name__ == "__main__":
+    main()

pyalgoengine-0.7.6.post1/algo_engine/apps/sim_input/sim_mouse.py

@@ -0,0 +1,137 @@
+__package__ = 'algo_engine.apps.sim_input'
+
+import ctypes
+import enum
+import time
+from ctypes import wintypes
+from typing import Literal
+
+from . import LOGGER, check_windows_version
+
+check_windows_version((6, 1))
+LOGGER.getChild('Mouse')
+
+
+# Constants for mouse events
+class MouseEvent(enum.IntEnum):
+    MOUSEEVENTF_MOVE = 0x0001
+    MOUSEEVENTF_LEFTDOWN = 0x0002
+    MOUSEEVENTF_LEFTUP = 0x0004
+    MOUSEEVENTF_RIGHTDOWN = 0x0008
+    MOUSEEVENTF_RIGHTUP = 0x0010
+    MOUSEEVENTF_ABSOLUTE = 0x8000
+
+
+# Structure to store point coordinates
+class POINT(ctypes.Structure):
+    _fields_ = [("x", wintypes.LONG), ("y", wintypes.LONG)]
+
+
+# Windows API functions
+user32 = ctypes.windll.user32
+
+
+# Get the current mouse location
+def get_location() -> POINT:
+    """
+    Get the current mouse cursor position.
+
+    Returns:
+        tuple: (x, y) coordinates of the mouse cursor.
+    """
+    point = POINT()
+    user32.GetCursorPos(ctypes.byref(point))
+    return point
+
+
+def move_mouse(x: int, y: int):
+    """
+    Move the mouse cursor to a specific screen location.
+
+    Args:
+        x (int): The target x-coordinate.
+        y (int): The target y-coordinate.
+    """
+    user32.SetCursorPos(x, y)
+
+
+# Simulate mouse press
+def press_mouse(button: Literal['l', 'r', 'left', 'right'] = 'l'):
+    """
+    Simulate a mouse button press.
+
+    Args:
+        button (str): The button to press ("left" or "right").
+    """
+    match button:
+        case 'l' | "left":
+            user32.mouse_event(MouseEvent.MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0)
+        case 'r' | "right":
+            user32.mouse_event(MouseEvent.MOUSEEVENTF_RIGHTDOWN, 0, 0, 0, 0)
+        case _:
+            raise ValueError("Invalid button. Use 'left' or 'right'.")
+
+
+# Simulate mouse release
+def release_mouse(button: Literal['l', 'r', 'left', 'right'] = 'l'):
+    """
+    Simulate a mouse button release.
+
+    Args:
+        button (str): The button to release ("left" or "right").
+    """
+
+    match button:
+        case 'l' | "left":
+            user32.mouse_event(MouseEvent.MOUSEEVENTF_LEFTUP, 0, 0, 0, 0)
+        case 'r' | "right":
+            user32.mouse_event(MouseEvent.MOUSEEVENTF_RIGHTUP, 0, 0, 0, 0)
+        case _:
+            raise ValueError("Invalid button. Use 'left' or 'right'.")
+
+
+# Simulate a mouse click
+def click_mouse(button: Literal['l', 'r', 'left', 'right'] = 'l'):
+    """
+    Simulate a mouse click (press + release).
+
+    Args:
+        button (str): The button to click ("left" or "right").
+    """
+    press_mouse(button)
+    release_mouse(button)
+
+
+# Simulate a mouse double click
+def double_click_mouse(button: Literal['l', 'r', 'left', 'right'] = 'l', interval: float = 0.1):
+    """
+    Simulate a mouse double click.
+
+    Args:
+        button (str): The button to double-click ("left" or "right").
+        interval (float): Time between clicks (in seconds). Default is 0.1s.
+    """
+    click_mouse(button)
+    time.sleep(interval)
+    click_mouse(button)
+
+
+# Example usage
+if __name__ == "__main__":
+    LOGGER.info('Staring sim mouse input sequence in 5 seconds...')
+    time.sleep(5)
+
+    p = get_location()
+    LOGGER.info(f"Current mouse location: {p.x, p.y}")
+
+    LOGGER.info('Move to diagonal location...')
+    move_mouse(x=p.y, y=p.x)
+
+    LOGGER.info(f"Simulating left click...")
+    click_mouse(button="l")
+
+    LOGGER.info(f"Simulating right click...")
+    click_mouse(button="r")
+
+    LOGGER.info("Simulating double click...")
+    double_click_mouse()

pyalgoengine-0.7.6.post1/algo_engine/apps/sim_input/window.py

@@ -0,0 +1,162 @@
+__package__ = 'algo_engine.apps.sim_input'
+
+import ctypes
+import dataclasses
+import enum
+import os
+from typing import Literal
+
+from . import LOGGER
+
+LOGGER.getChild('Window')
+
+# Define necessary Windows API functions and constants
+user32 = ctypes.windll.user32
+kernel32 = ctypes.windll.kernel32
+psapi = ctypes.windll.psapi
+
+# Define constants for access rights
+PROCESS_QUERY_INFORMATION = 0x0400
+PROCESS_VM_READ = 0x0010
+
+# Define necessary Windows API function prototypes
+WNDENUMPROC = ctypes.WINFUNCTYPE(ctypes.c_bool, ctypes.c_int, ctypes.POINTER(ctypes.c_int))
+
+
+@dataclasses.dataclass(frozen=True)
+class WindowInfo:
+    window_name: str
+    pid: int
+    hwnd: int
+    executable_name: str
+    executable_path: str
+
+
+class WindowState(enum.IntEnum):
+    SW_SHOWNORMAL = 1  # Show the window normally
+    SW_SHOWMINIMIZED = 2  # Minimize the window
+    SW_SHOWMAXIMIZED = 3  # Maximize the window
+    SW_SHOWNOACTIVATE = 4  # Show the window without activating it
+    SW_SHOW = 5  # Show the window and bring it to the foreground
+
+
+# Function to get PID from window handle
+def get_pid(hwnd):
+    pid = ctypes.c_ulong()
+    user32.GetWindowThreadProcessId(hwnd, ctypes.byref(pid))
+    return pid.value
+
+
+# Function to retrieve the executable path and name of a process
+def get_executable_info(pid):
+    # Open the process to get information
+    h_process = kernel32.OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, False, pid)
+    if not h_process:
+        return None, None
+
+    # Buffer to hold the path
+    path_buffer = ctypes.create_unicode_buffer(1024)
+
+    # Get the full executable path using GetModuleFileNameEx
+    if psapi.GetModuleFileNameExW(h_process, 0, path_buffer, ctypes.byref(ctypes.c_ulong(1024))):
+        executable_path = path_buffer.value
+        executable_name = os.path.basename(executable_path)
+    else:
+        executable_path = None
+        executable_name = None
+
+    # Close the process handle
+    kernel32.CloseHandle(h_process)
+
+    return executable_name, executable_path
+
+
+# Function to check if a window is visible (including minimized)
+def is_window_visible(hwnd):
+    return user32.IsWindowVisible(hwnd)
+
+
+# Function to enumerate windows
+def get_windows() -> list[WindowInfo]:
+    windows = []
+
+    def enum_windows_proc(hwnd, _):
+        # Only include visible windows
+        if not is_window_visible(hwnd):
+            return True
+
+        # Get window title (for name)
+        length = user32.GetWindowTextLengthW(hwnd)
+        if length > 0:
+            buffer = ctypes.create_unicode_buffer(length + 1)
+            user32.GetWindowTextW(hwnd, buffer, length + 1)
+            window_name = buffer.value
+        else:
+            window_name = "Untitled"
+
+        # Get the PID for the window
+        pid = get_pid(hwnd)
+
+        # Get executable name and path
+        executable_name, executable_path = get_executable_info(pid)
+
+        # Append to the windows list as a tuple (window_name, pid, hwnd, executable_name, executable_path)
+        windows.append(WindowInfo(window_name=window_name, pid=pid, hwnd=hwnd, executable_name=executable_name, executable_path=executable_path))
+        return True
+
+    # Enumerate all windows (including child windows)
+    user32.EnumWindows(WNDENUMPROC(enum_windows_proc), 0)
+
+    return windows
+
+
+def find_window(name: str = None, executable: str = None) -> list[WindowInfo]:
+    windows = get_windows()
+    matched = []
+
+    for window in windows:
+        if name is not None and name.lower() not in window.name.lower():
+            continue
+
+        if executable is not None and executable.lower() not in window.executable_name.lower():
+            continue
+
+        matched.append(window)
+
+    return matched
+
+
+# Function to set the window action (top, maximize, minimize)
+def set_window(window_info: WindowInfo, action: Literal['top', 'maximize', 'minimize', 'max', 'min']):
+    hwnd = window_info.hwnd
+
+    match action:
+        case "top":
+            # Bring the window to the front (top)
+            user32.ShowWindow(hwnd, WindowState.SW_SHOWNORMAL)
+            user32.SetForegroundWindow(hwnd)
+        case "maximize" | 'max':
+            # Maximize the window
+            user32.ShowWindow(hwnd, WindowState.SW_SHOWMAXIMIZED)
+        case "minimize" | 'min':
+            # Minimize the window
+            user32.ShowWindow(hwnd, WindowState.SW_SHOWMINIMIZED)
+        case _:
+            raise ValueError(f"Unknown action: {action}")
+
+
+def main():
+    # Example usage
+    windows = get_windows()
+    for _ in windows:
+        LOGGER.debug(_)
+
+    firefox = find_window(executable="firefox")[0]
+    LOGGER.info(firefox)
+
+    set_window(window_info=firefox, action='top')
+    set_window(window_info=firefox, action='maximize')
+
+
+if __name__ == "__main__":
+    main()