Metadata-Version: 2.4
Name: py_gpi
Version: 0.1.0
Summary: Générateur de Projet Intelligent – Créez des projets backend prêts à l'emploi
License: MIT
Requires-Python: >=3.8
Description-Content-Type: text/markdown
Requires-Dist: typer>=0.9.0
Requires-Dist: rich>=13.0.0
Requires-Dist: jinja2>=3.1.0
Requires-Dist: pydantic>=2.0.0
Requires-Dist: pyyaml>=6.0

# 🚀 GPI – Générateur de Projet Intelligent

**Crée un projet backend complet en 30 secondes.**

GPI te pose quelques questions simples, puis génère tout le code pour toi :
fichiers, dossiers, base de données, authentification, Docker… **prêt à lancer.**

---

## 📦 Installation

Ouvre un terminal (invite de commandes) et tape :

```bash
pip install gpi
```

> **⚠️ Sur Windows**, si tu vois « accès refusé » :
> - Clique droit sur **Terminal** ou **PowerShell** → **Exécuter en tant qu'administrateur**
> - Puis relance `pip install gpi`
>
> **⚠️ Sur Mac/Linux**, si « permission denied » :
> ```bash
> pip install --user gpi
> ```

**Vérifie que ça marche :**
```bash
gpi version
```
Tu dois voir `GPI v0.1.0`.

---

## 🎬 Utilisation rapide (2 minutes)

### Méthode 1 : Mode interactif (le plus simple)

```bash
gpi init
```

GPI te pose les questions une par une :

```
🔧 Quel framework souhaitez-vous utiliser ?
  1. fastapi – Moderne, asynchrone, idéal pour API rapides
  2. flask – Léger et flexible, parfait pour prototypes
  3. django – Tout-en-un, idéal pour applications complexes
  Votre choix (1-3) : 1

🏗️  Quelle architecture ?
  1. monolithique – Un seul projet, simple à démarrer
  2. microservices – Plusieurs services indépendants (avancé)
  Votre choix (1-2) : 1

🎓 Quel est votre niveau ?
  1. debutant – Projet simple et bien expliqué
  2. intermediaire – Plus d'options techniques
  3. expert – Architecture production-ready
  Votre choix (1-3) : 1

📁 Nom du projet : monapi
📝 Description : Ma première API
🔐 Ajouter l'authentification JWT ? : oui
📂 Organisation des routes CRUD : 1
🌐 Langue des commentaires : 1 (Français)

⏳ Génération en cours...
✅ Projet généré avec succès dans "monapi"
```

### Méthode 2 : Avec un fichier de configuration

Crée un fichier `projet.yaml` :

```yaml
framework: fastapi
architecture: monolithique
niveau: debutant
nom: monapi
description: "Ma première API"
auth: jwt
database: sqlite
route_org: single
langue: fr
tests: true
```

Puis lance :

```bash
gpi init --config projet.yaml
```

---

## 🏃 Lancer le projet généré

### FastAPI
```bash
cd monapi
pip install -r requirements.txt
uvicorn main:app --reload --host 0.0.0.0 --port 8000
```
Ouvre http://localhost:8000/docs dans ton navigateur → tu verras toutes les routes.

### Flask
```bash
cd monapi
pip install -r requirements.txt
python run.py
```

### Django
```bash
cd monapi
pip install -r requirements.txt
python manage.py migrate
python manage.py runserver 0.0.0.0:8000
```

---

## 📱 Tester depuis ton téléphone

GPI détecte automatiquement l'adresse IP de ton ordinateur.
Après la génération, il t'affiche quelque chose comme :

```
📱 Mobile : http://192.168.1.20:8000
```

**Pour que ça marche :**
1. Ton téléphone doit être sur le **même Wi-Fi** que ton PC.
2. Ouvre l'URL dans le navigateur de ton téléphone.
3. Si ça ne marche pas → vérifie ton **pare-feu** (désactive-le temporairement pour tester).

---

## 🎓 Les 3 niveaux expliqués

### 🟢 Débutant
- Questions simples (nom, auth oui/non, langue)
- Base de données SQLite (rien à installer)
- Code très commenté en français
- **Parfait pour apprendre**

### 🟡 Intermédiaire
- Choix de la base de données (SQLite ou PostgreSQL)
- Tests unitaires
- Docker pour la base de données
- Organisation personnalisable des routes
- Commentaires fr/en/bilingue

