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

makcu/__main__.py

@@ -33,7 +33,7 @@ def debug_console():
 def test_port(port):
     try:
         print(f"Trying to connect to {port} (without init command)...")
-        controller = create_controller(send_init=False)
+        controller = create_controller(fallback_com_port=port, send_init=False)
         print(f"✅ Successfully connected to {port}")
         controller.disconnect()
     except MakcuConnectionError as e:
@@ -47,14 +47,14 @@ def run_tests():
     package_dir = Path(__file__).resolve().parent
     test_file = package_dir / "test_suite.py"
 
-    sys.exit(pytest.main([
+    result = pytest.main([
         str(test_file),
         "--rootdir", str(package_dir),
         "-v", "--tb=short",
         "--capture=tee-sys",
         "--html=latest_pytest.html",
         "--self-contained-html"
-    ]))
+    ])
 
     report_path = os.path.abspath("latest_pytest.html")
     if os.path.exists(report_path):
@@ -63,11 +63,13 @@ def run_tests():
     else:
         print("❌ Report not found. Something went wrong.")
 
-    if result.returncode != 0:
+    if result != 0:
         print("❌ Some tests failed.")
     else:
         print("✅ All tests passed.")
 
+    sys.exit(result)
+    
 def main():
     args = sys.argv[1:]
 

makcu/connection.py

@@ -29,7 +29,12 @@ class SerialTransport:
         self._listener_thread = None
         self._button_states = {btn: False for btn in self.button_map.values()}
         self._last_callback_time = {bit: 0 for bit in self.button_map}
-        self._pause_listener = False
+        
+        self._response_buffer = ""
+        self._response_ready = threading.Event()
+        self._waiting_for_response = False
+        self._response_timeout = 0.01
+        self._command_lock = threading.Lock()
 
         self._button_enum_map = {
             0: MouseButton.LEFT,
@@ -47,28 +52,45 @@ class SerialTransport:
         self.serial = None
         self._current_baud = None
 
-
-    def receive_response(self, max_bytes=1024, max_lines=3, sent_command: str = "") -> str:
-        lines = []
+    def receive_response(self, sent_command: str = "") -> str:
         try:
-            for _ in range(max_lines):
-                line = self.serial.readline(max_bytes)
-                if not line:
-                    break
-                decoded = line.decode(errors="ignore").strip()
-                if decoded:
-                    lines.append(decoded)
+            if self._response_ready.wait(timeout=self._response_timeout):
+                response = self._response_buffer
+                self._response_buffer = ""
+                self._response_ready.clear()
+                
+                lines = response.strip().split('\n')
+                lines = [line.strip() for line in lines if line.strip()]
+                
+                command_clean = sent_command.strip()
+                cleaned_lines = []
+                
+                for line in lines:
+                    if not line:
+                        continue
+                    if line == command_clean:
+                        continue
+                    if line.startswith('>>> '):
+                        actual_response = line[4:].strip()
+                        if actual_response and actual_response != command_clean:
+                            cleaned_lines.append(actual_response)
+                        continue
+                    if line == command_clean:
+                        continue
+                    cleaned_lines.append(line)
+                
+                result = "\n".join(cleaned_lines)
+                if self.debug:
+                    self._log(f"Command: {command_clean} -> Response: '{result}'")
+                return result
+            else:
+                return ""
+                
         except Exception as e:
-            print(f"[RECV ERROR] {e}")
+            if self.debug:
+                self._log(f"Error in receive_response: {e}")
             return ""
 
-        command_clean = sent_command.strip()
-        if lines:
-            lines.pop(-1)
-        if command_clean in lines and len(lines) > 1:
-            lines.remove(command_clean)
-        return "\n".join(lines)
-
     def set_button_callback(self, callback):
         self._button_callback = callback
 
@@ -115,7 +137,6 @@ class SerialTransport:
             return True
         return False
 
-
     def connect(self):
         if self._is_connected:
             self._log("Already connected.")
@@ -153,37 +174,40 @@ class SerialTransport:
         return self._is_connected
 
     def send_command(self, command, expect_response=False):
-        time.sleep(0.06)
         if not self._is_connected or not self.serial or not self.serial.is_open:
             raise MakcuConnectionError("Serial connection not open.")
-        with self._lock:
+        
+        with self._command_lock:
             try:
-                self._pause_listener = True
-                self.serial.reset_input_buffer()
+                if expect_response:
+                    self._response_buffer = ""
+                    self._response_ready.clear()
+                    self._waiting_for_response = True
+                
                 self.serial.write(command.encode("ascii") + b"\r\n")
                 self.serial.flush()
+                
                 if expect_response:
                     response = self.receive_response(sent_command=command)
+                    self._waiting_for_response = False
                     if not response:
                         raise MakcuTimeoutError(f"No response from device for command: {command}")
                     return response
-            finally:
-                self._pause_listener = False
+                    
+            except Exception as e:
+                self._waiting_for_response = False
+                raise
 
     def get_button_states(self):
         return dict(self._button_states)
 
     def get_button_mask(self) -> int:
-        mask = 0
-        for i, name in self.button_map.items():
-            if self._button_states.get(name, False):
-                mask |= (1 << i)
-        return mask
+        return self._last_mask
 
     def enable_button_monitoring(self, enable: bool = True):
         self.send_command("km.buttons(1)" if enable else "km.buttons(0)")
 
-    def catch_button(self, button: str):
+    def catch_button(self, button: MouseButton):
         command = {
             "LEFT": "km.catch_ml(0)",
             "RIGHT": "km.catch_mr(0)",
@@ -196,76 +220,71 @@ class SerialTransport:
         else:
             raise ValueError(f"Unsupported button: {button}")
 
-    def read_captured_clicks(self, button: str) -> int:
-        command = {
-            "LEFT": "km.catch_ml()",
-            "RIGHT": "km.catch_mr()",
-            "MIDDLE": "km.catch_mm()",
-            "MOUSE4": "km.catch_ms1()",
-            "MOUSE5": "km.catch_ms2()",
-        }.get(button.upper())
-        if command:
-            result = self.send_command(command, expect_response=True)
-            try:
-                return int(result.strip())
-            except Exception:
-                return 0
-        else:
-            raise ValueError(f"Unsupported button: {button}")
+    def _is_button_data(self, byte_value):
+        return byte_value <= 0b11111 and byte_value not in [0x0D, 0x0A]
+
+    def _is_ascii_data(self, byte_value):
+        return 32 <= byte_value <= 126 or byte_value in [0x0D, 0x0A]  # Include CR/LF
 
     def _listen(self, debug=False):
         self._log("Started listener thread")
-        button_states = {i: False for i in self.button_map}
         self._last_mask = 0
-        self._last_callback_time = {bit: 0 for bit in self.button_map}
+        ascii_buffer = bytearray()
+        response_lines = []
 
         while self._is_connected and not self._stop_event.is_set():
-            if self._pause_listener:
-                time.sleep(0.001)
-                continue
-
             try:
-                byte = self.serial.read(1)
-                if byte:
-                    value = byte[0]
-
-                    if value != self._last_mask:
-                        byte_str = str(byte)
-
-                        if "b'\\x00" in byte_str:
-                            for bit in self.button_map:
-                                button_states[bit] = False
-
-                        elif "b'\\x" in byte_str:
-                            for bit, name in self.button_map.items():
-                                is_pressed = bool(value & (1 << bit))
-                                if is_pressed != button_states[bit]:
-                                    button_states[bit] = is_pressed
-
-                        for bit, name in self.button_map.items():
-                            self._button_states[name] = button_states[bit]
-
-                        if self._button_callback:
+                data = self.serial.read(self.serial.in_waiting or 1)
+                if not data:
+                    continue
+
+                for byte_val in data:
+                    if (self._is_button_data(byte_val) and 
+                                not self._waiting_for_response): 
+                        if byte_val != self._last_mask:
+                            changed_bits = byte_val ^ self._last_mask
                             for bit, name in self.button_map.items():
-                                previous = bool(self._last_mask & (1 << bit))
-                                current = bool(value & (1 << bit))
-                                if previous != current:
+                                if changed_bits & (1 << bit):
+                                    is_pressed = bool(byte_val & (1 << bit))
+                                    self._button_states[name] = is_pressed
                                     button_enum = self._button_enum_map.get(bit)
-                                    if button_enum:
-                                        self._button_callback(button_enum, current)
-
-                        self._last_mask = value
-
-                        if debug:
-                            pressed = [name for bit, name in self.button_map.items() if button_states[bit]]
-                            button_str = ", ".join(pressed) if pressed else "No buttons pressed"
-                            self._log(f"Byte: {value} (0x{value:02X}) -> {button_str}")
+                                    if button_enum and self._button_callback:
+                                        self._button_callback(button_enum, is_pressed)
+
+                            self._last_mask = byte_val
+
+                            if debug:
+                                pressed = [name for _, name in self.button_map.items() if self._button_states[name]]
+                                button_str = ", ".join(pressed) if pressed else "No buttons pressed"
+                                self._log(f"Mask: 0x{byte_val:02X} -> {button_str}")
+                    elif self._is_ascii_data(byte_val):
+                        if self._waiting_for_response:
+                            ascii_buffer.append(byte_val)                        
+                            if byte_val == 0x0A:
+                                try:
+                                    line = ascii_buffer.decode('ascii', errors='ignore').strip()
+                                    ascii_buffer.clear()
+                                    
+                                    if line:
+                                        response_lines.append(line)
+                                        
+                                        if (len(response_lines) >= 2 or 
+                                            (len(response_lines) == 1 and not line.startswith('>>> '))):
+                                            
+                                            full_response = '\n'.join(response_lines)
+                                            self._response_buffer = full_response
+                                            self._response_ready.set()
+                                            response_lines.clear()
+                                            
+                                except Exception as e:
+                                    self._log(f"Error decoding ASCII response: {e}")
+                                    ascii_buffer.clear()
+                                    response_lines.clear()
 
             except serial.SerialException as e:
                 if "ClearCommError failed" not in str(e):
                     self._log(f"Serial error during listening: {e}")
                     break
-
-            time.sleep(0.0001)
-
+            except Exception as e:
+                self._log(f"Unexpected error in listener: {e}")
         self._log("Listener thread exiting")

makcu/controller.py

@@ -72,6 +72,14 @@ class MakcuController:
         self._check_connection()
         self.mouse.lock_side2(lock)
 
+    def lock_x(self, lock: bool):
+        self._check_connection()
+        self.mouse.lock_x(lock)
+
+    def lock_y(self, lock: bool):
+        self._check_connection()
+        self.mouse.lock_y(lock)
+
     def spoof_serial(self, serial: str):
         self._check_connection()
         self.mouse.spoof_serial(serial)
@@ -92,33 +100,24 @@ class MakcuController:
         self._check_connection()
         return self.transport.get_button_mask()
 
-    def is_button_locked(self, button: MouseButton) -> bool:
-        self._check_connection()
-        return self.mouse.is_button_locked(button)
-
-    def capture(self, button: MouseButton):
+    def is_locked(self, button: MouseButton) -> bool:
         self._check_connection()
-        self.mouse.begin_capture(button.name)
-
-    def get_captured_clicks(self, button: MouseButton) -> int:
-        self._check_connection()
-        return self.mouse.stop_capturing_clicks(button.name)
-
+        return self.mouse.is_locked(button)
 
     def click_human_like(self, button: MouseButton, count: int = 1,
         profile: str = "normal", jitter: int = 0):
         self._check_connection()
 
         timing_profiles = {
-            "normal": {"min_down": 60,  "max_down": 120, "min_wait": 100, "max_wait": 180},
-            "fast":   {"min_down": 30,  "max_down": 60,  "min_wait": 50,  "max_wait": 100},
-            "slow":   {"min_down": 100, "max_down": 180, "min_wait": 150, "max_wait": 300},
+            "normal": (60, 120, 100, 180),
+            "fast": (30, 60, 50, 100),
+            "slow": (100, 180, 150, 300),
         }
 
         if profile not in timing_profiles:
             raise ValueError(f"Invalid profile: {profile}. Choose from {list(timing_profiles.keys())}")
 
-        t = timing_profiles[profile]
+        min_down, max_down, min_wait, max_wait = timing_profiles[profile]
 
         for _ in range(count):
             if jitter > 0:
@@ -127,10 +126,10 @@ class MakcuController:
                 self.mouse.move(dx, dy)
 
             self.mouse.press(button)
-            time.sleep(random.uniform(t["min_down"], t["max_down"]) / 1000.0)
+            time.sleep(random.uniform(min_down, max_down) / 1000.0)
             self.mouse.release(button)
-            time.sleep(random.uniform(t["min_wait"], t["max_wait"]) / 1000.0)
-    
+            time.sleep(random.uniform(min_wait, max_wait) / 1000.0)
+
     def enable_button_monitoring(self, enable: bool = True):
         self._check_connection()
         self.transport.enable_button_monitoring(enable)
@@ -143,10 +142,6 @@ class MakcuController:
         self._check_connection()
         return self.mouse.get_all_lock_states()
 
-    def stop_capturing_clicks(self, button: str) -> int:
-        self._check_connection()
-        return self.mouse.stop_capturing_clicks(button)
-
     def press(self, button: MouseButton):
         self._check_connection()
         self.mouse.press(button)
@@ -154,11 +149,11 @@ class MakcuController:
     def release(self, button: MouseButton):
         self._check_connection()
         self.mouse.release(button)
-        
+
     def get_button_states(self) -> dict:
         self._check_connection()
         return self.transport.get_button_states()
 
-    def is_button_pressed(self, button: MouseButton) -> bool:
+    def is_pressed(self, button: MouseButton) -> bool:
         self._check_connection()
         return self.transport.get_button_states().get(button.name.lower(), False)

makcu/mouse.py

@@ -1,32 +1,29 @@
 from .enums import MouseButton
 from .errors import MakcuCommandError
 from serial.tools import list_ports
+import time
 
 class Mouse:
     def __init__(self, transport):
         self.transport = transport
 
+    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:
+            raise MakcuCommandError(f"Unsupported button: {button}")
+        self.transport.send_command(f"km.{command_map[button]}({state})")
+
     def press(self, button: MouseButton):
-        cmd = {
-            MouseButton.LEFT: "km.left(1)",
-            MouseButton.RIGHT: "km.right(1)",
-            MouseButton.MIDDLE: "km.middle(1)"
-        }.get(button)
-        if cmd:
-            self.transport.send_command(cmd)
-        else:
-            raise MakcuCommandError(f"Unsupported button for press(): {button}")
+        self._send_button_command(button, 1)
 
     def release(self, button: MouseButton):
-        cmd = {
-            MouseButton.LEFT: "km.left(0)",
-            MouseButton.RIGHT: "km.right(0)",
-            MouseButton.MIDDLE: "km.middle(0)"
-        }.get(button)
-        if cmd:
-            self.transport.send_command(cmd)
-        else:
-            raise MakcuCommandError(f"Unsupported button for release(): {button}")
+        self._send_button_command(button, 0)
 
     def move(self, x: int, y: int):
         self.transport.send_command(f"km.move({x},{y})")
@@ -40,16 +37,33 @@ class Mouse:
     def scroll(self, delta: int):
         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 lock_middle(self, lock: bool): self.transport.send_command(f"km.lock_mm({int(lock)})")
-    def lock_right(self, lock: bool): self.transport.send_command(f"km.lock_mr({int(lock)})")
-    def lock_side1(self, lock: bool): self.transport.send_command(f"km.lock_ms1({int(lock)})")
-    def lock_side2(self, lock: bool): self.transport.send_command(f"km.lock_ms2({int(lock)})")
-    def lock_x(self, lock: bool): self.transport.send_command(f"km.lock_mx({int(lock)})")
-    def lock_y(self, lock: bool): self.transport.send_command(f"km.lock_my({int(lock)})")
+    def lock_left(self, lock: bool):
+        self.transport.send_command(f"km.lock_ml({int(lock)})")
+        
+    def lock_middle(self, lock: bool):
+        self.transport.send_command(f"km.lock_mm({int(lock)})")
+
+    def lock_right(self, lock: bool):
+        self.transport.send_command(f"km.lock_mr({int(lock)})")
+
+    def lock_side1(self, lock: bool):
+        self.transport.send_command(f"km.lock_ms1({int(lock)})")
+
+    def lock_side2(self, lock: bool):
+        self.transport.send_command(f"km.lock_ms2({int(lock)})")
+
+    def lock_x(self, lock: bool):
+        self.transport.send_command(f"km.lock_mx({int(lock)})")
+
+    def lock_y(self, lock: bool):
+        self.transport.send_command(f"km.lock_my({int(lock)})")
 
-    def spoof_serial(self, serial: str): self.transport.send_command(f"km.serial('{serial}')")
-    def reset_serial(self): self.transport.send_command("km.serial(0)")
+
+    def spoof_serial(self, serial: str):
+        self.transport.send_command(f"km.serial('{serial}')")
+
+    def reset_serial(self):
+        self.transport.send_command("km.serial(0)")
 
     def get_device_info(self) -> dict:
         port_name = self.transport.port
@@ -74,51 +88,80 @@ class Mouse:
     def get_firmware_version(self) -> str:
         return self.transport.send_command("km.version()", expect_response=True)
 
-    def is_locked(self, target: str) -> bool:
-        target = target.upper()
-        commands = {
-            "X": "km.lock_mx()",
-            "Y": "km.lock_my()",
-            "LEFT": "km.lock_ml()",
-            "MIDDLE": "km.lock_mm()",
-            "RIGHT": "km.lock_mr()",
-            "MOUSE4": "km.lock_ms1()",
-            "MOUSE5": "km.lock_ms2()",
+    def _get_lock_command(self, target: str) -> str:
+        command_map = {
+            "X": "mx", "Y": "my",
+            "LEFT": "ml", "RIGHT": "mr", "MIDDLE": "mm",
+            "MOUSE4": "ms1", "MOUSE5": "ms2",
         }
-        if target not in commands:
+        key = target.upper()
+        if key not in command_map:
             raise ValueError(f"Unsupported lock target: {target}")
+        return f"km.lock_{command_map[key]}()"
+
+    def is_locked(self, button: MouseButton) -> bool:
         try:
-            result = self.transport.send_command(commands[target], expect_response=True)
-            return result.strip() == "1"
-        except Exception:
+            # 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}'")
+            
+            result = result.strip()
+            
+            if result in ['1', '0']:
+                return result == '1'
+            
+            lines = result.split('\n')
+            for line in lines:
+                line = line.strip()
+                if line in ['1', '0']:
+                    return line == '1'
+            
+            import re
+            numbers = re.findall(r'\b[01]\b', result)
+            if numbers:
+                return numbers[-1] == '1'
+            
+            if hasattr(self.transport, 'debug') and self.transport.debug:
+                print(f"Could not parse lock status from: '{result}'")
+            
+            return False
+            
+        except Exception as e:
+            if hasattr(self.transport, 'debug') and self.transport.debug:
+                print(f"Error checking lock status: {e}")
             return False
-
-    def is_button_locked(self, button: MouseButton) -> bool:
-        name_map = {
-            MouseButton.LEFT: "LEFT",
-            MouseButton.RIGHT: "RIGHT",
-            MouseButton.MIDDLE: "MIDDLE",
-            MouseButton.MOUSE4: "MOUSE4",
-            MouseButton.MOUSE5: "MOUSE5"
-        }
-        return self.is_locked(name_map[button])
-
-    def begin_capture(self, button: str):
-        """
-        Assumes lock_<button>(1) has already been called.
-        Sends catch_<button>(0) to begin capturing click cycles.
-        """
-        self.transport.catch_button(button)
-
-    def stop_capturing_clicks(self, button: str) -> int:
-        """
-        Assumes lock_<button>(0) has already been called.
-        Returns the total number of clicks since begin_capture.
-        """
-        return self.transport.read_captured_clicks(button)
 
     def get_all_lock_states(self) -> dict:
-        return {
-            target: self.is_locked(target)
-            for target in ["X", "Y", "LEFT", "RIGHT", "MIDDLE", "MOUSE4", "MOUSE5"]
-        }
+        """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

makcu/test_suite.py

@@ -1,22 +1,17 @@
-import pytest
+import pytest, time
 from makcu import MouseButton
 
-def test_is_button_pressed(makcu):
-    assert makcu.is_button_pressed(MouseButton.LEFT) in [True, False]
-
 def test_press_and_release(makcu):
     makcu.press(MouseButton.LEFT)
     makcu.release(MouseButton.LEFT)
 
 def test_firmware_version(makcu):
-    print("Getting firmware version...")
     version = makcu.mouse.get_firmware_version()
-    print(f"Firmware version: {version}")
     assert version and len(version.strip()) > 0
 
 def test_middle_click(makcu):
-    makcu.mouse.press(MouseButton.MIDDLE)
-    makcu.mouse.release(MouseButton.MIDDLE)
+    makcu.press(MouseButton.MIDDLE)
+    makcu.release(MouseButton.MIDDLE)
 
 def test_device_info(makcu):
     print("Fetching device info...")
@@ -31,16 +26,16 @@ def test_port_connection(makcu):
 @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_button_locked(MouseButton.RIGHT)
+    assert makcu.mouse.is_locked(MouseButton.RIGHT)
 
     makcu.mouse.begin_capture("RIGHT")
-    makcu.mouse.press(MouseButton.RIGHT)
+    makcu.press(MouseButton.RIGHT)
     makcu.mouse.release(MouseButton.RIGHT)
-    makcu.mouse.press(MouseButton.RIGHT)
+    makcu.press(MouseButton.RIGHT)
     makcu.mouse.release(MouseButton.RIGHT)
 
     makcu.mouse.lock_right(False)
-    assert not makcu.mouse.is_button_locked(MouseButton.RIGHT)
+    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}"
@@ -60,22 +55,10 @@ def test_get_button_states(makcu):
 def test_lock_state(makcu):
     print("Locking LEFT button...")
     makcu.lock_left(True)
-
     print("Querying lock state while LEFT is locked...")
-    assert makcu.is_button_locked(MouseButton.LEFT)
-
-    print("Querying all lock states...")
-    all_states = makcu.get_all_lock_states()
-    print(f"All lock states: {all_states}")
-
-    assert all_states["LEFT"] is True
-    assert isinstance(all_states["RIGHT"], bool)
-
-    print("Unlocking LEFT button...")
-    makcu.lock_left(False)
-
-    print("Rechecking LEFT lock state after unlock...")
-    assert not makcu.is_button_locked(MouseButton.LEFT)
+    state = makcu.is_locked(MouseButton.LEFT)  # Check state AFTER ensuring it's locked
+    print(state)
+    assert state  # Now assert the current state
 
 def test_makcu_behavior(makcu):
     makcu.move(25, 25)

{makcu-0.1.2.dist-info → makcu-0.1.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: makcu
-Version: 0.1.2
+Version: 0.1.4
 Summary: Python library to interact with Makcu devices.
 Author: SleepyTotem
 License: GPL
@@ -50,14 +50,6 @@ python -m makcu [command]
 | `--testPort COM3` | Tests a specific COM port for connectivity |
 | `--runtest` | Runs all automated tests and opens a test report |
 
-### Examples
-
-```bash
-python -m makcu --debug
-python -m makcu --testPort COM3
-python -m makcu --runtest
-```
-
 ---
 
 ## 🧠 Quickstart (Python)
@@ -65,7 +57,7 @@ python -m makcu --runtest
 ```python
 from makcu import create_controller, MouseButton
 
-makcu = create_controller("COM1") # Fallback port
+makcu = create_controller("COM1")
 makcu.click(MouseButton.LEFT)
 makcu.move(100, 50)
 makcu.scroll(-1)
@@ -79,20 +71,14 @@ makcu.disconnect()
 ### 🔧 Initialization
 
 ```python
-makcu = create_controller(debug=True, send_init=True)
-```
-
-#### Set fallback port manually
-
-```python
-makcu = create_controller("COM4")  # Optional fallback com port
+makcu = create_controller(fallback_com_port="COM1", debug=True, send_init=True)
 ```
 
 ---
 
 ### 🎮 Mouse Control
 
-#### Clicks
+#### Button Actions
 
 ```python
 makcu.click(MouseButton.LEFT)
@@ -103,21 +89,21 @@ makcu.release(MouseButton.RIGHT)
 #### Movement
 
 ```python
-makcu.move(dx=30, dy=20)
+makcu.move(30, 20)
 makcu.move_smooth(100, 40, segments=10)
 makcu.move_bezier(50, 50, 15, ctrl_x=25, ctrl_y=25)
 ```
 
-#### Scrolling
+#### Scroll Wheel
 
 ```python
-makcu.scroll(-3)  # Scroll down
-makcu.scroll(3)   # Scroll up
+makcu.scroll(-3)
+makcu.scroll(3)
 ```
 
 ---
 
-### 🔒 Locking and Unlocking
+### 🔒 Locking
 
 ```python
 makcu.lock_left(True)
@@ -129,10 +115,10 @@ makcu.lock_mouse_x(True)
 makcu.lock_mouse_y(False)
 ```
 
-#### Lock Status
+#### Lock State Query
 
 ```python
-makcu.is_button_locked(MouseButton.LEFT)
+makcu.is_locked(MouseButton.LEFT)
 makcu.get_all_lock_states()
 ```
 
@@ -144,7 +130,7 @@ makcu.get_all_lock_states()
 makcu.click_human_like(
     button=MouseButton.LEFT,
     count=5,
-    profile="normal",  # "fast", "slow" also available
+    profile="normal",  # or "fast", "slow"
     jitter=3
 )
 ```
@@ -155,10 +141,7 @@ makcu.click_human_like(
 
 ```python
 info = makcu.get_device_info()
-print(info)
-
 version = makcu.get_firmware_version()
-print(version)
 ```
 
 ---
@@ -172,15 +155,15 @@ makcu.reset_serial()
 
 ---
 
-## 🧪 Button Monitoring & Capture
+## 🧪 Button Monitoring
 
-### Enable Real-time Monitoring
+### Enable Monitoring
 
 ```python
 makcu.enable_button_monitoring(True)
 ```
 
-### Set Callback Function
+### Set Event Callback
 
 ```python
 def on_button_event(button, pressed):
@@ -191,66 +174,46 @@ makcu.set_button_callback(on_button_event)
 
 ---
 
-## ❌ Click Capturing (Pending Firmware Update)
-
-Click capturing will allow you to detect and count click events in software.
+## ❌ Click Capturing (Pending Firmware Fix)
 
 ```python
 makcu.mouse.lock_right(True)
-makcu.capture(MouseButton.RIGHT)
+makcu.mouse.begin_capture("RIGHT")
 
-# User clicks however many times
+# Simulated user input...
 
 makcu.mouse.lock_right(False)
-count = makcu.get_captured_clicks(MouseButton.RIGHT)
+count = makcu.mouse.stop_capturing_clicks("RIGHT")
 print(f"Captured clicks: {count}")
 ```
 
-> ⚠️ This feature is currently broken in firmware. Do not rely on it yet.
+> ⚠️ Not fully supported yet — firmware must be updated to complete this feature.
 
 ---
 
 ## 🔢 Bitmask & Button States
 
-### Get Bitmask of Active Buttons
-
 ```python
 mask = makcu.get_button_mask()
-print(f"Button mask: {mask}")
-```
-
-### Get Raw Button State Map
-
-```python
 states = makcu.get_button_states()
-print(states)  # {'left': False, 'right': True, ...}
-```
-
-### Check if a Specific Button Is Pressed
 
-```python
-if makcu.is_button_pressed(MouseButton.RIGHT):
-    print("Right button is pressed")
+if makcu.is_pressed(MouseButton.RIGHT):
+    print("Right button is currently pressed")
 ```
 
 ---
 
-## ⚙️ Low-Level Command Access
-
-### Send raw serial commands
+## ⚙️ Low-Level Access
 
 ```python
-from makcu import create_controller
-makcu = create_controller()
 response = makcu.transport.send_command("km.version()", expect_response=True)
-print(response)
 ```
 
 ---
 
 ## 🧪 Test Suite
 
-Run all tests and generate HTML report:
+Run full test suite and generate an HTML report:
 
 ```bash
 python -m makcu --runtest
@@ -287,11 +250,11 @@ except MakcuConnectionError as e:
 
 ## 🛠️ Developer Notes
 
-- Uses CH343 USB Serial
-- Auto-connects to correct port or fallback
-- Supports baud rate switching to 4M
-- Automatically enables `km.buttons(1)` monitoring if `send_init=True`
-- Supports raw button state polling
+- Communicates via CH343 USB serial
+- Automatically finds correct port or uses fallback
+- Switches baud to 4M after initial connect
+- Enables `km.buttons(1)` on init if requested
+- Supports full button state tracking with events
 
 ---
 
@@ -301,10 +264,11 @@ GPL License © SleepyTotem
 
 ---
 
-## Support
-Please open an issue on the project repository and I will get to it asap
+## 🙋 Support
+
+Open an issue on GitHub if you encounter bugs or need help.
 
 ## 🌐 Links
 
-- 🔗 [Project Homepage](https://github.com/SleepyTotem/makcu-py-lib)
-- 🔗 [PyPi Homepage](https://github.com/SleepyTotem/makcu-py-lib)
+- [GitHub Repo](https://github.com/SleepyTotem/makcu-py-lib)
+- [PyPI Package](https://pypi.org/project/makcu/)

makcu-0.1.4.dist-info/RECORD

@@ -0,0 +1,14 @@
+makcu/__init__.py,sha256=hCP6COi14T4C0V35crnbBEzJPa9hnwGb-gDPoxs_H6E,459
+makcu/__main__.py,sha256=wjRtr7V6qd54w43lHmXQldlVffKMW27nkhKa4E5B9t8,2830
+makcu/conftest.py,sha256=TQibb01_1OfzDrDU5u3IDlrfehXyr7E7jx3g0VySZmU,560
+makcu/connection.py,sha256=NDo8cmAnsu_-Njc-CacLFTKXkALvSc7E2BXYOY5aljg,12030
+makcu/controller.py,sha256=wBrGlO_mivd7YFRQJ84BVXGIuu3G7ChRos9fucTYWzM,5115
+makcu/enums.py,sha256=VmvCLmpghVHuTAkvCGMfA14MgWTtFVMfsGQQNnJ58Ts,126
+makcu/errors.py,sha256=4CkQ4gKa7GL5-BO3yOAJMMsy3QlUDDL42S1P1clqV4A,562
+makcu/mouse.py,sha256=PkBowk--SSHo13gRwK3jnORSQVQV1YeIF4NWE_Cm4KU,6388
+makcu/test_suite.py,sha256=qHYklwhVCeZbpndlwUrSGnd2a5wQtJwefjlo_ZWXD-Y,2661
+makcu-0.1.4.dist-info/licenses/LICENSE,sha256=IwGE9guuL-ryRPEKi6wFPI_zOhg7zDZbTYuHbSt_SAk,35823
+makcu-0.1.4.dist-info/METADATA,sha256=tZCMI-5J3s4Sp_zAVlrvKiLbGCcFGDCbRkDzzlilQWs,4828
+makcu-0.1.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+makcu-0.1.4.dist-info/top_level.txt,sha256=IRO1UVb5LK_ovjau0g4oObyXQqy00tVEE-yF5lPgw1w,6
+makcu-0.1.4.dist-info/RECORD,,

makcu-0.1.2.dist-info/RECORD

@@ -1,14 +0,0 @@
-makcu/__init__.py,sha256=hCP6COi14T4C0V35crnbBEzJPa9hnwGb-gDPoxs_H6E,459
-makcu/__main__.py,sha256=0fC-GdjCjC-ZCwE0Zwq-EJAuD5wEOo78Di7j9UAvcy0,2790
-makcu/conftest.py,sha256=TQibb01_1OfzDrDU5u3IDlrfehXyr7E7jx3g0VySZmU,560
-makcu/connection.py,sha256=AL1W-5ql7Wf54O_lDH8Tf36G73Ny1MUpx05TYXQt8zk,10268
-makcu/controller.py,sha256=AgulithR4NFHib-Q3mwmSlqhrodOmNFtojAnBgs3pMQ,5518
-makcu/enums.py,sha256=VmvCLmpghVHuTAkvCGMfA14MgWTtFVMfsGQQNnJ58Ts,126
-makcu/errors.py,sha256=4CkQ4gKa7GL5-BO3yOAJMMsy3QlUDDL42S1P1clqV4A,562
-makcu/mouse.py,sha256=rjrSE9PwO0e3CCtZ9oYqoxd17gVFNpeXlyBe5aV-QFc,4912
-makcu/test_suite.py,sha256=zko1SaUC-zOnEy7PH22DzJXXELVoV4JVHwagIdCTW5M,3196
-makcu-0.1.2.dist-info/licenses/LICENSE,sha256=IwGE9guuL-ryRPEKi6wFPI_zOhg7zDZbTYuHbSt_SAk,35823
-makcu-0.1.2.dist-info/METADATA,sha256=lCvjpEpQ0GnQ7bbUWiB3JWqJoNqZiVxtp9fTj_k2P88,5600
-makcu-0.1.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-makcu-0.1.2.dist-info/top_level.txt,sha256=IRO1UVb5LK_ovjau0g4oObyXQqy00tVEE-yF5lPgw1w,6
-makcu-0.1.2.dist-info/RECORD,,