Wie organisiere ich eine relativ große Kolbenanwendung?

Ich baue meine erste Flask-App und kann keine gute, saubere Pythonic-Methode zum Organisieren meiner Anwendung finden. Ich möchte nicht alles in einer einzigen .py-Datei haben, wie in ihrem Beispiel. Ich möchte jeden Teil meiner App in einem separaten Modul haben. Was wäre ein guter Weg, um Dinge zu organisieren?

Ich habe ein Flask Boilerplate-Projekt namens " Fbone " erstellt, bitte zögern Sie nicht, es auszuprobieren und zu teilen :)

Fbone (Flask Bone) ist eine Flask (Python Microframework) Template / Bootstrap / Boilerplate-Anwendung.

Überblick

• Gut konzipiert für große Projekte mit Blaupause.
• Integration in das heißeste Frontend-Framework: jQuery / html5boilerplate / bootstrap.
• Unterstützt von der berühmten SQLalchemy.
• Implementiere kniffliges "Remember Me" per Flask-Login.
• Behandeln Sie Webformulare mit flask-wtform.
• Unit Testing mit Kolbentest und Nase.
• Einfache Bereitstellung über Fabric und mod_wsgi (Beispiel enthalten).
• i18n von flask-babel

Übrigens fand ich dieses Wiki gerade beim Erstellen eines großen Projekts mit Flask nützlich. Bitte überprüfen Sie es!

Flask 0.7 implementiert Blueprints . Sie eignen sich hervorragend für die Verwendung des routeDekorators, ohne das Hauptanwendungsobjekt zu importieren.

Lesen Sie unbedingt Matt Wrights wunderbaren Beitrag zu diesem Thema.

Der Beitrag enthält:

1. Eine Beschreibung einer Struktur für große Kolbenprojekte

2. Eine Beispielanwendung auf Github

3. Eine Beschreibung der besten Entwurfspraktiken im Allgemeinen bei großen Webanwendungen wie MVC-Muster, App-Fabriken, Services und Datenmigration, um nur einige zu nennen (meiner Meinung nach interessanteste Funktion).

Ich arbeite an einem (nach meinen Maßstäben) großen Flask-Projekt (5000 Zeilen Python-Code und es ist nur halb fertig). Der Kunde möchte, dass das Projekt modular aufgebaut ist, daher habe ich diesen Ansatz gewählt:

Meine Ordnerstruktur sieht folgendermaßen aus:

├── __init__.py
├── modules.yml
├── config
├── controllers
│   └── ...
├── lib: Common functions I use often
│   └── ...
├── models
│   └── ...
├── static: All static files
│   ├── css
│   ├── img
│   └── js
└── templates: Jinja2 templates
    └── ...

In modules.ymldefiniere ich meine Module einschließlich Name und URL. Auf diese Weise kann der Kunde Module aktivieren / deaktivieren, ohne eine einzelne Python-Datei zu berühren. Außerdem generiere ich die Menüs basierend auf der Modulliste. Vereinbarungsgemäß jedes Modul hat sein eigenes Python-Modul in controllers/dem seiner Last wird modelaus models/. Jeder Controller definiert einen Blueprintals Controller gespeicherten Namen. ZB für ein userModul habe ich in controllers/user.py:

# Module name is 'user', thus save Blueprint as 'user' variable
user = Blueprint('user', __name__)

@user.route('/user/')
def index():
    pass

Auf diese Weise kann ich das modules.ymlin my lesen __init__.pyund alle aktivierten Module dynamisch laden und registrieren:

# Import modules
for module in modules:

    # Get module name from 'url' setting, exculde leading slash
    modname = module['url'][1:]

    try:
        # from project.controllers.<modname> import <modname>
        mod = __import__(
            'project.controllers.' + modname, None, None, modname
        )
    except Exception as e:
        # Log exceptions here
        # [...]

    mod = getattr(mod, modname)  # Get blueprint from module
    app.register_blueprint(mod, url_prefix=module['url'])

Ich hoffe, das kann eine Inspiration für dich sein :)

Ich habe in einem sozialen Netzwerk gearbeitet, das auf Flask aufgebaut ist. Das Besondere an meinem Projekt war, dass der Server nur API-Endpunkte bedient und das Frontend eine einseitige Backbone-App ist. Die Kolbenstruktur, die ich genommen habe, ist die folgende:

├── app │ ├── api
│ │ ├── auth.py │ │ └── ... │ ├── app.py │ ├── common │ │ ├── constants.py │ │ ├── helpers.py │ │ ├── response.py │ │ └── ... │ ├── config.py │ ├── extensions.py │ ├── frontend │ │ └── controllers.py │ ├── static │ │ └── ... │ ├── templates │ │ ├── app.html │ │ └── ... │ └── users │ ├── UserConstants.py │ ├── UserForms.py │ ├── UserHelpers.py │ ├── UserModels.py │ └── __init__.py ├── alembic | ├── version │ └── ... ├── tests │ └── ...

Den ausführlicheren Beitrag, den ich zu diesem Thema geschrieben habe, können Sie hier lesen . Ich fand es viel intuitiver, verschiedene Funktionsbereiche in einen eigenen Ordner zu unterteilen.

Ich habe vor einiger Zeit an dem Code gearbeitet und ihn komplett mit Open Source bezogen! Sie können es auf Github überprüfen .

Ich habe einen Flask App Yapper von Grund auf neu erstellt und ihn für die Frontend- und Backend-Entwicklung in gulp integriert. Es ist eine einfache Blog-Engine, die jedoch leicht an die Anforderungen angepasst werden kann. Es ist mit Blueprints gut strukturiert.

Kasse der Projektseite yapper