tesla-fleet-api 0.8.2__py3-none-any.whl → 0.8.4__py3-none-any.whl

tesla_fleet_api/const.py

@@ -3,7 +3,7 @@
 from enum import Enum
 import logging
 
-VERSION = "0.8.2"
+VERSION = "0.8.4"
 LOGGER = logging.getLogger(__package__)
 SERVERS = {
     "na": "https://fleet-api.prd.na.vn.cloud.tesla.com",

tesla_fleet_api/exceptions.py

@@ -293,146 +293,146 @@ class LibraryError(Exception):
     """Errors related to this library."""
 
 
-class TeslaFleetSigningError(TeslaFleetError):
+class TeslaFleetInformationFault(TeslaFleetError):
     """Vehicle has responded with an error when sending a signed command"""
 
     message = "Vehicle has responded with an error when sending a signed command"
 
 
-class UnknownFault(TeslaFleetSigningError):
+class UnknownFault(TeslaFleetInformationFault):
     """Unknown fault on signed command."""
 
     message = "Unknown fault on signed command."
     code = 1
 
 
-class NotOnWhitelistFault(TeslaFleetSigningError):
+class NotOnWhitelistFault(TeslaFleetInformationFault):
     """Not on whitelist fault on signed command."""
 
     message = "Not on whitelist fault on signed command."
     code = 2
 
 
-class IVSmallerThanExpectedFault(TeslaFleetSigningError):
+class IVSmallerThanExpectedFault(TeslaFleetInformationFault):
     """IV smaller than expected fault on signed command."""
 
     message = "IV smaller than expected fault on signed command."
     code = 3
 
 
-class InvalidTokenFault(TeslaFleetSigningError):
+class InvalidTokenFault(TeslaFleetInformationFault):
     """Invalid token fault on signed command."""
 
     message = "Invalid token fault on signed command."
     code = 4
 
 
-class TokenAndCounterInvalidFault(TeslaFleetSigningError):
+class TokenAndCounterInvalidFault(TeslaFleetInformationFault):
     """Token and counter invalid fault on signed command."""
 
     message = "Token and counter invalid fault on signed command."
     code = 5
 
 
-class AESDecryptAuthFault(TeslaFleetSigningError):
+class AESDecryptAuthFault(TeslaFleetInformationFault):
     """AES decrypt auth fault on signed command."""
 
     message = "AES decrypt auth fault on signed command."
     code = 6
 
 
-class ECDSAInputFault(TeslaFleetSigningError):
+class ECDSAInputFault(TeslaFleetInformationFault):
     """ECDSA input fault on signed command."""
 
     message = "ECDSA input fault on signed command."
     code = 7
 
 
-class ECDSASignatureFault(TeslaFleetSigningError):
+class ECDSASignatureFault(TeslaFleetInformationFault):
     """ECDSA signature fault on signed command."""
 
     message = "ECDSA signature fault on signed command."
     code = 8
 
 
-class LocalEntityStartFault(TeslaFleetSigningError):
+class LocalEntityStartFault(TeslaFleetInformationFault):
     """Local entity start fault on signed command."""
 
     message = "Local entity start fault on signed command."
     code = 9
 
 
-class LocalEntityResultFault(TeslaFleetSigningError):
+class LocalEntityResultFault(TeslaFleetInformationFault):
     """Local entity result fault on signed command."""
 
     message = "Local entity result fault on signed command."
     code = 10
 
 
-class CouldNotRetrieveKeyFault(TeslaFleetSigningError):
+class CouldNotRetrieveKeyFault(TeslaFleetInformationFault):
     """Could not retrieve key fault on signed command."""
 
     message = "Could not retrieve key fault on signed command."
     code = 11
 
 
-class CouldNotRetrieveTokenFault(TeslaFleetSigningError):
+class CouldNotRetrieveTokenFault(TeslaFleetInformationFault):
     """Could not retrieve token fault on signed command."""
 
     message = "Could not retrieve token fault on signed command."
     code = 12
 
 
-class SignatureTooShortFault(TeslaFleetSigningError):
+class SignatureTooShortFault(TeslaFleetInformationFault):
     """Signature too short fault on signed command."""
 
     message = "Signature too short fault on signed command."
     code = 13
 
 
-class TokenIsIncorrectLengthFault(TeslaFleetSigningError):
+class TokenIsIncorrectLengthFault(TeslaFleetInformationFault):
     """Token is incorrect length fault on signed command."""
 
     message = "Token is incorrect length fault on signed command."
     code = 14
 
 
-class IncorrectEpochFault(TeslaFleetSigningError):
+class IncorrectEpochFault(TeslaFleetInformationFault):
     """Incorrect epoch fault on signed command."""
 
     message = "Incorrect epoch fault on signed command."
     code = 15
 
 
-class IVIncorrectLengthFault(TeslaFleetSigningError):
+class IVIncorrectLengthFault(TeslaFleetInformationFault):
     """IV incorrect length fault on signed command."""
 
     message = "IV incorrect length fault on signed command."
     code = 16
 
 
-class TimeExpiredFault(TeslaFleetSigningError):
+class TimeExpiredFault(TeslaFleetInformationFault):
     """Time expired fault on signed command."""
 
     message = "Time expired fault on signed command."
     code = 17
 
 
-class NotProvisionedWithIdentityFault(TeslaFleetSigningError):
+class NotProvisionedWithIdentityFault(TeslaFleetInformationFault):
     """Not provisioned with identity fault on signed command."""
 
     message = "Not provisioned with identity fault on signed command."
     code = 18
 
 
-class CouldNotHashMetadataFault(TeslaFleetSigningError):
+class CouldNotHashMetadataFault(TeslaFleetInformationFault):
     """Could not hash metadata fault on signed command."""
 
     message = "Could not hash metadata fault on signed command."
     code = 19
 
 
-SIGNING_EXCEPTIONS = [
+INFORMATION_FAULTS = [
     None,
     UnknownFault,
     NotOnWhitelistFault,
@@ -456,6 +456,201 @@ SIGNING_EXCEPTIONS = [
 ]
 
 
+class TeslaFleetMessageFault(TeslaFleetError):
+    """Vehicle has responded with an error when sending a signed command"""
+
+    message = "Vehicle has responded with an error when sending a signed command"
+
+
+class TeslaFleetMessageFaultBusy(TeslaFleetMessageFault):
+    """Vehicle is busy"""
+
+    message = "Vehicle is busy"
+    code = 1
+
+
+class TeslaFleetMessageFaultTimeout(TeslaFleetMessageFault):
+    """Vehicle timed out"""
+
+    message = "Vehicle timed out"
+    code = 2
+
+
+class TeslaFleetMessageFaultUnknownKeyId(TeslaFleetMessageFault):
+    """Unknown Key ID"""
+
+    message = "Unknown Key ID"
+    code = 3
+
+
+class TeslaFleetMessageFaultInactiveKey(TeslaFleetMessageFault):
+    """Inactive Key"""
+
+    message = "Inactive Key"
+    code = 4
+
+
+class TeslaFleetMessageFaultInvalidSignature(TeslaFleetMessageFault):
+    """Invalid Signature"""
+
+    message = "Invalid Signature"
+    code = 5
+
+
+class TeslaFleetMessageFaultInvalidTokenOrCounter(TeslaFleetMessageFault):
+    """Invalid Token or Counter"""
+
+    message = "Invalid Token or Counter"
+    code = 6
+
+
+class TeslaFleetMessageFaultInsufficientPrivileges(TeslaFleetMessageFault):
+    """Insufficient Privileges"""
+
+    message = "Insufficient Privileges"
+    code = 7
+
+
+class TeslaFleetMessageFaultInvalidDomains(TeslaFleetMessageFault):
+    """Invalid Domains"""
+
+    message = "Invalid Domains"
+    code = 8
+
+
+class TeslaFleetMessageFaultInvalidCommand(TeslaFleetMessageFault):
+    """Invalid Command"""
+
+    message = "Invalid Command"
+    code = 9
+
+
+class TeslaFleetMessageFaultDecoding(TeslaFleetMessageFault):
+    """Decoding Error"""
+
+    message = "Decoding Error"
+    code = 10
+
+
+class TeslaFleetMessageFaultInternal(TeslaFleetMessageFault):
+    """Internal Error"""
+
+    message = "Internal Error"
+    code = 11
+
+
+class TeslaFleetMessageFaultWrongPersonalization(TeslaFleetMessageFault):
+    """Wrong Personalization"""
+
+    message = "Wrong Personalization"
+    code = 12
+
+
+class TeslaFleetMessageFaultBadParameter(TeslaFleetMessageFault):
+    """Bad Parameter"""
+
+    message = "Bad Parameter"
+    code = 13
+
+
+class TeslaFleetMessageFaultKeychainIsFull(TeslaFleetMessageFault):
+    """Keychain is Full"""
+
+    message = "Keychain is Full"
+    code = 14
+
+
+class TeslaFleetMessageFaultIncorrectEpoch(TeslaFleetMessageFault):
+    """Incorrect Epoch"""
+
+    message = "Incorrect Epoch"
+    code = 15
+
+
+class TeslaFleetMessageFaultIVIncorrectLength(TeslaFleetMessageFault):
+    """IV Incorrect Length"""
+
+    message = "IV Incorrect Length"
+    code = 16
+
+
+class TeslaFleetMessageFaultTimeExpired(TeslaFleetMessageFault):
+    """Time Expired"""
+
+    message = "Time Expired"
+    code = 17
+
+
+class TeslaFleetMessageFaultNotProvisionedWithIdentity(TeslaFleetMessageFault):
+    """Not Provisioned with Identity"""
+
+    message = "Not Provisioned with Identity"
+    code = 18
+
+
+class TeslaFleetMessageFaultCouldNotHashMetadata(TeslaFleetMessageFault):
+    """Could not Hash Metadata"""
+
+    message = "Could not Hash Metadata"
+    code = 19
+
+
+class TeslaFleetMessageFaultTimeToLiveTooLong(TeslaFleetMessageFault):
+    """Time to Live Too Long"""
+
+    message = "Time to Live Too Long"
+    code = 20
+
+
+class TeslaFleetMessageFaultRemoteAccessDisabled(TeslaFleetMessageFault):
+    """Remote Access Disabled"""
+
+    message = "Remote Access Disabled"
+    code = 21
+
+
+class TeslaFleetMessageFaultRemoteServiceAccessDisabled(TeslaFleetMessageFault):
+    """Remote Service Access Disabled"""
+
+    message = "Remote Service Access Disabled"
+    code = 22
+
+
+class TeslaFleetMessageFaultCommandRequiresAccountCredentials(TeslaFleetMessageFault):
+    """Command Requires Account Credentials"""
+
+    message = "Command Requires Account Credentials"
+    code = 23
+
+
+MESSAGE_FAULTS = [
+    None,
+    TeslaFleetMessageFaultBusy,
+    TeslaFleetMessageFaultTimeout,
+    TeslaFleetMessageFaultUnknownKeyId,
+    TeslaFleetMessageFaultInactiveKey,
+    TeslaFleetMessageFaultInvalidSignature,
+    TeslaFleetMessageFaultInvalidTokenOrCounter,
+    TeslaFleetMessageFaultInsufficientPrivileges,
+    TeslaFleetMessageFaultInvalidDomains,
+    TeslaFleetMessageFaultInvalidCommand,
+    TeslaFleetMessageFaultDecoding,
+    TeslaFleetMessageFaultInternal,
+    TeslaFleetMessageFaultWrongPersonalization,
+    TeslaFleetMessageFaultBadParameter,
+    TeslaFleetMessageFaultKeychainIsFull,
+    TeslaFleetMessageFaultIncorrectEpoch,
+    TeslaFleetMessageFaultIVIncorrectLength,
+    TeslaFleetMessageFaultTimeExpired,
+    TeslaFleetMessageFaultNotProvisionedWithIdentity,
+    TeslaFleetMessageFaultCouldNotHashMetadata,
+    TeslaFleetMessageFaultTimeToLiveTooLong,
+    TeslaFleetMessageFaultRemoteAccessDisabled,
+    TeslaFleetMessageFaultRemoteServiceAccessDisabled,
+    TeslaFleetMessageFaultCommandRequiresAccountCredentials,
+]
+
+
 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

tesla_fleet_api/teslafleetapi.py

@@ -30,7 +30,7 @@ class TeslaFleetApi:
     session: aiohttp.ClientSession
     headers: dict[str, str]
     refresh_hook: Awaitable | None = None
-    _private_key: ec.EllipticCurvePrivateKey | None = None
+    private_key: ec.EllipticCurvePrivateKey | None = None
 
     def __init__(
         self,
@@ -161,14 +161,16 @@ class TeslaFleetApi:
             "api/1/products",
         )
 
-    async def get_private_key(self, path: str = "private_key.pem") -> ec.EllipticCurvePrivateKey:
+    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(
+            self.private_key = ec.generate_private_key(
                 ec.SECP256R1(), default_backend()
             )
             # save the key
-            pem = self._private_key.private_bytes(
+            pem = self.private_key.private_bytes(
                 encoding=serialization.Encoding.PEM,
                 format=serialization.PrivateFormat.TraditionalOpenSSL,
                 encryption_algorithm=serialization.NoEncryption(),
@@ -189,5 +191,10 @@ class TeslaFleetApi:
 
             if not isinstance(value, ec.EllipticCurvePrivateKey):
                 raise AssertionError("Loaded key is not an EllipticCurvePrivateKey")
-            self._private_key = value
-        return self._private_key
+            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/vehiclesigned.py

@@ -9,7 +9,7 @@ import hashlib
 from cryptography.hazmat.primitives.asymmetric import ec
 from cryptography.hazmat.primitives.serialization import PublicFormat, Encoding
 
-from tesla_fleet_api.exceptions import SIGNING_EXCEPTIONS
+from .exceptions import MESSAGE_FAULTS
 
 from .const import (
     LOGGER,
@@ -22,16 +22,17 @@ from .const import (
 from .vehiclespecific import VehicleSpecific
 
 from .pb2.universal_message_pb2 import (
-    OPERATIONSTATUS_OK,
+    # OPERATIONSTATUS_OK,
     OPERATIONSTATUS_WAIT,
     OPERATIONSTATUS_ERROR,
     DOMAIN_VEHICLE_SECURITY,
     DOMAIN_INFOTAINMENT,
+    Domain,
+    # MessageFault_E,
     RoutableMessage,
 )
 from .pb2.car_server_pb2 import (
     Action,
-    HvacAutoAction,
     MediaPlayAction,
     VehicleAction,
     VehicleControlFlashLightsAction,
@@ -48,8 +49,8 @@ from .pb2.car_server_pb2 import (
     HvacSteeringWheelHeaterAction,
     HvacTemperatureAdjustmentAction,
     GetNearbyChargingSites,
-    NearbyChargingSites,
-    Superchargers,
+    # NearbyChargingSites,
+    # Superchargers,
     VehicleControlCancelSoftwareUpdateAction,
     VehicleControlHonkHornAction,
     VehicleControlResetValetPinAction,
@@ -61,15 +62,13 @@ from .pb2.car_server_pb2 import (
     VehicleControlWindowAction,
     HvacBioweaponModeAction,
     AutoSeatClimateAction,
-    Ping,
+    # Ping,
     ScheduledChargingAction,
     ScheduledDepartureAction,
     HvacClimateKeeperAction,
     SetChargingAmpsAction,
     SetCabinOverheatProtectionAction,
     SetVehicleNameAction,
-    ChargePortDoorOpen,
-    ChargePortDoorClose,
     SetCopTempAction,
     VehicleControlSetPinToDriveAction,
     VehicleControlResetPinToDriveAction,
@@ -79,8 +78,9 @@ from .pb2.car_server_pb2 import (
     MediaPreviousTrack,
     MediaPreviousFavorite,
 )
-from .pb2.vehicle_pb2 import VehicleState, ClimateState
+from .pb2.vehicle_pb2 import VehicleState
 from .pb2.vcsec_pb2 import (
+    # SignedMessage_information_E,
     UnsignedMessage,
     RKEAction_E,
     ClosureMoveRequest,
@@ -154,7 +154,7 @@ class Session:
 class VehicleSigned(VehicleSpecific):
     """Class describing the Tesla Fleet API vehicle endpoints and commands for a specific vehicle with command signing."""
 
-    _private_key: ec.EllipticCurvePrivateKey
+    private_key: ec.EllipticCurvePrivateKey
     _public_key: bytes
     _from_destination: bytes
     _sessions: dict[int, Session]
@@ -164,13 +164,13 @@ class VehicleSigned(VehicleSpecific):
     ):
         super().__init__(parent, vin)
         if key:
-            self._private_key = key
-        elif parent._parent._private_key:
-            self._private_key = parent._parent._private_key
+            self.private_key = key
+        elif parent._parent.private_key:
+            self.private_key = parent._parent.private_key
         else:
             raise ValueError("No private key.")
 
-        self._public_key = self._private_key.public_key().public_bytes(
+        self._public_key = self.private_key.public_key().public_bytes(
             encoding=Encoding.X962, format=PublicFormat.UncompressedPoint
         )
         self._from_destination = randbytes(16)
@@ -179,13 +179,19 @@ class VehicleSigned(VehicleSpecific):
     async def _signed_message(self, msg: RoutableMessage) -> RoutableMessage:
         """Serialize a message and send to the signed command endpoint."""
         routable_message = base64.b64encode(msg.SerializeToString()).decode()
-        resp = await self.signed_command(routable_message)
-        msg = RoutableMessage()
-        msg.ParseFromString(base64.b64decode(resp["response"]))
-        return msg
+        resp_json = await self.signed_command(routable_message)
+        resp = RoutableMessage()
+        resp.ParseFromString(base64.b64decode(resp_json["response"]))
+
+        LOGGER.error(resp.signedMessageStatus)
+        if resp.signedMessageStatus.operation_status == OPERATIONSTATUS_ERROR:
+            raise MESSAGE_FAULTS[resp.signedMessageStatus.signed_message_fault]
+
+        return resp
 
     async def _handshake(self, domain: int) -> None:
         """Perform a handshake with the vehicle."""
+        LOGGER.debug(f"Handshake with domain {Domain.Name(domain)}")
         msg = RoutableMessage()
         msg.to_destination.domain = domain
         msg.from_destination.routing_address = self._from_destination
@@ -197,10 +203,11 @@ class VehicleSigned(VehicleSpecific):
 
         # Get session info with publicKey, epoch, and clock_time
         info = SessionInfo.FromString(resp.session_info)
+
         vehicle_public_key = info.publicKey
 
         # Derive shared key from private key _key and vehicle public key
-        shared = self._private_key.exchange(
+        shared = self.private_key.exchange(
             ec.ECDH(),
             ec.EllipticCurvePublicKey.from_encoded_point(
                 ec.SECP256R1(), vehicle_public_key
@@ -228,6 +235,7 @@ class VehicleSigned(VehicleSpecific):
 
     async def _send(self, domain: int, command: bytes) -> dict[str, Any]:
         """Send a signed message to the vehicle."""
+        LOGGER.debug(f"Sending to domain {Domain.Name(domain)}")
         msg = RoutableMessage()
         msg.to_destination.domain = domain
         msg.from_destination.routing_address = self._from_destination
@@ -267,28 +275,15 @@ class VehicleSigned(VehicleSpecific):
 
         resp = await self._signed_message(msg)
 
-        LOGGER.debug(resp)
-        if resp.signedMessageStatus.operation_status == OPERATIONSTATUS_ERROR:
-            raise SIGNING_EXCEPTIONS[resp.signedMessageStatus.signed_message_fault]
         if resp.signedMessageStatus.operation_status == OPERATIONSTATUS_WAIT:
             return {"response": {"result": False}}
 
-        if resp.protobuf_message_as_bytes and (
-            text := resp.protobuf_message_as_bytes.decode()
-        ):
-            LOGGER.warning(text)
-
-            # if domain == DOMAIN_INFOTAINMENT:
-            #    resp_msg = Action()
-            #    resp_msg.ParseFromString(resp.protobuf_message_as_bytes)
-            #    print("INFOTAINMENT RESPONSE", resp_msg)
-            #    #return {"response": {"result": False, "reason": resp_msg}}
-            # elif domain == DOMAIN_VEHICLE_SECURITY:
-            #    resp_msg = UnsignedMessage()
-            #    resp_msg.ParseFromString(resp.protobuf_message_as_bytes)
-            #    print("VCSEC RESPONSE", resp_msg)
-            #    print(resp.protobuf_message_as_bytes.encode())
-            #    #return {"response": {"result": False, "reason": resp_msg}}
+        LOGGER.debug(resp)
+        reason = resp.protobuf_message_as_bytes[8:].decode()
+
+        if reason:
+            LOGGER.error(reason)
+            return {"response": {"result": False, "reason": reason}}
 
         return {"response": {"result": True, "reason": ""}}
 

{tesla_fleet_api-0.8.2.dist-info → tesla_fleet_api-0.8.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tesla_fleet_api
-Version: 0.8.2
+Version: 0.8.4
 Summary: Tesla Fleet API library for Python
 Home-page: https://github.com/Teslemetry/tesla_fleet_api
 Author: Brett Adams

{tesla_fleet_api-0.8.2.dist-info → tesla_fleet_api-0.8.4.dist-info}/RECORD

@@ -1,19 +1,19 @@
 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=UqD-Vof5Dv7VkJZ7Qe4DgwVYlhiEBzM1V-Qzxde_6Aw,9577
+tesla_fleet_api/const.py,sha256=LdClo7IxPtcVCtp_9eLnBHGm6eAQngPXlBqFCjbUsdA,9577
 tesla_fleet_api/energy.py,sha256=S7D75MPuMVsHgkyUcFfMqjGCLZBM5YVFlWLEHbaX-zw,5957
 tesla_fleet_api/energyspecific.py,sha256=UfeaGE59aoAa8UhpQCXUi0sOrNCA40xZlqwF73BXTVY,4254
-tesla_fleet_api/exceptions.py,sha256=zl8m4Z51ihVD5cKYSZ8e6heerArF0j5isQmX-gSdkwM,15456
+tesla_fleet_api/exceptions.py,sha256=wteuynQA2OY13IHEsiQHV-WU8BPUCpDDHBaYbRvQlHI,20299
 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=zEu47xLopPfkpqE5nx2rf9eqZuZFii1jjXsOgay6Q3A,7229
+tesla_fleet_api/teslafleetapi.py,sha256=4Rnh_HNZkIw54o9SYAaHsA8vY0pmk_bMncrLuJ8MtSk,7389
 tesla_fleet_api/teslafleetoauth.py,sha256=OY9yRQuokYo3ts0C8Qb6Z-o9NNAGHbX9F5mHfAh50fo,4121
 tesla_fleet_api/teslafleetopensource.py,sha256=TJfVPcqJlA1b3kMoGuLr-g5Gn8UDyYsTZhjvGY1MtIk,2007
 tesla_fleet_api/teslemetry.py,sha256=Rl73BWYYJk1UWIhCPwywcXGRlkATYZrPz3LP-Covppw,3272
 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=W5Y_ok5PK7jtXsenWpMWJTS4RpLhRW-1AlTPv1a6R6A,31765
-tesla_fleet_api/vehiclesigned.py,sha256=vQ5luKjfpFAjnLBpJhOrUfdDDa24AEwKLRrf82bRQWs,39167
+tesla_fleet_api/vehiclesigned.py,sha256=kxcR_I5B6I8ZsE336d22QDlVNpfxkdvRnW38XolLBsw,38698
 tesla_fleet_api/vehiclespecific.py,sha256=Nr4zZzfmIuw3RFYjQEX6c_xtYZgztMsN5ohVn-YEH0I,20600
 tesla_fleet_api/pb2/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tesla_fleet_api/pb2/__init__.pyi,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -25,8 +25,8 @@ tesla_fleet_api/pb2/signatures_pb2.py,sha256=5mdJUC8EC8kx1UxYrHK5XI3_7M6v7w2POH1
 tesla_fleet_api/pb2/universal_message_pb2.py,sha256=F6-SkYXSuzWDsBvnGMg9k2pAIZv13v609qCPx7NSrdw,7254
 tesla_fleet_api/pb2/vcsec_pb2.py,sha256=CMJ97e4Mm4p7NFcgybbCC2KJRcvtrcqmBy_pGycYhMo,26238
 tesla_fleet_api/pb2/vehicle_pb2.py,sha256=P1V7Dqg3BBGZwODxTpZqtxLP6fGS_FNBqJcz_Fp0crs,2482
-tesla_fleet_api-0.8.2.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-tesla_fleet_api-0.8.2.dist-info/METADATA,sha256=sNmh6uj5rzAIUbXzR5hoLenHTKsNy-xXgrMRwcrUmbc,3821
-tesla_fleet_api-0.8.2.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-tesla_fleet_api-0.8.2.dist-info/top_level.txt,sha256=jeNbog_1saXBFrGpom9WyPWmilxsyP3szL_G7JLWQfM,16
-tesla_fleet_api-0.8.2.dist-info/RECORD,,
+tesla_fleet_api-0.8.4.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+tesla_fleet_api-0.8.4.dist-info/METADATA,sha256=IgxXyOX1pquDCnzteGukMbnBUKIO9V95H2bP4xl67Hc,3821
+tesla_fleet_api-0.8.4.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+tesla_fleet_api-0.8.4.dist-info/top_level.txt,sha256=jeNbog_1saXBFrGpom9WyPWmilxsyP3szL_G7JLWQfM,16
+tesla_fleet_api-0.8.4.dist-info/RECORD,,