carconnectivity-connector-skoda 0.1a9__py3-none-any.whl → 0.1a10__py3-none-any.whl

{carconnectivity_connector_skoda-0.1a9.dist-info → carconnectivity_connector_skoda-0.1a10.dist-info}/METADATA

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

{carconnectivity_connector_skoda-0.1a9.dist-info → carconnectivity_connector_skoda-0.1a10.dist-info}/RECORD

@@ -1,19 +1,19 @@
 carconnectivity_connectors/skoda/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-carconnectivity_connectors/skoda/_version.py,sha256=SmWP1wxex0Jz9QX1vssYQ7oA2LcafCkYCa3HnNL8JV8,408
+carconnectivity_connectors/skoda/_version.py,sha256=-6RZUfHP4tKhu5IUXqJlxl_E1uda42gm5BR0t7cpGAg,409
 carconnectivity_connectors/skoda/capability.py,sha256=JlNEaisVYF8qWv0wNDHTaas36uIpTIQ3NVR69wesiYQ,4513
 carconnectivity_connectors/skoda/charging.py,sha256=oDHxZxrfTMvtYCJxmGfKFeWVMH4ceQ5HTKRAspnsunU,3312
-carconnectivity_connectors/skoda/connector.py,sha256=dPdNsgurP8N7DZCfTuNBSohmeph2-vocfJgnVfmJYvI,53482
-carconnectivity_connectors/skoda/mqtt_client.py,sha256=VoYGHTxQbLX8WW1HWWZaJF1-hLxz0FGYR9RfLrY2LCI,25387
+carconnectivity_connectors/skoda/connector.py,sha256=c0vi2H-yoJM6uX7PMIWLzJ-YeksyXyqBMpJT21uyc_I,61826
+carconnectivity_connectors/skoda/mqtt_client.py,sha256=ZESgR4JRPPgAiLLEPvcnD6UeSaL-dMC1MvOWaqDdvj8,27944
 carconnectivity_connectors/skoda/vehicle.py,sha256=H3GRDNimMghFwFi--y9BsgoSK3pMibNf_l6SsDN6gvQ,2759
 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=PLWSSKw9Dg7hBbhzJ_nEycNrqiG6GiEM15h2wduL8jI,16592
+carconnectivity_connectors/skoda/auth/openid_session.py,sha256=LusWi2FZZIL3buodGXZKUR0naLhhqeYv0uRW4V3wI2w,16842
 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.1a9.dist-info/LICENSE,sha256=PIwI1alwDyOfvEQHdGCm2u9uf_mGE8030xZDfun0xTo,1071
-carconnectivity_connector_skoda-0.1a9.dist-info/METADATA,sha256=dbKJrcPF2Xvw3mFX5H6njG5cFKPbWDl-MHn444vV4H0,5326
-carconnectivity_connector_skoda-0.1a9.dist-info/WHEEL,sha256=A3WOREP4zgxI0fKrHUG8DC8013e3dK3n7a6HDbcEIwE,91
-carconnectivity_connector_skoda-0.1a9.dist-info/top_level.txt,sha256=KqA8GviZsDH4PtmnwSQsz0HB_w-TWkeEHLIRNo5dTaI,27
-carconnectivity_connector_skoda-0.1a9.dist-info/RECORD,,
+carconnectivity_connector_skoda-0.1a10.dist-info/LICENSE,sha256=PIwI1alwDyOfvEQHdGCm2u9uf_mGE8030xZDfun0xTo,1071
+carconnectivity_connector_skoda-0.1a10.dist-info/METADATA,sha256=_xdTO18nMfBi4hYnpdo6Cr3kCHegfhu9IJ1_EJIJOBo,5327
+carconnectivity_connector_skoda-0.1a10.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+carconnectivity_connector_skoda-0.1a10.dist-info/top_level.txt,sha256=KqA8GviZsDH4PtmnwSQsz0HB_w-TWkeEHLIRNo5dTaI,27
+carconnectivity_connector_skoda-0.1a10.dist-info/RECORD,,

{carconnectivity_connector_skoda-0.1a9.dist-info → carconnectivity_connector_skoda-0.1a10.dist-info}/WHEEL

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

carconnectivity_connectors/skoda/_version.py

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

carconnectivity_connectors/skoda/auth/openid_session.py

