U
|
ß=®d ã @ sì d dl mZ d dlZd dlZd dlZd dlZd dlZd dlZ d dl
|
m Z d dl m Z d dlmZ d dlmZ d dlmZ d dlmZ d d lmZ d
|
d lmZ d
|
d lmZ d
|
d lm Z d
|
dl m Z d
|
dl m Z d
|
dl m!Z! e j"rêd
|
dl#m$Z$ e% Z&e j'de j(de j)f dZ*e j'dej+dZ,e j'dej-dZ.e j'dej/dZ0e j'dej1dZ2e j'dej3dZ4e j'dej5dZ6e j'dej7dZ8e j'd ej9dZ:ddd d d Z;G d d! d!Z<d"d#d$d%d&Z=d'd( Z>d)d#d*d+d,d-Z?d.d/ Z@d#d0d1d2ZAdS )3é )Ú annotationsN)Ú defaultdict)Ú timedelta)Úupdate_wrapper)ÚFileSystemLoader)Údefault_exceptions)Ú HTTPException)Úcached_propertyé )Útyping)ÚAppGroup)Ú current_app)Ú get_root_path)Úsend_from_directory)Ú _default_template_ctx_processor)ÚResponseÚF.)ÚboundÚT_after_requestÚT_before_requestÚT_error_handlerÚ
|
T_teardownÚ T_template_context_processorÚT_url_defaultsÚT_url_value_preprocessorÚT_route©ÚfÚreturnc s0 j dddd fdd }t tt| ¡S )Nút.Any)ÚargsÚkwargsr c s | ¡ | f||S ©N)Ú_check_setup_finished)Úselfr r! ©r Úf_name© úEd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\flask/scaffold.pyÚ wrapper_func1 s
|
z!setupmethod.<locals>.wrapper_func)Ú__name__ÚtÚcastr r )r r) r' r% r( Ú setupmethod. s r- c @ s e Zd ZU dZded< dZded< dZded< dhdddddd d
|
d Zdd d dZdddddZ e
|
dd ddZ e j dddddZ e
|
dd ddZ e
|
dd ddZej dddd dZdd d d d Zdd!d d"d#Zed$d d%d&Zdiddd(d)d*d+Zddd,d-d.d/d0Zedd1d-d2d3d4Zedd1d-d2d5d6Zedd1d-d2d7d8Zedd1d-d2d9d:Zedd1d-d2d;d<Zedd1d-d2d=d>Zedjddd?d@d1ddAdBdCZ eddDdEdFdGZ edHdHdIdJdKZ edLdLdIdMdNZ edOdOdIdPdQZ edRdRdIdSdTZ!edUdUdIdVdWZ"edXdXdIdYdZZ#ed[d\d]d^d_Z$ed[d`ddadbdcZ%e&d[dddedfdgZ'dS )kÚScaffoldaù Common behavior shared between :class:`~flask.Flask` and
|
:class:`~flask.blueprints.Blueprint`.
|
|
:param import_name: The import name of the module where this object
|
is defined. Usually :attr:`__name__` should be used.
|
:param static_folder: Path to a folder of static files to serve.
|
If this is set, a static route will be added.
|
:param static_url_path: URL prefix for the static route.
|
:param template_folder: Path to a folder containing template files.
|
for rendering. If this is set, a Jinja loader will be added.
|
:param root_path: The path that static, template, and resource files
|
are relative to. Typically not set, it is discovered based on
|
the ``import_name``.
|
|
.. versionadded:: 2.0
|
ÚstrÚnameNz
|
str | NoneÚ_static_folderÚ_static_url_pathzstr | os.PathLike | None)Ú import_nameÚ static_folderÚstatic_url_pathÚtemplate_folderÚ root_pathc C s || _ || _|| _|| _|d kr*t| j }|| _t | _i | _t dd | _
|
t t | _ t t | _ t t | _t t d tgi| _t t | _t t | _d S )Nc S s t tS r" )r Údictr' r' r' r( Ú<lambda> ó z#Scaffold.__init__.<locals>.<lambda>)r3 r4 r5 r6 r r7 r ÚcliÚview_functionsr Úerror_handler_specÚlistÚbefore_request_funcsÚafter_request_funcsÚteardown_request_funcsr Útemplate_context_processorsÚurl_value_preprocessorsÚurl_default_functions)r$ r3 r4 r5 r6 r7 r' r' r( Ú__init__N s.
|
|
|
ýþþþþýþzScaffold.__init__)r c C s dt | j d| jdS )Nú<ú ú>)Útyper* r0 ©r$ r' r' r( Ú__repr__â s zScaffold.__repr__ÚNone)r& r c C s t d S r" ©ÚNotImplementedError)r$ r& r' r' r( r# å s z Scaffold._check_setup_finishedc C s$ | j dk r tj | j| j ¡S dS dS )zhThe absolute path to the configured static folder. ``None``
|
if no static folder is set.
|
N)r1 ÚosÚpathÚjoinr7 rJ r' r' r( r4 è s
|
zScaffold.static_folder)Úvaluer c C s" |d k rt |¡ d¡}|| _d S )Nz\/)rO ÚfspathÚrstripr1 ©r$ rR r' r' r( r4 ò s Úboolc C s
|
| j dk S )zQ``True`` if :attr:`static_folder` is set.
|
|
.. versionadded:: 0.5
|
N)r4 rJ r' r' r( Úhas_static_folderù s zScaffold.has_static_folderc C s< | j dk r| j S | jdk r8tj | j¡}d| d¡S dS )z§The URL prefix that the static route will be accessible from.
|
|
If it was not configured during init, it is derived from
|
:attr:`static_folder`.
|
Nú/)r2 r4 rO rP ÚbasenamerT )r$ rY r' r' r( r5 s
|
|
zScaffold.static_url_pathc C s |d k r| d¡}|| _d S )NrX )rT r2 rU r' r' r( r5 s
|
z
|
int | None)Úfilenamer c C s0 t jd }|dkrdS t|tr,t| ¡ S |S )a Used by :func:`send_file` to determine the ``max_age`` cache
|
value for a given file path if it wasn't passed.
|
|
By default, this returns :data:`SEND_FILE_MAX_AGE_DEFAULT` from
|
the configuration of :data:`~flask.current_app`. This defaults
|
to ``None``, which tells the browser to use conditional requests
|
instead of a timed cache, which is usually preferable.
|
|
.. versionchanged:: 2.0
|
The default configuration is ``None`` instead of 12 hours.
|
|
.. versionadded:: 0.9
|
ZSEND_FILE_MAX_AGE_DEFAULTN)r ÚconfigÚ
|
isinstancer ÚintÚ total_seconds)r$ rZ rR r' r' r( Úget_send_file_max_age s
|
|
z Scaffold.get_send_file_max_ager c C s0 | j std| |¡}tt t| j¡||dS )zïThe view function used to serve files from
|
:attr:`static_folder`. A route is automatically registered for
|
this view at :attr:`static_url_path` if :attr:`static_folder` is
|
set.
|
|
.. versionadded:: 0.5
|
z2'static_folder' must be set to serve static_files.)Úmax_age)rW Ú RuntimeErrorr_ r r+ r, r/ r4 )r$ rZ r` r' r' r( Úsend_static_file0 s
|
ÿzScaffold.send_static_filezFileSystemLoader | Nonec C s( | j dk r ttj | j| j ¡S dS dS )zÒThe Jinja loader for this object's templates. By default this
|
is a class :class:`jinja2.loaders.FileSystemLoader` to
|
:attr:`template_folder` if it is set.
|
|
.. versionadded:: 0.5
|
N)r6 r rO rP rQ r7 rJ r' r' r( Ú jinja_loaderB s
|
zScaffold.jinja_loaderÚrbzt.IO[t.AnyStr])ÚresourceÚmoder c C s& |dkrt dttj | j|¡|S )aK Open a resource file relative to :attr:`root_path` for
|
reading.
|
|
For example, if the file ``schema.sql`` is next to the file
|
``app.py`` where the ``Flask`` app is defined, it can be opened
|
with:
|
|
.. code-block:: python
|
|
with app.open_resource("schema.sql") as f:
|
conn.executescript(f.read())
|
|
:param resource: Path to the resource relative to
|
:attr:`root_path`.
|
:param mode: Open the file in this mode. Only reading is
|
supported, valid values are "r" (or "rt") and "rb".
|
> ÚrÚrtrd z)Resources can only be opened for reading.)Ú
|
ValueErrorÚopenrO rP rQ r7 )r$ re rf r' r' r( Ú open_resourceO s zScaffold.open_resourcer8 z t.Callable[[T_route], T_route])ÚmethodÚruleÚoptionsr c C s( d|krt d| j|fd|gi|S )NÚmethodsz8Use the 'route' decorator to use the 'methods' argument.)Ú TypeErrorÚroute)r$ rl rm rn r' r' r( Ú _method_routef s zScaffold._method_router )rm rn r c K s | d||¡S )z\Shortcut for :meth:`route` with ``methods=["GET"]``.
|
|
.. versionadded:: 2.0
|
ÚGET©rr ©r$ rm rn r' r' r( Úgetq s z Scaffold.getc K s | d||¡S )z]Shortcut for :meth:`route` with ``methods=["POST"]``.
|
|
.. versionadded:: 2.0
|
ÚPOSTrt ru r' r' r( Úposty s z Scaffold.postc K s | d||¡S )z\Shortcut for :meth:`route` with ``methods=["PUT"]``.
|
|
.. versionadded:: 2.0
|
ÚPUTrt ru r' r' r( Úput s z Scaffold.putc K s | d||¡S )z_Shortcut for :meth:`route` with ``methods=["DELETE"]``.
|
|
.. versionadded:: 2.0
|
ÚDELETErt ru r' r' r( Údelete s zScaffold.deletec K s | d||¡S )z^Shortcut for :meth:`route` with ``methods=["PATCH"]``.
|
|
.. versionadded:: 2.0
|
ÚPATCHrt ru r' r' r( Úpatch s zScaffold.patchc s ddd fdd }|S )aì Decorate a view function to register it with the given URL
|
rule and options. Calls :meth:`add_url_rule`, which has more
|
details about the implementation.
|
|
.. code-block:: python
|
|
@app.route("/")
|
def index():
|
return "Hello, World!"
|
|
See :ref:`url-route-registrations`.
|
|
The endpoint name for the route defaults to the name of the view
|
function if the ``endpoint`` parameter isn't passed.
|
|
The ``methods`` parameter defaults to ``["GET"]``. ``HEAD`` and
|
``OPTIONS`` are added automatically.
|
|
:param rule: The URL rule string.
|
:param options: Extra options passed to the
|
:class:`~werkzeug.routing.Rule` object.
|
r r c s" dd ¡}j|| f | S )NÚendpoint)ÚpopÚ add_url_rule)r r ©rn rm r$ r' r( Ú decorator² s z!Scaffold.route.<locals>.decoratorr' )r$ rm rn r r' r r( rq s zScaffold.routezft.RouteCallable | Nonez bool | None)rm r Ú view_funcÚprovide_automatic_optionsrn r c K s t dS )a; Register a rule for routing incoming requests and building
|
URLs. The :meth:`route` decorator is a shortcut to call this
|
with the ``view_func`` argument. These are equivalent:
|
|
.. code-block:: python
|
|
@app.route("/")
|
def index():
|
...
|
|
.. code-block:: python
|
|
def index():
|
...
|
|
app.add_url_rule("/", view_func=index)
|
|
See :ref:`url-route-registrations`.
|
|
The endpoint name for the route defaults to the name of the view
|
function if the ``endpoint`` parameter isn't passed. An error
|
will be raised if a function has already been registered for the
|
endpoint.
|
|
The ``methods`` parameter defaults to ``["GET"]``. ``HEAD`` is
|
always added automatically, and ``OPTIONS`` is added
|
automatically by default.
|
|
``view_func`` does not necessarily need to be passed, but if the
|
rule should participate in routing an endpoint name must be
|
associated with a view function at some point with the
|
:meth:`endpoint` decorator.
|
|
.. code-block:: python
|
|
app.add_url_rule("/", endpoint="index")
|
|
@app.endpoint("index")
|
def index():
|
...
|
|
If ``view_func`` has a ``required_methods`` attribute, those
|
methods are added to the passed and automatic methods. If it
|
has a ``provide_automatic_methods`` attribute, it is used as the
|
default if the parameter is not passed.
|
|
:param rule: The URL rule string.
|
:param endpoint: The endpoint name to associate with the rule
|
and view function. Used when routing and building URLs.
|
Defaults to ``view_func.__name__``.
|
:param view_func: The view function to associate with the
|
endpoint name.
|
:param provide_automatic_options: Add the ``OPTIONS`` method and
|
respond to ``OPTIONS`` requests automatically.
|
:param options: Extra options passed to the
|
:class:`~werkzeug.routing.Rule` object.
|
NrM )r$ rm r r r
rn r' r' r( r ¹ s BzScaffold.add_url_rulezt.Callable[[F], F])r r c s ddd fdd }|S )a® Decorate a view function to register it for the given
|
endpoint. Used if a rule is added without a ``view_func`` with
|
:meth:`add_url_rule`.
|
|
.. code-block:: python
|
|
app.add_url_rule("/ex", endpoint="example")
|
|
@app.endpoint("example")
|
def example():
|
...
|
|
:param endpoint: The endpoint name to associate with the view
|
function.
|
r r c s | j < | S r" )r< ©r ©r r$ r' r( r s
|
z$Scaffold.endpoint.<locals>.decoratorr' )r$ r r r' r r( r ý s zScaffold.endpointr r c C s | j dg ¡ |¡ |S )a² Register a function to run before each request.
|
|
For example, this can be used to open a database connection, or
|
to load the logged in user from the session.
|
|
.. code-block:: python
|
|
@app.before_request
|
def load_user():
|
if "user_id" in session:
|
g.user = db.session.get(session["user_id"])
|
|
The function will be called without any arguments. If it returns
|
a non-``None`` value, the value is handled as if it was the
|
return value from the view, and further request handling is
|
stopped.
|
|
This is available on both app and blueprint objects. When used on an app, this
|
executes before every request. When used on a blueprint, this executes before
|
every request that the blueprint handles. To register with a blueprint and
|
execute before every request, use :meth:`.Blueprint.before_app_request`.
|
N)r? Ú
|
setdefaultÚappend©r$ r r' r' r( Úbefore_request s zScaffold.before_requestr c C s | j dg ¡ |¡ |S )aW Register a function to run after each request to this object.
|
|
The function is called with the response object, and must return
|
a response object. This allows the functions to modify or
|
replace the response before it is sent.
|
|
If a function raises an exception, any remaining
|
``after_request`` functions will not be called. Therefore, this
|
should not be used for actions that must execute, such as to
|
close resources. Use :meth:`teardown_request` for that.
|
|
This is available on both app and blueprint objects. When used on an app, this
|
executes after every request. When used on a blueprint, this executes after
|
every request that the blueprint handles. To register with a blueprint and
|
execute after every request, use :meth:`.Blueprint.after_app_request`.
|
N)r@ r r r r' r' r( Ú after_request0 s zScaffold.after_requestr c C s | j dg ¡ |¡ |S )a Register a function to be called when the request context is
|
popped. Typically this happens at the end of each request, but
|
contexts may be pushed manually as well during testing.
|
|
.. code-block:: python
|
|
with app.test_request_context():
|
...
|
|
When the ``with`` block exits (or ``ctx.pop()`` is called), the
|
teardown functions are called just before the request context is
|
made inactive.
|
|
When a teardown function was called because of an unhandled
|
exception it will be passed an error object. If an
|
:meth:`errorhandler` is registered, it will handle the exception
|
and the teardown will not receive it.
|
|
Teardown functions must avoid raising exceptions. If they
|
execute code that might fail they must surround that code with a
|
``try``/``except`` block and log any errors.
|
|
The return values of teardown functions are ignored.
|
|
This is available on both app and blueprint objects. When used on an app, this
|
executes after every request. When used on a blueprint, this executes after
|
every request that the blueprint handles. To register with a blueprint and
|
execute after every request, use :meth:`.Blueprint.teardown_app_request`.
|
N)rA r r r r' r' r( Úteardown_requestE s zScaffold.teardown_requestr c C s | j d |¡ |S )a# Registers a template context processor function. These functions run before
|
rendering a template. The keys of the returned dict are added as variables
|
available in the template.
|
|
This is available on both app and blueprint objects. When used on an app, this
|
is called for every rendered template. When used on a blueprint, this is called
|
for templates rendered from the blueprint's views. To register with a blueprint
|
and affect every template, use :meth:`.Blueprint.app_context_processor`.
|
N)rB r r r' r' r( Úcontext_processorg s zScaffold.context_processorr c C s | j d |¡ |S )al Register a URL value preprocessor function for all view
|
functions in the application. These functions will be called before the
|
:meth:`before_request` functions.
|
|
The function can modify the values captured from the matched url before
|
they are passed to the view. For example, this can be used to pop a
|
common language code value and place it in ``g`` rather than pass it to
|
every view.
|
|
The function is passed the endpoint name and values dict. The return
|
value is ignored.
|
|
This is available on both app and blueprint objects. When used on an app, this
|
is called for every request. When used on a blueprint, this is called for
|
requests that the blueprint handles. To register with a blueprint and affect
|
every request, use :meth:`.Blueprint.app_url_value_preprocessor`.
|
N)rC r r r' r' r( Úurl_value_preprocessorx s z Scaffold.url_value_preprocessorr c C s | j d |¡ |S )aý Callback function for URL defaults for all view functions of the
|
application. It's called with the endpoint and values and should
|
update the values passed in place.
|
|
This is available on both app and blueprint objects. When used on an app, this
|
is called for every request. When used on a blueprint, this is called for
|
requests that the blueprint handles. To register with a blueprint and affect
|
every request, use :meth:`.Blueprint.app_url_defaults`.
|
N)rD r r r' r' r( Ú url_defaults s zScaffold.url_defaultsztype[Exception] | intz.t.Callable[[T_error_handler], T_error_handler])Úcode_or_exceptionr c s ddd fdd }|S )a Register a function to handle errors by code or exception class.
|
|
A decorator that is used to register a function given an
|
error code. Example::
|
|
@app.errorhandler(404)
|
def page_not_found(error):
|
return 'This page does not exist', 404
|
|
You can also register handlers for arbitrary exceptions::
|
|
@app.errorhandler(DatabaseError)
|
def special_exception_handler(error):
|
return 'Database connection failed', 500
|
|
This is available on both app and blueprint objects. When used on an app, this
|
can handle errors from every request. When used on a blueprint, this can handle
|
errors from requests that the blueprint handles. To register with a blueprint
|
and affect every request, use :meth:`.Blueprint.app_errorhandler`.
|
|
.. versionadded:: 0.7
|
Use :meth:`register_error_handler` instead of modifying
|
:attr:`error_handler_spec` directly, for application wide error
|
handlers.
|
|
.. versionadded:: 0.7
|
One can now additionally also register custom exception types
|
that do not necessarily have to be a subclass of the
|
:class:`~werkzeug.exceptions.HTTPException` class.
|
|
:param code_or_exception: the code as integer for the handler, or
|
an arbitrary exception
|
r r c s | ¡ | S r" )Úregister_error_handlerr ©r r$ r' r( r Å s z(Scaffold.errorhandler.<locals>.decoratorr' )r$ r r r' r r( Ú errorhandler s &zScaffold.errorhandlerzft.ErrorHandlerCallable)r r r c C s$ | |¡\}}|| jd | |< dS )z¼Alternative error attach function to the :meth:`errorhandler`
|
decorator that is more straightforward to use for non decorator
|
usage.
|
|
.. versionadded:: 0.7
|
N)Ú_get_exc_class_and_coder= )r$ r r Ú exc_classÚcoder' r' r( r Ë s z Scaffold.register_error_handlerz"tuple[type[Exception], int | None])Úexc_class_or_coder c C s t | tr@z t| }W qD tk
|
r< td| ddY qDX n| }t |tr\t|dt|tsxtd|j dt|t r||j
|
fS |dfS dS )a Get the exception class being handled. For HTTP status codes
|
or ``HTTPException`` subclasses, return both the exception and
|
status code.
|
|
:param exc_class_or_code: Any exception class, or an HTTP status
|
code as an integer.
|
ú'z^' is not a recognized HTTP error code. Use a subclass of HTTPException with that code instead.Nzh is an instance, not a class. Handlers can only be registered for Exception classes or HTTP error codes.zl' is not a subclass of Exception. Handlers can only be registered for Exception classes or HTTP error codes.) r\ r] r ÚKeyErrorri Ú Exceptionrp Ú
|
issubclassr* r r )r r r' r' r( r Ú s*
|
|
ÿü
|
|
ÿ
|
ÿ
|
|
z Scaffold._get_exc_class_and_code)NNNN)rd )NNN)(r* Ú
|
__module__Ú __qualname__Ú__doc__Ú__annotations__r1 r2 rE rK r# Úpropertyr4 ÚsetterrW r5 r_ rb r rc rk rr r- rv rx rz r| r~ rq r r r r r r r r r r Ú staticmethodr r' r' r' r( r. 8 s
|
ú û C! +r. z
|
t.Callabler/ )r r c C s | dk st d| jS )zsInternal helper that returns the default endpoint for a given
|
function. This always is the function name.
|
Nz/expected view func if endpoint is not provided.)ÚAssertionErrorr* )r r' r' r( Ú_endpoint_from_view_func s r¥ c C sJ t | dr| |¡S t| }|jdkr4|jdkr4dS td|j ddS )zµAttempt to figure out if the given name is a package or a module.
|
|
:param: loader: The loader that handled the name.
|
:param mod_name: The name of the package or module.
|
Ú
|
is_packageÚ_frozen_importlibZNamespaceLoaderTr z<.is_package()' must be implemented for PEP 302 import hooks.N)Úhasattrr¦ rI r r* ÚAttributeError)ÚloaderÚmod_nameÚclsr' r' r( Ú)_matching_loader_thinks_module_is_package s
|
|
ÿr zpathlib.PurePathrV )rP Úbaser c C s, z| |¡ W dS tk
|
r& Y dS X d S )NTF)Ú relative_tori )rP r® r' r' r( Ú_path_is_relative_to( s
|
|
r° c sh | d¡\}}}z tj |¡}|dkr.tdW n ttfk
|
rH Y nX |jdkr²tj | ¡}|dk r|jrt t
|
j |j¡¡ fdd|jD }n
|
t |j}t
|
j t|¡S |jrÎt
|
j t
|
j |j¡¡S t
|
j |j¡S t |¡}|dksø|dkr t
|
¡ S t|dr| |¡}n t|d r,|j}n t |¡j}t
|
j t
|
j |¡¡ t||rdt
|
j ¡ S )
|
z2Find the path that contains the package or module.Ú.Nz not found> NÚ namespacec 3 s | ]}t |r|V qd S r" )r° )Ú.0Úlocation©Ú package_pathr' r( Ú <genexpr>J s
|
þz%_find_package_path.<locals>.<genexpr>Ú__main__Ú get_filenameÚarchive)Ú partitionÚ importlibÚutilÚ find_specri Ú ImportErrorÚoriginÚsubmodule_search_locationsÚpathlibÚPathrO rP Ú
|
commonpathÚiterÚdirnameÚnextÚpkgutilÚ
|
get_loaderÚgetcwdr¨ r¹ rº Ú import_moduleÚ__file__Úabspathr )r3 Z root_mod_nameÚ_Z root_specZ package_specZsearch_locationsrª rZ r' rµ r( Ú_find_package_path1 sB
|
ÿ
|
þ
|
|
rÏ )r3 c C s¢ t | }tj tj¡}tt |¡|r.||fS tj |¡\}}|
|
¡ dkrtj |¡\}}|
|
¡ dkrn||fS tj |¡
|
¡ dkrtj |¡|fS ||fS d|fS )a Find the prefix that a package is installed under, and the path
|
that it would be imported from.
|
|
The prefix is the directory containing the standard directory
|
hierarchy (lib, bin, etc.). If the package is not installed to the
|
system (:attr:`sys.prefix`) or a virtualenv (``site-packages``),
|
``None`` is returned.
|
|
The path is the entry in :attr:`sys.path` that contains the package
|
for import. If the package is not installed, it's assumed that the
|
package was imported from the current working directory.
|
z site-packagesÚlibN) rÏ rO rP rÍ ÚsysÚprefixr° r ÚPurePathÚsplitÚlowerrY rÆ )r3 r¶ Z py_prefixZ site_parentZ site_folderÚparentÚfolderr' r' r( Ú find_packageu s rØ )BÚ
|
__future__r Úimportlib.utilr¼ rO r rÈ rÑ r r+ Ú collectionsr Údatetimer Ú functoolsr Zjinja2r Zwerkzeug.exceptionsr r Zwerkzeug.utilsr Ú Úftr; r Úglobalsr Zhelpersr r Z
|
templatingr Ú TYPE_CHECKINGÚwrappersr ÚobjectÚ _sentinelÚTypeVarÚCallableÚAnyr ZAfterRequestCallabler ZBeforeRequestCallabler ZErrorHandlerCallabler ZTeardownCallabler Z TemplateContextProcessorCallabler ZURLDefaultCallabler Z URLValuePreprocessorCallabler Z RouteCallabler r- r. r¥ r r° rÏ rØ r' r' r' r( Ú<module> sb ÿ ÿ
|
T D
|
