carconnectivity-connector-seatcupra 0.1.2a1__py3-none-any.whl → 0.2__py3-none-any.whl

{carconnectivity_connector_seatcupra-0.1.2a1.dist-info → carconnectivity_connector_seatcupra-0.2.dist-info}/METADATA

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

{carconnectivity_connector_seatcupra-0.1.2a1.dist-info → carconnectivity_connector_seatcupra-0.2.dist-info}/RECORD

@@ -1,21 +1,21 @@
+carconnectivity_connector_seatcupra-0.2.dist-info/licenses/LICENSE,sha256=PIwI1alwDyOfvEQHdGCm2u9uf_mGE8030xZDfun0xTo,1071
 carconnectivity_connectors/seatcupra/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-carconnectivity_connectors/seatcupra/_version.py,sha256=VzTjVbsUC2B6Y5R_ncX3UCI-1y_cf0-27tYAHy1JsEY,513
+carconnectivity_connectors/seatcupra/_version.py,sha256=3yop_Zw31tLW5V7T20Ar9d_ywZdoSjaF0mFPUD-T2xY,506
 carconnectivity_connectors/seatcupra/capability.py,sha256=936V06hOX8AuAMxL_S9wVyVa36Xw1bo9081X0xf5f94,5064
-carconnectivity_connectors/seatcupra/charging.py,sha256=BJe_5GEB0JkP78tpU6kyKpwuwjDZHvm-kt3PTlpQHeU,3336
+carconnectivity_connectors/seatcupra/charging.py,sha256=mayvseay5x2r2qjWqol0ijlgoBL2L2A0A96T44FOiHg,4076
 carconnectivity_connectors/seatcupra/climatization.py,sha256=0xxWlxrheAPzkVT8WRQtbm6ExZmVdgW7lUdOXyS_qWY,1695
 carconnectivity_connectors/seatcupra/command_impl.py,sha256=LmBOCWGZPfJCG_4-5449xvO6NAvnPDsAWEBKlsG4WoI,3051
-carconnectivity_connectors/seatcupra/connector.py,sha256=llxFhVdpnL5MxmHbOej1wMio5tareY3zha0qaFhnPgs,107680
-carconnectivity_connectors/seatcupra/vehicle.py,sha256=s0G-HqG5qcwStDxD3649KgLMa3lKPZ4TOGWRJEuQzsQ,3403
+carconnectivity_connectors/seatcupra/connector.py,sha256=_8Lvg1yqHHbH4mkhThwq0KZZL64rzKoFYurQCQurqY4,130482
+carconnectivity_connectors/seatcupra/vehicle.py,sha256=LHkAlVD_C8xOX81wCGFZbZqyhctpKx-CN0T3NZJ2jFk,3946
 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=SXO_77diYSmHN3KNSccDASk95Ko8uK5WWKSjIJNHrUA,13558
+carconnectivity_connectors/seatcupra/auth/my_cupra_session.py,sha256=VF_9U8fESLkndVaPn2W1ZxZwNr9-ndeaegeTVT5FyYk,13904
 carconnectivity_connectors/seatcupra/auth/openid_session.py,sha256=pGdTSt2zMtPWD4EY8MoZTj8lT6_krfa1Xt3Fyh877FA,16972
 carconnectivity_connectors/seatcupra/auth/session_manager.py,sha256=ZIDvC848T3fy6PgGqCl8A2SzaNhu2YG19Xam5kgp7SA,5635
 carconnectivity_connectors/seatcupra/auth/vw_web_session.py,sha256=CcI6m68IyRs6WsMDu-IsW3Dj85vyGiMmxvFqNETMHO0,10929
 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.1.2a1.dist-info/LICENSE,sha256=PIwI1alwDyOfvEQHdGCm2u9uf_mGE8030xZDfun0xTo,1071
-carconnectivity_connector_seatcupra-0.1.2a1.dist-info/METADATA,sha256=ii6XPx0SHu1N2SEXwPeDC-Pei__53Le9BlV08yKzRUw,5473
-carconnectivity_connector_seatcupra-0.1.2a1.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
-carconnectivity_connector_seatcupra-0.1.2a1.dist-info/top_level.txt,sha256=KqA8GviZsDH4PtmnwSQsz0HB_w-TWkeEHLIRNo5dTaI,27
-carconnectivity_connector_seatcupra-0.1.2a1.dist-info/RECORD,,
+carconnectivity_connector_seatcupra-0.2.dist-info/METADATA,sha256=3RrvEwAnY_qIK95IUNMpVuc42qYt9LU9aZ-At4Qvf-g,5491
+carconnectivity_connector_seatcupra-0.2.dist-info/WHEEL,sha256=1tXe9gY0PYatrMPMDd6jXqjfpz_B-Wqm32CPfRC58XU,91
+carconnectivity_connector_seatcupra-0.2.dist-info/top_level.txt,sha256=KqA8GviZsDH4PtmnwSQsz0HB_w-TWkeEHLIRNo5dTaI,27
+carconnectivity_connector_seatcupra-0.2.dist-info/RECORD,,

