tesla-fleet-api 0.0.4__py3-none-any.whl → 0.0.5__py3-none-any.whl

tesla_fleet_api/__init__.py

@@ -1,3 +1,3 @@
-from .TeslaFleetApi import TeslaFleetApi
-from .TeslaFleetOAuth import TeslaFleetOAuth
-from .Teslemetry import Teslemetry
+from .teslafleetapi import TeslaFleetApi
+from .teslafleetoauth import TeslaFleetOAuth
+from .teslemetry import Teslemetry

tesla_fleet_api/charging.py

@@ -0,0 +1,57 @@
+from typing import Any
+from .const import (
+    Methods,
+)
+
+
+class Charging:
+    """Class describing the Tesla Fleet API charging endpoints."""
+
+    def __init__(self, parent):
+        self._request = parent._request
+
+    async def history(
+        self,
+        vin: str | None = None,
+        startTime: str | None = None,
+        endTime: str | None = None,
+        pageNo: int | None = None,
+        pageSize: int | None = None,
+        sortBy: str | None = None,
+        sortOrder: str | None = None,
+    ) -> dict[str, Any]:
+        """Returns the paginated charging history."""
+        return await self._request(
+            Methods.GET,
+            "api/1/dx/charging/history",
+            {
+                vin: vin,
+                startTime: startTime,
+                endTime: endTime,
+                pageNo: pageNo,
+                pageSize: pageSize,
+                sortBy: sortBy,
+                sortOrder: sortOrder,
+            },
+        )
+
+    async def sessions(
+        self,
+        vin: str | None = None,
+        date_from: str | None = None,
+        date_to: str | None = None,
+        limit: int | None = None,
+        offset: int | None = None,
+    ) -> dict[str, Any]:
+        """Returns the charging session information including pricing and energy data. This endpoint is only available for business accounts that own a fleet of vehicles."""
+        return await self._request(
+            Methods.GET,
+            "api/1/dx/charging/sessions",
+            {
+                vin: vin,
+                date_from: date_from,
+                date_to: date_to,
+                limit: limit,
+                offset: offset,
+            },
+        )

tesla_fleet_api/energy.py

@@ -0,0 +1,130 @@
+from typing import Any
+from .const import Methods
+
+
+class Energy:
+    """Class describing the Tesla Fleet API partner endpoints"""
+
+    def __init__(self, parent):
+        self._request = parent._request
+
+    async def backup(
+        self, energy_site_id: int, backup_reserve_percent: int
+    ) -> dict[str, Any]:
+        """Adjust the site's backup reserve."""
+        return await self._request(
+            Methods.POST,
+            f"api/1/energy_sites/{energy_site_id}/backup",
+            data={backup_reserve_percent: backup_reserve_percent},
+        )
+
+    async def backup_history(
+        self,
+        energy_site_id: int,
+        kind: str,
+        start_date: str,
+        end_date: str,
+        period: str,
+        time_zone: str,
+    ) -> dict[str, Any]:
+        """Returns the backup (off-grid) event history of the site in duration of seconds."""
+        return await self._request(
+            Methods.GET,
+            f"api/1/energy_sites/{energy_site_id}/calendar_history?kind={kind}&start_date={start_date}&end_date={end_date}&period={period}&time_zone={time_zone}",
+        )
+
+    async def charge_history(
+        self,
+        energy_site_id: int,
+        kind: str,
+        start_date: str,
+        end_date: str,
+        time_zone: str,
+    ) -> dict[str, Any]:
+        """Returns the charging history of a wall connector."""
+        return await self._request(
+            Methods.GET,
+            f"api/1/energy_sites/{energy_site_id}/telemetry_history?kind={kind}&start_date={start_date}&end_date={end_date}&time_zone={time_zone}",
+        )
+
+    async def energy_history(
+        self,
+        energy_site_id: int,
+        kind: str,
+        start_date: str,
+        end_date: str,
+        period: str,
+        time_zone: str,
+    ) -> dict[str, Any]:
+        """Returns the energy measurements of the site, aggregated to the requested period."""
+        return await self._request(
+            Methods.GET,
+            f"api/1/energy_sites/{energy_site_id}/calendar_history?kind={kind}&start_date={start_date}&end_date={end_date}&period={period}&time_zone={time_zone}",
+        )
+
+    async def grid_import_export(
+        self,
+        energy_site_id: int,
+        disallow_charge_from_grid_with_solar_installed: bool,
+        customer_preferred_export_rule: str,
+    ) -> dict[str, Any]:
+        """Allow/disallow charging from the grid and exporting energy to the grid."""
+        return await self._request(
+            Methods.POST,
+            f"api/1/energy_sites/{energy_site_id}/grid_import_export",
+            data={
+                disallow_charge_from_grid_with_solar_installed: disallow_charge_from_grid_with_solar_installed,
+                customer_preferred_export_rule: customer_preferred_export_rule,
+            },
+        )
+
+    async def live_status(self, energy_site_id: int) -> dict[str, Any]:
+        """Returns the live status of the site (power, state of energy, grid status, storm mode)."""
+        return await self._request(
+            Methods.GET,
+            f"api/1/energy_sites/{energy_site_id}/live_status",
+        )
+
+    async def off_grid_vehicle_charging_reserve(
+        self, energy_site_id: int, off_grid_vehicle_charging_reserve_percent: int
+    ) -> dict[str, Any]:
+        """Adjust the site's off-grid vehicle charging backup reserve."""
+        return await self._request(
+            Methods.POST,
+            f"api/1/energy_sites/{energy_site_id}/off_grid_vehicle_charging_reserve",
+            data={
+                off_grid_vehicle_charging_reserve_percent: off_grid_vehicle_charging_reserve_percent
+            },
+        )
+
+    async def operation(
+        self, energy_site_id: int, default_real_mode: str
+    ) -> dict[str, Any]:
+        """Set the site's mode."""
+        return await self._request(
+            Methods.POST,
+            f"api/1/energy_sites/{energy_site_id}/operation",
+            data={default_real_mode: default_real_mode},
+        )
+
+    async def products(self) -> dict[str, Any]:
+        """Returns products mapped to user."""
+        return await self._request(
+            Methods.GET,
+            "api/1/products",
+        )
+
+    async def site_info(self, energy_site_id: int) -> 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._request(
+            Methods.GET,
+            f"api/1/energy_sites/{energy_site_id}/site_info",
+        )
+
+    async def storm_mode(self, energy_site_id: int, enabled: bool) -> dict[str, Any]:
+        """Update storm watch participation."""
+        return await self._request(
+            Methods.POST,
+            f"api/1/energy_sites/{energy_site_id}/storm_mode",
+            data={enabled: enabled},
+        )

