rivian-python-client 0.2.4__tar.gz → 1.0.1__tar.gz

{rivian_python_client-0.2.4 → rivian_python_client-1.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: rivian-python-client
-Version: 0.2.4
+Version: 1.0.1
 Summary: Rivian API Client (Unofficial)
 License: MIT
 Author: Brian Retterer
@@ -12,7 +12,8 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Requires-Dist: aiohttp (>=3.0.0)
-Requires-Dist: yarl (>=1.6.0)
+Requires-Dist: backports-strenum (>=1.2.4,<2.0.0) ; python_version < "3.11"
+Requires-Dist: cryptography (>=41.0.1,<42.0.0)
 Description-Content-Type: text/markdown
 
 # Python: Rivian API Client

{rivian_python_client-0.2.4 → rivian_python_client-1.0.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "rivian-python-client"
-version = "0.2.4"
+version = "1.0.1"
 description = "Rivian API Client (Unofficial)"
 readme = "README.md"
 authors = ["Brian Retterer <bretterer@gmail.com>"]
@@ -12,17 +12,21 @@ packages = [
 [tool.poetry.dependencies]
 python = "^3.9"
 aiohttp = ">=3.0.0"
-yarl = ">=1.6.0"
+cryptography = "^41.0.1"
+backports-strenum = { version = "^1.2.4", python = "<3.11" } 
 
-[tool.poetry.dev-dependencies]
+[tool.poetry.group.dev.dependencies]
 pytest = "^7.1.2"
 pytest-asyncio = "^0.18.3"
 python-dotenv = "^0.20.0"
 aresponses = "^2.1.5"
 
+[tool.poetry-dynamic-versioning]
+enable = true
+vcs = "git"
+style = "semver"
+pattern = "default-unprefixed"
 
 [build-system]
-requires = ["poetry-core>=1.0.0"]
-build-backend = "poetry.core.masonry.api"
-
-
+requires = ["poetry-core>=1.0.0", "poetry-dynamic-versioning"]
+build-backend = "poetry_dynamic_versioning.backend"

{rivian_python_client-0.2.4 → rivian_python_client-1.0.1}/src/rivian/__init__.py

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

{rivian_python_client-0.2.4 → rivian_python_client-1.0.1}/src/rivian/const.py

@@ -1,8 +1,14 @@
 """Rivian constants."""
 from __future__ import annotations
 
+import sys
 from typing import Final
 
+if sys.version_info >= (3, 11):
+    from enum import StrEnum
+else:
+    from backports.strenum import StrEnum
+
 LIVE_SESSION_PROPERTIES: Final[set[str]] = {
     "chargerId",
     "currentCurrency",
@@ -120,3 +126,73 @@ VEHICLE_STATE_PROPERTIES: Final[set[str]] = {
     "windowRearRightClosed",
     "wiperFluidState",
 }
+
+
+class VehicleCommand(StrEnum):
+    """Supported vehicle commands."""
+
+    WAKE_VEHICLE = "WAKE_VEHICLE"
+    HONK_AND_FLASH_LIGHTS = "HONK_AND_FLASH_LIGHTS"
+    UNLOCK_USER_PREFERENCES_AND_DISABLE_ALARM = (
+        "UNLOCK_USER_PREFERENCES_AND_DISABLE_ALARM"
+    )
+
+    # Charging
+    CHARGING_LIMITS = "CHARGING_LIMITS"
+    START_CHARGING = "START_CHARGING"
+    STOP_CHARGING = "STOP_CHARGING"
+
+    # Climate
+    CABIN_HVAC_DEFROST_DEFOG = "CABIN_HVAC_DEFROST_DEFOG"
+    CABIN_HVAC_LEFT_SEAT_HEAT = "CABIN_HVAC_LEFT_SEAT_HEAT"
+    CABIN_HVAC_LEFT_SEAT_VENT = "CABIN_HVAC_LEFT_SEAT_VENT"
+    CABIN_HVAC_REAR_LEFT_SEAT_HEAT = "CABIN_HVAC_REAR_LEFT_SEAT_HEAT"
+    CABIN_HVAC_REAR_RIGHT_SEAT_HEAT = "CABIN_HVAC_REAR_RIGHT_SEAT_HEAT"
+    CABIN_HVAC_RIGHT_SEAT_HEAT = "CABIN_HVAC_RIGHT_SEAT_HEAT"
+    CABIN_HVAC_RIGHT_SEAT_VENT = "CABIN_HVAC_RIGHT_SEAT_VENT"
+    CABIN_HVAC_STEERING_HEAT = "CABIN_HVAC_STEERING_HEAT"
+    CABIN_PRECONDITIONING_SET_TEMP = "CABIN_PRECONDITIONING_SET_TEMP"
+    VEHICLE_CABIN_PRECONDITION_DISABLE = "VEHICLE_CABIN_PRECONDITION_DISABLE"
+    VEHICLE_CABIN_PRECONDITION_ENABLE = "VEHICLE_CABIN_PRECONDITION_ENABLE"
+
+    # Closures
+    LOCK_ALL_CLOSURES_FEEDBACK = "LOCK_ALL_CLOSURES_FEEDBACK"
+    UNLOCK_ALL_CLOSURES = "UNLOCK_ALL_CLOSURES"
+    UNLOCK_DRIVER_DOOR = "UNLOCK_DRIVER_DOOR"
+    UNLOCK_PASSENGER_DOOR = "UNLOCK_PASSENGER_DOOR"
+
+    # Frunk
+    CLOSE_FRUNK = "CLOSE_FRUNK"
+    OPEN_FRUNK = "OPEN_FRUNK"
+
+    # Gear guard
+    ENABLE_GEAR_GUARD = "ENABLE_GEAR_GUARD"
+    ENABLE_GEAR_GUARD_VIDEO = "ENABLE_GEAR_GUARD_VIDEO"
+    DISABLE_GEAR_GUARD = "DISABLE_GEAR_GUARD"
+    DISABLE_GEAR_GUARD_VIDEO = "DISABLE_GEAR_GUARD_VIDEO"
+
+    # Liftgate (R1S only)
+    CLOSE_LIFTGATE = "CLOSE_LIFTGATE"
+
+    # Liftgate/tailgate
+    OPEN_LIFTGATE_UNLATCH_TAILGATE = "OPEN_LIFTGATE_UNLATCH_TAILGATE"
+
+    # OTA
+    OTA_INSTALL_NOW_ACKNOWLEDGE = "OTA_INSTALL_NOW_ACKNOWLEDGE"
+
+    # Panic
+    PANIC_OFF = "PANIC_OFF"
+    PANIC_ON = "PANIC_ON"
+
+    # Side bin (R1T only)
+    RELEASE_LEFT_SIDE_BIN = "RELEASE_LEFT_SIDE_BIN"
+    RELEASE_RIGHT_SIDE_BIN = "RELEASE_RIGHT_SIDE_BIN"
+
+    # Tonneau (Only for R1T with powered tonneau)
+    CLOSE_TONNEAU_COVER = "CLOSE_TONNEAU_COVER"
+    OPEN_TONNEAU_COVER = "OPEN_TONNEAU_COVER"
+
+    # Windows
+    CLOSE_ALL_WINDOWS = "CLOSE_ALL_WINDOWS"
+    OPEN_ALL_WINDOWS = "OPEN_ALL_WINDOWS"
+    UNLOCK_ALL_AND_OPEN_WINDOWS = "UNLOCK_ALL_AND_OPEN_WINDOWS"

{rivian_python_client-0.2.4 → rivian_python_client-1.0.1}/src/rivian/exceptions.py

@@ -31,3 +31,11 @@ class RivianTemporarilyLockedError(RivianApiException):
 
 class RivianApiRateLimitError(RivianApiException):
     """Rivian API is being rate limited."""
+
+
+class RivianPhoneLimitReachedError(RivianApiException):
+    """Rivian phone limit has been reached."""
+
+
+class RivianBadRequestError(RivianApiException):
+    """Rivian API bad request."""

{rivian_python_client-0.2.4 → rivian_python_client-1.0.1}/src/rivian/rivian.py

@@ -2,34 +2,35 @@
 from __future__ import annotations
 
 import asyncio
-import json
 import logging
 import socket
+import time
 import uuid
 from collections.abc import Callable
 from typing import Any, Type
+from warnings import warn
 
 import aiohttp
 import async_timeout
-from aiohttp import ClientRequest, ClientResponse, ClientWebSocketResponse
+from aiohttp import ClientResponse, ClientWebSocketResponse
 
-from .const import LIVE_SESSION_PROPERTIES, VEHICLE_STATE_PROPERTIES
+from .const import LIVE_SESSION_PROPERTIES, VEHICLE_STATE_PROPERTIES, VehicleCommand
 from .exceptions import (
     RivianApiException,
     RivianApiRateLimitError,
+    RivianBadRequestError,
     RivianDataError,
-    RivianExpiredTokenError,
     RivianInvalidCredentials,
     RivianInvalidOTP,
+    RivianPhoneLimitReachedError,
     RivianTemporarilyLockedError,
     RivianUnauthenticated,
 )
+from .utils import generate_vehicle_command_hmac
 from .ws_monitor import WebSocketMonitor
 
 _LOGGER = logging.getLogger(__name__)
 
-CESIUM_BASEPATH = "https://cesium.rivianservices.com/v2"
-AUTH_BASEPATH = "https://auth.rivianservices.com/auth/api/v1"
 GRAPHQL_BASEPATH = "https://rivian.com/api/gql"
 GRAPHQL_GATEWAY = GRAPHQL_BASEPATH + "/gateway/graphql"
 GRAPHQL_CHARGING = GRAPHQL_BASEPATH + "/chrg/user/graphql"
@@ -60,6 +61,7 @@ VALUE_RECORD_TEMPLATE = "{ __typename value updatedAt }"
 
 ERROR_CODE_CLASS_MAP: dict[str, Type[RivianApiException]] = {
     "BAD_CURRENT_PASSWORD": RivianInvalidCredentials,
+    "BAD_REQUEST_ERROR": RivianBadRequestError,
     "DATA_ERROR": RivianDataError,
     "INTERNAL_SERVER_ERROR": RivianApiException,
     "RATE_LIMIT": RivianApiRateLimitError,
@@ -68,27 +70,40 @@ ERROR_CODE_CLASS_MAP: dict[str, Type[RivianApiException]] = {
 }
 
 
+def send_deprecation_warning(old_name: str, new_name: str) -> None:  # pragma: no cover
+    """Send a deprecation warning."""
+    message = f"{old_name} has been deprecated in favor of {new_name}, the alias will be removed in the future"
+    warn(
+        message,
+        DeprecationWarning,
+        stacklevel=2,
+    )
+    _LOGGER.warning(message)
+
+
 class Rivian:
     """Main class for the Rivian API Client"""
 
     def __init__(
         self,
-        client_id: str,
-        client_secret: str,
         request_timeout: int = 10,
         session: aiohttp.client.ClientSession | None = None,
+        *,
+        access_token: str = "",
+        refresh_token: str = "",
+        csrf_token: str = "",
+        app_session_token: str = "",
+        user_session_token: str = "",
     ) -> None:
         self._session = session
         self._close_session = False
-        self._session_token = ""
-        self._access_token = ""
-        self._refresh_token = ""
-        self._csrf_token = ""
-        self._app_session_token = ""
-        self._user_session_token = ""
-
-        self.client_id = client_id
-        self.client_secret = client_secret
+
+        self._access_token = access_token
+        self._refresh_token = refresh_token
+        self._csrf_token = csrf_token
+        self._app_session_token = app_session_token
+        self._user_session_token = user_session_token
+
         self.request_timeout = request_timeout
 
         self._otp_needed = False
@@ -97,242 +112,7 @@ class Rivian:
         self._ws_monitor: WebSocketMonitor | None = None
         self._subscriptions: dict[str, str] = {}
 
-    async def authenticate(
-        self,
-        username: str,
-        password: str,
-    ) -> ClientResponse | dict[str, str]:
-        """Authenticate against the Rivian API with Username and Password"""
-        url = AUTH_BASEPATH + "/token/auth"
-
-        headers = {**BASE_HEADERS}
-
-        json_data = {
-            "grant_type": "password",
-            "username": username,
-            "client_id": self.client_id,
-            "client_secret": self.client_secret,
-            "pwd": password,
-        }
-
-        if self._session is None:
-            self._session = aiohttp.ClientSession()
-            self._close_session = True
-
-        try:
-            async with async_timeout.timeout(self.request_timeout):
-                response = await self._session.request(
-                    "POST",
-                    url,
-                    json=json_data,
-                    headers=headers,
-                )
-        except asyncio.TimeoutError as exception:
-            raise Exception(
-                "Timeout occurred while connecting to Rivian API."
-            ) from exception
-        except (aiohttp.ClientError, socket.gaierror) as exception:
-            raise Exception(
-                "Error occurred while communicating with Rivian."
-            ) from exception
-
-        content_type = response.headers.get("Content-Type", "")
-
-        if response.status == 401:
-            self._otp_needed = True
-            response_json = await response.json()
-            self._session_token = response_json["session_token"]
-            return response
-
-        if response.status // 100 in [4, 5]:
-            contents = await response.read()
-            response.close()
-
-            if content_type == "application/json":
-                raise Exception(response.status, json.loads(contents.decode("utf8")))
-            raise Exception(response.status, {"message": contents.decode("utf8")})
-
-        if "application/json" in content_type:
-            response_json = await response.json()
-            self._access_token = response_json["access_token"]
-            self._refresh_token = response_json["refresh_token"]
-            return response
-
-        text = await response.text()
-        return {"message": text}
-
-    async def validate_otp(
-        self,
-        username: str,
-        otp: str,
-    ) -> dict[str, Any]:
-        """Validate the OTP"""
-        url = AUTH_BASEPATH + "/token/auth"
-
-        headers = BASE_HEADERS | {"Authorization": "Bearer " + self._session_token}
-
-        json_data = {
-            "grant_type": "password",
-            "username": username,
-            "client_id": self.client_id,
-            "client_secret": self.client_secret,
-            "otp_token": otp,
-        }
-
-        if self._session is None:
-            self._session = aiohttp.ClientSession()
-            self._close_session = True
-
-        try:
-            async with async_timeout.timeout(self.request_timeout):
-                response = await self._session.request(
-                    "POST",
-                    url,
-                    json=json_data,
-                    headers=headers,
-                )
-        except asyncio.TimeoutError as exception:
-            raise Exception(
-                "Timeout occurred while connecting to Rivian API."
-            ) from exception
-        except (aiohttp.ClientError, socket.gaierror) as exception:
-            raise Exception(
-                "Error occurred while communicating with Rivian."
-            ) from exception
-
-        content_type = response.headers.get("Content-Type", "")
-
-        if response.status // 100 in [4, 5]:
-            contents = await response.read()
-            response.close()
-
-            if content_type == "application/json":
-                raise Exception(response.status, json.loads(contents.decode("utf8")))
-            raise Exception(response.status, {"message": contents.decode("utf8")})
-
-        if "application/json" in content_type:
-            response_json = await response.json()
-            self._access_token = response_json["access_token"]
-            self._refresh_token = response_json["refresh_token"]
-            return response
-
-        text = await response.text()
-        return {"message": text}
-
-    async def refresh_access_token(
-        self,
-        refresh_token: str,
-        client_id: str,
-        client_secret: str,
-    ) -> ClientRequest:
-        """Validate the OTP"""
-        url = AUTH_BASEPATH + "/token/refresh"
-
-        headers = {**BASE_HEADERS}
-
-        json_data = {
-            "token": refresh_token,
-            "client_id": client_id,
-            "client_secret": client_secret,
-        }
-
-        if self._session is None:
-            self._session = aiohttp.ClientSession()
-            self._close_session = True
-
-        try:
-            async with async_timeout.timeout(self.request_timeout):
-                response = await self._session.request(
-                    "POST",
-                    url,
-                    json=json_data,
-                    headers=headers,
-                )
-        except asyncio.TimeoutError as exception:
-            raise Exception(
-                "Timeout occurred while connecting to Rivian API."
-            ) from exception
-        except (aiohttp.ClientError, socket.gaierror) as exception:
-            raise Exception(
-                "Error occurred while communicating with Rivian."
-            ) from exception
-
-        content_type = response.headers.get("Content-Type", "")
-
-        if response.status // 100 in [4, 5]:
-            contents = await response.read()
-            response.close()
-
-            if content_type == "application/json":
-                raise Exception(
-                    response.status, json.loads(contents.decode("utf8")), json_data
-                )
-            raise Exception(response.status, {"message": contents.decode("utf8")})
-
-        if "application/json" in content_type:
-            response_json = await response.json()
-            self._access_token = response_json["access_token"]
-            return response
-
-        return response
-
-    async def get_vehicle_info(
-        self, vin: str, access_token: str, properties: dict[str]
-    ) -> dict[str, Any]:
-        """get the vehicle info"""
-        url = CESIUM_BASEPATH + "/vehicle/latest"
-
-        headers = BASE_HEADERS | {"Authorization": "Bearer " + access_token}
-
-        json_data = {
-            "car": vin,
-            "properties": properties,
-        }
-
-        if self._session is None:
-            self._session = aiohttp.ClientSession()
-            self._close_session = True
-
-        try:
-            async with async_timeout.timeout(self.request_timeout):
-                response = await self._session.request(
-                    "POST",
-                    url,
-                    json=json_data,
-                    headers=headers,
-                )
-        except asyncio.TimeoutError as exception:
-            raise Exception(
-                "Timeout occurred while connecting to Rivian API."
-            ) from exception
-        except (aiohttp.ClientError, socket.gaierror) as exception:
-            raise Exception(
-                "Error occurred while communicating with Rivian."
-            ) from exception
-
-        if response.status // 100 in [4, 5]:
-            contents = await response.read()
-            response.close()
-
-            response_json = await response.json()
-            if response.status == 401 and response_json["error_code"] == -40:
-                raise RivianExpiredTokenError(
-                    response.status,
-                    response_json,
-                    headers,
-                    json_data,
-                )
-
-            raise Exception(
-                response.status,
-                json.loads(contents.decode("utf8")),
-                headers,
-                json_data,
-            )
-
-        return response
-
-    async def create_csrf_token(self) -> dict[str, Any]:
+    async def create_csrf_token(self) -> None:
         """Create cross-site-request-forgery (csrf) token."""
         url = GRAPHQL_GATEWAY
 
@@ -352,13 +132,7 @@ class Rivian:
         self._csrf_token = csrf_data["csrfToken"]
         self._app_session_token = csrf_data["appSessionToken"]
 
-        return response
-
-    async def authenticate_graphql(
-        self,
-        username: str,
-        password: str,
-    ) -> dict[str, Any]:
+    async def authenticate(self, username: str, password: str) -> None:
         """Authenticate against the Rivian GraphQL API with Username and Password"""
         url = GRAPHQL_GATEWAY
 
@@ -389,9 +163,17 @@ class Rivian:
             self._refresh_token = login_data["refreshToken"]
             self._user_session_token = login_data["userSessionToken"]
 
-        return response
+    async def authenticate_graphql(
+        self, username: str, password: str
+    ) -> None:  # pragma: no cover
+        """### DEPRECATED (use `authenticate` instead)
 
-    async def validate_otp_graphql(self, username: str, otpCode: str) -> dict[str, Any]:
+        Authenticate against the Rivian GraphQL API with Username and Password.
+        """
+        send_deprecation_warning("authenticate_graphql", "authenticate")
+        return await self.authenticate(username=username, password=password)
+
+    async def validate_otp(self, username: str, otp_code: str) -> None:
         """Validates OTP against the Rivian GraphQL API with Username, OTP Code, and OTP Token"""
         url = GRAPHQL_GATEWAY
 
@@ -406,7 +188,7 @@ class Rivian:
             "query": "mutation LoginWithOTP($email: String!, $otpCode: String!, $otpToken: String!) {\n  loginWithOTP(email: $email, otpCode: $otpCode, otpToken: $otpToken) {\n    __typename\n    ... on MobileLoginResponse {\n      __typename\n      accessToken\n      refreshToken\n      userSessionToken\n    }\n  }\n}",
             "variables": {
                 "email": username,
-                "otpCode": otpCode,
+                "otpCode": otp_code,
                 "otpToken": self._otp_token,
             },
         }
@@ -421,10 +203,79 @@ class Rivian:
         self._refresh_token = login_data["refreshToken"]
         self._user_session_token = login_data["userSessionToken"]
 
-        return response
+    async def validate_otp_graphql(
+        self, username: str, otpCode: str
+    ) -> None:  # pragma: no cover
+        """### DEPRECATED (use `validate_otp` instead)
+
+        Validates OTP against the Rivian GraphQL API with Username, OTP Code, and OTP Token.
+        """
+        send_deprecation_warning("validate_otp_graphql", "validate_otp")
+        return await self.validate_otp(username=username, otp_code=otpCode)
+
+    async def disenroll_phone(self, identity_id: str) -> bool:
+        """Disenroll a phone."""
+        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": "DisenrollPhone",
+            "variables": {"attrs": {"enrollmentId": identity_id}},
+            "query": "mutation DisenrollPhone($attrs: DisenrollPhoneAttributes!) { disenrollPhone(attrs: $attrs) { __typename success } }",
+        }
+
+        response = await self.__graphql_query(headers, url, graphql_json)
+        if response.status == 200:
+            data = await response.json()
+            return data.get("data", {}).get("disenrollPhone", {}).get("success")
+        return False
 
-    async def get_user_information(self) -> ClientResponse:
-        """get user information (user.id, vehicle vins)"""
+    async def enroll_phone(
+        self,
+        user_id: str,
+        vehicle_id: str,
+        device_type: str,
+        device_name: str,
+        public_key: str,
+    ) -> bool:
+        """Enable control of a vehicle by enrolling a phone.
+
+        To generate a public/private key for enrollment, use the `utils.generate_key_pair` function.
+        The private key will need to be retained to sign commands sent via the `send_vehicle_command` method.
+        """
+        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": "EnrollPhone",
+            "variables": {
+                "attrs": {
+                    "userId": user_id,
+                    "vehicleId": vehicle_id,
+                    "publicKey": public_key,
+                    "type": device_type,
+                    "name": device_name,
+                }
+            },
+            "query": "mutation EnrollPhone($attrs: EnrollPhoneAttributes!) { enrollPhone(attrs: $attrs) { __typename success } }",
+        }
+        response = await self.__graphql_query(headers, url, graphql_json)
+        if response.status == 200:
+            data = await response.json()
+            if data.get("data", {}).get("enrollPhone", {}).get("success"):
+                return True
+        return False
+
+    async def get_user_information(
+        self, include_phones: bool = False
+    ) -> ClientResponse:
+        """Get user information."""
         url = GRAPHQL_GATEWAY
 
         headers = BASE_HEADERS | {
@@ -432,16 +283,19 @@ class Rivian:
             "U-Sess": self._user_session_token,
         }
 
+        vehicles_fragment = "vehicles { id vin name vas { __typename vasVehicleId vehiclePublicKey } roles state createdAt updatedAt vehicle { __typename id vin modelYear make model expectedBuildDate plannedBuildDate expectedGeneralAssemblyStartDate actualGeneralAssemblyDate } }"
+        phones_fragment = "enrolledPhones { __typename vas { __typename vasPhoneId publicKey } enrolled { __typename deviceType deviceName vehicleId identityId shortName } }"
+
         graphql_json = {
             "operationName": "getUserInfo",
-            "query": "query getUserInfo {\n    currentUser {\n        __typename\n        id\n        vehicles {\n        id\n        vin\n        name\n        vas {\n            __typename\n            vasVehicleId\n            vehiclePublicKey\n        }\n        roles\n        state\n        createdAt\n        updatedAt\n        vehicle {\n            __typename\n            id\n            vin\n            modelYear\n            make\n            model\n            expectedBuildDate\n            plannedBuildDate\n            expectedGeneralAssemblyStartDate\n            actualGeneralAssemblyDate\n        }\n        }\n    }\n}",
+            "query": f"query getUserInfo {{ currentUser {{ __typename id {vehicles_fragment} {phones_fragment if include_phones else ''} }} }}",
             "variables": None,
         }
 
         return await self.__graphql_query(headers, url, graphql_json)
 
     async def get_registered_wallboxes(self) -> ClientResponse:
-        """get wallboxes (graphql)"""
+        """Get registered wallboxes."""
         url = GRAPHQL_CHARGING
 
         headers = BASE_HEADERS | {
@@ -458,8 +312,69 @@ class Rivian:
 
         return await self.__graphql_query(headers, url, graphql_json)
 
-    async def get_vehicle_state(self, vin: str, properties: set[str]) -> ClientResponse:
-        """get vehicle state (graphql)"""
+    async def get_vehicle_command_state(self, command_id: str) -> ClientResponse:
+        """Get vehicle command state."""
+        url = GRAPHQL_GATEWAY
+
+        headers = BASE_HEADERS | {
+            "A-Sess": self._app_session_token,
+            "U-Sess": self._user_session_token,
+        }
+
+        graphql_query = "query getVehicleCommand($id: String!) { getVehicleCommand(id: $id) { __typename id command createdAt state responseCode statusCode } }"
+
+        graphql_json = {
+            "operationName": "getVehicleCommand",
+            "query": graphql_query,
+            "variables": {"id": command_id},
+        }
+
+        return await self.__graphql_query(headers, url, graphql_json)
+
+    async def get_vehicle_images(
+        self,
+        *,
+        extension: str | None = None,
+        resolution: str | None = None,
+        vehicle_version: str | None = None,
+        preorder_version: str | None = None,
+    ) -> ClientResponse:
+        """Get vehicle images.
+
+        Known parameter values:
+          - extension: `png`, `webp`
+          - resolution: `@1x`, `@2x`, `@3x` (for png); `hdpi`, `xhdpi`, `xxhdpi`, `xxxhdpi` (for webp)
+          - vehicle_version/preorder_version: `1`, `2` (all other values return v1 images)
+        """
+        url = GRAPHQL_GATEWAY
+
+        headers = BASE_HEADERS | {
+            "A-Sess": self._app_session_token,
+            "U-Sess": self._user_session_token,
+        }
+
+        graphql_query = "query getVehicleImages( $extension: String $resolution: String $versionForVehicle: String $versionForPreOrder: String ) { getVehicleOrderMobileImages( resolution: $resolution extension: $extension version: $versionForPreOrder ) { ...image } getVehicleMobileImages( resolution: $resolution extension: $extension version: $versionForVehicle ) { ...image } } fragment image on VehicleMobileImage { orderId vehicleId url extension resolution size design placement }"
+
+        graphql_json = {
+            "operationName": "getVehicleImages",
+            "query": graphql_query,
+            "variables": {
+                "extension": extension,
+                "resolution": resolution,
+                "versionForVehicle": vehicle_version,
+                "versionForPreOrder": preorder_version,
+            },
+        }
+
+        return await self.__graphql_query(headers, url, graphql_json)
+
+    async def get_vehicle_state(
+        self, vin: str, properties: set[str] | None = None
+    ) -> ClientResponse:
+        """Get vehicle state."""
+        if not properties:
+            properties = VEHICLE_STATE_PROPERTIES
+
         url = GRAPHQL_GATEWAY
 
         headers = BASE_HEADERS | {
@@ -509,11 +424,112 @@ class Rivian:
 
         return await self.__graphql_query(headers, url, graphql_json)
 
+    def _validate_vehicle_command(
+        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 in (
+            VehicleCommand.CABIN_HVAC_DEFROST_DEFOG,
+            VehicleCommand.CABIN_HVAC_LEFT_SEAT_HEAT,
+            VehicleCommand.CABIN_HVAC_LEFT_SEAT_VENT,
+            VehicleCommand.CABIN_HVAC_REAR_LEFT_SEAT_HEAT,
+            VehicleCommand.CABIN_HVAC_REAR_RIGHT_SEAT_HEAT,
+            VehicleCommand.CABIN_HVAC_RIGHT_SEAT_HEAT,
+            VehicleCommand.CABIN_HVAC_RIGHT_SEAT_VENT,
+            VehicleCommand.CABIN_HVAC_STEERING_HEAT,
+        ):
+            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"
+                )
+        if command == VehicleCommand.CABIN_PRECONDITIONING_SET_TEMP:
+            if not (
+                params
+                and isinstance((temp := params.get("HVAC_set_temp")), (float, int))
+                and (16 <= temp <= 29 or temp in (0, 63.5))
+            ):
+                raise RivianBadRequestError(
+                    "HVAC setting must include parameter `HVAC_set_temp` with a valid value between 16 and 29 or 0/63.5 for LO/HI, respectively"
+                )
+            params["HVAC_set_temp"] = str(params["HVAC_set_temp"])
+
+    async def send_vehicle_command(
+        self,
+        command: VehicleCommand | str,
+        vehicle_id: str,
+        phone_id: str,
+        identity_id: str,
+        vehicle_key: str,
+        private_key: str,
+        *,
+        params: dict[str, Any] | None = None,
+    ) -> str | None:
+        """Send a command to the vehicle.
+
+        To generate a public/private key for commands, use the `utils.generate_key_pair` function.
+        The public key will first need to be enrolled via the `enroll_phone` method, otherwise commands will fail.
+
+        Certain commands may require additional details via the `params` mapping.
+        Some known examples include:
+          - `CABIN_HVAC_*`: params = {"level": 0..4} where 0 is off, 1 is on, 2 is low/level_1, 3 is medium/level_2 and 4 is high/level_3
+          - `CABIN_PRECONDITIONING_SET_TEMP`: params = {"HVAC_set_temp": "deg_C"} where `deg_C` is a string value between 16 and 29 or 0/63.5 for LO/HI, respectively
+          - `CHARGING_LIMITS`: params = {"SOC_limit": 50..100}
+        """
+        self._validate_vehicle_command(command, params)
+
+        command = str(command)
+        timestamp = str(int(time.time()))
+        hmac = generate_vehicle_command_hmac(
+            command, timestamp, vehicle_key, private_key
+        )
+
+        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": "sendVehicleCommand",
+            "variables": {
+                "attrs": {
+                    "command": command,
+                    "hmac": hmac,
+                    "timestamp": str(timestamp),
+                    "vasPhoneId": phone_id,
+                    "deviceId": identity_id,
+                    "vehicleId": vehicle_id,
+                }
+                | ({"params": params} if params else {})
+            },
+            "query": "mutation sendVehicleCommand($attrs: VehicleCommandAttributes!) { sendVehicleCommand(attrs: $attrs) { __typename id command state } }",
+        }
+
+        response = await self.__graphql_query(headers, url, graphql_json)
+        if response.status == 200:
+            data = await response.json()
+            if status := data.get("data", {}).get("sendVehicleCommand", {}):
+                return status.get("id")
+        return None
+
     async def subscribe_for_vehicle_updates(
         self,
         vehicle_id: str,
+        callback: Callable[[dict[str, Any]], None],
         properties: set[str] | None = None,
-        callback: Callable = None,
     ) -> Callable | None:
         """Open a web socket connection to receive updates."""
         if not properties:
@@ -521,6 +537,7 @@ class Rivian:
 
         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 = {
@@ -533,6 +550,7 @@ class Rivian:
             return unsubscribe
         except Exception as ex:  # pylint: disable=broad-except
             _LOGGER.error(ex)
+            return None
 
     async def _ws_connect(self) -> ClientWebSocketResponse:
         """Initiate a websocket connection."""
@@ -557,12 +575,15 @@ class Rivian:
         ws_monitor = self._ws_monitor
         if ws_monitor.websocket is None or ws_monitor.websocket.closed:
             await ws_monitor.new_connection(True)
+            assert ws_monitor.websocket
         if ws_monitor.monitor is None or ws_monitor.monitor.done():
             await ws_monitor.start_monitor()
         return ws_monitor.websocket
 
-    async def __graphql_query(self, headers: dict(str, str), url: str, body: str):
-        """execute and return arbitrary graphql query"""
+    async def __graphql_query(
+        self, headers: dict[str, str], url: str, body: dict[str, Any]
+    ) -> ClientResponse:
+        """Execute and return arbitrary graphql query."""
         if self._session is None:
             self._session = aiohttp.ClientSession()
             self._close_session = True
@@ -590,14 +611,22 @@ class Rivian:
                 for error in errors:
                     if extensions := error.get("extensions"):
                         code = extensions["code"]
-                        if err_cls := ERROR_CODE_CLASS_MAP.get(code):
-                            raise err_cls(response.status, response_json, headers, body)
-                        if code == "BAD_USER_INPUT" and (
-                            extensions["reason"] == "INVALID_OTP"
+                        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,

rivian_python_client-1.0.1/src/rivian/utils.py

@@ -0,0 +1,90 @@
+"""Utilities."""
+from __future__ import annotations
+
+import hashlib
+import hmac
+from base64 import b64decode, b64encode
+from typing import cast
+
+from cryptography.hazmat.primitives import hashes, serialization
+from cryptography.hazmat.primitives.asymmetric import ec
+from cryptography.hazmat.primitives.kdf.hkdf import HKDF
+
+
+def base64_encode(data: bytes) -> str:
+    """Encode bytes to Base64 string"""
+    return b64encode(data).decode("utf-8")
+
+
+def decode_private_key(private_key_str: str) -> ec.EllipticCurvePrivateKey:
+    """Decode an EC private key."""
+    key = serialization.load_pem_private_key(b64decode(private_key_str), password=None)
+    return cast(ec.EllipticCurvePrivateKey, key)
+
+
+def decode_public_key(public_key_str) -> ec.EllipticCurvePublicKey:
+    """Decode an EC public key."""
+    return ec.EllipticCurvePublicKey.from_encoded_point(
+        ec.SECP256R1(), bytes.fromhex(public_key_str)
+    )
+
+
+def encode_private_key(private_key: ec.EllipticCurvePrivateKey) -> str:
+    """Encode an EC public key."""
+    return base64_encode(
+        private_key.private_bytes(
+            encoding=serialization.Encoding.PEM,
+            format=serialization.PrivateFormat.PKCS8,
+            encryption_algorithm=serialization.NoEncryption(),
+        )
+    )
+
+
+def encode_public_key(public_key: ec.EllipticCurvePublicKey) -> str:
+    """Encode an EC public key."""
+    return public_key.public_bytes(
+        encoding=serialization.Encoding.X962,
+        format=serialization.PublicFormat.UncompressedPoint,
+    ).hex()
+
+
+def generate_key_pair() -> tuple[str, str]:
+    """Generate an ECDH public-private key pair.
+
+    Copied from https://rivian-api.kaedenb.org/app/controls/enroll-phone/
+    """
+    # Generate a private key
+    private_key = ec.generate_private_key(ec.SECP256R1())
+
+    # Get the corresponding public key
+    public_key = private_key.public_key()
+
+    # Serialize the keys in the standard format
+    private_key_str = encode_private_key(private_key)
+    public_key_str = encode_public_key(public_key)
+
+    # Return the public-private key pair as strings
+    return (public_key_str, private_key_str)
+
+
+def generate_vehicle_command_hmac(
+    command: str, timestamp: str, vehicle_key: str, private_key: str
+):
+    """Generate vehicle command hmac."""
+    message = (command + timestamp).encode("utf-8")
+    secret_key = get_secret_key(private_key, vehicle_key)
+    return get_message_signature(secret_key, message)
+
+
+def get_message_signature(secret_key: bytes, message: bytes) -> str:
+    """Get message signature."""
+    return hmac.new(secret_key, message, hashlib.sha256).hexdigest()
+
+
+def get_secret_key(private_key_str: str, public_key_str: str) -> bytes:
+    """Get HKDF derived secrety key from private/public key pair."""
+    private_key = decode_private_key(private_key_str)
+    public_key = decode_public_key(public_key_str)
+    secret = private_key.exchange(ec.ECDH(), public_key)
+    hkdf = HKDF(algorithm=hashes.SHA256(), length=32, salt=None, info=b"")
+    return hkdf.derive(secret)

{rivian_python_client-0.2.4 → rivian_python_client-1.0.1}/src/rivian/ws_monitor.py

@@ -11,7 +11,7 @@ from typing import TYPE_CHECKING, Any
 from uuid import uuid4
 
 import async_timeout
-from aiohttp import ClientWebSocketResponse, WSMsgType
+from aiohttp import ClientWebSocketResponse, WSMessage, WSMsgType
 
 if TYPE_CHECKING:
     from .rivian import Rivian
@@ -81,6 +81,7 @@ class WebSocketMonitor:
         await cancel_task(self._receiver_task)
         self._disconnect = False
         # pylint: disable=protected-access
+        assert self._account._session
         self._ws = await self._account._session.ws_connect(
             url=self._url, headers={"sec-websocket-protocol": "graphql-transport-ws"}
         )
@@ -94,7 +95,7 @@ class WebSocketMonitor:
     ) -> Callable[[], Awaitable[None]] | None:
         """Start a subscription."""
         if not self.connected:
-            return
+            return None
         _id = str(uuid4())
         self._subscriptions[_id] = (callback, payload)
         await self._subscribe(_id, payload)
@@ -104,12 +105,14 @@ class WebSocketMonitor:
             if _id in self._subscriptions:
                 del self._subscriptions[_id]
                 if self.connected:
+                    assert self._ws
                     await self._ws.send_json({"id": _id, "type": "complete"})
 
         return unsubscribe
 
     async def _subscribe(self, _id: str, payload: dict[str, Any]) -> None:
         """Send a subscribe request."""
+        assert self._ws
         await self._ws.send_json({"id": _id, "payload": payload, "type": "subscribe"})
 
     async def _resubscribe_all(self) -> None:
@@ -142,8 +145,7 @@ class WebSocketMonitor:
                         self._connection_ack.set()
                     elif data_type == "next":
                         if (_id := data.get("id")) in self._subscriptions:
-                            if callback := self._subscriptions[_id][0]:
-                                callback(data)
+                            self._subscriptions[_id][0](data)
                     else:
                         self._log_message(msg)
                 elif msg.type == WSMsgType.ERROR:
@@ -159,7 +161,8 @@ class WebSocketMonitor:
         attempt = 0
         while not self._disconnect:
             while self.connected:
-                if self._receiver_task.done():  # Need to restart the receiver
+                if self._receiver_task and self._receiver_task.done():
+                    # Need to restart the receiver
                     self._receiver_task = asyncio.ensure_future(self._receiver())
                 await asyncio.sleep(1)
             if not self._disconnect:
@@ -191,7 +194,9 @@ class WebSocketMonitor:
             await self._ws.close()
         await cancel_task(self._monitor_task, self._receiver_task)
 
-    def _log_message(self, message: str | Exception, is_error: bool = False) -> None:
+    def _log_message(
+        self, message: str | Exception | WSMessage, is_error: bool = False
+    ) -> None:
         """Log a message."""
         log_method = _LOGGER.error if is_error else _LOGGER.debug
         log_method(message)