Basic usage of flask-classy

What to do in this article

• Basic usage of flask-classy

Not covered in this article

• How to use flask
• Handling endpoints in flask-classy
• Allocation of multiple routes to one method in flask-classy
• How to handle subdomains in flask-classy

The following articles are not written by using flask-classy on a regular basis, but are written while studying as needed. If you find any mistakes, please submit an edit request or point them out in the comments. Thank you.

What is flask-classy

Flask is a lightweight web framework available in python.

When using flask, usually you create an application using decorators and functions, but when you try to create a large web application across multiple files, use a guy called Blueprint. You need to play with Gonyo Gonyo.

Flask-Classy can introduce a unified method of routing without the hassle of messing around with it.

Official page

https://pythonhosted.org/Flask-Classy/

I will roughly describe it with reference to the above page.

Installation

pip install flask-classy

Minimum usage

1. Create an instance of the Flask class as you normally would use flask
2. Create a class that inherits FlaskView.
3. ** Use the class method `` `register``` of the created class with an instance of Flask class as an argument **
4. Launch the application

from flask import Flask
from flask.ext.classy import FlaskView

app = Flask(__name__)

class HelloView(FlaskView):
    def index(self):
        return "hello world"

HelloView.register(app)

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

If you launch the above file from the command line, you should be able to access `localhost: 5000 / hello``` and see the string `hello world```.

Please note that the process of registering 3 is skipped in the following samples.

Routing and naming conventions

Class naming convention

flaskviewFor class names that inherit from, as suffixviewCan be used.

helloviewThe corresponding url is/hello/It will be.

You can use it, so you don't have to use suffix.

flaskviewInheritedhelloEven if you create a class, the corresponding url is/hello/It will be.

Method naming convention

Although it has appeared in the minimum usage, the following methods in the class that inherits FlaskView have predetermined routing.

In addition to Python's usual naming convention, the following method names are used in FlaskView and should be avoided.

• build_route_name
• build_rule
• decorators
• get_route_base
• make_proxy_method
• parse_options
• register
• route_base
• route_prefix
• trailing_slash

Method names other than the above can be accessed as follows.

There are also some other special method names defined.

life cycle

1. @app.before_request
2. class.before_request
3. class.before_ target method
4. class. Target method
5. class.after_ target method
6. class.after_request
7. @app.after_request

Will be in the order of

Routing override

The URL is determined by the class name and function name, but here are some measures to avoid it.

Override routing from class name

There are two ways

Declare route_base as a class variable

class HelloView(FlaskView):
    route_base='/'

Pass route_base to register as an argument

HelloView.register(app, route_base='/')

Both of the above overwrite / hello, which should be defined from the class name, and make it accessible with `/`.

Override method routing

This is one way

from flask.ext.classy import FlaskView, route

class HelloView(FlaskView):
	@route('/hoge/')
    def index(self):
        return 'hello'

As mentioned above, for the method of the class that inherits FlaskView, use `route``` defined in `flask.ext.classy``` You can overwrite the routing by decorating it.

In the case of the above sample, you can access it if the url is `/ hello / hoge /`.

HTTP method

flask.ext.classsy route can take exactly the same arguments as flask route.

 ** As with normal flask, you can only get GET access just by defining methods and routing. ** **

 If you want to add an http method other than GET, pass a list with the name `` `methods``` in the argument of `` `@ route```.

 For the time being, it seems that any character string can be entered in the list element (verification required), but I think that it is okay but not profitable.
 Let's put in a normal HTTP method.


 Below is a sample.


```python3
from flask.ext.classy import FlaskView, route

class HelloView(FlaskView):
	@route('/index/', methods=['GET','POST'])
    def index(self):
        return 'hello'

As mentioned above, by adding methods, you can access with the corresponding HTTP method.