PyClickerRPA 0.1.0__py3-none-any.whl

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",
+]

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())

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)

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

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

autoclicker/gui/__init__.py

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

autoclicker/gui/flow_connection.py

@@ -0,0 +1,91 @@
+"""Flow graph connection (edge) — port of flowconnection.cpp.
+
+Forward edges are drawn as downward bezier curves; back-edges (target above
+source) are dashed loop arrows and carry an optional repeat-count label.
+"""
+from __future__ import annotations
+
+import math
+
+from PySide6.QtCore import QPointF, Qt
+from PySide6.QtGui import QColor, QFont, QPainterPath, QPen, QPolygonF
+from PySide6.QtWidgets import QGraphicsItem, QGraphicsPathItem, QGraphicsTextItem
+
+
+class FlowConnection(QGraphicsPathItem):
+    def __init__(self, from_port, to_port, parent=None):
+        super().__init__(parent)
+        self.from_port = from_port
+        self.to_port = to_port
+        self.repeat_count = 1
+        self.setPen(QPen(QColor(200, 200, 200), 2))
+        self.setFlag(QGraphicsItem.ItemIsSelectable)
+        self.setZValue(-1)
+
+        from_port.connections.append(self)
+        to_port.connections.append(self)
+
+        self._label = QGraphicsTextItem(self)
+        self._label.setDefaultTextColor(QColor(255, 200, 50))
+        self._label.setFont(QFont("Consolas", 9, QFont.Bold))
+        self._label.setVisible(False)
+
+        self.update_path()
+
+    def detach(self):
+        if self in self.from_port.connections:
+            self.from_port.connections.remove(self)
+        if self in self.to_port.connections:
+            self.to_port.connections.remove(self)
+
+    def set_repeat_count(self, count: int):
+        self.repeat_count = count
+        if count > 1 or count < 0:
+            self._label.setPlainText("∞" if count < 0 else f"×{count}")
+            self._label.setVisible(True)
+        else:
+            self._label.setVisible(False)
+        self.update_path()
+
+    def update_path(self):
+        start = self.from_port.center_scene_pos()
+        end = self.to_port.center_scene_pos()
+        path = QPainterPath()
+        path.moveTo(start)
+
+        if end.y() < start.y():  # back-edge (loop)
+            offset = 40 + abs(start.y() - end.y()) * 0.15
+            mid_x = min(start.x(), end.x()) - offset
+            path.cubicTo(start.x() - offset * 0.5, start.y() + 30,
+                         mid_x, (start.y() + end.y()) / 2,
+                         end.x() - offset * 0.5, end.y() - 30)
+            path.lineTo(end)
+            self.setPen(QPen(QColor(234, 67, 53), 2, Qt.DashLine))
+        else:
+            dy = end.y() - start.y()
+            ctrl = min(dy * 0.5, 80.0)
+            path.cubicTo(start.x(), start.y() + ctrl, end.x(), end.y() - ctrl, end.x(), end.y())
+            self.setPen(QPen(QColor(200, 200, 200), 2))
+
+        self.setPath(path)
+        mid = path.pointAtPercent(0.5)
+        self._label.setPos(mid + QPointF(5, -10))
+
+    def paint(self, painter, option, widget=None):
+        super().paint(painter, option, widget)
+        p = self.path()
+        if p.isEmpty():
+            return
+        before = p.pointAtPercent(0.95)
+        tip = p.pointAtPercent(1.0)
+        angle = math.atan2(tip.y() - before.y(), tip.x() - before.x())
+        size = 10
+        p1 = tip - QPointF(math.cos(angle - math.pi / 6) * size, math.sin(angle - math.pi / 6) * size)
+        p2 = tip - QPointF(math.cos(angle + math.pi / 6) * size, math.sin(angle + math.pi / 6) * size)
+        painter.setPen(Qt.NoPen)
+        painter.setBrush(self.pen().color())
+        painter.drawPolygon(QPolygonF([tip, p1, p2]))
+        if self.isSelected():
+            painter.setPen(QPen(Qt.yellow, 2, Qt.DotLine))
+            painter.setBrush(Qt.NoBrush)
+            painter.drawPath(p)