tesla-fleet-api 1.0.2__py3-none-any.whl → 1.0.4__py3-none-any.whl

tesla_fleet_api/const.py

@@ -3,7 +3,7 @@
 from enum import Enum
 import logging
 
-VERSION = "1.0.2"
+VERSION = "1.0.4"
 LOGGER = logging.getLogger(__package__)
 SERVERS = {
     "na": "https://fleet-api.prd.na.vn.cloud.tesla.com",
@@ -159,3 +159,17 @@ class TeslaEnergyPeriod(StrEnum):
     MONTH = "month"
     YEAR = "year"
     LIFETIME = "lifetime"
+
+class BluetoothVehicleData(StrEnum):
+    CHARGE_STATE = "GetChargeState"
+    CLIMATE_STATE = "GetClimateState"
+    DRIVE_STATE = "GetDriveState"
+    LOCATION_STATE = "GetLocationState"
+    CLOSURES_STATE = "GetClosuresState"
+    CHARGE_SCHEDULE_STATE = "GetChargeScheduleState"
+    PRECONDITIONING_SCHEDULE_STATE = "GetPreconditioningScheduleState"
+    TIRE_PRESSURE_STATE = "GetTirePressureState"
+    MEDIA_STATE = "GetMediaState"
+    MEDIA_DETAIL_STATE = "GetMediaDetailState"
+    SOFTWARE_UPDATE_STATE = "GetSoftwareUpdateState"
+    PARENTAL_CONTROLS_STATE = "GetParentalControlsState"

tesla_fleet_api/exceptions.py

@@ -656,6 +656,26 @@ class TeslaFleetMessageFaultResponseSizeExceedsMTU(TeslaFleetMessageFault):
     message = "Client's request was received, but response size exceeded MTU"
     code = 25
 
+class TeslaFleetMessageFaultRepeatedCounter(TeslaFleetMessageFault):
+    """The vehicle has seen this counter value before. Reset the counter and try again"""
+
+    message = "The vehicle has seen this counter value before. Reset the counter and try again"
+    code = 26
+
+
+class TeslaFleetMessageFaultInvalidKeyHandle(TeslaFleetMessageFault):
+    """The key handle is not valid. The key may have been revoked or expired"""
+
+    message = "The key handle is not valid. The key may have been revoked or expired"
+    code = 27
+
+
+class TeslaFleetMessageFaultRequiresResponseEncryption(TeslaFleetMessageFault):
+    """The response requires encryption but encryption was not requested"""
+
+    message = "The response requires encryption but encryption was not requested"
+    code = 28
+
 
 MESSAGE_FAULTS = [
     None,
@@ -684,9 +704,9 @@ MESSAGE_FAULTS = [
     TeslaFleetMessageFaultCommandRequiresAccountCredentials,
     TeslaFleetMessageFaultFieldExceedsMTU,
     TeslaFleetMessageFaultResponseSizeExceedsMTU,
-    None,
-    None,
-    None,
+    TeslaFleetMessageFaultRepeatedCounter,
+    TeslaFleetMessageFaultInvalidKeyHandle,
+    TeslaFleetMessageFaultRequiresResponseEncryption,
 ]
 
 class SignedMessageInformationFault(TeslaFleetError):

tesla_fleet_api/tesla/bluetooth.py

@@ -2,6 +2,9 @@
 
 import hashlib
 import re
+from google.protobuf.json_format import MessageToJson, MessageToDict
+from bleak.backends.device import BLEDevice
+from cryptography.hazmat.primitives.asymmetric import ec
 
 from tesla_fleet_api.tesla.tesla import Tesla
 from tesla_fleet_api.tesla.vehicle.bluetooth import VehicleBluetooth
@@ -36,8 +39,16 @@ class Vehicles(dict[str, VehicleBluetooth]):
         """Creates a specific vehicle."""
         return self.createBluetooth(vin)
 
-    def createBluetooth(self, vin: str) -> VehicleBluetooth:
+    def createBluetooth(self, vin: str, key: ec.EllipticCurvePrivateKey | None = None, device: None | str | BLEDevice = None) -> VehicleBluetooth:
         """Creates a specific vehicle."""
-        vehicle = VehicleBluetooth(self._parent, vin)
+        vehicle = VehicleBluetooth(self._parent, vin, key, device)
         self[vin] = vehicle
         return vehicle
+
+def toJson(message) -> str:
+    """Convert a protobuf message to JSON."""
+    return MessageToJson(message, preserving_proto_field_name=True)
+
+def toDict(message) -> dict:
+    """Convert a protobuf message to a dictionary."""
+    return MessageToDict(message, preserving_proto_field_name=True)

tesla_fleet_api/tesla/partner.py

@@ -1,5 +1,5 @@
 from typing import Any
-from ..const import Method
+from tesla_fleet_api.const import Method
 
 
 class Partner:

tesla_fleet_api/tesla/vehicle/bluetooth.py

@@ -1,10 +1,10 @@
 from __future__ import annotations
 
 import hashlib
-from asyncio import Future, get_running_loop
+import asyncio
 from typing import TYPE_CHECKING
 from google.protobuf.message import DecodeError
-
+from bleak_retry_connector import establish_connection, MAX_CONNECT_ATTEMPTS
 from bleak import BleakClient, BleakScanner
 from bleak.backends.characteristic import BleakGATTCharacteristic
 from bleak.backends.device import BLEDevice
@@ -16,19 +16,30 @@ from tesla_fleet_api.tesla.vehicle.commands import Commands
 
 from tesla_fleet_api.const import (
     LOGGER,
+    BluetoothVehicleData
 )
 from tesla_fleet_api.exceptions import (
-    MESSAGE_FAULTS,
     WHITELIST_OPERATION_STATUS,
     WhitelistOperationStatus,
 )
 
 # Protocol
 from tesla_fleet_api.tesla.vehicle.proto.car_server_pb2 import (
-    Response,
-)
-from tesla_fleet_api.tesla.vehicle.proto.signatures_pb2 import (
-    SessionInfo,
+    Action,
+    VehicleAction,
+    GetVehicleData,
+    GetChargeState,
+    GetClimateState,
+    GetDriveState,
+    GetLocationState,
+    GetClosuresState,
+    GetChargeScheduleState,
+    GetPreconditioningScheduleState,
+    GetTirePressureState,
+    GetMediaState,
+    GetMediaDetailState,
+    GetSoftwareUpdateState,
+    GetParentalControlsState,
 )
 from tesla_fleet_api.tesla.vehicle.proto.universal_message_pb2 import (
     Destination,
@@ -37,15 +48,18 @@ from tesla_fleet_api.tesla.vehicle.proto.universal_message_pb2 import (
 )
 from tesla_fleet_api.tesla.vehicle.proto.vcsec_pb2 import (
     FromVCSECMessage,
+    InformationRequest,
+    InformationRequestType,
     KeyFormFactor,
     KeyMetadata,
     PermissionChange,
     PublicKey,
     RKEAction_E,
     UnsignedMessage,
+    VehicleStatus,
     WhitelistOperation,
-
 )
+from tesla_fleet_api.tesla.vehicle.proto.vehicle_pb2 import ChargeScheduleState, ChargeState, ClimateState, ClosuresState, DriveState, LocationState, MediaDetailState, MediaState, ParentalControlsState, PreconditioningScheduleState, SoftwareUpdateState, TirePressureState, VehicleData
 
 SERVICE_UUID = "00000211-b2d1-43f0-9b88-960cebf8b91e"
 WRITE_UUID = "00000212-b2d1-43f0-9b88-960cebf8b91e"
@@ -63,42 +77,48 @@ class VehicleBluetooth(Commands):
     """Class describing the Tesla Fleet API vehicle endpoints and commands for a specific vehicle with command signing."""
 
     ble_name: str
+    device: BLEDevice
     client: BleakClient
-    _device: BLEDevice
-    _futures: dict[Domain, Future]
+    _queues: dict[Domain, asyncio.Queue]
     _ekey: ec.EllipticCurvePublicKey
     _recv: bytearray = bytearray()
     _recv_len: int = 0
     _auth_method = "aes"
 
     def __init__(
-        self, parent: Tesla, vin: str, key: ec.EllipticCurvePrivateKey | None = None
+        self, parent: Tesla, vin: str, key: ec.EllipticCurvePrivateKey | None = None, device: None | str | BLEDevice = None
     ):
         super().__init__(parent, vin, key)
         self.ble_name = "S" + hashlib.sha1(vin.encode('utf-8')).hexdigest()[:16] + "C"
-        self._futures = {}
-
-    async def find_client(self, scanner: BleakScanner = BleakScanner()) -> BleakClient:
+        self._queues = {
+            Domain.DOMAIN_VEHICLE_SECURITY: asyncio.Queue(),
+            Domain.DOMAIN_INFOTAINMENT: asyncio.Queue(),
+        }
+        if device is not None:
+            self.client = BleakClient(device, services=[SERVICE_UUID])
+
+    async def find_vehicle(self, name: str | None = None, address: str | None = None, scanner: BleakScanner = BleakScanner()) -> BLEDevice:
         """Find the Tesla BLE device."""
-
-        device = await scanner.find_device_by_name(self.ble_name)
+        if name is not None:
+            device = await scanner.find_device_by_name(name)
+        elif address is not None:
+            device = await scanner.find_device_by_address(address)
+        else:
+            device = await scanner.find_device_by_name(self.ble_name)
         if not device:
             raise ValueError(f"Device {self.ble_name} not found")
-        self._device = device
-        self.client = BleakClient(self._device, services=[SERVICE_UUID])
-        LOGGER.debug(f"Discovered device {self._device.name} {self._device.address}")
-        return self.client
+        self.device = device
+        return self.device
 
-    def create_client(self, mac:str) -> BleakClient:
-        """Create a client using a MAC address."""
-        self.client = BleakClient(mac, services=[SERVICE_UUID])
-        return self.client
+    def set_device(self, device: BLEDevice) -> None:
+        self.device = device
 
-    async def connect(self, mac:str | None = None) -> None:
+    def get_device(self) -> BLEDevice:
+        return self.device
+
+    async def connect(self, device: BLEDevice | None = None, max_attempts: int = MAX_CONNECT_ATTEMPTS) -> None:
         """Connect to the Tesla BLE device."""
-        if mac is not None:
-            self.create_client(mac)
-        await self.client.connect()
+        self.client = await establish_connection(BleakClient, self.device, self.vin, max_attempts=max_attempts, ble_device_callback=self.get_device)
         await self.client.start_notify(READ_UUID, self._on_notify)
 
     async def disconnect(self) -> bool:
@@ -114,7 +134,7 @@ class VehicleBluetooth(Commands):
         """Exit the async context."""
         await self.disconnect()
 
-    def _on_notify(self,sender: BleakGATTCharacteristic,data : bytearray) -> None:
+    async def _on_notify(self,sender: BleakGATTCharacteristic,data : bytearray) -> None:
         """Receive data from the Tesla BLE device."""
         if self._recv_len:
             self._recv += data
@@ -124,68 +144,55 @@ class VehicleBluetooth(Commands):
         LOGGER.debug(f"Received {len(self._recv)} of {self._recv_len} bytes")
         while len(self._recv) > self._recv_len:
             LOGGER.warn(f"Received more data than expected: {len(self._recv)} > {self._recv_len}")
-            self._on_message(bytes(self._recv[:self._recv_len]))
+            await self._on_message(bytes(self._recv[:self._recv_len]))
             self._recv_len = int.from_bytes(self._recv[self._recv_len:self._recv_len+2], 'big')
             self._recv = self._recv[self._recv_len+2:]
             continue
         if len(self._recv) == self._recv_len:
-            self._on_message(bytes(self._recv))
+            await self._on_message(bytes(self._recv))
             self._recv = bytearray()
             self._recv_len = 0
 
-    def _on_message(self, data:bytes) -> None:
+    async def _on_message(self, data:bytes) -> None:
         """Receive messages from the Tesla BLE data."""
         try:
             msg = RoutableMessage.FromString(data)
         except DecodeError as e:
             LOGGER.error(f"Error parsing message: {e}")
+            self._recv = bytearray()
+            self._recv_len = 0
             return
 
-        # Update Session
-        if(msg.session_info):
-            info = SessionInfo.FromString(msg.session_info)
-            LOGGER.debug(f"Received session info: {info}")
-            self._sessions[msg.from_destination.domain].update(info)
-
         if(msg.to_destination.routing_address != self._from_destination):
-            # Get the ephemeral key here and save to self._ekey
-            return
-
-        if(self._futures[msg.from_destination.domain]):
-            LOGGER.debug(f"Received response for request {msg.request_uuid}")
-            self._futures[msg.from_destination.domain].set_result(msg)
+            # Ignore ephemeral key broadcasts
             return
 
-        if msg.from_destination.domain == Domain.DOMAIN_VEHICLE_SECURITY:
-            submsg = FromVCSECMessage.FromString(msg.protobuf_message_as_bytes)
-            LOGGER.warning(f"Received orphaned VCSEC response: {submsg}")
-        elif msg.from_destination.domain == Domain.DOMAIN_INFOTAINMENT:
-            submsg = Response.FromString(msg.protobuf_message_as_bytes)
-            LOGGER.warning(f"Received orphaned INFOTAINMENT response: {submsg}")
+        LOGGER.info(f"Received response: {msg}")
+        await self._queues[msg.from_destination.domain].put(msg)
 
-    async def _create_future(self, domain: Domain) -> Future:
-        if(not self._sessions[domain].lock.locked):
-            raise ValueError("Session is not locked")
-        self._futures[domain] = get_running_loop().create_future()
-        return self._futures[domain]
-
-    async def _send(self, msg: RoutableMessage) -> RoutableMessage:
+    async def _send(self, msg: RoutableMessage, requires: str) -> RoutableMessage:
         """Serialize a message and send to the vehicle and wait for a response."""
         domain = msg.to_destination.domain
         async with self._sessions[domain].lock:
             LOGGER.debug(f"Sending message {msg}")
-            future = await self._create_future(domain)
+
             payload = prependLength(msg.SerializeToString())
 
+            # Empty the queue before sending the message
+            while not self._queues[domain].empty():
+                await self._queues[domain].get()
             await self.client.write_gatt_char(WRITE_UUID, payload, True)
 
-            resp = await future
-            LOGGER.debug(f"Received message {resp}")
+            # Process the response
+            async with asyncio.timeout(10):
+                while True:
+                    resp = await self._queues[domain].get()
+                    LOGGER.debug(f"Received message {resp}")
 
-            if resp.signedMessageStatus.signed_message_fault:
-                raise MESSAGE_FAULTS[resp.signedMessageStatus.signed_message_fault]
+                    self.validate_msg(resp)
 
-            return resp
+                    if resp.HasField(requires):
+                        return resp
 
     async def pair(self, role: Role = Role.ROLE_OWNER, form: KeyFormFactor = KeyFormFactor.KEY_FORM_FACTOR_CLOUD_KEY):
         """Pair the key."""
@@ -224,3 +231,167 @@ class VehicleBluetooth(Commands):
         return await self._sendVehicleSecurity(
             UnsignedMessage(RKEAction=RKEAction_E.RKE_ACTION_WAKE_VEHICLE)
         )
+
+    async def vehicle_data(self, endpoints: list[BluetoothVehicleData]) -> VehicleData:
+        """Get vehicle data."""
+        return await self._getInfotainment(
+            Action(
+                vehicleAction=VehicleAction(
+                    getVehicleData=GetVehicleData(
+                        getChargeState = GetChargeState() if BluetoothVehicleData.CHARGE_STATE in endpoints else None,
+                        getClimateState = GetClimateState() if BluetoothVehicleData.CLIMATE_STATE in endpoints else None,
+                        getDriveState = GetDriveState() if BluetoothVehicleData.DRIVE_STATE in endpoints else None,
+                        getLocationState = GetLocationState() if BluetoothVehicleData.LOCATION_STATE in endpoints else None,
+                        getClosuresState = GetClosuresState() if BluetoothVehicleData.CLOSURES_STATE in endpoints else None,
+                        getChargeScheduleState = GetChargeScheduleState() if BluetoothVehicleData.CHARGE_SCHEDULE_STATE in endpoints else None,
+                        getPreconditioningScheduleState = GetPreconditioningScheduleState() if BluetoothVehicleData.PRECONDITIONING_SCHEDULE_STATE in endpoints else None,
+                        getTirePressureState = GetTirePressureState() if BluetoothVehicleData.TIRE_PRESSURE_STATE in endpoints else None,
+                        getMediaState = GetMediaState() if BluetoothVehicleData.MEDIA_STATE in endpoints else None,
+                        getMediaDetailState = GetMediaDetailState() if BluetoothVehicleData.MEDIA_DETAIL_STATE in endpoints else None,
+                        getSoftwareUpdateState = GetSoftwareUpdateState() if BluetoothVehicleData.SOFTWARE_UPDATE_STATE in endpoints else None,
+                        getParentalControlsState = GetParentalControlsState() if BluetoothVehicleData.PARENTAL_CONTROLS_STATE in endpoints else None,
+                    )
+                )
+            )
+        )
+
+    async def charge_state(self) -> ChargeState:
+        return (await self._getInfotainment(
+            Action(
+                vehicleAction=VehicleAction(
+                    getVehicleData=GetVehicleData(
+                        getChargeState=GetChargeState()
+                    )
+                )
+            )
+        )).charge_state
+
+    async def climate_state(self) -> ClimateState:
+        return (await self._getInfotainment(
+            Action(
+                vehicleAction=VehicleAction(
+                    getVehicleData=GetVehicleData(
+                        getClimateState=GetClimateState()
+                    )
+                )
+            )
+        )).climate_state
+
+    async def drive_state(self) -> DriveState:
+        return (await self._getInfotainment(
+            Action(
+                vehicleAction=VehicleAction(
+                    getVehicleData=GetVehicleData(
+                        getDriveState=GetDriveState()
+                    )
+                )
+            )
+        )).drive_state
+
+    async def location_state(self) -> LocationState:
+        return (await self._getInfotainment(
+            Action(
+                vehicleAction=VehicleAction(
+                    getVehicleData=GetVehicleData(
+                        getLocationState=GetLocationState()
+                    )
+                )
+            )
+        )).location_state
+
+    async def closures_state(self) -> ClosuresState:
+        return (await self._getInfotainment(
+            Action(
+                vehicleAction=VehicleAction(
+                    getVehicleData=GetVehicleData(
+                        getClosuresState=GetClosuresState()
+                    )
+                )
+            )
+        )).closures_state
+
+    async def charge_schedule_state(self) -> ChargeScheduleState:
+        return (await self._getInfotainment(
+            Action(
+                vehicleAction=VehicleAction(
+                    getVehicleData=GetVehicleData(
+                        getChargeScheduleState=GetChargeScheduleState()
+                    )
+                )
+            )
+        )).charge_schedule_state
+
+    async def preconditioning_schedule_state(self) -> PreconditioningScheduleState:
+        return (await self._getInfotainment(
+            Action(
+                vehicleAction=VehicleAction(
+                    getVehicleData=GetVehicleData(
+                        getPreconditioningScheduleState=GetPreconditioningScheduleState()
+                    )
+                )
+            )
+        )).preconditioning_schedule_state
+
+    async def tire_pressure_state(self) -> TirePressureState:
+        return (await self._getInfotainment(
+            Action(
+                vehicleAction=VehicleAction(
+                    getVehicleData=GetVehicleData(
+                        getTirePressureState=GetTirePressureState()
+                    )
+                )
+            )
+        )).tire_pressure_state
+
+    async def media_state(self) -> MediaState:
+        return (await self._getInfotainment(
+            Action(
+                vehicleAction=VehicleAction(
+                    getVehicleData=GetVehicleData(
+                        getMediaState=GetMediaState()
+                    )
+                )
+            )
+        )).media_state
+
+    async def media_detail_state(self) -> MediaDetailState:
+        return (await self._getInfotainment(
+            Action(
+                vehicleAction=VehicleAction(
+                    getVehicleData=GetVehicleData(
+                        getMediaDetailState=GetMediaDetailState()
+                    )
+                )
+            )
+        )).media_detail_state
+
+    async def software_update_state(self) -> SoftwareUpdateState:
+        return (await self._getInfotainment(
+            Action(
+                vehicleAction=VehicleAction(
+                    getVehicleData=GetVehicleData(
+                        getSoftwareUpdateState=GetSoftwareUpdateState()
+                    )
+                )
+            )
+        )).software_update_state
+
+    async def parental_controls_state(self) -> ParentalControlsState:
+        return (await self._getInfotainment(
+            Action(
+                vehicleAction=VehicleAction(
+                    getVehicleData=GetVehicleData(
+                        getParentalControlsState=GetParentalControlsState()
+                    )
+                )
+            )
+        )).parental_controls_state
+
+    async def vehicle_state(self) -> VehicleStatus:
+        return await self._getVehicleSecurity(
+            UnsignedMessage(
+                InformationRequest=InformationRequest(
+                    informationRequestType=InformationRequestType.INFORMATION_REQUEST_TYPE_GET_STATUS
+                )
+            )
+        )

tesla_fleet_api/tesla/vehicle/commands.py

@@ -14,7 +14,10 @@ from cryptography.hazmat.primitives.ciphers.aead import AESGCM
 from asyncio import Lock, sleep
 
 from tesla_fleet_api.exceptions import (
+    MESSAGE_FAULTS,
     SIGNED_MESSAGE_INFORMATION_FAULTS,
+    NotOnWhitelistFault,
+    #TeslaFleetMessageFaultInvalidSignature,
     TeslaFleetMessageFaultIncorrectEpoch,
     TeslaFleetMessageFaultInvalidTokenOrCounter,
 )
@@ -37,33 +40,25 @@ from tesla_fleet_api.tesla.vehicle.proto.car_server_pb2 import (
     Response,
 )
 from tesla_fleet_api.tesla.vehicle.proto.signatures_pb2 import (
-    SIGNATURE_TYPE_AES_GCM_PERSONALIZED,
-    SIGNATURE_TYPE_HMAC_PERSONALIZED,
-    TAG_COUNTER,
-    TAG_DOMAIN,
-    TAG_END,
-    TAG_EPOCH,
-    TAG_EXPIRES_AT,
-    TAG_PERSONALIZATION,
-    TAG_SIGNATURE_TYPE,
+    Session_Info_Status,
+    SignatureType,
+    Tag,
     AES_GCM_Personalized_Signature_Data,
     KeyIdentity,
     SessionInfo,
     SignatureData,
 )
 from tesla_fleet_api.tesla.vehicle.proto.universal_message_pb2 import (
-    DOMAIN_INFOTAINMENT,
-    DOMAIN_VEHICLE_SECURITY,
-    OPERATIONSTATUS_ERROR,
-    OPERATIONSTATUS_WAIT,
+    OperationStatus_E,
     Destination,
     Domain,
     RoutableMessage,
     SessionInfoRequest,
+    Flags,
 )
 from tesla_fleet_api.tesla.vehicle.proto.vcsec_pb2 import (
-    OPERATIONSTATUS_OK,
     FromVCSECMessage,
+    VehicleStatus,
 )
 from tesla_fleet_api.tesla.vehicle.proto.car_server_pb2 import (
     Action,
@@ -110,7 +105,7 @@ from tesla_fleet_api.tesla.vehicle.proto.car_server_pb2 import (
     MediaPreviousTrack,
     MediaPreviousFavorite,
 )
-from tesla_fleet_api.tesla.vehicle.proto.vehicle_pb2 import VehicleState, ClimateState
+from tesla_fleet_api.tesla.vehicle.proto.vehicle_pb2 import VehicleData, VehicleState, ClimateState
 from tesla_fleet_api.tesla.vehicle.proto.vcsec_pb2 import (
     UnsignedMessage,
     RKEAction_E,
@@ -173,6 +168,7 @@ class Session:
     hmac: bytes
     publicKey: bytes
     lock: Lock
+    ready: bool
 
     def __init__(self, parent: Commands, domain: Domain):
         self.parent = parent
@@ -258,10 +254,21 @@ class Commands(Vehicle):
 
 
     @abstractmethod
-    async def _send(self, msg: RoutableMessage) -> RoutableMessage:
+    async def _send(self, msg: RoutableMessage, requires: str) -> RoutableMessage:
         """Transmit the message to the vehicle."""
         raise NotImplementedError
 
+    def validate_msg(self, msg: RoutableMessage) -> None:
+        """Validate the message."""
+        if(msg.session_info):
+            info = SessionInfo.FromString(msg.session_info)
+            if(info.status == Session_Info_Status.SESSION_INFO_STATUS_KEY_NOT_ON_WHITELIST):
+                raise NotOnWhitelistFault
+            self._sessions[msg.from_destination.domain].update(info)
+
+        if msg.signedMessageStatus.signed_message_fault > 0:
+            raise MESSAGE_FAULTS[msg.signedMessageStatus.signed_message_fault]
+
     @abstractmethod
     async def _command(self, domain: Domain, command: bytes, attempt: int = 0) -> dict[str, Any]:
         """Serialize a message and send to the signed command endpoint."""
@@ -277,8 +284,9 @@ class Commands(Vehicle):
             raise ValueError(f"Unknown auth method: {self._auth_method}")
 
         try:
-            resp = await self._send(msg)
+            resp = await self._send(msg, "protobuf_message_as_bytes")
         except (
+            #TeslaFleetMessageFaultInvalidSignature,
             TeslaFleetMessageFaultIncorrectEpoch,
             TeslaFleetMessageFaultInvalidTokenOrCounter,
         ) as e:
@@ -288,7 +296,7 @@ class Commands(Vehicle):
                 raise e
             return await self._command(domain, command, attempt)
 
-        if resp.signedMessageStatus.operation_status == OPERATIONSTATUS_WAIT:
+        if resp.signedMessageStatus.operation_status == OperationStatus_E.OPERATIONSTATUS_WAIT:
             attempt += 1
             if attempt > 3:
                 # We tried 3 times, give up, raise the error
@@ -298,8 +306,53 @@ class Commands(Vehicle):
             return await self._command(domain, command, attempt)
 
         if resp.HasField("protobuf_message_as_bytes"):
-            if(resp.from_destination.domain == DOMAIN_VEHICLE_SECURITY):
-                vcsec = FromVCSECMessage.FromString(resp.protobuf_message_as_bytes)
+            #decrypt
+            if(resp.signature_data.HasField("AES_GCM_Response_data")):
+                if(msg.signature_data.HasField("AES_GCM_Personalized_data")):
+                    request_hash = bytes([SignatureType.SIGNATURE_TYPE_AES_GCM_PERSONALIZED]) + msg.signature_data.AES_GCM_Personalized_data.tag
+                elif(msg.signature_data.HasField("HMAC_Personalized_data")):
+                    request_hash = bytes([SignatureType.SIGNATURE_TYPE_HMAC_PERSONALIZED]) + msg.signature_data.HMAC_Personalized_data.tag
+                    if(session.domain == Domain.DOMAIN_VEHICLE_SECURITY):
+                        request_hash = request_hash[:17]
+                else:
+                    raise ValueError("Invalid request signature data")
+
+                metadata = bytes([
+                    Tag.TAG_SIGNATURE_TYPE,
+                    1,
+                    SignatureType.SIGNATURE_TYPE_AES_GCM_RESPONSE,
+                    Tag.TAG_DOMAIN,
+                    1,
+                    resp.from_destination.domain,
+                    Tag.TAG_PERSONALIZATION,
+                    17,
+                    *self.vin.encode(),
+                    Tag.TAG_COUNTER,
+                    4,
+                    *struct.pack(">I", resp.signature_data.AES_GCM_Response_data.counter),
+                    Tag.TAG_FLAGS,
+                    4,
+                    *struct.pack(">I", resp.flags),
+                    Tag.TAG_REQUEST_HASH,
+                    17,
+                    *request_hash,
+                    Tag.TAG_FAULT,
+                    4,
+                    *struct.pack(">I", resp.signedMessageStatus.signed_message_fault),
+                    Tag.TAG_END,
+                ])
+
+                aad = Hash(SHA256())
+                aad.update(metadata)
+                aesgcm = AESGCM(session.sharedKey)
+                resp.protobuf_message_as_bytes = aesgcm.decrypt(resp.signature_data.AES_GCM_Response_data.nonce, resp.protobuf_message_as_bytes + resp.signature_data.AES_GCM_Response_data.tag, aad.finalize())
+
+            if(resp.from_destination.domain == Domain.DOMAIN_VEHICLE_SECURITY):
+                try:
+                    vcsec = FromVCSECMessage.FromString(resp.protobuf_message_as_bytes)
+                except Exception as e:
+                    LOGGER.error("Failed to parse VCSEC message: %s %s", e, resp)
+                    raise e
                 LOGGER.debug("VCSEC Response: %s", vcsec)
                 if vcsec.HasField("nominalError"):
                     LOGGER.error("Command failed with reason: %s", vcsec.nominalError.genericError)
@@ -309,9 +362,13 @@ class Commands(Vehicle):
                             "reason": GenericError_E.Name(vcsec.nominalError.genericError)
                         }
                     }
-                elif vcsec.commandStatus.operationStatus == OPERATIONSTATUS_OK:
+                elif vcsec.HasField("vehicleStatus"):
+                    return {
+                        "response": vcsec.vehicleStatus
+                    }
+                elif vcsec.commandStatus.operationStatus == OperationStatus_E.OPERATIONSTATUS_OK:
                     return {"response": {"result": True, "reason": ""}}
-                elif vcsec.commandStatus.operationStatus == OPERATIONSTATUS_WAIT:
+                elif vcsec.commandStatus.operationStatus == OperationStatus_E.OPERATIONSTATUS_WAIT:
                     attempt += 1
                     if attempt > 3:
                         # We tried 3 times, give up, raise the error
@@ -319,29 +376,37 @@ class Commands(Vehicle):
                     async with session.lock:
                         await sleep(2)
                     return await self._command(domain, command, attempt)
-                elif vcsec.commandStatus.operationStatus == OPERATIONSTATUS_ERROR:
+                elif vcsec.commandStatus.operationStatus == OperationStatus_E.OPERATIONSTATUS_ERROR:
                     if(resp.HasField("signedMessageStatus")):
                         raise SIGNED_MESSAGE_INFORMATION_FAULTS[vcsec.commandStatus.signedMessageStatus.signedMessageInformation]
 
-            elif(resp.from_destination.domain == DOMAIN_INFOTAINMENT):
-                response = Response.FromString(resp.protobuf_message_as_bytes)
+            elif(resp.from_destination.domain == Domain.DOMAIN_INFOTAINMENT):
+                try:
+                    response = Response.FromString(resp.protobuf_message_as_bytes)
+                except Exception as e:
+                    LOGGER.error("Failed to parse Infotainment Response: %s %s", e, resp)
+                    raise e
                 LOGGER.debug("Infotainment Response: %s", response)
                 if (response.HasField("ping")):
-                    print(response.ping)
                     return {
                         "response": {
                             "result": True,
                             "reason": response.ping.local_timestamp
                         }
                     }
+                if response.HasField("vehicleData"):
+                    return {
+                        "response": response.vehicleData
+                    }
                 if response.HasField("actionStatus"):
                     return {
                         "response": {
-                            "result": response.actionStatus.result == OPERATIONSTATUS_OK,
+                            "result": response.actionStatus.result == OperationStatus_E.OPERATIONSTATUS_OK,
                             "reason": response.actionStatus.result_reason.plain_text or ""
                             }
                         }
 
+
         return {"response": {"result": True, "reason": ""}}
 
     async def _commandHmac(self, session: Session, command: bytes, attempt: int = 1) -> RoutableMessage:
@@ -351,25 +416,25 @@ class Commands(Vehicle):
         hmac_personalized = session.hmac_personalized()
 
         metadata = bytes([
-            TAG_SIGNATURE_TYPE,
+            Tag.TAG_SIGNATURE_TYPE,
             1,
-            SIGNATURE_TYPE_HMAC_PERSONALIZED,
-            TAG_DOMAIN,
+            SignatureType.SIGNATURE_TYPE_HMAC_PERSONALIZED,
+            Tag.TAG_DOMAIN,
             1,
             session.domain,
-            TAG_PERSONALIZATION,
+            Tag.TAG_PERSONALIZATION,
             17,
             *self.vin.encode(),
-            TAG_EPOCH,
+            Tag.TAG_EPOCH,
             len(hmac_personalized.epoch),
             *hmac_personalized.epoch,
-            TAG_EXPIRES_AT,
+            Tag.TAG_EXPIRES_AT,
             4,
             *struct.pack(">I", hmac_personalized.expires_at),
-            TAG_COUNTER,
+            Tag.TAG_COUNTER,
             4,
             *struct.pack(">I", hmac_personalized.counter),
-            TAG_END,
+            Tag.TAG_END,
         ])
 
         hmac_personalized.tag = hmac.new(
@@ -398,27 +463,31 @@ class Commands(Vehicle):
         LOGGER.debug(f"Sending AES to domain {Domain.Name(session.domain)}")
 
         aes_personalized = session.aes_gcm_personalized()
+        flags = 1 << Flags.FLAG_ENCRYPT_RESPONSE
 
         metadata = bytes([
-            TAG_SIGNATURE_TYPE,
+            Tag.TAG_SIGNATURE_TYPE,
             1,
-            SIGNATURE_TYPE_AES_GCM_PERSONALIZED,
-            TAG_DOMAIN,
+            SignatureType.SIGNATURE_TYPE_AES_GCM_PERSONALIZED,
+            Tag.TAG_DOMAIN,
             1,
             session.domain,
-            TAG_PERSONALIZATION,
+            Tag.TAG_PERSONALIZATION,
             17,
             *self.vin.encode(),
-            TAG_EPOCH,
+            Tag.TAG_EPOCH,
             len(aes_personalized.epoch),
             *aes_personalized.epoch,
-            TAG_EXPIRES_AT,
+            Tag.TAG_EXPIRES_AT,
             4,
             *struct.pack(">I", aes_personalized.expires_at),
-            TAG_COUNTER,
+            Tag.TAG_COUNTER,
             4,
             *struct.pack(">I", aes_personalized.counter),
-            TAG_END,
+            Tag.TAG_FLAGS,
+            4,
+            *struct.pack(">I", flags),
+            Tag.TAG_END,
         ])
 
         aad = Hash(SHA256())
@@ -429,7 +498,6 @@ class Commands(Vehicle):
 
         aes_personalized.tag = ct[-16:]
 
-        # I think this whole section could be improved
         return RoutableMessage(
             to_destination=Destination(
                 domain=session.domain,
@@ -444,7 +512,8 @@ class Commands(Vehicle):
                     public_key=self._public_key
                 ),
                 AES_GCM_Personalized_data=aes_personalized,
-            )
+            ),
+            flags=flags,
         )
 
 
@@ -452,10 +521,20 @@ class Commands(Vehicle):
         """Sign and send a message to Infotainment computer."""
         return await self._command(Domain.DOMAIN_VEHICLE_SECURITY, command.SerializeToString())
 
+    async def _getVehicleSecurity(self, command: UnsignedMessage) -> VehicleStatus:
+        """Sign and send a message to Infotainment computer."""
+        reply = await self._command(Domain.DOMAIN_VEHICLE_SECURITY, command.SerializeToString())
+        return reply["response"]
+
     async def _sendInfotainment(self, command: Action) -> dict[str, Any]:
         """Sign and send a message to Infotainment computer."""
         return await self._command(Domain.DOMAIN_INFOTAINMENT, command.SerializeToString())
 
+    async def _getInfotainment(self, command: Action) -> VehicleData:
+        """Sign and send a message to Infotainment computer."""
+        reply = await self._command(Domain.DOMAIN_INFOTAINMENT, command.SerializeToString())
+        return reply["response"]
+
     async def handshakeVehicleSecurity(self) -> None:
         """Perform a handshake with the vehicle security domain."""
         await self._handshake(Domain.DOMAIN_VEHICLE_SECURITY)
@@ -464,7 +543,7 @@ class Commands(Vehicle):
         """Perform a handshake with the infotainment domain."""
         await self._handshake(Domain.DOMAIN_INFOTAINMENT)
 
-    async def _handshake(self, domain: Domain) -> None:
+    async def _handshake(self, domain: Domain) -> bool:
         """Perform a handshake with the vehicle."""
 
         LOGGER.debug(f"Handshake with domain {Domain.Name(domain)}")
@@ -481,7 +560,8 @@ class Commands(Vehicle):
             uuid=randbytes(16)
         )
 
-        await self._send(msg)
+        await self._send(msg, "session_info")
+        return self._sessions[domain].ready
 
     async def ping(self) -> dict[str, Any]:
         """Ping the vehicle."""

tesla_fleet_api/tesla/vehicle/signed.py

@@ -7,8 +7,10 @@ from tesla_fleet_api.tesla.vehicle.fleet import VehicleFleet
 from tesla_fleet_api.tesla.vehicle.commands import Commands
 from tesla_fleet_api.exceptions import (
     MESSAGE_FAULTS,
+    NotOnWhitelistFault,
 )
 from tesla_fleet_api.tesla.vehicle.proto.signatures_pb2 import (
+    Session_Info_Status,
     SessionInfo,
 )
 from tesla_fleet_api.tesla.vehicle.proto.universal_message_pb2 import (
@@ -31,25 +33,17 @@ class VehicleSigned(VehicleFleet, Commands):
         super(Commands, self).__init__(parent, vin)
 
 
-    async def _send(self, msg: RoutableMessage) -> RoutableMessage:
+    async def _send(self, msg: RoutableMessage, requires: str) -> RoutableMessage:
         """Serialize a message and send to the signed command endpoint."""
+        # requires isnt used because Fleet API messages are singular
 
         async with self._sessions[msg.to_destination.domain].lock:
-            resp = await self.signed_command(
+            json = await self.signed_command(
                 base64.b64encode(msg.SerializeToString()).decode()
             )
 
-            resp_msg = RoutableMessage.FromString(base64.b64decode(resp["response"]))
+            resp = RoutableMessage.FromString(base64.b64decode(json["response"]))
 
-            # Check UUID?
-            # Check RoutingAdress?
+            self.validate_msg(resp)
 
-            if resp_msg.session_info:
-                self._sessions[resp_msg.from_destination.domain].update(
-                    SessionInfo.FromString(resp_msg.session_info), self.private_key
-                )
-
-            if resp_msg.signedMessageStatus.signed_message_fault:
-                raise MESSAGE_FAULTS[resp_msg.signedMessageStatus.signed_message_fault]
-
-            return resp_msg
+            return resp

tesla_fleet_api/tesla/vehicle/vehicles.py

@@ -31,7 +31,7 @@ class Vehicles(dict[str, Vehicle]):
         self[vin] = vehicle
         return vehicle
 
-    def createBluetooth(self, vin: str) -> VehicleBluetooth:
+    def createBluetooth(self, vin: str):
         """Creates a bluetooth vehicle that uses command protocol."""
         vehicle = VehicleBluetooth(self._parent, vin)
         self[vin] = vehicle

{tesla_fleet_api-1.0.2.dist-info → tesla_fleet_api-1.0.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: tesla_fleet_api
-Version: 1.0.2
+Version: 1.0.4
 Summary: Tesla Fleet API library for Python
 Home-page: https://github.com/Teslemetry/python-tesla-fleet-api
 Author: Brett Adams
@@ -18,6 +18,7 @@ Requires-Dist: aiolimiter
 Requires-Dist: cryptography
 Requires-Dist: protobuf
 Requires-Dist: bleak
+Requires-Dist: bleak-retry-connector
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier
@@ -29,10 +30,11 @@ Dynamic: requires-python
 Dynamic: summary
 
 # Tesla Fleet Api
-Python library for Tesla Fleet API and Teslemetry.
+Python library for Tesla Fleet API and Tesla Command Protocol, including signed commands and encrypted local Bluetooth (BLE). Also provides interfaces for Teslemetry and Tessie.
 
-Based on [Tesla Developer documentation](https://developer.tesla.com/docs/fleet-api).
+Based on [Tesla Developer documentation](https://developer.tesla.com/docs/fleet-api) and [Tesla Command Protocol](https://github.com/teslamotors/vehicle-command/blob/main/pkg/protocol/protocol.md)
 
+**Documentation is currently outdated for V1.0.X**
 
 ## TeslaFleetApi
 This is the base class, however can also be used directly if you have a valid user access_token.

{tesla_fleet_api-1.0.2.dist-info → tesla_fleet_api-1.0.4.dist-info}/RECORD

@@ -1,23 +1,23 @@
 tesla_fleet_api/__init__.py,sha256=3DZMoZ-5srW-7SooAjqcRubQDuZPY8rMKH7eqIp4qtg,392
-tesla_fleet_api/const.py,sha256=GZFCZXq6-dRlECb7auojMGg0y03zg-Dt_zfeQ6aT8oY,3158
-tesla_fleet_api/exceptions.py,sha256=c-Was9VCfyiVG3H5XwygTBVXJ4Ib8H1WoPe3srXWRTk,34633
+tesla_fleet_api/const.py,sha256=HK5PibaarH3CjrtN2Ma-xytZyhkpTdlbQ8rpVbL9DDo,3748
+tesla_fleet_api/exceptions.py,sha256=1EkMnDxQYxZBn4ApjGodIBZyNPu9oa_Pgpdl6lQQ5gk,35523
 tesla_fleet_api/ratecalculator.py,sha256=4lz8yruUeouHXh_3ezsXX-CTpIegp1T1J4VuRV_qdHA,1791
 tesla_fleet_api/tesla/__init__.py,sha256=Cvpqu8OaOFmbuwu9KjgYrje8eVluDp2IU_zwdtXbmO0,282
-tesla_fleet_api/tesla/bluetooth.py,sha256=l2HOew_iCOw5RRr190NQasz080NYiea47fgjQIh_kGs,1271
+tesla_fleet_api/tesla/bluetooth.py,sha256=WhDo66OEwCGhvsGskvWcGUiNv6eyFsdEiQdIm571jQM,1835
 tesla_fleet_api/tesla/charging.py,sha256=D7I7cAf-3-95sIjyP6wpVqCq9Cppj6U-VPFQGpQQ8bs,1704
 tesla_fleet_api/tesla/energysite.py,sha256=96Q5npsJ2YIa257o_NL5_3gJNUS-ioAL7sTeQeGPgAM,6110
 tesla_fleet_api/tesla/fleet.py,sha256=X74tzwGO9w65j9YUGuW04CwG7Bx6biEHwxIjWGCzB4c,5670
 tesla_fleet_api/tesla/oauth.py,sha256=aWBsWmnM-QxzaU8W9TXVNxGsYn_LraXnpexwdE8wOqo,4104
-tesla_fleet_api/tesla/partner.py,sha256=TU3Xg18x2w3PHv6Dy3Mo40pb417pp5lqnF0c1vDCt6g,1224
+tesla_fleet_api/tesla/partner.py,sha256=e-l6sEP6-IupjFEQieSUjhhvRXF3aL4ebPNahcGFRCE,1238
 tesla_fleet_api/tesla/tesla.py,sha256=Jlz90-fM0nJbhnQN0k3ukNv59-9KqZZbyQ91IiLIbfo,2010
 tesla_fleet_api/tesla/user.py,sha256=w8rwiAOIFjuDus8M0RpZ0wucJtw8kYFKtJfYVk7Ekr0,1194
 tesla_fleet_api/tesla/vehicle/__init__.py,sha256=3A5_wTQHofRShof4pUNOtF78-7lUh62uz2jq2ecnmRY,381
-tesla_fleet_api/tesla/vehicle/bluetooth.py,sha256=BQ5r7Fpogs8_zL9EBAq3XW--AbuDh1eUmTYm-wJok0M,8735
-tesla_fleet_api/tesla/vehicle/commands.py,sha256=RBK_tQmrtjIAUjTCmGyRE5x0U1UeFJRHVmlG2y9u2PA,47191
+tesla_fleet_api/tesla/vehicle/bluetooth.py,sha256=tEbuUMjG3PfDLc1s1ACg-3zdnF-lSwDsH1U5tg5qbRI,15746
+tesla_fleet_api/tesla/vehicle/commands.py,sha256=zgfc2yo1UxEh8ePqSb-4h0UTK0RmpCG_9LZX44CES2c,51268
 tesla_fleet_api/tesla/vehicle/fleet.py,sha256=K9BVZj6CChJSDSMFroa7Cz0KrsYWj32ILtQumarkLaU,32080
-tesla_fleet_api/tesla/vehicle/signed.py,sha256=OPQy_LHxTvRcY8bAHrzRLPlN_vYOupdr_TEmHY9PGuQ,1807
+tesla_fleet_api/tesla/vehicle/signed.py,sha256=ggdtq8PydKoCk044L5b2262nfNzZqPBnsJ4SonTFbb4,1539
 tesla_fleet_api/tesla/vehicle/vehicle.py,sha256=TyW5-LRlgRulWsm2indE3utSTdrJJRfG7H45Cc-ZASk,505
-tesla_fleet_api/tesla/vehicle/vehicles.py,sha256=kQWOlvpseDqs2c8Co3Elo4RPeoHbK7AeSyX-t4Q5MDM,1585
+tesla_fleet_api/tesla/vehicle/vehicles.py,sha256=wyMLfHNK_QaNTDtU9mkGRl2fB3Gb6lvmSfcgXzKu7WY,1565
 tesla_fleet_api/tesla/vehicle/proto/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tesla_fleet_api/tesla/vehicle/proto/__init__.pyi,sha256=qFXWNIgl71wB260u-XPzaAwWAHL6krw21q-aXnBtop0,252
 tesla_fleet_api/tesla/vehicle/proto/car_server_pb2.py,sha256=v_eb4NDIkx_ZYPYW29_EFRky5vQ4b2q14gwuQSbouYw,29202
@@ -44,8 +44,8 @@ tesla_fleet_api/teslemetry/vehicle.py,sha256=9_2N1iNNDouqfb6YBBWAFjnlzVRTf5frhXi
 tesla_fleet_api/tessie/__init__.py,sha256=9lhQJaB6X4PObUL9QdaaZYqs2BxiTidu3zmHcBESLVw,78
 tesla_fleet_api/tessie/tessie.py,sha256=qdMZ61TcQi5JRuv2qaxuLHtOuy8WZJ1WNqWg5WDAwwU,2615
 tesla_fleet_api/tessie/vehicle.py,sha256=9khv4oCkGGLxHzQ2FYhDPH7wczxEDiUppsDXalawarE,1125
-tesla_fleet_api-1.0.2.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-tesla_fleet_api-1.0.2.dist-info/METADATA,sha256=vxPX8yS0x5TVB11oyZeKQQV3NIVd3ZRF_nYSGIDgEhk,4056
-tesla_fleet_api-1.0.2.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-tesla_fleet_api-1.0.2.dist-info/top_level.txt,sha256=jeNbog_1saXBFrGpom9WyPWmilxsyP3szL_G7JLWQfM,16
-tesla_fleet_api-1.0.2.dist-info/RECORD,,
+tesla_fleet_api-1.0.4.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+tesla_fleet_api-1.0.4.dist-info/METADATA,sha256=KxQg4FAxCoWBheKhRSo104TIDTtcswTz-LhgFN7UAUo,4382
+tesla_fleet_api-1.0.4.dist-info/WHEEL,sha256=nn6H5-ilmfVryoAQl3ZQ2l8SH5imPWFpm1A5FgEuFV4,91
+tesla_fleet_api-1.0.4.dist-info/top_level.txt,sha256=jeNbog_1saXBFrGpom9WyPWmilxsyP3szL_G7JLWQfM,16
+tesla_fleet_api-1.0.4.dist-info/RECORD,,

{tesla_fleet_api-1.0.2.dist-info → tesla_fleet_api-1.0.4.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.0)
+Generator: setuptools (75.8.1)
 Root-Is-Purelib: true
 Tag: py3-none-any