dycw-utilities 0.125.12__tar.gz → 0.125.14__tar.gz

{dycw_utilities-0.125.12 → dycw_utilities-0.125.14}/PKG-INFO

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

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

{dycw_utilities-0.125.12 → dycw_utilities-0.125.14}/src/tests/test_asyncio.py

@@ -975,6 +975,12 @@ class TestLooper:
         looper.put_left_nowait(None)
         assert not looper.empty()
 
+    def test_get_all_nowait(self) -> None:
+        looper = _ExampleLooper()
+        looper.put_left_nowait(None)
+        items = looper.get_all_nowait()
+        assert items == [None]
+
     async def test_initialize_already_initializing(
         self, *, caplog: LogCaptureFixture
     ) -> None:
@@ -982,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:
@@ -998,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:
@@ -1122,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:
@@ -1133,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:
@@ -1154,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:
@@ -1181,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,
             )
         )
@@ -1221,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:
@@ -1244,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.12 → dycw_utilities-0.125.14}/src/utilities/__init__.py

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

{dycw_utilities-0.125.12 → dycw_utilities-0.125.14}/src/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()