`Tc@sdZddlZddlZddlmZddlmZddlmZddl m Z ddl m Z ddl mZmZmZmZdd lmZmZmZmZd d lmZmZmZmZmZmZd d lmZd d l m!Z!m"Z"d dl#m$Z$m%Z%d dl&m'Z'm(Z(m)Z)d dl*m+Z+m,Z,m-Z-m.Z.d dl/m0Z0d dl1m2Z2d dl3m4Z4m5Z5m6Z6d dl7m8Z8m9Z9m:Z:m;Z;m<Z<d dl=m>Z>m?Z?m@Z@mAZAeZBdZCdZDdefdYZEdS(s flask.app ~~~~~~~~~ This module implements the central WSGI application object. :copyright: (c) 2011 by Armin Ronacher. :license: BSD, see LICENSE for more details. iN(tLock(t timedelta(tchain(tupdate_wrapper(t ImmutableDict(tMaptRuletRequestRedirectt BuildError(t HTTPExceptiontInternalServerErrortMethodNotAllowedt BadRequesti(t_PackageBoundObjectturl_fortget_flashed_messagestlocked_cached_propertyt_endpoint_from_view_funct find_package(tjson(tRequesttResponse(tConfigAttributetConfig(tRequestContextt AppContextt_AppCtxGlobals(t_request_ctx_stacktrequesttsessiontg(tSecureCookieSessionInterface(tblueprint_is_module(tDispatchingJinjaLoadert Environmentt_default_template_ctx_processor(trequest_startedtrequest_finishedtgot_request_exceptiontrequest_tearing_downtappcontext_tearing_down(treraiset string_typest text_typet integer_typescCs t|tstd|S|S(Ntseconds(t isinstanceR(tvalue((sO/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/flask/app.pyt_make_timedelta+s csfd}t|S(skWraps a method so that it performs a check in debug mode if the first request was already handled. cs1|jr!|jr!tdn|||S(NsmA setup function was called after the first request was handled. This usually indicates a bug in the application where a module was not imported and decorators or other functionality was called too late. To fix this make sure to import all your view modules, database models and everything related at a central place before the application starts serving requests.(tdebugt_got_first_requesttAssertionError(tselftargstkwargs(tf(sO/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/flask/app.pyt wrapper_func5s(R(R7R8((R7sO/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/flask/app.pyt setupmethod1s tFlaskcBs eZdZeZeZeZdZ dZ e e e Z [ [ e dZe dZe dZe dZe ddeZe d Ze d ZeZd d d ddd d ZejZejZedddgZeie d6e d6drd6drd6drd6e"ddd6e d 6drd 6drd6drd6dd6drd6drd6ed6e d6drd6dtd!6e d"6e d#6d$d%6ed&6ed'6ed(6Z#e$Z%drZ&e'Z(drdrd)d*dre d+Z)d,Z*d-Z+e e*e+Z,[*[+e-d.Z.e d/Z/e d0Z0e d1Z1e-d2Z2e d3Z3e d4Z4d5Z5d6d7Z6d8Z7d9Z8d:Z9d;Z:d<Z;drdrdrd=Z<ed>Z=d?Z>d@Z?dAZ@dBZAeBdCZCeBdrdrdDZDdEZEeBdFZFeBdGZGdHZHeBdIZIeBdrdJZJeBdrdKZKeBdrdLZLeBdrdMZMeBdrdNZNeBdrdOZOeBdPZPeBdQZQeBdRZReBdSZSeBdTZTeBdUZUeBdVZVeBdWZWdXZXdYZYdZZZd[Z[d\Z\d]Z]d^Z^d_Z_d`Z`daZadbZbdcZcddZddeZedfZfdgZgdhZhdrdiZidrdjZjdkZkdlZldmZmdnZne doZodpZpdqZqRS(usThe flask object implements a WSGI application and acts as the central object. It is passed the name of the module or package of the application. Once it is created it will act as a central registry for the view functions, the URL rules, template configuration and much more. The name of the package is used to resolve resources from inside the package or the folder the module is contained in depending on if the package parameter resolves to an actual python package (a folder with an `__init__.py` file inside) or a standard module (just a `.py` file). For more information about resource loading, see :func:`open_resource`. Usually you create a :class:`Flask` instance in your main module or in the `__init__.py` file of your package like this:: from flask import Flask app = Flask(__name__) .. admonition:: About the First Parameter The idea of the first parameter is to give Flask an idea what belongs to your application. This name is used to find resources on the file system, can be used by extensions to improve debugging information and a lot more. So it's important what you provide there. If you are using a single module, `__name__` is always the correct value. If you however are using a package, it's usually recommended to hardcode the name of your package there. For example if your application is defined in `yourapplication/app.py` you should create it with one of the two versions below:: app = Flask('yourapplication') app = Flask(__name__.split('.')[0]) Why is that? The application will work even with `__name__`, thanks to how resources are looked up. However it will make debugging more painful. Certain extensions can make assumptions based on the import name of your application. For example the Flask-SQLAlchemy extension will look for the code in your application that triggered an SQL query in debug mode. If the import name is not properly set up, that debugging information is lost. (For example it would only pick up SQL queries in `yourapplication.app` and not `yourapplication.views.frontend`) .. versionadded:: 0.7 The `static_url_path`, `static_folder`, and `template_folder` parameters were added. .. versionadded:: 0.8 The `instance_path` and `instance_relative_config` parameters were added. :param import_name: the name of the application package :param static_url_path: can be used to specify a different path for the static files on the web. Defaults to the name of the `static_folder` folder. :param static_folder: the folder with static files that should be served at `static_url_path`. Defaults to the ``'static'`` folder in the root path of the application. :param template_folder: the folder that contains the templates that should be used by the application. Defaults to ``'templates'`` folder in the root path of the application. :param instance_path: An alternative instance path for the application. By default the folder ``'instance'`` next to the package or module is assumed to be the instance path. :param instance_relative_config: if set to `True` relative filenames for loading the config are assumed to be relative to the instance path instead of the application root. cCs|jS(N(tapp_ctx_globals_class(R4((sO/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/flask/app.pyt_get_request_globals_classscCs-ddlm}|td||_dS(Ni(twarnsCrequest_globals_class attribute is now called app_ctx_globals_class(twarningsR=tDeprecationWarningR;(R4R/R=((sO/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/flask/app.pyt_set_request_globals_classstDEBUGtTESTINGt SECRET_KEYtSESSION_COOKIE_NAMEtPERMANENT_SESSION_LIFETIMEt get_convertertUSE_X_SENDFILEt LOGGER_NAMEt-iPs s7%(levelname)s in %(module)s [%(pathname)s:%(lineno)d]: s %(message)s t extensionssjinja2.ext.autoescapesjinja2.ext.with_tPROPAGATE_EXCEPTIONStPRESERVE_CONTEXT_ON_EXCEPTIONtdaysit SERVER_NAMEtAPPLICATION_ROOTRtSESSION_COOKIE_DOMAINtSESSION_COOKIE_PATHtSESSION_COOKIE_HTTPONLYtSESSION_COOKIE_SECUREtMAX_CONTENT_LENGTHi i<tSEND_FILE_MAX_AGE_DEFAULTtTRAP_BAD_REQUEST_ERRORStTRAP_HTTP_EXCEPTIONSthttptPREFERRED_URL_SCHEMEt JSON_AS_ASCIItJSON_SORT_KEYStJSONIFY_PRETTYPRINT_REGULARtstatict templatesc Cstj||d||dk rQddlm}|tddd|}n|dk ri||_n|dk r||_n|dkr|j}n!t j j |st dn||_ |j||_d|_|j|_i|_i|_i|jd6|_g|_i|_g|_i|_i|_g|_i|_i|_itgd6|_i|_ i|_!t"|_#t$|_%t&|_'|j(r|j)|jdd d d |j*ndS( Nttemplate_folderi(R=s)static_path is now called static_url_patht stacklevelisXIf an instance path is provided it must be absolute. A relative path was given instead.s/tendpointR]t view_func(+R t__init__tNoneR>R=R?tstatic_url_patht static_foldertauto_find_instance_pathtostpathtisabst ValueErrort instance_patht make_configtconfigt_loggert import_namet logger_nametview_functionst_error_handlersterror_handler_specturl_build_error_handlerstbefore_request_funcstbefore_first_request_funcstafter_request_funcstteardown_request_funcstteardown_appcontext_funcsturl_value_preprocessorsturl_default_functionsR#ttemplate_context_processorst blueprintsRJRturl_maptFalseR2Rt_before_request_lockthas_static_foldert add_url_ruletsend_static_file( R4Rpt static_pathReRfR_Rltinstance_relative_configR=((sO/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/flask/app.pyRc;sR                       cCs-ddlm}|tddd|jS(Ni(R=sOerror_handlers is deprecated, use the new error_handler_spec attribute instead.R`i(R>R=R?Rs(R4R=((sO/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/flask/app.pyt_get_error_handlersscCs||_||jd|j}|dkr(ddlm}n|||jd|S(sCreates a test client for this application. For information about unit testing head over to :ref:`testing`. Note that if you are testing for assertions or exceptions in your application code, you must set ``app.testing = True`` in order for the exceptions to propagate to the test client. Otherwise, the exception will be handled by the application (not visible to the test client) and the only indication of an AssertionError or other exception will be a 500 status code response to the test client. See the :attr:`testing` attribute. For example:: app.testing = True client = app.test_client() The test client can be used in a `with` block to defer the closing down of the context until the end of the `with` block. This is useful if you want to access the context locals for testing:: with app.test_client() as c: rv = c.get('/?vodka=42') assert request.args['vodka'] == '42' See :class:`~flask.testing.FlaskClient` for more information. .. versionchanged:: 0.4 added support for `with` block usage for the client. .. versionadded:: 0.7 The `use_cookies` parameter was added as well as the ability to override the client to be used by setting the :attr:`test_client_class` attribute. i(t FlaskClientt use_cookiesN(ttest_client_classRdt flask.testingRtresponse_class(R4Rtcls((sO/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/flask/app.pyt test_client s!  cCs|jj||S(sPCreates or opens a new session. Default implementation stores all session data in a signed cookie. This requires that the :attr:`secret_key` is set. Instead of overriding this method we recommend replacing the :class:`session_interface`. :param request: an instance of :attr:`request_class`. (tsession_interfacet open_session(R4R((sO/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/flask/app.pyR1scCs|jj|||S(sSaves the session if it needs updates. For the default implementation, check :meth:`open_session`. Instead of overriding this method we recommend replacing the :class:`session_interface`. :param session: the session to be saved (a :class:`~werkzeug.contrib.securecookie.SecureCookie` object) :param response: an instance of :attr:`response_class` (Rt save_session(R4Rtresponse((sO/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/flask/app.pyR;s cCs|jj|S(sCreates a new instance of a missing session. Instead of overriding this method we recommend replacing the :class:`session_interface`. .. versionadded:: 0.7 (Rtmake_null_session(R4((sO/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/flask/app.pyRGscKsrt|std|js4td|n*ddlm}|td|dd|j||dS( snRegisters a module with this application. The keyword argument of this function are the same as the ones for the constructor of the :class:`Module` class and will override the values of the module if provided. .. versionchanged:: 0.7 The module system was deprecated in favor for the blueprint system. sUregister_module requires actual module objects. Please upgrade to blueprints though.sLModule support was disabled but code attempted to register a module named %ri(R=sModules are deprecated. Upgrade to using blueprints. Have a look into the documentation for more information. If this module was registered by a Flask-Extension upgrade the extension or contact the author of that extension instead. (Registered %r)R`iN(R R3tenable_modulest RuntimeErrorR>R=R?tregister_blueprint(R4tmoduleRR=((sO/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/flask/app.pytregister_moduleOs     cKst}|j|jkrW|j|j|ksmtd||j|j|jfn||j|jRegisters a function to be called when the application context ends. These functions are typically also called when the request context is popped. Example:: ctx = app.app_context() ctx.push() ... ctx.pop() When ``ctx.pop()`` is executed in the above example, the teardown functions are called just before the app context moves from the stack of active contexts. This becomes relevant if you are using such constructs in tests. Since a request context typically also manages an application context it would also be called when you pop a request context. When a teardown function was called because of an exception it will be passed an error object. .. versionadded:: 0.9 (RzR(R4R7((sO/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/flask/app.pytteardown_appcontextscCs|jdj||S(s0Registers a template context processor function.N(R}RdR(R4R7((sO/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/flask/app.pytcontext_processorscCs |jjdgj||S(sRegisters a function as URL value preprocessor for all view functions of the application. It's called before the view functions are called and can modify the url values provided. N(R{RRdR(R4R7((sO/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/flask/app.pyturl_value_preprocessorscCs |jjdgj||S(sCallback 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. N(R|RRdR(R4R7((sO/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/flask/app.pyt url_defaultsscCs|jjtj}|jdkr(|S|rM|j|krM||j}n|jdj|j}|dkrv|S||S(sHandles an HTTP exception. By default this will invoke the registered error handlers and fall back to returning the exception as response. .. versionadded:: 0.3 N(RtRRRRRd(R4tethandlersthandler((sO/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/flask/app.pythandle_http_exception s cCs/|jdrtS|jdr+t|tStS(sChecks if an HTTP exception should be trapped or not. By default this will return `False` for all exceptions except for a bad request key error if ``TRAP_BAD_REQUEST_ERRORS`` is set to `True`. It also returns `True` if ``TRAP_HTTP_EXCEPTIONS`` is set to `True`. This is called for all HTTP exceptions raised by a view function. If it returns `True` for any exception the error handler for this exception is not called and it shows up as regular exception in the traceback. This is helpful for debugging implicitly raised HTTP exceptions. .. versionadded:: 0.8 RWRV(RnRR.R R(R4R ((sO/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/flask/app.pyttrap_http_exception4s    c Cstj\}}}||ks'tt|trS|j| rS|j|Sd}|jjt j }|dk r|jdd}n|jdjdd}x6t ||D]%\}} t||r| |SqWt |||dS(sThis method is called whenever an exception occurs that should be handled. A special case are :class:`~werkzeug.exception.HTTPException`\s which are forwarded by this function to the :meth:`handle_http_exception` method. This function will either return a response value or reraise the exception with the same traceback. .. versionadded:: 0.7 N((((Rtexc_infoR3R.R R R RtRRRRdRR)( R4R texc_typet exc_valuettbtblueprint_handlersR t app_handlerst typecheckR ((sO/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/flask/app.pythandle_user_exceptionHs   cCstj\}}}tj|d||jdjd}|jro||krft|||qo|n|j |||f|dkrt S||S(sDefault exception handling that kicks in when an exception occurs that is not caught. In debug mode the exception will be re-raised immediately, otherwise it is logged and the handler for a 500 internal server error is used. If no such handler exists, a default 500 internal server error message is displayed. .. versionadded:: 0.3 t exceptioniN( RRR&tsendRtRdRRR)t log_exceptionR (R4R RRRR ((sO/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/flask/app.pythandle_exceptiongs     cCs*|jjdtjtjfd|dS(s Logs an exception. This is called by :meth:`handle_exception` if debugging is disabled and right before the handler is called. The default implementation logs the exception as error on the :attr:`logger`. .. versionadded:: 0.8 sException on %s [%s]RN(RterrorRRitmethod(R4R((sO/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/flask/app.pyRs  cCsX|j s,t|jt s,|jdkr8|jnddlm}||dS(s.Exceptions that are recording during routing are reraised with this method. During debug we are not reraising redirect requests for non ``GET``, ``HEAD``, or ``OPTIONS`` requests and we're raising a different error instead to help debug situations. :internal: RtHEADRi(tFormDataRoutingRedirectN(sGETRsOPTIONS(R1R.trouting_exceptionRRt debughelpersR(R4RR((sO/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/flask/app.pytraise_routing_exceptions   cCsvtjj}|jdk r+|j|n|j}t|dtr_|j dkr_|j S|j |j |j S(sDoes the request dispatching. Matches the URL and returns the return value of the view or error handler. This does not have to be a response object. In order to convert the return value to a proper response object, call :func:`make_response`. .. versionchanged:: 0.7 This no longer does the exception handling, this code was moved to the new :meth:`full_dispatch_request`. RRN(RRRRRdR turl_ruleRRRtmake_default_options_responseRrRat view_args(R4treqR((sO/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/flask/app.pytdispatch_requests   cCs|jy8tj||j}|dkrA|j}nWn"tk rf}|j|}nX|j|}|j |}t j|d||S(sDispatches the request and on top of that performs request pre and postprocessing as well as HTTP exception catching and error handling. .. versionadded:: 0.7 RN( t*try_trigger_before_first_request_functionsR$Rtpreprocess_requestRdR%t ExceptionRt make_responsetprocess_responseR%(R4RR R((sO/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/flask/app.pytfull_dispatch_requests    cCsR|jr dS|j6|jr$dSt|_x|jD] }|q7WWdQXdS(sCalled before each request and will ensure that it triggers the :attr:`before_first_request_funcs` and only exactly once per application instance (which means process usually). :internal: N(R2RRRw(R4R((sO/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/flask/app.pyR&s    cCstjj}t|dr*|j}nKg}y|jddWn.tk rb}|j}ntk rt}nX|j }|j j ||S(sThis method is called to create the default `OPTIONS` response. This can be changed through subclassing to change the default behavior of `OPTIONS` responses. .. versionadded:: 0.7 tallowed_methodsRs--( RRt url_adapterthasattrR,tmatchR t valid_methodsR RtallowR(R4tadapterRR R((sO/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/flask/app.pyR"s   cCstS(sThis is called to figure out if an error should be ignored or not as far as the teardown system is concerned. If this function returns `True` then the teardown handlers will not be passed the error. .. versionadded:: 0.10 (R(R4R((sO/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/flask/app.pytshould_ignore_errorscCsd}}t|tr=|ddt|\}}}n|dkrXtdnt||jst|tttfr|j|d|d|}d}}q|jj |t j }n|dk rt|t r||_ q||_n|r|jj|n|S(srConverts the return value from a view function to a real response object that is an instance of :attr:`response_class`. The following types are allowed for `rv`: .. tabularcolumns:: |p{3.5cm}|p{9.5cm}| ======================= =========================================== :attr:`response_class` the object is returned unchanged :class:`str` a response object is created with the string as body :class:`unicode` a response object is created with the string encoded to utf-8 as body a WSGI function the function is called as WSGI application and buffered as response object :class:`tuple` A tuple in the form ``(response, status, headers)`` where `response` is any of the types defined here, `status` is a string or an integer and `headers` is a list of a dictionary with header values. ======================= =========================================== :param rv: the return value from the view function .. versionchanged:: 0.9 Previously a tuple was interpreted as the arguments for the response object. is'View function did not return a responsetheaderststatusN(N(RdR.ttupletlenRkRR+tbytest bytearrayt force_typeRtenvironR*R5t status_codeR4textend(R4RR5R4((sO/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/flask/app.pyR)s" $     cCsz|dk r,|jj|jd|jdS|jddk rv|jj|jdd|jdpedd|jdSdS( sCreates a URL adapter for the given request. The URL adapter is created at a point where the request context is not yet set up so the request is passed explicitly. .. versionadded:: 0.6 .. versionchanged:: 0.9 This can now also be called without a request object when the URL adapter is created for the application context. RRNt script_nameROt/t url_schemeRYN(RdRtbind_to_environR;Rntbind(R4R((sO/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/flask/app.pytcreate_url_adapter5s   cCsz|jjdd}d|krX|jddd}t||jj|d}nx|D]}|||q_WdS(sInjects the URL defaults for the given endpoint directly into the values dictionary passed. This is used internally and automatically called on URL building. .. versionadded:: 0.7 t.iiN(((R|RRdRR(R4RatvaluesRRR((sO/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/flask/app.pytinject_url_defaultsKs  ! c Cstj\}}}xM|jD]B}y&||||}|dk rJ|SWqtk r`}qXqW||krt|||n|dS(sIHandle :class:`~werkzeug.routing.BuildError` on :meth:`url_for`. N(RRRuRdRR)( R4RRaRERRRR R((sO/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/flask/app.pythandle_url_build_errorYs  cCstjjj}|jjdd}|dk rX||jkrXt||j|}nx!|D]}|tjtj q_W|j jdd}|dk r||j krt||j |}nx'|D]}|}|dk r|SqWdS(sCalled before the actual request dispatching and will call every as :meth:`before_request` decorated function. If any of these function returns a value it's handled as if it was the return value from the view and further request handling is stopped. This also triggers the :meth:`url_value_processor` functions before the actual :meth:`before_request` functions are called. N((( RRRRR{RRdRRaR#Rv(R4RRRR((sO/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/flask/app.pyR'ls     cCstj}|jj}|j}|dk rX||jkrXt|t|j|}nd|jkrt|t|jd}nx|D]}||}qW|j j |j s|j |j |n|S(sCan be overridden in order to modify the response object before it's sent to the WSGI server. By default this will call all the :meth:`after_request` decorated functions. .. versionchanged:: 0.5 As of Flask 0.5 the functions registered for after request execution are called in reverse order of registration. :param response: a :attr:`response_class` object. :return: a new response object or the same, has to be an instance of :attr:`response_class`. N( RRRRt_after_request_functionsRdRxRtreversedRtis_null_sessionRR(R4RtctxRRR ((sO/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/flask/app.pyR*s    cCs|dkrtjd}nt|jjdd}tjjj }|dk r||jkrt |t|j|}nx|D]}||}qWt j |d|dS(sCalled after the actual request dispatching and will call every as :meth:`teardown_request` decorated function. This is not actually called by the :class:`Flask` object itself but is always triggered when the request context is popped. That way we have a tighter control over certain resources under testing environments. .. versionchanged:: 0.9 Added the `exc` argument. Previously this was always using the current exception information. itexcN(( RdRRRIRyRRRRRRR'R(R4RLRRRR((sO/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/flask/app.pytdo_teardown_requests  cCsZ|dkrtjd}nx!t|jD]}||q/Wtj|d|dS(sCalled when an application context is popped. This works pretty much the same as :meth:`do_teardown_request` but for the application context. .. versionadded:: 0.9 iRLN(RdRRRIRzR(R(R4RLR((sO/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/flask/app.pytdo_teardown_appcontexts  cCs t|S(sBinds the application only. For as long as the application is bound to the current context the :data:`flask.current_app` points to that application. An application context is automatically created when a request context is pushed if necessary. Example usage:: with app.app_context(): ... .. versionadded:: 0.9 (R(R4((sO/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/flask/app.pyt app_contexts cCs t||S(sCreates a :class:`~flask.ctx.RequestContext` from the given environment and binds it to the current context. This must be used in combination with the `with` statement because the request is only bound to the current context for the duration of the `with` block. Example usage:: with app.request_context(environ): do_something_with(request) The object returned can also be used without the `with` statement which is useful for working in the shell. The example above is doing exactly the same as this code:: ctx = app.request_context(environ) ctx.push() try: do_something_with(request) finally: ctx.pop() .. versionchanged:: 0.3 Added support for non-with statement usage and `with` statement is now passed the ctx object. :param environ: a WSGI environment (R(R4R;((sO/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/flask/app.pytrequest_contextscOsKddlm}||||}z|j|jSWd|jXdS(sCreates a WSGI environment from the given values (see :func:`werkzeug.test.EnvironBuilder` for more information, this function accepts the same arguments). i(tmake_test_environ_builderN(RRQRPt get_environtclose(R4R5R6RQtbuilder((sO/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/flask/app.pyttest_request_contexts cCs|j|}|jd}zUy|j}Wn1tk re}|}|j|j|}nX|||SWd|j|rd}n|j|XdS(sThe actual WSGI application. This is not implemented in `__call__` so that middlewares can be applied without losing a reference to the class. So instead of doing this:: app = MyMiddleware(app) It's a better idea to do this instead:: app.wsgi_app = MyMiddleware(app.wsgi_app) Then you still have the original application object around and can continue to call methods on it. .. versionchanged:: 0.7 The behavior of the before and after request callbacks was changed under error conditions and a new callback was added that will always execute at the end of the request, independent on if an error occurred or not. See :ref:`callbacks-and-errors`. :param environ: a WSGI environment :param start_response: a callable accepting a status code, a list of headers and an optional exception context to start the response N( RPtpushRdR+R(R)RR3tauto_pop(R4R;tstart_responseRKRRR ((sO/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/flask/app.pytwsgi_apps  cCs-ddlm}|tddd|jS(Ni(R=s9Flask.modules is deprecated, use Flask.blueprints insteadR`i(R>R=R?R~(R4R=((sO/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/flask/app.pyR#scCs|j||S(sShortcut for :attr:`wsgi_app`.(RY(R4R;RX((sO/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/flask/app.pyt__call__*scCsd|jj|jfS(Ns<%s %r>(t __class__RR(R4((sO/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/flask/app.pyt__repr__.s Nii(rRt __module__t__doc__Rt request_classRRRR;R<R@tpropertytrequest_globals_classRR1Rt secret_keytsession_cookie_nameR0tpermanent_session_lifetimetuse_x_sendfileRqRRtdebug_log_formatRt JSONEncodert json_encodert JSONDecodert json_decoderRRRRdRRRRRRRRcRRterror_handlersRRRRRRRRmRgRRRRRRRRRRRRR9RRRRaRRRRRRRRRRRRRRRRRR R RRRR R%R+R&R"R3R)RCRFRGR'R*RMRNRORPRURYRRZR\(((sO/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/flask/app.pyR:BsJ                     9 &  _ *       %           9         ( (FR^RhRt threadingRtdatetimeRt itertoolsRt functoolsRtwerkzeug.datastructuresRtwerkzeug.routingRRRRtwerkzeug.exceptionsR R R R thelpersR RRRRRtRtwrappersRRRnRRRKRRRRRRRRtsessionsRRR t templatingR!R"R#tsignalsR$R%R&R'R(t_compatR)R*R+R,RR0R9R:(((sO/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/flask/app.pyt s0  ""."("