seo-dev-env 0.1.3
Générateur d'environnements de développement pour tous niveaux
Requires Python: >=3.6

Très bien ! Voici une explication claire, complète et structurée de l'utilisation de **`seo-dev-env`**, un générateur d'environnements de développement Flask. L’objectif est que **même un débutant puisse comprendre** ce que chaque niveau fait, **comment les fichiers interagissent** et **ce qu’on peut construire avec**.

---

## 🔧 Qu’est-ce que `seo-dev-env` ?

C’est un **outil Python** qui te permet de **créer un projet Flask prêt à l’emploi** avec une seule commande. Selon ton **niveau** (débutant, intermédiaire ou pro), il te génère automatiquement une structure de projet adaptée, propre et bien organisée.

---

## 🚀 Installation

```bash
pip install seo-dev-env
```

Tu peux maintenant utiliser la commande `seo-create` ou l'importer dans un script Python.

---

## ⚙️ Utilisation

### ➤ En ligne de commande (CLI)

```bash
seo-create debutant mon-projet
```

Cela crée un projet nommé `mon-projet` avec une structure simple (pour débutant).

### ➤ En Python

```python
from seo import creer_projet

creer_projet('pro', 'mon-projet-élite')
```

Cela génère un projet "pro" avec Docker et une API robuste.

---

## 🧱 Niveaux disponibles et structure de projet

### 🐣 1. Débutant : Structure Simple

Idéal pour ceux qui apprennent Flask ou font un petit projet/test.

#### 🔹 Structure du dossier :

```
mon-projet/
├── app.py
├── templates/
│   └── index.html
├── static/
│   └── style.css
└── requirements.txt
```

#### 🔹 À quoi ça sert :

* `app.py` : ton fichier principal Flask
* `templates/index.html` : ta page HTML (Jinja2)
* `static/style.css` : ton style CSS
* `requirements.txt` : liste des bibliothèques Python à installer

#### ✅ Ce que tu peux construire :

* Une landing page
* Un formulaire de contact
* Une démo rapide pour un concept

---

### ⚡ 2. Intermédiaire : Architecture MVC

Architecture propre, réutilisable, bien structurée. Idéal pour un **site web dynamique** ou une **application complète**.

#### 🔹 Structure du dossier :

```
mon-projet/
├── app/
│   ├── __init__.py
│   ├── routes.py
│   ├── models.py
│   └── forms.py
├── templates/
│   └── base.html
│   └── home.html
├── static/
│   └── css/
├── config.py
├── run.py
└── requirements.txt
```

#### 🔹 Détail des fichiers :

* `app/__init__.py` : initialise l'app Flask
* `routes.py` : contient les pages et leurs comportements
* `models.py` : les objets liés à la base de données (SQLAlchemy)
* `forms.py` : formulaires (WTForms)
* `config.py` : configuration générale (dev, prod, clés secrètes)
* `run.py` : fichier pour lancer l’app
* `templates/` : toutes les pages HTML avec héritage de `base.html`

#### ✅ Ce que tu peux construire :

* Blog personnel
* Dashboard interne
* Site avec base de données (utilisateurs, commentaires, etc.)
* Application avec authentification/login

---

### 🚀 3. Pro : Docker + API Pro

Projet conçu pour des applications **robustes, déployables en production**, avec Docker, API REST, structure scalable.

#### 🔹 Structure du dossier :

```
mon-projet-élite/
├── api/
│   ├── __init__.py
│   ├── routes/
│   │   └── user_routes.py
│   ├── models/
│   │   └── user_model.py
│   └── services/
│       └── auth_service.py
├── config/
│   └── config.py
├── docker/
│   └── Dockerfile
├── docker-compose.yml
├── requirements.txt
├── .env
└── run.py
```

#### 🔹 Détail des fichiers :

* `api/` : ton app Flask sous forme d’API modulaire

  * `routes/` : routes REST (GET, POST, etc.)
  * `models/` : objets de base de données (SQLAlchemy ou autre ORM)
  * `services/` : logique métier (auth, traitement, etc.)
* `config/` : configuration centralisée
* `Dockerfile` & `docker-compose.yml` : pour l’environnement Docker
* `.env` : variables d’environnement sensibles
* `run.py` : point d’entrée de l’application

#### ✅ Ce que tu peux construire :

* Backend d’une app mobile
* API REST sécurisée
* Projet SaaS ou e-commerce scalable
* Application avec CI/CD, PostgreSQL, Redis, etc.

---

## 🔁 Interaction des fichiers (exemples)

### Exemple pour le niveau **intermédiaire** :

1. `run.py` lance l'application
2. Il appelle `app/__init__.py` pour créer l’objet Flask
3. `init.py` charge les routes via `routes.py`
4. Les routes retournent des templates comme `home.html`
5. Les données viennent de `models.py`
6. Si besoin de formulaire, `forms.py` gère la validation

---

## 💡 Que peut-on faire de A à Z ?

Exemple : construire un **portail de gestion de projets**

1. Utilise `seo-create pro gestion-projets`
2. Ajoute une base PostgreSQL dans `docker-compose.yml`
3. Développe des routes pour :

   * Créer un projet (`POST /projets`)
   * Lister les projets (`GET /projets`)
   * Ajouter des tâches à un projet (`POST /projets/<id>/taches`)
4. Gère l’authentification via JWT dans `services/auth_service.py`
5. Déploie avec Docker sur un VPS

---

## 🧠 Résumé des avantages

| Niveau        | Idéal pour                   | Points forts                              |
| ------------- | ---------------------------- | ----------------------------------------- |
| Débutant      | Apprentissage, mini-projets  | Ultra simple, immédiat                    |
| Intermédiaire | Sites complets avec logique  | MVC propre, bonne base pour la croissance |
| Pro           | APIs, apps déployables, SaaS | Docker, structure modulaire, scalable     |

un petit exmple😁👌;

Parfait ! Je vais te montrer un exemple complet avec le **niveau Intermédiaire (⚡ Architecture MVC)**, qui est un bon équilibre entre simplicité et puissance. Nous allons créer un **mini tableau de bord de gestion de tâches** (type Todo App multi-utilisateur).

---

## 🎯 Objectif du projet : Gestion de tâches (Task Manager)

Chaque utilisateur peut :

* s’inscrire et se connecter,
* créer, modifier et supprimer ses tâches,
* voir ses tâches dans un tableau de bord.

---

## 🧰 Étape 1 : Génération du projet

```bash
seo-create intermediaire task-manager
cd task-manager
```

---

## 🗂️ Structure du projet (générée automatiquement)

```
task-manager/
├── app/
│   ├── __init__.py
│   ├── routes.py
│   ├── models.py
│   └── forms.py
├── templates/
│   ├── base.html
│   ├── home.html
│   ├── login.html
│   └── dashboard.html
├── static/
│   └── style.css
├── config.py
├── run.py
└── requirements.txt
```

---

## 🔧 Étape 2 : Configurer la base

**config.py**

```python
import os

class Config:
    SECRET_KEY = 'cle-super-secrete'
    SQLALCHEMY_DATABASE_URI = 'sqlite:///db.sqlite3'
    SQLALCHEMY_TRACK_MODIFICATIONS = False
```

---

## 🧱 Étape 3 : Initialiser l’app

