About new container_context

[lesnik512]

@vrslev Raised some questions. @alexanderlazarev0 Let's discuss them, before releasing as 2.0.0

In new design default value of reset_all_containers is False in container_context, while in DIContextMiddleware it's True. Maybe make them consistent?

[alexanderlazarev0]

Agreed, if you notice anything else, please let me know. I will make those changes as part of the pull request for #140.

Also, @lesnik512 I have already migrated a larger application to the pre-release version and haven't had any issues. However, keep in mind that that app does not make use of the global_context.

[lesnik512]

@alexanderlazarev0

However, keep in mind that that app does make use of the global_context.

Do you mean, that it doesn't make use of the global_context?

[alexanderlazarev0]

See #143 (Work in progress)

[alexanderlazarev0]

Okay there is actually a large issue on the pre-release version 2.0.0a0 (alpha):

Here was my first example to reproduce:

# app.py
from that_depends import providers
from that_depends import BaseContainer, container_context, inject, Provide
import uvicorn

app = FastAPI()


async def async_creator() -> typing.Iterator[str]:
    try:
        await asyncio.sleep(1)
        yield str(uuid4())
    finally:
        print("Tearing down")


class MyContainer(BaseContainer):
    my_async_context_resource = providers.ContextResource(async_creator)

async def init_container_context():
    async with container_context(MyContainer):
        yield


router = APIRouter(dependencies=[Depends(init_container_context)])

@container_context()
@inject
async def injected(val: str = Provide[MyContainer.my_async_context_resource]) -> str:
    return val

@router.get("/")
async def read_root():
    return await injected()

app.include_router(router)

if __name__ == "__main__":
    uvicorn.run("test:app", port=8008, reload=True)

# stress_test.py
import threading
import requests

# Define the target endpoint and the payload
endpoint = "http://localhost:8008/"
# Function to send a single request
def send_request():
    try:
        response = requests.get(endpoint)
        print(f"Response Code: {response.status_code}, Response Body: {response.text}")
    except Exception as e:
        print(f"Request failed: {e}")
if __name__ == '__main__':

    # Create and start multiple threads
    num_threads = 50  # Number of simultaneous requests
    threads = []

    for _ in range(num_threads):
        thread = threading.Thread(target=send_request)
        threads.append(thread)
        thread.start()

    # Wait for all threads to finish
    for thread in threads:
        thread.join()

Long story short, this causes a contextvar issue because of context switching (asyncio). I already found the fix (I believe) so just writing this here in case someone else sees this.

[alexanderlazarev0]

Here is a test that reproduces this behaviour (already added in #143):

async def test_async_context_switching() -> None:
    async def slow_async_creator() -> typing.AsyncIterator[str]:
        await asyncio.sleep(0.1)
        yield str(uuid.uuid4())

    class MyContainer(BaseContainer):
        slow_provider = providers.ContextResource(slow_async_creator)

    async def _injected() -> str:
        async with MyContainer.slow_provider.async_context():
            return await MyContainer.slow_provider.async_resolve()

    await asyncio.gather(*[_injected() for _ in range(10)])