tesla-fleet-api 0.9.10__py3-none-any.whl → 1.0.1__py3-none-any.whl

tesla_fleet_api/{teslafleetapi.py → tesla/fleet.py}

@@ -2,26 +2,20 @@
 
 from json import dumps
 from typing import Any, Awaitable
-from os.path import exists
 import aiohttp
-import aiofiles
 
-# cryptography
-from cryptography.hazmat.primitives.asymmetric import ec
-from cryptography.hazmat.primitives import serialization
-from cryptography.hazmat.backends import default_backend
-
-from .exceptions import raise_for_status, InvalidRegion, LibraryError, ResponseError
-from .const import SERVERS, Method, LOGGER, VERSION
+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 .energy import Energy
+from .energysite import EnergySites
 from .partner import Partner
 from .user import User
-from .vehicle import Vehicle
+from .vehicle.vehicles import Vehicles
 
 
 # Based on https://developer.tesla.com/docs/fleet-api
-class TeslaFleetApi:
+class TeslaFleetApi(Tesla):
     """Class describing the Tesla Fleet API."""
 
     access_token: str | None = None
@@ -30,7 +24,6 @@ class TeslaFleetApi:
     session: aiohttp.ClientSession
     headers: dict[str, str]
     refresh_hook: Awaitable | None = None
-    private_key: ec.EllipticCurvePrivateKey | None = None
 
     def __init__(
         self,
@@ -63,13 +56,13 @@ class TeslaFleetApi:
         if charging_scope:
             self.charging = Charging(self)
         if energy_scope:
-            self.energy = Energy(self)
+            self.energySites = EnergySites(self)
         if user_scope:
             self.user = User(self)
         if partner_scope:
             self.partner = Partner(self)
         if vehicle_scope:
-            self.vehicle = Vehicle(self)
+            self.vehicles = Vehicles(self)
 
     async def find_server(self) -> str:
         """Find the server URL for the Tesla Fleet API."""
@@ -162,41 +155,3 @@ class TeslaFleetApi:
             Method.GET,
             "api/1/products",
         )
-
-    async def get_private_key(
-        self, path: str = "private_key.pem"
-    ) -> ec.EllipticCurvePrivateKey:
-        """Get or create the private key."""
-        if not exists(path):
-            self.private_key = ec.generate_private_key(
-                ec.SECP256R1(), default_backend()
-            )
-            # save the key
-            pem = self.private_key.private_bytes(
-                encoding=serialization.Encoding.PEM,
-                format=serialization.PrivateFormat.TraditionalOpenSSL,
-                encryption_algorithm=serialization.NoEncryption(),
-            )
-            async with aiofiles.open(path, "wb") as key_file:
-                await key_file.write(pem)
-        else:
-            try:
-                async with aiofiles.open(path, "rb") as key_file:
-                    key_data = await key_file.read()
-                value = serialization.load_pem_private_key(
-                    key_data, password=None, backend=default_backend()
-                )
-            except FileNotFoundError:
-                raise FileNotFoundError(f"Private key file not found at {path}")
-            except PermissionError:
-                raise PermissionError(f"Permission denied when trying to read {path}")
-
-            if not isinstance(value, ec.EllipticCurvePrivateKey):
-                raise AssertionError("Loaded key is not an EllipticCurvePrivateKey")
-            self.private_key = value
-        return self.private_key
-
-    @property
-    def has_private_key(self) -> bool:
-        """Check if the private key has been set."""
-        return self.private_key is not None

tesla_fleet_api/{teslafleetoauth.py → tesla/oauth.py}

@@ -2,16 +2,15 @@ from typing import Any
 import aiohttp
 import time
 
-from tesla_fleet_api.const import Method
-from .teslafleetapi import TeslaFleetApi
-from .const import Scope, SERVERS
+from . import TeslaFleetApi
+from ..const import Scope, SERVERS, Method
 
 
 class TeslaFleetOAuth(TeslaFleetApi):
     """Tesla Fleet OAuth API."""
 
     expires: int
-    refresh_token: str
+    refresh_token: str | None
     redirect_uri: str | None
     _client_secret: str | None
 

