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

makcu/controller.py

@@ -9,9 +9,8 @@ from .errors import MakcuConnectionError
 from .enums import MouseButton
 
 class MakcuController:
-    """Ultra-optimized MakcuController for gaming performance"""
     
-    # Pre-computed lock mappings for O(1) access
+
     _BUTTON_LOCK_MAP = {
         MouseButton.LEFT: 'lock_left',
         MouseButton.RIGHT: 'lock_right',
@@ -34,93 +33,80 @@ class MakcuController:
         self._executor = ThreadPoolExecutor(max_workers=1)
         self._connection_callbacks: List[Callable[[bool], None]] = []
         
-        # Cache connection state to avoid repeated checks
+
         self._connected = False
 
-    # Connection management
+
     def connect(self) -> None:
-        """Connect with state caching"""
         self.transport.connect()
         self._connected = True
         self._notify_connection_change(True)
 
     def disconnect(self) -> None:
-        """Disconnect with cleanup"""
         self.transport.disconnect()
         self._connected = False
         self._notify_connection_change(False)
         self._executor.shutdown(wait=False)
 
     def is_connected(self) -> bool:
-        """Fast cached connection check"""
         return self._connected and self.transport.is_connected()
 
     def _check_connection(self) -> None:
-        """Inline connection check for speed"""
         if not self._connected:
             raise MakcuConnectionError("Not connected")
 
     def _notify_connection_change(self, connected: bool) -> None:
-        """Notify callbacks with error suppression"""
         for callback in self._connection_callbacks:
             try:
                 callback(connected)
             except Exception:
-                pass  # Silently ignore for performance
+                pass
+
 
-    # Optimized mouse operations
     def click(self, button: MouseButton) -> None:
-        """Optimized click - direct command"""
         if not self._connected:
             raise MakcuConnectionError("Not connected")
         self.mouse.press(button)
         self.mouse.release(button)
 
     def double_click(self, button: MouseButton) -> None:
-        """Double click with minimal delay"""
         if not self._connected:
             raise MakcuConnectionError("Not connected")
         self.mouse.press(button)
         self.mouse.release(button)
-        # 1ms delay for double click recognition
+
         time.sleep(0.001)
         self.mouse.press(button)
         self.mouse.release(button)
 
     def move(self, dx: int, dy: int) -> None:
-        """Direct move"""
         if not self._connected:
             raise MakcuConnectionError("Not connected")
         self.mouse.move(dx, dy)
 
     def scroll(self, delta: int) -> None:
-        """Direct scroll"""
         if not self._connected:
             raise MakcuConnectionError("Not connected")
         self.mouse.scroll(delta)
 
     def press(self, button: MouseButton) -> None:
-        """Direct press"""
         if not self._connected:
             raise MakcuConnectionError("Not connected")
         self.mouse.press(button)
 
     def release(self, button: MouseButton) -> None:
-        """Direct release"""
         if not self._connected:
             raise MakcuConnectionError("Not connected")
         self.mouse.release(button)
 
-    # Advanced movement - unchanged but with connection check optimization
+
     def move_smooth(self, dx: int, dy: int, segments: int = 10) -> None:
-        """Smooth movement"""
         if not self._connected:
             raise MakcuConnectionError("Not connected")
         self.mouse.move_smooth(dx, dy, segments)
 
     def move_bezier(self, dx: int, dy: int, segments: int = 20,
                     ctrl_x: Optional[int] = None, ctrl_y: Optional[int] = None) -> None:
-        """Bezier curve movement"""
         if not self._connected:
             raise MakcuConnectionError("Not connected")
         if ctrl_x is None:
@@ -129,9 +115,8 @@ class MakcuController:
             ctrl_y = dy // 2
         self.mouse.move_bezier(dx, dy, segments, ctrl_x, ctrl_y)
 
-    # Optimized lock API
+
     def lock(self, target: Union[MouseButton, str]) -> None:
-        """Lock with fast lookup"""
         if not self._connected:
             raise MakcuConnectionError("Not connected")
             
@@ -149,7 +134,6 @@ class MakcuController:
             raise ValueError(f"Invalid lock target: {target}")
 
     def unlock(self, target: Union[MouseButton, str]) -> None:
-        """Unlock with fast lookup"""
         if not self._connected:
             raise MakcuConnectionError("Not connected")
             
@@ -166,7 +150,7 @@ class MakcuController:
         else:
             raise ValueError(f"Invalid unlock target: {target}")
 
-    # Direct lock methods for backward compatibility
+
     def lock_left(self, lock: bool) -> None:
         if not self._connected:
             raise MakcuConnectionError("Not connected")
@@ -203,105 +187,89 @@ class MakcuController:
         self.mouse.lock_y(lock)
 
     def lock_mouse_x(self, lock: bool) -> None:
-        """Alias for lock_x"""
         self.lock_x(lock)
 
     def lock_mouse_y(self, lock: bool) -> None:
-        """Alias for lock_y"""
         self.lock_y(lock)
 
     def is_locked(self, button: MouseButton) -> bool:
-        """Check lock state"""
         if not self._connected:
             raise MakcuConnectionError("Not connected")
         return self.mouse.is_locked(button)
 
     def get_all_lock_states(self) -> Dict[str, bool]:
-        """Get all lock states"""
         if not self._connected:
             raise MakcuConnectionError("Not connected")
         return self.mouse.get_all_lock_states()
 
-    # Device operations
+
     def spoof_serial(self, serial: str) -> None:
-        """Spoof device serial"""
         if not self._connected:
             raise MakcuConnectionError("Not connected")
         self.mouse.spoof_serial(serial)
 
     def reset_serial(self) -> None:
-        """Reset device serial"""
         if not self._connected:
             raise MakcuConnectionError("Not connected")
         self.mouse.reset_serial()
 
     def get_device_info(self) -> Dict[str, str]:
-        """Get device information"""
         if not self._connected:
             raise MakcuConnectionError("Not connected")
         return self.mouse.get_device_info()
 
     def get_firmware_version(self) -> str:
-        """Get firmware version"""
         if not self._connected:
             raise MakcuConnectionError("Not connected")
         return self.mouse.get_firmware_version()
 
-    # Button monitoring - direct transport access for speed
+
     def get_button_mask(self) -> int:
-        """Get current button mask"""
         if not self._connected:
             raise MakcuConnectionError("Not connected")
         return self.transport.get_button_mask()
 
     def get_button_states(self) -> Dict[str, bool]:
-        """Get current button states"""
         if not self._connected:
             raise MakcuConnectionError("Not connected")
         return self.transport.get_button_states()
 
     def is_pressed(self, button: MouseButton) -> bool:
-        """Check if button is pressed"""
         if not self._connected:
             raise MakcuConnectionError("Not connected")
         return self.transport.get_button_states().get(button.name.lower(), False)
 
     def enable_button_monitoring(self, enable: bool = True) -> None:
-        """Enable/disable button monitoring"""
         if not self._connected:
             raise MakcuConnectionError("Not connected")
         self.transport.enable_button_monitoring(enable)
 
     def set_button_callback(self, callback: Optional[Callable[[MouseButton, bool], None]]) -> None:
-        """Set button event callback"""
         if not self._connected:
             raise MakcuConnectionError("Not connected")
         self.transport.set_button_callback(callback)
 
-    # Connection management
+
     def on_connection_change(self, callback: Callable[[bool], None]) -> None:
-        """Register connection status change callback"""
         self._connection_callbacks.append(callback)
 
     def remove_connection_callback(self, callback: Callable[[bool], None]) -> None:
-        """Remove connection status callback"""
         if callback in self._connection_callbacks:
             self._connection_callbacks.remove(callback)
 
-    # Human-like interactions with optimized timing
+
     def click_human_like(self, button: MouseButton, count: int = 1,
                         profile: str = "normal", jitter: int = 0) -> None:
-        """Human-like clicking optimized for gaming"""
         if not self._connected:
             raise MakcuConnectionError("Not connected")
 
-        # Pre-computed timing profiles (in milliseconds)
+
         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),  # New gaming profile
