There’s several class variables on Request and Response that are intended for customization, and any WSGI extension could potentially be represented with a method on the request.

Another detail that has made some things harder is that I like custom Request/Response subclasses, and I want the decorator to be at least somewhat orthogonal to those classes, so you have to have some way to add parameters to these things.

One thing that I may have over-thought is whether something like .wsgi_app should just be a very straight class method for this case.

from pasteob import *

class PerRequest(object):
    class __metaclass__(type):
        @webob_wrap
        def __call__(cls, req):
            return type.__call__(cls, req)()

    def __init__(self, req):
        self.req = req

#### 

class MyClass(PerRequest):
    def __call__(self):
        return Response('whatever')

print Request.blank('/').get_response(MyClass)

This can’t get any more concise and this wasn’t even a design consideration for webob_wrap.

[Sorry for stalking your webob.dec effort, I hope this feedback is not entirely unwanted.]

class MyClass(object):
    def __init__(self, req):
        self.req = req
    def __call__(self):
        return Response('whatever')
    wsgi_app = wsgify.instantiator()

Then MyClass.wsgi_app is a WSGI application that will instantiate the class for every call. You could then create a web.py-style class like this:

class ByMethod(object):
    def __init__(self, req):
        self.req = req
    def __call__(self):
        method = getattr(self, self.req.method, None)
        if method is None:
            raise exc.HTTPMethodNotAllowed()
        return method()
    wsgi_app = wsgify.instantiator()

class Whatever(ByMethod):
    def GET(self): ...
    def POST(self): ...

Just quickly had a look at the implementation and it seems overly complex to me. I’ve had exception handling in an early version of the “Request.application” decorator in Werkzeug as well and it turned out to be a mistake. It’s easier to write a simple try/except than configuring a decorator to handle some exceptions (like 404 not found).

Right now the full implementation is a two liner and works: Request.application

I think you’re slightly over-engineering your decorator here.