gh-158903: Avoid AttributeError in BaseEventLoop.__del__ and close() during premature teardown

Author: JohnnyWilson16

Lib/asyncio/proactor_events.py

@@ -722,8 +722,10 @@ def close(self):
         # call_soon(), which is forbidden when the event loop is closed.
         self._stop_accept_futures()
         self._close_self_pipe()
-        self._proactor.close()
-        self._proactor = None
+        proactor = getattr(self, '_proactor', None)
+        if proactor is not None:
+            proactor.close()
+            self._proactor = None
         self._selector = None
 
         # Close the event loop
@@ -799,14 +801,20 @@ async def _sendfile_native(self, transp, file, offset, count):
                 transp.resume_reading()
 
     def _close_self_pipe(self):
-        if self._self_reading_future is not None:
-            self._self_reading_future.cancel()
+        self_reading_future = getattr(self, '_self_reading_future', None)
+        if self_reading_future is not None:
+            self_reading_future.cancel()
             self._self_reading_future = None
-        self._ssock.close()
-        self._ssock = None
-        self._csock.close()
-        self._csock = None
-        self._internal_fds -= 1
+        ssock = getattr(self, '_ssock', None)
+        if ssock is not None:
+            ssock.close()
+            self._ssock = None
+        csock = getattr(self, '_csock', None)
+        if csock is not None:
+            csock.close()
+            self._csock = None
+        if getattr(self, '_internal_fds', 0) > 0:
+            self._internal_fds -= 1
 
     def _make_self_pipe(self):
         # A self-socket, really. :-)
@@ -911,9 +919,12 @@ def _process_events(self, event_list):
         pass
 
     def _stop_accept_futures(self):
-        for future in self._accept_futures.values():
+        accept_futures = getattr(self, '_accept_futures', None)
+        if accept_futures is None:
+            return
+        for future in accept_futures.values():
             future.cancel()
-        self._accept_futures.clear()
+        accept_futures.clear()
 
     def _stop_serving(self, sock):
         future = self._accept_futures.pop(sock.fileno(), None)

Lib/asyncio/selector_events.py

@@ -104,17 +104,24 @@ def close(self):
             return
         self._close_self_pipe()
         super().close()
-        if self._selector is not None:
-            self._selector.close()
+        selector = getattr(self, '_selector', None)
+        if selector is not None:
+            selector.close()
             self._selector = None
 
     def _close_self_pipe(self):
-        self._remove_reader(self._ssock.fileno())
-        self._ssock.close()
-        self._ssock = None
-        self._csock.close()
-        self._csock = None
-        self._internal_fds -= 1
+        ssock = getattr(self, '_ssock', None)
+        if ssock is not None:
+            if getattr(self, '_selector', None) is not None:
+                self._remove_reader(ssock.fileno())
+            ssock.close()
+            self._ssock = None
+        csock = getattr(self, '_csock', None)
+        if csock is not None:
+            csock.close()
+            self._csock = None
+        if getattr(self, '_internal_fds', 0) > 0:
+            self._internal_fds -= 1
 
     def _make_self_pipe(self):
         # A self-socket, really. :-)

Lib/asyncio/unix_events.py

@@ -70,17 +70,19 @@ def __init__(self, selector=None):
 
     def close(self):
         super().close()
-        if not sys.is_finalizing():
-            for sig in list(self._signal_handlers):
-                self.remove_signal_handler(sig)
-        else:
-            if self._signal_handlers:
-                warnings.warn(f"Closing the loop {self!r} "
-                              f"on interpreter shutdown "
-                              f"stage, skipping signal handlers removal",
-                              ResourceWarning,
-                              source=self)
-                self._signal_handlers.clear()
+        signal_handlers = getattr(self, '_signal_handlers', None)
+        if signal_handlers is not None:
+            if not sys.is_finalizing():
+                for sig in list(signal_handlers):
+                    self.remove_signal_handler(sig)
+            else:
+                if signal_handlers:
+                    warnings.warn(f"Closing the loop {self!r} "
+                                  f"on interpreter shutdown "
+                                  f"stage, skipping signal handlers removal",
+                                  ResourceWarning,
+                                  source=self)
+                    signal_handlers.clear()
 
     def _process_self_data(self, data):
         for signum in data:

Lib/test/test_asyncio/test_base_events.py

@@ -217,11 +217,29 @@ def test_close(self):
         self.loop.close()
         self.loop.close()
 
-        # operation blocked when the loop is closed
         f = self.loop.create_future()
         self.assertRaises(RuntimeError, self.loop.run_forever)
         self.assertRaises(RuntimeError, self.loop.run_until_complete, f)
 
+    def test_close_partially_initialized_loop(self):
+        # gh-158903: An event loop interrupted before socket setup finishes
+        # must close cleanly and be garbage collected without AttributeError.
+        class IncompleteSelectorLoop(asyncio.SelectorEventLoop):
+            def __init__(self):
+                super(asyncio.base_events.BaseEventLoop, self).__init__()
+
+        loop = IncompleteSelectorLoop.__new__(IncompleteSelectorLoop)
+        asyncio.base_events.BaseEventLoop.__init__(loop)
+
+        # Must not raise AttributeError
+        loop.close()
+
+        # Must not trigger unraisable exception during deallocation
+        with support.catch_unraisable_exception() as cm:
+            del loop
+            support.gc_collect()
+            self.assertIsNone(cm.unraisable)
+
     def test__add_callback_handle(self):
         h = asyncio.Handle(lambda: False, (), self.loop, None)
 

Misc/NEWS.d/next/Library/2026-10-07-12-00-00.gh-issue-158903.a1b2c3.rst

@@ -0,0 +1 @@
+Fix :exc:`AttributeError` in :meth:`asyncio.BaseEventLoop.__del__` and :meth:`close` when tearing down an event loop that was interrupted during initialization.