+            "gaming": (20, 40, 30, 60),
         }
 
         if profile not in timing_profiles:
@@ -324,78 +292,67 @@ class MakcuController:
 
     def drag(self, start_x: int, start_y: int, end_x: int, end_y: int,
              button: MouseButton = MouseButton.LEFT, duration: float = 1.0) -> None:
-        """Optimized drag operation"""
         if not self._connected:
             raise MakcuConnectionError("Not connected")
         
-        # Move to start
+
         self.move(start_x, start_y)
-        time.sleep(0.02)  # Reduced from 0.05
+        time.sleep(0.02)
         
-        # Press button
+
         self.press(button)
-        time.sleep(0.02)  # Reduced from 0.05
+        time.sleep(0.02)
         
-        # Move to end with smooth motion
+
         segments = max(10, int(duration * 30))
         self.move_smooth(end_x - start_x, end_y - start_y, segments)
         
-        # Release button
-        time.sleep(0.02)  # Reduced from 0.05
+
+        time.sleep(0.02)
         self.release(button)
 
-    # Context manager support
+
     def __enter__(self):
-        """Context manager entry"""
         if not self.is_connected():
             self.connect()
         return self
 
     def __exit__(self, exc_type, exc_val, exc_tb):
-        """Context manager exit"""
         self.disconnect()
 
