python-roborock 7.15.0__tar.gz → 7.15.2__tar.gz

{python_roborock-7.15.0 → python_roborock-7.15.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: python-roborock
-Version: 7.15.0
+Version: 7.15.2
 Summary: A package to control Roborock vacuums.
 Project-URL: Repository, https://github.com/python-roborock/python-roborock
 Project-URL: Documentation, https://python-roborock.readthedocs.io/

{python_roborock-7.15.0 → python_roborock-7.15.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "python-roborock"
-version = "7.15.0"
+version = "7.15.2"
 description = "A package to control Roborock vacuums."
 authors = [{ name = "humbertogontijo", email = "humbertogontijo@users.noreply.github.com" }, {name="Lash-L"}, {name="allenporter"}]
 requires-python = ">=3.11, <4"

{python_roborock-7.15.0 → python_roborock-7.15.2}/roborock/data/mower/mower_code_mappings.py

@@ -1,9 +1,12 @@
 """Code mappings for Roborock mower devices."""
 
+import logging
 from typing import Self, cast
 
 from roborock.data.code_mappings import RoborockModeEnum
 
+_LOGGER = logging.getLogger(__name__)
+
 __all__ = [
     "MowerAfsStatus",
     "MowerChargeState",
@@ -38,6 +41,7 @@ class MowerEnum(RoborockModeEnum):
         """Resolve a wire value by name, string value, or integer code."""
         if (member := cls.from_any_optional(code)) is not None:
             return member
+        _LOGGER.debug("Unknown %s code %r; defaulting to UNKNOWN", cls.__name__, code)
         return cast(Self, cls.UNKNOWN)  # type: ignore[attr-defined]
 
 

{python_roborock-7.15.0 → python_roborock-7.15.2}/roborock/data/mower/mower_containers.py

@@ -48,6 +48,7 @@ class MowerStatus(RoborockBase):
     """Core mower status backed by mower DPS updates (data points 120-145)."""
 
     error_code: MowerErrorCode | None = field(default=None, metadata={"dps": RoborockMowerDataProtocol.ERROR_CODE})
+    """None means no error code was supplied; UNKNOWN means an unknown error."""
     battery: int | None = field(default=None, metadata={"dps": RoborockMowerDataProtocol.BATTERY})
     mow_type: MowerMowType | None = field(default=None, metadata={"dps": RoborockMowerDataProtocol.MOW_TYPE})
     mow_state: MowerDetailState | None = field(default=None, metadata={"dps": RoborockMowerDataProtocol.MOW_STATE})

{python_roborock-7.15.0 → python_roborock-7.15.2}/roborock/map/b01_q10_map_parser.py

@@ -20,17 +20,11 @@ documentation that informed this clean-room implementation comes from the
 https://github.com/v1b3c0d3x3r/roborock-qseries-map-bridge
 """
 
-import io
 import math
 import statistics
 import struct
 from dataclasses import dataclass, field, replace
 
-from PIL import Image
-from vacuum_map_parser_base.config.color import ColorsPalette, SupportedColor
-from vacuum_map_parser_base.config.image_config import ImageConfig
-from vacuum_map_parser_base.map_data import ImageData, MapData, Point
-
 from roborock.data.b01_q10.b01_q10_containers import Q10RoborockPoint
 from roborock.data.code_mappings import RoborockEnum
 from roborock.data.containers import RoborockBase
@@ -44,10 +38,6 @@ from .b01_grid_layers import (
     GridLayers,
     decompose_grid,
 )
-from .map_parser import ParsedMapData
-from .room_colors import adjacency_aware_room_colors
-
-_MAP_FILE_FORMAT = "PNG"
 
 # Semantic raster classes, confirmed against real ss07 captures (rendered and
 # eyeballed): 243 is the background outside the home (~half the grid), 240 is
@@ -776,111 +766,3 @@ class B01Q10MapParserConfig:
 
     map_scale: int = 4
     """Scale factor for the rendered map image."""
-
-
-class B01Q10MapParser:
-    """Decoder/renderer for Q10 ``MAP_RESPONSE`` (protocol 301) payloads."""
-
-    def __init__(self, config: B01Q10MapParserConfig | None = None) -> None:
-        self._config = config or B01Q10MapParserConfig()
-
-    @property
-    def config(self) -> B01Q10MapParserConfig:
-        """The parser configuration (image scale, ...)."""
-        return self._config
-
-    def parse(self, payload: bytes) -> ParsedMapData:
-        """Parse a raw Q10 map packet into a rendered PNG + ``MapData``."""
-        return self.parsed_from_packet(parse_map_packet(payload))
-
-    def parse_packet(self, packet: Q10MapPacket) -> ParsedMapData:
-        """Render an already-decoded packet.
-
-        This preserves the public API used by the existing map trait. Callers
-        rendering a modified packet can use :meth:`parsed_from_packet` directly.
-        """
-        return self.parsed_from_packet(packet)
-
-    def map_data_from_packet(self, packet: Q10MapPacket) -> MapData:
-        """Build MapData with a rendered base image, without PNG serialization."""
-        image = self._render(packet)
-
-        map_data = MapData()
-        map_data.image = ImageData(
-            size=packet.width * packet.height,
-            top=0,
-            left=0,
-            height=packet.height,
-            width=packet.width,
-            image_config=ImageConfig(scale=self._config.map_scale),
-            data=image,
-            # ImageDimensions uses V1's bottom-up map convention before
-            # projecting into the top-down PNG. Q10 points are already
-            # top-down grid pixels, so this adapter cancels that standard flip
-            # and lets Q10 use the shared V1 ImageGenerator without moving
-            # overlays vertically.
-            img_transformation=lambda p: Point(p.x, packet.height - p.y - 1, p.a),
-        )
-        room_names = {room.id: room.name for room in packet.rooms}
-        if room_names:
-            map_data.additional_parameters["room_names"] = room_names
-
-        # Carpet cells are flat grid indices (y*width + x) in the same top-down
-        # pixel space as the rendered raster, so they line up with the image.
-        if packet.carpet_mask is not None:
-            map_data.carpet_map = {i for i, value in enumerate(packet.carpet_mask) if value}
-
-        return map_data
-
-    def parsed_from_packet(self, packet: Q10MapPacket) -> ParsedMapData:
-        """Render a (possibly erase-modified) packet into a PNG + ``MapData``."""
-        map_data = self.map_data_from_packet(packet)
-        image_bytes = io.BytesIO()
-        if map_data.image is not None:
-            map_data.image.data.save(image_bytes, format=_MAP_FILE_FORMAT)
-        return ParsedMapData(image_content=image_bytes.getvalue(), map_data=map_data)
-
-    def _render(self, packet: Q10MapPacket) -> Image.Image:
-        """Render the Q10 grid with the V1 map palette."""
-        palette = _build_palette(packet.grid, packet.width)
-        flat_palette = [channel for color in palette for channel in color]
-        p_img = Image.frombytes("P", (packet.width, packet.height), packet.grid)
-        p_img.putpalette(flat_palette, rawmode="RGBA")
-        img = p_img.convert("RGBA")
-        # The ss07 grid is stored top-down (row 0 = top of the home), so it is
-        # rendered as-is -- unlike the V1/Q7 convention, no vertical flip.
-        scale = self._config.map_scale
-        if scale > 1:
-            img = img.resize((packet.width * scale, packet.height * scale), resample=Image.Resampling.NEAREST)
-        return img
-
-
-def _opaque(color: tuple[int, ...]) -> tuple[int, int, int, int]:
-    """Return a palette color as RGBA."""
-    return (color[0], color[1], color[2], color[3] if len(color) == 4 else 255)
-
-
-def _build_palette(grid: bytes, width: int) -> list[tuple[int, int, int, int]]:
-    """Map Q10 cells onto the same colors used by the V1 map renderer."""
-
-    def room_id(value: int) -> int | None:
-        return max(1, value // 4) if 0 < value < _WALL_THRESHOLD else None
-
-    colors = ColorsPalette()
-    room_colors = adjacency_aware_room_colors(
-        grid,
-        width,
-        colors,
-        room_id,
-    )
-    outside = (0, 0, 0, 0)
-    palette = [outside] * 256
-    for value in {value for value in grid if 0 < value < _WALL_THRESHOLD}:
-        palette[value] = _opaque(room_colors[max(1, value // 4)])
-    wall = _opaque(colors.get_color(SupportedColor.GREY_WALL))
-    for value in range(_WALL_THRESHOLD, 256):
-        palette[value] = wall
-    palette[_UNSEGMENTED_FLOOR_VALUE] = _opaque(colors.get_color(SupportedColor.MAP_INSIDE))
-    palette[_BACKGROUND_VALUE] = outside
-    palette[0] = outside
-    return palette

{python_roborock-7.15.0 → python_roborock-7.15.2}/roborock/map/b01_q10_render.py

@@ -1,7 +1,7 @@
 """Compose a Q10 (B01/ss07) map into a single rendered result.
 
-The :class:`~roborock.map.b01_q10_map_parser.B01Q10MapParser` turns wire bytes
-into a :class:`~roborock.map.b01_q10_map_parser.Q10MapPacket`; this module
+The :func:`~roborock.map.b01_q10_map_parser.parse_map_packet` function turns wire
+bytes into a :class:`~roborock.map.b01_q10_map_parser.Q10MapPacket`; this module
 combines that map-protocol packet with the latest trace-protocol packet and DPS
 overlay snapshot. Calibration, path and position are derived from those source
 objects rather than managed independently by callers.
@@ -18,9 +18,12 @@ import math
 from collections.abc import Sequence
 from dataclasses import dataclass
 
+from PIL import Image
+from vacuum_map_parser_base.config.color import ColorsPalette, SupportedColor
 from vacuum_map_parser_base.config.drawable import Drawable
+from vacuum_map_parser_base.config.image_config import ImageConfig
 from vacuum_map_parser_base.config.size import Size, Sizes
-from vacuum_map_parser_base.map_data import Area, MapData, Path, Point, Wall
+from vacuum_map_parser_base.map_data import Area, ImageData, MapData, Path, Point, Wall
 
 from roborock.exceptions import RoborockException
 
@@ -31,7 +34,9 @@ from .b01_grid_layers import (
     solve_calibration_with_origin,
 )
 from .b01_q10_map_parser import (
-    B01Q10MapParser,
+    _BACKGROUND_VALUE,
+    _UNSEGMENTED_FLOOR_VALUE,
+    _WALL_THRESHOLD,
     B01Q10MapParserConfig,
     Q10EraseZone,
     Q10HistoricalTracePacket,
@@ -41,6 +46,7 @@ from .b01_q10_map_parser import (
 )
 from .b01_q10_overlays import ZONE_TYPE_NO_GO, ZONE_TYPE_NO_MOP, Q10Zone
 from .map_parser import DEFAULT_DRAWABLES, MapParserConfig, _create_image_generator
+from .room_colors import adjacency_aware_room_colors
 
 # Path-units-per-pixel candidates for calibration. A dense ss07 path lands a
 # best fit of 20.0 around the header origin -- ground-truthed June 2026 on the
@@ -97,7 +103,6 @@ def render_q10_map(
     available trace and DPS overlays are projected and drawn in pixel space.
     Raises :class:`RoborockException` if map rendering fails.
     """
-    parser = B01Q10MapParser(config)
     trace_calibration = solve_q10_calibration(packet, trace)
     vector_calibration = _vector_calibration(packet, trace_calibration)
 
@@ -109,7 +114,7 @@ def render_q10_map(
             # areas disappear (as the app shows).
             render_packet = erased_packet(packet, cells)
 
-    map_data = parser.map_data_from_packet(render_packet)
+    map_data = _map_data_from_packet(render_packet, config=config)
     if map_data.image is None:
         raise RoborockException("Failed to render Q10 map image")
 
@@ -335,3 +340,84 @@ def _draw_map_content(
     buffer = io.BytesIO()
     map_data.image.data.save(buffer, format="PNG")
     return buffer.getvalue()
+
+
+def _map_data_from_packet(
+    packet: Q10MapPacket,
+    *,
+    config: B01Q10MapParserConfig,
+) -> MapData:
+    """Build MapData with a rendered base image, without PNG serialization."""
+    image = _render_base_grid(packet, scale=config.map_scale)
+
+    map_data = MapData()
+    map_data.image = ImageData(
+        size=packet.width * packet.height,
+        top=0,
+        left=0,
+        height=packet.height,
+        width=packet.width,
+        image_config=ImageConfig(scale=config.map_scale),
+        data=image,
+        # ImageDimensions uses V1's bottom-up map convention before
+        # projecting into the top-down PNG. Q10 points are already
+        # top-down grid pixels, so this adapter cancels that standard flip
+        # and lets Q10 use the shared V1 ImageGenerator without moving
+        # overlays vertically.
+        img_transformation=lambda p: Point(p.x, packet.height - p.y - 1, p.a),
+    )
+    room_names = {room.id: room.name for room in packet.rooms}
+    if room_names:
+        map_data.additional_parameters["room_names"] = room_names
+
+    # Carpet cells are flat grid indices (y*width + x) in the same top-down
+    # pixel space as the rendered raster, so they line up with the image.
+    if packet.carpet_mask is not None:
+        map_data.carpet_map = {i for i, value in enumerate(packet.carpet_mask) if value}
+
+    return map_data
+
+
+def _render_base_grid(packet: Q10MapPacket, *, scale: int) -> Image.Image:
+    """Render the Q10 grid with the V1 map palette."""
+    palette = _build_palette(packet.grid, packet.width)
+    flat_palette = [channel for color in palette for channel in color]
+    p_img = Image.frombytes("P", (packet.width, packet.height), packet.grid)
+    p_img.putpalette(flat_palette, rawmode="RGBA")
+    img = p_img.convert("RGBA")
+    # The ss07 grid is stored top-down (row 0 = top of the home), so it is
+    # rendered as-is -- unlike the V1/Q7 convention, no vertical flip.
+    if scale > 1:
+        img = img.resize((packet.width * scale, packet.height * scale), resample=Image.Resampling.NEAREST)
+    return img
+
+
+def _opaque(color: tuple[int, ...]) -> tuple[int, int, int, int]:
+    """Return a palette color as RGBA."""
+    return (color[0], color[1], color[2], color[3] if len(color) == 4 else 255)
+
+
+def _build_palette(grid: bytes, width: int) -> list[tuple[int, int, int, int]]:
+    """Map Q10 cells onto the same colors used by the V1 map renderer."""
+
+    def room_id(value: int) -> int | None:
+        return max(1, value // 4) if 0 < value < _WALL_THRESHOLD else None
+
+    colors = ColorsPalette()
+    room_colors = adjacency_aware_room_colors(
+        grid,
+        width,
+        colors,
+        room_id,
+    )
+    outside = (0, 0, 0, 0)
+    palette = [outside] * 256
+    for value in {value for value in grid if 0 < value < _WALL_THRESHOLD}:
+        palette[value] = _opaque(room_colors[max(1, value // 4)])
+    wall = _opaque(colors.get_color(SupportedColor.GREY_WALL))
+    for value in range(_WALL_THRESHOLD, 256):
+        palette[value] = wall
+    palette[_UNSEGMENTED_FLOOR_VALUE] = _opaque(colors.get_color(SupportedColor.MAP_INSIDE))
+    palette[_BACKGROUND_VALUE] = outside
+    palette[0] = outside
+    return palette

{python_roborock-7.15.0 → python_roborock-7.15.2}/roborock/protocols/v1_protocol.py

@@ -306,16 +306,29 @@ def create_blob_response_decoder() -> Callable[[RoborockMessage], BlobResponse |
     return _decode_blob_response
 
 
+# Number of incomplete multi-part map responses kept while waiting for missing parts.
+_MAX_PENDING_MAP_RESPONSES = 4
+
+
 def create_map_response_decoder(security_data: SecurityData) -> Callable[[RoborockMessage], MapResponse | None]:
-    """Create a decoder for V1 map response messages."""
+    """Create a decoder for V1 map response messages.
 
-    def _decode_map_response(message: RoborockMessage) -> MapResponse | None:
-        """Decode a V1 map response message."""
-        if not message.payload or len(message.payload) < 24:
+    Large maps are split into multiple messages that share the same ``random``
+    and ``timestamp`` and are numbered by ``seq``. All parts except the last
+    one use protocol ``MAP_RESPONSE_PART`` (300), the last one uses
+    ``MAP_RESPONSE`` (301). Only the first part starts with the map header.
+    Parts may arrive out of order, so they are buffered until complete.
+    """
+    endpoint_bytes = security_data.endpoint.encode()
+    # (random, timestamp) -> seq -> (is last part, payload)
+    pending: dict[tuple[int, int], dict[int, tuple[bool, bytes]]] = {}
+
+    def _decode_payload(payload: bytes) -> MapResponse | None:
+        if len(payload) < 24:
             raise RoborockException("Invalid V1 map response format: missing payload")
-        header, body = message.payload[:24], message.payload[24:]
+        header, body = payload[:24], payload[24:]
         [endpoint, _, request_id, _] = struct.unpack("<8s8sH6s", header)
-        if not endpoint.decode().startswith(security_data.endpoint):
+        if not endpoint.startswith(endpoint_bytes):
             _LOGGER.debug("Received map response not requested by this device, ignoring.")
             return None
         try:
@@ -325,6 +338,39 @@ def create_map_response_decoder(security_data: SecurityData) -> Callable[[Roboro
         decompressed = Utils.decompress(decrypted)
         return MapResponse(request_id=request_id, data=decompressed)
 
+    def _remember(key: tuple[int, int], parts: dict[int, tuple[bool, bytes]]) -> None:
+        pending[key] = parts
+        while len(pending) > _MAX_PENDING_MAP_RESPONSES:
+            del pending[next(iter(pending))]
+
+    def _add_part(key: tuple[int, int], seq: int, is_last: bool, payload: bytes) -> MapResponse | None:
+        parts = pending.pop(key, {})
+        parts[seq] = (is_last, payload)
+        seqs = sorted(parts)
+        complete = (
+            parts[seqs[-1]][0]
+            and seqs == list(range(seqs[0], seqs[-1] + 1))
+            and parts[seqs[0]][1].startswith(endpoint_bytes)
+        )
+        if not complete:
+            _remember(key, parts)
+            return None
+        return _decode_payload(b"".join(parts[s][1] for s in seqs))
+
+    def _decode_map_response(message: RoborockMessage) -> MapResponse | None:
+        """Decode a V1 map response message."""
+        if not message.payload:
+            raise RoborockException("Invalid V1 map response format: missing payload")
+        payload = message.payload
+        key = (message.random, message.timestamp)
+        is_last = message.protocol == RoborockMessageProtocol.MAP_RESPONSE
+        if message.protocol == RoborockMessageProtocol.MAP_RESPONSE_PART or (is_last and key in pending):
+            return _add_part(key, message.seq, is_last, payload)
+        if is_last and not payload.startswith(endpoint_bytes):
+            # Possibly the last part of a multi-part response that arrived first.
+            _remember(key, {message.seq: (True, payload)})
+        return _decode_payload(payload)
+
     return _decode_map_response
 
 

{python_roborock-7.15.0 → python_roborock-7.15.2}/roborock/roborock_message.py

@@ -15,6 +15,7 @@ class RoborockMessageProtocol(RoborockEnum):
     GENERAL_RESPONSE = 5
     RPC_REQUEST = 101
     RPC_RESPONSE = 102
+    MAP_RESPONSE_PART = 300  # Non-final part of a map response split into multiple messages
     MAP_RESPONSE = 301
 
 

{python_roborock-7.15.0 → python_roborock-7.15.2}/roborock/testing/v1_simulator.py

@@ -10,7 +10,7 @@ import json
 import logging
 import struct
 import time
-from collections.abc import Callable
+from collections.abc import Callable, Sequence
 from dataclasses import asdict, replace
 from enum import Enum
 from typing import Any
@@ -45,6 +45,7 @@ from roborock.protocols.v1_protocol import SecurityData
 from roborock.roborock_message import RoborockDataProtocol, RoborockMessage, RoborockMessageProtocol
 from roborock.testing.channel import FakeChannel
 from roborock.testing.simulator import RoborockDeviceSimulator
+from roborock.util import get_next_int
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -255,8 +256,12 @@ class V1VacuumSimulator(RoborockDeviceSimulator):
 
         # The simulated robot's own view of its map. Tests extend the path
         # with advance_path() and move the robot via robot_position.
+        # Set map_parts > 1 (and optionally map_part_order) to split map
+        # responses across MAP_RESPONSE_PART (300) and MAP_RESPONSE (301) frames.
         self.path_length = 0
         self.robot_position = (25000, 24000, 90)
+        self.map_parts = 1
+        self.map_part_order: Sequence[int] | None = None
 
         self.device_cache = DeviceCache(self.duid, InMemoryCache())
         # The endpoint must fit the eight byte map response header field and the
@@ -416,11 +421,44 @@ class V1VacuumSimulator(RoborockDeviceSimulator):
         data = header + body + digest_header
         return data + hashlib.sha1(data, usedforsecurity=False).digest()
 
-    def _map_response_message(self, request_id: int, map_bytes: bytes) -> RoborockMessage:
-        """Frame the map as the encrypted binary response the device sends."""
+    def _map_response_messages(self, request_id: int, map_bytes: bytes) -> list[RoborockMessage]:
+        """Frame the map as one or more encrypted binary messages as the device sends."""
+        if self.map_parts < 1:
+            raise ValueError("map_parts must be at least 1")
         body = Utils.encrypt_cbc(gzip.compress(map_bytes), self.security_data.nonce)
         header = struct.pack("<8s8sH6s", self.security_data.endpoint.encode(), bytes(8), request_id & 0xFFFF, bytes(6))
-        return RoborockMessage(protocol=RoborockMessageProtocol.MAP_RESPONSE, payload=header + body)
+        if self.map_parts == 1:
+            if self.map_part_order is not None and list(self.map_part_order) != [0]:
+                raise ValueError("map_part_order must be a permutation of range(map_parts)")
+            return [RoborockMessage(protocol=RoborockMessageProtocol.MAP_RESPONSE, payload=header + body)]
+        if self.map_parts > len(body):
+            raise ValueError("map_parts cannot exceed encrypted map body length")
+
+        # Keep the 24-byte header intact on the first part and split the encrypted
+        # body evenly into map_parts non-empty contiguous slices.
+        total = len(body)
+        boundaries = [(i * total) // self.map_parts for i in range(self.map_parts + 1)]
+        chunks = [body[boundaries[i] : boundaries[i + 1]] for i in range(self.map_parts)]
+        chunks[0] = header + chunks[0]
+        random_id = get_next_int(10000, 99999)
+        timestamp = int(time.time())
+        messages = [
+            RoborockMessage(
+                protocol=RoborockMessageProtocol.MAP_RESPONSE
+                if idx == len(chunks) - 1
+                else RoborockMessageProtocol.MAP_RESPONSE_PART,
+                payload=chunk,
+                seq=idx + 1,
+                random=random_id,
+                timestamp=timestamp,
+            )
+            for idx, chunk in enumerate(chunks)
+        ]
+        if self.map_part_order is not None:
+            if sorted(self.map_part_order) != list(range(self.map_parts)):
+                raise ValueError("map_part_order must be a permutation of range(map_parts)")
+            messages = [messages[i] for i in self.map_part_order]
+        return messages
 
     async def _handle_publish(self, message: RoborockMessage, channel: FakeChannel) -> None:
         if not message.payload:
@@ -455,7 +493,8 @@ class V1VacuumSimulator(RoborockDeviceSimulator):
 
         if method == "get_map_v1" and error is None and isinstance(result, bytes):
             # Custom handlers return decompressed map bytes, just like the default.
-            channel.notify_subscribers(self._map_response_message(msg_id, result))
+            for map_msg in self._map_response_messages(msg_id, result):
+                channel.notify_subscribers(map_msg)
             return
 
         response_data = {

python_roborock-7.15.2/roborock/web_api/__init__.py

@@ -0,0 +1,37 @@
+"""Roborock cloud REST API clients.
+
+The public entry points are :class:`RoborockApiClient` and :class:`UserWebApiClient`.
+Endpoints are grouped by resource into submodules (``auth``, ``homes``, ``devices``,
+``scenes``, ``jobs``, ``ota``, ``products``); each exposes a mixin that
+``RoborockApiClient`` composes. Everything that was importable from the former
+``roborock.web_api`` module is re-exported here for backwards compatibility.
+"""
+
+from ._base import BASE_URLS, IotLoginInfo, RoborockApiBase
+from ._request import PreparedRequest
+from .auth import DEFAULT_AGREEMENT_MAJOR_VERSION, DEFAULT_AGREEMENT_MINOR_VERSION, AuthApi
+from .client import RoborockApiClient, UserWebApiClient
+from .devices import DevicesApi
+from .homes import HomesApi
+from .jobs import JobsApi
+from .ota import OtaApi
+from .products import ProductsApi
+from .scenes import ScenesApi
+
+__all__ = [
+    "BASE_URLS",
+    "DEFAULT_AGREEMENT_MAJOR_VERSION",
+    "DEFAULT_AGREEMENT_MINOR_VERSION",
+    "AuthApi",
+    "DevicesApi",
+    "HomesApi",
+    "IotLoginInfo",
+    "JobsApi",
+    "OtaApi",
+    "PreparedRequest",
+    "ProductsApi",
+    "RoborockApiBase",
+    "RoborockApiClient",
+    "ScenesApi",
+    "UserWebApiClient",
+]