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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dycw-utilities
-Version: 0.125.12
+Version: 0.125.13
 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.13.dist-info}/RECORD

@@ -1,6 +1,6 @@
-utilities/__init__.py,sha256=eu0r7qVMzjFJgG7Su5IuWbXETZTCy5nXfNr7kwpH_yw,61
+utilities/__init__.py,sha256=7ZYwhNHFuejRkKzg0MeSvh2I14YxTE-mRj6ie69FmMU,61
 utilities/altair.py,sha256=Gpja-flOo-Db0PIPJLJsgzAlXWoKUjPU1qY-DQ829ek,9156
-utilities/asyncio.py,sha256=G7CaIcR-oANVjKWIH7KFMHpPZqL1CkwCV6FBT8vrkKA,46941
+utilities/asyncio.py,sha256=uUVIpmBMP-tAYPnE2Yi7ZyTno7VYImjNp7uA85MQhys,47865
 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.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,,

utilities/__init__.py

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

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()
@@ -830,7 +835,8 @@ 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
@@ -839,14 +845,16 @@ class Looper(Generic[_T]):
                         self,
                         repr_error(error),
                     )
-                    self._initialization_failures += 1
+                    async with self._lock:
+                        self._initialization_failures += 1
                     ret = error
                 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()
@@ -935,27 +943,31 @@ class Looper(Generic[_T]):
         """Restart the looper."""
         _ = self._debug and self._logger.debug("%s: restarting...", self)
         self._is_pending_restart.clear()
-        self._restart_attempts += 1
+        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:
                 _ = self._debug and self._logger.debug("%s: finished restarting", self)
-                self._restart_successes += 1
+                async with self._lock:
+                    self._restart_successes += 1
             case Exception(), None:
                 _ = self._logger.warning(
                     "%s: encountered %s whilst restarting, during tear down",
                     self,
                     repr_error(tear_down),
                 )
-                self._restart_failures += 1
+                async with self._lock:
+                    self._restart_failures += 1
             case None, Exception():
                 _ = self._logger.warning(
                     "%s: encountered %s whilst restarting, during initialization",
                     self,
                     repr_error(initialization),
                 )
-                self._restart_failures += 1
+                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",
@@ -963,7 +975,8 @@ class Looper(Generic[_T]):
                     repr_error(tear_down),
                     repr_error(initialization),
                 )
-                self._restart_failures += 1
+                async with self._lock:
+                    self._restart_failures += 1
             case _ as never:
                 assert_never(never)
 
@@ -984,7 +997,8 @@ class Looper(Generic[_T]):
                     _ = await self.initialize()
                 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 +1007,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,7 +1045,8 @@ 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)
@@ -1043,7 +1060,8 @@ 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
@@ -1052,13 +1070,15 @@ class Looper(Generic[_T]):
                         self,
                         repr_error(error),
                     )
-                    self._tear_down_failures += 1
+                    async with self._lock:
+                        self._tear_down_failures += 1
                     ret = error
                 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()