Revert "The asyncadapter util now has get_running_loop (#151)" (#155)

Author: almarklein

rendercanvas/_loop.py

@@ -52,13 +52,12 @@ class BaseLoop:
     """
 
     def __init__(self):
-        self.__tasks = set()  # only used by the async adapter
+        self.__tasks = set()
         self.__canvas_groups = set()
         self.__should_stop = 0
         self.__state = (
             0  # 0: off, 1: ready, 2: detected-active, 3: inter-active, 4: running
         )
-        self._using_adapter = False
 
     def __repr__(self):
         full_class_name = f"{self.__class__.__module__}.{self.__class__.__name__}"
@@ -78,20 +77,12 @@ def _register_canvas_group(self, canvas_group):
             self.__state = 1
             self._rc_init()
             self.add_task(self._loop_task, name="loop-task")
-            self._using_adapter = len(self.__tasks) > 0
         self.__canvas_groups.add(canvas_group)
 
     def _unregister_canvas_group(self, canvas_group):
         # A CanvasGroup will call this when it selects a different loop.
         self.__canvas_groups.discard(canvas_group)
 
-    def _get_sniffio_activator(self):
-        # A CanvasGroup will call this to activate the loop
-        if self._using_adapter:
-            return asyncadapter.SniffioActivator(self)
-        else:
-            return None
-
     def get_canvases(self) -> list[BaseRenderCanvas]:
         """Get a list of currently active (not-closed) canvases."""
         canvases = []
@@ -400,7 +391,7 @@ def _rc_add_task(self, async_func, name):
         * The subclass is responsible for cancelling remaining tasks in _rc_stop.
         * Return None.
         """
-        task = asyncadapter.Task(self._rc_call_later, async_func(), name, self)
+        task = asyncadapter.Task(self._rc_call_later, async_func(), name)
         self.__tasks.add(task)
         task.add_done_callback(self.__tasks.discard)
 

rendercanvas/base.py

@@ -478,12 +478,6 @@ def _draw_frame_and_present(self):
             return
         self.__is_drawing = True
 
-        try:
-            # sniffio_activator = self._rc_canvas_group?._loop?._get_sniffio_activator()
-            sniffio_activator = self._rc_canvas_group._loop._get_sniffio_activator()
-        except AttributeError:  # _rc_canvas_group or _loop can be None
-            sniffio_activator = None
-
         try:
             # This method is called from the GUI layer. It can be called from a
             # "draw event" that we requested, or as part of a forced draw.
@@ -537,8 +531,6 @@ def _draw_frame_and_present(self):
 
         finally:
             self.__is_drawing = False
-            if sniffio_activator:
-                sniffio_activator.restore()
 
     # %% Primary canvas management methods
 

rendercanvas/utils/asyncadapter.py

@@ -4,9 +4,8 @@
 """
 
 import logging
-import threading
 
-from sniffio import thread_local as _sniffio_thread_local
+from sniffio import thread_local as sniffio_thread_local
 
 
 logger = logging.getLogger("asyncadapter")
@@ -59,56 +58,14 @@ class CancelledError(BaseException):
     pass
 
 
-class _ThreadLocalWithLoop(threading.local):
-    loop = None  # set default value as a class attr, like sniffio does
-
-
-_ourloop_thread_local = _ThreadLocalWithLoop()
-
-
-def get_running_loop() -> object:
-    """Return the running event loop. Raise a RuntimeError if there is none.
-
-    This function is thread-specific.
-    """
-    # This is inspired by asyncio, and together with sniffio, allows the same
-    # code to handle asyncio and our adapter for some cases.
-    loop = _ourloop_thread_local.loop
-    if loop is None:
-        raise RuntimeError(f"no running {__name__} loop")
-    return loop
-
-
-class SniffioActivator:
-    def __init__(self, loop):
-        self.active = True
-        self.old_loop = _ourloop_thread_local.loop
-        self.old_name = _sniffio_thread_local.name
-        _sniffio_thread_local.name = __name__
-        _ourloop_thread_local.loop = loop
-
-    def restore(self):
-        if self.active:
-            self.active = False
-            _sniffio_thread_local.name = self.old_name
-            _ourloop_thread_local.loop = self.old_loop
-
-    def __del__(self):
-        if self.active:
-            logger.warning(
-                "asyncadapter's SniffioActivator.restore() was never called."
-            )
-
-
 class Task:
-    """Representation of a task, executing a co-routine."""
+    """Representation of task, exectuting a co-routine."""
 
-    def __init__(self, call_later_func, coro, name, loop):
+    def __init__(self, call_later_func, coro, name):
         self._call_later = call_later_func
         self._done_callbacks = []
         self.coro = coro
         self.name = name
-        self.loop = loop
         self.cancelled = False
         self.call_step_later(0)
 
@@ -138,8 +95,7 @@ def step(self):
         result = None
         stop = False
 
-        sniffio_activator = SniffioActivator(self.loop)
-
+        old_name, sniffio_thread_local.name = sniffio_thread_local.name, __name__
         try:
             if self.cancelled:
                 stop = True
@@ -156,7 +112,7 @@ def step(self):
             logger.error(f"Error in task: {err}")
             stop = True
         finally:
-            sniffio_activator.restore()
+            sniffio_thread_local.name = old_name
 
         # Clean up to help gc
         if stop: