Create bottle.py module decorator, to ease subclassing

Currently in bottle, the @route decorator is a Bottle instance attribute, making it harder to subclass, as following code will not work, as not syntaxically correct:

import bottle

class App(bottle.Bottle):
    @self.route('/there')   # <--- wrong syntax!
    def some_func(self): pass

So, considering some different options, and trying not to go down the bottleCBV route that seems quite weird to me, I setup a workaround in a personal project (see here), which sums up as follows:

import inspect
import bottle

def route(path: str, method: str = 'GET')
    """Decorate a method, to track it for later routing."""
    def wrapper(func):
        func.route = (path, method)
        return func
   return wrapper

class BottleApp(bottle.Bottle):
    """A parent class, taking care of setting-up the routing."""
    def __init__(*args, **kwargs):
        super().__init__(*args, **kwargs)
        self.set_routes()

    def set_routes(self):
        for meth in inspect(self, predicate=inspect.ismethod):
            if hasattr(meth, 'route'):
               # and now the magic happens
               self.route(path=meth.route.path, method=meth.route.method, callback=meth)

With just this, we can now subclass in a lean way:

class MyApp(BottleApp):
    """A class, that can be run by a WSGI server, that can bear its own attributes."""
    @route(path='/users')
    def users(self):
        return self.whatever

I’d be happy to propose a Pull Request to integrate this, what do you think about this?

Some comments and thoughts:

• The @route module decorator may use different attribute names, and could also consider a list of acceptable methods. Hooks shall also be considered, I’ve worked around this already;
• I would put set_routes method to bottle.Bottle class directly.

[defnull]

There are some attempts to implement such a base class (or other ways to create bottle apps) around, if you look for them. The reusability-pattern I have seen the most is to just create the application within a function:

def create_app(**settings):
    app = bottle.Bottle()
    ...
    return app

A base-class could add a lot of metaclass-magic to the mix, for example, inject specialized decorators to be used at declatarion-time or make sure the final class is callable. But I’m not sure if that really helps. Explicit is better than implicit, after all.

[josephernest]

@defnull, what would be a simple and recommended way to create a class for an application? (which builds the Bottle object and starts it)
Here is an old question about this: Bottle framework and OOP, using method instead of function, I would be interested about the “canonical way”, blessed by the creator of the library 😃

I was thinking about something like:

import bottle

class App:
    def __init__(self, port=80):
        self.app = bottle.Bottle()
        self.port = port

    def setup_routes(self):
        @self.app.route("/foo")
        def foo():
            return("foo")

        @self.app.route("/bar")
        def bar():
            return("bar")

    def start(self):
        self.app.run(port=self.port)

a = App()
a.setup_routes()
a.start()

PS: I noted the fact that it’s not a good idea to subclass bottle.Bottle (in your previous comment).