carconnectivity-connector-skoda 0.5a1__tar.gz → 0.5a2__tar.gz

{carconnectivity_connector_skoda-0.5a1 → carconnectivity_connector_skoda-0.5a2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: carconnectivity-connector-skoda
-Version: 0.5a1
+Version: 0.5a2
 Summary: CarConnectivity connector for Skoda services
 Author: Till Steinbach
 License: MIT License

{carconnectivity_connector_skoda-0.5a1 → carconnectivity_connector_skoda-0.5a2}/src/carconnectivity_connector_skoda.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: carconnectivity-connector-skoda
-Version: 0.5a1
+Version: 0.5a2
 Summary: CarConnectivity connector for Skoda services
 Author: Till Steinbach
 License: MIT License

{carconnectivity_connector_skoda-0.5a1 → carconnectivity_connector_skoda-0.5a2}/src/carconnectivity_connectors/skoda/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.5a1'
+__version__ = version = '0.5a2'
 __version_tuple__ = version_tuple = (0, 5)

{carconnectivity_connector_skoda-0.5a1 → carconnectivity_connector_skoda-0.5a2}/src/carconnectivity_connectors/skoda/charging.py

@@ -26,11 +26,11 @@ class SkodaCharging(Charging):  # pylint: disable=too-many-instance-attributes
     """
     def __init__(self, vehicle: ElectricVehicle | None = None, origin: Optional[Charging] = None) -> None:
         if origin is not None:
-            super().__init__(origin=origin)
-            self.settings: Charging.Settings = SkodaCharging.Settings(origin=origin.settings)
+            super().__init__(vehicle=vehicle, origin=origin)
+            self.settings: Charging.Settings = SkodaCharging.Settings(parent=self, origin=origin.settings)
         else:
             super().__init__(vehicle=vehicle)
-            self.settings: Charging.Settings = SkodaCharging.Settings(origin=self.settings)
+            self.settings: Charging.Settings = SkodaCharging.Settings(parent=self, origin=self.settings)
         self.errors: Dict[str, Error] = {}
         self.is_in_saved_location: BooleanAttribute = BooleanAttribute("is_in_saved_location", parent=self, tags={'connector_custom'})
 
@@ -40,7 +40,7 @@ class SkodaCharging(Charging):  # pylint: disable=too-many-instance-attributes
         """
         def __init__(self, parent: Optional[GenericObject] = None, origin: Optional[Charging.Settings] = None) -> None:
             if origin is not None:
-                super().__init__(origin=origin)
+                super().__init__(parent=parent, origin=origin)
             else:
                 super().__init__(parent=parent)
             self.preferred_charge_mode: EnumAttribute = EnumAttribute("preferred_charge_mode", parent=self, tags={'connector_custom'})

{carconnectivity_connector_skoda-0.5a1 → carconnectivity_connector_skoda-0.5a2}/src/carconnectivity_connectors/skoda/connector.py

@@ -23,7 +23,8 @@ 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 GenericAttribute, BooleanAttribute, DurationAttribute, TemperatureAttribute, EnumAttribute
+from carconnectivity.attributes import BooleanAttribute, DurationAttribute, TemperatureAttribute, EnumAttribute, LevelAttribute, \
+    CurrentAttribute
 from carconnectivity.charging import Charging
 from carconnectivity.position import Position
 from carconnectivity.climatization import Climatization
@@ -509,14 +510,24 @@ class Connector(BaseConnector):
             if 'settings' in data and data['settings'] is not None:
                 if 'targetStateOfChargeInPercent' in data['settings'] and data['settings']['targetStateOfChargeInPercent'] is not None \
                         and vehicle.charging is not None and vehicle.charging.settings is not None:
+                    vehicle.charging.settings.target_level.minimum = 50.0
+                    vehicle.charging.settings.target_level.maximum = 100.0
+                    vehicle.charging.settings.target_level.precision = 10.0
+                    vehicle.charging.settings.target_level._add_on_set_hook(self.__on_charging_target_level_change)  # pylint: disable=protected-access
+                    vehicle.charging.settings.target_level._is_changeable = True  # pylint: disable=protected-access
                     # pylint: disable-next=protected-access
                     vehicle.charging.settings.target_level._set_value(value=data['settings']['targetStateOfChargeInPercent'], measured=captured_at)
                 else:
                     vehicle.charging.settings.target_level._set_value(None, measured=captured_at)  # pylint: disable=protected-access
                 if 'maxChargeCurrentAc' in data['settings'] and data['settings']['maxChargeCurrentAc'] is not None \
                         and vehicle.charging is not None and vehicle.charging.settings is not None:
+                    vehicle.charging.settings.maximum_current.minimum = 6.0
+                    vehicle.charging.settings.maximum_current.maximum = 16.0
+                    vehicle.charging.settings.maximum_current.precision = 1.0
+                    vehicle.charging.settings.maximum_current._add_on_set_hook(self.__on_charging_maximum_current_change)  # pylint: disable=protected-access
+                    vehicle.charging.settings.maximum_current._is_changeable = True  # pylint: disable=protected-access
                     if data['settings']['maxChargeCurrentAc'] == 'MAXIMUM':
-                        vehicle.charging.settings.maximum_current._set_value(value=11, measured=captured_at)  # pylint: disable=protected-access
+                        vehicle.charging.settings.maximum_current._set_value(value=16, measured=captured_at)  # pylint: disable=protected-access
                     elif data['settings']['maxChargeCurrentAc'] == 'REDUCED':
                         vehicle.charging.settings.maximum_current._set_value(value=6, measured=captured_at)  # pylint: disable=protected-access
                     else:
@@ -525,6 +536,8 @@ class Connector(BaseConnector):
                 else:
                     vehicle.charging.settings.maximum_current._set_value(None, measured=captured_at)  # pylint: disable=protected-access
                 if 'autoUnlockPlugWhenCharged' in data['settings'] and data['settings']['autoUnlockPlugWhenCharged'] is not None:
+                    vehicle.charging.settings.auto_unlock._add_on_set_hook(self.__on_charging_auto_unlock_change)  # pylint: disable=protected-access
+                    vehicle.charging.settings.auto_unlock._is_changeable = True  # pylint: disable=protected-access
                     if data['settings']['autoUnlockPlugWhenCharged'] in ['ON', 'PERMANENT']:
                         vehicle.charging.settings.auto_unlock._set_value(True, measured=captured_at)  # pylint: disable=protected-access
                     elif data['settings']['autoUnlockPlugWhenCharged'] == 'OFF':
@@ -1234,7 +1247,7 @@ class Connector(BaseConnector):
                     car_type = GenericVehicle.Type(range_data['carType'])
                     if car_type == GenericVehicle.Type.ELECTRIC and not isinstance(vehicle, SkodaElectricVehicle):
                         LOG.debug('Promoting %s to SkodaElectricVehicle object for %s', vehicle.__class__.__name__, vin)
-                        vehicle = SkodaElectricVehicle(origin=vehicle)
+                        vehicle = SkodaElectricVehicle(garage=self.car_connectivity.garage, origin=vehicle)
                         self.car_connectivity.garage.replace_vehicle(vin, vehicle)
                     elif car_type in [GenericVehicle.Type.FUEL,
                                       GenericVehicle.Type.GASOLINE,
@@ -1244,11 +1257,11 @@ class Connector(BaseConnector):
                                       GenericVehicle.Type.LPG] \
                             and not isinstance(vehicle, SkodaCombustionVehicle):
                         LOG.debug('Promoting %s to SkodaCombustionVehicle object for %s', vehicle.__class__.__name__, vin)
-                        vehicle = SkodaCombustionVehicle(origin=vehicle)
+                        vehicle = SkodaCombustionVehicle(garage=self.car_connectivity.garage, origin=vehicle)
                         self.car_connectivity.garage.replace_vehicle(vin, vehicle)
                     elif car_type == GenericVehicle.Type.HYBRID and not isinstance(vehicle, SkodaHybridVehicle):
                         LOG.debug('Promoting %s to SkodaHybridVehicle object for %s', vehicle.__class__.__name__, vin)
-                        vehicle = SkodaHybridVehicle(origin=vehicle)
+                        vehicle = SkodaHybridVehicle(garage=self.car_connectivity.garage, origin=vehicle)
                         self.car_connectivity.garage.replace_vehicle(vin, vehicle)
                 except ValueError:
                     LOG_API.warning('Unknown car type %s', range_data['carType'])
@@ -1889,5 +1902,122 @@ class Connector(BaseConnector):
             raise CommandError(f'Retrying failed: {retry_error}') from retry_error
         return command_arguments
 
+    def __on_charging_target_level_change(self, level_attribute: LevelAttribute, target_level: float) -> float:
+        """
+        Callback for the charging target level change.
+
+        Args:
+            level_attribute (LevelAttribute): The level attribute that changed.
+            target_level (float): The new target level.
+        """
+        if level_attribute.parent is None or level_attribute.parent.parent is None \
+                or level_attribute.parent.parent.parent is None or not isinstance(level_attribute.parent.parent.parent, SkodaVehicle):
+            raise SetterError('Object hierarchy is not as expected')
+        vehicle: SkodaVehicle = level_attribute.parent.parent.parent
+        vin: Optional[str] = vehicle.vin.value
+        if vin is None:
+            raise SetterError('VIN in object hierarchy missing')
+        precision: float = level_attribute.precision if level_attribute.precision is not None else 10.0
+        target_level = round(target_level / precision) * precision
+        setting_dict = {}
+        setting_dict['targetSOCInPercent'] = target_level
+
+        url = f'https://mysmob.api.connect.skoda-auto.cz/api/v1/charging/{vin}/set-charge-limit'
+        try:
+            settings_response: requests.Response = self.session.put(url, data=json.dumps(setting_dict), allow_redirects=True)
+            if settings_response.status_code != requests.codes['accepted']:
+                LOG.error('Could not set target level (%s)', settings_response.status_code)
+                raise SetterError(f'Could not set value ({settings_response.status_code})')
+        except requests.exceptions.ConnectionError as connection_error:
+            raise SetterError(f'Connection error: {connection_error}.'
+                              ' If this happens frequently, please check if other applications communicate with the Skoda server.') from connection_error
+        except requests.exceptions.ChunkedEncodingError as chunked_encoding_error:
+            raise SetterError(f'Error: {chunked_encoding_error}') from chunked_encoding_error
+        except requests.exceptions.ReadTimeout as timeout_error:
+            raise SetterError(f'Timeout during read: {timeout_error}') from timeout_error
+        except requests.exceptions.RetryError as retry_error:
+            raise SetterError(f'Retrying failed: {retry_error}') from retry_error
+        return target_level
+
+    def __on_charging_maximum_current_change(self, current_attribute: CurrentAttribute, maximum_current: float) -> float:
+        """
+        Callback for the charging target level change.
+
+        Args:
+            current_attribute (CurrentAttribute): The current attribute that changed.
+            maximum_current (float): The new maximum current.
+        """
+        if current_attribute.parent is None or current_attribute.parent.parent is None \
+                or current_attribute.parent.parent.parent is None or not isinstance(current_attribute.parent.parent.parent, SkodaVehicle):
+            raise SetterError('Object hierarchy is not as expected')
+        vehicle: SkodaVehicle = current_attribute.parent.parent.parent
+        vin: Optional[str] = vehicle.vin.value
+        if vin is None:
+            raise SetterError('VIN in object hierarchy missing')
+        setting_dict = {}
+        precision: float = current_attribute.precision if current_attribute.precision is not None else 1.0
+        maximum_current = round(maximum_current / precision) * precision
+        if maximum_current < 16:
+            setting_dict['chargingCurrent'] = "REDUCED"
+            maximum_current = 6.0
+        else:
+            setting_dict['chargingCurrent'] = "MAXIMUM"
+            maximum_current = 16.0
+
+        url = f'https://mysmob.api.connect.skoda-auto.cz/api/v1/charging/{vin}/set-charging-current'
+        try:
+            settings_response: requests.Response = self.session.put(url, data=json.dumps(setting_dict), allow_redirects=True)
+            if settings_response.status_code != requests.codes['accepted']:
+                LOG.error('Could not set target charging current (%s)', settings_response.status_code)
+                raise SetterError(f'Could not set value ({settings_response.status_code})')
+        except requests.exceptions.ConnectionError as connection_error:
+            raise SetterError(f'Connection error: {connection_error}.'
+                              ' If this happens frequently, please check if other applications communicate with the Skoda server.') from connection_error
+        except requests.exceptions.ChunkedEncodingError as chunked_encoding_error:
+            raise SetterError(f'Error: {chunked_encoding_error}') from chunked_encoding_error
+        except requests.exceptions.ReadTimeout as timeout_error:
+            raise SetterError(f'Timeout during read: {timeout_error}') from timeout_error
+        except requests.exceptions.RetryError as retry_error:
+            raise SetterError(f'Retrying failed: {retry_error}') from retry_error
+        return maximum_current
+
+    def __on_charging_auto_unlock_change(self, boolean_attribute: BooleanAttribute, auto_unlock: bool) -> bool:
+        """
+        Callback for the charging target level change.
+
+        Args:
+            boolean_attribute (BooleanAttribute): The boolean attribute that changed.
+            auto_unlock (float): The new auto_unlock setting.
+        """
+        if boolean_attribute.parent is None or boolean_attribute.parent.parent is None \
+                or boolean_attribute.parent.parent.parent is None or not isinstance(boolean_attribute.parent.parent.parent, SkodaVehicle):
+            raise SetterError('Object hierarchy is not as expected')
+        vehicle: SkodaVehicle = boolean_attribute.parent.parent.parent
+        vin: Optional[str] = vehicle.vin.value
+        if vin is None:
+            raise SetterError('VIN in object hierarchy missing')
+        setting_dict = {}
+        if auto_unlock:
+            setting_dict['autoUnlockPlug'] = "PERMANENT"
+        else:
+            setting_dict['autoUnlockPlug'] = "OFF"
+
+        url = f'https://mysmob.api.connect.skoda-auto.cz/api/v1/charging/{vin}/set-auto-unlock-plug'
+        try:
+            settings_response: requests.Response = self.session.put(url, data=json.dumps(setting_dict), allow_redirects=True)
+            if settings_response.status_code != requests.codes['accepted']:
+                LOG.error('Could not set auto unlock setting (%s)', settings_response.status_code)
+                raise SetterError(f'Could not set value ({settings_response.status_code})')
+        except requests.exceptions.ConnectionError as connection_error:
+            raise SetterError(f'Connection error: {connection_error}.'
+                              ' If this happens frequently, please check if other applications communicate with the Skoda server.') from connection_error
+        except requests.exceptions.ChunkedEncodingError as chunked_encoding_error:
+            raise SetterError(f'Error: {chunked_encoding_error}') from chunked_encoding_error
+        except requests.exceptions.ReadTimeout as timeout_error:
+            raise SetterError(f'Timeout during read: {timeout_error}') from timeout_error
+        except requests.exceptions.RetryError as retry_error:
+            raise SetterError(f'Retrying failed: {retry_error}') from retry_error
+        return auto_unlock
+
     def get_name(self) -> str:
         return "Skoda Connector"

{carconnectivity_connector_skoda-0.5a1 → carconnectivity_connector_skoda-0.5a2}/src/carconnectivity_connectors/skoda/vehicle.py

@@ -30,7 +30,7 @@ class SkodaVehicle(GenericVehicle):  # pylint: disable=too-many-instance-attribu
     def __init__(self, vin: Optional[str] = None, garage: Optional[Garage] = None, managing_connector: Optional[BaseConnector] = None,
                  origin: Optional[SkodaVehicle] = None) -> None:
         if origin is not None:
-            super().__init__(origin=origin)
+            super().__init__(garage=garage, origin=origin)
             self.capabilities: Capabilities = origin.capabilities
             self.capabilities.parent = self
             self.in_motion: BooleanAttribute = origin.in_motion
@@ -55,13 +55,14 @@ class SkodaElectricVehicle(ElectricVehicle, SkodaVehicle):
     def __init__(self, vin: Optional[str] = None, garage: Optional[Garage] = None, managing_connector: Optional[BaseConnector] = None,
                  origin: Optional[SkodaVehicle] = None) -> None:
         if origin is not None:
-            super().__init__(origin=origin)
+            super().__init__(garage=garage, origin=origin)
             if isinstance(origin, ElectricVehicle):
-                self.charging: Charging = SkodaCharging(origin=origin.charging)
-                self.charging.parent = self
+                self.charging: Charging = SkodaCharging(vehicle=self, origin=origin.charging)
+            else:
+                self.charging: Charging = SkodaCharging(vehicle=self, origin=self.charging)
         else:
             super().__init__(vin=vin, garage=garage, managing_connector=managing_connector)
-            self.charging: Charging = SkodaCharging(vehicle=self)
+            self.charging: Charging = SkodaCharging(vehicle=self, origin=self.charging)
 
 
 class SkodaCombustionVehicle(CombustionVehicle, SkodaVehicle):
@@ -71,7 +72,7 @@ class SkodaCombustionVehicle(CombustionVehicle, SkodaVehicle):
     def __init__(self, vin: Optional[str] = None, garage: Optional[Garage] = None, managing_connector: Optional[BaseConnector] = None,
                  origin: Optional[SkodaVehicle] = None) -> None:
         if origin is not None:
-            super().__init__(origin=origin)
+            super().__init__(garage=garage, origin=origin)
         else:
             super().__init__(vin=vin, garage=garage, managing_connector=managing_connector)
 
@@ -83,6 +84,6 @@ class SkodaHybridVehicle(HybridVehicle, SkodaVehicle):
     def __init__(self, vin: Optional[str] = None, garage: Optional[Garage] = None, managing_connector: Optional[BaseConnector] = None,
                  origin: Optional[SkodaVehicle] = None) -> None:
         if origin is not None:
-            super().__init__(origin=origin)
+            super().__init__(garage=garage, origin=origin)
         else:
             super().__init__(vin=vin, garage=garage, managing_connector=managing_connector)