ryseble 1.0.0__tar.gz

ryseble-1.0.0/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+
+Copyright (c) 2025 RYSE
+
+
+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 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.

ryseble-1.0.0/PKG-INFO

@@ -0,0 +1,43 @@
+Metadata-Version: 2.4
+Name: ryseble
+Version: 1.0.0
+Summary: Python library for RYSE BLE Smart Shade devices (used by Home Assistant integration).
+Author-email: MOHAMED Kallel <mohamed.kallel@yahoo.fr>
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: bleak>=0.22.0
+Dynamic: license-file
+
+
+# === README.md ===
+# ryseble
+
+A small Python library to interact with RYSE BLE Smart Shade devices. Designed to be
+used by Home Assistant integrations but reusable in other projects.
+
+## Features
+- Pair/connect/disconnect with device
+- Read/write raw packets
+- Helpers to build position/get-position packets
+
+## Installation
+
+```bash
+pip install ryseble
+```
+
+## Usage (example)
+
+```python
+from ryseble.device import RyseBLEDevice
+from ryseble.packets import build_position_packet, build_get_position_packet
+
+device = RyseBLEDevice(address="AA:BB:CC:DD:EE:FF", rx_uuid="...", tx_uuid="...")
+await device.pair()
+await device.write_data(build_position_packet(50))
+```

ryseble-1.0.0/README.md

@@ -0,0 +1,28 @@
+
+# === README.md ===
+# ryseble
+
+A small Python library to interact with RYSE BLE Smart Shade devices. Designed to be
+used by Home Assistant integrations but reusable in other projects.
+
+## Features
+- Pair/connect/disconnect with device
+- Read/write raw packets
+- Helpers to build position/get-position packets
+
+## Installation
+
+```bash
+pip install ryseble
+```
+
+## Usage (example)
+
+```python
+from ryseble.device import RyseBLEDevice
+from ryseble.packets import build_position_packet, build_get_position_packet
+
+device = RyseBLEDevice(address="AA:BB:CC:DD:EE:FF", rx_uuid="...", tx_uuid="...")
+await device.pair()
+await device.write_data(build_position_packet(50))
+```

ryseble-1.0.0/pyproject.toml

@@ -0,0 +1,21 @@
+[project]
+name = "ryseble"
+version = "1.0.0"
+description = "Python library for RYSE BLE Smart Shade devices (used by Home Assistant integration)."
+readme = "README.md"
+requires-python = ">=3.9"
+license = {text = "MIT"}
+authors = [ { name = "MOHAMED Kallel", email = "mohamed.kallel@yahoo.fr" } ]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "License :: OSI Approved :: MIT License",
+  "Operating System :: OS Independent",
+]
+
+dependencies = [
+  "bleak>=0.22.0"
+]
+
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"

ryseble-1.0.0/ryseble/__init__.py

@@ -0,0 +1,26 @@
+"""
+Ryse BLE Python Library
+~~~~~~~~~~~~~~~~~~~~~~~
+This library provides tools to communicate with Ryse gears
+over Bluetooth Low Energy (BLE).
+
+Modules:
+- device: RyseBLEDevice class for managing connections
+- packets: Helpers to build BLE packets
+- constants: Protocol constants and UUIDs
+- bluetoothctl: Bluetoothctl wrapper functions
+"""
+
+from .device import RyseBLEDevice
+from .packets import build_position_packet, build_get_position_packet
+from .constants import HARDCODED_UUIDS, PAIRING_MODE_FLAG
+from . import bluetoothctl
+
+__all__ = [
+    "RyseBLEDevice",
+    "build_position_packet",
+    "build_get_position_packet",
+    "HARDCODED_UUIDS",
+    "PAIRING_MODE_FLAG",
+    "bluetoothctl",
+]

ryseble-1.0.0/ryseble/bluetoothctl.py

