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

makcu/mouse.py

@@ -1,167 +1,252 @@
+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
 
+
+class AxisButton:
+    def __init__(self, name: str) -> None:
+        self.name = name
+
 class Mouse:
-    def __init__(self, transport):
+    
+
+    _BUTTON_COMMANDS = {
+        MouseButton.LEFT: "left",
+        MouseButton.RIGHT: "right",
+        MouseButton.MIDDLE: "middle",
+        MouseButton.MOUSE4: "ms1",
+        MouseButton.MOUSE5: "ms2",
+    }
+    
+
+    _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
+        self._cache_valid = False
+        
 
-    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:
+        self._init_command_cache()
+    
+    def _init_command_cache(self) -> None:
+
+        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_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) -> None:
+        if button not in self._BUTTON_COMMANDS:
             raise MakcuCommandError(f"Unsupported button: {button}")
-        self.transport.send_command(f"km.{command_map[button]}({state})")
+        
+
+        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:
+        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:
+        self.transport.send_command(self._RELEASE_COMMANDS[button])
 
-    def move(self, x: int, y: int):
+    def move(self, x: int, y: int) -> None:
         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:
+        if button not in self._BUTTON_COMMANDS:
+            raise MakcuCommandError(f"Unsupported button: {button}")
+        
+
+        press_cmd = self._PRESS_COMMANDS[button]
+        release_cmd = self._RELEASE_COMMANDS[button]
+        
+
+        transport = self.transport
+        transport.send_command(press_cmd)
+        transport.send_command(release_cmd)
+
+    def move_smooth(self, x: int, y: int, segments: int) -> None:
         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:
         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:
         self.transport.send_command(f"km.wheel({delta})")
 
-    def lock_left(self, lock: bool):
-        self.transport.send_command(f"km.lock_ml({int(lock)})")
+
+    def _set_lock(self, name: str, lock: bool) -> None:
+        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)
+        
+
+        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:
         self.transport.send_command(f"km.serial('{serial}')")
 
-    def reset_serial(self):
+    def reset_serial(self) -> None:
         self.transport.send_command("km.serial(0)")
 
-    def get_device_info(self) -> dict:
+    def get_device_info(self) -> Dict[str, Union[str, bool]]:
         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
+        except Exception:
+            pass
+        
         return info
 
     def get_firmware_version(self) -> str:
-        return self.transport.send_command("km.version()", expect_response=True)
+        response = self.transport.send_command("km.version()", expect_response=True, timeout=0.1)
+        return response or ""
+
+    def _invalidate_cache(self) -> None:
+        self._cache_valid = False
+
+    def get_all_lock_states(self) -> Dict[str, bool]:
+
+        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)),
+            }
+        
 
-    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]}()"
+        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
+                    
+
+                    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:
         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()
+
+            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'
+
+            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}'")
+
+            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,6 +1,17 @@
-import pytest, time
+import pytest
+import time
 from makcu import MouseButton
 
+
+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):
+    print("Connecting to port...")
+    makcu.connect()
+    assert makcu.is_connected(), "Failed to connect to the makcu"
+
 def test_press_and_release(makcu):
     makcu.press(MouseButton.LEFT)
     makcu.release(MouseButton.LEFT)
@@ -23,23 +34,6 @@ def test_device_info(makcu):
 def test_port_connection(makcu):
     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):
     print("Getting button mask...")
     mask = makcu.get_button_mask()
@@ -49,33 +43,103 @@ def test_button_mask(makcu):
 def test_get_button_states(makcu):
     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):
     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):
     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)
+def test_batch_commands(makcu):
+    print("Testing batch command execution (10 commands)...")
+    
+    start_time = time.perf_counter()
+    
+
+    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 elapsed_ms < 50, f"Batch commands took {elapsed_ms:.2f}ms, expected < 50ms"
+    
+
+    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):
+    start = time.perf_counter_ns()
+    
+
+    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):
+    start = time.perf_counter_ns()
+    
+
+    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):
+    start = time.perf_counter_ns()
+    
+
+    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
 
-    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}"
 
-    makcu.enable_button_monitoring(False)
+@pytest.mark.skip(reason="Capture test disabled until firmware supports tracking clicks from software input")
+def test_capture_right_clicks(makcu):
+    pass