tesla-fleet-api 1.0.11__py3-none-any.whl → 1.0.13__py3-none-any.whl

tesla_fleet_api/const.py

@@ -3,7 +3,7 @@
 from enum import Enum
 import logging
 
-VERSION = "1.0.11"
+VERSION = "1.0.13"
 LOGGER = logging.getLogger(__package__)
 SERVERS = {
     "na": "https://fleet-api.prd.na.vn.cloud.tesla.com",
@@ -47,10 +47,18 @@ class Seat(IntEnum):
     FRONT_LEFT = 0
     FRONT_RIGHT = 1
     REAR_LEFT = 2
+    REAT_LEFT_BACK = 3
     REAR_CENTER = 4
     REAR_RIGHT = 5
-    THIRD_LEFT = 6
-    THIRD_RIGHT = 7
+    REAR_RIGHT_BACK = 6
+    THIRD_LEFT = 7
+    THIRD_RIGHT = 8
+
+class AutoSeat(IntEnum):
+    """Auto Climate Seat positions"""
+
+    FRONT_LEFT = 1
+    FRONT_RIGHT = 2
 
 
 class Level(IntEnum):

tesla_fleet_api/tesla/__init__.py

@@ -3,9 +3,23 @@
 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.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 import Vehicles, VehiclesBluetooth, VehicleFleet, VehicleSigned, VehicleBluetooth
 
 __all__ = [
     "TeslaFleetApi",
     "TeslaBluetooth",
     "TeslaFleetOAuth",
+    "Charging",
+    "EnergySites",
+    "Partner",
+    "User",
+    "Vehicles",
+    "VehiclesBluetooth",
+    "VehicleFleet",
+    "VehicleSigned",
+    "VehicleBluetooth"
 ]

tesla_fleet_api/tesla/fleet.py

@@ -115,8 +115,7 @@ class TeslaFleetApi(Tesla):
             json=json,
             params=params,
         ) as resp:
-            LOGGER.debug("Requested: %s", resp.url)
-            LOGGER.debug("Response Status: %s", resp.status)
+            LOGGER.debug("Status %s from %s", resp.status, resp.url)
             if "x-txid" in resp.headers:
                 LOGGER.debug("Response TXID: %s", resp.headers["x-txid"])
             if "RateLimit-Reset" in resp.headers:

tesla_fleet_api/tesla/vehicle/__init__.py

@@ -1,12 +1,13 @@
 """Tesla Fleet API classes."""
 
-from tesla_fleet_api.tesla.vehicle.vehicles import Vehicles
+from tesla_fleet_api.tesla.vehicle.vehicles import Vehicles, VehiclesBluetooth
 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",
+    "VehiclesBluetooth",
     "VehicleFleet",
     "VehicleBluetooth",
     "VehicleSigned",

tesla_fleet_api/tesla/vehicle/bluetooth.py

@@ -2,7 +2,8 @@ from __future__ import annotations
 
 import hashlib
 import asyncio
-from typing import TYPE_CHECKING
+import struct
+from typing import TYPE_CHECKING, Callable, Any
 from google.protobuf.message import DecodeError
 from bleak_retry_connector import establish_connection, MAX_CONNECT_ATTEMPTS
 from bleak import BleakClient, BleakScanner
@@ -75,6 +76,70 @@ def prependLength(message: bytes) -> bytearray:
     """Prepend a 2-byte length to the payload."""
     return bytearray([len(message) >> 8, len(message) & 0xFF]) + message
 
