Support `__aenter__`/`__aexit__` for experimental-async coroutines

[0x676e67]

Summary

We are using PyO3's experimental async support for coroutines, but currently, these coroutine objects do not support the async context manager protocol.

Because of this, we have to await the response first before we can use it in an async with block. The current code looks like this:

import asyncio
import rnet
from rnet import Response

async def main():
    # Currently, we must await the coroutine first separately
    resp: Response = await rnet.get("https://httpbin.io/stream/20")
    async with resp:
        async with resp.stream() as streamer:
            async for chunk in streamer:
                print(chunk)
                await asyncio.sleep(0.1)

if __name__ == "__main__":
    asyncio.run(main())

Expected Behavior

The expected usage should be much cleaner, allowing us to use async with directly on the awaited coroutine:

import asyncio
import rnet

async def main():
    # The goal is to support this one-liner pattern
    async with rnet.get("https://httpbin.io/stream/20") as resp:
        async with resp.stream() as streamer:
            async for chunk in streamer:
                print(chunk)
                await asyncio.sleep(0.1)

if __name__ == "__main__":
    asyncio.run(main())

[0x676e67]

I think what is needed is something like this. This is a context manager. Is this related to the coroutine implementation within Pyo3?

#[pymethods(crate = "crate")]
impl Coroutine {
    fn __aenter__(slf: Py<Self>, py: Python<'_>) -> PyResult<Py<Self>> {
        Ok(slf)
    }

    fn __aexit__<'p>(
        &mut self, 
        py: Python<'p>, 
        exc_type: Bound<'p, PyAny>, 
        exc_value: Bound<'p, PyAny>, 
        traceback: Bound<'p, PyAny>
    ) -> PyResult<Bound<'p, PyAny>> {
        if let Some(result) = &self.result {
             return result.bind(py).call_method1("__aexit__", (exc_type, exc_value, traceback));
        }
        
        Ok(py.None().into_bound(py))
    }
}

import asyncio

class AsyncResponse:
    """
    A class that functions as both an Awaitable and an Async Context Manager.
    This mimics the behavior seen in libraries like httpx or aiohttp.
    """
    def __init__(self, url: str):
        self.url = url
        self.status = "Pending"
        self._closed = False

    # --- Async Context Manager Protocol ---
    async def __aenter__(self):
        """Executed when entering: 'async with ...'"""
        print(f"[Context] Opening connection to: {self.url}")
        await asyncio.sleep(0.5)  # Simulate I/O
        self.status = "Connected"
        return self

    async def __aexit__(self, exc_type, exc_val, exc_tb):
        """Executed when exiting the block to ensure cleanup."""
        await self.close()
        print(f"[Context] Connection to {self.url} closed.")

    # --- Awaitable Protocol (The 'Future' behavior) ---
    def __await__(self):
        """Allows the instance to be used as: 'resp = await AsyncResponse(...)'"""
        return self._run_and_return().__await__()

    async def _run_and_return(self):
        """Internal helper to handle the 'one-shot' await logic."""
        async with self as managed:
            print(f"[Await] Fetching full data from {managed.url}...")
            await asyncio.sleep(0.5)
            return f"Full Body Content from {self.url}"

    async def close(self):
        """General cleanup method."""
        if not self._closed:
            self._closed = True
            # Real-world: close sockets, files, or database cursors here.

# --- Example Usage ---

async def main():
    # Pattern 1: Using 'async with'
    # Best for streaming data or keeping the connection open for multiple tasks.
    print("--- Usage 1: Context Manager Mode ---")
    async with AsyncResponse("https://api.example.com/stream") as resp:
        print(f"Status: {resp.status}")
        print("Processing data within the context...")

    print("\n" + "="*40 + "\n")

    # Pattern 2: Using 'await'
    # Best for simple, one-off requests where you just want the final data.
    print("--- Usage 2: Awaitable Mode ---")
    data = await AsyncResponse("https://api.example.com/get")
    print(f"Received: {data}")

if __name__ == "__main__":
    asyncio.run(main())