Understand the Flask project structure

Preface

First, we isolate my project using virtualenv. For example, we want to develop a polling application (a poll app).

mkdir poll_app
cd poll_app
virtualenv .
source bin/activate

Commonly used Python libraries

I am developing an application that requires a database. Therefore, I always use flask_script and flask_migrate libraries. I don't like Flask's CLI tooling.

Flask-Script: https://flask-script.readthedocs.io/en/latest/

Flask-Migrate: https://flask-migrate.readthedocs.io/en/latest/

Similarly to Django, I created a file called manage. py Python file, for example:

from MYAPP.data.models import db
from MYAPP import app
from flask_script import Manager
from flask_migrate import Migrate, MigrateCommand
db.init_app(app)
migrate = Migrate(app, db)
manager = Manager(app)
manager.add_command('db', MigrateCommand)
if __name__ == "__main__":
    manager.run()

Then, we can perform the following operations on the data:

python manage.py db init # --> init migrations
python manage.py db migrate # --> migrate models
python manage.py db upgrade # --> apply changes
python manage.py db --help # --> :)

Main application file

Create a new project , I create a file app.py in the root folder and then it changes like this.

from MYAPP import app
# To do: This place will change later
config = {
    "development": "config.Development"
}
if __name__ == "__main__":
    app.config.from_object(config["development"])
    app.run()

Configuration File

I also created a configuration file called config.py in the root folder.

class BaseConfig(object):
    """ Base config class. This fields will use by production and development server """
    ORIGINS = ["*"] # for api calls
    SECRET_KEY = 'YOUR SECRET KEY'
class Development(BaseConfig):
    """ Development config. We use Debug mode """
    PORT = 5000
    DEBUG = True
    TESTING = False
    ENV = 'dev'
# Currently we only have development config.
# If you have production, you will need to pass it to here.
config = {
    'development': 'config.Development'
}
def configure_app(app):
    """ 
        App configuration will be here. 
        Parameters
        ----------
        app : Flask
            app instance
    """
    app.config.from_object(config['development'])

Folder structure

I create a folder in the root directory and name it om_core, and then create two new folders in Qi api and data..

api files store application logic and routing. For example, I created a folder called user in the api.

Generate two files named init.py and controllers.py in the user folder, as will our other API layers. controllers.py (controller file) should look like this:

from flask import Blueprint, jsonify, request
from MYAPP.data.models import db, User
user = Blueprint('user', __name__)
@user.route('/', methods=['GET'])
def get_users():
    return jsonify({ "message": "Hi user :)"})
@user.route(&#39;/<int:id>&#39;, methods=[&#39;GET&#39;])
def users(id):
    return jsonify({ "id": id })

I always use blueprints.

The data folder stores some models. For example, I created a file called models.py:

from flask_sqlalchemy import SQLAlchemy
from MYAPP import app
# We didn't pass app instance here.
db = SQLAlchemy()
class User(db.Model):
    """ Model for user management """
    id = db.Column(db.Integer, primary_key=True)
    email = db.Column(db.String(100), unique=True)
    password = db.Column(db.String(100))
    name = db.Column(db.String(100))
    surname = db.Column(db.String(100))
    active = db.Column(db.Boolean(), default=True)
    created_at = db.Column(db.DateTime, default=db.func.now())
    updated_at = db.Column(db.DateTime, default=db.func.now())
    def __init__(self, email, password, name, surname, active, created_at, updated_at):
        self.email = email
        self.password = password
        self.name = name
        self.surname = surname
        self.active = active
        self.created_at = created_at
        self.updated_at = updated_at

Let’s go back to the om_core folder. I created a file called init .py to use the Api layer as an endpoint.

from flask import Flask
from flask_cors import CORS
from config import BaseConfig
from config import configure_app
app = Flask(__name__)
from MYAPP.api.user.controllers import user
""" Corst settings will be here. We maybe use this endpoint later. """
cors = CORS(app, resources={
    r'/api/*': {
        'origins': BaseConfig.ORIGINS
    }
})
configure_app(app)
app.url_map.strict_slashes = False
app.register_blueprint(user, url_prefix='/api/users')

In the above code, I have used Flask-CORS to allow requests from different origins. This is not required if you do not want to allow requests from different origins.

Screenshots of the overall project structure

The screenshots are as follows:

Recommended tutorial: "Python Tutorial"

The above is the detailed content of Understand the Flask project structure. For more information, please follow other related articles on the PHP Chinese website!