tesla-fleet-api 0.9.9__py3-none-any.whl → 1.0.0__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/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.9.dist-info → tesla_fleet_api-1.0.0.dist-info}/METADATA

@@ -1,11 +1,11 @@
 Metadata-Version: 2.2
 Name: tesla_fleet_api
-Version: 0.9.9
+Version: 1.0.0
 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.0.dist-info/RECORD

@@ -0,0 +1,24 @@
+tesla_fleet_api/__init__.py,sha256=FewtEncMLxOZa3dVA3SsT3tY--RMNF9-GXIpOTkbXvk,396
+tesla_fleet_api/const.py,sha256=uyfy2ZOfFZd4sunTRiIuB3FtGxIzmO1VAcSRs1pztSY,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=H4LQwNJ4RwtKMWMwfHTOyG2om11MtvC9px0Go2GCRNE,915
+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/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.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+tesla_fleet_api-1.0.0.dist-info/METADATA,sha256=vmW8VMIM1jR6N_64JNBgkivup9NBaM9blKTkFULRDxY,4056
+tesla_fleet_api-1.0.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+tesla_fleet_api-1.0.0.dist-info/top_level.txt,sha256=jeNbog_1saXBFrGpom9WyPWmilxsyP3szL_G7JLWQfM,16
+tesla_fleet_api-1.0.0.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/pb2/__init__.pyi

@@ -1,9 +0,0 @@
-from . import car_server_pb2
-from . import common_pb2
-from . import errors_pb2
-from . import keys_pb2
-from . import managed_charging_pb2
-from . import signatures_pb2
-from . import universal_message_pb2
-from . import vcsec_pb2
-from . import vehicle_pb2