carconnectivity-connector-skoda 0.1a7__tar.gz → 0.1a9__tar.gz

{carconnectivity_connector_skoda-0.1a7 → carconnectivity_connector_skoda-0.1a9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: carconnectivity-connector-skoda
-Version: 0.1a7
+Version: 0.1a9
 Summary: CarConnectivity connector for Skoda services
 Author: Till Steinbach
 License: MIT License

{carconnectivity_connector_skoda-0.1a7 → carconnectivity_connector_skoda-0.1a9}/src/carconnectivity_connector_skoda.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: carconnectivity-connector-skoda
-Version: 0.1a7
+Version: 0.1a9
 Summary: CarConnectivity connector for Skoda services
 Author: Till Steinbach
 License: MIT License

{carconnectivity_connector_skoda-0.1a7 → carconnectivity_connector_skoda-0.1a9}/src/carconnectivity_connector_skoda.egg-info/SOURCES.txt

@@ -20,6 +20,7 @@ src/carconnectivity_connector_skoda.egg-info/top_level.txt
 src/carconnectivity_connectors/skoda/__init__.py
 src/carconnectivity_connectors/skoda/_version.py
 src/carconnectivity_connectors/skoda/capability.py
+src/carconnectivity_connectors/skoda/charging.py
 src/carconnectivity_connectors/skoda/connector.py
 src/carconnectivity_connectors/skoda/mqtt_client.py
 src/carconnectivity_connectors/skoda/vehicle.py

{carconnectivity_connector_skoda-0.1a7 → carconnectivity_connector_skoda-0.1a9}/src/carconnectivity_connectors/skoda/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.1a7'
+__version__ = version = '0.1a9'
 __version_tuple__ = version_tuple = (0, 1)

carconnectivity_connector_skoda-0.1a9/src/carconnectivity_connectors/skoda/charging.py

@@ -0,0 +1,67 @@
+"""
+Module for charging for skoda vehicles.
+"""
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+from enum import Enum
+
+from carconnectivity.charging import Charging
+
+if TYPE_CHECKING:
+    from typing import Dict
+
+
+class SkodaCharging(Charging):  # pylint: disable=too-many-instance-attributes
+    """
+    SkodaCharging class for handling Skoda vehicle charging information.
+
+    This class extends the Charging class and includes an enumeration of various 
+    charging states specific to Skoda vehicles.
+    """
+    class SkodaChargingState(Enum,):
+        """
+        Enum representing the various charging states for a Skoda vehicle.
+
+        Attributes:
+            OFF: The vehicle is not charging.
+            READY_FOR_CHARGING: The vehicle is ready to start charging.
+            NOT_READY_FOR_CHARGING: The vehicle is not ready to start charging.
+            CONSERVATION: The vehicle is in conservation mode.
+            CHARGE_PURPOSE_REACHED_NOT_CONSERVATION_CHARGING: The vehicle has reached its charging purpose and is not in conservation charging mode.
+            CHARGE_PURPOSE_REACHED_CONSERVATION: The vehicle has reached its charging purpose and is in conservation charging mode.
+            CHARGING: The vehicle is currently charging.
+            ERROR: There is an error in the charging process.
+            UNSUPPORTED: The charging state is unsupported.
+            DISCHARGING: The vehicle is discharging.
+            UNKNOWN: The charging state is unknown.
+        """
+        OFF = 'off'
+        CONNECT_CABLE = 'connectCable'
+        READY_FOR_CHARGING = 'readyForCharging'
+        NOT_READY_FOR_CHARGING = 'notReadyForCharging'
+        CONSERVATION = 'conservation'
+        CHARGE_PURPOSE_REACHED_NOT_CONSERVATION_CHARGING = 'chargePurposeReachedAndNotConservationCharging'
+        CHARGE_PURPOSE_REACHED_CONSERVATION = 'chargePurposeReachedAndConservation'
+        CHARGING = 'charging'
+        ERROR = 'error'
+        UNSUPPORTED = 'unsupported'
+        DISCHARGING = 'discharging'
+        UNKNOWN = 'unknown charging state'
+
+
+# Mapping of Skoda charging states to generic charging states
+mapping_skoda_charging_state: Dict[SkodaCharging.SkodaChargingState, Charging.ChargingState] = {
+    SkodaCharging.SkodaChargingState.OFF: Charging.ChargingState.OFF,
+    SkodaCharging.SkodaChargingState.CONNECT_CABLE: Charging.ChargingState.OFF,
+    SkodaCharging.SkodaChargingState.READY_FOR_CHARGING: Charging.ChargingState.READY_FOR_CHARGING,
+    SkodaCharging.SkodaChargingState.NOT_READY_FOR_CHARGING: Charging.ChargingState.OFF,
+    SkodaCharging.SkodaChargingState.CONSERVATION: Charging.ChargingState.CONSERVATION,
+    SkodaCharging.SkodaChargingState.CHARGE_PURPOSE_REACHED_NOT_CONSERVATION_CHARGING: Charging.ChargingState.READY_FOR_CHARGING,
+    SkodaCharging.SkodaChargingState.CHARGE_PURPOSE_REACHED_CONSERVATION: Charging.ChargingState.CONSERVATION,
+    SkodaCharging.SkodaChargingState.CHARGING: Charging.ChargingState.CHARGING,
+    SkodaCharging.SkodaChargingState.ERROR: Charging.ChargingState.ERROR,
+    SkodaCharging.SkodaChargingState.UNSUPPORTED: Charging.ChargingState.UNSUPPORTED,
+    SkodaCharging.SkodaChargingState.DISCHARGING: Charging.ChargingState.DISCHARGING,
+    SkodaCharging.SkodaChargingState.UNKNOWN: Charging.ChargingState.UNKNOWN
+}

{carconnectivity_connector_skoda-0.1a7 → carconnectivity_connector_skoda-0.1a9}/src/carconnectivity_connectors/skoda/connector.py

@@ -6,7 +6,7 @@ import threading
 import os
 import logging
 import netrc
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, timezone
 import requests
 
 from carconnectivity.garage import Garage
@@ -20,12 +20,15 @@ from carconnectivity.windows import Windows
 from carconnectivity.lights import Lights
 from carconnectivity.drive import GenericDrive, ElectricDrive, CombustionDrive
 from carconnectivity.attributes import BooleanAttribute, DurationAttribute
+from carconnectivity.charging import Charging
+from carconnectivity.position import Position
 
 from carconnectivity_connectors.base.connector import BaseConnector
 from carconnectivity_connectors.skoda.auth.session_manager import SessionManager, SessionUser, Service
 from carconnectivity_connectors.skoda.auth.my_skoda_session import MySkodaSession
 from carconnectivity_connectors.skoda.vehicle import SkodaVehicle, SkodaElectricVehicle, SkodaCombustionVehicle, SkodaHybridVehicle
 from carconnectivity_connectors.skoda.capability import Capability
+from carconnectivity_connectors.skoda.charging import SkodaCharging, mapping_skoda_charging_state
 from carconnectivity_connectors.skoda._version import __version__
 from carconnectivity_connectors.skoda.mqtt_client import SkodaMQTTClient
 
@@ -150,12 +153,17 @@ class Connector(BaseConnector):
 
     def _background_loop(self) -> None:
         self._stop_event.clear()
+        fetch: bool = True
         while not self._stop_event.is_set():
             interval = 300
             try:
                 try:
-                    self.fetch_all()
-                    self.last_update._set_value(value=datetime.now())  # pylint: disable=protected-access
+                    if fetch:
+                        self.fetch_all()
+                        fetch = False
+                    else:
+                        self.update_vehicles()
+                    self.last_update._set_value(value=datetime.now(tz=timezone.utc))  # pylint: disable=protected-access
                     if self.interval.value is not None:
                         interval: int = self.interval.value.total_seconds()
                 except Exception:
@@ -267,15 +275,37 @@ class Connector(BaseConnector):
                             vehicle.license_plate._set_value(None)  # pylint: disable=protected-access
 
                         log_extra_keys(LOG_API, 'vehicles', vehicle_dict,  {'vin', 'licensePlate'})
-                        vehicle = self.fetch_vehicle_status(vehicle)
-                        if isinstance(vehicle, SkodaElectricVehicle):
-                            vehicle = self.fetch_charging(vehicle)
+
+                        vehicle = self.fetch_vehicle_details(vehicle)
                     else:
                         raise APIError('Could not parse vehicle, vin missing')
         for vin in set(garage.list_vehicle_vins()) - seen_vehicle_vins:
             vehicle_to_remove = garage.get_vehicle(vin)
             if vehicle_to_remove is not None and vehicle_to_remove.is_managed_by_connector(self):
                 garage.remove_vehicle(vin)
+        self.update_vehicles()
+
+    def update_vehicles(self) -> None:
+        """
+        Updates the status of all vehicles in the garage managed by this connector.
+
+        This method iterates through all vehicle VINs in the garage, and for each vehicle that is
+        managed by this connector and is an instance of SkodaVehicle, it updates the vehicle's status
+        by fetching data from various APIs. If the vehicle is an instance of SkodaElectricVehicle,
+        it also fetches charging information.
+
+        Returns:
+            None
+        """
+        garage: Garage = self.car_connectivity.garage
+        for vin in set(garage.list_vehicle_vins()):
+            vehicle_to_update: Optional[GenericVehicle] = garage.get_vehicle(vin)
+            if vehicle_to_update is not None and isinstance(vehicle_to_update, SkodaVehicle) and vehicle_to_update.is_managed_by_connector(self):
+                vehicle_to_update = self.fetch_vehicle_status_second_api(vehicle_to_update)
+                vehicle_to_update = self.fetch_driving_range(vehicle_to_update)
+                vehicle_to_update = self.fetch_position(vehicle_to_update)
+                if isinstance(vehicle_to_update, SkodaElectricVehicle):
+                    vehicle_to_update = self.fetch_charging(vehicle_to_update)
 
     def fetch_charging(self, vehicle: SkodaElectricVehicle) -> SkodaElectricVehicle:
         """
@@ -301,6 +331,18 @@ class Connector(BaseConnector):
             else:
                 raise APIError('Could not fetch charging, carCapturedTimestamp missing')
             if 'status' in data and data['status'] is not None:
+                if 'state' in data['status'] and data['status']['state'] is not None:
+                    if data['status']['state'] in [item.name for item in SkodaCharging.SkodaChargingState]:
+                        skoda_charging_state = SkodaCharging.SkodaChargingState[data['status']['state']]
+                        charging_state: Charging.ChargingState = mapping_skoda_charging_state[skoda_charging_state]
+                    else:
+                        LOG_API.info('Unkown charging state %s not in %s', data['status']['state'], str(SkodaCharging.SkodaChargingState))
+                        charging_state = Charging.ChargingState.UNKNOWN
+
+                    # pylint: disable-next=protected-access
+                    vehicle.charging.state._set_value(value=charging_state, measured=captured_at)
+                else:
+                    vehicle.charging.state._set_value(None, measured=captured_at)  # pylint: disable=protected-access
                 if 'chargingRateInKilometersPerHour' in data['status'] and data['status']['chargingRateInKilometersPerHour'] is not None:
                     # pylint: disable-next=protected-access
                     vehicle.charging.rate._set_value(value=data['status']['chargingRateInKilometersPerHour'], measured=captured_at, unit=Speed.KMH)
@@ -319,13 +361,68 @@ class Connector(BaseConnector):
                     vehicle.charging.remaining_duration._set_value(None, measured=captured_at)  # pylint: disable=protected-access
                 log_extra_keys(LOG_API, 'status', data['status'],  {'chargingRateInKilometersPerHour',
                                                                     'chargePowerInKw',
-                                                                    'remainingTimeToFullyChargedInMinutes'})
+                                                                    'remainingTimeToFullyChargedInMinutes',
+                                                                    'state'})
             log_extra_keys(LOG_API, 'charging data', data,  {'carCapturedTimestamp', 'status'})
         return vehicle
 
-    def fetch_vehicle_status(self, vehicle: SkodaVehicle) -> SkodaVehicle:
+    def fetch_position(self, vehicle: SkodaVehicle) -> SkodaVehicle:
+        """
+        Fetches the position of the given Skoda vehicle and updates its position attributes.
+
+        Args:
+            vehicle (SkodaVehicle): The Skoda vehicle object containing the VIN and position attributes.
+
+        Returns:
+            SkodaVehicle: The updated Skoda vehicle object with the fetched position data.
+
+        Raises:
+            APIError: If the VIN is missing.
+            ValueError: If the vehicle has no position 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/v1/maps/positions?vin={vin}'
+        data: Dict[str, Any] | None = self._fetch_data(url, session=self.session)
+        if data is not None:
+            if 'positions' in data and data['positions'] is not None:
+                for position_dict in data['positions']:
+                    if 'type' in position_dict and position_dict['type'] == 'VEHICLE':
+                        if 'gpsCoordinates' in position_dict and position_dict['gpsCoordinates'] is not None:
+                            if 'latitude' in position_dict['gpsCoordinates'] and position_dict['gpsCoordinates']['latitude'] is not None:
+                                latitude: Optional[float] = position_dict['gpsCoordinates']['latitude']
+                            else:
+                                latitude = None
+                            if 'longitude' in position_dict['gpsCoordinates'] and position_dict['gpsCoordinates']['longitude'] is not None:
+                                longitude: Optional[float] = position_dict['gpsCoordinates']['longitude']
+                            else:
+                                longitude = None
+                            vehicle.position.latitude._set_value(latitude)  # pylint: disable=protected-access
+                            vehicle.position.longitude._set_value(longitude)  # pylint: disable=protected-access
+                            vehicle.position.position_type._set_value(Position.PositionType.PARKING)  # pylint: disable=protected-access
+                        else:
+                            vehicle.position.latitude._set_value(None)  # pylint: disable=protected-access
+                            vehicle.position.longitude._set_value(None)  # pylint: disable=protected-access
+                            vehicle.position.position_type._set_value(None)  # pylint: disable=protected-access
+                    else:
+                        vehicle.position.latitude._set_value(None)  # pylint: disable=protected-access
+                        vehicle.position.longitude._set_value(None)  # pylint: disable=protected-access
+                        vehicle.position.position_type._set_value(None)  # pylint: disable=protected-access
+                    log_extra_keys(LOG_API, 'positions', position_dict,  {'type',
+                                                                          'gpsCoordinates',
+                                                                          'address'})
+            else:
+                vehicle.position.latitude._set_value(None)  # pylint: disable=protected-access
+                vehicle.position.longitude._set_value(None)  # pylint: disable=protected-access
+                vehicle.position.position_type._set_value(None)  # pylint: disable=protected-access
+        return vehicle
+
+    def fetch_vehicle_details(self, vehicle: SkodaVehicle) -> SkodaVehicle:
         """
-        Fetches the status of a vehicle from the Skoda API.
+        Fetches the details of a vehicle from the Skoda API.
 
         Args:
             vehicle (GenericVehicle): The vehicle object containing the VIN.
@@ -374,7 +471,30 @@ class Connector(BaseConnector):
             else:
                 vehicle.model._set_value(None)  # pylint: disable=protected-access
             log_extra_keys(LOG_API, 'api/v2/garage/vehicles/VIN', vehicle_data, {'softwareVersion'})
+        return vehicle
+
+    def fetch_driving_range(self, vehicle: SkodaVehicle) -> SkodaVehicle:
+        """
+        Fetches the driving range data for a given Skoda vehicle and updates the vehicle object accordingly.
 
+        Args:
+            vehicle (SkodaVehicle): The Skoda vehicle object for which to fetch the driving range data.
+
+        Returns:
+            SkodaVehicle: The updated Skoda vehicle object with the fetched driving range data.
+
+        Raises:
+            APIError: If the vehicle's VIN is missing.
+
+        Notes:
+            - The method fetches data from the Skoda API using the vehicle's VIN.
+            - It updates the vehicle's type if the fetched data indicates a different type (e.g., electric, combustion, hybrid).
+            - It updates the vehicle's total range and individual drive ranges (primary and secondary) based on the fetched data.
+            - It logs warnings for unknown car types and engine types.
+        """
+        vin = vehicle.vin.value
+        if vin is None:
+            raise APIError('VIN is missing')
         url = f'https://mysmob.api.connect.skoda-auto.cz/api/v2/vehicle-status/{vin}/driving-range'
         range_data: Dict[str, Any] | None = self._fetch_data(url, self.session)
         if range_data:
@@ -461,7 +581,21 @@ class Connector(BaseConnector):
                                                                                                'totalRangeInKm',
                                                                                                'primaryEngineRange',
                                                                                                'secondaryEngineRange'})
+        return vehicle
 
+    def fetch_vehicle_status_second_api(self, vehicle: SkodaVehicle) -> SkodaVehicle:
+        """
+        Fetches the status of a vehicle from other Skoda API.
+
+        Args:
+            vehicle (GenericVehicle): The vehicle object containing the VIN.
+
+        Returns:
+            None
+        """
+        vin = vehicle.vin.value
+        if vin is None:
+            raise APIError('VIN is missing')
         url = f'https://api.connect.skoda-auto.cz/api/v2/vehicle-status/{vin}'
         vehicle_status_data: Dict[str, Any] | None = self._fetch_data(url, self.session)
         if vehicle_status_data:

{carconnectivity_connector_skoda-0.1a7 → carconnectivity_connector_skoda-0.1a9}/src/carconnectivity_connectors/skoda/mqtt_client.py

@@ -7,15 +7,21 @@ import logging
 import uuid
 import ssl
 import json
-from datetime import timedelta
+from datetime import timedelta, timezone
 
 from paho.mqtt.client import Client
 from paho.mqtt.enums import MQTTProtocolVersion, CallbackAPIVersion, MQTTErrorCode
 
+from carconnectivity.errors import CarConnectivityError
 from carconnectivity.observable import Observable
-from carconnectivity.vehicle import GenericVehicle, ElectricVehicle
+from carconnectivity.vehicle import GenericVehicle
+
 from carconnectivity.drive import ElectricDrive
 from carconnectivity.util import robust_time_parse, log_extra_keys
+from carconnectivity.charging import Charging
+
+from carconnectivity_connectors.skoda.vehicle import SkodaElectricVehicle
+from carconnectivity_connectors.skoda.charging import SkodaCharging, mapping_skoda_charging_state
 
 
 if TYPE_CHECKING:
@@ -101,7 +107,7 @@ class SkodaMQTTClient(Client):  # pylint: disable=too-many-instance-attributes
         if (flags & Observable.ObserverEvent.ENABLED) and isinstance(element, GenericVehicle):
             self._subscribe_vehicle(element)
         elif (flags & Observable.ObserverEvent.DISABLED) and isinstance(element, GenericVehicle):
-            self._subscribe_vehicle(element)
+            self._unsubscribe_vehicle(element)
 
     def _subscribe_vehicles(self) -> None:
         """
@@ -235,15 +241,12 @@ class SkodaMQTTClient(Client):  # pylint: disable=too-many-instance-attributes
             - Warning if the vehicle's VIN is not enabled or is None.
             - Info for each topic successfully unsubscribed.
         """
-        if not vehicle.vin.enabled or vehicle.vin.value is None:
-            LOG.warning('Could not unsubscribe to vehicle without vin')
-        else:
-            vin: str = vehicle.vin.value
-            for topic in self.subscribed_topics:
-                if vin in topic:
-                    self.unsubscribe(topic)
-                    self.subscribed_topics.remove(topic)
-                    LOG.debug('Unsubscribed from topic %s', topic)
+        vin: str = vehicle.id
+        for topic in self.subscribed_topics:
+            if vin in topic:
+                self.unsubscribe(topic)
+                self.subscribed_topics.remove(topic)
+                LOG.debug('Unsubscribed from topic %s', topic)
 
     def _on_connect_callback(self, mqttc, obj, flags, reason_code, properties) -> None:
         """
@@ -444,27 +447,56 @@ class SkodaMQTTClient(Client):  # pylint: disable=too-many-instance-attributes
                 if 'timestamp' in data and data['timestamp'] is not None:
                     measured_at: datetime = robust_time_parse(data['timestamp'])
                 else:
-                    measured_at: datetime = datetime.now()
+                    measured_at: datetime = datetime.now(tz=timezone.utc)
                 if service_event == 'charging':
                     if 'name' in data and data['name'] == 'change-charge-mode' or data['name'] == 'change-soc':
                         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, ElectricVehicle):
