python-roborock 5.20.1__py3-none-any.whl → 5.22.0__py3-none-any.whl

{python_roborock-5.20.1.dist-info → python_roborock-5.22.0.dist-info}/METADATA

@@ -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.dist-info → python_roborock-5.22.0.dist-info}/RECORD

@@ -1,7 +1,7 @@
 roborock/__init__.py,sha256=jpp3MEmevRvoJ5tq2waCDGH5VfJk--Lv1DmrwEdDyEQ,375
 roborock/broadcast_protocol.py,sha256=fjNQW7NdBKRzSy6126TfCSoYGpT2Esj9Jd-t7tXFc_E,4015
 roborock/callbacks.py,sha256=w2yPXtWFH7zfoFsLPYoCTbfwbE9p1ivA7iDcw20lJQI,4300
-roborock/cli.py,sha256=LQ2mxKlsloSJMp7-DjLiXS5S-AN85tads2ZvA4MzcVg,54916
+roborock/cli.py,sha256=3AZHW8Co1H0Bqi7o1nMKA2MkfPuld_OdbPHQh_sNzCA,63478
 roborock/const.py,sha256=fWpgUPrCgLnaXmncgjCLZET-t7wHWQlpyzV8qHtTjb4,2860
 roborock/device_features.py,sha256=ltWheUjsaOHm-Naw24evRkDUVBT9gB2l4wX-meI_dWo,35960
 roborock/diagnostics.py,sha256=YIc7BhC6Cy6W2a6hykvfSRPG8NpLrPZCc_7jTX2Zdho,5091
@@ -13,11 +13,11 @@ roborock/roborock_typing.py,sha256=Rwx0c0oZCMY-4O8VMLnFSO_OUNb_D59cyG_ktZTZoZI,1
 roborock/util.py,sha256=mjw329ujLjoWPPAr9mG0VZstaVL06dmVvNnYACB-Pxk,1650
 roborock/web_api.py,sha256=M_A4PiRK5cwkoT3oS8fvglOU97s1jpWKuuCxeeCiF_E,37507
 roborock/data/__init__.py,sha256=DikqaVM7VPVddkBNkHSss5zb1_iKB7GYmc2GiHoMAkA,257
-roborock/data/code_mappings.py,sha256=CzD9q-VuPy70pDZdjZ6kgK4vcGdzNGV3Eo5z9QGOYp0,8399
+roborock/data/code_mappings.py,sha256=Cj1nEQkv3Vko7Mh8FODNtfIS5gn5KlTq2QXFtcincHo,8948
 roborock/data/containers.py,sha256=-b6H2snGQTzsJSsctgil6sx8rLtCDihTTzdkxcFRdlE,16489
 roborock/data/b01_q10/__init__.py,sha256=E4lwJcz4AI1z92FcYOJ-cY3fcfHSoXqvYVgfA-TgaRk,71
-roborock/data/b01_q10/b01_q10_code_mappings.py,sha256=qJmw4lGYjQO_Uowsp6gMudbULmkBtNq0ZiHaUxoUZ-4,8336
-roborock/data/b01_q10/b01_q10_containers.py,sha256=wFHeZPGj6NvljKL99j1209ldwiVNAdqKh52UvMFU640,3514
+roborock/data/b01_q10/b01_q10_code_mappings.py,sha256=NDKLgm9UvsRo90rLFvEkZ-eD5QbA_-hqgSSHa6DkhLM,9883
+roborock/data/b01_q10/b01_q10_containers.py,sha256=YD08ZJnHv-ItK6guYtj-cH0bbYsvD2kMCfKat9DblBI,8628
 roborock/data/b01_q7/__init__.py,sha256=D-Cd8eB0njf1PQPM6Exl_9A0AhpzIjrL0hapGOCEkkA,69
 roborock/data/b01_q7/b01_q7_code_mappings.py,sha256=EHSCZSv_Os049NcenKo4tkPjDOB4vpmQ2p2Psr9FRCc,10698
 roborock/data/b01_q7/b01_q7_containers.py,sha256=jNEHoNEdq276XJZGGUmtSyJ81cSIzJwem-O_NOgmfdQ,10270
@@ -47,12 +47,20 @@ roborock/devices/traits/common.py,sha256=KUlXvx2UcFVeNXEhPiCAdy2APu7zrJmM_jME_bM
 roborock/devices/traits/traits_mixin.py,sha256=7t15l_Ty1cN-3-fKNtRH1XR6-mfadPnTBCQRZP4rAtc,2092
 roborock/devices/traits/a01/__init__.py,sha256=i-us9zLPWPfSQ5XWq8t0MiYLYe5NkcLvk3aEQTYT7E0,8104
 roborock/devices/traits/b01/__init__.py,sha256=pGN6wEocE6Fr2BTasG8Z_75crD6OdTwpju59Vw7eTDk,202
-roborock/devices/traits/b01/q10/__init__.py,sha256=bABqhW9Xr-FGjNHSl8b6veOVFI4M2LebLnnoCTfzaPQ,3729
+roborock/devices/traits/b01/q10/__init__.py,sha256=CGzhddpgCvEJF-H9ZbZ1P89XNcPf2wcpBMn-1JVliN8,5803
+roborock/devices/traits/b01/q10/button_light.py,sha256=_CCWSjFe_iZnnSXgBHOju31VUmwG1KKd_jGkmSpLew4,994
+roborock/devices/traits/b01/q10/child_lock.py,sha256=bTsbAMxn7AF1zpWteyZCkQm4jj3NiWD8ddZTM3tlG_0,1131
 roborock/devices/traits/b01/q10/command.py,sha256=mcWNRSq72bfa79_EjKRgMEIDTV3vWFh2ofBe4aF7EOE,1306
+roborock/devices/traits/b01/q10/common.py,sha256=Qxl3zBAUulqdrjFZJ0DPEFEIJLvlPqUKuTQGPloy7Ds,3089
+roborock/devices/traits/b01/q10/consumable.py,sha256=MbtMgYKqzNdVn6M1iyOAqZPCYTbN_Q_Pr4h8EYGEiuY,669
+roborock/devices/traits/b01/q10/do_not_disturb.py,sha256=klyGQZ_nHyO6bhPlwBl8vElTnMwPf4A8VXwxkU8rMlM,1157
+roborock/devices/traits/b01/q10/dust_collection.py,sha256=LM-0YH4pMrEqLUCFP2g-DymhL5ZUQ4bHd-2EyKHmucY,1582
 roborock/devices/traits/b01/q10/map.py,sha256=ETaPWIH1qpiZQrutwm3aJu-WxS-idxLtjxntRduE70Q,4170
-roborock/devices/traits/b01/q10/remote.py,sha256=ZvURdYP023vsJF6Mx9rA004bi6tOPAjrL4o7dC1baFQ,1257
-roborock/devices/traits/b01/q10/status.py,sha256=dIuUpRVjOVXvFr-EA_7lV9KCF7XXjE4vQOFsd-Bbh8w,1133
-roborock/devices/traits/b01/q10/vacuum.py,sha256=7PUPWaLqj3jsNLw87oyf1oz2UXckF4Z5Fh6ZYqeY7Ww,2280
+roborock/devices/traits/b01/q10/network_info.py,sha256=XiCr6YPu7xkvhgeaGwXli-_4SB88QW63ykiegyaau2k,656
+roborock/devices/traits/b01/q10/remote.py,sha256=8-fg4SA5M-tdMufHPeD9hIcax7y9Qh7pzcE7rBBVW_o,1267
+roborock/devices/traits/b01/q10/status.py,sha256=JAPixbsQ8jfN3OvI7o_NxISXFk8l7rGHFYcL4pH97Jk,859
+roborock/devices/traits/b01/q10/vacuum.py,sha256=w2FftNH5n-Tb-9drR3-5OiMy85FJfTDNmtt34LklC8w,4374
+roborock/devices/traits/b01/q10/volume.py,sha256=UnT0yYDQntxYwnpv4_NVychm0FnGAYRAWA_FJR4yJag,1001
 roborock/devices/traits/b01/q7/__init__.py,sha256=gHgIK-KBLDJDEneBmSJfTa38sumj1IuZl-lcvoZeYLY,8116
 roborock/devices/traits/b01/q7/clean_summary.py,sha256=Tod29LUHBsOS0XL8SU1SdBQEHWTCifGZVCwSWGhYpy8,2933
 roborock/devices/traits/b01/q7/map.py,sha256=Zrvj8LNctIFksCBoiZVQ1x4hgG3wwp1jqPY-If__JXw,1489