**app/**init**.py**

```python
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from flask_login import LoginManager
from config import Config

db = SQLAlchemy()
login = LoginManager()
login.login_view = 'login'

def create_app():
    app = Flask(__name__)
    app.config.from_object(Config)

    db.init_app(app)
    login.init_app(app)

    from app.routes import bp
    app.register_blueprint(bp)

    return app
```

---

## 👤 Étape 4 : Modèle utilisateur + tâche

**app/models.py**

```python
from app import db
from flask_login import UserMixin
from werkzeug.security import generate_password_hash, check_password_hash
from app import login

class User(UserMixin, db.Model):
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(64), unique=True)
    password_hash = db.Column(db.String(128))
    tasks = db.relationship('Task', backref='owner', lazy='dynamic')

    def set_password(self, password):
        self.password_hash = generate_password_hash(password)
    
    def check_password(self, password):
        return check_password_hash(self.password_hash, password)

@login.user_loader
def load_user(id):
    return User.query.get(int(id))

class Task(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    title = db.Column(db.String(128))
    done = db.Column(db.Boolean, default=False)
    user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
```

---

## 🧾 Étape 5 : Les formulaires

**app/forms.py**

```python
from flask_wtf import FlaskForm
from wtforms import StringField, PasswordField, SubmitField, BooleanField
from wtforms.validators import DataRequired, EqualTo

class LoginForm(FlaskForm):
    username = StringField('Nom d\'utilisateur', validators=[DataRequired()])
    password = PasswordField('Mot de passe', validators=[DataRequired()])
    submit = SubmitField('Connexion')

class TaskForm(FlaskForm):
    title = StringField('Titre de la tâche', validators=[DataRequired()])
    submit = SubmitField('Ajouter')
```

---

## 🌐 Étape 6 : Les routes principales

**app/routes.py**

```python
from flask import Blueprint, render_template, redirect, url_for, request, flash
from flask_login import login_user, logout_user, login_required, current_user
from app.models import User, Task
from app.forms import LoginForm, TaskForm
from app import db

bp = Blueprint('main', __name__)

@bp.route('/', methods=['GET', 'POST'])
def login():
    form = LoginForm()
    if form.validate_on_submit():
        user = User.query.filter_by(username=form.username.data).first()
        if user and user.check_password(form.password.data):
            login_user(user)
            return redirect(url_for('main.dashboard'))
        flash('Identifiants invalides.')
    return render_template('login.html', form=form)

@bp.route('/dashboard', methods=['GET', 'POST'])
@login_required
def dashboard():
    form = TaskForm()
    if form.validate_on_submit():
        task = Task(title=form.title.data, owner=current_user)
        db.session.add(task)
        db.session.commit()
        return redirect(url_for('main.dashboard'))
    tasks = current_user.tasks.all()
    return render_template('dashboard.html', tasks=tasks, form=form)

@bp.route('/logout')
def logout():
    logout_user()
    return redirect(url_for('main.login'))
```

---

## 🧪 Étape 7 : Initialisation de la base

Dans un terminal Python (depuis le dossier du projet) :

```python
from app import create_app, db
from app.models import User

app = create_app()
app.app_context().push()
db.create_all()

# Création d'un utilisateur test
u = User(username='admin')
u.set_password('admin')
db.session.add(u)
db.session.commit()
```

---

## 🖥️ Étape 8 : Templates HTML simplifiés

**templates/base.html**

```html
<!DOCTYPE html>
<html>
<head>
    <title>{% block title %}Task Manager{% endblock %}</title>
    <link rel="stylesheet" href="{{ url_for('static', filename='style.css') }}">
</head>
<body>
    {% block content %}{% endblock %}
</body>
</html>
```

**templates/login.html**

```html
{% extends "base.html" %}
{% block content %}
  <h2>Connexion</h2>
  <form method="post">
    {{ form.hidden_tag() }}
    {{ form.username.label }} {{ form.username() }}<br>
    {{ form.password.label }} {{ form.password() }}<br>
    {{ form.submit() }}
  </form>
{% endblock %}
```

**templates/dashboard.html**

```html
{% extends "base.html" %}
{% block content %}
  <h2>Bienvenue {{ current_user.username }}</h2>
  <a href="{{ url_for('main.logout') }}">Déconnexion</a>
  <form method="post">
    {{ form.hidden_tag() }}
    {{ form.title.label }} {{ form.title() }}
    {{ form.submit() }}
  </form>
  <ul>
    {% for task in tasks %}
      <li>{{ task.title }} {% if task.done %}(fait){% endif %}</li>
    {% endfor %}
  </ul>
{% endblock %}
```

---

## 🌍 Étape 9 : Lancer l’application

**run.py**

```python
from app import create_app

app = create_app()

if __name__ == '__main__':
    app.run(debug=True)
```

Puis lance :

```bash
python run.py
```

---

## ☁️ Étape 10 : Déploiement (plusieurs options)

### Option simple : [Render](https://render.com)

1. Crée un repo GitHub et pousse ton code
2. Va sur render.com et connecte ton GitHub
3. Clique sur "New Web Service"
4. Paramètres :

   * **Build Command** : `pip install -r requirements.txt`
   * **Start Command** : `python run.py`

---

## ✅ Résultat final

Tu as :

* Un système d'authentification
* Un tableau de bord utilisateur
* Un modèle MVC clair et extensible
* Une app Flask prête pour production (avec ajout facile de tests, Bootstrap, API, etc.)