pymammotion 0.4.17__py3-none-any.whl → 0.4.19__py3-none-any.whl

pymammotion/aliyun/tea/core.py

@@ -0,0 +1,295 @@
+import asyncio
+import logging
+import os
+import ssl
+import time
+from typing import Any
+from urllib.parse import urlencode, urlparse
+
+import aiohttp
+import certifi
+from requests import PreparedRequest, adapters, status_codes
+from Tea.exceptions import RequiredArgumentException, RetryError
+from Tea.model import TeaModel
+from Tea.request import TeaRequest
+from Tea.response import TeaResponse
+from Tea.stream import BaseStream
+
+DEFAULT_CONNECT_TIMEOUT = 5000
+DEFAULT_READ_TIMEOUT = 10000
+DEFAULT_POOL_SIZE = 10
+
+logger = logging.getLogger("alibabacloud-tea")
+logger.setLevel(logging.DEBUG)
+ch = logging.StreamHandler()
+logger.addHandler(ch)
+
+
+class TeaCore:
+    http_adapter = adapters.HTTPAdapter(pool_connections=DEFAULT_POOL_SIZE, pool_maxsize=DEFAULT_POOL_SIZE * 4)
+    https_adapter = adapters.HTTPAdapter(pool_connections=DEFAULT_POOL_SIZE, pool_maxsize=DEFAULT_POOL_SIZE * 4)
+
+    @staticmethod
+    def get_adapter(prefix):
+        if prefix.upper() == "HTTP":
+            return TeaCore.http_adapter
+        else:
+            return TeaCore.https_adapter
+
+    @staticmethod
+    def _prepare_http_debug(request, symbol):
+        base = ""
+        for key, value in request.headers.items():
+            base += f"\n{symbol} {key} : {value}"
+        return base
+
+    @staticmethod
+    def _do_http_debug(request, response) -> None:
+        # logger the request
+        url = urlparse(request.url)
+        request_base = f"\n> {request.method.upper()} {url.path + url.query} HTTP/1.1"
+        logger.debug(request_base + TeaCore._prepare_http_debug(request, ">"))
+
+        # logger the response
+        response_base = (
+            f"\n< HTTP/1.1 {response.status_code}" f" {status_codes._codes.get(response.status_code)[0].upper()}"
+        )
+        logger.debug(response_base + TeaCore._prepare_http_debug(response, "<"))
+
+    @staticmethod
+    def compose_url(request):
+        host = request.headers.get("host")
+        if not host:
+            raise RequiredArgumentException("endpoint")
+        else:
+            host = host.rstrip("/")
+        protocol = f"{request.protocol.lower()}://"
+        pathname = request.pathname
+
+        if host.startswith(("http://", "https://")):
+            protocol = ""
+
+        if request.port == 80:
+            port = ""
+        else:
+            port = f":{request.port}"
+
+        url = protocol + host + port + pathname
+
+        if request.query:
+            if "?" in url:
+                if not url.endswith("&"):
+                    url += "&"
+            else:
+                url += "?"
+
+            encode_query = {}
+            for key in request.query:
+                value = request.query[key]
+                if value is not None:
+                    encode_query[key] = str(value)
+            url += urlencode(encode_query)
+        return url.rstrip("?&")
+
+    @staticmethod
+    async def async_do_action(request: TeaRequest, runtime_option=None) -> TeaResponse:
+        runtime_option = runtime_option or {}
+
+        url = TeaCore.compose_url(request)
+        verify = not runtime_option.get("ignoreSSL", False)
+
+        timeout = runtime_option.get("timeout")
+        connect_timeout = runtime_option.get("connectTimeout") or timeout or DEFAULT_CONNECT_TIMEOUT
+        read_timeout = runtime_option.get("readTimeout") or timeout or DEFAULT_READ_TIMEOUT
+
+        connect_timeout, read_timeout = (int(connect_timeout) / 1000, int(read_timeout) / 1000)
+
+        proxy = None
+        if request.protocol.upper() == "HTTP":
+            proxy = runtime_option.get("httpProxy")
+            if not proxy:
+                proxy = os.environ.get("HTTP_PROXY") or os.environ.get("http_proxy")
+        elif request.protocol.upper() == "HTTPS":
+            proxy = runtime_option.get("httpsProxy")
+            if not proxy:
+                proxy = os.environ.get("HTTPS_PROXY") or os.environ.get("https_proxy")
+
+        connector = None
+        ca_cert = certifi.where()
+        if ca_cert and request.protocol.upper() == "HTTPS":
+            loop = asyncio.get_event_loop()
+
+            ssl_context = await loop.run_in_executor(None, ssl.create_default_context, ssl.Purpose.SERVER_AUTH)
+            await loop.run_in_executor(None, ssl_context.load_verify_locations, ca_cert)
+            connector = aiohttp.TCPConnector(
+                ssl=ssl_context,
+            )
+        else:
+            verify = False
+
+        timeout = aiohttp.ClientTimeout(sock_read=read_timeout, sock_connect=connect_timeout)
+        async with aiohttp.ClientSession(connector=connector) as s:
+            body = b""
+            if isinstance(request.body, BaseStream):
+                for content in request.body:
+                    body += content
+            elif isinstance(request.body, str):
+                body = request.body.encode("utf-8")
+            else:
+                body = request.body
+            try:
+                async with s.request(
+                    request.method, url, data=body, headers=request.headers, ssl=verify, proxy=proxy, timeout=timeout
+                ) as response:
+                    tea_resp = TeaResponse()
+                    tea_resp.body = await response.read()
+                    tea_resp.headers = {k.lower(): v for k, v in response.headers.items()}
+                    tea_resp.status_code = response.status
+                    tea_resp.status_message = response.reason
+                    tea_resp.response = response
+            except OSError as e:
+                raise RetryError(str(e))
+        return tea_resp
+
+    @staticmethod
+    def do_action(request: TeaRequest, runtime_option=None) -> TeaResponse:
+        url = TeaCore.compose_url(request)
+
+        runtime_option = runtime_option or {}
+
+        verify = not runtime_option.get("ignoreSSL", False)
+        if verify:
+            verify = runtime_option.get("ca", True) if runtime_option.get("ca", True) is not None else True
+        cert = runtime_option.get("cert", None)
+
+        timeout = runtime_option.get("timeout")
+        connect_timeout = runtime_option.get("connectTimeout") or timeout or DEFAULT_CONNECT_TIMEOUT
+        read_timeout = runtime_option.get("readTimeout") or timeout or DEFAULT_READ_TIMEOUT
+
+        timeout = (int(connect_timeout) / 1000, int(read_timeout) / 1000)
+
+        if isinstance(request.body, str):
+            request.body = request.body.encode("utf-8")
+
+        p = PreparedRequest()
+        p.prepare(
+            method=request.method.upper(),
+            url=url,
+            data=request.body,
+            headers=request.headers,
+        )
+
+        proxies = {}
+        http_proxy = runtime_option.get("httpProxy")
+        https_proxy = runtime_option.get("httpsProxy")
+        no_proxy = runtime_option.get("noProxy")
+
+        if not http_proxy:
+            http_proxy = os.environ.get("HTTP_PROXY") or os.environ.get("http_proxy")
+        if not https_proxy:
+            https_proxy = os.environ.get("HTTPS_PROXY") or os.environ.get("https_proxy")
+
+        if http_proxy:
+            proxies["http"] = http_proxy
+        if https_proxy:
+            proxies["https"] = https_proxy
+        if no_proxy:
+            proxies["no_proxy"] = no_proxy
+
+        adapter = TeaCore.get_adapter(request.protocol)
+        try:
+            resp = adapter.send(
+                p,
+                proxies=proxies,
+                timeout=timeout,
+                verify=verify,
+                cert=cert,
+            )
+        except OSError as e:
+            raise RetryError(str(e))
+
+        debug = runtime_option.get("debug") or os.getenv("DEBUG")
+        if debug and debug.lower() == "sdk":
+            TeaCore._do_http_debug(p, resp)
+
+        response = TeaResponse()
+        response.status_message = resp.reason
+        response.status_code = resp.status_code
+        response.headers = {k.lower(): v for k, v in resp.headers.items()}
+        response.body = resp.content
+        response.response = resp
+        return response
+
+    @staticmethod
+    def get_response_body(resp) -> str:
+        return resp.content.decode("utf-8")
+
+    @staticmethod
+    def allow_retry(dic, retry_times, now=None) -> bool:
+        if retry_times == 0:
+            return True
+        if dic is None or not dic.__contains__("maxAttempts") or dic.get("retryable") is not True and retry_times >= 1:
+            return False
+        else:
+            retry = 0 if dic.get("maxAttempts") is None else int(dic.get("maxAttempts"))
+        return retry >= retry_times
+
+    @staticmethod
+    def get_backoff_time(dic, retry_times) -> int:
+        default_back_off_time = 0
+        if dic is None or not dic.get("policy") or dic.get("policy") == "no":
+            return default_back_off_time
+
+        back_off_time = dic.get("period", default_back_off_time)
+        if not isinstance(back_off_time, int) and not (isinstance(back_off_time, str) and back_off_time.isdigit()):
+            return default_back_off_time
+
+        back_off_time = int(back_off_time)
+        if back_off_time < 0:
+            return retry_times
+
+        return back_off_time
+
+    @staticmethod
+    async def sleep_async(t) -> None:
+        await asyncio.sleep(t)
+
+    @staticmethod
+    def sleep(t) -> None:
+        time.sleep(t)
+
+    @staticmethod
+    def is_retryable(ex) -> bool:
+        return isinstance(ex, RetryError)
+
+    @staticmethod
+    def bytes_readable(body):
+        return body
+
+    @staticmethod
+    def merge(*dic_list) -> dict:
+        dic_result = {}
+        for item in dic_list:
+            if isinstance(item, dict):
+                dic_result.update(item)
+            elif isinstance(item, TeaModel):
+                dic_result.update(item.to_map())
+        return dic_result
+
+    @staticmethod
+    def to_map(model: TeaModel | None) -> dict[str, Any]:
+        if isinstance(model, TeaModel):
+            return model.to_map()
+        else:
+            return dict()
+
+    @staticmethod
+    def from_map(model: TeaModel, dic: dict[str, Any]) -> TeaModel:
+        if isinstance(model, TeaModel):
+            try:
+                return model.from_map(dic)
+            except Exception:
+                model._map = dic
+                return model
+        else:
+            return model

