o

'we���@
s�
dd
lm
Z

ddlZddlZddlZddlZddlZddl	m
Z

ddlmZ
ddl
mZ
ddlmZ
ddlmZ
ddlmZ
dd	lmZ
d
dlmZ
d
dlmZ
d
d
lmZ
d
dlmZ
d
dlmZ
d
dlm Z 
ej!rqd
dl"m#Z#
e$�Z%ej&dej'dej(fd�Z)ej&dej*d�Z+ej&dej,d�Z-ej&dej.d�Z/ej&dej0d�Z1ej&dej2d�Z3ej&dej4d�Z5ej&dej6d�Z7ej&dej8d�Z9d3dd �Z:Gd!d"�d"�Z;d4d&d'�Z<d5d,d-�Z=d.d/�Z>d6d1d2�Z?dS)7�)
�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

s(�j�
d��
fdd�}
t
�tt|
���S)N�args�t.Any�kwargsrc

s |��
�

�|g
|
�
Ri|�
�
S�
N)
�_check_setup_finished)�selfrr �r�f_name��G/home/arjun/projects/env/lib/python3.10/site-packages/flask/scaffold.py�wrapper_func0s


z!setupmethod.<locals>.wrapper_func)rrr rrr)�__name__�
t�castrr)rr(r&r$r'�setupmethod-s
r,c@
s�
eZ
dZUd
Zded<dZded<dZded<				dndodd�Zdpdd�Zdqdd�Z	e
drdd��
Zejdsdd��
Ze
dtdd��
Z
e
drdd��
Zejdud d��
Zdvd#d$�Zdwd&d'�Zedxd)d*��
Zdydzd/d0�Zd{d6d7�Zed|d9d:��
Zed|d;d<��
Zed|d=d>��
Zed|d?d@��
Zed|dAdB��
Zed|dCdD��
Ze			d}d~dJdK��
ZeddMdN��
Zed�dQdR��
Zed�dTdU��
Zed�dWdX��
Z ed�dZd[��
Z!ed�d]d^��
Z"ed�d`da��
Z#ed�dedf��
Z$ed�dhdi��
Z%e&d�dldm��
Z'dS)��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�nameN�
str | None�_static_folder�_static_url_path�import_name�
static_folder�str | os.PathLike | None�static_url_path�template_folder�	root_pathcC
s�|
|_||_
||_||_|durt|j�
}||_t�|_i|_t	d
d��
|_
t	t�
|_t	t�
|_
t	t�
|_t	tdtg
i
�|_t	t�
|_t	t�
|_dS)NcS
stt
�
Sr!)r�dictr&r&r&r'�<lambda>�sz#Scaffold.__init__.<locals>.<lambda>)r3r4r6r7rr8r�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#r3r4r6r7r8r&r&r'�__init__Ms.




�������zScaffold.__init__rc

C
sd
t|�
j
�d|j�d�S)N�
<�
 �
>)�typer)r/�
r#r&r&r'�__repr__�s
zScaffold.__repr__r%�Nonec
C
�t�
r!�
�NotImplementedError)r#r%r&r&r'r"�s
zScaffold._check_setup_finishedc

C
s |jd
u
rt
j�|j|j�Sd
S)zhThe absolute path to the configured static folder. ``None``
        if no static folder is set.
        N)r1�os�path�joinr8rJr&r&r'r4�s

zScaffold.static_folder�valuecC
s"|
du
rt�
|
�
�d
�
}
|
|_dS)Nz\/)rP�fspath�rstripr1�r#rSr&r&r'r4�s

�boolc

C
s
|jd
u
S)zQ``True`` if :attr:`static_folder` is set.

        .. versionadded:: 0.5
        N)
r4rJr&r&r'�has_static_folder�s
zScaffold.has_static_folderc
C
s<|jd
u
r|jS|j
d
u
rtj�|j
�
}
d|
���d�
Sd
S)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�
/)r2r4rPrQ�basenamerU)r#rZr&r&r'r6
s




zScaffold.static_url_pathcC
s|
du
r	|
�d
�
}
|
|_
dS)NrY)rUr2rVr&r&r'r6
s


