Object Oriented Python with Flask Server?

I know this is a late reply, but I came across this question while facing a similar issue. I found flask-classful really good. You inherit your class from FlaskView and register the Flask app with your MyServer class

http://flask-classful.teracy.org/#

In this case, with flask-classful, your code would look like this:

from flask import Flask
from flask_classful import FlaskView, route

app = Flask(__name__)

class MyServer(FlaskView):
  def __init__(self):
    globalData = json.load(filename)

  @route('/getSomeData')
  def getSomeData():
    return random.choice(globalData) #select some random data to return


MyServer.register(app, base_route="/")


if __name__ == "__main__":
  app.run(host='0.0.0.0')

The least-coupled solution is to apply the routes at runtime (instead of at load time):

def init_app(flask_app, database_interface, filesystem_interface):
    server = MyServer(database_interface, filesystem_interface)
    flask_app.route('get_data', methods=['GET'])(server.get_data)

This is very testable--just invoke init_app() in your test code with the mocked/faked dependencies (database_interface and filesystem_interface) and a flask app that has been configured for testing (app.config["TESTING"]=True or something like that) and you're all-set to write tests that cover your entire application (including the flask routing).

The only downside is this isn't very "Flasky" (or so I've been told); the Flask idiom is to use @app.route(), which is applied at load time and is necessarily tightly coupled because dependencies are hard-coded into the implementation instead of injected into some constructor or factory method (and thus complicated to test).

The following code is a simple solution for OOP with Flask:

from flask import Flask, request


class Server:
    def __init__(self, name):
        self.app = Flask(name)

        @self.app.route('/')
        def __index():
            return self.index()

        @self.app.route('/hello')
        def __hello():
            return self.hello()

        @self.app.route('/user_agent')
        def __user_agent():
            return self.user_agent()

        @self.app.route('/factorial/<n>', methods=['GET'])
        def __factorial(n):
            return self.factorial(n)

    def index(self):
        return 'Index Page'

    def hello(self):
        return 'Hello, World'

    def user_agent(self):
        return request.headers.get('User-Agent')

    def factorial(self, n):
        n = int(n)
        fact = 1
        for num in range(2, n + 1):
            fact = fact * num
        return str(fact)

    def run(self, host, port):
        self.app.run(host=host, port=port)


def main():
    server = Server(__name__)
    server.run(host='0.0.0.0', port=5000)


if __name__ == '__main__':
    main()

To test the code, browse the following urls:

• http://localhost:5000/
• http://localhost:5000/hello
• http://localhost:5000/user_agent
• http://localhost:5000/factorial/10

a bit late but heres a quick implementation that i use to register routes at init time

from flask import Flask,request,render_template
from functools import partial


registered_routes = {}
def register_route(route=None):
    #simple decorator for class based views
    def inner(fn):
        registered_routes[route] = fn
        return fn
    return inner

class MyServer(Flask):
    def __init__(self,*args,**kwargs):
        if not args:
            kwargs.setdefault('import_name',__name__)
        Flask.__init__(self,*args ,**kwargs)
        # register the routes from the decorator
        for route,fn in registered_routes.items():
            partial_fn = partial(fn,self)
            partial_fn.__name__ = fn.__name__
            self.route(route)(partial_fn)


    @register_route("/")
    def index(self):
        return render_template("my_template.html")

if __name__ == "__main__":
    MyServer(template_folder=os.path.dirname(__file__)).run(debug=True)

if you wish to approach MyServer class as a resource
I believe that flask_restful can help you:

from flask import Flask
from flask_restful import Resource, Api
import json
import numpy as np

app = Flask(__name__)
api = Api(app)

class MyServer(Resource):
    def __init__(self):
        self.globalData = json.load(filename)

    def get(self):
        return np.random.choice(self.globalData)

api.add_resource(MyServer, '/')

if __name__ == '__main__':
    app.run()

Here is a simple example that answers with "foo" on http://localhost:5000/, completely contained within a class.

from flask import Flask


class ExampleApp:
    def __init__(self):
        self._app = Flask(__name__)
        self._app.route("/")(self.foo_route)
        self._foo = "foo"

    def run(self):
        self._app.run()

    def foo_route(self):
        return self._foo


if __name__ == "__main__":
    ExampleApp().run()

Instead of using decorators, you call the decorator-function (app.route) with the method you'd like it to use to generate a response.

_foo is used as an example to show that foo_route can indeed access class members.