+                            if isinstance(vehicle, SkodaElectricVehicle):
                                 electric_drive: 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
+                                    if 'state' in data['data'] and data['data']['state'] is not None:
+                                        if data['data']['state'] in [item.value for item in SkodaCharging.SkodaChargingState]:
+                                            skoda_charging_state = SkodaCharging.SkodaChargingState(data['data']['state'])
+                                            charging_state = mapping_skoda_charging_state[skoda_charging_state]
+                                        else:
+                                            LOG_API.info('Unkown charging state %s not in %s', data['data']['state'], str(SkodaCharging.SkodaChargingState))
+                                            charging_state = Charging.ChargingState.UNKNOWN
+                                        # pylint: disable-next=protected-access
+                                        vehicle.charging.state._set_value(value=charging_state, measured=measured_at)
+                                        if charging_state == Charging.ChargingState.OFF:
+                                            # pylint: disable-next=protected-access
+                                            vehicle.charging.type._set_value(value=Charging.ChargingType.OFF, measured=measured_at)
+                                            # pylint: disable-next=protected-access
+                                            vehicle.charging.rate._set_value(value=0, measured=measured_at)
+                                            # pylint: disable-next=protected-access
+                                            vehicle.charging.power._set_value(value=0, measured=measured_at)
                                     if 'soc' in data['data'] and data['data']['soc'] is not None:
                                         electric_drive.level._set_value(measured=measured_at, value=data['data']['soc'])  # pylint: disable=protected-access
                                     if 'chargedRange' in data['data'] and data['data']['chargedRange'] is not None:
                                         # pylint: disable-next=protected-access
                                         electric_drive.range._set_value(measured=measured_at, value=data['data']['chargedRange'])
