Come organizzare un'applicazione Flask relativamente grande?

Question

Sto costruendo la mia prima app Flask e non riesco a trovare un buon modo per organizzare la mia applicazione in Python. Non voglio avere tutto in un singolo file .py come nel loro esempio. Mi piacerebbe avere ciascuna parte della mia app in un modulo separato. Quale sarebbe un buon modo per organizzare le cose?

Answer 1

ho creato un progetto Flask boilerplate chiamato "Fbone", non esitate a check it out e :) forchetta

Fbone (Flask ossea) è un pallone (Python microframework) applicazione template/bootstrap/boilerplate.

Panoramica

• ben progettato per il grande progetto che utilizza progetto.
• Integrazione con il framework di frontend più caldo: jQuery/html5boilerplate/bootstrap.
• Sostenuto dal famoso SQLalchemy.
• Implementare in modo ingannevole "ricordami" con il login di una boccetta.
• Gestire i moduli Web con il flask-wtform.
• Test unitario con test del pallone e naso.
• Distribuire facilmente tramite fabric e mod_wsgi (esempio incluso).
• i18n dal pallone-babele

btw, ho appena trovato questo wiki sulla costruzione di un grande progetto con la boccetta utile, pls controllare!

Answer 2

Flask 0.7 attrezzi Blueprints. Sono ottimi per l'utilizzo del decoratore route senza importare l'oggetto dell'applicazione principale.

Answer 3

Sto lavorando ad un (grande standard) progetto Flask (5000 linee di codice Python ed è solo parzialmente rifinito). Il cliente vuole il progetto per essere modulare, così ho preso questa suddetto approccio:

mia struttura di cartelle simile a questa:

├── __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.yml ho definire il mio moduli tra cui nome e l'URL. In questo modo il cliente è in grado di abilitare/disabilitare i moduli senza toccare un singolo file Python. Inoltre, creo i menu in base all'elenco dei moduli. Per convenzione ogni modulo ha il proprio modulo Python in controllers/ che carica il suo model da models/. Ogni controller definisce uno Blueprint memorizzato come nome del controllore. Per esempio. per un modulo user, ho in controllers/user.py:

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

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

In questo modo, posso leggere il modules.yml a mio carico __init__.py e e registrare tutti i moduli abilitati in modo dinamico:

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

spero, questo può essere qualche fonte d'ispirazione per te :)

Answer 4

Leggere attentamente Matt Wright's wonderful post sull'argomento.

Le caratteristiche pubblicare:

1. Una descrizione di una struttura per i grandi progetti pallone

2. An example application on Github

3. una descrizione delle migliori pratiche di progettazione in generale quando si tratta di grandi dimensioni app Web, come il pattern MVC, le fabbricazioni di app, i servizi e la migrazione dei dati per citarne alcuni (la caratteristica più interessante IMHO).

Answer 5

Ho creato un'applicazione Flask yapper da zero e integrati con fiato sia per frontend e backend di sviluppo. È un semplice motore di blog, ma può essere facilmente modificato per lo sviluppo in base alle esigenze. È ben strutturato usando i Blueprints.

Checkout pagina del progetto yapper

Answer 6

ho lavorato su un social network costruito sulla cima di Flask. La particolarità del mio progetto era che il server serviva esclusivamente endpoint API e il frontend è un'app Backbone di una pagina. La struttura Flask ho preso è la seguente:

├── 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 │ └── ...

Potete leggere il più post di approfondimento che ho scritto sull'argomento here. Ho trovato molto più intuitivo separare diverse aree funzionali dalla propria cartella.

Ho lavorato al codice qualche tempo fa e l'ho aperto completamente! Puoi dare un'occhiata a on github.