Verstehen Sie die Flask-Projektstruktur

Vorwort

Zuerst isolieren wir mein Projekt mit Virtualenv. Wir wollen zum Beispiel eine Umfrageanwendung (eine Umfrage-App) entwickeln.

mkdir poll_app
cd poll_app
virtualenv .
source bin/activate

Häufig verwendete Python-Bibliotheken

Ich entwickle eine Anwendung, die eine Datenbank erfordert. Daher verwende ich immer die Bibliotheken flask_script und flask_migrate. Mir gefallen die CLI-Tools von Flask nicht.

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

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

Ähnlich habe ich mit Django eine Datei namens manage im Stammordner py erstellt , zum Beispiel:

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

Dann können wir die folgenden Operationen an den Daten durchführen:

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

Hauptanwendungsdatei

Neues Projekt erstellen, Ich erstelle eine Datei app.py im Stammordner und dann ändert sie sich wie folgt.

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

Konfigurationsdatei

Ich habe auch eine Konfigurationsdatei namens config.py im Stammordner erstellt.

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

Ordnerstruktur

Ich erstelle einen Ordner im Stammverzeichnis und nenne ihn om_core und erstelle dann zwei neue Ordner in Qi api und data.

API-Dateien speichern Anwendungslogik und Routing. Ich habe zum Beispiel einen Ordner namens „user“ in der API erstellt.

Generieren Sie zwei Dateien mit den Namen init.py und controllers.py im Benutzerordner, ebenso wie unsere anderen API-Ebenen. controllers.py (Controller-Datei) sollte so aussehen:

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

Ich verwende immer Blueprints.

Datenordner speichert einige Modelle. Ich habe zum Beispiel eine Datei namens models.py erstellt:

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

Gehen wir zurück zum Ordner om_core. Ich habe eine Datei namens init.py erstellt, um die API-Ebene als Endpunkt zu verwenden.

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

Im obigen Code habe ich Flask-CORS verwendet, um Anfragen unterschiedlicher Herkunft zuzulassen. Dies ist nicht erforderlich, wenn Sie keine Anfragen unterschiedlicher Herkunft zulassen möchten.

Screenshots der gesamten Projektstruktur

Die Screenshots lauten wie folgt:

Empfohlenes Tutorial: „Python-Tutorial"

Das obige ist der detaillierte Inhalt vonVerstehen Sie die Flask-Projektstruktur. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!