gvjddlmZddlZddlZddlZddlZddlZddl m Z ddl m Z ddl mZddl mZddlmZddlmZdd lmZd d lmZd d lmZd d lmZej6rddlmZeZej@dejBdejDfZ#ej@dejHejDZ%ej@dejLZ'ej@dejPZ)ej@dejTZ+ej@dejXZ-ej@dej\Z/ej@dej`Z1ej@dejdZ3d dZ4GddZ5d!dZ6d"dZ7d#dZ8y)$) annotationsN) defaultdict)update_wrapper) BaseLoader)FileSystemLoader)default_exceptions) HTTPException)cached_property)typing) get_root_path)_default_template_ctx_processor)GroupF.)boundT_after_requestT_before_requestT_error_handler T_teardownT_template_context_processorT_url_defaultsT_url_value_preprocessorT_routectjdfd }tjtt |S)Nc>|j|g|i|SN)_check_setup_finished)selfargskwargsff_names r/var/www/html/FastMealFinder_FlaskServer-InitialRelease/venv/lib/python3.12/site-packages/flask/sansio/scaffold.py wrapper_funcz!setupmethod..wrapper_func-s& ""6*'''')rScaffoldrt.Anyr r'returnr')__name__tcastrr)r!r$r"s` @r# setupmethodr,*s+ ZZF( 66!^L!4 55r%ceZdZUdZded<ded<dZded<dZded < d% d&d Zd'd Zd(d Z e d)d Z e jd*dZ e d+dZ e d)dZejd,dZed-dZ d.dZed/dZed/dZed/dZed/dZed/dZed/dZe d0 d1dZed2dZed3dZed4dZed5dZe d6dZe d7d Zed8d!Z e d9d"Z!e d:d#Z"e# d;d$Z$y)z#Scaffold.__init__..~s D 1r%) import_name static_folderstatic_url_pathtemplate_folderr root_pathview_functionsrerror_handler_speclistbefore_request_funcsafter_request_funcsteardown_request_funcsrtemplate_context_processorsurl_value_preprocessorsurl_default_functions)rr9r:r;r<r=s r#__init__zScaffold.__init__Ks'*. /  %d&6&67I#<>$ 1 2 "   !    "   #" t&E%FG H ($   $$   "r%cNdt|jd|jdS)N< >)typer)r0rs r#__repr__zScaffold.__repr__s&4:&&'q Q77r%ctrNotImplementedError)rr"s r#rzScaffold._check_setup_finisheds!!r%c|j4tjj|j|jSy)zhThe absolute path to the configured static folder. ``None`` if no static folder is set. N)r2ospathjoinr=rMs r#r:zScaffold.static_folders2    *77<<0C0CD Dr%c^|$tj|jd}||_y)Nz\/)rSfspathrstripr2rvalues r#r:zScaffold.static_folders)  IIe$++E2E#r%c|jduS)zQ``True`` if :attr:`static_folder` is set. .. versionadded:: 0.5 N)r:rMs r#has_static_folderzScaffold.has_static_folders !!--r%c|j |jS|j=tjj |j}d|j dSy)zThe 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/)r3r:rSrTbasenamerX)rr_s r#r;zScaffold.static_url_paths\  ,(( (    )ww''(:(:;Hxj>((- -r%c8||jd}||_y)Nr^)rXr3rYs r#r;zScaffold.static_url_paths  LL%E %r%c|j=ttjj |j |jSy)zThe 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)r<rrSrTrUr=rMs r# jinja_loaderzScaffold.jinja_loaders7    +#BGGLLAUAU$VW Wr%cLd|vr td|j|fd|gi|S)Nmethodsz8Use the 'route' decorator to use the 'methods' argument.) TypeErrorroute)rmethodruleoptionss r# _method_routezScaffold._method_routes5  VW Wtzz$<.decoratorhs1{{:t4H D  dHa ;7 ;Hr%)r!rr(rr7)rrhrirs``` r#rfzScaffold.routeOs2  r%c t)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. rP)rrhr view_funcprovide_automatic_optionsris r#rzScaffold.add_url_ruleos D"!r%cdfd }|S)aDecorate 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. c&|j<|Sr)r>)r!rrs r#rz$Scaffold.endpoint..decorators,-D   )Hr%r!rr(rr7)rrrs`` r#rzScaffold.endpoints$ r%c\|jjdgj||S)aRegister 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)rA setdefaultappendrr!s r#before_requestzScaffold.before_requests*0 !!,,T26==a@r%c\|jjdgj||S)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)rBrrrs r# after_requestzScaffold.after_requests*$   ++D"5< ##..tR8??Br%cB|jdj||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)rDrrs r#context_processorzScaffold.context_processors" ((.55a8r%cB|jdj||S)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)rErrs r#url_value_preprocessorzScaffold.url_value_preprocessor.s", $$T*11!4r%cB|jdj||S)aCallback 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)rFrrs r# url_defaultszScaffold.url_defaultsGs" ""4(//2r%cdfd }|S)aRegister 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 c,j||Sr)register_error_handler)r!code_or_exceptionrs r#rz(Scaffold.errorhandler..decorator{s  ' '(91 =Hr%)r!rr(rr7)rrrs`` r# errorhandlerzScaffold.errorhandlerUsL r%cV|j|\}}||jd||<y)zAlternative 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?)rrr! exc_classcodes r#rzScaffold.register_error_handlers3667HI 49:%d+I6r%cHt|tr t|}n|}t|t rt |dt|t st d|jdt|tr||jfS|dfS#t$rt d|ddwxYw)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.) isinstanceintrKeyError ValueError Exceptionre issubclassr)r r)exc_class_or_coders r#rz Scaffold._get_exc_class_and_codes ' - ./@A *I i +-    )Y/I&&'(((  i /inn, ,d? "5  )*+**  s BB!)NNNN) r9r/r:str | os.PathLike[str] | Noner;r1r<rr=r1)r(r/)r"r/r(None)r(r1)rZrr(r)r(bool)rZr1r(r)r(zBaseLoader | None)rgr/rhr/rizdict[str, t.Any]r(t.Callable[[T_route], T_route])rhr/rir'r(r)NNN) rhr/rr1rzft.RouteCallable | Nonerz bool | Nonerir'r(r)rr/r(zt.Callable[[F], F])r!rr(r)r!rr(r)r!rr(r)r!rr(r)r!rr(r)r!rr(r)rtype[Exception] | intr(z.t.Callable[[T_error_handler], T_error_handler])rrr!zft.ErrorHandlerCallabler(r)rrr(z"tuple[type[Exception], int | None])%r) __module__ __qualname____doc____annotations__r2r3rGrNrpropertyr:setterr\r;r rbrjr,rorsrvryr|rfrrrrrrrrrr staticmethodrr7r%r#r&r&4s/" J I!%NJ%#'j' 8<&*9= $ LL5L$ L 7 L  L\8"$$ ..  &&    = = =" = ( =889988;;::> $-115 A"A"A"+ A" $/ A"  A" A"A"F.4(B ' &  # "0  )!6) 7))V ;0 ; # ;  ; ;)#0)# +)#)#r%r&c,|Jd|jS)zsInternal helper that returns the default endpoint for a given function. This always is the function name. z/expected view func if endpoint is not provided.)r))rs r#_endpoint_from_view_funcrs"  S"SS   r%cv|jd\}}} tjj|}| t d |jr|j|jdk(rtjj|}|g|jr[tjt jj|jtfd|jD}n|jd}t jj|St jjt jj|jSt jj|jS#t tf$rt jcYSwxYw)z2Find the path that contains the package or module..z not found namespacec3DK|]}j|r|ywr)is_relative_to).0location package_paths r# z%_find_package_path..s'' #228<'s r) partition importlibutil find_specr ImportErrorrSgetcwdsubmodule_search_locationsoriginpathlibPathrT commonpathnextdirname)r9 root_mod_name_ root_spec package_specsearch_locationrs @r#_find_package_pathrsa%//4M1a NN,,];  [) ) ++    #y'7'7;'F$>>33K@L'L,S,S&||GG&&|'N'NO  #''$-$H$H'##,"F"Fq"I77???3 377??277??93C3C#DE Ewwy//00C  $ yy{ s,F#F87F8cPt|}tjjtj }t j|j|r||fStjj|\}}|jdk(rtjj|\}}|jdk(r||fStjj|jdk(r!tjj||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-packageslibN) rrSrTabspathsysprefixrPurePathrsplitlowerr_r)r9r py_prefix site_parent site_folderparentfolders r# find_packagers&k2L +I %44Y?,&&!ww}}\:Ko-{3 <<>U "<' ' 77  F # ) ) +u 477??6*L8 8L((  r%r)rzft.RouteCallabler(r/)r9r/r(r/)r9r/r(ztuple[str | None, str])9 __future__rimportlib.utilrrSrrr r* collectionsr functoolsrjinja2rrwerkzeug.exceptionsrr werkzeug.utilsr fthelpersr templatingr TYPE_CHECKINGclickrobject _sentinelTypeVarCallableAnyrAfterRequestCallablerBeforeRequestCallablerErrorHandlerCallablerTeardownCallabler TemplateContextProcessorCallablerURLDefaultCallablerURLValuePreprocessorCallabler RouteCallablerr,r&rrrr7r%r#rsg"  #$#2-*#8?? H  AIIcCJ/0!))-R5L5LQUU5ST199/r7O7OP!))-R5L5LM QYY|2+>+> ? (qyy""*M*M +23H3HI$199b&E&E !))IR%5%5 66F #F #R*1Z&r%