The default CherryPy routing style is based on instances of classes with methods decorated by @cherrypy.expose.
In the example below, these urls are provided by simple tweaking on otherwise ordinary classes.
/
/hello
/hello/again
/bye
/bye/again
I wonder if there is a way to achieve this using Flask's @route or some other decorator.
import cherrypy
class Root(object):
@cherrypy.expose
def index(self):
return 'my app'
class Greeting(object):
def __init__(self, name, greeting):
self.name = name
self.greeting = greeting
@cherrypy.expose
def index(self):
return '%s %s!' %(self.greeting, self.name)
@cherrypy.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')
cherrypy.quickstart(root)
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 inspect
from flask import Flask
def expose(f):
"""Decorator that flags a method to be exposed"""
f._exposed_method = True
return f
class 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 system
that it isn't very scary to extend it. I highly suggest diving in yourself and
giving it a shot, but I had fun solving your question so I have the script as a
gist here.
This particular code I've written isn't perfect and hasn't been heavily 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'd have to create some kind of application factory to do it. Again, I highly suggest looking into the internals of flask to make it do what you want. You may 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, using them is very different and setting instance attributes is not something I know to be possible using vanilla blueprints. Again, you can always extend :-)