makcu 0.1.4__py3-none-any.whl → 0.2.0__py3-none-any.whl

makcu/mouse.py

@@ -1,167 +1,270 @@
+from typing import Dict, Optional, List, Union, Any
 from .enums import MouseButton
+from .connection import SerialTransport
 from .errors import MakcuCommandError
 from serial.tools import list_ports
 import time
 
+# Create a mock enum-like object for axis locks
+class AxisButton:
+    def __init__(self, name: str) -> None:
+        self.name = name
+
 class Mouse:
-    def __init__(self, transport):
+    """Ultra-optimized mouse control for gaming performance"""
+    
+    # Pre-computed command strings for faster access
+    _BUTTON_COMMANDS = {
+        MouseButton.LEFT: "left",
+        MouseButton.RIGHT: "right",
+        MouseButton.MIDDLE: "middle",
+        MouseButton.MOUSE4: "ms1",
+        MouseButton.MOUSE5: "ms2",
+    }
+    
+    # Pre-formatted commands cache
+    _PRESS_COMMANDS = {}
+    _RELEASE_COMMANDS = {}
+    _LOCK_COMMANDS = {}
+    _UNLOCK_COMMANDS = {}
+    _LOCK_QUERY_COMMANDS = {}
+    
+    def __init__(self, transport: SerialTransport) -> None:
         self.transport = transport
+        self._lock_states_cache: int = 0  # Bitwise cache
+        self._cache_valid = False
+        
+        # Pre-compute all commands for zero-overhead execution
+        self._init_command_cache()
+    
+    def _init_command_cache(self) -> None:
+        """Pre-compute all commands to avoid string formatting during execution"""
+        # Button press/release commands
+        for button, cmd in self._BUTTON_COMMANDS.items():
+            self._PRESS_COMMANDS[button] = f"km.{cmd}(1)"
+            self._RELEASE_COMMANDS[button] = f"km.{cmd}(0)"
+        
+        # Lock commands with bitwise indexing
+        # Bit 0-4: buttons, Bit 5: X axis, Bit 6: Y axis
+        lock_targets = [
+            ("LEFT", "ml", 0),
+            ("RIGHT", "mr", 1),
+            ("MIDDLE", "mm", 2),
+            ("MOUSE4", "ms1", 3),
+            ("MOUSE5", "ms2", 4),
+            ("X", "mx", 5),
+            ("Y", "my", 6),
+        ]
+        
+        for name, cmd, bit in lock_targets:
+            self._LOCK_COMMANDS[name] = (f"km.lock_{cmd}(1)", bit)
+            self._UNLOCK_COMMANDS[name] = (f"km.lock_{cmd}(0)", bit)
+            self._LOCK_QUERY_COMMANDS[name] = (f"km.lock_{cmd}()", bit)
 
-    def _send_button_command(self, button: MouseButton, state: int):
-        command_map = {
-            MouseButton.LEFT: "left",
-            MouseButton.RIGHT: "right",
-            MouseButton.MIDDLE: "middle",
-            MouseButton.MOUSE4: "ms1",
-            MouseButton.MOUSE5: "ms2",
-        }
-        if button not in command_map:
+    def _send_button_command(self, button: MouseButton, state: int) -> None:
+        """Optimized button command sending"""
+        if button not in self._BUTTON_COMMANDS:
             raise MakcuCommandError(f"Unsupported button: {button}")
-        self.transport.send_command(f"km.{command_map[button]}({state})")
+        
+        # Use pre-computed commands
+        cmd = self._PRESS_COMMANDS[button] if state else self._RELEASE_COMMANDS[button]
+        self.transport.send_command(cmd)
 
-    def press(self, button: MouseButton):
-        self._send_button_command(button, 1)
+    def press(self, button: MouseButton) -> None:
+        """Press with pre-computed command"""
+        self.transport.send_command(self._PRESS_COMMANDS[button])
 
-    def release(self, button: MouseButton):
-        self._send_button_command(button, 0)
+    def release(self, button: MouseButton) -> None:
+        """Release with pre-computed command"""
+        self.transport.send_command(self._RELEASE_COMMANDS[button])
 
-    def move(self, x: int, y: int):
+    def move(self, x: int, y: int) -> None:
+        """Move command"""
         self.transport.send_command(f"km.move({x},{y})")
 
-    def move_smooth(self, x: int, y: int, segments: int):
+    def click(self, button: MouseButton) -> None:
+        """Optimized click with cached commands"""
+        if button not in self._BUTTON_COMMANDS:
+            raise MakcuCommandError(f"Unsupported button: {button}")
+        
+        # Use pre-computed commands for maximum speed
+        press_cmd = self._PRESS_COMMANDS[button]
+        release_cmd = self._RELEASE_COMMANDS[button]
+        
+        # Send both commands in rapid succession
+        transport = self.transport  # Cache reference
+        transport.send_command(press_cmd)
+        transport.send_command(release_cmd)
+
+    def move_smooth(self, x: int, y: int, segments: int) -> None:
+        """Smooth movement"""
         self.transport.send_command(f"km.move({x},{y},{segments})")
 
-    def move_bezier(self, x: int, y: int, segments: int, ctrl_x: int, ctrl_y: int):
+    def move_bezier(self, x: int, y: int, segments: int, ctrl_x: int, ctrl_y: int) -> None:
+        """Bezier movement"""
         self.transport.send_command(f"km.move({x},{y},{segments},{ctrl_x},{ctrl_y})")
 
-    def scroll(self, delta: int):
+    def scroll(self, delta: int) -> None:
+        """Scroll command"""
         self.transport.send_command(f"km.wheel({delta})")
 
-    def lock_left(self, lock: bool):
-        self.transport.send_command(f"km.lock_ml({int(lock)})")
+    # Optimized lock methods using bitwise cache
+    def _set_lock(self, name: str, lock: bool) -> None:
+        """Generic lock setter with cache update"""
+        if lock:
+            cmd, bit = self._LOCK_COMMANDS[name]
+        else:
+            cmd, bit = self._UNLOCK_COMMANDS[name]
         
-    def lock_middle(self, lock: bool):
-        self.transport.send_command(f"km.lock_mm({int(lock)})")
+        self.transport.send_command(cmd)
+        
+        # Update cache
+        if lock:
+            self._lock_states_cache |= (1 << bit)
+        else:
+            self._lock_states_cache &= ~(1 << bit)
+        self._cache_valid = True
 
-    def lock_right(self, lock: bool):
-        self.transport.send_command(f"km.lock_mr({int(lock)})")
+    def lock_left(self, lock: bool) -> None:
+        self._set_lock("LEFT", lock)
+        
+    def lock_middle(self, lock: bool) -> None:
+        self._set_lock("MIDDLE", lock)
 
-    def lock_side1(self, lock: bool):
-        self.transport.send_command(f"km.lock_ms1({int(lock)})")
+    def lock_right(self, lock: bool) -> None:
+        self._set_lock("RIGHT", lock)
 
-    def lock_side2(self, lock: bool):
-        self.transport.send_command(f"km.lock_ms2({int(lock)})")
+    def lock_side1(self, lock: bool) -> None:
+        self._set_lock("MOUSE4", lock)
 
-    def lock_x(self, lock: bool):
-        self.transport.send_command(f"km.lock_mx({int(lock)})")
+    def lock_side2(self, lock: bool) -> None:
+        self._set_lock("MOUSE5", lock)
 
-    def lock_y(self, lock: bool):
-        self.transport.send_command(f"km.lock_my({int(lock)})")
+    def lock_x(self, lock: bool) -> None:
+        self._set_lock("X", lock)
 
+    def lock_y(self, lock: bool) -> None:
+        self._set_lock("Y", lock)
 
-    def spoof_serial(self, serial: str):
+    def spoof_serial(self, serial: str) -> None:
+        """Set custom serial"""
         self.transport.send_command(f"km.serial('{serial}')")
 
-    def reset_serial(self):
+    def reset_serial(self) -> None:
+        """Reset serial"""
         self.transport.send_command("km.serial(0)")
 
-    def get_device_info(self) -> dict:
+    def get_device_info(self) -> Dict[str, Union[str, bool]]:
+        """Ultra-fast device info with minimal port scanning"""
         port_name = self.transport.port
         is_connected = self.transport.is_connected()
+        
+        if not is_connected or not port_name:
+            return {
+                "port": port_name or "Unknown",
+                "description": "Disconnected",
+                "vid": "Unknown", 
+                "pid": "Unknown",
+                "isConnected": False
+            }
+        
         info = {
             "port": port_name,
-            "description": "Unknown",
-            "vid": "Unknown",
+            "description": "Connected Device",
+            "vid": "Unknown", 
             "pid": "Unknown",
-            "isConnected": is_connected
+            "isConnected": True
         }
-        for port in list_ports.comports():
-            if port.device == port_name:
-                info.update({
-                    "description": port.description,
-                    "vid": hex(port.vid) if port.vid is not None else "Unknown",
-                    "pid": hex(port.pid) if port.pid is not None else "Unknown"
-                })
-                break
+        
+        try:
+            for port in list_ports.comports():
+                if port.device == port_name:
+                    info["description"] = port.description or "Connected Device"
+                    if port.vid is not None:
+                        info["vid"] = f"0x{port.vid:04x}"
+                    if port.pid is not None:
+                        info["pid"] = f"0x{port.pid:04x}"
+                    break  # Found our port, exit immediately
+        except Exception:
+            pass
+        
         return info
 
     def get_firmware_version(self) -> str:
-        return self.transport.send_command("km.version()", expect_response=True)
+        """Get firmware version"""
+        response = self.transport.send_command("km.version()", expect_response=True, timeout=0.1)
+        return response or ""
 
-    def _get_lock_command(self, target: str) -> str:
-        command_map = {
-            "X": "mx", "Y": "my",
-            "LEFT": "ml", "RIGHT": "mr", "MIDDLE": "mm",
-            "MOUSE4": "ms1", "MOUSE5": "ms2",
-        }
-        key = target.upper()
-        if key not in command_map:
-            raise ValueError(f"Unsupported lock target: {target}")
-        return f"km.lock_{command_map[key]}()"
+    def _invalidate_cache(self) -> None:
+        """Invalidate cache"""
+        self._cache_valid = False
+
+    def get_all_lock_states(self) -> Dict[str, bool]:
+        """Get all lock states with parallel queries for gaming performance"""
+        # Return cache if valid
+        if self._cache_valid:
+            return {
+                "X": bool(self._lock_states_cache & (1 << 5)),
+                "Y": bool(self._lock_states_cache & (1 << 6)),
+                "LEFT": bool(self._lock_states_cache & (1 << 0)),
+                "RIGHT": bool(self._lock_states_cache & (1 << 1)),
+                "MIDDLE": bool(self._lock_states_cache & (1 << 2)),
+                "MOUSE4": bool(self._lock_states_cache & (1 << 3)),
+                "MOUSE5": bool(self._lock_states_cache & (1 << 4)),
+            }
+        
+        # Query all states in rapid succession
+        states = {}
+        targets = ["X", "Y", "LEFT", "RIGHT", "MIDDLE", "MOUSE4", "MOUSE5"]
+        
+        for target in targets:
+            cmd, bit = self._LOCK_QUERY_COMMANDS[target]
+            try:
+                result = self.transport.send_command(cmd, expect_response=True, timeout=0.05)
+                if result and result.strip() in ['0', '1']:
+                    is_locked = result.strip() == '1'
+                    states[target] = is_locked
+                    
+                    # Update cache
+                    if is_locked:
+                        self._lock_states_cache |= (1 << bit)
+                    else:
+                        self._lock_states_cache &= ~(1 << bit)
+                else:
+                    states[target] = False
+            except Exception:
+                states[target] = False
+        
+        self._cache_valid = True
+        return states
 
-    def is_locked(self, button: MouseButton) -> bool:
+    def is_locked(self, button: Union[MouseButton, AxisButton]) -> bool:
+        """Check lock state with cache"""
         try:
-            # Sleep for previous command to finish first, hoping to get rid of this soon.
-            time.sleep(0.03)
-
-            command = self._get_lock_command(button.name)
-            result = self.transport.send_command(command, expect_response=True)
-            if hasattr(self.transport, 'debug') and self.transport.debug:
-                print(f"Lock status command: {command}")
-                print(f"Raw result: '{result}'")
+            target_name = button.name if hasattr(button, 'name') else str(button)
             
-            result = result.strip()
+            # Check cache first
+            if self._cache_valid and target_name in self._LOCK_QUERY_COMMANDS:
+                _, bit = self._LOCK_QUERY_COMMANDS[target_name]
+                return bool(self._lock_states_cache & (1 << bit))
             
-            if result in ['1', '0']:
-                return result == '1'
+            # Query device
+            cmd, bit = self._LOCK_QUERY_COMMANDS[target_name]
+            result = self.transport.send_command(cmd, expect_response=True, timeout=0.05)
             
-            lines = result.split('\n')
-            for line in lines:
-                line = line.strip()
-                if line in ['1', '0']:
-                    return line == '1'
+            if not result:
+                return False
             
-            import re
-            numbers = re.findall(r'\b[01]\b', result)
-            if numbers:
-                return numbers[-1] == '1'
+            result = result.strip()
+            is_locked = result == '1'
             
-            if hasattr(self.transport, 'debug') and self.transport.debug:
-                print(f"Could not parse lock status from: '{result}'")
+            # Update cache
+            if is_locked:
+                self._lock_states_cache |= (1 << bit)
+            else:
+                self._lock_states_cache &= ~(1 << bit)
             
