Can Flask provide CherryPy style routing?

In order to do something like this you'll have to use a bit of python magic, however, it's absolutely possible to do with flask. The most straight-forward way to copy your example would be to subclass flask. This is one way to do it:

import inspectfrom flask import Flaskdef expose(f):    """Decorator that flags a method to be exposed"""    f._exposed_method = True    return fclass FlaskOfCherryPy(Flask):    """Custom flask that allows cherrypy's expose decorator"""    def quickstart(self, root_handler, *args, **kwargs):        self._process_root_handler(root_handler)        self.run(*args, **kwargs)    def _process_root_handler(self, root_handler):        # Prime the recursive processing        root_url = []        self._process_a_handler(root_handler, root_url)    def _process_a_handler(self, current_handler, url_stack):        # This gives a list of all the members of current_handler        members = inspect.getmembers(current_handler)        for name, value in members:            # You probably want to skip things that start with a _ or __            if name.startswith('_'):                continue            # Check if the method is decorated            is_exposed_method = getattr(value, '_exposed_method', False)            # If it's a callable with the _exposed_method attribute set            # Then it's an exposed method            if is_exposed_method and callable(value):                self._add_exposed_url(url_stack, name, value)            else:                new_stack = url_stack[:]                new_stack.append(name)                self._process_a_handler(value, new_stack)    def _add_exposed_url(self, url_stack, name, view_func):        copied_stack = url_stack[:]        if name != 'index':            copied_stack.append(name)        url = "/%s" % "/".join(copied_stack)        if name == 'index':            copied_stack.append(name)        view_name = "_".join(copied_stack)        self.add_url_rule(url, view_name, view_func)class Root(object):    @expose    def index(self):        return 'my app'class Greeting(object):    def __init__(self, name, greeting):        self.name = name        self.greeting = greeting    @expose    def index(self):        return '%s %s!' %(self.greeting, self.name)    @expose    def again(self):        return '%s again, %s!' %(self.greeting, self.name)if __name__ == '__main__':    root = Root()    root.hello = Greeting('Foo', 'Hello')    root.bye = Greeting('Bar', 'Bye')    app = FlaskOfCherryPy(__name__)    app.quickstart(root)

Essentially the trick is grabbing all methods that are tagged with the_exposed_method attribute and passing them to the Flask.add_url_rule(see docs here). The beauty of flask is that it's such a lightweight systemthat it isn't very scary to extend it. I highly suggest diving in yourself andgiving it a shot, but I had fun solving your question so I have the script as agist here.

This particular code I've written isn't perfect and hasn't beenheavily tested, but it definitely works for your particular use case. Also,it's not necessarily how you would want to run the app in production. You'dhave to create some kind of application factory to do it. Again, I highlysuggest looking into the internals of flask to make it do what you want. Youmay also want to look at class-based views or blueprints that flask offers.They're able to some things similarly to how you had them here. Granted, usingthem is very different and setting instance attributes is not something I knowto be possible using vanilla blueprints. Again, you can always extend :-)