pymammotion 0.2.62__py3-none-any.whl → 0.5.51__py3-none-any.whl

pymammotion/aliyun/cloud_gateway.py

@@ -1,32 +1,33 @@
 """Module for interacting with Aliyun Cloud IoT Gateway."""
 
+import asyncio
 import base64
 import hashlib
 import hmac
 import itertools
 import json
+from json.decoder import JSONDecodeError
+from logging import getLogger
 import random
 import string
 import time
 import uuid
-from logging import getLogger
 
-from aiohttp import ClientSession
-from alibabacloud_iot_api_gateway.client import Client
+from aiohttp import ClientSession, ConnectionTimeoutError
 from alibabacloud_iot_api_gateway.models import CommonParams, Config, IoTApiRequest
 from alibabacloud_tea_util.client import Client as UtilClient
 from alibabacloud_tea_util.models import RuntimeOptions
+from Tea.exceptions import UnretryableException
 
+from pymammotion.aliyun.client import Client
 from pymammotion.aliyun.model.aep_response import AepResponse
 from pymammotion.aliyun.model.connect_response import ConnectResponse
-from pymammotion.aliyun.model.dev_by_account_response import (
-    ListingDevByAccountResponse,
-)
+from pymammotion.aliyun.model.dev_by_account_response import ListingDevAccountResponse
 from pymammotion.aliyun.model.login_by_oauth_response import LoginByOAuthResponse
 from pymammotion.aliyun.model.regions_response import RegionResponse
-from pymammotion.aliyun.model.session_by_authcode_response import (
-    SessionByAuthCodeResponse,
-)
+from pymammotion.aliyun.model.session_by_authcode_response import SessionByAuthCodeResponse
+from pymammotion.aliyun.model.thing_response import ThingPropertiesResponse
+from pymammotion.aliyun.regions import region_mappings
 from pymammotion.const import ALIYUN_DOMAIN, APP_KEY, APP_SECRET, APP_VERSION
 from pymammotion.http.http import MammotionHTTP
 from pymammotion.utility.datatype_converter import DatatypeConverter
@@ -49,6 +50,10 @@ MOVE_HEADERS = (
 class SetupException(Exception):
     """Raise when mqtt expires token or token is invalid."""
 
+    def __init__(self, *args: object) -> None:
+        super().__init__(args)
+        self.iot_id = args[1]
+
 
 class AuthRefreshException(Exception):
     """Raise exception when library cannot refresh token."""
@@ -57,6 +62,38 @@ class AuthRefreshException(Exception):
 class DeviceOfflineException(Exception):
     """Raise exception when device is offline."""
 
+    def __init__(self, *args: object) -> None:
+        super().__init__(args)
+        self.iot_id = args[1]
+
+
+class FailedRequestException(Exception):
+    """Raise exception when request response is bad."""
+
+    def __init__(self, *args: object) -> None:
+        super().__init__(args)
+        self.iot_id = args[0]
+
+
+class NoConnectionException(UnretryableException):
+    """Raise exception when device is unreachable."""
+
+
+class GatewayTimeoutException(Exception):
+    """Raise exception when the gateway times out."""
+
+    def __init__(self, *args: object) -> None:
+        super().__init__(args)
+        self.iot_id = args[1]
+
+
+class TooManyRequestsException(Exception):
+    """Raise exception when the gateway times out."""
+
+    def __init__(self, *args: object) -> None:
+        super().__init__(args)
+        self.iot_id = args[1]
+
 
 class LoginException(Exception):
     """Raise exception when library cannot log in."""
@@ -66,6 +103,9 @@ class CheckSessionException(Exception):
     """Raise exception when checking session results in a failure."""
 
 
+EXPIRED_CREDENTIAL_EXCEPTIONS = (CheckSessionException, SetupException)
+
+
 class CloudIOTGateway:
     """Class for interacting with Aliyun Cloud IoT Gateway."""
 
@@ -77,19 +117,20 @@ class CloudIOTGateway:
 
     def __init__(
         self,
+        mammotion_http: MammotionHTTP,
         connect_response: ConnectResponse | None = None,
         login_by_oauth_response: LoginByOAuthResponse | None = None,
         aep_response: AepResponse | None = None,
         session_by_authcode_response: SessionByAuthCodeResponse | None = None,
         region_response: RegionResponse | None = None,
-        dev_by_account: ListingDevByAccountResponse | None = None,
+        dev_by_account: ListingDevAccountResponse | None = None,
     ) -> None:
         """Initialize the CloudIOTGateway."""
-        self.mammotion_http: MammotionHTTP | None = None
+        self.mammotion_http: MammotionHTTP = mammotion_http
         self._app_key = APP_KEY
         self._app_secret = APP_SECRET
         self.domain = ALIYUN_DOMAIN
-
+        self.message_delay = 1
         self._client_id = self.generate_hardware_string(8)  # 8 characters
         self._device_sn = self.generate_hardware_string(32)  # 32 characters
         self._utdid = self.generate_hardware_string(32)  # 32 characters
@@ -99,9 +140,16 @@ class CloudIOTGateway:
         self._session_by_authcode_response = session_by_authcode_response
         self._region_response = region_response
         self._devices_by_account_response = dev_by_account
+        self._iot_token_issued_at = int(time.time())
+        if self._session_by_authcode_response:
+            self._iot_token_issued_at = (
+                self._session_by_authcode_response.token_issued_at
+                if self._session_by_authcode_response.token_issued_at is not None
+                else int(time.time())
+            )
 
     @staticmethod
-    def generate_random_string(length: int):
+    def generate_random_string(length: int) -> str:
         """Generate a random string of specified length."""
         characters = string.ascii_letters + string.digits
         return "".join(random.choice(characters) for _ in range(length))
@@ -112,7 +160,15 @@ class CloudIOTGateway:
         hashed_uuid = hashlib.sha1(f"{uuid.getnode()}".encode()).hexdigest()
         return "".join(itertools.islice(itertools.cycle(hashed_uuid), length))
 
-    def sign(self, data):
+    @staticmethod
+    def parse_json_response(response_body_str: str) -> dict:
+        try:
+            return json.loads(response_body_str) if response_body_str is not None else {}
+        except JSONDecodeError:
+            logger.error("Couldn't decode message %s", response_body_str)
+            return {"code": 22000}
+
+    def sign(self, data: dict) -> str:
         """Generate signature for the given data."""
         keys = ["appKey", "clientId", "deviceSn", "timestamp"]
         concatenated_str = ""
@@ -127,8 +183,13 @@ class CloudIOTGateway:
             hashlib.sha1,
         ).hexdigest()
 
-    def get_region(self, country_code: str, auth_code: str):
+    async def get_region(self, country_code: str) -> RegionResponse:
         """Get the region based on country code and auth code."""
+        auth_code = self.mammotion_http.login_info.authorization_code
+
+        if self._region_response is not None:
+            return self._region_response
+
         config = Config(
             app_key=self._app_key,
             app_secret=self._app_secret,
@@ -150,17 +211,33 @@ class CloudIOTGateway:
         )
 
         # send request
-        response = client.do_request("/living/account/region/get", "https", "POST", None, body, RuntimeOptions())
-        logger.debug(response.status_message)
-        logger.debug(response.headers)
-        logger.debug(response.status_code)
-        logger.debug(response.body)
-
+        try:
+            response = await client.async_do_request(
+                "/living/account/region/get", "https", "POST", None, body, RuntimeOptions()
+            )
+            logger.debug(response.status_message)
+            logger.debug(response.headers)
+            logger.debug(response.status_code)
+            logger.debug(response.body)
+        except ConnectionTimeoutError:
+            body = {"data": {}, "code": 200}
+
+            region = region_mappings.get(country_code, "US")
+            body["data"]["shortRegionId"] = region
+            body["data"]["regionEnglishName"] = ""
+            body["data"]["oaApiGatewayEndpoint"] = f"living-account.{region}.aliyuncs.com"
+            body["data"]["regionId"] = region
+            body["data"]["mqttEndpoint"] = f"public.itls.{region}.aliyuncs.com:1883"
+            body["data"]["pushChannelEndpoint"] = f"living-accs.{region}.aliyuncs.com"
+            body["data"]["apiGatewayEndpoint"] = f"{region}.api-iot.aliyuncs.com"
+
+            RegionResponse.from_dict(body)
+            return body
         # Decode the response body
         response_body_str = response.body.decode("utf-8")
 
         # Load the JSON string into a dictionary
-        response_body_dict = json.loads(response_body_str)
+        response_body_dict = self.parse_json_response(response_body_str)
 
         if int(response_body_dict.get("code")) != 200:
             raise Exception("Error in getting regions: " + response_body_dict["msg"])
@@ -170,7 +247,7 @@ class CloudIOTGateway:
 
         return response.body
 
-    def aep_handle(self):
+    async def aep_handle(self) -> AepResponse:
         """Handle AEP authentication."""
         aep_domain = self.domain
 
@@ -209,7 +286,7 @@ class CloudIOTGateway:
         )
 
         # send request
-        response = client.do_request("/app/aepauth/handle", "https", "POST", None, body, RuntimeOptions())
+        response = await client.async_do_request("/app/aepauth/handle", "https", "POST", None, body, RuntimeOptions())
         logger.debug(response.status_message)
         logger.debug(response.headers)
         logger.debug(response.status_code)
@@ -217,7 +294,7 @@ class CloudIOTGateway:
 
         response_body_str = response.body.decode("utf-8")
 
-        response_body_dict = json.loads(response_body_str)
+        response_body_dict = self.parse_json_response(response_body_str)
 
         if int(response_body_dict.get("code")) != 200:
             raise Exception("Error in getting mqtt credentials: " + response_body_dict["msg"])
@@ -226,9 +303,9 @@ class CloudIOTGateway:
 
         logger.debug(response_body_dict)
 
-        return response.body
+        return self._aep_response
 
-    async def connect(self):
+    async def connect(self) -> ConnectResponse:
         """Connect to the Aliyun Cloud IoT Gateway."""
         region_url = "sdk.openaccount.aliyun.com"
         time_now = time.time()
@@ -302,8 +379,9 @@ class CloudIOTGateway:
                     return self._connect_response
                 raise LoginException(data)
 
-    async def login_by_oauth(self, country_code: str, auth_code: str):
+    async def login_by_oauth(self, country_code: str):
         """Login by OAuth."""
+        auth_code = self.mammotion_http.login_info.authorization_code
         region_url = self._region_response.data.oaApiGatewayEndpoint
 
         async with ClientSession() as session:
@@ -374,7 +452,7 @@ class CloudIOTGateway:
                     return self._login_by_oauth_response
                 raise LoginException(data)
 
-    def session_by_auth_code(self):
+    async def session_by_auth_code(self) -> SessionByAuthCodeResponse:
         """Create a session by auth code."""
         config = Config(
             app_key=self._app_key,
@@ -399,7 +477,7 @@ class CloudIOTGateway:
         )
 
         # send request
-        response = client.do_request(
+        response = await client.async_do_request(
             "/account/createSessionByAuthCode",
             "https",
             "POST",
@@ -416,7 +494,7 @@ class CloudIOTGateway:
         response_body_str = response.body.decode("utf-8")
 
         # Load the JSON string into a dictionary
-        response_body_dict = json.loads(response_body_str)
+        response_body_dict = self.parse_json_response(response_body_str)
 
         session_by_auth = SessionByAuthCodeResponse.from_dict(response_body_dict)
 
@@ -431,7 +509,7 @@ class CloudIOTGateway:
 
         return response.body
 
-    def sign_out(self) -> None:
+    async def sign_out(self) -> dict:
         config = Config(
             app_key=self._app_key,
             app_secret=self._app_secret,
@@ -455,7 +533,7 @@ class CloudIOTGateway:
 
         # send request
         # possibly need to do this ourselves
-        response = client.do_request(
+        response = await client.async_do_request(
             "/iotx/account/invalidSession",
             "https",
             "POST",
@@ -472,13 +550,12 @@ class CloudIOTGateway:
         response_body_str = response.body.decode("utf-8")
 
         # Load the JSON string into a dictionary
-        response_body_dict = json.loads(response_body_str)
-        logger.debug(response_body_dict)
+        response_body_dict = self.parse_json_response(response_body_str)
         return response_body_dict
 
-    def check_or_refresh_session(self):
+    async def check_or_refresh_session(self):
         """Check or refresh the session."""
-        logger.debug("Try to refresh token")
+        logger.debug("Trying to refresh token")
         config = Config(
             app_key=self._app_key,
             app_secret=self._app_secret,
@@ -502,7 +579,7 @@ class CloudIOTGateway:
 
         # send request
         # possibly need to do this ourselves
-        response = client.do_request(
+        response = await client.async_do_request(
             "/account/checkOrRefreshSession",
             "https",
             "POST",
@@ -519,18 +596,23 @@ class CloudIOTGateway:
         response_body_str = response.body.decode("utf-8")
 
         # Load the JSON string into a dictionary
-        response_body_dict = json.loads(response_body_str)
+        response_body_dict = self.parse_json_response(response_body_str)
 
         if int(response_body_dict.get("code")) != 200:
             logger.error(response_body_dict)
-            self.sign_out()
+            await self.sign_out()
+            raise CheckSessionException("Error check or refresh token: " + response_body_dict.__str__())
+
+        if response_body_dict.get("code") == 2401:
+            await self.sign_out()
             raise CheckSessionException("Error check or refresh token: " + response_body_dict.__str__())
 
         session = SessionByAuthCodeResponse.from_dict(response_body_dict)
         session_data = session.data
 
         if (
-            session_data.identityId is None
+            session_data is None
+            or session_data.identityId is None
             or session_data.refreshTokenExpire is None
             or session_data.iotToken is None
             or session_data.iotTokenExpire is None
@@ -541,7 +623,7 @@ class CloudIOTGateway:
         self._session_by_authcode_response = session
         self._iot_token_issued_at = int(time.time())
 
-    def list_binding_by_account(self) -> ListingDevByAccountResponse:
+    async def list_binding_by_account(self) -> ListingDevAccountResponse:
         """List bindings by account."""
         config = Config(
             app_key=self._app_key,
@@ -565,7 +647,9 @@ class CloudIOTGateway:
         )
 
         # send request
-        response = client.do_request("/uc/listBindingByAccount", "https", "POST", None, body, RuntimeOptions())
+        response = await client.async_do_request(
+            "/uc/listBindingByAccount", "https", "POST", None, body, RuntimeOptions()
+        )
         logger.debug(response.status_message)
         logger.debug(response.headers)
         logger.debug(response.status_code)
@@ -575,15 +659,15 @@ class CloudIOTGateway:
         response_body_str = response.body.decode("utf-8")
 
         # Load the JSON string into a dictionary
-        response_body_dict = json.loads(response_body_str)
+        response_body_dict = self.parse_json_response(response_body_str)
 
         if int(response_body_dict.get("code")) != 200:
-            raise Exception("Error in creating session: " + response_body_dict["msg"])
+            raise Exception("Error in creating session: " + response_body_dict["message"])
 
-        self._devices_by_account_response = ListingDevByAccountResponse.from_dict(response_body_dict)
+        self._devices_by_account_response = ListingDevAccountResponse.from_dict(response_body_dict)
         return self._devices_by_account_response
 
-    def list_binding_by_dev(self, iot_id: str):
+    async def list_binding_by_dev(self, iot_id: str):
         config = Config(
             app_key=self._app_key,
             app_secret=self._app_secret,
@@ -606,7 +690,91 @@ class CloudIOTGateway:
         )
 
         # send request
-        response = client.do_request("/uc/listBindingByDev", "https", "POST", None, body, RuntimeOptions())
+        response = await client.async_do_request("/uc/listBindingByDev", "https", "POST", None, body, RuntimeOptions())
+        logger.debug(response.status_message)
+        logger.debug(response.headers)
+        logger.debug(response.status_code)
+        logger.debug(response.body)
+
+        # Decode the response body
+        response_body_str = response.body.decode("utf-8")
+
+        # Load the JSON string into a dictionary
+        response_body_dict = self.parse_json_response(response_body_str)
+
+        if int(response_body_dict.get("code")) != 200:
+            raise Exception("Error in getting shared device list: " + response_body_dict["msg"])
+
+        self._devices_by_account_response = ListingDevAccountResponse.from_dict(response_body_dict)
+        return self._devices_by_account_response
+
+    async def confirm_share(self, record_list: list[str]) -> bool:
+        config = Config(
+            app_key=self._app_key,
+            app_secret=self._app_secret,
+            domain=self._region_response.data.apiGatewayEndpoint,
+        )
+
+        client = Client(config)
+
+        # build request
+        request = CommonParams(
+            api_ver="1.0.7",
+            language="en-US",
+            iot_token=self._session_by_authcode_response.data.iotToken,
+        )
+        body = IoTApiRequest(
+            id=str(uuid.uuid4()),
+            params={"agree": 1, "recordIdList": record_list},
+            request=request,
+            version="1.0",
+        )
+
+        # send request
+        response = await client.async_do_request("/uc/confirmShare", "https", "POST", None, body, RuntimeOptions())
+        logger.debug(response.status_message)
+        logger.debug(response.headers)
+        logger.debug(response.status_code)
+        logger.debug(response.body)
+
+        # Decode the response body
+        response_body_str = response.body.decode("utf-8")
+
+        # Load the JSON string into a dictionary
+        response_body_dict = self.parse_json_response(response_body_str)
+
+        if int(response_body_dict.get("code")) != 200:
+            raise Exception("Error in accepting share: " + response_body_dict["msg"])
+
+        return True
+
+    async def get_shared_notice_list(self):
+        ### status 0 accepted status -1 ready to be accepted 3 expired
+        config = Config(
+            app_key=self._app_key,
+            app_secret=self._app_secret,
+            domain=self._region_response.data.apiGatewayEndpoint,
+        )
+
+        client = Client(config)
+
+        # build request
+        request = CommonParams(
+            api_ver="1.0.9",
+            language="en-US",
+            iot_token=self._session_by_authcode_response.data.iotToken,
+        )
+        body = IoTApiRequest(
+            id=str(uuid.uuid4()),
+            params={"pageSize": 100, "pageNo": 1},
+            request=request,
+            version="1.0",
+        )
+
+        # send request
+        response = await client.async_do_request(
+            "/uc/getShareNoticeList", "https", "POST", None, body, RuntimeOptions()
+        )
         logger.debug(response.status_message)
         logger.debug(response.headers)
         logger.debug(response.status_code)
@@ -616,16 +784,33 @@ class CloudIOTGateway:
         response_body_str = response.body.decode("utf-8")
 
         # Load the JSON string into a dictionary
-        response_body_dict = json.loads(response_body_str)
+        response_body_dict = self.parse_json_response(response_body_str)
 
         if int(response_body_dict.get("code")) != 200:
             raise Exception("Error in creating session: " + response_body_dict["msg"])
 
-        self._devices_by_account_response = ListingDevByAccountResponse.from_dict(response_body_dict)
+        self._devices_by_account_response = ListingDevAccountResponse.from_dict(response_body_dict)
         return self._devices_by_account_response
 
-    def send_cloud_command(self, iot_id: str, command: bytes) -> str:
-        """Send a cloud command to the specified IoT device."""
+    async def send_cloud_command(self, iot_id: str, command: bytes) -> str:
+        """Sends a cloud command to a specified IoT device.
+
+        This function checks if the IoT token is expired and attempts to refresh it if
+        possible. It then constructs a request using the provided command and sends it
+        to the IoT device via an asynchronous HTTP POST request. The function handles
+        various error codes and exceptions based on the response from the cloud
+        service.
+
+        Args:
+            iot_id (str): The unique identifier of the IoT device.
+            command (bytes): The command to be sent to the IoT device in binary format.
+
+        Returns:
+            str: A unique message ID for the sent command.
+
+        """
+        if command is None:
+            raise Exception("Command is missing / None")
 
         """Check if iotToken is expired"""
         if self._iot_token_issued_at + self._session_by_authcode_response.data.iotTokenExpire <= (
@@ -635,7 +820,7 @@ class CloudIOTGateway:
             if self._iot_token_issued_at + self._session_by_authcode_response.data.refreshTokenExpire > (
                 int(time.time())
             ):
-                self.check_or_refresh_session()
+                await self.check_or_refresh_session()
             else:
                 raise AuthRefreshException("Refresh token expired. Please re-login")
 
@@ -646,7 +831,6 @@ class CloudIOTGateway:
         )
 
         client = Client(config)
-
         # build request
         request = CommonParams(
             api_ver="1.0.5",
@@ -654,7 +838,7 @@ class CloudIOTGateway:
             iot_token=self._session_by_authcode_response.data.iotToken,
         )
 
-        # TODO move to using  InvokeThingServiceRequest()
+        # TODO move to using InvokeThingServiceRequest()
 
         message_id = str(uuid.uuid4())
 
@@ -670,59 +854,126 @@ class CloudIOTGateway:
         )
         logger.debug(self.converter.printBase64Binary(command))
         # send request
-        response = client.do_request("/thing/service/invoke", "https", "POST", None, body, RuntimeOptions())
+        runtime_options = RuntimeOptions(autoretry=True, backoff_policy="yes")
+        response = await client.async_do_request("/thing/service/invoke", "https", "POST", None, body, runtime_options)
         logger.debug(response.status_message)
         logger.debug(response.headers)
         logger.debug(response.status_code)
         logger.debug(response.body)
         logger.debug(iot_id)
 
+        if response.status_code == 429:
+            logger.debug("too many requests.")
+            if self.message_delay > 8:
+                raise TooManyRequestsException(response.status_message, iot_id)
+            asyncio.get_event_loop().call_later(
+                self.message_delay, lambda: asyncio.ensure_future(self.send_cloud_command(iot_id, command))
+            )
+            self.message_delay = self.message_delay * 2
+            return message_id
+
         response_body_str = response.body.decode("utf-8")
-        response_body_dict = json.loads(response_body_str)
+        response_body_dict = self.parse_json_response(response_body_str)
 
         if int(response_body_dict.get("code")) != 200:
             logger.error(
                 "Error in sending cloud command: %s - %s",
                 str(response_body_dict.get("code")),
-                str(response_body_dict.get("msg")),
+                str(response_body_dict.get("message")),
             )
+            if response_body_dict.get("code") == 22000:
+                logger.error(response.body)
+                raise FailedRequestException(iot_id)
+            if response_body_dict.get("code") == 20056:
+                logger.debug("Gateway timeout.")
+                raise GatewayTimeoutException(response_body_dict.get("code"), iot_id)
+
             if response_body_dict.get("code") == 29003:
                 logger.debug(self._session_by_authcode_response.data.identityId)
-                self.sign_out()
-                raise SetupException(response_body_dict.get("code"))
+                await self.sign_out()
+                raise SetupException(response_body_dict.get("code"), iot_id)
             if response_body_dict.get("code") == 6205:
-                raise DeviceOfflineException(response_body_dict.get("code"))
-                """Device is offline."""
+                raise DeviceOfflineException(response_body_dict.get("code"), iot_id)
+
+            if response_body_dict.get("code") == 460:
+                logger.debug("iotToken expired, must re-login.")
+                raise CheckSessionException(response_body_dict.get("message"))
+
+        if self.message_delay != 1:
+            self.message_delay = 1
 
         return message_id
 
+    async def get_device_properties(self, iot_id: str) -> ThingPropertiesResponse:
+        """List bindings by account."""
+        config = Config(
+            app_key=self._app_key,
+            app_secret=self._app_secret,
+            domain=self._region_response.data.apiGatewayEndpoint,
+        )
+
+        client = Client(config)
+
+        # build request
+        request = CommonParams(
+            api_ver="1.0.0",
+            language="en-US",
+            iot_token=self._session_by_authcode_response.data.iotToken,
+        )
+        body = IoTApiRequest(
+            id=str(uuid.uuid4()),
+            params={
+                "iotId": f"{iot_id}",
+            },
+            request=request,
+            version="1.0",
+        )
+
+        # send request
+        response = await client.async_do_request("/thing/properties/get", "https", "POST", None, body, RuntimeOptions())
+        logger.debug(response.status_message)
+        logger.debug(response.headers)
+        logger.debug(response.status_code)
+        logger.debug(response.body)
+
+        # Decode the response body
+        response_body_str = response.body.decode("utf-8")
+
+        # Load the JSON string into a dictionary
+        response_body_dict = self.parse_json_response(response_body_str)
+
+        if int(response_body_dict.get("code")) != 200:
+            raise Exception("Error in getting properties: " + response_body_dict["msg"])
+
+        return ThingPropertiesResponse.from_dict(response_body_dict)
+
     @property
     def devices_by_account_response(self):
         return self._devices_by_account_response
 
-    def set_http(self, mammotion_http) -> None:
+    def set_http(self, mammotion_http: MammotionHTTP) -> None:
         self.mammotion_http = mammotion_http
 
     @property
-    def region_response(self):
+    def region_response(self) -> RegionResponse | None:
         return self._region_response
 
     @property
-    def aep_response(self):
+    def aep_response(self) -> AepResponse | None:
         return self._aep_response
 
     @property
-    def session_by_authcode_response(self):
+    def session_by_authcode_response(self) -> SessionByAuthCodeResponse:
         return self._session_by_authcode_response
 
     @property
-    def client_id(self):
+    def client_id(self) -> str:
         return self._client_id
 
     @property
-    def login_by_oauth_response(self):
+    def login_by_oauth_response(self) -> LoginByOAuthResponse | None:
         return self._login_by_oauth_response
 
     @property
-    def connect_response(self):
+    def connect_response(self) -> ConnectResponse | None:
         return self._connect_response