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

tesla_fleet_api/{vehiclesigned.py → tesla/vehicle/commands.py}

@@ -1,20 +1,28 @@
 from __future__ import annotations
-import base64
+from abc import abstractmethod
+
+import struct
 from random import randbytes
 from typing import Any, TYPE_CHECKING
 import time
-import struct
 import hmac
 import hashlib
 from cryptography.hazmat.primitives.asymmetric import ec
 from cryptography.hazmat.primitives.serialization import PublicFormat, Encoding
+from cryptography.hazmat.primitives.hashes import Hash, SHA256
+from cryptography.hazmat.primitives.ciphers.aead import AESGCM
 from asyncio import Lock, sleep
 
-from tesla_fleet_api.pb2.errors_pb2 import GenericError_E
+from ...exceptions import (
+    SIGNED_MESSAGE_INFORMATION_FAULTS,
+    TeslaFleetMessageFaultIncorrectEpoch,
+    TeslaFleetMessageFaultInvalidTokenOrCounter,
+)
 
-from .exceptions import MESSAGE_FAULTS, SIGNED_MESSAGE_INFORMATION_FAULTS, TeslaFleetMessageFaultIncorrectEpoch, TeslaFleetMessageFaultInvalidTokenOrCounter
+from .vehicle import Vehicle
 
-from .const import (
+
+from ...const import (
     LOGGER,
     Trunk,
     ClimateKeeperMode,
@@ -22,18 +30,42 @@ from .const import (
     SunRoofCommand,
     WindowCommand,
 )
-from .vehiclespecific import VehicleSpecific
 
-from .pb2.universal_message_pb2 import (
-    OPERATIONSTATUS_WAIT,
-    OPERATIONSTATUS_ERROR,
-    DOMAIN_VEHICLE_SECURITY,
+# Protocol
+from .proto.errors_pb2 import GenericError_E
+from .proto.car_server_pb2 import (
+    Response,
+)
+from .proto.signatures_pb2 import (
+    SIGNATURE_TYPE_AES_GCM_PERSONALIZED,
+    SIGNATURE_TYPE_HMAC_PERSONALIZED,
+    TAG_COUNTER,
+    TAG_DOMAIN,
+    TAG_END,
+    TAG_EPOCH,
+    TAG_EXPIRES_AT,
+    TAG_PERSONALIZATION,
+    TAG_SIGNATURE_TYPE,
+    AES_GCM_Personalized_Signature_Data,
+    KeyIdentity,
+    SessionInfo,
+    SignatureData,
+)
+from .proto.universal_message_pb2 import (
     DOMAIN_INFOTAINMENT,
+    DOMAIN_VEHICLE_SECURITY,
+    OPERATIONSTATUS_ERROR,
+    OPERATIONSTATUS_WAIT,
+    Destination,
     Domain,
     RoutableMessage,
+    SessionInfoRequest,
 )
-from .pb2.car_server_pb2 import (
-    Response,
+from .proto.vcsec_pb2 import (
+    OPERATIONSTATUS_OK,
+    FromVCSECMessage,
+)
+from .proto.car_server_pb2 import (
     Action,
     MediaPlayAction,
     VehicleAction,
@@ -64,7 +96,7 @@ from .pb2.car_server_pb2 import (
     VehicleControlWindowAction,
     HvacBioweaponModeAction,
     AutoSeatClimateAction,
-    # Ping,
+    Ping,
     ScheduledChargingAction,
     ScheduledDepartureAction,
     HvacClimateKeeperAction,
@@ -80,202 +112,171 @@ from .pb2.car_server_pb2 import (
     MediaPreviousTrack,
     MediaPreviousFavorite,
 )
-from .pb2.vehicle_pb2 import VehicleState
-from .pb2.vcsec_pb2 import (
-    # SignedMessage_information_E,
-    OPERATIONSTATUS_OK,
-    FromVCSECMessage,
+from .proto.vehicle_pb2 import VehicleState, ClimateState
+from .proto.vcsec_pb2 import (
     UnsignedMessage,
     RKEAction_E,
     ClosureMoveRequest,
     ClosureMoveType_E,
 )
-from .pb2.signatures_pb2 import (
-    SIGNATURE_TYPE_HMAC_PERSONALIZED,
-    TAG_DOMAIN,
-    TAG_SIGNATURE_TYPE,
-    SessionInfo,
+from .proto.signatures_pb2 import (
     HMAC_Personalized_Signature_Data,
-    TAG_PERSONALIZATION,
-    TAG_EPOCH,
-    TAG_EXPIRES_AT,
-    TAG_COUNTER,
-    TAG_END,
 )
-from .pb2.common_pb2 import (
+from .proto.common_pb2 import (
     Void,
     PreconditioningTimes,
     OffPeakChargingTimes,
-    # ChargeSchedule,
-    # PreconditionSchedule,
 )
 
 if TYPE_CHECKING:
-    from .vehicle import Vehicle
+    from ..tesla import Tesla
+
+# ENUMs to convert ints to proto typed ints
+AutoSeatClimatePositions = (
+    AutoSeatClimateAction.AutoSeatPosition_FrontLeft,
+    AutoSeatClimateAction.AutoSeatPosition_FrontRight,
+)
+
+HvacSeatCoolerLevels = (
+    HvacSeatCoolerActions.HvacSeatCoolerLevel_Off,
+    HvacSeatCoolerActions.HvacSeatCoolerLevel_Low,
+    HvacSeatCoolerActions.HvacSeatCoolerLevel_Med,
+    HvacSeatCoolerActions.HvacSeatCoolerLevel_High,
+)
+
+HvacSeatCoolerPositions = (
+    HvacSeatCoolerActions.HvacSeatCoolerPosition_FrontLeft,
+    HvacSeatCoolerActions.HvacSeatCoolerPosition_FrontRight,
+)
+
+HvacClimateKeeperActions = (
+    HvacClimateKeeperAction.ClimateKeeperAction_Off,
+    HvacClimateKeeperAction.ClimateKeeperAction_On,
+    HvacClimateKeeperAction.ClimateKeeperAction_Dog,
+    HvacClimateKeeperAction.ClimateKeeperAction_Camp,
+)
 
+CopActivationTemps = (
+    ClimateState.CopActivationTemp.CopActivationTempLow,
+    ClimateState.CopActivationTemp.CopActivationTempMedium,
+    ClimateState.CopActivationTemp.CopActivationTempHigh,
+)
 
 class Session:
     """A connect to a domain"""
 
+    domain: Domain
+    parent: Commands
     key: bytes
     counter: int
     epoch: bytes
     delta: int
+    sharedKey: bytes
     hmac: bytes
     publicKey: bytes
     lock: Lock
 
-    def __init__(self):
+    def __init__(self, parent: Commands, domain: Domain):
+        self.parent = parent
+        self.domain = domain
         self.lock = Lock()
         self.counter = 0
+        self.ready = False
 
-    def update(self, sessionInfo: SessionInfo, privateKey: ec.EllipticCurvePrivateKey):
+    def update(self, sessionInfo: SessionInfo):
         """Update the session with new information"""
+
         self.counter = sessionInfo.counter
         self.epoch = sessionInfo.epoch
         self.delta = int(time.time()) - sessionInfo.clock_time
-        if (self.publicKey != sessionInfo.publicKey):
+        if (not self.ready or self.publicKey != sessionInfo.publicKey):
             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(
-                self.key, "authenticated command".encode(), hashlib.sha256
-            ).digest()
+            self.sharedKey = self.parent.shared_key(sessionInfo.publicKey)
+            self.hmac = hmac.new(self.sharedKey, "authenticated command".encode(), hashlib.sha256).digest()
+        self.ready = True
 
-    def get(self) -> HMAC_Personalized_Signature_Data:
+    def hmac_personalized(self) -> HMAC_Personalized_Signature_Data:
         """Sign a command and return session metadata"""
-        self.counter = self.counter+1
+        self.counter += 1
         return HMAC_Personalized_Signature_Data(
             epoch=self.epoch,
             counter=self.counter,
             expires_at=int(time.time()) - self.delta + 10,
         )
 
+    def aes_gcm_personalized(self) -> AES_GCM_Personalized_Signature_Data:
+        """Sign a command and return session metadata"""
+        self.counter += 1
+        return AES_GCM_Personalized_Signature_Data(
+            epoch=self.epoch,
+            nonce=randbytes(12),
+            counter=self.counter,
+            expires_at=int(time.time()) - self.delta + 10,
+        )
+
 
-class VehicleSigned(VehicleSpecific):
+class Commands(Vehicle):
     """Class describing the Tesla Fleet API vehicle endpoints and commands for a specific vehicle with command signing."""
 
     private_key: ec.EllipticCurvePrivateKey
     _public_key: bytes
     _from_destination: bytes
     _sessions: dict[int, Session]
+    _require_keys = True
+    _auth_method: str
 
     def __init__(
-        self, parent: Vehicle, vin: str, key: ec.EllipticCurvePrivateKey | None = None
+        self, parent: Tesla, vin: str, private_key: ec.EllipticCurvePrivateKey | None = None, public_key: bytes | None = None
     ):
         super().__init__(parent, vin)
-        if 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(
-            encoding=Encoding.X962, format=PublicFormat.UncompressedPoint
-        )
         self._from_destination = randbytes(16)
-        self._sessions = {}
-
-    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
-
-    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
-        msg.from_destination.routing_address = self._from_destination
-        msg.session_info_request.public_key = self._public_key
-        msg.uuid = randbytes(16)
-
-        # Send handshake message
-        await self._send(msg)
-
-        return self._sessions[domain]
-
-    async def _sendVehicleSecurity(self, command: UnsignedMessage) -> dict[str, Any]:
-        """Sign and send a message to Infotainment computer."""
-        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."""
-        return await self._sign(DOMAIN_INFOTAINMENT, command.SerializeToString())
-
-    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)}")
+        self._sessions = {
+            Domain.DOMAIN_VEHICLE_SECURITY: Session(self, Domain.DOMAIN_VEHICLE_SECURITY),
+            Domain.DOMAIN_INFOTAINMENT: Session(self, Domain.DOMAIN_INFOTAINMENT),
+        }
+
+        if(self._require_keys):
+            if private_key:
+                self.private_key = private_key
+            elif parent.private_key:
+                self.private_key = parent.private_key
+            else:
+                raise ValueError("No private key.")
+
+            self._public_key = public_key or self.private_key.public_key().public_bytes(
+                encoding=Encoding.X962, format=PublicFormat.UncompressedPoint
+        )
 
-        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)
+    def shared_key(self, vehicleKey: bytes) -> bytes:
+        exchange = self.private_key.exchange(
+            ec.ECDH(),
+            ec.EllipticCurvePublicKey.from_encoded_point(
+                ec.SECP256R1(), vehicleKey
+            ),
+        )
+        return hashlib.sha1(exchange).digest()[:16]
 
-        metadata = bytes([
-            TAG_SIGNATURE_TYPE,
-            1,
-            SIGNATURE_TYPE_HMAC_PERSONALIZED,
-            TAG_DOMAIN,
-            1,
-            domain,
-            TAG_PERSONALIZATION,
-            17,
-            *self.vin.encode(),
-            TAG_EPOCH,
-            len(hmac_personalized.epoch),
-            *hmac_personalized.epoch,
-            TAG_EXPIRES_AT,
-            4,
-            *struct.pack(">I", hmac_personalized.expires_at),
-            TAG_COUNTER,
-            4,
-            *struct.pack(">I", hmac_personalized.counter),
-            TAG_END,
-        ])
 
-        hmac_personalized.tag = hmac.new(
-            session.hmac, metadata + command, hashlib.sha256
-        ).digest()
+    @abstractmethod
+    async def _send(self, msg: RoutableMessage) -> RoutableMessage:
+        """Transmit the message to the vehicle."""
+        raise NotImplementedError
 
-        # 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
+    @abstractmethod
+    async def _command(self, domain: Domain, command: bytes, attempt: int = 0) -> dict[str, Any]:
+        """Serialize a message and send to the signed command endpoint."""
+        session = self._sessions[domain]
+        if not session.ready:
+            await self._handshake(domain)
+
+        if self._auth_method == "hmac":
+            msg = await self._commandHmac(session, command)
+        elif self._auth_method == "aes":
+            msg = await self._commandAes(session, command)
+        else:
+            raise ValueError(f"Unknown auth method: {self._auth_method}")
 
         try:
             resp = await self._send(msg)
@@ -287,7 +288,7 @@ class VehicleSigned(VehicleSpecific):
             if attempt > 3:
                 # We tried 3 times, give up, raise the error
                 raise e
-            return await self._sign(domain, command, attempt)
+            return await self._command(domain, command, attempt)
 
         if resp.signedMessageStatus.operation_status == OPERATIONSTATUS_WAIT:
             attempt += 1
@@ -296,7 +297,7 @@ class VehicleSigned(VehicleSpecific):
                 return {"response": {"result": False, "reason": "Too many retries"}}
             async with session.lock:
                 await sleep(2)
-            return await self._sign(domain, command, attempt)
+            return await self._command(domain, command, attempt)
 
         if resp.HasField("protobuf_message_as_bytes"):
             if(resp.from_destination.domain == DOMAIN_VEHICLE_SECURITY):
@@ -319,7 +320,7 @@ class VehicleSigned(VehicleSpecific):
                         return {"response": {"result": False, "reason": "Too many retries"}}
                     async with session.lock:
                         await sleep(2)
-                    return await self._sign(domain, command, attempt)
+                    return await self._command(domain, command, attempt)
                 elif vcsec.commandStatus.operationStatus == OPERATIONSTATUS_ERROR:
                     if(resp.HasField("signedMessageStatus")):
                         raise SIGNED_MESSAGE_INFORMATION_FAULTS[vcsec.commandStatus.signedMessageStatus.signedMessageInformation]
@@ -345,6 +346,155 @@ class VehicleSigned(VehicleSpecific):
 
         return {"response": {"result": True, "reason": ""}}
 
+    async def _commandHmac(self, session: Session, command: bytes, attempt: int = 1) -> RoutableMessage:
+        """Create a signed message."""
+        LOGGER.debug(f"Sending HMAC to domain {Domain.Name(session.domain)}")
+
+        hmac_personalized = session.hmac_personalized()
+
+        metadata = bytes([
+            TAG_SIGNATURE_TYPE,
+            1,
+            SIGNATURE_TYPE_HMAC_PERSONALIZED,
+            TAG_DOMAIN,
+            1,
+            session.domain,
+            TAG_PERSONALIZATION,
+            17,
+            *self.vin.encode(),
+            TAG_EPOCH,
+            len(hmac_personalized.epoch),
+            *hmac_personalized.epoch,
+            TAG_EXPIRES_AT,
+            4,
+            *struct.pack(">I", hmac_personalized.expires_at),
+            TAG_COUNTER,
+            4,
+            *struct.pack(">I", hmac_personalized.counter),
+            TAG_END,
+        ])
+
+        hmac_personalized.tag = hmac.new(
+            session.hmac, metadata + command, hashlib.sha256
+        ).digest()
+
+        return RoutableMessage(
+            to_destination=Destination(
+                domain=session.domain,
+            ),
+            from_destination=Destination(
+                routing_address=self._from_destination
+            ),
+            protobuf_message_as_bytes=command,
+            uuid=randbytes(16),
+            signature_data=SignatureData(
+                signer_identity=KeyIdentity(
+                    public_key=self._public_key
+                ),
+                HMAC_Personalized_data=hmac_personalized,
+            )
+        )
+
+    async def _commandAes(self, session: Session, command: bytes, attempt: int = 1) -> RoutableMessage:
+        """Create an encrypted message."""
+        LOGGER.debug(f"Sending AES to domain {Domain.Name(session.domain)}")
+
+        aes_personalized = session.aes_gcm_personalized()
+
+        metadata = bytes([
+            TAG_SIGNATURE_TYPE,
+            1,
+            SIGNATURE_TYPE_AES_GCM_PERSONALIZED,
+            TAG_DOMAIN,
+            1,
+            session.domain,
+            TAG_PERSONALIZATION,
+            17,
+            *self.vin.encode(),
+            TAG_EPOCH,
+            len(aes_personalized.epoch),
+            *aes_personalized.epoch,
+            TAG_EXPIRES_AT,
+            4,
+            *struct.pack(">I", aes_personalized.expires_at),
+            TAG_COUNTER,
+            4,
+            *struct.pack(">I", aes_personalized.counter),
+            TAG_END,
+        ])
+
+        aad = Hash(SHA256())
+        aad.update(metadata)
+
+        aesgcm = AESGCM(session.sharedKey)
+        ct = aesgcm.encrypt(aes_personalized.nonce, command, aad.finalize())
+
+        aes_personalized.tag = ct[-16:]
+
+        # I think this whole section could be improved
+        return RoutableMessage(
+            to_destination=Destination(
+                domain=session.domain,
+            ),
+            from_destination=Destination(
+                routing_address=self._from_destination
+            ),
+            protobuf_message_as_bytes=ct[:-16],
+            uuid=randbytes(16),
+            signature_data=SignatureData(
+                signer_identity=KeyIdentity(
+                    public_key=self._public_key
+                ),
+                AES_GCM_Personalized_data=aes_personalized,
+            )
+        )
+
+
+    async def _sendVehicleSecurity(self, command: UnsignedMessage) -> dict[str, Any]:
+        """Sign and send a message to Infotainment computer."""
+        return await self._command(Domain.DOMAIN_VEHICLE_SECURITY, command.SerializeToString())
+
+    async def _sendInfotainment(self, command: Action) -> dict[str, Any]:
+        """Sign and send a message to Infotainment computer."""
+        return await self._command(Domain.DOMAIN_INFOTAINMENT, command.SerializeToString())
+
+    async def handshakeVehicleSecurity(self) -> None:
+        """Perform a handshake with the vehicle security domain."""
+        await self._handshake(Domain.DOMAIN_VEHICLE_SECURITY)
+
+    async def handshakeInfotainment(self) -> None:
+        """Perform a handshake with the infotainment domain."""
+        await self._handshake(Domain.DOMAIN_INFOTAINMENT)
+
+    async def _handshake(self, domain: Domain) -> None:
+        """Perform a handshake with the vehicle."""
+
+        LOGGER.debug(f"Handshake with domain {Domain.Name(domain)}")
+        msg = RoutableMessage(
+            to_destination=Destination(
+                domain=domain,
+            ),
+            from_destination=Destination(
+                routing_address=self._from_destination
+            ),
+            session_info_request=SessionInfoRequest(
+                public_key=self._public_key
+            ),
+            uuid=randbytes(16)
+        )
+
+        await self._send(msg)
+
+    async def ping(self) -> dict[str, Any]:
+        """Ping the vehicle."""
+        return await self._sendInfotainment(
+            Action(
+                vehicleAction=VehicleAction(
+                    ping=Ping(ping_id=0)
+                )
+            )
+        )
+
     async def actuate_trunk(self, which_trunk: Trunk | str) -> dict[str, Any]:
         """Controls the front or rear trunk."""
         if which_trunk == Trunk.FRONT:
@@ -363,6 +513,7 @@ class VehicleSigned(VehicleSpecific):
                     )
                 )
             )
+        raise ValueError("Invalid trunk.")
 
     async def adjust_volume(self, volume: float) -> dict[str, Any]:
         """Adjusts vehicle media playback volume."""
@@ -468,7 +619,7 @@ class VehicleSigned(VehicleSpecific):
             )
         )
 
-    async def clear_pin_to_drive_admin(self, pin: str):
+    async def clear_pin_to_drive_admin(self, pin: str | None = None):
         """Deactivates PIN to Drive and resets the associated PIN for vehicles running firmware versions 2023.44+. This command is only accessible to fleet managers or owners."""
         return await self._sendInfotainment(
             Action(
@@ -588,6 +739,7 @@ class VehicleSigned(VehicleSpecific):
     # navigation_gps_request doesnt require signing
     # navigation_request doesnt require signing
     # navigation_sc_request doesnt require signing
+    #
 
     async def remote_auto_seat_climate_request(
         self, auto_seat_position: int, auto_climate_on: bool
@@ -601,7 +753,7 @@ class VehicleSigned(VehicleSpecific):
                     autoSeatClimateAction=AutoSeatClimateAction(
                         carseat=[
                             AutoSeatClimateAction.CarSeat(
-                                on=auto_climate_on, seat_position=auto_seat_position
+                                on=auto_climate_on, seat_position=AutoSeatClimatePositions[auto_seat_position]
                             )
                         ]
                     )
@@ -612,6 +764,8 @@ class VehicleSigned(VehicleSpecific):
     # remote_auto_steering_wheel_heat_climate_request has no protobuf
 
     # remote_boombox not implemented
+    #
+
 
     async def remote_seat_cooler_request(
         self, seat_position: int, seat_cooler_level: int
@@ -631,8 +785,8 @@ class VehicleSigned(VehicleSpecific):
                     hvacSeatCoolerActions=HvacSeatCoolerActions(
                         hvacSeatCoolerAction=[
                             HvacSeatCoolerActions.HvacSeatCoolerAction(
-                                seat_cooler_level=seat_cooler_level + 1,
-                                seat_position=seat_position,
+                                seat_cooler_level=HvacSeatCoolerLevels[seat_cooler_level],
+                                seat_position=HvacSeatCoolerPositions[seat_position],
                             )
                         ]
                     )
@@ -817,11 +971,12 @@ class VehicleSigned(VehicleSpecific):
         """Enables climate keeper mode."""
         if isinstance(climate_keeper_mode, ClimateKeeperMode):
             climate_keeper_mode = climate_keeper_mode.value
+
         return await self._sendInfotainment(
             Action(
                 vehicleAction=VehicleAction(
                     hvacClimateKeeperAction=HvacClimateKeeperAction(
-                        ClimateKeeperAction=climate_keeper_mode,
+                        ClimateKeeperAction=HvacClimateKeeperActions[climate_keeper_mode],
                         # manual_override
                     )
                 )
@@ -837,7 +992,7 @@ class VehicleSigned(VehicleSpecific):
         return await self._sendInfotainment(
             Action(
                 vehicleAction=VehicleAction(
-                    setCopTempAction=SetCopTempAction(copActivationTemp=cop_temp + 1)
+                    setCopTempAction=SetCopTempAction(copActivationTemp=CopActivationTemps[cop_temp])
                 )
             )
         )
@@ -876,7 +1031,7 @@ class VehicleSigned(VehicleSpecific):
             Action(
                 vehicleAction=VehicleAction(
                     scheduledChargingAction=ScheduledChargingAction(
-                        enable=enable, charging_time=time
+                        enabled=enable, charging_time=time
                     )
                 )
             )
@@ -895,14 +1050,14 @@ class VehicleSigned(VehicleSpecific):
         """Sets a time at which departure should be completed. The time parameter is minutes after midnight (e.g: time=120 schedules departure for 2:00am vehicle local time)."""
 
         if preconditioning_weekdays_only:
-            preconditioning_times = PreconditioningTimes(weekdays=Void)
+            preconditioning_times = PreconditioningTimes(weekdays=Void())
         else:
-            preconditioning_times = PreconditioningTimes(all_week=Void)
+            preconditioning_times = PreconditioningTimes(all_week=Void())
 
         if off_peak_charging_weekdays_only:
-            off_peak_charging_times = OffPeakChargingTimes(weekdays=Void)
+            off_peak_charging_times = OffPeakChargingTimes(weekdays=Void())
         else:
-            off_peak_charging_times = OffPeakChargingTimes(all_week=Void)
+            off_peak_charging_times = OffPeakChargingTimes(all_week=Void())
 
         return await self._sendInfotainment(
             Action(
@@ -962,7 +1117,7 @@ class VehicleSigned(VehicleSpecific):
         return await self._sendInfotainment(
             Action(
                 vehicleAction=VehicleAction(
-                    setVehicleNameAction=SetVehicleNameAction(vehicle_name=vehicle_name)
+                    setVehicleNameAction=SetVehicleNameAction(vehicleName=vehicle_name)
                 )
             )
         )
@@ -1076,6 +1231,8 @@ class VehicleSigned(VehicleSpecific):
             action = VehicleControlWindowAction(vent=Void())
         elif command == "close":
             action = VehicleControlWindowAction(close=Void())
+        else:
+            raise ValueError(f"Invalid window command: {command}")
 
         return await self._sendInfotainment(
             Action(vehicleAction=VehicleAction(vehicleControlWindowAction=action))