dycw-utilities 0.125.13__tar.gz → 0.125.15__tar.gz

{dycw_utilities-0.125.13 → dycw_utilities-0.125.15}/PKG-INFO

@@ -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 → dycw_utilities-0.125.15}/pyproject.toml

@@ -93,7 +93,7 @@ dependencies = [
 name = "dycw-utilities"
 readme = "README.md"
 requires-python = ">= 3.12"
-version = "0.125.13"
+version = "0.125.15"
 
 [project.optional-dependencies]
 test = [
@@ -334,7 +334,7 @@ zzz-test-zoneinfo = [
 # bump-my-version
 [tool.bumpversion]
 allow_dirty = true
-current_version = "0.125.13"
+current_version = "0.125.15"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"

{dycw_utilities-0.125.13 → dycw_utilities-0.125.15}/src/tests/test_asyncio.py

@@ -988,14 +988,20 @@ class TestLooper:
             @override
             async def _initialize_core(self) -> None:
                 if self._initialization_attempts == 1:
-                    _ = await super().initialize()
+                    _ = await super().initialize(sleep_if_failure=False)
                 await super()._initialize_core()
 
         looper = Example()
-        _ = await looper.initialize()
+        _ = await looper.initialize(sleep_if_failure=False)
         _ = one(m for m in caplog.messages if search(": already initializing$", m))
 
-    async def test_initialize_failure(self, *, caplog: LogCaptureFixture) -> None:
+    @given(case=sampled_from([(True, "; sleeping for .*"), (False, "")]))
+    @settings(suppress_health_check={HealthCheck.function_scoped_fixture})
+    async def test_initialize_failure(
+        self, *, case: tuple[bool, str], caplog: LogCaptureFixture
+    ) -> None:
+        sleep_if_failure, extra = case
+
         class Example(_ExampleLooper):
             @override
             async def _initialize_core(self) -> None:
@@ -1004,11 +1010,13 @@ class TestLooper:
                 await super()._initialize_core()
 
         looper = Example()
-        _ = await looper.initialize()
+        _ = await looper.initialize(sleep_if_failure=sleep_if_failure)
         _ = one(
             m
             for m in caplog.messages
-            if search(r": encountered _ExampleLooperError\(\) whilst initializing$", m)
+            if search(
+                rf": encountered _ExampleLooperError\(\) whilst initializing{extra}$", m
+            )
         )
 
     def test_len_and_qsize(self) -> None:
@@ -1128,9 +1136,13 @@ class TestLooper:
             if search(r": already requested stop when empty$", m)
         )
 
+    @given(case=sampled_from([(True, "; sleeping for .*"), (False, "")]))
+    @settings(suppress_health_check={HealthCheck.function_scoped_fixture})
     async def test_restart_failure_during_initialization(
-        self, *, caplog: LogCaptureFixture
+        self, *, case: tuple[bool, str], caplog: LogCaptureFixture
     ) -> None:
+        sleep_if_failure, extra = case
+
         class Example(_ExampleLooper):
             @override
             async def _initialize_core(self) -> None:
@@ -1139,19 +1151,23 @@ class TestLooper:
                 await super()._initialize_core()
 
         looper = Example()
-        await looper.restart()
+        await looper.restart(sleep_if_failure=sleep_if_failure)
         _ = one(
             m
             for m in caplog.messages
             if search(
-                r": encountered _ExampleLooperError\(\) whilst restarting, during initialization$",
+                rf": encountered _ExampleLooperError\(\) whilst restarting \(initialize\){extra}$",
                 m,
             )
         )
 
+    @given(case=sampled_from([(True, "; sleeping for .*"), (False, "")]))
+    @settings(suppress_health_check={HealthCheck.function_scoped_fixture})
     async def test_restart_failure_during_tear_down(
-        self, *, caplog: LogCaptureFixture
+        self, *, case: tuple[bool, str], caplog: LogCaptureFixture
     ) -> None:
+        sleep_if_failure, extra = case
+
         class Example(_ExampleLooper):
             @override
             async def _tear_down_core(self) -> None:
@@ -1160,19 +1176,23 @@ class TestLooper:
                 await super()._tear_down_core()
 
         looper = Example()
-        await looper.restart()
+        await looper.restart(sleep_if_failure=sleep_if_failure)
         _ = one(
             m
             for m in caplog.messages
             if search(
-                r": encountered _ExampleLooperError\(\) whilst restarting, during tear down$",
+                rf": encountered _ExampleLooperError\(\) whilst restarting \(tear down\){extra}$",
                 m,
             )
         )
 
+    @given(case=sampled_from([(True, "; sleeping for .*"), (False, "")]))
+    @settings(suppress_health_check={HealthCheck.function_scoped_fixture})
     async def test_restart_failure_during_tear_down_and_initialization(
-        self, *, caplog: LogCaptureFixture
+        self, *, case: tuple[bool, str], caplog: LogCaptureFixture
     ) -> None:
+        sleep_if_failure, extra = case
+
         class Example(_ExampleLooper):
             @override
             async def _initialize_core(self) -> None:
@@ -1187,12 +1207,12 @@ class TestLooper:
                 await super()._tear_down_core()
 
         looper = Example()
-        await looper.restart()
+        await looper.restart(sleep_if_failure=sleep_if_failure)
         _ = one(
             m
             for m in caplog.messages
             if search(
-                r": encountered _ExampleLooperError\(\) \(tear down\) and then _ExampleLooperError\(\) \(initialization\) whilst restarting$",
+                rf": encountered _ExampleLooperError\(\) \(tear down\) and then _ExampleLooperError\(\) \(initialization\) whilst restarting{extra}$",
                 m,
             )
         )
@@ -1227,21 +1247,27 @@ class TestLooper:
             )
         )
 
-    async def test_tear_down_already_initializing(
+    async def test_tear_down_already_tearing_down(
         self, *, caplog: LogCaptureFixture
     ) -> None:
         class Example(_ExampleLooper):
             @override
             async def _tear_down_core(self) -> None:
                 if self._tear_down_attempts == 1:
-                    _ = await super().tear_down()
+                    _ = await super().tear_down(sleep_if_failure=False)
                 await super()._tear_down_core()
 
         looper = Example()
-        _ = await looper.tear_down()
+        _ = await looper.tear_down(sleep_if_failure=False)
         _ = one(m for m in caplog.messages if search(": already tearing down$", m))
 
-    async def test_tear_down_failure(self, *, caplog: LogCaptureFixture) -> None:
+    @given(case=sampled_from([(True, "; sleeping for .*"), (False, "")]))
+    @settings(suppress_health_check={HealthCheck.function_scoped_fixture})
+    async def test_tear_down_failure(
+        self, *, case: tuple[bool, str], caplog: LogCaptureFixture
+    ) -> None:
+        sleep_if_failure, extra = case
+
         class Example(_ExampleLooper):
             @override
             async def _tear_down_core(self) -> None:
@@ -1250,11 +1276,13 @@ class TestLooper:
                 await super()._tear_down_core()
 
         looper = Example()
-        _ = await looper.tear_down()
+        _ = await looper.tear_down(sleep_if_failure=sleep_if_failure)
         _ = one(
             m
             for m in caplog.messages
-            if search(r": encountered _ExampleLooperError\(\) whilst tearing down$", m)
+            if search(
+                rf": encountered _ExampleLooperError\(\) whilst tearing down{extra}$", m
+            )
         )
 
     def _assert_stats(

{dycw_utilities-0.125.13 → dycw_utilities-0.125.15}/src/utilities/__init__.py

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

{dycw_utilities-0.125.13 → dycw_utilities-0.125.15}/src/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