@@ -0,0 +1,72 @@
+import asyncio
+import subprocess
+from typing import Optional
+
+def close_process(process: subprocess.Popen) -> None:
+    """Close a running process gracefully."""
+    if process and process.poll() is None:
+        process.terminate()
+        try:
+            process.wait(timeout=2)
+        except subprocess.TimeoutExpired:
+            process.kill()
+
+async def run_command(command: str) -> str:
+    """Run a shell command asynchronously and return its output."""
+    proc = await asyncio.create_subprocess_shell(
+        command,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+    )
+    stdout, stderr = await proc.communicate()
+    if proc.returncode != 0:
+        raise RuntimeError(f"Command failed: {command}\n{stderr.decode()}")
+    return stdout.decode().strip()
+
+def start_bluetoothctl() -> subprocess.Popen:
+    """Start a bluetoothctl subprocess."""
+    return subprocess.Popen(
+        ["bluetoothctl"],
+        stdin=subprocess.PIPE,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True,
+    )
+
+async def send_command_in_process(
+    process: subprocess.Popen, command: str, delay: float = 2
+) -> None:
+    """Send a command to bluetoothctl process."""
+    if process.stdin is None:
+        raise RuntimeError("Process has no stdin")
+    process.stdin.write(command + "\n")
+    process.stdin.flush()
+    await asyncio.sleep(delay)
+
+async def is_device_connected(address: str) -> bool:
+    """Check if a device is connected via bluetoothctl."""
+    output = await run_command(f"bluetoothctl info {address}")
+    return "Connected: yes" in output
+
+async def is_device_bonded(address: str) -> bool:
+    """Check if a device is bonded via bluetoothctl."""
+    output = await run_command(f"bluetoothctl info {address}")
+    return "Bonded: yes" in output
+
+async def is_device_paired(address: str) -> bool:
+    """Check if a device is paired via bluetoothctl."""
+    output = await run_command(f"bluetoothctl info {address}")
+    return "Paired: yes" in output
+
+async def get_first_manufacturer_data_byte(mac_address: str) -> Optional[int]:
+    """Fetch the first manufacturer data byte for a given MAC address."""
+    output = await run_command(f"bluetoothctl info {mac_address}")
+    for line in output.splitlines():
+        if "ManufacturerData Key" in line:
+            try:
+                # Extract first byte (assumes hex like 0x01 0x02 …)
+                hex_values = line.split(":")[1].strip().split()
+                return int(hex_values[0], 16)
+            except Exception:
+                return None
+    return None

ryseble-1.0.0/ryseble/constants.py

@@ -0,0 +1,8 @@
+# Hardcoded UUIDs used by Ryse devices
+HARDCODED_UUIDS = {
+    "rx_uuid": "a72f2801-b0bd-498b-b4cd-4a3901388238",
+    "tx_uuid": "a72f2802-b0bd-498b-b4cd-4a3901388238",
+}
+
+# Pairing mode flag
+PAIRING_MODE_FLAG = 0x01

ryseble-1.0.0/ryseble/device.py