+                                    # If charging state changed, fetch charging again
+                                    if old_charging_state != charging_state:
+                                        try:
+                                            self._skoda_connector.fetch_charging(vehicle)
+                                        except CarConnectivityError as e:
+                                            LOG.error('Error while fetching charging: %s', e)
                                 if 'timeToFinish' in data['data'] and data['data']['timeToFinish'] is not None \
                                         and vehicle.charging is not None:
-                                    remaining_duration: timedelta = timedelta(minutes=data['data']['timeToFinish'])
+                                    try:
+                                        remaining_duration: Optional[timedelta] = timedelta(minutes=int(data['data']['timeToFinish']))
+                                    except ValueError:
+                                        remaining_duration: Optional[timedelta] = None
                                     # pylint: disable-next=protected-access
                                     vehicle.charging.remaining_duration._set_value(measured=measured_at, value=remaining_duration)
-                                log_extra_keys(LOG_API, 'data', data['data'],  {'vin', 'userId', 'soc', 'chargedRange', 'timeToFinish'})
+                                log_extra_keys(LOG_API, 'data', data['data'],  {'vin', 'userId', 'soc', 'chargedRange', 'timeToFinish', 'state'})
                                 LOG.debug('Received %s event for vehicle %s from user %s', data['name'], vin, user_id)
                                 return
+                            else:
+                                LOG.debug('Discarded %s event for vehicle %s from user %s: vehicle is not an electric vehicle', data['name'], vin, user_id)
                     LOG_API.info('Received event name %s service event %s for vehicle %s from user %s: %s', data['name'],
                                  service_event, vin, user_id, msg.payload)
                     return