tesla_fleet_api/exceptions.py

@@ -211,16 +211,16 @@ async def raise_for_status(resp: aiohttp.ClientResponse) -> None:
     """Raise an exception if the response status code is >=400."""
     # https://developer.tesla.com/docs/fleet-api#response-codes
 
-    if e.status == 401 and resp.content_length == 0:
+    if resp.status == 401 and resp.content_length == 0:
         # This error does not return a body
-        raise OAuthExpired() from e
+        raise OAuthExpired()
 
     data = await resp.json()
 
     try:
         resp.raise_for_status()
     except aiohttp.ClientResponseError as e:
-        if e.status == 400:
+        if resp.status == 400:
             if data.error == Errors.INVALID_COMMAND:
                 raise InvalidCommand(data) from e
             elif data.error == Errors.INVALID_FIELD:
@@ -233,44 +233,44 @@ async def raise_for_status(resp: aiohttp.ClientResponse) -> None:
                 raise InvalidRedirectUrl(data) from e
             elif data.error == Errors.UNAUTHORIZED_CLIENT:
                 raise UnauthorizedClient(data) from e
-        elif e.status == 401:
+        elif resp.status == 401:
             if data.error == Errors.MOBILE_ACCESS_DISABLED:
                 raise MobileAccessDisabled(data) from e
             elif data.error == Errors.INVALID_TOKEN:
                 raise InvalidToken(data) from e
-        elif e.status == 402:
+        elif resp.status == 402:
             raise PaymentRequired(data) from e
-        elif e.status == 403:
+        elif resp.status == 403:
             raise Forbidden(data) from e
-        elif e.status == 404:
+        elif resp.status == 404:
             raise NotFound(data) from e
-        elif e.status == 405:
+        elif resp.status == 405:
             raise NotAllowed(data) from e
-        elif e.status == 406:
+        elif resp.status == 406:
             raise NotAcceptable(data) from e
-        elif e.status == 408:
+        elif resp.status == 408:
             raise VehicleOffline(data) from e
-        elif e.status == 412:
+        elif resp.status == 412:
             raise PreconditionFailed(data) from e
-        elif e.status == 421:
+        elif resp.status == 421:
             raise InvalidRegion(data) from e
-        elif e.status == 422:
+        elif resp.status == 422:
             raise InvalidResource(data) from e
-        elif e.status == 423:
+        elif resp.status == 423:
             raise Locked(data) from e
