carconnectivity-connector-skoda 0.2a5__py3-none-any.whl → 0.4__py3-none-any.whl

{carconnectivity_connector_skoda-0.2a5.dist-info → carconnectivity_connector_skoda-0.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: carconnectivity-connector-skoda
-Version: 0.2a5
+Version: 0.4
 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>=0.3a2
+Requires-Dist: carconnectivity>=0.4
 Requires-Dist: oauthlib~=3.2.2
 Requires-Dist: requests~=2.32.3
 Requires-Dist: jwt~=1.3.1

carconnectivity_connector_skoda-0.4.dist-info/RECORD

@@ -0,0 +1,23 @@
+carconnectivity_connectors/skoda/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+carconnectivity_connectors/skoda/_version.py,sha256=z4A7Ai6QyXWBOpaj5g4Fi0n9CYi27WfJ6gm02OiXBxE,506
+carconnectivity_connectors/skoda/capability.py,sha256=vbAKK8KKre-CndLF6_5qyWLpfa4KZHk1U-hpb6nCL5w,4225
+carconnectivity_connectors/skoda/charging.py,sha256=CoUOYHHUPPPldKQvv0h-qrUsoEtstR3iUx-l0IU5rNM,6798
+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/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/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
+carconnectivity_connectors/skoda/auth/openid_session.py,sha256=5JfR-gS1uKpE8DD-sx5Qvw6zv-OJhzcRlt0D-cm38-Y,16832
+carconnectivity_connectors/skoda/auth/session_manager.py,sha256=Uf1vujuDBYUCAXhYToOsZkgbTtfmY3Qe0ICTfwomBpI,2899
+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.4.dist-info/LICENSE,sha256=PIwI1alwDyOfvEQHdGCm2u9uf_mGE8030xZDfun0xTo,1071
+carconnectivity_connector_skoda-0.4.dist-info/METADATA,sha256=mgi4p5xjlB5jJxeBIm3W3vZnkBjXuaCT8ZdRIDFA--g,5361
+carconnectivity_connector_skoda-0.4.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
+carconnectivity_connector_skoda-0.4.dist-info/top_level.txt,sha256=KqA8GviZsDH4PtmnwSQsz0HB_w-TWkeEHLIRNo5dTaI,27
+carconnectivity_connector_skoda-0.4.dist-info/RECORD,,

{carconnectivity_connector_skoda-0.2a5.dist-info → carconnectivity_connector_skoda-0.4.dist-info}/WHEEL

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

carconnectivity_connectors/skoda/_version.py

@@ -1,8 +1,13 @@
-# file generated by setuptools_scm
+# file generated by setuptools-scm
 # don't change, don't track in version control
+
+__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+
 TYPE_CHECKING = False
 if TYPE_CHECKING:
-    from typing import Tuple, Union
+    from typing import Tuple
+    from typing import Union
+
     VERSION_TUPLE = Tuple[Union[int, str], ...]
 else:
     VERSION_TUPLE = object
@@ -12,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.2a5'
-__version_tuple__ = version_tuple = (0, 2)
+__version__ = version = '0.4'
+__version_tuple__ = version_tuple = (0, 4)

carconnectivity_connectors/skoda/auth/skoda_web_session.py

@@ -121,6 +121,8 @@ class SkodaWebSession(OpenIDSession):
                 raise RetrievalError('Temporary server error during login')
 
             if 'Location' not in response.headers:
+                if 'consent' in url:
+                    raise AuthenticationError('Could not find Location in headers, probably due to missing consent. Try visiting: ' + url)
                 raise APICompatibilityError('Forwarding without Location in headers')
 
             url = response.headers['Location']

carconnectivity_connectors/skoda/climatization.py

@@ -1,12 +1,12 @@
 """
-Module for charging for skoda vehicles.
+Module for climatization for skoda vehicles.
 """
 from __future__ import annotations
 from typing import TYPE_CHECKING
 
 from carconnectivity.climatization import Climatization
 from carconnectivity.objects import GenericObject
-from carconnectivity.vehicle import ElectricVehicle
+from carconnectivity.vehicle import GenericVehicle
 
 from carconnectivity_connectors.skoda.error import Error
 
@@ -21,13 +21,15 @@ class SkodaClimatization(Climatization):  # pylint: disable=too-many-instance-at
     This class extends the Climatization class and includes an enumeration of various
     charging states specific to Skoda vehicles.
     """
-    def __init__(self, vehicle: ElectricVehicle | None = None, origin: Optional[Climatization] = None) -> None:
+    def __init__(self, vehicle: GenericVehicle | None = None, origin: Optional[Climatization] = None) -> None:
         if origin is not None:
             super().__init__(origin=origin)
-            self.settings: Climatization.Settings = SkodaClimatization.Settings(origin=origin.settings)
+            if not isinstance(self.settings, SkodaClimatization.Settings):
+                self.settings: Climatization.Settings = SkodaClimatization.Settings(parent=self, origin=origin.settings)
+            self.settings.parent = self
         else:
             super().__init__(vehicle=vehicle)
-            self.settings: Climatization.Settings = SkodaClimatization.Settings(origin=self.settings)
+            self.settings: Climatization.Settings = SkodaClimatization.Settings(parent=self)
         self.errors: Dict[str, Error] = {}
 
     class Settings(Climatization.Settings):
@@ -36,6 +38,6 @@ class SkodaClimatization(Climatization):  # pylint: disable=too-many-instance-at
         """
         def __init__(self, parent: Optional[GenericObject] = None, origin: Optional[Climatization.Settings] = None) -> None:
             if origin is not None:
-                super().__init__(origin=origin)
+                super().__init__(parent=parent, origin=origin)
             else:
                 super().__init__(parent=parent)

carconnectivity_connectors/skoda/command_impl.py

@@ -31,6 +31,8 @@ class SpinCommand(GenericCommand):
 
     @value.setter
     def value(self, new_value: Optional[Union[str, Dict]]) -> None:
+        # Execute early hooks before parsing the value
+        new_value = self._execute_on_set_hook(new_value, early_hook=True)
         if isinstance(new_value, str):
             parser = ThrowingArgumentParser(prog='', add_help=False, exit_on_error=False)
             parser.add_argument('command', help='Command to execute', type=SpinCommand.Command,
@@ -55,8 +57,8 @@ class SpinCommand(GenericCommand):
                     raise ValueError('Invalid value for SpinCommand. '
                                      f'Command must be one of {SpinCommand.Command}')
         if self._is_changeable:
-            for hook in self._on_set_hooks:
-                new_value = hook(self, new_value)
+            # Execute late hooks before setting the value
+            new_value = self._execute_on_set_hook(new_value, early_hook=False)
             self._set_value(new_value)
         else:
             raise TypeError('You cannot set this attribute. Attribute is not mutable.')

carconnectivity_connectors/skoda/connector.py

@@ -4,6 +4,7 @@ from typing import TYPE_CHECKING
 
 import threading
 import os
+import traceback
 import logging
 import netrc
 from datetime import datetime, timedelta, timezone
@@ -15,20 +16,21 @@ import requests
 from carconnectivity.garage import Garage
 from carconnectivity.vehicle import GenericVehicle
 from carconnectivity.errors import AuthenticationError, TooManyRequestsError, RetrievalError, APIError, APICompatibilityError, \
-    TemporaryAuthenticationError, ConfigurationError, SetterError, CommandError
+    TemporaryAuthenticationError, 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
 from carconnectivity.windows import Windows
 from carconnectivity.lights import Lights
 from carconnectivity.drive import GenericDrive, ElectricDrive, CombustionDrive
-from carconnectivity.attributes import BooleanAttribute, DurationAttribute, TemperatureAttribute
+from carconnectivity.attributes import GenericAttribute, BooleanAttribute, DurationAttribute, TemperatureAttribute, EnumAttribute
 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.enums import ConnectionState
 
 from carconnectivity_connectors.base.connector import BaseConnector
 from carconnectivity_connectors.skoda.auth.session_manager import SessionManager, SessionUser, Service
@@ -71,7 +73,7 @@ class Connector(BaseConnector):
         max_age (Optional[int]): Maximum age for cached data in seconds.
     """
     def __init__(self, connector_id: str, car_connectivity: CarConnectivity, config: Dict) -> None:
-        BaseConnector.__init__(self, connector_id=connector_id, car_connectivity=car_connectivity, config=config)
+        BaseConnector.__init__(self, connector_id=connector_id, car_connectivity=car_connectivity, config=config, log=LOG, api_log=LOG_API)
 
         self._mqtt_client: SkodaMQTTClient = SkodaMQTTClient(skoda_connector=self)
 
@@ -79,83 +81,74 @@ class Connector(BaseConnector):
         self._background_connect_thread: Optional[threading.Thread] = None
         self._stop_event = threading.Event()
 
-        self.connected: BooleanAttribute = BooleanAttribute(name="connected", parent=self, tags={'connector_custom'})
+        self.connection_state: EnumAttribute = EnumAttribute(name="connection_state", parent=self, value_type=ConnectionState,
+                                                             value=ConnectionState.DISCONNECTED, tags={'connector_custom'})
+        self.rest_connected: bool = False
+        self.mqtt_connected: bool = False
         self.interval: DurationAttribute = DurationAttribute(name="interval", parent=self, tags={'connector_custom'})
+        self.interval.minimum = timedelta(seconds=180)
+        self.interval._is_changeable = True  # pylint: disable=protected-access
+
         self.commands: Commands = Commands(parent=self)
 
         self.user_id: Optional[str] = None
 
-        # Configure logging
-        if 'log_level' in config and config['log_level'] is not None:
-            config['log_level'] = config['log_level'].upper()
-            if config['log_level'] in logging._nameToLevel:
-                LOG.setLevel(config['log_level'])
-                self.log_level._set_value(config['log_level'])  # pylint: disable=protected-access
-                logging.getLogger('requests').setLevel(config['log_level'])
-                logging.getLogger('urllib3').setLevel(config['log_level'])
-                logging.getLogger('oauthlib').setLevel(config['log_level'])
-            else:
-                raise ConfigurationError(f'Invalid log level: "{config["log_level"]}" not in {list(logging._nameToLevel.keys())}')
-        if 'api_log_level' in config and config['api_log_level'] is not None:
-            config['api_log_level'] = config['api_log_level'].upper()
-            if config['api_log_level'] in logging._nameToLevel:
-                LOG_API.setLevel(config['api_log_level'])
-            else:
-                raise ConfigurationError(f'Invalid log level: "{config["log_level"]}" not in {list(logging._nameToLevel.keys())}')
-        LOG.info("Loading skoda connector with config %s", config_remove_credentials(self.config))
+        LOG.info("Loading skoda connector with config %s", config_remove_credentials(config))
 
         if 'spin' in config and config['spin'] is not None:
-            self._spin: Optional[str] = config['spin']
+            self.active_config['spin'] = config['spin']
         else:
-            self._spin = None
+            self.active_config['spin'] = None
 
-        username: Optional[str] = None
-        password: Optional[str] = None
-        if 'username' in self.config and 'password' in self.config:
-            username = self.config['username']
-            password = self.config['password']
+        self.active_config['username'] = None
+        self.active_config['password'] = None
+        if 'username' in config and 'password' in config:
+            self.active_config['username'] = config['username']
+            self.active_config['password'] = config['password']
         else:
-            if 'netrc' in self.config:
-                netrc_filename: str = self.config['netrc']
+            if 'netrc' in config:
+                self.active_config['netrc'] = config['netrc']
             else:
-                netrc_filename = os.path.join(os.path.expanduser("~"), ".netrc")
+                self.active_config['netrc'] = os.path.join(os.path.expanduser("~"), ".netrc")
             try:
-                secrets = netrc.netrc(file=netrc_filename)
+                secrets = netrc.netrc(file=self.active_config['netrc'])
                 secret: tuple[str, str, str] | None = secrets.authenticators("skoda")
                 if secret is None:
-                    raise AuthenticationError(f'Authentication using {netrc_filename} failed: skoda not found in netrc')
-                username, account, password = secret
+                    raise AuthenticationError(f'Authentication using {self.active_config["netrc"]} failed: skoda not found in netrc')
+                self.active_config['username'], account, self.active_config['password'] = secret
 
-                if self._spin is None and account is not None:
+                if self.active_config['spin'] is None and account is not None:
                     try:
-                        self._spin = account
+                        self.active_config['spin'] = account
                     except ValueError as err:
                         LOG.error('Could not parse spin from netrc: %s', err)
             except netrc.NetrcParseError as err:
-                LOG.error('Authentification using %s failed: %s', netrc_filename, err)
-                raise AuthenticationError(f'Authentication using {netrc_filename} failed: {err}') from err
+                LOG.error('Authentification using %s failed: %s', self.active_config['netrc'], err)
+                raise AuthenticationError(f'Authentication using {self.active_config["netrc"]} failed: {err}') from err
             except TypeError as err:
-                if 'username' not in self.config:
-                    raise AuthenticationError(f'"skoda" entry was not found in {netrc_filename} netrc-file.'
+                if 'username' not in config:
+                    raise AuthenticationError(f'"skoda" entry was not found in {self.active_config["netrc"]} netrc-file.'
                                               ' Create it or provide username and password in config') from err
             except FileNotFoundError as err:
-                raise AuthenticationError(f'{netrc_filename} netrc-file was not found. Create it or provide username and password in config') from err
-
-        interval: int = 300
-        if 'interval' in self.config:
-            interval = self.config['interval']
-            if interval < 300:
-                raise ValueError('Intervall must be at least 300 seconds')
-        self.max_age: int = interval - 1
-        if 'max_age' in self.config:
-            self.max_age = self.config['max_age']
-        self.interval._set_value(timedelta(seconds=interval))  # pylint: disable=protected-access
-
-        if username is None or password is None:
+                raise AuthenticationError(f'{self.active_config["netrc"]} netrc-file was not found. Create it or provide username and password in config') \
+                                          from err
+
+        self.active_config['interval'] = 300
+        if 'interval' in config:
+            self.active_config['interval'] = config['interval']
+            if self.active_config['interval'] < 180:
+                raise ValueError('Intervall must be at least 180 seconds')
+        self.active_config['max_age'] = self.active_config['interval'] - 1
+        if 'max_age' in config:
+            self.active_config['max_age'] = config['max_age']
+        self.interval._set_value(timedelta(seconds=self.active_config['interval']))  # pylint: disable=protected-access
+
+        if self.active_config['username'] is None or self.active_config['password'] is None:
             raise AuthenticationError('Username or password not provided')
 
         self._manager: SessionManager = SessionManager(tokenstore=car_connectivity.get_tokenstore(), cache=car_connectivity.get_cache())
-        session: requests.Session = self._manager.get_session(Service.MY_SKODA, SessionUser(username=username, password=password))
+        session: requests.Session = self._manager.get_session(Service.MY_SKODA, SessionUser(username=self.active_config['username'],
+                                                                                            password=self.active_config['password']))
         if not isinstance(session, MySkodaSession):
             raise AuthenticationError('Could not create session')
         self.session: MySkodaSession = session
@@ -169,12 +162,15 @@ class Connector(BaseConnector):
         self._stop_event.clear()
         # Start background thread for Rest API polling
         self._background_thread = threading.Thread(target=self._background_loop, daemon=False)
+        self._background_thread.name = 'carconnectivity.connectors.skoda-background'
         self._background_thread.start()
         # Start background thread for MQTT connection
         self._background_connect_thread = threading.Thread(target=self._background_connect_loop, daemon=False)
+        self._background_connect_thread.name = 'carconnectivity.connectors.skoda-background_connect'
         self._background_connect_thread.start()
         # Start MQTT thread
         self._mqtt_client.loop_start()
+        self.healthy._set_value(value=True)  # pylint: disable=protected-access
 
     def _background_connect_loop(self) -> None:
         while not self._stop_event.is_set():
@@ -188,6 +184,7 @@ class Connector(BaseConnector):
     def _background_loop(self) -> None:
         self._stop_event.clear()
         fetch: bool = True
+        self.connection_state._set_value(value=ConnectionState.CONNECTING)  # pylint: disable=protected-access
         while not self._stop_event.is_set():
             interval = 300
             try:
@@ -206,21 +203,43 @@ class Connector(BaseConnector):
                     raise
             except TooManyRequestsError as err:
                 LOG.error('Retrieval error during update. Too many requests from your account (%s). Will try again after 15 minutes', str(err))
+                self.connection_state._set_value(value=ConnectionState.ERROR)  # pylint: disable=protected-access
+                self.rest_connected = False
                 self._stop_event.wait(900)
             except RetrievalError as err:
                 LOG.error('Retrieval error during update (%s). Will try again after configured interval of %ss', str(err), interval)
+                self.connection_state._set_value(value=ConnectionState.ERROR)  # pylint: disable=protected-access
+                self.rest_connected = False
                 self._stop_event.wait(interval)
             except APIError as err:
                 LOG.error('API error during update (%s). Will try again after configured interval of %ss', str(err), interval)
+                self.connection_state._set_value(value=ConnectionState.ERROR)  # pylint: disable=protected-access
+                self.rest_connected = False
                 self._stop_event.wait(interval)
             except APICompatibilityError as err:
                 LOG.error('API compatability error during update (%s). Will try again after configured interval of %ss', str(err), interval)
+                self.connection_state._set_value(value=ConnectionState.ERROR)  # pylint: disable=protected-access
+                self.rest_connected = False
                 self._stop_event.wait(interval)
             except TemporaryAuthenticationError as err:
                 LOG.error('Temporary authentification error during update (%s). Will try again after configured interval of %ss', str(err), interval)
+                self.connection_state._set_value(value=ConnectionState.ERROR)  # pylint: disable=protected-access
+                self.rest_connected = False
                 self._stop_event.wait(interval)
+            except Exception as err:
+                LOG.critical('Critical error during update: %s', traceback.format_exc())
+                self.connection_state._set_value(value=ConnectionState.ERROR)  # pylint: disable=protected-access
+                self.rest_connected = False
+                self.healthy._set_value(value=False)  # pylint: disable=protected-access
+                raise err
             else:
+                self.rest_connected = True
+                if self.mqtt_connected:
+                    self.connection_state._set_value(value=ConnectionState.CONNECTED)  # pylint: disable=protected-access
                 self._stop_event.wait(interval)
+        # When leaving the loop, set the connection state to disconnected
+        self.connection_state._set_value(value=ConnectionState.DISCONNECTED)  # pylint: disable=protected-access
+        self.rest_connected = False
 
     def persist(self) -> None:
         """
@@ -251,12 +270,12 @@ class Connector(BaseConnector):
                 self.car_connectivity.garage.remove_vehicle(vehicle.id)
                 vehicle.enabled = False
         self._stop_event.set()
+        self.session.close()
         if self._background_thread is not None:
             self._background_thread.join()
         if self._background_connect_thread is not None:
             self._background_connect_thread.join()
         self.persist()
-        self.session.close()
         return super().shutdown()
 
     def fetch_all(self) -> None:
@@ -354,12 +373,38 @@ 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'):
+                        vehicle_to_update = self.fetch_connection_status(vehicle_to_update)
                     if vehicle_to_update.capabilities.has_capability('PARKING_POSITION'):
                         vehicle_to_update = self.fetch_position(vehicle_to_update)
                     if vehicle_to_update.capabilities.has_capability('CHARGING') and isinstance(vehicle_to_update, SkodaElectricVehicle):
                         vehicle_to_update = self.fetch_charging(vehicle_to_update)
                     if vehicle_to_update.capabilities.has_capability('AIR_CONDITIONING'):
                         vehicle_to_update = self.fetch_air_conditioning(vehicle_to_update)
+                    if vehicle_to_update.capabilities.has_capability('VEHICLE_HEALTH_INSPECTION'):
+                        vehicle_to_update = self.fetch_maintenance(vehicle_to_update)
+                vehicle_to_update = self.decide_state(vehicle_to_update)
+        self.car_connectivity.transaction_end()
+
+    def decide_state(self, vehicle: SkodaVehicle) -> SkodaVehicle:
+        """
+        Decides the state of the vehicle based on the current data.
+
+        Args:
+            vehicle (SkodaVehicle): The Skoda vehicle object.
+
+        Returns:
+            SkodaVehicle: The Skoda vehicle object with the updated state.
+        """
+        if vehicle is not None:
+            if vehicle.in_motion is not None and vehicle.in_motion.enabled and vehicle.in_motion.value:
+                vehicle.state._set_value(GenericVehicle.State.IGNITION_ON)  # pylint: disable=protected-access
+            elif vehicle.position is not None and vehicle.position.enabled and vehicle.position.position_type is not None \
+                    and vehicle.position.position_type.enabled and vehicle.position.position_type.value == Position.PositionType.PARKING:
+                vehicle.state._set_value(GenericVehicle.State.PARKED)  # pylint: disable=protected-access
+            else:
+                vehicle.state._set_value(None)  # pylint: disable=protected-access
+        return vehicle
 
     def fetch_charging(self, vehicle: SkodaElectricVehicle, no_cache: bool = False) -> SkodaElectricVehicle:
         """
@@ -568,6 +613,41 @@ class Connector(BaseConnector):
                     vehicle.charging.errors.clear()
             log_extra_keys(LOG_API, 'charging data', data,  {'carCapturedTimestamp', 'status', 'isVehicleInSavedLocation', 'errors', 'settings'})
         return vehicle
+    
+    def fetch_connection_status(self, vehicle: SkodaVehicle, no_cache: bool = False) -> SkodaVehicle:
+        """
+        Fetches the connection status of the given Skoda vehicle and updates its connection attributes.
+
+        Args:
+            vehicle (SkodaVehicle): The Skoda vehicle object containing the VIN and connection attributes.
+
+        Returns:
+            SkodaVehicle: The updated Skoda vehicle object with the fetched connection data.
+
+        Raises:
+            APIError: If the VIN is missing.
+            ValueError: If the vehicle has no connection object.
+        """
+        vin = vehicle.vin.value
+        if vin is None:
+            raise APIError('VIN is missing')
+        url = f'https://mysmob.api.connect.skoda-auto.cz/api/v2/connection-status/{vin}/readiness'
+        data: Dict[str, Any] | None = self._fetch_data(url=url, session=self.session, no_cache=no_cache)
+        #  {'unreachable': False, 'inMotion': False, 'batteryProtectionLimitOn': False}
+        if data is not None:
+            if 'unreachable' in data and data['unreachable'] is not None:
+                if data['unreachable']:
+                    vehicle.connection_state._set_value(vehicle.ConnectionState.OFFLINE)  # pylint: disable=protected-access
+                else:
+                    vehicle.connection_state._set_value(vehicle.ConnectionState.REACHABLE)  # pylint: disable=protected-access
+            else:
+                vehicle.connection_state._set_value(None)  # pylint: disable=protected-access
+            if 'inMotion' in data and data['inMotion'] is not None:
+                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'})
+        return vehicle
 
     def fetch_position(self, vehicle: SkodaVehicle, no_cache: bool = False) -> SkodaVehicle:
         """
@@ -589,7 +669,7 @@ class Connector(BaseConnector):
         if vehicle.position is None:
             raise ValueError('Vehicle has no charging object')
         url = f'https://mysmob.api.connect.skoda-auto.cz/api/v1/maps/positions?vin={vin}'
-        data: Dict[str, Any] | None = self._fetch_data(url=url, session=self.session, no_cache=no_cache)
+        data: Dict[str, Any] | None = self._fetch_data(url=url, session=self.session, no_cache=no_cache, allow_empty=True)
         if data is not None:
             if 'positions' in data and data['positions'] is not None:
                 for position_dict in data['positions']:
@@ -623,6 +703,53 @@ class Connector(BaseConnector):
                 vehicle.position.position_type._set_value(None)  # pylint: disable=protected-access
         return vehicle
 
+    def fetch_maintenance(self, vehicle: SkodaVehicle, no_cache: bool = False) -> SkodaVehicle:
+        """
+        Fetches the maintenance information for a given Skoda vehicle.
+
+        Args:
+            vehicle (SkodaVehicle): The vehicle object for which maintenance information is to be fetched.
+            no_cache (bool, optional): If True, bypasses the cache and fetches fresh data. Defaults to False.
+
+        Returns:
+            SkodaVehicle: The vehicle object with updated maintenance information.
+
+        Raises:
+            APIError: If the VIN is missing or if the 'capturedAt' field is missing in the fetched data.
+            ValueError: If the vehicle has no charging object.
+        """
+        vin = vehicle.vin.value
+        if vin is None:
+            raise APIError('VIN is missing')
+        if vehicle.position is None:
+            raise ValueError('Vehicle has no charging object')
+        url = f'https://mysmob.api.connect.skoda-auto.cz/api/v3/vehicle-maintenance/vehicles/{vin}/report'
+        data: Dict[str, Any] | None = self._fetch_data(url=url, session=self.session, no_cache=no_cache)
+        #{'capturedAt': '2025-02-24T19:54:32.728Z', 'inspectionDueInDays': 620, 'mileageInKm': 2512}
+        if data is not None:
+            if 'capturedAt' in data and data['capturedAt'] is not None:
+                captured_at: datetime = robust_time_parse(data['capturedAt'])
+            else:
+                raise APIError('Could not fetch maintenance, capturedAt missing')
+            if 'mileageInKm' in data and data['mileageInKm'] is not None:
+                vehicle.odometer._set_value(value=data['mileageInKm'], measured=captured_at, unit=Length.KM)  # pylint: disable=protected-access
+            else:
+                vehicle.odometer._set_value(None)  # pylint: disable=protected-access
+            if 'inspectionDueInDays' in data and data['inspectionDueInDays'] is not None:
+                inspection_due: timedelta = timedelta(days=data['inspectionDueInDays'])
+                inspection_date: datetime = captured_at + inspection_due
+                inspection_date = inspection_date.replace(hour=0, minute=0, second=0, microsecond=0)
+                # pylint: disable-next=protected-access
+                vehicle.maintenance.inspection_due_at._set_value(value=inspection_date, measured=captured_at)
+            else:
+                vehicle.maintenance.inspection_due_at._set_value(None)  # pylint: disable=protected-access
+            log_extra_keys(LOG_API, 'maintenance', data,  {'capturedAt', 'mileageInKm', 'inspectionDueInDays'})
+
+        #url = f'https://mysmob.api.connect.skoda-auto.cz/api/v1/vehicle-health-report/warning-lights/{vin}'
+        #data: Dict[str, Any] | None = self._fetch_data(url=url, session=self.session, no_cache=no_cache)
+        #{'capturedAt': '2025-02-24T15:32:35.032Z', 'mileageInKm': 2512, 'warningLights': [{'category': 'ASSISTANCE', 'defects': []}, {'category': 'COMFORT', 'defects': []}, {'category': 'BRAKE', 'defects': []}, {'category': 'ELECTRIC_ENGINE', 'defects': []}, {'category': 'LIGHTING', 'defects': []}, {'category': 'TIRE', 'defects': []}, {'category': 'OTHER', 'defects': []}]}
+        return vehicle
+
     def fetch_air_conditioning(self, vehicle: SkodaVehicle, no_cache: bool = False) -> SkodaVehicle:
         """
         Fetches the air conditioning data for a given Skoda vehicle and updates the vehicle object with the retrieved data.
@@ -682,12 +809,19 @@ class Connector(BaseConnector):
                 # pylint: disable-next=protected-access
                 vehicle.climatization.settings.target_temperature._add_on_set_hook(self.__on_air_conditioning_target_temperature_change)
                 vehicle.climatization.settings.target_temperature._is_changeable = True  # pylint: disable=protected-access
+                precision: float = 0.5
+                min_temperature: Optional[float] = None
+                max_temperature: Optional[float] = None
                 unit: Temperature = Temperature.UNKNOWN
                 if 'unitInCar' in data['targetTemperature'] and data['targetTemperature']['unitInCar'] is not None:
                     if data['targetTemperature']['unitInCar'] == 'CELSIUS':
                         unit = Temperature.C
+                        min_temperature: Optional[float] = 16
+                        max_temperature: Optional[float] = 29.5
                     elif data['targetTemperature']['unitInCar'] == 'FAHRENHEIT':
                         unit = Temperature.F
+                        min_temperature: Optional[float] = 61
+                        max_temperature: Optional[float] = 85
                     elif data['targetTemperature']['unitInCar'] == 'KELVIN':
                         unit = Temperature.K
                     else:
@@ -697,6 +831,10 @@ class Connector(BaseConnector):
                     vehicle.climatization.settings.target_temperature._set_value(value=data['targetTemperature']['temperatureValue'],
                                                                                  measured=captured_at,
                                                                                  unit=unit)
+                    vehicle.climatization.settings.target_temperature.precision = precision
+                    vehicle.climatization.settings.target_temperature.minimum = min_temperature
+                    vehicle.climatization.settings.target_temperature.maximum = max_temperature
+
                 else:
                     # pylint: disable-next=protected-access
                     vehicle.climatization.settings.target_temperature._set_value(value=None, measured=captured_at, unit=unit)
@@ -948,7 +1086,7 @@ class Connector(BaseConnector):
             data = self._fetch_data(url, session=self.session, allow_http_error=True)
             if data is not None and 'compositeRenders' in data:  # pylint: disable=too-many-nested-blocks
                 for image in data['compositeRenders']:
-                    if not 'layers' in image or image['layers'] is None or len(image['layers']) == 0:
+                    if 'layers' not in image or image['layers'] is None or len(image['layers']) == 0:
                         continue
                     image_url: Optional[str] = None
                     for layer in image['layers']:
@@ -959,13 +1097,13 @@ class Connector(BaseConnector):
                         continue
                     img = None
                     cache_date = None
-                    if self.max_age is not None and self.session.cache is not None and image_url in self.session.cache:
+                    if self.active_config['max_age'] is not None and self.session.cache is not None and image_url in self.session.cache:
                         img, cache_date_string = self.session.cache[image_url]
                         img = base64.b64decode(img)  # pyright: ignore[reportPossiblyUnboundVariable]
                         img = Image.open(io.BytesIO(img))  # pyright: ignore[reportPossiblyUnboundVariable]
                         cache_date = datetime.fromisoformat(cache_date_string)
-                    if img is None or self.max_age is None \
-                            or (cache_date is not None and cache_date < (datetime.utcnow() - timedelta(seconds=self.max_age))):
+                    if img is None or self.active_config['max_age'] is None \
+                            or (cache_date is not None and cache_date < (datetime.utcnow() - timedelta(seconds=self.active_config['max_age']))):
                         try:
                             image_download_response = requests.get(image_url, stream=True)
                             if image_download_response.status_code == requests.codes['ok']:
@@ -1000,8 +1138,8 @@ class Connector(BaseConnector):
                             if 'car_picture' in vehicle.images.images:
                                 vehicle.images.images['car_picture']._set_value(img)  # pylint: disable=protected-access
                             else:
-                                vehicle.images.images['car_picture']: ImageAttribute = ImageAttribute(name="car_picture", parent=vehicle.images,
-                                                                                                        value=img, tags={'carconnectivity'})
+                                vehicle.images.images['car_picture'] = ImageAttribute(name="car_picture", parent=vehicle.images,
+                                                                                      value=img, tags={'carconnectivity'})
         return vehicle
 
     def fetch_driving_range(self, vehicle: SkodaVehicle, no_cache: bool = False) -> SkodaVehicle:
@@ -1224,11 +1362,11 @@ class Connector(BaseConnector):
                     allowed_errors=None) -> Optional[Dict[str, Any]]:  # noqa: C901
         data: Optional[Dict[str, Any]] = None
         cache_date: Optional[datetime] = None
-        if not no_cache and (self.max_age is not None and session.cache is not None and url in session.cache):
+        if not no_cache and (self.active_config['max_age'] is not None and session.cache is not None and url in session.cache):
             data, cache_date_string = session.cache[url]
             cache_date = datetime.fromisoformat(cache_date_string)
-        if data is None or self.max_age is None \
-                or (cache_date is not None and cache_date < (datetime.utcnow() - timedelta(seconds=self.max_age))):
+        if data is None or self.active_config['max_age'] is None \
+                or (cache_date is not None and cache_date < (datetime.utcnow() - timedelta(seconds=self.active_config['max_age']))):
             try:
                 status_response: requests.Response = session.get(url, allow_redirects=False)
                 self._record_elapsed(status_response.elapsed)
@@ -1236,6 +1374,8 @@ class Connector(BaseConnector):
                     data = status_response.json()
                     if session.cache is not None:
                         session.cache[url] = (data, str(datetime.utcnow()))
+                elif status_response.status_code == requests.codes['no_content'] and allow_empty:
+                    data = None
                 elif status_response.status_code == requests.codes['too_many_requests']:
                     raise TooManyRequestsError('Could not fetch data due to too many requests from your account. '
                                                f'Status Code was: {status_response.status_code}')
@@ -1302,10 +1442,20 @@ class Connector(BaseConnector):
             raise SetterError(f'Unknown temperature unit {temperature_attribute.unit}')
 
         url = f'https://mysmob.api.connect.skoda-auto.cz/api/v2/air-conditioning/{vin}/settings/target-temperature'
-        settings_response: requests.Response = self.session.post(url, data=json.dumps(setting_dict), allow_redirects=True)
-        if settings_response.status_code != requests.codes['accepted']:
-            LOG.error('Could not set target temperature (%s)', settings_response.status_code)
-            raise SetterError(f'Could not set value ({settings_response.status_code})')
+        try:
+            settings_response: requests.Response = self.session.post(url, data=json.dumps(setting_dict), allow_redirects=True)
+            if settings_response.status_code != requests.codes['accepted']:
+                LOG.error('Could not set target temperature (%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_temperature
 
     def __on_air_conditioning_at_unlock_change(self, at_unlock_attribute: BooleanAttribute, at_unlock_value: bool) -> bool:
@@ -1321,10 +1471,20 @@ class Connector(BaseConnector):
         setting_dict['airConditioningAtUnlockEnabled'] = at_unlock_value
 
         url = f'https://mysmob.api.connect.skoda-auto.cz/api/v2/air-conditioning/{vin}/settings/ac-at-unlock'
-        settings_response: requests.Response = self.session.post(url, data=json.dumps(setting_dict), allow_redirects=True)
-        if settings_response.status_code != requests.codes['accepted']:
-            LOG.error('Could not set air conditioning at unlock (%s)', settings_response.status_code)
-            raise SetterError(f'Could not set value ({settings_response.status_code})')
+        try:
+            settings_response: requests.Response = self.session.post(url, data=json.dumps(setting_dict), allow_redirects=True)
+            if settings_response.status_code != requests.codes['accepted']:
+                LOG.error('Could not set air conditioning at unlock (%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 at_unlock_value
 
     def __on_air_conditioning_window_heating_change(self, window_heating_attribute: BooleanAttribute, window_heating_value: bool) -> bool:
@@ -1340,10 +1500,20 @@ class Connector(BaseConnector):
         setting_dict['windowHeatingEnabled'] = window_heating_value
 
         url = f'https://mysmob.api.connect.skoda-auto.cz/api/v2/air-conditioning/{vin}/settings/ac-at-unlock'
-        settings_response: requests.Response = self.session.post(url, data=json.dumps(setting_dict), allow_redirects=True)
-        if settings_response.status_code != requests.codes['accepted']:
-            LOG.error('Could not set air conditioning window heating (%s)', settings_response.status_code)
-            raise SetterError(f'Could not set value ({settings_response.status_code})')
+        try:
+            settings_response: requests.Response = self.session.post(url, data=json.dumps(setting_dict), allow_redirects=True)
+            if settings_response.status_code != requests.codes['accepted']:
+                LOG.error('Could not set air conditioning window heating (%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 window_heating_value
 
     def __on_air_conditioning_start_stop(self, start_stop_command: ClimatizationStartStopCommand, command_arguments: Union[str, Dict[str, Any]]) \
@@ -1360,53 +1530,66 @@ class Connector(BaseConnector):
         if 'command' not in command_arguments:
             raise CommandError('Command argument missing')
         command_dict = {}
-        if command_arguments['command'] == ClimatizationStartStopCommand.Command.START:
-            command_dict['heaterSource'] = 'ELECTRIC'
-            command_dict['targetTemperature'] = {}
-            if 'target_temperature' in command_arguments:
-                # Round target temperature to nearest 0.5
-                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 CommandError('Temperature unit is not of type Temperature')
-                    if command_arguments['target_temperature_unit'] == Temperature.C:
+        try:
+            if command_arguments['command'] == ClimatizationStartStopCommand.Command.START:
+                command_dict['heaterSource'] = 'ELECTRIC'
+                command_dict['targetTemperature'] = {}
+                precision: float = 0.5
+                if 'target_temperature' in command_arguments:
+                    # Round target temperature to nearest 0.5
+                    command_dict['targetTemperature']['temperatureValue'] = round(command_arguments['target_temperature'] / precision) * precision
+                    if 'target_temperature_unit' in command_arguments:
+                        if not isinstance(command_arguments['target_temperature_unit'], 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:
+                            command_dict['targetTemperature']['unitInCar'] = 'FAHRENHEIT'
+                        elif command_arguments['target_temperature_unit'] == Temperature.K:
+                            command_dict['targetTemperature']['unitInCar'] = 'KELVIN'
+                        else:
+                            raise CommandError(f'Unknown temperature unit {command_arguments["target_temperature_unit"]}')
+                    else:
                         command_dict['targetTemperature']['unitInCar'] = 'CELSIUS'
-                    elif command_arguments['target_temperature_unit'] == Temperature.F:
+                elif start_stop_command.parent is not None and (climatization := start_stop_command.parent.parent) is not None \
+                        and isinstance(climatization, Climatization) and climatization.settings is not None \
+                        and climatization.settings.target_temperature is not None and climatization.settings.target_temperature.enabled \
+                        and climatization.settings.target_temperature.value is not None:  # pylint: disable=too-many-boolean-expressions
+                    if climatization.settings.target_temperature.precision is not None:
+                        precision = climatization.settings.target_temperature.precision
+                    # Round target temperature to nearest 0.5
+                    command_dict['targetTemperature']['temperatureValue'] = round(climatization.settings.target_temperature.value / precision) * precision
+                    if climatization.settings.target_temperature.unit == Temperature.C:
+                        command_dict['targetTemperature']['unitInCar'] = 'CELSIUS'
+                    elif climatization.settings.target_temperature.unit == Temperature.F:
                         command_dict['targetTemperature']['unitInCar'] = 'FAHRENHEIT'
-                    elif command_arguments['target_temperature_unit'] == Temperature.K:
+                    elif climatization.settings.target_temperature.unit == Temperature.K:
                         command_dict['targetTemperature']['unitInCar'] = 'KELVIN'
                     else:
-                        raise CommandError(f'Unknown temperature unit {command_arguments["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'
-            elif start_stop_command.parent is not None and (climatization := start_stop_command.parent.parent) is not None \
-                    and isinstance(climatization, Climatization) and climatization.settings is not None \
-                    and climatization.settings.target_temperature is not None and climatization.settings.target_temperature.enabled \
-                    and climatization.settings.target_temperature.value is not None:  # pylint: disable=too-many-boolean-expressions
-                # Round target temperature to nearest 0.5
-                command_dict['targetTemperature']['temperatureValue'] = round(climatization.settings.target_temperature.value * 2) / 2
-                if climatization.settings.target_temperature.unit == Temperature.C:
-                    command_dict['targetTemperature']['unitInCar'] = 'CELSIUS'
-                elif climatization.settings.target_temperature.unit == Temperature.F:
-                    command_dict['targetTemperature']['unitInCar'] = 'FAHRENHEIT'
-                elif climatization.settings.target_temperature.unit == Temperature.K:
-                    command_dict['targetTemperature']['unitInCar'] = 'KELVIN'
-                else:
-                    raise CommandError(f'Unknown temperature unit {climatization.settings.target_temperature.unit}')
+                url = f'https://mysmob.api.connect.skoda-auto.cz/api/v2/air-conditioning/{vin}/start'
+                command_response: requests.Response = self.session.post(url, data=json.dumps(command_dict), allow_redirects=True)
+            elif command_arguments['command'] == ClimatizationStartStopCommand.Command.STOP:
+                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:
-                command_dict['targetTemperature']['temperatureValue'] = 25.0
-                command_dict['targetTemperature']['unitInCar'] = 'CELSIUS'
-            url = f'https://mysmob.api.connect.skoda-auto.cz/api/v2/air-conditioning/{vin}/start'
-            command_response: requests.Response = self.session.post(url, data=json.dumps(command_dict), allow_redirects=True)
-        elif command_arguments['command'] == ClimatizationStartStopCommand.Command.STOP:
-            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 CommandError(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 CommandError(f'Could not start/stop air conditioning ({command_response.status_code}: {command_response.text})')
+            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 CommandError(f'Could not start/stop air conditioning ({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_start_stop(self, start_stop_command: ChargingStartStopCommand, command_arguments: Union[str, Dict[str, Any]]) \
@@ -1422,18 +1605,29 @@ class Connector(BaseConnector):
             raise CommandError('VIN in object hierarchy missing')
         if 'command' not in command_arguments:
             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)
-        elif command_arguments['command'] == ChargingStartStopCommand.Command.STOP:
-            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 CommandError(f'Unknown command {command_arguments["command"]}')
+        try:
+            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)
+            elif command_arguments['command'] == ChargingStartStopCommand.Command.STOP:
+                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 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 CommandError(f'Could not start/stop charging ({command_response.status_code}: {command_response.text})')
+            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 CommandError(f'Could not start/stop charging ({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_honk_flash(self, honk_flash_command: HonkAndFlashCommand, command_arguments: Union[str, Dict[str, Any]]) \
@@ -1463,10 +1657,20 @@ class Connector(BaseConnector):
             command_dict['vehiclePosition']['longitude'] = vehicle.position.longitude.value
 
             url = f'https://mysmob.api.connect.skoda-auto.cz/api/v1/vehicle-access/{vin}/honk-and-flash'
-            command_response: requests.Response = self.session.post(url, data=json.dumps(command_dict), allow_redirects=True)
-            if command_response.status_code != requests.codes['accepted']:
-                LOG.error('Could not execute honk or flash command (%s: %s)', command_response.status_code, command_response.text)
-                raise CommandError(f'Could not execute honk or flash command ({command_response.status_code}: {command_response.text})')
+            try:
+                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 CommandError(f'Could not execute honk or flash command ({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 SetterError(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
         else:
             raise CommandError(f'Unknown command {command_arguments["command"]}')
         return command_arguments
@@ -1488,19 +1692,29 @@ class Connector(BaseConnector):
         if 'spin' in command_arguments:
             command_dict['currentSpin'] = command_arguments['spin']
         else:
-            if self._spin is None:
+            if self.active_config['spin'] is None:
                 raise CommandError('S-PIN is missing, please add S-PIN to your configuration or .netrc file')
-            command_dict['currentSpin'] = self._spin
+            command_dict['currentSpin'] = self.active_config['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 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 CommandError(f'Could not execute locking command ({command_response.status_code}: {command_response.text})')
+        try:
+            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 CommandError(f'Could not execute locking command ({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_wake_sleep(self, wake_sleep_command: WakeSleepCommand, command_arguments: Union[str, Dict[str, Any]]) \
@@ -1519,10 +1733,20 @@ class Connector(BaseConnector):
         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})')
+            try:
+                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})')
+            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
         elif command_arguments['command'] == WakeSleepCommand.Command.SLEEP:
             raise CommandError('Sleep command not supported by vehicle. Vehicle will put itself to sleep')
         else:
@@ -1537,22 +1761,35 @@ class Connector(BaseConnector):
         if 'command' not in command_arguments:
             raise CommandError('Command argument missing')
         command_dict = {}
-        if self._spin is None:
+        if self.active_config['spin'] is None:
             raise CommandError('S-PIN is missing, please add S-PIN to your configuration or .netrc file')
         if 'spin' in command_arguments:
             command_dict['currentSpin'] = command_arguments['spin']
         else:
-            if self._spin is None or self._spin == '':
+            if self.active_config['spin'] is None or self.active_config['spin'] == '':
                 raise CommandError('S-PIN is missing, please add S-PIN to your configuration or .netrc file')
-            command_dict['currentSpin'] = self._spin
+            command_dict['currentSpin'] = self.active_config['spin']
         if command_arguments['command'] == SpinCommand.Command.VERIFY:
             url = 'https://mysmob.api.connect.skoda-auto.cz/api/v1/spin/verify'
         else:
             raise CommandError(f'Unknown command {command_arguments["command"]}')
-        command_response: requests.Response = self.session.post(url, data=json.dumps(command_dict), allow_redirects=True)
-        if command_response.status_code != requests.codes['ok']:
-            LOG.error('Could not execute spin command (%s: %s)', command_response.status_code, command_response.text)
-            raise CommandError(f'Could not execute spin command ({command_response.status_code}: {command_response.text})')
-        else:
-            LOG.info('Spin verify command executed successfully')
+        try:
+            command_response: requests.Response = self.session.post(url, data=json.dumps(command_dict), allow_redirects=True)
+            if command_response.status_code != requests.codes['ok']:
+                LOG.error('Could not execute spin command (%s: %s)', command_response.status_code, command_response.text)
+                raise CommandError(f'Could not execute spin command ({command_response.status_code}: {command_response.text})')
+            else:
+                LOG.info('Spin verify command executed successfully')
+        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 get_name(self) -> str:
+        return "Skoda Connector"

carconnectivity_connectors/skoda/mqtt_client.py

@@ -22,6 +22,7 @@ from carconnectivity.util import robust_time_parse, log_extra_keys
 from carconnectivity.charging import Charging
 from carconnectivity.climatization import Climatization
 from carconnectivity.units import Speed, Power, Length
+from carconnectivity.enums import ConnectionState
 
 from carconnectivity_connectors.skoda.vehicle import SkodaVehicle, SkodaElectricVehicle
 from carconnectivity_connectors.skoda.charging import SkodaCharging, mapping_skoda_charging_state
@@ -77,6 +78,7 @@ class SkodaMQTTClient(Client):  # pylint: disable=too-many-instance-attributes
         Returns:
             MQTTErrorCode: The result of the connection attempt.
         """
+        self._skoda_connector.connection_state._set_value(value=ConnectionState.CONNECTING)  # pylint: disable=protected-access
         return super().connect(*args, host='mqtt.messagehub.de', port=8883, keepalive=60, **kwargs)
 
     def _on_pre_connect_callback(self, client: Client, userdata: Any) -> None:
@@ -312,7 +314,9 @@ class SkodaMQTTClient(Client):  # pylint: disable=too-many-instance-attributes
         # reason_code 0 means success
         if reason_code == 0:
             LOG.info('Connected to Skoda MQTT server')
-            self._skoda_connector.connected._set_value(value=True)  # pylint: disable=protected-access
+            if self._skoda_connector.rest_connected:
+                self._skoda_connector.connection_state._set_value(value=ConnectionState.CONNECTED)  # pylint: disable=protected-access
+            self._skoda_connector.mqtt_connected = True
             observer_flags: Observable.ObserverEvent = Observable.ObserverEvent.ENABLED | Observable.ObserverEvent.DISABLED
             self._skoda_connector.car_connectivity.garage.add_observer(observer=self._on_carconnectivity_vehicle_enabled,
                                                                        flag=observer_flags,
@@ -385,7 +389,8 @@ class SkodaMQTTClient(Client):  # pylint: disable=too-many-instance-attributes
         del properties
         del flags
 
-        self._skoda_connector.connected._set_value(value=False)  # pylint: disable=protected-access
+        self._skoda_connector.connection_state._set_value(value=ConnectionState.DISCONNECTED)  # pylint: disable=protected-access
+        self._skoda_connector.mqtt_connected = False
         self._skoda_connector.car_connectivity.garage.remove_observer(observer=self._on_carconnectivity_vehicle_enabled)
 
         self.subscribed_topics.clear()
@@ -469,7 +474,7 @@ class SkodaMQTTClient(Client):  # pylint: disable=too-many-instance-attributes
                         if 'data' in data and data['data'] is not None:
                             vehicle: Optional[GenericVehicle] = self._skoda_connector.car_connectivity.garage.get_vehicle(vin)
                             if isinstance(vehicle, SkodaElectricVehicle):
-                                electric_drive: ElectricDrive = vehicle.get_electric_drive()
+                                electric_drive: Optional[ElectricDrive] = vehicle.get_electric_drive()
                                 if electric_drive is not None:
                                     charging_state: Optional[Charging.ChargingState] = vehicle.charging.state.value
                                     old_charging_state: Optional[Charging.ChargingState] = charging_state
@@ -509,6 +514,7 @@ class SkodaMQTTClient(Client):  # pylint: disable=too-many-instance-attributes
                                     if old_charging_state != charging_state:
                                         try:
                                             self._skoda_connector.fetch_charging(vehicle, no_cache=True)
+                                            self._skoda_connector.car_connectivity.transaction_end()
                                         except CarConnectivityError as e:
                                             LOG.error('Error while fetching charging: %s', e)
                                 if 'timeToFinish' in data['data'] and data['data']['timeToFinish'] is not None \
@@ -536,6 +542,7 @@ class SkodaMQTTClient(Client):  # pylint: disable=too-many-instance-attributes
                             if isinstance(vehicle, SkodaVehicle):
                                 try:
                                     self._skoda_connector.fetch_air_conditioning(vehicle, no_cache=True)
+                                    self._skoda_connector.car_connectivity.transaction_end()
                                 except CarConnectivityError as e:
                                     LOG.error('Error while fetching air conditioning: %s', e)
                     elif 'name' in data and data['name'] == 'climatisation-completed':
@@ -582,6 +589,7 @@ class SkodaMQTTClient(Client):  # pylint: disable=too-many-instance-attributes
                                             self._skoda_connector.fetch_air_conditioning(vehicle, no_cache=True)
                                         except CarConnectivityError as e:
                                             LOG.error('Error while fetching air conditioning: %s', e)
+                                    self._skoda_connector.car_connectivity.transaction_end()
 
                                 if vin in self.delayed_access_function_timers:
                                     self.delayed_access_function_timers[vin].cancel()
@@ -598,6 +606,7 @@ class SkodaMQTTClient(Client):  # pylint: disable=too-many-instance-attributes
                             if isinstance(vehicle, SkodaVehicle):
                                 try:
                                     self._skoda_connector.fetch_vehicle_status(vehicle, no_cache=True)
+                                    self._skoda_connector.car_connectivity.transaction_end()
                                 except CarConnectivityError as e:
                                     LOG.error('Error while fetching vehicle status: %s', e)
 
@@ -629,6 +638,7 @@ class SkodaMQTTClient(Client):  # pylint: disable=too-many-instance-attributes
                                 LOG.debug('Received %s operation request for vehicle %s from user %s', operation_request, vin, user_id)
                                 try:
                                     self._skoda_connector.fetch_air_conditioning(vehicle, no_cache=True)
+                                    self._skoda_connector.car_connectivity.transaction_end()
                                 except CarConnectivityError as e:
                                     LOG.error('Error while fetching air-conditioning: %s', e)
                                 return
@@ -649,6 +659,7 @@ class SkodaMQTTClient(Client):  # pylint: disable=too-many-instance-attributes
                                 LOG.debug('Received %s operation request for vehicle %s from user %s', operation_request, vin, user_id)
                                 try:
                                     self._skoda_connector.fetch_charging(vehicle, no_cache=True)
+                                    self._skoda_connector.car_connectivity.transaction_end()
                                 except CarConnectivityError as e:
                                     LOG.error('Error while fetching charging: %s', e)
                                 return

carconnectivity_connectors/skoda/ui/connector_ui.py

@@ -0,0 +1,39 @@
+""" User interface for the Skoda connector in the Car Connectivity application. """
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+import os
+
+import flask
+
+from carconnectivity_connectors.base.ui.connector_ui import BaseConnectorUI
+
+if TYPE_CHECKING:
+    from typing import Optional, List, Dict, Union, Literal
+
+    from carconnectivity_connectors.base.connector import BaseConnector
+
+
+class ConnectorUI(BaseConnectorUI):
+    """
+    A user interface class for the Skoda connector in the Car Connectivity application.
+    """
+    def __init__(self, connector: BaseConnector):
+        blueprint: Optional[flask.Blueprint] = flask.Blueprint(name='skoda', import_name='carconnectivity-connector-skoda', url_prefix='/skoda',
+                                                                    template_folder=os.path.dirname(__file__) + '/templates')
+        super().__init__(connector, blueprint=blueprint)
+
+    def get_nav_items(self) -> List[Dict[Literal['text', 'url', 'sublinks', 'divider'], Union[str, List]]]:
+        """
+        Generates a list of navigation items for the Skoda connector UI.
+        """
+        return super().get_nav_items()
+
+    def get_title(self) -> str:
+        """
+        Returns the title of the connector.
+
+        Returns:
+            str: The title of the connector, which is "Skoda".
+        """
+        return "Skoda"

carconnectivity_connectors/skoda/vehicle.py

@@ -4,9 +4,11 @@ from typing import TYPE_CHECKING
 
 from carconnectivity.vehicle import GenericVehicle, ElectricVehicle, CombustionVehicle, HybridVehicle
 from carconnectivity.charging import Charging
+from carconnectivity.attributes import BooleanAttribute
 
 from carconnectivity_connectors.skoda.capability import Capabilities
 from carconnectivity_connectors.skoda.charging import SkodaCharging
+from carconnectivity_connectors.skoda.climatization import SkodaClimatization
 
 SUPPORT_IMAGES = False
 try:
@@ -31,12 +33,16 @@ class SkodaVehicle(GenericVehicle):  # pylint: disable=too-many-instance-attribu
             super().__init__(origin=origin)
             self.capabilities: Capabilities = origin.capabilities
             self.capabilities.parent = self
+            self.in_motion: BooleanAttribute = origin.in_motion
+            self.in_motion.parent = self
             if SUPPORT_IMAGES:
                 self._car_images = origin._car_images
 
         else:
             super().__init__(vin=vin, garage=garage, managing_connector=managing_connector)
+            self.climatization = SkodaClimatization(vehicle=self, origin=self.climatization)
             self.capabilities = Capabilities(vehicle=self)
+            self.in_motion = BooleanAttribute(name='in_motion', parent=self, tags={'connector_custom'})
             if SUPPORT_IMAGES:
                 self._car_images: Dict[str, Image.Image] = {}
         self.manufacturer._set_value(value='Škoda')  # pylint: disable=protected-access

carconnectivity_connector_skoda-0.2a5.dist-info/RECORD

@@ -1,22 +0,0 @@
-carconnectivity_connectors/skoda/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-carconnectivity_connectors/skoda/_version.py,sha256=a3v4YSZuX3dc1rsmKxffi4xGREQvzv2JwGo2cmifdH4,408
-carconnectivity_connectors/skoda/capability.py,sha256=vbAKK8KKre-CndLF6_5qyWLpfa4KZHk1U-hpb6nCL5w,4225
-carconnectivity_connectors/skoda/charging.py,sha256=CoUOYHHUPPPldKQvv0h-qrUsoEtstR3iUx-l0IU5rNM,6798
-carconnectivity_connectors/skoda/climatization.py,sha256=-Nk4tO5C5_YYNQfUIUWBL7mGgR6-J0_pOZplLK8p_ms,1627
-carconnectivity_connectors/skoda/command_impl.py,sha256=WdgxWPgi82-UgmyFpiSZE-KHRtRjqn7CH-YX9N3bAoI,2875
-carconnectivity_connectors/skoda/connector.py,sha256=87k1cfXCQt8vqfc8OTudTjWQ3-nyPbwZTityRmUaFfQ,111127
-carconnectivity_connectors/skoda/error.py,sha256=ffxzvjmci7vtp9Q1K4DR1kBF0kTJxN5Gluci3kDBkEI,2459
-carconnectivity_connectors/skoda/mqtt_client.py,sha256=PHvMkNhmkP_FxHvVlXzFLJA6Q3vkFCK8jZHkfII_j74,38123
-carconnectivity_connectors/skoda/vehicle.py,sha256=EhrhAY41A05S2yf5YoU-uvo_alAiSdjFuAyLW318DJw,3383
-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
-carconnectivity_connectors/skoda/auth/openid_session.py,sha256=5JfR-gS1uKpE8DD-sx5Qvw6zv-OJhzcRlt0D-cm38-Y,16832
-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.2a5.dist-info/LICENSE,sha256=PIwI1alwDyOfvEQHdGCm2u9uf_mGE8030xZDfun0xTo,1071
-carconnectivity_connector_skoda-0.2a5.dist-info/METADATA,sha256=BveQjEfxoeoepVP7gk4EOLaadbA8c1E0HvToCb-nzj0,5365
-carconnectivity_connector_skoda-0.2a5.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-carconnectivity_connector_skoda-0.2a5.dist-info/top_level.txt,sha256=KqA8GviZsDH4PtmnwSQsz0HB_w-TWkeEHLIRNo5dTaI,27
-carconnectivity_connector_skoda-0.2a5.dist-info/RECORD,,