tesla_fleet_api/{partner.py → tesla/partner.py}

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

tesla_fleet_api/tesla/tesla.py

@@ -0,0 +1,52 @@
+"""Tesla Fleet API for Python."""
+
+from os.path import exists
+import aiofiles
+
+# cryptography
+from cryptography.hazmat.primitives.asymmetric import ec
+from cryptography.hazmat.primitives import serialization
+from cryptography.hazmat.backends import default_backend
+
+class Tesla:
+    """Base class describing interactions with Tesla products."""
+
+    private_key: ec.EllipticCurvePrivateKey | None = None
+
+    async def get_private_key(
+        self, path: str = "private_key.pem"
+    ) -> ec.EllipticCurvePrivateKey:
+        """Get or create the private key."""
+        if not exists(path):
+            self.private_key = ec.generate_private_key(
+                ec.SECP256R1(), default_backend()
+            )
+            # save the key
+            pem = self.private_key.private_bytes(
+                encoding=serialization.Encoding.PEM,
+                format=serialization.PrivateFormat.TraditionalOpenSSL,
+                encryption_algorithm=serialization.NoEncryption(),
+            )
+            async with aiofiles.open(path, "wb") as key_file:
+                await key_file.write(pem)
+        else:
+            try:
+                async with aiofiles.open(path, "rb") as key_file:
+                    key_data = await key_file.read()
+                value = serialization.load_pem_private_key(
+                    key_data, password=None, backend=default_backend()
+                )
+            except FileNotFoundError:
+                raise FileNotFoundError(f"Private key file not found at {path}")
+            except PermissionError:
+                raise PermissionError(f"Permission denied when trying to read {path}")
+
+            if not isinstance(value, ec.EllipticCurvePrivateKey):
+                raise AssertionError("Loaded key is not an EllipticCurvePrivateKey")
+            self.private_key = value
+        return self.private_key
+
+    @property
+    def has_private_key(self) -> bool:
+        """Check if the private key has been set."""
+        return self.private_key is not None

tesla_fleet_api/{user.py → tesla/user.py}

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

tesla_fleet_api/tesla/vehicle/__init__.py

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

tesla_fleet_api/tesla/vehicle/bluetooth.py

@@ -0,0 +1,219 @@
+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 .commands import Commands
+
+from ...const import (
+    LOGGER,
+)
+from ...exceptions import (
+    MESSAGE_FAULTS,
+    WHITELIST_OPERATION_STATUS,
+)
+
+# Protocol
+from .proto.car_server_pb2 import (
+    Response,
+)
+from .proto.signatures_pb2 import (
+    SessionInfo,
+)
+from .proto.universal_message_pb2 import (
+    Destination,
+    Domain,
+    RoutableMessage,
+)
+from .proto.vcsec_pb2 import (
+    FromVCSECMessage,
+    KeyFormFactor,
+    KeyMetadata,
+    PermissionChange,
+    PublicKey,
+    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 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 discover(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):
+        """Create a client with a MAC."""
+        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):
+        """Exit the async context."""
+        await self.disconnect()
+
+    def _on_notify(self,sender: BleakGATTCharacteristic,data : bytearray):
+        """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):
+        """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 msg.from_destination.domain == Domain.DOMAIN_VEHICLE_SECURITY:
+            submsg = FromVCSECMessage.FromString(msg.protobuf_message_as_bytes)
+            print(submsg)
+        elif msg.from_destination.domain == Domain.DOMAIN_INFOTAINMENT:
+            submsg = Response.FromString(msg.protobuf_message_as_bytes)
+            print(submsg)
+
+        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
+
+    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)
+        print(respMsg)
+        if(respMsg.commandStatus.whitelistOperationStatus.whitelistOperationInformation):
+            if(respMsg.commandStatus.whitelistOperationStatus.whitelistOperationInformation < len(WHITELIST_OPERATION_STATUS)):
+                raise WHITELIST_OPERATION_STATUS[respMsg.commandStatus.whitelistOperationStatus.whitelistOperationInformation]
+            else:
+                raise ValueError(f"Unknown whitelist operation status: {respMsg.commandStatus.whitelistOperationStatus.whitelistOperationInformation}")
+        return