tesla-fleet-api 0.9.5__py3-none-any.whl → 0.9.6__py3-none-any.whl

tesla_fleet_api/teslafleetapi.py

@@ -106,6 +106,11 @@ class TeslaFleetApi:
             if access_token := await self.refresh_hook():
                 self.access_token = access_token
 
+        headers = {
+            "Authorization": f"Bearer {self.access_token}",
+            "X-Library": f"python tesla_fleet_api {VERSION}",
+        }
+
         # Remove None values from params and json
         if params:
             params = {k: v for k, v in params.items() if v is not None}
@@ -113,15 +118,12 @@ class TeslaFleetApi:
         if json:
             json = {k: v for k, v in json.items() if v is not None}
             LOGGER.debug("Body: %s", dumps(json))
+            headers["Content-Type"] = "application/json"
 
         async with self.session.request(
             method,
             f"{self.server}/{path}",
-            headers={
-                "Authorization": f"Bearer {self.access_token}",
-                "Content-Type": "application/json",
-                "X-Library": f"python tesla_fleet_api {VERSION}",
-            },
+            headers=headers,
             json=json,
             params=params,
         ) as resp:

tesla_fleet_api/teslafleetoauth.py

@@ -45,7 +45,7 @@ class TeslaFleetOAuth(TeslaFleetApi):
         """Get the login URL."""
         if self.redirect_uri is None:
             raise ValueError("Redirect URI is missing")
-        return f"https://auth.tesla.com/oauth2/v3/authorize?response_type=code&prompt=login&client_id={self.client_id}&redirect_uri={self.redirect_uri}&scope={'+'.join(scopes)}&state={state}"
+        return f"https://auth.tesla.com/oauth2/v3/authorize?response_type=code&client_id={self.client_id}&redirect_uri={self.redirect_uri}&scope={'+'.join(scopes)}&state={state}"
 
     async def get_refresh_token(self, code: str) -> None:
         """Get the refresh token."""

tesla_fleet_api/teslemetry.py

@@ -96,11 +96,11 @@ class Teslemetry(TeslaFleetApi):
             )
         ).get("response")
 
-    async def vehicle_force_refresh(self, vin: str) -> dict[str, Any]:
+    async def vehicle_data_refresh(self, vin: str) -> dict[str, Any]:
         """Force a refresh of the vehicle data."""
         return await self._request(
             Method.GET,
-            f"api/force/{vin}",
+            f"api/refresh/{vin}",
         )
 
     async def _request(

tesla_fleet_api/vehicle.py

@@ -44,7 +44,7 @@ class Vehicle:
 
     def pre2021(self, vin: str) -> bool:
         """Checks if a vehicle is a pre-2021 model S or X."""
-        return vin[9] <= "L" and vin[3] in ["S", "X"]
+        return vin[3] in ["S", "X"] and (vin[9] <= "L" or (vin[9] == "M" and vin[7] in ['1', '2', '3', '4']))
 
     async def actuate_trunk(
         self, vehicle_tag: str | int, which_trunk: Trunk | str

tesla_fleet_api/vehiclesigned.py

@@ -8,8 +8,11 @@ import hmac
 import hashlib
 from cryptography.hazmat.primitives.asymmetric import ec
 from cryptography.hazmat.primitives.serialization import PublicFormat, Encoding
+from asyncio import Lock, sleep
 
-from .exceptions import MESSAGE_FAULTS, TeslaFleetMessageFaultIncorrectEpoch
+from tesla_fleet_api.pb2.errors_pb2 import GenericError_E
+
+from .exceptions import MESSAGE_FAULTS, SIGNED_MESSAGE_INFORMATION_FAULTS, TeslaFleetMessageFaultIncorrectEpoch, TeslaFleetMessageFaultInvalidTokenOrCounter
 
 from .const import (
     LOGGER,
@@ -22,19 +25,18 @@ from .const import (
 from .vehiclespecific import VehicleSpecific
 
 from .pb2.universal_message_pb2 import (
-    # OPERATIONSTATUS_OK,
-    MESSAGEFAULT_ERROR_INCORRECT_EPOCH,
     OPERATIONSTATUS_WAIT,
     OPERATIONSTATUS_ERROR,
     DOMAIN_VEHICLE_SECURITY,
     DOMAIN_INFOTAINMENT,
     Domain,
-    # MessageFault_E,
     RoutableMessage,
 )
 from .pb2.car_server_pb2 import (
+    Response,
     Action,
     MediaPlayAction,
+    ResultReason,
     VehicleAction,
     VehicleControlFlashLightsAction,
     ChargingStartStopAction,
@@ -82,6 +84,8 @@ from .pb2.car_server_pb2 import (
 from .pb2.vehicle_pb2 import VehicleState
 from .pb2.vcsec_pb2 import (
     # SignedMessage_information_E,
+    OPERATIONSTATUS_OK,
+    FromVCSECMessage,
     UnsignedMessage,
     RKEAction_E,
     ClosureMoveRequest,
@@ -91,6 +95,7 @@ from .pb2.signatures_pb2 import (
     SIGNATURE_TYPE_HMAC_PERSONALIZED,
     TAG_DOMAIN,
     TAG_SIGNATURE_TYPE,
+    KeyIdentity,
     SignatureData,
     SessionInfo,
     HMAC_Personalized_Signature_Data,
@@ -121,35 +126,38 @@ class Session:
     epoch: bytes
     delta: int
     hmac: bytes
-
-    def __init__(self, key: bytes, counter: int, epoch: bytes, delta: int):
-        """Create a session instance for a single domain"""
-        self.key = key
-        self.counter = counter
-        self.epoch = epoch
-        self.delta = delta
+    publicKey: bytes
+    lock: Lock
+
+    def __init__(self):
+        self.lock = Lock()
+
+    def update(self, sessionInfo: SessionInfo, privateKey: ec.EllipticCurvePrivateKey):
+        """Update the session with new information"""
+        self.counter = sessionInfo.counter
+        self.epoch = sessionInfo.epoch
+        self.delta = int(time.time()) - sessionInfo.clock_time
+        self.publicKey = sessionInfo.publicKey
+        self.key = hashlib.sha1(
+            privateKey.exchange(
+                ec.ECDH(),
+                ec.EllipticCurvePublicKey.from_encoded_point(
+                    ec.SECP256R1(), self.publicKey
+                ),
+            )
+        ).digest()[:16]
         self.hmac = hmac.new(
-            key, "authenticated command".encode(), hashlib.sha256
+            self.key, "authenticated command".encode(), hashlib.sha256
         ).digest()
 
     def get(self) -> HMAC_Personalized_Signature_Data:
         """Sign a command and return session metadata"""
         self.counter += 1
-        signature = HMAC_Personalized_Signature_Data()
-        signature.epoch = self.epoch
-        signature.counter = self.counter
-        signature.expires_at = int(time.time()) - self.delta + 10
-        return signature
-
-    def tag(
-        self,
-        signature: HMAC_Personalized_Signature_Data,
-        command: bytes,
-        metadata: bytes,
-    ) -> HMAC_Personalized_Signature_Data:
-        """Sign a command and return the signature"""
-        signature.tag = hmac.new(self.hmac, metadata + command, hashlib.sha256).digest()
-        return signature
+        return HMAC_Personalized_Signature_Data(
+            epoch=self.epoch,
+            counter=self.counter,
+            expires_at=int(time.time()) - self.delta + 10,
+        )
 
 
 class VehicleSigned(VehicleSpecific):
@@ -177,22 +185,35 @@ class VehicleSigned(VehicleSpecific):
         self._from_destination = randbytes(16)
         self._sessions = {}
 
-    async def _signed_message(self, msg: RoutableMessage) -> RoutableMessage:
+    async def _send(self, msg: RoutableMessage) -> RoutableMessage:
         """Serialize a message and send to the signed command endpoint."""
-        routable_message = base64.b64encode(msg.SerializeToString()).decode()
-        resp_json = await self.signed_command(routable_message)
-        resp = RoutableMessage()
-        resp.ParseFromString(base64.b64decode(resp_json["response"]))
 
-        if resp.signedMessageStatus:
-            LOGGER.error("Command returned with signedMessageStatus: %s", resp.signedMessageStatus)
-            if resp.signedMessageStatus.operation_status == OPERATIONSTATUS_ERROR:
-                raise MESSAGE_FAULTS[resp.signedMessageStatus.signed_message_fault]
+        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"]))
 
-        return resp
+            # Check UUID?
+            # Check RoutingAdress?
 
-    async def _handshake(self, domain: int) -> None:
+            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
+
+    async def _handshake(self, domain: Domain) -> Session:
         """Perform a handshake with the vehicle."""
+        if session := self._sessions.get(domain):
+            return session
+        self._sessions[domain] = Session()
+
         LOGGER.debug(f"Handshake with domain {Domain.Name(domain)}")
         msg = RoutableMessage()
         msg.to_destination.domain = domain
@@ -201,51 +222,34 @@ class VehicleSigned(VehicleSpecific):
         msg.uuid = randbytes(16)
 
         # Send handshake message
-        resp = await self._signed_message(msg)
-
-        # Get session info with publicKey, epoch, and clock_time
-        info = SessionInfo.FromString(resp.session_info)
+        await self._send(msg)
 
-        vehicle_public_key = info.publicKey
-
-        # Derive shared key from private key _key and vehicle public key
-        shared = self.private_key.exchange(
-            ec.ECDH(),
-            ec.EllipticCurvePublicKey.from_encoded_point(
-                ec.SECP256R1(), vehicle_public_key
-            ),
-        )
-
-        self._sessions[domain] = Session(
-            key=hashlib.sha1(shared).digest()[:16],
-            counter=info.counter,
-            epoch=info.epoch,
-            delta=int(time.time()) - info.clock_time,
-        )
+        return self._sessions[domain]
 
     async def _sendVehicleSecurity(self, command: UnsignedMessage) -> dict[str, Any]:
         """Sign and send a message to Infotainment computer."""
-        if DOMAIN_VEHICLE_SECURITY not in self._sessions:
-            await self._handshake(DOMAIN_VEHICLE_SECURITY)
-        return await self._send(DOMAIN_VEHICLE_SECURITY, command.SerializeToString())
+        return await self._sign(DOMAIN_VEHICLE_SECURITY, command.SerializeToString())
 
     async def _sendInfotainment(self, command: Action) -> dict[str, Any]:
         """Sign and send a message to Infotainment computer."""
-        if DOMAIN_INFOTAINMENT not in self._sessions:
-            await self._handshake(DOMAIN_INFOTAINMENT)
-        return await self._send(DOMAIN_INFOTAINMENT, command.SerializeToString())
+        return await self._sign(DOMAIN_INFOTAINMENT, command.SerializeToString())
 
-    async def _send(self, domain: int, command: bytes, attempt: int = 1) -> dict[str, Any]:
+    async def _sign(
+        self, domain: Domain, command: bytes, attempt: int = 1
+    ) -> dict[str, Any]:
         """Send a signed message to the vehicle."""
         LOGGER.debug(f"Sending to domain {Domain.Name(domain)}")
+
+        session = await self._handshake(domain)
+        hmac_personalized = session.get()
+
         msg = RoutableMessage()
         msg.to_destination.domain = domain
         msg.from_destination.routing_address = self._from_destination
         msg.protobuf_message_as_bytes = command
         msg.uuid = randbytes(16)
 
-        session = self._sessions[domain].get()
-        metadata = [
+        metadata = bytes([
             TAG_SIGNATURE_TYPE,
             1,
             SIGNATURE_TYPE_HMAC_PERSONALIZED,
@@ -256,48 +260,92 @@ class VehicleSigned(VehicleSpecific):
             17,
             *self.vin.encode(),
             TAG_EPOCH,
-            len(session.epoch),
-            *session.epoch,
+            len(hmac_personalized.epoch),
+            *hmac_personalized.epoch,
             TAG_EXPIRES_AT,
             4,
-            *struct.pack(">I", session.expires_at),
+            *struct.pack(">I", hmac_personalized.expires_at),
             TAG_COUNTER,
             4,
-            *struct.pack(">I", session.counter),
+            *struct.pack(">I", hmac_personalized.counter),
             TAG_END,
-        ]
-
-        session = self._sessions[domain].tag(session, command, bytes(metadata))
+        ])
 
-        signature = SignatureData()
-        signature.HMAC_Personalized_data.CopyFrom(session)
-        signature.signer_identity.public_key = self._public_key
+        hmac_personalized.tag = hmac.new(
+            session.hmac, metadata + command, hashlib.sha256
+        ).digest()
 
-        msg.signature_data.CopyFrom(signature)
+        # I think this whole section could be improved
+        msg.signature_data.HMAC_Personalized_data.CopyFrom(hmac_personalized)
+        msg.signature_data.signer_identity.public_key = self._public_key
 
         try:
-            resp = await self._signed_message(msg)
-        except TeslaFleetMessageFaultIncorrectEpoch as e:
+            resp = await self._send(msg)
+        except (
+            TeslaFleetMessageFaultIncorrectEpoch,
+            TeslaFleetMessageFaultInvalidTokenOrCounter,
+        ) as e:
             attempt += 1
             if attempt > 3:
                 # We tried 3 times, give up, raise the error
                 raise e
-            LOGGER.info(f"Session expired, starting new handshake with {Domain.Name(domain)}")
-            await self._handshake(domain)
-            LOGGER.info(f"Handshake complete, retrying message to {Domain.Name(domain)}")
-            return await self._send(domain, command, attempt)
+            return await self._sign(domain, command, attempt)
 
         if resp.signedMessageStatus.operation_status == OPERATIONSTATUS_WAIT:
-            return {"response": {"result": False}}
-
-        LOGGER.debug("Command response: %s", resp)
-        reason = resp.protobuf_message_as_bytes[8:].decode()
-
-        if reason:
-            LOGGER.error("Command failed with reason: %s", reason)
-            return {"response": {"result": False, "reason": reason}}
-
-        return {"response": {"result": True, "reason": ""}}
+            attempt += 1
+            if attempt > 3:
+                # We tried 3 times, give up, raise the error
+                return {"response": {"result": False, "reason": "Too many retries"}}
+            async with session.lock:
+                await sleep(2)
+            return await self._sign(domain, command, attempt)
+
+        if resp.HasField("signedMessageStatus"):
+            if(resp.from_destination.domain == DOMAIN_VEHICLE_SECURITY):
+                vcsec = FromVCSECMessage.FromString(resp.protobuf_message_as_bytes)
+                LOGGER.debug("VCSEC Response: %s", vcsec)
+                if vcsec.HasField("nominalError"):
+                    LOGGER.error("Command failed with reason: %s", vcsec.nominalError.genericError)
+                    return {
+                        "response": {
+                        "result": False,
+                        "reason": GenericError_E.Name(vcsec.nominalError.genericError)
+                    }
+                }
+                elif vcsec.commandStatus.operationStatus == OPERATIONSTATUS_OK:
+                    return {"response": {"result": True, "reason": ""}}
+                elif vcsec.commandStatus.operationStatus == OPERATIONSTATUS_WAIT:
+                    attempt += 1
+                    if attempt > 3:
+                        # We tried 3 times, give up, raise the error
+                        return {"response": {"result": False, "reason": "Too many retries"}}
+                    async with session.lock:
+                        await sleep(2)
+                    return await self._sign(domain, command, attempt)
+                elif vcsec.commandStatus.operationStatus == OPERATIONSTATUS_ERROR:
+                    if(vcsec.commandStatus.signedMessageStatus):
+                        raise SIGNED_MESSAGE_INFORMATION_FAULTS[vcsec.commandStatus.signedMessageStatus.signedMessageInformation]
+
+            elif(resp.from_destination.domain == DOMAIN_INFOTAINMENT):
+                response = Response.FromString(resp.protobuf_message_as_bytes)
+                LOGGER.debug("Infotainment Response: %s", response)
+                if (response.HasField("ping")):
+                    print(response.ping)
+                    return {
+                        "response": {
+                            "result": True,
+                            "reason": response.ping.local_timestamp
+                        }
+                    }
+                if response.HasField("actionStatus"):
+                    return {
+                        "response": {
+                            "result": response.actionStatus.result == OPERATIONSTATUS_OK,
+                            "reason": response.actionStatus.result_reason.plain_text or ""
+                            }
+                        }
+
+        return {"response": {"result": None, "reason": "No Response"}}
 
     async def actuate_trunk(self, which_trunk: Trunk | str) -> dict[str, Any]:
         """Controls the front or rear trunk."""

{tesla_fleet_api-0.9.5.dist-info → tesla_fleet_api-0.9.6.dist-info}/METADATA

@@ -1,8 +1,8 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: tesla_fleet_api
-Version: 0.9.5
+Version: 0.9.6
 Summary: Tesla Fleet API library for Python
-Home-page: https://github.com/Teslemetry/tesla_fleet_api
+Home-page: https://github.com/Teslemetry/python-tesla-fleet-api
 Author: Brett Adams
 Author-email: hello@teslemetry.com
 Classifier: Development Status :: 4 - Beta
@@ -17,6 +17,15 @@ Requires-Dist: aiofiles
 Requires-Dist: aiolimiter
 Requires-Dist: cryptography
 Requires-Dist: protobuf
+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 Teslemetry.

tesla_fleet_api-0.9.6.dist-info/RECORD

@@ -0,0 +1,42 @@
+tesla_fleet_api/__init__.py,sha256=BVZUDsfaxT05tAfcMHHWiyFyXwmDOx_wP_IHZBscgho,729
+tesla_fleet_api/charging.py,sha256=N_mc8axrXj3iduqLj_jCt4Vx86tHqe3xqQT4R1R7HvU,1689
+tesla_fleet_api/const.py,sha256=UdgXLx2blO4ByR3oY0YP2V0LjBCYbhsmWuMkBr3gwV0,12888
+tesla_fleet_api/energy.py,sha256=S7D75MPuMVsHgkyUcFfMqjGCLZBM5YVFlWLEHbaX-zw,5957
+tesla_fleet_api/energyspecific.py,sha256=UfeaGE59aoAa8UhpQCXUi0sOrNCA40xZlqwF73BXTVY,4254
+tesla_fleet_api/exceptions.py,sha256=qnRWqPJ_5gia4-j3o4mP5OwUuBRtC3SAbZKo-_XSRiI,29729
+tesla_fleet_api/partner.py,sha256=1vIBUaxKLIfqcC0X6VXZN0dMAzj_CLNPUMjA6QVqZ1k,1223
+tesla_fleet_api/ratecalculator.py,sha256=4lz8yruUeouHXh_3ezsXX-CTpIegp1T1J4VuRV_qdHA,1791
+tesla_fleet_api/teslafleetapi.py,sha256=8j-kvV6_oCuIlDdS5kWlCbo9chWsT48Gn2iKt3uOAjg,7409
+tesla_fleet_api/teslafleetoauth.py,sha256=NmzycAeg68sWASjiWan3B5LdIgrfmoLTDqLHYCmoKKg,4108
+tesla_fleet_api/teslafleetopensource.py,sha256=TJfVPcqJlA1b3kMoGuLr-g5Gn8UDyYsTZhjvGY1MtIk,2007
+tesla_fleet_api/teslemetry.py,sha256=_n59RQvJKl82ylLe09bLY_8iyfjz_DHqCdRVsWeif4s,3308
+tesla_fleet_api/tessie.py,sha256=4dBYxe1G2v9JvJGRbb01wXrAmvWT4jOfV4f_VQE_vkE,2302
+tesla_fleet_api/user.py,sha256=TZE2oh-n5zrhKXmGRuiNL9voKVODD7rBhGE_IObYVGA,1179
+tesla_fleet_api/vehicle.py,sha256=mSFJG-bLBNh_iSJnruk9EZSypZUxMpKwMgKA9_8CPDc,32146
+tesla_fleet_api/vehiclesigned.py,sha256=N06Evfo5_AwkOjNg0cpCHYV7SH-5zjzHsYnMmYpCKZY,42001
+tesla_fleet_api/vehiclespecific.py,sha256=P7KI8MqUbAyM2cfDC8NqbJXzGL2ZsOIx3IBeqB8xYQY,20656
+tesla_fleet_api/pb2/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tesla_fleet_api/pb2/__init__.pyi,sha256=qFXWNIgl71wB260u-XPzaAwWAHL6krw21q-aXnBtop0,252
+tesla_fleet_api/pb2/car_server_pb2.py,sha256=v_eb4NDIkx_ZYPYW29_EFRky5vQ4b2q14gwuQSbouYw,29202
+tesla_fleet_api/pb2/car_server_pb2.pyi,sha256=qkig9HEsOE4Dk2-r38BAWOyALqt7CtUnlirgSVt_oa8,46334
+tesla_fleet_api/pb2/common_pb2.py,sha256=C5O6BBTckU3F-XItLfivaPG_XVCnzF_JX4mpVfM_jFk,3931
+tesla_fleet_api/pb2/common_pb2.pyi,sha256=8aZiigp74MfSOMpHtMw0D9Jj0kwPz1zV_BIZfVWhh_0,5012
+tesla_fleet_api/pb2/errors_pb2.py,sha256=nfOvriyjVgVxnJZIAYNRHiBa1_14dOXhC9Pokc5anV8,1631
+tesla_fleet_api/pb2/errors_pb2.pyi,sha256=CNsAR7Oe6wavnqjzhInEyAFxMio6TtXfaNT0DUztn6o,1478
+tesla_fleet_api/pb2/keys_pb2.py,sha256=-hyVP9-W1DypTYLaWwkOSUzgia6l9R3M9wUIgvNs-T0,1252
+tesla_fleet_api/pb2/keys_pb2.pyi,sha256=HH-TfhE5ihwmoPCGdiVnZ5B7KkaMJglEpusgLc1J02M,676
+tesla_fleet_api/pb2/managed_charging_pb2.py,sha256=4crkLo6uC0YPkgw90jRjAqlGMFnRze_koUt2-pw14m4,1430
+tesla_fleet_api/pb2/managed_charging_pb2.pyi,sha256=SqEmrfknTfzYTUYHtsoCpt1Fw2YpU3OyQllX247UfyQ,1227
+tesla_fleet_api/pb2/signatures_pb2.py,sha256=TRaJ6lzmJtryhhmBC_PbYzftc-pqCmwC6wuBCXHeuTg,4734
+tesla_fleet_api/pb2/signatures_pb2.pyi,sha256=-OGm9ctBnEJiXk-3nkFCPRTxKgFiqFgMbKeq3x2zGGM,6101
+tesla_fleet_api/pb2/universal_message_pb2.py,sha256=UklH73qoYsqxylie6IK8iIcw2tmykSqDiaBKSWz66OQ,5093
+tesla_fleet_api/pb2/universal_message_pb2.pyi,sha256=a_RygTJL26v0rA7QuUwsxiG1_ZBcliwXCqOAqTIJ6UE,7647
+tesla_fleet_api/pb2/vcsec_pb2.py,sha256=PDv9TfiXnNs6sQ0D5vBrsSSPinSqu3eBUwvTcG8xMWo,15919
+tesla_fleet_api/pb2/vcsec_pb2.pyi,sha256=cyK1uyRtDjRVqVlyl5uRQYY1RhFlWSJheLg3PGfs-_s,28524
+tesla_fleet_api/pb2/vehicle_pb2.py,sha256=bqyFJM-1qZ7W9XKREINhYZx8yXAudmq6W8_Pdfkhbkk,44711
+tesla_fleet_api/pb2/vehicle_pb2.pyi,sha256=sAUW_9aVB8NqJCnhZjXMLfqfePLVZv_7PfSKZKEBaQA,74251
+tesla_fleet_api-0.9.6.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+tesla_fleet_api-0.9.6.dist-info/METADATA,sha256=NZZXKNqQjFt6LPS7r8TOsnEH89osm5SqRcVaIvaB5Ck,4022
+tesla_fleet_api-0.9.6.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+tesla_fleet_api-0.9.6.dist-info/top_level.txt,sha256=jeNbog_1saXBFrGpom9WyPWmilxsyP3szL_G7JLWQfM,16
+tesla_fleet_api-0.9.6.dist-info/RECORD,,

{tesla_fleet_api-0.9.5.dist-info → tesla_fleet_api-0.9.6.dist-info}/WHEEL

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

tesla_fleet_api-0.9.5.dist-info/RECORD

@@ -1,33 +0,0 @@
-tesla_fleet_api/__init__.py,sha256=BVZUDsfaxT05tAfcMHHWiyFyXwmDOx_wP_IHZBscgho,729
-tesla_fleet_api/charging.py,sha256=N_mc8axrXj3iduqLj_jCt4Vx86tHqe3xqQT4R1R7HvU,1689
-tesla_fleet_api/const.py,sha256=40Oi7XwilcT6ZbNcQnm9hOawKNY4JLrfZA0Xc4H7g7s,12888
-tesla_fleet_api/energy.py,sha256=S7D75MPuMVsHgkyUcFfMqjGCLZBM5YVFlWLEHbaX-zw,5957
-tesla_fleet_api/energyspecific.py,sha256=UfeaGE59aoAa8UhpQCXUi0sOrNCA40xZlqwF73BXTVY,4254
-tesla_fleet_api/exceptions.py,sha256=KUozIEvZv9Haal6ofRb0SFHQQBe8UH-lEAFVwkJFzW0,20942
-tesla_fleet_api/partner.py,sha256=1vIBUaxKLIfqcC0X6VXZN0dMAzj_CLNPUMjA6QVqZ1k,1223
-tesla_fleet_api/ratecalculator.py,sha256=4lz8yruUeouHXh_3ezsXX-CTpIegp1T1J4VuRV_qdHA,1791
-tesla_fleet_api/teslafleetapi.py,sha256=4Rnh_HNZkIw54o9SYAaHsA8vY0pmk_bMncrLuJ8MtSk,7389
-tesla_fleet_api/teslafleetoauth.py,sha256=ClrVh4_lpatW8w44fWM0PZiVB-ciPHr-9h4yw1Zf9w8,4121
-tesla_fleet_api/teslafleetopensource.py,sha256=TJfVPcqJlA1b3kMoGuLr-g5Gn8UDyYsTZhjvGY1MtIk,2007
-tesla_fleet_api/teslemetry.py,sha256=IiDxEjDfWdXlpI7qFGW2YwroWoLbUdWSSVM6zCnhQl8,3307
-tesla_fleet_api/tessie.py,sha256=4dBYxe1G2v9JvJGRbb01wXrAmvWT4jOfV4f_VQE_vkE,2302
-tesla_fleet_api/user.py,sha256=TZE2oh-n5zrhKXmGRuiNL9voKVODD7rBhGE_IObYVGA,1179
-tesla_fleet_api/vehicle.py,sha256=e0AotkaI-WftNfxJbLF8peIq3l99f6-ezVSEQbkOD1I,32090
-tesla_fleet_api/vehiclesigned.py,sha256=PXXBeMpQf_5-ZQccjhtf6wllgCMhOOmtSjZzmjHYgls,39886
-tesla_fleet_api/vehiclespecific.py,sha256=P7KI8MqUbAyM2cfDC8NqbJXzGL2ZsOIx3IBeqB8xYQY,20656
-tesla_fleet_api/pb2/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tesla_fleet_api/pb2/__init__.pyi,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tesla_fleet_api/pb2/car_server_pb2.py,sha256=I3bq-cbq_4GXZblJatOFtjUny9seZb_1caNWMUciry0,51750
-tesla_fleet_api/pb2/common_pb2.py,sha256=Iip_uomlO1s6wTyQl2QYxkUdVKB1qqSrpD3MHr-5rl0,6041
-tesla_fleet_api/pb2/errors_pb2.py,sha256=ESk8GRN-jbsVvPWsWC0WfntmOXfRWVjy3sPT99WL89Q,2149
-tesla_fleet_api/pb2/keys_pb2.py,sha256=T5q0OMlMiwFJV5xSmn6E2tnLCzr463Rk3pweaLFiPgM,1366
-tesla_fleet_api/pb2/managed_charging_pb2.py,sha256=g6dJu9sYe9D2BCAWNFUNM_Qr0gJM5AHxmAJikHstQMc,1792
-tesla_fleet_api/pb2/signatures_pb2.py,sha256=UZCXDYgV-tYIrzVHeqi0NaytUtRZJB-_lC7IVjIbggc,7719
-tesla_fleet_api/pb2/universal_message_pb2.py,sha256=XF08dOMbhN0F9D4xbaNJhUIAEqbKdK1iYQdZFAloWdk,7826
-tesla_fleet_api/pb2/vcsec_pb2.py,sha256=CMJ97e4Mm4p7NFcgybbCC2KJRcvtrcqmBy_pGycYhMo,26238
-tesla_fleet_api/pb2/vehicle_pb2.py,sha256=ViSm74kS3iLjB2C18w-FDZyCkvi2e71GNKVmH2FU8zg,57629
-tesla_fleet_api-0.9.5.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-tesla_fleet_api-0.9.5.dist-info/METADATA,sha256=f08KYxa2kQw_SuEZ0lAir5VORsuA95XYMVMmRl-80hE,3818
-tesla_fleet_api-0.9.5.dist-info/WHEEL,sha256=A3WOREP4zgxI0fKrHUG8DC8013e3dK3n7a6HDbcEIwE,91
-tesla_fleet_api-0.9.5.dist-info/top_level.txt,sha256=jeNbog_1saXBFrGpom9WyPWmilxsyP3szL_G7JLWQfM,16
-tesla_fleet_api-0.9.5.dist-info/RECORD,,