Sync Client

def __del__(self):
    """Cleanup on deletion."""
    # Unregister atexit handler if object is deleted manually
    try:
        atexit.unregister(self._cleanup_on_exit)
    except Exception:
        pass

    try:
        if self._async_client._connected:
            self.disconnect()
    except Exception:
        pass
    finally:
        self._cleanup_loop()

def __enter__(self):
    """Context manager entry."""
    self.connect()
    return self

def __exit__(self, exc_type, exc_val, exc_tb):
    """Context manager exit."""
    self.disconnect()

def __getattr__(self, name: str):
    """Delegate attribute access to async client, wrapping coroutines.

    This allows automatic synchronous wrapping of all async methods without
    explicit redefinition, reducing code duplication.
    """
    attr = getattr(self._async_client, name)

    # If it's a coroutine function, wrap it to run synchronously
    if asyncio.iscoroutinefunction(attr):
        def sync_wrapper(*args, **kwargs):
            return self._run_async(attr(*args, **kwargs))
        # Preserve function metadata for better IDE support
        sync_wrapper.__name__ = name
        sync_wrapper.__doc__ = attr.__doc__
        return sync_wrapper

    # Otherwise return the attribute as-is
    return attr

def __init__(self, address: str):
    """Initialize the Client.

    Args:
        address: Bluetooth device address (e.g., "1D:6B:5E:B5:A5:54")
    """
    self._async_client = AsyncClient(address)
    self._loop: Optional[asyncio.AbstractEventLoop] = None
    self._loop_thread = None
    self._setup_loop()

# Dynamically add command methods to AsyncClient

    DeviceInfo object with device specifications.

Raises:

for cmd_name, cmd_func in COMMANDS.items():
    setattr(AsyncClient, cmd_name, _create_async_method(cmd_name, cmd_func))

"""
return self._session.get_device_info()

    """Ensure the client is connected."""
    if not self._connected:
        raise RuntimeError("Client not connected. Call connect() first")

async def __aenter__(self):
    """Async context manager entry."""
    await self.connect()

@staticmethod
def scan(timeout: float = 5.0):
    """Scan for compatible LED devices synchronously."""
    return scan_devices_sync(timeout=timeout)

class Client:
    """Synchronous client for controlling the LED matrix via BLE.

This is a synchronous wrapper around AsyncClient that handles the event loop
automatically for simpler usage in non-async code.
"""

@staticmethod
def scan(timeout: float = 5.0):

"""Scan for compatible LED devices synchronously."""
return scan_devices_sync(timeout=timeout)

def __init__(self, address: str):
    """Initialize the Client.

Args:
    address: Bluetooth device address (e.g., "1D:6B:5E:B5:A5:54")
"""

self._async_client = AsyncClient(address)
self._loop: Optional[asyncio.AbstractEventLoop] = None
self._loop_thread = None

    self._setup_loop()

def _setup_loop(self):

"""Set up a persistent event loop in a separate thread."""
import threading

def start_loop(loop):
    asyncio.set_event_loop(loop)
    loop.run_forever()

self._loop = asyncio.new_event_loop()
self._loop_thread = threading.Thread(target=start_loop, args=(self._loop,), daemon=True)

self._loop_thread.start()

# Register cleanup handler to ensure disconnection on exit

    atexit.register(self._cleanup_on_exit)

def _cleanup_on_exit(self):

"""Cleanup handler for atexit."""
try:
    if self._async_client._connected:

        self.disconnect()
except Exception:
    pass

finally:
    self._cleanup_loop()

async def __aexit__(self, exc_type, exc_val, exc_tb):
    """Async context manager exit."""