seo-dev-env 0.1.0__py3-none-any.whl

seo/__init__.py

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

seo/generators.py

@@ -0,0 +1,161 @@
+import os
+import subprocess
+import sys
+import shutil
+from pathlib import Path
+from .utils import creer_fichier, copier_dossier
+
+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

seo/utils.py

@@ -0,0 +1,24 @@
+import os
+from pathlib import Path
+
+def creer_fichier(chemin, contenu):
+    """Crée un fichier avec le contenu spécifié"""
+    chemin = Path(chemin)
+    chemin.parent.mkdir(parents=True, exist_ok=True)
+    with open(chemin, 'w', encoding='utf-8') as f:
+        f.write(contenu)
+
+def copier_dossier(source, destination):
+    """Copie récursivement un dossier"""
+    source = Path(source)
+    destination = Path(destination)
+    
+    destination.mkdir(parents=True, exist_ok=True)
+    
+    for item in source.iterdir():
+        dest_item = destination / item.name
+        if item.is_dir():
+            copier_dossier(item, dest_item)
+        else:
+            with open(item, 'r', encoding='utf-8') as src_file:
+                creer_fichier(dest_item, src_file.read())

seo_dev_env-0.1.0.dist-info/METADATA

@@ -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.)
+

seo_dev_env-0.1.0.dist-info/RECORD

@@ -0,0 +1,26 @@
+seo/__init__.py,sha256=UZS5pTtyPZ4-3JGGZSgfEKl8aTTFY9IsiM6gvwKRMzA,110
+seo/generators.py,sha256=E2lTwkZNvtJiT4FyC3tMt_wDJaPGBxjVmvXTaxORwuo,5755
+seo/utils.py,sha256=ocTb_CotkmmB_5aZSZXGCG_gJNaC9GdvZFb2ayWHaLE,794
+seo/templates/debutant/app.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+seo/templates/debutant/index.html,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+seo/templates/debutant/style.css,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+seo/templates/intermediaire/config.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+seo/templates/intermediaire/run.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+seo/templates/intermediaire/app/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+seo/templates/intermediaire/app/models.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+seo/templates/intermediaire/app/routes.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+seo/templates/pro/docker-compose.yml,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+seo/templates/pro/app/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+seo/templates/pro/app/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+seo/templates/pro/app/api/v1/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+seo/templates/pro/app/api/v1/endpoints.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+seo/templates/pro/app/core/config.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+seo/templates/pro/app/core/security.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+seo/templates/pro/app/db/base.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+seo/templates/pro/app/db/models.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+seo_dev_env-0.1.0.dist-info/licenses/LICENSE.ls,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+seo_dev_env-0.1.0.dist-info/METADATA,sha256=bKC9Xe9jcyCuwYf93L9W3o0-JAPJp268E_48UuIFWK8,13961
+seo_dev_env-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+seo_dev_env-0.1.0.dist-info/entry_points.txt,sha256=lrqV5FhVM9pbEiYK-U9rtiWP1ZaUditqz9hpnLxy9E4,51
+seo_dev_env-0.1.0.dist-info/top_level.txt,sha256=5WsA3DhwhBGXTOKiKgDtiTUjXlpLk4oeUvrSKrtRFoQ,4
+seo_dev_env-0.1.0.dist-info/RECORD,,

seo_dev_env-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

seo_dev_env-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+seo-create = seo.generators:main

seo_dev_env-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+seo