### 🔴 Expert
- Microservices avec Docker Compose complet
- Cache Redis
- File d'attente (Celery/RQ)
- Monitoring (Prometheus/Grafana)
- Tests unitaires + intégration

---

## 📁 Ce que GPI génère

### FastAPI monolithique (exemple)

```
monapi/
├── .env                 ← Variables secrètes (NE PAS partager)
├── .env.example         ← Modèle pour les autres développeurs
├── .gitignore           ← Fichiers ignorés par Git
├── README.md            ← Documentation de ton projet
├── requirements.txt     ← Liste des packages à installer
├── main.py              ← Point d'entrée de l'application
├── database.py          ← Connexion à la base de données
├── models/
│   └── item.py          ← Définition des tables
├── schemas/
│   └── item.py          ← Validation des données entrantes
├── routers/
│   └── items.py         ← Routes API (GET, POST, PUT, DELETE)
├── auth/                ← (si authentification activée)
│   ├── security.py      ← Hachage des mots de passe + JWT
│   └── routes.py        ← Inscription, connexion, profil
└── tests/               ← (si tests activés)
    └── test_items.py    ← Tests automatiques
```

### Microservices (exemple)

```
monprojet/
├── docker-compose.yml   ← Lance tous les services d'un coup
├── .env                 ← Variables partagées
├── README.md
└── services/
    ├── auth/            ← Service d'authentification
    │   ├── main.py
    │   ├── Dockerfile
    │   └── ...
    ├── users/           ← Service utilisateurs
    │   └── ...
    └── products/        ← Service produits
        └── ...
```

---

## 🔧 Options de la commande

| Commande | Description |
|----------|-------------|
| `gpi init` | Lance l'assistant interactif |
| `gpi init -c projet.yaml` | Génère depuis un fichier config |
| `gpi init --no-network` | Désactive la détection IP réseau |
| `gpi version` | Affiche la version |
| `gpi --help` | Affiche l'aide |

---

## 📝 Référence des options du fichier YAML

| Clé | Valeurs possibles | Défaut |
|-----|-------------------|--------|
| `framework` | `fastapi`, `flask`, `django` | `fastapi` |
| `architecture` | `monolithique`, `microservices` | `monolithique` |
| `niveau` | `debutant`, `intermediaire`, `expert` | `debutant` |
| `nom` | Lettres, chiffres, _ (pas d'espace) | `monapi` |
| `description` | Texte libre | `""` |
| `auth` | `jwt`, `sessions`, `oauth2`, `aucune` | `aucune` |
| `database` | `sqlite`, `postgresql`, `mysql` | `sqlite` |
| `route_org` | `single` (1 fichier), `split` (4 fichiers) | `single` |
| `langue` | `fr`, `en`, `bilingue` | `fr` |
| `tests` | `true`, `false` | `false` |
| `docker` | `true`, `false` | `false` |
| `services` | Liste de noms (microservices) | `[auth, users]` |
| `redis` | `true`, `false` | `false` |
| `queue` | `celery`, `rq`, `aucune` | `aucune` |
| `monitoring` | `true`, `false` | `false` |
| `port` | Numéro de port | `8000` |

---

## ❓ Problèmes courants

### « gpi : commande introuvable »
Le dossier d'installation Python n'est pas dans le PATH.
```bash
# Solution : lance avec python -m
python -m gpi init
```
Ou ajoute le dossier Scripts de Python au PATH de ton système.

### « Permission denied » / « Accès refusé »
- **Windows** : ouvre le terminal en tant qu'**administrateur**
- **Mac/Linux** : utilise `sudo gpi init` ou change de dossier (`cd ~/projets`)

### « Le port 8000 est déjà utilisé »
Un autre programme utilise ce port. Change-le :
```bash
# FastAPI
uvicorn main:app --reload --port 8001
# Django
python manage.py runserver 0.0.0.0:8001
```

### « Mon téléphone ne peut pas se connecter »
1. Vérifie que tu es sur le **même réseau Wi-Fi**
2. Vérifie que le **pare-feu** autorise le port
3. Retrouve ton IP manuellement :
   - Windows : `ipconfig` → cherche « IPv4 »
   - Mac/Linux : `ifconfig` ou `ip addr`

---

## 🧪 Lancer les tests de GPI

```bash
pip install pytest
python -m pytest tests/ -v
```

---

## 📄 Licence

MIT – Libre d'utilisation, modification et distribution.

---

Fait avec ❤️ par l'équipe GPI.