pymammotion/data/model/hash_list.py

@@ -12,6 +12,7 @@ class PathType(IntEnum):
     AREA = 0
     OBSTACLE = 1
     PATH = 2
+    LINE = 10
     DUMP = 12
     SVG = 13
 
@@ -83,6 +84,32 @@ class FrameList(DataClassORJSONMixin):
     data: list[NavGetCommData | SvgMessage] = field(default_factory=list)
 
 
+@dataclass
+class Plan(DataClassORJSONMixin):
+    sub_cmd: int = 2
+    version: str = ""
+    user_id: str = ""
+    device_id: str = ""
+    plan_id: str = ""
+    task_id: str = ""
+    start_time: str = "00:00"
+    knife_height: int = 0
+    model: int = 0
+    edge_mode: int = 0
+    route_model: int = 0
+    route_spacing: int = 0
+    ultrasonic_barrier: int = 0
+    total_plan_num: int = 0
+    speed: float = 0.0
+    task_name: str = ""
+    zone_hashs: list[str] = field(default_factory=list)
+    reserved: str = ""
+    start_date: str = ""
+    trigger_type: int = 0
+    remained_seconds: str = "-1"
+    toward_included_angle: int = 0
+
+
 @dataclass(eq=False, repr=False)
 class NavGetHashListData(DataClassORJSONMixin):
     """Dataclass for NavGetHashListData."""
@@ -124,8 +151,10 @@ class HashList(DataClassORJSONMixin):
     area: dict[int, FrameList] = field(default_factory=dict)  # type 0
     path: dict[int, FrameList] = field(default_factory=dict)  # type 2
     obstacle: dict[int, FrameList] = field(default_factory=dict)  # type 1
-    dump: dict[int, FrameList] = field(default_factory=dict)  # type 12?
+    dump: dict[int, FrameList] = field(default_factory=dict)  # type 12? / sub cmd 4
     svg: dict[int, FrameList] = field(default_factory=dict)  # type 13
+    line: dict[int, FrameList] = field(default_factory=dict)  # type 10 possibly breakpoint? / sub cmd 3
+    plan: dict[int, Plan] = field(default_factory=dict)
     area_name: list[AreaHashNameList] = field(default_factory=list)
 
     def update_hash_lists(self, hashlist: list[int]) -> None:
@@ -152,6 +181,8 @@ class HashList(DataClassORJSONMixin):
         all_hash_ids = set(self.area.keys()).union(
             self.path.keys(), self.obstacle.keys(), self.dump.keys(), self.svg.keys()
         )
+        if sub_cmd == 3:
+            all_hash_ids = set(self.line.keys())
         return [
             i
             for root_list in self.root_hash_lists
@@ -174,7 +205,7 @@ class HashList(DataClassORJSONMixin):
         if target_root_list is None:
             return []
 
-        return self._find_missing_frames(target_root_list)
+        return self.find_missing_frames(target_root_list)
 
     def update_root_hash_list(self, hash_list: NavGetHashListData) -> None:
         target_root_list = next(
@@ -206,26 +237,29 @@ class HashList(DataClassORJSONMixin):
         missing_frames = []
         filtered_lists = [rl for rl in self.root_hash_lists if rl.sub_cmd == hash_ack.sub_cmd]
         for root_list in filtered_lists:
-            missing = self._find_missing_frames(root_list)
+            missing = self.find_missing_frames(root_list)
             if missing:
                 missing_frames.extend(missing)
         return missing_frames
 
     def missing_frame(self, hash_data: NavGetCommDataAck | SvgMessageAckT) -> list[int]:
         if hash_data.type == PathType.AREA:
-            return self._find_missing_frames(self.area.get(hash_data.hash))
+            return self.find_missing_frames(self.area.get(hash_data.hash))
 
         if hash_data.type == PathType.OBSTACLE:
-            return self._find_missing_frames(self.obstacle.get(hash_data.hash))
+            return self.find_missing_frames(self.obstacle.get(hash_data.hash))
 
         if hash_data.type == PathType.PATH:
-            return self._find_missing_frames(self.path.get(hash_data.hash))
+            return self.find_missing_frames(self.path.get(hash_data.hash))
+
+        if hash_data.type == PathType.LINE:
+            return self.find_missing_frames(self.line.get(hash_data.hash))
 
         if hash_data.type == PathType.DUMP:
-            return self._find_missing_frames(self.dump.get(hash_data.hash))
+            return self.find_missing_frames(self.dump.get(hash_data.hash))
 
         if hash_data.type == PathType.SVG:
-            return self._find_missing_frames(self.svg.get(hash_data.data_hash))
+            return self.find_missing_frames(self.svg.get(hash_data.data_hash))
 
         return []
 
@@ -247,6 +281,9 @@ class HashList(DataClassORJSONMixin):
         if hash_data.type == PathType.PATH:
             return self._add_hash_data(self.path, hash_data)
 
+        if hash_data.type == PathType.LINE:
+            return self._add_hash_data(self.line, hash_data)
+
         if hash_data.type == PathType.DUMP:
             return self._add_hash_data(self.dump, hash_data)
 
@@ -256,7 +293,7 @@ class HashList(DataClassORJSONMixin):
         return False
 
     @staticmethod
-    def _find_missing_frames(frame_list: FrameList | RootHashList) -> list[int]:
+    def find_missing_frames(frame_list: FrameList | RootHashList) -> list[int]:
         if frame_list is None:
             return []
 

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/mammotion/commands/messages/navigation.py

@@ -297,7 +297,7 @@ class MessageNavigation(AbstractMessage, ABC):
 
     def synchronize_hash_data(self, hash_num: int) -> bytes:
         build = MctlNav(todev_get_commondata=NavGetCommData(pver=1, action=8, hash=hash_num, sub_cmd=1))
-        logger.debug(f"Send command--209,hash synchronize area data hash:{hash}")
+        logger.debug(f"Send command--209,hash synchronize area data hash:{hash_num}")
         return self.send_order_msg_nav(build)
 
     def get_area_to_be_transferred(self) -> bytes:

pymammotion/mammotion/devices/base.py

@@ -44,19 +44,19 @@ class MammotionBaseDevice:
         self._cloud_device = cloud_device
 
     async def datahash_response(self, hash_ack: NavGetHashListAck) -> None:
-        """Handle datahash responses."""
+        """Handle datahash responses for root level hashs."""
+        current_frame = hash_ack.current_frame
 
         missing_frames = self.mower.map.missing_root_hash_frame(hash_ack)
         if len(missing_frames) == 0:
-            for sub_cmd in [0, 3]:
-                if len(self.mower.map.missing_hashlist(sub_cmd)) > 0:
-                    # data_hash = self.mower.map.missing_hashlist(hash_ack.sub_cmd).pop()
-                    for data_hash in self.mower.map.missing_hashlist(hash_ack.sub_cmd):
-                        await self.queue_command("synchronize_hash_data", hash_num=data_hash)
+            if len(self.mower.map.missing_hashlist(0)) > 0:
+                data_hash = self.mower.map.missing_hashlist(hash_ack.sub_cmd).pop()
+                await self.queue_command("synchronize_hash_data", hash_num=data_hash)
             return
 
-        for frame in missing_frames:
-            await self.queue_command("get_hash_response", total_frame=hash_ack.total_frame, current_frame=frame - 1)
+        if current_frame != missing_frames[0] - 1:
+            current_frame = missing_frames[0] - 1
+        await self.queue_command("get_hash_response", total_frame=hash_ack.total_frame, current_frame=current_frame)
 
     async def commdata_response(self, common_data: NavGetCommDataAck | SvgMessageAckT) -> None:
         """Handle common data responses."""
@@ -211,25 +211,49 @@ class MammotionBaseDevice:
 
         self.mower.map.update_hash_lists(self.mower.map.hashlist)
 
+        await self.queue_command("send_todev_ble_sync", sync_type=3)
+
         if self._cloud_device and len(self.mower.map.area_name) == 0 and not DeviceType.is_luba1(self.mower.name):
             await self.queue_command("get_area_name_list", device_id=self._cloud_device.iotId)
 
         await self.queue_command("read_plan", sub_cmd=2, plan_index=0)
 
-        await self.queue_command("get_all_boundary_hash_list", sub_cmd=0)
+        if len(self.mower.map.root_hash_lists) == 0:
+            await self.queue_command("get_all_boundary_hash_list", sub_cmd=0)
+
+        for hash, frame in self.mower.map.area.items():
+            missing_frames = self.mower.map.find_missing_frames(frame)
+            if len(missing_frames) > 0:
+                del self.mower.map.area[hash]
+
+        for hash, frame in self.mower.map.path.items():
+            missing_frames = self.mower.map.find_missing_frames(frame)
+            if len(missing_frames) > 0:
+                del self.mower.map.path[hash]
+
+        for hash, frame in self.mower.map.obstacle.items():
+            missing_frames = self.mower.map.find_missing_frames(frame)
+            if len(missing_frames) > 0:
+                del self.mower.map.obstacle[hash]
+
+        # for hash, frame in self.mower.map.svg.items():
+        #     missing_frames = self.mower.map.find_missing_frames(frame)
+        #     if len(missing_frames) > 0:
+        #         del self.mower.map.svg[hash]
+
         if len(self.mower.map.missing_hashlist()) > 0:
             data_hash = self.mower.map.missing_hashlist().pop()
             await self.queue_command("synchronize_hash_data", hash_num=data_hash)
 
-        if len(self.mower.map.missing_hashlist(3)) > 0:
-            data_hash = self.mower.map.missing_hashlist().pop()
-            await self.queue_command("synchronize_hash_data", hash_num=data_hash)
+        # if len(self.mower.map.missing_hashlist(3)) > 0:
+        #     data_hash = self.mower.map.missing_hashlist(3).pop()
+        #     await self.queue_command("synchronize_hash_data", hash_num=data_hash)
 
         # sub_cmd 3 is job hashes??
         # 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/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 self.connect_iot(mammotion_http, cloud_client)
+        await cloud_client.list_binding_by_account()
+        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/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)
 
@@ -369,7 +368,7 @@ class MammotionBaseBLEDevice(MammotionBaseDevice):
         _LOGGER.debug("%s: Sending command: %s", self.name, key)
         await self._message.post_custom_data_bytes(command)
 
-        timeout = 2
+        timeout = 1
         timeout_handle = self.loop.call_at(self.loop.time() + timeout, _handle_timeout, self._notify_future)
         timeout_expired = False
         try: