U
|
ß=®dDV ã @ s d dl mZ d dlZd dlZd dlZd dlZd dlZd dlm Z
|
d dl m Z d dl mZ d dlmZ d dlmZ d dlmZ d dlZd d lmZ d d
|
lmZ d d lmZ d d lm Z d d lm Z d dlm Z d dlm Z d dl m!Z! d dl m"Z" d dl m#Z# d dl m$Z$ d dl m%Z% d dl m&Z& d dl'm(Z( d dl)m*Z* d dl)m+Z, d dl-m.Z/ ddl0m1Z1 dd l0mZ2 dd l3m4Z4 dd l3m5Z5 dd l6m7Z7 dd l6m8Z8 dd!l6m9Z9 dd"l:m;Z; dd#l:m<Z< dd$l:m=Z= dd%l:m>Z> dd&l:m?Z? dd'l:m@Z@ dd(lAmBZB dd)lAmCZC dd*lAmDZD dd+lAmEZE dd,lFmGZG dd-lFmHZH dd.lmIZI dd/lJmKZK dd0lJmLZL dd1lJmMZM dd2lJmNZN dd3lJmOZO dd4lPmQZQ dd5lPmRZR dd6lSmTZT dd7lSmUZU dd8lSmVZV dd9lSmWZW dd:lSmXZX dd;lYmZZZ dd<lYm[Z[ dd=l\m]Z] ddl\m.Z. ej^r,dd>l_m`Z` dd?lambZb dd@lamcZc ejddAe2jedBZfejddCe2jgdBZhejddDe2jidBZjejddEe2jkdBZlejddFe2jmdBZndGdHdIdJdKZoG dLdM dMeNZpdS )Né )Ú annotationsN)ÚIterator)Ú timedelta)Úiscoroutinefunction)Úchain)Ú TracebackType)Úquote)ÚHeaders)Ú ImmutableDict)ÚAborter)Ú
|
BadRequest)ÚBadRequestKeyError)Ú HTTPException)ÚInternalServerError)Ú
|
BuildError)ÚMap)Ú
|
MapAdapter)ÚRequestRedirect)ÚRoutingException)ÚRule)Úis_running_from_reloader)Úcached_property)Úredirect)ÚResponseé )Úcli)Útyping)ÚConfig)ÚConfigAttribute)Ú_AppCtxGlobals©Ú
|
AppContext©ÚRequestContext)Ú_cv_app)Ú _cv_request)Úg)Úrequest)Ú request_ctx)Úsession)Ú_split_blueprint_path)Úget_debug_flag)Úget_flashed_messages)Úget_load_dotenv)ÚDefaultJSONProvider)Ú JSONProvider©Ú create_logger)Ú_endpoint_from_view_func)Ú _sentinel)Ú find_package)ÚScaffold)Ú setupmethod)Ú SecureCookieSessionInterface)ÚSessionInterface)Úappcontext_tearing_down)Úgot_request_exception)Úrequest_finished)Úrequest_started)Úrequest_tearing_down©ÚDispatchingJinjaLoader)Ú Environment)ÚRequest)Ú Blueprint©Ú FlaskClient©ÚFlaskCliRunnerÚT_shell_context_processor)ÚboundÚ
|
T_teardownÚT_template_filterÚT_template_globalÚT_template_testztimedelta | int | Noneztimedelta | None©ÚvalueÚreturnc C s | d kst | tr| S t| dS )N)Úseconds)Ú
|
isinstancer )rN © rR ú@d:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\flask/app.pyÚ_make_timedeltaU s rT c s* e Zd ZU dZeZeZeZ e
|
Z e Z eZedZedZededZeZded< i Zded < ed
|
d d
|
d
|
ed d d d
|
ddd
|
d
|
dd d
|
dd
|
d
|
d
|
d d dd
|
ddZe Z e Z d
|
Z ded< d
|
Z!ded< e" Z#ded< dèd d d d d d d d d d d
|
fd!d" Z$d d#d$d%d&Z%e&d d'd(d)Z'e&d*d'd+d,Z(e&d-d'd.d/Z)e*d d'd0d1Z+déd d2d3d4d5Z,d6d'd7d8Z-d d'd9d:Z.dêd d d<d=d>d?Z/d-d'd@dAZ0dBd'dCdDZ1d d dEdFdGZ2dd#dHdIdJZ3dd'dKdLZ4e*d d'dMdNZ5e5j6d d#dOdPdNZ5dëd dQdRd dSd#dTdUdVZ7dìd dSdWdXdYdZZ8dSd[d\d]d^Z9e:d_dSd#d`dadbZ;dcd'dddeZ<e:díd d dfdRdSd#dgdhdiZ=e:dîd djdkdldmZ>e:dïdnd d#dodpdqZ?e:dðd drdkdsdtZ@e:dñdud d#dodvdwZAe:dòd dxdkdydzZBe:dód{d d#dod|d}ZCe:d~d~dddZDe:dddddZEd
ddddZFdddddZGd
d dddZHd
ddddZId
ddddZJdd#dddZKdddddZLdd'dd ZMdd'd¡d¢ZNdôd£d dd¤d¥d¦ZOdd'd§d¨ZPd©d dªd«d¬ZQddd®d¯d°ZRd±d²d®d³d´ZSd
|
d
|
d
|
d
|
dµd d d d dRdSd d¶d·d¸ZTdõd dºd»d¼d½d¾ZUddd¿dÀdÁZVdÂdÃddÄdÅZWd dd#dÆdÇdÈZXdÉd dÊd dËdÌdÍZYdÎd'dÏdÐZZdddÑdÒdÓZ[e\fd©d#dÔdÕdÖZ]e\fd©d#dÔd×dØZ^dÙd'dÚdÛZ_ddÜdÝdÞdßZ`dSdSdÜdàdádâZadddSdãdädåZbdddSdãdædçZc ZdS )öÚFlaskaÒ The flask object implements a WSGI application and acts as the central
|
object. It is passed the name of the module or package of the
|
application. Once it is created it will act as a central registry for
|
the view functions, the URL rules, template configuration and much more.
|
|
The name of the package is used to resolve resources from inside the
|
package or the folder the module is contained in depending on if the
|
package parameter resolves to an actual python package (a folder with
|
an :file:`__init__.py` file inside) or a standard module (just a ``.py`` file).
|
|
For more information about resource loading, see :func:`open_resource`.
|
|
Usually you create a :class:`Flask` instance in your main module or
|
in the :file:`__init__.py` file of your package like this::
|
|
from flask import Flask
|
app = Flask(__name__)
|
|
.. admonition:: About the First Parameter
|
|
The idea of the first parameter is to give Flask an idea of what
|
belongs to your application. This name is used to find resources
|
on the filesystem, can be used by extensions to improve debugging
|
information and a lot more.
|
|
So it's important what you provide there. If you are using a single
|
module, `__name__` is always the correct value. If you however are
|
using a package, it's usually recommended to hardcode the name of
|
your package there.
|
|
For example if your application is defined in :file:`yourapplication/app.py`
|
you should create it with one of the two versions below::
|
|
app = Flask('yourapplication')
|
app = Flask(__name__.split('.')[0])
|
|
Why is that? The application will work even with `__name__`, thanks
|
to how resources are looked up. However it will make debugging more
|
painful. Certain extensions can make assumptions based on the
|
import name of your application. For example the Flask-SQLAlchemy
|
extension will look for the code in your application that triggered
|
an SQL query in debug mode. If the import name is not properly set
|
up, that debugging information is lost. (For example it would only
|
pick up SQL queries in `yourapplication.app` and not
|
`yourapplication.views.frontend`)
|
|
.. versionadded:: 0.7
|
The `static_url_path`, `static_folder`, and `template_folder`
|
parameters were added.
|
|
.. versionadded:: 0.8
|
The `instance_path` and `instance_relative_config` parameters were
|
added.
|
|
.. versionadded:: 0.11
|
The `root_path` parameter was added.
|
|
.. versionadded:: 1.0
|
The ``host_matching`` and ``static_host`` parameters were added.
|
|
.. versionadded:: 1.0
|
The ``subdomain_matching`` parameter was added. Subdomain
|
matching needs to be enabled manually now. Setting
|
:data:`SERVER_NAME` does not implicitly enable it.
|
|
:param import_name: the name of the application package
|
:param static_url_path: can be used to specify a different path for the
|
static files on the web. Defaults to the name
|
of the `static_folder` folder.
|
:param static_folder: The folder with static files that is served at
|
``static_url_path``. Relative to the application ``root_path``
|
or an absolute path. Defaults to ``'static'``.
|
:param static_host: the host to use when adding the static route.
|
Defaults to None. Required when using ``host_matching=True``
|
with a ``static_folder`` configured.
|
:param host_matching: set ``url_map.host_matching`` attribute.
|
Defaults to False.
|
:param subdomain_matching: consider the subdomain relative to
|
:data:`SERVER_NAME` when matching routes. Defaults to False.
|
:param template_folder: the folder that contains the templates that should
|
be used by the application. Defaults to
|
``'templates'`` folder in the root path of the
|
application.
|
:param instance_path: An alternative instance path for the application.
|
By default the folder ``'instance'`` next to the
|
package or module is assumed to be the instance
|
path.
|
:param instance_relative_config: if set to ``True`` relative filenames
|
for loading the config are assumed to
|
be relative to the instance path instead
|
of the application root.
|
:param root_path: The path to the root of the application files.
|
This should only be set manually when it can't be detected
|
automatically, such as for namespace packages.
|
ÚTESTINGÚ
|
SECRET_KEYÚPERMANENT_SESSION_LIFETIME)Z get_converterztype[JSONProvider]Újson_provider_classÚdictÚ jinja_optionsNFé )Údaysú/r) TÚhttpiý )ÚDEBUGrV ÚPROPAGATE_EXCEPTIONSrW rX ZUSE_X_SENDFILEÚ SERVER_NAMEÚAPPLICATION_ROOTZSESSION_COOKIE_NAMEZSESSION_COOKIE_DOMAINZSESSION_COOKIE_PATHZSESSION_COOKIE_HTTPONLYZSESSION_COOKIE_SECUREZSESSION_COOKIE_SAMESITEZ SESSION_REFRESH_EACH_REQUESTZMAX_CONTENT_LENGTHZSEND_FILE_MAX_AGE_DEFAULTÚTRAP_BAD_REQUEST_ERRORSÚTRAP_HTTP_EXCEPTIONSZEXPLAIN_TEMPLATE_LOADINGÚPREFERRED_URL_SCHEMEÚTEMPLATES_AUTO_RELOADZMAX_COOKIE_SIZEztype[FlaskClient] | NoneÚtest_client_classztype[FlaskCliRunner] | NoneÚtest_cli_runner_classr8 Úsession_interfaceÚstaticÚ templatesÚstrz
|
str | Nonezstr | os.PathLike | NoneÚbool)
|
Ú import_nameÚstatic_url_pathÚ static_folderÚ static_hostÚ host_matchingÚsubdomain_matchingÚtemplate_folderÚ instance_pathÚinstance_relative_configÚ root_pathc sô t j|||||
|
d |d kr(| ¡ }ntj |¡s<td|| _| | ¡| _ |
|
¡ | _ | | ¡| _ g | _g | _g | _i | _i | _| ¡ | _|| j_|| _d| _| jræt||ksºtdt | ¡ | j | j dd| fddd | j | j _ d S )
|
N)ro rq rp ru rx zWIf an instance path is provided it must be absolute. A relative path was given instead.Fz-Invalid static_host/host_matching combinationz/<path:filename>rk c s j f | S ©N)Zsend_static_file)Úkw©Zself_refrR rS Ú<lambda>ö ó z Flask.__init__.<locals>.<lambda>)ÚendpointÚhostÚ view_func)!ÚsuperÚ__init__Úauto_find_instance_pathÚosÚpathÚisabsÚ
|
ValueErrorrv Ú make_configÚconfigÚ make_aborterZaborterrY ÚjsonÚurl_build_error_handlersÚteardown_appcontext_funcsÚshell_context_processorsÚ
|
blueprintsÚ
|
extensionsÚ url_map_classÚurl_maprs rt Ú_got_first_requestZhas_static_folderrn ÚAssertionErrorÚweakrefÚrefÚ add_url_rulerp Únamer ) Úselfro rp rq rr rs rt ru rv rw rx ©Ú __class__r{ rS r b sP û
|
ÿ
|
þ
|
|
|
ÿþ
|
|
|
ü zFlask.__init__ÚNone)Úf_namerO c C s | j rtd| dd S )NzThe setup method 'zõ' can no longer be called on the application. It has already handled its first request, any changes will not be applied consistently.
|
Make sure all imports, decorators, functions, etc. needed to set up the application are done before running it.)r r )r r rR rR rS Ú_check_setup_finishedý s
|
ÿzFlask._check_setup_finished)rO c C sF | j dkr@ttjd dd}|dkr(dS tj tj |¡¡d S | j S )a_ The name of the application. This is usually the import name
|
with the difference that it's guessed from the run file if the
|
import name is main. This name is used as a display name when
|
Flask needs the name of the application. It can be set and overridden
|
to change the value.
|
|
.. versionadded:: 0.8
|
Ú__main__Ú__file__Nr )ro ÚgetattrÚsysÚmodulesr r
ÚsplitextÚbasename)r ÚfnrR rR rS r s
|
|
z
|
Flask.namezlogging.Loggerc C s t | S )a» A standard Python :class:`~logging.Logger` for the app, with
|
the same name as :attr:`name`.
|
|
In debug mode, the logger's :attr:`~logging.Logger.level` will
|
be set to :data:`~logging.DEBUG`.
|
|
If there are no handlers configured, a default handler will be
|
added. See :doc:`/logging` for more information.
|
|
.. versionchanged:: 1.1.0
|
The logger takes the same name as :attr:`name` rather than
|
hard-coding ``"flask.app"``.
|
|
.. versionchanged:: 1.0.0
|
Behavior was simplified. The logger is always named
|
``"flask.app"``. The level is only set during configuration,
|
it doesn't check ``app.debug`` each time. Only one format is
|
used, not different ones depending on ``app.debug``. No
|
handlers are removed, and a handler is only added if no
|
handlers are already configured.
|
|
.. versionadded:: 0.3
|
r0 ©r rR rR rS Úlogger s z Flask.loggerr@ c C s | ¡ S )zÓThe Jinja environment used to load templates.
|
|
The environment is created the first time this property is
|
accessed. Changing :attr:`jinja_options` after that will have no
|
effect.
|
)Úcreate_jinja_environmentr§ rR rR rS Ú jinja_env5 s zFlask.jinja_envc C s ddl }|jdtdd | jS )zÏThis attribute is set to ``True`` if the application started
|
handling the first request.
|
|
.. deprecated:: 2.3
|
Will be removed in Flask 2.4.
|
|
.. versionadded:: 0.8
|
r NzC'got_first_request' is deprecated and will be removed in Flask 2.4.é )Ú
|
stacklevel)ÚwarningsÚwarnÚDeprecationWarningr )r r rR rR rS Úgot_first_request? s
|
ýzFlask.got_first_requestr )Úinstance_relativerO c C s0 | j }|r| j}t| j}t |d< | ||¡S )ad Used to create the config attribute by the Flask constructor.
|
The `instance_relative` parameter is passed in from the constructor
|
of Flask (there named `instance_relative_config`) and indicates if
|
the config should be relative to the instance path or the root path
|
of the application.
|
|
.. versionadded:: 0.8
|
r` )rx rv rZ Údefault_configr+ Ú config_class)r r± rx ÚdefaultsrR rR rS r R s
|
|
zFlask.make_configr c C s | ¡ S )aV Create the object to assign to :attr:`aborter`. That object
|
is called by :func:`flask.abort` to raise HTTP errors, and can
|
be called directly as well.
|
|
By default, this creates an instance of :attr:`aborter_class`,
|
which defaults to :class:`werkzeug.exceptions.Aborter`.
|
|
.. versionadded:: 2.2
|
)Ú aborter_classr§ rR rR rS r b s
|
zFlask.make_aborterc C s< t | j\}}|dkr$tj |d¡S tj |d| j d¡S )a Tries to locate the instance path if it was not provided to the
|
constructor of the application class. It will basically calculate
|
the path to a folder named ``instance`` next to your main file or
|
the package.
|
|
.. versionadded:: 0.8
|
NÚinstanceÚvarz -instance)r4 ro r r
Újoinr )r ÚprefixÚ package_pathrR rR rS r n s z Flask.auto_find_instance_pathÚrbzt.IO[t.AnyStr])ÚresourceÚmoderO c C s t tj | j|¡|S )aª Opens a resource from the application's instance folder
|
(:attr:`instance_path`). Otherwise works like
|
:meth:`open_resource`. Instance resources can also be opened for
|
writing.
|
|
:param resource: the name of the resource. To access resources within
|
subfolders use forward slashes as separator.
|
:param mode: resource file opening mode, default is 'rb'.
|
)Úopenr r
r¸ rv )r r¼ r½ rR rR rS Úopen_instance_resource{ s
|
z Flask.open_instance_resourcec C s t | j}d|kr | j|d< d|krD| jd }|dkr<| j}||d< | j| f|}|jj| jt | jt
|
t t d | j j|jd< |S )aÇ Create the Jinja environment based on :attr:`jinja_options`
|
and the various Jinja-related methods of the app. Changing
|
:attr:`jinja_options` after this will have no effect. Also adds
|
Flask-related globals and filters to the environment.
|
|
.. versionchanged:: 0.11
|
``Environment.auto_reload`` set in accordance with
|
``TEMPLATES_AUTO_RELOAD`` configuration option.
|
|
.. versionadded:: 0.5
|
Z
|
autoescapeÚ auto_reloadrg N)Úurl_forr, r r' r) r& zjson.dumps_function)rZ r[ Úselect_jinja_autoescaper ÚdebugÚjinja_environmentÚglobalsÚupdaterÁ r, r' r) r& r ÚdumpsZpolicies)r ÚoptionsrÀ ÚrvrR rR rS r© s&
|
|
|
÷ z Flask.create_jinja_environmentr? c C s t | S )a Creates the loader for the Jinja2 environment. Can be used to
|
override just the loader and keeping the rest unchanged. It's
|
discouraged to override this function. Instead one should override
|
the :meth:`jinja_loader` function instead.
|
|
The global loader dispatches between the loaders of the application
|
and the individual blueprints.
|
|
.. versionadded:: 0.7
|
r> r§ rR rR rS Úcreate_global_jinja_loader¯ s z Flask.create_global_jinja_loader)ÚfilenamerO c C s |dkr dS | d¡S )a Returns ``True`` if autoescaping should be active for the given
|
template name. If no template name is given, returns `True`.
|
|
.. versionchanged:: 2.2
|
Autoescaping is now enabled by default for ``.svg`` files.
|
|
.. versionadded:: 0.5
|
NT)z.htmlz.htmz.xmlz.xhtmlz.svg)Úendswith)r rË rR rR rS r ¼ s z Flask.select_jinja_autoescape)ÚcontextrO c C s^ d}t rt|tt j}| ¡ }|D ]*}|| jkr$| j| D ]}| | ¡ q<q$| |¡ dS )a Update the template context with some commonly used variables.
|
This injects request, session, config and g into the template
|
context as well as everything template context processors want
|
to inject. Note that the as of Flask 0.6, the original values
|
in the context will not be overridden if a context processor
|
decides to return a value with the same key.
|
|
:param context: the context as a dictionary that is updated in place
|
to add extra variables.
|
ry N)r' r Úreversedr ÚcopyZtemplate_context_processorsrÆ )r rÍ ÚnamesZorig_ctxr ÚfuncrR rR rS Úupdate_template_contextÉ s
|
z Flask.update_template_contextc C s& | t d}| jD ]}| | ¡ q|S )z¹Returns the shell context for an interactive shell for this
|
application. This runs all the registered shell context
|
processors.
|
|
.. versionadded:: 0.11
|
)Zappr& )r& r rÆ )r rÉ Ú processorrR rR rS Úmake_shell_contextå s
|
|
zFlask.make_shell_contextc C s
|
| j d S )a¢ Whether debug mode is enabled. When using ``flask run`` to start the
|
development server, an interactive debugger will be shown for unhandled
|
exceptions, and the server will be reloaded when code changes. This maps to the
|
:data:`DEBUG` config key. It may not behave as expected if set late.
|
|
**Do not enable debug mode when deploying in production.**
|
|
Default: ``False``
|
r` )r r§ rR rR rS rà ñ s z Flask.debugrM c C s$ || j d< | j d d kr || j_d S )Nr` rg )r rª rÀ )r rN rR rR rS rà þ s
|
z
|
int | Nonez bool | Nonezt.Any)r ÚportrÃ Ú load_dotenvrÈ rO c K s, t j d¡dkr(t s$tjddd dS t|rJt ¡ dt jkrJt | _
|
|dk r\t || _
|
| j d¡}d }}|r| d ¡\}} }|s|r|}nd
|
}|s¢|d kr¬t|}n|rºt|}nd }| d | j
|
¡ | d| j
|
¡ | dd¡ t | j
|
| j¡ d dlm}
|
z |
|
t t|¡|| f| W 5 d| _X dS )a×
|
Runs the application on a local development server.
|
|
Do not use ``run()`` in a production setting. It is not intended to
|
meet security and performance requirements for a production server.
|
Instead, see :doc:`/deploying/index` for WSGI server recommendations.
|
|
If the :attr:`debug` flag is set the server will automatically reload
|
for code changes and show a debugger in case an exception happened.
|
|
If you want to run the application in debug mode, but disable the
|
code execution on the interactive debugger, you can pass
|
``use_evalex=False`` as parameter. This will keep the debugger's
|
traceback screen active, but disable code execution.
|
|
It is not recommended to use this function for development with
|
automatic reloading as this is badly supported. Instead you should
|
be using the :command:`flask` command line script's ``run`` support.
|
|
.. admonition:: Keep in Mind
|
|
Flask will suppress any server error with a generic error page
|
unless it is in debug mode. As such to enable just the
|
interactive debugger without the code reloading, you have to
|
invoke :meth:`run` with ``debug=True`` and ``use_reloader=False``.
|
Setting ``use_debugger`` to ``True`` without being in debug mode
|
won't catch any exceptions because there won't be any to
|
catch.
|
|
:param host: the hostname to listen on. Set this to ``'0.0.0.0'`` to
|
have the server available externally as well. Defaults to
|
``'127.0.0.1'`` or the host in the ``SERVER_NAME`` config variable
|
if present.
|
:param port: the port of the webserver. Defaults to ``5000`` or the
|
port defined in the ``SERVER_NAME`` config variable if present.
|
:param debug: if given, enable or disable debug mode. See
|
:attr:`debug`.
|
:param load_dotenv: Load the nearest :file:`.env` and :file:`.flaskenv`
|
files to set environment variables. Will also change the working
|
directory to the directory containing the first file found.
|
:param options: the options to be forwarded to the underlying Werkzeug
|
server. See :func:`werkzeug.serving.run_simple` for more
|
information.
|
|
.. versionchanged:: 1.0
|
If installed, python-dotenv will be used to load environment
|
variables from :file:`.env` and :file:`.flaskenv` files.
|
|
The :envvar:`FLASK_DEBUG` environment variable will override :attr:`debug`.
|
|
Threaded mode is enabled by default.
|
|
.. versionchanged:: 0.10
|
The default port is now picked from the ``SERVER_NAME``
|
variable.
|
ZFLASK_RUN_FROM_CLIÚtruez * Ignoring a call to 'app.run()' that would block the current 'flask' CLI command.
|
Only call 'app.run()' in an 'if __name__ == "__main__"' guard.Úred)ZfgNZ FLASK_DEBUGrb ú:z 127.0.0.1r i Z use_reloaderZ use_debuggerZthreadedT)Ú
|
run_simpleF)r ÚenvironÚgetr ÚclickZsechor- r rÖ r+ rà rn r Ú partitionÚintÚ
|
setdefaultZshow_server_bannerr Úwerkzeug.servingrÚ r ÚtÚcastrm ) r r rÕ rà rÖ rÈ Ú server_nameZsn_hostZsn_portÚ_rÚ rR rR rS Úrun sD Aû
|
|
|
|
z Flask.runrD )Ú use_cookiesÚkwargsrO c K s2 | j }|dkrddlm} || | jfd|i|S )a Creates a test client for this application. For information
|
about unit testing head over to :doc:`/testing`.
|
|
Note that if you are testing for assertions or exceptions in your
|
application code, you must set ``app.testing = True`` in order for the
|
exceptions to propagate to the test client. Otherwise, the exception
|
will be handled by the application (not visible to the test client) and
|
the only indication of an AssertionError or other exception will be a
|
500 status code response to the test client. See the :attr:`testing`
|
attribute. For example::
|
|
app.testing = True
|
client = app.test_client()
|
|
The test client can be used in a ``with`` block to defer the closing down
|
of the context until the end of the ``with`` block. This is useful if
|
you want to access the context locals for testing::
|
|
with app.test_client() as c:
|
rv = c.get('/?vodka=42')
|
assert request.args['vodka'] == '42'
|
|
Additionally, you may pass optional keyword arguments that will then
|
be passed to the application's :attr:`test_client_class` constructor.
|
For example::
|
|
from flask.testing import FlaskClient
|
|
class CustomClient(FlaskClient):
|
def __init__(self, *args, **kwargs):
|
self._authentication = kwargs.pop("authentication")
|
super(CustomClient,self).__init__( *args, **kwargs)
|
|
app.test_client_class = CustomClient
|
client = app.test_client(authentication='Basic ....')
|
|
See :class:`~flask.testing.FlaskClient` for more information.
|
|
.. versionchanged:: 0.4
|
added support for ``with`` block usage for the client.
|
|
.. versionadded:: 0.7
|
The `use_cookies` parameter was added as well as the ability
|
to override the client to be used by setting the
|
:attr:`test_client_class` attribute.
|
|
.. versionchanged:: 0.11
|
Added `**kwargs` to support passing additional keyword arguments to
|
the constructor of :attr:`test_client_class`.
|
Nr rC rç )rh ÚtestingrD Úresponse_class)r rç rè ÚclsrR rR rS Ú test_client s 3 ÿÿÿzFlask.test_clientrF )rè rO c K s& | j }|dkrddlm} || f|S )a- Create a CLI runner for testing CLI commands.
|
See :ref:`testing-cli`.
|
|
Returns an instance of :attr:`test_cli_runner_class`, by default
|
:class:`~flask.testing.FlaskCliRunner`. The Flask app object is
|
passed as the first argument.
|
|
.. versionadded:: 1.0
|
Nr rE )ri ré rF )r rè rë rR rR rS Útest_cli_runnerº s
|
zFlask.test_cli_runnerrB )Ú blueprintrÈ rO c K s | | |¡ dS )ax Register a :class:`~flask.Blueprint` on the application. Keyword
|
arguments passed to this method will override the defaults set on the
|
blueprint.
|
|
Calls the blueprint's :meth:`~flask.Blueprint.register` method after
|
recording the blueprint in the application's :attr:`blueprints`.
|
|
:param blueprint: The blueprint to register.
|
:param url_prefix: Blueprint routes will be prefixed with this.
|
:param subdomain: Blueprint routes will match on this subdomain.
|
:param url_defaults: Blueprint routes will use these default values for
|
view arguments.
|
:param options: Additional keyword arguments are passed to
|
:class:`~flask.blueprints.BlueprintSetupState`. They can be
|
accessed in :meth:`~flask.Blueprint.record` callbacks.
|
|
.. versionchanged:: 2.0.1
|
The ``name`` option can be used to change the (pre-dotted)
|
name the blueprint is registered with. This allows the same
|
blueprint to be registered multiple times with unique names
|
for ``url_for``.
|
|
.. versionadded:: 0.7
|
N)Úregister)r rî rÈ rR rR rS Úregister_blueprintË s zFlask.register_blueprintzt.ValuesView[Blueprint]c C s
|
| j ¡ S )zhIterates over all blueprints by the order they were registered.
|
|
.. versionadded:: 0.11
|
)r Úvaluesr§ rR rR rS Úiter_blueprintsç s zFlask.iter_blueprintszft.RouteCallable | None)Úruler~ r Úprovide_automatic_optionsrÈ rO c K s |d krt |}||d< | dd ¡}|d kr<t|dd p:d}t|trNtddd |D }tt|dd}|d krt|d d }|d kr¤d
|
|kr d }| d
|
¡ nd }||O }| j|fd|i|}||_ | j
|
|¡ |d k r| j |¡}|d k r ||kr t d | || j |< d S )Nr~ Úmethods)ÚGETzYAllowed methods must be a list of strings, for example: @app.route(..., methods=["POST"])c S s h | ] }| ¡ qS rR )Úupper)Ú.0ÚitemrR rR rS Ú <setcomp> s z%Flask.add_url_rule.<locals>.<setcomp>Úrequired_methodsrR rô ÚOPTIONSTFzDView function mapping is overwriting an existing endpoint function: )r2 Úpopr¡ rQ rm Ú TypeErrorÚsetÚaddÚurl_rule_classrô r Úview_functionsrÜ r ) r ró r~ r rô rÈ rõ rû Zold_funcrR rR rS r î sD
|
ÿ ÿ
|
ÿzFlask.add_url_rulez2t.Callable[[T_template_filter], T_template_filter])r rO c s ddd fdd }|S )a A decorator that is used to register custom template filter.
|
You can specify a name for the filter, otherwise the function
|
name will be used. Example::
|
|
@app.template_filter()
|
def reverse(s):
|
return s[::-1]
|
|
:param name: the optional name of the filter, otherwise the
|
function name will be used.
|
rJ ©ÚfrO c s j | d | S ©N)r )Úadd_template_filter©r ©r r rR rS Ú decorator9 s z(Flask.template_filter.<locals>.decoratorrR ©r r r rR r rS Útemplate_filter) s zFlask.template_filterzft.TemplateFilterCallable)r r rO c C s || j j|p|j< dS )zäRegister a custom template filter. Works exactly like the
|
:meth:`template_filter` decorator.
|
|
:param name: the optional name of the filter, otherwise the
|
function name will be used.
|
N)rª ÚfiltersÚ__name__©r r r rR rR rS r ? s
|
zFlask.add_template_filterz.t.Callable[[T_template_test], T_template_test]c s ddd fdd }|S )aS A decorator that is used to register custom template test.
|
You can specify a name for the test, otherwise the function
|
name will be used. Example::
|
|
@app.template_test()
|
def is_prime(n):
|
if n == 2:
|
return True
|
for i in range(2, int(math.ceil(math.sqrt(n))) + 1):
|
if n % i == 0:
|
return False
|
return True
|
|
.. versionadded:: 0.10
|
|
:param name: the optional name of the test, otherwise the
|
function name will be used.
|
rL r c s j | d | S r )Úadd_template_testr r rR rS r b s z&Flask.template_test.<locals>.decoratorrR r
|
rR r rS Ú template_testK s zFlask.template_testzft.TemplateTestCallablec C s || j j|p|j< dS )zþRegister a custom template test. Works exactly like the
|
:meth:`template_test` decorator.
|
|
.. versionadded:: 0.10
|
|
:param name: the optional name of the test, otherwise the
|
function name will be used.
|
N)rª Útestsr r rR rR rS r h s zFlask.add_template_testz2t.Callable[[T_template_global], T_template_global]c s ddd fdd }|S )a¿ A decorator that is used to register a custom template global function.
|
You can specify a name for the global function, otherwise the function
|
name will be used. Example::
|
|
@app.template_global()
|
def double(n):
|
return 2 * n
|
|
.. versionadded:: 0.10
|
|
:param name: the optional name of the global function, otherwise the
|
function name will be used.
|
rK r c s j | d | S r )Úadd_template_globalr r rR rS r s z(Flask.template_global.<locals>.decoratorrR r
|
rR r rS Útemplate_globalv s zFlask.template_globalzft.TemplateGlobalCallablec C s || j j|p|j< dS )a Register a custom template global function. Works exactly like the
|
:meth:`template_global` decorator.
|
|
.. versionadded:: 0.10
|
|
:param name: the optional name of the global function, otherwise the
|
function name will be used.
|
N)rª rÅ r r rR rR rS r s zFlask.add_template_globalrI r c C s | j |¡ |S )a¨ Registers a function to be called when the application
|
context is popped. The application context is typically popped
|
after the request context for each request, at the end of CLI
|
commands, or after a manually pushed context ends.
|
|
.. code-block:: python
|
|
with app.app_context():
|
...
|
|
When the ``with`` block exits (or ``ctx.pop()`` is called), the
|
teardown functions are called just before the app context is
|
made inactive. Since a request context typically also manages an
|
application context it would also be called when you pop a
|
request context.
|
|
When a teardown function was called because of an unhandled
|
exception it will be passed an error object. If an
|
:meth:`errorhandler` is registered, it will handle the exception
|
and the teardown will not receive it.
|
|
Teardown functions must avoid raising exceptions. If they
|
execute code that might fail they must surround that code with a
|
``try``/``except`` block and log any errors.
|
|
The return values of teardown functions are ignored.
|
|
.. versionadded:: 0.9
|
)r Úappend©r r rR rR rS Úteardown_appcontext s zFlask.teardown_appcontextrG c C s | j |¡ |S )zVRegisters a shell context processor function.
|
|
.. versionadded:: 0.11
|
)r r r rR rR rS Úshell_context_processor¾ s z Flask.shell_context_processorÚ Exceptionz ft.ErrorHandlerCallable | None)ÚerO c
|
C s | t|¡\}}tjd}|dk r,|dfndD ]P}|D ]F}| j| | }|sPq8|jD ]&}| |¡} | dk rV| S qVq8q0dS )a( Return a registered error handler for an exception in this order:
|
blueprint handler for a specific code, app handler for a specific code,
|
blueprint handler for an exception class, app handler for an exception
|
class, or ``None`` if a suitable handler is not found.
|
Nry )N)Z_get_exc_class_and_codeÚtyper' r Zerror_handler_specÚ__mro__rÜ )
|
r r Ú exc_classÚcoderÐ Úcr Z handler_maprë ÚhandlerrR rR rS Ú_find_error_handlerÉ s
|
|
|
zFlask._find_error_handlerr z&HTTPException | ft.ResponseReturnValuec C s@ |j dkr|S t|tr |S | |¡}|dkr2|S | |¡|S )ac Handles an HTTP exception. By default this will invoke the
|
registered error handlers and fall back to returning the
|
exception as response.
|
|
.. versionchanged:: 1.0.3
|
``RoutingException``, used internally for actions such as
|
slash redirects during routing, is not passed to error
|
handlers.
|
|
.. versionchanged:: 1.0
|
Exceptions are looked up by code *and* by MRO, so
|
``HTTPException`` subclasses can be handled with a catch-all
|
handler for the base ``HTTPException``.
|
|
.. versionadded:: 0.3
|
N)r rQ r r Ú ensure_sync©r r r rR rR rS Úhandle_http_exceptionà s
|
|
|
zFlask.handle_http_exceptionc C sF | j d rdS | j d }|dkr4| jr4t|tr4dS |rBt|tS dS )aù Checks if an HTTP exception should be trapped or not. By default
|
this will return ``False`` for all exceptions except for a bad request
|
key error if ``TRAP_BAD_REQUEST_ERRORS`` is set to ``True``. It
|
also returns ``True`` if ``TRAP_HTTP_EXCEPTIONS`` is set to ``True``.
|
|
This is called for all HTTP exceptions raised by a view function.
|
If it returns ``True`` for any exception the error handler for this
|
exception is not called and it shows up as regular exception in the
|
traceback. This is helpful for debugging implicitly raised HTTP
|
exceptions.
|
|
.. versionchanged:: 1.0
|
Bad request errors are not trapped by default in debug mode.
|
|
.. versionadded:: 0.8
|
re Trd NF)r rà rQ r r )r r Ztrap_bad_requestrR rR rS Útrap_http_exception s
|
|
ÿþý
|
zFlask.trap_http_exceptionc C s` t |tr | js| jd r d|_t |tr>| |¡s>| |¡S | |¡}|dkrR | |¡|S )a> This method is called whenever an exception occurs that
|
should be handled. A special case is :class:`~werkzeug
|
.exceptions.HTTPException` which is forwarded to the
|
:meth:`handle_http_exception` method. This function will either
|
return a response value or reraise the exception with the same
|
traceback.
|
|
.. versionchanged:: 1.0
|
Key errors raised from request data like ``form`` show the
|
bad key in debug mode rather than a generic bad request
|
message.
|
|
.. versionadded:: 0.7
|
rd TN)
|
rQ r rà r Zshow_exceptionr r$ r# r r! r" rR rR rS Úhandle_user_exception& s
|
ÿÿ
|
|
zFlask.handle_user_exceptionr c C s t ¡ }tj| | j|d | jd }|dkr8| jp6| j}|rN|d |krJ || |¡ t |d}|
|
|¡}|dk r| |¡|}| j |ddS )a½ Handle an exception that did not have an error handler
|
associated with it, or that was raised from an error handler.
|
This always causes a 500 ``InternalServerError``.
|
|
Always sends the :data:`got_request_exception` signal.
|
|
If :data:`PROPAGATE_EXCEPTIONS` is ``True``, such as in debug
|
mode, the error will be re-raised so that the debugger can
|
display it. Otherwise, the original exception is logged, and
|
an :exc:`~werkzeug.exceptions.InternalServerError` is returned.
|
|
If an error handler is registered for ``InternalServerError`` or
|
``500``, it will be used. For consistency, the handler will
|
always receive the ``InternalServerError``. The original
|
unhandled exception is available as ``e.original_exception``.
|
|
.. versionchanged:: 1.1.0
|
Always passes the ``InternalServerError`` instance to the
|
handler, setting ``original_exception`` to the unhandled
|
error.
|
|
.. versionchanged:: 1.1.0
|
``after_request`` functions and other finalization is done
|
even for the default 500 response when there is no handler.
|
|
.. versionadded:: 0.3
|
)Ú_async_wrapperÚ exceptionra Nr )Zoriginal_exceptionT)Úfrom_error_handler) r¢ Úexc_infor: Úsendr! r ré rÃ Ú log_exceptionr r Úfinalize_request)r r r) Ú propagateÚ server_errorr rR rR rS Úhandle_exceptionF s
|
|
|
|
zFlask.handle_exceptionzEtuple[type, BaseException, TracebackType] | tuple[(None, None, None)])r) rO c C s& | j jdtj dtj d|d dS )a Logs an exception. This is called by :meth:`handle_exception`
|
if debugging is disabled and right before the handler is called.
|
The default implementation logs the exception as error on the
|
:attr:`logger`.
|
|
.. versionadded:: 0.8
|
z Exception on z [ú])r) N)r¨ Úerrorr' r
Úmethod)r r) rR rR rS r+ { s ÿzFlask.log_exceptionrA z
|
t.NoReturn)r' rO c C sF | j r(t|jtr(|jjdks(|jdkr.|jddlm} ||dS )a× Intercept routing exceptions and possibly do something else.
|
|
In debug mode, intercept a routing redirect and replace it with
|
an error if the body will be discarded.
|
|
With modern Werkzeug this shouldn't occur, since it now uses a
|
308 status which tells the browser to resend the method and
|
body.
|
|
.. versionchanged:: 2.1
|
Don't intercept 307 and 308 redirects.
|
|
:meta private:
|
:internal:
|
> é3 é4 > rö ÚHEADrü r )ÚFormDataRoutingRedirectN)rà rQ Úrouting_exceptionr r r2 Z debughelpersr6 )r r' r6 rR rR rS Úraise_routing_exception s ÿ
|
þ
|
ýü z Flask.raise_routing_exceptionzft.ResponseReturnValuec C s\ t j}|jdk r| |¡ |j}t|ddr>|jdkr>| ¡ S |j}| | j
|
|j ¡f |S )a· Does the request dispatching. Matches the URL and returns the
|
return value of the view or error handler. This does not have to
|
be a response object. In order to convert the return value to a
|
proper response object, call :func:`make_response`.
|
|
.. versionchanged:: 0.7
|
This no longer does the exception handling, this code was
|
moved to the new :meth:`full_dispatch_request`.
|
Nrô Frü ) r( r' r7 r8 Zurl_ruler¡ r2 Ú make_default_options_responseÚ view_argsr! r r~ )r Úreqró r: rR rR rS Údispatch_request¦ s
|
|
|
|
ÿþzFlask.dispatch_requestc
|
C sj d| _ z,tj| | jd | ¡ }|dkr0| ¡ }W n, tk
|
r^ } z| |¡}W 5 d}~X Y nX | |¡S )zÀDispatches the request and on top of that performs request
|
pre and postprocessing as well as HTTP exception catching and
|
error handling.
|
|
.. versionadded:: 0.7
|
T)r& N) r r< r* r! Úpreprocess_requestr< r r% r, )r rÉ r rR rR rS Úfull_dispatch_request¿ s zFlask.full_dispatch_requestz&ft.ResponseReturnValue | HTTPException)rÉ r( rO c C sV | |¡}z | |¡}tj| | j|d W n& tk
|
rP |s@ | j d¡ Y nX |S )a) Given the return value from a view function this finalizes
|
the request by converting it into a response and invoking the
|
postprocessing functions. This is invoked for both normal
|
request dispatching as well as error handlers.
|
|
Because this means that it might be called as a result of a
|
failure a special safe mode is available which can be enabled
|
with the `from_error_handler` flag. If enabled, failures in
|
response processing will be logged and otherwise ignored.
|
|
:internal:
|
)r& Úresponsez?Request finalizing failed with an error while handling an error)Ú make_responseÚprocess_responser; r* r! r r¨ r' )r rÉ r( r? rR rR rS r, Ñ s
|
|
ÿ
|
ÿ
|
zFlask.finalize_requestc C s& t j}| ¡ }| ¡ }|j |¡ |S )zÚThis method is called to create the default ``OPTIONS`` response.
|
This can be changed through subclassing to change the default
|
behavior of ``OPTIONS`` responses.
|
|
.. versionadded:: 0.7
|
)r( Ú url_adapterZallowed_methodsrê ZallowrÆ )r Úadapterrõ rÉ rR rR rS r9 ð s
|
z#Flask.make_default_options_responsezBaseException | None)r1 rO c C s dS )a
|
This is called to figure out if an error should be ignored
|
or not as far as the teardown system is concerned. If this
|
function returns ``True`` then the teardown handlers will not be
|
passed the error.
|
|
.. versionadded:: 0.10
|
FrR )r r1 rR rR rS Úshould_ignore_errorý s zFlask.should_ignore_errorz
|
t.Callable)rÑ rO c C s t |r| |¡S |S )a) Ensure that the function is synchronous for WSGI workers.
|
Plain ``def`` functions are returned as-is. ``async def``
|
functions are wrapped to run and wait for the response.
|
|
Override this method to change how the app runs async views.
|
|
.. versionadded:: 2.0
|
)r Ú async_to_sync)r rÑ rR rR rS r! s
|
zFlask.ensure_syncz t.Callable[..., t.Coroutine]zt.Callable[..., t.Any]c C s8 zddl m} W n tk
|
r. tddY nX ||S )a1 Return a sync function that will run the coroutine function.
|
|
.. code-block:: python
|
|
result = app.async_to_sync(func)(*args, **kwargs)
|
|
Override this method to change how the app converts async code
|
to be synchronously callable.
|
|
.. versionadded:: 2.0
|
r )rE zAInstall Flask with the 'async' extra in order to use async views.N)Z asgiref.syncrE Ú ImportErrorÚ RuntimeError)r rÑ Zasgiref_async_to_syncrR rR rS rE s ÿþzFlask.async_to_sync©Ú_anchorÚ_methodÚ_schemeÚ _external)r~ rI rJ rK rL rñ rO c
|
K sN t d¡}|dk rd|j}|jj} |dd
dkrR| dk rF| | }n |dd
}|dkr¤|dk }n@t d¡}
|
|
|
dk r~|
|
j}n
|
| d¡}|dkrtd|dkr¤d}|dk r¸|s¸td| ||¡ z|j
|
|||||d} W nH t k
|
r$ } z(|j ||||d | | ||¡ W Y ¢S d} ~ X Y nX |dk rJt|d d
|
}| d | } | S ) a Generate a URL to the given endpoint with the given values.
|
|
This is called by :func:`flask.url_for`, and can be called
|
directly as well.
|
|
An *endpoint* is the name of a URL rule, usually added with
|
:meth:`@app.route() <route>`, and usually the same name as the
|
view function. A route defined in a :class:`~flask.Blueprint`
|
will prepend the blueprint's name separated by a ``.`` to the
|
endpoint.
|
|
In some cases, such as email messages, you want URLs to include
|
the scheme and domain, like ``https://example.com/hello``. When
|
not in an active request, URLs will be external by default, but
|
this requires setting :data:`SERVER_NAME` so Flask knows what
|
domain to use. :data:`APPLICATION_ROOT` and
|
:data:`PREFERRED_URL_SCHEME` should also be configured as
|
needed. This config is only used when not in an active request.
|
|
Functions can be decorated with :meth:`url_defaults` to modify
|
keyword arguments before the URL is built.
|
|
If building fails for some reason, such as an unknown endpoint
|
or incorrect values, the app's :meth:`handle_url_build_error`
|
method is called. If that returns a string, that is returned,
|
otherwise a :exc:`~werkzeug.routing.BuildError` is raised.
|
|
:param endpoint: The endpoint name associated with the URL to
|
generate. If this starts with a ``.``, the current blueprint
|
name (if any) will be used.
|
:param _anchor: If given, append this as ``#anchor`` to the URL.
|
:param _method: If given, generate the URL associated with this
|
method for the endpoint.
|
:param _scheme: If given, the URL will have this scheme if it
|
is external.
|
:param _external: If given, prefer the URL to be internal
|
(False) or require it to be external (True). External URLs
|
include the scheme and domain. When not in an active
|
request, URLs are external by default.
|
:param values: Values to use for the variable parts of the URL
|
rule. Unknown keys are appended as query string arguments,
|
like ``?a=b&c=d``.
|
|
.. versionadded:: 2.2
|
Moved from ``flask.url_for``, which calls this method.
|
Nr Ú.zUnable to build URLs outside an active request without 'SERVER_NAME' configured. Also configure 'APPLICATION_ROOT' and 'PREFERRED_URL_SCHEME' as needed.Tz4When specifying '_scheme', '_external' must be True.)r2 Ú
|
url_schemeZforce_externalrH z%!#$&'()*+,/:;=?@)Úsafeú#)r% rÜ rB r' rî r$ Úcreate_url_adapterrG r Úinject_url_defaultsÚbuildr rÆ Úhandle_url_build_errorÚ
|
_url_quote) r r~ rI rJ rK rL rñ Zreq_ctxrB Zblueprint_nameZapp_ctxrÉ r1 rR rR rS rÁ , sV 8
|
|
|
|
ÿ û
|
ÿ$
|
z Flask.url_foré. rß Ú BaseResponse)Úlocationr rO c C s t ||| jdS )aV Create a redirect response object.
|
|
This is called by :func:`flask.redirect`, and can be called
|
directly as well.
|
|
:param location: The URL to redirect to.
|
:param code: The status code for the redirect.
|
|
.. versionadded:: 2.2
|
Moved from ``flask.redirect``, which calls this method.
|
)r r )Ú _wz_redirectrê )r rX r rR rR rS r © s zFlask.redirect)rÉ rO c
|
C s¼ d }}t |trht|}|dkr.|\}}}n:|dkr`t |d ttttfrV|\}}qh|\}}ntd|dkrtdtjdt || j spt |t
|
t t fsªt |t rÄ| j |||d}d }}n¬t |ttfrà| j |¡}nt |tsôt|rZz| j |tj¡}W nN tk
|
rV } z.t| d t|j d
|
t ¡ d ¡dW 5 d}~X Y nX ntd t|j d
|
t t|¡}|dk r¦t |t
|
t t fr ||_ n||_ |r¸|j |¡ |S ) a Convert the return value from a view function to an instance of
|
:attr:`response_class`.
|
|
:param rv: the return value from the view function. The view function
|
must return a response. Returning ``None``, or the view ending
|
without returning, is not allowed. The following types are allowed
|
for ``view_rv``:
|
|
``str``
|
A response object is created with the string encoded to UTF-8
|
as the body.
|
|
``bytes``
|
A response object is created with the bytes as the body.
|
|
``dict``
|
A dictionary that will be jsonify'd before being returned.
|
|
``list``
|
A list that will be jsonify'd before being returned.
|
|
``generator`` or ``iterator``
|
A generator that returns ``str`` or ``bytes`` to be
|
streamed as the response.
|
|
``tuple``
|
Either ``(body, status, headers)``, ``(body, status)``, or
|
``(body, headers)``, where ``body`` is any of the other types
|
allowed here, ``status`` is a string or an integer, and
|
``headers`` is a dictionary or a list of ``(key, value)``
|
tuples. If ``body`` is a :attr:`response_class` instance,
|
``status`` overwrites the exiting value and ``headers`` are
|
extended.
|
|
:attr:`response_class`
|
The object is returned unchanged.
|
|
other :class:`~werkzeug.wrappers.Response` class
|
The object is coerced to :attr:`response_class`.
|
|
:func:`callable`
|
The function is called as a WSGI application. The result is
|
used to create a response object.
|
|
.. versionchanged:: 2.2
|
A generator will be converted to a streaming response.
|
A list will be converted to a JSON response.
|
|
.. versionchanged:: 1.1
|
A dict will be converted to a JSON response.
|
|
.. versionchanged:: 0.9
|
Previously a tuple was interpreted as the arguments for the
|
response object.
|
Né r« r zThe view function did not return a valid response tuple. The tuple must have the form (body, status, headers), (body, status), or (body, headers).zThe view function for zh did not return a valid response. The function either returned None or ended without a return statement.)ÚstatusÚheadersz²
|
The view function did not return a valid response. The return type must be a string, dict, list, tuple with headers or status, Response instance, or WSGI callable, but it was a rM z±The view function did not return a valid response. The return type must be a string, dict, list, tuple with headers or status, Response instance, or WSGI callable, but it was a ) rQ ÚtupleÚlenr rZ Úlistrþ r' r~ rê rm ÚbytesÚ bytearrayÚ _abc_Iteratorr r? rW ÚcallableZ
|
force_typerÛ r r Úwith_tracebackr¢ r) râ rã r r[ Ú status_coder\ rÆ )r rÉ r[ r\ Zlen_rvr rR rR rS r@ · sf 9
|
|
|
ÿ ÿý
|
ÿÿ
|
úúÿ
|
zFlask.make_responsezRequest | NonezMapAdapter | Nonec C sp |dk r:| j s | jjpd}nd}| jj|j| jd |dS | jd dk rl| jj| jd | jd | jd dS dS )a* Creates a URL adapter for the given request. The URL adapter
|
is created at a point where the request context is not yet set
|
up so the request is passed explicitly.
|
|
.. versionadded:: 0.6
|
|
.. versionchanged:: 0.9
|
This can now also be called without a request object when the
|
URL adapter is created for the application context.
|
|
.. versionchanged:: 1.0
|
:data:`SERVER_NAME` no longer implicitly enables subdomain
|
matching. Use :attr:`subdomain_matching` instead.
|
Nrb )rä Ú subdomainrc rf )Ú script_namerN )rt r Zdefault_subdomainZbind_to_environrÛ r Úbind)r r' rf rR rR rS rQ C s ýýzFlask.create_url_adapter)r~ rñ rO c C sZ d}d|kr(t |tt| d¡d }|D ](}|| jkr,| j| D ]}||| qDq,dS )zÖInjects the URL defaults for the given endpoint directly into
|
the values dictionary passed. This is used internally and
|
automatically called on URL building.
|
|
.. versionadded:: 0.7
|
ry rM r N)r rÎ r* Ú
|
rpartitionZurl_default_functions)r r~ rñ rÐ r rÑ rR rR rS rR k s ÿ
|
zFlask.inject_url_defaultsr zdict[str, t.Any])r1 r~ rñ rO c C sn | j D ]L}z||||}W n& tk
|
r@ } z|}W 5 d}~X Y qX |dk r| S q|t ¡ d krf |dS )a Called by :meth:`.url_for` if a
|
:exc:`~werkzeug.routing.BuildError` was raised. If this returns
|
a value, it will be returned by ``url_for``, otherwise the error
|
will be re-raised.
|
|
Each function in :attr:`url_build_error_handlers` is called with
|
``error``, ``endpoint`` and ``values``. If a function returns
|
``None`` or raises a ``BuildError``, it is skipped. Otherwise,
|
its return value is returned by ``url_for``.
|
|
:param error: The active ``BuildError`` being handled.
|
:param endpoint: The endpoint being built.
|
:param values: The keyword arguments passed to ``url_for``.
|
Nr )r r r¢ r) )r r1 r~ rñ r rÉ r rR rR rS rT s
|
|
z Flask.handle_url_build_errorz ft.ResponseReturnValue | Nonec C s dt tj}|D ],}|| jkr| j| D ]}|tjtj q*q|D ]>}|| jkrD| j| D ]$}| |¡ }|dk r\| S q\qDdS )a Called before the request is dispatched. Calls
|
:attr:`url_value_preprocessors` registered with the app and the
|
current blueprint (if any). Then calls :attr:`before_request_funcs`
|
registered with the app and the blueprint.
|
|
If any :meth:`before_request` handler returns a non-None value, the
|
value is handled as if it was the return value from the view, and
|
further request handling is stopped.
|
N)N)rÎ r' r Zurl_value_preprocessorsr~ r: Zbefore_request_funcsr! )r rÐ r Zurl_funcZ before_funcrÉ rR rR rS r= ¢ s
|
|
|
zFlask.preprocess_request)r? rO c C s t ¡ }|jD ]}| |¡|}qttjdD ]0}|| jkr.t| j| D ]}| |¡|}qJq.| j
|
|j ¡s| j | |j |¡ |S )a Can be overridden in order to modify the response object
|
before it's sent to the WSGI server. By default this will
|
call all the :meth:`after_request` decorated functions.
|
|
.. versionchanged:: 0.5
|
As of Flask 0.5 the functions registered for after request
|
execution are called in reverse order of registration.
|
|
:param response: a :attr:`response_class` object.
|
:return: a new response object or the same, has to be an
|
instance of :attr:`response_class`.
|
ry ) r( Z_get_current_objectZ_after_request_functionsr! r r' r Zafter_request_funcsrÎ rj Zis_null_sessionr) Z save_session)r r? ÚctxrÑ r rR rR rS rA ½ s
|
|
zFlask.process_response)ÚexcrO c C sh |t krt ¡ d }ttjdD ]0}|| jkr t| j| D ]}| |¡| q<q t j
|
| | j|d dS )a2 Called after the request is dispatched and the response is
|
returned, right before the request context is popped.
|
|
This calls all functions decorated with
|
:meth:`teardown_request`, and :meth:`Blueprint.teardown_request`
|
if a blueprint handled the request. Finally, the
|
:data:`request_tearing_down` signal is sent.
|
|
This is called by
|
:meth:`RequestContext.pop() <flask.ctx.RequestContext.pop>`,
|
which may be delayed during testing to maintain access to
|
resources.
|
|
:param exc: An unhandled exception raised while dispatching the
|
request. Detected from the current exception information if
|
not passed. Passed to each teardown function.
|
|
.. versionchanged:: 0.9
|
Added the ``exc`` argument.
|
r ry ©r& rk N) r3 r¢ r) r r' r Zteardown_request_funcsrÎ r! r= r* )r rk r rÑ rR rR rS Údo_teardown_requestÙ s
|
zFlask.do_teardown_requestc C sH |t krt ¡ d }t| jD ]}| |¡| q tj| | j|d dS )aÕ Called right before the application context is popped.
|
|
When handling a request, the application context is popped
|
after the request context. See :meth:`do_teardown_request`.
|
|
This calls all functions decorated with
|
:meth:`teardown_appcontext`. Then the
|
:data:`appcontext_tearing_down` signal is sent.
|
|
This is called by
|
:meth:`AppContext.pop() <flask.ctx.AppContext.pop>`.
|
|
.. versionadded:: 0.9
|
r rl N)r3 r¢ r) rÎ r r! r9 r* )r rk rÑ rR rR rS Údo_teardown_appcontextú s
|
z Flask.do_teardown_appcontextr! c C s t | S )aF Create an :class:`~flask.ctx.AppContext`. Use as a ``with``
|
block to push the context, which will make :data:`current_app`
|
point at this application.
|
|
An application context is automatically pushed by
|
:meth:`RequestContext.push() <flask.ctx.RequestContext.push>`
|
when handling a request, and when running a CLI command. Use
|
this to manually create a context outside of these situations.
|
|
::
|
|
with app.app_context():
|
init_db()
|
|
See :doc:`/appcontext`.
|
|
.. versionadded:: 0.9
|
r r§ rR rR rS Ú app_context s zFlask.app_contextr# )rÛ rO c C s
|
t | |S )a$ Create a :class:`~flask.ctx.RequestContext` representing a
|
WSGI environment. Use a ``with`` block to push the context,
|
which will make :data:`request` point at this request.
|
|
See :doc:`/reqcontext`.
|
|
Typically you should not call this from your own code. A request
|
context is automatically pushed by the :meth:`wsgi_app` when
|
handling a request. Use :meth:`test_request_context` to create
|
an environment and context instead of this method.
|
|
:param environ: a WSGI environment
|
r" )r rÛ rR rR rS Úrequest_context( s zFlask.request_context)Úargsrè rO c O s> ddl m} || f||}z| | ¡ ¡W ¢S | ¡ X dS )aà Create a :class:`~flask.ctx.RequestContext` for a WSGI
|
environment created from the given values. This is mostly useful
|
during testing, where you may want to run a function that uses
|
request data without dispatching a full request.
|
|
See :doc:`/reqcontext`.
|
|
Use a ``with`` block to push the context, which will make
|
:data:`request` point at the request for the created
|
environment. ::
|
|
with app.test_request_context(...):
|
generate_report()
|
|
When using the shell, it may be easier to push and pop the
|
context manually to avoid indentation. ::
|
|
ctx = app.test_request_context(...)
|
ctx.push()
|
...
|
ctx.pop()
|
|
Takes the same arguments as Werkzeug's
|
:class:`~werkzeug.test.EnvironBuilder`, with some defaults from
|
the application. See the linked Werkzeug docs for most of the
|
available arguments. Flask-specific behavior is listed here.
|
|
:param path: URL path being requested.
|
:param base_url: Base URL where the app is being served, which
|
``path`` is relative to. If not given, built from
|
:data:`PREFERRED_URL_SCHEME`, ``subdomain``,
|
:data:`SERVER_NAME`, and :data:`APPLICATION_ROOT`.
|
:param subdomain: Subdomain name to append to
|
:data:`SERVER_NAME`.
|
:param url_scheme: Scheme to use instead of
|
:data:`PREFERRED_URL_SCHEME`.
|
:param data: The request body, either as a string or a dict of
|
form keys and values.
|
:param json: If given, this is serialized as JSON and passed as
|
``data``. Also defaults ``content_type`` to
|
``application/json``.
|
:param args: other positional arguments passed to
|
:class:`~werkzeug.test.EnvironBuilder`.
|
:param kwargs: other keyword arguments passed to
|
:class:`~werkzeug.test.EnvironBuilder`.
|
r )ÚEnvironBuilderN)ré rr Úcloserp Z get_environ)r rq rè rr ZbuilderrR rR rS Útest_request_context8 s
|
/ zFlask.test_request_context)rÛ Ústart_responserO c
|
C sÊ | |¡}d}zlz| ¡ | ¡ }W nH tk
|
rT } z|}| |¡}W 5 d}~X Y n t
|
¡ d } Y nX |||W ¢S d|kr¤|d t ¡ |d t ¡ |dk rº| |¡rºd}| |¡ X dS )a The actual WSGI application. This is not implemented in
|
:meth:`__call__` so that middlewares can be applied without
|
losing a reference to the app object. Instead of doing this::
|
|
app = MyMiddleware(app)
|
|
It's a better idea to do this instead::
|
|
app.wsgi_app = MyMiddleware(app.wsgi_app)
|
|
Then you still have the original application object around and
|
can continue to call methods on it.
|
|
.. versionchanged:: 0.7
|
Teardown events for the request and app contexts are called
|
even if an unhandled error occurs. Other events may not be
|
called depending on when an error occurs during dispatch.
|
See :ref:`callbacks-and-errors`.
|
|
:param environ: A WSGI environment.
|
:param start_response: A callable accepting a status code,
|
a list of headers, and an optional exception context to
|
start the response.
|
Nz werkzeug.debug.preserve_contextr ) rp r$ rÜ r% rD rý Úpushr> r r/ r¢ r) )r rÛ ru rj r1 r? r rR rR rS Úwsgi_appp s&
|
zFlask.wsgi_appc C s | ||¡S )z«The WSGI server calls the Flask application object as the
|
WSGI application. This calls :meth:`wsgi_app`, which can be
|
wrapped to apply middleware.
|
)rw )r rÛ ru rR rR rS Ú__call__ s zFlask.__call__) Nrk NFFrl NFN)F)r» )NNNT)T)NNN)N)N)N)N)N)N)F)rV )er Ú
|
__module__Ú __qualname__Ú__doc__rA Z request_classr rê r rµ r@ rÄ r Zapp_ctx_globals_classr r³ r ré Z
|
secret_keyrT Zpermanent_session_lifetimer. rY Ú__annotations__r[ r
|
r r² r r r r rh ri r7 rj r r r r r¨ rª Úpropertyr° r r r r¿ r© rÊ r rÒ rÔ rà Úsetterræ rì rí r6 rð rò r r r r r r r r r r r# r$ r% r/ r+ r8 r< r> r, r9 rD r! rE rÁ r r@ rQ rR rT r= rA r3 rm rn ro rp rt rw rx Ú __classcell__rR rR r rS rU \ s2
|
b
|
ÿ éÿ õ& ( û{: û : ÿ ÿ ÿ ÿ ÿ ÿ !
|
## 5 ý
|
ù } (" ÿ"ÿ80rU )qÚ
|
__future__r Úloggingr r¢ r râ r Úcollections.abcr rb Údatetimer Úinspectr Ú itertoolsr Útypesr Ú urllib.parser rU rÝ Zwerkzeug.datastructuresr r
|
Zwerkzeug.exceptionsr r r r r Zwerkzeug.routingr r r r r r rá r Zwerkzeug.utilsr r rY Zwerkzeug.wrappersr rW Ú r Úftr r r rj r r! r# rÅ r$ r% r& r' r( r) Zhelpersr* r+ r, r- Z json.providerr. r/ r1 Zscaffoldr2 r3 r4 r5 r6 Úsessionsr7 r8 Zsignalsr9 r: r; r< r= Z
|
templatingr? r@ ÚwrappersrA Ú TYPE_CHECKINGr rB ré rD rF ÚTypeVarZ ShellContextProcessorCallablerG ZTeardownCallablerI ZTemplateFilterCallablerJ ZTemplateGlobalCallablerK ZTemplateTestCallablerL rT rU rR rR rR rS Ú<module> s ÿ
|
