seo-dev-env 0.1.0__tar.gz → 0.1.1__tar.gz

{seo_dev_env-0.1.0/seo_dev_env.egg-info → seo_dev_env-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: seo-dev-env
-Version: 0.1.0
+Version: 0.1.1
 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

seo_dev_env-0.1.1/seo/__init__.py

@@ -0,0 +1,3 @@
+from .generators import creer_environnement, creer_projet, creer_projet_interactif, main
+
+__all__ = ['creer_environnement', 'creer_projet', 'creer_projet_interactif', 'main']

seo_dev_env-0.1.1/seo/cli.py

@@ -0,0 +1,165 @@
+"""CLI interactif pour SEO Dev Env"""
+import sys
+from typing import Dict, Any
+
+
+def afficher_titre():
+    print("\n" + "="*60)
+    print(" SEO Dev Env - Créateur d'architecture Flask")
+    print("   pour développeurs francophones")
+    print("="*60 + "\n")
+
+
+def poser_question(question: str, options: list, defaut: int = 1) -> int:
+    print(f"\n{question}")
+    for i, option in enumerate(options, 1):
+        marqueur = "" if i == defaut else " "
+        print(f"  {marqueur} {i}. {option}")
+    while True:
+        try:
+            choix = input(f"\nVotre choix [1-{len(options)}] (défaut: {defaut}): ").strip()
+            if not choix:
+                return defaut - 1
+            choix_int = int(choix)
+            if 1 <= choix_int <= len(options):
+                return choix_int - 1
+            else:
+                print(f" Veuillez choisir entre 1 et {len(options)}")
+        except ValueError:
+            print(" Veuillez entrer un nombre valide")
+        except KeyboardInterrupt:
+            print("\n\n Annulé")
+            sys.exit(0)
+
+
+def poser_question_texte(question: str, defaut: str = "") -> str:
+    prompt = f"{question} (défaut: {defaut}): " if defaut else f"{question}: "
+    try:
+        reponse = input(prompt).strip()
+        return reponse if reponse else defaut
+    except KeyboardInterrupt:
+        print("\n\n Annulé")
+        sys.exit(0)
+
+
+def confirmer(question: str, defaut: bool = True) -> bool:
+    suffixe = "[O/n]" if defaut else "[o/N]"
+    try:
+        reponse = input(f"{question} {suffixe}: ").strip().lower()
+        if not reponse:
+            return defaut
+        return reponse in ["o", "oui", "y", "yes"]
+    except KeyboardInterrupt:
+        print("\n\n Annulé")
+        sys.exit(0)
+
+
+def collecter_preferences() -> Dict[str, Any]:
+    afficher_titre()
+    preferences = {}
+    
+    print(" Configuration du projet")
+    preferences["nom_projet"] = poser_question_texte("Nom de votre projet", "mon-projet")
+    
+    type_options = [
+        "Apprentissage (simple, pour débuter)",
+        "Application web (structure MVC complète)",
+        "API professionnelle (production-ready)",
+        "Startup SaaS (auth, paiement, dashboard)"
+    ]
+    type_choix = poser_question(" Quel type de projet ?", type_options)
+    types_mapping = {0: "apprentissage", 1: "application", 2: "api", 3: "saas"}
+    preferences["type_projet"] = types_mapping[type_choix]
+    
+    if preferences["type_projet"] in ["application", "api", "saas"]:
+        db_options = [
+            "SQLite (simple, fichier local)",
+            "PostgreSQL (recommandé pour production)",
+            "MySQL (compatible, largement utilisé)"
+        ]
+        db_choix = poser_question("  Quelle base de données ?", db_options,
+                                   defaut=2 if preferences["type_projet"] in ["api", "saas"] else 1)
+        db_mapping = {0: "sqlite", 1: "postgresql", 2: "mysql"}
+        preferences["base_donnees"] = db_mapping[db_choix]
+        
+        if preferences["base_donnees"] == "sqlite" and preferences["type_projet"] in ["api", "saas"]:
+            print("\n  ATTENTION: SQLite non recommandé pour production.")
+            if not confirmer("\n   Continuer avec SQLite ?", defaut=False):
+                print("\n    Passage à PostgreSQL")
+                preferences["base_donnees"] = "postgresql"
+        
+        auth_options = [
+            "Session classique (cookies Flask)",
+            "JWT (tokens, pour API)",
+            "OAuth2 (Google, GitHub, etc.)"
+        ]
+        auth_choix = poser_question(" Type d'authentification ?", auth_options,
+                                     defaut=2 if preferences["type_projet"] == "api" else 1)
+        auth_mapping = {0: "session", 1: "jwt", 2: "oauth"}
+        preferences["auth"] = auth_mapping[auth_choix]
+        
+        if preferences["type_projet"] in ["api", "saas"]:
+            preferences["docker"] = True
+            print("\n Docker inclus automatiquement")
+        else:
+            preferences["docker"] = confirmer("\n Inclure Docker ?", defaut=True)
+    else:
+        preferences["base_donnees"] = "sqlite"
+        preferences["auth"] = "session"
+        preferences["docker"] = False
+    
+    if preferences["type_projet"] == "saas":
+        preferences["stripe"] = confirmer("\n Inclure Stripe ?", defaut=True)
+        preferences["email"] = confirmer(" Inclure Flask-Mail ?", defaut=True)
+        preferences["celery"] = confirmer("  Inclure Celery ?", defaut=True)
+    
+    preferences["git"] = confirmer("\n Initialiser Git ?", defaut=True)
+    return preferences
+
+
+def afficher_resume(preferences: Dict[str, Any]):
+    print("\n" + "="*60)
+    print(" Résumé")
+    print("="*60)
+    print(f"\n   Projet: {preferences['nom_projet']}")
+    print(f"   Type: {preferences['type_projet']}")
+    if "base_donnees" in preferences:
+        print(f"    Base: {preferences['base_donnees']}")
+    if "auth" in preferences:
+        print(f"   Auth: {preferences['auth']}")
+    if preferences.get("docker"):
+        print("   Docker: ")
+    if preferences.get("stripe"):
+        print("   Stripe: ")
+    if preferences.get("email"):
+        print("   Email: ")
+    if preferences.get("celery"):
+        print("    Celery: ")
+    if preferences.get("git"):
+        print("   Git: ")
+    print("\n" + "="*60 + "\n")
+
+
+def afficher_prochaines_etapes(nom_projet: str, type_projet: str, docker: bool = False):
+    print("\n" + "="*60)
+    print(" Projet créé !")
+    print("="*60)
+    print(f"\n Prochaines étapes:\n")
+    print(f"  1. cd {nom_projet}")
+    if docker:
+        print("  2. docker-compose up --build")
+    else:
+        if type_projet == "apprentissage":
+            print("  2. python app.py")
+        else:
+            print("  2. python -m venv venv")
+            print("  3. venv\\Scripts\\activate")
+            print("  4. pip install -r requirements.txt")
+            print("  5. seo db init")
+            print("  6. seo user create")
+            print("  7. seo run")
+    print("\n Commandes:")
+    print("   seo db init     - Initialiser la base")
+    print("   seo user create - Créer un admin")
+    print("   seo run         - Lancer l'app")
+    print("\n" + "="*60 + "\n")

seo_dev_env-0.1.1/seo/commandes.py

@@ -0,0 +1,93 @@
+"""
+Commandes internes pour gérer le projet Flask
+"""
+import os
+import sys
+import subprocess
+from pathlib import Path
+
+
+def commande_db(action: str):
+    """Gestion de la base de données"""
+    if action == "init":
+        print("  Initialisation de la base...")
+        subprocess.run([sys.executable, "-m", "flask", "db", "init"])
+        print(" Base initialisée")
+    elif action == "migrate":
+        message = input("Message (optionnel): ").strip()
+        if message:
+            subprocess.run([sys.executable, "-m", "flask", "db", "migrate", "-m", message])
+        else:
+            subprocess.run([sys.executable, "-m", "flask", "db", "migrate"])
+        print(" Migration créée")
+    elif action == "upgrade":
+        subprocess.run([sys.executable, "-m", "flask", "db", "upgrade"])
+        print(" Migrations appliquées")
+    else:
+        print(f" Action '{action}' inconnue")
+
+
+def commande_user(action: str):
+    """Gestion des utilisateurs"""
+    if action == "create":
+        print(" Création admin\n")
+        username = input("Username: ").strip()
+        email = input("Email: ").strip()
+        import getpass
+        password = getpass.getpass("Password: ")
+        
+        try:
+            from app import create_app, db
+            from app.models import User
+            app = create_app()
+            with app.app_context():
+                user = User(username=username, email=email, is_admin=True)
+                user.set_password(password)
+                db.session.add(user)
+                db.session.commit()
+                print(f" Utilisateur '{username}' créé")
+        except ImportError as e:
+            print(f" Erreur: {e}")
+    elif action == "list":
+        try:
+            from app import create_app, db
+            from app.models import User
+            app = create_app()
+            with app.app_context():
+                users = User.query.all()
+                print("\n Utilisateurs:\n")
+                for user in users:
+                    print(f"   {user.username}")
+        except ImportError:
+            print(" Impossible de charger les utilisateurs")
+
+
+def commande_run(mode: str = "dev"):
+    """Lance l'application"""
+    if mode == "dev":
+        print(" Mode développement...\n")
+        os.environ["FLASK_ENV"] = "development"
+        os.environ["FLASK_DEBUG"] = "1"
+        if Path("run.py").exists():
+            subprocess.run([sys.executable, "run.py"])
+        elif Path("app.py").exists():
+            subprocess.run([sys.executable, "app.py"])
+        else:
+            subprocess.run([sys.executable, "-m", "flask", "run", "--debug"])
+
+
+def afficher_aide():
+    """Affiche l'aide"""
+    print("\n" + "="*60)
+    print(" Commandes SEO")
+    print("="*60 + "\n")
+    print("  Base de données:")
+    print("  seo db init      - Initialiser")
+    print("  seo db migrate   - Créer migration")
+    print("  seo db upgrade   - Appliquer")
+    print("\n Utilisateurs:")
+    print("  seo user create  - Créer admin")
+    print("  seo user list    - Lister")
+    print("\n Lancement:")
+    print("  seo run          - Mode dev")
+    print("\n" + "="*60 + "\n")

seo_dev_env-0.1.1/seo/generators.py

@@ -0,0 +1,335 @@
+import os
+import subprocess
+import sys
+import shutil
+from pathlib import Path
+from typing import Dict, Any
+from .utils import creer_fichier, copier_dossier
+from .cli import collecter_preferences, afficher_resume, afficher_prochaines_etapes
+
+class EnvironnementGenerator:
+    """Classe de base pour générer des environnements"""
+    
+    def __init__(self, niveau: str, type_app: str, chemin: str):
+        self.niveau = niveau
+        self.type_app = type_app
+        self.chemin_projet = Path(chemin).resolve()
+        self.packages = []
+        self.template_dir = Path(__file__).parent / 'templates' / niveau
+        
+    def _installer_dependances(self):
+        """Installe les packages nécessaires"""
+        if self.packages:
+            print(f"🔧 Installation des packages: {', '.join(self.packages)}")
+            subprocess.run([sys.executable, '-m', 'pip', 'install'] + self.packages)
+        
+    def _copier_template(self):
+        """Copie les fichiers du template"""
+        if self.template_dir.exists():
+            copier_dossier(self.template_dir, self.chemin_projet)
+        else:
+            print(f"⚠️ Avertissement: Template {self.niveau} non trouvé, création de base")
+            self._creer_structure_base()
+    
+    def _creer_structure_base(self):
+        """Crée une structure de base si le template est manquant"""
+        creer_fichier(self.chemin_projet / 'app.py', "# Votre application Flask")
+        (self.chemin_projet / 'templates').mkdir(exist_ok=True)
+        creer_fichier(self.chemin_projet / 'templates/index.html', "<h1>Bienvenue</h1>")
+        
+    def _post_creation(self):
+        """Actions supplémentaires après création"""
+        pass
+        
+    def generer(self):
+        """Méthode principale pour générer l'environnement"""
+        self.chemin_projet.mkdir(exist_ok=True, parents=True)
+        print(f"🏗️ Création de l'environnement {self.niveau} ({self.type_app})...")
+        
+        self._copier_template()
+        self._creer_structure()
+        self._installer_dependances()
+        self._post_creation()
+        
+        print(f"✅ Environnement créé avec succès dans {self.chemin_projet}")
+        print("👉 Pour démarrer: cd " + str(self.chemin_projet))
+
+class DebutantWebGenerator(EnvironnementGenerator):
+    """Générateur pour débutants - Site web simple"""
+    
+    def __init__(self, chemin):
+        super().__init__('debutant', 'web', chemin)
+        self.packages = ['flask', 'python-dotenv']
+    
+    def _creer_structure(self):
+        # Personnalisation supplémentaire
+        creer_fichier(
+            self.chemin_projet / 'README.md',
+            f"# Mon Premier Projet Flask\n\nCe projet a été créé avec SEO pour les débutants!"
+        )
+
+class IntermediaireWebGenerator(EnvironnementGenerator):
+    """Générateur intermédiaire - Applications web complètes"""
+    
+    def __init__(self, chemin):
+        super().__init__('intermediaire', 'web', chemin)
+        self.packages = [
+            'flask',
+            'flask-sqlalchemy',
+            'flask-wtf',
+            'flask-login',
+            'flask-migrate',
+            'python-dotenv'
+        ]
+    
+    def _creer_structure(self):
+        # Création de la base de données
+        db_path = self.chemin_projet / 'app.db'
+        if not db_path.exists():
+            with open(db_path, 'w') as f:
+                f.write("")
+        
+        # Création du fichier requirements
+        creer_fichier(
+            self.chemin_projet / 'requirements.txt',
+            "\n".join(self.packages)
+        )
+
+class ProWebGenerator(EnvironnementGenerator):
+    """Générateur pro - Applications professionnelles"""
+    
+    def __init__(self, chemin):
+        super().__init__('pro', 'web', chemin)
+        self.packages = [
+            'flask',
+            'flask-restx',
+            'flask-cors',
+            'flask-sqlalchemy',
+            'flask-migrate',
+            'flask-jwt-extended',
+            'python-dotenv',
+            'gunicorn',
+            'psycopg2-binary'
+        ]
+    
+    def _post_creation(self):
+        # Initialiser un dépôt Git
+        try:
+            subprocess.run(['git', 'init', str(self.chemin_projet)], check=True)
+            print("📦 Dépôt Git initialisé")
+        except:
+            print("⚠️ Git non installé, ignore l'initialisation du dépôt")
+
+# Interface simplifiée
+def creer_environnement(niveau, type_app='web', chemin='.'):
+    """
+    Crée un environnement de développement adapté
+    
+    Args:
+        niveau: 'debutant', 'intermediaire' ou 'pro'
+        type_app: 'web' ou 'mobile' (défaut: 'web')
+        chemin: Chemin où créer le projet (défaut: dossier actuel)
+    """
+    generators = {
+        'debutant': DebutantWebGenerator,
+        'intermediaire': IntermediaireWebGenerator,
+        'pro': ProWebGenerator
+    }
+    
+    if niveau not in generators:
+        raise ValueError(f"🚫 Niveau non supporté: {niveau}")
+    
+    generator = generators[niveau](chemin)
+    generator.generer()
+    
+    # Ajout des instructions spécifiques
+    if niveau == 'debutant':
+        print("\n🚀 Pour démarrer votre application:")
+        print(f"cd {chemin}")
+        print("python app.py")
+    elif niveau == 'intermediaire':
+        print("\n🚀 Pour initialiser la base de données:")
+        print(f"cd {chemin}")
+        print("flask db init")
+        print("flask db migrate")
+        print("flask db upgrade")
+        print("flask run")
+    else:
+        print("\n🚀 Pour démarrer avec Docker:")
+        print(f"cd {chemin}")
+        print("docker-compose up --build")
+
+# Alias pour une utilisation plus simple
+creer_projet = creer_environnement
+
+
+def main():
+    """Point d'entrée principal pour le CLI"""
+    import argparse
+    
+    parser = argparse.ArgumentParser(
+        description='SEO Dev Env - Générateur de projets Flask pour francophones'
+    )
+    
+    subparsers = parser.add_subparsers(dest='commande', help='Commandes disponibles')
+    
+    # Commande create (mode interactif)
+    parser_create = subparsers.add_parser('create', help='Créer un nouveau projet (mode interactif)')
+    parser_create.add_argument('nom', nargs='?', help='Nom du projet (optionnel, sera demandé si non fourni)')
+    
+    # Commandes db
+    parser_db = subparsers.add_parser('db', help='Gestion de la base de données')
+    parser_db.add_argument('action', choices=['init', 'migrate', 'upgrade', 'downgrade'])
+    
+    # Commandes user
+    parser_user = subparsers.add_parser('user', help='Gestion des utilisateurs')
+    parser_user.add_argument('action', choices=['create', 'list'])
+    
+    # Commande run
+    parser_run = subparsers.add_parser('run', help='Lancer l\'application')
+    parser_run.add_argument('mode', nargs='?', default='dev', choices=['dev', 'prod'])
+    
+    # Commande help
+    parser_help = subparsers.add_parser('help', help='Afficher l\'aide')
+    
+    args = parser.parse_args()
+    
+    # Si aucune commande, afficher l'aide
+    if not args.commande:
+        from .commandes import afficher_aide
+        afficher_aide()
+        return
+    
+    # Traiter les commandes
+    if args.commande == 'create':
+        creer_projet_interactif(args.nom)
+    
+    elif args.commande == 'db':
+        from .commandes import commande_db
+        commande_db(args.action)
+    
+    elif args.commande == 'user':
+        from .commandes import commande_user
+        commande_user(args.action)
+    
+    elif args.commande == 'run':
+        from .commandes import commande_run
+        commande_run(args.mode)
+    
+    elif args.commande == 'help':
+        from .commandes import afficher_aide
+        afficher_aide()
+
+
+def creer_projet_interactif(nom_fourni: str = None):
+    """Crée un projet en mode interactif"""
+    # Collecter les préférences
+    preferences = collecter_preferences()
+    
+    # Utiliser le nom fourni en argument si disponible
+    if nom_fourni:
+        preferences['nom_projet'] = nom_fourni
+    
+    # Afficher le résumé
+    afficher_resume(preferences)
+    
+    # Confirmer
+    from .cli import confirmer
+    if not confirmer("Créer le projet avec cette configuration ?"):
+        print("❌ Annulé")
+        return
+    
+    # Générer le projet selon le type
+    generer_selon_preferences(preferences)
+    
+    # Afficher les prochaines étapes
+    afficher_prochaines_etapes(
+        preferences['nom_projet'],
+        preferences['type_projet'],
+        preferences.get('docker', False)
+    )
+
+
+def generer_selon_preferences(preferences: Dict[str, Any]):
+    """Génère le projet selon les préférences"""
+    type_projet = preferences['type_projet']
+    nom_projet = preferences['nom_projet']
+    
+    if type_projet == 'apprentissage':
+        generator = ApprentissageGenerator(nom_projet, preferences)
+    elif type_projet == 'application':
+        generator = ApplicationGenerator(nom_projet, preferences)
+    elif type_projet == 'api':
+        generator = APIGenerator(nom_projet, preferences)
+    elif type_projet == 'saas':
+        generator = SaaSGenerator(nom_projet, preferences)
+    else:
+        raise ValueError(f"Type de projet inconnu: {type_projet}")
+    
+    generator.generer()
+
+
+class ApprentissageGenerator(EnvironnementGenerator):
+    """Générateur pour débutants"""
+    def __init__(self, nom: str, preferences: Dict[str, Any]):
+        super().__init__('debutant', 'web', nom)
+        self.preferences = preferences
+        self.packages = ['flask', 'python-dotenv']
+    
+    def _creer_structure(self):
+        creer_fichier(self.chemin_projet / 'README.md',
+                     f"# {self.preferences['nom_projet']}\n\nProjet Flask pour apprentissage")
+
+
+class ApplicationGenerator(EnvironnementGenerator):
+    """Générateur pour applications web (architecture par feature)"""
+    def __init__(self, nom: str, preferences: Dict[str, Any]):
+        super().__init__('intermediaire', 'web', nom)
+        self.preferences = preferences
+        self.packages = [
+            'flask', 'flask-sqlalchemy', 'flask-migrate',
+            'flask-wtf', 'flask-login', 'python-dotenv'
+        ]
+    
+    def _creer_structure(self):
+        creer_fichier(self.chemin_projet / 'requirements.txt', "\n".join(self.packages))
+
+
+class APIGenerator(EnvironnementGenerator):
+    """Générateur pour API professionnelles"""
+    def __init__(self, nom: str, preferences: Dict[str, Any]):
+        super().__init__('pro', 'api', nom)
+        self.preferences = preferences
+        self.packages = [
+            'flask', 'flask-restx', 'flask-cors', 'flask-sqlalchemy',
+            'flask-migrate', 'flask-jwt-extended', 'python-dotenv', 'gunicorn'
+        ]
+        if preferences.get('base_donnees') == 'postgresql':
+            self.packages.append('psycopg2-binary')
+        elif preferences.get('base_donnees') == 'mysql':
+            self.packages.append('pymysql')
+    
+    def _creer_structure(self):
+        creer_fichier(self.chemin_projet / 'requirements.txt', "\n".join(self.packages))
+
+
+class SaaSGenerator(EnvironnementGenerator):
+    """Générateur pour startup SaaS"""
+    def __init__(self, nom: str, preferences: Dict[str, Any]):
+        super().__init__('pro', 'saas', nom)
+        self.preferences = preferences
+        self.packages = [
+            'flask', 'flask-restx', 'flask-cors', 'flask-sqlalchemy',
+            'flask-migrate', 'flask-jwt-extended', 'python-dotenv', 'gunicorn'
+        ]
+        if preferences.get('stripe'):
+            self.packages.append('stripe')
+        if preferences.get('email'):
+            self.packages.append('flask-mail')
+        if preferences.get('celery'):
+            self.packages.extend(['celery', 'redis'])
+        if preferences.get('base_donnees') == 'postgresql':
+            self.packages.append('psycopg2-binary')
+    
+    def _creer_structure(self):
+        creer_fichier(self.chemin_projet / 'requirements.txt', "\n".join(self.packages))

seo_dev_env-0.1.1/seo/templates/debutant/app.py

@@ -0,0 +1,16 @@
+from flask import Flask, render_template
+
+app = Flask(__name__)
+app.config["SECRET_KEY"] = "votre-cle-secrete-changez-moi"
+
+@app.route("/")
+def accueil():
+    return render_template("index.html", titre="Bienvenue")
+
+@app.route("/a-propos")
+def a_propos():
+    return render_template("a_propos.html", titre="À propos")
+
+if __name__ == "__main__":
+    print(" Application Flask démarrée sur http://localhost:5000")
+    app.run(debug=True)

seo_dev_env-0.1.1/seo/templates/debutant/index.html

@@ -0,0 +1,46 @@
+<!DOCTYPE html>
+<html lang="fr">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>{{ titre }} - Mon Projet Flask</title>
+    <link rel="stylesheet" href="{{ url_for('static', filename='style.css') }}">
+</head>
+<body>
+    <nav>
+        <div class="container">
+            <h1> Mon Projet Flask</h1>
+            <ul>
+                <li><a href="/">Accueil</a></li>
+                <li><a href="/a-propos">À propos</a></li>
+            </ul>
+        </div>
+    </nav>
+    
+    <main class="container">
+        <h2>Bienvenue sur votre première application Flask !</h2>
+        <p>Cette application a été générée avec <strong>SEO Dev Env</strong>.</p>
+        
+        <div class="card">
+            <h3> Prochaines étapes</h3>
+            <ul>
+                <li>Personnalisez ce template dans <code>templates/index.html</code></li>
+                <li>Modifiez le style dans <code>static/style.css</code></li>
+                <li>Ajoutez de nouvelles routes dans <code>app.py</code></li>
+            </ul>
+        </div>
+        
+        <div class="card">
+            <h3> Ressources utiles</h3>
+            <ul>
+                <li><a href="https://flask.palletsprojects.com/" target="_blank">Documentation Flask</a></li>
+                <li><a href="https://jinja.palletsprojects.com/" target="_blank">Documentation Jinja2</a></li>
+            </ul>
+        </div>
+    </main>
+    
+    <footer>
+        <p>Créé avec  en utilisant Flask</p>
+    </footer>
+</body>
+</html>