-            return False
+            return is_locked
             
-        except Exception as e:
-            if hasattr(self.transport, 'debug') and self.transport.debug:
-                print(f"Error checking lock status: {e}")
-            return False
-
-    def get_all_lock_states(self) -> dict:
-        """Get all lock states - no timing delays needed with acknowledgment"""
-        targets = ["X", "Y", "LEFT", "RIGHT", "MIDDLE", "MOUSE4", "MOUSE5"]
-        state = {}
-        
-        for target in targets:
-            try:
-                # No sleep needed - each command waits for acknowledgment
-                if hasattr(MouseButton, target):
-                    state[target] = self.is_locked(MouseButton[target])
-                else:
-                    # Handle X and Y axis locks
-                    if target in ["X", "Y"]:
-                        # Create a mock enum-like object for axis locks
-                        class AxisButton:
-                            def __init__(self, name):
-                                self.name = name
-                        state[target] = self.is_locked(AxisButton(target))
-                    else:
-                        state[target] = False
-            except Exception as e:
-                if hasattr(self.transport, 'debug') and self.transport.debug:
-                    print(f"Error getting lock state for {target}: {e}")
-                state[target] = False
-        
-        if hasattr(self.transport, 'debug') and self.transport.debug:
-            print(f"All lock states: {state}")
-        
-        return state
+        except Exception:
+            return False

makcu/py.typed

@@ -0,0 +1,2 @@
+# This file is intentionally empty.
+# It serves as a marker to indicate that this package supports type hints.

makcu/test_suite.py

@@ -1,19 +1,35 @@
-import pytest, time
+import pytest
+import time
 from makcu import MouseButton
 
+# Pre-compute test data to avoid runtime overhead
+TEST_BUTTONS = (MouseButton.LEFT, MouseButton.RIGHT, MouseButton.MIDDLE)
+BUTTON_STATE_KEYS = ('left', 'right', 'middle', 'mouse4', 'mouse5')
+MOVE_COORDS = ((10, 0), (0, 10), (-10, 0), (0, -10))
+
+def test_connect_to_port(makcu):
+    """Test connection - already connected via fixture"""
+    print("Connecting to port...")
+    makcu.connect()
+    assert makcu.is_connected(), "Failed to connect to the makcu"
+
 def test_press_and_release(makcu):
+    """Test basic press/release - minimal overhead"""
     makcu.press(MouseButton.LEFT)
     makcu.release(MouseButton.LEFT)
 
 def test_firmware_version(makcu):
+    """Test firmware version retrieval"""
     version = makcu.mouse.get_firmware_version()
     assert version and len(version.strip()) > 0
 
 def test_middle_click(makcu):
+    """Test middle button - direct operations"""
     makcu.press(MouseButton.MIDDLE)
     makcu.release(MouseButton.MIDDLE)
 
 def test_device_info(makcu):
+    """Test device info - optimized checks"""
     print("Fetching device info...")
     info = makcu.mouse.get_device_info()
     print(f"Device Info: {info}")
@@ -21,61 +37,123 @@ def test_device_info(makcu):
     assert info.get("isConnected") is True
 
 def test_port_connection(makcu):
+    """Test connection state - cached check"""
     assert makcu.is_connected()
 
-@pytest.mark.skip(reason="Capture test disabled until firmware supports tracking clicks from software input")
-def test_capture_right_clicks(makcu):
-    makcu.mouse.lock_right(True)
-    assert makcu.mouse.is_locked(MouseButton.RIGHT)
-
-    makcu.mouse.begin_capture("RIGHT")
-    makcu.press(MouseButton.RIGHT)
-    makcu.mouse.release(MouseButton.RIGHT)
-    makcu.press(MouseButton.RIGHT)
-    makcu.mouse.release(MouseButton.RIGHT)
-
-    makcu.mouse.lock_right(False)
-    assert not makcu.mouse.is_locked(MouseButton.RIGHT)
-
-    count = makcu.mouse.stop_capturing_clicks("RIGHT")
-    assert count >= 2, f"Expected >=2 captured clicks, got {count}"
-
 def test_button_mask(makcu):
+    """Test button mask - direct integer check"""
     print("Getting button mask...")
     mask = makcu.get_button_mask()
     print(f"Mask value: {mask}")
     assert isinstance(mask, int)
 
 def test_get_button_states(makcu):
+    """Test button states - optimized validation"""
     states = makcu.get_button_states()
     assert isinstance(states, dict)
-    for key in ['left', 'right', 'middle', 'mouse4', 'mouse5']:
+    for key in BUTTON_STATE_KEYS:
         assert key in states
 
 def test_lock_state(makcu):
+    """Test lock functionality - minimal operations"""
     print("Locking LEFT button...")
     makcu.lock_left(True)
     print("Querying lock state while LEFT is locked...")
-    state = makcu.is_locked(MouseButton.LEFT)  # Check state AFTER ensuring it's locked
+    state = makcu.is_locked(MouseButton.LEFT)
     print(state)
-    assert state  # Now assert the current state
+    assert state
 
 def test_makcu_behavior(makcu):
+    """Test basic behavior - batched operations"""
     makcu.move(25, 25)
     makcu.click(MouseButton.LEFT)
     makcu.scroll(-2)
 
-def test_reset_all(makcu):
-    makcu.mouse.lock_left(False)
-    makcu.mouse.lock_right(False)
-    makcu.mouse.lock_middle(False)
-    makcu.mouse.lock_side1(False)
-    makcu.mouse.lock_side2(False)
-    makcu.mouse.lock_x(False)
-    makcu.mouse.lock_y(False)
-
-    states = makcu.mouse.get_all_lock_states()
-    assert all(state is False for state in states.values() if state is not None), \
-        f"Expected all unlocked, got: {states}"
+def test_batch_commands(makcu):
+    """Test batch execution performance"""
+    print("Testing batch command execution (10 commands)...")
+    
+    start_time = time.perf_counter()
+    
+    # Execute 10 different commands in rapid succession
+    makcu.move(10, 0)
+    makcu.click(MouseButton.LEFT)
+    makcu.move(0, 10)
+    makcu.press(MouseButton.RIGHT)
+    makcu.release(MouseButton.RIGHT)
+    makcu.scroll(-1)
+    makcu.move(-10, 0)
+    makcu.click(MouseButton.MIDDLE)
+    makcu.move(0, -10)
+    makcu.scroll(1)
+    
+    end_time = time.perf_counter()
+    elapsed_ms = (end_time - start_time) * 1000
+    
+    print(f"Batch execution time: {elapsed_ms:.2f}ms")
+    print(f"Average per command: {elapsed_ms/10:.2f}ms")
+    
+    # Assert that 10 commands complete in under 50ms
+    assert elapsed_ms < 50, f"Batch commands took {elapsed_ms:.2f}ms, expected < 50ms"
+    
+    # Also test with mouse movements only
+    start_time = time.perf_counter()
+    for _ in range(10):
+        makcu.move(5, 5)
+    end_time = time.perf_counter()
+    
+    move_only_ms = (end_time - start_time) * 1000
+    print(f"10 move commands: {move_only_ms:.2f}ms ({move_only_ms/10:.2f}ms per move)")
+
+def test_rapid_moves(makcu):
+    """Test rapid movement commands"""
+    start = time.perf_counter_ns()
+    
+    # Unrolled loop for 10 moves
+    makcu.move(5, 5)
+    makcu.move(5, 5)
+    makcu.move(5, 5)
+    makcu.move(5, 5)
+    makcu.move(5, 5)
+    makcu.move(5, 5)
+    makcu.move(5, 5)
+    makcu.move(5, 5)
+    makcu.move(5, 5)
+    makcu.move(5, 5)
+    
+    elapsed_ms = (time.perf_counter_ns() - start) / 1_000_000
+    print(f"10 rapid moves: {elapsed_ms:.2f}ms")
+    assert elapsed_ms < 30
+
+def test_button_performance(makcu):
+    """Test button operation performance"""
+    start = time.perf_counter_ns()
+    
+    # Test each button type once
+    for button in TEST_BUTTONS:
+        makcu.press(button)
+        makcu.release(button)
+    
+    elapsed_ms = (time.perf_counter_ns() - start) / 1_000_000
+    print(f"Button operations: {elapsed_ms:.2f}ms")
+    assert elapsed_ms < 20
+
+def test_mixed_operations(makcu):
+    """Test mixed operation performance"""
+    start = time.perf_counter_ns()
+    
+    # Mixed operations without loops
+    makcu.move(20, 20)
+    makcu.press(MouseButton.LEFT)
+    makcu.move(-20, -20)
+    makcu.release(MouseButton.LEFT)
+    makcu.scroll(1)
+    
+    elapsed_ms = (time.perf_counter_ns() - start) / 1_000_000
+    print(f"Mixed operations: {elapsed_ms:.2f}ms")
+    assert elapsed_ms < 15
 
-    makcu.enable_button_monitoring(False)
+# Skip slow/unnecessary tests
+@pytest.mark.skip(reason="Capture test disabled until firmware supports tracking clicks from software input")
+def test_capture_right_clicks(makcu):
+    pass