Metadata-Version: 2.4
Name: python-cheats
Version: 0.1.0
Summary: CLI tool to display Python library cheat sheets in your terminal
Author-email: Mohamed NDIAYE <mintok2000@gmail.com>
License: MIT
Project-URL: Homepage, https://github.com/Moesthetics-code/python-cheats
Project-URL: Documentation, https://github.com/Moesthetics-code/python-cheats#readme
Project-URL: Repository, https://github.com/Moesthetics-code/python-cheats
Project-URL: Bug Tracker, https://github.com/Moesthetics-code/python-cheats/issues
Keywords: cheatsheet,documentation,cli,reference,python
Classifier: Development Status :: 4 - Beta
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: MIT License
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.8
Classifier: Programming Language :: Python :: 3.9
Classifier: Programming Language :: Python :: 3.10
Classifier: Programming Language :: Python :: 3.11
Classifier: Programming Language :: Python :: 3.12
Classifier: Topic :: Software Development :: Documentation
Classifier: Topic :: Utilities
Requires-Python: >=3.8
Description-Content-Type: text/markdown
License-File: LICENSE
Requires-Dist: click>=8.0.0
Requires-Dist: rich>=13.0.0
Provides-Extra: dev
Requires-Dist: pytest>=7.0.0; extra == "dev"
Requires-Dist: black>=23.0.0; extra == "dev"
Requires-Dist: flake8>=6.0.0; extra == "dev"
Requires-Dist: mypy>=1.0.0; extra == "dev"
Provides-Extra: ai
Requires-Dist: groq>=0.11.0; extra == "ai"
Dynamic: license-file

# Python Cheats

Outil CLI rapide pour afficher des fiches pratiques (cheat sheets) directement dans le terminal : Python, data science, frameworks web, DevOps, cloud, réseaux, bases de données, front-end et bien plus.

Plus de **300 fiches** prêtes à l'emploi, pagination automatique, recherche interne, menu interactif par sections, export en fichier, coloration syntaxique.

```
+----------------------------------------------------------+
|                                                            |
|                    PYTHON CHEATS                          |
|      Quick Reference for Python Libraries & Syntax         |
|                                                            |
+----------------------------------------------------------+
```

---

## Sommaire

- [Présentation](#présentation)
- [Fonctionnalités](#fonctionnalités)
- [Installation](#installation)
- [Démarrage rapide](#démarrage-rapide)
- [Utilisation détaillée](#utilisation-détaillée)
  - [Toutes les options](#toutes-les-options-cli)
  - [Recherche dans une fiche](#recherche-dans-une-fiche)
  - [Menu interactif des sections](#menu-interactif-des-sections)
  - [Pagination](#pagination)
  - [Export](#export)
  - [Head / Tail](#head--tail)
- [Liste complète des fiches disponibles (308)](#liste-complète-des-fiches-disponibles-308)
- [Structure du projet](#structure-du-projet)
- [Architecture interne](#architecture-interne)
- [Ajouter sa propre fiche](#ajouter-sa-propre-fiche)
- [Développement](#développement)
  - [Installation en mode développeur](#installation-en-mode-développeur)
  - [Lancer les tests](#lancer-les-tests)
  - [Qualité de code](#qualité-de-code)
  - [Build & publication du package](#build--publication-du-package)
- [Dépendances](#dépendances)
- [Compatibilité](#compatibilité)
- [Problèmes connus](#problèmes-connus)
- [FAQ](#faq)
- [Contribuer](#contribuer)
- [Licence](#licence)

---

## Présentation

`python-cheats` est un outil en ligne de commande, écrit en Python, qui affiche des antisèches (« cheat sheets ») formatées et colorées directement dans un terminal. L'objectif : ne plus quitter le terminal pour retrouver la syntaxe d'une boucle, la liste des méthodes `pandas`, une commande `docker`, ou la configuration d'un `nginx`.

Chaque fiche est un simple fichier `.txt` stocké dans `python_cheats/cheatsheets/`. Le CLI les charge, les met en forme avec [Rich](https://github.com/Textualize/rich) (coloration, panneaux, pagination), et propose plusieurs modes de consultation (vue complète, recherche, sections, extraits).

## Fonctionnalités

- **Affichage formaté** : panneaux colorés, mise en forme du code, titres de sections mis en évidence.
- **Pagination automatique** : les fiches longues (plus de 100 lignes par défaut) s'ouvrent dans un pager navigable (`q` pour quitter, `Entrée`/flèches pour naviguer).
- **Recherche interne** (`--search`) : filtre le contenu d'une fiche autour d'un terme donné.
- **Menu interactif par sections** (`--sections`) : navigue section par section dans une fiche longue.
- **Extraits ciblés** (`--head` / `--tail`) : n'affiche que les N premières ou dernières lignes.
- **Export** (`--export`) : sauvegarde une fiche en `.txt` ou `.md` dans le dossier courant.
- **Liste catégorisée** (`--list`) : affiche toutes les fiches disponibles regroupées par thème.
- **Mode sans couleur** (`--no-color`) et **sans bannière** (`--no-banner`) pour les scripts et environnements CI.
- **Suggestions automatiques** : en cas de faute de frappe sur un nom de fiche, l'outil propose les fiches les plus proches.
- **Compatible Windows / macOS / Linux**, avec un correctif d'encodage UTF-8 automatique sous Windows.
- **Assistant IA optionnel via Groq** (`--ask`, `--smart-search`) : pose des questions en langage naturel sur une fiche précise, ou effectue une recherche + synthèse sur l'ensemble des fiches. Fonctionnalité entièrement opt-in (voir [Fonctionnalités IA](#fonctionnalités-ia-optionnelles) ci-dessous) ; l'outil reste 100% utilisable hors-ligne sans elle.

## Installation

### Depuis PyPI (une fois publié)

```bash
pip install python-cheats
```

### Depuis les sources (ce dépôt)

```bash
git clone <url-du-depot>
cd python-cheats
pip install .
```

### Dans un environnement virtuel (recommandé)

```bash
python -m venv .venv
source .venv/bin/activate       # Linux / macOS
.venv\Scripts\activate          # Windows

pip install .
```

Après installation, la commande `python-cheats` est disponible globalement (elle est déclarée comme `console_scripts` dans `pyproject.toml`, pointant vers `python_cheats.cli:main`).

## Démarrage rapide

```bash
# Afficher la bannière et l'aide
python-cheats --help

# Lister toutes les fiches disponibles, triées par catégorie
python-cheats --list

# Afficher une fiche (pagination automatique si elle dépasse 100 lignes)
python-cheats pandas

# Rechercher un terme précis dans une fiche
python-cheats pandas --search groupby

# Naviguer une fiche longue section par section
python-cheats fastapi_ultra_mega_detail --sections
```

## Fonctionnalités IA (optionnelles)

`python-cheats` reste un outil 100% offline par défaut. Deux options permettent d'aller plus loin en s'appuyant sur [Groq](https://groq.com) (inférence LLM très rapide) quand une réponse exacte en grep ne suffit pas.

### Installation

```bash
pip install "python-cheats[ai]"
```

Puis configurez votre clé API (gratuite sur [console.groq.com/keys](https://console.groq.com/keys)) :

```bash
export GROQ_API_KEY="gsk_..."
# Ajoutez cette ligne à votre ~/.bashrc ou ~/.zshrc pour la rendre permanente
```

Sans clé configurée, `--ask` et `--smart-search` affichent un message d'erreur clair expliquant comment en obtenir une — aucune fonctionnalité existante n'est affectée.

### `--ask` — Question sur une fiche précise

Charge la fiche demandée et répond à une question en se basant **uniquement** sur son contenu (le modèle est instruit de dire "je ne sais pas" plutôt que d'inventer) :

```bash
python-cheats fastapi --ask "comment gérer l'authentification JWT ?"
python-cheats django --ask "middleware CSRF ?" --ai-model llama-3.1-8b-instant
```

### `--smart-search` — Recherche + synthèse sur toutes les fiches

Pas besoin de connaître le nom exact de la fiche : l'outil identifie localement (sans appel réseau) les 3 fiches les plus pertinentes par mots-clés, puis demande à Groq de synthétiser une réponse à partir de leur contenu, en citant ses sources :

```bash
python-cheats --smart-search "comment paginer une réponse API flask"
python-cheats --smart-search "différence entre TRUNCATE et DELETE" --ai-context 5
```

### Options associées

| Option | Description |
|---|---|
| `--ask QUESTION` | Pose une question sur le contenu de `TOPIC` (nécessite `TOPIC`) |
| `--smart-search QUERY` | Recherche + synthèse sur toutes les fiches, sans préciser `TOPIC` |
| `--ai-model MODEL` | Modèle Groq à utiliser (défaut : `llama-3.3-70b-versatile`) |
| `--ai-context N` | Nombre de fiches utilisées comme contexte pour `--smart-search` (défaut : 3) |

### Comment ça marche (architecture RAG légère)

1. **Retrieval local** (`python_cheats/ai.py::find_relevant_topics`) : scoring par mots-clés sur le nom et le contenu des fiches — aucun appel réseau, quasi instantané.
2. **Generation via Groq** : seules les fiches jugées pertinentes (contenu tronqué à ~6000 caractères chacune) sont envoyées en contexte au modèle, avec une consigne stricte de ne pas inventer d'information hors de ce contexte.

### Confidentialité

Avec `--ask` / `--smart-search`, le contenu des fiches concernées (et votre question) est envoyé à l'API Groq. N'utilisez pas ces options sur des fiches contenant des informations sensibles que vous ne souhaitez pas transmettre à un service tiers.

## Utilisation détaillée

### Toutes les options CLI

```
Usage: python-cheats [OPTIONS] [TOPIC]

  Python Cheats - Quick reference for Python libraries and syntax.

  Affiche les fiches pratiques pour les bibliothèques et la syntaxe
  Python directement dans le terminal, avec pagination automatique
  et recherche facile.

Options:
  -s, --search TERM              Recherche un terme précis dans la fiche
  -l, --list                     Liste toutes les fiches disponibles
  -e, --export [txt|md]          Exporte la fiche vers un fichier
  --no-color                     Désactive toute la coloration
  --no-banner                    Masque la bannière d'accueil
  --page / --no-page             Force la pagination on/off (auto par défaut)
  --head N                       Affiche uniquement les N premières lignes
  --tail N                       Affiche uniquement les N dernières lignes
  -sec, --sections                Affiche un menu interactif par sections
  --line-threshold N              Seuil de pagination automatique (défaut : 100 lignes)
  --version                       Affiche la version installée
  --help                          Affiche l'aide
```

Arguments positionnels :

| Argument | Description |
|---|---|
| `TOPIC` | Nom de la fiche à afficher (ex. `pandas`, `docker`, `regex`). Optionnel si `--list` est utilisé. |

### Recherche dans une fiche

```bash
python-cheats numpy --search "array"
```

Le CLI filtre le contenu autour de chaque occurrence du terme (insensible à la casse) et affiche uniquement les blocs pertinents, avec un encadré indiquant le nombre d'occurrences trouvées.

### Menu interactif des sections

```bash
python-cheats pytest_complete --sections
```

Affiche la liste numérotée des sections détectées dans la fiche (repérées par les titres marqués dans le fichier source) : choisissez un numéro pour afficher uniquement cette section, `0` pour tout afficher en mode paginé, ou `q` pour quitter.

### Pagination

Par défaut, toute fiche dépassant **100 lignes** s'ouvre automatiquement dans un pager (navigation `Entrée` / flèches / `Espace`, sortie avec `q`). Ce comportement est ajustable :

```bash
# Forcer la pagination
python-cheats django --page

# Désactiver la pagination (tout afficher d'un coup)
python-cheats django --no-page

# Changer le seuil de déclenchement automatique (ex. 200 lignes)
python-cheats django --line-threshold 200
```

### Export

```bash
# Exporter au format texte brut
python-cheats decorators --export txt

# Exporter au format markdown
python-cheats loops --export md
```

Le fichier est écrit dans le répertoire courant sous le nom `<topic>_cheatsheet.<format>`, encodé en UTF-8.

### Head / Tail

```bash
python-cheats flask --head 50      # 50 premières lignes
python-cheats django --tail 100    # 100 dernières lignes
```

`--head` et `--tail` sont mutuellement exclusifs.

## Liste complète des fiches disponibles (308)

La commande `python-cheats --list` regroupe automatiquement les fiches les plus courantes par thème. Voici l'inventaire **exhaustif** des 308 fiches présentes dans `python_cheats/cheatsheets/`, classées par domaine (le nom entre parenthèses est le nom de fichier à passer en argument, sans l'extension `.txt`) :

#### Python – cœur du langage (40)

`arg_kwarg`, `asyncio`, `builtins`, `collections`, `comprehensions`, `condition`, `context`, `dataclass`, `datetime`, `decorators`, `exceptions`, `file`, `functions`, `functools`, `generators`, `introduction_python`, `itertools`, `logging`, `loops`, `math`, `module`, `module_pro`, `os`, `pathlib`, `poo`, `poo_detail`, `poo_detail_`, `random`, `recursive`, `socket`, `socket_pro`, `subprocess`, `syntax`, `sys`, `tempfile`, `threading`, `time`, `trie`, `typer`, `yaml`

#### Data Science / Analyse de données (22)

`analyse`, `analyse_de_données`, `analyse_de_données_projet`, `analyse_de_données_projet1`, `analyse_de_données_projet2`, `analyse_de_données_projet3`, `analyse_de_données_projet4`, `analyse_de_données_projet5`, `analyse_de_données_ultra_detail`, `data`, `data_scientist`, `excel`, `machine_learning`, `matplotlib`, `matplotlib_seaborn`, `numpy`, `pandas`, `plotly`, `scikit_learn`, `scipy`, `seaborn`, `statsmodels`

#### Frameworks web Python (16)

`api`, `api_avance`, `api_flask`, `django`, `django_detail`, `exercices_fastapi`, `exercices_flask`, `fastapi`, `fastapi_ultra_mega_detail`, `flask`, `flask_mega_ultra_detail`, `gunicorn`, `jinja2`, `rest_api`, `session`, `session_flask`

#### Bases de données / ORM (19)

`asm_et_oracle`, `asm_oracle`, `base_de_donnees`, `conf_replica_set_mongodb_2`, `conf_replica_set_mongodb_5`, `conf_sharding_mongodb`, `database`, `db`, `introduction_mongo_db`, `introduction_mysql`, `introduction_oracle_et_postgresql`, `mongodb`, `mysql`, `no_sql_mongo_db`, `oracle`, `redis`, `sql`, `sqlalchemy`, `sqlalchemy_detail`

#### Tests / Qualité de code (12)

`Snyk`, `black`, `exercices_tdd`, `pytest`, `pytest_`, `pytest_detail`, `ruff`, `sonarqube`, `sonarqube_java`, `sonarqube_python`, `tdd`, `unittest`

#### HTTP / API / Web (8)

`api_gateway_custom`, `graphql`, `httpie`, `httpx`, `json`, `kong_gateway`, `navigateur`, `requests`

#### DevOps / CI-CD (40)

`Puppet`, `ansible`, `argocd`, `argocd_git_simulation`, `docker`, `docker-py`, `docker_python`, `docker_simulation`, `elk`, `elk_simulation_java`, `elk_simulation_python`, `exercices_git`, `exercices_git_github`, `exercices_versioning`, `git`, `git_github_simulation`, `git_github_simulation_`, `github_action`, `github_action_v1`, `harbor`, `jenkins`, `jenkins_all`, `jenkins_v1`, `jenkinsx`, `kubernate_simulation`, `kubernetes`, `nexus`, `nexus-detail`, `nexus_simulation`, `nomad`, `openshift`, `opentelemetry`, `podman`, `prometheus`, `prometheus_grafana_python`, `puppet-demo`, `terraform`, `terraform_ansible_simulation`, `terraform_ansible_simulation_`, `terraform_detail`

#### Cloud – AWS / Azure / PaaS (23)

`aws`, `aws-auto_scaling`, `aws_cloudwatch`, `aws_ec2`, `aws_iam`, `aws_lamda`, `aws_rds`, `aws_route_53`, `aws_s3`, `aws_vpc`, `azure`, `exercices_aws`, `exercices_aws_`, `exercices_awss`, `exo_aws`, `exo_aws_`, `firebase`, `firebase-pro`, `heroku`, `projet_aws`, `railway`, `render`, `vercel`

#### Réseaux / Système / Infra (38)

`adressage_ip`, `bash`, `communication`, `conf_apache`, `conf_apache_debutant`, `conf_bonding_lag`, `conf_dhcp`, `conf_dhcp_with_dnmask`, `conf_dns`, `conf_dns_basic`, `conf_firwall`, `conf_ip`, `conf_lamp`, `conf_linux`, `conf_nginx`, `conf_proxy`, `conf_routing`, `conf_serveur_web`, `conf_ssh`, `conf_ssh_distant`, `conf_vlan`, `exercices_adressage_ip`, `exercices_apache`, `exercices_communication`, `exercices_dhcp`, `exercices_dns`, `exercices_ftp`, `exercices_lamp`, `exercices_linux`, `exercices_nginx`, `exercices_ssh`, `linux`, `nginx_for_python`, `nginx_gataway`, `reseaux_pour_dev`, `vmware`, `vmware_pro`, `vmware_test`

#### Sécurité (2)

`cryptography`, `securite`

#### Frontend / JavaScript / Web (17)

`angular`, `beautifulsoup`, `css`, `exercices_javascript`, `html`, `html_css`, `html_css_ultra_detail`, `javascript`, `javascript_detaille`, `javascript_ultra_detail`, `nodejs_ultra_detail`, `react`, `react_ultra_detail`, `react_ultra_mega_detail`, `tailwind-css`, `tailwind_css`, `typescript_ultra_detail`

#### Autres langages / Frameworks backend (20)

`architecture`, `architecture1`, `architecture2`, `architecture_des_ordinateurs`, `architecture_trois_tiers`, `architecture_trois_tiers_avance`, `asp_net`, `asp_net_core`, `blazor`, `blazor_s`, `design_patterns`, `exercices_java`, `jee_ultra_detail`, `kafka`, `microservices`, `patterns`, `rabbit_mq`, `spring_boot_ultra_mega_detail`, `spring_ultra_detail__`, `uml`

#### Projets fil rouge (10)

`projet_fil_rouge_django`, `projet_fil_rouge_fastapi1`, `projet_fil_rouge_fastapi2`, `projet_fil_rouge_fastapi3`, `projet_fil_rouge_fastapi5`, `projet_fil_rouge_flask`, `projet_fil_rouge_flutter`, `projet_fil_rouge_jee`, `projet_fil_rouge_spring`, `projet_fil_rouge_spring___`

#### Divers / Outils / Théorie (41)

`add`, `add_`, `analogie-compilation1`, `analogie_compilation`, `argparse`, `babel`, `cerely`, `design_thinking`, `documentation`, `examen_conf`, `exercices_programmation_lineaire`, `exercices_python`, `exercices_stack`, `exercices_theorie_des_jeux`, `faker`, `ipython`, `performance`, `pip`, `pl_appliquee`, `programmation_lineaire`, `programmation_lineaire` *(variante détaillée)*, `programmation_lineaire_avancee`, `pulp`, `pydantic`, `pyomo`, `pypdf`, `pyqt5`, `regex`, `ri`, `schedule`, `scrum`, `streamlit`, `stripe`, `stripe_pro`, `theorie_des_jeux_pro`, `theorie_des_graphes`, `theorie_des_jeux`, `tkinter`, `twisted`, `urllib`, `virtualenv`

> **Total : 308 fiches**, organisées en 15 grandes catégories.

> **Remarque sur l'encodage des noms de fichiers** : quelques fichiers contenant un accent dans leur nom d'origine (ex. `analyse_de_données`, `réseaux_pour_dev`, `théorie_des_jeux_pro`) ont été ré-encodés lors d'une compression/décompression sous Windows et apparaissent sur disque avec des séquences du type `#U00e9` à la place de `é`. Le contenu des fichiers n'est pas affecté, seul le **nom de fichier** l'est. Pour les invoquer avec `python-cheats`, utilisez le nom de fichier exact tel qu'il apparaît sur le disque (`python-cheats --list` affichera le nom réellement utilisable). Un script de renommage est fourni ci-dessous si vous souhaitez corriger ces noms :
>
> ```bash
> cd python_cheats/cheatsheets
> for f in *'#U'*; do
>   new=$(python3 -c "import sys,re; print(re.sub(r'#U([0-9a-fA-F]{4,6})', lambda m: chr(int(m.group(1),16)), sys.argv[1]))" "$f")
>   mv -- "$f" "$new"
> done
> ```

## Structure du projet

```
python-cheats/
├── pyproject.toml              # Configuration moderne du projet (PEP 621)
├── setup.py                    # Compatibilité setuptools historique
├── requirements.txt            # Dépendances de développement
├── MANIFEST.in                 # Fichiers additionnels inclus dans le package
├── LICENSE                     # Licence MIT
├── README.md                   # Ce fichier
├── python_cheats/
│   ├── __init__.py             # Point d'entrée du module
│   ├── cli.py                  # Interface en ligne de commande (Click + Rich)
│   ├── core.py                 # Logique métier : CheatSheetManager
│   ├── requirements.txt
│   └── cheatsheets/            # 308 fiches pratiques au format .txt
│       ├── pandas.txt
│       ├── numpy.txt
│       ├── flask.txt
│       ├── docker.txt
│       ├── ...
│       └── kubernetes.txt
├── python_cheats.egg-info/     # Métadonnées générées par setuptools
└── tests/
    ├── __init__.py
    └── test_core.py            # Tests unitaires du CheatSheetManager
```

## Architecture interne

### `python_cheats/core.py` — `CheatSheetManager`

Classe centrale, responsable de l'accès aux fiches sur disque :

| Méthode | Rôle |
|---|---|
| `list_available()` | Liste tous les fichiers `.txt` du dossier `cheatsheets/` (triés alphabétiquement). |
| `get_cheatsheet(topic)` | Lit et retourne le contenu d'une fiche (`utf-8-sig`, gère le BOM). Retourne `None` si le fichier n'existe pas. |
| `search_in_content(content, term)` | Filtre le contenu ligne par ligne autour des occurrences du terme recherché (insensible à la casse). |
| `add_cheatsheet(topic, content)` | Crée ou met à jour une fiche. |
| `apply_syntax_highlighting(content)` | Détecte les blocs de code indentés (4 espaces) et les titres de section, applique une coloration Python via `rich.syntax.Syntax` (thème `monokai`). |

### `python_cheats/cli.py` — Interface CLI

Construit avec [Click](https://click.palletsprojects.com/) pour le parsing des arguments/options, et [Rich](https://github.com/Textualize/rich) pour tout le rendu terminal (bannière, tableaux, panneaux, pager). Les fonctions clés :

- `print_banner()` — bannière d'accueil.
- `print_available_sheets(sheets)` — tableau catégorisé des fiches (`--list`).
- `format_content_simple(content, no_color)` — mise en forme légère (titres, commentaires, blocs de code).
- `show_sections_menu(manager, topic, content, no_color)` — menu interactif (`--sections`).
- `main(...)` — point d'entrée (`@click.command`), orchestre toutes les options.

Convention interne : dans les fichiers source des fiches, une ligne commençant par un symbole dédié (marqueur de titre) délimite le début d'une nouvelle section, utilisé à la fois pour la coloration (`core.py`) et pour la détection des sections du menu interactif (`cli.py`).

## Ajouter sa propre fiche

1. Créez un fichier texte dans `python_cheats/cheatsheets/`, nommé `<mon_sujet>.txt`.
2. Structurez le contenu avec des titres de section clairement identifiables et du code indenté de 4 espaces pour bénéficier de la coloration automatique.
3. Vérifiez qu'elle apparaît :
   ```bash
   python-cheats --list
   python-cheats mon_sujet
   ```
4. Ajoutez-la dans une catégorie du tableau de `print_available_sheets()` (`cli.py`) si vous voulez qu'elle apparaisse groupée avec les fiches phares dans `--list`.
5. (Optionnel) Ajoutez un test dans `tests/test_core.py`.

Vous pouvez aussi passer par l'API Python :

```python
from python_cheats.core import CheatSheetManager

manager = CheatSheetManager()
manager.add_cheatsheet("mon_sujet", "Contenu de ma fiche...")
```

## Développement

### Installation en mode développeur

```bash
git clone <url-du-depot>
cd python-cheats
pip install -e ".[dev]"
```

Cela installe le package en mode éditable ainsi que les dépendances de développement (`pytest`, `black`, `flake8`, `mypy`).

### Lancer les tests

```bash
pytest
pytest -v                    # mode verbeux
pytest tests/test_core.py    # un seul fichier
pytest --cov=python_cheats   # couverture (nécessite pytest-cov)
```

### Qualité de code

```bash
black python_cheats/         # formatage automatique
flake8 python_cheats/        # lint
mypy python_cheats/          # vérification de types
```

### Build & publication du package

```bash
python -m build              # génère dist/*.whl et dist/*.tar.gz
twine check dist/*           # vérifie le package avant publication
twine upload dist/*          # publie sur PyPI
```

## Dépendances

**Exécution**

| Paquet | Version minimale | Usage |
|---|---|---|
| `click` | >= 8.0 | Parsing des arguments et options CLI |
| `rich` | >= 13.0 | Rendu terminal (panneaux, tableaux, pager, coloration) |

**Développement**

| Paquet | Version minimale | Usage |
|---|---|---|
| `pytest` | >= 7.0 | Tests unitaires |
| `build` | >= 1.0 | Construction du package |
| `twine` | >= 4.0 | Publication sur PyPI |
| `black` | >= 24.0 | Formatage automatique |
| `flake8` | >= 6.0 | Lint |
| `mypy` | >= 1.0 | Vérification de types statiques |

Python **3.8 ou supérieur** est requis (voir `requires-python` dans `pyproject.toml`).

## Compatibilité

- **Linux / macOS** : fonctionne nativement dans tout terminal moderne (UTF-8).
- **Windows** : `cli.py` reconfigure automatiquement `stdout`/`stderr` en UTF-8 au démarrage pour éviter les problèmes d'affichage sur `cmd.exe` et PowerShell.
- **Terminaux sans support étendu / SSH minimal** : utilisez `--no-color` pour un rendu texte brut ; le contenu des fiches lui-même est en ASCII pur (voir la note ci-dessous), ce qui garantit un affichage correct même sur les terminaux les plus limités.

> Les fiches `.txt` ont été nettoyées de toute icône/emoji codée en dur (✅, ➡, 📊, etc.), qui s'affichait de façon incohérente selon les terminaux, polices et systèmes d'exploitation. Elles ont été remplacées par des équivalents ASCII lisibles partout (`[OK]`, `->`, `[ATTENTION]`, `*`, etc.), afin de garantir un rendu fiable en toutes circonstances.

## Problèmes connus

- Certains noms de fichiers de fiches contiennent des séquences `#Uxxxx` à la place d'un caractère accentué, suite à un problème d'encodage lors d'une compression/décompression sous Windows (voir la note dans la [liste des fiches](#liste-complète-des-fiches-disponibles-308)). Le contenu des fiches n'est pas impacté.
- Certaines fiches existent en plusieurs variantes proches (ex. `pytest`, `pytest_`, `pytest_detail`, ou `terraform_ansible_simulation` / `terraform_ansible_simulation_`), résultat de versions successives conservées côte à côte. Un nettoyage/fusion futur est envisageable.
- `--head` et `--tail` ne peuvent pas être combinés (erreur explicite affichée si tentative).

## FAQ

**Comment savoir si une fiche existe pour un sujet donné ?**
`python-cheats --list` puis cherchez le nom, ou utilisez `python-cheats <sujet approximatif>` : en cas d'échec, l'outil suggère automatiquement les fiches au nom proche.

**Puis-je désactiver la pagination par défaut ?**
Oui : `python-cheats <sujet> --no-page`, ou changez le seuil avec `--line-threshold`.

**Comment exporter toutes les fiches d'un coup ?**
Pas de commande dédiée pour l'instant ; vous pouvez scripter avec :
```bash
for f in python_cheats/cheatsheets/*.txt; do
  topic=$(basename "$f" .txt)
  python-cheats "$topic" --export md --no-banner --no-page > /dev/null
done
```

**Le texte affiché est illisible / plein de caractères bizarres dans mon terminal.**
Assurez-vous que votre terminal est configuré en UTF-8. Le contenu des fiches a été nettoyé de tout emoji/icône non standard ; si le problème persiste, utilisez `--no-color` pour un rendu texte brut.

## Contribuer

Les contributions sont les bienvenues, en particulier pour :
- Ajouter de nouvelles fiches ou compléter les fiches existantes.
- Corriger les noms de fichiers mal encodés (voir [Problèmes connus](#problèmes-connus)).
- Fusionner les fiches en double / quasi-doublons.
- Améliorer la détection des sections et la coloration syntaxique.

Processus suggéré :
1. Forkez le dépôt.
2. Créez une branche (`git checkout -b feature/ma-fiche`).
3. Committez vos changements (`git commit -m "Ajout fiche X"`).
4. Poussez la branche (`git push origin feature/ma-fiche`).
5. Ouvrez une Pull Request.

## Licence

Distribué sous licence **MIT**. Voir le fichier [`LICENSE`](LICENSE) pour le texte complet.
