quart.app module
- class quart.app.Quart(import_name: str, static_url_path: Optional[str] = None, static_folder: Optional[str] = 'static', static_host: Optional[str] = None, host_matching: bool = False, subdomain_matching: bool = False, template_folder: Optional[str] = 'templates', instance_path: Optional[str] = None, instance_relative_config: bool = False, root_path: Optional[str] = None)
Bases:
Scaffold
The web framework class, handles requests and returns responses.
The primary method from a serving viewpoint is
handle_request()
, from an application viewpoint all the other methods are vital.This can be extended in many ways, with most methods designed with this in mind. Additionally any of the classes listed as attributes can be replaced.
- aborter_class
The class to use to raise HTTP error via the abort helper function.
- app_ctx_globals_class
The class to use for the
g
object
- asgi_http_class
The class to use to handle the ASGI HTTP protocol.
- Type
- asgi_lifespan_class
The class to use to handle the ASGI lifespan protocol.
- Type
- asgi_websocket_class
The class to use to handle the ASGI websocket protocol.
- Type
- config_class
The class to use for the configuration.
- env
The name of the environment the app is running on.
- debug
Wrapper around configuration DEBUG value, in many places this will result in more output if True. If unset, debug mode will be activated if environ is set to ‘development’.
- jinja_environment
The class to use for the jinja environment.
- jinja_options
The default options to set when creating the jinja environment.
- Type
dict
- permanent_session_lifetime
Wrapper around configuration PERMANENT_SESSION_LIFETIME value. Specifies how long the session data should survive.
- request_class
The class to use for requests.
- response_class
The class to user for responses.
- secret_key
Warpper around configuration SECRET_KEY value. The app secret for signing sessions.
- session_cookie_name
Wrapper around configuration SESSION_COOKIE_NAME, use to specify the cookie name for session data.
- session_interface
The class to use as the session interface.
- url_map_class
The class to map rules to endpoints.
- url_rule_class
The class to use for URL rules.
- websocket_class
The class to use for websockets.
- aborter_class
alias of
Aborter
- add_background_task(func: Callable, *args: Any, **kwargs: Any) None
- add_template_filter(func: Callable[[Any], Any], name: Optional[str] = None) None
Add a template filter.
This is designed to be used on the application directly. An example usage,
def to_upper(value): return value.upper() app.add_template_filter(to_upper)
- Parameters
func – The function that is the filter.
name – The filter name (defaults to function name).
- add_template_global(func: Callable[[Any], Any], name: Optional[str] = None) None
Add a template global.
This is designed to be used on the application directly. An example usage,
def five(): return 5 app.add_template_global(five)
- Parameters
func – The function that is the global.
name – The global name (defaults to function name).
- add_template_test(func: Callable[[Any], bool], name: Optional[str] = None) None
Add a template test.
This is designed to be used on the application directly. An example usage,
def is_upper(value): return value.isupper() app.add_template_test(is_upper)
- Parameters
func – The function that is the test.
name – The test name (defaults to function name).
- add_url_rule(rule: str, endpoint: Optional[str] = None, view_func: Optional[Callable] = None, provide_automatic_options: Optional[bool] = None, *, methods: Optional[Iterable[str]] = None, defaults: Optional[dict] = None, host: Optional[str] = None, subdomain: Optional[str] = None, is_websocket: bool = False, strict_slashes: Optional[bool] = None, merge_slashes: Optional[bool] = None) None
Add a route/url rule to the application.
This is designed to be used on the application directly. An example usage,
def route(): ... app.add_url_rule('/', route)
- Parameters
rule – The path to route on, should start with a
/
.endpoint – Optional endpoint name, if not present the function name is used.
view_func – Callable that returns a response.
provide_automatic_options – Optionally False to prevent OPTION handling.
methods – List of HTTP verbs the function routes.
defaults –
A dictionary of variables to provide automatically, use to provide a simpler default path for a route, e.g. to allow for
/book
rather than/book/0
,@app.route('/book', defaults={'page': 0}) @app.route('/book/<int:page>') def book(page): ...
host – The full host name for this route (should include subdomain if needed) - cannot be used with subdomain.
subdomain – A subdomain for this specific route.
strict_slashes – Strictly match the trailing slash present in the path. Will redirect a leaf (no slash) to a branch (with slash).
is_websocket – Whether or not the view_func is a websocket.
merge_slashes – Merge consecutive slashes to a single slash (unless as part of the path variable).
- after_serving(func: T_after_serving) T_after_serving
Add a after serving function.
This will allow the function provided to be called once after anything is served (after last byte is sent).
This is designed to be used as a decorator, if used to decorate a synchronous function, the function will be wrapped in
run_sync()
and run in a thread executor (with the wrapped function returned). An example usage,@app.after_serving async def func(): ...
- Parameters
func – The function itself.
- app_context() AppContext
Create and return an app context.
This is best used within a context, i.e.
async with app.app_context(): ...
- app_ctx_globals_class
alias of
_AppCtxGlobals
- async asgi_app(scope: Union[HTTPScope, WebsocketScope, LifespanScope], receive: Callable[[], Awaitable[Union[HTTPRequestEvent, HTTPDisconnectEvent, WebsocketConnectEvent, WebsocketReceiveEvent, WebsocketDisconnectEvent, LifespanStartupEvent, LifespanShutdownEvent]]], send: Callable[[Union[HTTPResponseStartEvent, HTTPResponseBodyEvent, HTTPServerPushEvent, HTTPEarlyHintEvent, HTTPDisconnectEvent, WebsocketAcceptEvent, WebsocketSendEvent, WebsocketResponseStartEvent, WebsocketResponseBodyEvent, WebsocketCloseEvent, LifespanStartupCompleteEvent, LifespanStartupFailedEvent, LifespanShutdownCompleteEvent, LifespanShutdownFailedEvent]], Awaitable[None]]) None
This handles ASGI calls, it can be wrapped in middleware.
When using middleware with Quart it is preferable to wrap this method rather than the app itself. This is to ensure that the app is an instance of this class - which allows the quart cli to work correctly. To use this feature simply do,
app.asgi_app = middleware(app.asgi_app)
- asgi_http_class
alias of
ASGIHTTPConnection
- asgi_lifespan_class
alias of
ASGILifespan
- asgi_websocket_class
alias of
ASGIWebsocketConnection
- auto_find_instance_path() Path
Locates the instance_path if it was not provided
- before_first_request(func: T_before_first_request) T_before_first_request
Add a before first request function.
This is designed to be used as a decorator, if used to decorate a synchronous function, the function will be wrapped in
run_sync()
and run in a thread executor (with the wrapped function returned). An example usage,@app.before_first_request async def func(): ...
- Parameters
func – The before first request function itself.
- before_serving(func: T_before_serving) T_before_serving
Add a before serving function.
This will allow the function provided to be called once before anything is served (before any byte is received).
This is designed to be used as a decorator, if used to decorate a synchronous function, the function will be wrapped in
run_sync()
and run in a thread executor (with the wrapped function returned). An example usage,@app.before_serving async def func(): ...
- Parameters
func – The function itself.
- create_global_jinja_loader() DispatchingJinjaLoader
Create and return a global (not blueprint specific) Jinja loader.
- create_jinja_environment() Environment
Create and return the jinja environment.
This will create the environment based on the
jinja_options
and configuration settings. The environment will include the Quart globals by default.
- create_url_adapter(request: Optional[BaseRequestWebsocket]) Optional[MapAdapter]
Create and return a URL adapter.
This will create the adapter based on the request if present otherwise the app configuration.
- property debug: bool
Activate debug mode (extra checks, logging and reloading).
Should/must be False in production.
- async dispatch_request(request_context: Optional[RequestContext] = None) Union[Response, Response, AnyStr, Mapping[str, Any], List[Any], AsyncGenerator[AnyStr, None], Generator[AnyStr, None, None], Tuple[Union[Response, Response, AnyStr, Mapping[str, Any], List[Any], AsyncGenerator[AnyStr, None], Generator[AnyStr, None, None]], Union[Headers, Dict[str, Union[str, List[str], Tuple[str, ...]]], List[Tuple[str, Union[str, List[str], Tuple[str, ...]]]]]], Tuple[Union[Response, Response, AnyStr, Mapping[str, Any], List[Any], AsyncGenerator[AnyStr, None], Generator[AnyStr, None, None]], int], Tuple[Union[Response, Response, AnyStr, Mapping[str, Any], List[Any], AsyncGenerator[AnyStr, None], Generator[AnyStr, None, None]], int, Union[Headers, Dict[str, Union[str, List[str], Tuple[str, ...]]], List[Tuple[str, Union[str, List[str], Tuple[str, ...]]]]]]]
Dispatch the request to the view function.
- Parameters
request_context – The request context, optional as Flask omits this argument.
- async dispatch_websocket(websocket_context: Optional[WebsocketContext] = None) Optional[Union[Response, Response, AnyStr, Mapping[str, Any], List[Any], AsyncGenerator[AnyStr, None], Generator[AnyStr, None, None], Tuple[Union[Response, Response, AnyStr, Mapping[str, Any], List[Any], AsyncGenerator[AnyStr, None], Generator[AnyStr, None, None]], Union[Headers, Dict[str, Union[str, List[str], Tuple[str, ...]]], List[Tuple[str, Union[str, List[str], Tuple[str, ...]]]]]], Tuple[Union[Response, Response, AnyStr, Mapping[str, Any], List[Any], AsyncGenerator[AnyStr, None], Generator[AnyStr, None, None]], int], Tuple[Union[Response, Response, AnyStr, Mapping[str, Any], List[Any], AsyncGenerator[AnyStr, None], Generator[AnyStr, None, None]], int, Union[Headers, Dict[str, Union[str, List[str], Tuple[str, ...]]], List[Tuple[str, Union[str, List[str], Tuple[str, ...]]]]]]]]
Dispatch the websocket to the view function.
- Parameters
websocket_context – The websocket context, optional to match the Flask convention.
- async do_teardown_appcontext(exc: Optional[BaseException]) None
Teardown the app (context), calling the teardown functions.
- async do_teardown_request(exc: Optional[BaseException], request_context: Optional[RequestContext] = None) None
Teardown the request, calling the teardown functions.
- Parameters
exc – Any exception not handled that has caused the request to teardown.
request_context – The request context, optional as Flask omits this argument.
- async do_teardown_websocket(exc: Optional[BaseException], websocket_context: Optional[WebsocketContext] = None) None
Teardown the websocket, calling the teardown functions.
- Parameters
exc – Any exception not handled that has caused the websocket to teardown.
websocket_context – The websocket context, optional as Flask omits this argument.
- ensure_async(func: Callable[[...], Any]) Callable[[...], Awaitable[Any]]
Ensure that the returned func is async and calls the func.
New in version 0.11.
Override if you wish to change how synchronous functions are run. Before Quart 0.11 this did not run the synchronous code in an executor.
- env
Implements a property descriptor for objects with a config attribute.
When used as a class instance it will look up the key on the class config object, for example:
class Object: config = {} foo = ConfigAttribute('foo') obj = Object() obj.foo = 'bob' assert obj.foo == obj.config['foo']
- async finalize_request(result: Union[Response, Response, AnyStr, Mapping[str, Any], List[Any], AsyncGenerator[AnyStr, None], Generator[AnyStr, None, None], Tuple[Union[Response, Response, AnyStr, Mapping[str, Any], List[Any], AsyncGenerator[AnyStr, None], Generator[AnyStr, None, None]], Union[Headers, Dict[str, Union[str, List[str], Tuple[str, ...]]], List[Tuple[str, Union[str, List[str], Tuple[str, ...]]]]]], Tuple[Union[Response, Response, AnyStr, Mapping[str, Any], List[Any], AsyncGenerator[AnyStr, None], Generator[AnyStr, None, None]], int], Tuple[Union[Response, Response, AnyStr, Mapping[str, Any], List[Any], AsyncGenerator[AnyStr, None], Generator[AnyStr, None, None]], int, Union[Headers, Dict[str, Union[str, List[str], Tuple[str, ...]]], List[Tuple[str, Union[str, List[str], Tuple[str, ...]]]]]], HTTPException], request_context: Optional[RequestContext] = None, from_error_handler: bool = False) Union[Response, Response]
Turns the view response return value into a response.
- Parameters
result – The result of the request to finalize into a response.
request_context – The request context, optional as Flask omits this argument.
- async finalize_websocket(result: Union[Response, Response, AnyStr, Mapping[str, Any], List[Any], AsyncGenerator[AnyStr, None], Generator[AnyStr, None, None], Tuple[Union[Response, Response, AnyStr, Mapping[str, Any], List[Any], AsyncGenerator[AnyStr, None], Generator[AnyStr, None, None]], Union[Headers, Dict[str, Union[str, List[str], Tuple[str, ...]]], List[Tuple[str, Union[str, List[str], Tuple[str, ...]]]]]], Tuple[Union[Response, Response, AnyStr, Mapping[str, Any], List[Any], AsyncGenerator[AnyStr, None], Generator[AnyStr, None, None]], int], Tuple[Union[Response, Response, AnyStr, Mapping[str, Any], List[Any], AsyncGenerator[AnyStr, None], Generator[AnyStr, None, None]], int, Union[Headers, Dict[str, Union[str, List[str], Tuple[str, ...]]], List[Tuple[str, Union[str, List[str], Tuple[str, ...]]]]]]], websocket_context: Optional[WebsocketContext] = None, from_error_handler: bool = False) Optional[Union[Response, Response]]
Turns the view response return value into a response.
- Parameters
result – The result of the websocket to finalize into a response.
websocket_context – The websocket context, optional as Flask omits this argument.
- async full_dispatch_request(request_context: Optional[RequestContext] = None) Union[Response, Response]
Adds pre and post processing to the request dispatching.
- Parameters
request_context – The request context, optional as Flask omits this argument.
- async full_dispatch_websocket(websocket_context: Optional[WebsocketContext] = None) Optional[Union[Response, Response]]
Adds pre and post processing to the websocket dispatching.
- Parameters
websocket_context – The websocket context, optional to match the Flask convention.
- property got_first_request: bool
Return if the app has received a request.
- async handle_background_exception(error: Exception) None
- async handle_exception(error: Exception) Union[Response, Response]
Handle an uncaught exception.
By default this switches the error response to a 500 internal server error.
- async handle_http_exception(error: HTTPException) Union[HTTPException, Response, Response, AnyStr, Mapping[str, Any], List[Any], AsyncGenerator[AnyStr, None], Generator[AnyStr, None, None], Tuple[Union[Response, Response, AnyStr, Mapping[str, Any], List[Any], AsyncGenerator[AnyStr, None], Generator[AnyStr, None, None]], Union[Headers, Dict[str, Union[str, List[str], Tuple[str, ...]]], List[Tuple[str, Union[str, List[str], Tuple[str, ...]]]]]], Tuple[Union[Response, Response, AnyStr, Mapping[str, Any], List[Any], AsyncGenerator[AnyStr, None], Generator[AnyStr, None, None]], int], Tuple[Union[Response, Response, AnyStr, Mapping[str, Any], List[Any], AsyncGenerator[AnyStr, None], Generator[AnyStr, None, None]], int, Union[Headers, Dict[str, Union[str, List[str], Tuple[str, ...]]], List[Tuple[str, Union[str, List[str], Tuple[str, ...]]]]]]]
Handle a HTTPException subclass error.
This will attempt to find a handler for the error and if fails will fall back to the error response.
- handle_url_build_error(error: Exception, endpoint: str, values: dict) str
Handle a build error.
Ideally this will return a valid url given the error endpoint and values.
- async handle_user_exception(error: Exception) Union[HTTPException, Response, Response, AnyStr, Mapping[str, Any], List[Any], AsyncGenerator[AnyStr, None], Generator[AnyStr, None, None], Tuple[Union[Response, Response, AnyStr, Mapping[str, Any], List[Any], AsyncGenerator[AnyStr, None], Generator[AnyStr, None, None]], Union[Headers, Dict[str, Union[str, List[str], Tuple[str, ...]]], List[Tuple[str, Union[str, List[str], Tuple[str, ...]]]]]], Tuple[Union[Response, Response, AnyStr, Mapping[str, Any], List[Any], AsyncGenerator[AnyStr, None], Generator[AnyStr, None, None]], int], Tuple[Union[Response, Response, AnyStr, Mapping[str, Any], List[Any], AsyncGenerator[AnyStr, None], Generator[AnyStr, None, None]], int, Union[Headers, Dict[str, Union[str, List[str], Tuple[str, ...]]], List[Tuple[str, Union[str, List[str], Tuple[str, ...]]]]]]]
Handle an exception that has been raised.
This should forward
HTTPException
tohandle_http_exception()
, then attempt to handle the error. If it cannot it should reraise the error.
- async handle_websocket_exception(error: Exception) Optional[Union[Response, Response]]
Handle an uncaught exception.
By default this logs the exception and then re-raises it.
- inject_url_defaults(endpoint: str, values: dict) None
Injects default URL values into the passed values dict.
This is used to assist when building urls, see url_for.
- property jinja_env: Environment
The jinja environment used to load templates.
- jinja_environment
alias of
Environment
- jinja_options: dict = {}
- json_provider_class
alias of
DefaultJSONProvider
- lock_class
alias of
Lock
- log_exception(exception_info: Union[Tuple[type, BaseException, TracebackType], Tuple[None, None, None]]) None
Log a exception to the
logger
.By default this is only invoked for unhandled exceptions.
- property logger: Logger
A
logging.Logger
logger for the app.This can be used to log messages in a format as defined in the app configuration, for example,
app.logger.debug("Request method %s", request.method) app.logger.error("Error, of some kind")
- make_aborter() Aborter
Create and return the aborter instance.
- make_config(instance_relative: bool = False) Config
Create and return the configuration with appropriate defaults.
- async make_default_options_response() Response
This is the default route function for OPTIONS requests.
- async make_response(result: Union[Response, Response, AnyStr, Mapping[str, Any], List[Any], AsyncGenerator[AnyStr, None], Generator[AnyStr, None, None], Tuple[Union[Response, Response, AnyStr, Mapping[str, Any], List[Any], AsyncGenerator[AnyStr, None], Generator[AnyStr, None, None]], Union[Headers, Dict[str, Union[str, List[str], Tuple[str, ...]]], List[Tuple[str, Union[str, List[str], Tuple[str, ...]]]]]], Tuple[Union[Response, Response, AnyStr, Mapping[str, Any], List[Any], AsyncGenerator[AnyStr, None], Generator[AnyStr, None, None]], int], Tuple[Union[Response, Response, AnyStr, Mapping[str, Any], List[Any], AsyncGenerator[AnyStr, None], Generator[AnyStr, None, None]], int, Union[Headers, Dict[str, Union[str, List[str], Tuple[str, ...]]], List[Tuple[str, Union[str, List[str], Tuple[str, ...]]]]]], HTTPException]) Union[Response, Response]
Make a Response from the result of the route handler.
- The result itself can either be:
A Response object (or subclass).
A tuple of a ResponseValue and a header dictionary.
A tuple of a ResponseValue, status code and a header dictionary.
A ResponseValue is either a Response object (or subclass) or a str.
- make_shell_context() dict
Create a context for interactive shell usage.
The
shell_context_processors
can be used to add additional context.
- property name: str
The name of this application.
This is taken from the
import_name
and is used for debugging purposes.
- async open_instance_resource(path: Union[bytes, str, PathLike], mode: str = 'rb') AiofilesContextManager[None, None, AsyncBufferedReader]
Open a file for reading.
Use as
async with await app.open_instance_resource(path) as file_: await file_.read()
- permanent_session_lifetime
Implements a property descriptor for objects with a config attribute.
When used as a class instance it will look up the key on the class config object, for example:
class Object: config = {} foo = ConfigAttribute('foo') obj = Object() obj.foo = 'bob' assert obj.foo == obj.config['foo']
- async postprocess_websocket(response: Optional[Union[Response, Response]], websocket_context: Optional[WebsocketContext] = None) Union[Response, Response]
Postprocess the websocket acting on the response.
- Parameters
response – The response after the websocket is finalized.
websocket_context – The websocket context, optional as Flask omits this argument.
- async preprocess_request(request_context: Optional[RequestContext] = None) Optional[Union[Response, Response, AnyStr, Mapping[str, Any], List[Any], AsyncGenerator[AnyStr, None], Generator[AnyStr, None, None], Tuple[Union[Response, Response, AnyStr, Mapping[str, Any], List[Any], AsyncGenerator[AnyStr, None], Generator[AnyStr, None, None]], Union[Headers, Dict[str, Union[str, List[str], Tuple[str, ...]]], List[Tuple[str, Union[str, List[str], Tuple[str, ...]]]]]], Tuple[Union[Response, Response, AnyStr, Mapping[str, Any], List[Any], AsyncGenerator[AnyStr, None], Generator[AnyStr, None, None]], int], Tuple[Union[Response, Response, AnyStr, Mapping[str, Any], List[Any], AsyncGenerator[AnyStr, None], Generator[AnyStr, None, None]], int, Union[Headers, Dict[str, Union[str, List[str], Tuple[str, ...]]], List[Tuple[str, Union[str, List[str], Tuple[str, ...]]]]]]]]
Preprocess the request i.e. call before_request functions.
- Parameters
request_context – The request context, optional as Flask omits this argument.
- async preprocess_websocket(websocket_context: Optional[WebsocketContext] = None) Optional[Union[Response, Response, AnyStr, Mapping[str, Any], List[Any], AsyncGenerator[AnyStr, None], Generator[AnyStr, None, None], Tuple[Union[Response, Response, AnyStr, Mapping[str, Any], List[Any], AsyncGenerator[AnyStr, None], Generator[AnyStr, None, None]], Union[Headers, Dict[str, Union[str, List[str], Tuple[str, ...]]], List[Tuple[str, Union[str, List[str], Tuple[str, ...]]]]]], Tuple[Union[Response, Response, AnyStr, Mapping[str, Any], List[Any], AsyncGenerator[AnyStr, None], Generator[AnyStr, None, None]], int], Tuple[Union[Response, Response, AnyStr, Mapping[str, Any], List[Any], AsyncGenerator[AnyStr, None], Generator[AnyStr, None, None]], int, Union[Headers, Dict[str, Union[str, List[str], Tuple[str, ...]]], List[Tuple[str, Union[str, List[str], Tuple[str, ...]]]]]]]]
Preprocess the websocket i.e. call before_websocket functions.
- Parameters
websocket_context – The websocket context, optional as Flask omits this argument.
- property preserve_context_on_exception: bool
- async process_response(response: Union[Response, Response], request_context: Optional[RequestContext] = None) Union[Response, Response]
Postprocess the request acting on the response.
- Parameters
response – The response after the request is finalized.
request_context – The request context, optional as Flask omits this argument.
- property propagate_exceptions: bool
Return true if exceptions should be propagated into debug pages.
If false the exception will be handled. See the
PROPAGATE_EXCEPTIONS
config setting.
- raise_routing_exception(request: BaseRequestWebsocket) NoReturn
- redirect(location: str, code: int = 302) Response
Create a redirect response object.
- register_blueprint(blueprint: Blueprint, **options: Any) None
Register a blueprint on the app.
This results in the blueprint’s routes, error handlers etc… being added to the app.
- Parameters
blueprint – The blueprint to register.
url_prefix – Optional prefix to apply to all paths.
url_defaults – Blueprint routes will use these default values for view arguments.
subdomain – Blueprint routes will match on this subdomain.
- request_context(request: Request) RequestContext
Create and return a request context.
Use the
test_request_context()
whilst testing. This is best used within a context, i.e.async with app.request_context(request): ...
- Parameters
request – A request to build a context around.
- run(host: Optional[str] = None, port: Optional[int] = None, debug: Optional[bool] = None, use_reloader: bool = True, loop: Optional[AbstractEventLoop] = None, ca_certs: Optional[str] = None, certfile: Optional[str] = None, keyfile: Optional[str] = None, **kwargs: Any) None
Run this application.
This is best used for development only, see Hypercorn for production servers.
- Parameters
host – Hostname to listen on. By default this is loopback only, use 0.0.0.0 to have the server listen externally.
port – Port number to listen on.
debug – If set enable (or disable) debug mode and debug output.
use_reloader – Automatically reload on code changes.
loop – Asyncio loop to create the server in, if None, take default one. If specified it is the caller’s responsibility to close and cleanup the loop.
ca_certs – Path to the SSL CA certificate file.
certfile – Path to the SSL certificate file.
keyfile – Path to the SSL key file.
- run_task(host: str = '127.0.0.1', port: int = 5000, debug: Optional[bool] = None, ca_certs: Optional[str] = None, certfile: Optional[str] = None, keyfile: Optional[str] = None, shutdown_trigger: Optional[Callable[[...], Awaitable[None]]] = None) Coroutine[None, None, None]
Return a task that when awaited runs this application.
This is best used for development only, see Hypercorn for production servers.
- Parameters
host – Hostname to listen on. By default this is loopback only, use 0.0.0.0 to have the server listen externally.
port – Port number to listen on.
debug – If set enable (or disable) debug mode and debug output.
ca_certs – Path to the SSL CA certificate file.
certfile – Path to the SSL certificate file.
keyfile – Path to the SSL key file.
- secret_key
Implements a property descriptor for objects with a config attribute.
When used as a class instance it will look up the key on the class config object, for example:
class Object: config = {} foo = ConfigAttribute('foo') obj = Object() obj.foo = 'bob' assert obj.foo == obj.config['foo']
- select_jinja_autoescape(filename: str) bool
Returns True if the filename indicates that it should be escaped.
- send_file_max_age_default
Implements a property descriptor for objects with a config attribute.
When used as a class instance it will look up the key on the class config object, for example:
class Object: config = {} foo = ConfigAttribute('foo') obj = Object() obj.foo = 'bob' assert obj.foo == obj.config['foo']
- session_cookie_name
Implements a property descriptor for objects with a config attribute.
When used as a class instance it will look up the key on the class config object, for example:
class Object: config = {} foo = ConfigAttribute('foo') obj = Object() obj.foo = 'bob' assert obj.foo == obj.config['foo']
- session_interface = <quart.sessions.SecureCookieSessionInterface object>
- shell_context_processor(func: T_shell_context_processor) T_shell_context_processor
Add a shell context processor.
This is designed to be used as a decorator. An example usage,
@app.shell_context_processor def additional_context(): return context
- async shutdown() None
- async startup() None
- sync_to_async(func: Callable[[...], Any]) Callable[[...], Awaitable[Any]]
Return a async function that will run the synchronous function func.
This can be used as so,:
result = await app.sync_to_async(func)(*args, **kwargs)
Override this method to change how the app converts sync code to be asynchronously callable.
- teardown_appcontext(func: T_teardown) T_teardown
Add a teardown app (context) function.
This is designed to be used as a decorator, if used to decorate a synchronous function, the function will be wrapped in
run_sync()
and run in a thread executor (with the wrapped function returned). An example usage,@app.teardown_appcontext async def func(): ...
- Parameters
func – The teardown function itself.
name – Optional blueprint key name.
- template_filter(name: Optional[str] = None) Callable[[T_template_filter], T_template_filter]
Add a template filter.
This is designed to be used as a decorator. An example usage,
@app.template_filter('name') def to_upper(value): return value.upper()
- Parameters
name – The filter name (defaults to function name).
- template_global(name: Optional[str] = None) Callable[[T_template_global], T_template_global]
Add a template global.
This is designed to be used as a decorator. An example usage,
@app.template_global('name') def five(): return 5
- Parameters
name – The global name (defaults to function name).
- template_test(name: Optional[str] = None) Callable[[T_template_test], T_template_test]
Add a template test.
This is designed to be used as a decorator. An example usage,
@app.template_test('name') def is_upper(value): return value.isupper()
- Parameters
name – The test name (defaults to function name).
- property templates_auto_reload: bool
Returns True if templates should auto reload.
- test_app() TestAppProtocol
- test_cli_runner(**kwargs: Any) QuartCliRunner
Creates and returns a CLI test runner.
- test_cli_runner_class
alias of
QuartCliRunner
- test_client(use_cookies: bool = True) TestClientProtocol
Creates and returns a test client.
- test_client_class
alias of
QuartClient
- test_request_context(path: str, *, method: str = 'GET', headers: ~typing.Optional[~typing.Union[dict, ~werkzeug.datastructures.Headers]] = None, query_string: ~typing.Optional[dict] = None, scheme: str = 'http', send_push_promise: ~typing.Callable[[str, ~werkzeug.datastructures.Headers], ~typing.Awaitable[None]] = <function no_op_push>, data: ~typing.Optional[AnyStr] = None, form: ~typing.Optional[dict] = None, json: ~typing.Any = <object object>, root_path: str = '', http_version: str = '1.1', scope_base: ~typing.Optional[dict] = None, auth: ~typing.Optional[~typing.Union[~werkzeug.datastructures.Authorization, ~typing.Tuple[str, str]]] = None, subdomain: ~typing.Optional[str] = None) RequestContext
Create a request context for testing purposes.
This is best used for testing code within request contexts. It is a simplified wrapper of
request_context()
. It is best used in a with block, i.e.async with app.test_request_context("/", method="GET"): ...
- Parameters
path – Request path.
method – HTTP verb
headers – Headers to include in the request.
query_string – To send as a dictionary, alternatively the query_string can be determined from the path.
scheme – Scheme for the request, default http.
- testing
Implements a property descriptor for objects with a config attribute.
When used as a class instance it will look up the key on the class config object, for example:
class Object: config = {} foo = ConfigAttribute('foo') obj = Object() obj.foo = 'bob' assert obj.foo == obj.config['foo']
- trap_http_exception(error: Exception) bool
Check it error is http and should be trapped.
Trapped errors are not handled by the
handle_http_exception()
, but instead trapped by the outer most (or user handlers). This can be useful when debugging to allow tracebacks to be viewed by the debug page.
- async try_trigger_before_first_request_functions() None
Trigger the before first request methods.
- async update_template_context(context: dict) None
Update the provided template context.
This adds additional context from the various template context processors.
- Parameters
context – The context to update (mutate).
- url_for(endpoint: str, *, _anchor: Optional[str] = None, _external: Optional[bool] = None, _method: Optional[str] = None, _scheme: Optional[str] = None, **values: Any) str
Return the url for a specific endpoint.
This is most useful in templates and redirects to create a URL that can be used in the browser.
- Parameters
endpoint – The endpoint to build a url for, if prefixed with
.
it targets endpoint’s in the current blueprint._anchor – Additional anchor text to append (i.e. #text).
_external – Return an absolute url for external (to app) usage.
_method – The method to consider alongside the endpoint.
_scheme – A specific scheme to use.
values – The values to build into the URL, as specified in the endpoint rule.
- websocket_context(websocket: Websocket) WebsocketContext
Create and return a websocket context.
Use the
test_websocket_context()
whilst testing. This is best used within a context, i.e.async with app.websocket_context(websocket): ...
- Parameters
websocket – A websocket to build a context around.
- while_serving(func: T_while_serving) T_while_serving
Add a while serving generator function.
This will allow the generator provided to be invoked at startup and then again at shutdown.
This is designed to be used as a decorator. An example usage,
@app.while_serving async def func(): ... # Startup yield ... # Shutdown
- Parameters
func – The function itself.