-    # Async methods for forward compatibility
+
     async def async_connect(self) -> None:
-        """Async connect"""
         loop = asyncio.get_running_loop()
         await loop.run_in_executor(self._executor, self.connect)
 
     async def async_disconnect(self) -> None:
-        """Async disconnect"""
         loop = asyncio.get_running_loop()
         await loop.run_in_executor(self._executor, self.disconnect)
 
     async def async_click(self, button: MouseButton) -> None:
-        """Async click"""
         loop = asyncio.get_running_loop()
         await loop.run_in_executor(self._executor, self.click, button)
 
     async def async_move(self, dx: int, dy: int) -> None:
-        """Async move"""
         loop = asyncio.get_running_loop()
         await loop.run_in_executor(self._executor, self.move, dx, dy)
 
     async def async_scroll(self, delta: int) -> None:
-        """Async scroll"""
         loop = asyncio.get_running_loop()
         await loop.run_in_executor(self._executor, self.scroll, delta)
 
-    # Async context manager
+
     async def __aenter__(self):
-        """Async context manager entry"""
         await self.async_connect()
         return self
 
     async def __aexit__(self, exc_type, exc_val, exc_tb):
-        """Async context manager exit"""
         await self.async_disconnect()
 
 
-# Factory functions with connection optimization
+
 def create_controller(fallback_com_port: str = "", debug: bool = False, 
                      send_init: bool = True, auto_reconnect: bool = True) -> MakcuController:
-    """Create and connect a controller"""
     makcu = MakcuController(
         fallback_com_port, 
         debug=debug, 
@@ -409,7 +366,6 @@ def create_controller(fallback_com_port: str = "", debug: bool = False,
 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,

makcu/errors.py

@@ -1,19 +1,14 @@
 class MakcuError(Exception):
-    """Base exception for all Makcu-related errors."""
     pass
 
 class MakcuConnectionError(MakcuError):
-    """Raised when the device connection fails."""
     pass
 
 class MakcuCommandError(MakcuError):
-    """Raised when a device command is invalid, rejected, or fails."""
     pass
 
 class MakcuTimeoutError(MakcuError):
-    """Raised when the device does not respond in time."""
     pass
 
 class MakcuResponseError(MakcuError):
-    """Raised when the response from the device is malformed or unexpected."""
     pass

makcu/mouse.py

@@ -5,15 +5,14 @@ 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:
-    """Ultra-optimized mouse control for gaming performance"""
     
-    # Pre-computed command strings for faster access
+
     _BUTTON_COMMANDS = {
         MouseButton.LEFT: "left",
         MouseButton.RIGHT: "right",
@@ -22,7 +21,7 @@ class Mouse:
         MouseButton.MOUSE5: "ms2",
     }
     
-    # Pre-formatted commands cache
+
     _PRESS_COMMANDS = {}
     _RELEASE_COMMANDS = {}
     _LOCK_COMMANDS = {}
@@ -31,21 +30,20 @@ class Mouse:
     
     def __init__(self, transport: SerialTransport) -> None:
         self.transport = transport
-        self._lock_states_cache: int = 0  # Bitwise cache
+        self._lock_states_cache: int = 0
         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),
@@ -62,55 +60,46 @@ class Mouse:
             self._LOCK_QUERY_COMMANDS[name] = (f"km.lock_{cmd}()", bit)
 
     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}")
         
-        # 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) -> None:
-        """Press with pre-computed command"""
         self.transport.send_command(self._PRESS_COMMANDS[button])
 
     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) -> None:
-        """Move command"""
         self.transport.send_command(f"km.move({x},{y})")
 
     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 = self.transport
         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) -> None:
-        """Bezier movement"""
         self.transport.send_command(f"km.move({x},{y},{segments},{ctrl_x},{ctrl_y})")
 
     def scroll(self, delta: int) -> None:
-        """Scroll command"""
         self.transport.send_command(f"km.wheel({delta})")
 
-    # 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:
@@ -118,7 +107,7 @@ class Mouse:
         
         self.transport.send_command(cmd)
         
-        # Update cache
+
         if lock:
             self._lock_states_cache |= (1 << bit)
         else:
@@ -147,15 +136,12 @@ class Mouse:
         self._set_lock("Y", lock)
 
     def spoof_serial(self, serial: str) -> None:
-        """Set custom serial"""
         self.transport.send_command(f"km.serial('{serial}')")
 
     def reset_serial(self) -> None:
-        """Reset serial"""
         self.transport.send_command("km.serial(0)")
 
     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()
         
@@ -184,24 +170,21 @@ class Mouse:
                         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
+                    break
         except Exception:
             pass
         
         return info
 
     def get_firmware_version(self) -> str:
-        """Get firmware version"""
         response = self.transport.send_command("km.version()", expect_response=True, timeout=0.1)
         return response or ""
 
     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)),
@@ -213,7 +196,7 @@ class Mouse:
                 "MOUSE5": bool(self._lock_states_cache & (1 << 4)),
             }
         
-        # Query all states in rapid succession
+
         states = {}
         targets = ["X", "Y", "LEFT", "RIGHT", "MIDDLE", "MOUSE4", "MOUSE5"]
         
@@ -225,7 +208,7 @@ class Mouse:
                     is_locked = result.strip() == '1'
                     states[target] = is_locked
                     
-                    # Update cache
+
                     if is_locked:
                         self._lock_states_cache |= (1 << bit)
                     else:
@@ -239,16 +222,15 @@ class Mouse:
         return states
 
     def is_locked(self, button: Union[MouseButton, AxisButton]) -> bool:
-        """Check lock state with cache"""
         try:
             target_name = button.name if hasattr(button, 'name') else str(button)
             
-            # 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))
             
-            # Query device
+
             cmd, bit = self._LOCK_QUERY_COMMANDS[target_name]
             result = self.transport.send_command(cmd, expect_response=True, timeout=0.05)
             
@@ -258,7 +240,7 @@ class Mouse:
             result = result.strip()
             is_locked = result == '1'
             
-            # Update cache
+
             if is_locked:
                 self._lock_states_cache |= (1 << bit)
             else: