ez-a-sync 0.24.34__tar.gz → 0.24.35__tar.gz

{ez_a_sync-0.24.34 → ez_a_sync-0.24.35}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ez-a-sync
-Version: 0.24.34
+Version: 0.24.35
 Summary: A library that makes it easy to define objects that can be used for both sync and async use cases.
 Home-page: https://github.com/BobTheBuidler/a-sync
 Author: BobTheBuidler

{ez_a_sync-0.24.34 → ez_a_sync-0.24.35}/a_sync/executor.py

@@ -20,6 +20,8 @@ import multiprocessing.context
 import queue
 import threading
 import weakref
+from asyncio import sleep
+from asyncio.futures import wrap_future, _convert_future_exc
 from concurrent.futures import _base, thread
 from functools import cached_property
 
@@ -32,6 +34,21 @@ TEN_MINUTES = 60 * 10
 Initializer = Callable[..., object]
 
 
+def _copy_future_state(cf_fut: concurrent.futures.Future, fut: asyncio.Future):
+    """Internal helper to copy state from another Future.
+
+    The other Future may be a concurrent.futures.Future.
+    """
+    # check this again in case it was cancelled since the last check
+    if fut.cancelled():
+        return
+    exception = cf_fut.exception()
+    if exception is None:
+        fut.set_result(cf_fut.result())
+    else:
+        fut.set_exception(_convert_future_exc(exception))
+
+
 class _AsyncExecutorMixin(concurrent.futures.Executor, _DebugDaemonMixin):
     """
     A mixin for Executors to provide asynchronous run and submit methods.
@@ -49,6 +66,15 @@ class _AsyncExecutorMixin(concurrent.futures.Executor, _DebugDaemonMixin):
         - :meth:`submit` for submitting functions to the executor.
     """
 
+    sync_mode: bool
+    """
+    Indicates if the executor is in synchronous mode (max_workers == 0).
+
+    Examples:
+        >>> if executor.sync_mode:
+        >>>     print("Executor is in synchronous mode.")
+    """
+
     _max_workers: int
 
     _workers: str
@@ -96,15 +122,35 @@ class _AsyncExecutorMixin(concurrent.futures.Executor, _DebugDaemonMixin):
         See Also:
             - :meth:`run` for running functions with the executor.
         """
+        fut = self._create_future()
         if self.sync_mode:
-            fut = self._get_loop().create_future()
             try:
                 fut.set_result(fn(*args, **kwargs))
             except Exception as e:
                 fut.set_exception(e)
         else:
-            fut = asyncio.futures.wrap_future(super().submit(fn, *args, **kwargs))  # type: ignore [assignment]
-            self._start_debug_daemon(fut, fn, *args, **kwargs)
+            self._ensure_debug_daemon(fut, fn, *args, **kwargs)
+
+            cf_fut = self._super_submit(fn, *args, **kwargs)
+
+            # TODO: implement logic to actually cancel the job, not just the future which is useless for our use case
+            # def _call_check_cancel(destination: asyncio.Future):
+            #     if destination.cancelled():
+            #         cf_fut.cancel()
+            #
+            # fut.add_done_callback(_call_check_cancel)
+
+            def _call_copy_future_state(cf_fut: "concurrent.futures.Future"):
+                if fut.cancelled():
+                    return
+                self._call_soon_threadsafe(
+                    _copy_future_state,
+                    cf_fut,
+                    fut,
+                )
+
+            cf_fut.add_done_callback(_call_copy_future_state)
+
         return fut
 
     def __repr__(self) -> str:
@@ -114,17 +160,6 @@ class _AsyncExecutorMixin(concurrent.futures.Executor, _DebugDaemonMixin):
         # NOTE: should this be queue length instead? probably
         return self.worker_count_current
 
-    @cached_property
-    def sync_mode(self) -> bool:
-        """
-        Indicates if the executor is in synchronous mode (max_workers == 0).
-
-        Examples:
-            >>> if executor.sync_mode:
-            >>>     print("Executor is in synchronous mode.")
-        """
-        return self._max_workers == 0
-
     @property
     def worker_count_current(self) -> int:
         """
@@ -135,6 +170,13 @@ class _AsyncExecutorMixin(concurrent.futures.Executor, _DebugDaemonMixin):
         """
         return len(getattr(self, f"_{self._workers}"))
 
+    def __init_mixin__(self):
+        self.sync_mode = self._max_workers == 0
+        loop = self._get_loop()
+        self._create_future = loop.create_future
+        self._super_submit = super().submit
+        self._call_soon_threadsafe = loop.call_soon_threadsafe
+
     async def _debug_daemon(self, fut: asyncio.Future, fn, *args, **kwargs) -> None:
         """
         Runs until manually cancelled by the finished work item.
@@ -162,10 +204,13 @@ class _AsyncExecutorMixin(concurrent.futures.Executor, _DebugDaemonMixin):
         else:
             msg = f"{msg[:-2]})"
 
-        while not fut.done():
-            await asyncio.sleep(15)
-            if not fut.done():
-                self.logger.debug(msg, self, fnid)
+        done = fut.done
+        log_debug = self.logger.debug
+
+        while not done():
+            await sleep(15)
+            if not done():
+                log_debug(msg, self, fnid)
 
 
 # Process
@@ -224,6 +269,7 @@ class AsyncProcessPoolExecutor(_AsyncExecutorMixin, concurrent.futures.ProcessPo
             self._max_workers = 0
         else:
             super().__init__(max_workers, mp_context, initializer, initargs)
+        self.__init_mixin__()
 
 
 # Thread
@@ -277,6 +323,7 @@ class AsyncThreadPoolExecutor(_AsyncExecutorMixin, concurrent.futures.ThreadPool
             self._max_workers = 0
         else:
             super().__init__(max_workers, thread_name_prefix, initializer, initargs)
+        self.__init_mixin__()
 
 
 # For backward-compatibility