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

tesla_fleet_api/__init__.py

@@ -1,15 +1,13 @@
-from .tesla.fleet import TeslaFleetApi
-from .tesla.bluetooth import TeslaBluetooth
-from .tesla.oauth import TeslaFleetOAuth
-from .tesla.opensource import TeslaFleetOpenSource
-from .teslemetry.teslemetry import Teslemetry
-from .tessie.tessie import Tessie
+from tesla_fleet_api.tesla.fleet import TeslaFleetApi
+from tesla_fleet_api.tesla.bluetooth import TeslaBluetooth
+from tesla_fleet_api.tesla.oauth import TeslaFleetOAuth
+from tesla_fleet_api.teslemetry.teslemetry import Teslemetry
+from tesla_fleet_api.tessie.tessie import Tessie
 
 __all__ = [
     "TeslaFleetApi",
     "TeslaBluetooth",
     "TeslaFleetOAuth",
-    "TeslaFleetOpenSource",
     "Teslemetry",
     "Tessie",
 ]

tesla_fleet_api/const.py

@@ -3,7 +3,7 @@
 from enum import Enum
 import logging
 
-VERSION = "1.0.0"
+VERSION = "1.0.2"
 LOGGER = logging.getLogger(__package__)
 SERVERS = {
     "na": "https://fleet-api.prd.na.vn.cloud.tesla.com",

tesla_fleet_api/exceptions.py

@@ -1,5 +1,5 @@
 import aiohttp
-from .const import LOGGER
+from tesla_fleet_api.const import LOGGER
 
 
 class TeslaFleetError(BaseException):
@@ -856,6 +856,9 @@ SIGNED_MESSAGE_INFORMATION_FAULTS = [
 class WhitelistOperationStatus(TeslaFleetError):
     message = "Whitelist operation failed"
 
+    def __init__(self, message):
+        self.message = message
+
 class WhitelistOperationUndocumentedError(WhitelistOperationStatus):
     message = "Undocumented whitelist operation error"
     code = 1
@@ -944,6 +947,14 @@ class WhitelistOperationServiceKeyAttemptingToAddServiceTechOutsideServiceMode(W
     message = "Service key attempting to add service tech outside service mode"
     code = 22
 
+# No idea what 23 & 24 are
+
+class WhitelistOperationServiceAuthorizationRequestTimedOut(WhitelistOperationStatus):
+    # This is observed but not documented
+    message = "Authorization request timed out"
+    code = 25
+
+
 WHITELIST_OPERATION_STATUS = [
     None,
     WhitelistOperationUndocumentedError,
@@ -967,7 +978,10 @@ WHITELIST_OPERATION_STATUS = [
     WhitelistOperationAttemptingToAddKeyWithoutRole,
     WhitelistOperationAttemptingToAddKeyWithServiceRole,
     WhitelistOperationNonServiceKeyAttemptingToAddServiceTech,
-    WhitelistOperationServiceKeyAttemptingToAddServiceTechOutsideServiceMode
+    WhitelistOperationServiceKeyAttemptingToAddServiceTechOutsideServiceMode,
+    WhitelistOperationStatus,
+    WhitelistOperationStatus,
+    WhitelistOperationServiceAuthorizationRequestTimedOut
 ]
 
 

tesla_fleet_api/tesla/__init__.py

@@ -1,8 +1,8 @@
 """Tesla Fleet API classes."""
 
-from .fleet import TeslaFleetApi
-from .bluetooth import TeslaBluetooth
-from .oauth import TeslaFleetOAuth
+from tesla_fleet_api.tesla.fleet import TeslaFleetApi
+from tesla_fleet_api.tesla.bluetooth import TeslaBluetooth
+from tesla_fleet_api.tesla.oauth import TeslaFleetOAuth
 
 __all__ = [
     "TeslaFleetApi",

tesla_fleet_api/tesla/bluetooth.py

@@ -1,8 +1,10 @@
 """Bluetooth only interface."""
 
+import hashlib
 import re
-from .tesla import Tesla
-from .vehicle.bluetooth import VehicleBluetooth
+
+from tesla_fleet_api.tesla.tesla import Tesla
+from tesla_fleet_api.tesla.vehicle.bluetooth import VehicleBluetooth
 
 class TeslaBluetooth(Tesla):
     """Class describing a Tesla Bluetooth connection."""
@@ -16,7 +18,11 @@ class TeslaBluetooth(Tesla):
 
     def valid_name(self, name: str) -> bool:
         """Check if a BLE device name is a valid Tesla vehicle."""
-        return bool(re.match("^S[a-f0-9]{16}[A-F]$", name))
+        return bool(re.match("^S[a-f0-9]{16}[CDRP]$", name))
+
+    def get_name(self, vin: str) -> str:
+        """Get the name of a vehicle."""
+        return "S" + hashlib.sha1(vin.encode('utf-8')).hexdigest()[:16] + "C"
 
 class Vehicles(dict[str, VehicleBluetooth]):
     """Class containing and creating vehicles."""
@@ -26,6 +32,10 @@ class Vehicles(dict[str, VehicleBluetooth]):
     def __init__(self, parent: TeslaBluetooth):
         self._parent = parent
 
+    def create(self, vin: str) -> VehicleBluetooth:
+        """Creates a specific vehicle."""
+        return self.createBluetooth(vin)
+
     def createBluetooth(self, vin: str) -> VehicleBluetooth:
         """Creates a specific vehicle."""
         vehicle = VehicleBluetooth(self._parent, vin)

tesla_fleet_api/tesla/charging.py

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

tesla_fleet_api/tesla/energysite.py

@@ -1,9 +1,9 @@
 from __future__ import annotations
 from typing import Any, TYPE_CHECKING
-from ..const import Method, EnergyOperationMode, EnergyExportMode, TeslaEnergyPeriod
+from tesla_fleet_api.const import Method, EnergyOperationMode, EnergyExportMode, TeslaEnergyPeriod
 
 if TYPE_CHECKING:
-    from . import TeslaFleetApi
+    from tesla_fleet_api.tesla.fleet import TeslaFleetApi
 
 class EnergySite:
     """Class describing the Tesla Fleet API partner endpoints"""

tesla_fleet_api/tesla/fleet.py

@@ -4,14 +4,14 @@ from json import dumps
 from typing import Any, Awaitable
 import aiohttp
 
-from .tesla import Tesla
-from ..exceptions import raise_for_status, InvalidRegion, LibraryError, ResponseError
-from ..const import SERVERS, Method, LOGGER, VERSION
-from .charging import Charging
-from .energysite import EnergySites
-from .partner import Partner
-from .user import User
-from .vehicle.vehicles import Vehicles
+from tesla_fleet_api.tesla.tesla import Tesla
+from tesla_fleet_api.exceptions import raise_for_status, InvalidRegion, LibraryError, ResponseError
+from tesla_fleet_api.const import SERVERS, Method, LOGGER, VERSION
+from tesla_fleet_api.tesla.charging import Charging
+from tesla_fleet_api.tesla.energysite import EnergySites
+from tesla_fleet_api.tesla.partner import Partner
+from tesla_fleet_api.tesla.user import User
+from tesla_fleet_api.tesla.vehicle.vehicles import Vehicles
 
 
 # Based on https://developer.tesla.com/docs/fleet-api

tesla_fleet_api/tesla/oauth.py

@@ -2,8 +2,8 @@ from typing import Any
 import aiohttp
 import time
 
-from . import TeslaFleetApi
-from ..const import Scope, SERVERS, Method
+from tesla_fleet_api.tesla import TeslaFleetApi
+from tesla_fleet_api.const import Scope, SERVERS, Method
 
 
 class TeslaFleetOAuth(TeslaFleetApi):

tesla_fleet_api/tesla/user.py

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

tesla_fleet_api/tesla/vehicle/__init__.py

@@ -0,0 +1,13 @@
+"""Tesla Fleet API classes."""
+
+from tesla_fleet_api.tesla.vehicle.vehicles import Vehicles
+from tesla_fleet_api.tesla.vehicle.fleet import VehicleFleet
+from tesla_fleet_api.tesla.vehicle.bluetooth import VehicleBluetooth
+from tesla_fleet_api.tesla.vehicle.signed import VehicleSigned
+
+__all__ = [
+    "Vehicles",
+    "VehicleFleet",
+    "VehicleBluetooth",
+    "VehicleSigned",
+]

tesla_fleet_api/tesla/vehicle/bluetooth.py

@@ -0,0 +1,226 @@
+from __future__ import annotations
+
+import hashlib
+from asyncio import Future, get_running_loop
+from typing import TYPE_CHECKING
+from google.protobuf.message import DecodeError
+
+from bleak import BleakClient, BleakScanner
+from bleak.backends.characteristic import BleakGATTCharacteristic
+from bleak.backends.device import BLEDevice
+from cryptography.hazmat.primitives.asymmetric import ec
+
+from tesla_fleet_api.tesla.vehicle.proto.keys_pb2 import Role
+
+from tesla_fleet_api.tesla.vehicle.commands import Commands
+
+from tesla_fleet_api.const import (
+    LOGGER,
+)
+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,
+)
+from tesla_fleet_api.tesla.vehicle.proto.universal_message_pb2 import (
+    Destination,
+    Domain,
+    RoutableMessage,
+)
+from tesla_fleet_api.tesla.vehicle.proto.vcsec_pb2 import (
+    FromVCSECMessage,
+    KeyFormFactor,
+    KeyMetadata,
+    PermissionChange,
+    PublicKey,
+    RKEAction_E,
+    UnsignedMessage,
+    WhitelistOperation,
+
+)
+
+SERVICE_UUID = "00000211-b2d1-43f0-9b88-960cebf8b91e"
+WRITE_UUID = "00000212-b2d1-43f0-9b88-960cebf8b91e"
+READ_UUID = "00000213-b2d1-43f0-9b88-960cebf8b91e"
+VERSION_UUID = "00000214-b2d1-43f0-9b88-960cebf8b91e"
+
+if TYPE_CHECKING:
+    from tesla_fleet_api.tesla.tesla import Tesla
+
+def prependLength(message: bytes) -> bytearray:
+    """Prepend a 2-byte length to the payload."""
+    return bytearray([len(message) >> 8, len(message) & 0xFF]) + message
+
+class VehicleBluetooth(Commands):
+    """Class describing the Tesla Fleet API vehicle endpoints and commands for a specific vehicle with command signing."""
+
+    ble_name: str
+    client: BleakClient
+    _device: BLEDevice
+    _futures: dict[Domain, Future]
+    _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
+    ):
+        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:
+        """Find the Tesla BLE device."""
+
+        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
+
+    def create_client(self, mac:str) -> BleakClient:
+        """Create a client using a MAC address."""
+        self.client = BleakClient(mac, services=[SERVICE_UUID])
+        return self.client
+
+    async def connect(self, mac:str | None = None) -> None:
+        """Connect to the Tesla BLE device."""
+        if mac is not None:
+            self.create_client(mac)
+        await self.client.connect()
+        await self.client.start_notify(READ_UUID, self._on_notify)
+
+    async def disconnect(self) -> bool:
+        """Disconnect from the Tesla BLE device."""
+        return await self.client.disconnect()
+
+    async def __aenter__(self) -> VehicleBluetooth:
+        """Enter the async context."""
+        await self.connect()
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb) -> None:
+        """Exit the async context."""
+        await self.disconnect()
+
+    def _on_notify(self,sender: BleakGATTCharacteristic,data : bytearray) -> None:
+        """Receive data from the Tesla BLE device."""
+        if self._recv_len:
+            self._recv += data
+        else:
+            self._recv_len = int.from_bytes(data[:2], 'big')
+            self._recv = data[2:]
+        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]))
+            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))
+            self._recv = bytearray()
+            self._recv_len = 0
+
+    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}")
+            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)
+            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}")
+
+    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:
+        """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())
+
+            await self.client.write_gatt_char(WRITE_UUID, payload, True)
+
+            resp = await future
+            LOGGER.debug(f"Received message {resp}")
+
+            if resp.signedMessageStatus.signed_message_fault:
+                raise MESSAGE_FAULTS[resp.signedMessageStatus.signed_message_fault]
+
+            return resp
+
+    async def pair(self, role: Role = Role.ROLE_OWNER, form: KeyFormFactor = KeyFormFactor.KEY_FORM_FACTOR_CLOUD_KEY):
+        """Pair the key."""
+
+        request = UnsignedMessage(
+            WhitelistOperation=WhitelistOperation(
+                addKeyToWhitelistAndAddPermissions=PermissionChange(
+                    key=PublicKey(PublicKeyRaw=self._public_key),
+                    keyRole=role
+                ),
+                metadataForKey=KeyMetadata(
+                    keyFormFactor=form
+                )
+            )
+        )
+        msg = RoutableMessage(
+            to_destination=Destination(
+                domain=Domain.DOMAIN_VEHICLE_SECURITY
+            ),
+            from_destination=Destination(
+                routing_address=self._from_destination
+            ),
+            protobuf_message_as_bytes=request.SerializeToString(),
+        )
+        resp = await self._send(msg)
+        respMsg = FromVCSECMessage.FromString(resp.protobuf_message_as_bytes)
+        if(respMsg.commandStatus.whitelistOperationStatus.whitelistOperationInformation):
+            if(respMsg.commandStatus.whitelistOperationStatus.whitelistOperationInformation < len(WHITELIST_OPERATION_STATUS)):
+                raise WHITELIST_OPERATION_STATUS[respMsg.commandStatus.whitelistOperationStatus.whitelistOperationInformation]
+            else:
+                raise WhitelistOperationStatus(f"Unknown whitelist operation failure: {respMsg.commandStatus.whitelistOperationStatus.whitelistOperationInformation}")
+        return
+
+    async def wake_up(self):
+        """Wake up the vehicle."""
+        return await self._sendVehicleSecurity(
+            UnsignedMessage(RKEAction=RKEAction_E.RKE_ACTION_WAKE_VEHICLE)
+        )