+class ReassemblingBuffer:
+    """
+    Reassembles bytearray streams where the first two bytes indicate the length of the message.
+    Handles potential packet corruption by discarding *entire* packets and retrying.
+    Uses a callback to process parsed messages.
+    """
+
+    def __init__(self, callback: Callable[[RoutableMessage], None]):
+        """
+        Initializes the buffer.
+
+        Args:
+            message_type: The protobuf message type (e.g., RoutableMessage) to parse the assembled data.
+            callback: A function that will be called with each parsed message.
+        """
+        self.buffer = bytearray()
+        self.expected_length = None
+        self.packet_starts = []
+        self.callback = callback
+
+    def receive_data(self, data: bytearray):
+        """
+        Receives a chunk of bytearray data and attempts to assemble a complete message.
+
+        Args:
+            data: The received bytearray data.
+        """
+        self.packet_starts.append(len(self.buffer))
+        self.buffer.extend(data)
+
+        while True:
+            if self.expected_length is None and len(self.buffer) >= 2:
+                self.expected_length = struct.unpack(">H", self.buffer[:2])[0] + 2
+
+            LOGGER.info(f"Buffer length: {len(self.buffer)}, Packet starts: {self.packet_starts}, Expected length: {self.expected_length}")
+
+            if self.expected_length is not None and self.expected_length > 1024:
+                LOGGER.warning(f"Expected length too large: {self.expected_length}")
+                self.discard_packet()
+
+            elif self.expected_length is not None and len(self.buffer) >= self.expected_length:
+                try:
+                    message = RoutableMessage()
+                    message.ParseFromString(bytes(self.buffer[2:self.expected_length]))
+                    self.buffer = self.buffer[self.expected_length:]
+                    self.packet_starts = [x - self.expected_length for x in self.packet_starts if x >= self.expected_length]
+                    self.expected_length = None
+                    self.callback(message)  # Call the callback with the parsed message
+
+                except DecodeError:
+                    self.discard_packet()
+            else:
+                return
+
+    def discard_packet(self):
+        self.packet_starts.pop(0)
+        if len(self.packet_starts) > 0:
+            self.buffer = self.buffer[self.packet_starts[0]:]
+            self.packet_starts = [x - self.packet_starts[0] for x in self.packet_starts]
+        else:
+            self.buffer = bytearray()
+            self.packet_starts = []
+        self.expected_length = None
+
 class VehicleBluetooth(Commands):
     """Class describing the Tesla Fleet API vehicle endpoints and commands for a specific vehicle with command signing."""
 
@@ -83,8 +148,7 @@ class VehicleBluetooth(Commands):
     client: BleakClient | None = None
     _queues: dict[Domain, asyncio.Queue]
     _ekey: ec.EllipticCurvePublicKey
-    _recv: bytearray = bytearray()
-    _recv_len: int = 0
+    _buffer: ReassemblingBuffer
     _auth_method = "aes"
 
     def __init__(
@@ -98,6 +162,7 @@ class VehicleBluetooth(Commands):
         }
         self.device = device
         self._connect_lock = asyncio.Lock()
+        self._buffer = ReassemblingBuffer(self._on_message)
 
     async def find_vehicle(self, name: str | None = None, address: str | None = None, scanner: BleakScanner | None = None) -> BLEDevice:
         """Find the Tesla BLE device."""
@@ -146,6 +211,7 @@ class VehicleBluetooth(Commands):
         """Connect to the Tesla BLE device if not already connected."""
         async with self._connect_lock:
             if not self.client or not self.client.is_connected:
+                LOGGER.info(f"Reconnecting to {self.ble_name}")
                 await self.connect(max_attempts=max_attempts)
 
     async def __aenter__(self) -> VehicleBluetooth:
@@ -157,63 +223,36 @@ class VehicleBluetooth(Commands):
         """Exit the async context."""
         await self.disconnect()
 
-    async def _on_notify(self,sender: BleakGATTCharacteristic,data : bytearray) -> None:
+    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')
-            if self._recv_len > 1024:
-                LOGGER.error("Parsed very large message length")
-                self._recv = bytearray()
-                self._recv_len = 0
-                return
-            self._recv = data[2:]
-        #while len(self._recv) > self._recv_len:
-        #
-        #    # Maybe this needs to trigger a reset
-        #    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:
-            if len(self._recv) > self._recv_len:
-                LOGGER.debug(f"Received more data than expected: {len(self._recv)} > {self._recv_len}")
-            try:
-                msg = RoutableMessage.FromString(bytes(self._recv[:self._recv_len]))
-                await self._on_message(msg)
-                self._recv = bytearray()
-                self._recv_len = 0
-            except DecodeError:
-                # Attempt parsing the whole payload
-                msg = RoutableMessage.FromString(bytes(self._recv))
-                LOGGER.warn(f"Parsed more data than length: {len(self._recv)} > {self._recv_len}")
-                await self._on_message(msg)
-                self._recv = bytearray()
-                self._recv_len = 0
-
-    async def _on_message(self, msg: RoutableMessage) -> None:
+        if sender.uuid != READ_UUID:
+            LOGGER.error(f"Unexpected sender: {sender}")
+            return
+        self._buffer.receive_data(data)
+
+    def _on_message(self, msg: RoutableMessage) -> None:
         """Receive messages from the Tesla BLE data."""
 
         if(msg.to_destination.routing_address != self._from_destination):
             # Ignore ephemeral key broadcasts
             return
 
-        LOGGER.debug(f"Received response: {msg}")
-        await self._queues[msg.from_destination.domain].put(msg)
+        LOGGER.info(f"Received response: {msg}")
+        self._queues[msg.from_destination.domain].put_nowait(msg)
 
-    async def _send(self, msg: RoutableMessage, requires: str, timeout: int = 2) -> RoutableMessage:
+    async def _send(self, msg: RoutableMessage, requires: str, timeout: int = 5) -> 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}")
+            LOGGER.info(f"Sending message {msg}")
 
             payload = prependLength(msg.SerializeToString())
 
             # Empty the queue before sending the message
             while not self._queues[domain].empty():
-                await self._queues[domain].get()
+                msg = await self._queues[domain].get()
+                LOGGER.warning(f"Discarded message {msg}")
 
             await self.connect_if_needed()
             assert self.client is not None
@@ -221,6 +260,7 @@ class VehicleBluetooth(Commands):
 
             # Process the response
             async with asyncio.timeout(timeout):
+                LOGGER.info(f"Waiting for response with {requires}")
                 while True:
                     resp = await self._queues[domain].get()
                     LOGGER.debug(f"Received message {resp}")
@@ -229,6 +269,8 @@ class VehicleBluetooth(Commands):
 
                     if resp.HasField(requires):
                         return resp
+                    else:
+                        LOGGER.warning(f"Ignoring message since it does not contain the required field {requires}, {resp.HasField(requires)}")
 
     async def query_display_name(self, max_attempts=5) -> str | None:
         """Read the device name via GATT characteristic if available"""
@@ -270,6 +312,11 @@ class VehicleBluetooth(Commands):
             LOGGER.error(f"Failed to read device version: {e}")
         return None
 
+    async def _command(self, domain: Domain, command: bytes, attempt: int = 0) -> dict[str, Any]:
+        """Serialize a message and send to the signed command endpoint."""
+        await self.connect_if_needed()
+        return await super()._command(domain, command, attempt)
+
     async def pair(self, role: Role = Role.ROLE_OWNER, form: KeyFormFactor = KeyFormFactor.KEY_FORM_FACTOR_CLOUD_KEY, timeout: int = 60):
         """Pair the key."""
 

tesla_fleet_api/tesla/vehicle/commands.py

@@ -269,7 +269,6 @@ class Commands(Vehicle):
         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."""
         session = self._sessions[domain]

tesla_fleet_api/tesla/vehicle/vehicles.py

@@ -1,16 +1,12 @@
 from __future__ import annotations
-import asyncio
 from typing import TYPE_CHECKING
-from bleak import BleakClient
 from bleak.backends.device import BLEDevice
-from bleak_retry_connector import establish_connection
 from cryptography.hazmat.primitives.asymmetric import ec
 
 from tesla_fleet_api.tesla.vehicle.signed import VehicleSigned
-from tesla_fleet_api.tesla.vehicle.bluetooth import NAME_UUID, VehicleBluetooth
+from tesla_fleet_api.tesla.vehicle.bluetooth import VehicleBluetooth
 from tesla_fleet_api.tesla.vehicle.fleet import VehicleFleet
 from tesla_fleet_api.tesla.vehicle.vehicle import Vehicle
-from tesla_fleet_api.const import LOGGER
 
 if TYPE_CHECKING:
     from tesla_fleet_api.tesla.fleet import TeslaFleetApi

tesla_fleet_api/teslemetry/__init__.py

@@ -1,5 +1,14 @@
 from tesla_fleet_api.teslemetry.teslemetry import Teslemetry
+from tesla_fleet_api.tesla.charging import Charging
+from tesla_fleet_api.tesla.energysite import EnergySites
+from tesla_fleet_api.tesla.user import User
+from tesla_fleet_api.teslemetry.vehicles import TeslemetryVehicles as Vehicles, TeslemetryVehicle as Vehicle
 
 __all__ = [
     "Teslemetry",
+    "Charging",
+    "EnergySites",
+    "User",
+    "Vehicles",
+    "Vehicle",
 ]

tesla_fleet_api/teslemetry/vehicles.py

@@ -2,18 +2,13 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, Any
 
 from tesla_fleet_api.const import Method
-from tesla_fleet_api.tesla.vehicle.vehicle import Vehicle
 from tesla_fleet_api.tesla.vehicle.vehicles import Vehicles
 from tesla_fleet_api.tesla.vehicle.fleet import VehicleFleet
 
 if TYPE_CHECKING:
     pass
 
-class TeslemetryVehicle(Vehicle):
-    """Teslemetry specific base vehicle."""
-    pass
-
-class TeslemetryVehicleFleet(VehicleFleet):
+class TeslemetryVehicle(VehicleFleet):
     """Teslemetry specific API vehicle."""
 
     async def server_side_polling(
@@ -52,22 +47,22 @@ class TeslemetryVehicleFleet(VehicleFleet):
 class TeslemetryVehicles(Vehicles):
     """Class containing and creating vehicles."""
 
-    Fleet = TeslemetryVehicleFleet
-
-    def create(self, vin: str) -> TeslemetryVehicleFleet:
-        """Creates a specific vehicle."""
-        return self.createFleet(vin)
+    Vehicle = TeslemetryVehicle
 
-    def createFleet(self, vin: str) -> TeslemetryVehicleFleet:
+    def create(self, vin: str) -> TeslemetryVehicle:
         """Creates a specific vehicle."""
-        vehicle = self.Fleet(self._parent, vin)
+        vehicle = self.Vehicle(self._parent, vin)
         self[vin] = vehicle
         return vehicle
 
+    def createFleet(self, vin: str):
+        """Creates a specific vehicle."""
+        raise NotImplementedError("Teslemetry cannot use Fleet API directly")
+
     def createSigned(self, vin: str):
         """Creates a specific vehicle."""
-        raise NotImplementedError("Signing is handled by Teslemetry server-side")
+        raise NotImplementedError("Teslemetry cannot use Fleet API directly")
 
     def createBluetooth(self, vin: str):
         """Creates a specific vehicle."""
-        raise NotImplementedError("Bluetooth is only handled locally")
+        raise NotImplementedError("Teslemetry cannot use local Bluetooth")

tesla_fleet_api/tessie/__init__.py

@@ -1,5 +1,14 @@
 from tesla_fleet_api.tessie.tessie import Tessie
+from tesla_fleet_api.tesla.charging import Charging
+from tesla_fleet_api.tesla.energysite import EnergySites
+from tesla_fleet_api.tesla.user import User
+from tesla_fleet_api.tessie.vehicles import TessieVehicles as Vehicles, TessieVehicle as Vehicle
 
 __all__ = [
     "Tessie",
+    "Charging",
+    "EnergySites",
+    "User",
+    "Vehicles",
+    "Vehicle",
 ]

tesla_fleet_api/tessie/vehicles.py

@@ -1,37 +1,32 @@
 from __future__ import annotations
 
-from tesla_fleet_api.tesla.vehicle.vehicle import Vehicle
 from tesla_fleet_api.tesla.vehicle.vehicles import Vehicles
 from tesla_fleet_api.tesla.vehicle.fleet import VehicleFleet
 
 
-class TessieVehicle(Vehicle):
-    """Tessie specific base vehicle."""
-    pass
-
-class TessieVehicleFleet(VehicleFleet):
+class TessieVehicle(VehicleFleet):
     """Tessie specific API vehicle."""
     pass
 
 class TessieVehicles(Vehicles):
     """Class containing and creating vehicles."""
 
-    Fleet = TessieVehicleFleet
-
-    def create(self, vin: str) -> TessieVehicleFleet:
-        """Creates a specific vehicle."""
-        return self.createFleet(vin)
+    Vehicle = TessieVehicle
 
-    def createFleet(self, vin: str) -> TessieVehicleFleet:
+    def create(self, vin: str) -> TessieVehicle:
         """Creates a specific vehicle."""
-        vehicle = self.Fleet(self._parent, vin)
+        vehicle = self.Vehicle(self._parent, vin)
         self[vin] = vehicle
         return vehicle
 
+    def createFleet(self, vin: str):
+        """Creates a specific vehicle."""
+        raise NotImplementedError("Tessie cannot use Fleet API directly")
+
     def createSigned(self, vin: str):
         """Creates a specific vehicle."""
-        raise NotImplementedError("Signing is handled by Tessie server-side")
+        raise NotImplementedError("Tessie cannot use Fleet API directly")
 
     def createBluetooth(self, vin: str):
         """Creates a specific vehicle."""
-        raise NotImplementedError("Bluetooth is only handled locally")
+        raise NotImplementedError("Tessie cannot use local Bluetooth")

tesla_fleet_api-1.0.13.dist-info/METADATA

@@ -0,0 +1,254 @@
+Metadata-Version: 2.2
+Name: tesla_fleet_api
+Version: 1.0.13
+Summary: Tesla Fleet API library for Python
+Home-page: https://github.com/Teslemetry/python-tesla-fleet-api
+Author: Brett Adams
+Author-email: hello@teslemetry.com
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp
+Requires-Dist: aiofiles
+Requires-Dist: aiolimiter
+Requires-Dist: cryptography
+Requires-Dist: protobuf
+Requires-Dist: bleak
+Requires-Dist: bleak-retry-connector
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Tesla Fleet API
+
+Tesla Fleet API is a Python library that provides an interface to interact with Tesla's Fleet API, including signed commands and encrypted local Bluetooth (BLE) communication. It also supports interactions with Teslemetry and Tessie services.
+
+## Features
+
+- Fleet API for vehicles
+- Fleet API for energy sites
+- Fleet API with signed vehicle commands
+- Bluetooth for vehicles
+- Teslemetry integration
+- Tessie integration
+
+## Installation
+
+You can install the library using pip:
+
+```bash
+pip install tesla-fleet-api
+```
+
+## Usage
+
+### Authentication
+
+The `TeslaFleetOAuth` class provides methods that help with authenticating to the Tesla Fleet API. Here's a basic example:
+
+```python
+import asyncio
+import aiohttp
+from tesla_fleet_api import TeslaFleetOAuth
+
+async def main():
+    async with aiohttp.ClientSession() as session:
+        oauth = TeslaFleetOAuth(
+            session=session,
+            client_id="<client_id>",
+            client_secret="<client_secret>",
+            redirect_uri="<redirect_uri>",
+        )
+
+        # Get the login URL and navigate the user to it
+        login_url = oauth.get_login_url(scopes=["openid", "email", "offline_access"])
+        print(f"Please go to {login_url} and authorize access.")
+
+        # After the user authorizes access, they will be redirected to the redirect_uri with a code
+        code = input("Enter the code you received: ")
+
+        # Exchange the code for a refresh token
+        await oauth.get_refresh_token(code)
+        print(f"Access token: {oauth.access_token}")
+        print(f"Refresh token: {oauth.refresh_token}")
+        # Dont forget to store the refresh token so you can use it again later
+
+asyncio.run(main())
+```
+
+### Fleet API for Vehicles
+
+The `TeslaFleetApi` class provides methods to interact with the Fleet API for vehicles. Here's a basic example:
+
+```python
+import asyncio
+import aiohttp
+from tesla_fleet_api import TeslaFleetApi
+from tesla_fleet_api.exceptions import TeslaFleetError
+
+async def main():
+    async with aiohttp.ClientSession() as session:
+        api = TeslaFleetApi(
+            access_token="<access_token>",
+            session=session,
+            region="na",
+        )
+
+        try:
+            data = await api.vehicles.list()
+            print(data)
+        except TeslaFleetError as e:
+            print(e)
+
+asyncio.run(main())
+```
+
+For more detailed examples, see [Fleet API for Vehicles](docs/fleet_api_vehicles.md).
+
+### Fleet API for Energy Sites
+
+The `EnergySites` class provides methods to interact with the Fleet API for energy sites. Here's a basic example:
+
+```python
+import asyncio
+import aiohttp
+from tesla_fleet_api import TeslaFleetApi
+from tesla_fleet_api.exceptions import TeslaFleetError
+
+async def main():
+    async with aiohttp.ClientSession() as session:
+        api = TeslaFleetApi(
+            access_token="<access_token>",
+            session=session,
+            region="na",
+        )
+
+        try:
+            energy_sites = await api.energySites.list()
+            print(energy_sites)
+        except TeslaFleetError as e:
+            print(e)
+
+asyncio.run(main())
+```
+
+For more detailed examples, see [Fleet API for Energy Sites](docs/fleet_api_energy_sites.md).
+
+### Fleet API with Signed Vehicle Commands
+
+The `VehicleSigned` class provides methods to interact with the Fleet API using signed vehicle commands. Here's a basic example:
+
+```python
+import asyncio
+import aiohttp
+from tesla_fleet_api import TeslaFleetApi
+from tesla_fleet_api.tesla.vehicle.signed import VehicleSigned
+from tesla_fleet_api.exceptions import TeslaFleetError
+
+async def main():
+    async with aiohttp.ClientSession() as session:
+        api = TeslaFleetApi(
+            access_token="<access_token>",
+            session=session,
+            region="na",
+        )
+
+        try:
+            vehicle = VehicleSigned(api, "<vin>")
+            await vehicle.handshake()
+            data = await vehicle.wake_up()
+            print(data)
+        except TeslaFleetError as e:
+            print(e)
+
+asyncio.run(main())
+```
+
+For more detailed examples, see [Fleet API with Signed Vehicle Commands](docs/fleet_api_signed_commands.md).
+
+### Bluetooth for Vehicles
+
+The `TeslaBluetooth` class provides methods to interact with Tesla vehicles using Bluetooth. Here's a basic example:
+
+```python
+import asyncio
+from bleak import BleakScanner
+from tesla_fleet_api import TeslaBluetooth
+
+async def main():
+    scanner = BleakScanner()
+    devices = await scanner.discover()
+    for device in devices:
+        if TeslaBluetooth().valid_name(device.name):
+            print(f"Found Tesla vehicle: {device.name}")
+
+asyncio.run(main())
+```
+
+For more detailed examples, see [Bluetooth for Vehicles](docs/bluetooth_vehicles.md).
+
+### Teslemetry
+
+The `Teslemetry` class provides methods to interact with the Teslemetry service. Here's a basic example:
+
+```python
+import asyncio
+import aiohttp
+from tesla_fleet_api import Teslemetry
+from tesla_fleet_api.exceptions import TeslaFleetError
+
+async def main():
+    async with aiohttp.ClientSession() as session:
+        api = Teslemetry(
+            access_token="<access_token>",
+            session=session,
+        )
+
+        try:
+            data = await api.vehicles.list()
+            print(data)
+        except TeslaFleetError as e:
+            print(e)
+
+asyncio.run(main())
+```
+
+For more detailed examples, see [Teslemetry](docs/teslemetry.md).
+
+### Tessie
+
+The `Tessie` class provides methods to interact with the Tessie service. Here's a basic example:
+
+```python
+import asyncio
+import aiohttp
+from tesla_fleet_api import Tessie
+from tesla_fleet_api.exceptions import TeslaFleetError
+
+async def main():
+    async with aiohttp.ClientSession() as session:
+        api = Tessie(
+            access_token="<access_token>",
+            session=session,
+        )
+
+        try:
+            data = await api.vehicles.list()
+            print(data)
+        except TeslaFleetError as e:
+            print(e)
+
+asyncio.run(main())
+```
+
+For more detailed examples, see [Tessie](docs/tessie.md).

{tesla_fleet_api-1.0.11.dist-info → tesla_fleet_api-1.0.13.dist-info}/RECORD

@@ -1,23 +1,23 @@
 tesla_fleet_api/__init__.py,sha256=3DZMoZ-5srW-7SooAjqcRubQDuZPY8rMKH7eqIp4qtg,392
-tesla_fleet_api/const.py,sha256=TSs1sofg_Dv2Q-NEcVOB10GNbF0cU25NcO7WooMLoOk,3749
+tesla_fleet_api/const.py,sha256=5-oJdYgUuRnEr7ZwnJGoYXWLViNVxfFPmkYHzC5SAYs,3900
 tesla_fleet_api/exceptions.py,sha256=GvjJBR77xGt2g3vhiAxcNtysj-e1Me7F-9PwO9dyzOo,35430
 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/__init__.py,sha256=1XjIJWgHsYHLw9qgiVRh4FrHVOH9V8tGF0hE92PQhX8,769
 tesla_fleet_api/tesla/bluetooth.py,sha256=lyPRVf1YdcElrYBsKOMCaLwMPE9rO7Iw1a6nE7VUZ94,2369
 tesla_fleet_api/tesla/charging.py,sha256=D7I7cAf-3-95sIjyP6wpVqCq9Cppj6U-VPFQGpQQ8bs,1704
 tesla_fleet_api/tesla/energysite.py,sha256=vStffklBQfQNAO_1wrHLFu7BlBCTVVbLh7_IrAUL3wg,6131
-tesla_fleet_api/tesla/fleet.py,sha256=zfmagXF4TbbVOPWcngCSKebaGB1daXbw8mTJ9o8einY,5432
+tesla_fleet_api/tesla/fleet.py,sha256=L82pVz7GJ8wKkUGqvvYnx9Kc13Bpu9LhDtmt4CV7H0g,5388
 tesla_fleet_api/tesla/oauth.py,sha256=aWBsWmnM-QxzaU8W9TXVNxGsYn_LraXnpexwdE8wOqo,4104
 tesla_fleet_api/tesla/partner.py,sha256=e-l6sEP6-IupjFEQieSUjhhvRXF3aL4ebPNahcGFRCE,1238
 tesla_fleet_api/tesla/tesla.py,sha256=Gs8-L3OsEMhs1N_vdDx-E46bOHKGowXTBxmRiP8NKh4,2391
 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=8SB3fDdJ1E8jDsaL6cix0Ks0lwlkvOLQ0_3lNZwWs1M,19064
-tesla_fleet_api/tesla/vehicle/commands.py,sha256=_LXAtuAIkeojJuw8k1QjEabAQQH2MLD5YZyUH58QoSg,51288
+tesla_fleet_api/tesla/vehicle/__init__.py,sha256=EYqPyPjaD9JP846c1iGBkk697VZ-eY_tcHntDixhDGE,425
+tesla_fleet_api/tesla/vehicle/bluetooth.py,sha256=rMxKOrc8T3Wz_sbuGYFot4ffCbOVP2jFSCd5tVuSWv0,21035
+tesla_fleet_api/tesla/vehicle/commands.py,sha256=L3apfGwry-IBuSSLbuoPPjW_q4new2xTr6Iy_kUa2pA,51268
 tesla_fleet_api/tesla/vehicle/fleet.py,sha256=K9BVZj6CChJSDSMFroa7Cz0KrsYWj32ILtQumarkLaU,32080
 tesla_fleet_api/tesla/vehicle/signed.py,sha256=RUzVnZIfykz3YZW2gaxd1iaN1i8LkLaEoiXrbqZn9kg,1339
 tesla_fleet_api/tesla/vehicle/vehicle.py,sha256=IBvRO6qGkUf4bi-pFongA9fIe9iScvz_wGXtzEJXilY,870
-tesla_fleet_api/tesla/vehicle/vehicles.py,sha256=wU0wXa57BD7InaUC1xoRhVc7oI5CemsocSryuUItyGI,2792
+tesla_fleet_api/tesla/vehicle/vehicles.py,sha256=c1KFTAYDvuTVNjM5O23KvT54UbNwo3ofFVpfkY-Mq5Y,2640
 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
@@ -38,14 +38,14 @@ tesla_fleet_api/tesla/vehicle/proto/vcsec_pb2.py,sha256=PDv9TfiXnNs6sQ0D5vBrsSSP
 tesla_fleet_api/tesla/vehicle/proto/vcsec_pb2.pyi,sha256=cyK1uyRtDjRVqVlyl5uRQYY1RhFlWSJheLg3PGfs-_s,28524
 tesla_fleet_api/tesla/vehicle/proto/vehicle_pb2.py,sha256=bqyFJM-1qZ7W9XKREINhYZx8yXAudmq6W8_Pdfkhbkk,44711
 tesla_fleet_api/tesla/vehicle/proto/vehicle_pb2.pyi,sha256=sAUW_9aVB8NqJCnhZjXMLfqfePLVZv_7PfSKZKEBaQA,74251
-tesla_fleet_api/teslemetry/__init__.py,sha256=CX7rMtlTuVvXoH9GkOAkQBTtM13ltuOO6EsGELuzQzY,94
+tesla_fleet_api/teslemetry/__init__.py,sha256=Vh7mh2r0L-7Oh-tIs5sAtHmE3OWV7UtyIbeazlTTHcc,434
 tesla_fleet_api/teslemetry/teslemetry.py,sha256=wcZOD1GnZ4lwC9LoicuSNbZ3z-ka9I4m1AMZP4LDYCY,3088
-tesla_fleet_api/teslemetry/vehicles.py,sha256=9nybVg7VHKLa2woMG6fzMmQP6xJIE_jdAdScXytxElI,2209
-tesla_fleet_api/tessie/__init__.py,sha256=9lhQJaB6X4PObUL9QdaaZYqs2BxiTidu3zmHcBESLVw,78
+tesla_fleet_api/teslemetry/vehicles.py,sha256=IJMRKb3jrW9ZSdJrCQ5wOYYZGVbFvSVza24Zpdh4d_0,2067
+tesla_fleet_api/tessie/__init__.py,sha256=WCH4z4WCjYEcSqQRwpWydZ6yulWA6422l4J55XfPmPg,406
 tesla_fleet_api/tessie/tessie.py,sha256=uhg0oOIxpwDvlvdBhKHeF3AGR2PzmdBgzh2-_EkmSq0,2617
-tesla_fleet_api/tessie/vehicles.py,sha256=gfEatilI_ct-R4CM5xYhrlduqCR9IHlyc56WmJf7v7k,1149
-tesla_fleet_api-1.0.11.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-tesla_fleet_api-1.0.11.dist-info/METADATA,sha256=YYe4EpiOI6j7CcrDsOs0HsjKgYQs3YPwKL9wceXFNcU,4383
-tesla_fleet_api-1.0.11.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
-tesla_fleet_api-1.0.11.dist-info/top_level.txt,sha256=jeNbog_1saXBFrGpom9WyPWmilxsyP3szL_G7JLWQfM,16
-tesla_fleet_api-1.0.11.dist-info/RECORD,,
+tesla_fleet_api/tessie/vehicles.py,sha256=Cdp0pt2Z8bzK5T9wQ8_KubGSZ3Gevx1Q18kqJqEUxfs,1011
+tesla_fleet_api-1.0.13.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+tesla_fleet_api-1.0.13.dist-info/METADATA,sha256=x8_qvQ6DGF46nxDlnUTnRpekd6j65bT_rSCmfXPN_fo,6960
+tesla_fleet_api-1.0.13.dist-info/WHEEL,sha256=beeZ86-EfXScwlR_HKu4SllMC9wUEj_8Z_4FJ3egI2w,91
+tesla_fleet_api-1.0.13.dist-info/top_level.txt,sha256=jeNbog_1saXBFrGpom9WyPWmilxsyP3szL_G7JLWQfM,16
+tesla_fleet_api-1.0.13.dist-info/RECORD,,

{tesla_fleet_api-1.0.11.dist-info → tesla_fleet_api-1.0.13.dist-info}/WHEEL

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

tesla_fleet_api-1.0.11.dist-info/METADATA

@@ -1,158 +0,0 @@
-Metadata-Version: 2.2
-Name: tesla_fleet_api
-Version: 1.0.11
-Summary: Tesla Fleet API library for Python
-Home-page: https://github.com/Teslemetry/python-tesla-fleet-api
-Author: Brett Adams
-Author-email: hello@teslemetry.com
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: Apache Software License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: aiohttp
-Requires-Dist: aiofiles
-Requires-Dist: aiolimiter
-Requires-Dist: cryptography
-Requires-Dist: protobuf
-Requires-Dist: bleak
-Requires-Dist: bleak-retry-connector
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
-
-# Tesla Fleet Api
-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) 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.
-
-```
-import asyncio
-import aiohttp
-
-from tesla_fleet_api import TeslaFleetApi
-from tesla_fleet_api.exceptions import TeslaFleetError
-
-
-async def main():
-    async with aiohttp.ClientSession() as session:
-        api = TeslaFleetApi(
-            access_token="<access_token>",
-            session=session,
-            region="na",
-        )
-
-        try:
-            data = await api.vehicle.list()
-            print(data)
-        except TeslaFleetError as e:
-            print(e)
-
-asyncio.run(main())
-```
-
-## TeslaFleetOAuth
-This extends TeslaFleetApi to support OAuth, and requires a client_id, and either a refresh_token or initial authentication code.
-
-```
-from tesla_fleet_api import TeslaFleetOAuth
-from tesla_fleet_api.exceptions import TeslaFleetError
-import json
-
-async def main():
-    with open("auth.json", "r") as f:
-        auth = json.load(f)
-    async with aiohttp.ClientSession() as session:
-        api = TeslaFleetOAuth(
-            session,
-            client_id=<client_id>,
-            access_token=auth["access_token"],
-            refresh_token=auth["refresh_token"],
-            expires=auth["expires"],
-            region="na",
-        )
-        try:
-            data = await api.vehicle.list()
-            print(data)
-        except TeslaFleetError as e:
-            print(e)
-
-    with open("auth.json", "w") as f:
-        json.dump(
-            {
-                "access_token": api.access_token,
-                "refresh_token": api.refresh_token,
-                "expires": api.expires,
-            },
-            f,
-        )
-
-asyncio.run(main())
-```
-
-## Teslemetry
-This extends TeslaFleetApi to send requests through Teslemetry, which manages all aspects of Tesla OAuth. This class only requires an access_token from the Teslemetry console.
-
-```
-import asyncio
-import aiohttp
-
-from tesla_fleet_api import Teslemetry
-from tesla_fleet_api.exceptions import TeslaFleetError
-
-
-async def main():
-    async with aiohttp.ClientSession() as session:
-        api = Teslemetry(
-            access_token="<access_token>",
-            session=session,
-        )
-
-        try:
-            data = await api.vehicle.list()
-            print(data)
-        except TeslaFleetError as e:
-            print(e)
-
-asyncio.run(main())
-```
-
-## Tessie
-This extends TeslaFleetApi to send requests through Tessie, which manages all aspects of Tesla OAuth. This class only requires an access_token from [Tessie](https://dash.tessie.com/settings/api).
-
-```
-import asyncio
-import aiohttp
-
-from tesla_fleet_api import Tessie
-from tesla_fleet_api.exceptions import TeslaFleetError
-
-
-async def main():
-    async with aiohttp.ClientSession() as session:
-        api = Tessie(
-            access_token="<access_token>",
-            session=session,
-        )
-
-        try:
-            data = await api.vehicle.list()
-            print(data)
-        except TeslaFleetError as e:
-            print(e)
-
-asyncio.run(main())
-```