python-roborock 2.9.6__tar.gz → 2.9.8__tar.gz

{python_roborock-2.9.6 → python_roborock-2.9.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: python-roborock
-Version: 2.9.6
+Version: 2.9.8
 Summary: A package to control Roborock vacuums.
 License: GPL-3.0-only
 Keywords: roborock,vacuum,homeassistant

{python_roborock-2.9.6 → python_roborock-2.9.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "python-roborock"
-version = "2.9.6"
+version = "2.9.8"
 description = "A package to control Roborock vacuums."
 authors = ["humbertogontijo <humbertogontijo@users.noreply.github.com>"]
 license = "GPL-3.0-only"

{python_roborock-2.9.6 → python_roborock-2.9.8}/roborock/api.py

@@ -20,8 +20,9 @@ from .exceptions import (
 from .roborock_future import RoborockFuture
 from .roborock_message import (
     RoborockMessage,
+    RoborockMessageProtocol,
 )
-from .util import get_next_int, get_running_loop_or_create_one
+from .util import get_next_int
 
 _LOGGER = logging.getLogger(__name__)
 KEEPALIVE = 60
@@ -35,7 +36,6 @@ class RoborockClient(ABC):
 
     def __init__(self, device_info: DeviceData) -> None:
         """Initialize RoborockClient."""
-        self.event_loop = get_running_loop_or_create_one()
         self.device_info = device_info
         self._nonce = secrets.token_bytes(16)
         self._waiting_queue: dict[int, RoborockFuture] = {}
@@ -102,7 +102,9 @@ class RoborockClient(ABC):
 
     def _async_response(self, request_id: int, protocol_id: int = 0) -> Any:
         queue = RoborockFuture(protocol_id)
-        if request_id in self._waiting_queue:
+        if request_id in self._waiting_queue and not (
+            request_id == 2 and protocol_id == RoborockMessageProtocol.PING_REQUEST
+        ):
             new_id = get_next_int(10000, 32767)
             self._logger.warning(
                 "Attempting to create a future with an existing id %s (%s)... New id is %s. "

{python_roborock-2.9.6 → python_roborock-2.9.8}/roborock/cloud_api.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import asyncio
 import logging
 import threading
 from abc import ABC
@@ -158,7 +159,8 @@ class RoborockMqttClient(RoborockClient, ABC):
             if disconnected_future := self._sync_disconnect():
                 # There are no errors set on this future
                 await disconnected_future
-            await self.event_loop.run_in_executor(None, self._mqtt_client.loop_stop)
+            loop = asyncio.get_running_loop()
+            await loop.run_in_executor(None, self._mqtt_client.loop_stop)
 
     async def async_connect(self) -> None:
         async with self._mutex:

{python_roborock-2.9.6 → python_roborock-2.9.8}/roborock/local_api.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import asyncio
 import logging
 from abc import ABC
-from asyncio import Lock, TimerHandle, Transport
+from asyncio import Lock, TimerHandle, Transport, get_running_loop
 from collections.abc import Callable
 from dataclasses import dataclass
 
@@ -72,7 +72,8 @@ class RoborockLocalClient(RoborockClient, ABC):
             await self.ping()
         except RoborockException:
             pass
-        self.keep_alive_task = self.event_loop.call_later(10, lambda: asyncio.create_task(self.keep_alive_func()))
+        loop = asyncio.get_running_loop()
+        self.keep_alive_task = loop.call_later(10, lambda: asyncio.create_task(self.keep_alive_func()))
 
     async def async_connect(self) -> None:
         should_ping = False
@@ -82,7 +83,8 @@ class RoborockLocalClient(RoborockClient, ABC):
                     self._sync_disconnect()
                     async with async_timeout.timeout(self.queue_timeout):
                         self._logger.debug(f"Connecting to {self.host}")
-                        self.transport, _ = await self.event_loop.create_connection(  # type: ignore
+                        loop = get_running_loop()
+                        self.transport, _ = await loop.create_connection(  # type: ignore
                             lambda: self._local_protocol, self.host, 58867
                         )
                         self._logger.info(f"Connected to {self.host}")
@@ -94,7 +96,8 @@ class RoborockLocalClient(RoborockClient, ABC):
             await self.keep_alive_func()
 
     def _sync_disconnect(self) -> None:
-        if self.transport and self.event_loop.is_running():
+        loop = asyncio.get_running_loop()
+        if self.transport and loop.is_running():
             self._logger.debug(f"Disconnecting from {self.host}")
             self.transport.close()
         if self.keep_alive_task:

{python_roborock-2.9.6 → python_roborock-2.9.8}/roborock/util.py

@@ -74,8 +74,7 @@ def run_sync():
 
 
 class RepeatableTask:
-    def __init__(self, loop: AbstractEventLoop, callback: Callable[[], Coroutine], interval: int):
-        self.loop = loop
+    def __init__(self, callback: Callable[[], Coroutine], interval: int):
         self.callback = callback
         self.interval = interval
         self._task: TimerHandle | None = None
@@ -86,7 +85,8 @@ class RepeatableTask:
             response = await self.callback()
         except RoborockException:
             pass
-        self._task = self.loop.call_later(self.interval, self._run_task_soon)
+        loop = asyncio.get_running_loop()
+        self._task = loop.call_later(self.interval, self._run_task_soon)
         return response
 
     def _run_task_soon(self):

{python_roborock-2.9.6 → python_roborock-2.9.8}/roborock/version_1_apis/roborock_client_v1.py

@@ -82,11 +82,11 @@ _SendCommandT = Callable[[RoborockCommand | str, list | dict | int | None], Any]
 
 
 class AttributeCache:
-    def __init__(self, attribute: RoborockAttribute, loop: asyncio.AbstractEventLoop, send_command: _SendCommandT):
+    def __init__(self, attribute: RoborockAttribute, send_command: _SendCommandT):
         self.attribute = attribute
         self._send_command = send_command
         self.attribute = attribute
-        self.task = RepeatableTask(loop, self._async_value, EVICT_TIME)
+        self.task = RepeatableTask(self._async_value, EVICT_TIME)
         self._value: Any = None
         self._mutex = asyncio.Lock()
         self.unsupported: bool = False
@@ -156,7 +156,7 @@ class RoborockClientV1(RoborockClient, ABC):
         super().__init__(device_info)
         self._status_type: type[Status] = ModelStatus.get(device_info.model, S7MaxVStatus)
         self.cache: dict[CacheableAttribute, AttributeCache] = {
-            cacheable_attribute: AttributeCache(attr, self.event_loop, self._send_command)
+            cacheable_attribute: AttributeCache(attr, self._send_command)
             for cacheable_attribute, attr in get_cache_map().items()
         }
         if device_info.device.duid not in self._listeners: