carconnectivity-connector-skoda 0.4a3__tar.gz → 0.4a5__tar.gz

{carconnectivity_connector_skoda-0.4a3 → carconnectivity_connector_skoda-0.4a5}/PKG-INFO

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

{carconnectivity_connector_skoda-0.4a3 → carconnectivity_connector_skoda-0.4a5}/pyproject.toml

@@ -14,7 +14,7 @@ authors = [
     { name = "Till Steinbach" }
 ]
 dependencies = [
-    "carconnectivity>=0.4a4",
+    "carconnectivity>=0.4a8",
     "oauthlib~=3.2.2",
     "requests~=2.32.3",
     "jwt~=1.3.1",

{carconnectivity_connector_skoda-0.4a3 → carconnectivity_connector_skoda-0.4a5}/src/carconnectivity_connector_skoda.egg-info/PKG-INFO

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

{carconnectivity_connector_skoda-0.4a3 → carconnectivity_connector_skoda-0.4a5}/src/carconnectivity_connector_skoda.egg-info/requires.txt

@@ -1,4 +1,4 @@
-carconnectivity>=0.4a4
+carconnectivity>=0.4a8
 oauthlib~=3.2.2
 requests~=2.32.3
 jwt~=1.3.1

{carconnectivity_connector_skoda-0.4a3 → carconnectivity_connector_skoda-0.4a5}/src/carconnectivity_connectors/skoda/_version.py

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

{carconnectivity_connector_skoda-0.4a3 → carconnectivity_connector_skoda-0.4a5}/src/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_connector_skoda-0.4a3 → carconnectivity_connector_skoda-0.4a5}/src/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
@@ -22,7 +23,7 @@ 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
 from carconnectivity.charging import Charging
 from carconnectivity.position import Position
 from carconnectivity.climatization import Climatization
@@ -72,6 +73,7 @@ class Connector(BaseConnector):
     """
     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, log=LOG, api_log=LOG_API)
+        self._healthy = False
 
         self._mqtt_client: SkodaMQTTClient = SkodaMQTTClient(skoda_connector=self)
 
@@ -81,6 +83,16 @@ class Connector(BaseConnector):
 
         self.connected: BooleanAttribute = BooleanAttribute(name="connected", parent=self, tags={'connector_custom'})
         self.interval: DurationAttribute = DurationAttribute(name="interval", parent=self, tags={'connector_custom'})
+
+        def __check_interval(attribute: GenericAttribute, value: Any) -> Any:
+            del attribute
+            if value is not None and value < timedelta(seconds=180):
+                raise ValueError('Intervall must be at least 180 seconds')
+            return value
+
+        self.interval._is_changeable = True  # pylint: disable=protected-access
+        self.interval._add_on_set_hook(__check_interval)  # pylint: disable=protected-access
+
         self.commands: Commands = Commands(parent=self)
 
         self.user_id: Optional[str] = None
@@ -154,12 +166,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 = True
 
     def _background_connect_loop(self) -> None:
         while not self._stop_event.is_set():
@@ -204,6 +219,10 @@ class Connector(BaseConnector):
             except TemporaryAuthenticationError as err:
                 LOG.error('Temporary authentification error during update (%s). Will try again after configured interval of %ss', str(err), interval)
                 self._stop_event.wait(interval)
+            except Exception as err:
+                LOG.critical('Critical error during update: %s', traceback.format_exc())
+                self._healthy = False
+                raise err
             else:
                 self._stop_event.wait(interval)
 
@@ -236,12 +255,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:
@@ -339,6 +358,8 @@ 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):
@@ -347,6 +368,27 @@ class Connector(BaseConnector):
                         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)
+
+    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:
         """
@@ -555,6 +597,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:
         """
@@ -716,12 +793,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:
@@ -731,6 +815,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)
@@ -1428,9 +1516,10 @@ class Connector(BaseConnector):
             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'] * 2) / 2
+                    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')
@@ -1448,8 +1537,10 @@ class Connector(BaseConnector):
                         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 * 2) / 2
+                    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:
@@ -1681,3 +1772,6 @@ class Connector(BaseConnector):
         except requests.exceptions.RetryError as retry_error:
             raise CommandError(f'Retrying failed: {retry_error}') from retry_error
         return command_arguments
+
+    def is_healthy(self) -> bool:
+        return self._healthy and super().is_healthy()

{carconnectivity_connector_skoda-0.4a3 → carconnectivity_connector_skoda-0.4a5}/src/carconnectivity_connectors/skoda/vehicle.py

@@ -4,6 +4,7 @@ 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
@@ -32,6 +33,8 @@ 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
 
@@ -39,6 +42,7 @@ class SkodaVehicle(GenericVehicle):  # pylint: disable=too-many-instance-attribu
             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