carconnectivity-connector-skoda 0.4a8__py3-none-any.whl → 0.5__py3-none-any.whl

{carconnectivity_connector_skoda-0.4a8.dist-info → carconnectivity_connector_skoda-0.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: carconnectivity-connector-skoda
-Version: 0.4a8
+Version: 0.5
 Summary: CarConnectivity connector for Skoda services
 Author: Till Steinbach
 License: MIT License
@@ -37,15 +37,16 @@ Classifier: Topic :: Software Development :: Libraries
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: carconnectivity>=0.4a11
+Requires-Dist: carconnectivity>=0.5
 Requires-Dist: oauthlib~=3.2.2
 Requires-Dist: requests~=2.32.3
 Requires-Dist: jwt~=1.3.1
 Requires-Dist: paho-mqtt~=2.1.0
+Dynamic: license-file
 
 
 
-# CarConnectivity Connector for Volkswagen Vehicles
+# CarConnectivity Connector for Skoda Vehicles
 [![GitHub sourcecode](https://img.shields.io/badge/Source-GitHub-green)](https://github.com/tillsteinbach/CarConnectivity-connector-skoda/)
 [![GitHub release (latest by date)](https://img.shields.io/github/v/release/tillsteinbach/CarConnectivity-connector-skoda)](https://github.com/tillsteinbach/CarConnectivity-connector-skoda/releases/latest)
 [![GitHub](https://img.shields.io/github/license/tillsteinbach/CarConnectivity-connector-skoda)](https://github.com/tillsteinbach/CarConnectivity-connector-skoda/blob/master/LICENSE)

{carconnectivity_connector_skoda-0.4a8.dist-info → carconnectivity_connector_skoda-0.5.dist-info}/RECORD

@@ -1,13 +1,14 @@
+carconnectivity_connector_skoda-0.5.dist-info/licenses/LICENSE,sha256=PIwI1alwDyOfvEQHdGCm2u9uf_mGE8030xZDfun0xTo,1071
 carconnectivity_connectors/skoda/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-carconnectivity_connectors/skoda/_version.py,sha256=yk7F-aY3-bSpr2Y78fjZ3DV9CNQcGrOzYh8bBvw_wKI,508
-carconnectivity_connectors/skoda/capability.py,sha256=vbAKK8KKre-CndLF6_5qyWLpfa4KZHk1U-hpb6nCL5w,4225
-carconnectivity_connectors/skoda/charging.py,sha256=CoUOYHHUPPPldKQvv0h-qrUsoEtstR3iUx-l0IU5rNM,6798
+carconnectivity_connectors/skoda/_version.py,sha256=6KN8_fYf4OIoH3z85tggP3fkMDQc76t8Gz3ntWifnNk,506
+carconnectivity_connectors/skoda/capability.py,sha256=wH563-XUb_TnT8di1qDjnj-cY-cNHcAT6z7mx21LhSQ,4770
+carconnectivity_connectors/skoda/charging.py,sha256=7DPNiTWFhxiiEFKVnbIIU2TCmkpmcMWx_zsHXGXFpAQ,6856
 carconnectivity_connectors/skoda/climatization.py,sha256=Jut468SkxjPBDTqroWFvDifVPfJBxGjsFed5pc4kZkg,1768
 carconnectivity_connectors/skoda/command_impl.py,sha256=vgno5Qb5To0hCHOEBWSG8UOwCY9kT5fz1e2y0b6zF7U,3047
-carconnectivity_connectors/skoda/connector.py,sha256=cwI-7AAwzKODZgyZtk2qL-HxBdEpEvHE2riVLTePXw4,128467
+carconnectivity_connectors/skoda/connector.py,sha256=wp3GXooqn1-O-TR4PxUdNR846EKrghBPCp3lN_5_UeE,144975
 carconnectivity_connectors/skoda/error.py,sha256=ffxzvjmci7vtp9Q1K4DR1kBF0kTJxN5Gluci3kDBkEI,2459
 carconnectivity_connectors/skoda/mqtt_client.py,sha256=RkZ43NG1Z_TUmc2hUZS0yYUfwewzfut63zZUhQR1xug,39101
-carconnectivity_connectors/skoda/vehicle.py,sha256=TeY3qKWbBfxFxt6UzSDrB-YZ4L8GURAvINzBiFm9Y9E,3819
+carconnectivity_connectors/skoda/vehicle.py,sha256=q5gwe-_yPfE_-aEc17UQ-Q0Z46IN7PCpNG5jLw5PZl0,3981
 carconnectivity_connectors/skoda/auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 carconnectivity_connectors/skoda/auth/auth_util.py,sha256=dGLUbUre0HBsTg_Ii5vW34f8DLrCykYJYCyzEvUBBEE,4434
 carconnectivity_connectors/skoda/auth/my_skoda_session.py,sha256=lSh23SFJs8opjmPwHTv-KNIKDep_WY4aItSP4Zq7bT8,10396
@@ -16,8 +17,7 @@ carconnectivity_connectors/skoda/auth/session_manager.py,sha256=Uf1vujuDBYUCAXhY
 carconnectivity_connectors/skoda/auth/skoda_web_session.py,sha256=tapjCRRPBu3tHrDoKmtuAlQhgxktib3oWTB8MHEzZTY,10816
 carconnectivity_connectors/skoda/auth/helpers/blacklist_retry.py,sha256=f3wsiY5bpHDBxp7Va1Mv9nKJ4u3qnCHZZmDu78_AhMk,1251
 carconnectivity_connectors/skoda/ui/connector_ui.py,sha256=2Gywhyki52IxIZXV6DhWhzrBLn2293LlUMhK1Rxnw9w,1376
-carconnectivity_connector_skoda-0.4a8.dist-info/LICENSE,sha256=PIwI1alwDyOfvEQHdGCm2u9uf_mGE8030xZDfun0xTo,1071
-carconnectivity_connector_skoda-0.4a8.dist-info/METADATA,sha256=FgmLzGc6cUEeulykyeFr7dxJGD0gfGzesmGqZiznnIY,5366
-carconnectivity_connector_skoda-0.4a8.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
-carconnectivity_connector_skoda-0.4a8.dist-info/top_level.txt,sha256=KqA8GviZsDH4PtmnwSQsz0HB_w-TWkeEHLIRNo5dTaI,27
-carconnectivity_connector_skoda-0.4a8.dist-info/RECORD,,
+carconnectivity_connector_skoda-0.5.dist-info/METADATA,sha256=NmEpTszVOGvqRN5lGNyxdOTneA0-lvH5WndA1zdPp6Q,5378
+carconnectivity_connector_skoda-0.5.dist-info/WHEEL,sha256=1tXe9gY0PYatrMPMDd6jXqjfpz_B-Wqm32CPfRC58XU,91
+carconnectivity_connector_skoda-0.5.dist-info/top_level.txt,sha256=KqA8GviZsDH4PtmnwSQsz0HB_w-TWkeEHLIRNo5dTaI,27
+carconnectivity_connector_skoda-0.5.dist-info/RECORD,,

{carconnectivity_connector_skoda-0.4a8.dist-info → carconnectivity_connector_skoda-0.5.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/skoda/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.4a8'
-__version_tuple__ = version_tuple = (0, 4)
+__version__ = version = '0.5'
+__version_tuple__ = version_tuple = (0, 5)

carconnectivity_connectors/skoda/capability.py

@@ -5,7 +5,7 @@ from typing import TYPE_CHECKING
 from enum import IntEnum
 
 from carconnectivity.objects import GenericObject
-from carconnectivity.attributes import StringAttribute
+from carconnectivity.attributes import StringAttribute, GenericAttribute
 
 if TYPE_CHECKING:
     from typing import Dict, Optional
@@ -77,7 +77,7 @@ class Capabilities(GenericObject):
         """
         return self.__capabilities.get(capability_id)
 
-    def has_capability(self, capability_id: str) -> bool:
+    def has_capability(self, capability_id: str, check_status_ok=False) -> bool:
         """
         Check if the Capabilities contains a capability with the specified ID.
 
@@ -87,7 +87,14 @@ class Capabilities(GenericObject):
         Returns:
             bool: True if the capability exists, otherwise False.
         """
-        return capability_id in self.__capabilities
+        if check_status_ok:
+            if capability_id in self.__capabilities and self.__capabilities[capability_id].enabled:
+                capability: Capability = self.__capabilities[capability_id]
+                if capability.status.enabled and capability.status.value is not None and len(capability.status.value) > 0:
+                    return False
+                return True
+            return False
+        return capability_id in self.__capabilities and self.__capabilities[capability_id].enabled
 
 
 class Capability(GenericObject):
@@ -103,7 +110,7 @@ class Capability(GenericObject):
         super().__init__(object_id=capability_id, parent=capabilities)
         self.delay_notifications = True
         self.capability_id = StringAttribute("id", self, capability_id, tags={'connector_custom'})
-        self.statuses = list[Capability.Status]
+        self.status = GenericAttribute("status", self, value=[], tags={'connector_custom'})
         self.enabled = True
         self.delay_notifications = False
 

carconnectivity_connectors/skoda/charging.py

@@ -26,11 +26,11 @@ class SkodaCharging(Charging):  # pylint: disable=too-many-instance-attributes
     """
     def __init__(self, vehicle: ElectricVehicle | None = None, origin: Optional[Charging] = None) -> None:
         if origin is not None:
-            super().__init__(origin=origin)
-            self.settings: Charging.Settings = SkodaCharging.Settings(origin=origin.settings)
+            super().__init__(vehicle=vehicle, origin=origin)
+            self.settings: Charging.Settings = SkodaCharging.Settings(parent=self, origin=origin.settings)
         else:
             super().__init__(vehicle=vehicle)
-            self.settings: Charging.Settings = SkodaCharging.Settings(origin=self.settings)
+            self.settings: Charging.Settings = SkodaCharging.Settings(parent=self, origin=self.settings)
         self.errors: Dict[str, Error] = {}
         self.is_in_saved_location: BooleanAttribute = BooleanAttribute("is_in_saved_location", parent=self, tags={'connector_custom'})
 
@@ -40,7 +40,7 @@ class SkodaCharging(Charging):  # pylint: disable=too-many-instance-attributes
         """
         def __init__(self, parent: Optional[GenericObject] = None, origin: Optional[Charging.Settings] = None) -> None:
             if origin is not None:
-                super().__init__(origin=origin)
+                super().__init__(parent=parent, origin=origin)
             else:
                 super().__init__(parent=parent)
             self.preferred_charge_mode: EnumAttribute = EnumAttribute("preferred_charge_mode", parent=self, tags={'connector_custom'})

carconnectivity_connectors/skoda/connector.py

@@ -23,14 +23,17 @@ from carconnectivity.doors import Doors
 from carconnectivity.windows import Windows
 from carconnectivity.lights import Lights
 from carconnectivity.drive import GenericDrive, ElectricDrive, CombustionDrive
-from carconnectivity.attributes import GenericAttribute, BooleanAttribute, DurationAttribute, TemperatureAttribute, EnumAttribute
+from carconnectivity.attributes import BooleanAttribute, DurationAttribute, TemperatureAttribute, EnumAttribute, LevelAttribute, \
+    CurrentAttribute
 from carconnectivity.charging import Charging
 from carconnectivity.position import Position
 from carconnectivity.climatization import Climatization
 from carconnectivity.charging_connector import ChargingConnector
 from carconnectivity.commands import Commands
-from carconnectivity.command_impl import ClimatizationStartStopCommand, ChargingStartStopCommand, HonkAndFlashCommand, LockUnlockCommand, WakeSleepCommand
+from carconnectivity.command_impl import ClimatizationStartStopCommand, ChargingStartStopCommand, HonkAndFlashCommand, LockUnlockCommand, WakeSleepCommand, \
+    WindowHeatingStartStopCommand
 from carconnectivity.enums import ConnectionState
+from carconnectivity.window_heating import WindowHeatings
 
 from carconnectivity_connectors.base.connector import BaseConnector
 from carconnectivity_connectors.skoda.auth.session_manager import SessionManager, SessionUser, Service
@@ -373,15 +376,15 @@ class Connector(BaseConnector):
                 vehicle_to_update = self.fetch_vehicle_status(vehicle_to_update)
                 vehicle_to_update = self.fetch_driving_range(vehicle_to_update)
                 if vehicle_to_update.capabilities is not None and vehicle_to_update.capabilities.enabled:
-                    if vehicle_to_update.capabilities.has_capability('READINESS'):
+                    if vehicle_to_update.capabilities.has_capability('READINESS', check_status_ok=True):
                         vehicle_to_update = self.fetch_connection_status(vehicle_to_update)
-                    if vehicle_to_update.capabilities.has_capability('PARKING_POSITION'):
+                    if vehicle_to_update.capabilities.has_capability('PARKING_POSITION', check_status_ok=True):
                         vehicle_to_update = self.fetch_position(vehicle_to_update)
-                    if vehicle_to_update.capabilities.has_capability('CHARGING') and isinstance(vehicle_to_update, SkodaElectricVehicle):
+                    if vehicle_to_update.capabilities.has_capability('CHARGING', check_status_ok=True) and isinstance(vehicle_to_update, SkodaElectricVehicle):
                         vehicle_to_update = self.fetch_charging(vehicle_to_update)
-                    if vehicle_to_update.capabilities.has_capability('AIR_CONDITIONING'):
+                    if vehicle_to_update.capabilities.has_capability('AIR_CONDITIONING', check_status_ok=True):
                         vehicle_to_update = self.fetch_air_conditioning(vehicle_to_update)
-                    if vehicle_to_update.capabilities.has_capability('VEHICLE_HEALTH_INSPECTION'):
+                    if vehicle_to_update.capabilities.has_capability('VEHICLE_HEALTH_INSPECTION', check_status_ok=True):
                         vehicle_to_update = self.fetch_maintenance(vehicle_to_update)
                 vehicle_to_update = self.decide_state(vehicle_to_update)
         self.car_connectivity.transaction_end()
@@ -507,14 +510,24 @@ class Connector(BaseConnector):
             if 'settings' in data and data['settings'] is not None:
                 if 'targetStateOfChargeInPercent' in data['settings'] and data['settings']['targetStateOfChargeInPercent'] is not None \
                         and vehicle.charging is not None and vehicle.charging.settings is not None:
+                    vehicle.charging.settings.target_level.minimum = 50.0
+                    vehicle.charging.settings.target_level.maximum = 100.0
+                    vehicle.charging.settings.target_level.precision = 10.0
+                    vehicle.charging.settings.target_level._add_on_set_hook(self.__on_charging_target_level_change)  # pylint: disable=protected-access
+                    vehicle.charging.settings.target_level._is_changeable = True  # pylint: disable=protected-access
                     # pylint: disable-next=protected-access
                     vehicle.charging.settings.target_level._set_value(value=data['settings']['targetStateOfChargeInPercent'], measured=captured_at)
                 else:
                     vehicle.charging.settings.target_level._set_value(None, measured=captured_at)  # pylint: disable=protected-access
                 if 'maxChargeCurrentAc' in data['settings'] and data['settings']['maxChargeCurrentAc'] is not None \
                         and vehicle.charging is not None and vehicle.charging.settings is not None:
+                    vehicle.charging.settings.maximum_current.minimum = 6.0
+                    vehicle.charging.settings.maximum_current.maximum = 16.0
+                    vehicle.charging.settings.maximum_current.precision = 1.0
+                    vehicle.charging.settings.maximum_current._add_on_set_hook(self.__on_charging_maximum_current_change)  # pylint: disable=protected-access
+                    vehicle.charging.settings.maximum_current._is_changeable = True  # pylint: disable=protected-access
                     if data['settings']['maxChargeCurrentAc'] == 'MAXIMUM':
-                        vehicle.charging.settings.maximum_current._set_value(value=11, measured=captured_at)  # pylint: disable=protected-access
+                        vehicle.charging.settings.maximum_current._set_value(value=16, measured=captured_at)  # pylint: disable=protected-access
                     elif data['settings']['maxChargeCurrentAc'] == 'REDUCED':
                         vehicle.charging.settings.maximum_current._set_value(value=6, measured=captured_at)  # pylint: disable=protected-access
                     else:
@@ -523,6 +536,8 @@ class Connector(BaseConnector):
                 else:
                     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:
+                    vehicle.charging.settings.auto_unlock._add_on_set_hook(self.__on_charging_auto_unlock_change)  # pylint: disable=protected-access
+                    vehicle.charging.settings.auto_unlock._is_changeable = True  # pylint: disable=protected-access
                     if data['settings']['autoUnlockPlugWhenCharged'] in ['ON', 'PERMANENT']:
                         vehicle.charging.settings.auto_unlock._set_value(True, measured=captured_at)  # pylint: disable=protected-access
                     elif data['settings']['autoUnlockPlugWhenCharged'] == 'OFF':
@@ -646,7 +661,7 @@ class Connector(BaseConnector):
                 vehicle.in_motion._set_value(data['inMotion'])  # pylint: disable=protected-access
             else:
                 vehicle.in_motion._set_value(None)  # pylint: disable=protected-access
-            log_extra_keys(LOG_API, 'connection status', data,  {'unreachable'})
+            log_extra_keys(LOG_API, 'connection status', data,  {'unreachable', 'inMotion'})
         return vehicle
 
     def fetch_position(self, vehicle: SkodaVehicle, no_cache: bool = False) -> SkodaVehicle:
@@ -701,6 +716,10 @@ class Connector(BaseConnector):
                 vehicle.position.latitude._set_value(None)  # pylint: disable=protected-access
                 vehicle.position.longitude._set_value(None)  # pylint: disable=protected-access
                 vehicle.position.position_type._set_value(None)  # pylint: disable=protected-access
+        else:
+            vehicle.position.latitude._set_value(None)  # pylint: disable=protected-access
+            vehicle.position.longitude._set_value(None)  # pylint: disable=protected-access
+            vehicle.position.position_type._set_value(None)  # pylint: disable=protected-access
         return vehicle
 
     def fetch_maintenance(self, vehicle: SkodaVehicle, no_cache: bool = False) -> SkodaVehicle:
@@ -969,7 +988,44 @@ class Connector(BaseConnector):
                     # pylint: disable-next=protected-access
                     vehicle.charging.connector.lock_state._set_value(value=None, measured=captured_at)
             if 'windowHeatingState' in data and data['windowHeatingState'] is not None:
-                pass
+                heating_on: bool = False
+                all_heating_invalid: bool = True
+                for window_id, state in data['windowHeatingState'].items():
+                    if window_id != 'unspecified':
+                        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 state.lower() in [item.value for item in WindowHeatings.HeatingState]:
+                            window_heating_state: WindowHeatings.HeatingState = WindowHeatings.HeatingState(state.lower())
+                            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', state.lower(), str(WindowHeatings.HeatingState))
+                            # pylint: disable-next=protected-access
+                            window.heating_state._set_value(WindowHeatings.HeatingState.UNKNOWN, measured=captured_at)
+                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)
             if 'errors' in data and data['errors'] is not None:
                 found_errors: Set[str] = set()
                 if not isinstance(vehicle.climatization, SkodaClimatization):
@@ -998,7 +1054,7 @@ class Connector(BaseConnector):
             log_extra_keys(LOG_API, 'air-condition', data,  {'carCapturedTimestamp', 'state', 'estimatedDateTimeToReachTargetTemperature',
                                                              'targetTemperature', 'outsideTemperature', 'chargerConnectionState',
                                                              'chargerLockState', 'airConditioningAtUnlock', 'steeringWheelPosition',
-                                                             'windowHeatingEnabled', 'seatHeatingActivated', 'errors'})
+                                                             'windowHeatingEnabled', 'seatHeatingActivated', 'windowHeatingState', 'errors'})
         return vehicle
 
     def fetch_vehicle_details(self, vehicle: SkodaVehicle, no_cache: bool = False) -> SkodaVehicle:
@@ -1034,6 +1090,20 @@ class Connector(BaseConnector):
                             else:
                                 capability = Capability(capability_id=capability_id, capabilities=vehicle.capabilities)
                                 vehicle.capabilities.add_capability(capability_id, capability)
+                            if 'statuses' in capability_dict and capability_dict['statuses'] is not None:
+                                statuses = capability_dict['statuses']
+                                if isinstance(statuses, list):
+                                    for status in statuses:
+                                        if status in [item.name for item in Capability.Status]:
+                                            capability.status.value.append(Capability.Status[status])
+                                        else:
+                                            LOG_API.warning('Capability status unkown %s', status)
+                                            capability.status.value.append(Capability.Status.UNKNOWN)
+                                else:
+                                    LOG_API.warning('Capability status not a list in %s', statuses)
+                            else:
+                                capability.status.value.clear()
+                            log_extra_keys(LOG_API, 'capability', capability_dict, {'id', 'statuses'})
                         else:
                             raise APIError('Could not parse capability, id missing')
                     for capability_id in vehicle.capabilities.capabilities.keys() - found_capabilities:
@@ -1043,7 +1113,7 @@ class Connector(BaseConnector):
             else:
                 vehicle.capabilities.clear_capabilities()
 
-            if vehicle.capabilities.has_capability('VEHICLE_WAKE_UP_TRIGGER'):
+            if vehicle.capabilities.has_capability('VEHICLE_WAKE_UP_TRIGGER', check_status_ok=True):
                 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)
@@ -1052,7 +1122,8 @@ class Connector(BaseConnector):
                     vehicle.commands.add_command(wake_sleep_command)
 
             # Add HONK_AND_FLASH command if necessary capabilities are available
-            if vehicle.capabilities.has_capability('HONK_AND_FLASH') and vehicle.capabilities.has_capability('PARKING_POSITION'):
+            if vehicle.capabilities.has_capability('HONK_AND_FLASH', check_status_ok=True) \
+                    and vehicle.capabilities.has_capability('PARKING_POSITION', check_status_ok=True):
                 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)
@@ -1061,7 +1132,7 @@ class Connector(BaseConnector):
                     vehicle.commands.add_command(honk_flash_command)
 
             # Add lock and unlock command
-            if vehicle.capabilities.has_capability('ACCESS'):
+            if vehicle.capabilities.has_capability('ACCESS', check_status_ok=True):
                 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)
@@ -1167,6 +1238,8 @@ class Connector(BaseConnector):
         url = f'https://mysmob.api.connect.skoda-auto.cz/api/v2/vehicle-status/{vin}/driving-range'
         range_data: Dict[str, Any] | None = self._fetch_data(url=url, session=self.session, no_cache=no_cache)
         if range_data:
+            if 'carCapturedTimestamp' not in range_data or range_data['carCapturedTimestamp'] is None:
+                raise APIError('Could not fetch driving range, carCapturedTimestamp missing')
             captured_at: datetime = robust_time_parse(range_data['carCapturedTimestamp'])
             # Check vehicle type and if it does not match the current vehicle type, create a new vehicle object using copy constructor
             if 'carType' in range_data and range_data['carType'] is not None:
@@ -1174,7 +1247,7 @@ class Connector(BaseConnector):
                     car_type = GenericVehicle.Type(range_data['carType'])
                     if car_type == GenericVehicle.Type.ELECTRIC and not isinstance(vehicle, SkodaElectricVehicle):
                         LOG.debug('Promoting %s to SkodaElectricVehicle object for %s', vehicle.__class__.__name__, vin)
-                        vehicle = SkodaElectricVehicle(origin=vehicle)
+                        vehicle = SkodaElectricVehicle(garage=self.car_connectivity.garage, origin=vehicle)
                         self.car_connectivity.garage.replace_vehicle(vin, vehicle)
                     elif car_type in [GenericVehicle.Type.FUEL,
                                       GenericVehicle.Type.GASOLINE,
@@ -1184,11 +1257,11 @@ class Connector(BaseConnector):
                                       GenericVehicle.Type.LPG] \
                             and not isinstance(vehicle, SkodaCombustionVehicle):
                         LOG.debug('Promoting %s to SkodaCombustionVehicle object for %s', vehicle.__class__.__name__, vin)
-                        vehicle = SkodaCombustionVehicle(origin=vehicle)
+                        vehicle = SkodaCombustionVehicle(garage=self.car_connectivity.garage, origin=vehicle)
                         self.car_connectivity.garage.replace_vehicle(vin, vehicle)
                     elif car_type == GenericVehicle.Type.HYBRID and not isinstance(vehicle, SkodaHybridVehicle):
                         LOG.debug('Promoting %s to SkodaHybridVehicle object for %s', vehicle.__class__.__name__, vin)
-                        vehicle = SkodaHybridVehicle(origin=vehicle)
+                        vehicle = SkodaHybridVehicle(garage=self.car_connectivity.garage, origin=vehicle)
                         self.car_connectivity.garage.replace_vehicle(vin, vehicle)
                 except ValueError:
                     LOG_API.warning('Unknown car type %s', range_data['carType'])
@@ -1791,5 +1864,160 @@ class Connector(BaseConnector):
             raise CommandError(f'Retrying failed: {retry_error}') from retry_error
         return command_arguments
 
+    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, SkodaVehicle):
+            raise CommandError('Object hierarchy is not as expected')
+        if not isinstance(command_arguments, dict):
+            raise CommandError('Command arguments are not a dictionary')
+        vehicle: SkodaVehicle = 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://mysmob.api.connect.skoda-auto.cz/api/v2/air-conditioning/{vin}/start-window-heating'
+                command_response: requests.Response = self.session.post(url, allow_redirects=True)
+            elif command_arguments['command'] == WindowHeatingStartStopCommand.Command.STOP:
+                url = f'https://mysmob.api.connect.skoda-auto.cz/api/v2/air-conditioning/{vin}/stop-window-heating'
+                
+                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 != requests.codes['accepted']:
+                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 Skoda 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_target_level_change(self, level_attribute: LevelAttribute, target_level: float) -> float:
+        """
+        Callback for the charging target level change.
+
+        Args:
+            level_attribute (LevelAttribute): The level attribute that changed.
+            target_level (float): The new target level.
+        """
+        if level_attribute.parent is None or level_attribute.parent.parent is None \
+                or level_attribute.parent.parent.parent is None or not isinstance(level_attribute.parent.parent.parent, SkodaVehicle):
+            raise SetterError('Object hierarchy is not as expected')
+        vehicle: SkodaVehicle = level_attribute.parent.parent.parent
+        vin: Optional[str] = vehicle.vin.value
+        if vin is None:
+            raise SetterError('VIN in object hierarchy missing')
+        precision: float = level_attribute.precision if level_attribute.precision is not None else 10.0
+        target_level = round(target_level / precision) * precision
+        setting_dict = {}
+        setting_dict['targetSOCInPercent'] = target_level
+
+        url = f'https://mysmob.api.connect.skoda-auto.cz/api/v1/charging/{vin}/set-charge-limit'
+        try:
+            settings_response: requests.Response = self.session.put(url, data=json.dumps(setting_dict), allow_redirects=True)
+            if settings_response.status_code != requests.codes['accepted']:
+                LOG.error('Could not set target level (%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 Skoda 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 target_level
+
+    def __on_charging_maximum_current_change(self, current_attribute: CurrentAttribute, maximum_current: float) -> float:
+        """
+        Callback for the charging target level change.
+
+        Args:
+            current_attribute (CurrentAttribute): The current attribute that changed.
+            maximum_current (float): The new maximum current.
+        """
+        if current_attribute.parent is None or current_attribute.parent.parent is None \
+                or current_attribute.parent.parent.parent is None or not isinstance(current_attribute.parent.parent.parent, SkodaVehicle):
+            raise SetterError('Object hierarchy is not as expected')
+        vehicle: SkodaVehicle = current_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 = current_attribute.precision if current_attribute.precision is not None else 1.0
+        maximum_current = round(maximum_current / precision) * precision
+        if maximum_current < 16:
+            setting_dict['chargingCurrent'] = "REDUCED"
+            maximum_current = 6.0
+        else:
+            setting_dict['chargingCurrent'] = "MAXIMUM"
+            maximum_current = 16.0
+
+        url = f'https://mysmob.api.connect.skoda-auto.cz/api/v1/charging/{vin}/set-charging-current'
+        try:
+            settings_response: requests.Response = self.session.put(url, data=json.dumps(setting_dict), allow_redirects=True)
+            if settings_response.status_code != requests.codes['accepted']:
+                LOG.error('Could not set target charging current (%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 Skoda 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 maximum_current
+
+    def __on_charging_auto_unlock_change(self, boolean_attribute: BooleanAttribute, auto_unlock: bool) -> bool:
+        """
+        Callback for the charging target level change.
+
+        Args:
+            boolean_attribute (BooleanAttribute): The boolean attribute that changed.
+            auto_unlock (float): The new auto_unlock setting.
+        """
+        if boolean_attribute.parent is None or boolean_attribute.parent.parent is None \
+                or boolean_attribute.parent.parent.parent is None or not isinstance(boolean_attribute.parent.parent.parent, SkodaVehicle):
+            raise SetterError('Object hierarchy is not as expected')
+        vehicle: SkodaVehicle = boolean_attribute.parent.parent.parent
+        vin: Optional[str] = vehicle.vin.value
+        if vin is None:
+            raise SetterError('VIN in object hierarchy missing')
+        setting_dict = {}
+        if auto_unlock:
+            setting_dict['autoUnlockPlug'] = "PERMANENT"
+        else:
+            setting_dict['autoUnlockPlug'] = "OFF"
+
+        url = f'https://mysmob.api.connect.skoda-auto.cz/api/v1/charging/{vin}/set-auto-unlock-plug'
+        try:
+            settings_response: requests.Response = self.session.put(url, data=json.dumps(setting_dict), allow_redirects=True)
+            if settings_response.status_code != requests.codes['accepted']:
+                LOG.error('Could not set auto unlock setting (%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 Skoda 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 auto_unlock
+
     def get_name(self) -> str:
         return "Skoda Connector"

carconnectivity_connectors/skoda/vehicle.py

@@ -30,7 +30,7 @@ class SkodaVehicle(GenericVehicle):  # pylint: disable=too-many-instance-attribu
     def __init__(self, vin: Optional[str] = None, garage: Optional[Garage] = None, managing_connector: Optional[BaseConnector] = None,
                  origin: Optional[SkodaVehicle] = 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
             self.in_motion: BooleanAttribute = origin.in_motion
@@ -55,13 +55,14 @@ class SkodaElectricVehicle(ElectricVehicle, SkodaVehicle):
     def __init__(self, vin: Optional[str] = None, garage: Optional[Garage] = None, managing_connector: Optional[BaseConnector] = None,
                  origin: Optional[SkodaVehicle] = None) -> None:
         if origin is not None:
-            super().__init__(origin=origin)
+            super().__init__(garage=garage, origin=origin)
             if isinstance(origin, ElectricVehicle):
-                self.charging: Charging = SkodaCharging(origin=origin.charging)
-                self.charging.parent = self
+                self.charging: Charging = SkodaCharging(vehicle=self, origin=origin.charging)
+            else:
+                self.charging: Charging = SkodaCharging(vehicle=self, origin=self.charging)
         else:
             super().__init__(vin=vin, garage=garage, managing_connector=managing_connector)
-            self.charging: Charging = SkodaCharging(vehicle=self)
+            self.charging: Charging = SkodaCharging(vehicle=self, origin=self.charging)
 
 
 class SkodaCombustionVehicle(CombustionVehicle, SkodaVehicle):
@@ -71,7 +72,7 @@ class SkodaCombustionVehicle(CombustionVehicle, SkodaVehicle):
     def __init__(self, vin: Optional[str] = None, garage: Optional[Garage] = None, managing_connector: Optional[BaseConnector] = None,
                  origin: Optional[SkodaVehicle] = 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)
 
@@ -83,6 +84,6 @@ class SkodaHybridVehicle(HybridVehicle, SkodaVehicle):
     def __init__(self, vin: Optional[str] = None, garage: Optional[Garage] = None, managing_connector: Optional[BaseConnector] = None,
                  origin: Optional[SkodaVehicle] = 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)