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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: python-roborock
-Version: 7.15.1
+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.1 → python_roborock-7.15.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "python-roborock"
-version = "7.15.1"
+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.1 → 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.1 → 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.1 → 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.1 → 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.1 → 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",
+]

python_roborock-7.15.2/roborock/web_api/_base.py

@@ -0,0 +1,168 @@
+"""Shared state and request-building helpers for the web API mixins.
+
+Every resource mixin (``AuthApi``, ``HomesApi``, ``JobsApi`` ...) inherits from
+``RoborockApiBase`` so that it can rely on the username, session, regional base
+URL resolution and the two request builders defined here. ``RoborockApiClient``
+composes the mixins into the single public client.
+"""
+
+import base64
+import hashlib
+import logging
+import secrets
+from dataclasses import dataclass
+
+import aiohttp
+
+from roborock.data import UserData
+from roborock.exceptions import (
+    RoborockException,
+    RoborockInvalidCredentials,
+    RoborockInvalidEmail,
+    RoborockMissingParameters,
+    RoborockNoResponseFromBaseURL,
+)
+
+from ._hawk import _get_hawk_authentication
+from ._request import PreparedRequest
+
+_LOGGER = logging.getLogger(__name__)
+
+BASE_URLS = [
+    "https://usiot.roborock.com",
+    "https://euiot.roborock.com",
+    "https://cniot.roborock.com",
+    "https://ruiot.roborock.com",
+]
+
+
+@dataclass
+class IotLoginInfo:
+    """Information about the login to the iot server."""
+
+    base_url: str
+    country_code: str
+    country: str
+
+
+class RoborockApiBase:
+    """State and helpers shared by all web API resource mixins."""
+
+    def __init__(
+        self, username: str, base_url: str | None = None, session: aiohttp.ClientSession | None = None
+    ) -> None:
+        """Sample API Client."""
+        self._username = username
+        self._base_url = base_url
+        self._device_identifier = secrets.token_urlsafe(16)
+        self.session = session
+        self._iot_login_info: IotLoginInfo | None = None
+        self._base_urls = BASE_URLS if base_url is None else [base_url]
+
+    async def _get_iot_login_info(self) -> IotLoginInfo:
+        if self._iot_login_info is None:
+            for iot_url in self._base_urls:
+                url_request = PreparedRequest(iot_url, self.session)
+                response = await url_request.request(
+                    "post",
+                    "/api/v1/getUrlByEmail",
+                    params={"email": self._username, "needtwostepauth": "false"},
+                )
+                if response is None:
+                    continue
+                response_code = response.get("code")
+                if response_code != 200:
+                    if response_code == 2003:
+                        raise RoborockInvalidEmail("Your email was incorrectly formatted.")
+                    elif response_code == 1001:
+                        raise RoborockMissingParameters(
+                            "You are missing parameters for this request, are you sure you entered your username?"
+                        )
+                    else:
+                        raise RoborockException(f"{response.get('msg')} - response code: {response_code}")
+                country_code = response["data"]["countrycode"]
+                country = response["data"]["country"]
+                if country_code is not None or country is not None:
+                    self._iot_login_info = IotLoginInfo(
+                        base_url=response["data"]["url"],
+                        country=country,
+                        country_code=country_code,
+                    )
+                    _LOGGER.debug("Country determined to be %s and code is %s", country, country_code)
+                    return self._iot_login_info
+            raise RoborockNoResponseFromBaseURL(
+                "No account was found for any base url we tried. Either your email is incorrect or we do not have a"
+                " record of the roborock server your device is on."
+            )
+        return self._iot_login_info
+
+    @property
+    async def base_url(self):
+        if self._base_url is not None:
+            return self._base_url
+        return (await self._get_iot_login_info()).base_url
+
+    @property
+    async def country(self):
+        return (await self._get_iot_login_info()).country
+
+    @property
+    async def country_code(self):
+        return (await self._get_iot_login_info()).country_code
+
+    def _get_header_client_id(self):
+        md5 = hashlib.md5()
+        md5.update(self._username.encode())
+        md5.update(self._device_identifier.encode())
+        return base64.b64encode(md5.digest()).decode()
+
+    async def _iot_request(self, extra_headers: dict | None = None) -> PreparedRequest:
+        """Build a request against the regional Base IoT server with the standard client headers."""
+        base_url = await self.base_url
+        headers = {"header_clientid": self._get_header_client_id(), **(extra_headers or {})}
+        return PreparedRequest(base_url, self.session, headers)
+
+    def _rriot_request(
+        self,
+        user_data: UserData,
+        path: str,
+        *,
+        formdata: dict | None = None,
+        params: dict | None = None,
+        body: dict | None = None,
+        extra_headers: dict | None = None,
+    ) -> PreparedRequest:
+        """Build a Hawk-authenticated request against the RRIoT server for ``path``.
+
+        The same ``formdata``/``params``/``body`` passed here must be sent on the request so
+        that the signed MAC matches what the server receives.
+        """
+        rriot = user_data.rriot
+        if rriot is None:
+            raise RoborockException("rriot is none")
+        if rriot.r.a is None:
+            raise RoborockException("Missing field 'a' in rriot reference")
+        headers = {
+            "Authorization": _get_hawk_authentication(rriot, path, formdata=formdata, params=params, body=body),
+            **(extra_headers or {}),
+        }
+        return PreparedRequest(rriot.r.a, self.session, headers)
+
+    async def _get_home_id(self, user_data: UserData):
+        home_id_request = await self._iot_request()
+        home_id_response = await home_id_request.request(
+            "get",
+            "/api/v1/getHomeDetail",
+            headers={"Authorization": user_data.token},
+        )
+        if home_id_response is None:
+            raise RoborockException("home_id_response is None")
+        if home_id_response.get("code") != 200:
+            _LOGGER.info("Get Home Id failed with the following context: %s", home_id_response)
+            if home_id_response.get("code") == 2010:
+                raise RoborockInvalidCredentials(
+                    f"Invalid credentials ({home_id_response.get('msg')}) - check your login and try again."
+                )
+            raise RoborockException(f"{home_id_response.get('msg')} - response code: {home_id_response.get('code')}")
+
+        return home_id_response["data"]["rrHomeId"]

python_roborock-7.15.2/roborock/web_api/_hawk.py

@@ -0,0 +1,58 @@
+"""Hawk request signing for the RRIoT (``user_data.rriot.r.a``) API surface."""
+
+import base64
+import hashlib
+import hmac
+import json
+import math
+import secrets
+import time
+
+from roborock.data import RRiot
+
+
+def _process_extra_hawk_values(values: dict | None) -> str:
+    if values is None:
+        return ""
+    else:
+        sorted_keys = sorted(values.keys())
+        result = []
+        for key in sorted_keys:
+            value = values.get(key)
+            result.append(f"{key}={value}")
+        return hashlib.md5("&".join(result).encode()).hexdigest()
+
+
+def _compact_json(body: dict) -> str:
+    """Serialize a JSON body to the exact compact bytes that are both signed and sent."""
+    return json.dumps(body, separators=(",", ":"))
+
+
+def _get_hawk_authentication(
+    rriot: RRiot,
+    url: str,
+    formdata: dict | None = None,
+    params: dict | None = None,
+    body: dict | None = None,
+) -> str:
+    timestamp = math.floor(time.time())
+    nonce = secrets.token_urlsafe(6)
+    params_str = _process_extra_hawk_values(params)
+    if body is not None:
+        payload_str = hashlib.md5(_compact_json(body).encode()).hexdigest()
+    else:
+        payload_str = _process_extra_hawk_values(formdata)
+
+    prestr = ":".join(
+        [
+            rriot.u,
+            rriot.s,
+            nonce,
+            str(timestamp),
+            hashlib.md5(url.encode()).hexdigest(),
+            params_str,
+            payload_str,
+        ]
+    )
+    mac = base64.b64encode(hmac.new(rriot.h.encode(), prestr.encode(), hashlib.sha256).digest()).decode()
+    return f'Hawk id="{rriot.u}",s="{rriot.s}",ts="{timestamp}",nonce="{nonce}",mac="{mac}"'