carconnectivity-connector-seatcupra 0.1a5__tar.gz → 0.1a7__tar.gz

{carconnectivity_connector_seatcupra-0.1a5 → carconnectivity_connector_seatcupra-0.1a7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: carconnectivity-connector-seatcupra
-Version: 0.1a5
+Version: 0.1a7
 Summary: CarConnectivity connector for Seat and Cupra services
 Author: Till Steinbach
 License: MIT License
@@ -37,7 +37,7 @@ Classifier: Topic :: Software Development :: Libraries
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: carconnectivity>=0.4a3
+Requires-Dist: carconnectivity>=0.4a4
 Requires-Dist: oauthlib~=3.2.2
 Requires-Dist: requests~=2.32.3
 Requires-Dist: jwt~=1.3.1

{carconnectivity_connector_seatcupra-0.1a5 → carconnectivity_connector_seatcupra-0.1a7}/pyproject.toml

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

{carconnectivity_connector_seatcupra-0.1a5 → carconnectivity_connector_seatcupra-0.1a7}/src/carconnectivity_connector_seatcupra.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: carconnectivity-connector-seatcupra
-Version: 0.1a5
+Version: 0.1a7
 Summary: CarConnectivity connector for Seat and Cupra services
 Author: Till Steinbach
 License: MIT License
@@ -37,7 +37,7 @@ Classifier: Topic :: Software Development :: Libraries
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: carconnectivity>=0.4a3
+Requires-Dist: carconnectivity>=0.4a4
 Requires-Dist: oauthlib~=3.2.2
 Requires-Dist: requests~=2.32.3
 Requires-Dist: jwt~=1.3.1

{carconnectivity_connector_seatcupra-0.1a5 → carconnectivity_connector_seatcupra-0.1a7}/src/carconnectivity_connector_seatcupra.egg-info/requires.txt

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

{carconnectivity_connector_seatcupra-0.1a5 → carconnectivity_connector_seatcupra-0.1a7}/src/carconnectivity_connectors/seatcupra/_version.py

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

{carconnectivity_connector_seatcupra-0.1a5 → carconnectivity_connector_seatcupra-0.1a7}/src/carconnectivity_connectors/seatcupra/connector.py

@@ -259,6 +259,8 @@ class Connector(BaseConnector):
                     vehicle_to_update = self.fetch_charging(vehicle_to_update)
                 if vehicle_to_update.capabilities.has_capability('parkingPosition'):
                     vehicle_to_update = self.fetch_parking_position(vehicle_to_update)
+                if vehicle_to_update.capabilities.has_capability('vehicleHealthInspection'):
+                    vehicle_to_update = self.fetch_maintenance(vehicle_to_update)
 
     def fetch_vehicles(self) -> None:
         """
@@ -737,6 +739,42 @@ class Connector(BaseConnector):
             vehicle.odometer._set_value(None)  # pylint: disable=protected-access
         return vehicle
 
+    def fetch_maintenance(self, vehicle: SeatCupraVehicle, no_cache: bool = False) -> SeatCupraVehicle:
+        vin = vehicle.vin.value
+        if vin is None:
+            raise APIError('VIN is missing')
+        url = f'https://ola.prod.code.seat.cloud.vwgroup.com/v1/vehicles/{vin}/maintenance'
+        data: Dict[str, Any] | None = self._fetch_data(url=url, session=self.session, no_cache=no_cache)
+        if data is not None:
+            if 'inspectionDueDays' in data and data['inspectionDueDays'] is not None:
+                inspection_due: timedelta = timedelta(days=data['inspectionDueDays'])
+                inspection_date: datetime = datetime.now(tz=timezone.utc) + 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)
+            else:
+                vehicle.maintenance.inspection_due_at._set_value(None)  # pylint: disable=protected-access
+            if 'inspectionDueKm' in data and data['inspectionDueKm'] is not None:
+                vehicle.maintenance.inspection_due_after._set_value(data['inspectionDueKm'], unit=Length.KM)  # pylint: disable=protected-access
+            else:
+                vehicle.maintenance.inspection_due_after._set_value(None)  # pylint: disable=protected-access
+            if 'oilServiceDueDays' in data and data['oilServiceDueDays'] is not None:
+                oil_service_due: timedelta = timedelta(days=data['oilServiceDueDays'])
+                oil_service_date: datetime = datetime.now(tz=timezone.utc) + oil_service_due
+                oil_service_date = oil_service_date.replace(hour=0, minute=0, second=0, microsecond=0)
+                # pylint: disable-next=protected-access
+                vehicle.maintenance.oil_service_due_at._set_value(value=oil_service_date)
+            else:
+                vehicle.maintenance.oil_service_due_at._set_value(None)  # pylint: disable=protected-access
+            if 'oilServiceDueKm' in data and data['oilServiceDueKm'] is not None:
+                vehicle.maintenance.oil_service_due_after._set_value(data['oilServiceDueKm'], unit=Length.KM)  # pylint: disable=protected-access
+            else:
+                vehicle.maintenance.oil_service_due_after._set_value(None)  # pylint: disable=protected-access
+            log_extra_keys(LOG_API, f'/v1/vehicles/{vin}/maintenance', data,  {'inspectionDueDays', 'inspectionDueKm', 'oilServiceDueDays', 'oilServiceDueKm'})
+        else:
+            vehicle.odometer._set_value(None)  # pylint: disable=protected-access
+        return vehicle
+
     def fetch_climatisation(self, vehicle: SeatCupraVehicle, no_cache: bool = False) -> SeatCupraVehicle:
         """
         Fetches the mileage of the given vehicle and updates its mileage attributes.
@@ -1051,27 +1089,37 @@ class Connector(BaseConnector):
         if 'command' not in command_arguments:
             raise CommandError('Command argument missing')
         command_dict: Dict = {}
-        if command_arguments['command'] == ChargingStartStopCommand.Command.START:
-            url = f'https://ola.prod.code.seat.cloud.vwgroup.com/vehicles/{vin}/charging/requests/start'
-            if isinstance(vehicle, SeatCupraElectricVehicle) and vehicle.charging is not None and vehicle.charging.settings is not None \
-                    and vehicle.charging.settings.maximum_current is not None and vehicle.charging.settings.maximum_current.enabled \
-                    and vehicle.charging.settings.maximum_current.value is not None:
-                if vehicle.charging.settings.maximum_current.value <= 6:
-                    command_dict['maxChargeCurrentAC'] = 'reduced'
+        try:
+            if command_arguments['command'] == ChargingStartStopCommand.Command.START:
+                url = f'https://ola.prod.code.seat.cloud.vwgroup.com/vehicles/{vin}/charging/requests/start'
+                if isinstance(vehicle, SeatCupraElectricVehicle) and vehicle.charging is not None and vehicle.charging.settings is not None \
+                        and vehicle.charging.settings.maximum_current is not None and vehicle.charging.settings.maximum_current.enabled \
+                        and vehicle.charging.settings.maximum_current.value is not None:
+                    if vehicle.charging.settings.maximum_current.value <= 6:
+                        command_dict['maxChargeCurrentAC'] = 'reduced'
+                    else:
+                        command_dict['maxChargeCurrentAC'] = 'maximum'
                 else:
                     command_dict['maxChargeCurrentAC'] = 'maximum'
+                command_response: requests.Response = self.session.post(url, json=command_dict, allow_redirects=True)
+            elif command_arguments['command'] == ChargingStartStopCommand.Command.STOP:
+                url = f'https://ola.prod.code.seat.cloud.vwgroup.com/vehicles/{vin}/charging/requests/stop'
+                command_response: requests.Response = self.session.post(url, data='{}', allow_redirects=True)
             else:
-                command_dict['maxChargeCurrentAC'] = 'maximum'
-            command_response: requests.Response = self.session.post(url, data=json.dumps(command_dict), allow_redirects=True)
-        elif command_arguments['command'] == ChargingStartStopCommand.Command.STOP:
-            url = f'https://ola.prod.code.seat.cloud.vwgroup.com/vehicles/{vin}/charging/requests/stop'
-            command_response: requests.Response = self.session.post(url, data='{}', allow_redirects=True)
-        else:
-            raise CommandError(f'Unknown command {command_arguments["command"]}')
-
-        if command_response.status_code not in [requests.codes['ok'], requests.codes['created']]:
-            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})')
+                raise CommandError(f'Unknown command {command_arguments["command"]}')
+
+            if command_response.status_code not in [requests.codes['ok'], requests.codes['created']]:
+                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_air_conditioning_start_stop(self, start_stop_command: ClimatizationStartStopCommand, command_arguments: Union[str, Dict[str, Any]]) \
@@ -1117,10 +1165,20 @@ class Connector(BaseConnector):
             url: str = f'https://ola.prod.code.seat.cloud.vwgroup.com/vehicles/{vin}/climatisation/requests/stop'
         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 not in [requests.codes['ok'], requests.codes['created']]:
-            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})')
+        try:
+            command_response: requests.Response = self.session.post(url, data=json.dumps(command_dict), allow_redirects=True)
+            if command_response.status_code not in [requests.codes['ok'], requests.codes['created']]:
+                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_spin(self, spin_command: SpinCommand, command_arguments: Union[str, Dict[str, Any]]) \
@@ -1134,7 +1192,7 @@ class Connector(BaseConnector):
         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']
+            command_dict['spin'] = command_arguments['spin']
         else:
             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')
@@ -1143,12 +1201,22 @@ class Connector(BaseConnector):
             url = f'https://ola.prod.code.seat.cloud.vwgroup.com/v2/users/{self.session.user_id}/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 __on_wake_sleep(self, wake_sleep_command: WakeSleepCommand, command_arguments: Union[str, Dict[str, Any]]) \
@@ -1167,10 +1235,20 @@ class Connector(BaseConnector):
         if command_arguments['command'] == WakeSleepCommand.Command.WAKE:
             url = f'https://ola.prod.code.seat.cloud.vwgroup.com/v1/vehicles/{vin}/vehicle-wakeup/request'
 
-            command_response: requests.Response = self.session.post(url, data='{}', allow_redirects=True)
-            if command_response.status_code not in (requests.codes['ok'], requests.codes['no_content']):
-                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 not in (requests.codes['ok'], requests.codes['no_content']):
+                    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:
@@ -1206,12 +1284,22 @@ class Connector(BaseConnector):
             command_dict['userPosition']['longitude'] = vehicle.position.longitude.value
 
             url = f'https://ola.prod.code.seat.cloud.vwgroup.com/v1/vehicles/{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 not in (requests.codes['ok'], requests.codes['no_content']):
-                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})')
-        else:
-            raise CommandError(f'Unknown command {command_arguments["command"]}')
+            try:
+                command_response: requests.Response = self.session.post(url, data=json.dumps(command_dict), allow_redirects=True)
+                if command_response.status_code not in (requests.codes['ok'], requests.codes['no_content']):
+                    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 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
+            else:
+                raise CommandError(f'Unknown command {command_arguments["command"]}')
         return command_arguments
 
     def __on_lock_unlock(self, lock_unlock_command: LockUnlockCommand, command_arguments: Union[str, Dict[str, Any]]) \
@@ -1240,10 +1328,20 @@ class Connector(BaseConnector):
             url = f'https://ola.prod.code.seat.cloud.vwgroup.com/v1/vehicles/{vin}/access/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['ok']:
-            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['ok']:
+                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_air_conditioning_settings_change(self, attribute: GenericAttribute, value: Any) -> Any:
@@ -1279,10 +1377,20 @@ class Connector(BaseConnector):
             setting_dict['climatisationWithoutExternalPower'] = settings.climatization_without_external_power.value
 
         url: str = f'https://ola.prod.code.seat.cloud.vwgroup.com/v2/vehicles/{vin}/climatisation/settings'
-        settings_response: requests.Response = self.session.post(url, data=json.dumps(setting_dict), allow_redirects=True)
-        if settings_response.status_code not in [requests.codes['ok'], requests.codes['created']]:
-            LOG.error('Could not set climatization settings (%s) %s', settings_response.status_code, settings_response.text)
-            raise SetterError(f'Could not set value ({settings_response.status_code}): {settings_response.text}')
+        try:
+            settings_response: requests.Response = self.session.post(url, data=json.dumps(setting_dict), allow_redirects=True)
+            if settings_response.status_code not in [requests.codes['ok'], requests.codes['created']]:
+                LOG.error('Could not set climatization settings (%s) %s', settings_response.status_code, settings_response.text)
+                raise SetterError(f'Could not set value ({settings_response.status_code}): {settings_response.text}')
+        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 value
 
     def get_version(self) -> str: