Structure minimal de projet Flask

flask est un mini Framework python pour le web avec des excès sur d’autre type d’application comme la programmation d’application desktop… C’est un Framework libre dont seul le programmeur définis la structure de son projet et bien entendu avec quelque règle, il n’existe donc aucune structure préétablies, par contre de mauvaise structure existe. Dans cet édit je me pencherai sur la structure minimal la plus simple et idéaliste possible selon mon expérience. Avant d’aller plus loin je précise que j’approuve 3 structures possible dont celui-ci pour les mini-projets, un autre pour les moyens projet a multiple dimension étroitement lié et un dernier pour les projet de grande envergures pluridimensionnel et un dernier mot étrange dynamiquement lié qui peut être feront l’objet d’un autre édit.

Structure idéal pour les projets de petite envergure

Bien cela constitut le statut minimal, en jetant un coup d’œil dans la documentation de flask vous trouverai ce qui vous plaira, maintenant expliquons la présence de chacun des éléments dans la structure

I- ProjectName

il s’agit simplement du dossier racine de votre projet et très certainement le nom du projet. Il contient un dossier du même nom que lui mais en minuscule et 2 fichiers .env et wsgi.py

1- projectname

première chose a savoir c’est un package python et il contiendra tout votre travail. C’est l’a que vous jouerai a l’Alpha :)

a son tour il contient un minimum de 2 dossier ( static & templates ) et un minimum de 4 ou 5 fichier selon vos préférences (__init__.py, admin.py, models.py, views.py et parfois forms.py)

a- static

beh, nous sommes sensé tous le connaitre il contient nos feuilles de style ( dossier css ), nos images ( dossier img ) ….

b-templates

comme le dossier static, il contient nos fichiers html

c- __init__.py

premièrement il est la preuve que notre dossier projectname est un package mais il signifie bien plus ici, il s’agit de la ou tous commence.

c’est dans ce fichier que sera défini et instancier votre application, c’est le fichier de démarrage.

un exemple de __init__.py:

#!/usr/bin/env python3
""" apps launcher """
from flask import Flask

app = Flask(__name__)


def run():
  """ run app """
  app.config['ENV'] = 'development'
  app.config['SECRET_KEY'] = 'your_secret_key'

  return app

d- views.py

c’est a la fois le controller et la vue dans le modele MVC, c’est dans ce fichier que sera définis ce que fera votre application et a quel fichier du templates sera t-il lier

un exemple de views.py:

#!/usr/bin/env python3
""" views file """
from flask import render_template, request, redirect, url_for
from projectname import app

@app.route('/login', methods=['GET', 'POST'], stric_slashes=False)
def login():
  """ login page """
  if request.method == 'POST':
    username = request.form.get('username')
    password = request.form.get('password')
    ....
    return redirect(url_for('home'))
  return render_template('login.html')

a l’url http://127.0.0.1:5000/login se trouvera votre page définis par le fichier login.html dans templates, mais pas maintenant tout les éléments ne sont pas encore en place

e- models.py

Oui, il contiendra nos models mais avant ajoutons quelque ingrédient a notre __init__.py

#!/usr/bin/env python3
""" apps launcher """
from flask import Flask
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)
db = SQLAlchemy(app)

def run():
  """ run app """
  app.config['ENV'] = 'development'
  app.config['SECRET_KEY'] = 'your_secret_key'
  app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///test.db'

  return app

flask_sqlalchemy est un Framework pour l’utilisation de l’ORM SqlAlchemy pour flask. je vous laisse faire la découverte par vous même. mais en ce qui nous concerne nous venons d’instancier l’utilisation de SQLite par l’orm SQLALchemy maintenant nous pouvons définir notre models.py

#!/usr/bin/env python3
""" all models """
from projectname import db
from uuid import uuid4


class User:
  """User models
     username : str = 'unknow'
     password : str = 'defaultpassword'
  """
  id = db.Column(db.String, primary_key=True, default=str(uuid4()))
  username = db.Column(db.String, default='unknow')
  password = db.Colimn(db.String, default='defaultpassword')

f- admin.py

c’est le fichier d’administration du projet il pourrait contenir des définitions de lien dont seul l’admin a accès et même construire un système d’administration personnalisé. Il est a peu pres semblable au views.py mais coté administrateur

g- forms.py

beh il contient les modèles de formulaire qui pourrait se définir avec flask_wtf ou se fichier pourrait ne pas existez et faire le travail a la main comme je tentais de le faire avec la méthode login dans views.py

enfin nous venons de finir avec les éléments de projectname, j’ai cru m’étouffer vu la longueur du chemin, mais j’espère que vous vous êtes bien amusez. maintenant passons aux autres élément de ProjectName que sont .env et wsgi.py

II- .env

comme vous devez bien vous en doutez c’est le fichier de configuration flask c’est ici que sera définis les variable d’environnements

un exemple de .env:

# environment variables
ENV=development
SECRET_KEY=nifchi-nevie84-649844-15615
SQLALCHEMY_DATABASE_URI=sqlite:///test.db

bien pour ce qui est de SECRET_KEY vous pouvez la définir en générant un uuid4 ou utiliser des générations de code secret en ligne

bien maintenant nous devons réécrire notre __init__.py en fonction des variables d’environnements et pour cela nous aurons besoin de python_dotenv un Framework qui convertira notre fichier .env en variable d’environnement UNIX

#!/usr/bin/env python3
""" apps launcher """
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from dotenv import load_dotenv
import os


app = Flask(__name__)
db = SQLAlchemy(app)
load_dotenv()

def run():
  """ run app """
  app.config['ENV'] = os.environ.get('ENV')
  app.config['SECRET_KEY'] = os.environ.get('SECRET_KEY')
  app.config['SQLALCHEMY_DATABASE_URI'] = os.environ.get('SQLALCHEMY_DATABASE_URI')

  return app

III- wsgi.py

c’est lui le réel lanceur de l’application c’est le point de départ véritable

#!/usr/bin/env python3
""" runner """
from projectname import run

app = run()


if __name__ == '_main__:
  app.run()

eh, bien je tiens a vous prévenir ce tutoriel a été écrit de façon directe sans être testé alors il peut avoir quelque petite erreur que vous serait je vous le promet en mesure de traité sans difficulté

le projet se lance de 2 manière différente dans un terminal bien entendu après avoir installer tout les dépendances c’est a dire

$ cd ProjectName
$ pip install flask flask_sqlalchemy python_dotenv

ensuite dans le même terminal

$ flask run
ou
  sur windows
$ python -m wsgi
  sur linux et en production
$ python wsgi

merci de m’avoir suivi et a bientôt pour bien des choses aventureuse vous pouvez m’écrire a l’adresse mail victorvaddely@gmail.com, me suivre sur https://www.linkedin.com/in/hydromel/ , https://twitter.com/WarningCode ou taper hydrogineer sur YouTube mais rien n’y es pour l’instant