makcu 2.1.3__py3-none-any.whl → 2.2.1__py3-none-any.whl

makcu/__init__.py

@@ -1,378 +1,22 @@
-import asyncio
-import random
-import time
-from typing import Optional, Dict, Callable, Union, List
-from concurrent.futures import ThreadPoolExecutor
-from .mouse import Mouse
-from .connection import SerialTransport
-from .errors import MakcuConnectionError
-from .enums import MouseButton
-from .controller import maybe_async
-
-class MakcuController:
-    _BUTTON_LOCK_MAP = {
-        MouseButton.LEFT: 'lock_left',
-        MouseButton.RIGHT: 'lock_right',
-        MouseButton.MIDDLE: 'lock_middle',
-        MouseButton.MOUSE4: 'lock_side1',
-        MouseButton.MOUSE5: 'lock_side2',
-    }
-    
-    def __init__(self, fallback_com_port: str = "", debug: bool = False, 
-                 send_init: bool = True, auto_reconnect: bool = True, 
-                 override_port: bool = False) -> None:
-        self.transport = SerialTransport(
-            fallback_com_port, 
-            debug=debug, 
-            send_init=send_init,
-            auto_reconnect=auto_reconnect,
-            override_port=override_port
-        )
-        self.mouse = Mouse(self.transport)
-        self._executor = ThreadPoolExecutor(max_workers=1)
-        self._connection_callbacks: List[Callable[[bool], None]] = []
-        self._connected = False
-
-    async def _run_async(self, func, *args, **kwargs):
-        """Run a function in the thread pool executor"""
-        loop = asyncio.get_running_loop()
-        return await loop.run_in_executor(self._executor, func, self, *args, **kwargs)
-
-    def _check_connection(self) -> None:
-        if not self._connected:
-            raise MakcuConnectionError("Not connected")
-
-    def _notify_connection_change(self, connected: bool) -> None:
-        for callback in self._connection_callbacks:
-            try:
-                callback(connected)
-            except Exception:
-                pass
-
-    @maybe_async
-    def connect(self) -> None:
-        self.transport.connect()
-        self._connected = True
-        self._notify_connection_change(True)
-
-    @maybe_async
-    def disconnect(self) -> None:
-        self.transport.disconnect()
-        self._connected = False
-        self._notify_connection_change(False)
-        self._executor.shutdown(wait=False)
-
-    @maybe_async
-    def is_connected(self) -> bool:
-        return self._connected and self.transport.is_connected()
-
-    @maybe_async
-    def click(self, button: MouseButton) -> None:
-        self._check_connection()
-        self.mouse.press(button)
-        self.mouse.release(button)
-
-    @maybe_async
-    def double_click(self, button: MouseButton) -> None:
-        self._check_connection()
-        self.mouse.press(button)
-        self.mouse.release(button)
-        time.sleep(0.001)
-        self.mouse.press(button)
-        self.mouse.release(button)
-
-    @maybe_async
-    def move(self, dx: int, dy: int) -> None:
-        self._check_connection()
-        self.mouse.move(dx, dy)
-
-    @maybe_async
-    def scroll(self, delta: int) -> None:
-        self._check_connection()
-        self.mouse.scroll(delta)
-
-    @maybe_async
-    def press(self, button: MouseButton) -> None:
-        self._check_connection()
-        self.mouse.press(button)
-
-    @maybe_async
-    def release(self, button: MouseButton) -> None:
-        self._check_connection()
-        self.mouse.release(button)
-
-    @maybe_async
-    def move_smooth(self, dx: int, dy: int, segments: int = 10) -> None:
-        self._check_connection()
-        self.mouse.move_smooth(dx, dy, segments)
-
-    @maybe_async
-    def move_bezier(self, dx: int, dy: int, segments: int = 20,
-                    ctrl_x: Optional[int] = None, ctrl_y: Optional[int] = None) -> None:
-        self._check_connection()
-        if ctrl_x is None:
-            ctrl_x = dx // 2
-        if ctrl_y is None:
-            ctrl_y = dy // 2
-        self.mouse.move_bezier(dx, dy, segments, ctrl_x, ctrl_y)
-
-    @maybe_async
-    def lock(self, target: Union[MouseButton, str]) -> None:
-        self._check_connection()
-        
-        if isinstance(target, MouseButton):
-            if target in self._BUTTON_LOCK_MAP:
-                getattr(self.mouse, self._BUTTON_LOCK_MAP[target])(True)
-            else:
-                raise ValueError(f"Unsupported button: {target}")
-        elif target.upper() in ['X', 'Y']:
-            if target.upper() == 'X':
-                self.mouse.lock_x(True)
-            else:
-                self.mouse.lock_y(True)
-        else:
-            raise ValueError(f"Invalid lock target: {target}")
-
-    @maybe_async
-    def unlock(self, target: Union[MouseButton, str]) -> None:
-        self._check_connection()
-        
-        if isinstance(target, MouseButton):
-            if target in self._BUTTON_LOCK_MAP:
-                getattr(self.mouse, self._BUTTON_LOCK_MAP[target])(False)
-            else:
-                raise ValueError(f"Unsupported button: {target}")
-        elif target.upper() in ['X', 'Y']:
-            if target.upper() == 'X':
-                self.mouse.lock_x(False)
-            else:
-                self.mouse.lock_y(False)
-        else:
-            raise ValueError(f"Invalid unlock target: {target}")
-
-    @maybe_async
-    def lock_left(self, lock: bool) -> None:
-        self._check_connection()
-        self.mouse.lock_left(lock)
-
-    @maybe_async
-    def lock_middle(self, lock: bool) -> None:
-        self._check_connection()
-        self.mouse.lock_middle(lock)
-
-    @maybe_async
-    def lock_right(self, lock: bool) -> None:
-        self._check_connection()
-        self.mouse.lock_right(lock)
-
-    @maybe_async
-    def lock_side1(self, lock: bool) -> None:
-        self._check_connection()
-        self.mouse.lock_side1(lock)
-
-    @maybe_async
-    def lock_side2(self, lock: bool) -> None:
-        self._check_connection()
-        self.mouse.lock_side2(lock)
-
-    @maybe_async
-    def lock_x(self, lock: bool) -> None:
-        self._check_connection()
-        self.mouse.lock_x(lock)
-
-    @maybe_async
-    def lock_y(self, lock: bool) -> None:
-        self._check_connection()
-        self.mouse.lock_y(lock)
-
-    @maybe_async
-    def lock_mouse_x(self, lock: bool) -> None:
-        self.lock_x(lock)
-
-    @maybe_async
-    def lock_mouse_y(self, lock: bool) -> None:
-        self.lock_y(lock)
-
-    @maybe_async
-    def is_locked(self, button: MouseButton) -> bool:
-        self._check_connection()
-        return self.mouse.is_locked(button)
-
-    @maybe_async
-    def get_all_lock_states(self) -> Dict[str, bool]:
-        self._check_connection()
-        return self.mouse.get_all_lock_states()
-
-    @maybe_async
-    def spoof_serial(self, serial: str) -> None:
-        self._check_connection()
-        self.mouse.spoof_serial(serial)
-
-    @maybe_async
-    def reset_serial(self) -> None:
-        self._check_connection()
-        self.mouse.reset_serial()
-
-    @maybe_async
-    def get_device_info(self) -> Dict[str, str]:
-        self._check_connection()
-        return self.mouse.get_device_info()
-
-    @maybe_async
-    def get_firmware_version(self) -> str:
-        self._check_connection()
-        return self.mouse.get_firmware_version()
-
-    @maybe_async
-    def get_button_mask(self) -> int:
-        self._check_connection()
-        return self.transport.get_button_mask()
-
-    @maybe_async
-    def get_button_states(self) -> Dict[str, bool]:
-        self._check_connection()
-        return self.transport.get_button_states()
-
-    @maybe_async
-    def is_pressed(self, button: MouseButton) -> bool:
-        self._check_connection()
-        return self.transport.get_button_states().get(button.name.lower(), False)
-
-    @maybe_async
-    def enable_button_monitoring(self, enable: bool = True) -> None:
-        self._check_connection()
-        self.transport.enable_button_monitoring(enable)
-
-    @maybe_async
-    def set_button_callback(self, callback: Optional[Callable[[MouseButton, bool], None]]) -> None:
-        self._check_connection()
-        self.transport.set_button_callback(callback)
-
-    @maybe_async
-    def on_connection_change(self, callback: Callable[[bool], None]) -> None:
-        self._connection_callbacks.append(callback)
-
-    @maybe_async
-    def remove_connection_callback(self, callback: Callable[[bool], None]) -> None:
-        if callback in self._connection_callbacks:
-            self._connection_callbacks.remove(callback)
-
-    @maybe_async
-    def click_human_like(self, button: MouseButton, count: int = 1,
-                        profile: str = "normal", jitter: int = 0) -> None:
-        self._check_connection()
-
-        timing_profiles = {
-            "normal": (60, 120, 100, 180),
-            "fast": (30, 60, 50, 100),
-            "slow": (100, 180, 150, 300),
-            "variable": (40, 200, 80, 250),
-            "gaming": (20, 40, 30, 60),
-        }
-
-        if profile not in timing_profiles:
-            raise ValueError(f"Invalid profile: {profile}")
-
-        min_down, max_down, min_wait, max_wait = timing_profiles[profile]
-
-        for i in range(count):
-            if jitter > 0:
-                dx = random.randint(-jitter, jitter)
-                dy = random.randint(-jitter, jitter)
-                self.mouse.move(dx, dy)
-
-            self.mouse.press(button)
-            time.sleep(random.uniform(min_down, max_down) / 1000.0)
-            self.mouse.release(button)
-            
-            if i < count - 1:
-                time.sleep(random.uniform(min_wait, max_wait) / 1000.0)
-
-    @maybe_async
-    def drag(self, start_x: int, start_y: int, end_x: int, end_y: int,
-             button: MouseButton = MouseButton.LEFT, duration: float = 1.0) -> None:
-        self._check_connection()
-        
-        # Move to start position
-        self.move(start_x, start_y)
-        time.sleep(0.02)
-        
-        # Press button
-        self.press(button)
-        time.sleep(0.02)
-        
-        # Smooth move to end position
-        segments = max(10, int(duration * 30))
-        self.move_smooth(end_x - start_x, end_y - start_y, segments)
-        
-        # Release button
-        time.sleep(0.02)
-        self.release(button)
-
-    # Context managers for both sync and async
-    def __enter__(self):
-        if not self.is_connected():
-            self.connect()
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        self.disconnect()
-
-    async def __aenter__(self):
-        if not await self.is_connected():
-            await self.connect()
-        return self
-
-    async def __aexit__(self, exc_type, exc_val, exc_tb):
-        await self.disconnect()
-
-    # Legacy async methods for backward compatibility
-    async def async_connect(self) -> None:
-        """Legacy method - use connect() instead"""
-        await self.connect()
-
-    async def async_disconnect(self) -> None:
-        """Legacy method - use disconnect() instead"""
-        await self.disconnect()
-
-    async def async_click(self, button: MouseButton) -> None:
-        """Legacy method - use click() instead"""
-        await self.click(button)
-
-    async def async_move(self, dx: int, dy: int) -> None:
-        """Legacy method - use move() instead"""
-        await self.move(dx, dy)
-
-    async def async_scroll(self, delta: int) -> None:
-        """Legacy method - use scroll() instead"""
-        await self.scroll(delta)
-
-
-def create_controller(fallback_com_port: str = "", debug: bool = False, 
-                     send_init: bool = True, auto_reconnect: bool = True, 
-                     override_port: bool = False) -> MakcuController:
-    """Create and connect a controller synchronously"""
-    makcu = MakcuController(
-        fallback_com_port, 
-        debug=debug, 
-        send_init=send_init,
-        auto_reconnect=auto_reconnect,
-        override_port=override_port
-    )
-    makcu.connect()
-    return makcu
-
-
-async def create_async_controller(fallback_com_port: str = "", debug: bool = False,
-                                 send_init: bool = True, auto_reconnect: bool = True, 
-                                 override_port: bool = False) -> MakcuController:
-    """Create and connect a controller asynchronously"""
-    makcu = MakcuController(
-        fallback_com_port,
-        debug=debug,
-        send_init=send_init,
-        auto_reconnect=auto_reconnect,
-        override_port=override_port
-    )
-    await makcu.connect()
-    return makcu
+from .controller import (
+    MakcuController,
+    create_controller,
+    create_async_controller,
+    maybe_async
+)
+from .enums import MouseButton
+from .errors import MakcuConnectionError
+
+# Version info
+__version__ = "2.2.1"
+__author__ = "SleepyTotem"
+
+# Main exports
+__all__ = [
+    'MakcuController',
+    'MouseButton',
+    'MakcuConnectionError',
+    'create_controller',
+    'create_async_controller',
+    'maybe_async'
+]

makcu/__main__.py

@@ -8,11 +8,12 @@ from makcu import create_controller, MakcuConnectionError, MakcuController
 import json
 import re
 import subprocess
+import makcu
 
-makcu_version = "v2.1.3"
+makcu_version = makcu.__version__
 
 def debug_console():
-    controller = create_controller()
+    controller = create_controller(debug=True)
     transport = controller.transport
 
     print("🔧 Makcu Debug Console")
@@ -90,42 +91,48 @@ def find_writable_directory() -> Path:
 def parse_html_results(html_file: Path) -> Tuple[List[Tuple[str, str, int]], int]:
     if not html_file.exists():
         raise FileNotFoundError(f"HTML report not found: {html_file}")
-    
+   
     with open(html_file, 'r', encoding='utf-8') as f:
         content = f.read()
-    
+   
     match = re.search(r'data-jsonblob="([^"]*)"', content)
     if not match:
         raise ValueError("Could not find JSON data in HTML report")
-    
+   
     json_str = match.group(1)
     json_str = json_str.replace('"', '"').replace(''', "'").replace('&', '&')
-    
+   
     try:
         data = json.loads(json_str)
     except json.JSONDecodeError as e:
         raise ValueError(f"Failed to parse JSON data: {e}")
-    
+   
     test_results = []
     total_ms = 0
-    
+   
     skip_tests = {'test_connect_to_port'}
-    
+   
     for test_id, test_data_list in data.get('tests', {}).items():
         test_name = test_id.split('::')[-1]
+        
+        # Skip tests that are in skip_tests
         if test_name in skip_tests:
             continue
-            
+           
         for test_data in test_data_list:
             status = test_data.get('result', 'UNKNOWN')
             duration_str = test_data.get('duration', '0 ms')
-            
+           
             duration_match = re.search(r'(\d+)\s*ms', duration_str)
             duration_ms = int(duration_match.group(1)) if duration_match else 0
-            total_ms += duration_ms
             
+            # Always add test to results
             test_results.append((test_name, status, duration_ms))
-    
+            
+            # Only add time to total if it's not a cleanup test
+            if 'cleanup' not in test_name.lower():
+                total_ms += duration_ms
+   
     return test_results, total_ms
 
 def run_tests() -> NoReturn:
@@ -243,8 +250,12 @@ def run_tests() -> NoReturn:
             display_name = test_name.replace("test_", "").replace("_", " ").title()
 
             if status.upper() == "PASSED":
-                status_text = "[green]✅ PASSED[/green]"
-                passed += 1
+                if display_name.lower().startswith("cleanup"):
+                    status_text = ""
+                    passed += 1
+                else:
+                    status_text = "[green]✅ PASSED[/green]"
+                    passed += 1
             elif status.upper() == "FAILED":
                 status_text = "[red]❌ FAILED[/red]"
                 failed += 1
@@ -262,7 +273,10 @@ def run_tests() -> NoReturn:
             elif duration_ms <= 10:
                 perf = "[yellow]Good[/yellow]"
             elif duration_ms > 0:
-                perf = "[red]🐌 Needs work[/red]"
+                if display_name.lower().startswith("cleanup"):
+                    perf = ""
+                else:
+                    perf = "[red]🐌 Needs work[/red]"
             else:
                 perf = "-"
 

makcu/conftest.py

@@ -3,32 +3,6 @@ import time
 from makcu import MakcuController, MouseButton
 
 @pytest.fixture(scope="session")
-def makcu(request):
+def makcu():
     ctrl = MakcuController(fallback_com_port="COM1", debug=False)
-
-    def cleanup():
-        if ctrl.is_connected():
-
-            time.sleep(0.1)
-
-            ctrl.lock_left(False)
-            ctrl.lock_right(False)
-            ctrl.lock_middle(False)
-            ctrl.lock_side1(False)
-            ctrl.lock_side2(False)
-            ctrl.lock_x(False)
-            ctrl.lock_y(False)
-
-            ctrl.release(MouseButton.LEFT)
-            ctrl.release(MouseButton.RIGHT)
-            ctrl.release(MouseButton.MIDDLE)
-            ctrl.release(MouseButton.MOUSE4)
-            ctrl.release(MouseButton.MOUSE5)
-
-            ctrl.enable_button_monitoring(False)
-
-        ctrl.disconnect()
-
-    request.addfinalizer(cleanup)
-
     return ctrl