�filename�
int | NonecC
s0tj
d
}|durdSt|t�rt|���
S|S)aUsed 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
        �SEND_FILE_MAX_AGE_DEFAULTN)r
�config�
isinstancer�int�
total_seconds)r#r[rSr&r&r'�get_send_file_max_age
s



zScaffold.get_send_file_max_agercC
s0|jst
d
�
�
|�|
�
}tt�t|j�|
|d�S)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)rX�RuntimeErrorrbrr*r+r.r4)r#r[rcr&r&r'�send_static_file/
s



�zScaffold.send_static_file�FileSystemLoader | Nonec

C
s$|jd
u
rt
tj�|j|j��
Sd
S)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)r7rrPrQrRr8rJr&r&r'�jinja_loaderA
s

zScaffold.jinja_loader�rb�resource�mode�t.IO[t.AnyStr]cC
s&|d
v
rtd�
�
t
tj�|j|
�|�S)aKOpen 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".
        >�
rrh�rtz)Resources can only be opened for reading.)�
ValueError�openrPrQrRr8)r#rirjr&r&r'�
open_resourceN
s
zScaffold.open_resource�method�rule�optionsr9�t.Callable[[T_route], T_route]cC
s(d
|vrtd�
�
|j
|f
d
|
g
i
|�
�
S)N�methodsz8Use the 'route' decorator to use the 'methods' argument.)�	TypeError�route)r#rqrrrsr&r&r'�
_method_routee
s
zScaffold._method_routercK
�|�d
|
|�S)z\Shortcut for :meth:`route` with ``methods=["GET"]``.

        .. versionadded:: 2.0
        �GET�
rx�r#rrrsr&r&r'�getp
�zScaffold.getcK
ry)z]Shortcut for :meth:`route` with ``methods=["POST"]``.

        .. versionadded:: 2.0
        �POSTr{r|r&r&r'�postx
r~z
Scaffold.postcK
ry)z\Shortcut for :meth:`route` with ``methods=["PUT"]``.

        .. versionadded:: 2.0
        �PUTr{r|r&r&r'�put�
r~zScaffold.putcK
ry)z_Shortcut for :meth:`route` with ``methods=["DELETE"]``.

        .. versionadded:: 2.0
        �DELETEr{r|r&r&r'�delete�
r~zScaffold.deletecK
ry)z^Shortcut for :meth:`route` with ``methods=["PATCH"]``.

        .. versionadded:: 2.0
        �PATCHr{r|r&r&r'�patch�
r~zScaffold.patchc
sd��
�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.
        rrrc

s&��d
d�}
�j
�
|
|fi��
�

|S)N�endpoint)�pop�add_url_rule)rr��rsrrr#r&r'�	decorator�
s


z!Scaffold.route.<locals>.decoratorN)rrrrr&)r#rrrsr�r&r�r'rw�
szScaffold.router��	view_func�ft.RouteCallable | None�provide_automatic_options�bool | Nonec
K
rM)
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.
        rN)r#rrr�r�r�rsr&r&r'r��
sBzScaffold.add_url_rule�t.Callable[[F], F]c
�d��
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.
        rrrc


s|�
j�<|Sr!)
r<�
r�r�r#r&r'r�s


z$Scaffold.endpoint.<locals>.decoratorN�rrrrr&)r#r�r�r&r�r'r��
szScaffold.endpointrrcC
�|j�
d
g��|
�

|
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#rr&r&r'�before_requests
zScaffold.before_requestrcC
r�)aWRegister 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_request/s
zScaffold.after_requestrcC
r�)aRegister 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)rAr�r�r�r&r&r'�teardown_requestDs
zScaffold.teardown_requestrcC
�|jd
�
|
�

|
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)rBr�r�r&r&r'�context_processorfs
zScaffold.context_processorrcC
r�)alRegister 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)rCr�r�r&r&r'�url_value_preprocessorws
zScaffold.url_value_preprocessorrcC
r�)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)rDr�r�r&r&r'�url_defaults�s
zScaffold.url_defaults�code_or_exception�type[Exception] | int�.t.Callable[[T_error_handler], T_error_handler]c
r�)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
        rrrc


s�
��|�
|Sr!)
�register_error_handlerr��r�r#r&r'r��s

z(Scaffold.errorhandler.<locals>.decoratorN)rrrrr&)r#r�r�r&r�r'�errorhandler�s&zScaffold.errorhandler�ft.ErrorHandlerCallablecC
s$|�|
�
\}}||j
d
||<d
S)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
zScaffold.register_error_handler�exc_class_or_code�"tuple[type[Exception], int | None]c
C
s�t|t
�rzt|}
Wnty


td
|�d��
d�w|}
t|
t�r*t|
�d��
�
t|
t�s8td
|
j�d��
�
t|
t	�rB|
|
j
fS|
dfS)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�KeyErrorrn�	Exceptionrv�
issubclassr)rr�)r�r�r&r&r'r��s,







���


�


�


z Scaffold._get_exc_class_and_code)NNNN)
r3r.r4r5r6r0r7r5r8r0)rr.)r%r.rrL)rr0)rSr5rrL)rrW)rSr0rrL)r[r0rr\)r[r.rr)rrf)
rh)rir.rjr.rrk)rqr.rrr.rsr9rrt)rrr.rsrrrt)NNN)rrr.r�r0r�r�r�r�rsrrrL)r�r.rr�)rrrr)rrrr)rrrr)rrrr)rrrr)rrrr)r�r�rr�)r�r�rr�rrL)r�r�rr�)(r)�
__module__�__qualname__�__doc__�__annotations__r1r2rErKr"�propertyr4�setterrXr6rbrer	rgrprxr,r}r�r�r�r�rwr�r�r�r�r�r�r�r�r�r��staticmethodr�r&r&r&r'r-7s�






�


	















�C



!




+

r-r��
t.Callabler.c

C
s|d
u
sJd�
�
|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.)
r))
r�r&r&r'�_endpoint_from_view_funcs
r�rQ�pathlib.PurePath�baserWcC
s&z|�|
�

Wd
St
y


YdSw)NTF)�relative_torn)rQr�r&r&r'�_path_is_relative_tos




�r�c
	
s�|�d
�
\}
}}zt
j�|
�
}|durtd�
�
Wnttfy'


t��YSw|jdvr\t
j�|�
}|du
rQ|j	rQt
�tj�
|j	�
�
�t�f
dd�|j	D�
�
}n|j	d}tj�|�
S|j	rjtj�tj�|j�
�
Stj�|j�
S)z2Find the path that contains the package or module.�
.Nz	not found>N�	namespacec
3
s�|]
}
t�|
�r|
V
qdSr!)
r�)�.0�location�
�package_pathr&r'�	<genexpr>1s�
�

�z%_find_package_path.<locals>.<genexpr>r
)�	partition�	importlib�util�	find_specrn�ImportErrorrP�getcwd�origin�submodule_search_locations�pathlib�PathrQ�
commonpath�next�dirname)r3�
root_mod_name�
_�	root_spec�package_spec�search_locationr&r�r'�_find_package_paths.

��

�
�

r�r3c
C
s�t|�
}
t
j�tj�
}tt�|
�
|�r||
fSt
j�	|
�
\}}|�
�d
krMt
j�	|�
\}}|�
�dkr7||
fSt
j�|�
�
�dkrIt
j�|�
|
fS||
fSd|
fS)aFind 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�rPrQ�abspath�sys�prefixr�r��PurePath�split�lowerrZr�)r3r��	py_prefix�site_parent�site_folder�parent�folderr&r&r'�find_packageCs





r�r�)r�r�rr.)rQr�r�r.rrW)r3r.)@�
__future__r�importlib.utilr�rPr�r�rr*�collectionsr�datetimer�	functoolsr�jinja2r�werkzeug.exceptionsrr�werkzeug.utilsr	��ftr;r�globalsr
�helpersrr�
templatingr�
TYPE_CHECKING�wrappersr�object�	_sentinel�TypeVar�Callable�Anyr�AfterRequestCallabler�BeforeRequestCallabler�ErrorHandlerCallabler�TeardownCallabler� TemplateContextProcessorCallabler�URLDefaultCallabler�URLValuePreprocessorCallabler�
RouteCallablerr,r-r�r�r�r�r&r&r&r'�<module>
s\





















�

�


T
	,