dycw-utilities 0.125.12__py3-none-any.whl → 0.125.14__py3-none-any.whl

{dycw_utilities-0.125.12.dist-info → dycw_utilities-0.125.14.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dycw-utilities
-Version: 0.125.12
+Version: 0.125.14
 Author-email: Derek Wan <d.wan@icloud.com>
 License-File: LICENSE
 Requires-Python: >=3.12

{dycw_utilities-0.125.12.dist-info → dycw_utilities-0.125.14.dist-info}/RECORD

@@ -1,6 +1,6 @@
-utilities/__init__.py,sha256=eu0r7qVMzjFJgG7Su5IuWbXETZTCy5nXfNr7kwpH_yw,61
+utilities/__init__.py,sha256=FUi2dI2qq8_0UHJ0RQEHLRzzmOO3YY-SHiWkJPnb-P4,61
 utilities/altair.py,sha256=Gpja-flOo-Db0PIPJLJsgzAlXWoKUjPU1qY-DQ829ek,9156
-utilities/asyncio.py,sha256=G7CaIcR-oANVjKWIH7KFMHpPZqL1CkwCV6FBT8vrkKA,46941
+utilities/asyncio.py,sha256=UUcMb_QT4g4-EW0qIoiSENu8x6Fcjn5_X-vvbMrLBfE,50658
 utilities/atomicwrites.py,sha256=geFjn9Pwn-tTrtoGjDDxWli9NqbYfy3gGL6ZBctiqSo,5393
 utilities/atools.py,sha256=IYMuFSFGSKyuQmqD6v5IUtDlz8PPw0Sr87Cub_gRU3M,1168
 utilities/cachetools.py,sha256=C1zqOg7BYz0IfQFK8e3qaDDgEZxDpo47F15RTfJM37Q,2910
@@ -88,7 +88,7 @@ utilities/warnings.py,sha256=un1LvHv70PU-LLv8RxPVmugTzDJkkGXRMZTE2-fTQHw,1771
 utilities/whenever.py,sha256=jS31ZAY5OMxFxLja_Yo5Fidi87Pd-GoVZ7Vi_teqVDA,16743
 utilities/zipfile.py,sha256=24lQc9ATcJxHXBPc_tBDiJk48pWyRrlxO2fIsFxU0A8,699
 utilities/zoneinfo.py,sha256=-5j7IQ9nb7gR43rdgA7ms05im-XuqhAk9EJnQBXxCoQ,1874
-dycw_utilities-0.125.12.dist-info/METADATA,sha256=9JECEW7LQjwHf5sjb53N4xApsa3V9RImfG__u2LDN4E,12852
-dycw_utilities-0.125.12.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-dycw_utilities-0.125.12.dist-info/licenses/LICENSE,sha256=gppZp16M6nSVpBbUBrNL6JuYfvKwZiKgV7XoKKsHzqo,1066
-dycw_utilities-0.125.12.dist-info/RECORD,,
+dycw_utilities-0.125.14.dist-info/METADATA,sha256=ptsWeHCzCc0Tmvlmzovy3NZ4PLYMSEeT8VdauAv3b0k,12852
+dycw_utilities-0.125.14.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+dycw_utilities-0.125.14.dist-info/licenses/LICENSE,sha256=gppZp16M6nSVpBbUBrNL6JuYfvKwZiKgV7XoKKsHzqo,1066
+dycw_utilities-0.125.14.dist-info/RECORD,,

utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.125.12"
+__version__ = "0.125.14"

utilities/asyncio.py

@@ -5,6 +5,7 @@ from abc import ABC, abstractmethod
 from asyncio import (
     CancelledError,
     Event,
+    Lock,
     PriorityQueue,
     Queue,
     QueueEmpty,
@@ -719,6 +720,7 @@ class Looper(Generic[_T]):
     _is_stopped: Event = field(default_factory=Event, init=False, repr=False)
     _is_tearing_down: Event = field(default_factory=Event, init=False, repr=False)
     # internal objects
+    _lock: Lock = field(default_factory=Lock, init=False, repr=False, hash=False)
     _logger: Logger = field(init=False, repr=False, hash=False)
     _queue: EnhancedQueue[_T] = field(
         default_factory=EnhancedQueue, init=False, repr=False, hash=False
@@ -742,8 +744,9 @@ class Looper(Generic[_T]):
             case False:
                 _ = self._debug and self._logger.debug("%s: entering context...", self)
                 self._is_entered.set()
-                self._entries += 1
-                self._task = create_task(self.run_looper())
+                async with self._lock:
+                    self._entries += 1
+                    self._task = create_task(self.run_looper())
                 for looper in self._yield_sub_loopers():
                     _ = self._debug and self._logger.debug(
                         "%s: adding sub-looper %s", self, looper
@@ -752,7 +755,8 @@ class Looper(Generic[_T]):
                         self._logger.warning(
                             "%s: changing sub-looper %s to auto-start...", self, looper
                         )
-                        looper.auto_start = True
+                        async with self._lock:
+                            looper.auto_start = True
                     _ = await self._stack.enter_async_context(looper)
                 if self.auto_start:
                     _ = self._debug and self._logger.debug("%s: auto-starting...", self)
@@ -797,9 +801,6 @@ class Looper(Generic[_T]):
             case Task() as task:
                 return task.__await__()
             case _ as never:
-                self._logger.warning(  # pragma: no cover
-                    "Got %s of type %s", self._task, type(self._task)
-                )
                 assert_never(never)
 
     def __len__(self) -> int:
@@ -812,6 +813,10 @@ class Looper(Generic[_T]):
         """Check if the queue is empty."""
         return self._queue.empty()
 
+    def get_all_nowait(self, *, reverse: bool = False) -> Sequence[_T]:
+        """Remove and return all items from the queue without blocking."""
+        return self._queue.get_all_nowait(reverse=reverse)
+
     def get_left_nowait(self) -> _T:
         """Remove and return an item from the start of the queue without blocking."""
         return self._queue.get_left_nowait()
@@ -820,7 +825,7 @@ class Looper(Generic[_T]):
         """Remove and return an item from the end of the queue without blocking."""
         return self._queue.get_right_nowait()
 
-    async def initialize(self) -> Exception | None:
+    async def initialize(self, *, sleep_if_failure: bool) -> Exception | None:
         """Initialize the looper."""
         match self._is_initializing.is_set():
             case True:
@@ -830,23 +835,38 @@ class Looper(Generic[_T]):
                 _ = self._debug and self._logger.debug("%s: initializing...", self)
                 self._is_initializing.set()
                 self._is_initialized.clear()
-                self._initialization_attempts += 1
+                async with self._lock:
+                    self._initialization_attempts += 1
                 try:
                     await self._initialize_core()
                 except Exception as error:  # noqa: BLE001
-                    _ = self._logger.warning(
-                        "%s: encountered %s whilst initializing",
-                        self,
-                        repr_error(error),
-                    )
-                    self._initialization_failures += 1
+                    async with self._lock:
+                        self._initialization_failures += 1
                     ret = error
+                    match sleep_if_failure:
+                        case True:
+                            _ = self._logger.warning(
+                                "%s: encountered %s whilst initializing; sleeping for %s...",
+                                self,
+                                repr_error(error),
+                                self.backoff,
+                            )
+                            await sleep(self._backoff)
+                        case False:
+                            _ = self._logger.warning(
+                                "%s: encountered %s whilst initializing",
+                                self,
+                                repr_error(error),
+                            )
+                        case _ as never:
+                            assert_never(never)
                 else:
                     _ = self._debug and self._logger.debug(
                         "%s: finished initializing", self
                     )
                     self._is_initialized.set()
-                    self._initialization_successes += 1
+                    async with self._lock:
+                        self._initialization_successes += 1
                     ret = None
                 finally:
                     self._is_initializing.clear()
@@ -931,39 +951,75 @@ class Looper(Generic[_T]):
             case _ as never:
                 assert_never(never)
 
-    async def restart(self) -> None:
+    async def restart(self, *, sleep_if_failure: bool) -> None:
         """Restart the looper."""
         _ = self._debug and self._logger.debug("%s: restarting...", self)
         self._is_pending_restart.clear()
-        self._restart_attempts += 1
-        tear_down = await self.tear_down()
-        initialization = await self.initialize()
-        match tear_down, initialization:
-            case None, None:
+        async with self._lock:
+            self._restart_attempts += 1
+        tear_down = await self.tear_down(sleep_if_failure=False)
+        initialization = await self.initialize(sleep_if_failure=False)
+        match tear_down, initialization, sleep_if_failure:
+            case None, None, bool():
                 _ = self._debug and self._logger.debug("%s: finished restarting", self)
-                self._restart_successes += 1
-            case Exception(), None:
+                async with self._lock:
+                    self._restart_successes += 1
+            case Exception(), None, True:
+                async with self._lock:
+                    self._restart_failures += 1
+                _ = self._logger.warning(
+                    "%s: encountered %s whilst restarting (tear down); sleeping for %s...",
+                    self,
+                    repr_error(tear_down),
+                    self.backoff,
+                )
+                await sleep(self._backoff)
+            case Exception(), None, False:
+                async with self._lock:
+                    self._restart_failures += 1
                 _ = self._logger.warning(
-                    "%s: encountered %s whilst restarting, during tear down",
+                    "%s: encountered %s whilst restarting (tear down)",
                     self,
                     repr_error(tear_down),
                 )
-                self._restart_failures += 1
-            case None, Exception():
+            case None, Exception(), True:
+                async with self._lock:
+                    self._restart_failures += 1
                 _ = self._logger.warning(
-                    "%s: encountered %s whilst restarting, during initialization",
+                    "%s: encountered %s whilst restarting (initialize); sleeping for %s...",
                     self,
                     repr_error(initialization),
+                    self.backoff,
                 )
-                self._restart_failures += 1
-            case Exception(), Exception():
+                await sleep(self._backoff)
+            case None, Exception(), False:
+                async with self._lock:
+                    self._restart_failures += 1
+                _ = self._logger.warning(
+                    "%s: encountered %s whilst restarting (initialize)",
+                    self,
+                    repr_error(initialization),
+                )
+            case Exception(), Exception(), True:
+                async with self._lock:
+                    self._restart_failures += 1
+                _ = self._logger.warning(
+                    "%s: encountered %s (tear down) and then %s (initialization) whilst restarting; sleeping for %s...",
+                    self,
+                    repr_error(tear_down),
+                    repr_error(initialization),
+                    self.backoff,
+                )
+                await sleep(self._backoff)
+            case Exception(), Exception(), False:
+                async with self._lock:
+                    self._restart_failures += 1
                 _ = self._logger.warning(
                     "%s: encountered %s (tear down) and then %s (initialization) whilst restarting",
                     self,
                     repr_error(tear_down),
                     repr_error(initialization),
                 )
-                self._restart_failures += 1
             case _ as never:
                 assert_never(never)
 
@@ -979,12 +1035,13 @@ class Looper(Generic[_T]):
                 ):
                     await self.stop()
                 elif self._is_pending_restart.is_set():
-                    await self.restart()
+                    await self.restart(sleep_if_failure=True)
                 elif not self._is_initialized.is_set():
-                    _ = await self.initialize()
+                    _ = await self.initialize(sleep_if_failure=True)
                 else:
                     _ = self._debug and self._logger.debug("%s: running core...", self)
-                    self._core_attempts += 1
+                    async with self._lock:
+                        self._core_attempts += 1
                     try:
                         await self.core()
                     except Exception as error:  # noqa: BLE001
@@ -993,11 +1050,13 @@ class Looper(Generic[_T]):
                             self,
                             repr_error(error),
                         )
-                        self._core_failures += 1
+                        async with self._lock:
+                            self._core_failures += 1
                         self.request_restart()
                         await sleep(self._backoff)
                     else:
-                        self._core_successes += 1
+                        async with self._lock:
+                            self._core_successes += 1
                         await sleep(self._freq)
 
     @property
@@ -1029,12 +1088,13 @@ class Looper(Generic[_T]):
                 _ = self._debug and self._logger.debug("%s: stopping...", self)
                 self._is_pending_stop.clear()
                 self._is_stopped.set()
-                self._stops += 1
+                async with self._lock:
+                    self._stops += 1
                 _ = self._debug and self._logger.debug("%s: stopped", self)
             case _ as never:
                 assert_never(never)
 
-    async def tear_down(self) -> Exception | None:
+    async def tear_down(self, *, sleep_if_failure: bool) -> Exception | None:
         """Tear down the looper."""
         match self._is_tearing_down.is_set():
             case True:
@@ -1043,22 +1103,37 @@ class Looper(Generic[_T]):
             case False:
                 _ = self._debug and self._logger.debug("%s: tearing down...", self)
                 self._is_tearing_down.set()
-                self._tear_down_attempts += 1
+                async with self._lock:
+                    self._tear_down_attempts += 1
                 try:
                     await self._tear_down_core()
                 except Exception as error:  # noqa: BLE001
-                    _ = self._logger.warning(
-                        "%s: encountered %s whilst tearing down",
-                        self,
-                        repr_error(error),
-                    )
-                    self._tear_down_failures += 1
+                    async with self._lock:
+                        self._tear_down_failures += 1
                     ret = error
+                    match sleep_if_failure:
+                        case True:
+                            _ = self._logger.warning(
+                                "%s: encountered %s whilst tearing down; sleeping for %s...",
+                                self,
+                                repr_error(error),
+                                self.backoff,
+                            )
+                            await sleep(self._backoff)
+                        case False:
+                            _ = self._logger.warning(
+                                "%s: encountered %s whilst tearing down",
+                                self,
+                                repr_error(error),
+                            )
+                        case _ as never:
+                            assert_never(never)
                 else:
                     _ = self._debug and self._logger.debug(
                         "%s: finished tearing down", self
                     )
-                    self._tear_down_successes += 1
+                    async with self._lock:
+                        self._tear_down_successes += 1
                     ret = None
                 finally:
                     self._is_tearing_down.clear()