mousebridge-mix 0.1.0__tar.gz

mousebridge_mix-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 MouseBridge contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

mousebridge_mix-0.1.0/MANIFEST.in

@@ -0,0 +1,4 @@
+include LICENSE README.md RELEASE.md
+include native/mix_sender.cpp
+recursive-include src/mousebridge *.py *.dll
+recursive-include tests *.py *.bin

mousebridge_mix-0.1.0/PKG-INFO

@@ -0,0 +1,91 @@
+Metadata-Version: 2.4
+Name: mousebridge-mix
+Version: 0.1.0
+Summary: Windows HID movement client for MouseBridge MIX v2
+License-Expression: MIT
+Classifier: Development Status :: 4 - Beta
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: System :: Hardware :: Universal Serial Bus (USB) :: Human Interface Device (HID)
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# mousebridge-mix
+
+Python client for MouseBridge MIX v2 firmware: initialize once, send mouse
+movements through Windows HID. Windows x64 and 64-bit Python 3.10+ required.
+The native sender DLL is included. No Zadig, WinUSB replacement, PyUSB,
+libusb, or additional Python runtime dependencies are required.
+
+## Install
+
+After publication on PyPI:
+
+```console
+python -m pip install mousebridge-mix
+```
+
+For a locally built wheel:
+
+```console
+python -m pip install mousebridge_mix-0.1.0-py3-none-win_amd64.whl
+```
+
+## Use
+
+Connect a Leonardo + USB Host Shield running **MIX v2** and its source mouse.
+
+```python
+from mousebridge import init
+
+with init() as mouse:
+    mouse.send_move(20, 0)
+    mouse.send_move(0, -20)
+```
+
+Optional selection: `init(vid=0x373E, pid=0x0047)` or `init(path=hid_path)`.
+Use your source device's VID/PID, not necessarily Arduino's. Generic discovery
+works when exactly one supported command collection is present.
+
+The familiar write interface remains available:
+
+```python
+import struct
+from mousebridge import find
+
+with find(idVendor=0x373E, idProduct=0x0047) as mouse:
+    mouse.write(1, struct.pack('<hh', 20, 0), timeout=8)
+```
+
+`write()` accepts endpoint `1` as a compatibility alias, or `mouse.endpoint`;
+it translates a four-byte XY payload into the MIX HID output report. It is
+not a PyUSB write to an arbitrary USB endpoint. `timeout` is accepted for
+compatibility but does not set a native write timeout.
+
+`send_move(x, y)` accepts signed int32 integers. `move()` is an alias.
+Sending is one synchronous native Windows `WriteFile` call; there is no
+Python retry loop, timer, queue, or sleep. The API returns no delivery status
+and does not promise non-blocking USB I/O. Use one caller per device and
+close it after use; the context manager does this automatically.
+
+Initialization reads descriptors and registers the MIX layout once. If the
+firmware reports no cached source state, move the physical mouse once,
+release its buttons, and initialize again. Physical and software motion are
+combined by MIX v2 firmware. This package does not update the firmware.
+Importing the package neither opens HID devices nor moves the cursor.
+
+## Update
+
+```console
+python -m pip install --upgrade mousebridge-mix
+```
+
+Updates take effect in a new Python process. Version 0.1.x targets the MIX v2
+`MX\x02` command capability; older MOTION and MIX v1 are rejected.
+
+## License
+
+MIT. See LICENSE. Source for the bundled native DLL is in the source
+archive under `native/mix_sender.cpp`.

mousebridge_mix-0.1.0/README.md

@@ -0,0 +1,77 @@
+# mousebridge-mix
+
+Python client for MouseBridge MIX v2 firmware: initialize once, send mouse
+movements through Windows HID. Windows x64 and 64-bit Python 3.10+ required.
+The native sender DLL is included. No Zadig, WinUSB replacement, PyUSB,
+libusb, or additional Python runtime dependencies are required.
+
+## Install
+
+After publication on PyPI:
+
+```console
+python -m pip install mousebridge-mix
+```
+
+For a locally built wheel:
+
+```console
+python -m pip install mousebridge_mix-0.1.0-py3-none-win_amd64.whl
+```
+
+## Use
+
+Connect a Leonardo + USB Host Shield running **MIX v2** and its source mouse.
+
+```python
+from mousebridge import init
+
+with init() as mouse:
+    mouse.send_move(20, 0)
+    mouse.send_move(0, -20)
+```
+
+Optional selection: `init(vid=0x373E, pid=0x0047)` or `init(path=hid_path)`.
+Use your source device's VID/PID, not necessarily Arduino's. Generic discovery
+works when exactly one supported command collection is present.
+
+The familiar write interface remains available:
+
+```python
+import struct
+from mousebridge import find
+
+with find(idVendor=0x373E, idProduct=0x0047) as mouse:
+    mouse.write(1, struct.pack('<hh', 20, 0), timeout=8)
+```
+
+`write()` accepts endpoint `1` as a compatibility alias, or `mouse.endpoint`;
+it translates a four-byte XY payload into the MIX HID output report. It is
+not a PyUSB write to an arbitrary USB endpoint. `timeout` is accepted for
+compatibility but does not set a native write timeout.
+
+`send_move(x, y)` accepts signed int32 integers. `move()` is an alias.
+Sending is one synchronous native Windows `WriteFile` call; there is no
+Python retry loop, timer, queue, or sleep. The API returns no delivery status
+and does not promise non-blocking USB I/O. Use one caller per device and
+close it after use; the context manager does this automatically.
+
+Initialization reads descriptors and registers the MIX layout once. If the
+firmware reports no cached source state, move the physical mouse once,
+release its buttons, and initialize again. Physical and software motion are
+combined by MIX v2 firmware. This package does not update the firmware.
+Importing the package neither opens HID devices nor moves the cursor.
+
+## Update
+
+```console
+python -m pip install --upgrade mousebridge-mix
+```
+
+Updates take effect in a new Python process. Version 0.1.x targets the MIX v2
+`MX\x02` command capability; older MOTION and MIX v1 are rejected.
+
+## License
+
+MIT. See LICENSE. Source for the bundled native DLL is in the source
+archive under `native/mix_sender.cpp`.

mousebridge_mix-0.1.0/RELEASE.md

