gA^dZddlmZddlmZmZGddeZGddeZd S) a flask.blueprints ~~~~~~~~~~~~~~~~ Blueprints are the recommended way to implement larger or more pluggable applications in Flask 0.7 and later. :copyright: (c) 2015 by Armin Ronacher. :license: BSD, see LICENSE for more details. )update_wrapper)_PackageBoundObject_endpoint_from_view_funcc eZdZdZdZddZdS)BlueprintSetupStatezTemporary holder object for registering a blueprint with the application. An instance of this class is created by the :meth:`~flask.Blueprint.make_setup_state` method and later passed to all register callback functions. c||_||_||_||_|jd}| |jj}||_|jd}| |jj}||_t|jj|_ |j |jdddS)N subdomain url_prefix url_defaults) app blueprintoptionsfirst_registrationgetr r dicturl_values_defaultsr update)selfrrrrr r s F/granary/edev/quantum/lib/python3.11/site-packages/flask/blueprints.py__init__zBlueprintSetupState.__init__s# #5L$$[11  0I#\%%l33  2J%!!CDD   !1!1."!E!EFFFFFNc "|jr |j|z}|d|j|t|}|j}d|vr t |fi|d}|jj||j j d||fd|i|dS)zA helper method to register a rule (and optionally a view function) to the application. The endpoint is automatically prefixed with the blueprint's name. r Ndefaults.) r setdefaultr rr rpopr add_url_rulername)rruleendpoint view_funcrrs rrz BlueprintSetupState.add_url_rule>s ? *?T)D;777  / ::H$  H@@ J(?(?@@Hdt~/B/B/BHH$M' G G2: G>E G G G G GrNN)__name__ __module__ __qualname____doc__rrr rrrrsK $G$G$GLGGGGGGrrceZdZdZdZdZ d"dZdZdZd#dZ d#dZ d Z d$d Z d Z d%d Zd%d Zd%dZd%dZd%dZd%dZdZdZdZdZdZdZdZdZdZdZdZdZdZ dZ!d Z"d!Z#dS)& Blueprinta6Represents a blueprint. A blueprint is an object that records functions that will be called with the :class:`~flask.blueprints.BlueprintSetupState` later to register functions or other things on the main application. See :ref:`blueprints` for more information. .. versionadded:: 0.7 FNc tj|||| ||_||_||_||_||_g|_|i}||_dS)N) root_path) rrr r r static_folderstatic_url_pathdeferred_functionsr) rr import_namer-r.template_folderr r r r,s rrzBlueprint.__init__\sm $T;/8 : : : : $"*."$  L#/   rc|jr%|jrddlm}|t d|j|dS)zRegisters a function that is called when the blueprint is registered on the application. This function is called with the state as argument as returned by the :meth:`make_setup_state` method. r)warnzgThe blueprint was already registered once but is getting modified now. These changes will not show up.N)_got_registered_oncewarn_on_modificationswarningsr3Warningr/append)rfuncr3s rrecordzBlueprint.recordlso  $ /)C / % % % % % % D-.. / / / &&t,,,,,rcTfd}|t|S)zWorks like :meth:`record` but wraps the function in another function that will ensure the function is only called once. If the blueprint is registered a second time on the application, the function passed is not called. c0|jr |dSdSN)r)stater9s rwrapperz&Blueprint.record_once..wrappers)' U   r)r:r)rr9r?s ` r record_oncezBlueprint.record_onceys:      {{>'488999rc&t||||S)zCreates an instance of :meth:`~flask.blueprints.BlueprintSetupState` object that is later passed to the register callback functions. Subclasses can override this to return a subclass of the setup state. )r)rrrrs rmake_setup_statezBlueprint.make_setup_states #4g7IJJJrcd|_||||}|jr%||jdz|jd|jD] }||dS)a>Called by :meth:`Flask.register_blueprint` to register a blueprint on the application. This can be overridden to customize the register behavior. Keyword arguments from :func:`~flask.Flask.register_blueprint` are directly forwarded to this method in the `options` dictionary. Tz/static)r#r"N)r4rBhas_static_folderrr.send_static_filer/)rrrrr>deferreds rregisterzBlueprint.registers%)!%%c74FGG  ! 2   t36HH)-)>(0  2 2 2/  H HUOOOO  rc fd}|S)zLike :meth:`Flask.route` but for a blueprint. The endpoint for the :func:`url_for` function is prefixed with the name of the blueprint. c^d|j}j||fi|S)Nr")rr%r)fr"rr!rs r decoratorz"Blueprint.route..decorators<{{:qz::H D dHa ; ;7 ; ; ;Hrr )rr!rrLs``` rroutezBlueprint.routes0       rc drdvs Jd|fddS)zLike :meth:`Flask.add_url_rule` but for a blueprint. The endpoint for the :func:`url_for` function is prefixed with the name of the blueprint. rz+Blueprint endpoints should not contain dotsc$|jfiSr=)r)sr"rr!r#s rz(Blueprint.add_url_rule..s# AN49 @ @ @ @rN)r:)rr!r"r#rs ````rrzBlueprint.add_url_rulesz  Vh&&&(U&&& AAAAAAA B B B B Brcfd}|S)a\Like :meth:`Flask.endpoint` but for a blueprint. This does not prefix the endpoint with the blueprint name, this has to be done explicitly by the user of this method. If the endpoint is prefixed with a `.` it will be registered to the current blueprint, otherwise it's an application independent endpoint. c@fd}|S)Nc&|jj<dSr=)rview_functions)r>r"rKs rregister_endpointz@Blueprint.endpoint..decorator..register_endpoints56 (222rr@)rKrVr"rs` rrLz%Blueprint.endpoint..decorators< 7 7 7 7 7 7   . / / /Hrr )rr"rLs`` rr"zBlueprint.endpoints*       rcfd}|S)zRegister a custom template filter, available application wide. Like :meth:`Flask.template_filter` but for a blueprint. :param name: the optional name of the filter, otherwise the function name will be used. c6||SN)r )add_app_template_filterrKr rs rrLz0Blueprint.app_template_filter..decorator!  ( ( ( 6 6 6Hrr rr rLs`` rapp_template_filterzBlueprint.app_template_filters*      rc@fd}||dS)aIRegister a custom template filter, available application wide. Like :meth:`Flask.add_template_filter` but for a blueprint. Works exactly like the :meth:`app_template_filter` decorator. :param name: the optional name of the filter, otherwise the function name will be used. c>|jjjpj<dSr=)r jinja_envfiltersr%r>rKr s rregister_templatez.register_template">?EI  '(: ; ; ;rNrWrrKr res `` rr[z!Blueprint.add_app_template_filtersC @ @ @ @ @ @ *+++++rcfd}|S)aRegister a custom template test, available application wide. Like :meth:`Flask.template_test` but for a blueprint. .. versionadded:: 0.10 :param name: the optional name of the test, otherwise the function name will be used. c6||SrZ)add_app_template_testr\s rrLz.Blueprint.app_template_test..decorators!  & &qt & 4 4 4Hrr r^s`` rapp_template_testzBlueprint.app_template_test*      rc@fd}||dS)aaRegister a custom template test, available application wide. Like :meth:`Flask.add_template_test` but for a blueprint. Works exactly like the :meth:`app_template_test` decorator. .. versionadded:: 0.10 :param name: the optional name of the test, otherwise the function name will be used. c>|jjjpj<dSr=)rrbtestsr%rds rrez:Blueprint.add_app_template_test..register_templates"<=EI  %d&8aj 9 9 9rNrWrgs `` rrjzBlueprint.add_app_template_tests= > > > > > > *+++++rcfd}|S)aRegister a custom template global, available application wide. Like :meth:`Flask.template_global` but for a blueprint. .. versionadded:: 0.10 :param name: the optional name of the global, otherwise the function name will be used. c6||SrZ)add_app_template_globalr\s rrLz0Blueprint.app_template_global..decoratorr]rr r^s`` rapp_template_globalzBlueprint.app_template_globalrlrc@fd}||dS)aiRegister a custom template global, available application wide. Like :meth:`Flask.add_template_global` but for a blueprint. Works exactly like the :meth:`app_template_global` decorator. .. versionadded:: 0.10 :param name: the optional name of the global, otherwise the function name will be used. c>|jjjpj<dSr=)rrbglobalsr%rds rrez.register_template rfrNrWrgs `` rrrz!Blueprint.add_app_template_globalsC @ @ @ @ @ @ *+++++rc<fdS)zLike :meth:`Flask.before_request` but for a blueprint. This function is only executed before each request that is handled by a function of that blueprint. ct|jjjgSr=)rbefore_request_funcsrr r8rPrKrs rrQz*Blueprint.before_request..s*15#= Z 2 & &vvayyrrWrrKs``rbefore_requestzBlueprint.before_request < 11111 2 2 2rc8|fdS)zLike :meth:`Flask.before_request`. Such a function is executed before each request, even if outside of a blueprint. cj|jjdgSr=)rryrr8rPrKs rrQz.Blueprint.before_app_request..s(15#= Zb ! !&&))rrWr{s `rbefore_app_requestzBlueprint.before_app_request6 ,,,, - - -rc8|fdS)zLike :meth:`Flask.before_first_request`. Such a function is executed before the first request to the application. cB|jjSr=)rbefore_first_request_funcsr8rs rrQz4Blueprint.before_app_first_request.."s15#C#J#J1#M#MrrWr{s `rbefore_app_first_requestz"Blueprint.before_app_first_requests( MMMMNNNrc<fdS)zLike :meth:`Flask.after_request` but for a blueprint. This function is only executed after each request that is handled by a function of that blueprint. ct|jjjgSr=)rafter_request_funcsrr r8rzs rrQz)Blueprint.after_request..*s*15#< Z 2 & &vvayyrrWr{s``r after_requestzBlueprint.after_request%r}rc8|fdS)zLike :meth:`Flask.after_request` but for a blueprint. Such a function is executed after each request, even if outside of the blueprint. cj|jjdgSr=)rrrr8rs rrQz-Blueprint.after_app_request..2s(15#< Zb ! !&&))rrWr{s `rafter_app_requestzBlueprint.after_app_request.rrc<fdS)a=Like :meth:`Flask.teardown_request` but for a blueprint. This function is only executed when tearing down requests handled by a function of that blueprint. Teardown request functions are executed when the request context is popped, even when no actual request was performed. ct|jjjgSr=)rteardown_request_funcsrr r8rzs rrQz,Blueprint.teardown_request..=s*15#? Z 2 & &vvayyrrWr{s``rteardown_requestzBlueprint.teardown_request6s< 11111 2 2 2rc8|fdS)zLike :meth:`Flask.teardown_request` but for a blueprint. Such a function is executed when tearing down each request, even if outside of the blueprint. cj|jjdgSr=)rrrr8rs rrQz0Blueprint.teardown_app_request..Fs(15#? Zb ! !&&))rrWr{s `rteardown_app_requestzBlueprint.teardown_app_requestAs6 ,,,, - - -rc<fdS)zLike :meth:`Flask.context_processor` but for a blueprint. This function is only executed for requests handled by a blueprint. ct|jjjgSr=)rtemplate_context_processorsrr r8rzs rrQz-Blueprint.context_processor..Ns*15#D Z 2 & &vvayyrrWr{s``rcontext_processorzBlueprint.context_processorJs< 11111 2 2 2rc8|fdS)zLike :meth:`Flask.context_processor` but for a blueprint. Such a function is executed each request, even if outside of the blueprint. cj|jjdgSr=)rrrr8rs rrQz1Blueprint.app_context_processor..Vs(15#D Zb ! !&&))rrWr{s `rapp_context_processorzBlueprint.app_context_processorRrrcfd}|S)zLike :meth:`Flask.errorhandler` but for a blueprint. This handler is used for all requests, even if outside of the blueprint. c<fdS)NcJ|jSr=)r errorhandler)rPcoderKs rrQz?Blueprint.app_errorhandler..decorator.._s"'?qu'9'9$'?'?'B'BrrW)rKrrs`rrLz-Blueprint.app_errorhandler..decorator^s*   BBBBB C C CHrr )rrrLs`` rapp_errorhandlerzBlueprint.app_errorhandlerZs*      rc<fdS)zRegisters a function as URL value preprocessor for this blueprint. It's called before the view functions are called and can modify the url values provided. ct|jjjgSr=)rurl_value_preprocessorsrr r8rzs rrQz2Blueprint.url_value_preprocessor..hs*15#@ Z 2 & &vvayyrrWr{s``rurl_value_preprocessorz Blueprint.url_value_preprocessorcr}rc<fdS)zCallback function for URL defaults for this blueprint. It's called with the endpoint and values and should update the values passed in place. ct|jjjgSr=)rurl_default_functionsrr r8rzs rrQz(Blueprint.url_defaults..qs*15#> Z 2 & &vvayyrrWr{s``rr zBlueprint.url_defaultslr}rc8|fdS)zESame as :meth:`url_value_preprocessor` but application wide. cj|jjdgSr=)rrrr8rs rrQz6Blueprint.app_url_value_preprocessor..xs(15#@ Zb ! !&&))rrWr{s `rapp_url_value_preprocessorz$Blueprint.app_url_value_preprocessoru6 ,,,, - - -rc8|fdS)z;Same as :meth:`url_defaults` but application wide. cj|jjdgSr=)rrrr8rs rrQz,Blueprint.app_url_defaults..s(15#> Zb ! !&&))rrWr{s `rapp_url_defaultszBlueprint.app_url_defaults|rrcfd}|S)a Registers an error handler that becomes active for this blueprint only. Please be aware that routing does not happen local to a blueprint so an error handler for 404 usually is not handled by a blueprint unless it is caused inside a view function. Another special case is the 500 internal server error which is always looked up from the application. Otherwise works as the :meth:`~flask.Flask.errorhandler` decorator of the :class:`~flask.Flask` object. c>fdS)NcF|jjSr=r_register_error_handlerr rPcode_or_exceptionrKrs rrQz;Blueprint.errorhandler..decorator..s#qu'D'D ,a(1(1rrW)rKrrs`rrLz)Blueprint.errorhandler..decorators?   111111 2 2 2Hrr )rrrLs`` rrzBlueprint.errorhandlers*      rc@fddS)a1Non-decorator version of the :meth:`errorhandler` error attach function, akin to the :meth:`~flask.Flask.register_error_handler` application-wide function of the :class:`~flask.Flask` object but for error handlers limited to this blueprint. .. versionadded:: 0.11 cF|jjSr=rrs rrQz2Blueprint.register_error_handler..s#15#@#@ I(!$-$-rNrW)rrrKs```rregister_error_handlerz Blueprint.register_error_handlersG ------ . . . . .r)NNNNNNN)Fr$r=)$r%r&r'r(r5r4rr:r@rBrHrMrr"r_r[rkrjrsrrr|rrrrrrrrrrr rrrrr rrr*r*Os4" 8<7;?C0000 - - - : : :KKKK"BBBB        , , , ,     , , , ,     , , , ,   " . . . . .rr*N) r( functoolsrhelpersrrobjectrr*r rrrs  %$$$$$BBBBBBBB;G;G;G;G;G&;G;G;G|N.N.N.N.N.#N.N.N.N.N.r