@@ -0,0 +1,126 @@
+"""RyseBLEDevice: async wrapper around Bleak for RYSE devices.
+
+This module intentionally keeps responsibilities small: connect/disconnect,
+read/write GATT characteristics, and deliver notifications via a callback.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from typing import Callable, Optional
+from bleak import BleakClient, BleakScanner
+import logging
+
+_LOGGER = logging.getLogger(__name__)
+
+class RyseBLEDevice:
+    """Represent a RYSE device and provide async methods to interact with it."""
+
+    def __init__(self, address: Optional[str] = None, rx_uuid: Optional[str] = None, tx_uuid: Optional[str] = None):
+        self.address = address
+        self.rx_uuid = rx_uuid
+        self.tx_uuid = tx_uuid
+        self.client: Optional[BleakClient] = None
+        # Optional async callback: async def cb(position: int)
+        self.update_callback: Optional[Callable[[int], None]] = None
+
+    async def pair(self, timeout: float = 30.0) -> bool:
+        """Connect to the device and subscribe to notifications."""
+        if not self.address:
+            _LOGGER.error("No device address provided for pairing.")
+            return False
+
+        _LOGGER.debug("Connecting to device %s", self.address)
+        self.client = BleakClient(self.address)
+        try:
+            await self.client.connect(timeout=timeout)
+            if self.client.is_connected:
+                _LOGGER.debug("Connected to %s", self.address)
+                if self.rx_uuid:
+                    try:
+                        await self.client.start_notify(self.rx_uuid, self._notification_handler)
+                        _LOGGER.debug("Started notify on %s", self.rx_uuid)
+                    except Exception as e:
+                        _LOGGER.debug("Could not start notify: %s", e)
+                return True
+        except Exception as e:
+            _LOGGER.error("Failed to connect to %s: %s", self.address, e)
+        return False
+
+    async def disconnect(self):
+        if self.client:
+            try:
+                if self.rx_uuid:
+                    try:
+                        await self.client.stop_notify(self.rx_uuid)
+                    except Exception:
+                        pass
+                await self.client.disconnect()
+            except Exception as e:
+                _LOGGER.debug("Error during disconnect: %s", e)
+            finally:
+                self.client = None
+
+    async def _notification_handler(self, sender, data: bytes):
+        """Handle BLE notifications from the device.
+
+        Filter and extract position update (protocol-specific). If a callback
+        is registered it will be awaited.
+        """
+        try:
+            # Basic validation based on observed protocol
+            if len(data) >= 5 and data[0] == 0xF5 and data[2] == 0x01 and data[3] == 0x18:
+                # ignore REPORT USER TARGET data
+                return
+
+            _LOGGER.debug("Received notification: %s", data.hex())
+
+            if len(data) >= 5 and data[0] == 0xF5 and data[2] == 0x01 and data[3] == 0x07:
+                position = data[4]
+                _LOGGER.debug("Parsed position: %d", position)
+                if self.update_callback:
+                    # allow callback to be coroutine or normal function
+                    if asyncio.iscoroutinefunction(self.update_callback):
+                        await self.update_callback(position)
+                    else:
+                        # run sync callbacks in event loop
+                        loop = asyncio.get_running_loop()
+                        loop.call_soon(self.update_callback, position)
+        except Exception as e:
+            _LOGGER.exception("Error in notification handler: %s", e)
+
+    async def read_data(self) -> Optional[bytes]:
+        """Read raw data from RX characteristic (if available)."""
+        if not self.client or not self.client.is_connected:
+            _LOGGER.debug("Client not connected for read")
+            return None
+        if not self.rx_uuid:
+            _LOGGER.debug("No RX UUID configured for read")
+            return None
+        try:
+            data = await self.client.read_gatt_char(self.rx_uuid)
+            return bytes(data)
+        except Exception as e:
+            _LOGGER.error("read_data failed: %s", e)
+            return None
+
+    async def write_data(self, data: bytes) -> bool:
+        """Write raw bytes to TX characteristic."""
+        if not self.client or not self.client.is_connected:
+            _LOGGER.debug("Client not connected for write")
+            return False
+        if not self.tx_uuid:
+            _LOGGER.debug("No TX UUID configured for write")
+            return False
+        try:
+            await self.client.write_gatt_char(self.tx_uuid, data)
+            _LOGGER.debug("Wrote %d bytes to %s", len(data), self.tx_uuid)
+            return True
+        except Exception as e:
+            _LOGGER.error("write_data failed: %s", e)
+            return False
+
+    @staticmethod
+    async def discover(timeout: float = 5.0):
+        """Discover BLE devices using BleakScanner; returns list of bleak device objects."""
+        return await BleakScanner.discover(timeout=timeout)

ryseble-1.0.0/ryseble/packets.py

@@ -0,0 +1,24 @@
+def build_position_packet(pos: int) -> bytes:
+    """Build a packet to set the shade position.
+
+    Args:
+        pos: Desired position (0–100).
+
+    Returns:
+        Bytes representing the command packet.
+    """
+    if not (0 <= pos <= 100):
+        raise ValueError("Position must be between 0 and 100")
+
+    # Example format: [0x01, pos]
+    return bytes([0x01, pos])
+
+
+def build_get_position_packet() -> bytes:
+    """Build a packet to request the current shade position.
+
+    Returns:
+        Bytes representing the command packet.
+    """
+    # Example format: [0x02]
+    return bytes([0x02])

ryseble-1.0.0/ryseble.egg-info/PKG-INFO

@@ -0,0 +1,43 @@
+Metadata-Version: 2.4
+Name: ryseble
+Version: 1.0.0
+Summary: Python library for RYSE BLE Smart Shade devices (used by Home Assistant integration).
+Author-email: MOHAMED Kallel <mohamed.kallel@yahoo.fr>
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: bleak>=0.22.0
+Dynamic: license-file
+
+
+# === README.md ===
+# ryseble
+
+A small Python library to interact with RYSE BLE Smart Shade devices. Designed to be
+used by Home Assistant integrations but reusable in other projects.
+
+## Features
+- Pair/connect/disconnect with device
+- Read/write raw packets
+- Helpers to build position/get-position packets
+
+## Installation
+
+```bash
+pip install ryseble
+```
+
+## Usage (example)
+
+```python
+from ryseble.device import RyseBLEDevice
+from ryseble.packets import build_position_packet, build_get_position_packet
+
+device = RyseBLEDevice(address="AA:BB:CC:DD:EE:FF", rx_uuid="...", tx_uuid="...")
+await device.pair()
+await device.write_data(build_position_packet(50))
+```

ryseble-1.0.0/ryseble.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+ryseble/__init__.py
+ryseble/bluetoothctl.py
+ryseble/constants.py
+ryseble/device.py
+ryseble/packets.py
+ryseble.egg-info/PKG-INFO
+ryseble.egg-info/SOURCES.txt
+ryseble.egg-info/dependency_links.txt
+ryseble.egg-info/requires.txt
+ryseble.egg-info/top_level.txt

ryseble-1.0.0/ryseble.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

ryseble-1.0.0/ryseble.egg-info/requires.txt

@@ -0,0 +1 @@
+bleak>=0.22.0

ryseble-1.0.0/ryseble.egg-info/top_level.txt

@@ -0,0 +1 @@
+ryseble

ryseble-1.0.0/setup.cfg

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