Comprendre la structure du projet Flask

Préface

Tout d'abord, nous isolons mon projet à l'aide de virtualenv. Par exemple, nous souhaitons développer une application de sondage (a poll app).

mkdir poll_app
cd poll_app
virtualenv .
source bin/activate

Bibliothèques Python couramment utilisées

Je développe une application qui nécessite une base de données. Par conséquent, j'utilise toujours les bibliothèques flask_script et flask_migrate. Je n'aime pas les outils CLI de Flask.

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

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

De même avec Django, j'ai créé un fichier appelé gérer dans le dossier racine py Python. , par exemple :

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()

Ensuite, on peut effectuer les opérations suivantes sur les données :

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 # --> :)

Fichier d'application principal

Créer un nouveau projet, Je crée un fichier app.py dans le dossier racine puis il change comme ceci.

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()

Fichier de configuration

J'ai également créé un fichier de configuration appelé config.py dans le dossier racine.

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'])

Structure des dossiers

Je crée un dossier dans le répertoire racine et le nomme om_core, puis je crée deux nouveaux dossiers dans l'API Qi et les données.

Les fichiers API stockent la logique et le routage des applications. Par exemple, j'ai créé un dossier appelé user dans l'API.

Générez deux fichiers nommés init.py et contrôleurs.py dans le dossier utilisateur, tout comme nos autres couches API. controllers.py (fichier de contrôleur) devrait ressembler à ceci :

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 })

J'utilise toujours des plans.

le dossier de données stocke certains modèles. Par exemple, j'ai créé un fichier appelé 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

Retournons dans le dossier om_core. J'ai créé un fichier appelé init .py pour utiliser la couche API comme point de terminaison.

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')

Dans le code ci-dessus, j'ai utilisé Flask-CORS pour autoriser les requêtes provenant de différentes origines. Ceci n’est pas obligatoire si vous ne souhaitez pas autoriser les demandes provenant de différentes origines.

Captures d'écran de la structure globale du projet

Les captures d'écran sont les suivantes :

Tutoriel recommandé : "Tutoriel Python"

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!