PyClickerRPA 0.1.0__tar.gz

pyclickerrpa-0.1.0/PKG-INFO

@@ -0,0 +1,90 @@
+Metadata-Version: 2.4
+Name: PyClickerRPA
+Version: 0.1.0
+Summary: Visual auto-click / RPA tool: window capture, OpenCV image matching, OCR, a node flow editor and step-list editor, recorder, scheduler and triggers (Windows).
+Author: Equinox
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/Equinox/PyClickerRPA
+Keywords: autoclicker,rpa,automation,opencv,template-matching,ocr,gui,windows
+Classifier: Environment :: Win32 (MS Windows)
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Desktop Environment
+Classifier: Intended Audience :: End Users/Desktop
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.23
+Requires-Dist: opencv-python>=4.8
+Requires-Dist: pywin32>=305; sys_platform == "win32"
+Requires-Dist: pynput>=1.7
+Requires-Dist: PySide6>=6.5
+Provides-Extra: ocr
+Requires-Dist: paddleocr>=2.7; extra == "ocr"
+Requires-Dist: paddlepaddle>=2.5; extra == "ocr"
+
+# PyClickerRPA
+
+A visual auto-click / RPA tool for Windows — window/screen capture, OpenCV
+template matching, optional OCR, a node-based flow editor **and** a linear
+step-list editor, an action recorder, a scheduler, and image/color triggers.
+
+It is a Python/PySide6 port of a Qt/C++ AutoClicker, and reads/writes the same
+`.json` task format.
+
+## Install
+
+```
+pip install PyClickerRPA
+```
+
+Optional OCR (find-text / read-text steps) needs PaddleOCR:
+
+```
+pip install "PyClickerRPA[ocr]"
+```
+
+## Run
+
+GUI:
+
+```
+autoclicker
+```
+
+Headless (run a saved task against a window by title, or the whole screen):
+
+```
+autoclicker-run task.json --window "Notepad"
+```
+
+## Features
+
+- **Targeting**: pick any visible window (or the whole screen); background-window
+  capture via `PrintWindow`.
+- **Matching**: OpenCV `TM_CCOEFF_NORMED` template matching (multi-scale, ROI,
+  multi-target), pixel-color checks, and optional PaddleOCR text find / read.
+- **Editors**: drag-and-drop **node flow graph** (back-edges become loops) and a
+  **step list** with a full per-step parameter dialog; both interoperate.
+- **~30+ step types**: click image/text/position, click-all, relative & offset
+  clicks, wait / random wait, drag / long-press / pinch / scroll, key / type /
+  hotkey, loop / goto / while / do-until, if image/text/color/count/var, set-var
+  (`++`/`--`, `last_x/last_y/last_text`), read-text→variable, call sub-task,
+  groups.
+- **Authoring aids**: action recorder (global hooks), snippet library, task
+  packages (`.zip` with templates), edit-on-preview coordinate picking,
+  template crop / color pick, single-step test run.
+- **Runtime**: live variables panel, hit markers on the preview, screenshot on
+  failure, retry / repeat / until policies.
+- **Automation**: global hotkeys (F6 run/stop, ESC stop), scheduler, and a
+  monitor/trigger mode (run a task when an image/color appears) with tray icon.
+- **Correctness**: multi-monitor + high-DPI aware coordinates.
+
+## Notes
+
+- **Windows only** (uses Win32 for capture and `SendInput`).
+- OCR's first run downloads PaddleOCR models (~100 MB).
+- Some target windows may require running as administrator.
+
+## License
+
+MIT

pyclickerrpa-0.1.0/PyClickerRPA.egg-info/PKG-INFO

@@ -0,0 +1,90 @@
+Metadata-Version: 2.4
+Name: PyClickerRPA
+Version: 0.1.0
+Summary: Visual auto-click / RPA tool: window capture, OpenCV image matching, OCR, a node flow editor and step-list editor, recorder, scheduler and triggers (Windows).
+Author: Equinox
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/Equinox/PyClickerRPA
+Keywords: autoclicker,rpa,automation,opencv,template-matching,ocr,gui,windows
+Classifier: Environment :: Win32 (MS Windows)
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Desktop Environment
+Classifier: Intended Audience :: End Users/Desktop
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.23
+Requires-Dist: opencv-python>=4.8
+Requires-Dist: pywin32>=305; sys_platform == "win32"
+Requires-Dist: pynput>=1.7
+Requires-Dist: PySide6>=6.5
+Provides-Extra: ocr
+Requires-Dist: paddleocr>=2.7; extra == "ocr"
+Requires-Dist: paddlepaddle>=2.5; extra == "ocr"
+
+# PyClickerRPA
+
+A visual auto-click / RPA tool for Windows — window/screen capture, OpenCV
+template matching, optional OCR, a node-based flow editor **and** a linear
+step-list editor, an action recorder, a scheduler, and image/color triggers.
+
+It is a Python/PySide6 port of a Qt/C++ AutoClicker, and reads/writes the same
+`.json` task format.
+
+## Install
+
+```
+pip install PyClickerRPA
+```
+
+Optional OCR (find-text / read-text steps) needs PaddleOCR:
+
+```
+pip install "PyClickerRPA[ocr]"
+```
+
+## Run
+
+GUI:
+
+```
+autoclicker
+```
+
+Headless (run a saved task against a window by title, or the whole screen):
+
+```
+autoclicker-run task.json --window "Notepad"
+```
+
+## Features
+
+- **Targeting**: pick any visible window (or the whole screen); background-window
+  capture via `PrintWindow`.
+- **Matching**: OpenCV `TM_CCOEFF_NORMED` template matching (multi-scale, ROI,
+  multi-target), pixel-color checks, and optional PaddleOCR text find / read.
+- **Editors**: drag-and-drop **node flow graph** (back-edges become loops) and a
+  **step list** with a full per-step parameter dialog; both interoperate.
+- **~30+ step types**: click image/text/position, click-all, relative & offset
+  clicks, wait / random wait, drag / long-press / pinch / scroll, key / type /
+  hotkey, loop / goto / while / do-until, if image/text/color/count/var, set-var
+  (`++`/`--`, `last_x/last_y/last_text`), read-text→variable, call sub-task,
+  groups.
+- **Authoring aids**: action recorder (global hooks), snippet library, task
+  packages (`.zip` with templates), edit-on-preview coordinate picking,
+  template crop / color pick, single-step test run.
+- **Runtime**: live variables panel, hit markers on the preview, screenshot on
+  failure, retry / repeat / until policies.
+- **Automation**: global hotkeys (F6 run/stop, ESC stop), scheduler, and a
+  monitor/trigger mode (run a task when an image/color appears) with tray icon.
+- **Correctness**: multi-monitor + high-DPI aware coordinates.
+
+## Notes
+
+- **Windows only** (uses Win32 for capture and `SendInput`).
+- OCR's first run downloads PaddleOCR models (~100 MB).
+- Some target windows may require running as administrator.
+
+## License
+
+MIT

pyclickerrpa-0.1.0/PyClickerRPA.egg-info/SOURCES.txt

@@ -0,0 +1,35 @@
+README.md
+pyproject.toml
+PyClickerRPA.egg-info/PKG-INFO
+PyClickerRPA.egg-info/SOURCES.txt
+PyClickerRPA.egg-info/dependency_links.txt
+PyClickerRPA.egg-info/entry_points.txt
+PyClickerRPA.egg-info/requires.txt
+PyClickerRPA.egg-info/top_level.txt
+autoclicker/__init__.py
+autoclicker/app.py
+autoclicker/capture.py
+autoclicker/clicker.py
+autoclicker/dpi.py
+autoclicker/matcher.py
+autoclicker/models.py
+autoclicker/ocr.py
+autoclicker/run.py
+autoclicker/runner.py
+autoclicker/windows.py
+autoclicker/gui/__init__.py
+autoclicker/gui/flow_connection.py
+autoclicker/gui/flow_editor.py
+autoclicker/gui/flow_node.py
+autoclicker/gui/hotkeys.py
+autoclicker/gui/main_window.py
+autoclicker/gui/monitor.py
+autoclicker/gui/preview_label.py
+autoclicker/gui/qt_runner.py
+autoclicker/gui/recorder.py
+autoclicker/gui/scheduler_widget.py
+autoclicker/gui/snippet_library.py
+autoclicker/gui/task_widget.py
+tests/test_matcher.py
+tests/test_models.py
+tests/test_runner.py

