python-roborock 5.20.1__tar.gz → 5.22.0__tar.gz

{python_roborock-5.20.1 → python_roborock-5.22.0}/PKG-INFO

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

@@ -1,6 +1,6 @@
 [project]
 name = "python-roborock"
-version = "5.20.1"
+version = "5.22.0"
 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-5.20.1 → python_roborock-5.22.0}/roborock/cli.py

@@ -49,7 +49,12 @@ except ImportError as err:
 
 from roborock import RoborockCommand
 from roborock.data import RoborockBase, UserData
-from roborock.data.b01_q10.b01_q10_code_mappings import B01_Q10_DP, YXCleanType, YXFanLevel
+from roborock.data.b01_q10.b01_q10_code_mappings import (
+    B01_Q10_DP,
+    YXCleanType,
+    YXDeviceDustCollectionFrequency,
+    YXFanLevel,
+)
 from roborock.data.code_mappings import SHORT_MODEL_TO_ENUM
 from roborock.device_features import DeviceFeatures
 from roborock.devices.cache import Cache, CacheData
@@ -446,13 +451,67 @@ async def _display_v1_trait(context: RoborockContext, device_id: str, display_fu
     click.echo(dump_json(trait.as_dict()))
 
 
-async def _q10_vacuum_trait(context: RoborockContext, device_id: str) -> VacuumTrait:
-    """Get VacuumTrait from Q10 device."""
+async def _q10_properties(context: RoborockContext, device_id: str) -> Q10PropertiesApi:
+    """Get the B01 Q10 properties API for a device."""
     device_manager = await context.get_device_manager()
     device = await device_manager.get_device(device_id)
     if device.b01_q10_properties is None:
         raise RoborockUnsupportedFeature("Device does not support B01 Q10 protocol. Is it a Q10?")
-    return device.b01_q10_properties.vacuum
+    return device.b01_q10_properties
+
+
+async def _q10_vacuum_trait(context: RoborockContext, device_id: str) -> VacuumTrait:
+    """Get VacuumTrait from Q10 device."""
+    return (await _q10_properties(context, device_id)).vacuum
+
+
+async def _display_q10_status(context: RoborockContext, device_id: str) -> None:
+    """Refresh and display the full status of a B01 Q10 device.
+
+    Unlike V1 devices, the Q10 reports its state asynchronously: ``refresh()``
+    sends a request and the device streams the values back over the persistent
+    subscribe loop. That loop also delivers unsolicited pushes, so the read-model
+    traits may already hold (possibly stale) values from before this command ran
+    -- checking that a field is merely populated isn't enough. To display data
+    the device sent *in response to this refresh*, we register update listeners,
+    fire the refresh, and wait for a fresh update before reading the traits.
+
+    All read-model traits refreshed by :meth:`Q10PropertiesApi.refresh` are shown,
+    not just ``status`` (volume, child lock, do-not-disturb, dust collection,
+    network info and consumables are part of the device's reported state too).
+    """
+    properties = await _q10_properties(context, device_id)
+
+    # Read-model traits populated from the device's DPS push stream.
+    traits = {
+        "status": properties.status,
+        "volume": properties.volume,
+        "child_lock": properties.child_lock,
+        "do_not_disturb": properties.do_not_disturb,
+        "dust_collection": properties.dust_collection,
+        "network_info": properties.network_info,
+        "consumable": properties.consumable,
+    }
+
+    updated = asyncio.Event()
+    unsubscribes = [trait.add_update_listener(updated.set) for trait in traits.values()]
+    try:
+        await properties.refresh()
+        try:
+            await asyncio.wait_for(updated.wait(), timeout=5)
+        except TimeoutError:
+            click.echo("Timed out waiting for status from device")
+            return
+        # The device streams its DPS across several pushes; give the remaining
+        # ones a brief window to arrive after the first fresh update.
+        await asyncio.sleep(0.5)
+    finally:
+        for unsubscribe in unsubscribes:
+            unsubscribe()
+
+    # Each concrete trait also subclasses a RoborockBase read-model, so it has
+    # ``as_dict``; the cast satisfies the typed UpdatableTrait view above.
+    click.echo(dump_json({name: cast(RoborockBase, trait).as_dict() for name, trait in traits.items()}))
 
 
 @session.command()
@@ -462,7 +521,14 @@ async def _q10_vacuum_trait(context: RoborockContext, device_id: str) -> VacuumT
 async def status(ctx, device_id: str):
     """Get device status."""
     context: RoborockContext = ctx.obj
-    await _display_v1_trait(context, device_id, lambda v1: v1.status)
+    device_manager = await context.get_device_manager()
+    device = await device_manager.get_device(device_id)
+    if device.v1_properties is not None:
+        await _display_v1_trait(context, device_id, lambda v1: v1.status)
+    elif device.b01_q10_properties is not None:
+        await _display_q10_status(context, device_id)
+    else:
+        click.echo("Feature not supported by device")
 
 
 @session.command()
@@ -1399,6 +1465,156 @@ async def q10_vacuum_dock(ctx: click.Context, device_id: str) -> None:
         click.echo(f"Error: {e}")
 
 
+@session.command()
+@click.option("--device_id", required=True, help="Device ID")
+@click.pass_context
+@async_command
+async def q10_vacuum_spot(ctx: click.Context, device_id: str) -> None:
+    """Start a spot / part clean on a Q10 device."""
+    context: RoborockContext = ctx.obj
+    try:
+        trait = await _q10_vacuum_trait(context, device_id)
+        await trait.spot_clean()
+        click.echo("Starting spot clean...")
+    except RoborockUnsupportedFeature:
+        click.echo("Device does not support B01 Q10 protocol. Is it a Q10?")
+    except RoborockException as e:
+        click.echo(f"Error: {e}")
+
+
+@session.command()
+@click.option("--device_id", required=True, help="Device ID")
+@click.option(
+    "--segments",
+    required=True,
+    help="Comma-separated room/segment ids to clean (see the `rooms` command), e.g. 9,2",
+)
+@click.pass_context
+@async_command
+async def q10_clean_segments(ctx: click.Context, device_id: str, segments: str) -> None:
+    """Start a room / segment clean on a Q10 device.
+
+    Room ids come from the `rooms` command (the device's map rooms).
+    """
+    context: RoborockContext = ctx.obj
+    try:
+        segment_ids = [int(s) for s in segments.split(",") if s.strip()]
+    except ValueError:
+        click.echo("--segments must be comma-separated integers, e.g. 9,2")
+        return
+    if not segment_ids:
+        click.echo("No segment ids provided")
+        return
+    try:
+        trait = await _q10_vacuum_trait(context, device_id)
+        await trait.clean_segments(segment_ids)
+        click.echo(f"Starting room clean of segments {segment_ids}...")
+    except RoborockUnsupportedFeature:
+        click.echo("Device does not support B01 Q10 protocol. Is it a Q10?")
+    except RoborockException as e:
+        click.echo(f"Error: {e}")
+
+
+async def _q10_set(ctx: click.Context, device_id: str, apply: Callable[[Any], Any], message: str) -> None:
+    """Run a Q10 settings write and report the result."""
+    context: RoborockContext = ctx.obj
+    try:
+        properties = await _q10_properties(context, device_id)
+        await apply(properties)
+        click.echo(message)
+    except RoborockUnsupportedFeature:
+        click.echo("Device does not support B01 Q10 protocol. Is it a Q10?")
+    except (RoborockException, ValueError) as e:
+        click.echo(f"Error: {e}")
+
+
+@session.command()
+@click.option("--device_id", required=True, help="Device ID")
+@click.option("--volume", required=True, type=int, help="Volume 0-100")
+@click.pass_context
+@async_command
+async def q10_set_volume(ctx: click.Context, device_id: str, volume: int) -> None:
+    """Set the speaker volume on a Q10 device."""
+    await _q10_set(ctx, device_id, lambda p: p.volume.set_volume(volume), f"Volume set to {volume}")
+
+
+@session.command()
+@click.option("--device_id", required=True, help="Device ID")
+@click.option("--enabled", required=True, type=bool, help="Enable (True) or disable (False)")
+@click.pass_context
+@async_command
+async def q10_set_child_lock(ctx: click.Context, device_id: str, enabled: bool) -> None:
+    """Enable or disable the child lock on a Q10 device."""
+    await _q10_set(
+        ctx,
+        device_id,
+        lambda p: p.child_lock.enable() if enabled else p.child_lock.disable(),
+        f"Child lock set to {enabled}",
+    )
+
+
+@session.command()
+@click.option("--device_id", required=True, help="Device ID")
+@click.option("--enabled", required=True, type=bool, help="Enable (True) or disable (False)")
+@click.pass_context
+@async_command
+async def q10_set_dnd(ctx: click.Context, device_id: str, enabled: bool) -> None:
+    """Enable or disable Do Not Disturb on a Q10 device."""
+    await _q10_set(
+        ctx,
+        device_id,
+        lambda p: p.do_not_disturb.enable() if enabled else p.do_not_disturb.disable(),
+        f"Do Not Disturb set to {enabled}",
+    )
+
+
+@session.command()
+@click.option("--device_id", required=True, help="Device ID")
+@click.option("--enabled", required=True, type=bool, help="Enable (True) or disable (False)")
+@click.pass_context
+@async_command
+async def q10_set_led(ctx: click.Context, device_id: str, enabled: bool) -> None:
+    """Enable or disable the indicator light (LED) on a Q10 device."""
+    await _q10_set(
+        ctx,
+        device_id,
+        lambda p: p.button_light.enable() if enabled else p.button_light.disable(),
+        f"LED set to {enabled}",
+    )
+
+
+@session.command()
+@click.option("--device_id", required=True, help="Device ID")
+@click.option("--enabled", required=True, type=bool, help="Enable (True) or disable (False)")
+@click.pass_context
+@async_command
+async def q10_set_dust_collection(ctx: click.Context, device_id: str, enabled: bool) -> None:
+    """Enable or disable automatic dust collection on a Q10 device."""
+    await _q10_set(
+        ctx,
+        device_id,
+        lambda p: p.dust_collection.enable() if enabled else p.dust_collection.disable(),
+        f"Dust collection set to {enabled}",
+    )
+
+
+@session.command()
+@click.option("--device_id", required=True, help="Device ID")
+@click.option(
+    "--frequency",
+    required=True,
+    type=click.Choice([str(m.code) for m in YXDeviceDustCollectionFrequency]),
+    help="Empty after every N cleans (0 = daily).",
+)
+@click.pass_context
+@async_command
+async def q10_set_dust_frequency(ctx: click.Context, device_id: str, frequency: str) -> None:
+    """Set how often the dock empties the bin (0 = daily, else every N cleans)."""
+    freq = YXDeviceDustCollectionFrequency.from_code(int(frequency))
+    label = "daily" if freq.code == 0 else f"every {freq.code} cleans"
+    await _q10_set(ctx, device_id, lambda p: p.dust_collection.set_frequency(freq), f"Dust frequency set to {label}")
+
+
 @session.command()
 @click.option("--device_id", required=True, help="Device ID")
 @click.pass_context

{python_roborock-5.20.1 → python_roborock-5.22.0}/roborock/data/b01_q10/b01_q10_code_mappings.py

@@ -85,9 +85,14 @@ class B01_Q10_DP(RoborockModeEnum):
     SUSPECTED_THRESHOLD = ("dpSuspectedThreshold", 99)
     SUSPECTED_THRESHOLD_UP = ("dpSuspectedThresholdUp", 100)
     COMMON = ("dpCommon", 101)
-    JUMP_SCAN = ("dpJumpScan", 101)
     REQUEST_DPS = ("dpRequestDps", 102)  # NOTE: typo "dpRequetdps" in source code
-    CLIFF_RESTRICTED_AREA = ("dpCliffRestrictedArea", 102)
+    # NOTE: the legacy B01 source also listed dpJumpScan (101) and
+    # dpCliffRestrictedArea (102), which collided with the confirmed dpCommon /
+    # dpRequestDps codes above (verified against ss07 hardware and the official app
+    # plugin) and shadowed them in ``from_code``. Both are unused and their real
+    # codes could not be verified, so they were removed rather than left as wrong
+    # duplicates. dpCliffRestrictedAreaUp (103) is kept: ss07 hardware does push
+    # data point 103 (an empty list when no cliff-restricted areas are set).
     CLIFF_RESTRICTED_AREA_UP = ("dpCliffRestrictedAreaUp", 103)
     BREAKPOINT_CLEAN = ("dpBreakpointClean", 104)
     VALLEY_POINT_CHARGING = ("dpValleyPointCharging", 105)
@@ -96,6 +101,13 @@ class B01_Q10_DP(RoborockModeEnum):
     VOICE_VERSION = ("dpVoiceVersion", 108)
     ROBOT_COUNTRY_CODE = ("dpRobotCountryCode", 109)
     HEARTBEAT = ("dpHeartbeat", 110)
+    # NOTE: ss07 hardware also pushes data points 112 and 113 in its full status
+    # dump. They are absent from the official app's vacuum plugin and stayed 0
+    # across every observed state (docked/charging, segment cleaning, lifted-off-
+    # ground fault, returning to dock, dustbin removed), so their meaning is not
+    # yet known. They are intentionally left unmapped; ``decode_rpc_response``
+    # silently ignores unknown codes via ``from_code_optional``, so they do not
+    # produce "not a valid code" warnings. Map them here once identified.
     STATUS = ("dpStatus", 121)
     BATTERY = ("dpBattery", 122)
     FAN_LEVEL = ("dpFanLevel", 123)  # NOTE: typo "dpfunLevel" in source code
@@ -215,13 +227,31 @@ class YXDeviceCleanTask(RoborockModeEnum):
 
 
 class YXDeviceDustCollectionFrequency(RoborockModeEnum):
-    DAILY = "daily", 0
+    # The app exposes "regular" (code 0) vs "frequent", where "frequent" selects
+    # one of the every-N-cleans intervals below.
+    REGULAR = "regular", 0
     INTERVAL_15 = "interval_15", 15
     INTERVAL_30 = "interval_30", 30
     INTERVAL_45 = "interval_45", 45
     INTERVAL_60 = "interval_60", 60
 
 
+class YXAreaUnit(RoborockModeEnum):
+    """Unit used to report cleaned area (dpAreaUnit)."""
+
+    SQUARE_METER = "square_meter", 0
+    SQUARE_FEET = "square_feet", 1
+
+
+class YXCarpetCleanType(RoborockModeEnum):
+    """Carpet handling behavior (dpCarpetCleanType)."""
+
+    RISE = "rise", 0  # lift the mop and boost over carpet
+    AVOID = "avoid", 1
+    IGNORE = "ignore", 2
+    CROSS = "cross", 3
+
+
 class RemoteCommand(IntEnum):
     FORWARD = 0
     LEFT = 2

python_roborock-5.22.0/roborock/data/b01_q10/b01_q10_containers.py

@@ -0,0 +1,211 @@
+"""Data container classes for Q10 B01 devices.
+
+Many of these classes use the `field(metadata={"dps": ...})` convention to map
+dataclass fields to device Data Points (DPS). This metadata is utilized by the
+`UpdatableTrait` helper in `roborock.devices.traits.b01.q10.common` to
+automatically update objects from raw device responses.
+"""
+
+from dataclasses import dataclass, field
+
+from ..containers import RoborockBase
+from .b01_q10_code_mappings import (
+    B01_Q10_DP,
+    YXAreaUnit,
+    YXBackType,
+    YXCarpetCleanType,
+    YXCleanLine,
+    YXCleanType,
+    YXDeviceCleanTask,
+    YXDeviceDustCollectionFrequency,
+    YXDeviceState,
+    YXFanLevel,
+    YXWaterLevel,
+)
+
+
+@dataclass
+class dpCleanRecord(RoborockBase):
+    op: str
+    result: int
+    id: str
+    data: list
+
+
+@dataclass
+class dpMultiMap(RoborockBase):
+    op: str
+    result: int
+    data: list
+
+
+@dataclass
+class dpGetCarpet(RoborockBase):
+    op: str
+    result: int
+    data: str
+
+
+@dataclass
+class dpSelfIdentifyingCarpet(RoborockBase):
+    op: str
+    result: int
+    data: str
+
+
+@dataclass
+class dpNetInfo(RoborockBase):
+    wifi_name: str | None = None
+    # "ip_adress" intentionally mirrors the device's "ipAdress" key (sic).
+    ip_adress: str | None = None
+    mac: str | None = None
+    signal: int | None = None
+
+    @property
+    def ip_address(self) -> str | None:
+        """Correctly-spelled alias for :attr:`ip_adress`."""
+        return self.ip_adress
+
+
+@dataclass
+class dpNotDisturbExpand(RoborockBase):
+    disturb_dust_enable: int | None = None
+    disturb_light: int | None = None
+    disturb_resume_clean: int | None = None
+    disturb_voice: int | None = None
+
+
+@dataclass
+class dpCurrentCleanRoomIds(RoborockBase):
+    room_id_list: list
+
+
+@dataclass
+class dpVoiceVersion(RoborockBase):
+    version: int
+
+
+@dataclass
+class dpTimeZone(RoborockBase):
+    time_zone_city: str | None = None
+    time_zone_sec: int | None = None
+
+
+@dataclass
+class Q10Status(RoborockBase):
+    """Core vacuum status for Q10 devices.
+
+    Fields are mapped to DPS values using metadata. Objects of this class can be
+    automatically updated using the `UpdatableTrait` helper. Settings that have
+    their own trait (volume, child lock, do-not-disturb, dust collection,
+    network info, consumables) live on those traits instead of here.
+    """
+
+    clean_time: int | None = field(default=None, metadata={"dps": B01_Q10_DP.CLEAN_TIME})
+    clean_area: int | None = field(default=None, metadata={"dps": B01_Q10_DP.CLEAN_AREA})
+    battery: int | None = field(default=None, metadata={"dps": B01_Q10_DP.BATTERY})
+    status: YXDeviceState | None = field(default=None, metadata={"dps": B01_Q10_DP.STATUS})
+    fan_level: YXFanLevel | None = field(default=None, metadata={"dps": B01_Q10_DP.FAN_LEVEL})
+    water_level: YXWaterLevel | None = field(default=None, metadata={"dps": B01_Q10_DP.WATER_LEVEL})
+    clean_count: int | None = field(default=None, metadata={"dps": B01_Q10_DP.CLEAN_COUNT})
+    total_clean_area: int | None = field(default=None, metadata={"dps": B01_Q10_DP.TOTAL_CLEAN_AREA})
+    total_clean_count: int | None = field(default=None, metadata={"dps": B01_Q10_DP.TOTAL_CLEAN_COUNT})
+    total_clean_time: int | None = field(default=None, metadata={"dps": B01_Q10_DP.TOTAL_CLEAN_TIME})
+    clean_mode: YXCleanType | None = field(default=None, metadata={"dps": B01_Q10_DP.CLEAN_MODE})
+    clean_task_type: YXDeviceCleanTask | None = field(default=None, metadata={"dps": B01_Q10_DP.CLEAN_TASK_TYPE})
+    back_type: YXBackType | None = field(default=None, metadata={"dps": B01_Q10_DP.BACK_TYPE})
+    cleaning_progress: int | None = field(default=None, metadata={"dps": B01_Q10_DP.CLEAN_PROGRESS})
+    fault: int | None = field(default=None, metadata={"dps": B01_Q10_DP.FAULT})
+
+    # Additional state reported in the device's full status dump.
+    clean_line: YXCleanLine | None = field(default=None, metadata={"dps": B01_Q10_DP.CLEAN_LINE})
+    carpet_clean_type: YXCarpetCleanType | None = field(default=None, metadata={"dps": B01_Q10_DP.CARPET_CLEAN_TYPE})
+    area_unit: YXAreaUnit | None = field(default=None, metadata={"dps": B01_Q10_DP.AREA_UNIT})
+    auto_boost: bool | None = field(default=None, metadata={"dps": B01_Q10_DP.AUTO_BOOST})
+    multi_map_switch: bool | None = field(default=None, metadata={"dps": B01_Q10_DP.MULTI_MAP_SWITCH})
+    map_save_switch: bool | None = field(default=None, metadata={"dps": B01_Q10_DP.MAP_SAVE_SWITCH})
+    recent_clean_record: bool | None = field(default=None, metadata={"dps": B01_Q10_DP.RECENT_CLEAN_RECORD})
+    valley_point_charging: bool | None = field(default=None, metadata={"dps": B01_Q10_DP.VALLEY_POINT_CHARGING})
+    line_laser_obstacle_avoidance: bool | None = field(
+        default=None, metadata={"dps": B01_Q10_DP.LINE_LASER_OBSTACLE_AVOIDANCE}
+    )
+    # Whether a mop module is attached, and whether "clean along floor direction" is on.
+    mop_state: bool | None = field(default=None, metadata={"dps": B01_Q10_DP.MOP_STATE})
+    ground_clean: bool | None = field(default=None, metadata={"dps": B01_Q10_DP.GROUND_CLEAN})
+    # True while an "add area" / re-clean (the app's draw-a-rectangle "re cleaning")
+    # request is in progress; pulses back to False once the robot has the area.
+    add_clean_state: bool | None = field(default=None, metadata={"dps": B01_Q10_DP.ADD_CLEAN_STATE})
+    robot_country_code: str | None = field(default=None, metadata={"dps": B01_Q10_DP.ROBOT_COUNTRY_CODE})
+    time_zone: dpTimeZone | None = field(default=None, metadata={"dps": B01_Q10_DP.TIME_ZONE})
+
+    # TODO(#846): value mappings for these ints are not yet decoded (no app
+    # control found / internal / constant); keep as int until reverse-engineered.
+    breakpoint_clean: int | None = field(default=None, metadata={"dps": B01_Q10_DP.BREAKPOINT_CLEAN})
+    timer_type: int | None = field(default=None, metadata={"dps": B01_Q10_DP.TIMER_TYPE})
+    user_plan: int | None = field(default=None, metadata={"dps": B01_Q10_DP.USER_PLAN})
+    robot_type: int | None = field(default=None, metadata={"dps": B01_Q10_DP.ROBOT_TYPE})
+
+    # DEPRECATED: consumable/accessory remaining-life now lives on the
+    # ``Q10Consumable`` trait. These aliases are kept here for backwards
+    # compatibility and will be removed in a follow-up release. See PR #846.
+    main_brush_life: int | None = field(default=None, metadata={"dps": B01_Q10_DP.MAIN_BRUSH_LIFE})
+    side_brush_life: int | None = field(default=None, metadata={"dps": B01_Q10_DP.SIDE_BRUSH_LIFE})
+    filter_life: int | None = field(default=None, metadata={"dps": B01_Q10_DP.FILTER_LIFE})
+    sensor_life: int | None = field(default=None, metadata={"dps": B01_Q10_DP.SENSOR_LIFE})
+
+
+@dataclass
+class SoundVolume(RoborockBase):
+    """Speaker volume read-model (0-100)."""
+
+    volume: int | None = field(default=None, metadata={"dps": B01_Q10_DP.VOLUME})
+
+
+@dataclass
+class ChildLock(RoborockBase):
+    """Child-lock read-model."""
+
+    child_lock: bool | None = field(default=None, metadata={"dps": B01_Q10_DP.CHILD_LOCK})
+
+
+@dataclass
+class DoNotDisturb(RoborockBase):
+    """Do Not Disturb read-model."""
+
+    not_disturb: bool | None = field(default=None, metadata={"dps": B01_Q10_DP.NOT_DISTURB})
+    not_disturb_expand: dpNotDisturbExpand | None = field(default=None, metadata={"dps": B01_Q10_DP.NOT_DISTURB_EXPAND})
+
+
+@dataclass
+class DustCollection(RoborockBase):
+    """Dock auto-empty (dust collection) read-model."""
+
+    dust_switch: bool | None = field(default=None, metadata={"dps": B01_Q10_DP.DUST_SWITCH})
+    dust_setting: YXDeviceDustCollectionFrequency | None = field(
+        default=None, metadata={"dps": B01_Q10_DP.DUST_SETTING}
+    )
+
+
+@dataclass
+class Q10Consumable(RoborockBase):
+    """Consumable / accessory remaining-life read-model.
+
+    Named with a ``Q10`` prefix to avoid shadowing the v1 ``Consumable`` when both
+    are star-imported into the ``roborock.data`` namespace.
+    """
+
+    main_brush_life: int | None = field(default=None, metadata={"dps": B01_Q10_DP.MAIN_BRUSH_LIFE})
+    side_brush_life: int | None = field(default=None, metadata={"dps": B01_Q10_DP.SIDE_BRUSH_LIFE})
+    filter_life: int | None = field(default=None, metadata={"dps": B01_Q10_DP.FILTER_LIFE})
+    sensor_life: int | None = field(default=None, metadata={"dps": B01_Q10_DP.SENSOR_LIFE})
+
+
+@dataclass
+class Q10NetworkInfo(RoborockBase):
+    """Network information read-model.
+
+    Named with a ``Q10`` prefix to avoid shadowing the v1 ``NetworkInfo`` when both
+    are star-imported into the ``roborock.data`` namespace.
+    """
+
+    net_info: dpNetInfo | None = field(default=None, metadata={"dps": B01_Q10_DP.NET_INFO})

{python_roborock-5.20.1 → python_roborock-5.22.0}/roborock/data/code_mappings.py

@@ -76,11 +76,17 @@ class RoborockModeEnum(StrEnum):
 
     @classmethod
     def from_code_optional(cls, code: int) -> Self | None:
-        """Gracefully return None if the code does not exist."""
-        try:
-            return cls.from_code(code)
-        except ValueError:
-            return None
+        """Gracefully return None if the code does not exist.
+
+        This is the silent counterpart to :meth:`from_code`: callers use it when
+        an unknown code is expected and tolerable (e.g. decoding a device push
+        that may include data points this library does not model yet), so it must
+        not emit the "not a valid code" warning that ``from_code`` logs.
+        """
+        for member in cls:
+            if member.code == code:
+                return member
+        return None
 
     @classmethod
     def from_value(cls, value: str) -> Self:
@@ -115,12 +121,14 @@ class RoborockModeEnum(StrEnum):
             return cls.from_value(str(value))
         except ValueError:
             pass
-        # Try integer code lookup (e.g. "11")
+        # Try integer code lookup (e.g. "11"). Use the silent optional variant so
+        # a value that is neither a name, a DP string, nor a known code resolves
+        # to None without logging a spurious "not a valid code" warning.
         try:
-            return cls.from_code(int(value))
+            int_code = int(value)
         except (ValueError, TypeError):
-            pass
-        return None
+            return None
+        return cls.from_code_optional(int_code)
 
     @classmethod
     def keys(cls) -> list[str]: