rivian-python-client 2.0.0__tar.gz → 2.1.0__tar.gz

rivian_python_client-2.1.0/.gitignore

@@ -0,0 +1,34 @@
+# Version file (auto-generated by Hatchling)
+src/rivian/__version__.py
+
+# IDE generated files
+.vscode/
+
+# Python generated files
+__pycache__/
+*.pyc
+.pytest_cache
+
+# Packaging generated files
+*.egg-info
+
+# Tox
+.tox
+
+# Code coverage
+.coverage
+
+# JS files
+*/node_modules/
+*package-lock.json
+
+dist/
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/

rivian_python_client-2.1.0/PKG-INFO

@@ -0,0 +1,42 @@
+Metadata-Version: 2.4
+Name: rivian-python-client
+Version: 2.1.0
+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
+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: typing-extensions>=4.14.1; python_version < '3.11'
+Provides-Extra: ble
+Requires-Dist: bleak>=0.21; extra == 'ble'
+Requires-Dist: dbus-fast>=2.11.0; (sys_platform == 'linux') and extra == 'ble'
+Description-Content-Type: text/markdown
+
+# Python: Rivian API Client
+
+Currently a Work In Progress
+
+## Dependencies
+
+[uv](https://docs.astral.sh/uv/)
+
+```
+curl -LsSf https://astral.sh/uv/install.sh | sh
+```
+
+## Setup
+
+Install project dependencies into the uv virtual environment and run pre-commit
+
+```
+uv sync --all-extras
+pre-commit install
+```
+
+## Run Tests
+
+```
+uv run pytest
+```

rivian_python_client-2.1.0/README.md

@@ -0,0 +1,26 @@
+# Python: Rivian API Client
+
+Currently a Work In Progress
+
+## Dependencies
+
+[uv](https://docs.astral.sh/uv/)
+
+```
+curl -LsSf https://astral.sh/uv/install.sh | sh
+```
+
+## Setup
+
+Install project dependencies into the uv virtual environment and run pre-commit
+
+```
+uv sync --all-extras
+pre-commit install
+```
+
+## Run Tests
+
+```
+uv run pytest
+```

rivian_python_client-2.1.0/pyproject.toml

@@ -0,0 +1,66 @@
+[project]
+name = "rivian-python-client"
+description = "Rivian API Client (Unofficial)"
+authors = [
+    { name = "Brian Retterer", email = "bretterer@gmail.com" },
+    { name = "J.R. Gutierrez", email = "jrgutier@gmail.com" },
+    { name = "Nathan Spencer", email = "natekspencer@gmail.com" },
+    { name = "Trevor Mack", email = "drummer8001@gmail.com" },
+]
+requires-python = ">=3.10"
+readme = "README.md"
+license = "MIT"
+dependencies = [
+    "aiohttp (>=3.0.0)",
+    "cryptography (>=41.0.1)",
+    "backports-strenum (>=1.2.4) ; python_version < '3.11'",
+    "typing_extensions (>=4.14.1) ; python_version < '3.11'",
+]
+dynamic = ["version"]
+
+[project.optional-dependencies]
+ble = [
+    "bleak (>=0.21)",
+    "dbus-fast (>=2.11.0) ; sys_platform == 'linux'",
+]
+
+[dependency-groups]
+dev = [
+    "pytest>=9.0,<10.0",
+    "pytest-asyncio>=1.0,<1.5",
+    "python-dotenv>=1.0,<1.3",
+    "aresponses>=3.0,<4.0",
+    "mypy>=1.7,<3.0",
+    "ruff>=0.16,<0.17",
+    "pre-commit>=4.6.1,<5",
+]
+
+[tool.hatch.build.hooks.version]
+path = "src/rivian/__version__.py"
+
+[tool.hatch.build.targets.sdist]
+include = ["src/rivian"]
+
+[tool.hatch.build.targets.wheel]
+include = ["src/rivian"]
+
+[tool.hatch.build.targets.wheel.sources]
+"src/rivian" = "rivian"
+
+[tool.hatch.version]
+source = "uv-dynamic-versioning"
+
+[tool.uv]
+default-groups = "all"
+cache-keys = [{ file = "pyproject.toml" }, { git = { commit = true, tags = true }}]
+
+[tool.uv-dynamic-versioning]
+pattern = "default-unprefixed"
+
+[tool.ruff.lint.isort]
+combine-as-imports = true
+split-on-trailing-comma = false
+
+[build-system]
+requires = ["hatchling", "uv-dynamic-versioning"]
+build-backend = "hatchling.build"

{rivian_python_client-2.0.0 → rivian_python_client-2.1.0}/src/rivian/__init__.py

@@ -1,6 +1,7 @@
 """Asynchronous Python client for the Rivian API."""
 
+from .__version__ import __version__
 from .const import VehicleCommand
 from .rivian import Rivian
 
-__all__ = ["Rivian", "VehicleCommand"]
+__all__ = ["Rivian", "VehicleCommand", "__version__"]

rivian_python_client-2.1.0/src/rivian/__version__.py

@@ -0,0 +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'

{rivian_python_client-2.0.0 → rivian_python_client-2.1.0}/src/rivian/ble.py

@@ -33,7 +33,7 @@ class BleNotificationResponse:
 
     def __init__(self) -> None:
         """Initialize the BLE notification response helper."""
-        self.data: bytes | None = None
+        self.data: bytearray | None = None
         self.event = asyncio.Event()
 
     def notification_handler(self, _, notification_data: bytearray) -> None:
@@ -115,7 +115,7 @@ async def pair_phone(
 
             _LOGGER.debug("Successfully paired with %s", device)
             return True
-    except Exception as ex:  # pylint: disable=broad-except
+    except Exception as ex:  # pylint: disable=broad-except # noqa: BLE001
         _LOGGER.debug(
             "Couldn't connect to %s. "
             'Make sure you are in the correct vehicle and have selected "Set Up" for the appropriate key and try again'
@@ -157,10 +157,10 @@ async def set_bluez_pairable(device: BLEDevice) -> bool:
         introspection = await bus.introspect("org.bluez", path)
         pobject = bus.get_proxy_object("org.bluez", path, introspection)
         iface = pobject.get_interface("org.bluez.Adapter1")
-        if not await iface.get_pairable():
-            await iface.set_pairable(True)
+        if not await iface.get_pairable():  # type: ignore[attr-defined]
+            await iface.set_pairable(True)  # type: ignore[attr-defined]
         bus.disconnect()
-    except Exception as ex:  # pylint: disable=broad-except
+    except Exception as ex:  # pylint: disable=broad-except # noqa: BLE001
         _LOGGER.error(ex)
         return False
 

rivian_python_client-2.1.0/src/rivian/parallax.py

@@ -0,0 +1,628 @@
+"""Decoder for Rivian Parallax protobuf payloads.
+
+Decodes base64-encoded protobuf binary payloads from the Parallax WebSocket
+subscription into structured Python dicts.
+
+Reference: https://github.com/kaedenbrinkman/rivian-api (RivDocs)
+"""
+
+from __future__ import annotations
+
+import base64
+import logging
+import struct
+from collections.abc import Callable
+from datetime import datetime, timezone
+from typing import Any
+
+_LOGGER = logging.getLogger(__name__)
+
+CLOSURE_MAP = {
+    1: "doorFrontLeftClosed",
+    2: "doorFrontRightClosed",
+    3: "doorRearLeftClosed",
+    4: "doorRearRightClosed",
+    5: "closureFrunkClosed",
+    6: "closureSideBinLeftClosed",
+    7: "closureLiftgateClosed",
+}
+
+LOCK_MAP = {
+    1: "doorFrontLeftLocked",
+    2: "doorFrontRightLocked",
+    3: "doorRearLeftLocked",
+    4: "doorRearRightLocked",
+    5: "closureFrunkLocked",
+    7: "closureLiftgateLocked",
+}
+
+POWER_STATE_MAP = {
+    1: "sleep",
+    2: "standby",
+    3: "ready",
+    4: "go",
+}
+
+TIRE_POSITION_MAP = {
+    1: "FrontLeft",
+    2: "FrontRight",
+    3: "RearLeft",
+    4: "RearRight",
+}
+
+
+def _decode_varint(data: bytes, offset: int) -> tuple[int, int]:
+    """Decode a protobuf varint, return (value, new_offset)."""
+    result = 0
+    shift = 0
+    while offset < len(data):
+        byte = data[offset]
+        result |= (byte & 0x7F) << shift
+        shift += 7
+        offset += 1
+        if not (byte & 0x80):
+            break
+    return result, offset
+
+
+def _decode_protobuf_fields(data: bytes) -> list[tuple[int, int, Any]]:
+    """Decode raw protobuf bytes into a list of (field_number, wire_type, value) tuples."""
+    fields = []
+    i = 0
+    while i < len(data):
+        tag, i = _decode_varint(data, i)
+        field_num = tag >> 3
+        wire_type = tag & 0x07
+        value: Any
+
+        if wire_type == 0:  # Varint
+            value, i = _decode_varint(data, i)
+            fields.append((field_num, wire_type, value))
+        elif wire_type == 1:  # 64-bit float
+            if i + 8 <= len(data):
+                value = struct.unpack("<d", data[i : i + 8])[0]
+                i += 8
+                fields.append((field_num, wire_type, value))
+            else:
+                break
+        elif wire_type == 2:  # Length-delimited
+            length, i = _decode_varint(data, i)
+            if i + length <= len(data):
+                value = data[i : i + length]
+                i += length
+                fields.append((field_num, wire_type, value))
+            else:
+                break
+        elif wire_type == 5:  # 32-bit float
+            if i + 4 <= len(data):
+                value = struct.unpack("<f", data[i : i + 4])[0]
+                i += 4
+                fields.append((field_num, wire_type, value))
+            else:
+                break
+        else:
+            _LOGGER.debug("Unknown wire type %d for field %d", wire_type, field_num)
+            break
+
+    return fields
+
+
+def decode_battery_state(payload: str) -> dict[str, Any]:
+    """Decode energy.high_voltage.battery_state.
+
+    Returns dict with keys:
+        - soc: float (percentage, 0-100)
+        - packEnergyKwh: float
+        - rangeKm: float (if present)
+    """
+    if not payload:
+        return {}
+    try:
+        data = base64.b64decode(payload)
+        fields = _decode_protobuf_fields(data)
+        result: dict[str, Any] = {}
+
+        for field_num, wire_type, value in fields:
+            if field_num == 1 and wire_type == 2:
+                # Nested charge_state message
+                inner_fields = _decode_protobuf_fields(value)
+                for inner_num, inner_wt, inner_val in inner_fields:
+                    if inner_num == 1 and inner_wt == 1:  # soc (float)
+                        result["soc"] = round(inner_val, 2)
+                    elif inner_num == 2 and inner_wt == 1:  # packEnergyKwh (float)
+                        result["packEnergyKwh"] = round(inner_val, 2)
+                    elif inner_num == 3 and inner_wt == 5:  # rangeKm (float)
+                        result["rangeKm"] = round(inner_val, 1)
+
+        return result
+    except Exception:
+        _LOGGER.debug("Failed to decode battery_state payload", exc_info=True)
+        return {}
+
+
+def decode_cabin_temperatures(payload: str) -> dict[str, Any]:
+    """Decode comfort.cabin.cabin_temperatures.
+
+    Returns dict with keys:
+        - cabinClimateInteriorTemperature: float (Celsius)
+        - cabinClimateDriverTemperature: float (Celsius)
+    """
+    if not payload:
+        return {}
+    try:
+        data = base64.b64decode(payload)
+        fields = _decode_protobuf_fields(data)
+        result: dict[str, Any] = {}
+
+        for field_num, wire_type, value in fields:
+            if field_num == 3 and wire_type == 5:  # interior temp (float, Celsius)
+                result["cabinClimateInteriorTemperature"] = round(value, 1)
+            if field_num == 4 and wire_type == 5:  # interior temp (float, Celsius)
+                result["cabinClimateDriverTemperature"] = round(value, 1)
+
+        return result
+    except Exception:
+        _LOGGER.debug("Failed to decode cabin temperatures payload", exc_info=True)
+        return {}
+
+
+def decode_charge_session_breakdown(payload: str) -> dict[str, Any]:
+    """Decode energy_edge_compute.graphs.charge_session_breakdown.
+
+    Returns dict with keys matching legacy getLiveSessionData field names:
+        - totalChargedEnergy: float (kWh total)
+        - power: float (kW, current charge rate)
+        - timeElapsed: int (seconds, estimated)
+        - rangeAddedThisSession: float (km, estimated from energy)
+    """
+    if not payload:
+        return {}
+    try:
+        data = base64.b64decode(payload)
+        fields = _decode_protobuf_fields(data)
+        result: dict[str, Any] = {}
+
+        total_kwh = 0.0
+
+        for field_num, wire_type, value in fields:
+            if field_num == 1 and wire_type == 5:  # totalKwh (float)
+                total_kwh = round(value, 4)
+                result["totalChargedEnergy"] = total_kwh
+            elif field_num == 9 and wire_type == 5:  # currentPower (float, kW)
+                result["power"] = round(value, 2)
+            elif field_num == 7 and wire_type == 0:  # timeRemainingMins or elapsed secs
+                result["_time_field_7"] = value
+            elif field_num == 10 and wire_type == 0:  # charge power integer (kW)
+                if "power" not in result:
+                    result["power"] = float(value)
+            elif field_num == 13 and wire_type == 0:  # chargingState enum
+                result["_charging_state"] = value
+
+        # Estimate range added: ~3.5 km/kWh (~2.17 mi/kWh) is a typical Rivian average
+        if total_kwh > 0:
+            result["rangeAddedThisSession"] = round(total_kwh * 3.5, 1)
+
+        # Derive charge rate (km/h) from current power (kW)
+        if "power" in result:
+            p = result["power"]
+            result["kilometersChargedPerHour"] = round(p * 3.5, 1) if p > 0 else 0.0
+
+        return result
+    except Exception:
+        _LOGGER.debug(
+            "Failed to decode charge_session_breakdown payload", exc_info=True
+        )
+        return {}
+
+
+def decode_charging_graph_global(payload: str) -> dict[str, Any]:
+    """Decode energy_edge_compute.graphs.charging_graph_global.
+
+    Returns dict with keys:
+        - startTime: str (ISO format timestamp of session start)
+        - timeElapsed: int (seconds elapsed since session start)
+        - power: float (kW, latest segment power)
+    """
+    if not payload:
+        return {}
+    try:
+        data = base64.b64decode(payload)
+        outer = _decode_protobuf_fields(data)
+        segments = []
+        for field_num, wire_type, value in outer:
+            if field_num == 1 and wire_type == 2:
+                inner = _decode_protobuf_fields(value)
+                seg: dict[str, Any] = {}
+                for in_num, in_wt, in_val in inner:
+                    if in_num == 1 and in_wt == 0:
+                        seg["soc"] = in_val
+                    elif in_num == 2 and in_wt == 5:
+                        seg["power"] = round(in_val, 2)
+                    elif in_num == 3 and in_wt == 0:
+                        seg["start_ms"] = in_val
+                    elif in_num == 4 and in_wt == 0:
+                        seg["end_ms"] = in_val
+                    elif in_num == 6 and in_wt == 0:
+                        seg["state"] = in_val
+                segments.append(seg)
+
+        if not segments:
+            return {}
+
+        active_segments = [
+            s for s in segments if s.get("power", 0) > 0 or s.get("state") == 3
+        ]
+
+        first_seg = active_segments[0] if active_segments else segments[0]
+        result: dict[str, Any] = {}
+
+        if "start_ms" in first_seg:
+            st = datetime.fromtimestamp(first_seg["start_ms"] / 1000, timezone.utc)
+            result["startTime"] = st.strftime("%Y-%m-%dT%H:%M:%S.%f%z")
+
+        if active_segments:
+            result["timeElapsed"] = sum(
+                max(0, int((s["end_ms"] - s["start_ms"]) / 1000))
+                for s in active_segments
+                if "end_ms" in s and "start_ms" in s
+            )
+        else:
+            result["timeElapsed"] = 0
+
+        latest_segment = segments[-1]
+        if (
+            "power" in latest_segment
+            and latest_segment.get("power", 0) > 0
+            and latest_segment.get("state") != 8
+        ):
+            result["power"] = latest_segment["power"]
+            result["kilometersChargedPerHour"] = round(result["power"] * 3.5, 1)
+        else:
+            result["power"] = 0.0
+            result["kilometersChargedPerHour"] = 0.0
+
+        return result
+    except Exception:
+        _LOGGER.debug("Failed to decode charging_graph_global payload", exc_info=True)
+        return {}
+
+
+def decode_charging_session_status(payload: str) -> dict[str, Any]:
+    """Decode charging.session.status.
+
+    Returns dict with keys:
+        - plugConnectionStatus: int (enum)
+        - displayStatus: int (enum)
+        - evseType: int (enum)
+    """
+    if not payload:
+        return {}
+    try:
+        data = base64.b64decode(payload)
+        fields = _decode_protobuf_fields(data)
+        result: dict[str, Any] = {}
+
+        for field_num, wire_type, value in fields:
+            if field_num == 1 and wire_type == 0:
+                result["plugConnectionStatus"] = value
+            elif field_num == 2 and wire_type == 0:
+                result["displayStatus"] = value
+            elif field_num == 3 and wire_type == 0:
+                result["evseType"] = value
+
+        return result
+    except Exception:
+        _LOGGER.debug("Failed to decode charging.session.status payload", exc_info=True)
+        return {}
+
+
+def decode_closures(payload: str) -> dict[str, Any]:
+    """Decode body.closures.states.
+
+    Returns dict with keys:
+        - doorFrontLeftClosed, doorFrontRightClosed, closureFrunkClosed, etc. ("closed" / "open")
+    """
+    if not payload:
+        return {}
+    try:
+        data = base64.b64decode(payload)
+        fields = _decode_protobuf_fields(data)
+        result: dict[str, Any] = {}
+
+        for field_num, wire_type, value in fields:
+            if field_num == 1 and wire_type == 2:  # Repeated nested closure state
+                inner = _decode_protobuf_fields(value)
+                cid = None
+                state_val = None
+                for in_num, in_type, in_val in inner:
+                    if in_num == 1 and in_type == 0:
+                        cid = in_val
+                    elif in_num == 2 and in_type == 0:
+                        state_val = in_val
+
+                if cid and cid in CLOSURE_MAP and state_val is not None:
+                    # 1 = open, 2 = closed
+                    result[CLOSURE_MAP[cid]] = "closed" if state_val == 2 else "open"
+
+        return result
+    except Exception:
+        _LOGGER.debug("Failed to decode closures payload", exc_info=True)
+        return {}
+
+
+def decode_defrost(payload: str) -> dict[str, Any]:
+    """Decode comfort.cabin.defrost_defog_status.
+
+    Returns dict with keys:
+        - defrostDefogStatus: str ("Defrost", "Off")
+    """
+    if not payload:
+        return {}
+    try:
+        data = base64.b64decode(payload)
+        fields = _decode_protobuf_fields(data)
+        result: dict[str, Any] = {}
+        for field_num, wire_type, value in fields:
+            if field_num == 1 and wire_type == 0:
+                result["defrostDefogStatus"] = "Defrost" if value == 2 else "Off"
+        return result
+    except Exception:
+        _LOGGER.debug("Failed to decode defrost payload", exc_info=True)
+        return {}
+
+
+def decode_gnss(payload: str) -> dict[str, Any]:
+    """Decode dynamics.vehicle.gnss.
+
+    Returns dict with keys:
+        - gnssLocation: {"latitude": float, "longitude": float, "timeStamp": str}
+        - gnssAltitude: float (meters)
+    """
+    if not payload:
+        return {}
+    try:
+        data = base64.b64decode(payload)
+        fields = _decode_protobuf_fields(data)
+        lat = None
+        lon = None
+        alt = None
+        for field_num, wire_type, value in fields:
+            if field_num == 1 and wire_type == 1:  # latitude (float)
+                lat = round(value, 6)
+            elif field_num == 2 and wire_type == 1:  # longitude (float)
+                lon = round(value, 6)
+            elif field_num == 3 and wire_type == 1:  # altitude (float)
+                alt = round(value, 1)
+
+        result: dict[str, Any] = {}
+        if lat is not None and lon is not None:
+            now_iso = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%f%z")
+            result["gnssLocation"] = {
+                "latitude": lat,
+                "longitude": lon,
+                "timeStamp": now_iso,
+            }
+        if alt is not None:
+            result["gnssAltitude"] = alt
+        return result
+    except Exception:
+        _LOGGER.debug("Failed to decode dynamics.vehicle.gnss payload", exc_info=True)
+        return {}
+
+
+def decode_locks(payload: str) -> dict[str, Any]:
+    """Decode body.locks.states.
+
+    Returns dict with keys:
+        - doorFrontLeftLocked, closureFrunkLocked, etc. ("locked" / "unlocked")
+    """
+    if not payload:
+        return {}
+    try:
+        data = base64.b64decode(payload)
+        fields = _decode_protobuf_fields(data)
+        result: dict[str, Any] = {}
+
+        for field_num, wire_type, value in fields:
+            if field_num == 1 and wire_type == 2:  # Repeated nested lock state
+                inner = _decode_protobuf_fields(value)
+                lid = None
+                state_val = None
+                for in_num, in_type, in_val in inner:
+                    if in_num == 1 and in_type == 0:
+                        lid = in_val
+                    elif in_num == 2 and in_type == 0:
+                        state_val = in_val
+
+                if lid and lid in LOCK_MAP and state_val is not None:
+                    # 1 = locked, 2 = unlocked
+                    result[LOCK_MAP[lid]] = "locked" if state_val == 1 else "unlocked"
+
+        return result
+    except Exception:
+        _LOGGER.debug("Failed to decode locks payload", exc_info=True)
+        return {}
+
+
+def decode_odometer(payload: str) -> dict[str, Any]:
+    """Decode dynamics.vehicle.odometer.
+
+    Returns dict with keys:
+        - vehicleMileage: float (meters)
+    """
+    if not payload:
+        return {}
+    try:
+        data = base64.b64decode(payload)
+        fields = _decode_protobuf_fields(data)
+        result: dict[str, Any] = {}
+
+        for field_num, wire_type, value in fields:
+            if field_num == 1 and wire_type == 0:
+                # Value is distance in km; HA expects meters
+                result["vehicleMileage"] = value * 1000
+
+        return result
+    except Exception:
+        _LOGGER.debug("Failed to decode odometer payload", exc_info=True)
+        return {}
+
+
+def decode_power_state(payload: str) -> dict[str, Any]:
+    """Decode vehicle.power.state.
+
+    Returns dict with keys:
+        - powerState: str ("sleep", "standby", "ready", "go")
+    """
+    if not payload:
+        return {}
+    try:
+        data = base64.b64decode(payload)
+        fields = _decode_protobuf_fields(data)
+        result: dict[str, Any] = {}
+
+        for field_num, wire_type, value in fields:
+            if field_num == 1 and wire_type == 0:
+                result["powerState"] = POWER_STATE_MAP.get(value, "standby")
+
+        return result
+    except Exception:
+        _LOGGER.debug("Failed to decode power state payload", exc_info=True)
+        return {}
+
+
+def decode_preconditioning(payload: str) -> dict[str, Any]:
+    """Decode comfort.cabin.cabin_preconditioning_status.
+
+    Returns dict with keys:
+        - cabinPreconditioningStatus: str ("active", "initiate", "off")
+    """
+    if not payload:
+        return {"cabinPreconditioningStatus": "off"}
+    try:
+        data = base64.b64decode(payload)
+        fields = _decode_protobuf_fields(data)
+        status_val = None
+        for field_num, wire_type, value in fields:
+            if field_num == 1 and wire_type == 0:
+                status_val = value
+
+        if status_val == 4:
+            return {"cabinPreconditioningStatus": "active"}
+        elif status_val in (1, 2):
+            return {"cabinPreconditioningStatus": "initiate"}
+        return {"cabinPreconditioningStatus": "off"}
+    except Exception:
+        _LOGGER.debug("Failed to decode preconditioning payload", exc_info=True)
+        return {}
+
+
+def decode_time_estimation(payload: str) -> dict[str, Any]:
+    """Decode charging.session.time_estimation.
+
+    Returns dict with keys:
+        - timeToEndOfCharge: int (seconds remaining)
+    """
+    if not payload:
+        return {}
+    try:
+        data = base64.b64decode(payload)
+        fields = _decode_protobuf_fields(data)
+        result: dict[str, Any] = {}
+
+        for field_num, wire_type, value in fields:
+            if field_num == 1 and wire_type == 0:
+                result["timeToEndOfCharge"] = value
+
+        return result
+    except Exception:
+        _LOGGER.debug("Failed to decode time_estimation payload", exc_info=True)
+        return {}
+
+
+def decode_tires(payload: str) -> dict[str, Any]:
+    """Decode dynamics.tires.state.
+
+    Returns dict with keys:
+        - tirePressureFrontLeft, tirePressureFrontRight, etc. (bar)
+        - tirePressureStatusFrontLeft, etc. ("OK")
+    """
+    if not payload:
+        return {}
+    try:
+        data = base64.b64decode(payload)
+        fields = _decode_protobuf_fields(data)
+        result: dict[str, Any] = {}
+
+        for field_num, wire_type, value in fields:
+            if field_num == 2 and wire_type == 2:  # Repeated nested tire state
+                inner = _decode_protobuf_fields(value)
+                pos = None
+                status = None
+                pressure = None
+                for in_num, in_type, in_val in inner:
+                    if in_num == 1 and in_type == 0:
+                        pos = in_val
+                    elif in_num == 2 and in_type == 0:
+                        status = "OK" if in_val == 1 else "Warning"
+                    elif in_num == 3 and in_type == 1:  # 64-bit float (bar)
+                        pressure = round(in_val, 2)
+
+                if pos and pos in TIRE_POSITION_MAP:
+                    suffix = TIRE_POSITION_MAP[pos]
+                    if pressure is not None:
+                        result[f"tirePressure{suffix}"] = pressure
+                    if status is not None:
+                        result[f"tirePressureStatus{suffix}"] = status
+
+        return result
+    except Exception:
+        _LOGGER.debug("Failed to decode tires payload", exc_info=True)
+        return {}
+
+
+# Map of RVM topic -> decoder function
+RVM_DECODERS: dict[str, Callable[[str], dict[str, Any]]] = {
+    "body.closures.states": decode_closures,
+    "body.locks.states": decode_locks,
+    "charging.session.status": decode_charging_session_status,
+    "charging.session.time_estimation": decode_time_estimation,
+    "comfort.cabin.cabin_preconditioning_status": decode_preconditioning,
+    "comfort.cabin.cabin_temperatures": decode_cabin_temperatures,
+    "comfort.cabin.defrost_defog_status": decode_defrost,
+    "dynamics.tires.state": decode_tires,
+    "dynamics.vehicle.gnss": decode_gnss,
+    "dynamics.vehicle.odometer": decode_odometer,
+    "energy.high_voltage.battery_state": decode_battery_state,
+    "energy_edge_compute.graphs.charge_session_breakdown": decode_charge_session_breakdown,
+    "energy_edge_compute.graphs.charging_graph_global": decode_charging_graph_global,
+    "vehicle.power.state": decode_power_state,
+}
+
+# Full list of Parallax RVMs subscribed for vehicle & charging telemetry
+PARALLAX_RVMS: list[str] = list(RVM_DECODERS.keys())
+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",
+]
+
+
+def decode_parallax_message(
+    rvm: str, payload: str, **kwargs: Any
+) -> dict[str, Any] | None:
+    """Decode a Parallax message payload given its RVM topic.
+
+    Accepts the GraphQL message fields directly (rvm, payload, and optional kwargs/timestamp).
+    Returns a dict of decoded fields, or None if no decoder exists for this RVM.
+    """
+    decoder = RVM_DECODERS.get(rvm)
+    if decoder is None:
+        _LOGGER.warning("Unknown Parallax RVM topic %s", rvm)
+        return None
+    return decoder(payload)

{rivian_python_client-2.0.0 → rivian_python_client-2.1.0}/src/rivian/rivian.py

@@ -8,8 +8,8 @@ import socket
 import sys
 import time
 import uuid
-from collections.abc import Callable
-from typing import Any, Type
+from collections.abc import Awaitable, Callable
+from typing import Any
 from warnings import warn
 
 import aiohttp
@@ -33,13 +33,17 @@ from .exceptions import (
     RivianTemporarilyLockedError,
     RivianUnauthenticated,
 )
+from .parallax import PARALLAX_RVMS
 from .utils import generate_vehicle_command_hmac
 from .ws_monitor import WebSocketMonitor
 
 if sys.version_info >= (3, 11):
     import asyncio as async_timeout
+    from typing import Self
 else:
     import async_timeout
+    from typing_extensions import Self
+
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -82,7 +86,7 @@ LIVE_SESSION_VALUE_RECORD_KEYS = {
 }
 VALUE_RECORD_TEMPLATE = "{ __typename value updatedAt }"
 
-ERROR_CODE_CLASS_MAP: dict[str, Type[RivianApiException]] = {
+ERROR_CODE_CLASS_MAP: dict[str, type[RivianApiException]] = {
     "BAD_CURRENT_PASSWORD": RivianInvalidCredentials,
     "BAD_REQUEST_ERROR": RivianBadRequestError,
     "DATA_ERROR": RivianDataError,
@@ -444,6 +448,40 @@ class Rivian:
 
         return await self.__graphql_query(headers, url, graphql_json)
 
+    async def get_charging_schedules(self, vehicle_id: str) -> ClientResponse:
+        """Get charging schedules for a vehicle."""
+        url = GRAPHQL_GATEWAY
+        headers = BASE_HEADERS | {
+            "A-Sess": self._app_session_token,
+            "U-Sess": self._user_session_token,
+        }
+        graphql_json = {
+            "operationName": "getVehicleChargingSchedules",
+            "query": "query getVehicleChargingSchedules($vehicleId: String!) {\n  getVehicle(id: $vehicleId) {\n    chargingSchedules {\n      weekDays\n      startTime\n      duration\n      location {\n        latitude\n        longitude\n      }\n      amperage\n      enabled\n    }\n  }\n}",
+            "variables": {"vehicleId": vehicle_id},
+        }
+        return await self.__graphql_query(headers, url, graphql_json)
+
+    async def set_charging_schedules(
+        self, vehicle_id: str, schedules: list[dict[str, Any]]
+    ) -> ClientResponse:
+        """Set charging schedules for a vehicle."""
+        url = GRAPHQL_GATEWAY
+        headers = BASE_HEADERS | {
+            "Csrf-Token": self._csrf_token,
+            "A-Sess": self._app_session_token,
+            "U-Sess": self._user_session_token,
+        }
+        graphql_json = {
+            "operationName": "setChargingSchedules",
+            "query": "mutation setChargingSchedules($vehicleId: String!, $chargingSchedules: [InputChargingSchedule!]!) {\n  setChargingSchedules(vehicleId: $vehicleId, chargingSchedules: $chargingSchedules) {\n    __typename\n    success\n  }\n}",
+            "variables": {
+                "vehicleId": vehicle_id,
+                "chargingSchedules": schedules,
+            },
+        }
+        return await self.__graphql_query(headers, url, graphql_json)
+
     async def get_vehicle_ota_update_details(self, vehicle_id: str) -> ClientResponse:
         """Get vehicle OTA update details."""
         url = GRAPHQL_GATEWAY
@@ -496,15 +534,14 @@ class Rivian:
         self, command: VehicleCommand | str, params: dict[str, Any] | None = None
     ) -> None:
         """Validate certian vehicle command/param combos."""
-        if command == VehicleCommand.CHARGING_LIMITS:
-            if not (
-                params
-                and isinstance((limit := params.get("SOC_limit")), int)
-                and 50 <= limit <= 100
-            ):
-                raise RivianBadRequestError(
-                    "Charging limit must include parameter `SOC_limit` with a valid value between 50 and 100"
-                )
+        if command == VehicleCommand.CHARGING_LIMITS and not (
+            params
+            and isinstance((limit := params.get("SOC_limit")), int)
+            and 50 <= limit <= 100
+        ):
+            raise RivianBadRequestError(
+                "Charging limit must include parameter `SOC_limit` with a valid value between 50 and 100"
+            )
         if command in (
             VehicleCommand.CABIN_HVAC_DEFROST_DEFOG,
             VehicleCommand.CABIN_HVAC_LEFT_SEAT_HEAT,
@@ -514,15 +551,14 @@ class Rivian:
             VehicleCommand.CABIN_HVAC_RIGHT_SEAT_HEAT,
             VehicleCommand.CABIN_HVAC_RIGHT_SEAT_VENT,
             VehicleCommand.CABIN_HVAC_STEERING_HEAT,
+        ) and not (
+            params
+            and isinstance((level := params.get("level")), int)
+            and 0 <= level <= 4
         ):
-            if not (
-                params
-                and isinstance((level := params.get("level")), int)
-                and 0 <= level <= 4
-            ):
-                raise RivianBadRequestError(
-                    "HVAC setting must include parameter `level` with a valid value between 0 and 4"
-                )
+            raise RivianBadRequestError(
+                "HVAC setting must include parameter `level` with a valid value between 0 and 4"
+            )
         if command == VehicleCommand.CABIN_PRECONDITIONING_SET_TEMP:
             if not (
                 params
@@ -616,14 +652,44 @@ class Rivian:
             unsubscribe = await self._ws_monitor.start_subscription(payload, callback)
             _LOGGER.debug("%s subscribed to updates", vehicle_id)
             return unsubscribe
-        except Exception as ex:  # pylint: disable=broad-except
+        except Exception as ex:  # pylint: disable=broad-except # noqa: BLE001
             _LOGGER.error(ex)
             return None
 
-    async def _ws_connect(self) -> ClientWebSocketResponse:
+    async def subscribe_for_parallax_messages(
+        self,
+        vehicle_id: str,
+        callback: Callable[[dict[str, Any]], None],
+        rvms: list[str] | None = None,
+    ) -> Callable[[], Awaitable[None]] | None:
+        """Open a web socket connection to receive Parallax message updates."""
+        if not rvms:
+            rvms = PARALLAX_RVMS
+
+        try:
+            await self._ws_connect()
+            assert self._ws_monitor
+            async with async_timeout.timeout(self.request_timeout):
+                await self._ws_monitor.connection_ack.wait()
+            payload = {
+                "operationName": "ParallaxMessages",
+                "query": "subscription ParallaxMessages($vehicleId: String!, $rvms: [String!]) { parallaxMessages(vehicleId: $vehicleId, rvms: $rvms) { payload timestamp rvm } }",
+                "variables": {
+                    "vehicleId": vehicle_id,
+                    "rvms": rvms,
+                },
+            }
+            unsubscribe = await self._ws_monitor.start_subscription(payload, callback)
+            _LOGGER.debug("%s subscribed to %d Parallax RVMs", vehicle_id, len(rvms))
+            return unsubscribe
+        except Exception as ex:  # pylint: disable=broad-except # noqa: BLE001
+            _LOGGER.error(ex)
+            return None
+
+    async def _ws_connect(self) -> ClientWebSocketResponse[bool]:
         """Initiate a websocket connection."""
 
-        async def connection_init(websocket: ClientWebSocketResponse) -> None:
+        async def connection_init(websocket: ClientWebSocketResponse[bool]) -> None:
             await websocket.send_json(
                 {
                     "payload": {
@@ -676,37 +742,34 @@ class Rivian:
                 "Error occurred while communicating with Rivian."
             ) from exception
 
-        try:
-            response_json = await response.json()
-            if errors := response_json.get("errors"):
-                for error in errors:
-                    if extensions := error.get("extensions"):
-                        code = extensions["code"]
-                        if (code, extensions.get("reason")) in (
-                            ("BAD_USER_INPUT", "INVALID_OTP"),
-                            ("UNAUTHENTICATED", "OTP_TOKEN_EXPIRED"),
-                        ):
-                            raise RivianInvalidOTP(
-                                response.status, response_json, headers, body
-                            )
-                        if (code, extensions.get("reason")) == (
-                            "CONFLICT",
-                            "ENROLL_PHONE_LIMIT_REACHED",
-                        ):
-                            raise RivianPhoneLimitReachedError(
-                                response.status, response_json, headers, body
-                            )
-                        if err_cls := ERROR_CODE_CLASS_MAP.get(code):
-                            raise err_cls(response.status, response_json, headers, body)
-                raise RivianApiException(
-                    "Error occurred while reading the graphql response from Rivian.",
-                    response.status,
-                    response_json,
-                    headers,
-                    body,
-                )
-        except Exception as exception:
-            raise exception
+        response_json = await response.json()
+        if errors := response_json.get("errors"):
+            for error in errors:
+                if extensions := error.get("extensions"):
+                    code = extensions["code"]
+                    if (code, extensions.get("reason")) in (
+                        ("BAD_USER_INPUT", "INVALID_OTP"),
+                        ("UNAUTHENTICATED", "OTP_TOKEN_EXPIRED"),
+                    ):
+                        raise RivianInvalidOTP(
+                            response.status, response_json, headers, body
+                        )
+                    if (code, extensions.get("reason")) == (
+                        "CONFLICT",
+                        "ENROLL_PHONE_LIMIT_REACHED",
+                    ):
+                        raise RivianPhoneLimitReachedError(
+                            response.status, response_json, headers, body
+                        )
+                    if err_cls := ERROR_CODE_CLASS_MAP.get(code):
+                        raise err_cls(response.status, response_json, headers, body)
+            raise RivianApiException(
+                "Error occurred while reading the graphql response from Rivian.",
+                response.status,
+                response_json,
+                headers,
+                body,
+            )
 
         return response
 
@@ -717,7 +780,7 @@ class Rivian:
         if self._session and self._close_session:
             await self._session.close()
 
-    async def __aenter__(self) -> Rivian:
+    async def __aenter__(self) -> Self:
         """Async enter.
         Returns:
             The Rivian object.

{rivian_python_client-2.0.0 → rivian_python_client-2.1.0}/src/rivian/ws_monitor.py

@@ -14,6 +14,7 @@ from typing import TYPE_CHECKING, Any
 from uuid import uuid4
 
 from aiohttp import ClientWebSocketResponse, WSMessage, WSMsgType
+from aiohttp.http_websocket import WSMessageTextBytes
 
 if sys.version_info >= (3, 11):
     import asyncio as async_timeout
@@ -44,7 +45,7 @@ class WebSocketMonitor:
         self,
         account: Rivian,
         url: str,
-        connection_init: Callable[[ClientWebSocketResponse], Awaitable[None]],
+        connection_init: Callable[[ClientWebSocketResponse[bool]], Awaitable[None]],
     ) -> None:
         """Initialize a web socket monitor."""
         self._account = account
@@ -53,7 +54,7 @@ class WebSocketMonitor:
 
         self._connection_ack: asyncio.Event = asyncio.Event()
         self._disconnect = False
-        self._ws: ClientWebSocketResponse | None = None
+        self._ws: ClientWebSocketResponse[bool] | None = None
         self._monitor_task: asyncio.Task | None = None
         self._receiver_task: asyncio.Task | None = None
         self._last_received: datetime | None = None
@@ -74,7 +75,7 @@ class WebSocketMonitor:
         return self._connection_ack
 
     @property
-    def websocket(self) -> ClientWebSocketResponse | None:
+    def websocket(self) -> ClientWebSocketResponse[bool] | None:
         """Return the web socket."""
         return self._ws
 
@@ -179,7 +180,7 @@ class WebSocketMonitor:
             if not self._disconnect:
                 try:
                     await self.new_connection()
-                except Exception as ex:  # pylint: disable=broad-except
+                except Exception as ex:  # pylint: disable=broad-except # noqa: BLE001
                     self._log_message(ex, True)
                 if not self._ws or self._ws.closed:
                     await asyncio.sleep(min(1 * 2**attempt + uniform(0, 1), 300))
@@ -206,7 +207,9 @@ class WebSocketMonitor:
         await cancel_task(self._monitor_task, self._receiver_task)
 
     def _log_message(
-        self, message: str | Exception | WSMessage, is_error: bool = False
+        self,
+        message: str | Exception | WSMessage | WSMessageTextBytes,
+        is_error: bool = False,
     ) -> None:
         """Log a message."""
         log_method = _LOGGER.error if is_error else _LOGGER.debug

rivian_python_client-2.0.0/PKG-INFO

@@ -1,49 +0,0 @@
-Metadata-Version: 2.4
-Name: rivian-python-client
-Version: 2.0.0
-Summary: Rivian API Client (Unofficial)
-License-Expression: MIT
-Author: Brian Retterer
-Author-email: bretterer@gmail.com
-Requires-Python: >=3.10
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Programming Language :: Python :: 3.14
-Provides-Extra: ble
-Requires-Dist: aiohttp (>=3.0.0)
-Requires-Dist: backports-strenum (>=1.2.4) ; python_version < "3.11"
-Requires-Dist: bleak (>=0.21) ; extra == "ble"
-Requires-Dist: cryptography (>=41.0.1)
-Requires-Dist: dbus-fast (>=2.11.0) ; (sys_platform == "linux") and (extra == "ble")
-Description-Content-Type: text/markdown
-
-# Python: Rivian API Client
-
-Currently a Work In Progress
-
-## Dependencies
-
-[Poetry](https://python-poetry.org/docs/)
-
-```
-curl -sSL https://install.python-poetry.org | python3 -
-```
-
-## Setup
-
-Install project dependencies into the poetry virtual environment and run pre-commit
-
-```
-poetry install --all-extras
-pre-commit install
-```
-
-## Run Tests
-
-```
-poetry run pytest
-```
-

rivian_python_client-2.0.0/README.md

@@ -1,26 +0,0 @@
-# Python: Rivian API Client
-
-Currently a Work In Progress
-
-## Dependencies
-
-[Poetry](https://python-poetry.org/docs/)
-
-```
-curl -sSL https://install.python-poetry.org | python3 -
-```
-
-## Setup
-
-Install project dependencies into the poetry virtual environment and run pre-commit
-
-```
-poetry install --all-extras
-pre-commit install
-```
-
-## Run Tests
-
-```
-poetry run pytest
-```

rivian_python_client-2.0.0/pyproject.toml

@@ -1,53 +0,0 @@
-[project]
-name = "rivian-python-client"
-description = "Rivian API Client (Unofficial)"
-license = "MIT"
-readme = "README.md"
-requires-python = ">=3.10"
-authors = [
-    { name = "Brian Retterer", email = "bretterer@gmail.com" },
-    { name = "J.R. Gutierrez", email = "jrgutier@gmail.com" },
-    { name = "Nathan Spencer", email = "natekspencer@gmail.com" },
-    { name = "Trevor Mack", email = "drummer8001@gmail.com" },
-]
-dependencies = [
-    "aiohttp (>=3.0.0)",
-    "cryptography (>=41.0.1)",
-    "backports-strenum (>=1.2.4) ; python_version < '3.11'",
-]
-dynamic = []
-version = "2.0.0"
-
-[project.optional-dependencies]
-ble = [
-    "bleak (>=0.21)",
-    "dbus-fast (>=2.11.0) ; sys_platform == 'linux'",
-]
-
-[tool.poetry]
-packages = [
-    { include = "rivian", from = "src" },
-]
-
-[tool.poetry.group.dev.dependencies]
-pytest = ">=7.1.2,<9.0.0"
-pytest-asyncio = ">=0.18.3,<1.3.0"
-python-dotenv = ">=0.20,<1.3"
-aresponses = ">=2.1.5,<4.0.0"
-mypy = ">=1.7.0,<2.0.0"
-ruff = ">=0.4,<0.15"
-pre-commit = "^4.1.0"
-
-[tool.poetry-dynamic-versioning]
-enable = false
-vcs = "git"
-style = "semver"
-pattern = "default-unprefixed"
-
-[tool.ruff.lint.isort]
-combine-as-imports = true
-split-on-trailing-comma = false
-
-[build-system]
-requires = ["poetry-core>=1.0.0", "poetry-dynamic-versioning"]
-build-backend = "poetry_dynamic_versioning.backend"