carconnectivity-connector-seatcupra 0.1a2__py3-none-any.whl → 0.1a4__py3-none-any.whl

{carconnectivity_connector_seatcupra-0.1a2.dist-info → carconnectivity_connector_seatcupra-0.1a4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: carconnectivity-connector-seatcupra
-Version: 0.1a2
+Version: 0.1a4
 Summary: CarConnectivity connector for Seat and Cupra services
 Author: Till Steinbach
 License: MIT License
@@ -37,7 +37,7 @@ Classifier: Topic :: Software Development :: Libraries
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: carconnectivity>=0.4a1
+Requires-Dist: carconnectivity>=0.4a2
 Requires-Dist: oauthlib~=3.2.2
 Requires-Dist: requests~=2.32.3
 Requires-Dist: jwt~=1.3.1

{carconnectivity_connector_seatcupra-0.1a2.dist-info → carconnectivity_connector_seatcupra-0.1a4.dist-info}/RECORD

@@ -1,9 +1,11 @@
 carconnectivity_connectors/seatcupra/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-carconnectivity_connectors/seatcupra/_version.py,sha256=Ef3bGV58pr38At7Z3T5w6O9Yfnm9fPuFoS1_rJQZJLs,508
+carconnectivity_connectors/seatcupra/_version.py,sha256=XHqmG-GhsB57W0JySzM4ri39xqaz6Dslz1JUg-rSYsA,508
 carconnectivity_connectors/seatcupra/capability.py,sha256=Oe9tC_u69bj6VmOuNJ21RKoETe2j3QyZCoz-VgcZPQ0,4523
-carconnectivity_connectors/seatcupra/charging.py,sha256=kcCJJddZxUXFoayYMpq3lzdnrPp5yexnGBfDB-zQrmE,3336
-carconnectivity_connectors/seatcupra/connector.py,sha256=0M_gF9QiKQoiOUwRbFXcoOvVZCS4VrxT65W90l6KZV0,61402
-carconnectivity_connectors/seatcupra/vehicle.py,sha256=O6_JNTSwl82EZIix_DNf8eTj4A1rxPwTO1IeN3daAR8,3233
+carconnectivity_connectors/seatcupra/charging.py,sha256=BJe_5GEB0JkP78tpU6kyKpwuwjDZHvm-kt3PTlpQHeU,3336
+carconnectivity_connectors/seatcupra/climatization.py,sha256=0xxWlxrheAPzkVT8WRQtbm6ExZmVdgW7lUdOXyS_qWY,1695
+carconnectivity_connectors/seatcupra/command_impl.py,sha256=mtw8ZwJLmf79fPDZ1N3ImLfB8Gt9JPbzjMuIo2y5v3M,2879
+carconnectivity_connectors/seatcupra/connector.py,sha256=7H5ZszO-UjOeYVVrf9BsK_kbgLwBDvxS2n9V1gnrRN8,87659
+carconnectivity_connectors/seatcupra/vehicle.py,sha256=SxhF4Qh9ABeLyPFLg5AJyvgtYVDFUKfP5KkchsJeAYg,3390
 carconnectivity_connectors/seatcupra/auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 carconnectivity_connectors/seatcupra/auth/auth_util.py,sha256=Y81h8fGOMSMgPtE4wI_TI9WgE_s43uaPjRLBBINhj4g,4433
 carconnectivity_connectors/seatcupra/auth/my_cupra_session.py,sha256=iK5SlankZqaeneC3SNad8nHHcrP0tTmYxToI_9cqwlo,10744
@@ -12,8 +14,8 @@ carconnectivity_connectors/seatcupra/auth/session_manager.py,sha256=NizIuY-pvkVB
 carconnectivity_connectors/seatcupra/auth/vw_web_session.py,sha256=hgsCdXugVnSgvLta4hBNtoNgMhAA83paAYO2fUOOFyM,10657
 carconnectivity_connectors/seatcupra/auth/helpers/blacklist_retry.py,sha256=f3wsiY5bpHDBxp7Va1Mv9nKJ4u3qnCHZZmDu78_AhMk,1251
 carconnectivity_connectors/seatcupra/ui/connector_ui.py,sha256=SNYnlcGJpbWhuLiIHD2l6H9IfSiMz3IgmvXsdossDnE,1412
-carconnectivity_connector_seatcupra-0.1a2.dist-info/LICENSE,sha256=PIwI1alwDyOfvEQHdGCm2u9uf_mGE8030xZDfun0xTo,1071
-carconnectivity_connector_seatcupra-0.1a2.dist-info/METADATA,sha256=7gAeWjXp1y-KkPw1JemIM1ncGwsPNuYzaHpWP6WPsDc,5386
-carconnectivity_connector_seatcupra-0.1a2.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-carconnectivity_connector_seatcupra-0.1a2.dist-info/top_level.txt,sha256=KqA8GviZsDH4PtmnwSQsz0HB_w-TWkeEHLIRNo5dTaI,27
-carconnectivity_connector_seatcupra-0.1a2.dist-info/RECORD,,
+carconnectivity_connector_seatcupra-0.1a4.dist-info/LICENSE,sha256=PIwI1alwDyOfvEQHdGCm2u9uf_mGE8030xZDfun0xTo,1071
+carconnectivity_connector_seatcupra-0.1a4.dist-info/METADATA,sha256=9Te-Nyk84I3WBL-0wSRphOaPLCSQvBCaWGU4yTG-N9Q,5386
+carconnectivity_connector_seatcupra-0.1a4.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+carconnectivity_connector_seatcupra-0.1a4.dist-info/top_level.txt,sha256=KqA8GviZsDH4PtmnwSQsz0HB_w-TWkeEHLIRNo5dTaI,27
+carconnectivity_connector_seatcupra-0.1a4.dist-info/RECORD,,

carconnectivity_connectors/seatcupra/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.1a2'
+__version__ = version = '0.1a4'
 __version_tuple__ = version_tuple = (0, 1)

carconnectivity_connectors/seatcupra/charging.py

@@ -32,7 +32,7 @@ class SeatCupraCharging(Charging):  # pylint: disable=too-many-instance-attribut
         """
         OFF = 'off'
         READY_FOR_CHARGING = 'readyForCharging'
-        NOT_READY_FOR_CHARGING = 'NotReadyForCharging'
+        NOT_READY_FOR_CHARGING = 'notReadyForCharging'
         CONSERVATION = 'conservation'
         CHARGE_PURPOSE_REACHED_NOT_CONSERVATION_CHARGING = 'chargePurposeReachedAndNotConservationCharging'
         CHARGE_PURPOSE_REACHED_CONSERVATION = 'chargePurposeReachedAndConservation'

carconnectivity_connectors/seatcupra/climatization.py

@@ -0,0 +1,39 @@
+"""
+Module for charging for Seat/Cupra vehicles.
+"""
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+from carconnectivity.climatization import Climatization
+from carconnectivity.objects import GenericObject
+from carconnectivity.vehicle import GenericVehicle
+
+if TYPE_CHECKING:
+    from typing import Optional
+
+
+class SeatCupraClimatization(Climatization):  # pylint: disable=too-many-instance-attributes
+    """
+    SeatCupraClimatization class for handling Seat/Cupra vehicle climatization information.
+
+    This class extends the Climatization class and includes an enumeration of various
+    climatization states specific to Volkswagen vehicles.
+    """
+    def __init__(self, vehicle: GenericVehicle | None = None, origin: Optional[Climatization] = None) -> None:
+        if origin is not None:
+            super().__init__(vehicle=vehicle, origin=origin)
+            if not isinstance(self.settings, SeatCupraClimatization.Settings):
+                self.settings: Climatization.Settings = SeatCupraClimatization.Settings(parent=self, origin=origin.settings)
+        else:
+            super().__init__(vehicle=vehicle)
+            self.settings: Climatization.Settings = SeatCupraClimatization.Settings(parent=self, origin=self.settings)
+
+    class Settings(Climatization.Settings):
+        """
+        This class represents the settings for a skoda car climatiation.
+        """
+        def __init__(self, parent: Optional[GenericObject] = None, origin: Optional[Climatization.Settings] = None) -> None:
+            if origin is not None:
+                super().__init__(parent=parent, origin=origin)
+            else:
+                super().__init__(parent=parent)

carconnectivity_connectors/seatcupra/command_impl.py

@@ -0,0 +1,72 @@
+"""This module defines the classes that represent attributes in the CarConnectivity system."""
+from __future__ import annotations
+from typing import TYPE_CHECKING, Dict, Union
+
+from enum import Enum
+import argparse
+import logging
+
+from carconnectivity.commands import GenericCommand
+from carconnectivity.objects import GenericObject
+from carconnectivity.errors import SetterError
+from carconnectivity.util import ThrowingArgumentParser
+
+if TYPE_CHECKING:
+    from carconnectivity.objects import Optional
+
+LOG: logging.Logger = logging.getLogger("carconnectivity.connectors.seatcupra")
+
+
+class SpinCommand(GenericCommand):
+    """
+    SpinCommand is a command class for verifying the spin
+
+    """
+    def __init__(self, name: str = 'spin', parent: Optional[GenericObject] = None) -> None:
+        super().__init__(name=name, parent=parent)
+
+    @property
+    def value(self) -> Optional[Union[str, Dict]]:
+        return super().value
+
+    @value.setter
+    def value(self, new_value: Optional[Union[str, Dict]]) -> None:
+        if isinstance(new_value, str):
+            parser = ThrowingArgumentParser(prog='', add_help=False, exit_on_error=False)
+            parser.add_argument('command', help='Command to execute', type=SpinCommand.Command,
+                                choices=list(SpinCommand.Command))
+            parser.add_argument('--spin', dest='spin', help='Spin to be used instead of spin from config or .netrc', type=str, required=False,
+                                default=None)
+            try:
+                args = parser.parse_args(new_value.split(sep=' '))
+            except argparse.ArgumentError as e:
+                raise SetterError(f'Invalid format for SpinCommand: {e.message} {parser.format_usage()}') from e
+
+            newvalue_dict = {}
+            newvalue_dict['command'] = args.command
+            if args.spin is not None:
+                newvalue_dict['spin'] = args.spin
+            new_value = newvalue_dict
+        elif isinstance(new_value, dict):
+            if 'command' in new_value and isinstance(new_value['command'], str):
+                if new_value['command'] in SpinCommand.Command:
+                    new_value['command'] = SpinCommand.Command(new_value['command'])
+                else:
+                    raise ValueError('Invalid value for SpinCommand. '
+                                     f'Command must be one of {SpinCommand.Command}')
+        if self._is_changeable:
+            for hook in self._on_set_hooks:
+                new_value = hook(self, new_value)
+            self._set_value(new_value)
+        else:
+            raise TypeError('You cannot set this attribute. Attribute is not mutable.')
+
+    class Command(Enum):
+        """
+        Enum class representing different commands for SPIN.
+
+        """
+        VERIFY = 'verify'
+
+        def __str__(self) -> str:
+            return self.value

carconnectivity_connectors/seatcupra/connector.py

@@ -15,7 +15,7 @@ from carconnectivity.garage import Garage
 from carconnectivity.errors import AuthenticationError, TooManyRequestsError, RetrievalError, APIError, APICompatibilityError, \
     TemporaryAuthenticationError, SetterError, CommandError
 from carconnectivity.util import robust_time_parse, log_extra_keys, config_remove_credentials
-from carconnectivity.units import Length, Power, Speed
+from carconnectivity.units import Length, Current
 from carconnectivity.doors import Doors
 from carconnectivity.windows import Windows
 from carconnectivity.lights import Lights
@@ -27,6 +27,7 @@ from carconnectivity.command_impl import ClimatizationStartStopCommand, WakeSlee
 from carconnectivity.climatization import Climatization
 from carconnectivity.commands import Commands
 from carconnectivity.charging import Charging
+from carconnectivity.charging_connector import ChargingConnector
 from carconnectivity.position import Position
 
 from carconnectivity_connectors.base.connector import BaseConnector
@@ -36,6 +37,8 @@ from carconnectivity_connectors.seatcupra._version import __version__
 from carconnectivity_connectors.seatcupra.capability import Capability
 from carconnectivity_connectors.seatcupra.vehicle import SeatCupraVehicle, SeatCupraElectricVehicle, SeatCupraCombustionVehicle, SeatCupraHybridVehicle
 from carconnectivity_connectors.seatcupra.charging import SeatCupraCharging, mapping_seatcupra_charging_state
+from carconnectivity_connectors.seatcupra.climatization import SeatCupraClimatization
+from carconnectivity_connectors.seatcupra.command_impl import SpinCommand
 
 SUPPORT_IMAGES = False
 try:
@@ -222,6 +225,12 @@ class Connector(BaseConnector):
 
         This method calls the `fetch_vehicles` method to retrieve vehicle data.
         """
+        # Add spin command
+        if self.commands is not None and not self.commands.contains_command('spin'):
+            spin_command = SpinCommand(parent=self.commands)
+            spin_command._add_on_set_hook(self.__on_spin)  # pylint: disable=protected-access
+            spin_command.enabled = True
+            self.commands.add_command(spin_command)
         self.fetch_vehicles()
         self.car_connectivity.transaction_end()
 
@@ -339,10 +348,10 @@ class Connector(BaseConnector):
                                     else:
                                         raise APIError('Could not fetch capabilities, capability ID missing')
                                     log_extra_keys(LOG_API, 'capability', capability_dict,  {'id', 'expirationDate', 'editable', 'parameters'})
-                                    
+
                                 for capability_id in vehicle.capabilities.capabilities.keys() - found_capabilities:
                                     vehicle.capabilities.remove_capability(capability_id)
-                                
+
                                 if vehicle.capabilities.has_capability('charging'):
                                     if not isinstance(vehicle, SeatCupraElectricVehicle):
                                         LOG.debug('Promoting %s to SeatCupraElectricVehicle object for %s', vehicle.__class__.__name__, vin)
@@ -353,7 +362,7 @@ class Connector(BaseConnector):
                                         charging_start_stop_command._add_on_set_hook(self.__on_charging_start_stop)  # pylint: disable=protected-access
                                         charging_start_stop_command.enabled = True
                                         vehicle.charging.commands.add_command(charging_start_stop_command)
-                                
+
                                 if vehicle.capabilities.has_capability('climatisation'):
                                     if vehicle.climatization is not None and vehicle.climatization.commands is not None \
                                             and not vehicle.climatization.commands.contains_command('start-stop'):
@@ -363,8 +372,36 @@ class Connector(BaseConnector):
                                         climatisation_start_stop_command._add_on_set_hook(self.__on_air_conditioning_start_stop)
                                         climatisation_start_stop_command.enabled = True
                                         vehicle.climatization.commands.add_command(climatisation_start_stop_command)
-                            else:
-                                vehicle.capabilities.clear_capabilities()
+
+                                if vehicle.capabilities.has_capability('vehicleWakeUpTrigger'):
+                                    if vehicle.commands is not None and vehicle.commands.commands is not None \
+                                            and not vehicle.commands.contains_command('wake-sleep'):
+                                        wake_sleep_command = WakeSleepCommand(parent=vehicle.commands)
+                                        wake_sleep_command._add_on_set_hook(self.__on_wake_sleep)  # pylint: disable=protected-access
+                                        wake_sleep_command.enabled = True
+                                        vehicle.commands.add_command(wake_sleep_command)
+
+                                # Add honkAndFlash command if necessary capabilities are available
+                                if vehicle.capabilities.has_capability('honkAndFlash'):
+                                    if vehicle.commands is not None and vehicle.commands.commands is not None \
+                                            and not vehicle.commands.contains_command('honk-flash'):
+                                        honk_flash_command = HonkAndFlashCommand(parent=vehicle.commands, with_duration=True)
+                                        honk_flash_command._add_on_set_hook(self.__on_honk_flash)  # pylint: disable=protected-access
+                                        honk_flash_command.enabled = True
+                                        vehicle.commands.add_command(honk_flash_command)
+
+                                # Add lock and unlock command
+                                if vehicle.capabilities.has_capability('access'):
+                                    if vehicle.doors is not None and vehicle.doors.commands is not None and vehicle.doors.commands.commands is not None \
+                                            and not vehicle.doors.commands.contains_command('lock-unlock'):
+                                        lock_unlock_command = LockUnlockCommand(parent=vehicle.doors.commands)
+                                        lock_unlock_command._add_on_set_hook(self.__on_lock_unlock)  # pylint: disable=protected-access
+                                        lock_unlock_command.enabled = True
+                                        vehicle.doors.commands.add_command(lock_unlock_command)
+                                    else:
+                                        vehicle.capabilities.clear_capabilities()
+                        if isinstance(vehicle, SeatCupraVehicle):
+                            vehicle = self.fetch_image(vehicle)
                     else:
                         raise APIError('Could not fetch vehicle data, VIN missing')
         for vin in set(garage.list_vehicle_vins()) - seen_vehicle_vins:
@@ -386,7 +423,7 @@ class Connector(BaseConnector):
         vin = vehicle.vin.value
         if vin is None:
             raise APIError('VIN is missing')
-        
+
         url = f'https://ola.prod.code.seat.cloud.vwgroup.com/vehicles/{vin}/connection'
         vehicle_connection_data: Dict[str, Any] | None = self._fetch_data(url=url, session=self.session, no_cache=no_cache)
         if vehicle_connection_data is not None:
@@ -514,11 +551,10 @@ class Connector(BaseConnector):
         vin = vehicle.vin.value
         if vin is None:
             raise APIError('VIN is missing')
-        url = f'https://ola.prod.code.seat.cloud.vwgroup.com/v1/vehicles/{vin}/measurements/engines'
-        vehicle_status_data: Dict[str, Any] | None = self._fetch_data(url=url, session=self.session, no_cache=no_cache)
-        #measurements
-        #{'primary': {'fuelType': 'gasoline', 'rangeInKm': 120.0}, 'secondary': {'fuelType': 'electric', 'rangeInKm': 40.0}}
-        print(vehicle_status_data)
+        # url = f'https://ola.prod.code.seat.cloud.vwgroup.com/v1/vehicles/{vin}/measurements/engines'
+        # vehicle_status_data: Dict[str, Any] | None = self._fetch_data(url=url, session=self.session, no_cache=no_cache)
+        # measurements
+        # {'primary': {'fuelType': 'gasoline', 'rangeInKm': 120.0}, 'secondary': {'fuelType': 'electric', 'rangeInKm': 40.0}}
         url = f'https://ola.prod.code.seat.cloud.vwgroup.com/v5/users/{self.session.user_id}/vehicles/{vin}/mycar'
         vehicle_status_data: Dict[str, Any] | None = self._fetch_data(url=url, session=self.session, no_cache=no_cache)
         if vehicle_status_data:
@@ -590,23 +626,6 @@ class Connector(BaseConnector):
             if 'services' in vehicle_status_data and vehicle_status_data['services'] is not None:
                 if 'charging' in vehicle_status_data['services'] and vehicle_status_data['services']['charging'] is not None:
                     charging_status: Dict = vehicle_status_data['services']['charging']
-                    if 'status' in charging_status and charging_status['status'] is not None:
-                        if charging_status['status'] in SeatCupraCharging.SeatCupraChargingState:
-                            volkswagen_charging_state = SeatCupraCharging.SeatCupraChargingState(charging_status['status'])
-                            charging_state: Charging.ChargingState = mapping_seatcupra_charging_state[volkswagen_charging_state]
-                        else:
-                            LOG_API.info('Unkown charging state %s not in %s', charging_status['status'],
-                                         str(SeatCupraCharging.SeatCupraChargingState))
-                            charging_state = Charging.ChargingState.UNKNOWN
-                        if isinstance(vehicle, ElectricVehicle):
-                            vehicle.charging.state._set_value(value=charging_state)  # pylint: disable=protected-access
-                        else:
-                            LOG_API.warning('Vehicle is not an electric or hybrid vehicle, but charging state was fetched')
-                    else:
-                        if isinstance(vehicle, ElectricVehicle):
-                            vehicle.charging.state._set_value(None)  # pylint: disable=protected-access
-                        else:
-                            LOG_API.warning('Vehicle is not an electric or hybrid vehicle, but charging state was fetched')
                     if 'targetPct' in charging_status and charging_status['targetPct'] is not None:
                         if isinstance(vehicle, ElectricVehicle):
                             vehicle.charging.settings.target_level._set_value(charging_status['targetPct'])  # pylint: disable=protected-access
@@ -636,26 +655,7 @@ class Connector(BaseConnector):
                         vehicle.charging.enabled = False
                 if 'climatisation' in vehicle_status_data['services'] and vehicle_status_data['services']['climatisation'] is not None:
                     climatisation_status: Dict = vehicle_status_data['services']['climatisation']
-                    if 'status' in climatisation_status and climatisation_status['status'] is not None:
-                        if climatisation_status['status'].lower() in [item.value for item in Climatization.ClimatizationState]:
-                            climatization_state: Climatization.ClimatizationState = Climatization.ClimatizationState(climatisation_status['status'].lower())
-                        else:
-                            LOG_API.info('Unknown climatization state %s not in %s', climatisation_status['status'],
-                                         str(Climatization.ClimatizationState))
-                            climatization_state = Climatization.ClimatizationState.UNKNOWN
-                        vehicle.climatization.state._set_value(value=climatization_state)  # pylint: disable=protected-access
-                    else:
-                        vehicle.climatization.state._set_value(None)  # pylint: disable=protected-access
-                    if 'targetTemperatureCelsius' in climatisation_status and climatisation_status['targetTemperatureCelsius'] is not None:
-                        target_temperature: Optional[float] = climatisation_status['targetTemperatureCelsius']
-                        vehicle.climatization.settings.target_temperature._set_value(value=target_temperature,  # pylint: disable=protected-access
-                                                                                     unit=Temperature.C)
-                    elif 'targetTemperatureFahrenheit' in climatisation_status and climatisation_status['targetTemperatureFahrenheit'] is not None:
-                        target_temperature = climatisation_status['targetTemperatureFahrenheit']
-                        vehicle.climatization.settings.target_temperature._set_value(value=target_temperature,  # pylint: disable=protected-access
-                                                                                     unit=Temperature.F)
-                    else:
-                        vehicle.climatization.settings.target_temperature._set_value(None)  # pylint: disable=protected-access
+
                     if 'remainingTime' in climatisation_status and climatisation_status['remainingTime'] is not None:
                         remaining_duration: timedelta = timedelta(minutes=climatisation_status['remainingTime'])
                         estimated_date_reached: datetime = datetime.now(tz=timezone.utc) + remaining_duration
@@ -663,6 +663,7 @@ class Connector(BaseConnector):
                         vehicle.climatization.estimated_date_reached._set_value(value=estimated_date_reached)  # pylint: disable=protected-access
                     else:
                         vehicle.climatization.estimated_date_reached._set_value(None)  # pylint: disable=protected-access
+                    # we take status, targetTemperatureCelsius, targetTemperatureFahrenheit, from climatization request
                     log_extra_keys(LOG_API, 'climatisation', climatisation_status, {'status', 'targetTemperatureCelsius', 'targetTemperatureFahrenheit',
                                                                                     'remainingTime'})
         return vehicle
@@ -755,12 +756,68 @@ class Connector(BaseConnector):
             raise APIError('VIN is missing')
         url = f'https://ola.prod.code.seat.cloud.vwgroup.com/v1/vehicles/{vin}/climatisation/status'
         data: Dict[str, Any] | None = self._fetch_data(url=url, session=self.session, no_cache=no_cache)
-        #{'climatisationStatus': {'carCapturedTimestamp': '2025-02-18T17:24:02Z', 'climatisationState': 'off', 'climatisationTrigger': 'unsupported'}, 'windowHeatingStatus': {'carCapturedTimestamp': '2025-02-18T16:57:51Z', 'windowHeatingStatus': [{'windowLocation': 'front', 'windowHeatingState': 'off'}, {'windowLocation': 'rear', 'windowHeatingState': 'off'}]}}
-        print(data)
+        # {'climatisationStatus': {'carCapturedTimestamp': '2025-02-18T17:24:02Z', 'climatisationState': 'off', 'climatisationTrigger': 'unsupported'}, 'windowHeatingStatus': {'carCapturedTimestamp': '2025-02-18T16:57:51Z', 'windowHeatingStatus': [{'windowLocation': 'front', 'windowHeatingState': 'off'}, {'windowLocation': 'rear', 'windowHeatingState': 'off'}]}}
+        if data is not None:
+            if 'climatisationStatus' in data and data['climatisationStatus'] is not None:
+                climatisation_status: Dict = data['climatisationStatus']
+                if 'carCapturedTimestamp' not in climatisation_status or climatisation_status['carCapturedTimestamp'] is None:
+                    raise APIError('Could not fetch vehicle status, carCapturedTimestamp missing')
+                captured_at: datetime = robust_time_parse(climatisation_status['carCapturedTimestamp'])
+                if 'climatisationState' in climatisation_status and climatisation_status['climatisationState'] is not None:
+                    if climatisation_status['climatisationState'].lower() in [item.value for item in Climatization.ClimatizationState]:
+                        climatization_state: Climatization.ClimatizationState = \
+                            Climatization.ClimatizationState(climatisation_status['climatisationState'].lower())
+                    else:
+                        LOG_API.info('Unknown climatization state %s not in %s', climatisation_status['climatisationState'],
+                                     str(Climatization.ClimatizationState))
+                        climatization_state = Climatization.ClimatizationState.UNKNOWN
+                    vehicle.climatization.state._set_value(value=climatization_state, measured=captured_at)  # pylint: disable=protected-access
+                else:
+                    vehicle.climatization.state._set_value(None)  # pylint: disable=protected-access
+                log_extra_keys(LOG_API, 'climatisation', data, {'carCapturedTimestamp', 'climatisationState'})
+            else:
+                vehicle.climatization.state._set_value(None)  # pylint: disable=protected-access
+            log_extra_keys(LOG_API, 'climatisation', data, {'climatisationStatus'})
         url = f'https://ola.prod.code.seat.cloud.vwgroup.com/v2/vehicles/{vin}/climatisation/settings'
         data: Dict[str, Any] | None = self._fetch_data(url=url, session=self.session, no_cache=no_cache)
-        #{'carCapturedTimestamp': '2025-02-18T17:23:47Z', 'climatisationWithoutExternalPower': True, 'targetTemperatureInCelsius': 22.0, 'targetTemperatureInFahrenheit': 72.0}
-        print(data)
+        if data is not None:
+            if not isinstance(vehicle.climatization, SeatCupraClimatization):
+                vehicle.climatization = SeatCupraClimatization(vehicle=vehicle, origin=vehicle.climatization)
+            if 'carCapturedTimestamp' not in data or data['carCapturedTimestamp'] is None:
+                raise APIError('Could not fetch vehicle status, carCapturedTimestamp missing')
+            captured_at: datetime = robust_time_parse(data['carCapturedTimestamp'])
+            if 'targetTemperatureInCelsius' in data and data['targetTemperatureInCelsius'] is not None:
+                # pylint: disable-next=protected-access
+                vehicle.climatization.settings.target_temperature._add_on_set_hook(self.__on_air_conditioning_settings_change)
+                vehicle.climatization.settings.target_temperature._is_changeable = True  # pylint: disable=protected-access
+
+                target_temperature: Optional[float] = data['targetTemperatureInCelsius']
+                vehicle.climatization.settings.target_temperature._set_value(value=target_temperature,  # pylint: disable=protected-access
+                                                                             measured=captured_at,
+                                                                             unit=Temperature.C)
+            elif 'targetTemperatureInFahrenheit' in data and data['targetTemperatureInFahrenheit'] is not None:
+                # pylint: disable-next=protected-access
+                vehicle.climatization.settings.target_temperature._add_on_set_hook(self.__on_air_conditioning_settings_change)
+                vehicle.climatization.settings.target_temperature._is_changeable = True  # pylint: disable=protected-access
+
+                target_temperature = data['targetTemperatureInFahrenheit']
+                vehicle.climatization.settings.target_temperature._set_value(value=target_temperature,  # pylint: disable=protected-access
+                                                                             measured=captured_at,
+                                                                             unit=Temperature.F)
+            else:
+                vehicle.climatization.settings.target_temperature._set_value(None)  # pylint: disable=protected-access
+            if 'climatisationWithoutExternalPower' in data and data['climatisationWithoutExternalPower'] is not None:
+                # pylint: disable-next=protected-access
+                vehicle.climatization.settings.climatization_without_external_power._add_on_set_hook(self.__on_air_conditioning_settings_change)
+                vehicle.climatization.settings.climatization_without_external_power._is_changeable = True  # pylint: disable=protected-access
+
+                # pylint: disable-next=protected-access
+                vehicle.climatization.settings.climatization_without_external_power._set_value(data['climatisationWithoutExternalPower'],
+                                                                                               measured=captured_at)
+            else:
+                vehicle.climatization.settings.climatization_without_external_power._set_value(None)  # pylint: disable=protected-access
+            log_extra_keys(LOG_API, f'https://ola.prod.code.seat.cloud.vwgroup.com/v2/vehicles/{vin}/climatisation/settings', data,
+                           {'carCapturedTimestamp', 'targetTemperatureInCelsius', 'targetTemperatureInFahrenheit', 'climatisationWithoutExternalPower'})
         return vehicle
 
     def fetch_charging(self, vehicle: SeatCupraVehicle, no_cache: bool = False) -> SeatCupraVehicle:
@@ -780,18 +837,147 @@ class Connector(BaseConnector):
         vin = vehicle.vin.value
         if vin is None:
             raise APIError('VIN is missing')
-        url = f'https://ola.prod.code.seat.cloud.vwgroup.com/v1/vehicles/{vin}/charging/status'
-        data: Dict[str, Any] | None = self._fetch_data(url=url, session=self.session, no_cache=no_cache)
-        #{'state': 'off', 'battery': {'currentSocPercentage': 86, 'estimatedRangeInKm': 40}, 'charging': {'state': 'notReadyForCharging', 'type': 'off', 'mode': 'invalid'}, 'plug': {'connection': 'disconnected', 'externalPower': 'unavailable', 'lock': 'unlocked'}}
-        print(data)
-        url = f'https://ola.prod.code.seat.cloud.vwgroup.com/v1/vehicles/{vin}/charging/info'
-        data: Dict[str, Any] | None = self._fetch_data(url=url, session=self.session, no_cache=no_cache)
-        #{'settings': {'maxChargeCurrentAc': 'reduced', 'targetSoc': 100}, 'chargingCareSettings': {}, 'chargingCareStatus': {'batteryCareTargetSoc': 80}}
-        print(data)
-        url = f'https://ola.prod.code.seat.cloud.vwgroup.com/v1/vehicles/{vin}/charging/settings'
-        data: Dict[str, Any] | None = self._fetch_data(url=url, session=self.session, no_cache=no_cache)
-        #{'maxChargeCurrentAc': False, 'defaultMaxTargetSocPercentage': 100}
-        print(data)
+        if isinstance(vehicle, ElectricVehicle):
+            url = f'https://ola.prod.code.seat.cloud.vwgroup.com/v1/vehicles/{vin}/charging/status'
+            data: Dict[str, Any] | None = self._fetch_data(url=url, session=self.session, no_cache=no_cache)
+
+            if data is not None:
+                if 'charging' in data and data['charging'] is not None:
+                    if 'state' in data['charging'] and data['charging']['state'] is not None:
+                        if data['charging']['state'] in SeatCupraCharging.SeatCupraChargingState:
+                            volkswagen_charging_state = SeatCupraCharging.SeatCupraChargingState(data['charging']['state'])
+                            charging_state: Charging.ChargingState = mapping_seatcupra_charging_state[volkswagen_charging_state]
+                        else:
+                            LOG_API.info('Unkown charging state %s not in %s', data['charging']['state'],
+                                        str(SeatCupraCharging.SeatCupraChargingState))
+                            charging_state = Charging.ChargingState.UNKNOWN
+                        vehicle.charging.state._set_value(value=charging_state)  # pylint: disable=protected-access
+                    else:
+                        vehicle.charging.state._set_value(None)  # pylint: disable=protected-access
+                    log_extra_keys(LOG_API, 'charging',  data['charging'], {'state'})
+                if 'plug' in data and data['plug'] is not None:
+                    if 'connection' in data['plug'] and data['plug']['connection'] is not None:
+                        if data['plug']['connection'] in [item.value for item in ChargingConnector.ChargingConnectorConnectionState]:
+                            plug_state: ChargingConnector.ChargingConnectorConnectionState = \
+                                ChargingConnector.ChargingConnectorConnectionState(data['plug']['connection'])
+                        else:
+                            LOG_API.info('Unknown plug state %s', data['plug']['connection'])
+                            plug_state = ChargingConnector.ChargingConnectorConnectionState.UNKNOWN
+                        vehicle.charging.connector.connection_state._set_value(value=plug_state)  # pylint: disable=protected-access
+                    else:
+                        vehicle.charging.connector.connection_state._set_value(value=None)  # pylint: disable=protected-access
+                    if 'externalPower' in data['plug'] and data['plug']['externalPower'] is not None:
+                        if data['plug']['externalPower'] in [item.value for item in ChargingConnector.ExternalPower]:
+                            plug_power_state: ChargingConnector.ExternalPower = \
+                                ChargingConnector.ExternalPower(data['plug']['externalPower'])
+                        else:
+                            LOG_API.info('Unknown plug power state %s', data['plug']['externalPower'])
+                            plug_power_state = ChargingConnector.ExternalPower.UNKNOWN
+                        vehicle.charging.connector.external_power._set_value(value=plug_power_state)  # pylint: disable=protected-access
+                    else:
+                        vehicle.charging.connector.external_power._set_value(None)  # pylint: disable=protected-access
+                    if 'lock' in data['plug'] and data['plug']['lock'] is not None:
+                        if data['plug']['lock'] in [item.value for item in ChargingConnector.ChargingConnectorLockState]:
+                            plug_lock_state: ChargingConnector.ChargingConnectorLockState = \
+                                ChargingConnector.ChargingConnectorLockState(data['plug']['lock'])
+                        else:
+                            LOG_API.info('Unknown plug lock state %s', data['plug']['lock'])
+                            plug_lock_state = ChargingConnector.ChargingConnectorLockState.UNKNOWN
+                        vehicle.charging.connector.lock_state._set_value(value=plug_lock_state)  # pylint: disable=protected-access
+                    else:
+                        vehicle.charging.connector.lock_state._set_value(None)  # pylint: disable=protected-access
+                    log_extra_keys(LOG_API, 'plug', data['plug'], {'connection', 'externalPower', 'lock'})
+                log_extra_keys(LOG_API, f'https://ola.prod.code.seat.cloud.vwgroup.com/v1/vehicles/{vin}/charging/status', data,
+                               {'state', 'battery', 'charging', 'plug'})
+
+            url = f'https://ola.prod.code.seat.cloud.vwgroup.com/v1/vehicles/{vin}/charging/settings'
+            data: Dict[str, Any] | None = self._fetch_data(url=url, session=self.session, no_cache=no_cache)
+            if data is not None:
+                if 'maxChargeCurrentAc' in data and data['maxChargeCurrentAc'] is not None:
+                    if data['maxChargeCurrentAc']:
+                        vehicle.charging.settings.maximum_current._set_value(value=16,  # pylint: disable=protected-access
+                                                                             unit=Current.A)
+                    else:
+                        vehicle.charging.settings.maximum_current._set_value(value=6,  # pylint: disable=protected-access
+                                                                             unit=Current.A)
+                else:
+                    vehicle.charging.settings.maximum_current._set_value(None)  # pylint: disable=protected-access
+                if 'defaultMaxTargetSocPercentage' in data and data['defaultMaxTargetSocPercentage'] is not None:
+                    vehicle.charging.settings.target_level._set_value(data['defaultMaxTargetSocPercentage'])  # pylint: disable=protected-access
+                else:
+                    vehicle.charging.settings.target_level._set_value(None)  # pylint: disable=protected-access
+        return vehicle
+
+    def fetch_image(self, vehicle: SeatCupraVehicle, no_cache: bool = False) -> SeatCupraVehicle:
+        """
+        Fetches the image of a given SeatCupraVehicle.
+
+        This method retrieves the image of the vehicle from a remote server. It supports caching to avoid redundant downloads.
+        If caching is enabled and the image is found in the cache and is not expired, it will be loaded from the cache.
+        Otherwise, it will be downloaded from the server.
+
+        Args:
+            vehicle (SeatCupraVehicle): The vehicle object for which the image is to be fetched.
+            no_cache (bool, optional): If True, bypasses the cache and fetches the image directly from the server. Defaults to False.
+
+        Returns:
+            SeatCupraVehicle: The vehicle object with the fetched image added to its attributes.
+
+        Raises:
+            RetrievalError: If there is a connection error, chunked encoding error, read timeout, or retry error during the image retrieval process.
+        """
+        if SUPPORT_IMAGES:
+            url: str = f'https://ola.prod.code.seat.cloud.vwgroup.com/v1/vehicles/{vehicle.vin.value}/renders'
+            data = self._fetch_data(url, session=self.session, allow_http_error=True, no_cache=no_cache)
+            if data is not None:  # pylint: disable=too-many-nested-blocks
+                for image_id, image_url in data.items():
+                    if image_id == 'isDefault':
+                        continue
+                    img = None
+                    cache_date = None
+                    if self.active_config['max_age'] is not None and self.session.cache is not None and image_url in self.session.cache:
+                        img, cache_date_string = self.session.cache[image_url]
+                        img = base64.b64decode(img)  # pyright: ignore[reportPossiblyUnboundVariable]
+                        img = Image.open(io.BytesIO(img))  # pyright: ignore[reportPossiblyUnboundVariable]
+                        cache_date = datetime.fromisoformat(cache_date_string)
+                    if img is None or self.active_config['max_age'] is None \
+                            or (cache_date is not None and cache_date < (datetime.utcnow() - timedelta(seconds=self.active_config['max_age']))):
+                        try:
+                            image_download_response = requests.get(image_url, stream=True, timeout=180)
+                            if image_download_response.status_code == requests.codes['ok']:
+                                img = Image.open(image_download_response.raw)  # pyright: ignore[reportPossiblyUnboundVariable]
+                                if self.session.cache is not None:
+                                    buffered = io.BytesIO()  # pyright: ignore[reportPossiblyUnboundVariable]
+                                    img.save(buffered, format="PNG")
+                                    img_str = base64.b64encode(buffered.getvalue()).decode("utf-8")  # pyright: ignore[reportPossiblyUnboundVariable]
+                                    self.session.cache[image_url] = (img_str, str(datetime.utcnow()))
+                            elif image_download_response.status_code == requests.codes['unauthorized']:
+                                LOG.info('Server asks for new authorization')
+                                self.session.login()
+                                image_download_response = self.session.get(image_url, stream=True)
+                                if image_download_response.status_code == requests.codes['ok']:
+                                    img = Image.open(image_download_response.raw)  # pyright: ignore[reportPossiblyUnboundVariable]
+                                    if self.session.cache is not None:
+                                        buffered = io.BytesIO()  # pyright: ignore[reportPossiblyUnboundVariable]
+                                        img.save(buffered, format="PNG")
+                                        img_str = base64.b64encode(buffered.getvalue()).decode("utf-8")  # pyright: ignore[reportPossiblyUnboundVariable]
+                                        self.session.cache[image_url] = (img_str, str(datetime.utcnow()))
+                        except requests.exceptions.ConnectionError as connection_error:
+                            raise RetrievalError(f'Connection error: {connection_error}') from connection_error
+                        except requests.exceptions.ChunkedEncodingError as chunked_encoding_error:
+                            raise RetrievalError(f'Error: {chunked_encoding_error}') from chunked_encoding_error
+                        except requests.exceptions.ReadTimeout as timeout_error:
+                            raise RetrievalError(f'Timeout during read: {timeout_error}') from timeout_error
+                        except requests.exceptions.RetryError as retry_error:
+                            raise RetrievalError(f'Retrying failed: {retry_error}') from retry_error
+                    if img is not None:
+                        vehicle._car_images[image_id] = img  # pylint: disable=protected-access
+                        if image_id == 'side':
+                            if 'car_picture' in vehicle.images.images:
+                                vehicle.images.images['car_picture']._set_value(img)  # pylint: disable=protected-access
+                            else:
+                                vehicle.images.images['car_picture'] = ImageAttribute(name="car_picture", parent=vehicle.images,
+                                                                                      value=img, tags={'carconnectivity'})
         return vehicle
 
     def _record_elapsed(self, elapsed: timedelta) -> None:
@@ -907,6 +1093,168 @@ class Connector(BaseConnector):
             raise CommandError(f'Could not start/stop air conditioning ({command_response.status_code}: {command_response.text})')
         return command_arguments
 
+    def __on_spin(self, spin_command: SpinCommand, command_arguments: Union[str, Dict[str, Any]]) \
+            -> Union[str, Dict[str, Any]]:
+        del spin_command
+        if not isinstance(command_arguments, dict):
+            raise CommandError('Command arguments are not a dictionary')
+        if 'command' not in command_arguments:
+            raise CommandError('Command argument missing')
+        command_dict = {}
+        if self.active_config['spin'] is None:
+            raise CommandError('S-PIN is missing, please add S-PIN to your configuration or .netrc file')
+        if 'spin' in command_arguments:
+            command_dict['currentSpin'] = command_arguments['spin']
+        else:
+            if self.active_config['spin'] is None or self.active_config['spin'] == '':
+                raise CommandError('S-PIN is missing, please add S-PIN to your configuration or .netrc file')
+            command_dict['spin'] = self.active_config['spin']
+        if command_arguments['command'] == SpinCommand.Command.VERIFY:
+            url = f'https://ola.prod.code.seat.cloud.vwgroup.com/v2/users/{self.session.user_id}/spin/verify'
+        else:
+            raise CommandError(f'Unknown command {command_arguments["command"]}')
+        command_response: requests.Response = self.session.post(url, data=json.dumps(command_dict), allow_redirects=True)
+        if command_response.status_code != requests.codes['ok']:
+            LOG.error('Could not execute spin command (%s: %s)', command_response.status_code, command_response.text)
+            raise CommandError(f'Could not execute spin command ({command_response.status_code}: {command_response.text})')
+        else:
+            LOG.info('Spin verify command executed successfully')
+        return command_arguments
+
+    def __on_wake_sleep(self, wake_sleep_command: WakeSleepCommand, command_arguments: Union[str, Dict[str, Any]]) \
+            -> Union[str, Dict[str, Any]]:
+        if wake_sleep_command.parent is None or wake_sleep_command.parent.parent is None \
+                or not isinstance(wake_sleep_command.parent.parent, GenericVehicle):
+            raise CommandError('Object hierarchy is not as expected')
+        if not isinstance(command_arguments, dict):
+            raise CommandError('Command arguments are not a dictionary')
+        vehicle: GenericVehicle = wake_sleep_command.parent.parent
+        vin: Optional[str] = vehicle.vin.value
+        if vin is None:
+            raise CommandError('VIN in object hierarchy missing')
+        if 'command' not in command_arguments:
+            raise CommandError('Command argument missing')
+        if command_arguments['command'] == WakeSleepCommand.Command.WAKE:
+            url = f'https://ola.prod.code.seat.cloud.vwgroup.com/v1/vehicles/{vin}/vehicle-wakeup/request'
+
+            command_response: requests.Response = self.session.post(url, data='{}', allow_redirects=True)
+            if command_response.status_code not in (requests.codes['ok'], requests.codes['no_content']):
+                LOG.error('Could not execute wake command (%s: %s)', command_response.status_code, command_response.text)
+                raise CommandError(f'Could not execute wake command ({command_response.status_code}: {command_response.text})')
+        elif command_arguments['command'] == WakeSleepCommand.Command.SLEEP:
+            raise CommandError('Sleep command not supported by vehicle. Vehicle will put itself to sleep')
+        else:
+            raise CommandError(f'Unknown command {command_arguments["command"]}')
+        return command_arguments
+
+    def __on_honk_flash(self, honk_flash_command: HonkAndFlashCommand, command_arguments: Union[str, Dict[str, Any]]) \
+            -> Union[str, Dict[str, Any]]:
+        if honk_flash_command.parent is None or honk_flash_command.parent.parent is None \
+                or not isinstance(honk_flash_command.parent.parent, GenericVehicle):
+            raise CommandError('Object hierarchy is not as expected')
+        if not isinstance(command_arguments, dict):
+            raise CommandError('Command arguments are not a dictionary')
+        vehicle: GenericVehicle = honk_flash_command.parent.parent
+        vin: Optional[str] = vehicle.vin.value
+        if vin is None:
+            raise CommandError('VIN in object hierarchy missing')
+        if 'command' not in command_arguments:
+            raise CommandError('Command argument missing')
+        command_dict = {}
+        if command_arguments['command'] in [HonkAndFlashCommand.Command.FLASH, HonkAndFlashCommand.Command.HONK_AND_FLASH]:
+            if 'duration' in command_arguments:
+                command_dict['durationInSeconds'] = command_arguments['duration']
+            else:
+                command_dict['durationInSeconds'] = 10
+            command_dict['mode'] = command_arguments['command'].value
+            command_dict['userPosition'] = {}
+            if vehicle.position is None or vehicle.position.latitude is None or vehicle.position.longitude is None \
+                    or vehicle.position.latitude.value is None or vehicle.position.longitude.value is None \
+                    or not vehicle.position.latitude.enabled or not vehicle.position.longitude.enabled:
+                raise CommandError('Can only execute honk and flash commands if vehicle position is known')
+            command_dict['userPosition']['latitude'] = vehicle.position.latitude.value
+            command_dict['userPosition']['longitude'] = vehicle.position.longitude.value
+
+            url = f'https://ola.prod.code.seat.cloud.vwgroup.com/v1/vehicles/{vin}/honk-and-flash'
+            command_response: requests.Response = self.session.post(url, data=json.dumps(command_dict), allow_redirects=True)
+            if command_response.status_code not in (requests.codes['ok'], requests.codes['no_content']):
+                LOG.error('Could not execute honk or flash command (%s: %s)', command_response.status_code, command_response.text)
+                raise CommandError(f'Could not execute honk or flash command ({command_response.status_code}: {command_response.text})')
+        else:
+            raise CommandError(f'Unknown command {command_arguments["command"]}')
+        return command_arguments
+
+    def __on_lock_unlock(self, lock_unlock_command: LockUnlockCommand, command_arguments: Union[str, Dict[str, Any]]) \
+            -> Union[str, Dict[str, Any]]:
+        if lock_unlock_command.parent is None or lock_unlock_command.parent.parent is None \
+                or lock_unlock_command.parent.parent.parent is None or not isinstance(lock_unlock_command.parent.parent.parent, GenericVehicle):
+            raise CommandError('Object hierarchy is not as expected')
+        if not isinstance(command_arguments, dict):
+            raise SetterError('Command arguments are not a dictionary')
+        vehicle: GenericVehicle = lock_unlock_command.parent.parent.parent
+        vin: Optional[str] = vehicle.vin.value
+        if vin is None:
+            raise CommandError('VIN in object hierarchy missing')
+        if 'command' not in command_arguments:
+            raise CommandError('Command argument missing')
+        command_dict = {}
+        if 'spin' in command_arguments:
+            command_dict['spin'] = command_arguments['spin']
+        else:
+            if self.active_config['spin'] is None:
+                raise CommandError('S-PIN is missing, please add S-PIN to your configuration or .netrc file')
+            command_dict['spin'] = self.active_config['spin']
+        if command_arguments['command'] == LockUnlockCommand.Command.LOCK:
+            url = f'https://ola.prod.code.seat.cloud.vwgroup.com/v1/vehicles/{vin}/access/lock'
+        elif command_arguments['command'] == LockUnlockCommand.Command.UNLOCK:
+            url = f'https://ola.prod.code.seat.cloud.vwgroup.com/v1/vehicles/{vin}/access/unlock'
+        else:
+            raise CommandError(f'Unknown command {command_arguments["command"]}')
+        command_response: requests.Response = self.session.post(url, data=json.dumps(command_dict), allow_redirects=True)
+        if command_response.status_code != requests.codes['ok']:
+            LOG.error('Could not execute locking command (%s: %s)', command_response.status_code, command_response.text)
+            raise CommandError(f'Could not execute locking command ({command_response.status_code}: {command_response.text})')
+        return command_arguments
+
+    def __on_air_conditioning_settings_change(self, attribute: GenericAttribute, value: Any) -> Any:
+        """
+        Callback for the climatization setting change.
+        """
+        if attribute.parent is None or not isinstance(attribute.parent, SeatCupraClimatization.Settings) \
+                or attribute.parent.parent is None \
+                or attribute.parent.parent.parent is None or not isinstance(attribute.parent.parent.parent, SeatCupraVehicle):
+            raise SetterError('Object hierarchy is not as expected')
+        settings: SeatCupraClimatization.Settings = attribute.parent
+        vehicle: SeatCupraVehicle = attribute.parent.parent.parent
+        vin: Optional[str] = vehicle.vin.value
+        if vin is None:
+            raise SetterError('VIN in object hierarchy missing')
+        setting_dict = {}
+        if settings.target_temperature.enabled and settings.target_temperature.value is not None:
+            # Round target temperature to nearest 0.5
+            # Check if the attribute changed is the target_temperature attribute
+            if isinstance(attribute, TemperatureAttribute) and attribute.id == 'target_temperature':
+                setting_dict['targetTemperature'] = round(value * 2) / 2
+            else:
+                setting_dict['targetTemperature'] = round(settings.target_temperature.value * 2) / 2
+            if settings.target_temperature.unit == Temperature.C:
+                setting_dict['targetTemperatureUnit'] = 'celsius'
+            elif settings.target_temperature.unit == Temperature.F:
+                setting_dict['targetTemperatureUnit'] = 'farenheit'
+            else:
+                setting_dict['targetTemperatureUnit'] = 'celsius'
+        if isinstance(attribute, BooleanAttribute) and attribute.id == 'climatisation_without_external_power':
+            setting_dict['climatisationWithoutExternalPower'] = value
+        elif settings.climatization_without_external_power.enabled and settings.climatization_without_external_power.value is not None:
+            setting_dict['climatisationWithoutExternalPower'] = settings.climatization_without_external_power.value
+
+        url: str = f'https://ola.prod.code.seat.cloud.vwgroup.com/v2/vehicles/{vin}/climatisation/settings'
+        settings_response: requests.Response = self.session.post(url, data=json.dumps(setting_dict), allow_redirects=True)
+        if settings_response.status_code not in [requests.codes['ok'], requests.codes['created']]:
+            LOG.error('Could not set climatization settings (%s) %s', settings_response.status_code, settings_response.text)
+            raise SetterError(f'Could not set value ({settings_response.status_code}): {settings_response.text}')
+        return value
+
     def get_version(self) -> str:
         return __version__
 

carconnectivity_connectors/seatcupra/vehicle.py

@@ -5,6 +5,7 @@ from typing import TYPE_CHECKING
 from carconnectivity.vehicle import GenericVehicle, ElectricVehicle, CombustionVehicle, HybridVehicle
 
 from carconnectivity_connectors.seatcupra.capability import Capabilities
+from carconnectivity_connectors.seatcupra.climatization import SeatCupraClimatization
 
 SUPPORT_IMAGES = False
 try:
@@ -38,14 +39,15 @@ class SeatCupraVehicle(GenericVehicle):  # pylint: disable=too-many-instance-att
             self.capabilities.parent = self
             if SUPPORT_IMAGES:
                 self._car_images = origin._car_images
-            
         else:
             super().__init__(vin=vin, garage=garage, managing_connector=managing_connector)
+            self.climatization = SeatCupraClimatization(origin=self.climatization)
             self.capabilities: Capabilities = Capabilities(vehicle=self)
             if SUPPORT_IMAGES:
                 self._car_images: Dict[str, Image.Image] = {}
 
 
+
 class SeatCupraElectricVehicle(ElectricVehicle, SeatCupraVehicle):
     """
     Represents a Seat/Cupra electric vehicle.