¿Cómo organizar una aplicación Flask relativamente grande?

Question

Estoy construyendo mi primera aplicación Flask y no puedo encontrar una manera clara y piatica de organizar mi aplicación. No quiero tener todo en un solo archivo .py como en su ejemplo. Me gustaría tener cada parte de mi aplicación en un módulo separado. ¿Cuál sería una buena manera de organizar las cosas?

Answer 1

He creado un proyecto Frasco repetitivo llamado "Fbone", no dude en comprobarlo y tenedor :)

Fbone (hueso del frasco) es un (microframework Python) aplicación de plantilla/bootstrap/repetitivo frasco.

general

• bien diseñados para la gran proyecto utilizando planos.
• Integre con el framework de frontend más moderno: jQuery/html5boilerplate/bootstrap.
• Respaldado por la famosa SQLalchemy.
• Implemente el truco "recordarme" por el matraz de inicio de sesión.
• Manejar formularios web por matraz-wtform.
• Pruebas unitarias con matraz y nariz.
• Implementar fácilmente a través de fabric y mod_wsgi (ejemplo incluido).
• i18n por matraz de babel

por cierto, acabo de encontrar este wiki en la construcción de un gran proyecto con el frasco útil, pls lo comprueban!

Answer 2

Flask 0.7 implementa Blueprints. Son excelentes para usar el decorador route sin importar el objeto principal de la aplicación.

Answer 3

Estoy trabajando en un gran proyecto Flask (por mis estándares) (5000 líneas de código Python y está solo a medio terminar). El cliente quiere que el proyecto sea modular, por lo que tomó esta apporach:

Mi estructura de carpetas es el siguiente:

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

En modules.yml defino mis módulos incluyendo el nombre y la dirección URL. De esta forma, el cliente puede habilitar/deshabilitar módulos sin tocar un solo archivo de Python. Además, genero los menús en base a la lista de módulos. Por convención, cada módulo tiene su propio módulo de Python en controllers/ que cargará su model desde models/. Cada controlador define un Blueprint almacenado como el nombre del controlador. P.ej. para un módulo user, tengo en controllers/user.py:

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

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

De esta manera, puedo leer el modules.yml en mi carga __init__.py y y registrar todos los módulos habilitados de forma dinámica:

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

espero, esto puede ser algo de inspiración para ti :)

Answer 4

Asegúrate de leer Matt Wright's wonderful post sobre el tema.

Las características post:

1. Una descripción de una estructura para grandes proyectos matraz

2. An example application on Github

3. Una descripción de las mejores prácticas de diseño en general cuando se trata de grandes aplicaciones web, como el patrón MVC, fábricas de aplicaciones, servicios y migración de datos por nombrar algunas (característica más interesante en mi humilde opinión).

Answer 5

He creado una aplicación Frasco yapper desde cero e integrado con trago tanto para el desarrollo frontend y backend. Es un motor de blog simple, pero se puede modificar fácilmente para desarrollar según los requisitos. Está bien estructurado usando Blueprints.

Pedido la página del proyecto yapper

Answer 6

trabajé en una red social construida sobre el frasco. Lo especial de mi proyecto fue que el servidor solo sirve puntos finales API y el frontend es una aplicación Backbone de una página. La estructura Frasco Tomé es la siguiente:

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

Puede leer el mensaje más profundo que escribí sobre el tema here. Me pareció mucho más intuitivo separar distintas áreas funcionales en su propia carpeta.

¡Trabajé en el código hace un tiempo y lo abrí por completo! Puede verificarlo on github.