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

tesla_fleet_api/tesla/vehicle/signed.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+import base64
+from typing import TYPE_CHECKING
+
+from .fleet import VehicleFleet
+from .commands import Commands
+
+from ...exceptions import (
+    MESSAGE_FAULTS,
+)
+from .proto.signatures_pb2 import (
+    SessionInfo,
+)
+from .proto.universal_message_pb2 import (
+    RoutableMessage,
+)
+
+if TYPE_CHECKING:
+    from ..fleet import TeslaFleetApi
+
+
+class VehicleSigned(VehicleFleet, Commands):
+    """Class describing the Tesla Fleet API vehicle endpoints and commands for a specific vehicle with command signing."""
+
+
+    _auth_method = "hmac"
+
+    def __init__(self, parent: TeslaFleetApi, vin: str):
+        """Initialize the VehicleSigned class."""
+        super().__init__(parent, vin)
+        super(Commands, self).__init__(parent, vin)
+
+
+    async def _send(self, msg: RoutableMessage) -> RoutableMessage:
+        """Serialize a message and send to the signed command endpoint."""
+
+        async with self._sessions[msg.to_destination.domain].lock:
+            resp = await self.signed_command(
+                base64.b64encode(msg.SerializeToString()).decode()
+            )
+
+            resp_msg = RoutableMessage.FromString(base64.b64decode(resp["response"]))
+
+            # Check UUID?
+            # Check RoutingAdress?
+
+            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

tesla_fleet_api/tesla/vehicle/vehicle.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+
+if TYPE_CHECKING:
+    from ..tesla import Tesla
+
+
+class Vehicle:
+    """Base class describing a Tesla vehicle."""
+
+    vin: str
+
+    def __init__(self, parent: Tesla, vin: str):
+        self.vin = vin
+
+    def pre2021(self, vin: str) -> bool:
+        """Checks if a vehicle is a pre-2021 model S or X."""
+        return vin[3] in ["S", "X"] and (vin[9] <= "L" or (vin[9] == "M" and vin[7] in ['1', '2', '3', '4']))

tesla_fleet_api/tesla/vehicle/vehicles.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+from .signed import VehicleSigned
+from .bluetooth import VehicleBluetooth
+from .fleet import VehicleFleet
+from .vehicle import Vehicle
+
+if TYPE_CHECKING:
+    from ..fleet import TeslaFleetApi
+
+
+
+class Vehicles(dict[str, Vehicle]):
+    """Class containing and creating vehicles."""
+
+    _parent: TeslaFleetApi
+
+    def __init__(self, parent: TeslaFleetApi):
+        self._parent = parent
+
+    def createFleet(self, vin: str) -> VehicleFleet:
+        """Creates a Fleet API vehicle."""
+        vehicle = VehicleFleet(self._parent, vin)
+        self[vin] = vehicle
+        return vehicle
+
+    def createSigned(self, vin: str) -> VehicleSigned:
+        """Creates a Fleet API vehicle that uses command protocol."""
+        vehicle = VehicleSigned(self._parent, vin)
+        self[vin] = vehicle
+        return vehicle
+
+    def createBluetooth(self, vin: str) -> VehicleBluetooth:
+        """Creates a bluetooth vehicle that uses command protocol."""
+        vehicle = VehicleBluetooth(self._parent, vin)
+        self[vin] = vehicle
+        return vehicle
+
+    def specific(self, vin: str) -> Vehicle:
+        """Legacy method for creating a Fleet API vehicle."""
+        return self.createFleet(vin)
+
+    def specificSigned(self, vin: str) -> VehicleSigned:
+        """Legacy method for creating a Fleet API vehicle that uses command protocol."""
+        return self.createSigned(vin)

tesla_fleet_api/teslemetry/__init__.py

@@ -0,0 +1,5 @@
+from .teslemetry import Teslemetry
+
+__all__ = [
+    "Teslemetry",
+]

tesla_fleet_api/{teslemetry.py → teslemetry/teslemetry.py}

@@ -1,30 +1,32 @@
 from typing import Any
 
 import aiohttp
-from aiolimiter import AsyncLimiter
 
-from .const import LOGGER, Method
-from .teslafleetapi import TeslaFleetApi
+from ..tesla.charging import Charging
+from ..tesla.energysite import EnergySites
+from ..tesla.user import User
+from .vehicle import TeslemetryVehicles
+from ..const import LOGGER, Method
+from ..tesla import TeslaFleetApi
 
-# Rate limit should be global, even if multiple instances are created
-rate_limit = AsyncLimiter(5, 10)
+class Teslemetry(TeslaFleetApi):
 
+    server = "https://api.teslemetry.com"
 
-class Teslemetry(TeslaFleetApi):
     def __init__(
         self,
         session: aiohttp.ClientSession,
         access_token: str,
     ):
         """Initialize the Teslemetry API."""
-        super().__init__(
-            session=session,
-            access_token=access_token,
-            server="https://api.teslemetry.com",
-            user_scope=False,
-            partner_scope=False,
-        )
-        self.rate_limit = rate_limit
+
+        self.session = session
+        self.access_token = access_token
+
+        self.charging = Charging(self)
+        self.energySites = EnergySites(self)
+        self.user = User(self)
+        self.vehicle = TeslemetryVehicles(self)
 
     async def ping(self) -> dict[str, bool]:
         """Send a ping."""
@@ -102,14 +104,3 @@ class Teslemetry(TeslaFleetApi):
             Method.GET,
             f"api/refresh/{vin}",
         )
-
-    async def _request(
-        self,
-        method: Method,
-        path: str,
-        params: dict[str, Any] | None = None,
-        json: dict[str, Any] | None = None,
-    ) -> dict[str, Any]:
-        """Send a request to the Teslemetry API."""
-        async with rate_limit:
-            return await super()._request(method, path, params, json)

tesla_fleet_api/teslemetry/vehicle.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING, Any
+
+from ..const import Method
+from ..tesla.vehicle.proto.universal_message_pb2 import Domain
+from ..tesla.vehicle.vehicle import Vehicle
+from ..tesla.vehicle.vehicles import Vehicles
+from ..tesla.vehicle.bluetooth import VehicleBluetooth
+from ..tesla.vehicle.fleet import VehicleFleet
+
+if TYPE_CHECKING:
+    from .teslemetry import Teslemetry
+
+class TeslemetryVehicle(Vehicle):
+    """Teslemetry specific base vehicle."""
+    pass
+
+class TeslemetryVehicleFleet(VehicleFleet):
+    """Teslemetry specific API vehicle."""
+
+    async def server_side_polling(
+        self, value: bool | None = None
+    ) -> bool | None:
+        """Get or set Auto mode."""
+        if value is True:
+            return (
+                await self._request(
+                    Method.POST,
+                    f"api/auto/{self.vin}",
+                )
+            ).get("response")
+        if value is False:
+            return (
+                await self._request(
+                    Method.DELETE,
+                    f"api/auto/{self.vin}",
+                )
+            ).get("response")
+        return (
+            await self._request(
+                Method.GET,
+                f"api/auto/{self.vin}",
+            )
+        ).get("response")
+
+    async def data_refresh(self) -> dict[str, Any]:
+        """Force a refresh of the vehicle data."""
+        return await self._request(
+            Method.GET,
+            f"api/refresh/{self.vin}",
+        )
+
+
+class TeslemetryVehicles(Vehicles):
+    """Class containing and creating vehicles."""
+
+    def create(self, vin: str) -> TeslemetryVehicleFleet:
+        """Creates a specific vehicle."""
+        return self.createFleet(vin)
+
+    def createFleet(self, vin: str) -> TeslemetryVehicleFleet:
+        """Creates a specific vehicle."""
+        vehicle = TeslemetryVehicleFleet(self._parent, vin)
+        self[vin] = vehicle
+        return vehicle
+
+    def createSigned(self, vin: str):
+        """Creates a specific vehicle."""
+        raise NotImplementedError("Signing is handled by Teslemetry server-side")
+
+    def createBluetooth(self, vin: str):
+        """Creates a specific vehicle."""
+        raise NotImplementedError("Bluetooth is only handled locally")

tesla_fleet_api/tessie/__init__.py

@@ -0,0 +1,5 @@
+from .tessie import Tessie
+
+__all__ = [
+    "Tessie",
+]

tesla_fleet_api/{tessie.py → tessie/tessie.py}

@@ -1,23 +1,31 @@
 import aiohttp
 from typing import Any
-from .teslafleetapi import TeslaFleetApi
-from .const import Method
 
+from ..tesla.charging import Charging
+from ..tesla.energysite import EnergySites
+from ..tesla.user import User
+from ..tesla import TeslaFleetApi
+from ..const import Method
+from .vehicle import TessieVehicles
 
 class Tessie(TeslaFleetApi):
+
+    server="https://api.tessie.com"
+
     def __init__(
         self,
         session: aiohttp.ClientSession,
         access_token: str,
     ):
         """Initialize the Tessie API."""
-        super().__init__(
-            session,
-            access_token,
-            server="https://api.tessie.com",
-            partner_scope=False,
-            user_scope=False,
-        )
+
+        self.session = session
+        self.access_token = access_token
+
+        self.charging = Charging(self)
+        self.energySites = EnergySites(self)
+        self.user = User(self)
+        self.vehicle = TessieVehicles(self)
 
     async def scopes(self) -> list[str]:
         """Get user scopes."""

tesla_fleet_api/tessie/vehicle.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING, Any
+
+from ..const import Method
+from ..tesla.vehicle.proto.universal_message_pb2 import Domain
+from ..tesla.vehicle.vehicle import Vehicle
+from ..tesla.vehicle.vehicles import Vehicles
+from ..tesla.vehicle.bluetooth import VehicleBluetooth
+from ..tesla.vehicle.fleet import VehicleFleet
+
+if TYPE_CHECKING:
+    from .tessie import Tessie
+
+class TessieVehicle(Vehicle):
+    """Tessie specific base vehicle."""
+    pass
+
+class TessieVehicleFleet(VehicleFleet):
+    """Tessie specific API vehicle."""
+    pass
+
+class TessieVehicles(Vehicles):
+    """Class containing and creating vehicles."""
+
+    def create(self, vin: str) -> TessieVehicleFleet:
+        """Creates a specific vehicle."""
+        return self.createFleet(vin)
+
+    def createFleet(self, vin: str) -> TessieVehicleFleet:
+        """Creates a specific vehicle."""
+        vehicle = TessieVehicleFleet(self._parent, vin)
+        self[vin] = vehicle
+        return vehicle
+
+    def createSigned(self, vin: str):
+        """Creates a specific vehicle."""
+        raise NotImplementedError("Signing is handled by Tessie server-side")
+
+    def createBluetooth(self, vin: str):
+        """Creates a specific vehicle."""
+        raise NotImplementedError("Bluetooth is only handled locally")

{tesla_fleet_api-0.9.10.dist-info → tesla_fleet_api-1.0.1.dist-info}/METADATA

@@ -1,11 +1,11 @@
 Metadata-Version: 2.2
 Name: tesla_fleet_api
-Version: 0.9.10
+Version: 1.0.1
 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 :: 4 - Beta
+Classifier: Development Status :: 5 - Production/Stable
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
@@ -17,6 +17,7 @@ Requires-Dist: aiofiles
 Requires-Dist: aiolimiter
 Requires-Dist: cryptography
 Requires-Dist: protobuf
+Requires-Dist: bleak
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

tesla_fleet_api-1.0.1.dist-info/RECORD

@@ -0,0 +1,51 @@
+tesla_fleet_api/__init__.py,sha256=FewtEncMLxOZa3dVA3SsT3tY--RMNF9-GXIpOTkbXvk,396
+tesla_fleet_api/const.py,sha256=8KPO_bQbwwspp1Gm-DrHt4EsuQQSFsp1n9yMk0b2hZA,3158
+tesla_fleet_api/exceptions.py,sha256=nTo9MIJrAxL-UxzbrMrr00QhSvrLaSc6ee00Ko9pB1Q,34213
+tesla_fleet_api/ratecalculator.py,sha256=4lz8yruUeouHXh_3ezsXX-CTpIegp1T1J4VuRV_qdHA,1791
+tesla_fleet_api/tesla/__init__.py,sha256=sWIkVh4lesdp5eGQPC9Hjk_eoyN1_g9zz7vpMsJzTgo,219
+tesla_fleet_api/tesla/bluetooth.py,sha256=7L6U8_xr2JiAX2YJOCLcsCOD7NkGdLLSf3-qnopHQtg,1092
+tesla_fleet_api/tesla/charging.py,sha256=9zNSFi9vo8v03KQRKyosO5me49_tDrg3_25BRZibfQ0,1690
+tesla_fleet_api/tesla/energysite.py,sha256=jauUrh14LL-EaMruxhye1YsNHjtTMmgCl1HCf_8mBeI,6070
+tesla_fleet_api/tesla/fleet.py,sha256=NCkHLd-ddpa0wkSu_CEOG7ru9ea5HTLXud4lvkh3DWM,5516
+tesla_fleet_api/tesla/oauth.py,sha256=pFGtIcERjsNKrO5VUEHm8WsNo1xF4DVbx3Yt2MhlGPQ,4070
+tesla_fleet_api/tesla/partner.py,sha256=TU3Xg18x2w3PHv6Dy3Mo40pb417pp5lqnF0c1vDCt6g,1224
+tesla_fleet_api/tesla/tesla.py,sha256=Jlz90-fM0nJbhnQN0k3ukNv59-9KqZZbyQ91IiLIbfo,2010
+tesla_fleet_api/tesla/user.py,sha256=1LVwarEU-wmkqkPw0LGvNiPRy6uGRZkYL-vr17sz51M,1180
+tesla_fleet_api/tesla/vehicle/__init__.py,sha256=luJKFuTGxmo4ef4tURaZgYwdkmWqCQrjxKogQzlFBtI,265
+tesla_fleet_api/tesla/vehicle/bluetooth.py,sha256=QjnFT4UYNsS4UWD_Spq-2T6Qlh4HnVCX_1ZCS18XjT8,8153
+tesla_fleet_api/tesla/vehicle/commands.py,sha256=INHps_29kPjblFSFJdQCrf2Ob3tURy6J9pO85NbGDVU,46874
+tesla_fleet_api/tesla/vehicle/fleet.py,sha256=j9jGE6kGUnmlO6kvB2CBJcwaEPaJ-CGxP7Cgv2AI9AU,32018
+tesla_fleet_api/tesla/vehicle/signed.py,sha256=lhf_zzMc9xL9P2S8GC7IQC-CEVkQNUIrT_gR8AvODCc,1659
+tesla_fleet_api/tesla/vehicle/vehicle.py,sha256=kbL6o-doro5wD-pMBbFcphfSUz1jNApfAUDEZmleKNs,485
+tesla_fleet_api/tesla/vehicle/vehicles.py,sha256=gG7I9tCr3-fag5DSLK2lXayBpjbgEpE61DeDzJZs4f8,1449
+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
+tesla_fleet_api/tesla/vehicle/proto/car_server_pb2.pyi,sha256=qkig9HEsOE4Dk2-r38BAWOyALqt7CtUnlirgSVt_oa8,46334
+tesla_fleet_api/tesla/vehicle/proto/common_pb2.py,sha256=C5O6BBTckU3F-XItLfivaPG_XVCnzF_JX4mpVfM_jFk,3931
+tesla_fleet_api/tesla/vehicle/proto/common_pb2.pyi,sha256=8aZiigp74MfSOMpHtMw0D9Jj0kwPz1zV_BIZfVWhh_0,5012
+tesla_fleet_api/tesla/vehicle/proto/errors_pb2.py,sha256=nfOvriyjVgVxnJZIAYNRHiBa1_14dOXhC9Pokc5anV8,1631
+tesla_fleet_api/tesla/vehicle/proto/errors_pb2.pyi,sha256=CNsAR7Oe6wavnqjzhInEyAFxMio6TtXfaNT0DUztn6o,1478
+tesla_fleet_api/tesla/vehicle/proto/keys_pb2.py,sha256=-hyVP9-W1DypTYLaWwkOSUzgia6l9R3M9wUIgvNs-T0,1252
+tesla_fleet_api/tesla/vehicle/proto/keys_pb2.pyi,sha256=HH-TfhE5ihwmoPCGdiVnZ5B7KkaMJglEpusgLc1J02M,676
+tesla_fleet_api/tesla/vehicle/proto/managed_charging_pb2.py,sha256=4crkLo6uC0YPkgw90jRjAqlGMFnRze_koUt2-pw14m4,1430
+tesla_fleet_api/tesla/vehicle/proto/managed_charging_pb2.pyi,sha256=SqEmrfknTfzYTUYHtsoCpt1Fw2YpU3OyQllX247UfyQ,1227
+tesla_fleet_api/tesla/vehicle/proto/signatures_pb2.py,sha256=TRaJ6lzmJtryhhmBC_PbYzftc-pqCmwC6wuBCXHeuTg,4734
+tesla_fleet_api/tesla/vehicle/proto/signatures_pb2.pyi,sha256=-OGm9ctBnEJiXk-3nkFCPRTxKgFiqFgMbKeq3x2zGGM,6101
+tesla_fleet_api/tesla/vehicle/proto/universal_message_pb2.py,sha256=UklH73qoYsqxylie6IK8iIcw2tmykSqDiaBKSWz66OQ,5093
+tesla_fleet_api/tesla/vehicle/proto/universal_message_pb2.pyi,sha256=a_RygTJL26v0rA7QuUwsxiG1_ZBcliwXCqOAqTIJ6UE,7647
+tesla_fleet_api/tesla/vehicle/proto/vcsec_pb2.py,sha256=PDv9TfiXnNs6sQ0D5vBrsSSPinSqu3eBUwvTcG8xMWo,15919
+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=OnHrZEkPGVFrziwMA-vArvh5vgBn6vT_nMbIhjN49V0,68
+tesla_fleet_api/teslemetry/teslemetry.py,sha256=BtV__OSenTg_dwM0aovbL--mv3HhIIWtoWHQp58sViQ,2990
+tesla_fleet_api/teslemetry/vehicle.py,sha256=aCe4Vhs4WHd6OQ-gzdxsPubKF_C5aLBoHrDvzyVgucI,2277
+tesla_fleet_api/tessie/__init__.py,sha256=UNsWgx5w0DJSIFcMd7jBBdSxklF3Vhubq9tSL8vfegg,56
+tesla_fleet_api/tessie/tessie.py,sha256=Z6t-ulDL7zfBIAJ6L7EBUMux2iawWjR1cR4jvYIhVFg,2523
+tesla_fleet_api/tessie/vehicle.py,sha256=C2Q0en3Uo3xtI2sU9jSHXUtYhgBrNJYYhl8gP2zVmfQ,1315
+tesla_fleet_api-1.0.1.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+tesla_fleet_api-1.0.1.dist-info/METADATA,sha256=6wVdb-DMTVaAa9hKPrYQNjphXXMbE6Rabxf003sDSB8,4056
+tesla_fleet_api-1.0.1.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+tesla_fleet_api-1.0.1.dist-info/top_level.txt,sha256=jeNbog_1saXBFrGpom9WyPWmilxsyP3szL_G7JLWQfM,16
+tesla_fleet_api-1.0.1.dist-info/RECORD,,

tesla_fleet_api/energyspecific.py

@@ -1,125 +0,0 @@
-from __future__ import annotations
-from typing import Any, TYPE_CHECKING
-from .const import EnergyExportMode, EnergyOperationMode, TeslaEnergyPeriod
-
-if TYPE_CHECKING:
-    from .energy import Energy
-
-
-class EnergySpecific:
-    """Class describing the Tesla Fleet API partner endpoints"""
-
-    _parent: Energy
-    energy_site_id: int
-
-    def __init__(
-        self,
-        parent: Energy,
-        energy_site_id: int,
-    ):
-        self._parent = parent
-        self.energy_site_id = energy_site_id
-
-    async def backup(self, backup_reserve_percent: int) -> dict[str, Any]:
-        """Adjust the site's backup reserve."""
-        return await self._parent.backup(
-            self.energy_site_id,
-            backup_reserve_percent,
-        )
-
-    async def backup_history(
-        self,
-        period: TeslaEnergyPeriod | str,
-        start_date: str | None = None,
-        end_date: str | None = None,
-        time_zone: str | None = None,
-    ) -> dict[str, Any]:
-        """Returns the backup (off-grid) event history of the site in duration of seconds."""
-        return await self._parent.backup_history(
-            self.energy_site_id,
-            period,
-            start_date,
-            end_date,
-            time_zone,
-        )
-
-    async def charge_history(
-        self,
-        start_date: str,
-        end_date: str,
-        time_zone: str | None = None,
-    ) -> dict[str, Any]:
-        """Returns the charging history of a wall connector."""
-        return await self._parent.charge_history(
-            self.energy_site_id,
-            start_date,
-            end_date,
-            time_zone,
-        )
-
-    async def energy_history(
-        self,
-        period: TeslaEnergyPeriod | str,
-        start_date: str | None = None,
-        end_date: str | None = None,
-        time_zone: str | None = None,
-    ) -> dict[str, Any]:
-        """Returns the energy measurements of the site, aggregated to the requested period."""
-        return await self._parent.energy_history(
-            self.energy_site_id,
-            period,
-            start_date,
-            end_date,
-            time_zone,
-        )
-
-    async def grid_import_export(
-        self,
-        disallow_charge_from_grid_with_solar_installed: bool | None = None,
-        customer_preferred_export_rule: EnergyExportMode | str | None = None,
-    ) -> dict[str, Any]:
-        """Allow/disallow charging from the grid and exporting energy to the grid."""
-        return await self._parent.grid_import_export(
-            self.energy_site_id,
-            disallow_charge_from_grid_with_solar_installed,
-            customer_preferred_export_rule,
-        )
-
-    async def live_status(self) -> dict[str, Any]:
-        """Returns the live status of the site (power, state of energy, grid status, storm mode)."""
-        return await self._parent.live_status(self.energy_site_id)
-
-    async def off_grid_vehicle_charging_reserve(
-        self, off_grid_vehicle_charging_reserve_percent: int
-    ) -> dict[str, Any]:
-        """Adjust the site's off-grid vehicle charging backup reserve."""
-        return await self._parent.off_grid_vehicle_charging_reserve(
-            self.energy_site_id, off_grid_vehicle_charging_reserve_percent
-        )
-
-    async def operation(
-        self, default_real_mode: EnergyOperationMode | str
-    ) -> dict[str, Any]:
-        """Set the site's mode."""
-        return await self._parent.operation(
-            self.energy_site_id,
-            default_real_mode,
-        )
-
-    async def site_info(self) -> dict[str, Any]:
-        """Returns information about the site. Things like assets (has solar, etc), settings (backup reserve, etc), and features (storm_mode_capable, etc)."""
-        return await self._parent.site_info(self.energy_site_id)
-
-    async def storm_mode(self, enabled: bool) -> dict[str, Any]:
-        """Update storm watch participation."""
-        return await self._parent.storm_mode(
-            self.energy_site_id,
-            enabled,
-        )
-
-    async def time_of_use_settings(self, settings: dict[str, Any]) -> dict[str, Any]:
-        """Update the site's time of use settings."""
-        return await self._parent.time_of_use_settings(
-            self.energy_site_id,
-            settings,
-        )

tesla_fleet_api/teslafleetopensource.py

@@ -1,61 +0,0 @@
-import aiohttp
-import time
-import secrets
-import hashlib
-import base64
-
-from .teslafleetoauth import TeslaFleetOAuth
-from .const import Scope, SERVERS
-
-
-class TeslaFleetOpenSource(TeslaFleetOAuth):
-    """Tesla Fleet Open Source OAuth API."""
-
-    code_verifier: str
-    code_challenge: str
-
-    def __init__(
-        self,
-        session: aiohttp.ClientSession,
-        client_id: str,
-        redirect_uri: str,
-    ):
-        self.code_verifier = secrets.token_urlsafe(32)
-
-        # Hash the code_verifier using SHA-256
-        hashed_verifier = hashlib.sha256(self.code_verifier.encode()).digest()
-        # Encode the hash using URL-safe Base64 encoding, without padding
-        self.code_challenge = (
-            base64.urlsafe_b64encode(hashed_verifier).decode().replace("=", "")
-        )
-
-        super().__init__(session, client_id, redirect_uri=redirect_uri)
-
-    def get_login_url(self, scopes: list[Scope], state: str = "login") -> str:
-        """Get the login URL without a client secret."""
-
-        return (
-            super().get_login_url(scopes, state)
-            + f"&code_challenge={self.code_challenge}"
-        )
-
-    async def get_refresh_token(self, code: str) -> None:
-        """Get the refresh token."""
-        async with self.session.post(
-            "https://auth.tesla.com/oauth2/v3/token",
-            data={
-                "grant_type": "authorization_code",
-                "client_id": self.client_id,
-                "code": code,
-                "audience": self.server,
-                "redirect_uri": self.redirect_uri,
-                "code_verifier": self.code_verifier,
-            },
-        ) as resp:
-            if resp.ok:
-                data = await resp.json()
-                self.refresh_token = data["refresh_token"]
-                self.access_token = data["access_token"]
-                self.expires = int(time.time()) + data["expires_in"]
-                region = code.split("_")[0].lower()
-                self.server = SERVERS.get(region)