seo-dev-env 0.1.0__tar.gz

seo_dev_env-0.1.0/PKG-INFO

@@ -0,0 +1,538 @@
+Metadata-Version: 2.4
+Name: seo-dev-env
+Version: 0.1.0
+Summary: Générateur d'environnements de développement pour tous niveaux
+Home-page: https://github.com/https://github.com/elkast/seo-dev-env
+Author: Votre Nom
+Author-email: orsinimelchisedek@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE.ls
+Requires-Dist: flask>=2.0.0
+Requires-Dist: python-dotenv>=0.19.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+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.)
+