carconnectivity-connector-skoda 0.1a22__py3-none-any.whl → 0.2a2__py3-none-any.whl

{carconnectivity_connector_skoda-0.1a22.dist-info → carconnectivity_connector_skoda-0.2a2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: carconnectivity-connector-skoda
-Version: 0.1a22
+Version: 0.2a2
 Summary: CarConnectivity connector for Skoda services
 Author: Till Steinbach
 License: MIT License
@@ -37,7 +37,7 @@ Classifier: Topic :: Software Development :: Libraries
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: carconnectivity
+Requires-Dist: carconnectivity>=0.2
 Requires-Dist: oauthlib~=3.2.2
 Requires-Dist: requests~=2.32.3
 Requires-Dist: jwt~=1.3.1

{carconnectivity_connector_skoda-0.1a22.dist-info → carconnectivity_connector_skoda-0.2a2.dist-info}/RECORD

@@ -1,13 +1,13 @@
 carconnectivity_connectors/skoda/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-carconnectivity_connectors/skoda/_version.py,sha256=HEdZtBITW7HcUEt9NLSPGn_UorBnRBrHZWl8fmngNs8,409
-carconnectivity_connectors/skoda/capability.py,sha256=JlNEaisVYF8qWv0wNDHTaas36uIpTIQ3NVR69wesiYQ,4513
+carconnectivity_connectors/skoda/_version.py,sha256=K5FRuDp7oE3vVzMAjjBq7gz8WRnAzHih0vG_csLk83E,408
+carconnectivity_connectors/skoda/capability.py,sha256=SnK9xVsqDA5EcWtBznzfWxe6gIpkYdjgY3UzNIc3OCY,4198
 carconnectivity_connectors/skoda/charging.py,sha256=rG_GoDPetjyjWCyV6l65hgEDU6ths6MkMQ0KL25rbVU,6663
 carconnectivity_connectors/skoda/climatization.py,sha256=-Nk4tO5C5_YYNQfUIUWBL7mGgR6-J0_pOZplLK8p_ms,1627
-carconnectivity_connectors/skoda/command_impl.py,sha256=dtJsiuhwSuR1PXz7AMrdBowHqPxw6DKSAQKk4Z63GG8,2957
-carconnectivity_connectors/skoda/connector.py,sha256=rMHAigH9t1P95vGewKxK54umBuqkI6-zFQYw5iPeols,118916
+carconnectivity_connectors/skoda/command_impl.py,sha256=WdgxWPgi82-UgmyFpiSZE-KHRtRjqn7CH-YX9N3bAoI,2875
+carconnectivity_connectors/skoda/connector.py,sha256=g4G9u8xE3iG6ASy7sGSXimaJ3zFV04E9GrNn5TB0ia4,105140
 carconnectivity_connectors/skoda/error.py,sha256=EnzzDxxJ1fswYT5QnMOVSebfoAcqoPmHKcG5i0Tqk3E,2405
 carconnectivity_connectors/skoda/mqtt_client.py,sha256=lfHJfKOl-FBVd5hV6cS6ZMpZ53ktXyVc4lafvQls-Tk,37748
-carconnectivity_connectors/skoda/vehicle.py,sha256=JKLqb6F4RyJ4C3D_sc6kcsdlqxZSlmdJNQfW04m7u78,3204
+carconnectivity_connectors/skoda/vehicle.py,sha256=_ALtlBy7sKVHmqpqAhWNbMd9dto915_SdNWcRi_AqYU,3088
 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
@@ -15,8 +15,8 @@ carconnectivity_connectors/skoda/auth/openid_session.py,sha256=LusWi2FZZIL3buodG
 carconnectivity_connectors/skoda/auth/session_manager.py,sha256=Uf1vujuDBYUCAXhYToOsZkgbTtfmY3Qe0ICTfwomBpI,2899
 carconnectivity_connectors/skoda/auth/skoda_web_session.py,sha256=cjzMkzx473Sh-4RgZAQULeRRcxB1MboddldCVM_y5LE,10640
 carconnectivity_connectors/skoda/auth/helpers/blacklist_retry.py,sha256=f3wsiY5bpHDBxp7Va1Mv9nKJ4u3qnCHZZmDu78_AhMk,1251
-carconnectivity_connector_skoda-0.1a22.dist-info/LICENSE,sha256=PIwI1alwDyOfvEQHdGCm2u9uf_mGE8030xZDfun0xTo,1071
-carconnectivity_connector_skoda-0.1a22.dist-info/METADATA,sha256=d5o6lGEA7DgbRIAn0be_LDLiLLXOIOmkGRcAdwodadw,5327
-carconnectivity_connector_skoda-0.1a22.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-carconnectivity_connector_skoda-0.1a22.dist-info/top_level.txt,sha256=KqA8GviZsDH4PtmnwSQsz0HB_w-TWkeEHLIRNo5dTaI,27
-carconnectivity_connector_skoda-0.1a22.dist-info/RECORD,,
+carconnectivity_connector_skoda-0.2a2.dist-info/LICENSE,sha256=PIwI1alwDyOfvEQHdGCm2u9uf_mGE8030xZDfun0xTo,1071
+carconnectivity_connector_skoda-0.2a2.dist-info/METADATA,sha256=t2d6yjpItOO8uvEmSK53fb2YoxQ7RK3TLBQ3x9YmHdw,5331
+carconnectivity_connector_skoda-0.2a2.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+carconnectivity_connector_skoda-0.2a2.dist-info/top_level.txt,sha256=KqA8GviZsDH4PtmnwSQsz0HB_w-TWkeEHLIRNo5dTaI,27
+carconnectivity_connector_skoda-0.2a2.dist-info/RECORD,,

carconnectivity_connectors/skoda/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.1a22'
-__version_tuple__ = version_tuple = (0, 1)
+__version__ = version = '0.2a2'
+__version_tuple__ = version_tuple = (0, 2)

carconnectivity_connectors/skoda/capability.py

@@ -89,12 +89,6 @@ class Capabilities(GenericObject):
         """
         return capability_id in self.__capabilities
 
-    def __str__(self) -> str:
-        return_string = 'Capabilities:\n'
-        for capability in self.__capabilities.values():
-            return_string += f'\t{capability}\n'
-        return return_string
-
 
 class Capability(GenericObject):
     """
@@ -113,10 +107,6 @@ class Capability(GenericObject):
         self.enabled = True
         self.delay_notifications = False
 
-    def __str__(self) -> str:
-        return_string = f'{self.capability_id}'
-        return return_string
-
     class Status(IntEnum):
         """
         Enum for capability status.

carconnectivity_connectors/skoda/command_impl.py

@@ -14,14 +14,12 @@ from carconnectivity.util import ThrowingArgumentParser
 if TYPE_CHECKING:
     from carconnectivity.objects import Optional
 
-LOG: logging.Logger = logging.getLogger("carconnectivity")
+LOG: logging.Logger = logging.getLogger("carconnectivity.connectors.skoda")
 
 
 class SpinCommand(GenericCommand):
     """
-    LockUnlockCommand is a command class for locking and unlocking the vehicle.
-
-    Command (Enum): Enum class representing different commands for locking.
+    SpinCommand is a command class for verifying the spin
 
     """
     def __init__(self, name: str = 'spin', parent: Optional[GenericObject] = None) -> None:

carconnectivity_connectors/skoda/connector.py

@@ -15,7 +15,7 @@ import requests
 from carconnectivity.garage import Garage
 from carconnectivity.vehicle import GenericVehicle
 from carconnectivity.errors import AuthenticationError, TooManyRequestsError, RetrievalError, APIError, APICompatibilityError, \
-    TemporaryAuthenticationError, ConfigurationError, SetterError
+    TemporaryAuthenticationError, ConfigurationError, SetterError, CommandError
 from carconnectivity.util import robust_time_parse, log_extra_keys, config_remove_credentials
 from carconnectivity.units import Length, Speed, Power, Temperature
 from carconnectivity.doors import Doors
@@ -28,7 +28,7 @@ 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
+from carconnectivity.command_impl import ClimatizationStartStopCommand, ChargingStartStopCommand, HonkAndFlashCommand, LockUnlockCommand, WakeSleepCommand
 
 from carconnectivity_connectors.base.connector import BaseConnector
 from carconnectivity_connectors.skoda.auth.session_manager import SessionManager, SessionUser, Service
@@ -255,6 +255,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()
 
@@ -362,7 +368,7 @@ class Connector(BaseConnector):
         url = f'https://mysmob.api.connect.skoda-auto.cz/api/v1/charging/{vin}'
         data: Dict[str, Any] | None = self._fetch_data(url=url, session=self.session, no_cache=no_cache)
         if data is not None:
-            if not vehicle.climatization.commands.contains_command('start-stop'):
+            if not vehicle.charging.commands.contains_command('start-stop'):
                 start_stop_command: ChargingStartStopCommand = ChargingStartStopCommand(parent=vehicle.charging.commands)
                 start_stop_command._add_on_set_hook(self.__on_charging_start_stop)  # pylint: disable=protected-access
                 start_stop_command.enabled = True
@@ -887,6 +893,14 @@ class Connector(BaseConnector):
             else:
                 vehicle.capabilities.clear_capabilities()
 
+            if vehicle.capabilities.has_capability('VEHICLE_WAKE_UP_TRIGGER'):
+                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 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.commands is not None and vehicle.commands.commands is not None \
@@ -905,14 +919,6 @@ class Connector(BaseConnector):
                     lock_unlock_command.enabled = True
                     vehicle.doors.commands.add_command(lock_unlock_command)
 
-            # Add spin command
-            if vehicle.commands is not None and vehicle.commands.commands is not None \
-                    and not vehicle.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
-                vehicle.commands.add_command(spin_command)
-
             if 'specification' in vehicle_data and vehicle_data['specification'] is not None:
                 if 'model' in vehicle_data['specification'] and vehicle_data['specification']['model'] is not None:
                     vehicle.model._set_value(vehicle_data['specification']['model'])  # pylint: disable=protected-access
@@ -1128,187 +1134,6 @@ class Connector(BaseConnector):
             log_extra_keys(LOG_API, f'/api/v2/vehicle-status/{vin}', vehicle_status_data, {'overall', 'carCapturedTimestamp'})
         return vehicle
 
-        # def fetch_vehicle_status_second_api(self, vehicle: SkodaVehicle, no_cache: bool = False) -> SkodaVehicle:
-        #     """
-        #     Fetches the status of a vehicle from other Skoda API.
-        #
-        #     Args:
-        #         vehicle (GenericVehicle): The vehicle object containing the VIN.
-        #
-        #     Returns:
-        #         None
-        #     """
-        #     vin = vehicle.vin.value
-        #     if vin is None:
-        #         raise APIError('VIN is missing')
-        #     url = f'https://api.connect.skoda-auto.cz/api/v2/vehicle-status/{vin}'
-        #     vehicle_status_data: Dict[str, Any] | None = self._fetch_data(url=url, session=self.session, no_cache=no_cache)
-        #     if vehicle_status_data:
-        #         if 'remote' in vehicle_status_data and vehicle_status_data['remote'] is not None:
-        #             vehicle_status_data = vehicle_status_data['remote']
-        #     if vehicle_status_data:
-        #         if 'capturedAt' in vehicle_status_data and vehicle_status_data['capturedAt'] is not None:
-        #             captured_at: datetime = robust_time_parse(vehicle_status_data['capturedAt'])
-        #         else:
-        #             raise APIError('Could not fetch vehicle status, capturedAt missing')
-        #         if 'mileageInKm' in vehicle_status_data and vehicle_status_data['mileageInKm'] is not None:
-        #             # pylint: disable-next=protected-access
-        #             vehicle.odometer._set_value(value=vehicle_status_data['mileageInKm'], measured=captured_at, unit=Length.KM)
-        #         else:
-        #             vehicle.odometer._set_value(value=None, measured=captured_at, unit=Length.KM)  # pylint: disable=protected-access
-        #         if 'status' in vehicle_status_data and vehicle_status_data['status'] is not None:
-        #             if 'open' in vehicle_status_data['status'] and vehicle_status_data['status']['open'] is not None:
-        #                 if vehicle_status_data['status']['open'] == 'YES':
-        #                     vehicle.doors.open_state._set_value(Doors.OpenState.OPEN, measured=captured_at)  # pylint: disable=protected-access
-        #                 elif vehicle_status_data['status']['open'] == 'NO':
-        #                     vehicle.doors.open_state._set_value(Doors.OpenState.CLOSED, measured=captured_at)  # pylint: disable=protected-access
-        #                 else:
-        #                     vehicle.doors.open_state._set_value(Doors.OpenState.UNKNOWN, measured=captured_at)  # pylint: disable=protected-access
-        #                     LOG_API.info('Unknown door open state: %s', vehicle_status_data['status']['open'])
-        #             else:
-        #                 vehicle.doors.open_state._set_value(None, measured=captured_at)  # pylint: disable=protected-access
-        #             if 'locked' in vehicle_status_data['status'] and vehicle_status_data['status']['locked'] is not None:
-        #                 if vehicle_status_data['status']['locked'] == 'YES':
-        #                     vehicle.doors.lock_state._set_value(Doors.LockState.LOCKED, measured=captured_at)  # pylint: disable=protected-access
-        #                 elif vehicle_status_data['status']['locked'] == 'NO':
-        #                     vehicle.doors.lock_state._set_value(Doors.LockState.UNLOCKED, measured=captured_at)  # pylint: disable=protected-access
-        #                 else:
-        #                     vehicle.doors.lock_state._set_value(Doors.LockState.UNKNOWN, measured=captured_at)  # pylint: disable=protected-access
-        #                     LOG_API.info('Unknown door lock state: %s', vehicle_status_data['status']['locked'])
-        #             else:
-        #                 vehicle.doors.lock_state._set_value(None, measured=captured_at)  # pylint: disable=protected-access
-        #         else:
-        #             vehicle.doors.open_state._set_value(None, measured=captured_at)  # pylint: disable=protected-access
-        #             vehicle.doors.lock_state._set_value(None, measured=captured_at)  # pylint: disable=protected-access
-        #         if 'doors' in vehicle_status_data and vehicle_status_data['doors'] is not None:
-        #             seen_door_ids: set[str] = set()
-        #             for door_status in vehicle_status_data['doors']:
-        #                 if 'name' in door_status and door_status['name'] is not None:
-        #                     door_id = door_status['name']
-        #                     seen_door_ids.add(door_id)
-        #                     if door_id in vehicle.doors.doors:
-        #                         door: Doors.Door = vehicle.doors.doors[door_id]
-        #                     else:
-        #                         door = Doors.Door(door_id=door_id, doors=vehicle.doors)
-        #                         vehicle.doors.doors[door_id] = door
-        #                     if 'status' in door_status and door_status['status'] is not None:
-        #                         if door_status['status'] == 'OPEN':
-        #                             door.lock_state._set_value(Doors.LockState.UNLOCKED, measured=captured_at)  # pylint: disable=protected-access
-        #                             door.open_state._set_value(Doors.OpenState.OPEN, measured=captured_at)  # pylint: disable=protected-access
-        #                         elif door_status['status'] == 'CLOSED':
-        #                             door.lock_state._set_value(Doors.LockState.UNKNOWN, measured=captured_at)  # pylint: disable=protected-access
-        #                             door.open_state._set_value(Doors.OpenState.CLOSED, measured=captured_at)  # pylint: disable=protected-access
-        #                         elif door_status['status'] == 'LOCKED':
-        #                             door.lock_state._set_value(Doors.LockState.LOCKED, measured=captured_at)  # pylint: disable=protected-access
-        #                             door.open_state._set_value(Doors.OpenState.CLOSED, measured=captured_at)  # pylint: disable=protected-access
-        #                         elif door_status['status'] == 'UNSUPPORTED':
-        #                             door.lock_state._set_value(Doors.LockState.UNKNOWN, measured=captured_at)  # pylint: disable=protected-access
-        #                             door.open_state._set_value(Doors.OpenState.UNKNOWN, measured=captured_at)  # pylint: disable=protected-access
-        #                         else:
-        #                             LOG_API.info('Unknown door status %s', door_status['status'])
-        #                             door.lock_state._set_value(Doors.LockState.UNKNOWN, measured=captured_at)  # pylint: disable=protected-access
-        #                             door.open_state._set_value(Doors.OpenState.UNKNOWN, measured=captured_at)  # pylint: disable=protected-access
-        #                     else:
-        #                         door.lock_state._set_value(None, measured=captured_at)  # pylint: disable=protected-access
-        #                         door.open_state._set_value(None, measured=captured_at)  # pylint: disable=protected-access
-        #                 else:
-        #                     raise APIError('Could not parse door, name missing')
-        #                 log_extra_keys(LOG_API, 'doors', door_status, {'name', 'status'})
-        #             for door_to_remove in set(vehicle.doors.doors) - seen_door_ids:
-        #                 vehicle.doors.doors[door_to_remove].enabled = False
-        #                 vehicle.doors.doors.pop(door_to_remove)
-        #             log_extra_keys(LOG_API, 'status', vehicle_status_data['status'],  {'open', 'locked'})
-        #         else:
-        #             vehicle.doors.open_state._set_value(None, measured=captured_at)  # pylint: disable=protected-access
-        #             vehicle.doors.doors = {}
-        #         if 'windows' in vehicle_status_data and vehicle_status_data['windows'] is not None:
-        #             seen_window_ids: set[str] = set()
-        #             all_windows_closed: bool = True
-        #             for window_status in vehicle_status_data['windows']:
-        #                 if 'name' in window_status and window_status['name'] is not None:
-        #                     window_id = window_status['name']
-        #                     seen_window_ids.add(window_id)
-        #                     if window_id in vehicle.windows.windows:
-        #                         window: Windows.Window = vehicle.windows.windows[window_id]
-        #                     else:
-        #                         window = Windows.Window(window_id=window_id, windows=vehicle.windows)
-        #                         vehicle.windows.windows[window_id] = window
-        #                     if 'status' in window_status and window_status['status'] is not None:
-        #                         if window_status['status'] == 'OPEN':
-        #                             all_windows_closed = False
-        #                             window.open_state._set_value(Windows.OpenState.OPEN, measured=captured_at)  # pylint: disable=protected-access
-        #                         elif window_status['status'] == 'CLOSED':
-        #                             window.open_state._set_value(Windows.OpenState.CLOSED, measured=captured_at)  # pylint: disable=protected-access
-        #                         elif window_status['status'] == 'UNSUPPORTED':
-        #                             window.open_state._set_value(Windows.OpenState.UNSUPPORTED, measured=captured_at)  # pylint: disable=protected-access
-        #                         elif window_status['status'] == 'INVALID':
-        #                             window.open_state._set_value(Windows.OpenState.INVALID, measured=captured_at)  # pylint: disable=protected-access
-        #                         else:
-        #                             LOG_API.info('Unknown window status %s', window_status['status'])
-        #                             window.open_state._set_value(Windows.OpenState.UNKNOWN, measured=captured_at)  # pylint: disable=protected-access
-        #                     else:
-        #                         window.open_state._set_value(None, measured=captured_at)  # pylint: disable=protected-access
-        #                 else:
-        #                     raise APIError('Could not parse window, name missing')
-        #                 log_extra_keys(LOG_API, 'doors', window_status, {'name', 'status'})
-        #             for window_to_remove in set(vehicle.windows.windows) - seen_window_ids:
-        #                 vehicle.windows.windows[window_to_remove].enabled = False
-        #                 vehicle.windows.windows.pop(window_to_remove)
-        #             if all_windows_closed:
-        #                 vehicle.windows.open_state._set_value(Windows.OpenState.CLOSED, measured=captured_at)  # pylint: disable=protected-access
-        #             else:
-        #                 vehicle.windows.open_state._set_value(Windows.OpenState.OPEN, measured=captured_at)  # pylint: disable=protected-access
-        #         else:
-        #             vehicle.windows.open_state._set_value(None, measured=captured_at)  # pylint: disable=protected-access
-        #             vehicle.windows.windows = {}
-        #         if 'lights' in vehicle_status_data and vehicle_status_data['lights'] is not None:
-        #             seen_light_ids: set[str] = set()
-        #             if 'overallStatus' in vehicle_status_data['lights'] and vehicle_status_data['lights']['overallStatus'] is not None:
-        #                 if vehicle_status_data['lights']['overallStatus'] == 'ON':
-        #                     vehicle.lights.light_state._set_value(Lights.LightState.ON, measured=captured_at)  # pylint: disable=protected-access
-        #                 elif vehicle_status_data['lights']['overallStatus'] == 'OFF':
-        #                     vehicle.lights.light_state._set_value(Lights.LightState.OFF, measured=captured_at)  # pylint: disable=protected-access
-        #                 elif vehicle_status_data['lights']['overallStatus'] == 'INVALID':
-        #                     vehicle.lights.light_state._set_value(Lights.LightState.INVALID, measured=captured_at)  # pylint: disable=protected-access
-        #                 else:
-        #                     LOG_API.info('Unknown light status %s', vehicle_status_data['lights']['overallStatus'])
-        #                     vehicle.lights.light_state._set_value(Lights.LightState.UNKNOWN, measured=captured_at)  # pylint: disable=protected-access
-        #             else:
-        #                 vehicle.lights.light_state._set_value(None, measured=captured_at)  # pylint: disable=protected-access
-        #             if 'lightsStatus' in vehicle_status_data['lights'] and vehicle_status_data['lights']['lightsStatus'] is not None:
-        #                 for light_status in vehicle_status_data['lights']['lightsStatus']:
-        #                     if 'name' in light_status and light_status['name'] is not None:
-        #                         light_id: str = light_status['name']
-        #                         seen_light_ids.add(light_id)
-        #                         if light_id in vehicle.lights.lights:
-        #                             light: Lights.Light = vehicle.lights.lights[light_id]
-        #                         else:
-        #                             light = Lights.Light(light_id=light_id, lights=vehicle.lights)
-        #                             vehicle.lights.lights[light_id] = light
-        #                         if 'status' in light_status and light_status['status'] is not None:
-        #                             if light_status['status'] == 'ON':
-        #                                 light.light_state._set_value(Lights.LightState.ON, measured=captured_at)  # pylint: disable=protected-access
-        #                             elif light_status['status'] == 'OFF':
-        #                                 light.light_state._set_value(Lights.LightState.OFF, measured=captured_at)  # pylint: disable=protected-access
-        #                             elif light_status['status'] == 'INVALID':
-        #                                 light.light_state._set_value(Lights.LightState.INVALID, measured=captured_at)  # pylint: disable=protected-access
-        #                             else:
-        #                                 LOG_API.info('Unknown light status %s', light_status['status'])
-        #                                 light.light_state._set_value(Lights.LightState.UNKNOWN, measured=captured_at)  # pylint: disable=protected-access
-        #                         else:
-        #                             light.light_state._set_value(None, measured=captured_at)  # pylint: disable=protected-access
-        #                     else:
-        #                         raise APIError('Could not parse light, name missing')
-        #                     log_extra_keys(LOG_API, 'lights', light_status, {'name', 'status'})
-        #                 for light_to_remove in set(vehicle.lights.lights) - seen_light_ids:
-        #                     vehicle.lights.lights[light_to_remove].enabled = False
-        #                     vehicle.lights.lights.pop(light_to_remove)
-        #             else:
-        #                 vehicle.lights.lights = {}
-        #             log_extra_keys(LOG_API, 'lights', vehicle_status_data['lights'], {'overallStatus', 'lightsStatus'})
-        #         log_extra_keys(LOG_API, 'vehicles', vehicle_status_data,  {'capturedAt', 'mileageInKm', 'status', 'doors', 'windows', 'lights'})
-        #     return vehicle
-
     def _record_elapsed(self, elapsed: timedelta) -> None:
         """
         Records the elapsed time.
@@ -1445,15 +1270,15 @@ class Connector(BaseConnector):
             -> 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 SetterError('Object hierarchy is not as expected')
+            raise CommandError('Object hierarchy is not as expected')
         if not isinstance(command_arguments, dict):
-            raise SetterError('Command arguments are not a dictionary')
+            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 SetterError('VIN in object hierarchy missing')
+            raise CommandError('VIN in object hierarchy missing')
         if 'command' not in command_arguments:
-            raise SetterError('Command argument missing')
+            raise CommandError('Command argument missing')
         command_dict = {}
         if command_arguments['command'] == ClimatizationStartStopCommand.Command.START:
             command_dict['heaterSource'] = 'ELECTRIC'
@@ -1463,7 +1288,7 @@ class Connector(BaseConnector):
                 command_dict['targetTemperature']['temperatureValue'] = round(command_arguments['target_temperature'] * 2) / 2
                 if 'target_temperature_unit' in command_arguments:
                     if not isinstance(command_arguments['target_temperature_unit'], Temperature):
-                        raise SetterError('Temperature unit is not of type Temperature')
+                        raise CommandError('Temperature unit is not of type Temperature')
                     if command_arguments['target_temperature_unit'] == Temperature.C:
                         command_dict['targetTemperature']['unitInCar'] = 'CELSIUS'
                     elif command_arguments['target_temperature_unit'] == Temperature.F:
@@ -1471,7 +1296,7 @@ class Connector(BaseConnector):
                     elif command_arguments['target_temperature_unit'] == Temperature.K:
                         command_dict['targetTemperature']['unitInCar'] = 'KELVIN'
                     else:
-                        raise SetterError(f'Unknown temperature unit {command_arguments['target_temperature_unit']}')
+                        raise CommandError(f'Unknown temperature unit {command_arguments["target_temperature_unit"]}')
                 else:
                     command_dict['targetTemperature']['unitInCar'] = 'CELSIUS'
             elif start_stop_command.parent is not None and (climatization := start_stop_command.parent.parent) is not None \
@@ -1487,7 +1312,7 @@ class Connector(BaseConnector):
                 elif climatization.settings.target_temperature.unit == Temperature.K:
                     command_dict['targetTemperature']['unitInCar'] = 'KELVIN'
                 else:
-                    raise SetterError(f'Unknown temperature unit {climatization.settings.target_temperature.unit}')
+                    raise CommandError(f'Unknown temperature unit {climatization.settings.target_temperature.unit}')
             else:
                 command_dict['targetTemperature']['temperatureValue'] = 25.0
                 command_dict['targetTemperature']['unitInCar'] = 'CELSIUS'
@@ -1497,26 +1322,26 @@ class Connector(BaseConnector):
             url = f'https://mysmob.api.connect.skoda-auto.cz/api/v2/air-conditioning/{vin}/stop'
             command_response: requests.Response = self.session.post(url, allow_redirects=True)
         else:
-            raise SetterError(f'Unknown command {command_arguments["command"]}')
+            raise CommandError(f'Unknown command {command_arguments["command"]}')
 
         if command_response.status_code != requests.codes['accepted']:
             LOG.error('Could not start/stop air conditioning (%s: %s)', command_response.status_code, command_response.text)
-            raise SetterError(f'Could not start/stop air conditioning ({command_response.status_code}: {command_response.text})')
+            raise CommandError(f'Could not start/stop air conditioning ({command_response.status_code}: {command_response.text})')
         return command_arguments
 
     def __on_charging_start_stop(self, start_stop_command: ChargingStartStopCommand, 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 SetterError('Object hierarchy is not as expected')
+            raise CommandError('Object hierarchy is not as expected')
         if not isinstance(command_arguments, dict):
-            raise SetterError('Command arguments are not a dictionary')
+            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 SetterError('VIN in object hierarchy missing')
+            raise CommandError('VIN in object hierarchy missing')
         if 'command' not in command_arguments:
-            raise SetterError('Command argument missing')
+            raise CommandError('Command argument missing')
         if command_arguments['command'] == ChargingStartStopCommand.Command.START:
             url = f'https://mysmob.api.connect.skoda-auto.cz/api/v1/charging/{vin}/start'
             command_response: requests.Response = self.session.post(url, allow_redirects=True)
@@ -1524,26 +1349,28 @@ class Connector(BaseConnector):
             url = f'https://mysmob.api.connect.skoda-auto.cz/api/v1/charging/{vin}/stop'
             command_response: requests.Response = self.session.post(url, allow_redirects=True)
         else:
-            raise SetterError(f'Unknown command {command_arguments["command"]}')
+            raise CommandError(f'Unknown command {command_arguments["command"]}')
 
         if command_response.status_code != requests.codes['accepted']:
             LOG.error('Could not start/stop charging (%s: %s)', command_response.status_code, command_response.text)
-            raise SetterError(f'Could not start/stop charging ({command_response.status_code}: {command_response.text})')
+            raise CommandError(f'Could not start/stop charging ({command_response.status_code}: {command_response.text})')
         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, SkodaVehicle):
-            raise SetterError('Object hierarchy is not as expected')
+            raise CommandError('Object hierarchy is not as expected')
         if not isinstance(command_arguments, dict):
-            raise SetterError('Command arguments are not a dictionary')
+            raise CommandError('Command arguments are not a dictionary')
         vehicle: SkodaVehicle = honk_flash_command.parent.parent
         vin: Optional[str] = vehicle.vin.value
         if vin is None:
-            raise SetterError('VIN in object hierarchy missing')
+            raise CommandError('VIN in object hierarchy missing')
         if 'command' not in command_arguments:
-            raise SetterError('Command argument missing')
+            raise CommandError('Command argument missing')
+        if 'duration' in command_arguments:
+            LOG.warning('Duration argument is not supported by the Skoda API')
         command_dict = {}
         if command_arguments['command'] in [HonkAndFlashCommand.Command.FLASH, HonkAndFlashCommand.Command.HONK_AND_FLASH]:
             command_dict['mode'] = command_arguments['command'].name
@@ -1551,7 +1378,7 @@ class Connector(BaseConnector):
             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 SetterError('Can only execute honk and flash commands if vehicle position is known')
+                raise CommandError('Can only execute honk and flash commands if vehicle position is known')
             command_dict['vehiclePosition']['latitude'] = vehicle.position.latitude.value
             command_dict['vehiclePosition']['longitude'] = vehicle.position.longitude.value
 
@@ -1559,72 +1386,93 @@ class Connector(BaseConnector):
             command_response: requests.Response = self.session.post(url, data=json.dumps(command_dict), allow_redirects=True)
             if command_response.status_code != requests.codes['accepted']:
                 LOG.error('Could not execute honk or flash command (%s: %s)', command_response.status_code, command_response.text)
-                raise SetterError(f'Could not execute honk or flash command ({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 SetterError(f'Unknown command {command_arguments["command"]}')
+            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, SkodaVehicle):
-            raise SetterError('Object hierarchy is not as expected')
+            raise CommandError('Object hierarchy is not as expected')
         if not isinstance(command_arguments, dict):
             raise SetterError('Command arguments are not a dictionary')
         vehicle: SkodaVehicle = lock_unlock_command.parent.parent.parent
         vin: Optional[str] = vehicle.vin.value
         if vin is None:
-            raise SetterError('VIN in object hierarchy missing')
+            raise CommandError('VIN in object hierarchy missing')
         if 'command' not in command_arguments:
-            raise SetterError('Command argument missing')
+            raise CommandError('Command argument missing')
         command_dict = {}
         if 'spin' in command_arguments:
             command_dict['currentSpin'] = command_arguments['spin']
         else:
             if self._spin is None:
-                raise SetterError('S-PIN is missing, please add S-PIN to your configuration or .netrc file')
+                raise CommandError('S-PIN is missing, please add S-PIN to your configuration or .netrc file')
             command_dict['currentSpin'] = self._spin
         if command_arguments['command'] == LockUnlockCommand.Command.LOCK:
             url = f'https://mysmob.api.connect.skoda-auto.cz/api/v1/vehicle-access/{vin}/lock'
         elif command_arguments['command'] == LockUnlockCommand.Command.UNLOCK:
             url = f'https://mysmob.api.connect.skoda-auto.cz/api/v1/vehicle-access/{vin}/unlock'
         else:
-            raise SetterError(f'Unknown command {command_arguments["command"]}')
+            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['accepted']:
             LOG.error('Could not execute locking command (%s: %s)', command_response.status_code, command_response.text)
-            raise SetterError(f'Could not execute locking command ({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_spin(self, spin_command: SpinCommand, command_arguments: Union[str, Dict[str, Any]]) \
+    def __on_wake_sleep(self, wake_sleep_command: WakeSleepCommand, command_arguments: Union[str, Dict[str, Any]]) \
             -> Union[str, Dict[str, Any]]:
-        if spin_command.parent is None or spin_command.parent.parent is None or not isinstance(spin_command.parent.parent, SkodaVehicle):
-            raise SetterError('Object hierarchy is not as expected')
+        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 SetterError('Command arguments are not a dictionary')
-        vehicle: SkodaVehicle = spin_command.parent.parent
+            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 SetterError('VIN in object hierarchy missing')
+            raise CommandError('VIN in object hierarchy missing')
         if 'command' not in command_arguments:
-            raise SetterError('Command argument missing')
+            raise CommandError('Command argument missing')
+        if command_arguments['command'] == WakeSleepCommand.Command.WAKE:
+            url = f'https://mysmob.api.connect.skoda-auto.cz/api/v1/vehicle-wakeup/{vin}?applyRequestLimiter=true'
+
+            command_response: requests.Response = self.session.post(url, data='{}', allow_redirects=True)
+            if command_response.status_code != requests.codes['accepted']:
+                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_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._spin is None:
-            raise SetterError('S-PIN is missing, please add S-PIN to your configuration or .netrc file')
+            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._spin is None:
-                raise SetterError('S-PIN is missing, please add S-PIN to your configuration or .netrc file')
+            if self._spin is None or self._spin == '':
+                raise CommandError('S-PIN is missing, please add S-PIN to your configuration or .netrc file')
             command_dict['currentSpin'] = self._spin
         if command_arguments['command'] == SpinCommand.Command.VERIFY:
-            url = 'https://mysmob.api.connect.skoda-auto.cz/v1/spin/verify'
+            url = 'https://mysmob.api.connect.skoda-auto.cz/api/v1/spin/verify'
         else:
-            raise SetterError(f'Unknown command {command_arguments["command"]}')
+            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['accepted']:
+        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 SetterError(f'Could not execute spin command ({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

carconnectivity_connectors/skoda/vehicle.py

@@ -29,10 +29,6 @@ class SkodaVehicle(GenericVehicle):  # pylint: disable=too-many-instance-attribu
             self.capabilities = Capabilities(vehicle=self)
         self.manufacturer._set_value(value='Škoda')  # pylint: disable=protected-access
 
-    def __str__(self) -> str:
-        return_string: str = f'\t{self.capabilities}\n'
-        return return_string
-
 
 class SkodaElectricVehicle(ElectricVehicle, SkodaVehicle):
     """