rivian-python-client 2.1.0__tar.gz → 2.2.0b0__tar.gz

{rivian_python_client-2.1.0 → rivian_python_client-2.2.0b0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: rivian-python-client
-Version: 2.1.0
+Version: 2.2.0b0
 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
@@ -8,6 +8,7 @@ Requires-Python: >=3.10
 Requires-Dist: aiohttp>=3.0.0
 Requires-Dist: backports-strenum>=1.2.4; python_version < '3.11'
 Requires-Dist: cryptography>=41.0.1
+Requires-Dist: protobuf<8,>=7.35.1
 Requires-Dist: typing-extensions>=4.14.1; python_version < '3.11'
 Provides-Extra: ble
 Requires-Dist: bleak>=0.21; extra == 'ble'

{rivian_python_client-2.1.0 → rivian_python_client-2.2.0b0}/pyproject.toml

@@ -15,6 +15,7 @@ dependencies = [
     "cryptography (>=41.0.1)",
     "backports-strenum (>=1.2.4) ; python_version < '3.11'",
     "typing_extensions (>=4.14.1) ; python_version < '3.11'",
+    "protobuf>=7.35.1,<8",
 ]
 dynamic = ["version"]
 
@@ -33,6 +34,8 @@ dev = [
     "mypy>=1.7,<3.0",
     "ruff>=0.16,<0.17",
     "pre-commit>=4.6.1,<5",
+    "types-protobuf>=7.35.1.20260906",
+    "grpcio-tools==1.84.0",
 ]
 
 [tool.hatch.build.hooks.version]
@@ -57,10 +60,13 @@ cache-keys = [{ file = "pyproject.toml" }, { git = { commit = true, tags = true
 [tool.uv-dynamic-versioning]
 pattern = "default-unprefixed"
 
+[tool.ruff]
+extend-exclude = ["*_pb2.py", "*_pb2.pyi"]
+
 [tool.ruff.lint.isort]
 combine-as-imports = true
 split-on-trailing-comma = false
 
 [build-system]
 requires = ["hatchling", "uv-dynamic-versioning"]
-build-backend = "hatchling.build"
+build-backend = "hatchling.build"

{rivian_python_client-2.1.0 → rivian_python_client-2.2.0b0}/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.1.0'
+__version__ = VERSION = '2.2.0b0'

rivian_python_client-2.2.0b0/src/rivian/parallax/__init__.py

@@ -0,0 +1,68 @@
+"""Decoders for Rivian Parallax protobuf payloads.
+
+Public API:
+    decode_parallax_message(rvm, payload, timestamp=None, **kwargs) -> dict | None
+        Adds `timestamp` (epoch milliseconds) as a UTC datetime if given.
+    decode_parallax_subscription_message(data) -> dict | None
+        Same, for a raw `subscribe_for_parallax_messages` message.
+    PARALLAX_RVMS: list[str]  — every RVM with a registered decoder
+    CHARGING_RVMS: list[str]  — the subset relevant to a charging session
+
+Layout:
+    core.py  - registry, payload parsing and shared helpers
+    proto/   - .proto schemas and their generated *_pb2 modules
+    <topic prefix>.py - one module per RVM topic prefix (body.*, etc.)
+
+To add a decoder, decorate it with
+`@RVMDecoder.register("the.rvm.topic", some_pb2.Message)` in its prefix's
+module; a new module also needs adding to the import list below.
+"""
+
+from __future__ import annotations
+
+from . import (  # noqa: F401  (imported to register their decoders)
+    body,
+    charging,
+    comfort,
+    departure,
+    device_table,
+    dynamics,
+    energy,
+    energy_edge_compute,
+    gearguard_streaming,
+    geofence,
+    holiday_celebration,
+    navigation,
+    ota,
+    parallax,
+    secure_file_transfer,
+    security,
+    user_passcodes,
+    vehicle,
+    vehicle_access,
+)
+from .core import (
+    RVMDecoder,
+    decode_parallax_message,
+    decode_parallax_subscription_message,
+)
+
+PARALLAX_RVMS: list[str] = list(RVMDecoder.decoders)
+
+CHARGING_RVMS: list[str] = [
+    "charging.session.notification",
+    "charging.session.remote_command",
+    "charging.session.soc_slider",
+    "charging.session.status",
+    "charging.session.time_estimation",
+    "energy.high_voltage.battery_state",
+    "energy_edge_compute.graphs.charge_session_breakdown",
+    "energy_edge_compute.graphs.charging_graph_global",
+]
+
+__all__ = [
+    "CHARGING_RVMS",
+    "PARALLAX_RVMS",
+    "decode_parallax_message",
+    "decode_parallax_subscription_message",
+]

rivian_python_client-2.2.0b0/src/rivian/parallax/body.py

@@ -0,0 +1,179 @@
+"""Decoders for `body.*` RVM topics: closures, locks, trailer."""
+
+from __future__ import annotations
+
+from typing import Any, Final
+
+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",
+}
+
+_CLOSURE_STATE_MAP: Final[dict[int, str]] = {
+    1: "open",
+    2: "closed",
+    4: "opening",
+    5: "closing",
+}
+
+
+def _enum_names(enum: Any, prefix: str) -> dict[int, str]:
+    """Map an enum's numbers to its lowercased names, minus `prefix`."""
+    return {
+        value.number: value.name.removeprefix(prefix).lower()
+        for value in enum.DESCRIPTOR.values
+    }
+
+
+# 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",
+}
+
+# Closure id -> (next-action field, result key, value names).
+_NEXT_ACTIONS: Final[dict[int, tuple[str, str, dict[int, str]]]] = {
+    body_pb2.FRUNK: (
+        "frunk_next_action",
+        "closureFrunkNextAction",
+        _enum_names(body_pb2.FrunkNextAction, "FRUNK_"),
+    ),
+    body_pb2.SIDE_BIN_LEFT: (
+        "side_bin_next_action",
+        "closureSideBinLeftNextAction",
+        _SIDE_BIN_NEXT_ACTIONS,
+    ),
+    body_pb2.SIDE_BIN_RIGHT: (
+        "side_bin_next_action",
+        "closureSideBinRightNextAction",
+        _SIDE_BIN_NEXT_ACTIONS,
+    ),
+    body_pb2.TAILGATE: (
+        "tailgate_next_action",
+        "closureTailgateNextAction",
+        _enum_names(body_pb2.TailgateNextAction, "TAILGATE_"),
+    ),
+    body_pb2.CHARGE_PORT: (
+        "charge_port_door_next_action",
+        "closureChargePortDoorNextAction",
+        _enum_names(body_pb2.ChargePortDoorNextAction, "CHARGE_PORT_DOOR_"),
+    ),
+}
+
+_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",
+}
+
+_TRAILER_PRESENCE_MAP: Final[dict[int, str]] = {
+    1: "trailer_not_present",
+    2: "trailer_present",
+    3: "trailer_present_with_brakes",
+    4: "trailer_invalid",
+}
+
+
+@RVMDecoder.register("body.closures.states", body_pb2.ClosuresState)
+def decode_closures(m: body_pb2.ClosuresState) -> dict[str, Any]:
+    """body.closures.states — state of every door, window and closure.
+
+    Fields:
+        doorFrontLeftClosed, closureFrunkClosed, etc.: str
+            ("open" | "closed" | "opening" | "closing")
+        closureFrunkNextAction, closureTailgateNextAction,
+        closureSideBinLeftNextAction, closureSideBinRightNextAction,
+        closureChargePortDoorNextAction: str — e.g. "open_allowed" (shut),
+            "close_allowed" (open); for the charge port,
+            "close_not_available" means plugged in
+
+    `chargePortState` can lag the door (e.g. "opening" until plugged in),
+    so prefer its next action. After an app command, next actions briefly
+    drop to "sna" / "open_not_available".
+    """
+    result: dict[str, Any] = {}
+    for s in m.closure:
+        cid = s.id
+        state_val = _present(s, "state")
+        if cid in _CLOSURE_MAP:
+            result[_CLOSURE_MAP[cid]] = _enum(
+                _CLOSURE_STATE_MAP, state_val, what="closure state"
+            )
+        else:
+            _LOGGER.debug("Unknown closure id %s (state %s)", cid, state_val)
+        if cid in _NEXT_ACTIONS:
+            field, key, names = _NEXT_ACTIONS[cid]
+            if (next_action := _present(s, field)) is not None:
+                result[key] = _enum(names, next_action, what=f"{key} value")
+    return result
+
+
+@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.
+
+    Fields:
+        doorFrontLeftLocked, closureFrunkLocked, etc.: str ("locked" | "unlocked")
+    """
+    result: dict[str, Any] = {}
+    for s in m.lock:
+        lid = s.id
+        state_val = _present(s, "state")
+        if state_val is None:
+            continue
+        if lid in _LOCK_MAP:
+            result[_LOCK_MAP[lid]] = "locked" if state_val == 1 else "unlocked"
+        else:
+            _LOGGER.debug("Unknown lock id %s (state %s)", lid, state_val)
+    return result
+
+
+@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.
+
+    Fields:
+        trailerStatus: str
+    """
+    result: dict[str, Any] = {}
+    presence = _enum(
+        _TRAILER_PRESENCE_MAP, _present(m, "presence"), what="trailer presence"
+    )
+    if presence is not None:
+        result["trailerStatus"] = presence
+    return result
+
+
+@RVMDecoder.register("body.wipers.fluid_level", body_pb2.WiperFluidLevel)
+def decode_wiper_fluid_level(m: body_pb2.WiperFluidLevel) -> dict[str, Any]:
+    """body.wipers.fluid_level — washer fluid level.
+
+    Fields:
+        _wiperFluidLevel: int — raw (1 so far, presumably normal)
+    """
+    if (v := _present(m, "field_2")) is None:
+        return {}
+    return {"_wiperFluidLevel": v}

rivian_python_client-2.2.0b0/src/rivian/parallax/charging.py

@@ -0,0 +1,226 @@
+"""Decoders for `charging.*` RVM topics."""
+
+from __future__ import annotations
+
+from typing import Any, Final
+
+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",
+}
+
+
+@RVMDecoder.register("charging.schedule.time_window", charging_pb2.ScheduleTimeWindow)
+def decode_schedule_time_window(m: charging_pb2.ScheduleTimeWindow) -> dict[str, Any]:
+    """charging.schedule.time_window — the scheduled charging window.
+
+    Fields:
+        chargingScheduleEnabled: bool — False when no schedule is set
+        chargingScheduleStartDay, chargingScheduleEndDay: str
+            ("sunday" ... "saturday")
+        chargingScheduleStartTime, chargingScheduleEndTime: int — minutes
+            after local midnight on that day (1440 = end of day)
+        chargingScheduleDuration: int — minutes (10080 for all week)
+        chargingScheduleAmps: int — current limit (A)
+        chargingScheduleLocation: {"latitude": float, "longitude": float}
+
+    The days are the window's current/next occurrence; its daily/weekdays
+    recurrence isn't sent.
+    """
+    result: dict[str, Any] = {"chargingScheduleEnabled": m.enabled}
+    if not m.HasField("window"):
+        return result
+    window = m.window
+    result["chargingScheduleStartDay"] = _enum(
+        _DAY_OF_WEEK_MAP, window.start_day or None, what="schedule start day"
+    )
+    result["chargingScheduleEndDay"] = _enum(
+        _DAY_OF_WEEK_MAP, window.end_day or None, what="schedule end day"
+    )
+    result["chargingScheduleStartTime"] = window.start_time
+    result["chargingScheduleEndTime"] = window.end_time
+    result["chargingScheduleDuration"] = window.duration
+    if window.HasField("amps"):
+        result["chargingScheduleAmps"] = window.amps
+    if window.HasField("location"):
+        result["chargingScheduleLocation"] = {
+            "latitude": round(window.location.latitude, 6),
+            "longitude": round(window.location.longitude, 6),
+        }
+    return result
+
+
+@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 {}
+
+
+_REMOTE_COMMAND_MAP: Final[dict[int, str]] = {
+    1: "start",
+    2: "stop",
+}
+
+
+@RVMDecoder.register(
+    "charging.session.remote_command", charging_pb2.SessionRemoteCommand
+)
+def decode_session_remote_command(
+    m: charging_pb2.SessionRemoteCommand,
+) -> dict[str, Any]:
+    """charging.session.remote_command — the last start/stop command.
+
+    Fields:
+        chargingRemoteCommand: str ("start" | "stop")
+
+    Also sent when the vehicle holds ("stop") or resumes ("start")
+    charging around a schedule or limit change.
+    """
+    if not m.HasField("command"):
+        return {}
+    return {
+        "chargingRemoteCommand": _enum(
+            _REMOTE_COMMAND_MAP, m.command, what="charging remote command"
+        )
+    }
+
+
+@RVMDecoder.register("charging.session.soc_slider", charging_pb2.SocSlider)
+def decode_soc_slider(m: charging_pb2.SocSlider) -> dict[str, Any]:
+    """charging.session.soc_slider — the charge limit.
+
+    Fields:
+        batteryLimit: int (percent, 0-100)
+    """
+    if not m.HasField("soc_limit"):
+        return {}
+    return {"batteryLimit": m.soc_limit}
+
+
+@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`.
+
+    0xFFFF seems to mean "not set".
+    """
+    return {"_field2": m.field2} if m.HasField("field2") else {}
+
+
+@RVMDecoder.register(
+    "charging.smart_charging.settings", charging_pb2.SmartChargingSettings
+)
+def decode_smart_charging_settings(
+    _m: charging_pb2.SmartChargingSettings,
+) -> dict[str, Any]:
+    """charging.smart_charging.settings — unmapped."""
+    return {}
+
+
+@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 {}
+
+
+@RVMDecoder.register(
+    "charging.smart_charging.weighted_charging_forecast",
+    charging_pb2.WeightedChargingForecast,
+)
+def decode_weighted_charging_forecast(
+    _m: charging_pb2.WeightedChargingForecast,
+) -> dict[str, Any]:
+    """charging.smart_charging.weighted_charging_forecast — unmapped."""
+    return {}
+
+
+_CONNECTION_STATE_MAP: Final[dict[int, str]] = {
+    1: "disconnected",
+    2: "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",
+}
+
+
+@RVMDecoder.register("charging.session.status", charging_pb2.SessionStatus)
+def decode_charging_status(m: charging_pb2.SessionStatus) -> dict[str, Any]:
+    """charging.session.status — plug and charging state.
+
+    Fields:
+        connectionState: str ("connected" | "disconnected")
+        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
+    """
+    result: dict[str, Any] = {}
+    if m.HasField("connection_state"):
+        result["connectionState"] = _enum(
+            _CONNECTION_STATE_MAP, m.connection_state, what="charging connection state"
+        )
+    if m.HasField("charging_state"):
+        result["chargerState"] = _enum(
+            _CHARGING_STATE_MAP, m.charging_state, what="charging state"
+        )
+    result["isActive"] = m.is_active
+    return result
+
+
+@RVMDecoder.register("charging.session.time_estimation", charging_pb2.TimeEstimation)
+def decode_time_estimation(m: charging_pb2.TimeEstimation) -> dict[str, Any]:
+    """charging.session.time_estimation — time to the charge limit.
+
+    Fields:
+        timeToEndOfCharge: int (minutes; 0 when not charging)
+    """
+    return {"timeToEndOfCharge": m.estimated_time_remaining}
+
+
+@RVMDecoder.register("charging.energy.state", charging_pb2.EnergyState)
+def decode_energy_state(m: charging_pb2.EnergyState) -> dict[str, Any]:
+    """charging.energy.state — unmapped; `_field1`-`_field3`, `_field11` raw."""
+    return {
+        f"_field{num}": v
+        for num in (1, 2, 3, 11)
+        if (v := _present(m, f"field_{num}")) is not None
+    }
+
+
+@RVMDecoder.register("charging.session.power", charging_pb2.SessionPower)
+def decode_session_power(_m: charging_pb2.SessionPower) -> dict[str, Any]:
+    """charging.session.power — unmapped; empty so far."""
+    return {}