<p>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.</p>
<p>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 <codeclass="file docutils literal notranslate"><spanclass="pre">__init__.py</span></code> file inside) or a standard module (just a <codeclass="docutils literal notranslate"><spanclass="pre">.py</span></code> file).</p>
<p>For more information about resource loading, see <aclass="reference internal"href="#flask.app.Flask.open_resource"title="flask.app.Flask.open_resource"><codeclass="xref py py-func docutils literal notranslate"><spanclass="pre">open_resource()</span></code></a>.</p>
<p>Usually you create a <aclass="reference internal"href="#flask.app.Flask"title="flask.app.Flask"><codeclass="xref py py-class docutils literal notranslate"><spanclass="pre">Flask</span></code></a> instance in your main module or
in the <codeclass="file docutils literal notranslate"><spanclass="pre">__init__.py</span></code> file of your package like this:</p>
<p>Why is that? The application will work even with <cite>__name__</cite>, 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 <cite>yourapplication.app</cite> and not
<cite>yourapplication.views.frontend</cite>)</p>
</div>
<divclass="versionadded">
<p><spanclass="versionmodified added">Added in version 0.7: </span>The <cite>static_url_path</cite>, <cite>static_folder</cite>, and <cite>template_folder</cite>
parameters were added.</p>
</div>
<divclass="versionadded">
<p><spanclass="versionmodified added">Added in version 0.8: </span>The <cite>instance_path</cite> and <cite>instance_relative_config</cite> parameters were
added.</p>
</div>
<divclass="versionadded">
<p><spanclass="versionmodified added">Added in version 0.11: </span>The <cite>root_path</cite> parameter was added.</p>
</div>
<divclass="versionadded">
<p><spanclass="versionmodified added">Added in version 1.0: </span>The <codeclass="docutils literal notranslate"><spanclass="pre">host_matching</span></code> and <codeclass="docutils literal notranslate"><spanclass="pre">static_host</span></code> parameters were added.</p>
</div>
<divclass="versionadded">
<p><spanclass="versionmodified added">Added in version 1.0: </span>The <codeclass="docutils literal notranslate"><spanclass="pre">subdomain_matching</span></code> parameter was added. Subdomain
matching needs to be enabled manually now. Setting
<codeclass="xref py py-data docutils literal notranslate"><spanclass="pre">SERVER_NAME</span></code> does not implicitly enable it.</p>
<li><p><strong>import_name</strong>– the name of the application package</p></li>
<li><p><strong>static_url_path</strong>– can be used to specify a different path for the
static files on the web. Defaults to the name
of the <cite>static_folder</cite> folder.</p></li>
<li><p><strong>static_folder</strong>– The folder with static files that is served at
<codeclass="docutils literal notranslate"><spanclass="pre">static_url_path</span></code>. Relative to the application <codeclass="docutils literal notranslate"><spanclass="pre">root_path</span></code>
or an absolute path. Defaults to <codeclass="docutils literal notranslate"><spanclass="pre">'static'</span></code>.</p></li>
<li><p><strong>static_host</strong>– the host to use when adding the static route.
Defaults to None. Required when using <codeclass="docutils literal notranslate"><spanclass="pre">host_matching=True</span></code>
with a <codeclass="docutils literal notranslate"><spanclass="pre">static_folder</span></code> configured.</p></li>
<li><p><strong>host_matching</strong>– set <codeclass="docutils literal notranslate"><spanclass="pre">url_map.host_matching</span></code> attribute.
Defaults to False.</p></li>
<li><p><strong>subdomain_matching</strong>– consider the subdomain relative to
<codeclass="xref py py-data docutils literal notranslate"><spanclass="pre">SERVER_NAME</span></code> when matching routes. Defaults to False.</p></li>
<li><p><strong>template_folder</strong>– the folder that contains the templates that should
be used by the application. Defaults to
<codeclass="docutils literal notranslate"><spanclass="pre">'templates'</span></code> folder in the root path of the
application.</p></li>
<li><p><strong>instance_path</strong>– An alternative instance path for the application.
By default the folder <codeclass="docutils literal notranslate"><spanclass="pre">'instance'</span></code> next to the
package or module is assumed to be the instance
path.</p></li>
<li><p><strong>instance_relative_config</strong>– if set to <codeclass="docutils literal notranslate"><spanclass="pre">True</span></code> relative filenames
for loading the config are assumed to
be relative to the instance path instead
of the application root.</p></li>
<li><p><strong>root_path</strong>– 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.</p></li>
<spanclass="sig-name descname"><spanclass="pre">app_context</span></span><spanclass="sig-paren">(</span><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><aclass="reference internal"href="#flask.ctx.AppContext"title="flask.ctx.AppContext"><spanclass="pre">AppContext</span></a></span></span><aclass="headerlink"href="#flask.app.Flask.app_context"title="Link to this definition"></a></dt>
<dd><p>Create an <aclass="reference internal"href="#flask.ctx.AppContext"title="flask.ctx.AppContext"><codeclass="xref py py-class docutils literal notranslate"><spanclass="pre">AppContext</span></code></a>. Use as a <codeclass="docutils literal notranslate"><spanclass="pre">with</span></code>
block to push the context, which will make <codeclass="xref py py-data docutils literal notranslate"><spanclass="pre">current_app</span></code>
point at this application.</p>
<p>An application context is automatically pushed by
<spanclass="sig-name descname"><spanclass="pre">async_to_sync</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">func</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">Callable</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="p"><spanclass="pre">[</span></span><spanclass="p"><spanclass="pre">...</span></span><spanclass="p"><spanclass="pre">]</span></span><spanclass="p"><spanclass="pre">,</span></span><spanclass="w"></span><spanclass="pre">Coroutine</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="pre">Any</span><spanclass="p"><spanclass="pre">,</span></span><spanclass="w"></span><spanclass="pre">Any</span><spanclass="p"><spanclass="pre">,</span></span><spanclass="w"></span><spanclass="pre">Any</span><spanclass="p"><spanclass="pre">]</span></span><spanclass="p"><spanclass="pre">]</span></span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">Callable</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="p"><spanclass="pre">[</span></span><spanclass="p"><spanclass="pre">...</span></span><spanclass="p"><spanclass="pre">]</span></span><spanclass="p"><spanclass="pre">,</span></span><spanclass="w"></span><spanclass="pre">Any</span><spanclass="p"><spanclass="pre">]</span></span></span></span><aclass="headerlink"href="#flask.app.Flask.async_to_sync"title="Link to this definition"></a></dt>
<dd><p>Return a sync function that will run the coroutine function.</p>
<spanclass="sig-name descname"><spanclass="pre">cli</span></span><emclass="property"><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="pre">Group</span></em><aclass="headerlink"href="#flask.app.Flask.cli"title="Link to this definition"></a></dt>
<dd><p>The Click command group for registering CLI commands for this
object. The commands are available from the <codeclass="docutils literal notranslate"><spanclass="pre">flask</span></code> command
once the application has been discovered and blueprints have
<spanclass="sig-name descname"><spanclass="pre">create_jinja_environment</span></span><spanclass="sig-paren">(</span><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><aclass="reference internal"href="#flask.templating.Environment"title="flask.templating.Environment"><spanclass="pre">Environment</span></a></span></span><aclass="headerlink"href="#flask.app.Flask.create_jinja_environment"title="Link to this definition"></a></dt>
<dd><p>Create the Jinja environment based on <codeclass="xref py py-attr docutils literal notranslate"><spanclass="pre">jinja_options</span></code>
and the various Jinja-related methods of the app. Changing
<codeclass="xref py py-attr docutils literal notranslate"><spanclass="pre">jinja_options</span></code> after this will have no effect. Also adds
Flask-related globals and filters to the environment.</p>
<divclass="versionchanged">
<p><spanclass="versionmodified changed">Changed in version 0.11: </span><codeclass="docutils literal notranslate"><spanclass="pre">Environment.auto_reload</span></code> set in accordance with
<spanclass="sig-name descname"><spanclass="pre">create_url_adapter</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">request</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><aclass="reference internal"href="#flask.wrappers.Request"title="flask.wrappers.Request"><spanclass="pre">Request</span></a><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">None</span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">MapAdapter</span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">None</span></span></span><aclass="headerlink"href="#flask.app.Flask.create_url_adapter"title="Link to this definition"></a></dt>
<dd><p>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.</p>
<divclass="versionchanged">
<p><spanclass="versionmodified changed">Changed in version 3.1: </span>If <codeclass="xref py py-data docutils literal notranslate"><spanclass="pre">SERVER_NAME</span></code> is set, it does not restrict requests to
only that domain, for both <codeclass="docutils literal notranslate"><spanclass="pre">subdomain_matching</span></code> and
<spanclass="sig-name descname"><spanclass="pre">default_config</span></span><emclass="property"><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="pre">dict</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="pre">str</span><spanclass="p"><spanclass="pre">,</span></span><spanclass="w"></span><spanclass="pre">t.Any</span><spanclass="p"><spanclass="pre">]</span></span></em><emclass="property"><spanclass="w"></span><spanclass="p"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="pre">{'APPLICATION_ROOT':</span><spanclass="pre">'/',</span><spanclass="pre">'DEBUG':</span><spanclass="pre">None,</span><spanclass="pre">'EXPLAIN_TEMPLATE_LOADING':</span><spanclass="pre">False,</span><spanclass="pre">'MAX_CONTENT_LENGTH':</span><spanclass="pre">None,</span><spanclass="pre">'MAX_COOKIE_SIZE':</span><spanclass="pre">4093,</span><spanclass="pre">'MAX_FORM_MEMORY_SIZE':</span><spanclass="pre">500000,</span><spanclass="pre">'MAX_FORM_PARTS':</span><spanclass="pre">1000,</span><spanclass="pre">'PERMANENT_SESSION_LIFETIME':</span><spanclass="pre">datetime.timedelta(days=31),</span><spanclass="pre">'PREFERRED_URL_SCHEME':</span><spanclass="pre">'http',</span><spanclass="pre">'PROPAGATE_EXCEPTIONS':</span><spanclass="pre">None,</span><spanclass="pre">'PROVIDE_AUTOMATIC_OPTIONS':</span><spanclass="pre">True,</span><spanclass="pre">'SECRET_KEY':</span><spanclass="pre">None,</span><spanclass="pre">'SECRET_KEY_FALLBACKS':</span><spanclass="pre">None,</span><spanclass="pre">'SEND_FILE_MAX_AGE_DEFAULT':</span><spanclass="pre">None,</span><spanclass="pre">'SERVER_NAME':</span><spanclass="pre">None,</span><spanclass="pre">'SESSION_COOKIE_DOMAIN':</span><spanclass="pre">None,</span><spanclass="pre">'SESSION_COOKIE_HTTPONLY':</span><spanclass="pre">True,</span><spanclass="pre">'SESSION_COOKIE_NAME':</span><spanclass="pre">'session',</span><spanclass="pre">'SESSION_COOKIE_PARTITIONED':</span><spanclass="pre">False,</span><spanclass="pre">'SESSION_COOKIE_PATH':</span><spanclass="pre">None,</span><spanclass="pre">'SESSION_COOKIE_SAMESITE':</span><spanclass="pre">None,</span><spanclass="pre">'SESSION_COOKIE_SECURE':</span><spanclass="pre">False,</span><spanclass="pre">'SESSION_REFRESH_EACH_REQUEST':</span><spanclass="pre">True,</span><spanclass="pre">'TEMPLATES_AUTO_RELOAD':</span><spanclass="pre">None,</span><spanclass="pre">'TESTING':</span><spanclass="pre">False,</span><spanclass="pre">'TRAP_BAD_REQUEST_ERRORS':</span><spanclass="pre">None,</span><spanclass="pre">'TRAP_HTTP_EXCEPTIONS':</span><spanclass="pre">False,</span><spanclass="pre">'TRUSTED_HOSTS':</span><spanclass="pre">None,</span><spanclass="pre">'USE_X_SENDFILE':</span><spanclass="pre">False}</span></em><aclass="headerlink"href="#flask.app.Flask.default_config"title="Link to this definition"></a></dt>
<spanclass="sig-name descname"><spanclass="pre">dispatch_request</span></span><spanclass="sig-paren">(</span><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">ft.ResponseReturnValue</span></span></span><aclass="headerlink"href="#flask.app.Flask.dispatch_request"title="Link to this definition"></a></dt>
<dd><p>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
<p><spanclass="versionmodified changed">Changed in version 0.7: </span>This no longer does the exception handling, this code was
moved to the new <aclass="reference internal"href="#flask.app.Flask.full_dispatch_request"title="flask.app.Flask.full_dispatch_request"><codeclass="xref py py-meth docutils literal notranslate"><spanclass="pre">full_dispatch_request()</span></code></a>.</p>
<spanclass="sig-name descname"><spanclass="pre">do_teardown_appcontext</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">exc:</span><spanclass="pre">BaseException</span><spanclass="pre">|</span><spanclass="pre">None</span><spanclass="pre">=</span><spanclass="pre"><object</span><spanclass="pre">object></span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">None</span></span></span><aclass="headerlink"href="#flask.app.Flask.do_teardown_appcontext"title="Link to this definition"></a></dt>
<dd><p>Called right before the application context is popped.</p>
<p>When handling a request, the application context is popped
after the request context. See <aclass="reference internal"href="#flask.app.Flask.do_teardown_request"title="flask.app.Flask.do_teardown_request"><codeclass="xref py py-meth docutils literal notranslate"><spanclass="pre">do_teardown_request()</span></code></a>.</p>
<p>This calls all functions decorated with
<codeclass="xref py py-meth docutils literal notranslate"><spanclass="pre">teardown_appcontext()</span></code>. Then the
<codeclass="xref py py-data docutils literal notranslate"><spanclass="pre">appcontext_tearing_down</span></code> signal is sent.</p>
<spanclass="sig-name descname"><spanclass="pre">do_teardown_request</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">exc:</span><spanclass="pre">BaseException</span><spanclass="pre">|</span><spanclass="pre">None</span><spanclass="pre">=</span><spanclass="pre"><object</span><spanclass="pre">object></span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">None</span></span></span><aclass="headerlink"href="#flask.app.Flask.do_teardown_request"title="Link to this definition"></a></dt>
<dd><p>Called after the request is dispatched and the response is
returned, right before the request context is popped.</p>
<ddclass="field-odd"><p><strong>exc</strong>– An unhandled exception raised while dispatching the
request. Detected from the current exception information if
not passed. Passed to each teardown function.</p>
</dd>
</dl>
<divclass="versionchanged">
<p><spanclass="versionmodified changed">Changed in version 0.9: </span>Added the <codeclass="docutils literal notranslate"><spanclass="pre">exc</span></code> argument.</p>
<spanclass="sig-name descname"><spanclass="pre">ensure_sync</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">func</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">Callable</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="p"><spanclass="pre">[</span></span><spanclass="p"><spanclass="pre">...</span></span><spanclass="p"><spanclass="pre">]</span></span><spanclass="p"><spanclass="pre">,</span></span><spanclass="w"></span><spanclass="pre">Any</span><spanclass="p"><spanclass="pre">]</span></span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">Callable</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="p"><spanclass="pre">[</span></span><spanclass="p"><spanclass="pre">...</span></span><spanclass="p"><spanclass="pre">]</span></span><spanclass="p"><spanclass="pre">,</span></span><spanclass="w"></span><spanclass="pre">Any</span><spanclass="p"><spanclass="pre">]</span></span></span></span><aclass="headerlink"href="#flask.app.Flask.ensure_sync"title="Link to this definition"></a></dt>
<dd><p>Ensure that the function is synchronous for WSGI workers.
Plain <codeclass="docutils literal notranslate"><spanclass="pre">def</span></code> functions are returned as-is. <codeclass="docutils literal notranslate"><spanclass="pre">async</span><spanclass="pre">def</span></code>
functions are wrapped to run and wait for the response.</p>
<p>Override this method to change how the app runs async views.</p>
<divclass="versionadded">
<p><spanclass="versionmodified added">Added in version 2.0.</span></p>
<spanclass="sig-name descname"><spanclass="pre">finalize_request</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">rv</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">ft.ResponseReturnValue</span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">HTTPException</span></span></em>, <emclass="sig-param"><spanclass="n"><spanclass="pre">from_error_handler</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">bool</span></span><spanclass="w"></span><spanclass="o"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="default_value"><spanclass="pre">False</span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><aclass="reference internal"href="#flask.wrappers.Response"title="flask.wrappers.Response"><spanclass="pre">Response</span></a></span></span><aclass="headerlink"href="#flask.app.Flask.finalize_request"title="Link to this definition"></a></dt>
<dd><p>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.</p>
<p>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 <cite>from_error_handler</cite> flag. If enabled, failures in
response processing will be logged and otherwise ignored.</p>
<spanclass="sig-name descname"><spanclass="pre">full_dispatch_request</span></span><spanclass="sig-paren">(</span><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><aclass="reference internal"href="#flask.wrappers.Response"title="flask.wrappers.Response"><spanclass="pre">Response</span></a></span></span><aclass="headerlink"href="#flask.app.Flask.full_dispatch_request"title="Link to this definition"></a></dt>
<dd><p>Dispatches the request and on top of that performs request
pre and postprocessing as well as HTTP exception catching and
error handling.</p>
<divclass="versionadded">
<p><spanclass="versionmodified added">Added in version 0.7.</span></p>
<spanclass="sig-name descname"><spanclass="pre">get_send_file_max_age</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">filename</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">str</span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">None</span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">int</span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">None</span></span></span><aclass="headerlink"href="#flask.app.Flask.get_send_file_max_age"title="Link to this definition"></a></dt>
<dd><p>Used by <codeclass="xref py py-func docutils literal notranslate"><spanclass="pre">send_file()</span></code> to determine the <codeclass="docutils literal notranslate"><spanclass="pre">max_age</span></code> cache
value for a given file path if it wasn’t passed.</p>
<p>By default, this returns <codeclass="xref py py-data docutils literal notranslate"><spanclass="pre">SEND_FILE_MAX_AGE_DEFAULT</span></code> from
the configuration of <codeclass="xref py py-data docutils literal notranslate"><spanclass="pre">current_app</span></code>. This defaults
to <codeclass="docutils literal notranslate"><spanclass="pre">None</span></code>, which tells the browser to use conditional requests
instead of a timed cache, which is usually preferable.</p>
<p>Note this is a duplicate of the same method in the Flask
class.</p>
<divclass="versionchanged">
<p><spanclass="versionmodified changed">Changed in version 2.0: </span>The default configuration is <codeclass="docutils literal notranslate"><spanclass="pre">None</span></code> instead of 12 hours.</p>
</div>
<divclass="versionadded">
<p><spanclass="versionmodified added">Added in version 0.9.</span></p>
<spanclass="sig-name descname"><spanclass="pre">handle_exception</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">e</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">Exception</span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><aclass="reference internal"href="#flask.wrappers.Response"title="flask.wrappers.Response"><spanclass="pre">Response</span></a></span></span><aclass="headerlink"href="#flask.app.Flask.handle_exception"title="Link to this definition"></a></dt>
<dd><p>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 <codeclass="docutils literal notranslate"><spanclass="pre">InternalServerError</span></code>.</p>
<p>Always sends the <codeclass="xref py py-data docutils literal notranslate"><spanclass="pre">got_request_exception</span></code> signal.</p>
<p>If <codeclass="xref py py-data docutils literal notranslate"><spanclass="pre">PROPAGATE_EXCEPTIONS</span></code> is <codeclass="docutils literal notranslate"><spanclass="pre">True</span></code>, 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 <codeclass="xref py py-exc docutils literal notranslate"><spanclass="pre">InternalServerError</span></code> is returned.</p>
<p>If an error handler is registered for <codeclass="docutils literal notranslate"><spanclass="pre">InternalServerError</span></code> or
<codeclass="docutils literal notranslate"><spanclass="pre">500</span></code>, it will be used. For consistency, the handler will
always receive the <codeclass="docutils literal notranslate"><spanclass="pre">InternalServerError</span></code>. The original
unhandled exception is available as <codeclass="docutils literal notranslate"><spanclass="pre">e.original_exception</span></code>.</p>
<divclass="versionchanged">
<p><spanclass="versionmodified changed">Changed in version 1.1.0: </span>Always passes the <codeclass="docutils literal notranslate"><spanclass="pre">InternalServerError</span></code> instance to the
handler, setting <codeclass="docutils literal notranslate"><spanclass="pre">original_exception</span></code> to the unhandled
error.</p>
</div>
<divclass="versionchanged">
<p><spanclass="versionmodified changed">Changed in version 1.1.0: </span><codeclass="docutils literal notranslate"><spanclass="pre">after_request</span></code> functions and other finalization is done
even for the default 500 response when there is no handler.</p>
</div>
<divclass="versionadded">
<p><spanclass="versionmodified added">Added in version 0.3.</span></p>
<spanclass="sig-name descname"><spanclass="pre">handle_http_exception</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">e</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">HTTPException</span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">HTTPException</span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">ft.ResponseReturnValue</span></span></span><aclass="headerlink"href="#flask.app.Flask.handle_http_exception"title="Link to this definition"></a></dt>
<dd><p>Handles an HTTP exception. By default this will invoke the
registered error handlers and fall back to returning the
exception as response.</p>
<divclass="versionchanged">
<p><spanclass="versionmodified changed">Changed in version 1.0.3: </span><codeclass="docutils literal notranslate"><spanclass="pre">RoutingException</span></code>, used internally for actions such as
slash redirects during routing, is not passed to error
handlers.</p>
</div>
<divclass="versionchanged">
<p><spanclass="versionmodified changed">Changed in version 1.0: </span>Exceptions are looked up by code <em>and</em> by MRO, so
<codeclass="docutils literal notranslate"><spanclass="pre">HTTPException</span></code> subclasses can be handled with a catch-all
handler for the base <codeclass="docutils literal notranslate"><spanclass="pre">HTTPException</span></code>.</p>
</div>
<divclass="versionadded">
<p><spanclass="versionmodified added">Added in version 0.3.</span></p>
<spanclass="sig-name descname"><spanclass="pre">handle_user_exception</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">e</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">Exception</span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">HTTPException</span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">ft.ResponseReturnValue</span></span></span><aclass="headerlink"href="#flask.app.Flask.handle_user_exception"title="Link to this definition"></a></dt>
<dd><p>This method is called whenever an exception occurs that
should be handled. A special case is <codeclass="xref py py-class docutils literal notranslate"><spanclass="pre">HTTPException</span></code> which is forwarded to the
<aclass="reference internal"href="#flask.app.Flask.handle_http_exception"title="flask.app.Flask.handle_http_exception"><codeclass="xref py py-meth docutils literal notranslate"><spanclass="pre">handle_http_exception()</span></code></a> method. This function will either
return a response value or reraise the exception with the same
traceback.</p>
<divclass="versionchanged">
<p><spanclass="versionmodified changed">Changed in version 1.0: </span>Key errors raised from request data like <codeclass="docutils literal notranslate"><spanclass="pre">form</span></code> show the
bad key in debug mode rather than a generic bad request
message.</p>
</div>
<divclass="versionadded">
<p><spanclass="versionmodified added">Added in version 0.7.</span></p>
<spanclass="sig-name descname"><spanclass="pre">log_exception</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">exc_info</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">tuple</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="pre">type</span><spanclass="p"><spanclass="pre">,</span></span><spanclass="w"></span><spanclass="pre">BaseException</span><spanclass="p"><spanclass="pre">,</span></span><spanclass="w"></span><spanclass="pre">TracebackType</span><spanclass="p"><spanclass="pre">]</span></span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">tuple</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="pre">None</span><spanclass="p"><spanclass="pre">,</span></span><spanclass="w"></span><spanclass="pre">None</span><spanclass="p"><spanclass="pre">,</span></span><spanclass="w"></span><spanclass="pre">None</span><spanclass="p"><spanclass="pre">]</span></span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">None</span></span></span><aclass="headerlink"href="#flask.app.Flask.log_exception"title="Link to this definition"></a></dt>
<dd><p>Logs an exception. This is called by <aclass="reference internal"href="#flask.app.Flask.handle_exception"title="flask.app.Flask.handle_exception"><codeclass="xref py py-meth docutils literal notranslate"><spanclass="pre">handle_exception()</span></code></a>
if debugging is disabled and right before the handler is called.
The default implementation logs the exception as error on the
<spanclass="sig-name descname"><spanclass="pre">make_default_options_response</span></span><spanclass="sig-paren">(</span><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><aclass="reference internal"href="#flask.wrappers.Response"title="flask.wrappers.Response"><spanclass="pre">Response</span></a></span></span><aclass="headerlink"href="#flask.app.Flask.make_default_options_response"title="Link to this definition"></a></dt>
<dd><p>This method is called to create the default <codeclass="docutils literal notranslate"><spanclass="pre">OPTIONS</span></code> response.
This can be changed through subclassing to change the default
behavior of <codeclass="docutils literal notranslate"><spanclass="pre">OPTIONS</span></code> responses.</p>
<divclass="versionadded">
<p><spanclass="versionmodified added">Added in version 0.7.</span></p>
<spanclass="sig-name descname"><spanclass="pre">make_response</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">rv</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">ft.ResponseReturnValue</span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><aclass="reference internal"href="#flask.wrappers.Response"title="flask.wrappers.Response"><spanclass="pre">Response</span></a></span></span><aclass="headerlink"href="#flask.app.Flask.make_response"title="Link to this definition"></a></dt>
<dd><p>Convert the return value from a view function to an instance of
<ddclass="field-odd"><p><strong>rv</strong>–<p>the return value from the view function. The view function
must return a response. Returning <codeclass="docutils literal notranslate"><spanclass="pre">None</span></code>, or the view ending
without returning, is not allowed. The following types are allowed
for <codeclass="docutils literal notranslate"><spanclass="pre">view_rv</span></code>:</p>
<dlclass="simple">
<dt><codeclass="docutils literal notranslate"><spanclass="pre">str</span></code></dt><dd><p>A response object is created with the string encoded to UTF-8
as the body.</p>
</dd>
<dt><codeclass="docutils literal notranslate"><spanclass="pre">bytes</span></code></dt><dd><p>A response object is created with the bytes as the body.</p>
</dd>
<dt><codeclass="docutils literal notranslate"><spanclass="pre">dict</span></code></dt><dd><p>A dictionary that will be jsonify’d before being returned.</p>
</dd>
<dt><codeclass="docutils literal notranslate"><spanclass="pre">list</span></code></dt><dd><p>A list that will be jsonify’d before being returned.</p>
</dd>
<dt><codeclass="docutils literal notranslate"><spanclass="pre">generator</span></code> or <codeclass="docutils literal notranslate"><spanclass="pre">iterator</span></code></dt><dd><p>A generator that returns <codeclass="docutils literal notranslate"><spanclass="pre">str</span></code> or <codeclass="docutils literal notranslate"><spanclass="pre">bytes</span></code> to be
streamed as the response.</p>
</dd>
<dt><codeclass="docutils literal notranslate"><spanclass="pre">tuple</span></code></dt><dd><p>Either <codeclass="docutils literal notranslate"><spanclass="pre">(body,</span><spanclass="pre">status,</span><spanclass="pre">headers)</span></code>, <codeclass="docutils literal notranslate"><spanclass="pre">(body,</span><spanclass="pre">status)</span></code>, or
<codeclass="docutils literal notranslate"><spanclass="pre">(body,</span><spanclass="pre">headers)</span></code>, where <codeclass="docutils literal notranslate"><spanclass="pre">body</span></code> is any of the other types
allowed here, <codeclass="docutils literal notranslate"><spanclass="pre">status</span></code> is a string or an integer, and
<codeclass="docutils literal notranslate"><spanclass="pre">headers</span></code> is a dictionary or a list of <codeclass="docutils literal notranslate"><spanclass="pre">(key,</span><spanclass="pre">value)</span></code>
tuples. If <codeclass="docutils literal notranslate"><spanclass="pre">body</span></code> is a <aclass="reference internal"href="#flask.app.Flask.response_class"title="flask.app.Flask.response_class"><codeclass="xref py py-attr docutils literal notranslate"><spanclass="pre">response_class</span></code></a> instance,
<codeclass="docutils literal notranslate"><spanclass="pre">status</span></code> overwrites the exiting value and <codeclass="docutils literal notranslate"><spanclass="pre">headers</span></code> are
extended.</p>
</dd>
<dt><aclass="reference internal"href="#flask.app.Flask.response_class"title="flask.app.Flask.response_class"><codeclass="xref py py-attr docutils literal notranslate"><spanclass="pre">response_class</span></code></a></dt><dd><p>The object is returned unchanged.</p>
</dd>
<dt>other <codeclass="xref py py-class docutils literal notranslate"><spanclass="pre">Response</span></code> class</dt><dd><p>The object is coerced to <aclass="reference internal"href="#flask.app.Flask.response_class"title="flask.app.Flask.response_class"><codeclass="xref py py-attr docutils literal notranslate"><spanclass="pre">response_class</span></code></a>.</p>
</dd>
<dt><codeclass="xref py py-func docutils literal notranslate"><spanclass="pre">callable()</span></code></dt><dd><p>The function is called as a WSGI application. The result is
used to create a response object.</p>
</dd>
</dl>
</p>
</dd>
</dl>
<divclass="versionchanged">
<p><spanclass="versionmodified changed">Changed in version 2.2: </span>A generator will be converted to a streaming response.
A list will be converted to a JSON response.</p>
</div>
<divclass="versionchanged">
<p><spanclass="versionmodified changed">Changed in version 1.1: </span>A dict will be converted to a JSON response.</p>
</div>
<divclass="versionchanged">
<p><spanclass="versionmodified changed">Changed in version 0.9: </span>Previously a tuple was interpreted as the arguments for the
<spanclass="sig-name descname"><spanclass="pre">make_shell_context</span></span><spanclass="sig-paren">(</span><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">dict</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="pre">str</span><spanclass="p"><spanclass="pre">,</span></span><spanclass="w"></span><spanclass="pre">Any</span><spanclass="p"><spanclass="pre">]</span></span></span></span><aclass="headerlink"href="#flask.app.Flask.make_shell_context"title="Link to this definition"></a></dt>
<dd><p>Returns the shell context for an interactive shell for this
application. This runs all the registered shell context
processors.</p>
<divclass="versionadded">
<p><spanclass="versionmodified added">Added in version 0.11.</span></p>
<spanclass="sig-name descname"><spanclass="pre">open_instance_resource</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">resource</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">str</span></span></em>, <emclass="sig-param"><spanclass="n"><spanclass="pre">mode</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">str</span></span><spanclass="w"></span><spanclass="o"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="default_value"><spanclass="pre">'rb'</span></span></em>, <emclass="sig-param"><spanclass="n"><spanclass="pre">encoding</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">str</span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">None</span></span><spanclass="w"></span><spanclass="o"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="default_value"><spanclass="pre">'utf-8'</span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">IO</span></span></span><aclass="headerlink"href="#flask.app.Flask.open_instance_resource"title="Link to this definition"></a></dt>
<dd><p>Open a resource file relative to the application’s instance folder
<codeclass="xref py py-attr docutils literal notranslate"><spanclass="pre">instance_path</span></code>. Unlike <aclass="reference internal"href="#flask.app.Flask.open_resource"title="flask.app.Flask.open_resource"><codeclass="xref py py-meth docutils literal notranslate"><spanclass="pre">open_resource()</span></code></a>, files in the
<li><p><strong>resource</strong>– Path to the resource relative to <codeclass="xref py py-attr docutils literal notranslate"><spanclass="pre">instance_path</span></code>.</p></li>
<li><p><strong>mode</strong>– Open the file in this mode.</p></li>
<li><p><strong>encoding</strong>– Open the file with this encoding when opening in text
mode. This is ignored when opening in binary mode.</p></li>
</ul>
</dd>
</dl>
<divclass="versionchanged">
<p><spanclass="versionmodified changed">Changed in version 3.1: </span>Added the <codeclass="docutils literal notranslate"><spanclass="pre">encoding</span></code> parameter.</p>
<spanclass="sig-name descname"><spanclass="pre">open_resource</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">resource</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">str</span></span></em>, <emclass="sig-param"><spanclass="n"><spanclass="pre">mode</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">str</span></span><spanclass="w"></span><spanclass="o"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="default_value"><spanclass="pre">'rb'</span></span></em>, <emclass="sig-param"><spanclass="n"><spanclass="pre">encoding</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">str</span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">None</span></span><spanclass="w"></span><spanclass="o"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="default_value"><spanclass="pre">None</span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">IO</span></span></span><aclass="headerlink"href="#flask.app.Flask.open_resource"title="Link to this definition"></a></dt>
<dd><p>Open a resource file relative to <codeclass="xref py py-attr docutils literal notranslate"><spanclass="pre">root_path</span></code> for reading.</p>
<p>For example, if the file <codeclass="docutils literal notranslate"><spanclass="pre">schema.sql</span></code> is next to the file
<codeclass="docutils literal notranslate"><spanclass="pre">app.py</span></code> where the <codeclass="docutils literal notranslate"><spanclass="pre">Flask</span></code> app is defined, it can be opened
<li><p><strong>resource</strong>– Path to the resource relative to <codeclass="xref py py-attr docutils literal notranslate"><spanclass="pre">root_path</span></code>.</p></li>
<li><p><strong>mode</strong>– Open the file in this mode. Only reading is supported,
valid values are <codeclass="docutils literal notranslate"><spanclass="pre">"r"</span></code> (or <codeclass="docutils literal notranslate"><spanclass="pre">"rt"</span></code>) and <codeclass="docutils literal notranslate"><spanclass="pre">"rb"</span></code>.</p></li>
<li><p><strong>encoding</strong>– Open the file with this encoding when opening in text
mode. This is ignored when opening in binary mode.</p></li>
</ul>
</dd>
</dl>
<divclass="versionchanged">
<p><spanclass="versionmodified changed">Changed in version 3.1: </span>Added the <codeclass="docutils literal notranslate"><spanclass="pre">encoding</span></code> parameter.</p>
<spanclass="sig-name descname"><spanclass="pre">preprocess_request</span></span><spanclass="sig-paren">(</span><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">ft.ResponseReturnValue</span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">None</span></span></span><aclass="headerlink"href="#flask.app.Flask.preprocess_request"title="Link to this definition"></a></dt>
<dd><p>Called before the request is dispatched. Calls
<codeclass="xref py py-attr docutils literal notranslate"><spanclass="pre">url_value_preprocessors</span></code> registered with the app and the
current blueprint (if any). Then calls <codeclass="xref py py-attr docutils literal notranslate"><spanclass="pre">before_request_funcs</span></code>
registered with the app and the blueprint.</p>
<p>If any <codeclass="xref py py-meth docutils literal notranslate"><spanclass="pre">before_request()</span></code> handler returns a non-None value, the
value is handled as if it was the return value from the view, and
<spanclass="sig-name descname"><spanclass="pre">process_response</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">response</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><aclass="reference internal"href="#flask.wrappers.Response"title="flask.wrappers.Response"><spanclass="pre">Response</span></a></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><aclass="reference internal"href="#flask.wrappers.Response"title="flask.wrappers.Response"><spanclass="pre">Response</span></a></span></span><aclass="headerlink"href="#flask.app.Flask.process_response"title="Link to this definition"></a></dt>
<dd><p>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 <codeclass="xref py py-meth docutils literal notranslate"><spanclass="pre">after_request()</span></code> decorated functions.</p>
<divclass="versionchanged">
<p><spanclass="versionmodified changed">Changed in version 0.5: </span>As of Flask 0.5 the functions registered for after request
execution are called in reverse order of registration.</p>
<spanclass="sig-name descname"><spanclass="pre">request_class</span></span><aclass="headerlink"href="#flask.app.Flask.request_class"title="Link to this definition"></a></dt>
<dd><p>The class that is used for request objects. See <codeclass="xref py py-class docutils literal notranslate"><spanclass="pre">Request</span></code>
for more information.</p>
<p>alias of <aclass="reference internal"href="#flask.wrappers.Request"title="flask.wrappers.Request"><codeclass="xref py py-class docutils literal notranslate"><spanclass="pre">Request</span></code></a></p>
<spanclass="sig-name descname"><spanclass="pre">request_context</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">environ</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">WSGIEnvironment</span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><aclass="reference internal"href="#flask.ctx.RequestContext"title="flask.ctx.RequestContext"><spanclass="pre">RequestContext</span></a></span></span><aclass="headerlink"href="#flask.app.Flask.request_context"title="Link to this definition"></a></dt>
<dd><p>Create a <aclass="reference internal"href="#flask.ctx.RequestContext"title="flask.ctx.RequestContext"><codeclass="xref py py-class docutils literal notranslate"><spanclass="pre">RequestContext</span></code></a> representing a
WSGI environment. Use a <codeclass="docutils literal notranslate"><spanclass="pre">with</span></code> block to push the context,
which will make <codeclass="xref py py-data docutils literal notranslate"><spanclass="pre">request</span></code> point at this request.</p>
<p>Typically you should not call this from your own code. A request
context is automatically pushed by the <aclass="reference internal"href="#flask.app.Flask.wsgi_app"title="flask.app.Flask.wsgi_app"><codeclass="xref py py-meth docutils literal notranslate"><spanclass="pre">wsgi_app()</span></code></a> when
handling a request. Use <aclass="reference internal"href="#flask.app.Flask.test_request_context"title="flask.app.Flask.test_request_context"><codeclass="xref py py-meth docutils literal notranslate"><spanclass="pre">test_request_context()</span></code></a> to create
an environment and context instead of this method.</p>
<spanclass="sig-name descname"><spanclass="pre">response_class</span></span><aclass="headerlink"href="#flask.app.Flask.response_class"title="Link to this definition"></a></dt>
<dd><p>The class that is used for response objects. See
<codeclass="xref py py-class docutils literal notranslate"><spanclass="pre">Response</span></code> for more information.</p>
<p>alias of <aclass="reference internal"href="#flask.wrappers.Response"title="flask.wrappers.Response"><codeclass="xref py py-class docutils literal notranslate"><spanclass="pre">Response</span></code></a></p>
<spanclass="sig-name descname"><spanclass="pre">run</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">host</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">str</span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">None</span></span><spanclass="w"></span><spanclass="o"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="default_value"><spanclass="pre">None</span></span></em>, <emclass="sig-param"><spanclass="n"><spanclass="pre">port</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">int</span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">None</span></span><spanclass="w"></span><spanclass="o"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="default_value"><spanclass="pre">None</span></span></em>, <emclass="sig-param"><spanclass="n"><spanclass="pre">debug</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">bool</span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">None</span></span><spanclass="w"></span><spanclass="o"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="default_value"><spanclass="pre">None</span></span></em>, <emclass="sig-param"><spanclass="n"><spanclass="pre">load_dotenv</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">bool</span></span><spanclass="w"></span><spanclass="o"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="default_value"><spanclass="pre">True</span></span></em>, <emclass="sig-param"><spanclass="o"><spanclass="pre">**</span></span><spanclass="n"><spanclass="pre">options</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">Any</span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">None</span></span></span><aclass="headerlink"href="#flask.app.Flask.run"title="Link to this definition"></a></dt>
<dd><p>Runs the application on a local development server.</p>
<p>Do not use <codeclass="docutils literal notranslate"><spanclass="pre">run()</span></code> in a production setting. It is not intended to
meet security and performance requirements for a production server.
Instead, see <spanclass="xref std std-doc">/deploying/index</span> for WSGI server recommendations.</p>
<p>If the <codeclass="xref py py-attr docutils literal notranslate"><spanclass="pre">debug</span></code> flag is set the server will automatically reload
for code changes and show a debugger in case an exception happened.</p>
<p>If you want to run the application in debug mode, but disable the
code execution on the interactive debugger, you can pass
<codeclass="docutils literal notranslate"><spanclass="pre">use_evalex=False</span></code> as parameter. This will keep the debugger’s
traceback screen active, but disable code execution.</p>
<p>It is not recommended to use this function for development with
automatic reloading as this is badly supported. Instead you should
be using the <strongclass="command">flask</strong> command line script’s <codeclass="docutils literal notranslate"><spanclass="pre">run</span></code> support.</p>
<divclass="admonition-keep-in-mind admonition">
<pclass="admonition-title">Keep in Mind</p>
<p>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 <aclass="reference internal"href="#flask.app.Flask.run"title="flask.app.Flask.run"><codeclass="xref py py-meth docutils literal notranslate"><spanclass="pre">run()</span></code></a> with <codeclass="docutils literal notranslate"><spanclass="pre">debug=True</span></code> and <codeclass="docutils literal notranslate"><spanclass="pre">use_reloader=False</span></code>.
Setting <codeclass="docutils literal notranslate"><spanclass="pre">use_debugger</span></code> to <codeclass="docutils literal notranslate"><spanclass="pre">True</span></code> without being in debug mode
won’t catch any exceptions because there won’t be any to
<li><p><strong>host</strong>– the hostname to listen on. Set this to <codeclass="docutils literal notranslate"><spanclass="pre">'0.0.0.0'</span></code> to
have the server available externally as well. Defaults to
<codeclass="docutils literal notranslate"><spanclass="pre">'127.0.0.1'</span></code> or the host in the <codeclass="docutils literal notranslate"><spanclass="pre">SERVER_NAME</span></code> config variable
if present.</p></li>
<li><p><strong>port</strong>– the port of the webserver. Defaults to <codeclass="docutils literal notranslate"><spanclass="pre">5000</span></code> or the
port defined in the <codeclass="docutils literal notranslate"><spanclass="pre">SERVER_NAME</span></code> config variable if present.</p></li>
<li><p><strong>debug</strong>– if given, enable or disable debug mode. See
<p><spanclass="versionmodified changed">Changed in version 0.10: </span>The default port is now picked from the <codeclass="docutils literal notranslate"><spanclass="pre">SERVER_NAME</span></code>
<spanclass="sig-name descname"><spanclass="pre">send_static_file</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">filename</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">str</span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><aclass="reference internal"href="#flask.wrappers.Response"title="flask.wrappers.Response"><spanclass="pre">Response</span></a></span></span><aclass="headerlink"href="#flask.app.Flask.send_static_file"title="Link to this definition"></a></dt>
<dd><p>The view function used to serve files from
<codeclass="xref py py-attr docutils literal notranslate"><spanclass="pre">static_folder</span></code>. A route is automatically registered for
this view at <codeclass="xref py py-attr docutils literal notranslate"><spanclass="pre">static_url_path</span></code> if <codeclass="xref py py-attr docutils literal notranslate"><spanclass="pre">static_folder</span></code> is
set.</p>
<p>Note this is a duplicate of the same method in the Flask
class.</p>
<divclass="versionadded">
<p><spanclass="versionmodified added">Added in version 0.5.</span></p>
<spanclass="sig-name descname"><spanclass="pre">session_interface</span></span><emclass="property"><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><aclass="reference internal"href="#flask.sessions.SessionInterface"title="flask.sessions.SessionInterface"><spanclass="pre">SessionInterface</span></a></em><emclass="property"><spanclass="w"></span><spanclass="p"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="pre"><flask.sessions.SecureCookieSessionInterface</span><spanclass="pre">object></span></em><aclass="headerlink"href="#flask.app.Flask.session_interface"title="Link to this definition"></a></dt>
<dd><p>the session interface to use. By default an instance of
<aclass="reference internal"href="#flask.sessions.SecureCookieSessionInterface"title="flask.sessions.SecureCookieSessionInterface"><codeclass="xref py py-class docutils literal notranslate"><spanclass="pre">SecureCookieSessionInterface</span></code></a> is used here.</p>
<divclass="versionadded">
<p><spanclass="versionmodified added">Added in version 0.8.</span></p>
<spanclass="sig-name descname"><spanclass="pre">test_cli_runner</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="o"><spanclass="pre">**</span></span><spanclass="n"><spanclass="pre">kwargs</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">t.Any</span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><aclass="reference internal"href="#flask.testing.FlaskCliRunner"title="flask.testing.FlaskCliRunner"><spanclass="pre">FlaskCliRunner</span></a></span></span><aclass="headerlink"href="#flask.app.Flask.test_cli_runner"title="Link to this definition"></a></dt>
<dd><p>Create a CLI runner for testing CLI commands.
See <spanclass="xref std std-ref">testing-cli</span>.</p>
<p>Returns an instance of <codeclass="xref py py-attr docutils literal notranslate"><spanclass="pre">test_cli_runner_class</span></code>, by default
<aclass="reference internal"href="#flask.testing.FlaskCliRunner"title="flask.testing.FlaskCliRunner"><codeclass="xref py py-class docutils literal notranslate"><spanclass="pre">FlaskCliRunner</span></code></a>. The Flask app object is
passed as the first argument.</p>
<divclass="versionadded">
<p><spanclass="versionmodified added">Added in version 1.0.</span></p>
<spanclass="sig-name descname"><spanclass="pre">test_client</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">use_cookies</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">bool</span></span><spanclass="w"></span><spanclass="o"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="default_value"><spanclass="pre">True</span></span></em>, <emclass="sig-param"><spanclass="o"><spanclass="pre">**</span></span><spanclass="n"><spanclass="pre">kwargs</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">t.Any</span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><aclass="reference internal"href="#flask.testing.FlaskClient"title="flask.testing.FlaskClient"><spanclass="pre">FlaskClient</span></a></span></span><aclass="headerlink"href="#flask.app.Flask.test_client"title="Link to this definition"></a></dt>
<dd><p>Creates a test client for this application. For information
about unit testing head over to <spanclass="xref std std-doc">/testing</span>.</p>
<p>Note that if you are testing for assertions or exceptions in your
application code, you must set <codeclass="docutils literal notranslate"><spanclass="pre">app.testing</span><spanclass="pre">=</span><spanclass="pre">True</span></code> 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 <codeclass="xref py py-attr docutils literal notranslate"><spanclass="pre">testing</span></code>
<p>See <aclass="reference internal"href="#flask.testing.FlaskClient"title="flask.testing.FlaskClient"><codeclass="xref py py-class docutils literal notranslate"><spanclass="pre">FlaskClient</span></code></a> for more information.</p>
<divclass="versionchanged">
<p><spanclass="versionmodified changed">Changed in version 0.4: </span>added support for <codeclass="docutils literal notranslate"><spanclass="pre">with</span></code> block usage for the client.</p>
</div>
<divclass="versionadded">
<p><spanclass="versionmodified added">Added in version 0.7: </span>The <cite>use_cookies</cite> parameter was added as well as the ability
<spanclass="sig-name descname"><spanclass="pre">test_request_context</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="o"><spanclass="pre">*</span></span><spanclass="n"><spanclass="pre">args</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">Any</span></span></em>, <emclass="sig-param"><spanclass="o"><spanclass="pre">**</span></span><spanclass="n"><spanclass="pre">kwargs</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">Any</span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><aclass="reference internal"href="#flask.ctx.RequestContext"title="flask.ctx.RequestContext"><spanclass="pre">RequestContext</span></a></span></span><aclass="headerlink"href="#flask.app.Flask.test_request_context"title="Link to this definition"></a></dt>
<dd><p>Create a <aclass="reference internal"href="#flask.ctx.RequestContext"title="flask.ctx.RequestContext"><codeclass="xref py py-class docutils literal notranslate"><spanclass="pre">RequestContext</span></code></a> 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.</p>
<li><p><strong>data</strong>– The request body, either as a string or a dict of
form keys and values.</p></li>
<li><p><strong>json</strong>– If given, this is serialized as JSON and passed as
<codeclass="docutils literal notranslate"><spanclass="pre">data</span></code>. Also defaults <codeclass="docutils literal notranslate"><spanclass="pre">content_type</span></code> to
<spanclass="sig-name descname"><spanclass="pre">update_template_context</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">context</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">dict</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="pre">str</span><spanclass="p"><spanclass="pre">,</span></span><spanclass="w"></span><spanclass="pre">Any</span><spanclass="p"><spanclass="pre">]</span></span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">None</span></span></span><aclass="headerlink"href="#flask.app.Flask.update_template_context"title="Link to this definition"></a></dt>
<dd><p>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
<li><p><strong>endpoint</strong>– The endpoint name associated with the URL to
generate. If this starts with a <codeclass="docutils literal notranslate"><spanclass="pre">.</span></code>, the current blueprint
name (if any) will be used.</p></li>
<li><p><strong>_anchor</strong>– If given, append this as <codeclass="docutils literal notranslate"><spanclass="pre">#anchor</span></code> to the URL.</p></li>
<li><p><strong>_method</strong>– If given, generate the URL associated with this
method for the endpoint.</p></li>
<li><p><strong>_scheme</strong>– If given, the URL will have this scheme if it
is external.</p></li>
<li><p><strong>_external</strong>– 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.</p></li>
<li><p><strong>values</strong>– Values to use for the variable parts of the URL
rule. Unknown keys are appended as query string arguments,
like <codeclass="docutils literal notranslate"><spanclass="pre">?a=b&c=d</span></code>.</p></li>
</ul>
</dd>
</dl>
<divclass="versionadded">
<p><spanclass="versionmodified added">Added in version 2.2: </span>Moved from <codeclass="docutils literal notranslate"><spanclass="pre">flask.url_for</span></code>, which calls this method.</p>
<spanclass="sig-name descname"><spanclass="pre">wsgi_app</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">environ</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">WSGIEnvironment</span></span></em>, <emclass="sig-param"><spanclass="n"><spanclass="pre">start_response</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">StartResponse</span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">cabc.Iterable</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="pre">bytes</span><spanclass="p"><spanclass="pre">]</span></span></span></span><aclass="headerlink"href="#flask.app.Flask.wsgi_app"title="Link to this definition"></a></dt>
<dd><p>The actual WSGI application. This is not implemented in
<codeclass="xref py py-meth docutils literal notranslate"><spanclass="pre">__call__()</span></code> so that middlewares can be applied without
losing a reference to the app object. Instead of doing this:</p>
<li><p><strong>environ</strong>– A WSGI environment.</p></li>
<li><p><strong>start_response</strong>– A callable accepting a status code,
a list of headers, and an optional exception context to
start the response.</p></li>
</ul>
</dd>
</dl>
</dd></dl>
</dd></dl>
</section>
<sectionid="module-flask.blueprints">
<spanid="flask-blueprints-module"></span><h2>flask.blueprints module<aclass="headerlink"href="#module-flask.blueprints"title="Link to this heading"></a></h2>
<spanclass="sig-name descname"><spanclass="pre">cli</span></span><emclass="property"><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="pre">Group</span></em><aclass="headerlink"href="#flask.blueprints.Blueprint.cli"title="Link to this definition"></a></dt>
<dd><p>The Click command group for registering CLI commands for this
object. The commands are available from the <codeclass="docutils literal notranslate"><spanclass="pre">flask</span></code> command
once the application has been discovered and blueprints have
<spanclass="sig-name descname"><spanclass="pre">get_send_file_max_age</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">filename</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">str</span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">None</span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">int</span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">None</span></span></span><aclass="headerlink"href="#flask.blueprints.Blueprint.get_send_file_max_age"title="Link to this definition"></a></dt>
<dd><p>Used by <codeclass="xref py py-func docutils literal notranslate"><spanclass="pre">send_file()</span></code> to determine the <codeclass="docutils literal notranslate"><spanclass="pre">max_age</span></code> cache
value for a given file path if it wasn’t passed.</p>
<p>By default, this returns <codeclass="xref py py-data docutils literal notranslate"><spanclass="pre">SEND_FILE_MAX_AGE_DEFAULT</span></code> from
the configuration of <codeclass="xref py py-data docutils literal notranslate"><spanclass="pre">current_app</span></code>. This defaults
to <codeclass="docutils literal notranslate"><spanclass="pre">None</span></code>, which tells the browser to use conditional requests
instead of a timed cache, which is usually preferable.</p>
<p>Note this is a duplicate of the same method in the Flask
class.</p>
<divclass="versionchanged">
<p><spanclass="versionmodified changed">Changed in version 2.0: </span>The default configuration is <codeclass="docutils literal notranslate"><spanclass="pre">None</span></code> instead of 12 hours.</p>
</div>
<divclass="versionadded">
<p><spanclass="versionmodified added">Added in version 0.9.</span></p>
<spanclass="sig-name descname"><spanclass="pre">open_resource</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">resource</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">str</span></span></em>, <emclass="sig-param"><spanclass="n"><spanclass="pre">mode</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">str</span></span><spanclass="w"></span><spanclass="o"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="default_value"><spanclass="pre">'rb'</span></span></em>, <emclass="sig-param"><spanclass="n"><spanclass="pre">encoding</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">str</span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">None</span></span><spanclass="w"></span><spanclass="o"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="default_value"><spanclass="pre">'utf-8'</span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">IO</span></span></span><aclass="headerlink"href="#flask.blueprints.Blueprint.open_resource"title="Link to this definition"></a></dt>
<dd><p>Open a resource file relative to <codeclass="xref py py-attr docutils literal notranslate"><spanclass="pre">root_path</span></code> for reading. The
blueprint-relative equivalent of the app’s <aclass="reference internal"href="#flask.app.Flask.open_resource"title="flask.app.Flask.open_resource"><codeclass="xref py py-meth docutils literal notranslate"><spanclass="pre">open_resource()</span></code></a>
<li><p><strong>resource</strong>– Path to the resource relative to <codeclass="xref py py-attr docutils literal notranslate"><spanclass="pre">root_path</span></code>.</p></li>
<li><p><strong>mode</strong>– Open the file in this mode. Only reading is supported,
valid values are <codeclass="docutils literal notranslate"><spanclass="pre">"r"</span></code> (or <codeclass="docutils literal notranslate"><spanclass="pre">"rt"</span></code>) and <codeclass="docutils literal notranslate"><spanclass="pre">"rb"</span></code>.</p></li>
<li><p><strong>encoding</strong>– Open the file with this encoding when opening in text
mode. This is ignored when opening in binary mode.</p></li>
</ul>
</dd>
</dl>
<divclass="versionchanged">
<p><spanclass="versionmodified changed">Changed in version 3.1: </span>Added the <codeclass="docutils literal notranslate"><spanclass="pre">encoding</span></code> parameter.</p>
<spanclass="sig-name descname"><spanclass="pre">send_static_file</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">filename</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">str</span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><aclass="reference internal"href="#flask.wrappers.Response"title="flask.wrappers.Response"><spanclass="pre">Response</span></a></span></span><aclass="headerlink"href="#flask.blueprints.Blueprint.send_static_file"title="Link to this definition"></a></dt>
<dd><p>The view function used to serve files from
<codeclass="xref py py-attr docutils literal notranslate"><spanclass="pre">static_folder</span></code>. A route is automatically registered for
this view at <codeclass="xref py py-attr docutils literal notranslate"><spanclass="pre">static_url_path</span></code> if <codeclass="xref py py-attr docutils literal notranslate"><spanclass="pre">static_folder</span></code> is
set.</p>
<p>Note this is a duplicate of the same method in the Flask
class.</p>
<divclass="versionadded">
<p><spanclass="versionmodified added">Added in version 0.5.</span></p>
</div>
</dd></dl>
</dd></dl>
</section>
<sectionid="module-flask.cli">
<spanid="flask-cli-module"></span><h2>flask.cli module<aclass="headerlink"href="#module-flask.cli"title="Link to this heading"></a></h2>
<emclass="property"><spanclass="pre">class</span><spanclass="w"></span></em><spanclass="sig-prename descclassname"><spanclass="pre">flask.cli.</span></span><spanclass="sig-name descname"><spanclass="pre">AppGroup</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">name</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">str</span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">None</span></span><spanclass="w"></span><spanclass="o"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="default_value"><spanclass="pre">None</span></span></em>, <emclass="sig-param"><spanclass="n"><spanclass="pre">commands</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">MutableMapping</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="pre">str</span><spanclass="p"><spanclass="pre">,</span></span><spanclass="w"></span><spanclass="pre">Command</span><spanclass="p"><spanclass="pre">]</span></span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">Sequence</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="pre">Command</span><spanclass="p"><spanclass="pre">]</span></span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">None</span></span><spanclass="w"></span><spanclass="o"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="default_value"><spanclass="pre">None</span></span></em>, <emclass="sig-param"><spanclass="o"><spanclass="pre">**</span></span><spanclass="n"><spanclass="pre">attrs</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">Any</span></span></em><spanclass="sig-paren">)</span><aclass="headerlink"href="#flask.cli.AppGroup"title="Link to this definition"></a></dt>
<p>This works similar to a regular click <codeclass="xref py py-class docutils literal notranslate"><spanclass="pre">Group</span></code> but it
changes the behavior of the <aclass="reference internal"href="#flask.cli.AppGroup.command"title="flask.cli.AppGroup.command"><codeclass="xref py py-meth docutils literal notranslate"><spanclass="pre">command()</span></code></a> decorator so that it
automatically wraps the functions in <aclass="reference internal"href="#flask.cli.with_appcontext"title="flask.cli.with_appcontext"><codeclass="xref py py-func docutils literal notranslate"><spanclass="pre">with_appcontext()</span></code></a>.</p>
<p>Not to be confused with <aclass="reference internal"href="#flask.cli.FlaskGroup"title="flask.cli.FlaskGroup"><codeclass="xref py py-class docutils literal notranslate"><spanclass="pre">FlaskGroup</span></code></a>.</p>
<spanclass="sig-name descname"><spanclass="pre">command</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="o"><spanclass="pre">*</span></span><spanclass="n"><spanclass="pre">args</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">Any</span></span></em>, <emclass="sig-param"><spanclass="o"><spanclass="pre">**</span></span><spanclass="n"><spanclass="pre">kwargs</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">Any</span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">Callable</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="p"><spanclass="pre">[</span></span><spanclass="pre">Callable</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="p"><spanclass="pre">[</span></span><spanclass="p"><spanclass="pre">...</span></span><spanclass="p"><spanclass="pre">]</span></span><spanclass="p"><spanclass="pre">,</span></span><spanclass="w"></span><spanclass="pre">Any</span><spanclass="p"><spanclass="pre">]</span></span><spanclass="p"><spanclass="pre">]</span></span><spanclass="p"><spanclass="pre">,</span></span><spanclass="w"></span><spanclass="pre">Command</span><spanclass="p"><spanclass="pre">]</span></span></span></span><aclass="headerlink"href="#flask.cli.AppGroup.command"title="Link to this definition"></a></dt>
<dd><p>This works exactly like the method of the same name on a regular
<codeclass="xref py py-class docutils literal notranslate"><spanclass="pre">click.Group</span></code> but it wraps callbacks in <aclass="reference internal"href="#flask.cli.with_appcontext"title="flask.cli.with_appcontext"><codeclass="xref py py-func docutils literal notranslate"><spanclass="pre">with_appcontext()</span></code></a>
unless it’s disabled by passing <codeclass="docutils literal notranslate"><spanclass="pre">with_appcontext=False</span></code>.</p>
<spanclass="sig-name descname"><spanclass="pre">group</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="o"><spanclass="pre">*</span></span><spanclass="n"><spanclass="pre">args</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">Any</span></span></em>, <emclass="sig-param"><spanclass="o"><spanclass="pre">**</span></span><spanclass="n"><spanclass="pre">kwargs</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">Any</span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">Callable</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="p"><spanclass="pre">[</span></span><spanclass="pre">Callable</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="p"><spanclass="pre">[</span></span><spanclass="p"><spanclass="pre">...</span></span><spanclass="p"><spanclass="pre">]</span></span><spanclass="p"><spanclass="pre">,</span></span><spanclass="w"></span><spanclass="pre">Any</span><spanclass="p"><spanclass="pre">]</span></span><spanclass="p"><spanclass="pre">]</span></span><spanclass="p"><spanclass="pre">,</span></span><spanclass="w"></span><spanclass="pre">Group</span><spanclass="p"><spanclass="pre">]</span></span></span></span><aclass="headerlink"href="#flask.cli.AppGroup.group"title="Link to this definition"></a></dt>
<dd><p>This works exactly like the method of the same name on a regular
<codeclass="xref py py-class docutils literal notranslate"><spanclass="pre">click.Group</span></code> but it defaults the group class to
<emclass="property"><spanclass="pre">class</span><spanclass="w"></span></em><spanclass="sig-prename descclassname"><spanclass="pre">flask.cli.</span></span><spanclass="sig-name descname"><spanclass="pre">CertParamType</span></span><aclass="headerlink"href="#flask.cli.CertParamType"title="Link to this definition"></a></dt>
<spanclass="sig-name descname"><spanclass="pre">convert</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">value</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">Any</span></span></em>, <emclass="sig-param"><spanclass="n"><spanclass="pre">param</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">Parameter</span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">None</span></span></em>, <emclass="sig-param"><spanclass="n"><spanclass="pre">ctx</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">Context</span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">None</span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">Any</span></span></span><aclass="headerlink"href="#flask.cli.CertParamType.convert"title="Link to this definition"></a></dt>
<dd><p>Convert the value to the correct type. This is not called if
the value is <codeclass="docutils literal notranslate"><spanclass="pre">None</span></code> (the missing value).</p>
<p>This must accept string values from the command line, as well as
values that are already the correct type. It may also convert
other compatible types.</p>
<p>The <codeclass="docutils literal notranslate"><spanclass="pre">param</span></code> and <codeclass="docutils literal notranslate"><spanclass="pre">ctx</span></code> arguments may be <codeclass="docutils literal notranslate"><spanclass="pre">None</span></code> in certain
situations, such as when converting prompt input.</p>
<p>If the value cannot be converted, call <codeclass="xref py py-meth docutils literal notranslate"><spanclass="pre">fail()</span></code> with a
<spanclass="sig-name descname"><spanclass="pre">name</span></span><emclass="property"><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="pre">str</span></em><emclass="property"><spanclass="w"></span><spanclass="p"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="pre">'path'</span></em><aclass="headerlink"href="#flask.cli.CertParamType.name"title="Link to this definition"></a></dt>
<p>Special subclass of the <aclass="reference internal"href="#flask.cli.AppGroup"title="flask.cli.AppGroup"><codeclass="xref py py-class docutils literal notranslate"><spanclass="pre">AppGroup</span></code></a> group that supports
loading more commands from the configured Flask app. Normally a
developer does not have to interface with this class but there are
some very advanced use cases for which it makes sense to create an
instance of this. see <spanclass="xref std std-ref">custom-scripts</span>.</p>
<li><p><strong>add_default_commands</strong>– if this is True then the default run and
shell commands will be added.</p></li>
<li><p><strong>add_version_option</strong>– adds the <codeclass="docutils literal notranslate"><spanclass="pre">--version</span></code> option.</p></li>
<li><p><strong>create_app</strong>– an optional callback that is passed the script info and
returns the loaded app.</p></li>
<li><p><strong>load_dotenv</strong>– Load the nearest <codeclass="file docutils literal notranslate"><spanclass="pre">.env</span></code> and <codeclass="file docutils literal notranslate"><spanclass="pre">.flaskenv</span></code>
files to set environment variables. Will also change the working
directory to the directory containing the first file found.</p></li>
<li><p><strong>set_debug_flag</strong>– Set the app’s debug flag.</p></li>
</ul>
</dd>
</dl>
<divclass="versionchanged">
<p><spanclass="versionmodified changed">Changed in version 3.1: </span><codeclass="docutils literal notranslate"><spanclass="pre">-e</span><spanclass="pre">path</span></code> takes precedence over default <codeclass="docutils literal notranslate"><spanclass="pre">.env</span></code> and <codeclass="docutils literal notranslate"><spanclass="pre">.flaskenv</span></code> files.</p>
</div>
<divclass="versionchanged">
<p><spanclass="versionmodified changed">Changed in version 2.2: </span>Added the <codeclass="docutils literal notranslate"><spanclass="pre">-A/--app</span></code>, <codeclass="docutils literal notranslate"><spanclass="pre">--debug/--no-debug</span></code>, <codeclass="docutils literal notranslate"><spanclass="pre">-e/--env-file</span></code> options.</p>
</div>
<divclass="versionchanged">
<p><spanclass="versionmodified changed">Changed in version 2.2: </span>An app context is pushed when running <codeclass="docutils literal notranslate"><spanclass="pre">app.cli</span></code> commands, so
<codeclass="docutils literal notranslate"><spanclass="pre">@with_appcontext</span></code> is no longer required for those commands.</p>
</div>
<divclass="versionchanged">
<p><spanclass="versionmodified changed">Changed in version 1.0: </span>If installed, python-dotenv will be used to load environment variables
from <codeclass="file docutils literal notranslate"><spanclass="pre">.env</span></code> and <codeclass="file docutils literal notranslate"><spanclass="pre">.flaskenv</span></code> files.</p>
<spanclass="sig-name descname"><spanclass="pre">get_command</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">ctx</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">Context</span></span></em>, <emclass="sig-param"><spanclass="n"><spanclass="pre">name</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">str</span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">Command</span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">None</span></span></span><aclass="headerlink"href="#flask.cli.FlaskGroup.get_command"title="Link to this definition"></a></dt>
<dd><p>Given a context and a command name, this returns a
<codeclass="xref py py-class docutils literal notranslate"><spanclass="pre">Command</span></code> object if it exists or returns <cite>None</cite>.</p>
<spanclass="sig-name descname"><spanclass="pre">list_commands</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">ctx</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">Context</span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">list</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="pre">str</span><spanclass="p"><spanclass="pre">]</span></span></span></span><aclass="headerlink"href="#flask.cli.FlaskGroup.list_commands"title="Link to this definition"></a></dt>
<dd><p>Returns a list of subcommand names in the order they should
<spanclass="sig-name descname"><spanclass="pre">make_context</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">info_name</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">str</span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">None</span></span></em>, <emclass="sig-param"><spanclass="n"><spanclass="pre">args</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">list</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="pre">str</span><spanclass="p"><spanclass="pre">]</span></span></span></em>, <emclass="sig-param"><spanclass="n"><spanclass="pre">parent</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">Context</span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">None</span></span><spanclass="w"></span><spanclass="o"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="default_value"><spanclass="pre">None</span></span></em>, <emclass="sig-param"><spanclass="o"><spanclass="pre">**</span></span><spanclass="n"><spanclass="pre">extra</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">Any</span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">Context</span></span></span><aclass="headerlink"href="#flask.cli.FlaskGroup.make_context"title="Link to this definition"></a></dt>
<dd><p>This function when given an info name and arguments will kick
off the parsing and create a new <codeclass="xref py py-class docutils literal notranslate"><spanclass="pre">Context</span></code>. It does not
invoke the actual command callback though.</p>
<p>To quickly customize the context class used without overriding
this method, set the <codeclass="xref py py-attr docutils literal notranslate"><spanclass="pre">context_class</span></code> attribute.</p>
<li><p><strong>info_name</strong>– the info name for this invocation. Generally this
is the most descriptive name for the script or
command. For the toplevel script it’s usually
the name of the script, for commands below it’s
the name of the command.</p></li>
<li><p><strong>args</strong>– the arguments to parse as list of strings.</p></li>
<li><p><strong>parent</strong>– the parent context if available.</p></li>
<li><p><strong>extra</strong>– extra keyword arguments forwarded to the context
constructor.</p></li>
</ul>
</dd>
</dl>
<divclass="versionchanged">
<p><spanclass="versionmodified changed">Changed in version 8.0: </span>Added the <codeclass="xref py py-attr docutils literal notranslate"><spanclass="pre">context_class</span></code> attribute.</p>
<spanclass="sig-name descname"><spanclass="pre">parse_args</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">ctx</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">Context</span></span></em>, <emclass="sig-param"><spanclass="n"><spanclass="pre">args</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">list</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="pre">str</span><spanclass="p"><spanclass="pre">]</span></span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">list</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="pre">str</span><spanclass="p"><spanclass="pre">]</span></span></span></span><aclass="headerlink"href="#flask.cli.FlaskGroup.parse_args"title="Link to this definition"></a></dt>
<dd><p>Given a context and a list of arguments this creates the parser
and parses the arguments, then modifies the context as necessary.
This is automatically invoked by <aclass="reference internal"href="#flask.cli.FlaskGroup.make_context"title="flask.cli.FlaskGroup.make_context"><codeclass="xref py py-meth docutils literal notranslate"><spanclass="pre">make_context()</span></code></a>.</p>
<emclass="property"><spanclass="pre">exception</span><spanclass="w"></span></em><spanclass="sig-prename descclassname"><spanclass="pre">flask.cli.</span></span><spanclass="sig-name descname"><spanclass="pre">NoAppException</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">message</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">str</span></span></em>, <emclass="sig-param"><spanclass="n"><spanclass="pre">ctx</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">Context</span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">None</span></span><spanclass="w"></span><spanclass="o"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="default_value"><spanclass="pre">None</span></span></em><spanclass="sig-paren">)</span><aclass="headerlink"href="#flask.cli.NoAppException"title="Link to this definition"></a></dt>
<emclass="property"><spanclass="pre">class</span><spanclass="w"></span></em><spanclass="sig-prename descclassname"><spanclass="pre">flask.cli.</span></span><spanclass="sig-name descname"><spanclass="pre">ScriptInfo</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">app_import_path</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">str</span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">None</span></span><spanclass="w"></span><spanclass="o"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="default_value"><spanclass="pre">None</span></span></em>, <emclass="sig-param"><spanclass="n"><spanclass="pre">create_app</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">t.Callable</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="p"><spanclass="pre">...</span></span><spanclass="p"><spanclass="pre">,</span></span><spanclass="w"></span><aclass="reference internal"href="#flask.app.Flask"title="flask.app.Flask"><spanclass="pre">Flask</span></a><spanclass="p"><spanclass="pre">]</span></span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">None</span></span><spanclass="w"></span><spanclass="o"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="default_value"><spanclass="pre">None</span></span></em>, <emclass="sig-param"><spanclass="n"><spanclass="pre">set_debug_flag</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">bool</span></span><spanclass="w"></span><spanclass="o"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="default_value"><spanclass="pre">True</span></span></em>, <emclass="sig-param"><spanclass="n"><spanclass="pre">load_dotenv_defaults</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">bool</span></span><spanclass="w"></span><spanclass="o"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="default_value"><spanclass="pre">True</span></span></em><spanclass="sig-paren">)</span><aclass="headerlink"href="#flask.cli.ScriptInfo"title="Link to this definition"></a></dt>
<p>Helper object to deal with Flask applications. This is usually not
necessary to interface with as it’s used internally in the dispatching
to click. In future versions of Flask this object will most likely play
a bigger role. Typically it’s created automatically by the
<aclass="reference internal"href="#flask.cli.FlaskGroup"title="flask.cli.FlaskGroup"><codeclass="xref py py-class docutils literal notranslate"><spanclass="pre">FlaskGroup</span></code></a> but you can also manually create it and pass it
onwards as click object.</p>
<divclass="versionchanged">
<p><spanclass="versionmodified changed">Changed in version 3.1: </span>Added the <codeclass="docutils literal notranslate"><spanclass="pre">load_dotenv_defaults</span></code> parameter and attribute.</p>
<spanclass="sig-name descname"><spanclass="pre">app_import_path</span></span><aclass="headerlink"href="#flask.cli.ScriptInfo.app_import_path"title="Link to this definition"></a></dt>
<dd><p>Optionally the import path for the Flask application.</p>
<spanclass="sig-name descname"><spanclass="pre">create_app</span></span><aclass="headerlink"href="#flask.cli.ScriptInfo.create_app"title="Link to this definition"></a></dt>
<dd><p>Optionally a function that is passed the script info to create
<spanclass="sig-name descname"><spanclass="pre">data</span></span><emclass="property"><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="pre">dict</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="pre">t.Any</span><spanclass="p"><spanclass="pre">,</span></span><spanclass="w"></span><spanclass="pre">t.Any</span><spanclass="p"><spanclass="pre">]</span></span></em><aclass="headerlink"href="#flask.cli.ScriptInfo.data"title="Link to this definition"></a></dt>
<dd><p>A dictionary with arbitrary data that can be associated with
<spanclass="sig-name descname"><spanclass="pre">load_app</span></span><spanclass="sig-paren">(</span><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><aclass="reference internal"href="#flask.app.Flask"title="flask.app.Flask"><spanclass="pre">Flask</span></a></span></span><aclass="headerlink"href="#flask.cli.ScriptInfo.load_app"title="Link to this definition"></a></dt>
<dd><p>Loads the Flask app (if not yet loaded) and returns it. Calling
this multiple times will just result in the already loaded app to
<spanclass="sig-name descname"><spanclass="pre">load_dotenv_defaults</span></span><aclass="headerlink"href="#flask.cli.ScriptInfo.load_dotenv_defaults"title="Link to this definition"></a></dt>
<dd><p>Whether default <codeclass="docutils literal notranslate"><spanclass="pre">.flaskenv</span></code> and <codeclass="docutils literal notranslate"><spanclass="pre">.env</span></code> files should be loaded.</p>
<p><codeclass="docutils literal notranslate"><spanclass="pre">ScriptInfo</span></code> doesn’t load anything, this is for reference when doing
the load elsewhere during processing.</p>
<divclass="versionadded">
<p><spanclass="versionmodified added">Added in version 3.1.</span></p>
<p>Click option type that accepts a list of values separated by the
OS’s path separator (<codeclass="docutils literal notranslate"><spanclass="pre">:</span></code>, <codeclass="docutils literal notranslate"><spanclass="pre">;</span></code> on Windows). Each value is
validated as a <codeclass="xref py py-class docutils literal notranslate"><spanclass="pre">click.Path</span></code> type.</p>
<spanclass="sig-name descname"><spanclass="pre">convert</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">value</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">Any</span></span></em>, <emclass="sig-param"><spanclass="n"><spanclass="pre">param</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">Parameter</span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">None</span></span></em>, <emclass="sig-param"><spanclass="n"><spanclass="pre">ctx</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">Context</span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">None</span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">Any</span></span></span><aclass="headerlink"href="#flask.cli.SeparatedPathType.convert"title="Link to this definition"></a></dt>
<dd><p>Convert the value to the correct type. This is not called if
the value is <codeclass="docutils literal notranslate"><spanclass="pre">None</span></code> (the missing value).</p>
<p>This must accept string values from the command line, as well as
values that are already the correct type. It may also convert
other compatible types.</p>
<p>The <codeclass="docutils literal notranslate"><spanclass="pre">param</span></code> and <codeclass="docutils literal notranslate"><spanclass="pre">ctx</span></code> arguments may be <codeclass="docutils literal notranslate"><spanclass="pre">None</span></code> in certain
situations, such as when converting prompt input.</p>
<p>If the value cannot be converted, call <codeclass="xref py py-meth docutils literal notranslate"><spanclass="pre">fail()</span></code> with a
<spanclass="sig-prename descclassname"><spanclass="pre">flask.cli.</span></span><spanclass="sig-name descname"><spanclass="pre">find_app_by_string</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">module</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">ModuleType</span></span></em>, <emclass="sig-param"><spanclass="n"><spanclass="pre">app_name</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">str</span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><aclass="reference internal"href="#flask.app.Flask"title="flask.app.Flask"><spanclass="pre">Flask</span></a></span></span><aclass="headerlink"href="#flask.cli.find_app_by_string"title="Link to this definition"></a></dt>
<dd><p>Check if the given string is a variable name or a function. Call
a function to get the app instance, or return the variable directly.</p>
<spanclass="sig-prename descclassname"><spanclass="pre">flask.cli.</span></span><spanclass="sig-name descname"><spanclass="pre">find_best_app</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">module</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">ModuleType</span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><aclass="reference internal"href="#flask.app.Flask"title="flask.app.Flask"><spanclass="pre">Flask</span></a></span></span><aclass="headerlink"href="#flask.cli.find_best_app"title="Link to this definition"></a></dt>
<dd><p>Given a module instance this tries to find the best possible
application in the module or raises an exception.</p>
<spanclass="sig-prename descclassname"><spanclass="pre">flask.cli.</span></span><spanclass="sig-name descname"><spanclass="pre">get_version</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">ctx</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">Context</span></span></em>, <emclass="sig-param"><spanclass="n"><spanclass="pre">param</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">Parameter</span></span></em>, <emclass="sig-param"><spanclass="n"><spanclass="pre">value</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">Any</span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">None</span></span></span><aclass="headerlink"href="#flask.cli.get_version"title="Link to this definition"></a></dt>
<spanclass="sig-prename descclassname"><spanclass="pre">flask.cli.</span></span><spanclass="sig-name descname"><spanclass="pre">load_dotenv</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">path</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">str</span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">PathLike</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="pre">str</span><spanclass="p"><spanclass="pre">]</span></span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">None</span></span><spanclass="w"></span><spanclass="o"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="default_value"><spanclass="pre">None</span></span></em>, <emclass="sig-param"><spanclass="n"><spanclass="pre">load_defaults</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">bool</span></span><spanclass="w"></span><spanclass="o"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="default_value"><spanclass="pre">True</span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">bool</span></span></span><aclass="headerlink"href="#flask.cli.load_dotenv"title="Link to this definition"></a></dt>
<dd><p>Load “dotenv” files to set environment variables. A given path takes
precedence over <codeclass="docutils literal notranslate"><spanclass="pre">.env</span></code>, which takes precedence over <codeclass="docutils literal notranslate"><spanclass="pre">.flaskenv</span></code>. After
loading and combining these files, values are only set if the key is not
already set in <codeclass="docutils literal notranslate"><spanclass="pre">os.environ</span></code>.</p>
<p>This is a no-op if <aclass="reference external"href="https://github.com/theskumar/python-dotenv#readme">python-dotenv</a> is not installed.</p>
<li><p><strong>path</strong>– Load the file at this location.</p></li>
<li><p><strong>load_defaults</strong>– Search for and load the default <codeclass="docutils literal notranslate"><spanclass="pre">.flaskenv</span></code> and
<ddclass="field-even"><p><codeclass="docutils literal notranslate"><spanclass="pre">True</span></code> if at least one env var was loaded.</p>
</dd>
</dl>
<divclass="versionchanged">
<p><spanclass="versionmodified changed">Changed in version 3.1: </span>Added the <codeclass="docutils literal notranslate"><spanclass="pre">load_defaults</span></code> parameter. A given path takes precedence
over default files.</p>
</div>
<divclass="versionchanged">
<p><spanclass="versionmodified changed">Changed in version 2.0: </span>The current directory is not changed to the location of the
loaded file.</p>
</div>
<divclass="versionchanged">
<p><spanclass="versionmodified changed">Changed in version 2.0: </span>When loading the env files, set the default encoding to UTF-8.</p>
</div>
<divclass="versionchanged">
<p><spanclass="versionmodified changed">Changed in version 1.1.0: </span>Returns <codeclass="docutils literal notranslate"><spanclass="pre">False</span></code> when python-dotenv is not installed, or when
the given path isn’t a file.</p>
</div>
<divclass="versionadded">
<p><spanclass="versionmodified added">Added in version 1.0.</span></p>
<spanclass="sig-prename descclassname"><spanclass="pre">flask.cli.</span></span><spanclass="sig-name descname"><spanclass="pre">locate_app</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">module_name</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">str</span></span></em>, <emclass="sig-param"><spanclass="n"><spanclass="pre">app_name</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">str</span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">None</span></span></em>, <emclass="sig-param"><spanclass="n"><spanclass="pre">raise_if_not_found</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">Literal</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="k"><spanclass="pre">True</span></span><spanclass="p"><spanclass="pre">]</span></span></span><spanclass="w"></span><spanclass="o"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="default_value"><spanclass="pre">True</span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><aclass="reference internal"href="#flask.app.Flask"title="flask.app.Flask"><spanclass="pre">Flask</span></a></span></span><aclass="headerlink"href="#flask.cli.locate_app"title="Link to this definition"></a></dt>
<spanclass="sig-prename descclassname"><spanclass="pre">flask.cli.</span></span><spanclass="sig-name descname"><spanclass="pre">main</span></span><spanclass="sig-paren">(</span><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">None</span></span></span><aclass="headerlink"href="#flask.cli.main"title="Link to this definition"></a></dt>
<spanclass="sig-prename descclassname"><spanclass="pre">flask.cli.</span></span><spanclass="sig-name descname"><spanclass="pre">prepare_import</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">path</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">str</span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">str</span></span></span><aclass="headerlink"href="#flask.cli.prepare_import"title="Link to this definition"></a></dt>
<dd><p>Given a filename this will try to calculate the python path, add it
to the search path and return the actual module name that is expected.</p>
<spanclass="sig-prename descclassname"><spanclass="pre">flask.cli.</span></span><spanclass="sig-name descname"><spanclass="pre">show_server_banner</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">debug</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">bool</span></span></em>, <emclass="sig-param"><spanclass="n"><spanclass="pre">app_import_path</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">str</span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">None</span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">None</span></span></span><aclass="headerlink"href="#flask.cli.show_server_banner"title="Link to this definition"></a></dt>
<dd><p>Show extra startup messages the first time the server is run,
<spanclass="sig-prename descclassname"><spanclass="pre">flask.cli.</span></span><spanclass="sig-name descname"><spanclass="pre">with_appcontext</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">f</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">F</span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">F</span></span></span><aclass="headerlink"href="#flask.cli.with_appcontext"title="Link to this definition"></a></dt>
<dd><p>Wraps a callback so that it’s guaranteed to be executed with the
script’s application context.</p>
<p>Custom commands (and their options) registered under <codeclass="docutils literal notranslate"><spanclass="pre">app.cli</span></code> or
<codeclass="docutils literal notranslate"><spanclass="pre">blueprint.cli</span></code> will always have an app context available, this
decorator is not required in that case.</p>
<divclass="versionchanged">
<p><spanclass="versionmodified changed">Changed in version 2.2: </span>The app context is active for subcommands as well as the
decorated callback. The app context is always available to
<codeclass="docutils literal notranslate"><spanclass="pre">app.cli</span></code> command and parameter callbacks.</p>
</div>
</dd></dl>
</section>
<sectionid="module-flask.config">
<spanid="flask-config-module"></span><h2>flask.config module<aclass="headerlink"href="#module-flask.config"title="Link to this heading"></a></h2>
<emclass="property"><spanclass="pre">class</span><spanclass="w"></span></em><spanclass="sig-prename descclassname"><spanclass="pre">flask.config.</span></span><spanclass="sig-name descname"><spanclass="pre">Config</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">root_path</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">str</span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">PathLike</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="pre">str</span><spanclass="p"><spanclass="pre">]</span></span></span></em>, <emclass="sig-param"><spanclass="n"><spanclass="pre">defaults</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">dict</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="pre">str</span><spanclass="p"><spanclass="pre">,</span></span><spanclass="w"></span><spanclass="pre">Any</span><spanclass="p"><spanclass="pre">]</span></span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">None</span></span><spanclass="w"></span><spanclass="o"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="default_value"><spanclass="pre">None</span></span></em><spanclass="sig-paren">)</span><aclass="headerlink"href="#flask.config.Config"title="Link to this definition"></a></dt>
<p>Or alternatively you can define the configuration options in the
module that calls <aclass="reference internal"href="#flask.config.Config.from_object"title="flask.config.Config.from_object"><codeclass="xref py py-meth docutils literal notranslate"><spanclass="pre">from_object()</span></code></a> or provide an import path to
a module that should be loaded. It is also possible to tell it to
use the same module and with that provide the configuration values
<spanclass="sig-name descname"><spanclass="pre">from_envvar</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">variable_name</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">str</span></span></em>, <emclass="sig-param"><spanclass="n"><spanclass="pre">silent</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">bool</span></span><spanclass="w"></span><spanclass="o"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="default_value"><spanclass="pre">False</span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">bool</span></span></span><aclass="headerlink"href="#flask.config.Config.from_envvar"title="Link to this definition"></a></dt>
<dd><p>Loads a configuration from an environment variable pointing to
a configuration file. This is basically just a shortcut with nicer
<li><p><strong>variable_name</strong>– name of the environment variable</p></li>
<li><p><strong>silent</strong>– set to <codeclass="docutils literal notranslate"><spanclass="pre">True</span></code> if you want silent failure for missing
<spanclass="sig-name descname"><spanclass="pre">from_file</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">filename</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">str</span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">PathLike</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="pre">str</span><spanclass="p"><spanclass="pre">]</span></span></span></em>, <emclass="sig-param"><spanclass="n"><spanclass="pre">load</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">Callable</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="p"><spanclass="pre">[</span></span><spanclass="pre">IO</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="pre">Any</span><spanclass="p"><spanclass="pre">]</span></span><spanclass="p"><spanclass="pre">]</span></span><spanclass="p"><spanclass="pre">,</span></span><spanclass="w"></span><spanclass="pre">Mapping</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="pre">str</span><spanclass="p"><spanclass="pre">,</span></span><spanclass="w"></span><spanclass="pre">Any</span><spanclass="p"><spanclass="pre">]</span></span><spanclass="p"><spanclass="pre">]</span></span></span></em>, <emclass="sig-param"><spanclass="n"><spanclass="pre">silent</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">bool</span></span><spanclass="w"></span><spanclass="o"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="default_value"><spanclass="pre">False</span></span></em>, <emclass="sig-param"><spanclass="n"><spanclass="pre">text</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">bool</span></span><spanclass="w"></span><spanclass="o"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="default_value"><spanclass="pre">True</span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">bool</span></span></span><aclass="headerlink"href="#flask.config.Config.from_file"title="Link to this definition"></a></dt>
<dd><p>Update the values in the config from a file that is loaded
using the <codeclass="docutils literal notranslate"><spanclass="pre">load</span></code> parameter. The loaded data is passed to the
<li><p><strong>filename</strong>– The path to the data file. This can be an
absolute path or relative to the config root path.</p></li>
<li><p><strong>load</strong> (<codeclass="docutils literal notranslate"><spanclass="pre">Callable[[Reader],</span><spanclass="pre">Mapping]</span></code> where <codeclass="docutils literal notranslate"><spanclass="pre">Reader</span></code>
implements a <codeclass="docutils literal notranslate"><spanclass="pre">read</span></code> method.) – A callable that takes a file handle and returns a
mapping of loaded data from the file.</p></li>
<li><p><strong>silent</strong>– Ignore the file if it doesn’t exist.</p></li>
<li><p><strong>text</strong>– Open the file in text or binary mode.</p></li>
<ddclass="field-even"><p><codeclass="docutils literal notranslate"><spanclass="pre">True</span></code> if the file was loaded successfully.</p>
</dd>
</dl>
<divclass="versionchanged">
<p><spanclass="versionmodified changed">Changed in version 2.3: </span>The <codeclass="docutils literal notranslate"><spanclass="pre">text</span></code> parameter was added.</p>
</div>
<divclass="versionadded">
<p><spanclass="versionmodified added">Added in version 2.0.</span></p>
<spanclass="sig-name descname"><spanclass="pre">from_mapping</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">mapping</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">Mapping</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="pre">str</span><spanclass="p"><spanclass="pre">,</span></span><spanclass="w"></span><spanclass="pre">Any</span><spanclass="p"><spanclass="pre">]</span></span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">None</span></span><spanclass="w"></span><spanclass="o"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="default_value"><spanclass="pre">None</span></span></em>, <emclass="sig-param"><spanclass="o"><spanclass="pre">**</span></span><spanclass="n"><spanclass="pre">kwargs</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">Any</span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">bool</span></span></span><aclass="headerlink"href="#flask.config.Config.from_mapping"title="Link to this definition"></a></dt>
<dd><p>Updates the config like <codeclass="xref py py-meth docutils literal notranslate"><spanclass="pre">update()</span></code> ignoring items with
<spanclass="sig-name descname"><spanclass="pre">from_object</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">obj</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">object</span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">str</span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">None</span></span></span><aclass="headerlink"href="#flask.config.Config.from_object"title="Link to this definition"></a></dt>
<dd><p>Updates the values from the given object. An object can be of one
of the following two types:</p>
<ulclass="simple">
<li><p>a string: in this case the object with that name will be imported</p></li>
<li><p>an actual object reference: that object is used directly</p></li>
</ul>
<p>Objects are usually either modules or classes. <aclass="reference internal"href="#flask.config.Config.from_object"title="flask.config.Config.from_object"><codeclass="xref py py-meth docutils literal notranslate"><spanclass="pre">from_object()</span></code></a>
loads only the uppercase attributes of the module/class. A <codeclass="docutils literal notranslate"><spanclass="pre">dict</span></code>
object will not work with <aclass="reference internal"href="#flask.config.Config.from_object"title="flask.config.Config.from_object"><codeclass="xref py py-meth docutils literal notranslate"><spanclass="pre">from_object()</span></code></a> because the keys of a
<codeclass="docutils literal notranslate"><spanclass="pre">dict</span></code> are not attributes of the <codeclass="docutils literal notranslate"><spanclass="pre">dict</span></code> class.</p>
<p>Nothing is done to the object before loading. If the object is a
class and has <codeclass="docutils literal notranslate"><spanclass="pre">@property</span></code> attributes, it needs to be
instantiated before being passed to this method.</p>
<p>You should not use this function to load the actual configuration but
rather configuration defaults. The actual config should be loaded
with <aclass="reference internal"href="#flask.config.Config.from_pyfile"title="flask.config.Config.from_pyfile"><codeclass="xref py py-meth docutils literal notranslate"><spanclass="pre">from_pyfile()</span></code></a> and ideally from a location not within the
package because the package might be installed system wide.</p>
<p>See <spanclass="xref std std-ref">config-dev-prod</span> for an example of class-based configuration
using <aclass="reference internal"href="#flask.config.Config.from_object"title="flask.config.Config.from_object"><codeclass="xref py py-meth docutils literal notranslate"><spanclass="pre">from_object()</span></code></a>.</p>
<spanclass="sig-name descname"><spanclass="pre">from_prefixed_env</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="pre">prefix:</span><spanclass="pre">str</span><spanclass="pre">=</span><spanclass="pre">'FLASK',</span><spanclass="pre">*,</span><spanclass="pre">loads:</span><spanclass="pre">~typing.Callable[[str],</span><spanclass="pre">~typing.Any]</span><spanclass="pre">=</span><spanclass="pre"><function</span><spanclass="pre">loads></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">bool</span></span></span><aclass="headerlink"href="#flask.config.Config.from_prefixed_env"title="Link to this definition"></a></dt>
<dd><p>Load any environment variables that start with <codeclass="docutils literal notranslate"><spanclass="pre">FLASK_</span></code>,
dropping the prefix from the env key for the config key. Values
are passed through a loading function to attempt to convert them
to more specific types than strings.</p>
<p>Keys are loaded in <codeclass="xref py py-func docutils literal notranslate"><spanclass="pre">sorted()</span></code> order.</p>
<p>The default loading function attempts to parse values as any
valid JSON type, including dicts and lists.</p>
<p>Specific items in nested dicts can be set by separating the
keys with double underscores (<codeclass="docutils literal notranslate"><spanclass="pre">__</span></code>). If an intermediate key
doesn’t exist, it will be initialized to an empty dict.</p>
<spanclass="sig-name descname"><spanclass="pre">from_pyfile</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">filename</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">str</span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">PathLike</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="pre">str</span><spanclass="p"><spanclass="pre">]</span></span></span></em>, <emclass="sig-param"><spanclass="n"><spanclass="pre">silent</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">bool</span></span><spanclass="w"></span><spanclass="o"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="default_value"><spanclass="pre">False</span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">bool</span></span></span><aclass="headerlink"href="#flask.config.Config.from_pyfile"title="Link to this definition"></a></dt>
<dd><p>Updates the values in the config from a Python file. This function
behaves as if the file was imported as module with the
<li><p><strong>filename</strong>– the filename of the config. This can either be an
absolute filename or a filename relative to the
root path.</p></li>
<li><p><strong>silent</strong>– set to <codeclass="docutils literal notranslate"><spanclass="pre">True</span></code> if you want silent failure for missing
<spanclass="sig-name descname"><spanclass="pre">get_namespace</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">namespace</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">str</span></span></em>, <emclass="sig-param"><spanclass="n"><spanclass="pre">lowercase</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">bool</span></span><spanclass="w"></span><spanclass="o"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="default_value"><spanclass="pre">True</span></span></em>, <emclass="sig-param"><spanclass="n"><spanclass="pre">trim_namespace</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">bool</span></span><spanclass="w"></span><spanclass="o"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="default_value"><spanclass="pre">True</span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">dict</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="pre">str</span><spanclass="p"><spanclass="pre">,</span></span><spanclass="w"></span><spanclass="pre">Any</span><spanclass="p"><spanclass="pre">]</span></span></span></span><aclass="headerlink"href="#flask.config.Config.get_namespace"title="Link to this definition"></a></dt>
<dd><p>Returns a dictionary containing a subset of configuration options
that match the specified namespace/prefix. Example usage:</p>
<emclass="property"><spanclass="pre">class</span><spanclass="w"></span></em><spanclass="sig-prename descclassname"><spanclass="pre">flask.config.</span></span><spanclass="sig-name descname"><spanclass="pre">ConfigAttribute</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">name</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">str</span></span></em>, <emclass="sig-param"><spanclass="n"><spanclass="pre">get_converter</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">Callable</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="p"><spanclass="pre">[</span></span><spanclass="pre">Any</span><spanclass="p"><spanclass="pre">]</span></span><spanclass="p"><spanclass="pre">,</span></span><spanclass="w"></span><spanclass="pre">T</span><spanclass="p"><spanclass="pre">]</span></span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">None</span></span><spanclass="w"></span><spanclass="o"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="default_value"><spanclass="pre">None</span></span></em><spanclass="sig-paren">)</span><aclass="headerlink"href="#flask.config.ConfigAttribute"title="Link to this definition"></a></dt>
<emclass="property"><spanclass="pre">class</span><spanclass="w"></span></em><spanclass="sig-prename descclassname"><spanclass="pre">flask.ctx.</span></span><spanclass="sig-name descname"><spanclass="pre">AppContext</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">app</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><aclass="reference internal"href="#flask.app.Flask"title="flask.app.Flask"><spanclass="pre">Flask</span></a></span></em><spanclass="sig-paren">)</span><aclass="headerlink"href="#flask.ctx.AppContext"title="Link to this definition"></a></dt>
<spanclass="sig-name descname"><spanclass="pre">pop</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">exc:</span><spanclass="pre">BaseException</span><spanclass="pre">|</span><spanclass="pre">None</span><spanclass="pre">=</span><spanclass="pre"><object</span><spanclass="pre">object></span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">None</span></span></span><aclass="headerlink"href="#flask.ctx.AppContext.pop"title="Link to this definition"></a></dt>
<spanclass="sig-name descname"><spanclass="pre">push</span></span><spanclass="sig-paren">(</span><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">None</span></span></span><aclass="headerlink"href="#flask.ctx.AppContext.push"title="Link to this definition"></a></dt>
<dd><p>Binds the app context to the current context.</p>
<spanclass="sig-name descname"><spanclass="pre">copy</span></span><spanclass="sig-paren">(</span><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><aclass="reference internal"href="#flask.ctx.RequestContext"title="flask.ctx.RequestContext"><spanclass="pre">RequestContext</span></a></span></span><aclass="headerlink"href="#flask.ctx.RequestContext.copy"title="Link to this definition"></a></dt>
<dd><p>Creates a copy of this request context with the same request object.
This can be used to move a request context to a different greenlet.
Because the actual request object is the same this cannot be used to
move a request context to a different thread unless access to the
request object is locked.</p>
<divclass="versionadded">
<p><spanclass="versionmodified added">Added in version 0.10.</span></p>
</div>
<divclass="versionchanged">
<p><spanclass="versionmodified changed">Changed in version 1.1: </span>The current session object is used instead of reloading the original
data. This prevents <cite>flask.session</cite> pointing to an out-of-date object.</p>
<spanclass="sig-name descname"><spanclass="pre">match_request</span></span><spanclass="sig-paren">(</span><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">None</span></span></span><aclass="headerlink"href="#flask.ctx.RequestContext.match_request"title="Link to this definition"></a></dt>
<dd><p>Can be overridden by a subclass to hook into the matching
<spanclass="sig-name descname"><spanclass="pre">pop</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">exc:</span><spanclass="pre">BaseException</span><spanclass="pre">|</span><spanclass="pre">None</span><spanclass="pre">=</span><spanclass="pre"><object</span><spanclass="pre">object></span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">None</span></span></span><aclass="headerlink"href="#flask.ctx.RequestContext.pop"title="Link to this definition"></a></dt>
<dd><p>Pops the request context and unbinds it by doing that. This will
also trigger the execution of functions registered by the
<spanclass="sig-name descname"><spanclass="pre">push</span></span><spanclass="sig-paren">(</span><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">None</span></span></span><aclass="headerlink"href="#flask.ctx.RequestContext.push"title="Link to this definition"></a></dt>
<spanclass="sig-prename descclassname"><spanclass="pre">flask.ctx.</span></span><spanclass="sig-name descname"><spanclass="pre">after_this_request</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">f</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">Callable</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="p"><spanclass="pre">[</span></span><spanclass="pre">Any</span><spanclass="p"><spanclass="pre">]</span></span><spanclass="p"><spanclass="pre">,</span></span><spanclass="w"></span><spanclass="pre">Any</span><spanclass="p"><spanclass="pre">]</span></span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">Callable</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="p"><spanclass="pre">[</span></span><spanclass="pre">Any</span><spanclass="p"><spanclass="pre">]</span></span><spanclass="p"><spanclass="pre">,</span></span><spanclass="w"></span><spanclass="pre">Awaitable</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="pre">Any</span><spanclass="p"><spanclass="pre">]</span></span><spanclass="p"><spanclass="pre">]</span></span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">Callable</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="p"><spanclass="pre">[</span></span><spanclass="pre">Any</span><spanclass="p"><spanclass="pre">]</span></span><spanclass="p"><spanclass="pre">,</span></span><spanclass="w"></span><spanclass="pre">Any</span><spanclass="p"><spanclass="pre">]</span></span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">Callable</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="p"><spanclass="pre">[</span></span><spanclass="pre">Any</span><spanclass="p"><spanclass="pre">]</span></span><spanclass="p"><spanclass="pre">,</span></span><spanclass="w"></span><spanclass="pre">Awaitable</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="pre">Any</span><spanclass="p"><spanclass="pre">]</span></span><spanclass="p"><spanclass="pre">]</span></span></span></span><aclass="headerlink"href="#flask.ctx.after_this_request"title="Link to this definition"></a></dt>
<dd><p>Executes a function after this request. This is useful to modify
response objects. The function is passed the response object and has
<spanclass="sig-prename descclassname"><spanclass="pre">flask.ctx.</span></span><spanclass="sig-name descname"><spanclass="pre">copy_current_request_context</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">f</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">F</span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">F</span></span></span><aclass="headerlink"href="#flask.ctx.copy_current_request_context"title="Link to this definition"></a></dt>
<dd><p>A helper function that decorates a function to retain the current
request context. This is useful when working with greenlets. The moment
the function is decorated a copy of the request context is created and
then pushed when the function is called. The current session is also
<spanclass="sig-prename descclassname"><spanclass="pre">flask.ctx.</span></span><spanclass="sig-name descname"><spanclass="pre">has_app_context</span></span><spanclass="sig-paren">(</span><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">bool</span></span></span><aclass="headerlink"href="#flask.ctx.has_app_context"title="Link to this definition"></a></dt>
<dd><p>Works like <aclass="reference internal"href="#flask.ctx.has_request_context"title="flask.ctx.has_request_context"><codeclass="xref py py-func docutils literal notranslate"><spanclass="pre">has_request_context()</span></code></a> but for the application
context. You can also just do a boolean check on the
<spanclass="sig-prename descclassname"><spanclass="pre">flask.ctx.</span></span><spanclass="sig-name descname"><spanclass="pre">has_request_context</span></span><spanclass="sig-paren">(</span><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">bool</span></span></span><aclass="headerlink"href="#flask.ctx.has_request_context"title="Link to this definition"></a></dt>
<dd><p>If you have code that wants to test if a request context is there or
not this function can be used. For instance, you may want to take advantage
of request information if the request object is available, but fail
<p><spanclass="versionmodified added">Added in version 0.7.</span></p>
</div>
</dd></dl>
</section>
<sectionid="module-flask.debughelpers">
<spanid="flask-debughelpers-module"></span><h2>flask.debughelpers module<aclass="headerlink"href="#module-flask.debughelpers"title="Link to this heading"></a></h2>
<emclass="property"><spanclass="pre">exception</span><spanclass="w"></span></em><spanclass="sig-prename descclassname"><spanclass="pre">flask.debughelpers.</span></span><spanclass="sig-name descname"><spanclass="pre">DebugFilesKeyError</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">request</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><aclass="reference internal"href="#flask.wrappers.Request"title="flask.wrappers.Request"><spanclass="pre">Request</span></a></span></em>, <emclass="sig-param"><spanclass="n"><spanclass="pre">key</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">str</span></span></em><spanclass="sig-paren">)</span><aclass="headerlink"href="#flask.debughelpers.DebugFilesKeyError"title="Link to this definition"></a></dt>
<emclass="property"><spanclass="pre">exception</span><spanclass="w"></span></em><spanclass="sig-prename descclassname"><spanclass="pre">flask.debughelpers.</span></span><spanclass="sig-name descname"><spanclass="pre">FormDataRoutingRedirect</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">request</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><aclass="reference internal"href="#flask.wrappers.Request"title="flask.wrappers.Request"><spanclass="pre">Request</span></a></span></em><spanclass="sig-paren">)</span><aclass="headerlink"href="#flask.debughelpers.FormDataRoutingRedirect"title="Link to this definition"></a></dt>
<emclass="property"><spanclass="pre">exception</span><spanclass="w"></span></em><spanclass="sig-prename descclassname"><spanclass="pre">flask.debughelpers.</span></span><spanclass="sig-name descname"><spanclass="pre">UnexpectedUnicodeError</span></span><aclass="headerlink"href="#flask.debughelpers.UnexpectedUnicodeError"title="Link to this definition"></a></dt>
<spanclass="sig-prename descclassname"><spanclass="pre">flask.debughelpers.</span></span><spanclass="sig-name descname"><spanclass="pre">explain_template_loading_attempts</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">app</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">App</span></span></em>, <emclass="sig-param"><spanclass="n"><spanclass="pre">template</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">str</span></span></em>, <emclass="sig-param"><spanclass="n"><spanclass="pre">attempts</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">list</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="pre">tuple</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="pre">BaseLoader</span><spanclass="p"><spanclass="pre">,</span></span><spanclass="w"></span><spanclass="pre">Scaffold</span><spanclass="p"><spanclass="pre">,</span></span><spanclass="w"></span><spanclass="pre">tuple</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="pre">str</span><spanclass="p"><spanclass="pre">,</span></span><spanclass="w"></span><spanclass="pre">str</span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">None</span><spanclass="p"><spanclass="pre">,</span></span><spanclass="w"></span><spanclass="pre">t.Callable</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="p"><spanclass="pre">[</span></span><spanclass="p"><spanclass="pre">]</span></span><spanclass="p"><spanclass="pre">,</span></span><spanclass="w"></span><spanclass="pre">bool</span><spanclass="p"><spanclass="pre">]</span></span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">None</span><spanclass="p"><spanclass="pre">]</span></span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">None</span><spanclass="p"><spanclass="pre">]</span></span><spanclass="p"><spanclass="pre">]</span></span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">None</span></span></span><aclass="headerlink"href="#flask.debughelpers.explain_template_loading_attempts"title="Link to this definition"></a></dt>
<dd><p>This should help developers understand what failed</p>
</dd></dl>
</section>
<sectionid="module-flask.globals">
<spanid="flask-globals-module"></span><h2>flask.globals module<aclass="headerlink"href="#module-flask.globals"title="Link to this heading"></a></h2>
</section>
<sectionid="module-flask.helpers">
<spanid="flask-helpers-module"></span><h2>flask.helpers module<aclass="headerlink"href="#module-flask.helpers"title="Link to this heading"></a></h2>
<spanclass="sig-prename descclassname"><spanclass="pre">flask.helpers.</span></span><spanclass="sig-name descname"><spanclass="pre">abort</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">code</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">int</span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">Response</span></span></em>, <emclass="sig-param"><spanclass="o"><spanclass="pre">*</span></span><spanclass="n"><spanclass="pre">args</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">Any</span></span></em>, <emclass="sig-param"><spanclass="o"><spanclass="pre">**</span></span><spanclass="n"><spanclass="pre">kwargs</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">Any</span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">NoReturn</span></span></span><aclass="headerlink"href="#flask.helpers.abort"title="Link to this definition"></a></dt>
<dd><p>Raise an <codeclass="xref py py-exc docutils literal notranslate"><spanclass="pre">HTTPException</span></code> for the given
status code.</p>
<p>If <codeclass="xref py py-data docutils literal notranslate"><spanclass="pre">current_app</span></code> is available, it will call its
<codeclass="xref py py-attr docutils literal notranslate"><spanclass="pre">aborter</span></code> object, otherwise it will use
<li><p><strong>code</strong>– The status code for the exception, which must be
registered in <codeclass="docutils literal notranslate"><spanclass="pre">app.aborter</span></code>.</p></li>
<li><p><strong>args</strong>– Passed to the exception.</p></li>
<li><p><strong>kwargs</strong>– Passed to the exception.</p></li>
</ul>
</dd>
</dl>
<divclass="versionadded">
<p><spanclass="versionmodified added">Added in version 2.2: </span>Calls <codeclass="docutils literal notranslate"><spanclass="pre">current_app.aborter</span></code> if available instead of always
using Werkzeug’s default <codeclass="docutils literal notranslate"><spanclass="pre">abort</span></code>.</p>
<spanclass="sig-prename descclassname"><spanclass="pre">flask.helpers.</span></span><spanclass="sig-name descname"><spanclass="pre">flash</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">message</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">str</span></span></em>, <emclass="sig-param"><spanclass="n"><spanclass="pre">category</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">str</span></span><spanclass="w"></span><spanclass="o"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="default_value"><spanclass="pre">'message'</span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">None</span></span></span><aclass="headerlink"href="#flask.helpers.flash"title="Link to this definition"></a></dt>
<dd><p>Flashes a message to the next request. In order to remove the
flashed message from the session and to display it to the user,
the template has to call <aclass="reference internal"href="#flask.helpers.get_flashed_messages"title="flask.helpers.get_flashed_messages"><codeclass="xref py py-func docutils literal notranslate"><spanclass="pre">get_flashed_messages()</span></code></a>.</p>
<divclass="versionchanged">
<p><spanclass="versionmodified changed">Changed in version 0.3: </span><cite>category</cite> parameter added.</p>
<li><p><strong>message</strong>– the message to be flashed.</p></li>
<li><p><strong>category</strong>– the category for the message. The following values
are recommended: <codeclass="docutils literal notranslate"><spanclass="pre">'message'</span></code> for any kind of message,
<codeclass="docutils literal notranslate"><spanclass="pre">'error'</span></code> for errors, <codeclass="docutils literal notranslate"><spanclass="pre">'info'</span></code> for information
messages and <codeclass="docutils literal notranslate"><spanclass="pre">'warning'</span></code> for warnings. However any
<spanclass="sig-prename descclassname"><spanclass="pre">flask.helpers.</span></span><spanclass="sig-name descname"><spanclass="pre">get_debug_flag</span></span><spanclass="sig-paren">(</span><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">bool</span></span></span><aclass="headerlink"href="#flask.helpers.get_debug_flag"title="Link to this definition"></a></dt>
<dd><p>Get whether debug mode should be enabled for the app, indicated by the
<spanclass="target"id="index-1"></span><codeclass="xref std std-envvar docutils literal notranslate"><spanclass="pre">FLASK_DEBUG</span></code> environment variable. The default is <codeclass="docutils literal notranslate"><spanclass="pre">False</span></code>.</p>
<spanclass="sig-prename descclassname"><spanclass="pre">flask.helpers.</span></span><spanclass="sig-name descname"><spanclass="pre">get_flashed_messages</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">with_categories</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">bool</span></span><spanclass="w"></span><spanclass="o"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="default_value"><spanclass="pre">False</span></span></em>, <emclass="sig-param"><spanclass="n"><spanclass="pre">category_filter</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">Iterable</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="pre">str</span><spanclass="p"><spanclass="pre">]</span></span></span><spanclass="w"></span><spanclass="o"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="default_value"><spanclass="pre">()</span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">list</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="pre">str</span><spanclass="p"><spanclass="pre">]</span></span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">list</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="pre">tuple</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="pre">str</span><spanclass="p"><spanclass="pre">,</span></span><spanclass="w"></span><spanclass="pre">str</span><spanclass="p"><spanclass="pre">]</span></span><spanclass="p"><spanclass="pre">]</span></span></span></span><aclass="headerlink"href="#flask.helpers.get_flashed_messages"title="Link to this definition"></a></dt>
<dd><p>Pulls all flashed messages from the session and returns them.
Further calls in the same request to the function will return
the same messages. By default just the messages are returned,
but when <cite>with_categories</cite> is set to <codeclass="docutils literal notranslate"><spanclass="pre">True</span></code>, the return value will
be a list of tuples in the form <codeclass="docutils literal notranslate"><spanclass="pre">(category,</span><spanclass="pre">message)</span></code> instead.</p>
<p>Filter the flashed messages to one or more categories by providing those
categories in <cite>category_filter</cite>. This allows rendering categories in
separate html blocks. The <cite>with_categories</cite> and <cite>category_filter</cite>
arguments are distinct:</p>
<ulclass="simple">
<li><p><cite>with_categories</cite> controls whether categories are returned with message
text (<codeclass="docutils literal notranslate"><spanclass="pre">True</span></code> gives a tuple, where <codeclass="docutils literal notranslate"><spanclass="pre">False</span></code> gives just the message text).</p></li>
<li><p><cite>category_filter</cite> filters the messages down to only those matching the
provided categories.</p></li>
</ul>
<p>See <spanclass="xref std std-doc">/patterns/flashing</span> for examples.</p>
<divclass="versionchanged">
<p><spanclass="versionmodified changed">Changed in version 0.3: </span><cite>with_categories</cite> parameter added.</p>
</div>
<divclass="versionchanged">
<p><spanclass="versionmodified changed">Changed in version 0.9: </span><cite>category_filter</cite> parameter added.</p>
<li><p><strong>with_categories</strong>– set to <codeclass="docutils literal notranslate"><spanclass="pre">True</span></code> to also receive categories.</p></li>
<li><p><strong>category_filter</strong>– filter of categories to limit return values. Only
<spanclass="sig-prename descclassname"><spanclass="pre">flask.helpers.</span></span><spanclass="sig-name descname"><spanclass="pre">get_load_dotenv</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">default</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">bool</span></span><spanclass="w"></span><spanclass="o"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="default_value"><spanclass="pre">True</span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">bool</span></span></span><aclass="headerlink"href="#flask.helpers.get_load_dotenv"title="Link to this definition"></a></dt>
<dd><p>Get whether the user has disabled loading default dotenv files by
setting <spanclass="target"id="index-2"></span><codeclass="xref std std-envvar docutils literal notranslate"><spanclass="pre">FLASK_SKIP_DOTENV</span></code>. The default is <codeclass="docutils literal notranslate"><spanclass="pre">True</span></code>, load
<spanclass="sig-prename descclassname"><spanclass="pre">flask.helpers.</span></span><spanclass="sig-name descname"><spanclass="pre">get_template_attribute</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">template_name</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">str</span></span></em>, <emclass="sig-param"><spanclass="n"><spanclass="pre">attribute</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">str</span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">Any</span></span></span><aclass="headerlink"href="#flask.helpers.get_template_attribute"title="Link to this definition"></a></dt>
<dd><p>Loads a macro (or variable) a template exports. This can be used to
invoke a macro from within Python code. If you for example have a
template named <codeclass="file docutils literal notranslate"><spanclass="pre">_cider.html</span></code> with the following contents:</p>
<spanclass="sig-prename descclassname"><spanclass="pre">flask.helpers.</span></span><spanclass="sig-name descname"><spanclass="pre">make_response</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="o"><spanclass="pre">*</span></span><spanclass="n"><spanclass="pre">args</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">t.Any</span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><aclass="reference internal"href="#flask.wrappers.Response"title="flask.wrappers.Response"><spanclass="pre">Response</span></a></span></span><aclass="headerlink"href="#flask.helpers.make_response"title="Link to this definition"></a></dt>
<dd><p>Sometimes it is necessary to set additional headers in a view. Because
views do not have to return response objects but can return a value that
is converted into a response object by Flask itself, it becomes tricky to
add headers to it. This function can be called instead of using a return
and you will get a response object which you can use to attach headers.</p>
<p>If view looked like this and you want to add a new header:</p>
<spanclass="n">response</span><spanclass="o">.</span><spanclass="n">headers</span><spanclass="p">[</span><spanclass="s1">'X-Parachutes'</span><spanclass="p">]</span><spanclass="o">=</span><spanclass="s1">'parachutes are cool'</span>
<spanclass="n">response</span><spanclass="o">.</span><spanclass="n">headers</span><spanclass="p">[</span><spanclass="s1">'X-Parachutes'</span><spanclass="p">]</span><spanclass="o">=</span><spanclass="s1">'parachutes are cool'</span>
</pre></div>
</div>
<p>Internally this function does the following things:</p>
<ulclass="simple">
<li><p>if no arguments are passed, it creates a new response argument</p></li>
<li><p>if one argument is passed, <codeclass="xref py py-meth docutils literal notranslate"><spanclass="pre">flask.Flask.make_response()</span></code>
is invoked with it.</p></li>
<li><p>if more than one argument is passed, the arguments are passed
to the <codeclass="xref py py-meth docutils literal notranslate"><spanclass="pre">flask.Flask.make_response()</span></code> function as tuple.</p></li>
</ul>
<divclass="versionadded">
<p><spanclass="versionmodified added">Added in version 0.6.</span></p>
<spanclass="sig-prename descclassname"><spanclass="pre">flask.helpers.</span></span><spanclass="sig-name descname"><spanclass="pre">redirect</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">location</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">str</span></span></em>, <emclass="sig-param"><spanclass="n"><spanclass="pre">code</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">int</span></span><spanclass="w"></span><spanclass="o"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="default_value"><spanclass="pre">302</span></span></em>, <emclass="sig-param"><spanclass="n"><spanclass="pre">Response</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">type</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="pre">Response</span><spanclass="p"><spanclass="pre">]</span></span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">None</span></span><spanclass="w"></span><spanclass="o"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="default_value"><spanclass="pre">None</span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">Response</span></span></span><aclass="headerlink"href="#flask.helpers.redirect"title="Link to this definition"></a></dt>
<dd><p>Create a redirect response object.</p>
<p>If <codeclass="xref py py-data docutils literal notranslate"><spanclass="pre">current_app</span></code> is available, it will use its
<codeclass="xref py py-meth docutils literal notranslate"><spanclass="pre">redirect()</span></code> method, otherwise it will use
<li><p><strong>location</strong>– The URL to redirect to.</p></li>
<li><p><strong>code</strong>– The status code for the redirect.</p></li>
<li><p><strong>Response</strong>– The response class to use. Not used when
<codeclass="docutils literal notranslate"><spanclass="pre">current_app</span></code> is active, which uses <codeclass="docutils literal notranslate"><spanclass="pre">app.response_class</span></code>.</p></li>
</ul>
</dd>
</dl>
<divclass="versionadded">
<p><spanclass="versionmodified added">Added in version 2.2: </span>Calls <codeclass="docutils literal notranslate"><spanclass="pre">current_app.redirect</span></code> if available instead of always
using Werkzeug’s default <codeclass="docutils literal notranslate"><spanclass="pre">redirect</span></code>.</p>
<dd><p>Send the contents of a file to the client.</p>
<p>The first argument can be a file path or a file-like object. Paths
are preferred in most cases because Werkzeug can manage the file and
get extra information from the path. Passing a file-like object
requires that the file is opened in binary mode, and is mostly
useful when building a file in memory with <codeclass="xref py py-class docutils literal notranslate"><spanclass="pre">io.BytesIO</span></code>.</p>
<p>Never pass file paths provided by a user. The path is assumed to be
trusted, so a user could craft a path to access a file you didn’t
intend. Use <aclass="reference internal"href="#flask.helpers.send_from_directory"title="flask.helpers.send_from_directory"><codeclass="xref py py-func docutils literal notranslate"><spanclass="pre">send_from_directory()</span></code></a> to safely serve
user-requested paths from within a directory.</p>
<p>If the WSGI server sets a <codeclass="docutils literal notranslate"><spanclass="pre">file_wrapper</span></code> in <codeclass="docutils literal notranslate"><spanclass="pre">environ</span></code>, it is
used, otherwise Werkzeug’s built-in wrapper is used. Alternatively,
if the HTTP server supports <codeclass="docutils literal notranslate"><spanclass="pre">X-Sendfile</span></code>, configuring Flask with
<codeclass="docutils literal notranslate"><spanclass="pre">USE_X_SENDFILE</span><spanclass="pre">=</span><spanclass="pre">True</span></code> will tell the server to send the given
path, which is much more efficient than reading it in Python.</p>
<li><p><strong>path_or_file</strong>– The path to the file to send, relative to the
current working directory if a relative path is given.
Alternatively, a file-like object opened in binary mode. Make
sure the file pointer is seeked to the start of the data.</p></li>
<li><p><strong>mimetype</strong>– The MIME type to send for the file. If not
provided, it will try to detect it from the file name.</p></li>
<li><p><strong>as_attachment</strong>– Indicate to a browser that it should offer to
save the file instead of displaying it.</p></li>
<li><p><strong>download_name</strong>– The default name browsers will use when saving
the file. Defaults to the passed file name.</p></li>
<li><p><strong>conditional</strong>– Enable conditional and range responses based on
request headers. Requires passing a file path and <codeclass="docutils literal notranslate"><spanclass="pre">environ</span></code>.</p></li>
<li><p><strong>etag</strong>– Calculate an ETag for the file, which requires passing
a file path. Can also be a string to use instead.</p></li>
<li><p><strong>last_modified</strong>– The last modified time to send for the file,
in seconds. If not provided, it will try to detect it from the
file path.</p></li>
<li><p><strong>max_age</strong>– How long the client should cache the file, in
seconds. If set, <codeclass="docutils literal notranslate"><spanclass="pre">Cache-Control</span></code> will be <codeclass="docutils literal notranslate"><spanclass="pre">public</span></code>, otherwise
it will be <codeclass="docutils literal notranslate"><spanclass="pre">no-cache</span></code> to prefer conditional caching.</p></li>
</ul>
</dd>
</dl>
<divclass="versionchanged">
<p><spanclass="versionmodified changed">Changed in version 2.0: </span><codeclass="docutils literal notranslate"><spanclass="pre">download_name</span></code> replaces the <codeclass="docutils literal notranslate"><spanclass="pre">attachment_filename</span></code>
parameter. If <codeclass="docutils literal notranslate"><spanclass="pre">as_attachment=False</span></code>, it is passed with
<p><spanclass="versionmodified changed">Changed in version 2.0: </span><codeclass="docutils literal notranslate"><spanclass="pre">max_age</span></code> replaces the <codeclass="docutils literal notranslate"><spanclass="pre">cache_timeout</span></code> parameter.
<codeclass="docutils literal notranslate"><spanclass="pre">conditional</span></code> is enabled and <codeclass="docutils literal notranslate"><spanclass="pre">max_age</span></code> is not set by
default.</p>
</div>
<divclass="versionchanged">
<p><spanclass="versionmodified changed">Changed in version 2.0: </span><codeclass="docutils literal notranslate"><spanclass="pre">etag</span></code> replaces the <codeclass="docutils literal notranslate"><spanclass="pre">add_etags</span></code> parameter. It can be a
string to use instead of generating one.</p>
</div>
<divclass="versionchanged">
<p><spanclass="versionmodified changed">Changed in version 2.0: </span>Passing a file-like object that inherits from
<codeclass="xref py py-class docutils literal notranslate"><spanclass="pre">TextIOBase</span></code> will raise a <codeclass="xref py py-exc docutils literal notranslate"><spanclass="pre">ValueError</span></code> rather
than sending an empty file.</p>
</div>
<divclass="versionadded">
<p><spanclass="versionmodified added">Added in version 2.0: </span>Moved the implementation to Werkzeug. This is now a wrapper to
pass some Flask-specific arguments.</p>
</div>
<divclass="versionchanged">
<p><spanclass="versionmodified changed">Changed in version 1.1: </span><codeclass="docutils literal notranslate"><spanclass="pre">filename</span></code> may be a <codeclass="xref py py-class docutils literal notranslate"><spanclass="pre">PathLike</span></code> object.</p>
</div>
<divclass="versionchanged">
<p><spanclass="versionmodified changed">Changed in version 1.1: </span>Passing a <codeclass="xref py py-class docutils literal notranslate"><spanclass="pre">BytesIO</span></code> object supports range requests.</p>
</div>
<divclass="versionchanged">
<p><spanclass="versionmodified changed">Changed in version 1.0.3: </span>Filenames are encoded with ASCII instead of Latin-1 for broader
compatibility with WSGI servers.</p>
</div>
<divclass="versionchanged">
<p><spanclass="versionmodified changed">Changed in version 1.0: </span>UTF-8 filenames as specified in <spanclass="target"id="index-3"></span><aclass="rfc reference external"href="https://datatracker.ietf.org/doc/html/rfc2231.html"><strong>RFC 2231</strong></a> are supported.</p>
</div>
<divclass="versionchanged">
<p><spanclass="versionmodified changed">Changed in version 0.12: </span>The filename is no longer automatically inferred from file
objects. If you want to use automatic MIME and etag support,
pass a filename via <codeclass="docutils literal notranslate"><spanclass="pre">filename_or_fp</span></code> or
<p><spanclass="versionmodified changed">Changed in version 0.12: </span><codeclass="docutils literal notranslate"><spanclass="pre">attachment_filename</span></code> is preferred over <codeclass="docutils literal notranslate"><spanclass="pre">filename</span></code> for MIME
detection.</p>
</div>
<divclass="versionchanged">
<p><spanclass="versionmodified changed">Changed in version 0.9: </span><codeclass="docutils literal notranslate"><spanclass="pre">cache_timeout</span></code> defaults to
<spanclass="sig-prename descclassname"><spanclass="pre">flask.helpers.</span></span><spanclass="sig-name descname"><spanclass="pre">send_from_directory</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">directory</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">os.PathLike</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="pre">str</span><spanclass="p"><spanclass="pre">]</span></span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">str</span></span></em>, <emclass="sig-param"><spanclass="n"><spanclass="pre">path</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">os.PathLike</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="pre">str</span><spanclass="p"><spanclass="pre">]</span></span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">str</span></span></em>, <emclass="sig-param"><spanclass="o"><spanclass="pre">**</span></span><spanclass="n"><spanclass="pre">kwargs</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">t.Any</span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><aclass="reference internal"href="#flask.wrappers.Response"title="flask.wrappers.Response"><spanclass="pre">Response</span></a></span></span><aclass="headerlink"href="#flask.helpers.send_from_directory"title="Link to this definition"></a></dt>
<dd><p>Send a file from within a directory using <aclass="reference internal"href="#flask.helpers.send_file"title="flask.helpers.send_file"><codeclass="xref py py-func docutils literal notranslate"><spanclass="pre">send_file()</span></code></a>.</p>
<li><p><strong>directory</strong>– The directory that <codeclass="docutils literal notranslate"><spanclass="pre">path</span></code> must be located under,
relative to the current application’s root path. This <em>must not</em>
be a value provided by the client, otherwise it becomes insecure.</p></li>
<li><p><strong>path</strong>– The path to the file to send, relative to
<li><p><strong>kwargs</strong>– Arguments to pass to <aclass="reference internal"href="#flask.helpers.send_file"title="flask.helpers.send_file"><codeclass="xref py py-func docutils literal notranslate"><spanclass="pre">send_file()</span></code></a>.</p></li>
</ul>
</dd>
</dl>
<divclass="versionchanged">
<p><spanclass="versionmodified changed">Changed in version 2.0: </span><codeclass="docutils literal notranslate"><spanclass="pre">path</span></code> replaces the <codeclass="docutils literal notranslate"><spanclass="pre">filename</span></code> parameter.</p>
</div>
<divclass="versionadded">
<p><spanclass="versionmodified added">Added in version 2.0: </span>Moved the implementation to Werkzeug. This is now a wrapper to
pass some Flask-specific arguments.</p>
</div>
<divclass="versionadded">
<p><spanclass="versionmodified added">Added in version 0.5.</span></p>
<spanclass="sig-prename descclassname"><spanclass="pre">flask.helpers.</span></span><spanclass="sig-name descname"><spanclass="pre">stream_with_context</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">generator_or_function</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">Iterator</span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">Iterator</span></span></span><aclass="headerlink"href="#flask.helpers.stream_with_context"title="Link to this definition"></a></dt>
<li><p><strong>endpoint</strong>– The endpoint name associated with the URL to
generate. If this starts with a <codeclass="docutils literal notranslate"><spanclass="pre">.</span></code>, the current blueprint
name (if any) will be used.</p></li>
<li><p><strong>_anchor</strong>– If given, append this as <codeclass="docutils literal notranslate"><spanclass="pre">#anchor</span></code> to the URL.</p></li>
<li><p><strong>_method</strong>– If given, generate the URL associated with this
method for the endpoint.</p></li>
<li><p><strong>_scheme</strong>– If given, the URL will have this scheme if it is
external.</p></li>
<li><p><strong>_external</strong>– 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.</p></li>
<li><p><strong>values</strong>– Values to use for the variable parts of the URL rule.
Unknown keys are appended as query string arguments, like
<p><spanclass="versionmodified changed">Changed in version 2.2: </span>Calls <codeclass="docutils literal notranslate"><spanclass="pre">current_app.url_for</span></code>, allowing an app to override the
behavior.</p>
</div>
<divclass="versionchanged">
<p><spanclass="versionmodified changed">Changed in version 0.10: </span>The <codeclass="docutils literal notranslate"><spanclass="pre">_scheme</span></code> parameter was added.</p>
</div>
<divclass="versionchanged">
<p><spanclass="versionmodified changed">Changed in version 0.9: </span>The <codeclass="docutils literal notranslate"><spanclass="pre">_anchor</span></code> and <codeclass="docutils literal notranslate"><spanclass="pre">_method</span></code> parameters were added.</p>
</div>
<divclass="versionchanged">
<p><spanclass="versionmodified changed">Changed in version 0.9: </span>Calls <codeclass="docutils literal notranslate"><spanclass="pre">app.handle_url_build_error</span></code> on build errors.</p>
</div>
</dd></dl>
</section>
<sectionid="module-flask.logging">
<spanid="flask-logging-module"></span><h2>flask.logging module<aclass="headerlink"href="#module-flask.logging"title="Link to this heading"></a></h2>
<spanclass="sig-prename descclassname"><spanclass="pre">flask.logging.</span></span><spanclass="sig-name descname"><spanclass="pre">create_logger</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">app</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">App</span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">logging.Logger</span></span></span><aclass="headerlink"href="#flask.logging.create_logger"title="Link to this definition"></a></dt>
<dd><p>Get the Flask app’s logger and configure it if needed.</p>
<spanclass="sig-prename descclassname"><spanclass="pre">flask.logging.</span></span><spanclass="sig-name descname"><spanclass="pre">default_handler</span></span><emclass="property"><spanclass="w"></span><spanclass="p"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="pre"><StreamHandler</span><spanclass="pre"><stderr></span><spanclass="pre">(NOTSET)></span></em><aclass="headerlink"href="#flask.logging.default_handler"title="Link to this definition"></a></dt>
<dd><p>Log messages to <codeclass="xref py py-func docutils literal notranslate"><spanclass="pre">wsgi_errors_stream()</span></code> with the format
<spanclass="sig-prename descclassname"><spanclass="pre">flask.logging.</span></span><spanclass="sig-name descname"><spanclass="pre">has_level_handler</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">logger</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">Logger</span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">bool</span></span></span><aclass="headerlink"href="#flask.logging.has_level_handler"title="Link to this definition"></a></dt>
<dd><p>Check if there is a handler in the logging chain that will handle the
given logger’s <codeclass="xref py py-meth docutils literal notranslate"><spanclass="pre">effective</span><spanclass="pre">level</span></code>.</p>
</dd></dl>
</section>
<sectionid="module-flask.sessions">
<spanid="flask-sessions-module"></span><h2>flask.sessions module<aclass="headerlink"href="#module-flask.sessions"title="Link to this heading"></a></h2>
<emclass="property"><spanclass="pre">class</span><spanclass="w"></span></em><spanclass="sig-prename descclassname"><spanclass="pre">flask.sessions.</span></span><spanclass="sig-name descname"><spanclass="pre">NullSession</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">initial</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">Mapping</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="pre">str</span><spanclass="p"><spanclass="pre">,</span></span><spanclass="w"></span><spanclass="pre">Any</span><spanclass="p"><spanclass="pre">]</span></span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">Iterable</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="pre">tuple</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="pre">str</span><spanclass="p"><spanclass="pre">,</span></span><spanclass="w"></span><spanclass="pre">Any</span><spanclass="p"><spanclass="pre">]</span></span><spanclass="p"><spanclass="pre">]</span></span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">None</span></span><spanclass="w"></span><spanclass="o"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="default_value"><spanclass="pre">None</span></span></em><spanclass="sig-paren">)</span><aclass="headerlink"href="#flask.sessions.NullSession"title="Link to this definition"></a></dt>
<spanclass="sig-name descname"><spanclass="pre">clear</span></span><spanclass="sig-paren">(</span><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">None.</span> <spanclass="pre">Remove</span><spanclass="pre">all</span><spanclass="pre">items</span><spanclass="pre">from</span><spanclass="pre">D.</span></span></span><aclass="headerlink"href="#flask.sessions.NullSession.clear"title="Link to this definition"></a></dt>
<spanclass="sig-name descname"><spanclass="pre">pop</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">k</span></span></em><spanclass="optional">[</span>, <emclass="sig-param"><spanclass="n"><spanclass="pre">d</span></span></em><spanclass="optional">]</span><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">v,</span><spanclass="pre">remove</span><spanclass="pre">specified</span><spanclass="pre">key</span><spanclass="pre">and</span><spanclass="pre">return</span><spanclass="pre">the</span><spanclass="pre">corresponding</span><spanclass="pre">value.</span></span></span><aclass="headerlink"href="#flask.sessions.NullSession.pop"title="Link to this definition"></a></dt>
<dd><p>If the key is not found, return the default if given; otherwise,
<spanclass="sig-name descname"><spanclass="pre">popitem</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="o"><spanclass="pre">*</span></span><spanclass="n"><spanclass="pre">args</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">Any</span></span></em>, <emclass="sig-param"><spanclass="o"><spanclass="pre">**</span></span><spanclass="n"><spanclass="pre">kwargs</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">Any</span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">NoReturn</span></span></span><aclass="headerlink"href="#flask.sessions.NullSession.popitem"title="Link to this definition"></a></dt>
<dd><p>Remove and return a (key, value) pair as a 2-tuple.</p>
<p>Pairs are returned in LIFO (last-in, first-out) order.
<spanclass="sig-name descname"><spanclass="pre">setdefault</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="o"><spanclass="pre">*</span></span><spanclass="n"><spanclass="pre">args</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">Any</span></span></em>, <emclass="sig-param"><spanclass="o"><spanclass="pre">**</span></span><spanclass="n"><spanclass="pre">kwargs</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">Any</span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">NoReturn</span></span></span><aclass="headerlink"href="#flask.sessions.NullSession.setdefault"title="Link to this definition"></a></dt>
<dd><p>Insert key with a value of default if key is not in the dictionary.</p>
<p>Return the value for key if key is in the dictionary, else default.</p>
<spanclass="sig-name descname"><spanclass="pre">update</span></span><spanclass="sig-paren">(</span><spanclass="optional">[</span><emclass="sig-param"><spanclass="n"><spanclass="pre">E</span></span></em>, <spanclass="optional">]</span><emclass="sig-param"><spanclass="n"><spanclass="pre">**F</span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">None.</span> <spanclass="pre">Update</span><spanclass="pre">D</span><spanclass="pre">from</span><spanclass="pre">dict/iterable</span><spanclass="pre">E</span><spanclass="pre">and</span><spanclass="pre">F.</span></span></span><aclass="headerlink"href="#flask.sessions.NullSession.update"title="Link to this definition"></a></dt>
<dd><p>If E is present and has a .keys() method, then does: for k in E: D[k] = E[k]
If E is present and lacks a .keys() method, then does: for k, v in E: D[k] = v
In either case, this is followed by: for k in F: D[k] = F[k]</p>
<emclass="property"><spanclass="pre">class</span><spanclass="w"></span></em><spanclass="sig-prename descclassname"><spanclass="pre">flask.sessions.</span></span><spanclass="sig-name descname"><spanclass="pre">SecureCookieSession</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">initial</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">Mapping</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="pre">str</span><spanclass="p"><spanclass="pre">,</span></span><spanclass="w"></span><spanclass="pre">Any</span><spanclass="p"><spanclass="pre">]</span></span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">Iterable</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="pre">tuple</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="pre">str</span><spanclass="p"><spanclass="pre">,</span></span><spanclass="w"></span><spanclass="pre">Any</span><spanclass="p"><spanclass="pre">]</span></span><spanclass="p"><spanclass="pre">]</span></span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">None</span></span><spanclass="w"></span><spanclass="o"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="default_value"><spanclass="pre">None</span></span></em><spanclass="sig-paren">)</span><aclass="headerlink"href="#flask.sessions.SecureCookieSession"title="Link to this definition"></a></dt>
<p>Base class for sessions based on signed cookies.</p>
<p>This session backend will set the <aclass="reference internal"href="#flask.sessions.SecureCookieSession.modified"title="flask.sessions.SecureCookieSession.modified"><codeclass="xref py py-attr docutils literal notranslate"><spanclass="pre">modified</span></code></a> and
<aclass="reference internal"href="#flask.sessions.SecureCookieSession.accessed"title="flask.sessions.SecureCookieSession.accessed"><codeclass="xref py py-attr docutils literal notranslate"><spanclass="pre">accessed</span></code></a> attributes. It cannot reliably track whether a
session is new (vs. empty), so <codeclass="xref py py-attr docutils literal notranslate"><spanclass="pre">new</span></code> remains hard coded to
<spanclass="sig-name descname"><spanclass="pre">accessed</span></span><emclass="property"><spanclass="w"></span><spanclass="p"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="pre">False</span></em><aclass="headerlink"href="#flask.sessions.SecureCookieSession.accessed"title="Link to this definition"></a></dt>
<dd><p>header, which allows caching proxies to cache different pages for
<spanclass="sig-name descname"><spanclass="pre">get</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">key</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">str</span></span></em>, <emclass="sig-param"><spanclass="n"><spanclass="pre">default</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">Any</span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">None</span></span><spanclass="w"></span><spanclass="o"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="default_value"><spanclass="pre">None</span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">Any</span></span></span><aclass="headerlink"href="#flask.sessions.SecureCookieSession.get"title="Link to this definition"></a></dt>
<dd><p>Return the value for key if key is in the dictionary, else default.</p>
<spanclass="sig-name descname"><spanclass="pre">modified</span></span><emclass="property"><spanclass="w"></span><spanclass="p"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="pre">False</span></em><aclass="headerlink"href="#flask.sessions.SecureCookieSession.modified"title="Link to this definition"></a></dt>
<dd><p>When data is changed, this is set to <codeclass="docutils literal notranslate"><spanclass="pre">True</span></code>. Only the session
dictionary itself is tracked; if the session contains mutable
data (for example a nested dict) then this must be set to
<codeclass="docutils literal notranslate"><spanclass="pre">True</span></code> manually when modifying that data. The session cookie
will only be written to the response if this is <codeclass="docutils literal notranslate"><spanclass="pre">True</span></code>.</p>
<spanclass="sig-name descname"><spanclass="pre">setdefault</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">key</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">str</span></span></em>, <emclass="sig-param"><spanclass="n"><spanclass="pre">default</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">Any</span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">None</span></span><spanclass="w"></span><spanclass="o"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="default_value"><spanclass="pre">None</span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">Any</span></span></span><aclass="headerlink"href="#flask.sessions.SecureCookieSession.setdefault"title="Link to this definition"></a></dt>
<dd><p>Insert key with a value of default if key is not in the dictionary.</p>
<p>Return the value for key if key is in the dictionary, else default.</p>
<emclass="property"><spanclass="pre">class</span><spanclass="w"></span></em><spanclass="sig-prename descclassname"><spanclass="pre">flask.sessions.</span></span><spanclass="sig-name descname"><spanclass="pre">SecureCookieSessionInterface</span></span><aclass="headerlink"href="#flask.sessions.SecureCookieSessionInterface"title="Link to this definition"></a></dt>
<emclass="property"><spanclass="pre">static</span><spanclass="w"></span></em><spanclass="sig-name descname"><spanclass="pre">digest_method</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">string</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">bytes</span></span><spanclass="w"></span><spanclass="o"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="default_value"><spanclass="pre">b''</span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">Any</span></span></span><aclass="headerlink"href="#flask.sessions.SecureCookieSessionInterface.digest_method"title="Link to this definition"></a></dt>
<dd><p>the hash function to use for the signature. The default is sha1</p>
<spanclass="sig-name descname"><spanclass="pre">get_signing_serializer</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">app</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><aclass="reference internal"href="#flask.app.Flask"title="flask.app.Flask"><spanclass="pre">Flask</span></a></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">URLSafeTimedSerializer</span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">None</span></span></span><aclass="headerlink"href="#flask.sessions.SecureCookieSessionInterface.get_signing_serializer"title="Link to this definition"></a></dt>
<spanclass="sig-name descname"><spanclass="pre">key_derivation</span></span><emclass="property"><spanclass="w"></span><spanclass="p"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="pre">'hmac'</span></em><aclass="headerlink"href="#flask.sessions.SecureCookieSessionInterface.key_derivation"title="Link to this definition"></a></dt>
<dd><p>the name of the itsdangerous supported key derivation. The default
<spanclass="sig-name descname"><spanclass="pre">open_session</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">app</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><aclass="reference internal"href="#flask.app.Flask"title="flask.app.Flask"><spanclass="pre">Flask</span></a></span></em>, <emclass="sig-param"><spanclass="n"><spanclass="pre">request</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><aclass="reference internal"href="#flask.wrappers.Request"title="flask.wrappers.Request"><spanclass="pre">Request</span></a></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><aclass="reference internal"href="#flask.sessions.SecureCookieSession"title="flask.sessions.SecureCookieSession"><spanclass="pre">SecureCookieSession</span></a><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">None</span></span></span><aclass="headerlink"href="#flask.sessions.SecureCookieSessionInterface.open_session"title="Link to this definition"></a></dt>
<dd><p>This is called at the beginning of each request, after
pushing the request context, before matching the URL.</p>
<p>This must return an object which implements a dictionary-like
interface as well as the <aclass="reference internal"href="#flask.sessions.SessionMixin"title="flask.sessions.SessionMixin"><codeclass="xref py py-class docutils literal notranslate"><spanclass="pre">SessionMixin</span></code></a> interface.</p>
<p>This will return <codeclass="docutils literal notranslate"><spanclass="pre">None</span></code> to indicate that loading failed in
some way that is not immediately an error. The request
context will fall back to using <codeclass="xref py py-meth docutils literal notranslate"><spanclass="pre">make_null_session()</span></code>
<spanclass="sig-name descname"><spanclass="pre">salt</span></span><emclass="property"><spanclass="w"></span><spanclass="p"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="pre">'cookie-session'</span></em><aclass="headerlink"href="#flask.sessions.SecureCookieSessionInterface.salt"title="Link to this definition"></a></dt>
<dd><p>the salt that should be applied on top of the secret key for the
<spanclass="sig-name descname"><spanclass="pre">save_session</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">app</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><aclass="reference internal"href="#flask.app.Flask"title="flask.app.Flask"><spanclass="pre">Flask</span></a></span></em>, <emclass="sig-param"><spanclass="n"><spanclass="pre">session</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><aclass="reference internal"href="#flask.sessions.SessionMixin"title="flask.sessions.SessionMixin"><spanclass="pre">SessionMixin</span></a></span></em>, <emclass="sig-param"><spanclass="n"><spanclass="pre">response</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><aclass="reference internal"href="#flask.wrappers.Response"title="flask.wrappers.Response"><spanclass="pre">Response</span></a></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">None</span></span></span><aclass="headerlink"href="#flask.sessions.SecureCookieSessionInterface.save_session"title="Link to this definition"></a></dt>
<dd><p>This is called at the end of each request, after generating
a response, before removing the request context. It is skipped
<spanclass="sig-name descname"><spanclass="pre">serializer</span></span><emclass="property"><spanclass="w"></span><spanclass="p"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="pre"><flask.json.tag.TaggedJSONSerializer</span><spanclass="pre">object></span></em><aclass="headerlink"href="#flask.sessions.SecureCookieSessionInterface.serializer"title="Link to this definition"></a></dt>
<dd><p>A python serializer for the payload. The default is a compact
JSON derived serializer with support for some extra Python types
<spanclass="sig-name descname"><spanclass="pre">session_class</span></span><aclass="headerlink"href="#flask.sessions.SecureCookieSessionInterface.session_class"title="Link to this definition"></a></dt>
<dd><p>alias of <aclass="reference internal"href="#flask.sessions.SecureCookieSession"title="flask.sessions.SecureCookieSession"><codeclass="xref py py-class docutils literal notranslate"><spanclass="pre">SecureCookieSession</span></code></a></p>
<emclass="property"><spanclass="pre">class</span><spanclass="w"></span></em><spanclass="sig-prename descclassname"><spanclass="pre">flask.sessions.</span></span><spanclass="sig-name descname"><spanclass="pre">SessionInterface</span></span><aclass="headerlink"href="#flask.sessions.SessionInterface"title="Link to this definition"></a></dt>
<p>The basic interface you have to implement in order to replace the
default session interface which uses werkzeug’s securecookie
implementation. The only methods you have to implement are
<aclass="reference internal"href="#flask.sessions.SessionInterface.open_session"title="flask.sessions.SessionInterface.open_session"><codeclass="xref py py-meth docutils literal notranslate"><spanclass="pre">open_session()</span></code></a> and <aclass="reference internal"href="#flask.sessions.SessionInterface.save_session"title="flask.sessions.SessionInterface.save_session"><codeclass="xref py py-meth docutils literal notranslate"><spanclass="pre">save_session()</span></code></a>, the others have
useful defaults which you don’t need to change.</p>
<p>The session object returned by the <aclass="reference internal"href="#flask.sessions.SessionInterface.open_session"title="flask.sessions.SessionInterface.open_session"><codeclass="xref py py-meth docutils literal notranslate"><spanclass="pre">open_session()</span></code></a> method has to
provide a dictionary like interface plus the properties and methods
from the <aclass="reference internal"href="#flask.sessions.SessionMixin"title="flask.sessions.SessionMixin"><codeclass="xref py py-class docutils literal notranslate"><spanclass="pre">SessionMixin</span></code></a>. We recommend just subclassing a dict
<p>If <aclass="reference internal"href="#flask.sessions.SessionInterface.open_session"title="flask.sessions.SessionInterface.open_session"><codeclass="xref py py-meth docutils literal notranslate"><spanclass="pre">open_session()</span></code></a> returns <codeclass="docutils literal notranslate"><spanclass="pre">None</span></code> Flask will call into
<aclass="reference internal"href="#flask.sessions.SessionInterface.make_null_session"title="flask.sessions.SessionInterface.make_null_session"><codeclass="xref py py-meth docutils literal notranslate"><spanclass="pre">make_null_session()</span></code></a> to create a session that acts as replacement
if the session support cannot work because some requirement is not
fulfilled. The default <aclass="reference internal"href="#flask.sessions.NullSession"title="flask.sessions.NullSession"><codeclass="xref py py-class docutils literal notranslate"><spanclass="pre">NullSession</span></code></a> class that is created
will complain that the secret key was not set.</p>
<p>To replace the session interface on an application all you have to do
is to assign <codeclass="xref py py-attr docutils literal notranslate"><spanclass="pre">flask.Flask.session_interface</span></code>:</p>
<spanclass="sig-name descname"><spanclass="pre">get_cookie_domain</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">app</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><aclass="reference internal"href="#flask.app.Flask"title="flask.app.Flask"><spanclass="pre">Flask</span></a></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">str</span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">None</span></span></span><aclass="headerlink"href="#flask.sessions.SessionInterface.get_cookie_domain"title="Link to this definition"></a></dt>
<dd><p>The value of the <codeclass="docutils literal notranslate"><spanclass="pre">Domain</span></code> parameter on the session cookie. If not set,
browsers will only send the cookie to the exact domain it was set from.
Otherwise, they will send it to any subdomain of the given value as well.</p>
<p>Uses the <codeclass="xref py py-data docutils literal notranslate"><spanclass="pre">SESSION_COOKIE_DOMAIN</span></code> config.</p>
<divclass="versionchanged">
<p><spanclass="versionmodified changed">Changed in version 2.3: </span>Not set by default, does not fall back to <codeclass="docutils literal notranslate"><spanclass="pre">SERVER_NAME</span></code>.</p>
<spanclass="sig-name descname"><spanclass="pre">get_cookie_httponly</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">app</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><aclass="reference internal"href="#flask.app.Flask"title="flask.app.Flask"><spanclass="pre">Flask</span></a></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">bool</span></span></span><aclass="headerlink"href="#flask.sessions.SessionInterface.get_cookie_httponly"title="Link to this definition"></a></dt>
<dd><p>Returns True if the session cookie should be httponly. This
currently just returns the value of the <codeclass="docutils literal notranslate"><spanclass="pre">SESSION_COOKIE_HTTPONLY</span></code>
<spanclass="sig-name descname"><spanclass="pre">get_cookie_name</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">app</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><aclass="reference internal"href="#flask.app.Flask"title="flask.app.Flask"><spanclass="pre">Flask</span></a></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">str</span></span></span><aclass="headerlink"href="#flask.sessions.SessionInterface.get_cookie_name"title="Link to this definition"></a></dt>
<dd><p>The name of the session cookie. Uses``app.config[“SESSION_COOKIE_NAME”]``.</p>
<spanclass="sig-name descname"><spanclass="pre">get_cookie_partitioned</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">app</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><aclass="reference internal"href="#flask.app.Flask"title="flask.app.Flask"><spanclass="pre">Flask</span></a></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">bool</span></span></span><aclass="headerlink"href="#flask.sessions.SessionInterface.get_cookie_partitioned"title="Link to this definition"></a></dt>
<dd><p>Returns True if the cookie should be partitioned. By default, uses
the value of <codeclass="xref py py-data docutils literal notranslate"><spanclass="pre">SESSION_COOKIE_PARTITIONED</span></code>.</p>
<divclass="versionadded">
<p><spanclass="versionmodified added">Added in version 3.1.</span></p>
<spanclass="sig-name descname"><spanclass="pre">get_cookie_path</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">app</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><aclass="reference internal"href="#flask.app.Flask"title="flask.app.Flask"><spanclass="pre">Flask</span></a></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">str</span></span></span><aclass="headerlink"href="#flask.sessions.SessionInterface.get_cookie_path"title="Link to this definition"></a></dt>
<dd><p>Returns the path for which the cookie should be valid. The
default implementation uses the value from the <codeclass="docutils literal notranslate"><spanclass="pre">SESSION_COOKIE_PATH</span></code>
config var if it’s set, and falls back to <codeclass="docutils literal notranslate"><spanclass="pre">APPLICATION_ROOT</span></code> or
uses <codeclass="docutils literal notranslate"><spanclass="pre">/</span></code> if it’s <codeclass="docutils literal notranslate"><spanclass="pre">None</span></code>.</p>
<spanclass="sig-name descname"><spanclass="pre">get_cookie_samesite</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">app</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><aclass="reference internal"href="#flask.app.Flask"title="flask.app.Flask"><spanclass="pre">Flask</span></a></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">str</span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">None</span></span></span><aclass="headerlink"href="#flask.sessions.SessionInterface.get_cookie_samesite"title="Link to this definition"></a></dt>
<dd><p>Return <codeclass="docutils literal notranslate"><spanclass="pre">'Strict'</span></code> or <codeclass="docutils literal notranslate"><spanclass="pre">'Lax'</span></code> if the cookie should use the
<codeclass="docutils literal notranslate"><spanclass="pre">SameSite</span></code> attribute. This currently just returns the value of
the <codeclass="xref py py-data docutils literal notranslate"><spanclass="pre">SESSION_COOKIE_SAMESITE</span></code> setting.</p>
<spanclass="sig-name descname"><spanclass="pre">get_cookie_secure</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">app</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><aclass="reference internal"href="#flask.app.Flask"title="flask.app.Flask"><spanclass="pre">Flask</span></a></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">bool</span></span></span><aclass="headerlink"href="#flask.sessions.SessionInterface.get_cookie_secure"title="Link to this definition"></a></dt>
<dd><p>Returns True if the cookie should be secure. This currently
just returns the value of the <codeclass="docutils literal notranslate"><spanclass="pre">SESSION_COOKIE_SECURE</span></code> setting.</p>
<spanclass="sig-name descname"><spanclass="pre">get_expiration_time</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">app</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><aclass="reference internal"href="#flask.app.Flask"title="flask.app.Flask"><spanclass="pre">Flask</span></a></span></em>, <emclass="sig-param"><spanclass="n"><spanclass="pre">session</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><aclass="reference internal"href="#flask.sessions.SessionMixin"title="flask.sessions.SessionMixin"><spanclass="pre">SessionMixin</span></a></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">datetime</span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">None</span></span></span><aclass="headerlink"href="#flask.sessions.SessionInterface.get_expiration_time"title="Link to this definition"></a></dt>
<dd><p>A helper method that returns an expiration date for the session
or <codeclass="docutils literal notranslate"><spanclass="pre">None</span></code> if the session is linked to the browser session. The
default implementation returns now + the permanent session
<spanclass="sig-name descname"><spanclass="pre">is_null_session</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">obj</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">object</span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">bool</span></span></span><aclass="headerlink"href="#flask.sessions.SessionInterface.is_null_session"title="Link to this definition"></a></dt>
<dd><p>Checks if a given object is a null session. Null sessions are
not asked to be saved.</p>
<p>This checks if the object is an instance of <aclass="reference internal"href="#flask.sessions.SessionInterface.null_session_class"title="flask.sessions.SessionInterface.null_session_class"><codeclass="xref py py-attr docutils literal notranslate"><spanclass="pre">null_session_class</span></code></a>
<spanclass="sig-name descname"><spanclass="pre">make_null_session</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">app</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><aclass="reference internal"href="#flask.app.Flask"title="flask.app.Flask"><spanclass="pre">Flask</span></a></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><aclass="reference internal"href="#flask.sessions.NullSession"title="flask.sessions.NullSession"><spanclass="pre">NullSession</span></a></span></span><aclass="headerlink"href="#flask.sessions.SessionInterface.make_null_session"title="Link to this definition"></a></dt>
<dd><p>Creates a null session which acts as a replacement object if the
real session support could not be loaded due to a configuration
error. This mainly aids the user experience because the job of the
null session is to still support lookup without complaining but
modifications are answered with a helpful error message of what
failed.</p>
<p>This creates an instance of <aclass="reference internal"href="#flask.sessions.SessionInterface.null_session_class"title="flask.sessions.SessionInterface.null_session_class"><codeclass="xref py py-attr docutils literal notranslate"><spanclass="pre">null_session_class</span></code></a> by default.</p>
<spanclass="sig-name descname"><spanclass="pre">null_session_class</span></span><aclass="headerlink"href="#flask.sessions.SessionInterface.null_session_class"title="Link to this definition"></a></dt>
<dd><p><aclass="reference internal"href="#flask.sessions.SessionInterface.make_null_session"title="flask.sessions.SessionInterface.make_null_session"><codeclass="xref py py-meth docutils literal notranslate"><spanclass="pre">make_null_session()</span></code></a> will look here for the class that should
be created when a null session is requested. Likewise the
<aclass="reference internal"href="#flask.sessions.SessionInterface.is_null_session"title="flask.sessions.SessionInterface.is_null_session"><codeclass="xref py py-meth docutils literal notranslate"><spanclass="pre">is_null_session()</span></code></a> method will perform a typecheck against
this type.</p>
<p>alias of <aclass="reference internal"href="#flask.sessions.NullSession"title="flask.sessions.NullSession"><codeclass="xref py py-class docutils literal notranslate"><spanclass="pre">NullSession</span></code></a></p>
<spanclass="sig-name descname"><spanclass="pre">open_session</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">app</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><aclass="reference internal"href="#flask.app.Flask"title="flask.app.Flask"><spanclass="pre">Flask</span></a></span></em>, <emclass="sig-param"><spanclass="n"><spanclass="pre">request</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><aclass="reference internal"href="#flask.wrappers.Request"title="flask.wrappers.Request"><spanclass="pre">Request</span></a></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><aclass="reference internal"href="#flask.sessions.SessionMixin"title="flask.sessions.SessionMixin"><spanclass="pre">SessionMixin</span></a><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">None</span></span></span><aclass="headerlink"href="#flask.sessions.SessionInterface.open_session"title="Link to this definition"></a></dt>
<dd><p>This is called at the beginning of each request, after
pushing the request context, before matching the URL.</p>
<p>This must return an object which implements a dictionary-like
interface as well as the <aclass="reference internal"href="#flask.sessions.SessionMixin"title="flask.sessions.SessionMixin"><codeclass="xref py py-class docutils literal notranslate"><spanclass="pre">SessionMixin</span></code></a> interface.</p>
<p>This will return <codeclass="docutils literal notranslate"><spanclass="pre">None</span></code> to indicate that loading failed in
some way that is not immediately an error. The request
context will fall back to using <aclass="reference internal"href="#flask.sessions.SessionInterface.make_null_session"title="flask.sessions.SessionInterface.make_null_session"><codeclass="xref py py-meth docutils literal notranslate"><spanclass="pre">make_null_session()</span></code></a>
<spanclass="sig-name descname"><spanclass="pre">pickle_based</span></span><emclass="property"><spanclass="w"></span><spanclass="p"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="pre">False</span></em><aclass="headerlink"href="#flask.sessions.SessionInterface.pickle_based"title="Link to this definition"></a></dt>
<dd><p>A flag that indicates if the session interface is pickle based.
This can be used by Flask extensions to make a decision in regards
to how to deal with the session object.</p>
<divclass="versionadded">
<p><spanclass="versionmodified added">Added in version 0.10.</span></p>
<spanclass="sig-name descname"><spanclass="pre">save_session</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">app</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><aclass="reference internal"href="#flask.app.Flask"title="flask.app.Flask"><spanclass="pre">Flask</span></a></span></em>, <emclass="sig-param"><spanclass="n"><spanclass="pre">session</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><aclass="reference internal"href="#flask.sessions.SessionMixin"title="flask.sessions.SessionMixin"><spanclass="pre">SessionMixin</span></a></span></em>, <emclass="sig-param"><spanclass="n"><spanclass="pre">response</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><aclass="reference internal"href="#flask.wrappers.Response"title="flask.wrappers.Response"><spanclass="pre">Response</span></a></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">None</span></span></span><aclass="headerlink"href="#flask.sessions.SessionInterface.save_session"title="Link to this definition"></a></dt>
<dd><p>This is called at the end of each request, after generating
a response, before removing the request context. It is skipped
<spanclass="sig-name descname"><spanclass="pre">should_set_cookie</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">app</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><aclass="reference internal"href="#flask.app.Flask"title="flask.app.Flask"><spanclass="pre">Flask</span></a></span></em>, <emclass="sig-param"><spanclass="n"><spanclass="pre">session</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><aclass="reference internal"href="#flask.sessions.SessionMixin"title="flask.sessions.SessionMixin"><spanclass="pre">SessionMixin</span></a></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">bool</span></span></span><aclass="headerlink"href="#flask.sessions.SessionInterface.should_set_cookie"title="Link to this definition"></a></dt>
<dd><p>Used by session backends to determine if a <codeclass="docutils literal notranslate"><spanclass="pre">Set-Cookie</span></code> header
should be set for this session cookie for this response. If the session
has been modified, the cookie is set. If the session is permanent and
the <codeclass="docutils literal notranslate"><spanclass="pre">SESSION_REFRESH_EACH_REQUEST</span></code> config is true, the cookie is
always set.</p>
<p>This check is usually skipped if the session was deleted.</p>
<divclass="versionadded">
<p><spanclass="versionmodified added">Added in version 0.11.</span></p>
<emclass="property"><spanclass="pre">class</span><spanclass="w"></span></em><spanclass="sig-prename descclassname"><spanclass="pre">flask.sessions.</span></span><spanclass="sig-name descname"><spanclass="pre">SessionMixin</span></span><aclass="headerlink"href="#flask.sessions.SessionMixin"title="Link to this definition"></a></dt>
<spanclass="sig-name descname"><spanclass="pre">accessed</span></span><emclass="property"><spanclass="w"></span><spanclass="p"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="pre">True</span></em><aclass="headerlink"href="#flask.sessions.SessionMixin.accessed"title="Link to this definition"></a></dt>
<dd><p>Some implementations can detect when session data is read or
written and set this when that happens. The mixin default is hard
coded to <codeclass="docutils literal notranslate"><spanclass="pre">True</span></code>.</p>
<spanclass="sig-name descname"><spanclass="pre">modified</span></span><emclass="property"><spanclass="w"></span><spanclass="p"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="pre">True</span></em><aclass="headerlink"href="#flask.sessions.SessionMixin.modified"title="Link to this definition"></a></dt>
<dd><p>Some implementations can detect changes to the session and set
this when that happens. The mixin default is hard coded to
<spanclass="sig-name descname"><spanclass="pre">new</span></span><emclass="property"><spanclass="w"></span><spanclass="p"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="pre">False</span></em><aclass="headerlink"href="#flask.sessions.SessionMixin.new"title="Link to this definition"></a></dt>
<emclass="property"><spanclass="pre">property</span><spanclass="w"></span></em><spanclass="sig-name descname"><spanclass="pre">permanent</span></span><emclass="property"><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="pre">bool</span></em><aclass="headerlink"href="#flask.sessions.SessionMixin.permanent"title="Link to this definition"></a></dt>
<dd><p>This reflects the <codeclass="docutils literal notranslate"><spanclass="pre">'_permanent'</span></code> key in the dict.</p>
</dd></dl>
</dd></dl>
</section>
<sectionid="module-flask.signals">
<spanid="flask-signals-module"></span><h2>flask.signals module<aclass="headerlink"href="#module-flask.signals"title="Link to this heading"></a></h2>
</section>
<sectionid="module-flask.templating">
<spanid="flask-templating-module"></span><h2>flask.templating module<aclass="headerlink"href="#module-flask.templating"title="Link to this heading"></a></h2>
<emclass="property"><spanclass="pre">class</span><spanclass="w"></span></em><spanclass="sig-prename descclassname"><spanclass="pre">flask.templating.</span></span><spanclass="sig-name descname"><spanclass="pre">DispatchingJinjaLoader</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">app</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">App</span></span></em><spanclass="sig-paren">)</span><aclass="headerlink"href="#flask.templating.DispatchingJinjaLoader"title="Link to this definition"></a></dt>
<spanclass="sig-name descname"><spanclass="pre">get_source</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">environment</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">Environment</span></span></em>, <emclass="sig-param"><spanclass="n"><spanclass="pre">template</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">str</span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">tuple</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="pre">str</span><spanclass="p"><spanclass="pre">,</span></span><spanclass="w"></span><spanclass="pre">str</span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">None</span><spanclass="p"><spanclass="pre">,</span></span><spanclass="w"></span><spanclass="pre">Callable</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="p"><spanclass="pre">[</span></span><spanclass="p"><spanclass="pre">]</span></span><spanclass="p"><spanclass="pre">,</span></span><spanclass="w"></span><spanclass="pre">bool</span><spanclass="p"><spanclass="pre">]</span></span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">None</span><spanclass="p"><spanclass="pre">]</span></span></span></span><aclass="headerlink"href="#flask.templating.DispatchingJinjaLoader.get_source"title="Link to this definition"></a></dt>
<dd><p>Get the template source, filename and reload helper for a template.
It’s passed the environment and template name and has to return a
tuple in the form <codeclass="docutils literal notranslate"><spanclass="pre">(source,</span><spanclass="pre">filename,</span><spanclass="pre">uptodate)</span></code> or raise a
<cite>TemplateNotFound</cite> error if it can’t locate the template.</p>
<p>The source part of the returned tuple must be the source of the
template as a string. The filename should be the name of the
file on the filesystem if it was loaded from there, otherwise
<codeclass="docutils literal notranslate"><spanclass="pre">None</span></code>. The filename is used by Python for the tracebacks
if no loader extension is used.</p>
<p>The last item in the tuple is the <cite>uptodate</cite> function. If auto
reloading is enabled it’s always called to check if the template
changed. No arguments are passed so the function must store the
old state somewhere (for example in a closure). If it returns <cite>False</cite>
<spanclass="sig-name descname"><spanclass="pre">list_templates</span></span><spanclass="sig-paren">(</span><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">list</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="pre">str</span><spanclass="p"><spanclass="pre">]</span></span></span></span><aclass="headerlink"href="#flask.templating.DispatchingJinjaLoader.list_templates"title="Link to this definition"></a></dt>
<dd><p>Iterates over all templates. If the loader does not support that
it should raise a <codeclass="xref py py-exc docutils literal notranslate"><spanclass="pre">TypeError</span></code> which is the default behavior.</p>
<emclass="property"><spanclass="pre">class</span><spanclass="w"></span></em><spanclass="sig-prename descclassname"><spanclass="pre">flask.templating.</span></span><spanclass="sig-name descname"><spanclass="pre">Environment</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">app</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">App</span></span></em>, <emclass="sig-param"><spanclass="o"><spanclass="pre">**</span></span><spanclass="n"><spanclass="pre">options</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">t.Any</span></span></em><spanclass="sig-paren">)</span><aclass="headerlink"href="#flask.templating.Environment"title="Link to this definition"></a></dt>
<spanclass="sig-prename descclassname"><spanclass="pre">flask.templating.</span></span><spanclass="sig-name descname"><spanclass="pre">render_template</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">template_name_or_list</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">str</span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">Template</span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">list</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="pre">str</span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">Template</span><spanclass="p"><spanclass="pre">]</span></span></span></em>, <emclass="sig-param"><spanclass="o"><spanclass="pre">**</span></span><spanclass="n"><spanclass="pre">context</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">Any</span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">str</span></span></span><aclass="headerlink"href="#flask.templating.render_template"title="Link to this definition"></a></dt>
<dd><p>Render a template by name with the given context.</p>
<spanclass="sig-prename descclassname"><spanclass="pre">flask.templating.</span></span><spanclass="sig-name descname"><spanclass="pre">render_template_string</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">source</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">str</span></span></em>, <emclass="sig-param"><spanclass="o"><spanclass="pre">**</span></span><spanclass="n"><spanclass="pre">context</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">Any</span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">str</span></span></span><aclass="headerlink"href="#flask.templating.render_template_string"title="Link to this definition"></a></dt>
<dd><p>Render a template from the given source string with the given
<spanclass="sig-prename descclassname"><spanclass="pre">flask.templating.</span></span><spanclass="sig-name descname"><spanclass="pre">stream_template</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">template_name_or_list</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">str</span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">Template</span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">list</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="pre">str</span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">Template</span><spanclass="p"><spanclass="pre">]</span></span></span></em>, <emclass="sig-param"><spanclass="o"><spanclass="pre">**</span></span><spanclass="n"><spanclass="pre">context</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">Any</span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">Iterator</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="pre">str</span><spanclass="p"><spanclass="pre">]</span></span></span></span><aclass="headerlink"href="#flask.templating.stream_template"title="Link to this definition"></a></dt>
<dd><p>Render a template by name with the given context as a stream.
This returns an iterator of strings, which can be used as a
<spanclass="sig-prename descclassname"><spanclass="pre">flask.templating.</span></span><spanclass="sig-name descname"><spanclass="pre">stream_template_string</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">source</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">str</span></span></em>, <emclass="sig-param"><spanclass="o"><spanclass="pre">**</span></span><spanclass="n"><spanclass="pre">context</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">Any</span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">Iterator</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="pre">str</span><spanclass="p"><spanclass="pre">]</span></span></span></span><aclass="headerlink"href="#flask.templating.stream_template_string"title="Link to this definition"></a></dt>
<dd><p>Render a template from the given source string with the given
context as a stream. This returns an iterator of strings, which can
<li><p><strong>subdomain</strong>– Subdomain name to append to <codeclass="xref py py-data docutils literal notranslate"><spanclass="pre">SERVER_NAME</span></code>.</p></li>
<li><p><strong>url_scheme</strong>– Scheme to use instead of
<li><p><strong>json</strong>– If given, this is serialized as JSON and passed as
<codeclass="docutils literal notranslate"><spanclass="pre">data</span></code>. Also defaults <codeclass="docutils literal notranslate"><spanclass="pre">content_type</span></code> to
<spanclass="sig-name descname"><spanclass="pre">json_dumps</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">obj</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">Any</span></span></em>, <emclass="sig-param"><spanclass="o"><spanclass="pre">**</span></span><spanclass="n"><spanclass="pre">kwargs</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">Any</span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">str</span></span></span><aclass="headerlink"href="#flask.testing.EnvironBuilder.json_dumps"title="Link to this definition"></a></dt>
<dd><p>Serialize <codeclass="docutils literal notranslate"><spanclass="pre">obj</span></code> to a JSON-formatted string.</p>
<p>The serialization will be configured according to the config associated
with this EnvironBuilder’s <codeclass="docutils literal notranslate"><spanclass="pre">app</span></code>.</p>
<emclass="property"><spanclass="pre">class</span><spanclass="w"></span></em><spanclass="sig-prename descclassname"><spanclass="pre">flask.testing.</span></span><spanclass="sig-name descname"><spanclass="pre">FlaskCliRunner</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">app</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><aclass="reference internal"href="#flask.app.Flask"title="flask.app.Flask"><spanclass="pre">Flask</span></a></span></em>, <emclass="sig-param"><spanclass="o"><spanclass="pre">**</span></span><spanclass="n"><spanclass="pre">kwargs</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">t.Any</span></span></em><spanclass="sig-paren">)</span><aclass="headerlink"href="#flask.testing.FlaskCliRunner"title="Link to this definition"></a></dt>
<spanclass="sig-name descname"><spanclass="pre">invoke</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">cli</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">Any</span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">None</span></span><spanclass="w"></span><spanclass="o"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="default_value"><spanclass="pre">None</span></span></em>, <emclass="sig-param"><spanclass="n"><spanclass="pre">args</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">Any</span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">None</span></span><spanclass="w"></span><spanclass="o"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="default_value"><spanclass="pre">None</span></span></em>, <emclass="sig-param"><spanclass="o"><spanclass="pre">**</span></span><spanclass="n"><spanclass="pre">kwargs</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">Any</span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">Result</span></span></span><aclass="headerlink"href="#flask.testing.FlaskCliRunner.invoke"title="Link to this definition"></a></dt>
<dd><p>Invokes a CLI command in an isolated environment. See
<codeclass="xref py py-meth docutils literal notranslate"><spanclass="pre">CliRunner.invoke</span></code> for
full method documentation. See <spanclass="xref std std-ref">testing-cli</span> for examples.</p>
<p>If the <codeclass="docutils literal notranslate"><spanclass="pre">obj</span></code> argument is not given, passes an instance of
<aclass="reference internal"href="#flask.cli.ScriptInfo"title="flask.cli.ScriptInfo"><codeclass="xref py py-class docutils literal notranslate"><spanclass="pre">ScriptInfo</span></code></a> that knows how to load the Flask
<emclass="property"><spanclass="pre">class</span><spanclass="w"></span></em><spanclass="sig-prename descclassname"><spanclass="pre">flask.testing.</span></span><spanclass="sig-name descname"><spanclass="pre">FlaskClient</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="o"><spanclass="pre">*</span></span><spanclass="n"><spanclass="pre">args</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">Any</span></span></em>, <emclass="sig-param"><spanclass="o"><spanclass="pre">**</span></span><spanclass="n"><spanclass="pre">kwargs</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">Any</span></span></em><spanclass="sig-paren">)</span><aclass="headerlink"href="#flask.testing.FlaskClient"title="Link to this definition"></a></dt>
<p>Works like a regular Werkzeug test client but has knowledge about
Flask’s contexts to defer the cleanup of the request context until
the end of a <codeclass="docutils literal notranslate"><spanclass="pre">with</span></code> block. For general information about how to
use this class refer to <codeclass="xref py py-class docutils literal notranslate"><spanclass="pre">werkzeug.test.Client</span></code>.</p>
<divclass="versionchanged">
<p><spanclass="versionmodified changed">Changed in version 0.12: </span><cite>app.test_client()</cite> includes preset default environment, which can be
set after instantiation of the <cite>app.test_client()</cite> object in
<cite>client.environ_base</cite>.</p>
</div>
<p>Basic usage is outlined in the <spanclass="xref std std-doc">/testing</span> chapter.</p>
<spanclass="sig-name descname"><spanclass="pre">application</span></span><emclass="property"><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><aclass="reference internal"href="#flask.app.Flask"title="flask.app.Flask"><spanclass="pre">Flask</span></a></em><aclass="headerlink"href="#flask.testing.FlaskClient.application"title="Link to this definition"></a></dt>
<spanclass="sig-name descname"><spanclass="pre">open</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="o"><spanclass="pre">*</span></span><spanclass="n"><spanclass="pre">args</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">t.Any</span></span></em>, <emclass="sig-param"><spanclass="n"><spanclass="pre">buffered</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">bool</span></span><spanclass="w"></span><spanclass="o"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="default_value"><spanclass="pre">False</span></span></em>, <emclass="sig-param"><spanclass="n"><spanclass="pre">follow_redirects</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">bool</span></span><spanclass="w"></span><spanclass="o"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="default_value"><spanclass="pre">False</span></span></em>, <emclass="sig-param"><spanclass="o"><spanclass="pre">**</span></span><spanclass="n"><spanclass="pre">kwargs</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">t.Any</span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">TestResponse</span></span></span><aclass="headerlink"href="#flask.testing.FlaskClient.open"title="Link to this definition"></a></dt>
<dd><p>Generate an environ dict from the given arguments, make a
request to the application using it, and return the response.</p>
<li><p><strong>args</strong>– Passed to <aclass="reference internal"href="#flask.testing.EnvironBuilder"title="flask.testing.EnvironBuilder"><codeclass="xref py py-class docutils literal notranslate"><spanclass="pre">EnvironBuilder</span></code></a> to create the
environ for the request. If a single arg is passed, it can
be an existing <aclass="reference internal"href="#flask.testing.EnvironBuilder"title="flask.testing.EnvironBuilder"><codeclass="xref py py-class docutils literal notranslate"><spanclass="pre">EnvironBuilder</span></code></a> or an environ dict.</p></li>
<li><p><strong>buffered</strong>– Convert the iterator returned by the app into
a list. If the iterator has a <codeclass="docutils literal notranslate"><spanclass="pre">close()</span></code> method, it is
called automatically.</p></li>
<li><p><strong>follow_redirects</strong>– Make additional requests to follow HTTP
redirects until a non-redirect status is returned.
<codeclass="xref py py-attr docutils literal notranslate"><spanclass="pre">TestResponse.history</span></code> lists the intermediate
responses.</p></li>
</ul>
</dd>
</dl>
<divclass="versionchanged">
<p><spanclass="versionmodified changed">Changed in version 2.1: </span>Removed the <codeclass="docutils literal notranslate"><spanclass="pre">as_tuple</span></code> parameter.</p>
</div>
<divclass="versionchanged">
<p><spanclass="versionmodified changed">Changed in version 2.0: </span>The request input stream is closed when calling
<codeclass="docutils literal notranslate"><spanclass="pre">response.close()</span></code>. Input streams for redirects are
automatically closed.</p>
</div>
<divclass="versionchanged">
<p><spanclass="versionmodified changed">Changed in version 0.5: </span>If a dict is provided as file in the dict for the <codeclass="docutils literal notranslate"><spanclass="pre">data</span></code>
parameter the content type has to be called <codeclass="docutils literal notranslate"><spanclass="pre">content_type</span></code>
instead of <codeclass="docutils literal notranslate"><spanclass="pre">mimetype</span></code>. This change was made for
consistency with <codeclass="xref py py-class docutils literal notranslate"><spanclass="pre">werkzeug.FileWrapper</span></code>.</p>
</div>
<divclass="versionchanged">
<p><spanclass="versionmodified changed">Changed in version 0.5: </span>Added the <codeclass="docutils literal notranslate"><spanclass="pre">follow_redirects</span></code> parameter.</p>
<spanclass="sig-name descname"><spanclass="pre">session_transaction</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="o"><spanclass="pre">*</span></span><spanclass="n"><spanclass="pre">args</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">Any</span></span></em>, <emclass="sig-param"><spanclass="o"><spanclass="pre">**</span></span><spanclass="n"><spanclass="pre">kwargs</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">Any</span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">Iterator</span><spanclass="p"><spanclass="pre">[</span></span><aclass="reference internal"href="#flask.sessions.SessionMixin"title="flask.sessions.SessionMixin"><spanclass="pre">SessionMixin</span></a><spanclass="p"><spanclass="pre">]</span></span></span></span><aclass="headerlink"href="#flask.testing.FlaskClient.session_transaction"title="Link to this definition"></a></dt>
<dd><p>When used in combination with a <codeclass="docutils literal notranslate"><spanclass="pre">with</span></code> statement this opens a
session transaction. This can be used to modify the session that
the test client uses. Once the <codeclass="docutils literal notranslate"><spanclass="pre">with</span></code> block is left the session is
<emclass="property"><spanclass="pre">class</span><spanclass="w"></span></em><spanclass="sig-prename descclassname"><spanclass="pre">flask.views.</span></span><spanclass="sig-name descname"><spanclass="pre">MethodView</span></span><aclass="headerlink"href="#flask.views.MethodView"title="Link to this definition"></a></dt>
<p>This can be useful for defining a REST API.</p>
<p><codeclass="xref py py-attr docutils literal notranslate"><spanclass="pre">methods</span></code> is automatically set based on the methods defined on
the class.</p>
<p>See <spanclass="xref std std-doc">views</span> for a detailed guide.</p>
<spanclass="sig-name descname"><spanclass="pre">dispatch_request</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="o"><spanclass="pre">**</span></span><spanclass="n"><spanclass="pre">kwargs</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">t.Any</span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">ft.ResponseReturnValue</span></span></span><aclass="headerlink"href="#flask.views.MethodView.dispatch_request"title="Link to this definition"></a></dt>
<dd><p>The actual view function behavior. Subclasses must override
this and return a valid response. Any variables from the URL
<emclass="property"><spanclass="pre">class</span><spanclass="w"></span></em><spanclass="sig-prename descclassname"><spanclass="pre">flask.views.</span></span><spanclass="sig-name descname"><spanclass="pre">View</span></span><aclass="headerlink"href="#flask.views.View"title="Link to this definition"></a></dt>
<p>Subclass this class and override <aclass="reference internal"href="#flask.views.View.dispatch_request"title="flask.views.View.dispatch_request"><codeclass="xref py py-meth docutils literal notranslate"><spanclass="pre">dispatch_request()</span></code></a> to
create a generic class-based view. Call <aclass="reference internal"href="#flask.views.View.as_view"title="flask.views.View.as_view"><codeclass="xref py py-meth docutils literal notranslate"><spanclass="pre">as_view()</span></code></a> to create a
view function that creates an instance of the class with the given
arguments and calls its <codeclass="docutils literal notranslate"><spanclass="pre">dispatch_request</span></code> method with any URL
variables.</p>
<p>See <spanclass="xref std std-doc">views</span> for a detailed guide.</p>
<p>Set <aclass="reference internal"href="#flask.views.View.methods"title="flask.views.View.methods"><codeclass="xref py py-attr docutils literal notranslate"><spanclass="pre">methods</span></code></a> on the class to change what methods the view
accepts.</p>
<p>Set <aclass="reference internal"href="#flask.views.View.decorators"title="flask.views.View.decorators"><codeclass="xref py py-attr docutils literal notranslate"><spanclass="pre">decorators</span></code></a> on the class to apply a list of decorators to
the generated view function. Decorators applied to the class itself
will not be applied to the generated view function!</p>
<p>Set <aclass="reference internal"href="#flask.views.View.init_every_request"title="flask.views.View.init_every_request"><codeclass="xref py py-attr docutils literal notranslate"><spanclass="pre">init_every_request</span></code></a> to <codeclass="docutils literal notranslate"><spanclass="pre">False</span></code> for efficiency, unless
you need to store request-global data on <codeclass="docutils literal notranslate"><spanclass="pre">self</span></code>.</p>
<emclass="property"><spanclass="pre">classmethod</span><spanclass="w"></span></em><spanclass="sig-name descname"><spanclass="pre">as_view</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">name</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">str</span></span></em>, <emclass="sig-param"><spanclass="o"><spanclass="pre">*</span></span><spanclass="n"><spanclass="pre">class_args</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">t.Any</span></span></em>, <emclass="sig-param"><spanclass="o"><spanclass="pre">**</span></span><spanclass="n"><spanclass="pre">class_kwargs</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">t.Any</span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">ft.RouteCallable</span></span></span><aclass="headerlink"href="#flask.views.View.as_view"title="Link to this definition"></a></dt>
<dd><p>Convert the class into a view function that can be registered
for a route.</p>
<p>By default, the generated view will create a new instance of the
view class for every request and call its
<aclass="reference internal"href="#flask.views.View.dispatch_request"title="flask.views.View.dispatch_request"><codeclass="xref py py-meth docutils literal notranslate"><spanclass="pre">dispatch_request()</span></code></a> method. If the view class sets
<aclass="reference internal"href="#flask.views.View.init_every_request"title="flask.views.View.init_every_request"><codeclass="xref py py-attr docutils literal notranslate"><spanclass="pre">init_every_request</span></code></a> to <codeclass="docutils literal notranslate"><spanclass="pre">False</span></code>, the same instance will
be used for every request.</p>
<p>Except for <codeclass="docutils literal notranslate"><spanclass="pre">name</span></code>, all other arguments passed to this method
are forwarded to the view class <codeclass="docutils literal notranslate"><spanclass="pre">__init__</span></code> method.</p>
<divclass="versionchanged">
<p><spanclass="versionmodified changed">Changed in version 2.2: </span>Added the <codeclass="docutils literal notranslate"><spanclass="pre">init_every_request</span></code> class attribute.</p>
<spanclass="sig-name descname"><spanclass="pre">decorators</span></span><emclass="property"><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="pre">ClassVar</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="pre">list</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="pre">Callable</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="p"><spanclass="pre">[</span></span><spanclass="p"><spanclass="pre">...</span></span><spanclass="p"><spanclass="pre">]</span></span><spanclass="p"><spanclass="pre">,</span></span><spanclass="w"></span><spanclass="pre">Any</span><spanclass="p"><spanclass="pre">]</span></span><spanclass="p"><spanclass="pre">]</span></span><spanclass="p"><spanclass="pre">]</span></span></em><emclass="property"><spanclass="w"></span><spanclass="p"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="pre">[]</span></em><aclass="headerlink"href="#flask.views.View.decorators"title="Link to this definition"></a></dt>
<dd><p>A list of decorators to apply, in order, to the generated view
function. Remember that <codeclass="docutils literal notranslate"><spanclass="pre">@decorator</span></code> syntax is applied bottom
to top, so the first decorator in the list would be the bottom
decorator.</p>
<divclass="versionadded">
<p><spanclass="versionmodified added">Added in version 0.8.</span></p>
<spanclass="sig-name descname"><spanclass="pre">dispatch_request</span></span><spanclass="sig-paren">(</span><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">ft.ResponseReturnValue</span></span></span><aclass="headerlink"href="#flask.views.View.dispatch_request"title="Link to this definition"></a></dt>
<dd><p>The actual view function behavior. Subclasses must override
this and return a valid response. Any variables from the URL
<spanclass="sig-name descname"><spanclass="pre">init_every_request</span></span><emclass="property"><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="pre">ClassVar</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="pre">bool</span><spanclass="p"><spanclass="pre">]</span></span></em><emclass="property"><spanclass="w"></span><spanclass="p"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="pre">True</span></em><aclass="headerlink"href="#flask.views.View.init_every_request"title="Link to this definition"></a></dt>
<dd><p>Create a new instance of this view class for every request by
default. If a view subclass sets this to <codeclass="docutils literal notranslate"><spanclass="pre">False</span></code>, the same
instance is used for every request.</p>
<p>A single instance is more efficient, especially if complex setup
is done during init. However, storing data on <codeclass="docutils literal notranslate"><spanclass="pre">self</span></code> is no
longer safe across requests, and <codeclass="xref py py-data docutils literal notranslate"><spanclass="pre">g</span></code> should be used
instead.</p>
<divclass="versionadded">
<p><spanclass="versionmodified added">Added in version 2.2.</span></p>
<spanclass="sig-name descname"><spanclass="pre">methods</span></span><emclass="property"><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="pre">ClassVar</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="pre">Collection</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="pre">str</span><spanclass="p"><spanclass="pre">]</span></span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">None</span><spanclass="p"><spanclass="pre">]</span></span></em><emclass="property"><spanclass="w"></span><spanclass="p"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="pre">None</span></em><aclass="headerlink"href="#flask.views.View.methods"title="Link to this definition"></a></dt>
<dd><p>The methods this view is registered for. Uses the same default
(<codeclass="docutils literal notranslate"><spanclass="pre">["GET",</span><spanclass="pre">"HEAD",</span><spanclass="pre">"OPTIONS"]</span></code>) as <codeclass="docutils literal notranslate"><spanclass="pre">route</span></code> and
<codeclass="docutils literal notranslate"><spanclass="pre">add_url_rule</span></code> by default.</p>
<spanclass="sig-name descname"><spanclass="pre">provide_automatic_options</span></span><emclass="property"><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="pre">ClassVar</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="pre">bool</span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">None</span><spanclass="p"><spanclass="pre">]</span></span></em><emclass="property"><spanclass="w"></span><spanclass="p"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="pre">None</span></em><aclass="headerlink"href="#flask.views.View.provide_automatic_options"title="Link to this definition"></a></dt>
<dd><p>Control whether the <codeclass="docutils literal notranslate"><spanclass="pre">OPTIONS</span></code> method is handled automatically.
Uses the same default (<codeclass="docutils literal notranslate"><spanclass="pre">True</span></code>) as <codeclass="docutils literal notranslate"><spanclass="pre">route</span></code> and
<codeclass="docutils literal notranslate"><spanclass="pre">add_url_rule</span></code> by default.</p>
</dd></dl>
</dd></dl>
</section>
<sectionid="module-flask.wrappers">
<spanid="flask-wrappers-module"></span><h2>flask.wrappers module<aclass="headerlink"href="#module-flask.wrappers"title="Link to this heading"></a></h2>
<emclass="property"><spanclass="pre">class</span><spanclass="w"></span></em><spanclass="sig-prename descclassname"><spanclass="pre">flask.wrappers.</span></span><spanclass="sig-name descname"><spanclass="pre">Request</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">environ</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">WSGIEnvironment</span></span></em>, <emclass="sig-param"><spanclass="n"><spanclass="pre">populate_request</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">bool</span></span><spanclass="w"></span><spanclass="o"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="default_value"><spanclass="pre">True</span></span></em>, <emclass="sig-param"><spanclass="n"><spanclass="pre">shallow</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">bool</span></span><spanclass="w"></span><spanclass="o"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="default_value"><spanclass="pre">False</span></span></em><spanclass="sig-paren">)</span><aclass="headerlink"href="#flask.wrappers.Request"title="Link to this definition"></a></dt>
<emclass="property"><spanclass="pre">property</span><spanclass="w"></span></em><spanclass="sig-name descname"><spanclass="pre">blueprint</span></span><emclass="property"><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="pre">str</span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">None</span></em><aclass="headerlink"href="#flask.wrappers.Request.blueprint"title="Link to this definition"></a></dt>
<dd><p>The registered name of the current blueprint.</p>
<p>This will be <codeclass="docutils literal notranslate"><spanclass="pre">None</span></code> if the endpoint is not part of a
blueprint, or if URL matching failed or has not been performed
yet.</p>
<p>This does not necessarily match the name the blueprint was
created with. It may have been nested, or registered with a
<emclass="property"><spanclass="pre">property</span><spanclass="w"></span></em><spanclass="sig-name descname"><spanclass="pre">blueprints</span></span><emclass="property"><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="pre">list</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="pre">str</span><spanclass="p"><spanclass="pre">]</span></span></em><aclass="headerlink"href="#flask.wrappers.Request.blueprints"title="Link to this definition"></a></dt>
<dd><p>The registered names of the current blueprint upwards through
parent blueprints.</p>
<p>This will be an empty list if there is no current blueprint, or
if URL matching failed.</p>
<divclass="versionadded">
<p><spanclass="versionmodified added">Added in version 2.0.1.</span></p>
<emclass="property"><spanclass="pre">property</span><spanclass="w"></span></em><spanclass="sig-name descname"><spanclass="pre">endpoint</span></span><emclass="property"><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="pre">str</span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">None</span></em><aclass="headerlink"href="#flask.wrappers.Request.endpoint"title="Link to this definition"></a></dt>
<dd><p>The endpoint that matched the request URL.</p>
<p>This will be <codeclass="docutils literal notranslate"><spanclass="pre">None</span></code> if matching failed or has not been
performed yet.</p>
<p>This in combination with <aclass="reference internal"href="#flask.wrappers.Request.view_args"title="flask.wrappers.Request.view_args"><codeclass="xref py py-attr docutils literal notranslate"><spanclass="pre">view_args</span></code></a> can be used to
<spanclass="sig-name descname"><spanclass="pre">json_module</span></span><emclass="property"><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="pre">t.Any</span></em><emclass="property"><spanclass="w"></span><spanclass="p"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="pre"><module</span><spanclass="pre">'flask.json'</span><spanclass="pre">from</span><spanclass="pre">'/home/edgar/ucr/software_des/repo/flask/src/flask/json/__init__.py'></span></em><aclass="headerlink"href="#flask.wrappers.Request.json_module"title="Link to this definition"></a></dt>
<dd><p>A module or other object that has <codeclass="docutils literal notranslate"><spanclass="pre">dumps</span></code> and <codeclass="docutils literal notranslate"><spanclass="pre">loads</span></code>
functions that match the API of the built-in <codeclass="xref py py-mod docutils literal notranslate"><spanclass="pre">json</span></code> module.</p>
<emclass="property"><spanclass="pre">property</span><spanclass="w"></span></em><spanclass="sig-name descname"><spanclass="pre">max_content_length</span></span><emclass="property"><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="pre">int</span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">None</span></em><aclass="headerlink"href="#flask.wrappers.Request.max_content_length"title="Link to this definition"></a></dt>
<dd><p>The maximum number of bytes that will be read during this request. If
this limit is exceeded, a 413 <codeclass="xref py py-exc docutils literal notranslate"><spanclass="pre">RequestEntityTooLarge</span></code>
error is raised. If it is set to <codeclass="docutils literal notranslate"><spanclass="pre">None</span></code>, no limit is enforced at the
Flask application level. However, if it is <codeclass="docutils literal notranslate"><spanclass="pre">None</span></code> and the request has
no <codeclass="docutils literal notranslate"><spanclass="pre">Content-Length</span></code> header and the WSGI server does not indicate that
it terminates the stream, then no data is read to avoid an infinite
stream.</p>
<p>Each request defaults to the <codeclass="xref py py-data docutils literal notranslate"><spanclass="pre">MAX_CONTENT_LENGTH</span></code> config, which
defaults to <codeclass="docutils literal notranslate"><spanclass="pre">None</span></code>. It can be set on a specific <codeclass="docutils literal notranslate"><spanclass="pre">request</span></code> to apply
the limit to that specific view. This should be set appropriately based
on an application’s or view’s specific needs.</p>
<divclass="versionchanged">
<p><spanclass="versionmodified changed">Changed in version 3.1: </span>This can be set per-request.</p>
</div>
<divclass="versionchanged">
<p><spanclass="versionmodified changed">Changed in version 0.6: </span>This is configurable through Flask config.</p>
<emclass="property"><spanclass="pre">property</span><spanclass="w"></span></em><spanclass="sig-name descname"><spanclass="pre">max_form_memory_size</span></span><emclass="property"><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="pre">int</span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">None</span></em><aclass="headerlink"href="#flask.wrappers.Request.max_form_memory_size"title="Link to this definition"></a></dt>
<dd><p>The maximum size in bytes any non-file form field may be in a
<codeclass="docutils literal notranslate"><spanclass="pre">multipart/form-data</span></code> body. If this limit is exceeded, a 413
<codeclass="xref py py-exc docutils literal notranslate"><spanclass="pre">RequestEntityTooLarge</span></code> error is raised. If it
is set to <codeclass="docutils literal notranslate"><spanclass="pre">None</span></code>, no limit is enforced at the Flask application level.</p>
<p>Each request defaults to the <codeclass="xref py py-data docutils literal notranslate"><spanclass="pre">MAX_FORM_MEMORY_SIZE</span></code> config, which
defaults to <codeclass="docutils literal notranslate"><spanclass="pre">500_000</span></code>. It can be set on a specific <codeclass="docutils literal notranslate"><spanclass="pre">request</span></code> to
apply the limit to that specific view. This should be set appropriately
based on an application’s or view’s specific needs.</p>
<divclass="versionchanged">
<p><spanclass="versionmodified changed">Changed in version 3.1: </span>This is configurable through Flask config.</p>
<emclass="property"><spanclass="pre">property</span><spanclass="w"></span></em><spanclass="sig-name descname"><spanclass="pre">max_form_parts</span></span><emclass="property"><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="pre">int</span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">None</span></em><aclass="headerlink"href="#flask.wrappers.Request.max_form_parts"title="Link to this definition"></a></dt>
<dd><p>The maximum number of fields that may be present in a
<codeclass="docutils literal notranslate"><spanclass="pre">multipart/form-data</span></code> body. If this limit is exceeded, a 413
<codeclass="xref py py-exc docutils literal notranslate"><spanclass="pre">RequestEntityTooLarge</span></code> error is raised. If it
is set to <codeclass="docutils literal notranslate"><spanclass="pre">None</span></code>, no limit is enforced at the Flask application level.</p>
<p>Each request defaults to the <codeclass="xref py py-data docutils literal notranslate"><spanclass="pre">MAX_FORM_PARTS</span></code> config, which
defaults to <codeclass="docutils literal notranslate"><spanclass="pre">1_000</span></code>. It can be set on a specific <codeclass="docutils literal notranslate"><spanclass="pre">request</span></code> to apply
the limit to that specific view. This should be set appropriately based
on an application’s or view’s specific needs.</p>
<divclass="versionchanged">
<p><spanclass="versionmodified changed">Changed in version 3.1: </span>This is configurable through Flask config.</p>
<spanclass="sig-name descname"><spanclass="pre">on_json_loading_failed</span></span><spanclass="sig-paren">(</span><emclass="sig-param"><spanclass="n"><spanclass="pre">e</span></span><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="n"><spanclass="pre">ValueError</span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">None</span></span></em><spanclass="sig-paren">)</span><spanclass="sig-return"><spanclass="sig-return-icon">→</span><spanclass="sig-return-typehint"><spanclass="pre">Any</span></span></span><aclass="headerlink"href="#flask.wrappers.Request.on_json_loading_failed"title="Link to this definition"></a></dt>
<dd><p>Called if <codeclass="xref py py-meth docutils literal notranslate"><spanclass="pre">get_json()</span></code> fails and isn’t silenced.</p>
<p>If this method returns a value, it is used as the return value
for <codeclass="xref py py-meth docutils literal notranslate"><spanclass="pre">get_json()</span></code>. The default implementation raises
<ddclass="field-odd"><p><strong>e</strong>– If parsing failed, this is the exception. It will be
<codeclass="docutils literal notranslate"><spanclass="pre">None</span></code> if the content type wasn’t <codeclass="docutils literal notranslate"><spanclass="pre">application/json</span></code>.</p>
</dd>
</dl>
<divclass="versionchanged">
<p><spanclass="versionmodified changed">Changed in version 2.3: </span>Raise a 415 error instead of 400.</p>
<spanclass="sig-name descname"><spanclass="pre">routing_exception</span></span><emclass="property"><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="pre">HTTPException</span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">None</span></em><emclass="property"><spanclass="w"></span><spanclass="p"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="pre">None</span></em><aclass="headerlink"href="#flask.wrappers.Request.routing_exception"title="Link to this definition"></a></dt>
<dd><p>If matching the URL failed, this is the exception that will be
raised / was raised as part of the request handling. This is
usually a <codeclass="xref py py-exc docutils literal notranslate"><spanclass="pre">NotFound</span></code> exception or
<spanclass="sig-name descname"><spanclass="pre">url_rule</span></span><emclass="property"><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="pre">Rule</span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">None</span></em><emclass="property"><spanclass="w"></span><spanclass="p"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="pre">None</span></em><aclass="headerlink"href="#flask.wrappers.Request.url_rule"title="Link to this definition"></a></dt>
<dd><p>The internal URL rule that matched the request. This can be
useful to inspect which methods are allowed for the URL from
a before/after handler (<codeclass="docutils literal notranslate"><spanclass="pre">request.url_rule.methods</span></code>) etc.
Though if the request’s method was invalid for the URL rule,
the valid list is available in <codeclass="docutils literal notranslate"><spanclass="pre">routing_exception.valid_methods</span></code>
<spanclass="sig-name descname"><spanclass="pre">view_args</span></span><emclass="property"><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="pre">dict</span><spanclass="p"><spanclass="pre">[</span></span><spanclass="pre">str</span><spanclass="p"><spanclass="pre">,</span></span><spanclass="w"></span><spanclass="pre">t.Any</span><spanclass="p"><spanclass="pre">]</span></span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">None</span></em><emclass="property"><spanclass="w"></span><spanclass="p"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="pre">None</span></em><aclass="headerlink"href="#flask.wrappers.Request.view_args"title="Link to this definition"></a></dt>
<dd><p>A dict of view arguments that matched the request. If an exception
happened when matching, this will be <codeclass="docutils literal notranslate"><spanclass="pre">None</span></code>.</p>
<spanclass="sig-name descname"><spanclass="pre">autocorrect_location_header</span></span><emclass="property"><spanclass="w"></span><spanclass="p"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="pre">False</span></em><aclass="headerlink"href="#flask.wrappers.Response.autocorrect_location_header"title="Link to this definition"></a></dt>
<dd><p>If a redirect <codeclass="docutils literal notranslate"><spanclass="pre">Location</span></code> header is a relative URL, make it an
absolute URL, including scheme and domain.</p>
<divclass="versionchanged">
<p><spanclass="versionmodified changed">Changed in version 2.1: </span>This is disabled by default, so responses will send relative
redirects.</p>
</div>
<divclass="versionadded">
<p><spanclass="versionmodified added">Added in version 0.8.</span></p>
<spanclass="sig-name descname"><spanclass="pre">default_mimetype</span></span><emclass="property"><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="pre">str</span><spanclass="w"></span><spanclass="p"><spanclass="pre">|</span></span><spanclass="w"></span><spanclass="pre">None</span></em><emclass="property"><spanclass="w"></span><spanclass="p"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="pre">'text/html'</span></em><aclass="headerlink"href="#flask.wrappers.Response.default_mimetype"title="Link to this definition"></a></dt>
<dd><p>the default mimetype if none is provided.</p>
<spanclass="sig-name descname"><spanclass="pre">json_module</span></span><emclass="property"><spanclass="w"></span><spanclass="p"><spanclass="pre">=</span></span><spanclass="w"></span><spanclass="pre"><module</span><spanclass="pre">'flask.json'</span><spanclass="pre">from</span><spanclass="pre">'/home/edgar/ucr/software_des/repo/flask/src/flask/json/__init__.py'></span></em><aclass="headerlink"href="#flask.wrappers.Response.json_module"title="Link to this definition"></a></dt>
<dd><p>A module or other object that has <codeclass="docutils literal notranslate"><spanclass="pre">dumps</span></code> and <codeclass="docutils literal notranslate"><spanclass="pre">loads</span></code>
functions that match the API of the built-in <codeclass="xref py py-mod docutils literal notranslate"><spanclass="pre">json</span></code> module.</p>
<emclass="property"><spanclass="pre">property</span><spanclass="w"></span></em><spanclass="sig-name descname"><spanclass="pre">max_cookie_size</span></span><emclass="property"><spanclass="p"><spanclass="pre">:</span></span><spanclass="w"></span><spanclass="pre">int</span></em><aclass="headerlink"href="#flask.wrappers.Response.max_cookie_size"title="Link to this definition"></a></dt>
<dd><p>Read-only view of the <codeclass="xref py py-data docutils literal notranslate"><spanclass="pre">MAX_COOKIE_SIZE</span></code> config key.</p>
<p>See <codeclass="xref py py-attr docutils literal notranslate"><spanclass="pre">max_cookie_size</span></code> in
Werkzeug’s docs.</p>
</dd></dl>
</dd></dl>
</section>
<sectionid="module-flask">
<spanid="module-contents"></span><h2>Module contents<aclass="headerlink"href="#module-flask"title="Link to this heading"></a></h2>
