Improve event loop fetching

This wasn't a global problem and only triggered edge cases for people
developing with too much (unnecessary?) complexity, but now we don't
cache the event loop and instead request the live event loop each time.

This is technically about 10x slower than using a cached event loop
reader, but the difference is just +20ns slower if we ask python to
lookup the active event loop each time vs using it cached on first
access forever.

Fixes #160
Fixes #186
Fixes #159

Author: mattsta

ib_async/connection.py

@@ -4,8 +4,6 @@
 
 from eventkit import Event
 
-from ib_async.util import getLoop
-
 
 class Connection(asyncio.Protocol):
     """
@@ -35,7 +33,8 @@ async def connectAsync(self, host, port):
             self.disconnect()
             await self.disconnected
         self.reset()
-        loop = getLoop()
+        # Use get_running_loop() directly for optimal performance in async context
+        loop = asyncio.get_running_loop()
         self.transport, _ = await loop.create_connection(lambda: self, host, port)
 
     def disconnect(self):

ib_async/util.py

@@ -361,7 +361,8 @@ def run(*awaitables: Awaitable, timeout: Optional[float] = None):
 
         if timeout:
             future = asyncio.wait_for(future, timeout)
-        task = asyncio.ensure_future(future)
+        # Pass loop explicitly to avoid deprecation warnings in Python 3.10+
+        task = asyncio.ensure_future(future, loop=loop)
 
         def onError(_):
             task.cancel()
@@ -492,13 +493,42 @@ def patchAsyncio():
     nest_asyncio.apply()
 
 
-@functools.cache
 def getLoop():
-    """Get asyncio event loop or create one if it doesn't exist."""
+    """
+    Get asyncio event loop with smart fallback handling.
+
+    This function is designed for use in synchronous contexts or when the
+    execution context is unknown. It will:
+    1. Try to get the currently running event loop (if in async context)
+    2. Fall back to getting the current thread's event loop via policy
+    3. Create a new event loop if none exists or if the existing one is closed
+
+    For performance-critical async code paths, prefer using
+    asyncio.get_running_loop() directly instead of this function.
+
+    Note: This function does NOT cache the loop to avoid stale loop bugs
+    when loops are closed and recreated (e.g., in testing, Jupyter notebooks).
+    """
     try:
-        # https://docs.python.org/3/library/asyncio-eventloop.html#asyncio.get_running_loop
+        # Fast path: we're in an async context (coroutine or callback)
         loop = asyncio.get_running_loop()
+        return loop
     except RuntimeError:
+        pass
+
+    # We're in a sync context or no loop is running
+    # Use the event loop policy to get the loop for this thread
+    # This avoids deprecation warnings from get_event_loop() in Python 3.10+
+    try:
+        loop = asyncio.get_event_loop_policy().get_event_loop()
+    except RuntimeError:
+        # No event loop exists for this thread, create one
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        return loop
+
+    # Check if the loop we got is closed - if so, create a new one
+    if loop.is_closed():
         loop = asyncio.new_event_loop()
         asyncio.set_event_loop(loop)