■ WoodAI

Du Python Théorique au Projet Réel

Guide pratique complet — Construire une application IA de A à Z

Auteur : Babatoundé David IDOHOU

Institution : Université d'Abomey-Calavi, Bénin
Niveau : Licence 3 — Mathématiques, Informatique et Applications
Projet : WoodAI — IA pour artisans menuisiers africains
Version : 1.0 — 2026

■ Ce guide documente chaque étape de la construction réelle du projet WoodAI. Il est

conçu pour tout étudiant qui connaît Python théoriquement mais n'a jamais appliqué ses
connaissances sur un vrai projet. Chaque notion est expliquée dans le contexte de son
utilisation concrète.
 Table des Matières

Chapitre 1 Philosophie du projet — Passer de la théorie à la pratique 4

Chapitre 2 Préparer son environnement de travail 6

Chapitre 3 Architecture d'un projet Python professionnel 9

Chapitre 4 Module 1 — L'optimiseur de découpe (Algorithmique) 12

Chapitre 5 Module 2 — Le valorisateur de chutes (Données) 17

Chapitre 6 L'interface utilisateur avec Streamlit 22

Chapitre 7 Les tests — Pourquoi et comment tester son code 27

Chapitre 8 Sécurité et qualité du code 31

Chapitre 9 Déployer son application en ligne 35

Chapitre 10 Méthode — Comment aborder tout nouveau projet 39

Annexe A Commandes essentielles Windows/PowerShell 43

Annexe B Erreurs fréquentes et solutions 45

Annexe C Ressources pour aller plus loin 47

 Chapitre 1 — Philosophie du Projet : De la Théorie à la Pratique

1.1 Le problème de l'enseignement théorique

Dans la plupart des universités africaines, Python s'enseigne comme une liste de notions :
les variables, les boucles, les fonctions, les classes... Les étudiants apprennent la syntaxe,
passent les examens, mais n'ont jamais construit quelque chose de réel. Résultat : à la fin
de la licence, on sait ce qu'est une fonction mais on ne sait pas comment organiser 5
fonctions pour qu'elles travaillent ensemble.

Ce guide part du principe inverse : on commence par le projet réel, et on explique les
notions au moment où elles apparaissent. C'est la méthode la plus efficace pour ancrer les
connaissances.

1.2 Ce qu'on a construit — WoodAI

WoodAI est une application d'intelligence artificielle conçue pour les artisans menuisiers
africains. Elle résout deux problèmes concrets observés dans l'atelier de Clément
IDOHOU, maître menuisier depuis 34 ans au Bénin :

Le gaspillage de bois par découpe non optimisée. Un menuisier coupe intuitivement et

Problème 1 perd souvent 30 à 40% de sa matière première.

Les chutes non valorisées. Les morceaux restants après découpe sont brûlés ou jetés,
Problème 2 alors qu'ils pourraient devenir des objets vendables.

1.3 Les notions Python mobilisées

Voici un tableau de toutes les notions Python utilisées dans ce projet, avec le chapitre où
elles sont expliquées :

Notion Utilisée pour Chapitre

Fonctions Organiser la logique de calcul 4

Dictionnaires Stocker les résultats structurés 4

Listes et tuples Stocker les pièces et chutes 4

pandas (DataFrame) Lire et manipuler les données CSV 5

Modules et imports Organiser le code en fichiers séparés 3

Environnements virtuels Isoler les dépendances du projet 2

Streamlit Créer l'interface utilisateur 6

pytest Tester automatiquement le code 7

Gestion des chemins

Accéder aux fichiers de façon portable 5
(os)
 Chapitre 2 — Préparer son Environnement de Travail

2.1 Pourquoi préparer un environnement ?

Un projet Python professionnel ne se lance jamais directement avec Python global installé
sur l'ordinateur. On crée toujours un environnement virtuel — une sorte de bulle isolée où
les bibliothèques installées n'interfèrent pas avec d'autres projets.

■ Analogie : Imagine que tu cuisines deux plats différents. Le premier nécessite du sel, le
second ne doit absolument pas en avoir. Si tu cuisines dans la même casserole sans la
laver, tu contamines le second plat. L'environnement virtuel, c'est avoir deux casseroles
séparées.

2.2 Les outils nécessaires

• Python 3.10+ — Le langage de programmation ([Link]
• VS Code — L'éditeur de code recommandé ([Link]
• pip — Le gestionnaire de bibliothèques Python (Inclus avec Python)
• Git — La gestion de versions (optionnel mais conseillé) ([Link]

2.3 Créer l'environnement virtuel — Pas à pas

Ouvrir le terminal VS Code
Étape 1 Raccourci : Ctrl + ` (la touche en haut à gauche du clavier)

Créer le dossier projet

Étape 2 mkdir woodai cd woodai

Créer l'environnement virtuel

Étape 3 python -m venv venv

Activer l'environnement (Windows)

Étape 4 venv\Scripts\activate

Vérifier l'activation
Étape 5 Tu dois voir (venv) au début de la ligne du terminal

Installer les bibliothèques

Étape 6 pip install streamlit pandas ortools pytest
 Vérifier l'installation
Étape 7 python -c "import streamlit; print('OK')"

2.4 Erreur fréquente — Le module venv ne charge pas

Sur Windows, PowerShell bloque par défaut l'exécution de scripts. Si vous voyez l'erreur
'Le module venv n'a pas pu être chargé', exécutez cette commande une seule fois :

Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser

Tapez O puis Entrée pour confirmer. Ce paramètre est permanent — vous n'aurez pas à le
refaire sur cet ordinateur.
 Chapitre 3 — Architecture d'un Projet Python Professionnel

3.1 Pourquoi organiser son code ?

Un débutant met tout son code dans un seul fichier. Ça fonctionne pour 50 lignes. Pour un
vrai projet, c'est catastrophique : impossible à lire, impossible à tester, impossible à
maintenir. Un projet professionnel sépare le code en modules selon leur rôle.

3.2 La structure de WoodAI expliquée

woodai/
■■■ [Link] ← Point d'entrée, interface utilisateur
■■■ lancer_woodai.bat ← Lanceur double-clic Windows
■■■ venv/ ← Environnement virtuel (ne pas toucher)
■■■ modules/
■ ■■■ __init__.py ← Déclare 'modules' comme package Python
■ ■■■ [Link] ← Module 1 : calcul d'optimisation
■ ■■■ [Link] ← Module 2 : suggestions d'objets
■■■ data/
■ ■■■ [Link] ← Base de données des objets réalisables
■■■ tests/
■■■ __init__.py ← Déclare 'tests' comme package Python
■■■ test_optimiseur.py ← Tests du module 1
■■■ test_valorisateur.py← Tests du module 2

3.3 Le rôle de __init__.py

Le fichier __init__.py est souvent incompris des débutants. C'est un fichier vide dont le seul
rôle est de dire à Python : 'ce dossier est un package, tu peux importer des modules
depuis lui.' Sans ce fichier, Python ne pourra pas trouver vos modules quand vous écrirez
'from [Link] import ...'.

■■ Erreur classique : ModuleNotFoundError: No module named 'modules' Cause : Le

fichier modules/__init__.py est absent ou le terminal n'est pas dans le bon dossier.
Solution : Vérifier que __init__.py existe et utiliser 'python -m pytest' plutôt que 'python
tests/[Link]' directement.

3.4 Créer la structure sur Windows (PowerShell)

Sur PowerShell Windows, certaines commandes Unix classiques ne fonctionnent pas de la
même façon. Voici les commandes correctes :

# Créer les dossiers (un par un sur PowerShell)

mkdir data
mkdir modules
mkdir tests

# Créer les fichiers vides

New-Item [Link] -ItemType File
New-Item modules\[Link] -ItemType File
New-Item modules\[Link] -ItemType File
New-Item data\[Link] -ItemType File
New-Item tests\test_optimiseur.py -ItemType File
New-Item modules\__init__.py -ItemType File
New-Item tests\__init__.py -ItemType File

■ Différence Unix/Windows : Sur Linux/Mac, 'mkdir a b c' crée 3 dossiers en une

commande. Sur PowerShell Windows, il faut les créer un par un. Si vous voyez 'Impossible
de trouver un paramètre positionnel', c'est cette raison.
 Chapitre 4 — Module 1 : L'Optimiseur de Découpe

4.1 Le problème mathématique

L'optimisation de découpe est un problème classique en recherche opérationnelle appelé
'Cutting Stock Problem' (Problème de découpe). L'objectif est de découper des pièces
dans une matière première (une planche) en minimisant les pertes.

Dans notre version simplifiée, on calcule :

• La surface totale de la planche disponible

• La surface cumulée de toutes les pièces à découper
• La surface de chute = surface totale - surface utilisée
• Le pourcentage d'utilisation = (surface utilisée / surface totale) × 100
• Les pièces qui ne rentrent pas dans la planche (dimensions dépassées)

4.2 Le code complet expliqué ligne par ligne

 def optimiser_decoupe(longueur_planche, largeur_planche, pieces):
# Calcul de la surface totale disponible
surface_totale = longueur_planche * largeur_planche
surface_utilisee = 0
plan = [] # Liste des pièces qui rentrent
chutes = [] # Liste des pièces qui ne rentrent pas

for piece in pieces:

long_piece, larg_piece, nom = piece # Décompactage du tuple

# Vérification dimensionnelle
if long_piece <= longueur_planche and larg_piece <= largeur_planch
e:
surface_piece = long_piece * larg_piece
surface_utilisee += surface_piece
[Link]({
"nom": nom,
"longueur": long_piece,
"largeur": larg_piece,
"surface": surface_piece
})
else:
[Link]({
"nom": nom,
"statut": "Ne rentre pas dans la planche"
})

# Calculs finaux
surface_chute = surface_totale - surface_utilisee
pourcentage_utilise = round((surface_utilisee / surface_totale) * 100,
2)
pourcentage_chute = round(100 - pourcentage_utilise, 2)

return {
"planche": {"longueur": longueur_planche, "largeur": largeur_planc
he,
"surface_totale": surface_totale},
"plan": plan,
"surface_utilisee": surface_utilisee,
"surface_chute": surface_chute,
"pourcentage_utilise": pourcentage_utilise,
"pourcentage_chute": pourcentage_chute,
"chutes": chutes
}

4.3 Notions Python utilisées ici

 Notion Syntaxe Explication

def nom_fonction(param1, Regroupe une logique réutilisable en lui donnant

Définition de fonction
param2): un nom

Décompactage de
long, larg, nom = piece Extraire les valeurs d'un tuple en une seule ligne
tuple

Initialiser une liste avant de la remplir avec

Liste vide plan = []
.append()

{"nom": "Plateau", Stocker des données structurées avec des clés

Dictionnaire
"surface": 4000} nommées

surface_utilisee +=
Opérateur += Ajouter une valeur à une variable existante
surface_piece

Fonction round() round(33.333, 2) Arrondir un nombre à N décimales

Return dict return {...} Retourner un dictionnaire avec tous les résultats
 Chapitre 5 — Module 2 : Le Valorisateur de Chutes

5.1 Le concept — Données terrain

Ce module est le cœur de l'intelligence de WoodAI. Il utilise une base de données d'objets
réalisables — construite à partir de l'expertise réelle de Clément IDOHOU — pour
suggérer quoi fabriquer avec les chutes disponibles. C'est un système de recommandation
basé sur les contraintes dimensionnelles.

5.2 La base de données CSV

Le fichier data/[Link] contient la liste des objets réalisables avec leurs dimensions
minimales requises et leur prix de vente estimé :

nom,longueur_min,largeur_min,description,prix_vente_fcfa
Cadre photo petit,20,15,Cadre photo pour petites photos,1500
Cadre photo grand,30,20,Cadre photo pour grandes photos,2500
Tabouret enfant,25,25,Petit tabouret pour enfant,3000
Étagère murale,40,15,Petite étagère murale,4000
Boîte décorative,15,10,Boîte en bois décorative,2000
Porte-stylos,10,10,Porte-stylos en bois pour bureau,1000
Planche à découper,30,20,Planche à découper cuisine,2500
Dessous de plat,15,15,Dessous de plat en bois,1200
Support téléphone,10,8,Support téléphone en bois,1500
Miroir cadre petit,25,20,Cadre pour petit miroir,3000

5.3 Pourquoi utiliser un CSV ?

Un fichier CSV (Comma-Separated Values) est la façon la plus simple de stocker des
données tabulaires. Les avantages pour WoodAI :

• Clément IDOHOU peut l'enrichir lui-même sans programmer

• Modifiable avec Excel, Google Sheets, ou n'importe quel éditeur de texte
• Lu facilement par Python avec la bibliothèque pandas
• Extensible : ajouter 100 nouveaux objets prend 5 minutes

5.4 Le code du valorisateur expliqué

 import pandas as pd
import os

def charger_objets():
# [Link] crée le bon chemin selon l'OS (Windows ou Linux)
chemin = [Link]("data", "[Link]")
return pd.read_csv(chemin)

def valoriser_chutes(chutes_dimensions):
objets = charger_objets() # Chargement du CSV comme DataFrame
resultats = []

for longueur, largeur in chutes_dimensions:

suggestions = []

# Itération sur chaque ligne du DataFrame

for _, objet in [Link]():
# Vérification : la chute est-elle assez grande ?
if (longueur >= objet["longueur_min"] and
largeur >= objet["largeur_min"]):
[Link]({
"objet": objet["nom"],
"description": objet["description"],
"prix_vente": objet["prix_vente_fcfa"]
})

[Link]({
"chute": f"{longueur}cm x {largeur}cm",
"suggestions": suggestions,
"nb_suggestions": len(suggestions),
"revenu_potentiel": sum(s["prix_vente"] for s in suggestions)
})

return resultats

5.5 La notion pandas expliquée

pandas est la bibliothèque Python standard pour manipuler des données tabulaires. Elle
charge un CSV en DataFrame — un objet qui ressemble à un tableau Excel mais qu'on
peut manipuler avec du code.

• pd.read_csv() — Lire un fichier CSV et le transformer en DataFrame

• [Link]() — Parcourir chaque ligne d'un DataFrame
• objet['colonne'] — Accéder à la valeur d'une colonne pour une ligne donnée
• sum(... for s in liste) — Expression génératrice : somme calculée à la volée
• f-string — f"{longueur}cm x {largeur}cm" : insérer des variables dans une chaîne
 Chapitre 6 — L'Interface Utilisateur avec Streamlit

6.1 Qu'est-ce que Streamlit ?

Streamlit est une bibliothèque Python qui permet de créer des applications web
interactives sans connaître HTML, CSS ou JavaScript. On écrit du Python pur, et Streamlit
génère automatiquement une interface moderne et responsive (compatible smartphone).

■ Comparaison : Avant Streamlit, créer une interface web pour un algorithme Python
nécessitait Flask/Django (backend) + HTML/CSS/JavaScript (frontend) = plusieurs
semaines de travail. Avec Streamlit : quelques heures.

6.2 Les composants Streamlit utilisés

Composant Usage

[Link]() Titre principal de la page

[Link]() Titre de section

[Link]() Sous-titre

st.number_input() Champ de saisie numérique avec min/max/valeur par défaut

st.text_input() Champ de saisie texte

[Link]() Bouton cliquable

[Link]() Diviser la page en colonnes côte à côte

[Link]() Afficher une métrique avec valeur et étiquette

[Link]() Message en vert (succès)

[Link]() Message en rouge (erreur)

[Link]() Message en orange (avertissement)

[Link]() Message en bleu (information)

[Link]() Ligne de séparation horizontale

st.set_page_config() Configurer titre, icône et layout de la page

6.3 Lancer l'application

 streamlit run [Link]

Cette commande lance un serveur local et ouvre automatiquement l'application dans le

navigateur à l'adresse [Link] Sur le réseau local, n'importe quel smartphone
connecté au même WiFi peut y accéder en tapant [Link]

6.4 Le lanceur double-clic (fichier .bat)

Pour éviter d'ouvrir VS Code à chaque fois, on crée un fichier .bat (batch script Windows)
qui automatise les étapes :

@echo off
cd /d "%~dp0"
call venv\Scripts\activate
streamlit run [Link]
pause

• @echo off → Ne pas afficher les commandes dans le terminal

• cd /d "%~dp0" → Se déplacer dans le dossier où se trouve le fichier .bat
• call venv\Scripts\activate → Activer l'environnement virtuel
• streamlit run [Link] → Lancer l'application
• pause → Garder le terminal ouvert pour voir les erreurs éventuelles
 Chapitre 7 — Les Tests : Pourquoi et Comment Tester son
Code

7.1 Pourquoi tester ?

Un code non testé est un code dont on ne sait pas s'il fonctionne vraiment. Dans WoodAI,
si l'optimiseur calcule mal une surface, un artisan va gaspiller du bois en croyant suivre
nos recommandations. Les tests automatiques détectent ces erreurs avant qu'elles
arrivent en production.

■ Règle professionnelle : On dit qu'un code est 'en production' quand de vrais utilisateurs
l'utilisent. Corriger un bug en production est 10 fois plus coûteux qu'un bug détecté
pendant le développement. D'où l'importance des tests.

7.2 pytest — La bibliothèque de tests Python

pytest est le standard industriel pour tester du code Python. Une fonction de test respecte
ces règles :

• Son nom commence par test_

• Elle se trouve dans un fichier dont le nom commence par test_
• Elle utilise assert pour vérifier qu'une valeur est correcte
• Si assert est faux, le test échoue (FAILED). Si tout est vrai, il réussit (PASSED)

7.3 Test du Module 1 — Optimiseur

 # tests/test_optimiseur.py
from [Link] import optimiser_decoupe

def test_decoupe_simple():
# Données d'entrée
pieces = [
(100, 50, "Plateau table"),
(60, 30, "Tiroir")
]
# Appel de la fonction
resultat = optimiser_decoupe(200, 100, pieces)

# Vérifications (assertions)
assert resultat["surface_utilisee"] == 6800 # 100*50 + 60*30
assert resultat["pourcentage_utilise"] == 34.0 # 6800/20000 * 100
print("Test réussi !")

test_decoupe_simple()

7.4 Test du Module 2 — Valorisateur

# tests/test_valorisateur.py
from [Link] import valoriser_chutes

def test_valorisation():
chutes = [(40, 25), (15, 10)]
resultats = valoriser_chutes(chutes)

# La grande chute doit avoir plus de suggestions que la petite

assert resultats[0]['nb_suggestions'] > resultats[1]['nb_suggestions']

# Vérifier que chaque suggestion a un prix positif

for suggestion in resultats[0]['suggestions']:
assert suggestion['prix_vente'] > 0

print(f"Chute 1 : {resultats[0]['nb_suggestions']} objets suggérés")

print(f"Chute 2 : {resultats[1]['nb_suggestions']} objets suggérés")

7.5 Lancer tous les tests

 # Lancer tous les tests du projet
python -m pytest tests/ -v

# Avec affichage des print()

python -m pytest tests/ -v -s

# Un seul fichier de test

python -m pytest tests/test_optimiseur.py -v

L'option -v (verbose) affiche le détail de chaque test. L'option -s affiche les messages
print() à l'intérieur des tests. On utilise toujours 'python -m pytest' (avec le flag -m) pour que
Python trouve correctement les modules du projet.
 Chapitre 8 — Sécurité et Qualité du Code

8.1 Valider les entrées utilisateur

Toute valeur saisie par un utilisateur peut être incorrecte, malveillante ou incohérente. On
doit toujours valider les entrées avant de les traiter.

def optimiser_decoupe_securise(longueur_planche, largeur_planche, pieces):

# Validation des dimensions de la planche
if longueur_planche <= 0 or largeur_planche <= 0:
raise ValueError("Les dimensions de la planche doivent être positi
ves")

if longueur_planche > 600 or largeur_planche > 300:

raise ValueError("Dimensions hors limites (max : 600cm x 300cm)")

if not pieces:
raise ValueError("La liste des pièces ne peut pas être vide")

if len(pieces) > 50:

raise ValueError("Maximum 50 pièces par planche")

# Si toutes les validations passent, on appelle la fonction normale

return optimiser_decoupe(longueur_planche, largeur_planche, pieces)

8.2 Gérer les erreurs avec try/except

 def charger_objets_securise():
try:
chemin = [Link]("data", "[Link]")
df = pd.read_csv(chemin)

# Vérifier que les colonnes nécessaires existent

colonnes_requises = ['nom', 'longueur_min', 'largeur_min', 'prix_v
ente_fcfa']
for col in colonnes_requises:
if col not in [Link]:
raise ValueError(f"Colonne manquante dans [Link] : {co
l}")

return df

except FileNotFoundError:
print("ERREUR : Le fichier data/[Link] est introuvable")
return [Link]() # Retourne un DataFrame vide

except Exception as e:
print(f"ERREUR inattendue : {e}")
return [Link]()

8.3 Bonnes pratiques de qualité

• Nommer clairement : surface_utilisee au lieu de s, longueur_planche au lieu de l
• Documenter les fonctions : Ajouter un docstring : """Description de ce que fait la
fonction"""
• Constantes en majuscules : PRIX_MAX_FCFA = 50000 au lieu de 50000 partout
dans le code
• Une fonction = une responsabilité : Ne pas mélanger le calcul et l'affichage dans la
même fonction
• Pas de magic numbers : Nommer les valeurs : MAX_LONGUEUR = 600 plutôt que
if longueur > 600
• Commits réguliers : Sauvegarder son travail avec Git à chaque étape importante
 Chapitre 9 — Déployer son Application en Ligne

9.1 Streamlit Cloud — Gratuit et simple

Streamlit propose un service d'hébergement gratuit appelé Streamlit Community Cloud. En
quelques clics, votre application locale devient accessible à n'importe qui dans le monde
via une URL publique.

Créer un compte GitHub

1 [Link] — Gratuit

Créer un dépôt GitHub

2 Uploader tous les fichiers du projet woodai/

Créer [Link]
3 Lister les bibliothèques : streamlit, pandas, ortools

Aller sur [Link]

4 Se connecter avec son compte GitHub

Cliquer 'New app'

5 Sélectionner le dépôt GitHub et le fichier [Link]

Déployer
6 L'URL publique est générée automatiquement

9.2 Le fichier [Link]

Ce fichier liste toutes les bibliothèques nécessaires pour que votre application fonctionne
sur un autre ordinateur ou serveur :

streamlit>=1.28.0
pandas>=2.0.0
ortools>=9.7.0

■ Pour générer automatiquement [Link] depuis votre environnement virtuel : pip

freeze > [Link] Cette commande liste toutes les bibliothèques installées avec
leurs versions exactes.
 Chapitre 10 — Méthode : Comment Aborder Tout Nouveau
Projet

10.1 La méthode en 7 étapes

Définir le problème réel

Avant de coder, répondre à : Quel problème concret résout-on ? Pour qui ? Avec quelles données
■ ? WoodAI a commencé par 34 ans d'observation dans un atelier de menuiserie.

Préparer l'environnement
Créer le dossier projet, l'environnement virtuel, installer les bibliothèques. Ne jamais coder sans
■ environnement virtuel sur un projet sérieux.

Définir l'architecture

■ Décider de la structure des fichiers avant d'écrire une seule ligne de code. Qui fait quoi ? Quel
■ fichier contient quelle logique ?

Coder module par module

■ Un module = une responsabilité. On code, on teste, on valide avant de passer au module suivant.
■ Ne jamais tout coder d'un coup sans tester.

Tester chaque module

Écrire un test dès qu'un module est terminé. Un test non écrit est un bug qui attend d'être trouvé en
■ production.

Construire l'interface

■ L'interface vient en dernier. La logique métier doit fonctionner parfaitement avant d'y ajouter une
■ interface. Streamlit permet de le faire rapidement.

Déployer et itérer
Mettre en ligne une version minimale fonctionnelle, recueillir les retours des utilisateurs réels,
■ améliorer en continu.

10.2 Les questions à se poser avant chaque projet

1. Quel problème réel est-ce que je résous ? (Pas une idée abstraite — un vrai
problème observé)
2. Qui va utiliser cet outil ? (Définir son utilisateur cible)
3. De quelles données ai-je besoin ? (Et comment les obtenir ?)
4. Quelles bibliothèques Python vont m'aider ? (Ne pas réinventer la roue)
5. Comment je vais tester que ça marche ? (Définir les critères de succès avant de
coder)
6. Comment l'utilisateur va interagir avec le résultat ? (Interface, fichier, API ?)
7. Quelle est la version minimale qui apporte déjà de la valeur ? (MVP — Minimum
Viable Product)
 Annexe A — Commandes Essentielles Windows/PowerShell

Commande Description

mkdir nom_dossier Créer un dossier

cd nom_dossier Se déplacer dans un dossier

cd .. Remonter d'un niveau

dir Lister les fichiers du dossier courant

New-Item [Link] -ItemType File Créer un fichier vide

python --version Vérifier la version Python installée

python -m venv venv Créer un environnement virtuel

venv\Scripts\activate Activer l'environnement virtuel

deactivate Désactiver l'environnement virtuel

pip install bibliothèque Installer une bibliothèque

pip list Lister les bibliothèques installées

pip freeze > [Link] Exporter les bibliothèques dans un fichier

streamlit run [Link] Lancer une application Streamlit

python -m pytest tests/ -v Lancer tous les tests

Ctrl + C Arrêter un programme en cours d'exécution

Ctrl + ` Ouvrir/fermer le terminal dans VS Code

 Annexe B — Erreurs Fréquentes et Solutions

■ Erreur ModuleNotFoundError: No module named 'modules'

■ Cause Python ne trouve pas le package modules/

Vérifier que modules/__init__.py existe. Utiliser 'python -m pytest' au lieu de 'python

■ Solution tests/[Link]'

■ Erreur Le module venv n'a pas pu être chargé

■ Cause PowerShell bloque l'exécution de scripts

■ Solution Exécuter : Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser

■ Erreur FileNotFoundError: data/[Link]

■ Cause Le fichier CSV est introuvable

■ Solution Vérifier que le terminal est dans le dossier woodai/ et que le fichier existe dans data/

■ Erreur SyntaxError: unterminated string literal

■ Cause Les guillemets se sont mal copiés depuis un PDF ou site web

■ Solution Retaper manuellement les guillemets dans le code plutôt que de coller

■ Erreur streamlit: command not found

■ Cause Streamlit n'est pas installé ou l'env virtuel n'est pas activé

■ Solution Activer l'env virtuel puis : pip install streamlit

■ Erreur mkdir: Impossible de trouver un paramètre

■ Cause PowerShell ne supporte pas mkdir avec plusieurs arguments

■ Solution Créer les dossiers un par un : mkdir data, mkdir modules, mkdir tests
 Annexe C — Ressources pour Aller Plus Loin

Documentation officielle
• Python — [Link]
• Streamlit — [Link]
• pandas — [Link]
• pytest — [Link]
• OR-Tools — [Link]

Hébergement gratuit
• Streamlit Community Cloud — [Link]
• GitHub (code source) — [Link]
• Railway (alternative) — [Link]

Apprendre Python appliqué

• Real Python — [Link]
• [Link] tutoriels FR — [Link]
• Kaggle (données + projets) — [Link]

Ce guide a été construit en une nuit, d'une idée à une application fonctionnelle. La
théorie sans pratique ne vaut rien. La pratique sans théorie est aveugle. WoodAI est
la preuve que les deux ensemble, ça change tout. — Babatoundé David IDOHOU,
Cotonou, Bénin, 2026