airmouse-core 2.0.0__tar.gz

airmouse_core-2.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 AirMouse Team
+
+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.

airmouse_core-2.0.0/PKG-INFO

@@ -0,0 +1,247 @@
+Metadata-Version: 2.4
+Name: airmouse-core
+Version: 2.0.0
+Summary: High-performance, secure Python server and protocol engine for AirMouse remote input devices
+Author-email: AirMouse Team <dev@airmouse.io>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/AirMouse/AirMouse
+Project-URL: Documentation, https://github.com/AirMouse/AirMouse/tree/main/pc/airmouse_py
+Project-URL: Repository, https://github.com/AirMouse/AirMouse.git
+Project-URL: Issues, https://github.com/AirMouse/AirMouse/issues
+Project-URL: Changelog, https://github.com/AirMouse/AirMouse/blob/main/CHANGELOG.md
+Keywords: airmouse,remote-mouse,input-devices,gyroscope,accelerometer,websocket,tcp,udp-discovery,one-euro-filter,jitter-buffer,zero-latency
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: System :: Hardware :: Hardware Drivers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: pynput>=1.7.6
+Requires-Dist: cryptography>=42.0.0
+Requires-Dist: websockets>=12.0
+Requires-Dist: qrcode[pil]>=7.4.2
+Requires-Dist: pillow>=10.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.1.0; extra == "dev"
+Requires-Dist: build>=1.0.0; extra == "dev"
+Requires-Dist: twine>=5.0.0; extra == "dev"
+Dynamic: license-file
+
+<div align="center">
+
+# 🖱️ AirMouse Core (`airmouse-core`)
+
+[![PyPI version](https://img.shields.io/pypi/v/airmouse-core.svg?color=blue)](https://pypi.org/project/airmouse-core/)
+[![Python Versions](https://img.shields.io/pypi/pyversions/airmouse-core.svg)](https://pypi.org/project/airmouse-core/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Code Style](https://img.shields.io/badge/code%20style-PEP%20561-green.svg)](https://peps.python.org/pep-0561/)
+[![Tests Coverage](https://img.shields.io/badge/coverage-88%25-brightgreen.svg)]()
+
+**High-performance, ultra-low-latency remote mouse and input server engine for Python.**  
+Seamlessly turns Android, iOS, or web client devices into responsive air mice with hardware-grade cursor smoothing, robust replay-attack mitigation, and TLS 1.2+ encryption.
+
+[Key Features](#-key-features) • [Installation](#-installation) • [Quick Start CLI](#-quick-start-cli) • [Python API](#-python-api) • [Architecture](#-architecture) • [Protocol V2](#-protocol-v2-specification) • [Testing](#-test-suite)
+
+</div>
+
+---
+
+## ⚡ Key Features
+
+- 🔒 **Enterprise-Grade TLS Security**:
+  - Full TLS 1.2+ encryption on both TCP and WebSocket connections.
+  - Automatic self-signed X.509 certificate provisioning with persistent key storage (`0600` permissions) to prevent TLS pinning breaks on server reboot.
+- 📱 **Zero-Friction Terminal QR Pairing**:
+  - Out-of-the-box CLI displays ANSI QR codes right in your terminal for 1-second camera scan pairing from mobile devices.
+- 🎯 **1€ (One Euro) Adaptive Smoothing**:
+  - Implements Casiez et al. adaptive low-pass filter algorithm to eliminate micro-jitter during slow precision movements while eliminating lag during fast sweeps.
+- 🌐 **LAN Auto-Discovery**:
+  - Multithreaded UDP broadcast responder with cryptographic challenge-response nonces for instantaneous zero-configuration LAN discovery.
+- 🧵 **Thread-Safe Actuation Decoupling**:
+  - Completely decouples high-frequency network I/O (`asyncio`) from OS windowing/mouse controller drivers (`pynput`) via an internal thread-safe queue.
+- 🛡️ **Anti-Replay Attack Protection**:
+  - Enforces sliding timestamp freshness windows and per-session monotonic sequence numbering.
+- 📦 **PEP 561 Compliant**:
+  - Full typing support with `py.typed` marker for static analysis with mypy, pyright, and modern IDE auto-complete.
+
+---
+
+## 📥 Installation
+
+Install the stable release directly from PyPI:
+
+```bash
+pip install airmouse-core
+```
+
+Or install with development dependencies:
+
+```bash
+pip install airmouse-core[dev]
+```
+
+---
+
+## 🚀 Quick Start CLI
+
+Run the production server directly from the command line:
+
+```bash
+airmouse-server --port 8080 --ws-port 8081 --udp-port 8083 --qr
+```
+
+### CLI Options:
+
+| Flag | Description | Default |
+|------|-------------|---------|
+| `--host` | Bind interface address | `0.0.0.0` |
+| `--port` | TCP listening port | `8080` |
+| `--ws-port` | WebSocket listening port | `8081` |
+| `--udp-port` | UDP LAN discovery broadcast port | `8083` |
+| `--qr` | Render terminal ANSI QR code for mobile pairing | `False` |
+| `--no-tls` | Disable TLS encryption | `False` (TLS enabled) |
+| `--no-smoothing` | Disable 1€ adaptive filter | `False` (Smoothing enabled) |
+| `--sensitivity` | Mouse cursor speed multiplier | `1.0` |
+| `--name` | Friendly server display name | `AirMouse Server` |
+
+---
+
+## 💻 Python API
+
+`airmouse-core` exposes a clean, intuitive public API:
+
+```python
+import asyncio
+from airmouse import (
+    AirMouseServer,
+    OneEuroFilter,
+    UDPJitterBuffer,
+    AuthManager,
+    ProtocolParser,
+)
+
+async def main():
+    # 1. Initialize server
+    server = AirMouseServer(
+        host="0.0.0.0",
+        tcp_port=8080,
+        ws_port=8081,
+        udp_port=8083,
+        enable_tls=True,
+        sensitivity=1.2,
+        smoothing=True,
+    )
+
+    # 2. Register lifecycle and input event callbacks
+    server.on_connect(lambda session_id: print(f"Client connected: {session_id}"))
+    server.on_disconnect(lambda session_id: print(f"Client disconnected: {session_id}"))
+    server.on_move(lambda dx, dy: print(f"Motion: dx={dx:.2f}, dy={dy:.2f}"))
+    server.on_click(lambda button: print(f"Click: {button}"))
+
+    # 3. Start server
+    await server.start()
+    print("AirMouse Server is running. Press Ctrl+C to exit.")
+
+    try:
+        await asyncio.Event().wait()
+    finally:
+        await server.stop()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+---
+
+## 🏗️ Architecture
+
+```
+ Mobile / Web Client (Android / iOS / Browser)
+                     │
+         ┌───────────┴───────────┐
+         ▼                       ▼
+   [TCP TLS 1.2+]         [WebSocket TLS]
+         │                       │
+         └───────────┬───────────┘
+                     │  (Asyncio Network Loop)
+                     ▼
+             ProtocolParser (V2)
+       [Replay & Bounds Validation]
+                     │
+                     ▼
+          Thread-Safe Command Queue
+                     │
+                     ▼
+            MouseActuatorThread
+         [OneEuroFilter Smoothing]
+                     │
+                     ▼
+       OS Cursor Actuation (pynput)
+```
+
+---
+
+## 📡 Protocol V2 Specification
+
+Every wire packet follows the strict canonical V2 envelope:
+
+```json
+{
+  "v": 2,
+  "type": "move",
+  "seq": 1024,
+  "ts": 1729771200000,
+  "id": "optional-request-id",
+  "payload": {
+    "dx": 12.5,
+    "dy": -3.2,
+    "dt": 0.016
+  }
+}
+```
+
+### Supported Message Types:
+- **`hello`**: Initial handshake pairing request carrying HMAC token.
+- **`welcome`**: Server approval response.
+- **`move`**: Relative mouse coordinates (`dx`, `dy`, `dt`).
+- **`click`**: Mouse button clicks (`left`, `right`, `middle`, `double`).
+- **`scroll`**: Wheel scroll offset (`delta`).
+- **`key`**: Keyboard input events (`key`, `modifiers`).
+- **`discover` / `offer`**: UDP LAN pairing handshake.
+- **`ping` / `pong`**: Heartbeat and connection keep-alive.
+
+---
+
+## 🧪 Test Suite
+
+The test suite covers 100% of the core functionality with high test coverage:
+
+```bash
+cd pc/airmouse_py
+pytest --cov=. --cov-report=term-missing tests
+```
+
+**Results:**
+- **46 passing unit and integration tests**
+- **88% code coverage**
+- Automated testing for replay protection, crypto HMAC validation, TLS X.509 generation, and socket concurrency.
+
+---
+
+## 📄 License
+
+This project is licensed under the [MIT License](LICENSE).

airmouse_core-2.0.0/README.md

@@ -0,0 +1,204 @@
+<div align="center">
+
+# 🖱️ AirMouse Core (`airmouse-core`)
+
+[![PyPI version](https://img.shields.io/pypi/v/airmouse-core.svg?color=blue)](https://pypi.org/project/airmouse-core/)
+[![Python Versions](https://img.shields.io/pypi/pyversions/airmouse-core.svg)](https://pypi.org/project/airmouse-core/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Code Style](https://img.shields.io/badge/code%20style-PEP%20561-green.svg)](https://peps.python.org/pep-0561/)
+[![Tests Coverage](https://img.shields.io/badge/coverage-88%25-brightgreen.svg)]()
+
+**High-performance, ultra-low-latency remote mouse and input server engine for Python.**  
+Seamlessly turns Android, iOS, or web client devices into responsive air mice with hardware-grade cursor smoothing, robust replay-attack mitigation, and TLS 1.2+ encryption.
+
+[Key Features](#-key-features) • [Installation](#-installation) • [Quick Start CLI](#-quick-start-cli) • [Python API](#-python-api) • [Architecture](#-architecture) • [Protocol V2](#-protocol-v2-specification) • [Testing](#-test-suite)
+
+</div>
+
+---
+
+## ⚡ Key Features
+
+- 🔒 **Enterprise-Grade TLS Security**:
+  - Full TLS 1.2+ encryption on both TCP and WebSocket connections.
+  - Automatic self-signed X.509 certificate provisioning with persistent key storage (`0600` permissions) to prevent TLS pinning breaks on server reboot.
+- 📱 **Zero-Friction Terminal QR Pairing**:
+  - Out-of-the-box CLI displays ANSI QR codes right in your terminal for 1-second camera scan pairing from mobile devices.
+- 🎯 **1€ (One Euro) Adaptive Smoothing**:
+  - Implements Casiez et al. adaptive low-pass filter algorithm to eliminate micro-jitter during slow precision movements while eliminating lag during fast sweeps.
+- 🌐 **LAN Auto-Discovery**:
+  - Multithreaded UDP broadcast responder with cryptographic challenge-response nonces for instantaneous zero-configuration LAN discovery.
+- 🧵 **Thread-Safe Actuation Decoupling**:
+  - Completely decouples high-frequency network I/O (`asyncio`) from OS windowing/mouse controller drivers (`pynput`) via an internal thread-safe queue.
+- 🛡️ **Anti-Replay Attack Protection**:
+  - Enforces sliding timestamp freshness windows and per-session monotonic sequence numbering.
+- 📦 **PEP 561 Compliant**:
+  - Full typing support with `py.typed` marker for static analysis with mypy, pyright, and modern IDE auto-complete.
+
+---
+
+## 📥 Installation
+
+Install the stable release directly from PyPI:
+
+```bash
+pip install airmouse-core
+```
+
+Or install with development dependencies:
+
+```bash
+pip install airmouse-core[dev]
+```
+
+---
+
+## 🚀 Quick Start CLI
+
+Run the production server directly from the command line:
+
+```bash
+airmouse-server --port 8080 --ws-port 8081 --udp-port 8083 --qr
+```
+
+### CLI Options:
+
+| Flag | Description | Default |
+|------|-------------|---------|
+| `--host` | Bind interface address | `0.0.0.0` |
+| `--port` | TCP listening port | `8080` |
+| `--ws-port` | WebSocket listening port | `8081` |
+| `--udp-port` | UDP LAN discovery broadcast port | `8083` |
+| `--qr` | Render terminal ANSI QR code for mobile pairing | `False` |
+| `--no-tls` | Disable TLS encryption | `False` (TLS enabled) |
+| `--no-smoothing` | Disable 1€ adaptive filter | `False` (Smoothing enabled) |
+| `--sensitivity` | Mouse cursor speed multiplier | `1.0` |
+| `--name` | Friendly server display name | `AirMouse Server` |
+
+---
+
+## 💻 Python API
+
+`airmouse-core` exposes a clean, intuitive public API:
+
+```python
+import asyncio
+from airmouse import (
+    AirMouseServer,
+    OneEuroFilter,
+    UDPJitterBuffer,
+    AuthManager,
+    ProtocolParser,
+)
+
+async def main():
+    # 1. Initialize server
+    server = AirMouseServer(
+        host="0.0.0.0",
+        tcp_port=8080,
+        ws_port=8081,
+        udp_port=8083,
+        enable_tls=True,
+        sensitivity=1.2,
+        smoothing=True,
+    )
+
+    # 2. Register lifecycle and input event callbacks
+    server.on_connect(lambda session_id: print(f"Client connected: {session_id}"))
+    server.on_disconnect(lambda session_id: print(f"Client disconnected: {session_id}"))
+    server.on_move(lambda dx, dy: print(f"Motion: dx={dx:.2f}, dy={dy:.2f}"))
+    server.on_click(lambda button: print(f"Click: {button}"))
+
+    # 3. Start server
+    await server.start()
+    print("AirMouse Server is running. Press Ctrl+C to exit.")
+
+    try:
+        await asyncio.Event().wait()
+    finally:
+        await server.stop()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+---
+
+## 🏗️ Architecture
+
+```
+ Mobile / Web Client (Android / iOS / Browser)
+                     │
+         ┌───────────┴───────────┐
+         ▼                       ▼
+   [TCP TLS 1.2+]         [WebSocket TLS]
+         │                       │
+         └───────────┬───────────┘
+                     │  (Asyncio Network Loop)
+                     ▼
+             ProtocolParser (V2)
+       [Replay & Bounds Validation]
+                     │
+                     ▼
+          Thread-Safe Command Queue
+                     │
+                     ▼
+            MouseActuatorThread
+         [OneEuroFilter Smoothing]
+                     │
+                     ▼
+       OS Cursor Actuation (pynput)
+```
+
+---
+
+## 📡 Protocol V2 Specification
+
+Every wire packet follows the strict canonical V2 envelope:
+
+```json
+{
+  "v": 2,
+  "type": "move",
+  "seq": 1024,
+  "ts": 1729771200000,
+  "id": "optional-request-id",
+  "payload": {
+    "dx": 12.5,
+    "dy": -3.2,
+    "dt": 0.016
+  }
+}
+```
+
+### Supported Message Types:
+- **`hello`**: Initial handshake pairing request carrying HMAC token.
+- **`welcome`**: Server approval response.
+- **`move`**: Relative mouse coordinates (`dx`, `dy`, `dt`).
+- **`click`**: Mouse button clicks (`left`, `right`, `middle`, `double`).
+- **`scroll`**: Wheel scroll offset (`delta`).
+- **`key`**: Keyboard input events (`key`, `modifiers`).
+- **`discover` / `offer`**: UDP LAN pairing handshake.
+- **`ping` / `pong`**: Heartbeat and connection keep-alive.
+
+---
+
+## 🧪 Test Suite
+
+The test suite covers 100% of the core functionality with high test coverage:
+
+```bash
+cd pc/airmouse_py
+pytest --cov=. --cov-report=term-missing tests
+```
+
+**Results:**
+- **46 passing unit and integration tests**
+- **88% code coverage**
+- Automated testing for replay protection, crypto HMAC validation, TLS X.509 generation, and socket concurrency.
+
+---
+
+## 📄 License
+
+This project is licensed under the [MIT License](LICENSE).

airmouse_core-2.0.0/airmouse/__init__.py

@@ -0,0 +1,21 @@
+"""
+AirMouse Core Library
+~~~~~~~~~~~~~~~~~~~~~
+Production-grade Python package for AirMouse servers and input processing.
+"""
+
+from core.jitter_buffer import UDPJitterBuffer
+from core.one_euro import OneEuroFilter
+from network.protocol import ProtocolParser
+from security.auth import AuthManager
+from airmouse.server import AirMouseServer
+
+__version__ = "2.0.0"
+
+__all__ = [
+    "AirMouseServer",
+    "OneEuroFilter",
+    "UDPJitterBuffer",
+    "AuthManager",
+    "ProtocolParser",
+]

airmouse_core-2.0.0/airmouse/cli.py

@@ -0,0 +1,201 @@
+"""
+airmouse.cli
+------------
+Command Line Interface for AirMouse server.
+Generates terminal QR code for zero-friction client pairing and runs the server out-of-the-box.
+"""
+
+import argparse
+import asyncio
+import io
+import json
+import logging
+import os
+import signal
+import socket
+import sys
+from typing import Optional
+
+import qrcode
+
+from airmouse.server import AirMouseServer
+from security.auth import AuthManager
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+)
+logger = logging.getLogger("AirMouseCLI")
+
+
+def get_local_ip() -> str:
+    """Best-effort discovery of non-loopback LAN IP address."""
+    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    try:
+        # Does not actually connect but picks the outgoing route interface
+        s.connect(("8.8.8.8", 80))
+        ip = s.getsockname()[0]
+    except Exception:
+        ip = "127.0.0.1"
+    finally:
+        s.close()
+    return ip
+
+
+def display_terminal_qr(data: str) -> None:
+    """Prints an ASCII/ANSI QR code directly in the terminal."""
+    qr = qrcode.QRCode(
+        version=1,
+        error_correction=qrcode.constants.ERROR_CORRECT_L,
+        box_size=1,
+        border=1,
+    )
+    qr.add_data(data)
+    qr.make(fit=True)
+
+    f = io.StringIO()
+    qr.print_ascii(out=f, invert=True)
+    f.seek(0)
+    print(f.read())
+
+
+def parse_args(argv=None) -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        prog="airmouse-server",
+        description="AirMouse Server - Zero-latency, TLS-secured remote input server",
+    )
+    parser.add_argument(
+        "--host",
+        type=str,
+        default="0.0.0.0",
+        help="IP address to bind to (default: 0.0.0.0)",
+    )
+    parser.add_argument(
+        "--port",
+        type=int,
+        default=8080,
+        help="TCP listening port (default: 8080)",
+    )
+    parser.add_argument(
+        "--ws-port",
+        type=int,
+        default=8081,
+        help="WebSocket listening port (default: 8081)",
+    )
+    parser.add_argument(
+        "--udp-port",
+        type=int,
+        default=8083,
+        help="UDP discovery broadcast listening port (default: 8083)",
+    )
+    parser.add_argument(
+        "--no-tls",
+        action="store_true",
+        help="Disable TLS encryption (TLS 1.2+ is enabled by default)",
+    )
+    parser.add_argument(
+        "--no-smoothing",
+        action="store_true",
+        help="Disable 1€ adaptive low-pass filter smoothing",
+    )
+    parser.add_argument(
+        "--sensitivity",
+        type=float,
+        default=1.0,
+        help="Mouse speed multiplier (default: 1.0)",
+    )
+    parser.add_argument(
+        "--qr",
+        action="store_true",
+        help="Display terminal QR code for instant Android client pairing",
+    )
+    parser.add_argument(
+        "--name",
+        type=str,
+        default="AirMouse Server",
+        help="Friendly server display name",
+    )
+    return parser.parse_args(argv)
+
+
+async def run_server(args: argparse.Namespace) -> None:
+    auth_mgr = AuthManager()
+    token = auth_mgr.generate_token("cli_client")
+    lan_ip = get_local_ip()
+
+    enable_tls = not args.no_tls
+
+    pairing_payload = {
+        "host": lan_ip,
+        "tcp_port": args.port,
+        "ws_port": args.ws_port,
+        "token": token,
+        "tls": enable_tls,
+        "name": args.name,
+    }
+    pairing_json = json.dumps(pairing_payload)
+
+    print("=" * 60)
+    print(f"  {args.name}")
+    print(f"  LAN Address: {lan_ip}")
+    print(f"  TCP Port   : {args.port} (TLS: {enable_tls})")
+    print(f"  WS Port    : {args.ws_port} (TLS: {enable_tls})")
+    print(f"  UDP Port   : {args.udp_port}")
+    print(f"  Pairing Token: {token}")
+    print("=" * 60)
+
+    if args.qr:
+        print("\nScan this QR code with the AirMouse Android App to pair:\n")
+        try:
+            display_terminal_qr(pairing_json)
+        except Exception as e:
+            logger.warning(f"Could not print QR code to terminal: {e}")
+
+    server = AirMouseServer(
+        host=args.host,
+        tcp_port=args.port,
+        ws_port=args.ws_port,
+        udp_port=args.udp_port,
+        enable_tls=enable_tls,
+        auth_manager=auth_mgr,
+        sensitivity=args.sensitivity,
+        smoothing=not args.no_smoothing,
+        server_name=args.name,
+    )
+
+    server.on_connect(lambda s_id: logger.info(f"[Event] Client Connected: {s_id}"))
+    server.on_disconnect(lambda s_id: logger.info(f"[Event] Client Disconnected: {s_id}"))
+    server.on_click(lambda btn: logger.debug(f"[Event] Mouse Click: {btn}"))
+
+    await server.start()
+    logger.info("AirMouse server started successfully and ready for connections.")
+
+    stop_event = asyncio.Event()
+
+    def _shutdown():
+        logger.info("Shutdown signal received, shutting down gracefully...")
+        stop_event.set()
+
+    for sig in (signal.SIGINT, signal.SIGTERM):
+        try:
+            asyncio.get_running_loop().add_signal_handler(sig, _shutdown)
+        except NotImplementedError:
+            pass
+
+    try:
+        await stop_event.wait()
+    finally:
+        await server.stop()
+        logger.info("AirMouse server shut down cleanly.")
+
+
+def main(argv=None) -> None:
+    args = parse_args(argv)
+    try:
+        asyncio.run(run_server(args))
+    except KeyboardInterrupt:
+        pass
+
+
+if __name__ == "__main__":
+    main()

airmouse_core-2.0.0/airmouse/py.typed

@@ -0,0 +1 @@
+# Marker file for PEP 561 type checking.