-        elif e.status == 429:
+        elif resp.status == 429:
             raise RateLimited(data) from e
-        elif e.status == 451:
+        elif resp.status == 451:
             raise ResourceUnavailableForLegalReasons(data) from e
-        elif e.status == 499:
+        elif resp.status == 499:
             raise ClientClosedRequest(data) from e
-        elif e.status == 500:
+        elif resp.status == 500:
             raise InternalServerError(data) from e
-        elif e.status == 503:
+        elif resp.status == 503:
             raise ServiceUnavailable(data) from e
-        elif e.status == 504:
+        elif resp.status == 504:
             raise GatewayTimeout(data) from e
-        elif e.status == 540:
+        elif resp.status == 540:
             raise DeviceUnexpectedResponse(data) from e
         else:
             raise e

tesla_fleet_api/partner.py

@@ -0,0 +1,21 @@
+from typing import Any
+from .const import Methods
+
+
+class Partner:
+    """Class describing the Tesla Fleet API partner endpoints"""
+
+    def __init__(self, parent):
+        self._request = parent._request
+
+    async def public_key(self, domain: str | None = None) -> dict[str, Any]:
+        """Returns the public key associated with a domain. It can be used to ensure the registration was successful."""
+        return await self._request(
+            Methods.GET, "api/1/partner_accounts/public_key", data={domain: domain}
+        )
+
+    async def register(self, domain: str) -> dict[str, Any]:
+        """Registers an existing account before it can be used for general API access. Each application from developer.tesla.com must complete this step."""
+        return await self._request(
+            Methods.POST, "api/1/partner_accounts", data={domain: domain}
+        )

tesla_fleet_api/teslafleetapi.py

@@ -0,0 +1,116 @@
+import aiohttp
+from .exceptions import raise_for_status, InvalidRegion, LibraryError
+from typing import Any
+from .const import (
+    SERVERS,
+    Methods,
+)
+from .charging import Charging
+from .energy import Energy
+from .partner import Partner
+from .user import User
+from .vehicle import Vehicle
+from .vehiclespecific import VehicleSpecific
+
+
+# Based on https://developer.tesla.com/docs/fleet-api
+class TeslaFleetApi:
+    """Class describing the Tesla Fleet API."""
+
+    server: str
+    session: aiohttp.ClientSession
+    headers: dict[str, str]
+    raise_for_status: bool
+    vehicles: list[VehicleSpecific]
+
+    def __init__(
+        self,
+        session: aiohttp.ClientSession,
+        access_token: str,
+        use_command_protocol: bool = False,
+        region: str | None = None,
+        server: str | None = None,
+        raise_for_status: bool = True,
+        charging_scope: bool = True,
+        energy_scope: bool = True,
+        partner_scope: bool = True,
+        user_scope: bool = True,
+        vehicle_scope: bool = True,
+    ):
+        """Initialize the Tesla Fleet API."""
+
+        self.session = session
+        self.access_token = access_token
+        self.use_command_protocol = use_command_protocol
+
+        if region and not server and region not in SERVERS:
+            raise ValueError(f"Region must be one of {", ".join(SERVERS.keys())}")
+        self.server = server or SERVERS.get(region)
+        self.raise_for_status = raise_for_status
+
+        if charging_scope:
+            self.charging = Charging(self)
+        if energy_scope:
+            self.energy = Energy(self)
+        if user_scope:
+            self.user = User(self)
+        if partner_scope:
+            self.partner = Partner(self)
+        if vehicle_scope:
+            self.vehicle = Vehicle(self)
+
+    async def find_server(self) -> None:
+        """Find the server URL for the Tesla Fleet API."""
+        for server in SERVERS.values():
+            self.server = server
+            try:
+                await self.user.region()
+                return
+            except InvalidRegion:
+                continue
+        raise LibraryError("Could not find a valid Tesla API server.")
+
+    async def _request(
+        self,
+        method: Methods,
+        path: str,
+        params: dict[str:Any] | None = None,
+        data: dict[str:Any] | None = None,
+        json: dict[str:Any] | None = None,
+    ):
+        """Send a request to the Tesla Fleet API."""
+
+        if not self.server:
+            raise ValueError("Server was not set at init. Call find_server() first.")
+
+        if method == Methods.GET and (data is not None or json is not None):
+            raise ValueError("GET requests cannot have data or json parameters.")
+
+        if params:
+            params = {k: v for k, v in params.items() if v is not None}
+        if data:
+            data = {k: v for k, v in data.items() if v is not None}
+        if json:
+            json = {k: v for k, v in json.items() if v is not None}
+
+        async with self.session.request(
+            method,
+            f"{self.server}/{path}",
+            headers={
+                "Authorization": f"Bearer {self.access_token}",
+                "Content-Type": "application/json",
+            },
+            data=data,
+            json=json,
+            params=params,
+        ) as resp:
+            if self.raise_for_status:
+                await raise_for_status(resp)
+            return await resp.json()
+
+    async def status(self):
+        """This endpoint returns the string "ok" if the API is operating normally. No HTTP headers are required."""
+        if not self.server:
+            raise ValueError("Server was not set at init. Call find_server() first.")
+        async with self.session.get(f"{self.server}/status") as resp:
+            return await resp.text()

tesla_fleet_api/{TeslaFleetOAuth.py → teslafleetoauth.py}

@@ -1,6 +1,6 @@
 import aiohttp
 import datetime
-from .TeslaFleetApi import TeslaFleetApi
+from .teslafleetapi import TeslaFleetApi
 
 
 class TeslaFleetOAuth(TeslaFleetApi):

tesla_fleet_api/{Teslemetry.py → teslemetry.py}

@@ -1,14 +1,26 @@
 import aiohttp
-from .TeslaFleetApi import TeslaFleetApi
+from .teslafleetapi import TeslaFleetApi
+from .vehicle import Vehicle
+from .vehiclespecific import VehicleSpecific
 from .const import Methods
 
 
+class TeslemetryVehicle(Vehicle):
+    """Tesla Fleet API Vehicle."""
+
+    async def create(self, only_subscribed=True) -> [VehicleSpecific]:
+        """Creates a class for each vehicle."""
+        if only_subscribed:
+            return [VehicleSpecific(self, vin) for vin in await self._parent.vehicles()]
+        return await super().create()
+
+
 class Teslemetry(TeslaFleetApi):
     def __init__(
         self,
         session: aiohttp.ClientSession,
         access_token: str,
-        raise_for_status: bool = False,
+        raise_for_status: bool = True,
     ):
         """Initialize the Teslemetry API."""
         super().__init__(
@@ -17,7 +29,11 @@ class Teslemetry(TeslaFleetApi):
             use_command_protocol=False,
             server="https://teslemetry.com",
             raise_for_status=raise_for_status,
+            partner_scope=False,
+            user_scope=False,
+            vehicle_scope=False,
         )
+        self.vehicle = TeslemetryVehicle(self)
 
     async def vehicles(self):
         """Get the subscribed vehicles."""
@@ -29,20 +45,3 @@ class Teslemetry(TeslaFleetApi):
     async def find_server(self):
         """Find the server URL for the Tesla Fleet API."""
         raise NotImplementedError("Do not use this function for Teslemetry.")
-
-    def stream(self, vin: str, fields, alerts, expire: int):
-        """Stream data from the Tesla Fleet API."""
-        raise NotImplementedError("Not implemented yet")
-
-    class Vehicle(TeslaFleetApi.Vehicle):
-        """Tesla Fleet API Vehicle."""
-
-        async def create(
-            self, only_subscribed=True
-        ) -> [TeslaFleetApi.Vehicle.Specific]:
-            """Creates a class for each vehicle."""
-            if only_subscribed:
-                return [
-                    self.Specific(self, vin) for vin in await self._parent.vehicles()
-                ]
-            return await super().create()

tesla_fleet_api/user.py

@@ -0,0 +1,29 @@
+from typing import Any
+from .const import Methods
+
+
+class User:
+    """Class describing the Tesla Fleet API user endpoints"""
+
+    def __init__(self, parent):
+        self._request = parent._request
+
+    async def backup_key(self) -> dict[str, Any]:
+        """Returns the public key associated with the user."""
+        return await self._request(Methods.GET, "api/1/users/backup_key")
+
+    async def feature_config(self) -> dict[str, Any]:
+        """Returns any custom feature flag applied to a user."""
+        return await self._request(Methods.GET, "api/1/users/feature_config")
+
+    async def me(self) -> dict[str, Any]:
+        """Returns a summary of a user's account."""
+        return await self._request(Methods.GET, "api/1/users/me")
+
+    async def orders(self) -> dict[str, Any]:
+        """Returns the active orders for a user."""
+        return await self._request(Methods.GET, "api/1/users/orders")
+
+    async def region(self) -> dict[str, Any]:
+        """Returns a user's region and appropriate fleet-api base URL. Accepts no parameters, response is based on the authentication token subject."""
+        return await self._request(Methods.GET, "api/1/users/region")