rivian-python-client 2.2.0b6__tar.gz → 2.2.0b8__tar.gz

{rivian_python_client-2.2.0b6 → rivian_python_client-2.2.0b8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: rivian-python-client
-Version: 2.2.0b6
+Version: 2.2.0b8
 Summary: Rivian API Client (Unofficial)
 Author-email: Brian Retterer <bretterer@gmail.com>, "J.R. Gutierrez" <jrgutier@gmail.com>, Nathan Spencer <natekspencer@gmail.com>, Trevor Mack <drummer8001@gmail.com>
 License-Expression: MIT

{rivian_python_client-2.2.0b6 → rivian_python_client-2.2.0b8}/src/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.0b6'
+__version__ = VERSION = '2.2.0b8'

{rivian_python_client-2.2.0b6 → rivian_python_client-2.2.0b8}/src/rivian/parallax/body.py

@@ -108,6 +108,28 @@ _LOCK_STATE_MAP: Final[dict[int, str]] = {
     body_pb2.LOCK_STATE_PARTIALLY_UNLOCKED: "partially_unlocked",
 }
 
+_REAR_HITCH_STATUS_MAP: Final[dict[int, str]] = {
+    body_pb2.REAR_HITCH_STATUS_NOT_PRESENT: "not_present",
+    body_pb2.REAR_HITCH_STATUS_ACCESSORY: "accessory",
+    body_pb2.REAR_HITCH_STATUS_TRAILER1: "trailer1",
+    body_pb2.REAR_HITCH_STATUS_TRAILER2: "trailer2",
+    body_pb2.REAR_HITCH_STATUS_TRAILER3: "trailer3",
+}
+
+_WINDOW_MAP: Final[dict[int, str]] = {
+    body_pb2.WINDOW_INSTANCE_FRONT_LEFT: "windowFrontLeftCalibrated",
+    body_pb2.WINDOW_INSTANCE_FRONT_RIGHT: "windowFrontRightCalibrated",
+    body_pb2.WINDOW_INSTANCE_REAR_LEFT: "windowRearLeftCalibrated",
+    body_pb2.WINDOW_INSTANCE_REAR_RIGHT: "windowRearRightCalibrated",
+    body_pb2.WINDOW_INSTANCE_REAR: "windowRearCalibrated",
+}
+
+# GraphQL's windowXCalibrated values.
+_CALIBRATION_MAP: Final[dict[int, str]] = {
+    body_pb2.CALIBRATION_STATUS_CALIBRATED: "Calibrated",
+    body_pb2.CALIBRATION_STATUS_NOT_CALIBRATED: "Not_Calibrated",
+}
+
 _TRAILER_PRESENCE_MAP: Final[dict[int, str]] = {
     body_pb2.TRAILER_NOT_PRESENT: "trailer_not_present",
     body_pb2.TRAILER_PRESENT: "trailer_present",
@@ -176,19 +198,37 @@ def decode_locks(m: body_pb2.LocksState) -> dict[str, Any]:
 
 
 @RVMDecoder.register("body.windows.states", body_pb2.WindowsState)
-def decode_windows(_m: body_pb2.WindowsState) -> dict[str, Any]:
-    """body.windows.states — unmapped."""
-    return {}
+def decode_windows(m: body_pb2.WindowsState) -> dict[str, Any]:
+    """body.windows.states — window calibration.
+
+    Fields:
+        windowFrontLeftCalibrated, windowFrontRightCalibrated,
+        windowRearLeftCalibrated, windowRearRightCalibrated,
+        windowRearCalibrated: str ("Calibrated" | "Not_Calibrated")
+    """
+    return {
+        _WINDOW_MAP[w.instance]: _enum(
+            _CALIBRATION_MAP, w.calibration_status or None, what="window calibration"
+        )
+        for w in m.window
+        if w.instance in _WINDOW_MAP
+    }
 
 
 @RVMDecoder.register("body.trailer.state", body_pb2.TrailerState)
 def decode_trailer_state(m: body_pb2.TrailerState) -> dict[str, Any]:
-    """body.trailer.state — trailer presence, with or without brakes.
+    """body.trailer.state — trailer presence and rear hitch status.
 
     Fields:
         trailerStatus: str
+        rearHitchStatus: str | None ("not_present" | "accessory" |
+            "trailer1" | "trailer2" | "trailer3")
     """
-    result: dict[str, Any] = {}
+    result: dict[str, Any] = {
+        "rearHitchStatus": _enum(
+            _REAR_HITCH_STATUS_MAP, m.rear_hitch_status or None, what="rear hitch"
+        )
+    }
     presence = _enum(
         _TRAILER_PRESENCE_MAP, _present(m, "presence"), what="trailer presence"
     )

{rivian_python_client-2.2.0b6 → rivian_python_client-2.2.0b8}/src/rivian/parallax/charging.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 from typing import Any, Final
 
+from ..utils import from_epoch
 from .core import RVMDecoder, _enum, _present
 from .proto import charging_pb2
 
@@ -58,15 +59,75 @@ def decode_schedule_time_window(m: charging_pb2.ScheduleTimeWindow) -> dict[str,
     return result
 
 
+_DERATE_STATUS_MAP: Final[dict[int, str]] = {
+    charging_pb2.DERATE_STATUS_NONE: "none",
+    charging_pb2.DERATE_STATUS_WARM_ADAPTER: "warm_adapter",
+    charging_pb2.DERATE_STATUS_DC_WARM_PLUG: "dc_warm_plug",
+    charging_pb2.DERATE_STATUS_AC_WARM_PLUG: "ac_warm_plug",
+    charging_pb2.DERATE_STATUS_EVSE_DERATING: "evse_derating",
+    charging_pb2.DERATE_STATUS_NEARING_TOC: "nearing_toc",
+    charging_pb2.DERATE_STATUS_NEAR_TOC_LFP_BATT_CALIBRATING: "near_toc_lfp_batt_calibrating",
+    charging_pb2.DERATE_STATUS_HVAC_PRIORITIZED: "hvac_prioritized",
+    charging_pb2.DERATE_STATUS_BATTERY_HEATING: "battery_heating",
+    charging_pb2.DERATE_STATUS_BATTERY_COOLING: "battery_cooling",
+    charging_pb2.DERATE_STATUS_CELL_THERMAL_LIM_COLD_NO_CURRENT: "cell_thermal_lim_cold_no_current",
+    charging_pb2.DERATE_STATUS_CELL_THERMAL_LIM_HOT_NO_CURRENT: "cell_thermal_lim_hot_no_current",
+    charging_pb2.DERATE_STATUS_CELL_THERMAL_LIM_COLD: "cell_thermal_lim_cold",
+    charging_pb2.DERATE_STATUS_CELL_THERMAL_LIM_HOT: "cell_thermal_lim_hot",
+    charging_pb2.DERATE_STATUS_PACK_HARDWARE_THERMAL_LIM: "pack_hardware_thermal_lim",
+    charging_pb2.DERATE_STATUS_HIGH_SOC_SIGMA: "high_soc_sigma",
+    charging_pb2.DERATE_STATUS_HV_BATTERY_FAULT: "hv_battery_fault",
+    charging_pb2.DERATE_STATUS_DCAC_EXPORT: "dcac_export",
+}
+
+_FAULT_CHIME_MAP: Final[dict[int, str]] = {
+    charging_pb2.FAULT_CHIME_NONE: "none",
+    charging_pb2.FAULT_CHIME_CHARGING_DISABLED_ALL: "charging_disabled_all",
+    charging_pb2.FAULT_CHIME_CHARGING_DISABLED_DC: "charging_disabled_dc",
+    charging_pb2.FAULT_CHIME_CHARGING_DISABLED_PIN_TEMP_DC: "charging_disabled_pin_temp_dc",
+    charging_pb2.FAULT_CHIME_CHARGING_DISABLED_PIN_TEMP_GRADIENT_DC: "charging_disabled_pin_temp_gradient_dc",
+    charging_pb2.FAULT_CHIME_CHARGING_DEGRADED_DC: "charging_degraded_dc",
+    charging_pb2.FAULT_CHIME_CHARGING_DISABLED_AC: "charging_disabled_ac",
+    charging_pb2.FAULT_CHIME_CHARGING_DISABLED_PIN_TEMP_AC: "charging_disabled_pin_temp_ac",
+    charging_pb2.FAULT_CHIME_CHARGING_DEGRADED_AC: "charging_degraded_ac",
+    charging_pb2.FAULT_CHIME_CHARGING_DISABLED_PARTIAL_CONNECTION: "charging_disabled_partial_connection",
+    charging_pb2.FAULT_CHIME_CHARGING_DISABLED_NOT_PARKED: "charging_disabled_not_parked",
+}
+
+
 @RVMDecoder.register("charging.session.notification", charging_pb2.SessionNotification)
 def decode_session_notification(m: charging_pb2.SessionNotification) -> dict[str, Any]:
-    """charging.session.notification — unmapped; field 1 as `_field1`."""
-    return {"_field1": m.field1} if m.HasField("field1") else {}
+    """charging.session.notification — charging derate and fault notices.
+
+    Fields:
+        chargerDerateStatus: str ("none" | "warm_adapter" | "nearing_toc" |
+            "battery_heating" | ...)
+        chargingFaultChime: str ("none" | "charging_disabled_all" |
+            "charging_disabled_dc" | ...)
+        _unexpectedStopReason: int — raw
+    """
+    return {
+        "chargerDerateStatus": _enum(
+            _DERATE_STATUS_MAP, m.derate_status, what="charger derate status"
+        ),
+        "chargingFaultChime": _enum(
+            _FAULT_CHIME_MAP, m.fault_chime, what="charging fault chime"
+        ),
+        "_unexpectedStopReason": m.unexpected_stop_reason,
+    }
 
 
-_REMOTE_COMMAND_MAP: Final[dict[int, str]] = {
-    charging_pb2.REMOTE_COMMAND_START: "start",
-    charging_pb2.REMOTE_COMMAND_STOP: "stop",
+# The same "true"/"false"/"signal_not_available" vocabulary as the alarm.
+_START_AVAILABILITY_MAP: Final[dict[int, str]] = {
+    charging_pb2.START_AVAILABILITY_SNA: "signal_not_available",
+    charging_pb2.START_AVAILABILITY_FALSE: "false",
+    charging_pb2.START_AVAILABILITY_TRUE: "true",
+}
+
+_TIME_ESTIMATION_VALIDITY_MAP: Final[dict[int, str]] = {
+    charging_pb2.TIME_ESTIMATION_VALIDITY_VALID: "valid",
+    charging_pb2.TIME_ESTIMATION_VALIDITY_INVALID: "invalid",
+    charging_pb2.TIME_ESTIMATION_VALIDITY_PACK_DISCHARGING: "pack_discharging",
 }
 
 
@@ -76,19 +137,16 @@ _REMOTE_COMMAND_MAP: Final[dict[int, str]] = {
 def decode_session_remote_command(
     m: charging_pb2.SessionRemoteCommand,
 ) -> dict[str, Any]:
-    """charging.session.remote_command — the last start/stop command.
+    """charging.session.remote_command — whether a remote start is available.
 
     Fields:
-        chargingRemoteCommand: str ("start" | "stop")
-
-    Also sent when the vehicle holds ("stop") or resumes ("start")
-    charging around a schedule or limit change.
+        remoteChargingAvailable: str ("true" | "false" |
+            "signal_not_available"); true while charging is held (e.g. by a
+            schedule), so "charge now" can start it
     """
-    if not m.HasField("command"):
-        return {}
     return {
-        "chargingRemoteCommand": _enum(
-            _REMOTE_COMMAND_MAP, m.command, what="charging remote command"
+        "remoteChargingAvailable": _enum(
+            _START_AVAILABILITY_MAP, m.start_available, what="remote charging"
         )
     }
 
@@ -107,29 +165,74 @@ def decode_soc_slider(m: charging_pb2.SocSlider) -> dict[str, Any]:
 
 @RVMDecoder.register("charging.session.trip_target", charging_pb2.TripTarget)
 def decode_trip_target(m: charging_pb2.TripTarget) -> dict[str, Any]:
-    """charging.session.trip_target — unmapped; field 2 as `_field2`.
+    """charging.session.trip_target — the trip's target state of charge.
 
-    0xFFFF seems to mean "not set".
+    Fields:
+        chargingTripTargetSoc: int | None (percent; None when not set)
     """
-    return {"_field2": m.field2} if m.HasField("field2") else {}
+    soc = m.soc_limit
+    return {"chargingTripTargetSoc": None if soc in (0, 0xFFFF) else soc}
 
 
 @RVMDecoder.register(
     "charging.smart_charging.settings", charging_pb2.SmartChargingSettings
 )
 def decode_smart_charging_settings(
-    _m: charging_pb2.SmartChargingSettings,
+    m: charging_pb2.SmartChargingSettings,
 ) -> dict[str, Any]:
-    """charging.smart_charging.settings — unmapped."""
-    return {}
+    """charging.smart_charging.settings — smart charging schedule.
+
+    Not seen yet; the schema comes from the app.
+
+    Fields:
+        smartChargingCleanEnergyEnabled: bool
+        smartChargingReadyByTimes: list of {"hours": int, "minutes": int,
+            "days": list[str]} ("monday" … "sunday")
+    """
+    return {
+        "smartChargingCleanEnergyEnabled": m.clean_energy_enabled,
+        "smartChargingReadyByTimes": [
+            {
+                "hours": t.hours,
+                "minutes": t.minutes,
+                "days": [
+                    _enum(_SMART_CHARGING_DAY_MAP, d, what="smart charging day")
+                    for d in t.days
+                ],
+            }
+            for t in m.ready_by_times
+        ],
+    }
 
 
 @RVMDecoder.register(
     "charging.smart_charging.smart_charging_info", charging_pb2.SmartChargingInfo
 )
-def decode_smart_charging_info(_m: charging_pb2.SmartChargingInfo) -> dict[str, Any]:
-    """charging.smart_charging.smart_charging_info — unmapped."""
-    return {}
+def decode_smart_charging_info(m: charging_pb2.SmartChargingInfo) -> dict[str, Any]:
+    """charging.smart_charging.smart_charging_info — smart charging status.
+
+    Not seen yet; the schema comes from the app.
+
+    Fields:
+        smartChargingNotification: str ("signal_not_available" |
+            "charging_with_clean_energy" | "charging_paused" |
+            "clean_energy_not_enough_time" |
+            "clean_energy_forecast_unavailable_or_incomplete")
+        smartChargingResumeTime: datetime, only when sent
+        _smartChargingScheduleType: int (raw; unmapped)
+    """
+    result: dict[str, Any] = {
+        "smartChargingNotification": _enum(
+            _SMART_CHARGING_NOTIFICATION_MAP,
+            m.notification,
+            what="smart charging notification",
+        ),
+        "_smartChargingScheduleType": m.schedule_type,
+    }
+    if m.HasField("resume_time"):
+        t = m.resume_time
+        result["smartChargingResumeTime"] = from_epoch(t.seconds + t.nanos / 1e9)
+    return result
 
 
 @RVMDecoder.register(
@@ -143,9 +246,35 @@ def decode_weighted_charging_forecast(
     return {}
 
 
+_SMART_CHARGING_DAY_MAP: Final[dict[int, str]] = {
+    charging_pb2.SMART_CHARGING_DAY_MONDAY: "monday",
+    charging_pb2.SMART_CHARGING_DAY_TUESDAY: "tuesday",
+    charging_pb2.SMART_CHARGING_DAY_WEDNESDAY: "wednesday",
+    charging_pb2.SMART_CHARGING_DAY_THURSDAY: "thursday",
+    charging_pb2.SMART_CHARGING_DAY_FRIDAY: "friday",
+    charging_pb2.SMART_CHARGING_DAY_SATURDAY: "saturday",
+    charging_pb2.SMART_CHARGING_DAY_SUNDAY: "sunday",
+}
+
+_SMART_CHARGING_NOTIFICATION_MAP: Final[dict[int, str]] = {
+    charging_pb2.SMART_CHARGING_NOTIFICATION_SNA: "signal_not_available",
+    charging_pb2.SMART_CHARGING_NOTIFICATION_CHARGING_WITH_CLEAN_ENERGY: (
+        "charging_with_clean_energy"
+    ),
+    charging_pb2.SMART_CHARGING_NOTIFICATION_CHARGING_PAUSED: "charging_paused",
+    charging_pb2.SMART_CHARGING_NOTIFICATION_CLEAN_ENERGY_NOT_ENOUGH_TIME: (
+        "clean_energy_not_enough_time"
+    ),
+    charging_pb2.SMART_CHARGING_NOTIFICATION_CLEAN_ENERGY_FORECAST_UNAVAILABLE_OR_INCOMPLETE: (
+        "clean_energy_forecast_unavailable_or_incomplete"
+    ),
+}
+
 _CONNECTION_STATE_MAP: Final[dict[int, str]] = {
     charging_pb2.CONNECTION_STATE_DISCONNECTED: "disconnected",
     charging_pb2.CONNECTION_STATE_CONNECTED: "connected",
+    charging_pb2.CONNECTION_STATE_ERROR: "error",
+    charging_pb2.CONNECTION_STATE_V2L_CONNECTED: "v2l_connected",
 }
 
 _CHARGING_STATE_MAP: Final[dict[int, str]] = {
@@ -182,12 +311,13 @@ def decode_charging_status(m: charging_pb2.SessionStatus) -> dict[str, Any]:
     """charging.session.status — plug and charging state.
 
     Fields:
-        connectionState: str ("connected" | "disconnected")
+        connectionState: str ("connected" | "disconnected" | "error" |
+            "v2l_connected")
         chargerState: str — GraphQL chargerState values, e.g.
             "charging_ready" (no session, or unplugged),
             "charging_connecting", "charging_active", "charging_complete",
             "charging_scheduled", "charging_stopped_by_user"
-        isActive: bool — true from a session's start until it ends
+        _evseType: int — raw; 1 while connected to a charger
     """
     result: dict[str, Any] = {}
     if m.HasField("connection_state"):
@@ -198,7 +328,7 @@ def decode_charging_status(m: charging_pb2.SessionStatus) -> dict[str, Any]:
         result["chargerState"] = _enum(
             _CHARGING_STATE_MAP, m.charging_state, what="charging state"
         )
-    result["isActive"] = m.is_active
+    result["_evseType"] = m.evse_type
     return result
 
 
@@ -208,8 +338,17 @@ def decode_time_estimation(m: charging_pb2.TimeEstimation) -> dict[str, Any]:
 
     Fields:
         timeToEndOfCharge: int (minutes; 0 when not charging)
+        chargingTimeEstimationValidity: str | None ("valid" | "invalid" |
+            "pack_discharging")
     """
-    return {"timeToEndOfCharge": m.estimated_time_remaining}
+    return {
+        "timeToEndOfCharge": m.estimated_time_remaining,
+        "chargingTimeEstimationValidity": _enum(
+            _TIME_ESTIMATION_VALIDITY_MAP,
+            m.validity or None,
+            what="time estimation validity",
+        ),
+    }
 
 
 _CHARGER_STATUS_MAP: Final[dict[int, str]] = {

{rivian_python_client-2.2.0b6 → rivian_python_client-2.2.0b8}/src/rivian/parallax/comfort.py

@@ -22,13 +22,22 @@ def decode_hvac_settings_status(m: comfort_pb2.HvacSettingsStatus) -> dict[str,
 
 @RVMDecoder.register("comfort.user_modes.state", comfort_pb2.UserModesState)
 def decode_user_modes_state(m: comfort_pb2.UserModesState) -> dict[str, Any]:
-    """comfort.user_modes.state — unmapped; fields 4 and 7 as `_field4`/`_field7`."""
-    result: dict[str, Any] = {}
-    if (v := _present(m, "field4")) is not None:
-        result["_field4"] = v
-    if (v := _present(m, "field7")) is not None:
-        result["_field7"] = v
-    return result
+    """comfort.user_modes.state — user modes.
+
+    Fields:
+        serviceMode, carWashMode: str ("on" | "off")
+        _petMode, _campMode, _transportMode, _climateKeep, _factoryMode:
+            int — raw; enum types unknown
+    """
+    return {
+        "serviceMode": "on" if m.in_service else "off",
+        "carWashMode": "on" if m.car_wash_mode else "off",
+        "_petMode": m.pet_mode,
+        "_campMode": m.camp_mode,
+        "_transportMode": m.transport_mode,
+        "_climateKeep": m.climate_keep,
+        "_factoryMode": m.factory_mode,
+    }
 
 
 _CLIMATE_HOLD_AVAILABILITY_MAP: Final[dict[int, str]] = {
@@ -50,6 +59,43 @@ _CLIMATE_HOLD_UNAVAILABILITY_REASON_MAP: Final[dict[int, str]] = {
     comfort_pb2.CLIMATE_HOLD_UNAVAILABILITY_UNSPECIFIED: "unspecified",
     comfort_pb2.CLIMATE_HOLD_UNAVAILABILITY_UNKNOWN: "unknown",
     comfort_pb2.CLIMATE_HOLD_UNAVAILABILITY_LOW_SOC: "low_soc",
+    comfort_pb2.CLIMATE_HOLD_UNAVAILABILITY_FAULT: "fault",
+}
+
+_DEFROST_MAP: Final[dict[int, str]] = {
+    comfort_pb2.DEFROST_DEFOG: "Defog",
+    comfort_pb2.DEFROST_ACTIVE: "Defrost",
+    comfort_pb2.DEFROST_DEFOG_DEFROST: "Defog_Defrost",
+    comfort_pb2.DEFROST_OFF: "Off",
+}
+
+# GraphQL's cabinPreconditioningStatus / cabinPreconditioningType values.
+_PRECONDITIONING_STATUS_MAP: Final[dict[int, str]] = {
+    comfort_pb2.PRECONDITIONING_STATUS_UNSPECIFIED: "undefined",
+    comfort_pb2.PRECONDITIONING_INITIATE: "initiate",
+    comfort_pb2.PRECONDITIONING_ACTIVE: "active",
+    comfort_pb2.PRECONDITIONING_ACTIVE_WARNING: "active_warning",
+    comfort_pb2.PRECONDITIONING_COMPLETE_MAINTAIN: "complete_maintain",
+    comfort_pb2.PRECONDITIONING_TIMEOUT_TEMP_NOT_ACHIEVED: (
+        "timeout_temperature_not_achieved"
+    ),
+    comfort_pb2.PRECONDITIONING_ERROR_SOC_LOW: "error_soc_low",
+    comfort_pb2.PRECONDITIONING_ERROR_SYSTEM_FAULT: "error_system_fault",
+    comfort_pb2.PRECONDITIONING_UNAVAILABLE: "unavailable",
+    comfort_pb2.PRECONDITIONING_TIMEOUT_COMPLETE: "timeout_complete",
+}
+
+_PRECONDITIONING_TYPE_MAP: Final[dict[int, str]] = {
+    comfort_pb2.PRECONDITIONING_TYPE_USER_SELECTED: "user_selected",
+    comfort_pb2.PRECONDITIONING_TYPE_SCREEN_PROTECTION: "screen_protection",
+    comfort_pb2.PRECONDITIONING_TYPE_SCHEDULED: "scheduled",
+    comfort_pb2.PRECONDITIONING_TYPE_AUTO_CABIN_VENTILATION: "auto_cabin_ventilation",
+}
+
+_PET_MODE_CABIN_CLIMATE_MAP: Final[dict[int, str]] = {
+    comfort_pb2.PET_MODE_CABIN_CLIMATE_COMFORTABLE: "comfortable",
+    comfort_pb2.PET_MODE_CABIN_CLIMATE_COLD: "cold",
+    comfort_pb2.PET_MODE_CABIN_CLIMATE_HOT: "hot",
 }
 
 _PET_MODE_STATE_MAP: Final[dict[int, str]] = {
@@ -105,20 +151,20 @@ def decode_preconditioning(m: comfort_pb2.CabinPreconditioningStatus) -> dict[st
     """comfort.cabin.cabin_preconditioning_status — cabin preconditioning state.
 
     Fields:
-        cabinPreconditioningStatus: str ("active" | "initiate" | "off");
-            pet comfort counts as "active"
+        cabinPreconditioningStatus: str ("undefined" | "initiate" | "active" |
+            "complete_maintain" | "unavailable" | ...); "unavailable" while
+            driving or in pet comfort
+        cabinPreconditioningType: str | None ("user_selected" |
+            "screen_protection" | "scheduled" | "auto_cabin_ventilation")
     """
-    if m.status in (
-        comfort_pb2.PRECONDITIONING_ACTIVE,
-        comfort_pb2.PRECONDITIONING_PET_COMFORT,
-    ):
-        return {"cabinPreconditioningStatus": "active"}
-    if m.status in (
-        comfort_pb2.PRECONDITIONING_INITIATE_1,
-        comfort_pb2.PRECONDITIONING_INITIATE_2,
-    ):
-        return {"cabinPreconditioningStatus": "initiate"}
-    return {"cabinPreconditioningStatus": "off"}
+    return {
+        "cabinPreconditioningStatus": _enum(
+            _PRECONDITIONING_STATUS_MAP, m.status, what="preconditioning status"
+        ),
+        "cabinPreconditioningType": _enum(
+            _PRECONDITIONING_TYPE_MAP, m.type or None, what="preconditioning type"
+        ),
+    }
 
 
 @RVMDecoder.register("comfort.cabin.cabin_temperatures", comfort_pb2.CabinTemperatures)
@@ -129,33 +175,27 @@ def decode_cabin_temperatures(m: comfort_pb2.CabinTemperatures) -> dict[str, Any
         cabinClimateInteriorTemperature: float (°C)
         cabinClimateDriverTemperature: float (°C) — set point, same as
             `hvacTargetTemperature`
+        cabinClimateExteriorTemperature: float (°C), when sent
     """
-    return {
+    result: dict[str, Any] = {
         "cabinClimateInteriorTemperature": round(m.interior_temperature, 1),
         "cabinClimateDriverTemperature": round(m.driver_set_point, 1),
     }
+    if (v := _present(m, "exterior_temperature")) is not None:
+        result["cabinClimateExteriorTemperature"] = round(v, 1)
+    return result
 
 
 @RVMDecoder.register(
     "comfort.cabin.cabin_ventilation_setting", comfort_pb2.CabinVentilationSetting
 )
 def decode_cabin_ventilation(m: comfort_pb2.CabinVentilationSetting) -> dict[str, Any]:
-    """comfort.cabin.cabin_ventilation_setting — passive ventilation settings.
+    """comfort.cabin.cabin_ventilation_setting — auto cabin ventilation.
 
     Fields:
         cabinVentilationEnabled: bool
-        cabinVentilationMode: str | None ("AUTO" | "MANUAL" | "OFF")
-        cabinVentilationWindowsPosition: int (percent open)
-        cabinVentilationSunroofPosition: int (percent open)
-        cabinVentilationDuration: int (minutes)
     """
-    return {
-        "cabinVentilationEnabled": m.enabled,
-        "cabinVentilationMode": m.mode or None,
-        "cabinVentilationWindowsPosition": m.windows_position,
-        "cabinVentilationSunroofPosition": m.sunroof_position,
-        "cabinVentilationDuration": m.duration,
-    }
+    return {"cabinVentilationEnabled": m.auto_cabin_ventilation_enabled}
 
 
 @RVMDecoder.register(
@@ -206,10 +246,14 @@ def decode_defrost_status(m: comfort_pb2.DefrostDefogStatus) -> dict[str, Any]:
     """comfort.cabin.defrost_defog_status — windshield defrost state.
 
     Fields:
-        defrostDefogStatus: str ("Defrost" | "Off")
+        defrostDefogStatus: str | None ("Defog" | "Defrost" | "Defog_Defrost"
+            | "Off")
     """
-    active = m.status == comfort_pb2.DEFROST_ACTIVE
-    return {"defrostDefogStatus": "Defrost" if active else "Off"}
+    return {
+        "defrostDefogStatus": _enum(
+            _DEFROST_MAP, m.status or None, what="defrost defog status"
+        )
+    }
 
 
 @RVMDecoder.register("comfort.cabin.pet_mode_status", comfort_pb2.PetModeStatus)
@@ -220,8 +264,9 @@ def decode_pet_mode_status(m: comfort_pb2.PetModeStatus) -> dict[str, Any]:
         petModeStatus: str — "disabled" while cabin climate is off, "off"
             while it runs without pet mode
         petModeTemperatureStatus: str
+        petModeCabinClimate: str ("comfortable" | "cold" | "hot")
 
-    Absent fields are their zero values ("off" / "default").
+    Absent fields are their zero values ("off" / "default" / "comfortable").
     """
     return {
         "petModeStatus": _enum(_PET_MODE_STATE_MAP, m.status, what="pet mode status"),
@@ -230,6 +275,9 @@ def decode_pet_mode_status(m: comfort_pb2.PetModeStatus) -> dict[str, Any]:
             m.temperature_status,
             what="pet mode temperature status",
         ),
+        "petModeCabinClimate": _enum(
+            _PET_MODE_CABIN_CLIMATE_MAP, m.cabin_climate, what="pet mode cabin climate"
+        ),
     }
 
 

{rivian_python_client-2.2.0b6 → rivian_python_client-2.2.0b8}/src/rivian/parallax/device_table.py

@@ -41,6 +41,7 @@ def decode_vas_keyper_devices(m: device_table_pb2.VasKeyperDevices) -> dict[str,
             vehicle.profiles.active_user)
         publicKey: str — hex; phone keys
         keyRevision: int — key table revision when the entry was last written
+        vehicleResponseRequired: bool
         keyStatus: str ("active" | "inactive" | "waiting_to_pair" |
             "pairing"); inactive covers unpaired, no longer paired and
             deleted keys
@@ -65,6 +66,7 @@ def decode_vas_keyper_devices(m: device_table_pb2.VasKeyperDevices) -> dict[str,
             ("profile_id", "profileId"),
             ("public_key", "publicKey"),
             ("revision", "keyRevision"),
+            ("vehicle_response_required", "vehicleResponseRequired"),
         ):
             if (v := _present(m.device, field)) is not None:
                 result[key] = v

{rivian_python_client-2.2.0b6 → rivian_python_client-2.2.0b8}/src/rivian/parallax/dynamics.py

@@ -75,7 +75,7 @@ def decode_drive_mode(m: dynamics_pb2.DriveMode) -> dict[str, Any]:
 
     Fields:
         driveMode: str
-        limitedAccelCold, limitedRegenCold: int — raw flags
+        limitedAccelCold, limitedRegenCold: bool
     """
     return {
         "driveMode": _enum(_DRIVE_MODE_MAP, _present(m, "mode"), what="drive mode"),