clickmate 0.1.2.dev0__tar.gz → 0.1.4__tar.gz

{clickmate-0.1.2.dev0 → clickmate-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: clickmate
-Version: 0.1.2.dev0
+Version: 0.1.4
 Summary: Add your description here
 Keywords: autoclicker,clickmate,automation,macos,quartz,mouse,cli
 Author: ivand890
@@ -37,7 +37,6 @@ Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
-Requires-Dist: pyautogui>=0.9.54
 Requires-Dist: pynput>=1.8.1
 Requires-Dist: pyobjc-framework-quartz>=10.3 ; sys_platform == 'darwin' and extra == 'mac'
 Requires-Python: >=3.11
@@ -50,7 +49,7 @@ Description-Content-Type: text/markdown
 
 # Clickmate
 
-Clickmate is a macOS-friendly Python autoclicker. It prefers native Quartz CoreGraphics events on macOS (when available) and falls back to `pynput` or `pyautogui`. It features randomized delays, adjustable hold time (“pressure”), and a clean single-line status UI.
+Clickmate is a macOS-friendly Python autoclicker. It prefers native Quartz CoreGraphics events on macOS (when available) and falls back to `pynput`. It features randomized delays, adjustable hold time (“pressure”), and a clean single-line status UI.
 
 ## Features
 
@@ -58,7 +57,7 @@ Clickmate is a macOS-friendly Python autoclicker. It prefers native Quartz CoreG
 - Randomized delay per click (0.5×–1.5× of base)
 - Adjust speed with `+` (faster) / `-` (slower)
 - Adjust hold time with `]` (increase) / `[` (decrease)
-- Toggle click engine with `m` (`pynput` → `quartz` → `pyautogui`)
+- Toggle click engine with `m` (`pynput` ↔ `quartz`, macOS only)
 - Single test click with `c`
 - Optional jitter movement `j` and debug logs `d`
 - Global hotkey to lock/unlock local keys: `Ctrl+Alt+K`
@@ -115,7 +114,7 @@ uv tool install .
 - `s` — start/pause
 - `+` / `-` — faster / slower
 - `]` / `[` — increase / decrease hold time
-- `m` — toggle engine (`pynput` → `quartz` → `pyautogui`)
+- `m` — toggle engine (`pynput` ↔ `quartz`, macOS only)
 - `c` — single test click
 - `j` — toggle jitter
 - `d` — toggle debug logs
@@ -133,7 +132,7 @@ Example:
 Key fields:
 - `delay` base delay; actual delays are randomized within `rng` (0.5×–1.5×)
 - `hold` button press duration (“pressure”)
-- `meth` engine: `QTZ` (Quartz), `PNP` (pynput), `PGA` (pyautogui)
+- `meth` engine: `QTZ` (Quartz), `PNP` (pynput)
 - `lock` `yes` when local keys are locked (only `Ctrl+Alt+K` works)
 - `fb:N` fallback count when switching engines was required
 
@@ -171,6 +170,5 @@ MIT — see `LICENSE`.
 
 ## Dependencies
 
-- `pyautogui` — automation
-- `pynput` — input handling and alternative click path
+- `pynput` — input handling and clicks
 - Optional: `pyobjc` (provides `Quartz`) — enables Quartz engine on macOS

{clickmate-0.1.2.dev0 → clickmate-0.1.4}/README.md

@@ -1,6 +1,6 @@
 # Clickmate
 
-Clickmate is a macOS-friendly Python autoclicker. It prefers native Quartz CoreGraphics events on macOS (when available) and falls back to `pynput` or `pyautogui`. It features randomized delays, adjustable hold time (“pressure”), and a clean single-line status UI.
+Clickmate is a macOS-friendly Python autoclicker. It prefers native Quartz CoreGraphics events on macOS (when available) and falls back to `pynput`. It features randomized delays, adjustable hold time (“pressure”), and a clean single-line status UI.
 
 ## Features
 
@@ -8,7 +8,7 @@ Clickmate is a macOS-friendly Python autoclicker. It prefers native Quartz CoreG
 - Randomized delay per click (0.5×–1.5× of base)
 - Adjust speed with `+` (faster) / `-` (slower)
 - Adjust hold time with `]` (increase) / `[` (decrease)
-- Toggle click engine with `m` (`pynput` → `quartz` → `pyautogui`)
+- Toggle click engine with `m` (`pynput` ↔ `quartz`, macOS only)
 - Single test click with `c`
 - Optional jitter movement `j` and debug logs `d`
 - Global hotkey to lock/unlock local keys: `Ctrl+Alt+K`
@@ -65,7 +65,7 @@ uv tool install .
 - `s` — start/pause
 - `+` / `-` — faster / slower
 - `]` / `[` — increase / decrease hold time
-- `m` — toggle engine (`pynput` → `quartz` → `pyautogui`)
+- `m` — toggle engine (`pynput` ↔ `quartz`, macOS only)
 - `c` — single test click
 - `j` — toggle jitter
 - `d` — toggle debug logs
@@ -83,7 +83,7 @@ Example:
 Key fields:
 - `delay` base delay; actual delays are randomized within `rng` (0.5×–1.5×)
 - `hold` button press duration (“pressure”)
-- `meth` engine: `QTZ` (Quartz), `PNP` (pynput), `PGA` (pyautogui)
+- `meth` engine: `QTZ` (Quartz), `PNP` (pynput)
 - `lock` `yes` when local keys are locked (only `Ctrl+Alt+K` works)
 - `fb:N` fallback count when switching engines was required
 
@@ -121,6 +121,5 @@ MIT — see `LICENSE`.
 
 ## Dependencies
 
-- `pyautogui` — automation
-- `pynput` — input handling and alternative click path
+- `pynput` — input handling and clicks
 - Optional: `pyobjc` (provides `Quartz`) — enables Quartz engine on macOS

{clickmate-0.1.2.dev0 → clickmate-0.1.4}/pyproject.toml

@@ -1,11 +1,10 @@
 [project]
 name = "clickmate"
-version = "0.1.2-dev"
+version = "0.1.4"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.11"
 dependencies = [
-    "pyautogui>=0.9.54",
     "pynput>=1.8.1",
 ]
 license = { file = "LICENSE" }

{clickmate-0.1.2.dev0 → clickmate-0.1.4}/src/autoclicker/__init__.py

@@ -4,4 +4,4 @@ Exports the CLI entrypoint via ``autoclicker.cli:main``.
 """
 
 __all__ = ["__version__"]
-__version__ = "0.1.2-dev"
+__version__ = "0.1.4"

{clickmate-0.1.2.dev0 → clickmate-0.1.4}/src/autoclicker/app.py

@@ -1,9 +1,13 @@
 import time
 import random
-import pyautogui
+import threading
 from pynput import keyboard
 from pynput.keyboard import Key
-from pynput.mouse import Controller as MouseController, Button
+from pynput.mouse import (
+    Controller as MouseController,
+    Button,
+    Listener as MouseListener,
+)
 import importlib
 import sys
 import shutil
@@ -15,6 +19,8 @@ try:
 except Exception:
     _HAS_QUARTZ = False
 
+# Click engines available on this platform, in toggle/fallback order
+_ENGINES = ["pynput", "quartz"] if _HAS_QUARTZ else ["pynput"]
 
 # Runtime state
 running = False
@@ -25,14 +31,20 @@ hold_time = 0.1  # how long to hold the button down per click
 # Randomization multipliers for per-click delay
 MIN_DELAY_MULTIPLIER = 0.5
 MAX_DELAY_MULTIPLIER = 1.5
-# Preferred click method: "pynput", "pyautogui", or "quartz" (macOS)
+# Preferred click method: "pynput" or "quartz" (macOS)
 # Default to Quartz if available for best macOS compatibility
 click_method = "quartz" if _HAS_QUARTZ else "pynput"
 debug = False
 jitter_enabled = False  # default jitter disabled (enable with 'j' if needed)
 jitter_px = 1
 local_keys_enabled = True  # when False, only the global hotkey works
+cursor_lock_enabled = False  # Lock cursor position when running
+locked_position = None  # (x, y) tuple
+_last_lock_alert = 0.0  # track last alert time for throttling
 _pressed_keys = set()  # track currently pressed keys for combo detection
+_cursor_lock_thread = None
+_cursor_lock_active = threading.Event()
+_cursor_lock_shutdown = threading.Event()
 
 
 # ---------------- Status line support -----------------
@@ -46,6 +58,7 @@ class Status:
     jitter_enabled: bool
     debug: bool
     local_keys_enabled: bool
+    cursor_lock_enabled: bool
     click_count: int = 0
     last_click_ts: float | None = None
     next_delay: float | None = None
@@ -85,9 +98,10 @@ class StatusRenderer:
         state_sym = "▶" if st.running else "⏸"
         # lock shows yes/no for compatibility (yes = locked)
         lock_val = "no" if st.local_keys_enabled else "yes"
+        clock_val = "yes" if st.cursor_lock_enabled else "no"
         jitter_sym = "J" if st.jitter_enabled else "-"
         debug_sym = "D" if st.debug else "-"
-        method_map = {"quartz": "QTZ", "pynput": "PNP", "pyautogui": "PGA"}
+        method_map = {"quartz": "QTZ", "pynput": "PNP"}
         method_disp = method_map.get(st.click_method, st.click_method)
         # Fixed width numeric fields to avoid jitter
         delay_val = f"{st.delay:5.2f}s"
@@ -117,6 +131,7 @@ class StatusRenderer:
             f"jitter:{jitter_sym}",
             f"debug:{debug_sym}",
             f"lock:{lock_val}",
+            f"clock:{clock_val}",
             f"clicks:{clicks_val}",
             f"last:{last_val}",
             f"next:{next_val}",
@@ -135,6 +150,8 @@ class StatusRenderer:
                 line = line.replace(state_sym, self._color(state_sym, "33"))
             if not st.local_keys_enabled:
                 line = line.replace("lock:yes", self._color("lock:yes", "31"))
+            if st.cursor_lock_enabled:
+                line = line.replace("clock:yes", self._color("clock:yes", "36"))
         width = shutil.get_terminal_size(fallback=(120, 20)).columns
         if len(line) > width:
             line = line[: max(0, width - 1)] + "…"
@@ -172,6 +189,7 @@ status = Status(
     jitter_enabled=jitter_enabled,
     debug=debug,
     local_keys_enabled=local_keys_enabled,
+    cursor_lock_enabled=cursor_lock_enabled,
 )
 status_renderer = StatusRenderer()
 
@@ -185,6 +203,7 @@ def _refresh_status(mark: bool = True):
     status.jitter_enabled = jitter_enabled
     status.debug = debug
     status.local_keys_enabled = local_keys_enabled
+    status.cursor_lock_enabled = cursor_lock_enabled
     if mark:
         status_renderer.mark()
 
@@ -195,10 +214,6 @@ def _set_message(msg: str):
     status_renderer.mark()
 
 
-# Configure pyautogui safety
-pyautogui.FAILSAFE = False  # disable corner failsafe to avoid unintended stops
-pyautogui.PAUSE = 0  # no extra pause added by pyautogui
-
 # Shared mouse controller for pynput method
 _mouse = MouseController()
 
@@ -211,31 +226,6 @@ def _click_with_pynput():
     _mouse.release(Button.left)
 
 
-def _click_with_pyautogui():
-    # Click at current pointer location via pyautogui
-    pyautogui.mouseDown()
-    if hold_time > 0:
-        time.sleep(hold_time)
-    pyautogui.mouseUp()
-
-
-def _convert_to_quartz_point(pos):
-    # Convert top-left origin (pyautogui) to bottom-left origin (Quartz)
-    try:
-        Quartz = importlib.import_module("Quartz")
-        CG = Quartz.CoreGraphics
-        bounds = CG.CGDisplayBounds(CG.CGMainDisplayID())
-        height = int(bounds.size.height)
-        return CG.CGPoint(pos[0], height - pos[1])
-    except Exception:
-        # Fallback: return as-is (may be wrong on some layouts)
-        try:
-            CG = Quartz.CoreGraphics  # type: ignore
-            return CG.CGPoint(pos[0], pos[1])
-        except Exception:
-            return pos
-
-
 def _click_with_quartz():
     if not _HAS_QUARTZ:
         raise RuntimeError("Quartz not available")
@@ -263,60 +253,58 @@ def _jitter_move():
     if not jitter_enabled or jitter_px <= 0:
         return
     try:
-        if click_method in ("pynput", "quartz"):
-            x, y = _mouse.position
-            _mouse.position = (x + jitter_px, y)
-            _mouse.position = (x, y)
-        else:
-            pyautogui.moveRel(jitter_px, 0, duration=0)
-            pyautogui.moveRel(-jitter_px, 0, duration=0)
+        x, y = _mouse.position
+        _mouse.position = (x + jitter_px, y)
+        _mouse.position = (x, y)
     except Exception:
         # ignore jitter failures
         pass
 
 
+def _click_with(method: str):
+    if method == "quartz":
+        _click_with_quartz()
+    else:
+        _click_with_pynput()
+
+
 def perform_click(with_jitter: bool = True):
     global click_method
     try:
         if with_jitter:
             _jitter_move()
-        if click_method == "pynput":
-            _click_with_pynput()
-        elif click_method == "quartz":
-            _click_with_quartz()
-        else:
-            _click_with_pyautogui()
+        _click_with(click_method)
         status.click_count += 1
         status.last_click_ts = time.time()
         status_renderer.mark()
     except Exception as e:
         # Fallback to the other method once if one fails
-        order = ["pynput", "quartz", "pyautogui"]
         try:
-            idx = order.index(click_method)
+            idx = _ENGINES.index(click_method)
         except ValueError:
-            idx = 0
-        other = order[(idx + 1) % len(order)]
+            idx = -1
+        other = _ENGINES[(idx + 1) % len(_ENGINES)]
+        if other == click_method:
+            # No alternative engine on this platform
+            raise
         if debug:
             print(f"Click via {click_method} failed: {e} -> trying {other}")
         click_method = other
         status.fallbacks += 1
         status_renderer.mark()
         _set_message(f"fallback->{other}")
-        if other == "pynput":
-            _click_with_pynput()
-        elif other == "quartz":
-            _click_with_quartz()
-        else:
-            _click_with_pyautogui()
+        _click_with(other)
         status.click_count += 1
         status.last_click_ts = time.time()
         status_renderer.mark()
 
 
 def toggle_running():
-    global running
+    global running, locked_position
     running = not running
+    if running:
+        locked_position = _mouse.position
+    _sync_cursor_lock_worker_state()
     _set_message("started" if running else "paused")
     _refresh_status()
 
@@ -330,6 +318,17 @@ def global_toggle_keys():
     _refresh_status()
 
 
+def toggle_cursor_lock():
+    global cursor_lock_enabled, locked_position
+    cursor_lock_enabled = not cursor_lock_enabled
+    if cursor_lock_enabled:
+        locked_position = _mouse.position
+    _sync_cursor_lock_worker_state()
+    state = "enabled" if cursor_lock_enabled else "disabled"
+    _set_message(f"cursor_lock:{state}")
+    _refresh_status()
+
+
 def increase_speed():
     global delay
     delay = max(min_delay, round(delay - 0.1, 3))
@@ -360,20 +359,18 @@ def decrease_hold():
 
 def toggle_method():
     global click_method
-    order = ["pynput", "quartz" if _HAS_QUARTZ else None, "pyautogui"]
-    order = [m for m in order if m]
     try:
-        idx = order.index(click_method)
+        idx = _ENGINES.index(click_method)
     except ValueError:
         idx = 0
-    click_method = order[(idx + 1) % len(order)]
+    click_method = _ENGINES[(idx + 1) % len(_ENGINES)]
     _set_message(f"method {click_method}")
     _refresh_status()
 
 
 def single_test_click():
-    pos = pyautogui.position()
-    _set_message(f"test {pos[0]},{pos[1]}")
+    x, y = _mouse.position
+    _set_message(f"test {int(x)},{int(y)}")
     perform_click(with_jitter=False)
     _refresh_status()
 
@@ -440,6 +437,8 @@ def on_press(key):
             state = "enabled" if jitter_enabled else "disabled"
             _set_message(f"jitter:{state}")
             _refresh_status()
+        elif ch == "l":  # toggle cursor lock
+            toggle_cursor_lock()
     except Exception:
         pass
 
@@ -452,6 +451,75 @@ def on_release(key):
         pass
 
 
+def on_mouse_move(x, y):
+    # We now use a dedicated thread for more aggressive locking on Windows,
+    # but we keep the listener for potential future use or other platforms.
+    pass
+
+
+def _enforce_cursor_lock():
+    """Logic to enforce cursor lock. Returns True if alert was triggered."""
+    global _last_lock_alert
+    if running and cursor_lock_enabled and locked_position:
+        curr = _mouse.position
+        # Check distance (squared)
+        dx = curr[0] - locked_position[0]
+        dy = curr[1] - locked_position[1]
+        if (dx * dx + dy * dy) > 25:  # > 5 pixels
+            _mouse.position = locked_position
+            now = time.time()
+            if now - _last_lock_alert > 2.0:
+                _set_message("Cursor locked! Movement detected.")
+                _last_lock_alert = now
+                return True
+    return False
+
+
+def _ensure_cursor_lock_worker():
+    global _cursor_lock_thread
+    if _cursor_lock_thread and _cursor_lock_thread.is_alive():
+        return
+    _cursor_lock_shutdown.clear()
+    _cursor_lock_thread = threading.Thread(
+        target=_cursor_lock_worker,
+        daemon=True,
+    )
+    _cursor_lock_thread.start()
+
+
+def _sync_cursor_lock_worker_state():
+    if running and cursor_lock_enabled:
+        _ensure_cursor_lock_worker()
+        _cursor_lock_active.set()
+    else:
+        _cursor_lock_active.clear()
+
+
+def _stop_cursor_lock_worker():
+    global _cursor_lock_thread
+    thread = _cursor_lock_thread
+    _cursor_lock_shutdown.set()
+    _cursor_lock_active.set()
+    if thread and thread.is_alive():
+        thread.join(timeout=0.1)
+    _cursor_lock_active.clear()
+    _cursor_lock_thread = None
+
+
+def _cursor_lock_worker():
+    """Dedicated thread to enforce cursor lock with high frequency."""
+    while not _cursor_lock_shutdown.is_set():
+        _cursor_lock_active.wait()
+        if _cursor_lock_shutdown.is_set():
+            break
+        while _cursor_lock_active.is_set() and not _cursor_lock_shutdown.is_set():
+            try:
+                _enforce_cursor_lock()
+            except Exception:
+                pass
+            time.sleep(0.005)  # 200Hz for smooth locking
+
+
 def main():  # pragma: no cover - interactive app
     # Safety: honor simple flags here too, so that even if the CLI wrapper is
     # bypassed (or an older entry point is used), we don't start the loop.
@@ -473,7 +541,7 @@ def main():  # pragma: no cover - interactive app
                 "  - Hotkeys:",
                 "      s start/pause • +/− speed • ]/[ hold • m method •",
                 "      c test",
-                "      j jitter • d debug • Ctrl+Alt+K lock",
+                "      j jitter • d debug • l lock cursor • Ctrl+Alt+K lock keys",
             ]
             print("\n".join(_help_lines))
             return
@@ -490,11 +558,15 @@ def main():  # pragma: no cover - interactive app
     listener = keyboard.Listener(on_press=on_press, on_release=on_release)
     listener.start()
 
+    # Mouse listener for future use
+    mouse_listener = MouseListener(on_move=on_mouse_move)
+    mouse_listener.start()
+
     print("Autoclicker ready (status line below). Press Ctrl+C to exit.")
     print(
         "Keys: 's' start/pause, '+' faster, '-' slower, '['/']' hold time,\n"
         "      'm' method, 'c' test, 'j' jitter, 'd' debug,\n"
-        "      Ctrl+Alt+K lock keys"
+        "      Ctrl+Alt+K lock keys, 'l' cursor lock"
     )
     _refresh_status()
 
@@ -502,7 +574,7 @@ def main():  # pragma: no cover - interactive app
         while True:
             if running:
                 if debug:
-                    pos = pyautogui.position()
+                    pos = _mouse.position
                     print(
                         f"Clicking at {pos} via {click_method} "
                         f"(delay {delay}s, hold {hold_time}s)"
@@ -527,6 +599,14 @@ def main():  # pragma: no cover - interactive app
             listener.stop()
         except Exception:
             pass
+        try:
+            mouse_listener.stop()
+        except Exception:
+            pass
+        try:
+            _stop_cursor_lock_worker()
+        except Exception:
+            pass
         try:
             status_renderer.finalize(status)
         except Exception: