Best practice to acessing context of a request outside a controller?

[albcunha]

Hello!

I have a very long etl, where I need to store some possible errors(they are expected) and return them to the client.

On flask, request is kind of global, so it would be pretty straight forward to save theses errors on it and, at the end, return them on the response body to the user.

I want to know the best approach on starlite.

I saw that I could call application state wherever i wanted to retrieve and add data, but then I need to manage each request, creating and deleting each request. As I don´t need to share contextual data between requests, this seems too cumbersome, specially because I need this context only in one endpoint.

Maybe should I use contextvars for this? This stackoverflow from fastapi suggests this approach: https://stackoverflow.com/a/72664502/5104701

I think, before separation from starlette, I could use starlette-context, it this still possible?

Is there a way to create a middleware for that?

As you see, too many question and too much lack of knowledge.

I´m sorry if it´s a basic question, but as starlite is a new api, there aren´t a lot of tutorials to explain some stuff.

Any help is welcome.

[provinzkraut]

I'm not sure I understand correctly what you're trying to do.

So you want to store errors that occur during the execution of a route handler function, and then return them to the client, all within the scope of a single request/response cycle? Where does global state come in there? Why do you need access to those errors outside the request/response if they are bound to it?

[albcunha]

So you want to store errors that occur during the execution of a route handler function, and then return them to the client, all within the scope of a single request/response cycle?
yes. They will be returned to the use. These errors are not "raise Exception" errors. They can be thought as specific responses that need to be stored separately.

Where does global state come in there?
It doesn´t necessarily need to come in. I just don´t know if there is a better solution.

Why do you need access to those errors outside the request/response if they are bound to it?
I dont need. They are errors that raise exceptions. They are specific responses that need a special storage.

I guess I could use a variable around, but this would be prone to error.

[provinzkraut]

They can be thought as specific responses that need to be stored separately.

Stored where? Why do they need to be stored? If all of this happens within a single request/response cycle, why do they need to be stored outside the request state? Maybe you should elaborate what you mean by "storing a response", since this isn't something you'd typically do. You return a response, once per request.

Can you maybe provide a code example of how this would look, so I can better understand what you're trying to achieve?

[albcunha]

yes. I will prepare it and past it here.

[infohash]

You can use dependency injection to access request object outside of the route handler.

from starlite import Controller, Provide, Request, Starlite, get


async def run_business_logic(request: Request) -> str:
    # do something with the request
    print(request.url)
    return 'client data processed successfully'


class MyController(Controller):
    dependencies = {'request_context': Provide(run_business_logic)}

    @get()
    async def my_route_handler(self, request_context: str) -> str:
        return request_context


app = Starlite(route_handlers=[MyController])

What's happening here?

I have marked run_business_logic as a dependency inside the controller. So whenever a new request will come, the dependency will be called first and its return value will be injected into the handler as a keyword argument. The dependency itself has a Request annotated keyword argument so starlite injects request object there also.

[albcunha]

That´s almost it, but I need to add data to it and retrieve it. Is it possible to create a state on the depency injection for it to be called outside de route handler?

[infohash]

You can inject anything to the dependency which is injected into the route handler. The data will also be injected.

def generate_report(data: RequestModel) -> dict[str, str]:
    ...

class MyController(Controller):
    path = "/"
    dependencies = {"request_context": Provide(generate_report)}

    @post(path="/report")
    async def process_report(self, request_context: dict[str, str], data: RequestModel) -> DataModel:
        ...

[albcunha]

I tried to make it very simple, but the most important thing is to magic_context return only data that belongs to that request, that will be added to final_data and returned to the user.
magic_context would work as a sidecar from generate_report().
Take in consideration that there are many classes that are being called on generate_report on my real case, that´s why I need it on my real case.

# app/controller.py

from starlite import Controller
from app.models import RequestModel, DataModel
from app.services import generate_report

class MagicRequestContext:
    def __init__(self):
        self.warnings = []
magic_context = MagicRequestContext()

class MyController(Controller):
    path = "/"

    @post(
        path="/report",
    )
    async def process_report(self, data: RequestModel) -> DataModel:
        """generates_report."""
        
        final_data = generate_report(data)
        final_data["warnings"] = magic_context.warnings

    return final_data

#app/services/generate_report.py

from app.controller import magic_context

def generate_report(data):
    magic_context.warnings = ['Wow! a error for api X']
    report = {}
    # do report
    return report

[peterschutt]

If generate_report() is responsible for setting the warnings on magic_context, and it returns the report to the handler, can't it just return the warnings also? Or, set them directly on the report?

If you really do need a request-scoped global context, then contextvars would seem the natural choice IMO.

[albcunha]

Normally you would be right, but this example is a oversimplified version of my real situation.

[Goldziher]

Ok, new to the party. Can you explain why request.state doesn't work for your use case?

[provinzkraut]

Normally you would be right, but this example is a oversimplified version of my real situation.

It would be really helpful if you could provide an example that actually shows the issue you’re having. Otherwise it’s going to be difficult to suggest a solution. As @peterschutt correctly pointed out, in this case you could just do something like

def generate_report(data):

    report = {}
    # do report
    report["warnings"] = ['Wow! a error for api X']
    return report

which is effectively what you're doing.

[albcunha]

Thank you all for the feedback.

I found a solution for what I was trying to do. It was inspired on this thread:. I´m posting a oversimplified version of all the classes the report calls, where I will actually use it.

Normally, you would just pass request as an argument, but on my real case I have several classes and methods. Sometimes they call other apis. For this reason, using contextvar as "sidecar" is handy, because I need only to call it where I need to save this warnings.

Let me know if I´m doing something wrong. :

# app/controller.py

from starlite import Controller, State, Request, get
from starlite.types import ASGIApp, Scope, Receive, Send
from starlite.middleware.base import MiddlewareProtocol
from contextvars import ContextVar
from app.models import RequestModel, DataModel
from app.services import generate_report


_request_state_ctx_var: ContextVar = ContextVar("request_state", default=None)


def get_request_state_warnings() -> List[Any]:
    request = _request_state_ctx_var.get()
    request_state = request.state.dict()
    warnings = request_state["warnings"]
    return warnings


def set_request_state_warnings(value: Any) -> None:
    request = _request_state_ctx_var.get()
    request.state.update({"warnings": value})


class RequestStateContextMiddleware(MiddlewareProtocol):
    def __init__(self, app: ASGIApp) -> None:
        super().__init__(app)
        self.app = app

    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
        if scope["type"] == "http":
            request = Request(scope)
            request.state.update({"warnings": []})
            _request_state_ctx_var.set(request)

        await self.app(scope, receive, send)


class MyController(Controller):
    path = "/"

    @post(
        path="/report",
    )
    async def process_report(self, data: RequestModel, , request: Request) -> DataModel:
        """generates_report."""
        request.state.update({"warnings": []})
        _request_state_ctx_var.set(request)
        final_data = generate_report(data)
        final_data["warnings"] = get_request_state_warning()
        return final_data

#app/services/generate_report.py

from app.controller import get_request_state_warnings, set_request_state_warnings

def generate_report(data):
    warnings =  get_request_state_warnings
    warnings.append('Wow! a error for  retrieving api X')
    set_request_state_warnings(warnings)
    report = {}
    # do report
    return report

[provinzkraut]

Forgive me if I'm missing something, but I still don't see the reason for doing it this way.

This does exactly the same thing:

def generate_report(data: RequestModel):
    report = {}
    # do report
    report["warnings"] =  ['Wow! a error for  retrieving api X']
    return report

class MyController(Controller):
    path = "/"

    @post(
        path="/report",
    )
    async def process_report(self, data: RequestModel , request: Request) -> DataModel:
        """generates_report."""
        final_data = generate_report(data)
        final_data["warnings"] = get_request_state_warning()
        return final_data

Or, if you insist on using some state for this:

def generate_report(data: RequestModel, request: Request):
    report = {}
    # do report
    request.state["warnings"].append('Wow! a error for  retrieving api X')
    return report

class MyController(Controller):
    path = "/"

    @post(
        path="/report",
    )
    async def process_report(self, data: RequestModel, request: Request) -> DataModel:
        """generates_report."""
        request.state.setdefault("warnings", list)
        final_data = generate_report(data)
        final_data["warnings"] = request.state["warnings"]
        return final_data

All this aside:

Normally, you would just pass request as an argument, but on my real case I have several classes and methods. Sometimes they call other apis. For this reason, using contextvar as "sidecar" is handy, because I need only to call it where I need to save this warnings.

I'd argue that this is just bad practice. Sure, it's cool to do this with context vars, but setting up a middleware, context vars and request state, just so you can omit passing one more parameter to some functions just isn't worth it. It also will make your application way harder to test and debug. I'd recommend you just pass around your report dictionary and accumulate the warnings there, or have every function that can return warnings return a tuple of the data and warnings and then accumulate that someplace else.

[albcunha]

Thank you for your feedback. I´ll take it in consideration and discuss it with other developers.

[albcunha]

In case anyone stumbles over this, implementations using contextvars wont work in some cases. As we rely on asyncio.to_thread() we cant get returns back. Backpropagation is not possible. This is discussed here: https://discuss.python.org/t/back-propagation-of-contextvar-changes-from-worker-threads/15928/24 . Maybe in the future it will be implemented.
I wasn´t fully able to explain our situation. Sometimes we have a lot of chained functions. Passing an argument through 6-8 functions/classes seems too much. We chose a simpler approach, we will update the database with the warnings and retrieve it at the end, as there won´t be many calls to each report generation, it´s easier to implement.
Some other references, if someone wants to dig in the subject:
https://blog.sqreen.com/asyncio/
https://aiocontext.readthedocs.io/en/latest/
https://kobybass.medium.com/python-contextvars-and-multithreading-faa33dbe953d
https://superfastpython.com/thread-context-variables-in-python/

Thank you for taking your time trying to help.

I´ll mark the thread as answered.