Comment organiser un relativement grand Flacon d'application?

Je suis en train de construire mon premier Flacon application et je ne peux pas trouver une bonne, propre Pythonic façon de l'organisation de mon application.
Je ne veux pas avoir tout dans un seul .py fichier comme dans l'exemple.
Je voudrais avoir chaque partie de mon application dans un module séparé.
Ce serait une bonne façon d'organiser les choses?

J'aime bien la mise en page est expliqué ici: flask.pocoo.org/docs/patterns/packages
Là, ils sont à l'aide de la circulaire importations que je voudrais éviter.
Vrai, mais je ne pense pas que c'est évitable si vous souhaitez utiliser l'application.itinéraire décorateur.

InformationsquelleAutor daniels | 2012-02-22

flask python

82

J'ai créé une Gourde réutilisable projet appelé "Fbone", n'hésitez pas à le vérifier et fourche 🙂

Fbone (Flacon os) est un Flacon (Python microframework) modèle/bootstrap/standard de l'application.

Aperçu
- Bien conçu pour les gros projet à l'aide de plan d'action.
- Intégrer avec les plus chaudes frontend framework: jQuery /html5boilerplate /bootstrap.
- Soutenu par le célèbre SQLalchemy.
- Mettre en œuvre délicate "se souvenir de moi" par flacon de connexion.
- Gérer des formulaires web en flacon-wtform.
- Tests unitaires avec le flacon de test et le nez.
- De déployer facilement via le tissu et mod_wsgi (exemple inclus).
- i18n par flacon de babel
btw, je viens de trouver cette wiki sur la construction d'un grand projet avec Flacon utile, pls vérifier!
- génial standard, bon travail!
- Vraiment comme cela. Merci!!!!
- Avant d'exécuter "fab d' comme détaillé dans le fichier README, vous devez activer votre environnement virtuel avec "source env/bin/activate"
- La fondation sera meilleure que celle de bootstrap, hein?
- Je ne pouvais pas dire où vous avez mis plusieurs modèles. Mettez-vous des modèles dans différents fichiers comme un framework php n'?
- (fbone)MacBook-Pro-de-Pyderman:flacon réutilisable Pyderman$ fab setup Warning: Command(s) not found: setup
- pastebin.com/KjfKLMR9
- Le tissu ne fonctionne pas avec Python 3.5
- Peut l'api partie dans le fbone projet être utilisé par des applications mobiles? De sorte que l'application basée sur le fbone projet peut être consulté à partir du web et mobiles des clients natifs?
InformationsquelleAutor imwilsonxu
20

Flacon de 0,7 implémente Les bleus. Ils sont parfaits pour l'utilisation de la route décorateur, sans importer le principal objet de l'application.
- Comment est un modèle différent d'un module?
- Techniquement, un plan d'action est une instance du Plan d'action de la classe. Ils peuvent s'étendre sur un ou plusieurs modules, ou plusieurs modèles peuvent coexister dans le même module. Il y a un peu de magie en coulisses pour trouver un plan directeur de module ou d'un package, pour trouver son templates et static dossiers.
- J'ai intégrer des plans dans ma gourde osseuse projet, voir ma réponse pls.
InformationsquelleAutor Alex Morega
17

Assurez-vous de lire Matt Wright magnifique post sur le sujet.

Le post caractéristiques:
1. Une description d'une structure pour les gros flacon de projets
2. Un exemple d'application sur Github
3. Une description des meilleures pratiques de conception en général quand il s'agit de grosses applications web, comme le modèle MVC, App les usines, les Services et la Migration de Données pour n'en nommer que quelques-uns (le plus intéressant, à mon humble avis).
- Une grande explication avec des exemples.
InformationsquelleAutor edsioufi
12

Je suis en train de travailler sur un (selon mes critères) gros Flacon de projet (5000 lignes de code Python et c'est seulement à moitié fini). Le client souhaite que le projet pour être modulaire, donc j'ai pris cette apporach:

Mon dossier structure ressemble à ceci:
```
├── __init__.py
├── modules.yml
├── config
├── controllers
│   └── ...
├── lib: Common functions I use often
│   └── ...
├── models
│   └── ...
├── static: All static files
│   ├── css
│   ├── img
│   └── js
└── templates: Jinja2 templates
    └── ...
```
Dans modules.yml je définir mes modules, y compris le nom et l'URL. De cette façon, le client est en mesure d'activer/désactiver des modules sans toucher un seul fichier Python. En outre, je crée les menus en fonction de la liste des modules. Par convention, chaque module possède sa propre Python-module controllers/ qui charge son model de models/. Chaque contrôleur définit un Blueprint stockées en tant que le nom du contrôleur. E. g. pour un user module, j'ai dans controllers/user.py:
```
# Module name is 'user', thus save Blueprint as 'user' variable
user = Blueprint('user', __name__)

@user.route('/user/')
def index():
    pass
```
De cette façon, je peux lire le modules.yml dans mon __init__.py et de charger et d'enregistrer tous les modules activés de façon dynamique:
```
# 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'])
```
Je l'espère, cela peut être un peu d'inspiration pour vous 🙂
- où mettez-vous votre fichiers de test?
- La structure décrite ci-dessus est en fait un sous-répertoire avec le nom du projet (project_name/). Il y a également une tests/ et un dossier de scripts/ dossier (pour les scripts exécutables). Pour tests/, il serait astucieux d'utiliser la même structure que dans la réponse: tests/models/ pour les essais sur modèle, tests/controllers/ pour contrôleur de tests, you name it. Qui aurait besoin d'un peu de surcharge pour le maintien de la structure, mais il serait très facile de trouver les fichiers dont vous avez besoin.
InformationsquelleAutor msiemens
3

J'ai travaillé sur un réseau social construit sur le haut du Flacon. La chose de spécial à propos de mon projet est que le serveur est purement servir de l'API de points de terminaison et le frontend est un Squelette d'application. Le Flacon de la structure que j'ai pris est le suivant:

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

Vous pouvez lire plus en profondeur post que j'ai écrit sur le sujet ici. Je l'ai trouvé beaucoup plus intuitive pour séparer les différents domaines fonctionnels de son propre dossier.

J'ai travaillé sur le code il y a un moment et open source complètement! Vous pouvez le vérifier sur github.
- Merci. A l'air sympa.
InformationsquelleAutor spchuang
2

J'ai créé un Flacon application yapper à partir de zéro et a intégré avec gulp pour les deux frontend et backend de développement.
C'est un simple moteur de blog, mais peut être facilement modifié pour le développement en fonction des besoins. Il est bien structuré à l'aide de Plans.

La caisse de la page du projet yapper

InformationsquelleAutor brijeshb42

Vous devez vous connecter pour publier un commentaire.