codekingpro/portable-devtools
114k
1�
2 ��j� � �� � S SK Jr S SKJr S SKrS SKrS SKrS SK r S SK3J r S SK J
r
S SKJr S SKJr S SKJr S SKrS SKJr S S KJr S S4KJr S S KJr S S KJ r S S
K J r S SK J r S SK J r S SK J!r! S SK J"r" S SK#J$r$ S SK%J&r' S SK(J)r) SSK*J+r+ SSK*Jr, SSK-J.r. SSK-J/r/ SSK0J1r1 SSK0J2r2 SS K0J3r3 SS K0J4r4 SS K0J5r5 SS K0J6r6 SS K0J7r7 SS!K8J9r9 SS"K8J:r: SS#K8J;r; SS$K8J<r< SS%K=J>r> SS&K?J@r@ SS'KAJBrB SS(KAJCrC SS)KDJErE SS*KDJFrF SS+KDJGrG SS,KDJHrH SS-KDJIrI SS.KJJKrK SS/KLJMrM SSKLJ&r& \R� ( a S S0KOJPrP S S1KOJQrQ SS2KRJSrS SS3KRJTrT SS4KJUrU \R� " S5\,R� S69rX\R� " S7\,R� S69rZ\R� " S8\,R� S69r\\R� " S9\,R� S69r^\R� " S:\,R� S69r`S>S; jra " S< S=\>5 rbg)?� )� annotationsN)� timedelta)�iscoroutinefunction)�chain)�
TracebackType)�quote)�Headers)�
ImmutableDict)�BadRequestKeyError)�
HTTPException)�InternalServerError)�5BuildError)�6MapAdapter)�RequestRedirect)�RoutingException)�Rule)�is_running_from_reloader)�Response)�get_host� )�cli)�typing��7AppContext��RequestContext)�_cv_app)� _cv_request)� current_app)�g)�request)� request_ctx)�session)�get_debug_flag)�get_flashed_messages)�get_load_dotenv)�send_from_directory)�App)� _sentinel)� SecureCookieSessionInterface)�SessionInterface)�appcontext_tearing_down)�got_request_exception)�request_finished)�request_started)�request_tearing_down)� Environment)�Request)�
StartResponse)�WSGIEnvironment�� FlaskClient��FlaskCliRunner)� HeadersValue�T_shell_context_processor)�bound�8T_teardown�T_template_filter�T_template_global�T_template_testc �H � U b [ U [ 5 ( a U $ [ U S9$ )N)�seconds)�9isinstancer )�values �OD:\code\apps\devtools\python\user_packages\Python313\site-packages\flask/app.py�_make_timedeltarE J s# � � �}�10�5�)�4�4�� � �U� #�#� c �^ ^ � \ rS rSr% Sr\" 0 SS_SS_SS_SS_S S_S11\" S S 9_S
S_SS_SS_SS_SS_SS_SS_SS_SS_SS_SS_SSSS SSSSS SS SS . E5 r\r S \12S!' \ r S"\13S#' \
" 5 rS$\14S%' SJ SKU 4S& jjjrSLS' jrSMS( jr SN SOS) jjr SP SOS* jjrSQS+ jrSRS, jrSSS- jrSTS. jrSUS/ jr SV SWS0 jjrSXSYS1 jjrSZS2 jr S[S3 jr S\S4 jr S]S5 jr S^S6 jr S_S7 jr S`S8 jr! Sa SbS9 jjr"S`S: jr#ScS; jr$ SdS< jr%SSSSS=. SeS> jjr&SfS? jr'SgS@ jr(ShSA jr)\*4 SiSB jjr+\*4 SiSC jjr,SjSD jr-SkSE jr.SlSF jr/ SmSG jr0 SmSH jr1SIr2U =r3$ )n�Flask�Q a� The flask object implements a WSGI application and acts as the central15object. It is passed the name of the module or package of the16application. Once it is created it will act as a central registry for17the view functions, the URL rules, template configuration and much more.18 19The name of the package is used to resolve resources from inside the20package or the folder the module is contained in depending on if the21package parameter resolves to an actual python package (a folder with22an :file:`__init__.py` file inside) or a standard module (just a ``.py`` file).23 24For more information about resource loading, see :func:`open_resource`.25 26Usually you create a :class:`Flask` instance in your main module or27in the :file:`__init__.py` file of your package like this::28 29 from flask import Flask30 app = Flask(__name__)31 32.. admonition:: About the First Parameter33 34 The idea of the first parameter is to give Flask an idea of what35 belongs to your application. This name is used to find resources36 on the filesystem, can be used by extensions to improve debugging37 information and a lot more.38 39 So it's important what you provide there. If you are using a single40 module, `__name__` is always the correct value. If you however are41 using a package, it's usually recommended to hardcode the name of42 your package there.43 44 For example if your application is defined in :file:`yourapplication/app.py`45 you should create it with one of the two versions below::46 47 app = Flask('yourapplication')48 app = Flask(__name__.split('.')[0])49 50 Why is that? The application will work even with `__name__`, thanks51 to how resources are looked up. However it will make debugging more52 painful. Certain extensions can make assumptions based on the53 import name of your application. For example the Flask-SQLAlchemy54 extension will look for the code in your application that triggered55 an SQL query in debug mode. If the import name is not properly set56 up, that debugging information is lost. (For example it would only57 pick up SQL queries in `yourapplication.app` and not58 `yourapplication.views.frontend`)59 60.. versionadded:: 0.761 The `static_url_path`, `static_folder`, and `template_folder`62 parameters were added.63 64.. versionadded:: 0.865 The `instance_path` and `instance_relative_config` parameters were66 added.67 68.. versionadded:: 0.1169 The `root_path` parameter was added.70 71.. versionadded:: 1.072 The ``host_matching`` and ``static_host`` parameters were added.73 74.. versionadded:: 1.075 The ``subdomain_matching`` parameter was added. Subdomain76 matching needs to be enabled manually now. Setting77 :data:`SERVER_NAME` does not implicitly enable it.78 79:param import_name: the name of the application package80:param static_url_path: can be used to specify a different path for the81 static files on the web. Defaults to the name82 of the `static_folder` folder.83:param static_folder: The folder with static files that is served at84 ``static_url_path``. Relative to the application ``root_path``85 or an absolute path. Defaults to ``'static'``.86:param static_host: the host to use when adding the static route.87 Defaults to None. Required when using ``host_matching=True``88 with a ``static_folder`` configured.89:param host_matching: set ``url_map.host_matching`` attribute.90 Defaults to False.91:param subdomain_matching: consider the subdomain relative to92 :data:`SERVER_NAME` when matching routes. Defaults to False.93:param template_folder: the folder that contains the templates that should94 be used by the application. Defaults to95 ``'templates'`` folder in the root path of the96 application.97:param instance_path: An alternative instance path for the application.98 By default the folder ``'instance'`` next to the99 package or module is assumed to be the instance100 path.101:param instance_relative_config: if set to ``True`` relative filenames102 for loading the config are assumed to103 be relative to the instance path instead104 of the application root.105:param root_path: The path to the root of the application files.106 This should only be set manually when it can't be detected107 automatically, such as for namespace packages.108�DEBUGN�TESTINGF�PROPAGATE_EXCEPTIONS�109SECRET_KEY�SECRET_KEY_FALLBACKS�PERMANENT_SESSION_LIFETIME� )�days�USE_X_SENDFILE�
TRUSTED_HOSTS� SERVER_NAME�APPLICATION_ROOT�/�SESSION_COOKIE_NAMEr# �SESSION_COOKIE_DOMAIN�SESSION_COOKIE_PATH�SESSION_COOKIE_HTTPONLYT�SESSION_COOKIE_SECURE�SESSION_COOKIE_PARTITIONED�SESSION_COOKIE_SAMESITEi � i� �httpi� ) � SESSION_REFRESH_EACH_REQUEST�MAX_CONTENT_LENGTH�MAX_FORM_MEMORY_SIZE�MAX_FORM_PARTS�SEND_FILE_MAX_AGE_DEFAULT�TRAP_BAD_REQUEST_ERRORS�TRAP_HTTP_EXCEPTIONS�EXPLAIN_TEMPLATE_LOADING�PREFERRED_URL_SCHEME�TEMPLATES_AUTO_RELOAD�MAX_COOKIE_SIZE�PROVIDE_AUTOMATIC_OPTIONSz
type[Request]�
request_classztype[Response]�response_classr+ �session_interfacec
�` >^ � [ T U ] UUUUUUUUU U110S9111 [ R " 5 U l U R U R l U R112 ( aP [
U5 U:X d S5 e[ R " U 5 m U R U R S3SUU 4S jS9 g g )N)113� import_name�static_url_path�
static_folder� static_host�
host_matching�subdomain_matching�template_folder�
instance_path�instance_relative_config� root_pathz-Invalid static_host/host_matching combinationz/<path:filename>�staticc �2 >� T" 5 R " S0 U D6$ )N� )�send_static_file)�kw�self_refs �rD �<lambda>� Flask.__init__.<locals>.<lambda> s �� �x�z�'B�'B�'H�R�'HrF )�endpoint�host� view_func) �super�__init__r �AppGroup�name�has_static_folder�bool�weakref�ref� add_url_rulerp )
�selfro rp rq rr rs rt ru rv rw rx r~ � __class__s
@�rD r� �Flask.__init__� s� �� � ���#� +�'�#�'� 1� +�'�%=� � � 114�" �<�<�>��� � � ����
� � !� !�� �$�
�5�
�?�
�5�115 �{�{�4�(�H� � � ��'�'�(�(8�9�!� �H�
�
� "rF c � � [ R S nUc g[ U[ 5 ( a [ UR 5 5 $ U$ )a Used by :func:`send_file` to determine the ``max_age`` cache116value for a given file path if it wasn't passed.117 118By default, this returns :data:`SEND_FILE_MAX_AGE_DEFAULT` from119the configuration of :data:`~flask.current_app`. This defaults120to ``None``, which tells the browser to use conditional requests121instead of a timed cache, which is usually preferable.122 123Note this is a duplicate of the same method in the Flask124class.125 126.. versionchanged:: 2.0127 The default configuration is ``None`` instead of 12 hours.128 129.. versionadded:: 0.9130rc N)r �configrB r �int�
total_seconds)r� �filenamerC s rD �get_send_file_max_age�Flask.get_send_file_max_age sC � �" �"�"�#>�?�� �=�� �e�Y� '� '��u�*�*�,�-� -�� rF c � � U R ( d [ S5 eU R U5 n[ [ R131 " [ U R 5 XS9$ )a The view function used to serve files from132:attr:`static_folder`. A route is automatically registered for133this view at :attr:`static_url_path` if :attr:`static_folder` is134set.135 136Note this is a duplicate of the same method in the Flask137class.138 139.. versionadded:: 0.5140 141z2'static_folder' must be set to serve static_files.)�max_age)r� � RuntimeErrorr� r' �t�cast�strrq )r� r� r� s rD r| �Flask.send_static_file4 sN � � �%�%� � S�T� T� �,�,�X�6��"�
�F�F�3��*�*� +�X�142� 143rF c � � US; a [ S5 e[ R R U R U5 nUS:X a [ XB5 $ [ XBUS9$ )a� Open a resource file relative to :attr:`root_path` for reading.144 145For example, if the file ``schema.sql`` is next to the file146``app.py`` where the ``Flask`` app is defined, it can be opened147with:148 149.. code-block:: python150 151 with app.open_resource("schema.sql") as f:152 conn.executescript(f.read())153 154:param resource: Path to the resource relative to :attr:`root_path`.155:param mode: Open the file in this mode. Only reading is supported,156 valid values are ``"r"`` (or ``"rt"``) and ``"rb"``.157:param encoding: Open the file with this encoding when opening in text158 mode. This is ignored when opening in binary mode.159 160.. versionchanged:: 3.1161 Added the ``encoding`` parameter.162> �r�rb�rtz)Resources can only be opened for reading.r� ��encoding)�163ValueError�os�path�joinrx �open�r� �resource�moder� r� s rD �
open_resource�Flask.open_resourceJ sP � �. �(� (� � H�I� I��w�w�|�|�D�N�N�H�5�� �4�<���#� #��D��2�2rF c � � [ R R U R U5 nSU; a [ XB5 $ [ XBUS9$ )a� Open a resource file relative to the application's instance folder164:attr:`instance_path`. Unlike :meth:`open_resource`, files in the165instance folder can be opened for writing.166 167:param resource: Path to the resource relative to :attr:`instance_path`.168:param mode: Open the file in this mode.169:param encoding: Open the file with this encoding when opening in text170 mode. This is ignored when opening in binary mode.171 172.. versionchanged:: 3.1173 Added the ``encoding`` parameter.174�br� )r� r� r� rv r� r� s rD �open_instance_resource� Flask.open_instance_resourcek s= � � �w�w�|�|�D� .� .��9�� �$�;���#� #��D��2�2rF c � � [ U R 5 nSU; a U R US' SU; a" U R S nUc U R nX!S' U R175 " U 40 UD6nUR R U R [ U R [ [ [ S9 U R R UR S' U$ )a� Create the Jinja environment based on :attr:`jinja_options`176and the various Jinja-related methods of the app. Changing177:attr:`jinja_options` after this will have no effect. Also adds178Flask-related globals and filters to the environment.179 180.. versionchanged:: 0.11181 ``Environment.auto_reload`` set in accordance with182 ``TEMPLATES_AUTO_RELOAD`` configuration option.183 184.. versionadded:: 0.5185�186autoescape� auto_reloadrh )�url_forr% r� r! r# r zjson.dumps_function)�dict�
jinja_options�select_jinja_autoescaper� �debug�jinja_environment�globals�updater� r% r! r# r �json�dumps�policies)r� �optionsr� �rvs rD �create_jinja_environment� Flask.create_jinja_environment� s� � � �t�)�)�*�� �w� &�$(�$@�$@�G�L� !� �� '� �+�+�&=�>�K��"� "�j�j� �%0�M� "�
�
#�
#�D�
4�G�
4��187�188�189����L�L�!5��;�;� ��� � 190 191� .2�Y�Y�_�_�� � �)�*�� rF c �. � Ub� U R S =nb X!l [ UR UR 5 Ul SnU R S nU R192 R ( a SnO0U R ( d U R193 R =( d SnU R194 R UR XCS9$ U R S bB U R195 R U R S U R S U R S S9$ g) aw Creates a URL adapter for the given request. The URL adapter196is created at a point where the request context is not yet set197up so the request is passed explicitly.198 199.. versionchanged:: 3.1200 If :data:`SERVER_NAME` is set, it does not restrict requests to201 only that domain, for both ``subdomain_matching`` and202 ``host_matching``.203 204.. versionchanged:: 1.0205 :data:`SERVER_NAME` no longer implicitly enables subdomain206 matching. Use :attr:`subdomain_matching` instead.207 208.. versionchanged:: 0.9209 This can be called outside a request when the URL adapter is created210 for an application context.211 212.. versionadded:: 0.6213NrS rT � )� server_name� subdomainrU rg )� script_name�214url_scheme) r� �
trusted_hostsr �environr� �url_maprs rt �default_subdomain�bind_to_environ�bind)r� r! r� r� r� s rD �create_url_adapter�Flask.create_url_adapter� s � �( � �!%���_�!=�=�
�J�(5�%� $�G�O�O�W�5J�5J�K�G�L� �I� �+�+�m�4�K��|�|�)�)� #� ��,�,� !�L�L� :� :� @�b� ��<�<�/�/����[� 0� �
�215 �;�;�}� %� 1��<�<�$�$�� � �M�*� �K�K�(:� ;� �;�;�'=�>� %� �
� rF c �� � U R ( aI [ UR [ 5 ( a* UR R S; d UR216 S; a UR eSSKJn U" U5 e)a� Intercept routing exceptions and possibly do something else.217 218In debug mode, intercept a routing redirect and replace it with219an error if the body will be discarded.220 221With modern Werkzeug this shouldn't occur, since it now uses a222308 status which tells the browser to resend the method and223body.224 225.. versionchanged:: 2.1226 Don't intercept 307 and 308 redirects.227 228:meta private:229:internal:230> �3 �4 > �GET�HEAD�OPTIONSr )�FormDataRoutingRedirect)r� rB �routing_exceptionr �code�method� debughelpersr� )r� r! r� s rD �raise_routing_exception� Flask.raise_routing_exception� sY � �" �231�232� �g� 7� 7� �I�I��(�(�-�-��;��~�~�!;�;��+�+� +�9�%�g�.�.rF c �P � Sn[ ( a# [ U[ [ R 5 5 nUR 5 nU HO nX@R233 ; d M U R234 U H( nUR
U R U5 " 5 5 M* MQ UR
U5 g)a� Update the template context with some commonly used variables.235This injects request, session, config and g into the template236context as well as everything template context processors want237to inject. Note that the as of Flask 0.6, the original values238in the context will not be overridden if a context processor239decides to return a value with the same key.240 241:param context: the context as a dictionary that is updated in place242 to add extra variables.243�NN)r! r �reversed�244blueprints�copy�template_context_processorsr� � ensure_sync)r� �context�names�orig_ctxr� �funcs rD �update_template_context� Flask.update_template_context� s� � � )0�� �7��%��'�*<�*<�!=�>�E� �<�<�>���D��7�7�7� � <� <�T� B�D��N�N�4�#3�#3�D�#9�#;�<� C� �245 ���x� rF c �j � U [ S.nU R H nUR U" 5 5 M U$ )z�Returns the shell context for an interactive shell for this246application. This runs all the registered shell context247processors.248 249.. versionadded:: 0.11250)�appr )r �shell_context_processorsr� )r� r� � processors rD �make_shell_context�Flask.make_shell_context s1 � � ��
"�� �6�6�I� �I�I�i�k� "� 7�� rF c � � [ R R S5 S:X a% [ 5 ( d [ R251 " SSS9 g[
U5 ( a8 [ R " 5 S[ R ; a [ 5 U l252 Ub [ U5 U l253 U R R S5 nS=pxU( a UR S 5 u pynU( d U( a UnOS254nU( d US :X a [ U5 nOU( a [ U5 nOS nUR S
U R 5 UR SU R 5 UR SS5 [ R " U R U R" 5 S SKJn255 U256" [( R* " [, U5 X 40 UD6 SU l g! SU l f = f)a Runs the application on a local development server.257 258Do not use ``run()`` in a production setting. It is not intended to259meet security and performance requirements for a production server.260Instead, see :doc:`/deploying/index` for WSGI server recommendations.261 262If the :attr:`debug` flag is set the server will automatically reload263for code changes and show a debugger in case an exception happened.264 265If you want to run the application in debug mode, but disable the266code execution on the interactive debugger, you can pass267``use_evalex=False`` as parameter. This will keep the debugger's268traceback screen active, but disable code execution.269 270It is not recommended to use this function for development with271automatic reloading as this is badly supported. Instead you should272be using the :command:`flask` command line script's ``run`` support.273 274.. admonition:: Keep in Mind275 276 Flask will suppress any server error with a generic error page277 unless it is in debug mode. As such to enable just the278 interactive debugger without the code reloading, you have to279 invoke :meth:`run` with ``debug=True`` and ``use_reloader=False``.280 Setting ``use_debugger`` to ``True`` without being in debug mode281 won't catch any exceptions because there won't be any to282 catch.283 284:param host: the hostname to listen on. Set this to ``'0.0.0.0'`` to285 have the server available externally as well. Defaults to286 ``'127.0.0.1'`` or the host in the ``SERVER_NAME`` config variable287 if present.288:param port: the port of the webserver. Defaults to ``5000`` or the289 port defined in the ``SERVER_NAME`` config variable if present.290:param debug: if given, enable or disable debug mode. See291 :attr:`debug`.292:param load_dotenv: Load the nearest :file:`.env` and :file:`.flaskenv`293 files to set environment variables. Will also change the working294 directory to the directory containing the first file found.295:param options: the options to be forwarded to the underlying Werkzeug296 server. See :func:`werkzeug.serving.run_simple` for more297 information.298 299.. versionchanged:: 1.0300 If installed, python-dotenv will be used to load environment301 variables from :file:`.env` and :file:`.flaskenv` files.302 303 The :envvar:`FLASK_DEBUG` environment variable will override :attr:`debug`.304 305 Threaded mode is enabled by default.306 307.. versionchanged:: 0.10308 The default port is now picked from the ``SERVER_NAME``309 variable.310�FLASK_RUN_FROM_CLI�truez� * Ignoring a call to 'app.run()' that would block the current 'flask' CLI command.311 Only call 'app.run()' in an 'if __name__ == "__main__"' guard.�red)�fgN� FLASK_DEBUGrT �:z 127.0.0.1r i� � use_reloader� use_debugger�threadedT)�312run_simpleF)r� r� �getr �click�sechor& r � load_dotenvr$ r� r� r� � partitionr� �313setdefault�show_server_bannerr� �werkzeug.servingr� r� r� r� �_got_first_request) r� r� �portr� r r� r� �sn_host�sn_port�_r� s rD �run� Flask.run" si � �B �:�:�>�>�.� /�6� 9�+�-�-�� � �+� � �
� �;� '� '� �O�O� � ��314�315�*� +� -��316� � � �e��D�J��k�k�o�o�m�4� � � �� �"-�"7�"7��"<� �G���� ��"�� �4�1�9��t�9�D�
��w�<�D��D����>�4�:�:�6����>�4�:�:�6����:�t�,� � � �t�z�z�4�9�9�5�/� ,� �q�v�v�c�4�(�$� @�� @�317 ',�D� #��e�D� #�s �#G � Gc �V � U R nUc SSKJn U" X R 4SU0UD6$ )al Creates a test client for this application. For information318about unit testing head over to :doc:`/testing`.319 320Note that if you are testing for assertions or exceptions in your321application code, you must set ``app.testing = True`` in order for the322exceptions to propagate to the test client. Otherwise, the exception323will be handled by the application (not visible to the test client) and324the only indication of an AssertionError or other exception will be a325500 status code response to the test client. See the :attr:`testing`326attribute. For example::327 328 app.testing = True329 client = app.test_client()330 331The test client can be used in a ``with`` block to defer the closing down332of the context until the end of the ``with`` block. This is useful if333you want to access the context locals for testing::334 335 with app.test_client() as c:336 rv = c.get('/?vodka=42')337 assert request.args['vodka'] == '42'338 339Additionally, you may pass optional keyword arguments that will then340be passed to the application's :attr:`test_client_class` constructor.341For example::342 343 from flask.testing import FlaskClient344 345 class CustomClient(FlaskClient):346 def __init__(self, *args, **kwargs):347 self._authentication = kwargs.pop("authentication")348 super(CustomClient,self).__init__( *args, **kwargs)349 350 app.test_client_class = CustomClient351 client = app.test_client(authentication='Basic ....')352 353See :class:`~flask.testing.FlaskClient` for more information.354 355.. versionchanged:: 0.4356 added support for ``with`` block usage for the client.357 358.. versionadded:: 0.7359 The `use_cookies` parameter was added as well as the ability360 to override the client to be used by setting the361 :attr:`test_client_class` attribute.362 363.. versionchanged:: 0.11364 Added `**kwargs` to support passing additional keyword arguments to365 the constructor of :attr:`test_client_class`.366r r5 � use_cookies)�test_client_class�testingr6 rl )r� r
�kwargs�clss rD � test_client�Flask.test_client� s> � �f �$�$�� �;� 3�� �%�%�367�3>�368�BH�369� 370rF c �> � U R nUc SSKJn U" U 40 UD6$ )z�Create a CLI runner for testing CLI commands.371See :ref:`testing-cli`.372 373Returns an instance of :attr:`test_cli_runner_class`, by default374:class:`~flask.testing.FlaskCliRunner`. The Flask app object is375passed as the first argument.376 377.. versionadded:: 1.0378r r7 )�test_cli_runner_classr r8 )r� r r s rD �test_cli_runner�Flask.test_cli_runner� s' � � �(�(�� �;� 6��4�"�6�"�"rF c �� � UR c U$ [ U[ 5 ( a U$ U R U[ R379 5 nUc U$ U R
U5 " U5 $ )a Handles an HTTP exception. By default this will invoke the380registered error handlers and fall back to returning the381exception as response.382 383.. versionchanged:: 1.0.3384 ``RoutingException``, used internally for actions such as385 slash redirects during routing, is not passed to error386 handlers.387 388.. versionchanged:: 1.0389 Exceptions are looked up by code *and* by MRO, so390 ``HTTPException`` subclasses can be handled with a catch-all391 handler for the base ``HTTPException``.392 393.. versionadded:: 0.3394)r� rB r �_find_error_handlerr! r� r� �r� �e�handlers rD �handle_http_exception�Flask.handle_http_exception� s_ � �*
�6�6�>��H�395 �a�)� *� *��H��*�*�1�g�.@�.@�A�� �?��H�� � ��(��+�+rF c �r � [ U[ 5 ( a, U R ( d U R S ( a SUl [ U[396 5 ( a' U R
U5 ( d U R U5 $ U R U[ R 5 nUc e U R U5 " U5 $ )a� This method is called whenever an exception occurs that397should be handled. A special case is :class:`~werkzeug398.exceptions.HTTPException` which is forwarded to the399:meth:`handle_http_exception` method. This function will either400return a response value or reraise the exception with the same401traceback.402 403.. versionchanged:: 1.0404 Key errors raised from request data like ``form`` show the405 bad key in debug mode rather than a generic bad request406 message.407 408.. versionadded:: 0.7409rd T) rB r r� r� �show_exceptionr �trap_http_exceptionr r r! r� r� r s rD �handle_user_exception�Flask.handle_user_exception s� � �" �a�+� ,� ,� �J�J�$�+�+�&?�@� #�A� � �a� � '� '��0H�0H��0K�0K��-�-�a�0� 0��*�*�1�g�.@�.@�A�� �?� �� � ��(��+�+rF c � � [ R " 5 n[ R " X R US9 U R410 S nUc U R =( d U R nU( a US UL a e UeU R U5 [ US9nU R U[ R 5 nUb U R U5 " U5 nU R USS9$ )a Handle an exception that did not have an error handler411associated with it, or that was raised from an error handler.412This always causes a 500 ``InternalServerError``.413 414Always sends the :data:`got_request_exception` signal.415 416If :data:`PROPAGATE_EXCEPTIONS` is ``True``, such as in debug417mode, the error will be re-raised so that the debugger can418display it. Otherwise, the original exception is logged, and419an :exc:`~werkzeug.exceptions.InternalServerError` is returned.420 421If an error handler is registered for ``InternalServerError`` or422``500``, it will be used. For consistency, the handler will423always receive the ``InternalServerError``. The original424unhandled exception is available as ``e.original_exception``.425 426.. versionchanged:: 1.1.0427 Always passes the ``InternalServerError`` instance to the428 handler, setting ``original_exception`` to the unhandled429 error.430 431.. versionchanged:: 1.1.0432 ``after_request`` functions and other finalization is done433 even for the default 500 response when there is no handler.434 435.. versionadded:: 0.3436)�_async_wrapper� exceptionrL r )�original_exceptionT)�from_error_handler)�sys�exc_infor- �sendr� r� r r� �
log_exceptionr
r r! r� �finalize_request)r� r r* � propagate� server_errorr s rD �handle_exception�Flask.handle_exception+ s� � �8 �<�<�>�� �"�"�4�8H�8H�TU�V��K�K� 6�7� � � � � � �2��437�438�I� � ��{�a� ���G� ���8�$�*�a�@� ��*�*�<��9K�9K�L�� � � �+�+�G�4�\�B�L��$�$�\�d�$�K�KrF c �~ � U R R S[ R S[ R S3US9 g)z�Logs an exception. This is called by :meth:`handle_exception`439if debugging is disabled and right before the handler is called.440The default implementation logs the exception as error on the441:attr:`logger`.442 443.. versionadded:: 0.8444z
Exception on z [�])r* N)�logger�errorr! r� r� )r� r* s rD r, �Flask.log_exception` s8 � �
� � ����G�L�L�>��G�N�N�+;�1� =�� � 445rF c �N � [ R nUR b U R U5 UR n[ USS5 ( a UR S:X a U R 5 $ UR nU R U R UR 5 " S0 UD6$ )a Does the request dispatching. Matches the URL and returns the446return value of the view or error handler. This does not have to447be a response object. In order to convert the return value to a448proper response object, call :func:`make_response`.449 450.. versionchanged:: 0.7451 This no longer does the exception handling, this code was452 moved to the new :meth:`full_dispatch_request`.453�provide_automatic_optionsFr� r{ ) r" r! r� r� �url_rule�getattrr� � make_default_options_response� view_argsr� �view_functionsr� )r� �req�ruler< s rD �dispatch_request�Flask.dispatch_requesto s� � � �!�!�� � � � ,� � (� (�� -��\�\��
�D�5�u� =� =��454�455�i�'��5�5�7� 7�&)�m�m� �� � �� 3� 3�D�M�M� B�C�P�i�P�PrF c � � SU l [ R " X R S9 U R 5 nUc U R 5 nU R U5 $ ! [ a nU R U5 n SnAN1SnAff = f)z�Dispatches the request and on top of that performs request456pre and postprocessing as well as HTTP exception catching and457error handling.458 459.. versionadded:: 0.7460T)r% N) r r/ r+ r� �preprocess_requestr@ � Exceptionr" r- )r� r� r s rD �full_dispatch_request�Flask.full_dispatch_request� s{ � � #'�� � /� � � ��6F�6F� G��(�(�*�B��z��*�*�,�� �$�$�R�(�(�� � /��+�+�A�.�B�� /�s �AA �461B �%A;�;B c �� � U R U5 n U R U5 n[ R " X R US9 U$ ! [462 a' U( d e U R R S5 U$ f = f)a� Given the return value from a view function this finalizes463the request by converting it into a response and invoking the464postprocessing functions. This is invoked for both normal465request dispatching as well as error handlers.466 467Because this means that it might be called as a result of a468failure a special safe mode is available which can be enabled469with the `from_error_handler` flag. If enabled, failures in470response processing will be logged and otherwise ignored.471 472:internal:473)r% �responsez?Request finalizing failed with an error while handling an error)�
make_response�process_responser. r+ r� rD r4 r& )r� r� r( rH s rD r- �Flask.finalize_request� s| � �" �%�%�b�)��474 ��,�,�X�6�H� � !� !��%5�%5��
� ���
� �%�� �K�K� !� !�Q�
� ��
�s �0A �-A6�5A6c � � [ R nUR 5 nU R 5 nUR R U5 U$ )z�This method is called to create the default ``OPTIONS`` response.475This can be changed through subclassing to change the default476behavior of ``OPTIONS`` responses.477 478.. versionadded:: 0.7479)r" � url_adapter�allowed_methodsrl �allowr� )r� �adapter�methodsr� s rD r; �#Flask.make_default_options_response� s@ � � �)�)���)�)�+��
�
�
�
"��480������ �� rF c �H � [ U5 ( a U R U5 $ U$ )a Ensure that the function is synchronous for WSGI workers.481Plain ``def`` functions are returned as-is. ``async def``482functions are wrapped to run and wait for the response.483 484Override this method to change how the app runs async views.485 486.. versionadded:: 2.0487)r �
async_to_sync)r� r� s rD r� �Flask.ensure_sync� s% � � �t� $� $��%�%�d�+� +�� rF c �T � SSK Jn U" U5 $ ! [ a
[ S5 Sef = f)a Return a sync function that will run the coroutine function.488 489.. code-block:: python490 491 result = app.async_to_sync(func)(*args, **kwargs)492 493Override this method to change how the app converts async code494to be synchronously callable.495 496.. versionadded:: 2.0497r )rT zAInstall Flask with the 'async' extra in order to use async views.N)� asgiref.syncrT � ImportErrorr� )r� r� �asgiref_async_to_syncs rD rT �Flask.async_to_sync� s; � � � K� %�T�*�*�� � � �S���
� �s � �'��_anchor�_method�_scheme� _externalc �^ � [ R " S5 nUbB UR nUR R n USS S:X a U b U U 3nOUSS nUc USLnOJ[498 R " S5 n499U500b
U501R nOU R
S5 nUc [ S5 eUc SnUb U( d [ S5 eU R X5 UR UUUUUS9n Ub [ US S5029nU S U 3n U $ ! [ a, n UR X#XES9 U R X�U5 s Sn A $ Sn A ff = f) a� Generate a URL to the given endpoint with the given values.503 504This is called by :func:`flask.url_for`, and can be called505directly as well.506 507An *endpoint* is the name of a URL rule, usually added with508:meth:`@app.route() <route>`, and usually the same name as the509view function. A route defined in a :class:`~flask.Blueprint`510will prepend the blueprint's name separated by a ``.`` to the511endpoint.512 513In some cases, such as email messages, you want URLs to include514the scheme and domain, like ``https://example.com/hello``. When515not in an active request, URLs will be external by default, but516this requires setting :data:`SERVER_NAME` so Flask knows what517domain to use. :data:`APPLICATION_ROOT` and518:data:`PREFERRED_URL_SCHEME` should also be configured as519needed. This config is only used when not in an active request.520 521Functions can be decorated with :meth:`url_defaults` to modify522keyword arguments before the URL is built.523 524If building fails for some reason, such as an unknown endpoint525or incorrect values, the app's :meth:`handle_url_build_error`526method is called. If that returns a string, that is returned,527otherwise a :exc:`~werkzeug.routing.BuildError` is raised.528 529:param endpoint: The endpoint name associated with the URL to530 generate. If this starts with a ``.``, the current blueprint531 name (if any) will be used.532:param _anchor: If given, append this as ``#anchor`` to the URL.533:param _method: If given, generate the URL associated with this534 method for the endpoint.535:param _scheme: If given, the URL will have this scheme if it536 is external.537:param _external: If given, prefer the URL to be internal538 (False) or require it to be external (True). External URLs539 include the scheme and domain. When not in an active540 request, URLs are external by default.541:param values: Values to use for the variable parts of the URL542 rule. Unknown keys are appended as query string arguments,543 like ``?a=b&c=d``.544 545.. versionadded:: 2.2546 Moved from ``flask.url_for``, which calls this method.547Nr �.z�Unable to build URLs outside an active request without 'SERVER_NAME' configured. Also configure 'APPLICATION_ROOT' and 'PREFERRED_URL_SCHEME' as needed.Tz4When specifying '_scheme', '_external' must be True.)r� r� �force_externalr[ z%!#$&'()*+,/:;=?@)�safe�#)r r� rM r! � blueprintr r� r� r� �inject_url_defaults�buildr r� �handle_url_build_error�548_url_quote)
r� r� r\ r] r^ r_ �values�req_ctxrM �blueprint_name�app_ctxr� r5 s
rD r� �
Flask.url_for� s� � �r �/�/�$�'�� � �!�-�-�K� $�_�_� 6� 6�N� ���|�s�"�!�-�"0�!1�(�� <�H� '���|�H� � � #�4� /� �� �k�k�$�'�G�549 �"� %� 1� 1� � "� 5� 5�d� ;� ��"�"� �� � � � � � � �y� � S�T� T� � � ��2� H� �"�"��� �"� (� #� �B� � � ��/B�C�G��4�q�� �"�B�� �� � H� �M�M� �'�
�
� �.�.�u��G� G�� H�s �
C6 �6550D,� !D'�!D,�'D,c �� � SnSn[ U[ 5 ( aZ [ U5 nUS:X a Uu pnOCUS:X a2 [ US [ [ [ [551 45 ( a Uu pOUu pO [
S5 eUc [
S[ R < S35 e[ XR 5 ( d� [ U[ [ [ 45 ( d [ U[ R 5 ( a U R UUUS9nS=p#O�[ U[ [552 45 ( a U R R! U5 nOs[ U[" 5 ( d [% U5 ( a, U R R' U[ R( 5 nO"[
S [+ U5 R, S55335 e[4 R6 " [8 U5 nUb- [ U[ [ [ 45 ( a X!l OX!l U( a UR> RA U5 U$ ! [ aO n[
U S [+ U5 R, S55435 R/ [0 R2 " 5 S 5 SeSnAff = f) a9 Convert the return value from a view function to an instance of555:attr:`response_class`.556 557:param rv: the return value from the view function. The view function558 must return a response. Returning ``None``, or the view ending559 without returning, is not allowed. The following types are allowed560 for ``view_rv``:561 562 ``str``563 A response object is created with the string encoded to UTF-8564 as the body.565 566 ``bytes``567 A response object is created with the bytes as the body.568 569 ``dict``570 A dictionary that will be jsonify'd before being returned.571 572 ``list``573 A list that will be jsonify'd before being returned.574 575 ``generator`` or ``iterator``576 A generator that returns ``str`` or ``bytes`` to be577 streamed as the response.578 579 ``tuple``580 Either ``(body, status, headers)``, ``(body, status)``, or581 ``(body, headers)``, where ``body`` is any of the other types582 allowed here, ``status`` is a string or an integer, and583 ``headers`` is a dictionary or a list of ``(key, value)``584 tuples. If ``body`` is a :attr:`response_class` instance,585 ``status`` overwrites the exiting value and ``headers`` are586 extended.587 588 :attr:`response_class`589 The object is returned unchanged.590 591 other :class:`~werkzeug.wrappers.Response` class592 The object is coerced to :attr:`response_class`.593 594 :func:`callable`595 The function is called as a WSGI application. The result is596 used to create a response object.597 598.. versionchanged:: 2.2599 A generator will be converted to a streaming response.600 A list will be converted to a JSON response.601 602.. versionchanged:: 1.1603 A dict will be converted to a JSON response.604 605.. versionchanged:: 0.9606 Previously a tuple was interpreted as the arguments for the607 response object.608N� � r z�The view function did not return a valid response tuple. The tuple must have the form (body, status, headers), (body, status), or (body, headers).zThe view function for zh did not return a valid response. The function either returned None or ended without a return statement.)�status�headersz�609The view function did not return a valid response. The return type must be a string, dict, list, tuple with headers or status, Response instance, or WSGI callable, but it was a ra z�The view function did not return a valid response. The return type must be a string, dict, list, tuple with headers or status, Response instance, or WSGI callable, but it was a )!rB �tuple�lenr r� �list� TypeErrorr! r� rl r� �bytes� bytearray�cabc�Iteratorr� rH � BaseResponse�callable�610force_typer� �type�__name__�with_tracebackr) r* r� r� r rr � status_coders r� )r� r� rr rs �len_rvr s rD rI �Flask.make_responsei sM � �r "��'+�� �b�%� � ���W�F� ��{�&(�#��G��1�� �b��e�g�t�U�D�%A�B�B�"$�K�B��!#�J�B�� �;�� � �:��(��)9�)9�(<� ==� =��
� �"� 1� 1�2�2��"�s�E�9� 5�6�6�*�R�� � �:W�:W� �(�(��!� #� )� ��611 $(�'����B��t� �-�-��Y�Y�'�'��+���B� �-�-��"� � � B� �,�,�7�7�� ����B� �� �R��)�)�*�!� -�� � �V�V�H�b�
!�� � ��&�3��y�"9�:�:� "� �!'�� � �J�J� � �g� &�� ��; !� B�#� �#� "� #'�r�(�"3�"3�!4�A� 7�� %�n�S�\�\�^�A�%6�7�T�
B��B�s � *H � 612I5�&A613I0�0I5c � � S/[ [ R 5 Q7nU HO nX R ; d M U R U H( nU" [ R [ R614 5 M* MQ U HI nX R ; d M U R U H" nU R U5 " 5 nUc M Us s $ MK g)a� Called before the request is dispatched. Calls615:attr:`url_value_preprocessors` registered with the app and the616current blueprint (if any). Then calls :attr:`before_request_funcs`617registered with the app and the blueprint.618 619If any :meth:`before_request` handler returns a non-None value, the620value is handled as if it was the return value from the view, and621further request handling is stopped.622N)r� r! r� �url_value_preprocessorsr� r< �before_request_funcsr� )r� r� r� �url_func� before_funcr� s rD rC �Flask.preprocess_request� s� � � �5���!3�!3�4�5���D��3�3�3� $� <� <�T� B�H� �W� -� -�w�/@�/@�A� !C� �623 �D��0�0�0�#'�#<�#<�T�#B�K� �)�)�+�6�8�B��~� !� � $C� � rF c �� � [ R " 5 nUR H nU R U5 " U5 nM [ [624 R S5 HJ nX@R ; d M [ U R U 5 H nU R U5 " U5 nM ML U R R UR 5 ( d& U R R XR U5 U$ )a� Can be overridden in order to modify the response object625before it's sent to the WSGI server. By default this will626call all the :meth:`after_request` decorated functions.627 628.. versionchanged:: 0.5629 As of Flask 0.5 the functions registered for after request630 execution are called in reverse order of registration.631 632:param response: a :attr:`response_class` object.633:return: a new response object or the same, has to be an634 instance of :attr:`response_class`.635r� )
r" �_get_current_object�_after_request_functionsr� r r! r� �after_request_funcsr� rm �is_null_session�_session� save_session)r� rH �ctxr� r� s rD rJ �Flask.process_response s� � � �-�-�/���0�0�D��'�'��-�h�7�H� 1� �'�,�,�g�6�D��/�/�/� $�T�%=�%=�d�%C� D�D� #� /� /�� 5�h� ?�H� E� 7�636 �%�%�5�5�c�l�l�C�C� � "� "� /� /��l�l�H� M��rF c �T � U[ L a [ R " 5 S n[ [ R637 S5 HJ nX R ; d M [ U R U 5 H nU R U5 " U5 M ML [ R " X R US9 g)a� Called after the request is dispatched and the response is638returned, right before the request context is popped.639 640This calls all functions decorated with641:meth:`teardown_request`, and :meth:`Blueprint.teardown_request`642if a blueprint handled the request. Finally, the643:data:`request_tearing_down` signal is sent.644 645This is called by646:meth:`RequestContext.pop() <flask.ctx.RequestContext.pop>`,647which may be delayed during testing to maintain access to648resources.649 650:param exc: An unhandled exception raised while dispatching the651 request. Detected from the current exception information if652 not passed. Passed to each teardown function.653 654.. versionchanged:: 0.9655 Added the ``exc`` argument.656r r� �r% �excN) r) r) r* r r! r� �teardown_request_funcsr� r� r0 r+ )r� r� r� r� s rD �do_teardown_request�Flask.do_teardown_request. s� � �0 �)� ��,�,�.��#�C��'�,�,�g�6�D��2�2�2� $�T�%@�%@��%F� G�D��$�$�T�*�3�/� H� 7�657 �!�!�$�7G�7G�S�QrF c �� � U[ L a [ R " 5 S n[ U R 5 H nU R U5 " U5 M [ R " X R658 US9 g)a� Called right before the application context is popped.659 660When handling a request, the application context is popped661after the request context. See :meth:`do_teardown_request`.662 663This calls all functions decorated with664:meth:`teardown_appcontext`. Then the665:data:`appcontext_tearing_down` signal is sent.666 667This is called by668:meth:`AppContext.pop() <flask.ctx.AppContext.pop>`.669 670.. versionadded:: 0.9671r r� N)r) r) r* r� �teardown_appcontext_funcsr� r, r+ )r� r� r� s rD �do_teardown_appcontext� Flask.do_teardown_appcontextP s] � �$ �)� ��,�,�.��#�C� �T� ;� ;�<�D� � � �T� "�3� '� =� �$�$�T�:J�:J�PS�TrF c � � [ U 5 $ )a� Create an :class:`~flask.ctx.AppContext`. Use as a ``with``672block to push the context, which will make :data:`current_app`673point at this application.674 675An application context is automatically pushed by676:meth:`RequestContext.push() <flask.ctx.RequestContext.push>`677when handling a request, and when running a CLI command. Use678this to manually create a context outside of these situations.679 680::681 682 with app.app_context():683 init_db()684 685See :doc:`/appcontext`.686 687.. versionadded:: 0.9688r )r� s rD � app_context�Flask.app_contextj s � �& �$� � rF c � � [ X5 $ )a� Create a :class:`~flask.ctx.RequestContext` representing a689WSGI environment. Use a ``with`` block to push the context,690which will make :data:`request` point at this request.691 692See :doc:`/reqcontext`.693 694Typically you should not call this from your own code. A request695context is automatically pushed by the :meth:`wsgi_app` when696handling a request. Use :meth:`test_request_context` to create697an environment and context instead of this method.698 699:param environ: a WSGI environment700r )r� r� s rD �request_context�Flask.request_context s � � �d�,�,rF c � � SSK Jn U" U /UQ70 UD6n U R UR 5 5 UR 5 $ ! UR 5 f = f)a� Create a :class:`~flask.ctx.RequestContext` for a WSGI701environment created from the given values. This is mostly useful702during testing, where you may want to run a function that uses703request data without dispatching a full request.704 705See :doc:`/reqcontext`.706 707Use a ``with`` block to push the context, which will make708:data:`request` point at the request for the created709environment. ::710 711 with app.test_request_context(...):712 generate_report()713 714When using the shell, it may be easier to push and pop the715context manually to avoid indentation. ::716 717 ctx = app.test_request_context(...)718 ctx.push()719 ...720 ctx.pop()721 722Takes the same arguments as Werkzeug's723:class:`~werkzeug.test.EnvironBuilder`, with some defaults from724the application. See the linked Werkzeug docs for most of the725available arguments. Flask-specific behavior is listed here.726 727:param path: URL path being requested.728:param base_url: Base URL where the app is being served, which729 ``path`` is relative to. If not given, built from730 :data:`PREFERRED_URL_SCHEME`, ``subdomain``,731 :data:`SERVER_NAME`, and :data:`APPLICATION_ROOT`.732:param subdomain: Subdomain name to append to733 :data:`SERVER_NAME`.734:param url_scheme: Scheme to use instead of735 :data:`PREFERRED_URL_SCHEME`.736:param data: The request body, either as a string or a dict of737 form keys and values.738:param json: If given, this is serialized as JSON and passed as739 ``data``. Also defaults ``content_type`` to740 ``application/json``.741:param args: other positional arguments passed to742 :class:`~werkzeug.test.EnvironBuilder`.743:param kwargs: other keyword arguments passed to744 :class:`~werkzeug.test.EnvironBuilder`.745r )�EnvironBuilder)r r� r� � get_environ�close)r� �argsr r� �builders rD �test_request_context�Flask.test_request_context� sK � �^ ,� ��7��7��7�� ��'�'��(;�(;�(=�>� �M�M�O��G�M�M�O�s � A �Ac �� � U R U5 nSn UR 5 U R 5 nU" X5 SU; a< US " [ R " 5 5 US " [ R " 5 5 Ub U R U5 ( a SnUR U5 $ ! [ a nUnU R U5 n SnAN�SnAf [746 R " 5 S ne = f! SU; a< US " [ R " 5 5 US " [ R " 5 5 Ub U R U5 ( a SnUR U5 f = f)a: The actual WSGI application. This is not implemented in747:meth:`__call__` so that middlewares can be applied without748losing a reference to the app object. Instead of doing this::749 750 app = MyMiddleware(app)751 752It's a better idea to do this instead::753 754 app.wsgi_app = MyMiddleware(app.wsgi_app)755 756Then you still have the original application object around and757can continue to call methods on it.758 759.. versionchanged:: 0.7760 Teardown events for the request and app contexts are called761 even if an unhandled error occurs. Other events may not be762 called depending on when an error occurs during dispatch.763 See :ref:`callbacks-and-errors`.764 765:param environ: A WSGI environment.766:param start_response: A callable accepting a status code,767 a list of headers, and an optional exception context to768 start the response.769Nr z werkzeug.debug.preserve_context) r� �pushrE rD r0 r) r* r r� r �should_ignore_error�pop)r� r� �start_responser� r5 rH r s rD �wsgi_app�Flask.wsgi_app� s/ � �6 �"�"�7�+��&*�� �
����770� �5�5�7�� �G�4�0�G�;��9�:�7�;�;�=�I��9�:�;�?�?�;L�M�� �T�%=�%=�e�%D�%D� �� �G�G�E�N�� �
4��� �0�0��3���
�� � ��q�)���� 1�G�;��9�:�7�;�;�=�I��9�:�;�?�?�;L�M�� �T�%=�%=�e�%D�%D� �� �G�G�E�N�s/ � B, �C/ �,771C,�6C� C/ � C,�,C/ �/A0E c �$ � U R X5 $ )z�The WSGI server calls the Flask application object as the772WSGI application. This calls :meth:`wsgi_app`, which can be773wrapped to apply middleware.774)r� )r� r� r� s rD �__call__�Flask.__call__� s � � �}�}�W�5�5rF )r r r� ) Nry NFF� templatesNFN)ro r� rp �775str | Nonerq � str | os.PathLike[str] | Nonerr r� rs r� rt r� ru r� rv r� rw r� rx r� )r� r� �return�776int | None)r� r� r� r )r� N)r� r� r� r� r� r� r� zt.IO[t.AnyStr])r� zutf-8)r� r1 )r! zRequest | Noner� zMapAdapter | None)r! r2 r� z777t.NoReturn)r� �dict[str, t.Any]r� �None)r� r� )NNNT) r� r� r r� r� � bool | Noner r� r� �t.Anyr� r� )T)r
r� r r� r� r6 )r r� r� r8 )r r r� �&HTTPException | ft.ResponseReturnValue)r rD r� r� )r rD r� r )r* zCtuple[type, BaseException, TracebackType] | tuple[None, None, None]r� r� )r� �ft.ResponseReturnValue)r� r )F)r� z&ft.ResponseReturnValue | HTTPExceptionr( r� r� r )r� �t.Callable[..., t.Any]r� r� )r� z1t.Callable[..., t.Coroutine[t.Any, t.Any, t.Any]]r� r� )r� r� r\ r� r] r� r^ r� r_ r� rj r� r� r� )r� r� r� r )r� z ft.ResponseReturnValue | None)rH r r� r )r� zBaseException | Noner� r� )r� r )r� r4 r� r )r� r� r r� r� r )r� r4 r� r3 r� zcabc.Iterable[bytes])4r� �778__module__� __qualname__�__firstlineno__�__doc__r779 r �default_configr2 rk �__annotations__r rl r* rm r� r� r| r� r� r� r� r� r� r� r780 r r r r" r0 r, r@ rE r- r; r� rT r� rI rC rJ r) r� r� r� r� r� r� r� �__static_attributes__�
__classcell__)r� s @rD rH rH Q sB �� �^�@ #� 781� �T� 782� �u� 783�
#�D� 784�
�$� 785�786
#�D� 787�
)�)��*<�
788�
�e� 789�
�T� 790�
�4� 791�
�� 792�
"�9� 793�
$�T� 794�
"�4� 795�
&�t� 796�
$�U� 797�
)�%�! 798�"
&�t�# 799�$ -1�"&�$+� #�)-�'+�$)�(-�$*�%)� #�)-�; 800� �N�H $+�M�=�*� &.�N�N�-� +G�*H��'�H�801 '+�7?�"&� #�#(�9D�$(�).� $�5��5� $�5� 5� 5�802 � 5� �
5� !�5� 7�5� "�5� #'�5� �5� 5�n�6803�. GK� 3�� 3�#&� 3�9C� 3� � 3�D GN�3��3�#&�3�9C�3� �3�,&�P3�j/�8!�8804� � � !� � y,��y,� �y,� � y,�805 � y,� �
y,� 806�y,�v8807�t#�"!,� �!,� /�!,�F ,�� ,� /� ,�@3L�j
808�V�
809� 810�
811� Q�2)�* $)� � 2� � !� � 812� �> � � +�E�+� �+�8 #� "� "�!%�|� �|�813 � |� �
|� �|� �|� �|� 814
�|�|L�\�6�< %.� R�
!� R� 815� R�H %.�U�
!�U� 816�U�4 �*-� 6 �p0�&�0�8E�0� �0�d6�&�6�8E�6� �6� 6rF rH )rC ztimedelta | int | Noner� ztimedelta | None)c�817__future__r �collections.abc�abcrz r� r) r r� r� �datetimer �inspectr � itertoolsr �typesr � urllib.parser ri r� �werkzeug.datastructuresr r818 �werkzeug.exceptionsr r r
�werkzeug.routingr r r r r r r �werkzeug.wrappersr r| �
werkzeug.wsgir r� r �ftr� r r r� r r r r r! r" r# �helpersr$ r% r& r' �819sansio.appr( �sansio.scaffoldr) �sessionsr* r+ �signalsr, r- r. r/ r0 �820templatingr1 �wrappersr2 �
TYPE_CHECKING�_typeshed.wsgir3 r4 r r6 r8 r9 �TypeVar� ShellContextProcessorCallabler: �TeardownCallabler< �TemplateFilterCallabler= �TemplateGlobalCallabler> �TemplateTestCallabler? rE rH r{ rF rD �<module>r� sC �� "� � � 821� � � � '� � � ,� � +� 1� 2� -� 3� '� '� ,� -� !� 5� 6� "� � � � � � � � � � � � #� )� $� (� � &� 2� &� ,� *� %� $� )� #� � ��?�?�,�.�$�'�$� �I�I� �r�'G�'G� � � �Y�Y�|�2�+>�+>�
?�822��I�I� 1��9R�9R�S� ��I�I� 1��9R�9R�S� ��)�)� -�R�5L�5L�M��$�o6�C� o6rF