pyclickerrpa-0.1.0/PyClickerRPA.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pyclickerrpa-0.1.0/PyClickerRPA.egg-info/entry_points.txt

@@ -0,0 +1,5 @@
+[console_scripts]
+autoclicker-run = autoclicker.run:main
+
+[gui_scripts]
+autoclicker = autoclicker.app:main

pyclickerrpa-0.1.0/PyClickerRPA.egg-info/requires.txt

@@ -0,0 +1,11 @@
+numpy>=1.23
+opencv-python>=4.8
+pynput>=1.7
+PySide6>=6.5
+
+[:sys_platform == "win32"]
+pywin32>=305
+
+[ocr]
+paddleocr>=2.7
+paddlepaddle>=2.5

pyclickerrpa-0.1.0/PyClickerRPA.egg-info/top_level.txt

@@ -0,0 +1 @@
+autoclicker

pyclickerrpa-0.1.0/README.md

@@ -0,0 +1,66 @@
+# PyClickerRPA
+
+A visual auto-click / RPA tool for Windows — window/screen capture, OpenCV
+template matching, optional OCR, a node-based flow editor **and** a linear
+step-list editor, an action recorder, a scheduler, and image/color triggers.
+
+It is a Python/PySide6 port of a Qt/C++ AutoClicker, and reads/writes the same
+`.json` task format.
+
+## Install
+
+```
+pip install PyClickerRPA
+```
+
+Optional OCR (find-text / read-text steps) needs PaddleOCR:
+
+```
+pip install "PyClickerRPA[ocr]"
+```
+
+## Run
+
+GUI:
+
+```
+autoclicker
+```
+
+Headless (run a saved task against a window by title, or the whole screen):
+
+```
+autoclicker-run task.json --window "Notepad"
+```
+
+## Features
+
+- **Targeting**: pick any visible window (or the whole screen); background-window
+  capture via `PrintWindow`.
+- **Matching**: OpenCV `TM_CCOEFF_NORMED` template matching (multi-scale, ROI,
+  multi-target), pixel-color checks, and optional PaddleOCR text find / read.
+- **Editors**: drag-and-drop **node flow graph** (back-edges become loops) and a
+  **step list** with a full per-step parameter dialog; both interoperate.
+- **~30+ step types**: click image/text/position, click-all, relative & offset
+  clicks, wait / random wait, drag / long-press / pinch / scroll, key / type /
+  hotkey, loop / goto / while / do-until, if image/text/color/count/var, set-var
+  (`++`/`--`, `last_x/last_y/last_text`), read-text→variable, call sub-task,
+  groups.
+- **Authoring aids**: action recorder (global hooks), snippet library, task
+  packages (`.zip` with templates), edit-on-preview coordinate picking,
+  template crop / color pick, single-step test run.
+- **Runtime**: live variables panel, hit markers on the preview, screenshot on
+  failure, retry / repeat / until policies.
+- **Automation**: global hotkeys (F6 run/stop, ESC stop), scheduler, and a
+  monitor/trigger mode (run a task when an image/color appears) with tray icon.
+- **Correctness**: multi-monitor + high-DPI aware coordinates.
+
+## Notes
+
+- **Windows only** (uses Win32 for capture and `SendInput`).
+- OCR's first run downloads PaddleOCR models (~100 MB).
+- Some target windows may require running as administrator.
+
+## License
+
+MIT

pyclickerrpa-0.1.0/autoclicker/__init__.py

@@ -0,0 +1,14 @@
+"""AutoClicker — Python port of the Qt/C++ visual auto-click / RPA tool.
+
+Phase 1 exposes the headless engine (models + capture + clicker + matcher +
+windows + runner). The GUI (PySide6) lands in later phases.
+"""
+from autoclicker.models import (
+    Step, Task, StepType, UntilCondition, RetryPolicy,
+    RepeatConfig, UntilConfig, RetryConfig,
+)
+
+__all__ = [
+    "Step", "Task", "StepType", "UntilCondition", "RetryPolicy",
+    "RepeatConfig", "UntilConfig", "RetryConfig",
+]

pyclickerrpa-0.1.0/autoclicker/app.py

@@ -0,0 +1,21 @@
+"""GUI entry point: python -m autoclicker.app"""
+from __future__ import annotations
+
+import sys
+
+
+def main() -> int:
+    from autoclicker.dpi import set_dpi_aware
+    set_dpi_aware()
+
+    from PySide6.QtWidgets import QApplication
+    from autoclicker.gui.main_window import MainWindow
+
+    app = QApplication(sys.argv)
+    win = MainWindow()
+    win.show()
+    return app.exec()
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

pyclickerrpa-0.1.0/autoclicker/capture.py

@@ -0,0 +1,94 @@
+"""Screen / window capture -> BGR numpy arrays (OpenCV order).
+
+Port of capture.cpp: ``capture_window`` grabs a specific HWND via PrintWindow
+(works for background windows that aren't fully occluded); ``capture_screen``
+grabs the whole virtual desktop via GDI BitBlt. No mss dependency — win32 GDI
+covers both.
+"""
+from __future__ import annotations
+
+import numpy as np
+
+try:
+    import win32gui
+    import win32ui
+    import win32con
+    _HAS_WIN32 = True
+except ImportError:  # allow import on non-Windows for tests that mock capture
+    _HAS_WIN32 = False
+
+
+# PrintWindow flag that renders the full content (incl. DWM-composited/partly hidden)
+PW_RENDERFULLCONTENT = 0x00000002
+
+
+def _bitmap_to_bgr(bmp, width: int, height: int) -> np.ndarray:
+    """Convert a win32ui bitmap's BGRA bits into an (H, W, 3) BGR ndarray."""
+    bits = bmp.GetBitmapBits(True)
+    arr = np.frombuffer(bits, dtype=np.uint8).reshape((height, width, 4))
+    return arr[:, :, :3].copy()  # drop alpha; BGRA -> BGR
+
+
+def capture_window(hwnd) -> np.ndarray:
+    """Capture the client area of *hwnd* as a BGR ndarray."""
+    if not _HAS_WIN32:
+        raise RuntimeError("win32 modules unavailable")
+
+    left, top, right, bottom = win32gui.GetClientRect(hwnd)
+    width, height = right - left, bottom - top
+    if width <= 0 or height <= 0:
+        return np.empty((0, 0, 3), dtype=np.uint8)
+
+    hwnd_dc = win32gui.GetWindowDC(hwnd)
+    mfc_dc = win32ui.CreateDCFromHandle(hwnd_dc)
+    save_dc = mfc_dc.CreateCompatibleDC()
+    bmp = win32ui.CreateBitmap()
+    bmp.CreateCompatibleBitmap(mfc_dc, width, height)
+    save_dc.SelectObject(bmp)
+
+    try:
+        import ctypes
+        ok = ctypes.windll.user32.PrintWindow(hwnd, save_dc.GetSafeHdc(), PW_RENDERFULLCONTENT)
+        if not ok:
+            # Fallback: BitBlt the window DC
+            save_dc.BitBlt((0, 0), (width, height), mfc_dc, (0, 0), win32con.SRCCOPY)
+        img = _bitmap_to_bgr(bmp, width, height)
+    finally:
+        win32gui.DeleteObject(bmp.GetHandle())
+        save_dc.DeleteDC()
+        mfc_dc.DeleteDC()
+        win32gui.ReleaseDC(hwnd, hwnd_dc)
+    return img
+
+
+def capture_screen() -> np.ndarray:
+    """Capture the entire virtual desktop as a BGR ndarray."""
+    if not _HAS_WIN32:
+        raise RuntimeError("win32 modules unavailable")
+
+    x = win32api_GetSystemMetrics(76)   # SM_XVIRTUALSCREEN
+    y = win32api_GetSystemMetrics(77)   # SM_YVIRTUALSCREEN
+    width = win32api_GetSystemMetrics(78)   # SM_CXVIRTUALSCREEN
+    height = win32api_GetSystemMetrics(79)  # SM_CYVIRTUALSCREEN
+
+    hdesktop = win32gui.GetDesktopWindow()
+    desktop_dc = win32gui.GetWindowDC(hdesktop)
+    mfc_dc = win32ui.CreateDCFromHandle(desktop_dc)
+    save_dc = mfc_dc.CreateCompatibleDC()
+    bmp = win32ui.CreateBitmap()
+    bmp.CreateCompatibleBitmap(mfc_dc, width, height)
+    save_dc.SelectObject(bmp)
+    try:
+        save_dc.BitBlt((0, 0), (width, height), mfc_dc, (x, y), win32con.SRCCOPY)
+        img = _bitmap_to_bgr(bmp, width, height)
+    finally:
+        win32gui.DeleteObject(bmp.GetHandle())
+        save_dc.DeleteDC()
+        mfc_dc.DeleteDC()
+        win32gui.ReleaseDC(hdesktop, desktop_dc)
+    return img
+
+
+def win32api_GetSystemMetrics(index: int) -> int:
+    import win32api
+    return win32api.GetSystemMetrics(index)

pyclickerrpa-0.1.0/autoclicker/clicker.py

@@ -0,0 +1,212 @@
+"""Mouse / keyboard synthesis via Win32 SendInput — port of clicker.cpp.
+
+Window-local coordinates are converted to screen coords (ClientToScreen) then
+normalised to the 0..65535 absolute range over the primary screen, matching the
+C++ implementation exactly (incl. its single-monitor assumption).
+"""
+from __future__ import annotations
+
+import ctypes
+import time
+
+try:
+    import win32gui
+    import win32con
+    _HAS_WIN32 = True
+except ImportError:
+    _HAS_WIN32 = False
+
+WHEEL_DELTA = 120
+
+# ---- ctypes SendInput plumbing ------------------------------------------------
+if _HAS_WIN32:
+    from ctypes import wintypes
+
+    ULONG_PTR = ctypes.wintypes.WPARAM
+
+    class _MOUSEINPUT(ctypes.Structure):
+        _fields_ = [("dx", wintypes.LONG), ("dy", wintypes.LONG),
+                    ("mouseData", wintypes.DWORD), ("dwFlags", wintypes.DWORD),
+                    ("time", wintypes.DWORD), ("dwExtraInfo", ULONG_PTR)]
+
+    class _KEYBDINPUT(ctypes.Structure):
+        _fields_ = [("wVk", wintypes.WORD), ("wScan", wintypes.WORD),
+                    ("dwFlags", wintypes.DWORD), ("time", wintypes.DWORD),
+                    ("dwExtraInfo", ULONG_PTR)]
+
+    class _INPUTunion(ctypes.Union):
+        _fields_ = [("mi", _MOUSEINPUT), ("ki", _KEYBDINPUT)]
+
+    class _INPUT(ctypes.Structure):
+        _fields_ = [("type", wintypes.DWORD), ("u", _INPUTunion)]
+
+    INPUT_MOUSE, INPUT_KEYBOARD = 0, 1
+    MOUSEEVENTF_MOVE, MOUSEEVENTF_ABSOLUTE = 0x0001, 0x8000
+    MOUSEEVENTF_LEFTDOWN, MOUSEEVENTF_LEFTUP = 0x0002, 0x0004
+    MOUSEEVENTF_RIGHTDOWN, MOUSEEVENTF_RIGHTUP = 0x0008, 0x0010
+    MOUSEEVENTF_WHEEL = 0x0800
+    MOUSEEVENTF_VIRTUALDESK = 0x4000
+    KEYEVENTF_KEYUP, KEYEVENTF_UNICODE = 0x0002, 0x0004
+    SM_CXSCREEN, SM_CYSCREEN = 0, 1
+    SM_XVIRTUALSCREEN, SM_YVIRTUALSCREEN = 76, 77
+    SM_CXVIRTUALSCREEN, SM_CYVIRTUALSCREEN = 78, 79
+    # Absolute move across the whole virtual desktop (multi-monitor correct)
+    _ABS_MOVE = MOUSEEVENTF_MOVE | MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_VIRTUALDESK
+
+    def _send(*inputs: _INPUT) -> None:
+        n = len(inputs)
+        arr = (_INPUT * n)(*inputs)
+        ctypes.windll.user32.SendInput(n, arr, ctypes.sizeof(_INPUT))
+
+    def _mouse(dx=0, dy=0, data=0, flags=0) -> _INPUT:
+        return _INPUT(type=INPUT_MOUSE, u=_INPUTunion(
+            mi=_MOUSEINPUT(dx, dy, data & 0xFFFFFFFF, flags, 0, 0)))
+
+    def _kbd(vk=0, scan=0, flags=0) -> _INPUT:
+        return _INPUT(type=INPUT_KEYBOARD, u=_INPUTunion(
+            ki=_KEYBDINPUT(vk, scan, flags, 0, 0)))
+
+    def _metric(i: int) -> int:
+        return ctypes.windll.user32.GetSystemMetrics(i)
+
+
+def _to_screen(hwnd, x: int, y: int) -> tuple[int, int]:
+    if hwnd:
+        return win32gui.ClientToScreen(hwnd, (x, y))
+    return x, y
+
+
+def _norm(sx: int, sy: int) -> tuple[int, int]:
+    # Normalize to 0..65535 over the whole virtual desktop (all monitors),
+    # to be paired with MOUSEEVENTF_VIRTUALDESK. Fixes the primary-screen-only
+    # assumption that misplaced clicks on multi-monitor / scaled setups.
+    x0, y0 = _metric(SM_XVIRTUALSCREEN), _metric(SM_YVIRTUALSCREEN)
+    cx = _metric(SM_CXVIRTUALSCREEN) or 1
+    cy = _metric(SM_CYVIRTUALSCREEN) or 1
+    nx = int((sx - x0) * 65535.0 / cx)
+    ny = int((sy - y0) * 65535.0 / cy)
+    return nx, ny
+
+
+class Clicker:
+    """Thin, injectable wrapper over Win32 input synthesis."""
+
+    # ---- mouse ----
+    def click(self, hwnd, x: int, y: int) -> None:
+        sx, sy = _to_screen(hwnd, x, y)
+        nx, ny = _norm(sx, sy)
+        _send(_mouse(nx, ny, flags=_ABS_MOVE),
+              _mouse(flags=MOUSEEVENTF_LEFTDOWN),
+              _mouse(flags=MOUSEEVENTF_LEFTUP))
+
+    def double_click(self, hwnd, x: int, y: int) -> None:
+        self.click(hwnd, x, y)
+        time.sleep(0.05)
+        self.click(hwnd, x, y)
+
+    def right_click(self, hwnd, x: int, y: int) -> None:
+        sx, sy = _to_screen(hwnd, x, y)
+        nx, ny = _norm(sx, sy)
+        _send(_mouse(nx, ny, flags=_ABS_MOVE),
+              _mouse(flags=MOUSEEVENTF_RIGHTDOWN),
+              _mouse(flags=MOUSEEVENTF_RIGHTUP))
+
+    def long_press(self, hwnd, x: int, y: int, hold_ms: int) -> None:
+        sx, sy = _to_screen(hwnd, x, y)
+        nx, ny = _norm(sx, sy)
+        _send(_mouse(nx, ny, flags=_ABS_MOVE))
+        _send(_mouse(flags=MOUSEEVENTF_LEFTDOWN))
+        time.sleep(hold_ms / 1000.0)
+        _send(_mouse(flags=MOUSEEVENTF_LEFTUP))
+
+    def swipe(self, hwnd, x1, y1, x2, y2, duration_ms: int = 500) -> None:
+        steps = 20
+        step_delay = duration_ms / steps / 1000.0
+        sx1, sy1 = _to_screen(hwnd, x1, y1)
+        sx2, sy2 = _to_screen(hwnd, x2, y2)
+        nx, ny = _norm(sx1, sy1)
+        _send(_mouse(nx, ny, flags=_ABS_MOVE))
+        _send(_mouse(flags=MOUSEEVENTF_LEFTDOWN))
+        for i in range(1, steps + 1):
+            cx = sx1 + (sx2 - sx1) * i // steps
+            cy = sy1 + (sy2 - sy1) * i // steps
+            mx, my = _norm(cx, cy)
+            _send(_mouse(mx, my, flags=_ABS_MOVE))
+            time.sleep(step_delay)
+        _send(_mouse(flags=MOUSEEVENTF_LEFTUP))
+
+    def drag(self, hwnd, x1, y1, x2, y2, duration_ms: int = 300) -> None:
+        self.swipe(hwnd, x1, y1, x2, y2, duration_ms)
+
+    def pinch(self, hwnd, cx, cy, start_dist, end_dist, duration_ms: int = 400) -> None:
+        sx, sy = _to_screen(hwnd, cx, cy)
+        nx, ny = _norm(sx, sy)
+        _send(_mouse(nx, ny, flags=_ABS_MOVE))
+        steps = 10
+        step_delay = duration_ms / steps / 1000.0
+        scroll_per_step = ((end_dist - start_dist) * WHEEL_DELTA) // (steps * 50)
+        for _ in range(steps):
+            _send(_mouse(data=scroll_per_step, flags=MOUSEEVENTF_WHEEL))
+            time.sleep(step_delay)
+
+    def scroll(self, hwnd, x, y, amount: int) -> None:
+        sx, sy = _to_screen(hwnd, x, y)
+        nx, ny = _norm(sx, sy)
+        _send(_mouse(nx, ny, flags=_ABS_MOVE))
+        _send(_mouse(data=amount * WHEEL_DELTA, flags=MOUSEEVENTF_WHEEL))
+
+    # ---- keyboard ----
+    def key_down(self, vk: int) -> None:
+        _send(_kbd(vk=vk))
+
+    def key_up(self, vk: int) -> None:
+        _send(_kbd(vk=vk, flags=KEYEVENTF_KEYUP))
+
+    def key_press(self, vk: int) -> None:
+        self.key_down(vk)
+        time.sleep(0.03)
+        self.key_up(vk)
+
+    def type_text(self, text: str) -> None:
+        for ch in text:
+            code = ord(ch)
+            _send(_kbd(scan=code, flags=KEYEVENTF_UNICODE),
+                  _kbd(scan=code, flags=KEYEVENTF_UNICODE | KEYEVENTF_KEYUP))
+            time.sleep(0.02)
+
+    def hotkey(self, modifier: int, vk: int) -> None:
+        if modifier:
+            self.key_down(modifier)
+        self.key_press(vk)
+        if modifier:
+            self.key_up(modifier)
+
+
+# ---- vk parsing (port of Clicker::parseVkCode) --------------------------------
+_NAMED_VK = {
+    "ENTER": 0x0D, "RETURN": 0x0D, "ESC": 0x1B, "ESCAPE": 0x1B, "TAB": 0x09,
+    "SPACE": 0x20, "BACKSPACE": 0x08, "BS": 0x08, "DELETE": 0x2E, "DEL": 0x2E,
+    "UP": 0x26, "DOWN": 0x28, "LEFT": 0x25, "RIGHT": 0x27, "HOME": 0x24, "END": 0x23,
+    "PAGEUP": 0x21, "PGUP": 0x21, "PAGEDOWN": 0x22, "PGDN": 0x22,
+    "CTRL": 0x11, "ALT": 0x12, "SHIFT": 0x10, "WIN": 0x5B,
+}
+_VK_F1 = 0x70
+
+
+def parse_vk(key_name: str) -> int:
+    """Map a key name to a virtual-key code (0 if unknown)."""
+    k = (key_name or "").upper().strip()
+    if k in _NAMED_VK:
+        return _NAMED_VK[k]
+    if k.startswith("F") and len(k) <= 3:
+        try:
+            n = int(k[1:])
+        except ValueError:
+            n = 0
+        if 1 <= n <= 24:
+            return _VK_F1 + n - 1
+    if len(k) == 1:
+        c = k[0]
+        if "A" <= c <= "Z" or "0" <= c <= "9":
+            return ord(c)
+    return 0

pyclickerrpa-0.1.0/autoclicker/dpi.py

@@ -0,0 +1,30 @@
+"""Process DPI awareness.
+
+Making the process per-monitor DPI-aware keeps window coordinates, screenshots
+and synthesized clicks in the same physical-pixel space on scaled displays
+(>100% scaling), avoiding offset clicks. Call once at startup.
+"""
+from __future__ import annotations
+
+import os
+
+
+def set_dpi_aware() -> None:
+    if os.name != "nt":
+        return
+    import ctypes
+    # PER_MONITOR_AWARE_V2 (Win10 1703+) -> PER_MONITOR (Win8.1) -> system-DPI (legacy)
+    try:
+        ctypes.windll.user32.SetProcessDpiAwarenessContext(ctypes.c_void_p(-4))
+        return
+    except Exception:
+        pass
+    try:
+        ctypes.windll.shcore.SetProcessDpiAwareness(2)
+        return
+    except Exception:
+        pass
+    try:
+        ctypes.windll.user32.SetProcessDPIAware()
+    except Exception:
+        pass

pyclickerrpa-0.1.0/autoclicker/gui/__init__.py

@@ -0,0 +1 @@
+"""PySide6 GUI for AutoClicker (Phase 2+)."""