pymammotion 0.4.16__tar.gz → 0.4.18__tar.gz

{pymammotion-0.4.16 → pymammotion-0.4.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pymammotion
-Version: 0.4.16
+Version: 0.4.18
 Summary: 
 License: GPL-3.0
 Author: Michael Arthur

pymammotion-0.4.18/pymammotion/aliyun/client.py

@@ -0,0 +1,230 @@
+import time
+
+from Tea.core import TeaCore
+from Tea.exceptions import UnretryableException
+from Tea.request import TeaRequest
+
+try:
+    from typing import Dict
+except ImportError:
+    pass
+
+from alibabacloud_apigateway_util.client import Client as APIGatewayUtilClient
+from alibabacloud_tea_util.client import Client as UtilClient
+
+
+class Client:
+    """test"""
+
+    _app_key = None  # type: str
+    _app_secret = None  # type: str
+    _protocol = None  # type: str
+    _user_agent = None  # type: str
+    _read_timeout = None  # type: int
+    _connect_timeout = None  # type: int
+    _http_proxy = None  # type: str
+    _https_proxy = None  # type: str
+    _no_proxy = None  # type: str
+    _max_idle_conns = None  # type: int
+    _domain = None  # type: str
+
+    def __init__(self, config) -> None:
+        self._domain = config.domain
+        self._app_key = config.app_key
+        self._app_secret = config.app_secret
+        self._protocol = config.protocol
+        self._read_timeout = config.read_timeout
+        self._connect_timeout = config.connect_timeout
+        self._http_proxy = config.http_proxy
+        self._https_proxy = config.https_proxy
+        self._no_proxy = config.no_proxy
+        self._max_idle_conns = config.max_idle_conns
+
+    def do_request(self, pathname, protocol, method, header, body, runtime):
+        """Send request
+
+        @type pathname: str
+        @param pathname: the url path
+
+        @type protocol: str
+        @param protocol: http or https
+
+        @type method: str
+        @param method: example GET
+
+        @type header: Dict[str, str]
+        @param header: request header
+
+        @type body: iot_api_gateway_models.IoTApiRequest
+        @param body: the object of IoTApiRequest
+
+        @type runtime: util_models.RuntimeOptions
+        @param runtime: which controls some details of call api, such as retry times
+
+        @rtype: TeaResponse
+        @return: the response
+        """
+        body.validate()
+        runtime.validate()
+        _runtime = {
+            "timeouted": "retry",
+            "readTimeout": UtilClient.default_number(runtime.read_timeout, self._read_timeout),
+            "connectTimeout": UtilClient.default_number(runtime.connect_timeout, self._connect_timeout),
+            "httpProxy": UtilClient.default_string(runtime.http_proxy, self._http_proxy),
+            "httpsProxy": UtilClient.default_string(runtime.https_proxy, self._https_proxy),
+            "noProxy": UtilClient.default_string(runtime.no_proxy, self._no_proxy),
+            "maxIdleConns": UtilClient.default_number(runtime.max_idle_conns, self._max_idle_conns),
+            "retry": {
+                "retryable": runtime.autoretry,
+                "maxAttempts": UtilClient.default_number(runtime.max_attempts, 3),
+            },
+            "backoff": {
+                "policy": UtilClient.default_string(runtime.backoff_policy, "no"),
+                "period": UtilClient.default_number(runtime.backoff_period, 1),
+            },
+            "ignoreSSL": runtime.ignore_ssl,
+        }
+        _last_request = None
+        _last_exception = None
+        _now = time.time()
+        _retry_times = 0
+        while TeaCore.allow_retry(_runtime.get("retry"), _retry_times, _now):
+            if _retry_times > 0:
+                _backoff_time = TeaCore.get_backoff_time(_runtime.get("backoff"), _retry_times)
+                if _backoff_time > 0:
+                    TeaCore.sleep(_backoff_time)
+            _retry_times = _retry_times + 1
+            try:
+                _request = TeaRequest()
+                _request.protocol = UtilClient.default_string(self._protocol, protocol)
+                _request.method = UtilClient.default_string(method, "POST")
+                _request.pathname = pathname
+                _request.headers = TeaCore.merge(
+                    {
+                        "host": self._domain,
+                        "date": UtilClient.get_date_utcstring(),
+                        "x-ca-nonce": UtilClient.get_nonce(),
+                        "x-ca-key": self._app_key,
+                        "x-ca-signaturemethod": "HmacSHA256",
+                        "accept": "application/json",
+                        "user-agent": self.get_user_agent(),
+                    },
+                    header,
+                )
+                if UtilClient.empty(body.id):
+                    body.id = UtilClient.get_nonce()
+                if not UtilClient.is_unset(body):
+                    _request.headers["content-type"] = "application/octet-stream"
+                    _request.headers["content-md5"] = APIGatewayUtilClient.get_content_md5(
+                        UtilClient.to_jsonstring(TeaCore.to_map(body))
+                    )
+                    _request.body = UtilClient.to_jsonstring(TeaCore.to_map(body))
+                _request.headers["x-ca-signature"] = APIGatewayUtilClient.get_signature(_request, self._app_secret)
+                _last_request = _request
+                _response = TeaCore.do_action(_request, _runtime)
+                return _response
+            except Exception as e:
+                if TeaCore.is_retryable(e):
+                    _last_exception = e
+                    continue
+                raise e
+        raise UnretryableException(_last_request, _last_exception)
+
+    async def async_do_request(self, pathname, protocol, method, header, body, runtime):
+        """Send request
+
+        @type pathname: str
+        @param pathname: the url path
+
+        @type protocol: str
+        @param protocol: http or https
+
+        @type method: str
+        @param method: example GET
+
+        @type header: Dict[str, str]
+        @param header: request header
+
+        @type body: iot_api_gateway_models.IoTApiRequest
+        @param body: the object of IoTApiRequest
+
+        @type runtime: util_models.RuntimeOptions
+        @param runtime: which controls some details of call api, such as retry times
+
+        @rtype: TeaResponse
+        @return: the response
+        """
+        body.validate()
+        runtime.validate()
+        _runtime = {
+            "timeouted": "retry",
+            "readTimeout": UtilClient.default_number(runtime.read_timeout, self._read_timeout),
+            "connectTimeout": UtilClient.default_number(runtime.connect_timeout, self._connect_timeout),
+            "httpProxy": UtilClient.default_string(runtime.http_proxy, self._http_proxy),
+            "httpsProxy": UtilClient.default_string(runtime.https_proxy, self._https_proxy),
+            "noProxy": UtilClient.default_string(runtime.no_proxy, self._no_proxy),
+            "maxIdleConns": UtilClient.default_number(runtime.max_idle_conns, self._max_idle_conns),
+            "retry": {
+                "retryable": runtime.autoretry,
+                "maxAttempts": UtilClient.default_number(runtime.max_attempts, 3),
+            },
+            "backoff": {
+                "policy": UtilClient.default_string(runtime.backoff_policy, "no"),
+                "period": UtilClient.default_number(runtime.backoff_period, 1),
+            },
+            "ignoreSSL": runtime.ignore_ssl,
+        }
+        _last_request = None
+        _last_exception = None
+        _now = time.time()
+        _retry_times = 0
+        while TeaCore.allow_retry(_runtime.get("retry"), _retry_times, _now):
+            if _retry_times > 0:
+                _backoff_time = TeaCore.get_backoff_time(_runtime.get("backoff"), _retry_times)
+                if _backoff_time > 0:
+                    TeaCore.sleep(_backoff_time)
+            _retry_times = _retry_times + 1
+            try:
+                _request = TeaRequest()
+                _request.protocol = UtilClient.default_string(self._protocol, protocol)
+                _request.method = UtilClient.default_string(method, "POST")
+                _request.pathname = pathname
+                _request.headers = TeaCore.merge(
+                    {
+                        "host": self._domain,
+                        "date": UtilClient.get_date_utcstring(),
+                        "x-ca-nonce": UtilClient.get_nonce(),
+                        "x-ca-key": self._app_key,
+                        "x-ca-signaturemethod": "HmacSHA256",
+                        "accept": "application/json",
+                        "user-agent": self.get_user_agent(),
+                    },
+                    header,
+                )
+                if UtilClient.empty(body.id):
+                    body.id = UtilClient.get_nonce()
+                if not UtilClient.is_unset(body):
+                    _request.headers["content-type"] = "application/octet-stream"
+                    _request.headers["content-md5"] = APIGatewayUtilClient.get_content_md5(
+                        UtilClient.to_jsonstring(TeaCore.to_map(body))
+                    )
+                    _request.body = UtilClient.to_jsonstring(TeaCore.to_map(body))
+                _request.headers["x-ca-signature"] = APIGatewayUtilClient.get_signature(_request, self._app_secret)
+                _last_request = _request
+                _response = await TeaCore.async_do_action(_request, _runtime)
+                return _response
+            except Exception as e:
+                if TeaCore.is_retryable(e):
+                    _last_exception = e
+                    continue
+                raise e
+        raise UnretryableException(_last_request, _last_exception)
+
+    def get_user_agent(self):
+        """Get user agent
+
+        @rtype: str
+        @return: user agent
+        """
+        user_agent = UtilClient.get_user_agent(self._user_agent)
+        return user_agent

{pymammotion-0.4.16 → pymammotion-0.4.18}/pymammotion/aliyun/cloud_gateway.py

@@ -12,12 +12,12 @@ import time
 import uuid
 
 from aiohttp import ClientSession
-from alibabacloud_iot_api_gateway.client import Client
 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
@@ -102,6 +102,7 @@ class CloudIOTGateway:
         dev_by_account: ListingDevByAccountResponse | None = None,
     ) -> None:
         """Initialize the CloudIOTGateway."""
+        self._iot_token_issued_at = None
         self.mammotion_http: MammotionHTTP | None = None
         self._app_key = APP_KEY
         self._app_secret = APP_SECRET
@@ -144,7 +145,7 @@ class CloudIOTGateway:
             hashlib.sha1,
         ).hexdigest()
 
-    def get_region(self, country_code: str, auth_code: str):
+    async def get_region(self, country_code: str, auth_code: str):
         """Get the region based on country code and auth code."""
 
         if self._region_response is not None:
@@ -171,7 +172,9 @@ class CloudIOTGateway:
         )
 
         # send request
-        response = client.do_request("/living/account/region/get", "https", "POST", None, body, RuntimeOptions())
+        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)
@@ -191,7 +194,7 @@ class CloudIOTGateway:
 
         return response.body
 
-    def aep_handle(self):
+    async def aep_handle(self):
         """Handle AEP authentication."""
         aep_domain = self.domain
 
@@ -230,7 +233,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)
@@ -395,7 +398,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):
         """Create a session by auth code."""
         config = Config(
             app_key=self._app_key,
@@ -420,7 +423,7 @@ class CloudIOTGateway:
         )
 
         # send request
-        response = client.do_request(
+        response = await client.async_do_request(
             "/account/createSessionByAuthCode",
             "https",
             "POST",
@@ -452,7 +455,7 @@ class CloudIOTGateway:
 
         return response.body
 
-    def sign_out(self) -> None:
+    async def sign_out(self) -> None:
         config = Config(
             app_key=self._app_key,
             app_secret=self._app_secret,
@@ -476,7 +479,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",
@@ -497,7 +500,7 @@ class CloudIOTGateway:
         logger.debug(response_body_dict)
         return response_body_dict
 
-    def check_or_refresh_session(self):
+    async def check_or_refresh_session(self):
         """Check or refresh the session."""
         logger.debug("Trying to refresh token")
         config = Config(
@@ -523,7 +526,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",
@@ -544,7 +547,7 @@ class CloudIOTGateway:
 
         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__())
 
         session = SessionByAuthCodeResponse.from_dict(response_body_dict)
@@ -562,7 +565,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) -> ListingDevByAccountResponse:
         """List bindings by account."""
         config = Config(
             app_key=self._app_key,
@@ -586,7 +589,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)
@@ -604,7 +609,7 @@ class CloudIOTGateway:
         self._devices_by_account_response = ListingDevByAccountResponse.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,
@@ -627,7 +632,7 @@ 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)
@@ -645,7 +650,7 @@ class CloudIOTGateway:
         self._devices_by_account_response = ListingDevByAccountResponse.from_dict(response_body_dict)
         return self._devices_by_account_response
 
-    def send_cloud_command(self, iot_id: str, command: bytes) -> str:
+    async def send_cloud_command(self, iot_id: str, command: bytes) -> str:
         """Send a cloud command to the specified IoT device."""
 
         if command is None:
@@ -659,7 +664,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")
 
@@ -694,7 +699,8 @@ 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)
@@ -716,7 +722,7 @@ class CloudIOTGateway:
 
             if response_body_dict.get("code") == 29003:
                 logger.debug(self._session_by_authcode_response.data.identityId)
-                self.sign_out()
+                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"), iot_id)

{pymammotion-0.4.16 → pymammotion-0.4.18}/pymammotion/http/http.py

@@ -13,6 +13,8 @@ class MammotionHTTP:
     def __init__(self) -> None:
         self.code = None
         self.msg = None
+        self.account = None
+        self._password = None
         self.response: Response | None = None
         self.login_info: LoginResponseData | None = None
         self._headers = {"User-Agent": "okhttp/3.14.9", "App-Version": "google Pixel 2 XL taimen-Android 11,1.11.332"}
@@ -106,7 +108,12 @@ class MammotionHTTP:
                 # Assuming the data format matches the expected structure
                 return Response[StreamSubscriptionResponse].from_dict(data)
 
-    async def login(self, username: str, password: str) -> Response[LoginResponseData]:
+    async def refresh_login(self) -> Response[LoginResponseData]:
+        return await self.login(self.account, self._password)
+
+    async def login(self, account: str, password: str) -> Response[LoginResponseData]:
+        self.account = account
+        self._password = password
         async with ClientSession(MAMMOTION_DOMAIN) as session:
             async with session.post(
                 "/oauth/token",
@@ -118,7 +125,7 @@ class MammotionHTTP:
                     "Ec-Version": "v1",
                 },
                 params=dict(
-                    username=self.encryption_utils.encryption_by_aes(username),
+                    username=self.encryption_utils.encryption_by_aes(account),
                     password=self.encryption_utils.encryption_by_aes(password),
                     client_id=self.encryption_utils.encryption_by_aes(MAMMOTION_CLIENT_ID),
                     client_secret=self.encryption_utils.encryption_by_aes(MAMMOTION_CLIENT_SECRET),

{pymammotion-0.4.16 → pymammotion-0.4.18}/pymammotion/mammotion/devices/base.py

@@ -56,9 +56,7 @@ class MammotionBaseDevice:
             return
 
         for frame in missing_frames:
-            await self.queue_command(
-                "get_hash_response", sub_cmd=hash_ack.sub_cmd, total_frame=hash_ack.total_frame, current_frame=frame - 1
-            )
+            await self.queue_command("get_hash_response", total_frame=hash_ack.total_frame, current_frame=frame - 1)
 
     async def commdata_response(self, common_data: NavGetCommDataAck | SvgMessageAckT) -> None:
         """Handle common data responses."""
@@ -231,7 +229,7 @@ class MammotionBaseDevice:
         # sub_cmd 4 is dump location (yuka)
         # jobs list
         #
-        # hash_list_result = await self._send_command_with_args("get_all_boundary_hash_list", sub_cmd=3)
+        await self.queue_command("get_all_boundary_hash_list", sub_cmd=3)
 
     async def async_read_settings(self) -> None:
         """Read settings from device."""

{pymammotion-0.4.16 → pymammotion-0.4.18}/pymammotion/mammotion/devices/mammotion.py

@@ -187,6 +187,18 @@ class Mammotion:
                 cloud_client = await self.login(account, password)
                 await self.initiate_cloud_connection(account, cloud_client)
 
+    async def refresh_login(self, account: str) -> None:
+        async with self._login_lock:
+            exists: MammotionCloud | None = self.mqtt_list.get(account)
+            if not exists:
+                return
+            mammotion_http = exists.cloud_client.mammotion_http
+            await mammotion_http.refresh_login()
+            await self.connect_iot(mammotion_http, exists.cloud_client)
+            if not exists.is_connected():
+                loop = asyncio.get_running_loop()
+                await loop.run_in_executor(None, exists.connect_async)
+
     async def initiate_cloud_connection(self, account: str, cloud_client: CloudIOTGateway) -> None:
         loop = asyncio.get_running_loop()
         if mqtt := self.mqtt_list.get(account):
@@ -242,21 +254,19 @@ class Mammotion:
         cloud_client = CloudIOTGateway()
         mammotion_http = MammotionHTTP()
         await mammotion_http.login(account, password)
+        await cloud_client.list_binding_by_account()
+        await self.connect_iot(mammotion_http, cloud_client)
+        return cloud_client
+
+    @staticmethod
+    async def connect_iot(mammotion_http: MammotionHTTP, cloud_client: CloudIOTGateway) -> None:
         country_code = mammotion_http.login_info.userInformation.domainAbbreviation
-        _LOGGER.debug("CountryCode: " + country_code)
-        _LOGGER.debug("AuthCode: " + mammotion_http.login_info.authorization_code)
         cloud_client.set_http(mammotion_http)
-        loop = asyncio.get_running_loop()
-        await loop.run_in_executor(
-            None, cloud_client.get_region, country_code, mammotion_http.login_info.authorization_code
-        )
+        await cloud_client.get_region(country_code, mammotion_http.login_info.authorization_code)
         await cloud_client.connect()
         await cloud_client.login_by_oauth(country_code, mammotion_http.login_info.authorization_code)
-        await loop.run_in_executor(None, cloud_client.aep_handle)
-        await loop.run_in_executor(None, cloud_client.session_by_auth_code)
-
-        await loop.run_in_executor(None, cloud_client.list_binding_by_account)
-        return cloud_client
+        await cloud_client.aep_handle()
+        await cloud_client.session_by_auth_code()
 
     async def remove_device(self, name: str) -> None:
         await self.device_manager.remove_device(name)

{pymammotion-0.4.16 → pymammotion-0.4.18}/pymammotion/mammotion/devices/mammotion_bluetooth.py

@@ -106,7 +106,6 @@ class MammotionBaseBLEDevice(MammotionBaseDevice):
 
     async def _ble_sync(self) -> None:
         if self._client is not None and self._client.is_connected:
-            _LOGGER.debug("BLE SYNC")
             command_bytes = self._commands.send_todev_ble_sync(2)
             await self._message.post_custom_data_bytes(command_bytes)
 

{pymammotion-0.4.16 → pymammotion-0.4.18}/pymammotion/mammotion/devices/mammotion_cloud.py

@@ -65,8 +65,8 @@ class MammotionCloud:
     def connect_async(self) -> None:
         self._mqtt_client.connect_async()
 
-    def send_command(self, iot_id: str, command: bytes) -> None:
-        self._mqtt_client.get_cloud_client().send_cloud_command(iot_id, command)
+    async def send_command(self, iot_id: str, command: bytes) -> None:
+        await self._mqtt_client.get_cloud_client().send_cloud_command(iot_id, command)
 
     async def on_connected(self) -> None:
         """Callback for when MQTT connects."""
@@ -102,7 +102,7 @@ class MammotionCloud:
         self._key = key
         _LOGGER.debug("Sending command: %s", key)
 
-        await self.loop.run_in_executor(None, self._mqtt_client.get_cloud_client().send_cloud_command, iot_id, command)
+        await self._mqtt_client.get_cloud_client().send_cloud_command(iot_id, command)
         future = MammotionFuture(iot_id)
         self._waiting_queue.append(future)
         timeout = 5
@@ -244,7 +244,7 @@ class MammotionBaseCloudDevice(MammotionBaseDevice):
         command_bytes = self._commands.send_todev_ble_sync(3)
         loop = asyncio.get_running_loop()
         try:
-            await loop.run_in_executor(None, self._mqtt.send_command, self.iot_id, command_bytes)
+            await self._mqtt.send_command(self.iot_id, command_bytes)
         except (CheckSessionException, SetupException):
             self._ble_sync_task.cancel()
 

{pymammotion-0.4.16 → pymammotion-0.4.18}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [project]
 name        = "pymammotion"
-version     = "0.4.16"
+version     = "0.4.18"
 license     = "GPL-3.0"
 description = ""
 readme      = "README.md"