{carconnectivity_connector_seatcupra-0.1.2a1.dist-info → carconnectivity_connector_seatcupra-0.2.dist-info}/WHEEL

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

carconnectivity_connectors/seatcupra/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.1.2a1'
-__version_tuple__ = version_tuple = (0, 1, 2)
+__version__ = version = '0.2'
+__version_tuple__ = version_tuple = (0, 2)

carconnectivity_connectors/seatcupra/auth/my_cupra_session.py

@@ -46,6 +46,7 @@ class MyCupraSession(VWWebSession):
 
             self.headers = CaseInsensitiveDict({
                 'accept': '*/*',
+                'connection': 'keep-alive',
                 'content-type': 'application/json',
                 'user-agent': 'SEATApp/2.5.0 (com.seat.myseat.ola; build:202410171614; iOS 15.8.3) Alamofire/5.7.0 Mobile',
                 'accept-language': 'de-de',
@@ -62,6 +63,7 @@ class MyCupraSession(VWWebSession):
 
             self.headers = CaseInsensitiveDict({
                 'accept': '*/*',
+                'connection': 'keep-alive',
                 'content-type': 'application/json',
                 'user-agent': 'CUPRAApp%20-%20Store/20220503 CFNetwork/1333.0.4 Darwin/21.5.0',
                 'accept-language': 'de-de',
@@ -220,12 +222,19 @@ class MyCupraSession(VWWebSession):
         if headers is None:
             headers = dict(self.headers)
 
-        body: Dict[str, str] = {
-            'client_id': self.client_id,
-            'client_secret': 'eb8814e641c81a2640ad62eeccec11c98effc9bccd4269ab7af338b50a94b3a2',
-            'grant_type': 'refresh_token',
-            'refresh_token': self.refresh_token
-        }
+        if self.is_seat:
+            body: Dict[str, str] = {
+                'client_id': self.client_id,
+                'grant_type': 'refresh_token',
+                'refresh_token': self.refresh_token
+            }
+        else:
+            body: Dict[str, str] = {
+                'client_id': self.client_id,
+                'client_secret': 'eb8814e641c81a2640ad62eeccec11c98effc9bccd4269ab7af338b50a94b3a2',
+                'grant_type': 'refresh_token',
+                'refresh_token': self.refresh_token
+            }
 
         headers['content-type'] = 'application/x-www-form-urlencoded; charset=utf-8'
 

carconnectivity_connectors/seatcupra/charging.py

@@ -12,6 +12,8 @@ from carconnectivity.vehicle import ElectricVehicle
 if TYPE_CHECKING:
     from typing import Optional, Dict
 
+    from carconnectivity.objects import GenericObject
+
 
 class SeatCupraCharging(Charging):  # pylint: disable=too-many-instance-attributes
     """
@@ -22,9 +24,22 @@ class SeatCupraCharging(Charging):  # pylint: disable=too-many-instance-attribut
     """
     def __init__(self, vehicle: ElectricVehicle | None = None, origin: Optional[Charging] = None) -> None:
         if origin is not None:
-            super().__init__(origin=origin)
+            super().__init__(vehicle=vehicle, origin=origin)
+            self.settings = SeatCupraCharging.Settings(parent=self, origin=origin.settings)
         else:
             super().__init__(vehicle=vehicle)
+            self.settings = SeatCupraCharging.Settings(parent=self, origin=self.settings)
+
+    class Settings(Charging.Settings):
+        """
+        This class represents the settings for car volkswagen car charging.
+        """
+        def __init__(self, parent: Optional[GenericObject] = None, origin: Optional[Charging.Settings] = None) -> None:
+            if origin is not None:
+                super().__init__(parent=parent, origin=origin)
+            else:
+                super().__init__(parent=parent)
+            self.max_current_in_ampere: Optional[bool] = None
 
     class SeatCupraChargingState(Enum,):
         """

carconnectivity_connectors/seatcupra/connector.py

@@ -20,17 +20,20 @@ from carconnectivity.units import Length, Current
 from carconnectivity.doors import Doors
 from carconnectivity.windows import Windows
 from carconnectivity.lights import Lights
-from carconnectivity.drive import GenericDrive, ElectricDrive, CombustionDrive
+from carconnectivity.drive import GenericDrive, ElectricDrive, CombustionDrive, DieselDrive
 from carconnectivity.vehicle import GenericVehicle, ElectricVehicle
-from carconnectivity.attributes import BooleanAttribute, DurationAttribute, GenericAttribute, TemperatureAttribute, EnumAttribute
+from carconnectivity.attributes import BooleanAttribute, DurationAttribute, GenericAttribute, TemperatureAttribute, EnumAttribute, CurrentAttribute, \
+    LevelAttribute
 from carconnectivity.units import Temperature
-from carconnectivity.command_impl import ClimatizationStartStopCommand, WakeSleepCommand, HonkAndFlashCommand, LockUnlockCommand, ChargingStartStopCommand
+from carconnectivity.command_impl import ClimatizationStartStopCommand, WakeSleepCommand, HonkAndFlashCommand, LockUnlockCommand, ChargingStartStopCommand, \
+    WindowHeatingStartStopCommand
 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.enums import ConnectionState
+from carconnectivity.window_heating import WindowHeatings
 
 from carconnectivity_connectors.base.connector import BaseConnector
 from carconnectivity_connectors.seatcupra.auth.session_manager import SessionManager, SessionUser, Service
@@ -288,6 +291,7 @@ class Connector(BaseConnector):
                 vehicle_to_update = self.fetch_vehicle_status(vehicle_to_update)
                 vehicle_to_update = self.fetch_vehicle_mycar_status(vehicle_to_update)
                 vehicle_to_update = self.fetch_mileage(vehicle_to_update)
+                vehicle_to_update = self.fetch_ranges(vehicle_to_update)
                 if vehicle_to_update.capabilities.has_capability('climatisation', check_status_ok=True):
                     vehicle_to_update = self.fetch_climatisation(vehicle_to_update)
                 if vehicle_to_update.capabilities.has_capability('charging', check_status_ok=True):
@@ -414,7 +418,7 @@ class Connector(BaseConnector):
                                                 capability.parameters[parameter] = value
                                     else:
                                         raise APIError('Could not fetch capabilities, capability ID missing')
-                                    log_extra_keys(LOG_API, 'capability', capability_dict,  {'id', 'expirationDate', 'editable', 'parameters'})
+                                    log_extra_keys(LOG_API, 'capability', capability_dict,  {'id', 'expirationDate', 'editable', 'parameters', 'status'})
 
                                 for capability_id in vehicle.capabilities.capabilities.keys() - found_capabilities:
                                     vehicle.capabilities.remove_capability(capability_id)
@@ -422,7 +426,7 @@ class Connector(BaseConnector):
                                 if vehicle.capabilities.has_capability('charging', check_status_ok=True):
                                     if not isinstance(vehicle, SeatCupraElectricVehicle):
                                         LOG.debug('Promoting %s to SeatCupraElectricVehicle object for %s', vehicle.__class__.__name__, vin)
-                                        vehicle = SeatCupraElectricVehicle(origin=vehicle)
+                                        vehicle = SeatCupraElectricVehicle(garage=self.car_connectivity.garage, origin=vehicle)
                                         self.car_connectivity.garage.replace_vehicle(vin, vehicle)
                                     if not vehicle.charging.commands.contains_command('start-stop'):
                                         charging_start_stop_command: ChargingStartStopCommand = ChargingStartStopCommand(parent=vehicle.charging.commands)
@@ -646,6 +650,8 @@ class Connector(BaseConnector):
                         else:
                             if engine_type == GenericDrive.Type.ELECTRIC:
                                 drive = ElectricDrive(drive_id=drive_id, drives=vehicle.drives)
+                            elif engine_type == GenericDrive.Type.DIESEL:
+                                drive = DieselDrive(drive_id=drive_id, drives=vehicle.drives)
                             elif engine_type in [GenericDrive.Type.FUEL,
                                                  GenericDrive.Type.GASOLINE,
                                                  GenericDrive.Type.PETROL,
@@ -684,15 +690,15 @@ class Connector(BaseConnector):
                         has_combustion = True
                 if has_electric and not has_combustion and not isinstance(vehicle, SeatCupraElectricVehicle):
                     LOG.debug('Promoting %s to SeatCupraElectricVehicle object for %s', vehicle.__class__.__name__, vin)
-                    vehicle = SeatCupraElectricVehicle(origin=vehicle)
+                    vehicle = SeatCupraElectricVehicle(garage=self.car_connectivity.garage, origin=vehicle)
                     self.car_connectivity.garage.replace_vehicle(vin, vehicle)
                 elif has_combustion and not has_electric and not isinstance(vehicle, SeatCupraCombustionVehicle):
                     LOG.debug('Promoting %s to SeatCupraCombustionVehicle object for %s', vehicle.__class__.__name__, vin)
-                    vehicle = SeatCupraCombustionVehicle(origin=vehicle)
+                    vehicle = SeatCupraCombustionVehicle(garage=self.car_connectivity.garage, origin=vehicle)
                     self.car_connectivity.garage.replace_vehicle(vin, vehicle)
                 elif has_combustion and has_electric and not isinstance(vehicle, SeatCupraHybridVehicle):
                     LOG.debug('Promoting %s to SeatCupraHybridVehicle object for %s', vehicle.__class__.__name__, vin)
-                    vehicle = SeatCupraHybridVehicle(origin=vehicle)
+                    vehicle = SeatCupraHybridVehicle(garage=self.car_connectivity.garage, origin=vehicle)
                     self.car_connectivity.garage.replace_vehicle(vin, vehicle)
             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:
@@ -845,6 +851,40 @@ class Connector(BaseConnector):
             vehicle.odometer._set_value(None)  # pylint: disable=protected-access
         return vehicle
 
+    def fetch_ranges(self, vehicle: SeatCupraVehicle, no_cache: bool = False) -> SeatCupraVehicle:
+        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}/ranges'
+        # {'ranges': [{'rangeName': 'gasolineRangeKm', 'value': 100.0}, {'rangeName': 'electricRangeKm', 'value': 28.0}]}
+        data: Dict[str, Any] | None = self._fetch_data(url=url, session=self.session, no_cache=no_cache)
+        if data is not None:
+            if 'ranges' in data and data['ranges'] is not None:
+                for drive in vehicle.drives.drives.values():
+                    if drive.type.enabled and drive.type.value == GenericDrive.Type.ELECTRIC:
+                        for range_dict in data['ranges']:
+                            if 'rangeName' in range_dict and range_dict['rangeName'] is not None and range_dict['rangeName'] == 'electricRangeKm' \
+                                    and 'value' in range_dict and range_dict['value'] is not None:
+                                drive.range._set_value(range_dict['value'], unit=Length.KM)  # pylint: disable=protected-access
+                                break
+                    elif drive.type.enabled and drive.type.value == GenericDrive.Type.GASOLINE:
+                        for range_dict in data['ranges']:
+                            if 'rangeName' in range_dict and range_dict['rangeName'] is not None and range_dict['rangeName'] == 'gasolineRangeKm' \
+                                    and 'value' in range_dict and range_dict['value'] is not None:
+                                drive.range._set_value(range_dict['value'], unit=Length.KM)  # pylint: disable=protected-access
+                                break
+                    elif drive.type.enabled and drive.type.value == GenericDrive.Type.DIESEL:
+                        for range_dict in data['ranges']:
+                            if 'rangeName' in range_dict and range_dict['rangeName'] is not None and range_dict['rangeName'] == 'dieselRangeKm' \
+                                    and 'value' in range_dict and range_dict['value'] is not None:
+                                drive.range._set_value(range_dict['value'], unit=Length.KM)  # pylint: disable=protected-access
+                            elif 'rangeName' in range_dict and range_dict['rangeName'] is not None and range_dict['rangeName'] == 'adBlueKm' \
+                                    and 'value' in range_dict and range_dict['value'] is not None:
+                                if isinstance(drive, DieselDrive):
+                                    drive.adblue_range._set_value(range_dict['value'], unit=Length.KM)  # pylint: disable=protected-access
+            log_extra_keys(LOG_API, f'https://ola.prod.code.seat.cloud.vwgroup.com/v1/vehicles/{vin}/ranges', data,  {'ranges'})
+        return vehicle
+
     def fetch_maintenance(self, vehicle: SeatCupraVehicle, no_cache: bool = False) -> SeatCupraVehicle:
         vin = vehicle.vin.value
         if vin is None:
@@ -921,7 +961,57 @@ class Connector(BaseConnector):
                 log_extra_keys(LOG_API, 'climatisationStatus', data['climatisationStatus'], {'carCapturedTimestamp', 'climatisationState'})
             else:
                 vehicle.climatization.state._set_value(None)  # pylint: disable=protected-access
-            log_extra_keys(LOG_API, 'climatisation', data, {'climatisationStatus'})
+            if 'windowHeatingStatus' in data and data['windowHeatingStatus'] is not None:
+                window_heating_status: Dict = data['windowHeatingStatus']
+                if 'carCapturedTimestamp' not in window_heating_status or window_heating_status['carCapturedTimestamp'] is None:
+                    raise APIError('Could not fetch vehicle status, carCapturedTimestamp missing')
+                captured_at: datetime = robust_time_parse(window_heating_status['carCapturedTimestamp'])
+                if 'windowHeatingStatus' in window_heating_status and window_heating_status['windowHeatingStatus'] is not None:
+                    heating_on: bool = False
+                    all_heating_invalid: bool = True
+                    for window_heating in window_heating_status['windowHeatingStatus']:
+                        if 'windowLocation' in window_heating and window_heating['windowLocation'] is not None:
+                            window_id = window_heating['windowLocation']
+                            if window_id in vehicle.window_heatings.windows:
+                                window: WindowHeatings.WindowHeating = vehicle.window_heatings.windows[window_id]
+                            else:
+                                window = WindowHeatings.WindowHeating(window_id=window_id, window_heatings=vehicle.window_heatings)
+                                vehicle.window_heatings.windows[window_id] = window
+                            if 'windowHeatingState' in window_heating and window_heating['windowHeatingState'] is not None:
+                                if window_heating['windowHeatingState'] in [item.value for item in WindowHeatings.HeatingState]:
+                                    window_heating_state: WindowHeatings.HeatingState = WindowHeatings.HeatingState(window_heating['windowHeatingState'])
+                                    if window_heating_state == WindowHeatings.HeatingState.ON:
+                                        heating_on = True
+                                    if window_heating_state in [WindowHeatings.HeatingState.ON,
+                                                                WindowHeatings.HeatingState.OFF]:
+                                        all_heating_invalid = False
+                                    window.heating_state._set_value(window_heating_state, measured=captured_at)  # pylint: disable=protected-access
+                                else:
+                                    LOG_API.info('Unknown window heating state %s not in %s', window_heating['windowHeatingState'],
+                                                    str(WindowHeatings.HeatingState))
+                                    # pylint: disable-next=protected-access
+                                    window.heating_state._set_value(WindowHeatings.HeatingState.UNKNOWN, measured=captured_at)
+                            else:
+                                window.heating_state._set_value(None, measured=captured_at)  # pylint: disable=protected-access
+                        log_extra_keys(LOG_API, 'windowHeatingStatus', window_heating, {'windowLocation', 'windowHeatingState'})
+                    if all_heating_invalid:
+                        # pylint: disable-next=protected-access
+                        vehicle.window_heatings.heating_state._set_value(WindowHeatings.HeatingState.INVALID, measured=captured_at)
+                    else:
+                        if heating_on:
+                            # pylint: disable-next=protected-access
+                            vehicle.window_heatings.heating_state._set_value(WindowHeatings.HeatingState.ON, measured=captured_at)
+                        else:
+                            # pylint: disable-next=protected-access
+                            vehicle.window_heatings.heating_state._set_value(WindowHeatings.HeatingState.OFF, measured=captured_at)
+                if vehicle.window_heatings is not None and vehicle.window_heatings.commands is not None \
+                        and not vehicle.window_heatings.commands.contains_command('start-stop'):
+                    start_stop_command = WindowHeatingStartStopCommand(parent=vehicle.window_heatings.commands)
+                    start_stop_command._add_on_set_hook(self.__on_window_heating_start_stop)  # pylint: disable=protected-access
+                    start_stop_command.enabled = True
+                    vehicle.window_heatings.commands.add_command(start_stop_command)
+                log_extra_keys(LOG_API, 'windowHeatingStatus', window_heating_status, {'carCapturedTimestamp', 'windowHeatingStatus'})
+            log_extra_keys(LOG_API, 'climatisation', data, {'climatisationStatus', 'windowHeatingStatus'})
         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)
         if data is not None:
@@ -1043,22 +1133,84 @@ class Connector(BaseConnector):
                 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'
+            url = f'https://ola.prod.code.seat.cloud.vwgroup.com/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)
+                # {'settings': {'maxChargeCurrentAC': 'reduced', 'carCapturedTimestamp': '2025-03-18T16:50:33Z', 'autoUnlockPlugWhenCharged': None, 'targetSoc_pct': 100, 'batteryCareTargetSocPercentage': 80}}
+                if 'settings' in data and data['settings'] is not None:
+                    if 'carCapturedTimestamp' not in data['settings'] or data['settings']['carCapturedTimestamp'] is None:
+                        raise APIError('Could not fetch vehicle status, carCapturedTimestamp missing')
+                    captured_at: datetime = robust_time_parse(data['settings']['carCapturedTimestamp'])
+                    if 'maxChargeCurrentAC_A' in data['settings'] and data['settings']['maxChargeCurrentAC_A'] is not None:
+                        if isinstance(vehicle.charging.settings, SeatCupraCharging.Settings):
+                            vehicle.charging.settings.max_current_in_ampere = True
+                        else:
+                            raise ValueError('Charging settings not of type VolkswagenCharging.Settings')
+                        vehicle.charging.settings.maximum_current.minimum = 6.0
+                        vehicle.charging.settings.maximum_current.maximum = 16.0
+                        vehicle.charging.settings.maximum_current.precision = 1.0
+                        # pylint: disable-next=protected-access
+                        vehicle.charging.settings.maximum_current._add_on_set_hook(self.__on_charging_settings_change)
+                        vehicle.charging.settings.maximum_current._is_changeable = True  # pylint: disable=protected-access
+                        vehicle.charging.settings.maximum_current._set_value(data['settings']['maxChargeCurrentAC_A'],  # pylint: disable=protected-access
+                                                                             measured=captured_at)
+                    elif 'maxChargeCurrentAC' in data['settings'] and data['settings']['maxChargeCurrentAC'] is not None:
+                        if isinstance(vehicle.charging.settings, SeatCupraCharging.Settings):
+                            vehicle.charging.settings.max_current_in_ampere = False
+                        else:
+                            raise ValueError('Charging settings not of type VolkswagenCharging.Settings')
+                        vehicle.charging.settings.maximum_current.minimum = 6.0
+                        vehicle.charging.settings.maximum_current.maximum = 16.0
+                        vehicle.charging.settings.maximum_current.precision = 1.0
+                        # pylint: disable-next=protected-access
+                        vehicle.charging.settings.maximum_current._add_on_set_hook(self.__on_charging_settings_change)
+                        vehicle.charging.settings.maximum_current._is_changeable = True  # pylint: disable=protected-access
+                        if data['settings']['maxChargeCurrentAC'] == 'maximum':
+                            vehicle.charging.settings.maximum_current._set_value(16.0,  # pylint: disable=protected-access
+                                                                                 measured=captured_at)
+                        elif data['settings']['maxChargeCurrentAC'] == 'reduced':
+                            vehicle.charging.settings.maximum_current._set_value(6.0,  # pylint: disable=protected-access
+                                                                                 measured=captured_at)
+                        else:
+                            LOG_API.info('Unknown max charge current %s', data['settings']['maxChargeCurrentAC'])
+                            vehicle.charging.settings.maximum_current._set_value(None, measured=captured_at)  # pylint: disable=protected-access
                     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
+                        vehicle.charging.settings.maximum_current._set_value(None, measured=captured_at)  # pylint: disable=protected-access
+                    if 'autoUnlockPlugWhenCharged' in data['settings'] and data['settings']['autoUnlockPlugWhenCharged'] is not None:
+                        # pylint: disable-next=protected-access
+                        vehicle.charging.settings.auto_unlock._add_on_set_hook(self.__on_charging_settings_change)
+                        vehicle.charging.settings.auto_unlock._is_changeable = True  # pylint: disable=protected-access
+                        if data['settings']['autoUnlockPlugWhenCharged'] == 'on':
+                            vehicle.charging.settings.auto_unlock._set_value(True,  # pylint: disable=protected-access
+                                                                             measured=captured_at)
+                        elif data['settings']['autoUnlockPlugWhenCharged'] == 'off':
+                            vehicle.charging.settings.auto_unlock._set_value(False,  # pylint: disable=protected-access
+                                                                             measured=captured_at)
+                        else:
+                            LOG_API.info('Unknown auto unlock plug when charged %s', data['settings']['autoUnlockPlugWhenCharged'])
+                            vehicle.charging.settings.auto_unlock._set_value(None, measured=captured_at)  # pylint: disable=protected-access
+                    else:
+                        vehicle.charging.settings.auto_unlock._set_value(None, measured=captured_at)  # pylint: disable=protected-access
+                    if 'targetSoc_pct' in data['settings'] and data['settings']['targetSoc_pct'] is not None:
+                        charging_capability: Optional[Capability] = vehicle.capabilities.get_capability('charging')
+                        if charging_capability is not None and ('supportsTargetStateOfCharge' not in charging_capability.parameters
+                                                                or charging_capability.parameters['supportsTargetStateOfCharge'] != 'false'):
+                            vehicle.charging.settings.target_level.minimum = 50.0
+                            vehicle.charging.settings.target_level.maximum = 100.0
+                            vehicle.charging.settings.target_level.precision = 10.0
+                            # pylint: disable-next=protected-access
+                            vehicle.charging.settings.target_level._add_on_set_hook(self.__on_charging_settings_change)
+                            vehicle.charging.settings.target_level._is_changeable = True  # pylint: disable=protected-access
+                        vehicle.charging.settings.target_level._set_value(data['settings']['targetSoc_pct'],  # pylint: disable=protected-access
+                                                                          measured=captured_at)
+                    else:
+                        vehicle.charging.settings.target_level._set_value(None, measured=captured_at)  # pylint: disable=protected-access
+                    log_extra_keys(LOG_API, 'chargingSettings', data['settings'], {'carCapturedTimestamp', 'maxChargeCurrentAC_A', 'maxChargeCurrentAC',
+                                                                                   'autoUnlockPlugWhenCharged', 'targetSoc_pct'})
+            else:
+                vehicle.charging.settings.maximum_current._set_value(None)  # pylint: disable=protected-access
+                vehicle.charging.settings.auto_unlock._set_value(None)  # pylint: disable=protected-access
+                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:
@@ -1205,7 +1357,6 @@ class Connector(BaseConnector):
             raise CommandError('VIN in object hierarchy missing')
         if 'command' not in command_arguments:
             raise CommandError('Command argument missing')
-        command_dict: Dict = {}
         try:
             if command_arguments['command'] == ChargingStartStopCommand.Command.START:
                 url = f'https://ola.prod.code.seat.cloud.vwgroup.com/vehicles/{vin}/charging/requests/start'
@@ -1494,20 +1645,25 @@ class Connector(BaseConnector):
         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
+            precision: float = settings.target_temperature.precision if settings.target_temperature.precision is not None else 0.5
             if isinstance(attribute, TemperatureAttribute) and attribute.id == 'target_temperature':
-                setting_dict['targetTemperature'] = round(value * 2) / 2
+                value = round(value / settings.target_temperature.precision) * settings.target_temperature.precision
+                setting_dict['targetTemperature'] = value
             else:
-                setting_dict['targetTemperature'] = round(settings.target_temperature.value * 2) / 2
+                setting_dict['targetTemperature'] = round(settings.target_temperature.value / precision) * precision
             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
+        climatization_capability: Optional[Capability] = vehicle.capabilities.get_capability('climatisation')
+        if climatization_capability is not None and ('supportsOffGridClimatisation' not in climatization_capability.parameters
+                                                     or climatization_capability.parameters['supportsOffGridClimatisation'] != 'false'):
+            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'
         try:
@@ -1526,6 +1682,114 @@ class Connector(BaseConnector):
             raise SetterError(f'Retrying failed: {retry_error}') from retry_error
         return value
 
+    def __on_window_heating_start_stop(self, start_stop_command: WindowHeatingStartStopCommand, command_arguments: Union[str, Dict[str, Any]]) \
+            -> Union[str, Dict[str, Any]]:
+        if start_stop_command.parent is None or start_stop_command.parent.parent is None \
+                or start_stop_command.parent.parent.parent is None or not isinstance(start_stop_command.parent.parent.parent, SeatCupraVehicle):
+            raise CommandError('Object hierarchy is not as expected')
+        if not isinstance(command_arguments, dict):
+            raise CommandError('Command arguments are not a dictionary')
+        vehicle: SeatCupraVehicle = start_stop_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')
+        try:
+            if command_arguments['command'] == WindowHeatingStartStopCommand.Command.START:
+                url = f'https://ola.prod.code.seat.cloud.vwgroup.com/vehicles/{vin}/windowheating/requests/start'
+                command_response: requests.Response = self.session.post(url, allow_redirects=True)
+            elif command_arguments['command'] == WindowHeatingStartStopCommand.Command.STOP:
+                url = f'https://ola.prod.code.seat.cloud.vwgroup.com/vehicles/{vin}/windowheating/requests/stop'
+                command_response: requests.Response = self.session.post(url, allow_redirects=True)
+            else:
+                raise CommandError(f'Unknown command {command_arguments["command"]}')
+
+            if command_response.status_code not in [requests.codes['ok'], requests.codes['created']]:
+                LOG.error('Could not start/stop window heating (%s: %s)', command_response.status_code, command_response.text)
+                raise CommandError(f'Could not start/stop window heating ({command_response.status_code}: {command_response.text})')
+        except requests.exceptions.ConnectionError as connection_error:
+            raise CommandError(f'Connection error: {connection_error}.'
+                               ' If this happens frequently, please check if other applications communicate with the Seat/Cupra server.') from connection_error
+        except requests.exceptions.ChunkedEncodingError as chunked_encoding_error:
+            raise CommandError(f'Error: {chunked_encoding_error}') from chunked_encoding_error
+        except requests.exceptions.ReadTimeout as timeout_error:
+            raise CommandError(f'Timeout during read: {timeout_error}') from timeout_error
+        except requests.exceptions.RetryError as retry_error:
+            raise CommandError(f'Retrying failed: {retry_error}') from retry_error
+        return command_arguments
+
+    def __on_charging_settings_change(self, attribute: GenericAttribute, value: Any) -> Any:
+        """
+        Callback for the charging setting change.
+        """
+        if attribute.parent is None or not isinstance(attribute.parent, SeatCupraCharging.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: SeatCupraCharging.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 = {}
+        precision: float = settings.maximum_current.precision if settings.maximum_current.precision is not None else 1.0
+        if isinstance(attribute, CurrentAttribute) and attribute.id == 'maximum_current':
+            value = round(value / precision) * precision
+            if settings.max_current_in_ampere:
+                setting_dict['maxChargeCurrentAcInAmperes'] = value
+            else:
+                if value < 6:
+                    raise SetterError('Maximum current must be greater than 6 amps')
+                if value < 16:
+                    setting_dict['maxChargeCurrentAc'] = 'reduced'
+                    value = 6.0
+                else:
+                    setting_dict['maxChargeCurrentAc'] = 'maximum'
+                    value = 16.0
+        elif settings.maximum_current.enabled and settings.maximum_current.value is not None:
+            if settings.max_current_in_ampere:
+                setting_dict['maxChargeCurrentAc_A'] = round(settings.maximum_current.value / precision) * precision
+            else:
+                if settings.maximum_current.value < 6:
+                    raise SetterError('Maximum current must be greater than 6 amps')
+                if settings.maximum_current.value < 16:
+                    setting_dict['maxChargeCurrentAc'] = 'reduced'
+                    settings.maximum_current.value = 6.0
+                else:
+                    setting_dict['maxChargeCurrentAc'] = 'maximum'
+                    settings.maximum_current.value = 16.0
+        if isinstance(attribute, BooleanAttribute) and attribute.id == 'auto_unlock':
+            setting_dict['autoUnlockPlugWhenChargedAc'] = 'on' if value else 'off'
+        elif settings.auto_unlock.enabled and settings.auto_unlock.value is not None:
+            setting_dict['autoUnlockPlugWhenChargedAc'] = 'on' if settings.auto_unlock.value else 'off'
+        charging_capability: Optional[Capability] = vehicle.capabilities.get_capability('charging')
+        if charging_capability is not None and ('supportsTargetStateOfCharge' not in charging_capability.parameters
+                                                or charging_capability.parameters['supportsTargetStateOfCharge'] != 'false'):
+            precision: float = settings.target_level.precision if settings.target_level.precision is not None else 10.0
+            if isinstance(attribute, LevelAttribute) and attribute.id == 'target_level':
+                value = round(value / precision) * precision
+                setting_dict['targetSoc'] = value
+            elif settings.target_level.enabled and settings.target_level.value is not None:
+                setting_dict['targetSoc'] = round(settings.target_level.value / precision) * precision
+
+        url: str = f'https://ola.prod.code.seat.cloud.vwgroup.com/v1/vehicles/{vin}/charging/settings'
+        try:
+            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 charging settings (%s)', settings_response.status_code)
+                raise SetterError(f'Could not set value ({settings_response.status_code})')
+        except requests.exceptions.ConnectionError as connection_error:
+            raise SetterError(f'Connection error: {connection_error}.'
+                              ' If this happens frequently, please check if other applications communicate with the Volkswagen server.') from connection_error
+        except requests.exceptions.ChunkedEncodingError as chunked_encoding_error:
+            raise SetterError(f'Error: {chunked_encoding_error}') from chunked_encoding_error
+        except requests.exceptions.ReadTimeout as timeout_error:
+            raise SetterError(f'Timeout during read: {timeout_error}') from timeout_error
+        except requests.exceptions.RetryError as retry_error:
+            raise SetterError(f'Retrying failed: {retry_error}') from retry_error
+        return value
+
     def get_version(self) -> str:
         return __version__
 

carconnectivity_connectors/seatcupra/vehicle.py

@@ -6,6 +6,7 @@ from carconnectivity.vehicle import GenericVehicle, ElectricVehicle, CombustionV
 
 from carconnectivity_connectors.seatcupra.capability import Capabilities
 from carconnectivity_connectors.seatcupra.climatization import SeatCupraClimatization
+from carconnectivity_connectors.seatcupra.charging import SeatCupraCharging
 
 SUPPORT_IMAGES = False
 try:
@@ -17,6 +18,8 @@ except ImportError:
 if TYPE_CHECKING:
     from typing import Optional, Dict
     from carconnectivity.garage import Garage
+    from carconnectivity.charging import Charging
+
     from carconnectivity_connectors.base.connector import BaseConnector
 
 
@@ -34,7 +37,7 @@ class SeatCupraVehicle(GenericVehicle):  # pylint: disable=too-many-instance-att
     def __init__(self, vin: Optional[str] = None, garage: Optional[Garage] = None, managing_connector: Optional[BaseConnector] = None,
                  origin: Optional[SeatCupraVehicle] = None) -> None:
         if origin is not None:
-            super().__init__(origin=origin)
+            super().__init__(garage=garage, origin=origin)
             self.capabilities: Capabilities = origin.capabilities
             self.capabilities.parent = self
             if SUPPORT_IMAGES:
@@ -54,9 +57,14 @@ class SeatCupraElectricVehicle(ElectricVehicle, SeatCupraVehicle):
     def __init__(self, vin: Optional[str] = None, garage: Optional[Garage] = None, managing_connector: Optional[BaseConnector] = None,
                  origin: Optional[SeatCupraVehicle] = None) -> None:
         if origin is not None:
-            super().__init__(origin=origin)
+            super().__init__(garage=garage, origin=origin)
+            if isinstance(origin, ElectricVehicle):
+                self.charging: Charging = SeatCupraCharging(vehicle=self, origin=origin.charging)
+            else:
+                self.charging: Charging = SeatCupraCharging(vehicle=self, origin=self.charging)
         else:
             super().__init__(vin=vin, garage=garage, managing_connector=managing_connector)
+            self.charging: Charging = SeatCupraCharging(vehicle=self, origin=self.charging)
 
 
 class SeatCupraCombustionVehicle(CombustionVehicle, SeatCupraVehicle):
@@ -66,7 +74,7 @@ class SeatCupraCombustionVehicle(CombustionVehicle, SeatCupraVehicle):
     def __init__(self, vin: Optional[str] = None, garage: Optional[Garage] = None, managing_connector: Optional[BaseConnector] = None,
                  origin: Optional[SeatCupraVehicle] = None) -> None:
         if origin is not None:
-            super().__init__(origin=origin)
+            super().__init__(garage=garage, origin=origin)
         else:
             super().__init__(vin=vin, garage=garage, managing_connector=managing_connector)
 
@@ -78,6 +86,6 @@ class SeatCupraHybridVehicle(HybridVehicle, SeatCupraVehicle):
     def __init__(self, vin: Optional[str] = None, garage: Optional[Garage] = None, managing_connector: Optional[BaseConnector] = None,
                  origin: Optional[SeatCupraVehicle] = None) -> None:
         if origin is not None:
-            super().__init__(origin=origin)
+            super().__init__(garage=garage, origin=origin)
         else:
             super().__init__(vin=vin, garage=garage, managing_connector=managing_connector)