rivian-python-client 2.2.0b1__py3-none-any.whl → 2.2.0b3__py3-none-any.whl

rivian/__version__.py

@@ -1,4 +1,4 @@
 # This file is auto-generated by Hatchling. As such, do not:
 #   - modify
 #   - track in version control e.g. be sure to add to .gitignore
-__version__ = VERSION = '2.2.0b1'
+__version__ = VERSION = '2.2.0b3'

rivian/parallax/body.py

@@ -8,28 +8,30 @@ from .core import _LOGGER, RVMDecoder, _enum, _present
 from .proto import body_pb2
 
 _CLOSURE_MAP: Final[dict[int, str]] = {
-    1: "doorFrontLeftClosed",
-    2: "doorFrontRightClosed",
-    3: "doorRearLeftClosed",
-    4: "doorRearRightClosed",
-    5: "closureFrunkClosed",
-    6: "closureTailgateClosed",
-    7: "closureLiftgateClosed",
-    8: "closureSideBinLeftClosed",
-    9: "closureSideBinRightClosed",
-    10: "chargePortState",
-    11: "closureTonneauClosed",
-    12: "windowFrontLeftClosed",
-    13: "windowFrontRightClosed",
-    14: "windowRearLeftClosed",
-    15: "windowRearRightClosed",
+    body_pb2.DOOR_FRONT_LEFT: "doorFrontLeftClosed",
+    body_pb2.DOOR_FRONT_RIGHT: "doorFrontRightClosed",
+    body_pb2.DOOR_REAR_LEFT: "doorRearLeftClosed",
+    body_pb2.DOOR_REAR_RIGHT: "doorRearRightClosed",
+    body_pb2.FRUNK: "closureFrunkClosed",
+    body_pb2.TAILGATE: "closureTailgateClosed",
+    body_pb2.LIFTGATE: "closureLiftgateClosed",
+    body_pb2.SIDE_BIN_LEFT: "closureSideBinLeftClosed",
+    body_pb2.SIDE_BIN_RIGHT: "closureSideBinRightClosed",
+    body_pb2.CHARGE_PORT: "chargePortState",
+    body_pb2.TONNEAU: "closureTonneauClosed",
+    body_pb2.WINDOW_FRONT_LEFT: "windowFrontLeftClosed",
+    body_pb2.WINDOW_FRONT_RIGHT: "windowFrontRightClosed",
+    body_pb2.WINDOW_REAR_LEFT: "windowRearLeftClosed",
+    body_pb2.WINDOW_REAR_RIGHT: "windowRearRightClosed",
+    body_pb2.WINDOW_REAR: "windowRearClosed",
 }
 
 _CLOSURE_STATE_MAP: Final[dict[int, str]] = {
-    1: "open",
-    2: "closed",
-    4: "opening",
-    5: "closing",
+    body_pb2.CLOSURE_STATE_OPEN: "open",
+    body_pb2.CLOSURE_STATE_CLOSED: "closed",
+    body_pb2.CLOSURE_STATE_AJAR: "ajar",
+    body_pb2.CLOSURE_STATE_OPENING: "opening",
+    body_pb2.CLOSURE_STATE_CLOSING: "closing",
 }
 
 
@@ -41,11 +43,7 @@ def _enum_names(enum: Any, prefix: str) -> dict[int, str]:
     }
 
 
-# Other side-bin values are unconfirmed, so they pass through as raw ints.
-_SIDE_BIN_NEXT_ACTIONS: Final[dict[int, str]] = {
-    body_pb2.SIDE_BIN_SNA: "sna",
-    body_pb2.SIDE_BIN_OPEN_ALLOWED: "open_allowed",
-}
+_SIDE_BIN_NEXT_ACTIONS: Final = _enum_names(body_pb2.SideBinNextAction, "SIDE_BIN_")
 
 # Closure id -> (next-action field, result key, value names).
 _NEXT_ACTIONS: Final[dict[int, tuple[str, str, dict[int, str]]]] = {
@@ -54,6 +52,11 @@ _NEXT_ACTIONS: Final[dict[int, tuple[str, str, dict[int, str]]]] = {
         "closureFrunkNextAction",
         _enum_names(body_pb2.FrunkNextAction, "FRUNK_"),
     ),
+    body_pb2.LIFTGATE: (
+        "liftgate_next_action",
+        "closureLiftgateNextAction",
+        _enum_names(body_pb2.LiftgateNextAction, "LIFTGATE_"),
+    ),
     body_pb2.SIDE_BIN_LEFT: (
         "side_bin_next_action",
         "closureSideBinLeftNextAction",
@@ -74,26 +77,42 @@ _NEXT_ACTIONS: Final[dict[int, tuple[str, str, dict[int, str]]]] = {
         "closureChargePortDoorNextAction",
         _enum_names(body_pb2.ChargePortDoorNextAction, "CHARGE_PORT_DOOR_"),
     ),
+    body_pb2.GROUP_WINDOWS: (
+        "windows_next_action",
+        "windowsNextAction",
+        _enum_names(body_pb2.WindowsNextAction, "WINDOWS_"),
+    ),
 }
 
 _LOCK_MAP: Final[dict[int, str]] = {
-    1: "doorFrontLeftLocked",
-    2: "doorFrontRightLocked",
-    3: "doorRearLeftLocked",
-    4: "doorRearRightLocked",
-    5: "closureFrunkLocked",
-    6: "closureTailgateLocked",
-    7: "closureLiftgateLocked",
-    8: "closureSideBinLeftLocked",
-    9: "closureSideBinRightLocked",
-    15: "closureTonneauLocked",
+    body_pb2.LOCK_DOOR_FRONT_LEFT: "doorFrontLeftLocked",
+    body_pb2.LOCK_DOOR_FRONT_RIGHT: "doorFrontRightLocked",
+    body_pb2.LOCK_DOOR_REAR_LEFT: "doorRearLeftLocked",
+    body_pb2.LOCK_DOOR_REAR_RIGHT: "doorRearRightLocked",
+    body_pb2.LOCK_FRUNK: "closureFrunkLocked",
+    body_pb2.LOCK_TAILGATE: "closureTailgateLocked",
+    body_pb2.LOCK_LIFTGATE: "closureLiftgateLocked",
+    body_pb2.LOCK_SIDE_BIN_LEFT: "closureSideBinLeftLocked",
+    body_pb2.LOCK_SIDE_BIN_RIGHT: "closureSideBinRightLocked",
+    body_pb2.LOCK_CHARGE_PORT: "closureChargePortLocked",
+    body_pb2.LOCK_TRUNK_SECURITY: "closureTrunkSecurityLocked",
+    body_pb2.LOCK_CENTER_CONSOLE: "closureCenterConsoleLocked",
+    body_pb2.LOCK_GLOVE_BOX: "closureGloveBoxLocked",
+    body_pb2.LOCK_GEAR_GUARD: "gearGuardLocked",
+    body_pb2.LOCK_TONNEAU: "closureTonneauLocked",
+}
+
+_LOCK_STATE_MAP: Final[dict[int, str]] = {
+    body_pb2.LOCK_STATE_LOCKED: "locked",
+    body_pb2.LOCK_STATE_UNLOCKED: "unlocked",
+    body_pb2.LOCK_STATE_PARTIALLY_UNLOCKED: "partially_unlocked",
 }
 
 _TRAILER_PRESENCE_MAP: Final[dict[int, str]] = {
-    1: "trailer_not_present",
-    2: "trailer_present",
-    3: "trailer_present_with_brakes",
-    4: "trailer_invalid",
+    body_pb2.TRAILER_NOT_PRESENT: "trailer_not_present",
+    body_pb2.TRAILER_PRESENT: "trailer_present",
+    body_pb2.TRAILER_PRESENT_WITH_BRAKES: "trailer_present_with_brakes",
+    body_pb2.TRAILER_INVALID: "trailer_invalid",
 }
 
 
@@ -103,10 +122,11 @@ def decode_closures(m: body_pb2.ClosuresState) -> dict[str, Any]:
 
     Fields:
         doorFrontLeftClosed, closureFrunkClosed, etc.: str
-            ("open" | "closed" | "opening" | "closing")
-        closureFrunkNextAction, closureTailgateNextAction,
-        closureSideBinLeftNextAction, closureSideBinRightNextAction,
-        closureChargePortDoorNextAction: str — e.g. "open_allowed" (shut),
+            ("open" | "closed" | "ajar" | "opening" | "closing")
+        closureFrunkNextAction, closureLiftgateNextAction,
+        closureTailgateNextAction, closureSideBinLeftNextAction,
+        closureSideBinRightNextAction, closureChargePortDoorNextAction,
+        windowsNextAction: str — e.g. "open_allowed" (shut),
             "close_allowed" (open); for the charge port,
             "close_not_available" means plugged in
 
@@ -122,7 +142,7 @@ def decode_closures(m: body_pb2.ClosuresState) -> dict[str, Any]:
             result[_CLOSURE_MAP[cid]] = _enum(
                 _CLOSURE_STATE_MAP, state_val, what="closure state"
             )
-        else:
+        elif cid != body_pb2.GROUP_WINDOWS:
             _LOGGER.debug("Unknown closure id %s (state %s)", cid, state_val)
         if cid in _NEXT_ACTIONS:
             field, key, names = _NEXT_ACTIONS[cid]
@@ -133,10 +153,12 @@ def decode_closures(m: body_pb2.ClosuresState) -> dict[str, Any]:
 
 @RVMDecoder.register("body.locks.states", body_pb2.LocksState)
 def decode_locks(m: body_pb2.LocksState) -> dict[str, Any]:
-    """body.locks.states — lock state of every lockable closure.
+    """body.locks.states — lock state of every lock.
 
     Fields:
-        doorFrontLeftLocked, closureFrunkLocked, etc.: str ("locked" | "unlocked")
+        doorFrontLeftLocked, closureFrunkLocked, gearGuardLocked (the Gear
+            Guard cable), etc.: str ("locked" | "unlocked" |
+            "partially_unlocked")
     """
     result: dict[str, Any] = {}
     for s in m.lock:
@@ -145,7 +167,9 @@ def decode_locks(m: body_pb2.LocksState) -> dict[str, Any]:
         if state_val is None:
             continue
         if lid in _LOCK_MAP:
-            result[_LOCK_MAP[lid]] = "locked" if state_val == 1 else "unlocked"
+            result[_LOCK_MAP[lid]] = _enum(
+                _LOCK_STATE_MAP, state_val, what="lock state"
+            )
         else:
             _LOGGER.debug("Unknown lock id %s (state %s)", lid, state_val)
     return result

rivian/parallax/charging.py

@@ -8,13 +8,13 @@ from .core import RVMDecoder, _enum, _present
 from .proto import charging_pb2
 
 _DAY_OF_WEEK_MAP: Final[dict[int, str]] = {
-    1: "sunday",
-    2: "monday",
-    3: "tuesday",
-    4: "wednesday",
-    5: "thursday",
-    6: "friday",
-    7: "saturday",
+    charging_pb2.ScheduleTimeWindow.SUNDAY: "sunday",
+    charging_pb2.ScheduleTimeWindow.MONDAY: "monday",
+    charging_pb2.ScheduleTimeWindow.TUESDAY: "tuesday",
+    charging_pb2.ScheduleTimeWindow.WEDNESDAY: "wednesday",
+    charging_pb2.ScheduleTimeWindow.THURSDAY: "thursday",
+    charging_pb2.ScheduleTimeWindow.FRIDAY: "friday",
+    charging_pb2.ScheduleTimeWindow.SATURDAY: "saturday",
 }
 
 
@@ -65,8 +65,8 @@ def decode_session_notification(m: charging_pb2.SessionNotification) -> dict[str
 
 
 _REMOTE_COMMAND_MAP: Final[dict[int, str]] = {
-    1: "start",
-    2: "stop",
+    charging_pb2.REMOTE_COMMAND_START: "start",
+    charging_pb2.REMOTE_COMMAND_STOP: "stop",
 }
 
 
@@ -144,34 +144,34 @@ def decode_weighted_charging_forecast(
 
 
 _CONNECTION_STATE_MAP: Final[dict[int, str]] = {
-    1: "disconnected",
-    2: "connected",
+    charging_pb2.CONNECTION_STATE_DISCONNECTED: "disconnected",
+    charging_pb2.CONNECTION_STATE_CONNECTED: "connected",
 }
 
 _CHARGING_STATE_MAP: Final[dict[int, str]] = {
-    1: "charging_ready",
-    2: "charging_connecting",
-    3: "charging_active",
-    4: "charging_complete",
-    5: "charging_scheduled",
-    6: "charging_vehicle_error",
-    7: "charging_station_error",
-    8: "charging_stopped_by_user",
-    9: "charging_stopped_by_station",
-    10: "charging_payment_error",
-    11: "charging_cert_error",
-    12: "charging_tls_error",
-    13: "charging_error_ac_adapter_used_on_dc",
-    14: "charging_error_dc_adapter_used_on_ac",
-    15: "charging_error_incompatible_charger",
-    16: "charging_sd_compensation",
-    17: "waiting_on_charger",
-    18: "charging_error_not_ready_or_incompatible_charger",
-    19: "charging_vehicle_stopped",
-    20: "charging_payment_error_start_rivian_app",
-    21: "charging_tls_error_unknown_charger",
-    22: "charging_tls_error_unexpected_fail",
-    23: "charging_tls_error_start_rivian_app",
+    charging_pb2.CHARGING_READY: "charging_ready",
+    charging_pb2.CHARGING_CONNECTING: "charging_connecting",
+    charging_pb2.CHARGING_ACTIVE: "charging_active",
+    charging_pb2.CHARGING_COMPLETE: "charging_complete",
+    charging_pb2.CHARGING_SCHEDULED: "charging_scheduled",
+    charging_pb2.CHARGING_VEHICLE_ERROR: "charging_vehicle_error",
+    charging_pb2.CHARGING_STATION_ERROR: "charging_station_error",
+    charging_pb2.CHARGING_USER_STOPPED: "charging_stopped_by_user",
+    charging_pb2.CHARGING_STATION_STOPPED: "charging_stopped_by_station",
+    charging_pb2.CHARGING_PAYMENT_ERROR: "charging_payment_error",
+    charging_pb2.CHARGING_CERT_ERROR: "charging_cert_error",
+    charging_pb2.CHARGING_TLS_ERROR: "charging_tls_error",
+    charging_pb2.CHARGING_ERROR_AC_ADAPTER_USED_ON_DC: "charging_error_ac_adapter_used_on_dc",
+    charging_pb2.CHARGING_ERROR_DC_ADAPTER_USED_ON_AC: "charging_error_dc_adapter_used_on_ac",
+    charging_pb2.CHARGING_ERROR_INCOMPATIBLE_CHARGER: "charging_error_incompatible_charger",
+    charging_pb2.CHARGING_SD_COMPENSATION: "charging_sd_compensation",
+    charging_pb2.WAITING_ON_CHARGER: "waiting_on_charger",
+    charging_pb2.CHARGER_NOT_READY_OR_INCOMPATIBLE: "charging_error_not_ready_or_incompatible_charger",
+    charging_pb2.CHARGING_VEHICLE_STOPPED: "charging_vehicle_stopped",
+    charging_pb2.CHARGING_PAYMENT_ERROR_START_RIVIAN_APP: "charging_payment_error_start_rivian_app",
+    charging_pb2.CHARGING_TLS_ERROR_UNKNOWN_CHARGER: "charging_tls_error_unknown_charger",
+    charging_pb2.CHARGING_TLS_ERROR_UNEXPECTED_FAIL: "charging_tls_error_unexpected_fail",
+    charging_pb2.CHARGING_TLS_ERROR_START_RIVIAN_APP: "charging_tls_error_start_rivian_app",
 }
 
 
@@ -211,9 +211,9 @@ def decode_time_estimation(m: charging_pb2.TimeEstimation) -> dict[str, Any]:
 
 
 _CHARGER_STATUS_MAP: Final[dict[int, str]] = {
-    1: "chrgr_sts_not_connected",
-    2: "chrgr_sts_connected_no_chrg",
-    3: "chrgr_sts_connected_charging",
+    charging_pb2.CHARGER_STATUS_NOT_CONNECTED: "chrgr_sts_not_connected",
+    charging_pb2.CHARGER_STATUS_CONNECTED_NO_CHARGE: "chrgr_sts_connected_no_chrg",
+    charging_pb2.CHARGER_STATUS_CONNECTED_CHARGING: "chrgr_sts_connected_charging",
 }
 
 

rivian/parallax/comfort.py

@@ -17,9 +17,7 @@ def decode_hvac_settings_status(m: comfort_pb2.HvacSettingsStatus) -> dict[str,
     Fields:
         hvacTargetTemperature: float (°C; 63.5 = "HI", set while defrosting)
     """
-    if (v := _present(m, "target_temperature")) is None:
-        return {}
-    return {"hvacTargetTemperature": round(v, 1)}
+    return {"hvacTargetTemperature": round(m.target_temperature, 1)}
 
 
 @RVMDecoder.register("comfort.user_modes.state", comfort_pb2.UserModesState)
@@ -34,60 +32,69 @@ def decode_user_modes_state(m: comfort_pb2.UserModesState) -> dict[str, Any]:
 
 
 _CLIMATE_HOLD_AVAILABILITY_MAP: Final[dict[int, str]] = {
-    0: "unspecified",
-    1: "available",
-    2: "controllable",
-    3: "unavailable",
+    comfort_pb2.CLIMATE_HOLD_AVAILABILITY_UNSPECIFIED: "unspecified",
+    comfort_pb2.CLIMATE_HOLD_AVAILABLE: "available",
+    comfort_pb2.CLIMATE_HOLD_CONTROLLABLE: "controllable",
+    comfort_pb2.CLIMATE_HOLD_UNAVAILABLE: "unavailable",
 }
 
 _CLIMATE_HOLD_STATUS_MAP: Final[dict[int, str]] = {
-    0: "unspecified",
-    1: "unavailable",
-    2: "off",
-    3: "on",
-    4: "fault",
+    comfort_pb2.CLIMATE_HOLD_STATUS_UNSPECIFIED: "unspecified",
+    comfort_pb2.CLIMATE_HOLD_STATUS_UNAVAILABLE: "unavailable",
+    comfort_pb2.CLIMATE_HOLD_STATUS_OFF: "off",
+    comfort_pb2.CLIMATE_HOLD_STATUS_ON: "on",
+    comfort_pb2.CLIMATE_HOLD_STATUS_FAULT: "fault",
 }
 
 _CLIMATE_HOLD_UNAVAILABILITY_REASON_MAP: Final[dict[int, str]] = {
-    0: "unspecified",
-    1: "unknown",
-    2: "low_soc",
+    comfort_pb2.CLIMATE_HOLD_UNAVAILABILITY_UNSPECIFIED: "unspecified",
+    comfort_pb2.CLIMATE_HOLD_UNAVAILABILITY_UNKNOWN: "unknown",
+    comfort_pb2.CLIMATE_HOLD_UNAVAILABILITY_LOW_SOC: "low_soc",
 }
 
 _PET_MODE_STATE_MAP: Final[dict[int, str]] = {
-    0: "off",
-    1: "on",
-    2: "disabled",
-    3: "faulty",
+    comfort_pb2.PET_MODE_OFF: "off",
+    comfort_pb2.PET_MODE_ON: "on",
+    comfort_pb2.PET_MODE_DISABLED: "disabled",
+    comfort_pb2.PET_MODE_FAULTY: "faulty",
 }
 
 _PET_MODE_TEMPERATURE_MAP: Final[dict[int, str]] = {
-    0: "default",
-    1: "cold",
-    2: "hot",
-    3: "faulty",
+    comfort_pb2.PET_MODE_TEMPERATURE_DEFAULT: "default",
+    comfort_pb2.PET_MODE_TEMPERATURE_COLD: "cold",
+    comfort_pb2.PET_MODE_TEMPERATURE_HOT: "hot",
+    comfort_pb2.PET_MODE_TEMPERATURE_FAULTY: "faulty",
 }
 
-_SEAT_CONDITIONING_MAP: Final[dict[int, str]] = {
-    1: "steeringWheel",
-    5: "seatFrontLeft",
-    7: "seatFrontRight",  # inferred
-    8: "seatRearLeft",
-    10: "seatRearRight",
-    11: "seatThirdRowLeft",  # R1S
-    13: "seatThirdRowRight",  # R1S
+# Seat keys use the GraphQL names: row 1 is "Front", row 2 "Rear", row 3
+# "ThirdRow".
+_CABIN_SURFACE_MAP: Final[dict[int, str]] = {
+    comfort_pb2.STEERING_WHEEL: "steeringWheel",
+    comfort_pb2.REAR_GLASS: "rearGlass",
+    comfort_pb2.FRONT_GLASS: "frontGlass",
+    comfort_pb2.SIDEVIEW_MIRRORS: "sideviewMirrors",
+    comfort_pb2.SEAT_ROW_1_LEFT: "seatFrontLeft",
+    comfort_pb2.SEAT_ROW_1_MIDDLE: "seatFrontMiddle",
+    comfort_pb2.SEAT_ROW_1_RIGHT: "seatFrontRight",
+    comfort_pb2.SEAT_ROW_2_LEFT: "seatRearLeft",
+    comfort_pb2.SEAT_ROW_2_MIDDLE: "seatRearMiddle",
+    comfort_pb2.SEAT_ROW_2_RIGHT: "seatRearRight",
+    comfort_pb2.SEAT_ROW_3_LEFT: "seatThirdRowLeft",
+    comfort_pb2.SEAT_ROW_3_MIDDLE: "seatThirdRowMiddle",
+    comfort_pb2.SEAT_ROW_3_RIGHT: "seatThirdRowRight",
+    comfort_pb2.WIPER_AREA: "wiperArea",
 }
 
-_SEAT_CONDITIONING_STATUS_MAP: Final[dict[int | None, str]] = {
+_CONDITIONING_LEVEL_MAP: Final[dict[int | None, str]] = {
     None: "Off",
-    1: "Level_1",
-    2: "Level_2",
-    3: "Level_3",
+    comfort_pb2.CONDITIONING_LEVEL_1: "Level_1",
+    comfort_pb2.CONDITIONING_LEVEL_2: "Level_2",
+    comfort_pb2.CONDITIONING_LEVEL_3: "Level_3",
 }
 
-_SEAT_CONDITIONING_TYPE_MAP: Final[dict[int, str]] = {
-    1: "Heat",
-    2: "Vent",
+_CONDITIONING_TYPE_MAP: Final[dict[int, str]] = {
+    comfort_pb2.CONDITIONING_HEAT: "Heat",
+    comfort_pb2.CONDITIONING_VENT: "Vent",
 }
 
 
@@ -123,12 +130,10 @@ def decode_cabin_temperatures(m: comfort_pb2.CabinTemperatures) -> dict[str, Any
         cabinClimateDriverTemperature: float (°C) — set point, same as
             `hvacTargetTemperature`
     """
-    result: dict[str, Any] = {}
-    if (v := _present(m, "interior_temperature")) is not None:
-        result["cabinClimateInteriorTemperature"] = round(v, 1)
-    if (v := _present(m, "driver_set_point")) is not None:
-        result["cabinClimateDriverTemperature"] = round(v, 1)
-    return result
+    return {
+        "cabinClimateInteriorTemperature": round(m.interior_temperature, 1),
+        "cabinClimateDriverTemperature": round(m.driver_set_point, 1),
+    }
 
 
 @RVMDecoder.register(
@@ -137,24 +142,20 @@ def decode_cabin_temperatures(m: comfort_pb2.CabinTemperatures) -> dict[str, Any
 def decode_cabin_ventilation(m: comfort_pb2.CabinVentilationSetting) -> dict[str, Any]:
     """comfort.cabin.cabin_ventilation_setting — passive ventilation settings.
 
-    Fields (each only when sent):
+    Fields:
         cabinVentilationEnabled: bool
-        cabinVentilationMode: str ("AUTO" | "MANUAL" | "OFF")
+        cabinVentilationMode: str | None ("AUTO" | "MANUAL" | "OFF")
         cabinVentilationWindowsPosition: int (percent open)
         cabinVentilationSunroofPosition: int (percent open)
         cabinVentilationDuration: int (minutes)
     """
-    result: dict[str, Any] = {}
-    for field, key in (
-        ("enabled", "cabinVentilationEnabled"),
-        ("mode", "cabinVentilationMode"),
-        ("windows_position", "cabinVentilationWindowsPosition"),
-        ("sunroof_position", "cabinVentilationSunroofPosition"),
-        ("duration", "cabinVentilationDuration"),
-    ):
-        if (v := _present(m, field)) is not None:
-            result[key] = v
-    return result
+    return {
+        "cabinVentilationEnabled": m.enabled,
+        "cabinVentilationMode": m.mode or None,
+        "cabinVentilationWindowsPosition": m.windows_position,
+        "cabinVentilationSunroofPosition": m.sunroof_position,
+        "cabinVentilationDuration": m.duration,
+    }
 
 
 @RVMDecoder.register(
@@ -176,29 +177,26 @@ def decode_climate_hold_status(m: comfort_pb2.ClimateHoldStatus) -> dict[str, An
     Fields:
         climateHoldStatus: str ("off" | "on" | "unavailable" | "fault" | "unspecified")
         climateHoldAvailability: str
-        climateHoldUnavailabilityReason: str (only when not "unspecified")
-        climateHoldEndTime: int (epoch seconds, only while a hold runs)
+        climateHoldUnavailabilityReason: str | None — None when unspecified
+        climateHoldEndTime: int | None (epoch seconds; None unless a hold runs)
     """
-    result: dict[str, Any] = {}
-    if (val := _present(m, "status")) is not None:
-        result["climateHoldStatus"] = _enum(
-            _CLIMATE_HOLD_STATUS_MAP, val, what="climate hold status"
-        )
-    if (val := _present(m, "availability")) is not None:
-        result["climateHoldAvailability"] = _enum(
-            _CLIMATE_HOLD_AVAILABILITY_MAP, val, what="climate hold availability"
-        )
-    if (val := _present(m, "unavailability_reason")) is not None:
-        reason = _enum(
-            _CLIMATE_HOLD_UNAVAILABILITY_REASON_MAP,
-            val,
-            what="climate hold unavailability reason",
-        )
-        if reason != "unspecified":
-            result["climateHoldUnavailabilityReason"] = reason
-    if m.end_time.seconds:
-        result["climateHoldEndTime"] = m.end_time.seconds
-    return result
+    reason = _enum(
+        _CLIMATE_HOLD_UNAVAILABILITY_REASON_MAP,
+        m.unavailability_reason,
+        what="climate hold unavailability reason",
+    )
+    return {
+        "climateHoldStatus": _enum(
+            _CLIMATE_HOLD_STATUS_MAP, m.status, what="climate hold status"
+        ),
+        "climateHoldAvailability": _enum(
+            _CLIMATE_HOLD_AVAILABILITY_MAP,
+            m.availability,
+            what="climate hold availability",
+        ),
+        "climateHoldUnavailabilityReason": None if reason == "unspecified" else reason,
+        "climateHoldEndTime": m.end_time.seconds or None,
+    }
 
 
 @RVMDecoder.register(
@@ -247,23 +245,22 @@ def decode_seat_conditioning(m: comfort_pb2.SeatConditioningStatus) -> dict[str,
         seatThirdRowLeftHeat, seatThirdRowRightHeat: str
             ("Off" | "Level_1" | "Level_2" | "Level_3")
         steeringWheelHeat: str ("Off" | "Level_1")
+        plus <surface>Heat/Vent for any other surface sent (middle seats,
+        rearGlass, frontGlass, sideviewMirrors, wiperArea)
 
-    Entries without a state are skipped.
+    A surface sent without a state is off.
     """
     result: dict[str, Any] = {}
-    for s in m.seat:
-        cid, hvac_type = s.id, s.type
-        if (state_val := _present(s, "state")) is None:
-            continue
-        if cid in _SEAT_CONDITIONING_MAP and hvac_type in _SEAT_CONDITIONING_TYPE_MAP:
-            key = (
-                f"{_SEAT_CONDITIONING_MAP[cid]}{_SEAT_CONDITIONING_TYPE_MAP[hvac_type]}"
-            )
-            result[key] = _SEAT_CONDITIONING_STATUS_MAP.get(state_val, state_val)
+    for surface in m.surface:
+        surface_id, hvac_type = surface.id, surface.type
+        state_val = _present(surface, "state")
+        if surface_id in _CABIN_SURFACE_MAP and hvac_type in _CONDITIONING_TYPE_MAP:
+            key = f"{_CABIN_SURFACE_MAP[surface_id]}{_CONDITIONING_TYPE_MAP[hvac_type]}"
+            result[key] = _CONDITIONING_LEVEL_MAP.get(state_val, state_val)
         else:
             _LOGGER.debug(
-                "Unknown seat conditioning status id %s (hvac_type %s; state %s)",
-                cid,
+                "Unknown cabin surface %s (hvac_type %s; state %s)",
+                surface_id,
                 hvac_type,
                 state_val,
             )

rivian/parallax/device_table.py

@@ -2,35 +2,68 @@
 
 from __future__ import annotations
 
-from typing import Any
+import uuid
+from typing import Any, Final
 
-from .core import RVMDecoder, _present
+from .core import RVMDecoder, _enum, _present
 from .proto import device_table_pb2
 
+_Devices = device_table_pb2.VasKeyperDevices
+_KEY_STATUS_MAP: Final[dict[int, str]] = {
+    _Devices.KEY_STATUS_ACTIVE: "active",
+    _Devices.KEY_STATUS_INACTIVE: "inactive",
+    _Devices.KEY_STATUS_WAITING_TO_PAIR: "waiting_to_pair",
+    _Devices.KEY_STATUS_PAIRING: "pairing",
+}
+
+_KEY_TYPE_MAP: Final[dict[int, str]] = {
+    _Devices.KEY_TYPE_PHONE: "phone",
+    _Devices.KEY_TYPE_KEY_CARD: "key_card",
+    _Devices.KEY_TYPE_KEY_FOB: "key_fob",
+}
+
 
 @RVMDecoder.register(
     "device_table.vas_keyper.devices", device_table_pb2.VasKeyperDevices
 )
 def decode_vas_keyper_devices(m: device_table_pb2.VasKeyperDevices) -> dict[str, Any]:
-    """device_table.vas_keyper.devices — a paired key (phone, fob or card).
+    """device_table.vas_keyper.devices — a key (phone, key card or fob).
+
+    Covers every driver's keys. A deleted key isn't removed; it's resent
+    as inactive.
 
     Fields (partial updates, so each only when sent):
+        deviceName: str — phone keys, e.g. the phone's name
+        keyType: str ("phone" | "key_card" | "key_fob"; key_fob inferred)
         mappedIdentityId: str — the GraphQL device's `mappedIdentityId`
-        hrid: str — short human-readable id
-        pairingId: str
-        infoStatus: int — small enum-like value
-        infoA, infoB, infoC: int — unknown
-        deviceId: str — hex; the GraphQL `devices[].id`
+        hrid: str — short human-readable id (key card)
+        profileId: str — the driver profile the key belongs to
+        publicKey: str — hex; phone keys
+        keyRevision: int — key table revision when the entry was last written
+        keyStatus: str ("active" | "inactive" | "waiting_to_pair" |
+            "pairing"); inactive covers unpaired, no longer paired and
+            deleted keys
+        infoC: int — 1 while active, 2147483647 while inactive, else the
+            pairing attempt number
+        infoA, infoB: int — unknown; always equal
+        deviceId: str — hex; for a key card, the GraphQL `devices[].id`
+        phoneId: str — the phone's UUID; phone keys
         credentialHex: str — hex; likely key material
-        keyType: int — raw enum
         active: bool
     """
     result: dict[str, Any] = {}
+    if m.HasField("label"):
+        if (v := _present(m.label, "name")) is not None:
+            result["deviceName"] = v
+        if (v := _present(m.label, "key_type")) is not None:
+            result["keyType"] = _enum(_KEY_TYPE_MAP, v, what="key type")
     if m.HasField("device"):
         for field, key in (
             ("mapped_identity_id", "mappedIdentityId"),
             ("hrid", "hrid"),
-            ("pairing_id", "pairingId"),
+            ("profile_id", "profileId"),
+            ("public_key", "publicKey"),
+            ("revision", "keyRevision"),
         ):
             if (v := _present(m.device, field)) is not None:
                 result[key] = v
@@ -42,18 +75,25 @@ def decode_vas_keyper_devices(m: device_table_pb2.VasKeyperDevices) -> dict[str,
         for field, key in (
             ("a", "infoA"),
             ("c", "infoC"),
-            ("status", "infoStatus"),
             ("b", "infoB"),
         ):
             if (v := _present(credentials.info, field)) is not None:
                 result[key] = v
-    if credentials.HasField("ble"):
-        if (device_id := _present(credentials.ble, "device_id")) is not None:
-            result["deviceId"] = device_id.hex()
-        if (cred := _present(credentials.ble, "credential")) is not None:
+        if (v := _present(credentials.info, "status")) is not None:
+            result["keyStatus"] = _enum(_KEY_STATUS_MAP, v, what="key status")
+    for field in ("card", "fob", "phone"):
+        if not credentials.HasField(field):
+            continue
+        material = getattr(credentials, field)
+        if (ident := _present(material, "id")) is not None:
+            if field == "phone" and len(ident) == 16:
+                result["phoneId"] = str(uuid.UUID(bytes=ident))
+            else:
+                result["deviceId"] = ident.hex()
+        if (cred := _present(material, "credential")) is not None:
             result["credentialHex"] = cred.hex()
     if (v := _present(credentials, "key_type")) is not None:
-        result["keyType"] = v
+        result["keyType"] = _enum(_KEY_TYPE_MAP, v, what="key type")
     if (v := _present(credentials, "active")) is not None:
         result["active"] = v
     return result