@@ -0,0 +1,48 @@
+# Build and publish
+
+Build from this folder in a Windows x64 Python environment:
+
+```console
+python -m venv .venv-build
+.venv-build\Scripts\python -m pip install build twine wheel "setuptools>=77"
+.venv-build\Scripts\python -m build
+.venv-build\Scripts\python -m twine check dist/*
+```
+
+This produces a Windows AMD64 wheel and a source archive. The wheel includes
+only the client modules, native DLL and metadata, never firmware, uploaders,
+admin credentials, logs, or project backups. Tests use fake HID transports.
+
+Before publishing, verify the PyPI name is available to your account, review
+README/license, and inspect exactly the files to be uploaded. Package-name
+availability checks are advisory; a missing public page does not reserve a
+name. Public publication has not been performed by this build.
+
+Test publication (requires your TestPyPI account/token):
+
+```console
+.venv-build\Scripts\python -m twine upload --repository testpypi dist/mousebridge_mix-0.1.0-py3-none-win_amd64.whl dist/mousebridge_mix-0.1.0.tar.gz
+```
+
+Then install in another clean environment with TestPyPI's index. This package
+has no runtime dependencies. TestPyPI and PyPI credentials are separate.
+
+Publish the same verified artifacts using your PyPI account:
+
+```console
+.venv-build\Scripts\python -m twine upload dist/mousebridge_mix-0.1.0-py3-none-win_amd64.whl dist/mousebridge_mix-0.1.0.tar.gz
+```
+
+Use Twine's credential prompt or a configured trusted publisher; do not
+place tokens in source code, command arguments, documentation, or this chat.
+The distribution name is mousebridge-mix; the import name is mousebridge.
+
+For an update, change `src/mousebridge/__init__.py`'s version, update code and
+compatibility notes, and build into a new output directory. PyPI does not
+allow replacing an already uploaded release file. Publish only explicit new
+filenames, not stale artifacts via an unrestricted wildcard.
+
+The native DLL was built from native/mix_sender.cpp with Zig 0.13.0:
+`zig cc -x c++ -std=c++11 -O2 -fno-exceptions -fno-rtti -s -Wall -Wextra -Werror -shared -target x86_64-windows-gnu native/mix_sender.cpp -o src/mousebridge/mousebridge_mix.dll`.
+When replacing it, recheck PE AMD64, imports/exports and firmware protocol
+compatibility; synchronize the integrity reference in verification/tests.

mousebridge_mix-0.1.0/native/mix_sender.cpp

@@ -0,0 +1,20 @@
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#include <stdint.h>
+#include <string.h>
+struct MixSender { HANDLE device;uint8_t report[12];uint16_t sequence; };
+extern "C" __declspec(dllexport) MixSender *WINAPI MotionCreate(HANDLE device,const uint8_t *data,unsigned,unsigned,unsigned,unsigned){
+    if(!device || device==INVALID_HANDLE_VALUE || !data || data[0]!=1 || data[2]!=16){SetLastError(ERROR_INVALID_PARAMETER);return nullptr;}
+    MixSender *sender=static_cast<MixSender *>(HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(MixSender)));
+    if(!sender){SetLastError(ERROR_NOT_ENOUGH_MEMORY);return nullptr;}
+    sender->device=device;sender->report[0]=3;sender->report[1]=data[8];sender->sequence=uint16_t(data[3])|(uint16_t(data[4])<<8);return sender;
+}
+extern "C" __declspec(dllexport) void WINAPI MotionSendMove(MixSender *sender,int32_t x,int32_t y){
+    if(!sender)return;
+    memcpy(sender->report+2,&x,4);memcpy(sender->report+6,&y,4);++sender->sequence;
+    sender->report[10]=uint8_t(sender->sequence);sender->report[11]=uint8_t(sender->sequence>>8);
+    DWORD written;WriteFile(sender->device,sender->report,sizeof(sender->report),&written,nullptr);
+}
+extern "C" __declspec(dllexport) void WINAPI MotionClose(MixSender *sender){
+    if(!sender)return;CloseHandle(sender->device);SecureZeroMemory(sender,sizeof(*sender));HeapFree(GetProcessHeap(),0,sender);
+}

mousebridge_mix-0.1.0/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["setuptools>=77", "wheel>=0.45"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "mousebridge-mix"
+dynamic = ["version"]
+description = "Windows HID movement client for MouseBridge MIX v2"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+license-files = ["LICENSE"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Operating System :: Microsoft :: Windows",
+  "Programming Language :: Python :: 3",
+  "Topic :: System :: Hardware :: Universal Serial Bus (USB) :: Human Interface Device (HID)",
+]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["mousebridge*"]
+
+[tool.setuptools.package-data]
+mousebridge = ["mousebridge_mix.dll"]
+
+[tool.setuptools.dynamic]
+version = {attr = "mousebridge.__version__"}

mousebridge_mix-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

mousebridge_mix-0.1.0/setup.py

@@ -0,0 +1,16 @@
+"""The bundled DLL is Windows AMD64, independent of the Python C ABI."""
+from setuptools import setup
+from wheel.bdist_wheel import bdist_wheel
+
+
+class WindowsWheel(bdist_wheel):
+    def finalize_options(self):
+        super().finalize_options()
+        self.root_is_pure = False
+        self.plat_name = 'win_amd64'
+
+    def get_tag(self):
+        return 'py3', 'none', 'win_amd64'
+
+
+setup(cmdclass={'bdist_wheel': WindowsWheel})

mousebridge_mix-0.1.0/src/mousebridge/__init__.py

@@ -0,0 +1,5 @@
+"""MouseBridge MIX v2 movement client. Importing never opens a device."""
+__version__ = '0.1.0'
+from .hid_mix import MixDevice, init, find
+
+__all__ = ['MixDevice', 'init', 'find', '__version__']

mousebridge_mix-0.1.0/src/mousebridge/bridge_client.py

@@ -0,0 +1,68 @@
+"""Bounded initialization exchanges; independent of command-line tooling."""
+from .bridge_protocol import STATUS, frame, decode_response, descriptor_frame, report_frames
+
+
+class BridgeClient:
+    __slots__ = ('device', 'sequence')
+
+    def __init__(self, device):
+        self.device = device
+        self.sequence = 0
+
+    def next_sequence(self):
+        self.sequence = (self.sequence + 1) & 65535
+        return self.sequence
+
+    def exchange(self, request):
+        if self.device.send_feature_report(request) != 64:
+            raise RuntimeError('Incomplete HID Feature write')
+        return decode_response(self.device.get_feature_report(2, 64), request[2],
+                               int.from_bytes(request[3:5], 'little'))
+
+    def checked(self, request):
+        response = self.exchange(request)
+        if response.status:
+            raise RuntimeError(f'Firmware rejected command: {STATUS[response.status]}')
+        return response.data
+
+    def descriptor(self, target):
+        # MIX adds 32 bytes to the bounded 192-byte source configuration.
+        limit = 224 if target == 0 else 18 if target == 1 else 384
+        result = bytearray(limit)
+        offset = 0
+        expected = None
+        for unused in range((limit + 54) // 55):
+            response = self.checked(descriptor_frame(target, offset, self.next_sequence()))
+            total = int.from_bytes(response[6:8], 'little')
+            count = response[8]
+            if expected is None:
+                expected = total
+            if (total != expected or total > limit or offset > total or
+                    count != min(55, total - offset)):
+                raise RuntimeError('Inconsistent or oversized descriptor response')
+            result[offset:offset + count] = response[9:9 + count]
+            offset += count
+            if offset == total:
+                return bytes(result[:total])
+        raise RuntimeError('Descriptor exceeded bounded read count')
+
+    def info(self):
+        data = self.checked(frame(1, self.next_sequence()))
+        return dict(source_interfaces=data[6], source_endpoints=data[7], command_interface=data[8],
+                    command_endpoint=hex(0x80 | data[9]), configuration_bytes=int.from_bytes(data[10:12], 'little'),
+                    report_descriptor_bytes=int.from_bytes(data[12:14], 'little'),
+                    vid=hex(int.from_bytes(data[14:16], 'little')), pid=hex(int.from_bytes(data[16:18], 'little')),
+                    relayed_mod65536=int.from_bytes(data[18:20], 'little'),
+                    injected_mod65536=int.from_bytes(data[20:22], 'little'),
+                    transfer_errors_mod65536=int.from_bytes(data[22:24], 'little'),
+                    blocked_polls_mod65536=int.from_bytes(data[24:26], 'little'),
+                    last_error=STATUS[data[26]], configuration=data[27])
+
+    def send_report(self, endpoint, report):
+        # Explicit raw CLI operation. No automatic BUSY retry.
+        for request in report_frames(endpoint, report, self.next_sequence()):
+            response = self.exchange(request)
+            if response.status:
+                raise RuntimeError(f'Firmware rejected report: {STATUS[response.status]}')
+            if response.data[6] != request[7] + request[8]:
+                raise RuntimeError('Incorrect fragment acknowledgement')

mousebridge_mix-0.1.0/src/mousebridge/bridge_protocol.py

@@ -0,0 +1,49 @@
+"""Protocol v1. HID report IDs are part of these buffers, not added a second time."""
+from dataclasses import dataclass
+import struct
+
+COMMAND_ID, RESPONSE_ID, VERSION, REPORT_SIZE, CHUNK = 1, 2, 1, 64, 55
+STATUS = ('OK', 'BAD_DESCRIPTOR', 'UNSUPPORTED', 'MEMORY_LIMIT', 'ENDPOINT_LIMIT',
+          'HOST_ERROR', 'NOT_READY', 'BAD_COMMAND', 'BAD_TARGET', 'BAD_LENGTH',
+          'BUSY', 'BAD_REPORT', 'USB_ERROR')
+
+def frame(opcode: int, sequence: int, target=0, total=0, offset=0, payload=b'') -> bytes:
+    if not 0 <= sequence <= 65535 or not 0 <= target <= 255:
+        raise ValueError('Sequence or target out of range')
+    if len(payload) > CHUNK or not 0 <= total <= 64 or not 0 <= offset <= 255:
+        raise ValueError('Invalid frame length')
+    return bytes([COMMAND_ID, VERSION, opcode]) + struct.pack('<H', sequence) + bytes(
+        [target, total, offset, len(payload)]) + payload + bytes(CHUNK - len(payload))
+
+def report_frames(endpoint: int, report: bytes, sequence: int):
+    if not 1 <= len(report) <= 64:
+        raise ValueError('A complete Input report must contain 1..64 bytes')
+    if not endpoint & 0x80 or endpoint & 0x70 or not 1 <= (endpoint & 15) <= 6:
+        raise ValueError('Use a source interrupt-IN endpoint address, e.g. 0x81')
+    return [frame(2, sequence, endpoint, len(report), pos, report[pos:pos + CHUNK])
+            for pos in range(0, len(report), CHUNK)]
+
+@dataclass(frozen=True)
+class Response:
+    __slots__ = ('status', 'opcode', 'sequence', 'data')
+    status: int
+    opcode: int
+    sequence: int
+    data: bytes
+
+def decode_response(raw: bytes, opcode: int, sequence: int) -> Response:
+    if len(raw) != REPORT_SIZE or raw[0:2] != bytes([RESPONSE_ID, VERSION]):
+        raise ValueError('Wrong response report size, ID or protocol version')
+    if raw[3] != opcode or int.from_bytes(raw[4:6], 'little') != sequence:
+        raise ValueError('Stale response or sequence/opcode mismatch')
+    if raw[2] >= len(STATUS):
+        raise ValueError('Unknown firmware status')
+    return Response(raw[2], opcode, sequence, raw)
+
+def descriptor_frame(target: int, offset: int, sequence: int):
+    if not 0 <= offset <= 65535:
+        raise ValueError('Descriptor offset out of range')
+    # For opcode 3, bytes 6 and 7 mean the 16-bit descriptor offset.
+    data = bytearray(frame(3, sequence, target))
+    data[6:8] = struct.pack('<H', offset)
+    return bytes(data)

mousebridge_mix-0.1.0/src/mousebridge/hid_mix.py

@@ -0,0 +1,70 @@
+"""MIX: initialize once, one synchronous native HID Output write per movement."""
+import ctypes
+import struct
+from pathlib import Path
+from .hid_motion import release_native
+
+
+class MixDevice:
+    __slots__ = ('_library','_context','_send','_close','endpoint','interface')
+    def __init__(self, transport):
+        from .motion_initialize import prepare_motion
+        self._context = self._library = None
+        try:
+            prepared = prepare_motion(transport, mix=True)
+            template, self.endpoint, self.interface = prepared[:3]
+            path = Path(__file__).with_name('mousebridge_mix.dll')
+            if not path.is_file():
+                raise OSError('Bundled mousebridge_mix.dll is missing; reinstall mousebridge-mix')
+            if ctypes.sizeof(ctypes.c_void_p) != 8:
+                raise OSError('MIX requires 64-bit Python')
+            self._library = ctypes.WinDLL(str(path),use_last_error=True)
+            create = self._library.MotionCreate
+            create.argtypes = [ctypes.c_void_p,ctypes.c_void_p,ctypes.c_uint,ctypes.c_uint,ctypes.c_uint,ctypes.c_uint]
+            create.restype = ctypes.c_void_p
+            self._send = self._library.MotionSendMove
+            self._send.argtypes = [ctypes.c_void_p,ctypes.c_int32,ctypes.c_int32]
+            self._send.restype = None
+            self._close = self._library.MotionClose
+            self._close.argtypes = [ctypes.c_void_p]
+            self._close.restype = None
+            buffer = (ctypes.c_ubyte*64).from_buffer(template)
+            self._context = create(transport.handle,buffer,0,0,0,0)
+            if not self._context:
+                raise ctypes.WinError(ctypes.get_last_error())
+            transport.detach_handle()
+        except BaseException:
+            self.close()
+            raise
+        finally:
+            transport.close()
+
+    @classmethod
+    def open(cls,vid=None,pid=None,path=None):
+        from .windows_hid import WindowsHid
+        return cls(WindowsHid(vid=vid,pid=pid,path=path))
+
+    def send_move(self,x,y):
+        if self._context is None: raise OSError('MIX sender is closed')
+        if type(x) is not int or type(y) is not int: raise TypeError('Integer movement required')
+        if not -2147483648<=x<=2147483647 or not -2147483648<=y<=2147483647: raise ValueError('Movement outside int32')
+        self._send(self._context,x,y)
+
+    def move(self,x,y): self.send_move(x,y)
+    def write(self,endpoint,data,timeout=None):
+        if endpoint not in (1,self.endpoint): raise ValueError('Use endpoint=1 or dev.endpoint')
+        self.send_move(*struct.unpack('<hh',data))
+
+    def close(self):
+        if self._context is not None:
+            self._close(self._context)
+            self._context = None
+        self._send = self._close = None
+        release_native(self._library)
+        self._library = None
+    def __enter__(self): return self
+    def __exit__(self,*args): self.close()
+
+
+def init(vid=None,pid=None,path=None): return MixDevice.open(vid,pid,path)
+def find(idVendor=None,idProduct=None): return init(idVendor,idProduct)

mousebridge_mix-0.1.0/src/mousebridge/hid_motion.py

@@ -0,0 +1,11 @@
+"""Native module lifetime helper used by the MIX client."""
+import ctypes
+
+
+def release_native(library):
+    if library is not None and hasattr(library, '_handle'):
+        release = ctypes.windll.kernel32.FreeLibrary
+        release.argtypes = [ctypes.c_void_p]
+        release.restype = ctypes.c_int
+        release(library._handle)
+

mousebridge_mix-0.1.0/src/mousebridge/hid_report_layout.py

@@ -0,0 +1,139 @@
+"""Conservative HID relative mouse layout parser (no manufacturer assumptions)."""
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class Field:
+    __slots__ = ('offset', 'width', 'minimum', 'maximum', 'usage')
+    offset: int
+    width: int
+    minimum: int
+    maximum: int
+    usage: int
+
+
+@dataclass
+class Layout:
+    __slots__ = ('report_id', 'length', 'x', 'y', 'relative')
+    report_id: int
+    length: int
+    x: Field
+    y: Field
+    relative: list
+
+    def overlay(self, x, y):
+        value, mask = 0, 0
+        prefix = 8 if self.report_id else 0
+        for f in self.relative:
+            v = x if f == self.x else y if f == self.y else 0
+            if not f.minimum <= v <= f.maximum:
+                raise ValueError(f'Value {v} outside HID logical range {f.minimum}..{f.maximum}')
+            bits = (1 << f.width) - 1
+            mask |= bits << (prefix + f.offset)
+            value |= (v & bits) << (prefix + f.offset)
+        if self.report_id:
+            value |= self.report_id
+        return value.to_bytes(self.length, 'little'), mask.to_bytes(self.length, 'little')
+
+
+def parse_mouse_layout(descriptor):
+    g = dict(page=0, size=0, count=0, id=0, minimum=0, maximum=0)
+    saved, collections, usages = [], [], []
+    usage_min = usage_max = None
+    offsets, fields, axes, owners = {}, {}, {}, {}
+    mouse_collection = 0
+    pos, has_ids = 0, False
+    while pos < len(descriptor):
+        head = descriptor[pos]; pos += 1
+        if head == 0xfe:
+            raise ValueError('HID long items are unsupported')
+        size = (0, 1, 2, 4)[head & 3]
+        if pos + size > len(descriptor):
+            raise ValueError('Truncated HID item')
+        data = descriptor[pos:pos+size]; pos += size
+        v = int.from_bytes(data, 'little')
+        signed = int.from_bytes(data, 'little', signed=True) if size else 0
+        kind, tag = (head >> 2) & 3, head >> 4
+        if kind == 1:
+            if tag == 0: g['page'] = v
+            elif tag == 1: g['minimum'] = signed
+            elif tag == 2: g['maximum'] = signed if g['minimum'] < 0 else v
+            elif tag == 7:
+                if not 1 <= v <= 32: raise ValueError('Unsupported Report Size')
+                g['size'] = v
+            elif tag == 8:
+                if not 1 <= v <= 255: raise ValueError('Invalid Report ID')
+                g['id'] = v; has_ids = True
+            elif tag == 9:
+                if not 1 <= v <= 512: raise ValueError('Unsupported Report Count')
+                g['count'] = v
+            elif tag == 10:
+                if size or len(saved) >= 4: raise ValueError('Invalid global PUSH')
+                saved.append(g.copy())
+            elif tag == 11:
+                if size or not saved: raise ValueError('Invalid global POP')
+                g = saved.pop()
+            elif tag not in (3, 4, 5, 6): raise ValueError('Unsupported global item')
+        elif kind == 2:
+            usage = v if size == 4 else (g['page'] << 16) | v
+            if tag == 0: usages.append(usage)
+            elif tag == 1: usage_min = usage
+            elif tag == 2: usage_max = usage
+            else: raise ValueError('Unsupported local HID item')
+        elif kind == 0:
+            if tag == 10:
+                if size != 1 or len(collections) >= 32: raise ValueError('Invalid Collection')
+                mouse = (v == 1 and (usages or [0])[0] == 0x10002)
+                if mouse: mouse_collection += 1
+                # A nested application collection cannot borrow ownership from a mouse.
+                owner = (mouse_collection if mouse else None) if v == 1 else (collections[-1] if collections else None)
+                collections.append(owner)
+            elif tag == 12:
+                if size or not collections: raise ValueError('Invalid End Collection')
+                collections.pop()
+            elif tag in (8, 9, 11):
+                if not size or not collections or not g['size'] or not g['count']:
+                    raise ValueError('Invalid HID data item')
+                key = (g['id'], tag)
+                start = offsets.get(key, 0)
+                end = start + g['size'] * g['count']
+                if end > (504 if g['id'] else 512): raise ValueError('Report exceeds 64 bytes')
+                offsets[key] = end
+                resolved = list(usages)
+                if usage_min is not None or usage_max is not None:
+                    if usage_min is None or usage_max is None or not 0 <= usage_max - usage_min <= 511:
+                        raise ValueError('Invalid usage range')
+                    resolved.extend(range(usage_min, usage_max + 1))
+                if tag == 8 and not v & 1:
+                    if v & 4:
+                        if not v & 2 or v & 0x100: raise ValueError('Unsupported relative Input')
+                        if not g['minimum'] <= 0 <= g['maximum']: raise ValueError('Relative field has no neutral zero')
+                        for i in range(g['count']):
+                            usage = resolved[min(i, len(resolved)-1)] if resolved else 0
+                            f = Field(start + i*g['size'], g['size'], g['minimum'], g['maximum'], usage)
+                            lo = -(1 << (f.width-1)) if f.minimum < 0 else 0
+                            hi = (1 << (f.width-1)) - 1 if f.minimum < 0 else (1 << f.width) - 1
+                            if f.minimum < lo or f.maximum > hi or f.minimum > f.maximum:
+                                raise ValueError('Logical bounds exceed field width')
+                            fields.setdefault(g['id'], []).append(f)
+                            owners.setdefault(g['id'], set()).add(collections[-1])
+                            if usage in (0x10030, 0x10031) and collections[-1]:
+                                a = axes.setdefault(g['id'], {})
+                                if usage in a: raise ValueError('Ambiguous mouse axis')
+                                a[usage] = f
+            else: raise ValueError('Unsupported main HID item')
+            usages = []; usage_min = usage_max = None
+        else:
+            raise ValueError('Reserved HID item')
+    if collections or saved: raise ValueError('Unbalanced HID descriptor')
+    if has_ids and any(rid == 0 for rid, _ in offsets): raise ValueError('Mixed numbered/unnumbered reports')
+    result = []
+    for rid, a in axes.items():
+        if set(a) == {0x10030, 0x10031}:
+            if None in owners[rid] or len(owners[rid]) != 1:
+                raise ValueError('Relative fields cross application collections in one report')
+            length = (offsets[(rid, 8)] + 7)//8 + bool(rid)
+            result.append(Layout(rid, length, a[0x10030], a[0x10031], fields[rid]))
+    if len(result) != 1: raise ValueError('Expected one unambiguous relative mouse X/Y report')
+    if result[0].length > 27: raise ValueError('Motion overlay supports reports up to 27 bytes')
+    return result[0]

mousebridge_mix-0.1.0/src/mousebridge/motion_initialize.py

@@ -0,0 +1,106 @@
+"""One-time mouse discovery and template preparation. No sending loop."""
+from .bridge_client import BridgeClient
+from .bridge_protocol import frame
+from .hid_report_layout import parse_mouse_layout
+
+
+def prepare_motion(transport, mix=False):
+    client = BridgeClient(transport)
+    identity = client.checked(frame(4, client.next_sequence()))
+    if identity[42:46] != b'MBD\x01':
+        raise RuntimeError('Command collection is not MouseBridge')
+    capability = client.exchange(frame(14, client.next_sequence()))
+    data = capability.data
+    if capability.status or data[6:9] != (b'MX\x02' if mix else b'MO\x01') or data[9] != 27:
+        raise RuntimeError('Установите прошивку MIX v2 для этого клиента' if mix else 'Install the MOTION firmware before opening the sender')
+    generation = data[10]
+    if mix and not 1 <= data[11] <= 6:
+        raise RuntimeError('No spare hardware endpoint for MIX OUT')
+    topology = client.checked(frame(13, client.next_sequence()))
+    if topology[6:9] != b'VT\x01':
+        raise RuntimeError('Cannot verify virtual interface ownership')
+    virtual_mask = topology[9]
+    information = client.checked(frame(1, client.next_sequence()))
+    if not 1 <= information[6] <= 4:
+        raise ValueError('Invalid interface count')
+    configuration = client.descriptor(0)
+    endpoints = {}
+    interface = None
+    mix_output_found = False
+    offset = 0
+    while offset < len(configuration):
+        length = configuration[offset]
+        if length < 2 or offset + length > len(configuration):
+            raise ValueError('Invalid configuration descriptor')
+        descriptor = configuration[offset:offset + length]
+        if descriptor[1] == 4:
+            if length != 9 or descriptor[3]:
+                raise ValueError('Unsupported interface descriptor')
+            interface = descriptor[2]
+            if interface != information[8] and not virtual_mask & (1 << interface):
+                endpoints[interface] = []
+        elif descriptor[1] == 5:
+            if length != 7:
+                raise ValueError('Invalid endpoint descriptor')
+            if interface in endpoints and descriptor[2] & 128 and descriptor[3] == 3:
+                endpoints[interface].append((descriptor[2], int.from_bytes(descriptor[4:6], 'little')))
+            if mix and interface == information[8] and descriptor[2] == data[11] and descriptor[3] == 3 and int.from_bytes(descriptor[4:6], 'little') >= 12:
+                mix_output_found = True
+        offset += length
+    if mix and not mix_output_found:
+        raise RuntimeError('MIX OUT endpoint missing from configuration')
+    selected = None
+    for slot in range(information[6]):
+        interface = information[28 + slot]
+        if interface not in endpoints:
+            continue
+        try:
+            layout = parse_mouse_layout(client.descriptor(slot + 2))
+        except ValueError:
+            continue
+        endpoint = None
+        for address, size in endpoints[interface]:
+            if size >= layout.length:
+                if endpoint is not None:
+                    raise ValueError('Ambiguous mouse endpoint')
+                endpoint = address
+        if endpoint is not None:
+            if selected is not None:
+                raise ValueError('Ambiguous mouse interface')
+            selected = (endpoint, interface, layout)
+    if selected is None:
+        raise ValueError('No supported relative mouse interface')
+    confirmed = client.checked(frame(14, client.next_sequence()))
+    if confirmed[10] != generation:
+        raise RuntimeError('USB session changed during initialization; reopen')
+    endpoint, interface, layout = selected
+    values, mask = layout.overlay(0, 0)
+    template = bytearray(64)
+    template[0:3] = b'\x01\x01\x0e'
+    template[3:5] = client.sequence.to_bytes(2, 'little')
+    template[5:9] = bytes((endpoint, layout.length, layout.report_id, generation))
+    template[9:9 + layout.length] = values
+    template[9 + layout.length:9 + 2 * layout.length] = mask
+    prefix = 8 if layout.report_id else 0
+    if mix:
+        registration = bytearray(frame(15, client.next_sequence()))
+        registration[5:9] = template[5:9]
+        registration[9:13] = bytes((layout.x.offset+prefix,layout.x.width,layout.y.offset+prefix,layout.y.width))
+        for offset, value in ((13,layout.x.minimum),(17,layout.x.maximum),(21,layout.y.minimum),(25,layout.y.maximum)):
+            registration[offset:offset+4] = value.to_bytes(4,'little',signed=True)
+        registration[29:29+layout.length] = mask
+        registered = client.exchange(registration)
+        if registered.status == 6:
+            raise RuntimeError('MIX ещё не готов. Пошевелите мышь, отпустите кнопки и повторите запуск.')
+        if registered.status:
+            raise RuntimeError('Firmware rejected MIX registration: ' + str(registered.status))
+        ready = client.checked(frame(14, client.next_sequence()))
+        if ready[10] != generation or ready[12] != layout.length:
+            raise RuntimeError('Состояние MIX изменилось при инициализации; повторите запуск')
+        if not ready[13]:
+            raise RuntimeError('MIX ждёт состояние мыши. Пошевелите мышь один раз и повторите запуск. Движения ещё не отправлялись.')
+        template[2] = 16
+    return (template, endpoint, interface, layout.x.offset + prefix, layout.x.width,
+            layout.y.offset + prefix, layout.y.width,
+            max(layout.x.minimum, -2147483648), min(layout.x.maximum, 2147483647),
+            max(layout.y.minimum, -2147483648), min(layout.y.maximum, 2147483647))

mousebridge_mix-0.1.0/src/mousebridge/windows_hid.py

@@ -0,0 +1,152 @@
+"""Native Windows HID Feature transport; Python standard library only."""
+import ctypes
+import ctypes.wintypes
+import os
+
+
+class GUID(ctypes.Structure):
+    _fields_ = [('a', ctypes.wintypes.DWORD), ('b', ctypes.wintypes.WORD), ('c', ctypes.wintypes.WORD), ('d', ctypes.c_ubyte * 8)]
+
+
+class InterfaceData(ctypes.Structure):
+    _fields_ = [('size', ctypes.wintypes.DWORD), ('guid', GUID), ('flags', ctypes.wintypes.DWORD), ('reserved', ctypes.c_size_t)]
+
+
+class WindowsHid:
+    __slots__ = ('hid', 'setup', 'kernel', 'handle', 'path', '_request', '_response')
+    def __init__(self, path=None, vid=None, pid=None):
+        if os.name != 'nt':
+            raise OSError('This transport requires Windows')
+        self.hid = ctypes.WinDLL('hid.dll', use_last_error=True)
+        self.setup = ctypes.WinDLL('setupapi.dll', use_last_error=True)
+        self.kernel = ctypes.WinDLL('kernel32.dll', use_last_error=True)
+        self.handle = None
+        self._request = (ctypes.c_ubyte * 64)()
+        self._response = (ctypes.c_ubyte * 64)()
+        self.kernel.CreateFileW.argtypes = [ctypes.wintypes.LPCWSTR, ctypes.wintypes.DWORD, ctypes.wintypes.DWORD, ctypes.c_void_p, ctypes.wintypes.DWORD, ctypes.wintypes.DWORD, ctypes.c_void_p]
+        self.kernel.CreateFileW.restype = ctypes.wintypes.HANDLE
+        self.kernel.CloseHandle.argtypes = [ctypes.wintypes.HANDLE]
+        self.kernel.FreeLibrary.argtypes = [ctypes.wintypes.HMODULE]
+        self.kernel.FreeLibrary.restype = ctypes.wintypes.BOOL
+        self.hid.HidD_GetHidGuid.argtypes = [ctypes.POINTER(GUID)]
+        for name in ('HidD_SetFeature', 'HidD_GetFeature'):
+            fn = getattr(self.hid, name)
+            fn.argtypes = [ctypes.wintypes.HANDLE, ctypes.c_void_p, ctypes.wintypes.ULONG]
+            fn.restype = ctypes.c_ubyte
+        self.hid.HidD_GetPreparsedData.argtypes = [ctypes.wintypes.HANDLE, ctypes.POINTER(ctypes.c_void_p)]
+        self.hid.HidD_GetPreparsedData.restype = ctypes.c_ubyte
+        self.hid.HidD_FreePreparsedData.argtypes = [ctypes.c_void_p]
+        self.hid.HidP_GetCaps.argtypes = [ctypes.c_void_p, ctypes.c_void_p]
+        self.hid.HidP_GetCaps.restype = ctypes.wintypes.LONG
+        self.setup.SetupDiGetClassDevsW.argtypes = [ctypes.POINTER(GUID), ctypes.wintypes.LPCWSTR, ctypes.wintypes.HWND, ctypes.wintypes.DWORD]
+        self.setup.SetupDiGetClassDevsW.restype = ctypes.wintypes.HANDLE
+        self.setup.SetupDiEnumDeviceInterfaces.argtypes = [ctypes.wintypes.HANDLE, ctypes.c_void_p, ctypes.POINTER(GUID), ctypes.wintypes.DWORD, ctypes.POINTER(InterfaceData)]
+        self.setup.SetupDiGetDeviceInterfaceDetailW.argtypes = [ctypes.wintypes.HANDLE, ctypes.POINTER(InterfaceData), ctypes.c_void_p, ctypes.wintypes.DWORD, ctypes.POINTER(ctypes.wintypes.DWORD), ctypes.c_void_p]
+        self.setup.SetupDiDestroyDeviceInfoList.argtypes = [ctypes.wintypes.HANDLE]
+        try:
+            paths = self._paths(vid, pid)
+            if path is not None:
+                paths = [candidate for candidate in paths if candidate == path]
+            if len(paths) != 1:
+                raise RuntimeError(f'Expected one MouseBridge command HID; found {len(paths)}')
+            self.path = paths[0]
+            self.handle = self._open(self.path, 0xC0000000)
+            if self.handle == ctypes.c_void_p(-1).value:
+                self.handle = None
+                raise ctypes.WinError(ctypes.get_last_error())
+        except BaseException:
+            self.close()
+            raise
+
+    def _open(self, path, access=0):
+        return self.kernel.CreateFileW(path, access, 3, None, 3, 0, None)
+
+    def _paths(self, vid, pid):
+        guid = GUID()
+        self.hid.HidD_GetHidGuid(ctypes.byref(guid))
+        devices = self.setup.SetupDiGetClassDevsW(ctypes.byref(guid), None, None, 18)
+        if devices == ctypes.c_void_p(-1).value:
+            raise ctypes.WinError(ctypes.get_last_error())
+        result = []
+        try:
+            for index in range(1024):
+                entry = InterfaceData(); entry.size = ctypes.sizeof(entry)
+                if not self.setup.SetupDiEnumDeviceInterfaces(devices, None, ctypes.byref(guid), index, ctypes.byref(entry)):
+                    if ctypes.get_last_error() != 259:
+                        raise ctypes.WinError(ctypes.get_last_error())
+                    break
+                needed = ctypes.wintypes.DWORD()
+                self.setup.SetupDiGetDeviceInterfaceDetailW(devices, ctypes.byref(entry), None, 0, ctypes.byref(needed), None)
+                if not 6 <= needed.value <= 65536:
+                    raise RuntimeError('Invalid HID path length')
+                detail = ctypes.create_string_buffer(needed.value)
+                ctypes.cast(detail, ctypes.POINTER(ctypes.wintypes.DWORD))[0] = 8 if ctypes.sizeof(ctypes.c_void_p) == 8 else 6
+                if not self.setup.SetupDiGetDeviceInterfaceDetailW(devices, ctypes.byref(entry), detail, needed, ctypes.byref(needed), None):
+                    continue
+                path = ctypes.wstring_at(ctypes.addressof(detail) + 4)
+                lower = path.lower()
+                if vid is not None and f'vid_{vid:04x}' not in lower:
+                    continue
+                if pid is not None and f'pid_{pid:04x}' not in lower:
+                    continue
+                handle = self._open(path)
+                if handle == ctypes.c_void_p(-1).value:
+                    continue
+                prep = ctypes.c_void_p()
+                try:
+                    if not self.hid.HidD_GetPreparsedData(handle, ctypes.byref(prep)):
+                        continue
+                    caps = ctypes.create_string_buffer(64)
+                    if self.hid.HidP_GetCaps(prep, caps) == 0x110000:
+                        words = ctypes.cast(caps, ctypes.POINTER(ctypes.wintypes.WORD))
+                        if (words[0], words[1], words[4]) == (1, 0xFF31, 64):
+                            result.append(path)
+                finally:
+                    if prep.value:
+                        self.hid.HidD_FreePreparsedData(prep)
+                    self.kernel.CloseHandle(handle)
+            else:
+                raise RuntimeError('HID enumeration exceeded bounded interface count')
+        finally:
+            self.setup.SetupDiDestroyDeviceInfoList(devices)
+        return result
+
+    def send_feature_report(self, data):
+        if not self.handle:
+            raise OSError('HID device is closed')
+        data = bytes(data)
+        if len(data) != 64 or data[0] != 1:
+            raise ValueError('MouseBridge commands require a 64-byte report with ID 1')
+        ctypes.memmove(self._request, data, 64)
+        if not self.hid.HidD_SetFeature(self.handle, self._request, 64):
+            raise ctypes.WinError(ctypes.get_last_error())
+        return len(data)
+
+    def get_feature_report(self, report_id, length):
+        if not self.handle:
+            raise OSError('HID device is closed')
+        if report_id != 2 or length != 64:
+            raise ValueError('MouseBridge responses require a 64-byte report with ID 2')
+        ctypes.memset(self._response, 0, 64)
+        self._response[0] = report_id
+        if not self.hid.HidD_GetFeature(self.handle, self._response, 64):
+            raise ctypes.WinError(ctypes.get_last_error())
+        return bytes(self._response)
+
+    def detach_handle(self):
+        """Transfer handle ownership after the native context was created successfully."""
+        handle = self.handle
+        self.handle = None
+        return handle
+
+    def close(self):
+        if self.handle:
+            self.kernel.CloseHandle(self.handle)
+            self.handle = None
+        # Only this object's LoadLibrary references are released; native sender owns its own.
+        if self.kernel is not None and hasattr(self.kernel, 'FreeLibrary'):
+            release = self.kernel.FreeLibrary
+            for library in (self.hid, self.setup, self.kernel):
+                if library is not None:
+                    release(library._handle)
+            self.hid = self.setup = self.kernel = None

mousebridge_mix-0.1.0/src/mousebridge_mix.egg-info/PKG-INFO

@@ -0,0 +1,91 @@
+Metadata-Version: 2.4
+Name: mousebridge-mix
+Version: 0.1.0
+Summary: Windows HID movement client for MouseBridge MIX v2
+License-Expression: MIT
+Classifier: Development Status :: 4 - Beta
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: System :: Hardware :: Universal Serial Bus (USB) :: Human Interface Device (HID)
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# mousebridge-mix
+
+Python client for MouseBridge MIX v2 firmware: initialize once, send mouse
+movements through Windows HID. Windows x64 and 64-bit Python 3.10+ required.
+The native sender DLL is included. No Zadig, WinUSB replacement, PyUSB,
+libusb, or additional Python runtime dependencies are required.
+
+## Install
+
+After publication on PyPI:
+
+```console
+python -m pip install mousebridge-mix
+```
+
+For a locally built wheel:
+
+```console
+python -m pip install mousebridge_mix-0.1.0-py3-none-win_amd64.whl
+```
+
+## Use
+
+Connect a Leonardo + USB Host Shield running **MIX v2** and its source mouse.
+
+```python
+from mousebridge import init
+
+with init() as mouse:
+    mouse.send_move(20, 0)
+    mouse.send_move(0, -20)
+```
+
+Optional selection: `init(vid=0x373E, pid=0x0047)` or `init(path=hid_path)`.
+Use your source device's VID/PID, not necessarily Arduino's. Generic discovery
+works when exactly one supported command collection is present.
+
+The familiar write interface remains available:
+
+```python
+import struct
+from mousebridge import find
+
+with find(idVendor=0x373E, idProduct=0x0047) as mouse:
+    mouse.write(1, struct.pack('<hh', 20, 0), timeout=8)
+```
+
+`write()` accepts endpoint `1` as a compatibility alias, or `mouse.endpoint`;
+it translates a four-byte XY payload into the MIX HID output report. It is
+not a PyUSB write to an arbitrary USB endpoint. `timeout` is accepted for
+compatibility but does not set a native write timeout.
+
+`send_move(x, y)` accepts signed int32 integers. `move()` is an alias.
+Sending is one synchronous native Windows `WriteFile` call; there is no
+Python retry loop, timer, queue, or sleep. The API returns no delivery status
+and does not promise non-blocking USB I/O. Use one caller per device and
+close it after use; the context manager does this automatically.
+
+Initialization reads descriptors and registers the MIX layout once. If the
+firmware reports no cached source state, move the physical mouse once,
+release its buttons, and initialize again. Physical and software motion are
+combined by MIX v2 firmware. This package does not update the firmware.
+Importing the package neither opens HID devices nor moves the cursor.
+
+## Update
+
+```console
+python -m pip install --upgrade mousebridge-mix
+```
+
+Updates take effect in a new Python process. Version 0.1.x targets the MIX v2
+`MX\x02` command capability; older MOTION and MIX v1 are rejected.
+
+## License
+
+MIT. See LICENSE. Source for the bundled native DLL is in the source
+archive under `native/mix_sender.cpp`.

mousebridge_mix-0.1.0/src/mousebridge_mix.egg-info/SOURCES.txt

@@ -0,0 +1,24 @@
+LICENSE
+MANIFEST.in
+README.md
+RELEASE.md
+pyproject.toml
+setup.py
+native/mix_sender.cpp
+src/mousebridge/__init__.py
+src/mousebridge/bridge_client.py
+src/mousebridge/bridge_protocol.py
+src/mousebridge/hid_mix.py
+src/mousebridge/hid_motion.py
+src/mousebridge/hid_report_layout.py
+src/mousebridge/motion_initialize.py
+src/mousebridge/mousebridge_mix.dll
+src/mousebridge/windows_hid.py
+src/mousebridge_mix.egg-info/PKG-INFO
+src/mousebridge_mix.egg-info/SOURCES.txt
+src/mousebridge_mix.egg-info/dependency_links.txt
+src/mousebridge_mix.egg-info/top_level.txt
+tests/fake_transport.py
+tests/test_mix.py
+tests/test_package.py
+tests/fixtures/captured-report-91.bin

mousebridge_mix-0.1.0/src/mousebridge_mix.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

mousebridge_mix-0.1.0/src/mousebridge_mix.egg-info/top_level.txt

@@ -0,0 +1 @@
+mousebridge

mousebridge_mix-0.1.0/tests/fake_transport.py

@@ -0,0 +1,23 @@
+from pathlib import Path
+FIXTURE = Path(__file__).parent / 'fixtures/captured-report-91.bin'
+
+class FakeTransport:
+    def __init__(self, statuses=()):
+        self.closed = False; self.requests = []; self.statuses = list(statuses); self.handle = 123; self.detached = False
+        self.descriptors = [bytes.fromhex('09 02 3b 00 02 01 00 80 fa 09 04 00 00 01 03 01 02 00 09 21 11 01 00 01 22 5b 00 07 05 81 03 08 00 01 09 04 01 00 01 03 00 00 00 09 21 11 01 00 01 22 26 00 07 05 82 03 08 00 01'), b'', FIXTURE.read_bytes()]
+    def send_feature_report(self, request):
+        self.request = bytes(request); self.requests.append(self.request); return 64
+    def get_feature_report(self, rid, length):
+        r = self.request; out = bytearray(64); out[:6] = bytes([2, 1, 0, r[2], r[3], r[4]])
+        if r[2] == 4: out[42:46] = b'MBD\x01'
+        elif r[2] == 1: out[6:10] = bytes([1, 1, 1, 2]); out[27] = 1; out[28] = 0
+        elif r[2] == 3:
+            data = self.descriptors[r[5]]; offset = int.from_bytes(r[6:8], 'little'); part = data[offset:offset+55]
+            out[6:8] = len(data).to_bytes(2, 'little'); out[8] = len(part); out[9:9+len(part)] = part
+        elif r[2] == 14 and not r[5]: out[6:10] = b'MO\x01\x1b'
+        elif r[2] == 13: out[6:9] = b'VT\x01'
+        elif r[2] == 14 and self.statuses: out[2] = self.statuses.pop(0)
+        return out
+    def detach_handle(self): self.detached = True; self.handle = None
+    def close(self): self.closed = True
+

mousebridge_mix-0.1.0/tests/test_mix.py

@@ -0,0 +1,75 @@
+import struct
+import unittest
+from unittest.mock import patch,MagicMock
+from fake_transport import FakeTransport
+from mousebridge.motion_initialize import prepare_motion
+
+
+class MixTransport(FakeTransport):
+    def __init__(self):
+        super().__init__()
+        config=bytearray(self.descriptors[0]);config[38]=2
+        config.extend(bytes((7,5,3,3,16,0,1)));config[2:4]=len(config).to_bytes(2,'little')
+        self.descriptors[0]=bytes(config)
+    def get_feature_report(self,rid,length):
+        result=super().get_feature_report(rid,length)
+        if self.request[2]==14:
+            result[6:9]=b'MX\x02';result[11]=3;result[12]=8;result[13]=1
+        return result
+
+
+class MixInitTests(unittest.TestCase):
+    def test_registration_from_descriptor(self):
+        transport=MixTransport()
+        prepared=prepare_motion(transport,mix=True)
+        self.assertEqual(prepared[0][2],16)
+        registration=transport.requests[-2]
+        self.assertEqual(registration[2],15)
+        self.assertEqual(registration[9:13],bytes((16,16,32,16)))
+        self.assertEqual(struct.unpack_from('<iiii',registration,13),(-32768,32767,-32768,32767))
+        self.assertEqual(registration[29:37],b'\0'+b'\xff'*7)
+    def test_old_firmware_rejected(self):
+        with self.assertRaises(RuntimeError): prepare_motion(FakeTransport(),mix=True)
+    def test_no_baseline_rejected_before_native_or_output(self):
+        class NotReady(MixTransport):
+            def get_feature_report(self,rid,length):
+                result=super().get_feature_report(rid,length)
+                if self.request[2]==14:result[13]=0
+                return result
+        from mousebridge.hid_mix import MixDevice
+        transport=NotReady()
+        with patch('mousebridge.hid_mix.ctypes.WinDLL') as load:
+            with self.assertRaisesRegex(RuntimeError,'Пошевелите мышь'):MixDevice(transport)
+        load.assert_not_called()
+        self.assertTrue(transport.closed and not transport.detached)
+    def test_missing_out_rejected(self):
+        transport=MixTransport();transport.descriptors[0]=FakeTransport().descriptors[0]
+        with self.assertRaisesRegex(RuntimeError,'OUT endpoint'): prepare_motion(transport,mix=True)
+
+    def test_native_wrapper_one_call_and_lifetime(self):
+        from mousebridge.hid_mix import MixDevice
+        transport=MixTransport()
+        library=MagicMock()
+        library.MotionCreate.return_value=123
+        with patch('mousebridge.hid_mix.ctypes.WinDLL',return_value=library),patch('mousebridge.hid_mix.release_native') as unload:
+            device=MixDevice(transport)
+            self.assertTrue(transport.closed and transport.detached)
+            count=len(transport.requests)
+            device.send_move(-2147483648,2147483647)
+            library.MotionSendMove.assert_called_once_with(123,-2147483648,2147483647)
+            self.assertEqual(len(transport.requests),count)
+            with self.assertRaises(ValueError):device.send_move(2147483648,0)
+            device.close();device.close()
+            library.MotionClose.assert_called_once_with(123)
+            unload.assert_any_call(library)
+            with self.assertRaises(OSError):device.send_move(0,0)
+
+    def test_failed_native_create_retains_handle(self):
+        from mousebridge.hid_mix import MixDevice
+        transport=MixTransport();library=MagicMock();library.MotionCreate.return_value=0
+        with patch('mousebridge.hid_mix.ctypes.WinDLL',return_value=library),patch('mousebridge.hid_mix.release_native'):
+            with self.assertRaises(OSError):MixDevice(transport)
+        self.assertTrue(transport.closed and not transport.detached)
+
+
+if __name__=='__main__': unittest.main()

mousebridge_mix-0.1.0/tests/test_package.py

@@ -0,0 +1,74 @@
+import ctypes
+import hashlib
+import os
+from pathlib import Path
+import struct
+import sys
+import unittest
+from unittest.mock import patch, MagicMock
+import mousebridge
+from mousebridge import MixDevice
+from test_mix import MixTransport
+
+DLL_SHA = '64FADF3F3180FCEAE86F0F76B4BD4E8D99445C607B5C1150472C24D4B3CC3B9E'
+
+class PackageTests(unittest.TestCase):
+    def test_public_api_and_namespaced_imports(self):
+        self.assertEqual(mousebridge.__version__, '0.1.0')
+        self.assertEqual(mousebridge.init.__module__, 'mousebridge.hid_mix')
+        self.assertNotIn('bridge_protocol', sys.modules)
+        self.assertNotIn('windows_hid', sys.modules)
+
+    def test_dll_hash_and_architecture(self):
+        data = Path(mousebridge.__file__).with_name('mousebridge_mix.dll').read_bytes()
+        self.assertEqual(hashlib.sha256(data).hexdigest().upper(), DLL_SHA)
+        offset = struct.unpack_from('<I', data, 0x3c)[0]
+        self.assertEqual(data[:2], b'MZ')
+        self.assertEqual(data[offset:offset+4], b'PE\0\0')
+        self.assertEqual(struct.unpack_from('<H', data, offset+4)[0], 0x8664)
+        self.assertEqual(struct.unpack_from('<H', data, offset+24)[0], 0x20b)
+
+    @unittest.skipUnless(os.name == 'nt' and ctypes.sizeof(ctypes.c_void_p) == 8, 'Windows x64 native check')
+    def test_native_load_exports_without_device(self):
+        path = Path(mousebridge.__file__).with_name('mousebridge_mix.dll')
+        library = ctypes.WinDLL(str(path), use_last_error=True)
+        try:
+            create = library.MotionCreate
+            create.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.c_uint, ctypes.c_uint, ctypes.c_uint, ctypes.c_uint]
+            create.restype = ctypes.c_void_p
+            self.assertFalse(create(None, None, 0, 0, 0, 0))
+            self.assertEqual(ctypes.get_last_error(), 87)
+            self.assertTrue(library.MotionSendMove and library.MotionClose)
+        finally:
+            from mousebridge.hid_motion import release_native
+            release_native(library)
+
+    def test_missing_dll_closes_transport(self):
+        transport = MixTransport()
+        with patch('mousebridge.hid_mix.Path.is_file', return_value=False), patch('mousebridge.hid_mix.ctypes.WinDLL') as load:
+            with self.assertRaisesRegex(OSError, 'reinstall'): MixDevice(transport)
+        load.assert_not_called(); self.assertTrue(transport.closed)
+
+    def test_wrong_python_bitness_never_loads_native(self):
+        transport = MixTransport()
+        with patch('mousebridge.hid_mix.ctypes.sizeof', return_value=4), patch('mousebridge.hid_mix.ctypes.WinDLL') as load:
+            with self.assertRaisesRegex(OSError, '64-bit'): MixDevice(transport)
+        load.assert_not_called(); self.assertTrue(transport.closed)
+
+    def test_write_shape_int32_bounds_and_single_native_call(self):
+        transport = MixTransport(); library = MagicMock(); library.MotionCreate.return_value = 123
+        with patch('mousebridge.hid_mix.ctypes.WinDLL', return_value=library), patch('mousebridge.hid_mix.release_native'):
+            with MixDevice(transport) as device:
+                count = len(transport.requests)
+                device.write(1, struct.pack('<hh', 20, -20), timeout=8)
+                library.MotionSendMove.assert_called_once_with(123, 20, -20)
+                self.assertEqual(len(transport.requests), count)
+                for xy in [(True,0), (0,1.0)]:
+                    with self.assertRaises(TypeError): device.send_move(*xy)
+                for xy in [(-2147483649,0), (0,2147483648)]:
+                    with self.assertRaises(ValueError): device.send_move(*xy)
+                with self.assertRaises(ValueError): device.write(99, b'1234')
+                with self.assertRaises(struct.error): device.write(1, b'123')
+            library.MotionClose.assert_called_once_with(123)
+
+if __name__ == '__main__': unittest.main()