dycw-utilities 0.125.13__py3-none-any.whl → 0.125.15__py3-none-any.whl

{dycw_utilities-0.125.13.dist-info → dycw_utilities-0.125.15.dist-info}/METADATA

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

{dycw_utilities-0.125.13.dist-info → dycw_utilities-0.125.15.dist-info}/RECORD

@@ -1,6 +1,6 @@
-utilities/__init__.py,sha256=7ZYwhNHFuejRkKzg0MeSvh2I14YxTE-mRj6ie69FmMU,61
+utilities/__init__.py,sha256=o8LjBx2A4acDe22uoFRzAfxBWmfrM93t-mLhWMyL0m0,61
 utilities/altair.py,sha256=Gpja-flOo-Db0PIPJLJsgzAlXWoKUjPU1qY-DQ829ek,9156
-utilities/asyncio.py,sha256=uUVIpmBMP-tAYPnE2Yi7ZyTno7VYImjNp7uA85MQhys,47865
+utilities/asyncio.py,sha256=f0AkOrSdlqiWroCGE3JuyDXO0xXwoPUeonIVCkX4o2Q,50560
 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.13.dist-info/METADATA,sha256=hQ21eoRHxkp3q3Y7wQ3F9fXew2_S1sTHV3hd68qX8e4,12852
-dycw_utilities-0.125.13.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-dycw_utilities-0.125.13.dist-info/licenses/LICENSE,sha256=gppZp16M6nSVpBbUBrNL6JuYfvKwZiKgV7XoKKsHzqo,1066
-dycw_utilities-0.125.13.dist-info/RECORD,,
+dycw_utilities-0.125.15.dist-info/METADATA,sha256=-hn0kXri9lE8xlAMFZ_Qbfkk57RIrd9BulAR_m5K1os,12852
+dycw_utilities-0.125.15.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+dycw_utilities-0.125.15.dist-info/licenses/LICENSE,sha256=gppZp16M6nSVpBbUBrNL6JuYfvKwZiKgV7XoKKsHzqo,1066
+dycw_utilities-0.125.15.dist-info/RECORD,,

utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.125.13"
+__version__ = "0.125.15"

utilities/asyncio.py

@@ -795,13 +795,9 @@ class Looper(Generic[_T]):
                 assert_never(never)
 
     def __await__(self) -> Any:
-        match self._task:
-            case None:
-                raise _LooperNoTaskError(looper=self)
-            case Task() as task:
-                return task.__await__()
-            case _ as never:
-                assert_never(never)
+        if (task := self._task) is None:  # cannot use match
+            raise _LooperNoTaskError(looper=self)
+        return task.__await__()
 
     def __len__(self) -> int:
         return self._queue.qsize()
@@ -825,7 +821,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:
@@ -840,14 +836,26 @@ class Looper(Generic[_T]):
                 try:
                     await self._initialize_core()
                 except Exception as error:  # noqa: BLE001
-                    _ = self._logger.warning(
-                        "%s: encountered %s whilst initializing",
-                        self,
-                        repr_error(error),
-                    )
                     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
@@ -939,44 +947,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()
         async with self._lock:
             self._restart_attempts += 1
-        tear_down = await self.tear_down()
-        initialization = await self.initialize()
-        match tear_down, initialization:
-            case None, None:
+        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)
                 async with self._lock:
                     self._restart_successes += 1
-            case Exception(), None:
+            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),
                 )
+            case None, Exception(), True:
                 async with self._lock:
                     self._restart_failures += 1
-            case None, Exception():
                 _ = 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,
                 )
+                await sleep(self._backoff)
+            case None, Exception(), False:
                 async with self._lock:
                     self._restart_failures += 1
-            case Exception(), Exception():
                 _ = self._logger.warning(
-                    "%s: encountered %s (tear down) and then %s (initialization) whilst restarting",
+                    "%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),
+                )
             case _ as never:
                 assert_never(never)
 
@@ -992,9 +1031,9 @@ 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)
                     async with self._lock:
@@ -1051,7 +1090,7 @@ class Looper(Generic[_T]):
             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:
@@ -1065,14 +1104,26 @@ class Looper(Generic[_T]):
                 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),
-                    )
                     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