mg-saic-client 0.9.4__py3-none-any.whl

mg_saic_client-0.9.4.dist-info/METADATA

@@ -0,0 +1,50 @@
+Metadata-Version: 2.4
+Name: mg-saic-client
+Version: 0.9.4
+Summary: SAIC next gen client library (MG iSMART)
+License-File: LICENSE
+Author: Giovanni Condello
+Author-email: saic-python-client@nanomad.net
+Requires-Python: >=3.11
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Dist: dacite (>=1.8.1,<2.0.0)
+Requires-Dist: httpx (>=0.27.0,<0.29.0)
+Requires-Dist: pycryptodome (>=3.20.0,<4.0.0)
+Requires-Dist: tenacity (>=9.0.0,<10.0.0)
+Project-URL: Homepage, https://github.com/SAIC-iSmart-API/saic-python-client-ng
+Project-URL: Issues, https://github.com/SAIC-iSmart-API/saic-python-client-ng/issues
+Description-Content-Type: text/markdown
+
+# SAIC Python client library
+
+## About
+
+A Python package for interacting with the MG iSmart API.
+
+MG iSmart is the connectivity system in your MG car (MG5 MG4, ZS, MGS5, MGS6 ...).
+
+Supported functionality (partial list, check the code for more)
+
+* login
+* set alarm switches
+* get message list
+* get vehicle status
+* get charging status
+* lock vehicle
+* unlock vehicle
+* start rear window heating
+* stop rear window heating
+* remote climate
+* heated seats
+
+
+## Prerequisites
+
+You have an iSmart account (can be created in the iSmart app)
+
+## Credit
+
+This is a maintained fork of [SAIC-iSmart-API/saic-python-client-ng](https://github.com/SAIC-iSmart-API/saic-python-client-ng) by Giovanni Condello, used by the [mg-saic-ha](https://github.com/townsmcp/mg-saic-ha) Home Assistant integration. Licensed under MIT; see [LICENSE](LICENSE).
+

mg_saic_client-0.9.4.dist-info/RECORD

@@ -0,0 +1,34 @@
+saic_ismart_client_ng/__init__.py,sha256=ec7PLuwM-B1EmZkeP6jrmgzSNUkl5j3OiHhkM7i0ZGk,746
+saic_ismart_client_ng/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+saic_ismart_client_ng/api/base.py,sha256=8xP3rrR2MSm6dR6sPtxfmUIpI5FwUH_5uNRXkjBWGAU,14655
+saic_ismart_client_ng/api/message/__init__.py,sha256=X0i1FLUnt6A7j4LQNML4YvTNOLKkPGBLRQIK4n-SlDs,2837
+saic_ismart_client_ng/api/message/schema.py,sha256=p-LTlvDHCD7QOn-e4qfyppiSbHz9UtA6Rv6FGC0qklk,2417
+saic_ismart_client_ng/api/schema.py,sha256=pTkbfpnUQ0_0kzfLdhuwnLPj1YbOidgevLwCJmkztpg,1836
+saic_ismart_client_ng/api/serialization_utils.py,sha256=ckeDO9mUTd_7qABGlyBSKXpl2tEv2bxocRFiLXhtIYo,546
+saic_ismart_client_ng/api/user/__init__.py,sha256=DXQAutvp8JObTxHjjU3IC7iho6-190ZfjzesKCGAPw4,408
+saic_ismart_client_ng/api/user/schema.py,sha256=TqUSkpk7p8VpuAEn8825yeOa3zY95lrzs9kc3_zBvZ4,139
+saic_ismart_client_ng/api/vehicle/__init__.py,sha256=0TEpuhhPiBOwctD2f0WIJ1glh_9XYXCWNe0DsF7mUJ8,2766
+saic_ismart_client_ng/api/vehicle/alarm/__init__.py,sha256=FyYQ1HKlF2UMHFPf7Oa5sN2hCosctZdAlZbmxFGpOHU,1180
+saic_ismart_client_ng/api/vehicle/alarm/schema.py,sha256=HFOo5bL2_0Kcz0fFmg-QGT5GTPwfKqjiC4IyeLojQM0,578
+saic_ismart_client_ng/api/vehicle/climate/__init__.py,sha256=A8a93ZGQK0KWtM1JV9dP8LHT7A1hoIg9Y5Xvxo5oOXI,3519
+saic_ismart_client_ng/api/vehicle/locks/__init__.py,sha256=fHaI3x1MsYwxeLOE2ArmzcgZrIPsCGMTYSIuaJRlBsg,2125
+saic_ismart_client_ng/api/vehicle/locks/schema.py,sha256=6s8a3wJUbvpFdP6VC1KBR7TnfZXzuG25DzqA2Nbykk4,118
+saic_ismart_client_ng/api/vehicle/schema.py,sha256=q7eZp5PL8ahHEyQStU63ogZIE23KT3a-EAWwSmtMts0,6337
+saic_ismart_client_ng/api/vehicle/windows/__init__.py,sha256=uMns151TD4AWEXZ2bIGWHQf53UgSp0n-hMgZ8b7AGp4,1930
+saic_ismart_client_ng/api/vehicle/windows/schema.py,sha256=SV4SZRy6M4C7CKvvQNoAeHnjWKX3AayVlIKCW8a8fL4,336
+saic_ismart_client_ng/api/vehicle_charging/__init__.py,sha256=6gbs9HNo1uXR-Npxhlubr2Z6OA7ntbm7xQ1Pon5SVEk,8603
+saic_ismart_client_ng/api/vehicle_charging/schema.py,sha256=8f6E-xc7jp4vKtLih3pAlRB_nQQ25M2gUfNiha6q1eo,19557
+saic_ismart_client_ng/crypto_utils.py,sha256=WTDFZZLnkw0OzgxdyMRY7eCuRf1VNXnu8DxLHWABnX4,2929
+saic_ismart_client_ng/exceptions.py,sha256=HXPKmCULQN3elE2RPe5dASBSyvPMi1XFtLIOwFifviw,816
+saic_ismart_client_ng/listener.py,sha256=uCnhbJ1Ga0JKKBJfdw1jtq1coGVXU9aD_NMp_Rtg-E0,346
+saic_ismart_client_ng/model.py,sha256=b4j9Ly1Cn0DAVeYERPrfEcAPUA84lbfjzyRPSnYtPJA,1655
+saic_ismart_client_ng/net/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+saic_ismart_client_ng/net/client/__init__.py,sha256=sO1DVXVR0PfELPR3j2XOhdo0MRQwcUZ-dpfwcNn7Tjs,3486
+saic_ismart_client_ng/net/crypto.py,sha256=V-8a4h_aGO2Tx5OhPJjPA9I0f5gVo-D6wvnUumg_ivQ,8865
+saic_ismart_client_ng/net/httpx/__init__.py,sha256=Ak6gt-xjkno9wOUAjE-gDNc6B5T03S0gex1xPJEQouE,2639
+saic_ismart_client_ng/net/utils.py,sha256=uCbRWR3oEX4MD99Lkrn26bk65sajPop9_YegPHaqx70,415
+saic_ismart_client_ng/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mg_saic_client-0.9.4.dist-info/METADATA,sha256=fWIRkmfn_A38Fz3jmb-bnTinOpgCeeMSH-XACEHcfRc,1582
+mg_saic_client-0.9.4.dist-info/WHEEL,sha256=eY7nduwzv-ldUxpzbRlxwvC693Hg6PX8bWDjEHjZ_dk,88
+mg_saic_client-0.9.4.dist-info/licenses/LICENSE,sha256=MLaavCZompIU1_X68Dps3CpXejMn19ESxP2IZPLTUhc,1083
+mg_saic_client-0.9.4.dist-info/RECORD,,

mg_saic_client-0.9.4.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.4.1
+Root-Is-Purelib: true
+Tag: py3-none-any

mg_saic_client-0.9.4.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 The SAIC-iSmart-API project
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

saic_ismart_client_ng/__init__.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from saic_ismart_client_ng.api.message import SaicMessageApi
+from saic_ismart_client_ng.api.user import SaicUserApi
+from saic_ismart_client_ng.api.vehicle.alarm import SaicVehicleAlarmApi
+from saic_ismart_client_ng.api.vehicle.climate import SaicVehicleClimateApi
+from saic_ismart_client_ng.api.vehicle.locks import SaicVehicleLocksApi
+from saic_ismart_client_ng.api.vehicle.windows import SaicVehicleWindowsApi
+from saic_ismart_client_ng.api.vehicle_charging import SaicVehicleChargingApi
+
+
+class SaicApi(
+    SaicUserApi,
+    SaicMessageApi,
+    SaicVehicleAlarmApi,
+    SaicVehicleLocksApi,
+    SaicVehicleWindowsApi,
+    SaicVehicleClimateApi,
+    SaicVehicleChargingApi,
+):
+    """The SAIC Api client."""

saic_ismart_client_ng/api/base.py

@@ -0,0 +1,429 @@
+from __future__ import annotations
+
+from dataclasses import asdict
+import datetime
+import logging
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    ClassVar,
+    Protocol,
+    TypeVar,
+)
+
+import dacite
+import httpx
+import tenacity
+from tenacity import RetryCallState, retry_if_exception
+
+from saic_ismart_client_ng.api.schema import LoginResp
+from saic_ismart_client_ng.crypto_utils import sha1_hex_digest
+from saic_ismart_client_ng.exceptions import (
+    SaicApiException,
+    SaicApiRetryException,
+    SaicLogoutException,
+)
+from saic_ismart_client_ng.net.client import SaicApiClient
+
+if TYPE_CHECKING:
+    from collections.abc import MutableMapping
+
+    from httpx._types import HeaderTypes, QueryParamTypes
+
+    from saic_ismart_client_ng.listener import SaicApiListener
+    from saic_ismart_client_ng.model import SaicApiConfiguration
+
+    class IsDataclass(Protocol):
+        # as already noted in comments, checking for this attribute is currently
+        # the most reliable way to ascertain that something is a dataclass
+        __dataclass_fields__: ClassVar[dict[str, Any]]
+
+    T = TypeVar("T", bound=IsDataclass)
+
+logger = logging.getLogger(__name__)
+
+
+class AbstractSaicApi:
+    def __init__(
+        self,
+        configuration: SaicApiConfiguration,
+        listener: SaicApiListener | None = None,
+    ) -> None:
+        self.__configuration = configuration
+        self.__api_client = SaicApiClient(configuration, listener=listener)
+        self.__token_expiration: datetime.datetime | None = None
+
+    async def close(self) -> None:
+        """Close the API client and release its HTTP resources."""
+        await self.__api_client.close()
+
+    async def login(self) -> LoginResp:
+        headers = {
+            "Content-Type": "application/x-www-form-urlencoded",
+            "Accept": "application/json",
+            "Authorization": "Basic c3dvcmQ6c3dvcmRfc2VjcmV0",
+        }
+        firebase_device_id = (
+            "simulator*********************************************"
+            + str(int(datetime.datetime.now().timestamp()))
+        )
+        form_body = {
+            "grant_type": "password",
+            "username": self.__configuration.username,
+            "password": sha1_hex_digest(self.__configuration.password),
+            "scope": "all",
+            "deviceId": f"{firebase_device_id}###com.saicmotor.europecar",
+            "deviceType": "0",  # 2 for huawei
+            "language": "EN",
+        }
+
+        if self.__configuration.username_is_email:
+            form_body.update({"loginType": "2"})
+        elif self.__configuration.phone_country_code is not None:
+            form_body.update(
+                {
+                    "loginType": "1",
+                    "countryCode": self.__configuration.phone_country_code,
+                }
+            )
+        else:
+            raise SaicApiException(
+                "Username is not an email but no phone number country code has been provided."
+            )
+
+        result = await self.execute_api_call(
+            "POST",
+            "/oauth/token",
+            form_body=form_body,
+            out_type=LoginResp,
+            headers=headers,
+        )
+        # Update the user token
+        if not (access_token := result.access_token) or not (
+            expiration := result.expires_in
+        ):
+            raise SaicApiException(
+                "Failed to get an access token, please check your credentials"
+            )
+
+        self.__api_client.user_token = access_token
+        self.__token_expiration = datetime.datetime.now() + datetime.timedelta(
+            seconds=expiration
+        )
+        return result
+
+    async def execute_api_call(
+        self,
+        method: str,
+        path: str,
+        *,
+        body: Any | None = None,
+        form_body: Any | None = None,
+        out_type: type[T],
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+    ) -> T:
+        result = await self.__execute_api_call(
+            method,
+            path,
+            body=body,
+            form_body=form_body,
+            out_type=out_type,
+            params=params,
+            headers=headers,
+            allow_null_body=False,
+        )
+        if result is None:
+            msg = f"Failed to execute api call {method} {path}, was expecting a result of type {out_type} got None instead"
+            raise SaicApiException(msg)
+        return result
+
+    async def execute_api_call_with_optional_result(
+        self,
+        method: str,
+        path: str,
+        *,
+        body: Any | None = None,
+        form_body: Any | None = None,
+        out_type: type[T],
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+    ) -> T | None:
+        return await self.__execute_api_call(
+            method,
+            path,
+            body=body,
+            form_body=form_body,
+            out_type=out_type,
+            params=params,
+            headers=headers,
+            allow_null_body=True,
+        )
+
+    async def execute_api_call_no_result(
+        self,
+        method: str,
+        path: str,
+        *,
+        body: Any | None = None,
+        form_body: Any | None = None,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+    ) -> None:
+        await self.__execute_api_call(
+            method,
+            path,
+            body=body,
+            form_body=form_body,
+            params=params,
+            headers=headers,
+            allow_null_body=True,
+        )
+
+    async def __execute_api_call(
+        self,
+        method: str,
+        path: str,
+        *,
+        body: Any | None = None,
+        form_body: Any | None = None,
+        out_type: type[T] | None = None,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        allow_null_body: bool = False,
+    ) -> T | None:
+        try:
+            url = f"{self.__configuration.base_uri}{path.removeprefix('/')}"
+            json_body = asdict(body) if body else None
+            req = httpx.Request(
+                method,
+                url,
+                params=params,
+                headers=headers,
+                data=form_body,
+                json=json_body,
+            )
+            response = await self.__api_client.send(req)
+            return await self.__deserialize(req, response, out_type, allow_null_body)
+        except SaicApiException as e:
+            raise e
+        except Exception as e:
+            msg = f"API call {method} {path} failed unexpectedly"
+            raise SaicApiException(msg, return_code=500) from e
+
+    async def execute_api_call_with_event_id(
+        self,
+        method: str,
+        path: str,
+        *,
+        body: Any | None = None,
+        out_type: type[T],
+        params: QueryParamTypes | None = None,
+        headers: MutableMapping[str, str] | None = None,
+        delay: tenacity.wait.WaitBaseT | None = None,
+    ) -> T:
+        result = await self.__execute_api_call_with_event_id(
+            method,
+            path,
+            body=body,
+            out_type=out_type,
+            params=params,
+            headers=headers,
+            delay=delay,
+        )
+        if result is None:
+            msg = f"Failed to execute api call {method} {path}, was expecting a result of type {out_type} got None instead"
+            raise SaicApiException(msg)
+        return result
+
+    async def execute_api_call_with_event_id_no_result(
+        self,
+        method: str,
+        path: str,
+        *,
+        body: Any | None = None,
+        params: QueryParamTypes | None = None,
+        headers: MutableMapping[str, str] | None = None,
+        delay: tenacity.wait.WaitBaseT | None = None,
+    ) -> None:
+        await self.__execute_api_call_with_event_id(
+            method,
+            path,
+            body=body,
+            params=params,
+            headers=headers,
+            delay=delay,
+        )
+
+    async def __execute_api_call_with_event_id(
+        self,
+        method: str,
+        path: str,
+        *,
+        body: Any | None = None,
+        out_type: type[T] | None = None,
+        params: QueryParamTypes | None = None,
+        headers: MutableMapping[str, str] | None = None,
+        delay: tenacity.wait.WaitBaseT | None = None,
+    ) -> T | None:
+        @tenacity.retry(
+            stop=tenacity.stop_after_delay(30),
+            wait=delay or tenacity.wait_fixed(self.__configuration.sms_delivery_delay),
+            retry=SaicApiRetryPolicy(),
+            after=saic_api_after_retry,
+            reraise=True,
+        )
+        async def execute_api_call_with_event_id_inner(*, event_id: str) -> T | None:
+            actual_headers = headers or {}
+            actual_headers.update({"event-id": event_id})
+            return await self.__execute_api_call(
+                method,
+                path,
+                body=body,
+                out_type=out_type,
+                params=params,
+                headers=actual_headers,
+            )
+
+        return await execute_api_call_with_event_id_inner(event_id="0")
+
+    async def __deserialize(
+        self,
+        request: httpx.Request,
+        response: httpx.Response,
+        data_class: type[T] | None,
+        allow_null_body: bool,
+    ) -> T | None:
+        try:
+            request_event_id = request.headers.get("event-id")
+            json_data = response.json()
+            return_code = json_data.get("code", -1)
+            error_message = json_data.get("message", "Unknown error")
+            logger.debug("Response code: %s %s", return_code, response.text)
+
+            if return_code in (401, 403) or response.status_code in (401, 403):
+                self.logout()
+                raise SaicLogoutException(response.text, return_code)
+
+            if return_code in (2, 3, 7):
+                logger.error(
+                    "API call return code is not acceptable: %s: %s",
+                    return_code,
+                    response.text,
+                )
+                raise SaicApiException(error_message, return_code=return_code)
+
+            if "event-id" in response.headers and "data" not in json_data:
+                event_id = response.headers["event-id"]
+                logger.info(
+                    "Retrying since we got event-id in headers: %s, but no data",
+                    event_id,
+                )
+                raise SaicApiRetryException(
+                    error_message, event_id=event_id, return_code=return_code
+                )
+
+            if return_code != 0:
+                if request_event_id is not None and request_event_id != "0":
+                    logger.info(
+                        "API call asked us to retry: %s %s. Event id was: %s",
+                        return_code,
+                        response.text,
+                        request_event_id,
+                    )
+                    raise SaicApiRetryException(
+                        error_message,
+                        event_id=request_event_id,
+                        return_code=return_code,
+                    )
+                logger.error(
+                    "API call return code is not acceptable: %s %s. Headers: %s",
+                    return_code,
+                    response.text,
+                    response.headers,
+                )
+                raise SaicApiException(error_message, return_code=return_code)
+
+            if data_class is None:
+                return None
+            if "data" in json_data:
+                return dacite.from_dict(data_class, json_data["data"])
+            if allow_null_body:
+                return None
+            msg = (
+                f"Failed to deserialize response, missing 'data' field: {response.text}"
+            )
+            raise SaicApiException(msg)
+
+        except SaicApiException as se:
+            raise se
+        except Exception as e:
+            if response.is_error:
+                if response.status_code in (401, 403):
+                    logger.exception(
+                        "API call failed due to an authentication failure: %s %s",
+                        response.status_code,
+                        response.text,
+                    )
+                    self.logout()
+                    raise SaicLogoutException(
+                        response.text, response.status_code
+                    ) from e
+                logger.exception(
+                    "API call failed: %s %s",
+                    response.status_code,
+                    response.text,
+                )
+                raise SaicApiException(response.text, response.status_code) from e
+            msg = f"Failed to deserialize response: {e}. Original json was {response.text}"
+            raise SaicApiException(msg) from e
+
+    def logout(self) -> None:
+        self.__api_client.user_token = ""
+        self.__token_expiration = None
+
+    @property
+    def is_logged_in(self) -> bool:
+        return (
+            self.__api_client.user_token is not None
+            and self.__token_expiration is not None
+            and self.__token_expiration > datetime.datetime.now()
+        )
+
+    @property
+    def token_expiration(self) -> datetime.datetime | None:
+        return self.__token_expiration
+
+
+def saic_api_after_retry(retry_state: RetryCallState) -> None:
+    if not retry_state.outcome:
+        return
+    wrapped_exception = retry_state.outcome.exception()
+    if isinstance(wrapped_exception, SaicApiRetryException):
+        if "event_id" in retry_state.kwargs:
+            event_id = wrapped_exception.event_id
+            logger.debug(
+                "Updating event_id to the newly obtained value %d",
+                event_id,
+            )
+            retry_state.kwargs["event_id"] = event_id
+        else:
+            logger.debug("Retrying without an event_id")
+
+
+class SaicApiRetryPolicy(retry_if_exception):
+    def __init__(self) -> None:
+        def __retry_policy(wrapped_exception: BaseException) -> bool:
+            if isinstance(wrapped_exception, SaicApiRetryException):
+                logger.debug("Retrying since we got SaicApiRetryException")
+                return True
+            if isinstance(wrapped_exception, SaicLogoutException):
+                logger.error("Not retrying since we got logged out")
+                return False
+            if isinstance(wrapped_exception, SaicApiException):
+                logger.error("Not retrying since we got a generic exception")
+                return False
+            logger.error("Not retrying", exc_info=wrapped_exception)
+            return False
+
+        super().__init__(__retry_policy)

saic_ismart_client_ng/api/message/__init__.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+from saic_ismart_client_ng.api.base import AbstractSaicApi
+from saic_ismart_client_ng.api.message.schema import (
+    MessageEntity,
+    MessageResp,
+    UpateMessageRequest,
+)
+
+__all__ = [
+    "MessageEntity",
+    "MessageResp",
+    "UpateMessageRequest",
+]
+
+
+class SaicMessageApi(AbstractSaicApi):
+    async def get_alarm_list(
+        self, *, page_num: int, page_size: int
+    ) -> MessageResp | None:
+        return await self.get_message_list(
+            page_num=page_num, page_size=page_size, message_group="ALARM"
+        )
+
+    async def get_command_list(
+        self, *, page_num: int, page_size: int
+    ) -> MessageResp | None:
+        return await self.get_message_list(
+            page_num=page_num, page_size=page_size, message_group="COMMAND"
+        )
+
+    async def get_news_list(
+        self, *, page_num: int, page_size: int
+    ) -> MessageResp | None:
+        return await self.get_message_list(
+            page_num=page_num, page_size=page_size, message_group="NEWS"
+        )
+
+    async def get_message_list(
+        self, *, page_num: int, page_size: int, message_group: str
+    ) -> MessageResp | None:
+        return await self.execute_api_call_with_optional_result(
+            "GET",
+            "/message/list",
+            params={
+                "pageNum": page_num,
+                "pageSize": page_size,
+                "messageGroup": message_group,
+            },
+            out_type=MessageResp,
+        )
+
+    async def delete_all_alarms(self) -> None:
+        await self.__change_message_status(action="DELETE_ALARM")
+
+    async def delete_all_commands(self) -> None:
+        await self.__change_message_status(action="DELETE_COMMAND")
+
+    async def delete_all_news(self) -> None:
+        await self.__change_message_status(action="DELETE_NEWS")
+
+    async def read_message(self, *, message_id: str | int) -> None:
+        await self.__change_message_status(message_id=message_id, action="READ")
+
+    async def delete_message(self, *, message_id: str | int) -> None:
+        await self.__change_message_status(message_id=message_id, action="DELETE")
+
+    async def __change_message_status(
+        self, *, action: str, message_id: str | int | None = None
+    ) -> None:
+        request = UpateMessageRequest(
+            actionType=action,
+            messageId=message_id,
+        )
+        await self.update_message_status(request)
+
+    async def update_message_status(self, data: UpateMessageRequest) -> None:
+        await self.execute_api_call_no_result(
+            "PUT",
+            "/message/status",
+            body=data,
+        )
+
+    async def get_unread_messages_count(self) -> MessageResp | None:
+        return await self.execute_api_call_with_optional_result(
+            "GET", "/message/unreadCount", out_type=MessageResp
+        )