@@ -101,8 +109,8 @@ roborock/protocols/a01_protocol.py,sha256=JCIhUuVNamcENu0gtZR2x8rBz6dpAZLcbA-NQg
 roborock/protocols/b01_q10_protocol.py,sha256=Ac3_VHJ2DAwBiXFMPYOHExEV0prxS9Ju0djiC8nKtiI,4935
 roborock/protocols/b01_q7_protocol.py,sha256=o8repRrxhxknzspsg1K27ds643rs87ilWXbj8RJtOCs,4619
 roborock/protocols/v1_protocol.py,sha256=uA-EMXd1AUBAXjkjAm0VxZlPLre0v2X9Kei5UqyPzaY,11141
-python_roborock-5.20.1.dist-info/METADATA,sha256=3EoWV62lgSj-6Cu9c8ve9cZjRlRC2--VgTDynMbEmtg,5281
-python_roborock-5.20.1.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
-python_roborock-5.20.1.dist-info/entry_points.txt,sha256=EvC1nMqi9ZXKgZnqlNXA33v_3nzgPNjnM0mzWlrehnY,47
-python_roborock-5.20.1.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-python_roborock-5.20.1.dist-info/RECORD,,
+python_roborock-5.22.0.dist-info/METADATA,sha256=5-phrqS20MJVmIfW1RzPIpiWW2LhAJOra6wFGM9V7ho,5281
+python_roborock-5.22.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+python_roborock-5.22.0.dist-info/entry_points.txt,sha256=EvC1nMqi9ZXKgZnqlNXA33v_3nzgPNjnM0mzWlrehnY,47
+python_roborock-5.22.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+python_roborock-5.22.0.dist-info/RECORD,,

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

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

roborock/data/b01_q10/b01_q10_containers.py

@@ -2,7 +2,7 @@
 
 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
-`update_from_dps` helper in `roborock.devices.traits.b01.q10.common` to
+`UpdatableTrait` helper in `roborock.devices.traits.b01.q10.common` to
 automatically update objects from raw device responses.
 """
 
@@ -11,9 +11,13 @@ 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,
@@ -51,18 +55,24 @@ class dpSelfIdentifyingCarpet(RoborockBase):
 
 @dataclass
 class dpNetInfo(RoborockBase):
-    wifiName: str
-    ipAdress: str
-    mac: str
-    signal: int
+    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
-    disturb_light: int
-    disturb_resume_clean: int
-    disturb_voice: int
+    disturb_dust_enable: int | None = None
+    disturb_light: int | None = None
+    disturb_resume_clean: int | None = None
+    disturb_voice: int | None = None
 
 
 @dataclass
@@ -77,16 +87,18 @@ class dpVoiceVersion(RoborockBase):
 
 @dataclass
 class dpTimeZone(RoborockBase):
-    timeZoneCity: str
-    timeZoneSec: int
+    time_zone_city: str | None = None
+    time_zone_sec: int | None = None
 
 
 @dataclass
 class Q10Status(RoborockBase):
-    """Status for Q10 devices.
+    """Core vacuum status for Q10 devices.
 
     Fields are mapped to DPS values using metadata. Objects of this class can be
-    automatically updated using the `update_from_dps` helper.
+    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})
@@ -99,12 +111,101 @@ class Q10Status(RoborockBase):
     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})
-    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})
     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})

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]:

roborock/devices/traits/b01/q10/__init__.py

@@ -10,15 +10,30 @@ from roborock.devices.transport.mqtt_channel import MqttChannel
 from roborock.map.b01_q10_map_parser import Q10MapPacket, Q10TracePacket
 from roborock.protocols.b01_q10_protocol import Q10DpsUpdate, Q10Message
 
+from .button_light import ButtonLightTrait
+from .child_lock import ChildLockTrait
 from .command import CommandTrait
+from .consumable import ConsumableTrait
+from .do_not_disturb import DoNotDisturbTrait
+from .dust_collection import DustCollectionTrait
 from .map import MapContentTrait
+from .network_info import NetworkInfoTrait
 from .remote import RemoteTrait
 from .status import StatusTrait
 from .vacuum import VacuumTrait
+from .volume import SoundVolumeTrait
 
 __all__ = [
     "Q10PropertiesApi",
+    "ButtonLightTrait",
+    "ChildLockTrait",
+    "ConsumableTrait",
+    "DoNotDisturbTrait",
+    "DustCollectionTrait",
     "MapContentTrait",
+    "NetworkInfoTrait",
+    "SoundVolumeTrait",
+    "StatusTrait",
 ]
 
 _LOGGER = logging.getLogger(__name__)
@@ -31,7 +46,7 @@ class Q10PropertiesApi(Trait):
     """Trait for sending commands to Q10 devices."""
 
     status: StatusTrait
-    """Trait for managing the status of Q10 devices."""
+    """Trait for managing the core status of Q10 devices."""
 
     vacuum: VacuumTrait
     """Trait for sending vacuum related commands to Q10 devices."""
@@ -39,6 +54,27 @@ class Q10PropertiesApi(Trait):
     remote: RemoteTrait
     """Trait for sending remote control related commands to Q10 devices."""
 
+    volume: SoundVolumeTrait
+    """Trait for reading / setting the speaker volume."""
+
+    child_lock: ChildLockTrait
+    """Trait for reading / controlling the child lock."""
+
+    do_not_disturb: DoNotDisturbTrait
+    """Trait for reading / controlling Do Not Disturb."""
+
+    dust_collection: DustCollectionTrait
+    """Trait for reading / controlling dock auto-empty (dust collection)."""
+
+    button_light: ButtonLightTrait
+    """Trait for controlling the indicator / button light (LED)."""
+
+    network_info: NetworkInfoTrait
+    """Trait exposing the device's network information."""
+
+    consumable: ConsumableTrait
+    """Trait exposing remaining life of consumables."""
+
     map: MapContentTrait
     """Trait for fetching the current parsed map (image + rooms)."""
 
@@ -49,7 +85,24 @@ class Q10PropertiesApi(Trait):
         self.vacuum = VacuumTrait(self.command)
         self.remote = RemoteTrait(self.command)
         self.status = StatusTrait()
+        self.volume = SoundVolumeTrait(self.command)
+        self.child_lock = ChildLockTrait(self.command)
+        self.do_not_disturb = DoNotDisturbTrait(self.command)
+        self.dust_collection = DustCollectionTrait(self.command)
+        self.button_light = ButtonLightTrait(self.command)
+        self.network_info = NetworkInfoTrait()
+        self.consumable = ConsumableTrait()
         self.map = MapContentTrait()
+        # Read-model traits updated from the device's DPS push stream.
+        self._updatable_traits = [
+            self.status,
+            self.volume,
+            self.child_lock,
+            self.do_not_disturb,
+            self.dust_collection,
+            self.network_info,
+            self.consumable,
+        ]
         self._subscribe_task: asyncio.Task[None] | None = None
 
     async def start(self) -> None:
@@ -83,7 +136,7 @@ class Q10PropertiesApi(Trait):
         Map and trace packets arrive as protocol-301 ``MAP_RESPONSE`` pushes (the
         Q10 is entirely push-driven: there is no synchronous get-map request, a
         ``dpRequestDps`` just nudges the device to publish its current map). DPS
-        updates feed the status trait. More traits can be dispatched here below.
+        updates feed the read-model traits. More traits can be dispatched here below.
         """
         if isinstance(message, Q10MapPacket):
             self.map.update_from_map_packet(message)
@@ -91,7 +144,10 @@ class Q10PropertiesApi(Trait):
             self.map.update_from_trace_packet(message)
         elif isinstance(message, Q10DpsUpdate):
             _LOGGER.debug("Received Q10 status update: %s", message.dps)
-            self.status.update_from_dps(message.dps)
+            # Notify all read-model traits about the new message; each trait
+            # only updates the fields that it is responsible for.
+            for trait in self._updatable_traits:
+                trait.update_from_dps(message.dps)
 
 
 def create(channel: MqttChannel) -> Q10PropertiesApi:

roborock/devices/traits/b01/q10/button_light.py

@@ -0,0 +1,29 @@
+"""Indicator / button light (LED) trait for Q10 B01 devices."""
+
+from roborock.data.b01_q10.b01_q10_code_mappings import B01_Q10_DP
+
+from .command import CommandTrait
+
+
+class ButtonLightTrait:
+    """Trait for controlling the indicator / button light (LED) of a Q10 device.
+
+    The device does not report the button-light state in its status dump, so
+    this trait is write-only (no read-back).
+    """
+
+    def __init__(self, command: CommandTrait) -> None:
+        """Initialize the button light trait."""
+        self._command = command
+
+    async def _write(self, value: int) -> None:
+        """Write the button-light data point via the dpCommon (101) wrapper."""
+        await self._command.send(B01_Q10_DP.COMMON, {str(B01_Q10_DP.BUTTON_LIGHT_SWITCH.code): value})
+
+    async def enable(self) -> None:
+        """Turn the indicator light on."""
+        await self._write(1)
+
+    async def disable(self) -> None:
+        """Turn the indicator light off."""
+        await self._write(0)

roborock/devices/traits/b01/q10/child_lock.py

@@ -0,0 +1,36 @@
+"""Child lock trait for Q10 B01 devices."""
+
+import logging
+
+from roborock.data.b01_q10.b01_q10_code_mappings import B01_Q10_DP
+from roborock.data.b01_q10.b01_q10_containers import ChildLock
+from roborock.devices.traits.common import DpsDataConverter
+
+from .command import CommandTrait
+from .common import UpdatableTrait
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class ChildLockTrait(ChildLock, UpdatableTrait):
+    """Trait for reading and controlling the child lock of a Q10 device."""
+
+    _CONVERTER = DpsDataConverter.from_dataclass(ChildLock)
+
+    def __init__(self, command: CommandTrait) -> None:
+        """Initialize the child lock trait."""
+        ChildLock.__init__(self)
+        UpdatableTrait.__init__(self, command, _LOGGER)
+
+    @property
+    def is_on(self) -> bool:
+        """Return whether the child lock is enabled."""
+        return bool(self.child_lock)
+
+    async def enable(self) -> None:
+        """Enable the child lock."""
+        await self._write(B01_Q10_DP.CHILD_LOCK, 1)
+
+    async def disable(self) -> None:
+        """Disable the child lock."""
+        await self._write(B01_Q10_DP.CHILD_LOCK, 0)

roborock/devices/traits/b01/q10/common.py

@@ -0,0 +1,70 @@
+"""Common helpers for Q10 B01 traits.
+
+Q10 devices push their full state as a single decoded DPS dictionary (see
+``Q10PropertiesApi._subscribe_loop``). Each trait owns a small ``RoborockBase``
+read-model whose fields are annotated with ``field(metadata={"dps": ...})`` and
+only updates the fields it is responsible for, ignoring the rest.
+
+The :class:`UpdatableTrait` base wires that read-model to the update lifecycle
+and (for traits that also write) exposes the ``dpCommon`` (101) wrapper used by
+Q10 setting writes.
+"""
+
+import logging
+from typing import Any, ClassVar, cast
+
+from roborock.data.b01_q10.b01_q10_code_mappings import B01_Q10_DP
+from roborock.data.containers import RoborockBase
+from roborock.devices.traits.common import DpsDataConverter, TraitUpdateListener
+
+from .command import CommandTrait
+
+
+class UpdatableTrait(TraitUpdateListener):
+    """Base for Q10 traits backed by a read-model updated from the DPS stream.
+
+    Concrete traits subclass both their ``RoborockBase`` read-model and this
+    class, set the ``_CONVERTER`` class attribute, and initialize the read-model
+    explicitly in their constructor, e.g.::
+
+        class SoundVolumeTrait(SoundVolume, UpdatableTrait):
+            _CONVERTER = DpsDataConverter.from_dataclass(SoundVolume)
+
+            def __init__(self, command: CommandTrait) -> None:
+                SoundVolume.__init__(self)
+                UpdatableTrait.__init__(self, command, _LOGGER)
+
+    The read-model init is called explicitly (rather than via ``super()``)
+    because the read-model dataclass precedes this class in the MRO.
+
+    Traits that also send commands receive a :class:`CommandTrait` and use the
+    :meth:`_write` helper, which wraps the write in the ``dpCommon`` (101) data
+    point as the device requires.
+    """
+
+    _CONVERTER: ClassVar[DpsDataConverter]
+
+    def __init__(self, command: CommandTrait | None, logger: logging.Logger) -> None:
+        """Initialize the update listener. The read-model is initialized by the subclass."""
+        TraitUpdateListener.__init__(self, logger=logger)
+        self._command = command
+
+    def update_from_dps(self, decoded_dps: dict[B01_Q10_DP, Any]) -> None:
+        """Update the trait's read-model from raw DPS data and notify listeners.
+
+        Concrete traits also subclass a ``RoborockBase`` read-model, so the cast
+        is always valid at runtime.
+        """
+        if self._CONVERTER.update_from_dps(cast(RoborockBase, self), decoded_dps):
+            self._notify_update()
+
+    async def _write(self, dp: B01_Q10_DP, value: int) -> None:
+        """Write a single data point value via the dpCommon (101) wrapper.
+
+        Q10 setting writes must be wrapped in ``dpCommon`` (101), e.g. setting
+        the volume sends ``{"dps": {"101": {"26": <value>}}}``. Writing the bare
+        data point (without the wrapper) is silently ignored by the device.
+        """
+        if self._command is None:
+            raise ValueError("Trait is read-only; no command channel was provided")
+        await self._command.send(B01_Q10_DP.COMMON, {str(dp.code): value})

roborock/devices/traits/b01/q10/consumable.py

@@ -0,0 +1,21 @@
+"""Consumable / accessory life trait for Q10 B01 devices."""
+
+import logging
+
+from roborock.data.b01_q10.b01_q10_containers import Q10Consumable
+from roborock.devices.traits.common import DpsDataConverter
+
+from .common import UpdatableTrait
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class ConsumableTrait(Q10Consumable, UpdatableTrait):
+    """Trait exposing remaining life of consumables (brushes, filter, sensors)."""
+
+    _CONVERTER = DpsDataConverter.from_dataclass(Q10Consumable)
+
+    def __init__(self) -> None:
+        """Initialize the consumable trait."""
+        Q10Consumable.__init__(self)
+        UpdatableTrait.__init__(self, command=None, logger=_LOGGER)

roborock/devices/traits/b01/q10/do_not_disturb.py

@@ -0,0 +1,36 @@
+"""Do Not Disturb trait for Q10 B01 devices."""
+
+import logging
+
+from roborock.data.b01_q10.b01_q10_code_mappings import B01_Q10_DP
+from roborock.data.b01_q10.b01_q10_containers import DoNotDisturb
+from roborock.devices.traits.common import DpsDataConverter
+
+from .command import CommandTrait
+from .common import UpdatableTrait
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class DoNotDisturbTrait(DoNotDisturb, UpdatableTrait):
+    """Trait for reading and controlling Do Not Disturb on a Q10 device."""
+
+    _CONVERTER = DpsDataConverter.from_dataclass(DoNotDisturb)
+
+    def __init__(self, command: CommandTrait) -> None:
+        """Initialize the Do Not Disturb trait."""
+        DoNotDisturb.__init__(self)
+        UpdatableTrait.__init__(self, command, _LOGGER)
+
+    @property
+    def is_on(self) -> bool:
+        """Return whether Do Not Disturb is enabled."""
+        return bool(self.not_disturb)
+
+    async def enable(self) -> None:
+        """Enable Do Not Disturb."""
+        await self._write(B01_Q10_DP.NOT_DISTURB, 1)
+
+    async def disable(self) -> None:
+        """Disable Do Not Disturb."""
+        await self._write(B01_Q10_DP.NOT_DISTURB, 0)

roborock/devices/traits/b01/q10/dust_collection.py

@@ -0,0 +1,43 @@
+"""Dust collection (dock auto-empty) trait for Q10 B01 devices."""
+
+import logging
+
+from roborock.data.b01_q10.b01_q10_code_mappings import B01_Q10_DP, YXDeviceDustCollectionFrequency
+from roborock.data.b01_q10.b01_q10_containers import DustCollection
+from roborock.devices.traits.common import DpsDataConverter
+
+from .command import CommandTrait
+from .common import UpdatableTrait
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class DustCollectionTrait(DustCollection, UpdatableTrait):
+    """Trait for reading and controlling automatic dust collection at the dock."""
+
+    _CONVERTER = DpsDataConverter.from_dataclass(DustCollection)
+
+    def __init__(self, command: CommandTrait) -> None:
+        """Initialize the dust collection trait."""
+        DustCollection.__init__(self)
+        UpdatableTrait.__init__(self, command, _LOGGER)
+
+    @property
+    def is_on(self) -> bool:
+        """Return whether automatic dust collection is enabled."""
+        return bool(self.dust_switch)
+
+    async def enable(self) -> None:
+        """Enable automatic dust collection at the dock."""
+        await self._write(B01_Q10_DP.DUST_SWITCH, 1)
+
+    async def disable(self) -> None:
+        """Disable automatic dust collection at the dock."""
+        await self._write(B01_Q10_DP.DUST_SWITCH, 0)
+
+    async def set_frequency(self, frequency: YXDeviceDustCollectionFrequency) -> None:
+        """Set how often the dock empties the bin.
+
+        The value is the interval in cleans, with ``DAILY`` (0) meaning daily.
+        """
+        await self._write(B01_Q10_DP.DUST_SETTING, frequency.code)

roborock/devices/traits/b01/q10/network_info.py

@@ -0,0 +1,21 @@
+"""Network information trait for Q10 B01 devices."""
+
+import logging
+
+from roborock.data.b01_q10.b01_q10_containers import Q10NetworkInfo
+from roborock.devices.traits.common import DpsDataConverter
+
+from .common import UpdatableTrait
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class NetworkInfoTrait(Q10NetworkInfo, UpdatableTrait):
+    """Trait exposing the device's network information (read-only)."""
+
+    _CONVERTER = DpsDataConverter.from_dataclass(Q10NetworkInfo)
+
+    def __init__(self) -> None:
+        """Initialize the network info trait."""
+        Q10NetworkInfo.__init__(self)
+        UpdatableTrait.__init__(self, command=None, logger=_LOGGER)

roborock/devices/traits/b01/q10/remote.py

@@ -20,7 +20,7 @@ class RemoteTrait:
         self._command = command
 
     async def _send_remote(self, action: RemoteCommand) -> None:
-        await self._command.send(B01_Q10_DP.COMMON, params={B01_Q10_DP.REMOTE: action.value})
+        await self._command.send(B01_Q10_DP.COMMON, params={str(B01_Q10_DP.REMOTE.code): action.value})
 
     async def forward(self) -> None:
         """Move forward."""

roborock/devices/traits/b01/q10/status.py

@@ -1,31 +1,26 @@
 """Status trait for Q10 B01 devices."""
 
 import logging
-from typing import Any
 
-from roborock.data.b01_q10.b01_q10_code_mappings import B01_Q10_DP
 from roborock.data.b01_q10.b01_q10_containers import Q10Status
-from roborock.devices.traits.common import DpsDataConverter, TraitUpdateListener
+from roborock.devices.traits.common import DpsDataConverter
 
-_LOGGER = logging.getLogger(__name__)
+from .common import UpdatableTrait
 
-_CONVERTER = DpsDataConverter.from_dataclass(Q10Status)
+_LOGGER = logging.getLogger(__name__)
 
 
-class StatusTrait(Q10Status, TraitUpdateListener):
-    """Trait for managing the status of Q10 Roborock devices.
+class StatusTrait(Q10Status, UpdatableTrait):
+    """Trait for managing the core status of Q10 Roborock devices.
 
     This is a thin wrapper around Q10Status that provides the Trait interface.
     The current values reflect the most recently received data from the device.
     New values can be requested through the `Q10PropertiesApi`'s `refresh` method.
     """
 
+    _CONVERTER = DpsDataConverter.from_dataclass(Q10Status)
+
     def __init__(self) -> None:
         """Initialize the status trait."""
-        super().__init__()
-        TraitUpdateListener.__init__(self, logger=_LOGGER)
-
-    def update_from_dps(self, decoded_dps: dict[B01_Q10_DP, Any]) -> None:
-        """Update the trait from raw DPS data."""
-        if _CONVERTER.update_from_dps(self, decoded_dps):
-            self._notify_update()
+        Q10Status.__init__(self)
+        UpdatableTrait.__init__(self, command=None, logger=_LOGGER)

roborock/devices/traits/b01/q10/vacuum.py

@@ -3,6 +3,7 @@
 from roborock.data.b01_q10.b01_q10_code_mappings import (
     B01_Q10_DP,
     YXCleanType,
+    YXDeviceCleanTask,
     YXFanLevel,
 )
 
@@ -21,50 +22,77 @@ class VacuumTrait:
         self._command = command
 
     async def start_clean(self) -> None:
-        """Start cleaning."""
+        """Start a whole-home clean.
+
+        The ``dpStartClean`` (201) command selects a task by code: ``1`` =
+        whole-home, ``2`` = segment/room (see :meth:`clean_segments`), ``3`` =
+        zone, ``4`` = build map, ``5`` = spot. Whole-home and spot accept the
+        bare integer code; segment cleaning needs a room selection (an object
+        payload) instead.
+
+        Verified live against ss07 hardware: ``{"dps": {"201": 1}}`` starts a
+        whole-home clean (clean_task_type -> 1).
+        """
+        await self._command.send(command=B01_Q10_DP.START_CLEAN, params=1)
+
+    async def clean_segments(self, segment_ids: list[int]) -> None:
+        """Start a room / segment clean for the given segment (room) ids.
+
+        The ids are the same room ids the device reports on its map (see the Q10
+        ``MapContentTrait`` -- ``map.rooms``, each with an ``id``).
+
+        Unlike whole-home and spot, ``dpStartClean`` (201) carries the room
+        selection as an object: ``{"cmd": <task>, "clean_paramters": [<id>, ...]}``,
+        where ``cmd`` is the segment-clean task code.
+
+        Verified live against ss07 hardware: sending
+        ``{"dps": {"201": {"cmd": 2, "clean_paramters": [9]}}}`` starts cleaning
+        room 9 (clean_task_type -> 2 / electoral).
+        """
         await self._command.send(
             command=B01_Q10_DP.START_CLEAN,
-            # TODO: figure out other commands
-            # 1 = start cleaning
-            # 2 = "electoral" clean, also has "clean_parameters"
-            # 4 = fast create map
-            params={"cmd": 1},
+            # "clean_paramters" intentionally mirrors the device's misspelling of
+            # "parameters" -- the firmware only accepts that exact key.
+            params={"cmd": YXDeviceCleanTask.ELECTORAL.code, "clean_paramters": segment_ids},
         )
 
+    async def spot_clean(self) -> None:
+        """Start a spot / part clean around the robot's current position.
+
+        Verified live: ``{"dps": {"201": 5}}`` (clean_task_type -> 5).
+        """
+        await self._command.send(command=B01_Q10_DP.START_CLEAN, params=5)
+
     async def pause_clean(self) -> None:
-        """Pause cleaning."""
-        await self._command.send(
-            command=B01_Q10_DP.PAUSE,
-            params={},
-        )
+        """Pause the current task. Verified live: ``{"dps": {"204": 0}}``."""
+        await self._command.send(command=B01_Q10_DP.PAUSE, params=0)
 
     async def resume_clean(self) -> None:
-        """Resume cleaning."""
-        await self._command.send(
-            command=B01_Q10_DP.RESUME,
-            params={},
-        )
+        """Resume a paused task. Verified live: ``{"dps": {"205": 0}}``."""
+        await self._command.send(command=B01_Q10_DP.RESUME, params=0)
 
     async def stop_clean(self) -> None:
-        """Stop cleaning."""
-        await self._command.send(
-            command=B01_Q10_DP.STOP,
-            params={},
-        )
+        """Stop / cancel the current task. Verified live: ``{"dps": {"206": 0}}``."""
+        await self._command.send(command=B01_Q10_DP.STOP, params=0)
 
     async def return_to_dock(self) -> None:
-        """Return to dock."""
-        await self._command.send(
-            command=B01_Q10_DP.START_DOCK_TASK,
-            params={},
-        )
+        """Send the robot back to the dock to charge.
+
+        Uses ``dpStartBack`` (202) with the back-dock task code ``5`` (charge),
+        matching the official app. Verified live: ``{"dps": {"202": 5}}`` puts the
+        robot into the returning state. (The other back-dock codes are ``1`` =
+        wash mop en route and ``4`` = collect dust en route.)
+        """
+        await self._command.send(command=B01_Q10_DP.START_BACK, params=5)
 
     async def empty_dustbin(self) -> None:
-        """Empty the dustbin at the dock."""
-        await self._command.send(
-            command=B01_Q10_DP.START_DOCK_TASK,
-            params=2,  # 2 = dock task type for "empty dustbin"
-        )
+        """Empty the dustbin at the dock.
+
+        Verified live: ``{"dps": {"203": 2}}`` triggers dust collection
+        (status -> emptying_the_bin). This is a dock task (``dpStartDockTask``),
+        distinct from the en-route collect-dust back-dock code.
+        """
+        await self._command.send(command=B01_Q10_DP.START_DOCK_TASK, params=2)
 
     async def set_clean_mode(self, mode: YXCleanType) -> None:
         """Set the cleaning mode (vacuum, mop, or both)."""

roborock/devices/traits/b01/q10/volume.py

@@ -0,0 +1,29 @@
+"""Sound volume trait for Q10 B01 devices."""
+
+import logging
+
+from roborock.data.b01_q10.b01_q10_code_mappings import B01_Q10_DP
+from roborock.data.b01_q10.b01_q10_containers import SoundVolume
+from roborock.devices.traits.common import DpsDataConverter
+
+from .command import CommandTrait
+from .common import UpdatableTrait
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class SoundVolumeTrait(SoundVolume, UpdatableTrait):
+    """Trait for reading and setting the speaker volume of a Q10 device."""
+
+    _CONVERTER = DpsDataConverter.from_dataclass(SoundVolume)
+
+    def __init__(self, command: CommandTrait) -> None:
+        """Initialize the volume trait."""
+        SoundVolume.__init__(self)
+        UpdatableTrait.__init__(self, command, _LOGGER)
+
+    async def set_volume(self, volume: int) -> None:
+        """Set the speaker volume (0-100)."""
+        if not 0 <= volume <= 100:
+            raise ValueError("volume must be between 0 and 100")
+        await self._write(B01_Q10_DP.VOLUME, volume)