B `(@sfdZddlmZmZddlmZddlmZdgZGddde Z Gddde Z Gd d d e Z d S) z Decorators to wrap functions to make them WSGI applications. The main decorator :class:`wsgify` turns a function into a WSGI application (while also allowing normal calling of the method with an instantiated request). )bytes_ text_type)Request) HTTPExceptionwsgifyc@seZdZdZeZdddZddZddd Zd d Z d d Z dddZ ddZ ddZ dddZeddZed ddZddZdS)!raTurns a request-taking, response-returning function into a WSGI app You can use this like:: @wsgify def myfunc(req): return webob.Response('hey there') With that ``myfunc`` will be a WSGI application, callable like ``app_iter = myfunc(environ, start_response)``. You can also call it like normal, e.g., ``resp = myfunc(req)``. (You can also wrap methods, like ``def myfunc(self, req)``.) If you raise exceptions from :mod:`webob.exc` they will be turned into WSGI responses. There are also several parameters you can use to customize the decorator. Most notably, you can use a :class:`webob.Request` subclass, like:: class MyRequest(webob.Request): @property def is_local(self): return self.remote_addr == '127.0.0.1' @wsgify(RequestClass=MyRequest) def myfunc(req): if req.is_local: return Response('hi!') else: raise webob.exc.HTTPForbidden Another customization you can add is to add `args` (positional arguments) or `kwargs` (of course, keyword arguments). While generally not that useful, you can use this to create multiple WSGI apps from one function, like:: import simplejson def serve_json(req, json_obj): return Response(json.dumps(json_obj), content_type='application/json') serve_ob1 = wsgify(serve_json, args=(ob1,)) serve_ob2 = wsgify(serve_json, args=(ob2,)) You can return several things from a function: * A :class:`webob.Response` object (or subclass) * *Any* WSGI application * None, and then ``req.response`` will be used (a pre-instantiated Response object) * A string, which will be written to ``req.response`` and then that response will be used. * Raise an exception from :mod:`webob.exc` Also see :func:`wsgify.middleware` for a way to make middleware. You can also subclass this decorator; the most useful things to do in a subclass would be to change `RequestClass` or override `call_func` (e.g., to add ``req.urlvars`` as keyword arguments to the function). NcCsD||_|dk r||jk r||_t||_|dkr4i}||_||_dS)N)func RequestClasstupleargskwargsmiddleware_wraps)selfrr r r r rrQ/home/kop/projects/devel/pgwui/test_venv/lib/python3.7/site-packages/webob/dec.py__init__Us  zwsgify.__init__cCsd|jjt||jfS)Nz<%s at %s wrapping %r>) __class____name__idr)rrrr__repr__aszwsgify.__repr__cCs(t|jdr ||j||S|SdS)N__get__)hasattrrcloner)robjtyperrrres zwsgify.__get__c OsX|j}|dkr4|s|r&td|jj|}||St|tr2t|dksP|r^td|j|}|d}||}| |_ y&| dd\}}|j |f||}Wn&t k r}z|}Wdd}~XYnX|dkr|j }t|trt||j}t|tr|} |j }|| ||j k r(|j |}|||S| ||\}}|j |f||SdS)z1Call this as a WSGI application or with a requestNz  (     2c@s*eZdZdZddZddZd ddZdS) r8zA `wsgify.middleware` invocation that has not yet wrapped a middleware function; the intermediate object when you do something like ``@wsgify.middleware(RequestClass=Foo)`` cCs||_||_||_dS)N) wrapper_classr;r')rrBr;r'rrrrsz_UnboundMiddleware.__init__cCsd|jjt||jfS)Nz<%s at %s wrapping %r>)rrrr;)rrrrrsz_UnboundMiddleware.__repr__NcCs(|dkr|j}|jj|fd|i|jS)Nr;)r;rBr<r')rrr;rrrr,!sz_UnboundMiddleware.__call__)N)rr=r>r?rrr,rrrrr8sr8c@s*eZdZdZddZddZd ddZdS) r9zRA middleware that has not yet been bound to an application or configured. cCs||_||_||_dS)N)rBr<r')rrBr<r'rrrr+sz_MiddlewareFactory.__init__cCsd|jjt||jfS)Nz<%s at %s wrapping %r>)rrrr<)rrrrr0sz_MiddlewareFactory.__repr__NcKs(|j}|||jj|j|f|S)N)r'copyr6rBr<)rr;configr'rrrr,4s  z_MiddlewareFactory.__call__)N)rr=r>r?rrr,rrrrr9&sr9N) r?Z webob.compatrrZ webob.requestrZ webob.excr__all__objectrr8r9rrrrs