@@ -112,6 +112,10 @@ class OpenIDSession(requests.Session):
         if new_retries_value:
             # Retry on internal server error (500)
             retries = BlacklistRetry(total=new_retries_value,
+                                     connect=new_retries_value,
+                                     read=new_retries_value,
+                                     status=new_retries_value,
+                                     other=new_retries_value,
                                      backoff_factor=0.1,
                                      status_forcelist=[500],
                                      status_blacklist=[429],

carconnectivity_connectors/skoda/connector.py

@@ -14,7 +14,7 @@ from carconnectivity.vehicle import GenericVehicle
 from carconnectivity.errors import AuthenticationError, TooManyRequestsError, RetrievalError, APIError, APICompatibilityError, \
     TemporaryAuthenticationError, ConfigurationError
 from carconnectivity.util import robust_time_parse, log_extra_keys, config_remove_credentials
-from carconnectivity.units import Length, Speed, Power
+from carconnectivity.units import Length, Speed, Power, Temperature
 from carconnectivity.doors import Doors
 from carconnectivity.windows import Windows
 from carconnectivity.lights import Lights
@@ -22,6 +22,7 @@ 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.climatization import Climatization
 
 from carconnectivity_connectors.base.connector import BaseConnector
 from carconnectivity_connectors.skoda.auth.session_manager import SessionManager, SessionUser, Service
@@ -303,9 +304,13 @@ class Connector(BaseConnector):
             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)
+                if vehicle_to_update.capabilities is not None and vehicle_to_update.capabilities.enabled:
+                    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)
 
     def fetch_charging(self, vehicle: SkodaElectricVehicle) -> SkodaElectricVehicle:
         """
@@ -355,10 +360,11 @@ class Connector(BaseConnector):
                     vehicle.charging.power._set_value(None, measured=captured_at, unit=Power.KW)  # pylint: disable=protected-access
                 if 'remainingTimeToFullyChargedInMinutes' in data['status'] and data['status']['remainingTimeToFullyChargedInMinutes'] is not None:
                     remaining_duration: timedelta = timedelta(minutes=data['status']['remainingTimeToFullyChargedInMinutes'])
+                    estimated_date_reached: datetime = captured_at + remaining_duration
                     # pylint: disable-next=protected-access
-                    vehicle.charging.remaining_duration._set_value(value=remaining_duration, measured=captured_at)
+                    vehicle.charging.estimated_date_reached._set_value(value=estimated_date_reached, measured=captured_at)
                 else:
-                    vehicle.charging.remaining_duration._set_value(None, measured=captured_at)  # pylint: disable=protected-access
+                    vehicle.charging.estimated_date_reached._set_value(None, measured=captured_at)  # pylint: disable=protected-access
                 log_extra_keys(LOG_API, 'status', data['status'],  {'chargingRateInKilometersPerHour',
                                                                     'chargePowerInKw',
                                                                     'remainingTimeToFullyChargedInMinutes',
@@ -420,6 +426,109 @@ class Connector(BaseConnector):
                 vehicle.position.position_type._set_value(None)  # pylint: disable=protected-access
         return vehicle
 
+    def fetch_air_conditioning(self, vehicle: SkodaVehicle) -> SkodaVehicle:
+        """
+        Fetches the air conditioning data for a given Skoda vehicle and updates the vehicle object with the retrieved data.
+
+        Args:
+            vehicle (SkodaVehicle): The vehicle object for which to fetch air conditioning data.
+
+        Returns:
+            SkodaVehicle: The updated vehicle object with the fetched air conditioning data.
+
+        Raises:
+            APIError: If the VIN is missing or if the carCapturedTimestamp is missing in the response data.
+            ValueError: If the vehicle has no charging object.
+
+        Notes:
+            - The method fetches data from the Skoda API using the vehicle's VIN.
+            - It updates the vehicle's climatization state, estimated date to reach target temperature, target temperature, and outside temperature.
+            - Logs additional keys found in the response data for debugging purposes.
+        """
+        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/v2/air-conditioning/{vin}'
+        data: Dict[str, Any] | None = self._fetch_data(url, session=self.session)
+        if data is not None:
+            if 'carCapturedTimestamp' in data and data['carCapturedTimestamp'] is not None:
+                captured_at: datetime = robust_time_parse(data['carCapturedTimestamp'])
+            else:
+                raise APIError('Could not fetch air conditioning, carCapturedTimestamp missing')
+            if 'state' in data and data['state'] is not None:
+                if data['state'] in [item.name for item in Climatization.ClimatizationState]:
+                    climatization_state: Climatization.ClimatizationState = Climatization.ClimatizationState[data['state']]
+                else:
+                    LOG_API.info('Unknown climatization state %s not in %s', data['state'], str(Climatization.ClimatizationState))
+                    climatization_state = Climatization.ClimatizationState.UNKNOWN
+                vehicle.climatization.state._set_value(value=climatization_state, measured=captured_at)  # pylint: disable=protected-access
+            else:
+                vehicle.climatization.state._set_value(None, measured=captured_at)  # pylint: disable=protected-access
+            if 'estimatedDateTimeToReachTargetTemperature' in data and data['estimatedDateTimeToReachTargetTemperature'] is not None:
+                estimated_reach: datetime = robust_time_parse(data['estimatedDateTimeToReachTargetTemperature'])
+                if estimated_reach is not None:
+                    vehicle.climatization.estimated_date_reached._set_value(value=estimated_reach, measured=captured_at)  # pylint: disable=protected-access
+                else:
+                    vehicle.climatization.estimated_date_reached._set_value(value=None, measured=captured_at)  # pylint: disable=protected-access
+            else:
+                vehicle.climatization.estimated_date_reached._set_value(value=None, measured=captured_at)  # pylint: disable=protected-access
+            if 'targetTemperature' in data and data['targetTemperature'] is not 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
+                    elif data['targetTemperature']['unitInCar'] == 'FAHRENHEIT':
+                        unit = Temperature.F
+                    elif data['targetTemperature']['unitInCar'] == 'KELVIN':
+                        unit = Temperature.K
+                    else:
+                        LOG_API.info('Unknown temperature unit for targetTemperature in air-conditioning %s', data['targetTemperature']['unitInCar'])
+                if 'temperatureValue' in data['targetTemperature'] and data['targetTemperature']['temperatureValue'] is not None:
+                    # pylint: disable-next=protected-access
+                    vehicle.climatization.target_temperature._set_value(value=data['targetTemperature']['temperatureValue'],
+                                                                        measured=captured_at,
+                                                                        unit=unit)
+                else:
+                    vehicle.climatization.target_temperature._set_value(value=None, measured=captured_at, unit=unit)  # pylint: disable=protected-access
+                log_extra_keys(LOG_API, 'targetTemperature', data['targetTemperature'],  {'unitInCar', 'temperatureValue'})
+            else:
+                # pylint: disable-next=protected-access
+                vehicle.climatization.target_temperature._set_value(value=None, measured=captured_at, unit=Temperature.UNKNOWN)
+            if 'outsideTemperature' in data and data['outsideTemperature'] is not None:
+                if 'carCapturedTimestamp' in data['outsideTemperature'] and data['outsideTemperature']['carCapturedTimestamp'] is not None:
+                    outside_captured_at: datetime = robust_time_parse(data['outsideTemperature']['carCapturedTimestamp'])
+                else:
+                    outside_captured_at = captured_at
+                if 'temperatureUnit' in data['outsideTemperature'] and data['outsideTemperature']['temperatureUnit'] is not None:
+                    unit: Temperature = Temperature.UNKNOWN
+                    if data['outsideTemperature']['temperatureUnit'] == 'CELSIUS':
+                        unit = Temperature.C
+                    elif data['outsideTemperature']['temperatureUnit'] == 'FAHRENHEIT':
+                        unit = Temperature.F
+                    elif data['outsideTemperature']['temperatureUnit'] == 'KELVIN':
+                        unit = Temperature.K
+                    else:
+                        LOG_API.info('Unknown temperature unit for outsideTemperature in air-conditioning %s', data['targetTemperature']['temperatureUnit'])
+                    if 'temperatureValue' in data['outsideTemperature'] and data['outsideTemperature']['temperatureValue'] is not None:
+                        # pylint: disable-next=protected-access
+                        vehicle.outside_temperature._set_value(value=data['outsideTemperature']['temperatureValue'],
+                                                               measured=outside_captured_at,
+                                                               unit=unit)
+                    else:
+                        # pylint: disable-next=protected-access
+                        vehicle.outside_temperature._set_value(value=None, measured=outside_captured_at, unit=Temperature.UNKNOWN)
+                else:
+                    # pylint: disable-next=protected-access
+                    vehicle.outside_temperature._set_value(value=None, measured=outside_captured_at, unit=Temperature.UNKNOWN)
+                log_extra_keys(LOG_API, 'targetTemperature', data['outsideTemperature'],  {'carCapturedTimestamp', 'temperatureUnit', 'temperatureValue'})
+            else:
+                vehicle.outside_temperature._set_value(value=None, measured=None, unit=Temperature.UNKNOWN)  # pylint: disable=protected-access
+            log_extra_keys(LOG_API, 'air-condition', data,  {'carCapturedTimestamp', 'state', 'estimatedDateTimeToReachTargetTemperature'
+                                                             'targetTemperature', 'outsideTemperature'})
+        return vehicle
+
     def fetch_vehicle_details(self, vehicle: SkodaVehicle) -> SkodaVehicle:
         """
         Fetches the details of a vehicle from the Skoda API.

carconnectivity_connectors/skoda/mqtt_client.py

@@ -20,7 +20,7 @@ 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.vehicle import SkodaVehicle, SkodaElectricVehicle
 from carconnectivity_connectors.skoda.charging import SkodaCharging, mapping_skoda_charging_state
 
 
@@ -437,7 +437,7 @@ class SkodaMQTTClient(Client):  # pylint: disable=too-many-instance-attributes
             return
 
         # service_events
-        match = re.match(r'^(?P<user_id>[0-9a-fA-F-]+)/(?P<vin>[A-Z0-9]+)/service-event/(?P<service_event>\w+)$', msg.topic)
+        match = re.match(r'^(?P<user_id>[0-9a-fA-F-]+)/(?P<vin>[A-Z0-9]+)/service-event/(?P<service_event>[a-zA-Z0-9-_]+)$', msg.topic)
         if match:
             user_id: str = match.group('user_id')
             vin: str = match.group('vin')
@@ -488,10 +488,11 @@ class SkodaMQTTClient(Client):  # pylint: disable=too-many-instance-attributes
                                         and vehicle.charging is not None:
                                     try:
                                         remaining_duration: Optional[timedelta] = timedelta(minutes=int(data['data']['timeToFinish']))
+                                        estimated_date_reached: Optional[datetime] = measured_at + remaining_duration
                                     except ValueError:
-                                        remaining_duration: Optional[timedelta] = None
+                                        estimated_date_reached: Optional[datetime] = None
                                     # pylint: disable-next=protected-access
-                                    vehicle.charging.remaining_duration._set_value(measured=measured_at, value=remaining_duration)
+                                    vehicle.charging.estimated_date_reached._set_value(measured=measured_at, value=estimated_date_reached)
                                 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
@@ -500,6 +501,39 @@ class SkodaMQTTClient(Client):  # pylint: disable=too-many-instance-attributes
                     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
+                elif service_event == 'air-conditioning':
+                    if 'name' in data and data['name'] == 'change-remaining-time':
+                        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, SkodaVehicle):
+                                try:
+                                    self._skoda_connector.fetch_air_conditioning(vehicle)
+                                except CarConnectivityError as e:
+                                    LOG.error('Error while fetching charging: %s', e)
+                    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
             LOG_API.info('Received unknown service event %s for vehicle %s from user %s: %s', service_event, vin, user_id, msg.payload)
             return
+        # service_events
+        match = re.match(r'^(?P<user_id>[0-9a-fA-F-]+)/(?P<vin>[A-Z0-9]+)/operation-request/(?P<operation_request>[a-zA-Z0-9-_/]+)$', msg.topic)
+        if match:
+            user_id: str = match.group('user_id')
+            vin: str = match.group('vin')
+            operation_request: str = match.group('operation_request')
+            data: Dict[str, Any] = json.loads(msg.payload)
+            if data is not None:
+                if operation_request == 'air-conditioning/start-stop-air-conditioning':
+                    vehicle: Optional[GenericVehicle] = self._skoda_connector.car_connectivity.garage.get_vehicle(vin)
+                    if isinstance(vehicle, SkodaVehicle):
+                        if 'status' in data and data['status'] is not None:
+                            if data['status'] == 'COMPLETED_SUCCESS':
+                                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)
+                                except CarConnectivityError as e:
+                                    LOG.error('Error while fetching air-conditioning: %s', e)
+                                return
+                    LOG_API.info('Received unknown operation request %s for vehicle %s from user %s: %s', operation_request, vin, user_id, msg.payload)
+                    return
         LOG_API.info('I don\'t understand message %s: %s', msg.topic, msg.payload)