Release 0.7.0

.github/workflows/build_and_test_python.yml

@@ -34,7 +34,7 @@ jobs:
           python -m pytest --doctest-modules --junitxml=junit/test-results-${{ matrix.python-version }}.xml
       - name: Lint with Ruff
         run: |
-          python -m pip install install ruff
+          python -m pip install ruff
           ruff check --output-format=github .
         continue-on-error: true
       - name: Surface failing tests

configuration.py → configuration/__init__.py

@@ -22,21 +22,38 @@ def __init__(self):
         self.saic_region: str = 'eu'
         self.saic_tenant_id: str = '459771'
         self.saic_relogin_delay: int = 15 * 60  # in seconds
-        self.abrp_token_map: dict[str, str] = {}
         self.battery_capacity_map: dict[str, float] = {}
-        self.abrp_api_key: str | None = None
         self.mqtt_host: str | None = None
         self.mqtt_port: int | None = None
         self.mqtt_transport_protocol: TransportProtocol | None = None
         self.tls_server_cert_path: str | None = None
         self.mqtt_user: str | None = None
         self.mqtt_password: str | None = None
         self.mqtt_client_id: str = 'saic-python-mqtt-gateway'
-        self.mqtt_topic: str | None = None
+        self.mqtt_topic: str = 'saic'
         self.charging_stations_by_vin: dict[str, ChargingStation] = {}
         self.anonymized_publishing: bool = False
         self.messages_request_interval: int = 60  # in seconds
         self.ha_discovery_enabled: bool = True
         self.ha_discovery_prefix: str = 'homeassistant'
         self.ha_show_unavailable: bool = True
         self.charge_dynamic_polling_min_percentage: float = 1.0
+        self.publish_raw_api_data: bool = False
+
+        # ABRP Integration
+        self.abrp_token_map: dict[str, str] = {}
+        self.abrp_api_key: str | None = None
+        self.publish_raw_abrp_data: bool = False
+
+        # OsmAnd Integration
+        self.osmand_device_id_map: dict[str, str] = {}
+        self.osmand_server_uri: str | None = None
+        self.publish_raw_osmand_data: bool = False
+
+    @property
+    def is_mqtt_enabled(self) -> bool:
+        return self.mqtt_host is not None and len(str(self.mqtt_host)) > 0
+
+    @property
+    def username_is_email(self):
+        return '@' in self.saic_user

configuration/argparse_extensions.py

@@ -0,0 +1,50 @@
+import argparse
+import os
+from typing import Callable
+
+
+class EnvDefault(argparse.Action):
+    def __init__(self, envvar, required=True, default=None, **kwargs):
+        if (
+                envvar in os.environ
+                and os.environ[envvar]
+        ):
+            default = os.environ[envvar]
+        if required and default:
+            required = False
+        super(EnvDefault, self).__init__(default=default, required=required, **kwargs)
+
+    def __call__(self, parser, namespace, values, option_string=None):
+        setattr(namespace, self.dest, values)
+
+
+def cfg_value_to_dict(cfg_value: str, result_map: dict, value_type: Callable[[str], any] = str):
+    if ',' in cfg_value:
+        map_entries = cfg_value.split(',')
+    else:
+        map_entries = [cfg_value]
+
+    for entry in map_entries:
+        if '=' in entry:
+            key_value_pair = entry.split('=')
+            key = key_value_pair[0]
+            value = key_value_pair[1]
+            result_map[key] = value_type(value)
+
+
+def check_positive(value):
+    ivalue = int(value)
+    if ivalue <= 0:
+        raise argparse.ArgumentTypeError(f'{ivalue} is an invalid positive int value')
+    return ivalue
+
+
+def check_positive_float(value):
+    fvalue = float(value)
+    if fvalue <= 0:
+        raise argparse.ArgumentTypeError(f'{fvalue} is an invalid positive float value')
+    return fvalue
+
+
+def check_bool(value):
+    return str(value).lower() in ['true', '1', 'yes', 'y']

handlers/message.py

@@ -0,0 +1,146 @@
+import datetime
+import logging
+from typing import Union
+
+from saic_ismart_client_ng import SaicApi
+from saic_ismart_client_ng.api.message.schema import MessageEntity
+from saic_ismart_client_ng.exceptions import SaicApiException, SaicLogoutException
+
+from handlers.relogin import ReloginHandler
+from handlers.vehicle import VehicleHandlerLocator
+from vehicle import RefreshMode
+
+LOG = logging.getLogger(__name__)
+
+
+class MessageHandler:
+    def __init__(
+            self,
+            gateway: VehicleHandlerLocator,
+            relogin_handler: ReloginHandler,
+            saicapi: SaicApi
+    ):
+        self.gateway = gateway
+        self.saicapi = saicapi
+        self.relogin_handler = relogin_handler
+        self.last_message_ts = datetime.datetime.min
+        self.last_message_id = None
+
+    async def check_for_new_messages(self) -> None:
+        if self.__should_poll():
+            try:
+                LOG.debug("Checking for new messages")
+                await self.__polling()
+            except Exception as e:
+                LOG.exception('MessageHandler poll loop failed', exc_info=e)
+
+    async def __polling(self):
+        try:
+            all_messages = await self.__get_all_alarm_messages()
+            LOG.info(f'{len(all_messages)} messages received')
+
+            new_messages = [m for m in all_messages if m.read_status != 'read']
+            for message in new_messages:
+                LOG.info(message.details)
+                await self.__read_message(message)
+
+            latest_message = self.__get_latest_message(all_messages)
+            if latest_message.messageId != self.last_message_id and latest_message.message_time > self.last_message_ts:
+                self.last_message_id = latest_message.messageId
+                self.last_message_ts = latest_message.message_time
+                LOG.info(
+                    f'{latest_message.title} detected at {latest_message.message_time}'
+                )
+                vehicle_handler = self.gateway.get_vehicle_handler(latest_message.vin)
+                if vehicle_handler:
+                    vehicle_handler.vehicle_state.notify_message(latest_message)
+
+            # Delete vehicle start messages unless they are the latest
+            vehicle_start_messages = [
+                m for m in all_messages
+                if m.messageType == '323' and m.messageId != self.last_message_id
+            ]
+            for vehicle_start_message in vehicle_start_messages:
+                await self.__delete_message(vehicle_start_message)
+        except SaicLogoutException as e:
+            LOG.error("API Client was logged out, waiting for a new login", exc_info=e)
+            self.relogin_handler.relogin()
+        except SaicApiException as e:
+            LOG.exception('MessageHandler poll loop failed during SAIC API Call', exc_info=e)
+        except Exception as e:
+            LOG.exception('MessageHandler poll loop failed unexpectedly', exc_info=e)
+
+    async def __get_all_alarm_messages(self) -> list[MessageEntity]:
+        idx = 1
+        all_messages = []
+        while True:
+            try:
+                message_list = await self.saicapi.get_alarm_list(page_num=idx, page_size=1)
+                if message_list.messages and len(message_list.messages) > 0:
+                    all_messages.extend(message_list.messages)
+                else:
+                    return all_messages
+                oldest_message = self.__get_oldest_message(all_messages)
+                if oldest_message is not None and oldest_message.message_time < self.last_message_ts:
+                    return all_messages
+            except SaicLogoutException as e:
+                raise e
+            except Exception as e:
+                LOG.exception(
+                    'Error while fetching a message from the SAIC API, please open the app and clear them, '
+                    'then report this as a bug.',
+                    exc_info=e
+                )
+            finally:
+                idx = idx + 1
+
+    async def __delete_message(self, latest_vehicle_start_message: MessageEntity):
+        try:
+            message_id = latest_vehicle_start_message.messageId
+            await self.saicapi.delete_message(message_id=message_id)
+            LOG.info(f'{latest_vehicle_start_message.title} message with ID {message_id} deleted')
+        except Exception as e:
+            LOG.exception('Could not delete message from server', exc_info=e)
+
+    async def __read_message(self, message: MessageEntity):
+        try:
+            message_id = message.messageId
+            await self.saicapi.read_message(message_id=message_id)
+            LOG.info(f'{message.title} message with ID {message_id} marked as read')
+        except Exception as e:
+            LOG.exception('Could not mark message as read from server', exc_info=e)
+
+    def __should_poll(self):
+        vehicle_handlers = self.gateway.vehicle_handlers or dict()
+        refresh_modes = [
+            vh.vehicle_state.refresh_mode
+            for vh in vehicle_handlers.values()
+            if vh.vehicle_state is not None
+        ]
+        # We do not poll if we have no cars or all cars have RefreshMode.OFF
+        if len(refresh_modes) == 0 or all(mode == RefreshMode.OFF for mode in refresh_modes):
+            logging.debug("Not checking for new messages as all cars have RefreshMode.OFF")
+            return False
+        elif self.relogin_handler.relogin_in_progress:
+            logging.warning("Not checking for new messages as we are waiting to log back in")
+            return False
+        else:
+            return True
+
+    @staticmethod
+    def __get_latest_message(vehicle_start_messages: list[MessageEntity]) -> Union[MessageEntity, None]:
+        return next(iter(reversed(
+            sorted(
+                vehicle_start_messages,
+                key=lambda m: m.message_time
+            )
+        )), None)
+
+    @staticmethod
+    def __get_oldest_message(vehicle_start_messages: list[MessageEntity]) -> Union[MessageEntity, None]:
+        return next(iter(
+            sorted(
+                vehicle_start_messages,
+                key=lambda m: m.message_time
+            )
+        ), None)

handlers/relogin.py

@@ -0,0 +1,52 @@
+import logging
+from datetime import timedelta, datetime
+
+from apscheduler.schedulers.asyncio import AsyncIOScheduler
+from saic_ismart_client_ng import SaicApi
+
+LOG = logging.getLogger(__name__)
+JOB_ID = 'relogin_task'
+
+
+class ReloginHandler():
+
+    def __init__(
+            self,
+            *,
+            relogin_relay: int,
+            api: SaicApi,
+            scheduler: AsyncIOScheduler
+    ):
+        self.__relogin_relay = relogin_relay
+        self.__scheduler = scheduler
+        self.__api = api
+        self.__login_task = None
+
+    @property
+    def relogin_in_progress(self) -> bool:
+        return self.__login_task is not None
+
+    def relogin(self):
+        if self.__login_task is None:
+            logging.warning(f"API Client got logged out, logging back in {self.__relogin_relay} seconds")
+            self.__login_task = self.__scheduler.add_job(
+                func=self.login,
+                trigger='date',
+                run_date=datetime.now() + timedelta(seconds=self.__relogin_relay),
+                id=JOB_ID,
+                name='Re-login the API client after a set delay',
+                max_instances=1
+            )
+
+    async def login(self):
+        try:
+            LOG.info("Logging in to SAIC API")
+            login_response_message = await self.__api.login()
+            LOG.info("Logged in as %s", login_response_message.account)
+        except Exception as e:
+            logging.exception("Could not login to the SAIC API due to an error", exc_info=e)
+            raise e
+        finally:
+            if self.__scheduler.get_job(JOB_ID) is not None:
+                self.__scheduler.remove_job(JOB_ID)
+            self.__login_task = None