quart.ctx module#

class quart.ctx.RequestContext(app, request, session=None)#

Bases: _BaseRequestWebsocketContext

The context relating to the specific request, bound to the current task.

Do not use directly, prefer the request_context() or test_request_context() instead.

Parameters:

app (Quart)
request (Request)
session (SessionMixin | None)

_after_request_functions#: List of functions to execute after the current request, see after_this_request().

property request: Request#

async push()#

Return type:: None

async pop(exc=_sentinel)#

Parameters:: exc (BaseException | None)
Return type:: None

class quart.ctx.WebsocketContext(app, request, session=None)#

Bases: _BaseRequestWebsocketContext

The context relating to the specific websocket, bound to the current task.

Do not use directly, prefer the websocket_context() or test_websocket_context() instead.

Parameters:

app (Quart)
request (Websocket)
session (SessionMixin | None)

_after_websocket_functions#: List of functions to execute after the current websocket, see after_this_websocket().

property websocket: Websocket#

async push()#

Return type:: None

async pop(exc=_sentinel)#

Parameters:: exc (BaseException | None)
Return type:: None

class quart.ctx.AppContext(app)#

Bases: object

The context relating to the app bound to the current task.

Do not use directly, prefer the app_context() instead.

Parameters:: app (Quart)

app#: The app itself.

url_adapter#: An adapter bound to the server, but not a specific task, useful for route building.

g#: An instance of the ctx globals class.

copy()#

Return type:: AppContext

async push()#

Return type:: None

async pop(exc=_sentinel)#

Parameters:: exc (BaseException | None)
Return type:: None

quart.ctx.after_this_request(func)#

Schedule the func to be called after the current request.

This is useful in situations whereby you want an after request function for a specific route or circumstance only, for example,

def index():
    @after_this_request
    def set_cookie(response):
        response.set_cookie('special', 'value')
        return response

    ...

Parameters:: func (AfterRequestCallable)
Return type:: AfterRequestCallable

quart.ctx.after_this_websocket(func)#

Schedule the func to be called after the current websocket.

This is useful in situations whereby you want an after websocket function for a specific route or circumstance only, for example,

Note

The response is an optional argument, and will only be passed if the websocket was not active (i.e. there was an error).

def index():
    @after_this_websocket
    def set_cookie(response: Optional[Response]):
        response.set_cookie('special', 'value')
        return response

    ...

Parameters:: func (AfterWebsocketCallable)
Return type:: AfterWebsocketCallable

quart.ctx.copy_current_app_context(func)#

Share the current app context with the function decorated.

The app context is local per task and hence will not be available in any other task. This decorator can be used to make the context available,

@copy_current_app_context
async def within_context() -> None:
    name = current_app.name
    ...

Parameters:: func (Callable)
Return type:: Callable

quart.ctx.copy_current_request_context(func)#

Share the current request context with the function decorated.

The request context is local per task and hence will not be available in any other task. This decorator can be used to make the context available,

@copy_current_request_context
async def within_context() -> None:
    method = request.method
    ...

Parameters:: func (Callable)
Return type:: Callable

quart.ctx.copy_current_websocket_context(func)#

Share the current websocket context with the function decorated.

The websocket context is local per task and hence will not be available in any other task. This decorator can be used to make the context available,

@copy_current_websocket_context
async def within_context() -> None:
    method = websocket.method
    ...

Parameters:: func (Callable)
Return type:: Callable

quart.ctx.has_app_context()#

Check if execution is within an app context.

This allows a controlled way to act if there is an app context available, or silently not act if not. For example,

if has_app_context():
    log.info("Executing in %s context", current_app.name)