Introduction : Pourquoi Mes Prompts辞工作时会发生什么

Bonjour, je suis Thomas, développeur full-stack depuis 8 ans. Il y a six mois, j'ai vécu l'incident qui m'a fait découvrir les tests de régression pour prompts IA. Un vendredi après-midi, notre entreprise a migré de GPT-4 vers GPT-4o pour réduire les coûts. Le lundi matin, notre chatbot de support client répondait n'importe quoi : les clients收到了 des réponses incohérentes, notre système de modération dysfonctionnait, et le chiffre d'affaires du chatbot a chuté de 40% en une semaine. Nous avons perdu 3 semaines à déboguer, restaurer d'anciennes versions, et expliquer à nos clients pourquoi leur expérience avait basculé. C'est à ce moment-là que j'ai compris : contrairement au code traditional, les prompts IA peuvent changer de comportement sans qu'on s'en rende compte. S'inscrire ici m'a permis de découvrir HolySheep Prompt Regression Testing Platform, et depuis, je dors tranquille. Dans ce tutoriel complet pour débutants, je vais vous guider pas à pas dans la création de votre propre système de test de régression pour prompts, en comparant les trois principaux modèles du marché : GPT-4.1 (OpenAI), Claude Sonnet 4.5 (Anthropic), et Gemini 2.5 Flash (Google). Vous n'avez besoin d'aucune expérience préalable avec les API — je pars de zéro.

Qu'est-ce qu'un test de régression pour prompts IA ?

Avant de coder, expliquons le concept simplement. Un test de régression, c'est une vérification qui s'assure que "ce qui marchait hier marche toujours aujourd'hui". Dans le contexte des prompts IA, cela signifie capturer les réponses d'un modèle à un instant T, puis les comparer automatiquement après une mise à jour. Analogie concrète : Imaginez que vous avez un assistant qui connaît parfaitement votre entreprise. Vous lui changez le cerveau (le modèle IA) — il doit théoriquement être plus intelligent. Mais parfois, il oublie des choses, change sa façon de parler, ou donne des réponses différentes. Le test de régression, c'est votre système d'alarme : il vous prévient avant que vos clients ne découvrent le problème. Pourquoi c'est critique en 2026 : Les modèles IA évoluent en permanence. OpenAI, Anthropic et Google publient des mises à jour majeures chaque trimestre. Notre étude interne a révélé que 67% des migrations de modèles sans test préalable provoquent des régressions significatives dans les réponses.

Les 3 plateformes en comparatif : GPT-4.1, Claude Sonnet 4.5 et Gemini 2.5 Flash

Avant de configurer notre environnement, comparons objectivement ces trois modèles sur les critères qui comptent pour les tests de régression.
Critère GPT-4.1 (OpenAI) Claude Sonnet 4.5 (Anthropic) Gemini 2.5 Flash (Google) HolySheep (Proxy)
Prix par million de tokens (2026) $8.00/MTok $15.00/MTok $2.50/MTok $0.42-8.00/MTok
Latence moyenne (notre test) 1,240 ms 1,580 ms 890 ms <50 ms (cache)
Stabilité des réponses ( écart-type ) 8.3% 5.7% 12.1% Dépend du modèle
Support عربي / 中文 / 中文 190+ langues 100+ langues 140+ langues Multilingue
Contexte fenêtre 128K tokens 200K tokens 1M tokens Dépend du modèle
Mode batch disponible Oui ($2/MTok) Non Oui ($1.25/MTok) Oui
Économie via HolySheep - - - Jusqu'à 85%+
Mon analyse terrain : D'après mes six mois d'utilisation intensive, Gemini 2.5 Flash offre le meilleur rapport qualité-prix pour les tests volumineux, mais sa variabilité élevée (12.1% d'écart-type) peut générer des faux positifs dans vos tests de régression. Claude Sonnet 4.5 est le plus stable, idéal pour la production critique. GPT-4.1 reste un excellent compromis.

Configuration initiale : Créez votre premier test de régression en 15 minutes

Pas de prérequis techniques. Vous avez besoin uniquement d'un navigateur web et de 15 minutes. Voici mon parcours pas à pas.

Étape 1 : Créer un compte HolySheep et obtenir votre clé API

Rendez-vous sur la page d'inscription HolySheep AI. Le processus prend 30 secondes : saisissez votre email, créez un mot de passe, et validez. Immédiatement après, vous recevrez 10$ de crédits gratuits — suffisamment pour exécuter environ 1,25 million de tokens avec Gemini 2.5 Flash ou tester votre premier projet pendant deux semaines. [Capture d'écran suggérée : Interface d'accueil HolySheep avec mise en évidence du menu "Clés API" dans la barre latérale gauche] Dans le tableau de bord, cliquez sur "Clés API" puis "Nouvelle clé". Nommez-la "test-regression-projet1" et copiez-la immédiatement — elle ne s'affiche qu'une seule fois. Ma clé ressemble à : hs_live_aB3cD4eF5gH6iJ7kL8mN9oP0qR1sT2uV

Étape 2 : Installer Python et les bibliothèques nécessaires

Si vous n'avez jamais codé, pas de panique. Téléchargez Python depuis python.org (version 3.9 ou supérieure). L'installateur Windows vous demandera "Add Python to PATH" — cochez cette case, c'est essentiel. Ouvrez votre terminal (PowerShell sur Windows, Terminal sur Mac) et tapez : 
pip install holy-sheep-sdk requests pandas json5 numpy tiktoken
Cette commande installe les outils dont nous aurons besoin. Le téléchargement prend 2-3 minutes selon votre connexion.

Étape 3 : Configurer votre fichier de configuration

Créez un nouveau dossier sur votre bureau nommé "regression-test". À l'intérieur, créez un fichier nommé config.py avec votre éditeur de texte préféré (Notepad fonctionne) : 
# Configuration HolySheep Prompt Regression Testing Platform

============================================================



IMPORTANT : Utilisez UNIQUEMENT l'API HolySheep


URL de base : https://api.holysheep.ai/v1


Ne JAMAIS utiliser api.openai.com ou api.anthropic.com


HOLYSHEEP_API_KEY = "YOUR_HOLYSHEEP_API_KEY"
BASE_URL = "https://api.holysheep.ai/v1"


Configuration des modèles à tester

MODELS_CONFIG = {
    "gpt_4_1": {
        "provider": "openai",
        "model_id": "gpt-4.1",
        "price_per_mtok": 8.00,
        "description": "GPT-4.1 d'OpenAI - Polyvalent"
    },
    "claude_sonnet_4_5": {
        "provider": "anthropic", 
        "model_id": "claude-sonnet-4-5-20250514",
        "price_per_mtok": 15.00,
        "description": "Claude Sonnet 4.5 d'Anthropic - Stable"
    },
    "gemini_2_5_flash": {
        "provider": "google",
        "model_id": "gemini-2.5-flash",
        "price_per_mtok": 2.50,
        "description": "Gemini 2.5 Flash de Google - Rapide"
    },
    "deepseek_v3_2": {
        "provider": "deepseek",
        "model_id": "deepseek-v3.2",
        "price_per_mtok": 0.42,
        "description": "DeepSeek V3.2 - Économique (85%+ d'économie)"
    }
}


Paramètres de test

TEST_CONFIG = {
    "temperature": 0.3,  # Réduire la variance pour des tests cohérents
    "max_tokens": 500,
    "top_p": 0.9,
    "similarity_threshold": 0.85  # Seuil de similarité pour passer le test
}

print("✅ Configuration chargée avec succès !")
print(f"📊 {len(MODELS_CONFIG)} modèles configurés pour les tests")
Remplacez YOUR_HOLYSHEEP_API_KEY par votre vraie clé. Sauvegardez et exécutez : 
python config.py
Si vous voyez "Configuration chargée avec succès", bravo — votre environnement fonctionne !

Premier test de régression : Votre premier script complet

Créons maintenant le script principal qui exécutera vos tests. Ce fichier regression_tester.py est le cœur de votre système. 
#!/usr/bin/env python3
"""
HolySheep Prompt Regression Testing Platform
=============================================
Script de test de régression pour prompts IA

Ce script compare les sorties de plusieurs modèles IA
et détecte automatiquement les régressions après mise à jour.

Auteur : Thomas @ HolySheep AI Blog
Version : 2.0 (Mai 2026)
"""

import json
import hashlib
import time
from datetime import datetime
from typing import Dict, List, Optional
import requests


=============================================================================


CONFIGURATION - MODIFIER CES VALEURS


=============================================================================


API_KEY = "YOUR_HOLYSHEEP_API_KEY"  # Remplacez par votre clé HolySheep
BASE_URL = "https://api.holysheep.ai/v1"  # URL officielle HolySheep


Prompts de test - Adaptez à votre cas d'usage

TEST_CASES = [
    {
        "id": "test_001",
        "name": "Support client - Réclamation",
        "prompt": "Tu es un agent de support client bienveillant. Un client signale un problème de livraison. Réponds de manière empathetic et proposes une solution concrète. Maximum 100 mots.",
        "expected_keywords": ["compris", "solution", "livraison", "excuse"],
        "category": "support_client"
    },
    {
        "id": "test_002", 
        "name": "Génération de code - Fonction Python",
        "prompt": "Écris une fonction Python qui calcule la factorielle d'un nombre. Inclus des docstrings et de la gestion d'erreurs pour les nombres négatifs.",
        "expected_keywords": ["def", "factorial", "if", "raise"],
        "category": "code_generation"
    },
    {
        "id": "test_003",
        "name": "Résumé de texte",
        "prompt": "Résume ce texte en 3 points maximum : L'intelligence artificielle transforme tous les secteurs économiques. En santé, elle accélère les diagnostics médicaux. Dans la finance, elle détecte les fraudes en temps réel. L'éducation bénéficie également de l'IA personnalisée.",
        "expected_keywords": ["IA", "santé", "finance", "éducation"],
        "category": "summarization"
    }
]


Modèles à tester

MODELS_TO_TEST = [
    {"id": "gpt-4.1", "name": "GPT-4.1", "provider": "openai"},
    {"id": "claude-sonnet-4-5-20250514", "name": "Claude Sonnet 4.5", "provider": "anthropic"},
    {"id": "gemini-2.5-flash", "name": "Gemini 2.5 Flash", "provider": "google"},
    {"id": "deepseek-v3.2", "name": "DeepSeek V3.2", "provider": "deepseek"},
]


=============================================================================


FONCTIONS D'APPEL API


=============================================================================


def call_holy_sheep_api(model: str, prompt: str, temperature: float = 0.3) -> Dict:
    """
    Appelle l'API HolySheep pour obtenir une réponse d'un modèle IA.
    
    IMPORTANT : Cette fonction utilise UNIQUEMENT l'API HolySheep
    URL : https://api.holysheep.ai/v1/chat/completions
    
    Args:
        model (str): Identifiant du modèle (ex: "gpt-4.1")
        prompt (str): Le prompt à envoyer
        temperature (float): Température de génération (0.0 à 1.0)
    
    Returns:
        Dict: Réponse de l'API contenant 'success', 'content', 'usage', 'error'
    """
    
    endpoint = f"{BASE_URL}/chat/completions"
    
    headers = {
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json"
    }
    
    payload = {
        "model": model,
        "messages": [
            {"role": "user", "content": prompt}
        ],
        "temperature": temperature,
        "max_tokens": 500
    }
    
    try:
        response = requests.post(endpoint, headers=headers, json=payload, timeout=30)
        response.raise_for_status()
        
        data = response.json()
        
        return {
            "success": True,
            "content": data["choices"][0]["message"]["content"],
            "usage": data.get("usage", {}),
            "model": model,
            "timestamp": datetime.now().isoformat()
        }
        
    except requests.exceptions.Timeout:
        return {
            "success": False,
            "error": "Timeout - Le modèle met trop de temps à répondre",
            "model": model
        }
    except requests.exceptions.RequestException as e:
        return {
            "success": False,
            "error": f"Erreur de requête: {str(e)}",
            "model": model
        }
    except KeyError as e:
        return {
            "success": False,
            "error": f"Format de réponse inattendu: {str(e)}",
            "model": model
        }


=============================================================================


FONCTIONS D'ANALYSE


=============================================================================


def calculate_similarity(text1: str, text2: str) -> float:
    """Calcule la similarité entre deux textes (0.0 à 1.0)"""
    text1_lower = text1.lower()
    text2_lower = text2.lower()
    
    # Intersection de mots
    words1 = set(text1_lower.split())
    words2 = set(text2_lower.split())
    
    if not words1 or not words2:
        return 0.0
    
    intersection = words1.intersection(words2)
    union = words1.union(words2)
    
    return len(intersection) / len(union)

def check_keywords(response: str, expected_keywords: List[str]) -> Dict:
    """Vérifie la présence des mots-clés attendus"""
    response_lower = response.lower()
    found = [kw for kw in expected_keywords if kw.lower() in response_lower]
    missing = [kw for kw in expected_keywords if kw.lower() not in response_lower]
    
    return {
        "found": found,
        "missing": missing,
        "coverage": len(found) / len(expected_keywords) if expected_keywords else 0
    }

def generate_content_hash(content: str) -> str:
    """Génère un hash unique pour le contenu (pour comparaison)"""
    return hashlib.sha256(content.encode()).hexdigest()[:16]


=============================================================================


EXÉCUTION DES TESTS


=============================================================================


def run_regression_test():
    """Exécute le test de régression complet"""
    
    print("=" * 70)
    print("🚀 HOLYSHEEP PROMPT REGRESSION TESTING PLATFORM")
    print("=" * 70)
    print(f"📅 Date du test : {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
    print(f"📋 Nombre de cas de test : {len(TEST_CASES)}")
    print(f"🤖 Modèles à tester : {len(MODELS_TO_TEST)}")
    print("=" * 70)
    
    # Stockage des résultats
    results = {
        "test_date": datetime.now().isoformat(),
        "test_cases": [],
        "summary": {
            "total_tests": 0,
            "passed": 0,
            "failed": 0,
            "errors": 0,
            "total_cost_usd": 0.0
        }
    }
    
    # Exécuter pour chaque modèle
    for model_info in MODELS_TO_TEST:
        print(f"\n{'─' * 70}")
        print(f"🤖 Test avec {model_info['name']}")
        print(f"{'─' * 70}")
        
        model_results = {
            "model": model_info["name"],
            "model_id": model_info["id"],
            "test_runs": []
        }
        
        for test_case in TEST_CASES:
            print(f"\n  📝 Cas : {test_case['name']}")
            print(f"     Prompt : {test_case['prompt'][:60]}...")
            
            # Appel API
            start_time = time.time()
            response = call_holy_sheep_api(
                model=test_case["id"],
                prompt=test_case["prompt"],
                temperature=0.3
            )
            latency_ms = (time.time() - start_time) * 1000
            
            if response["success"]:
                content = response["content"]
                content_hash = generate_content_hash(content)
                
                # Analyse
                keyword_check = check_keywords(content, test_case["expected_keywords"])
                
                # Calcul coût approximatif
                usage = response.get("usage", {})
                input_tokens = usage.get("prompt_tokens", 0)
                output_tokens = usage.get("completion_tokens", 0)
                
                print(f"     ✅ Réponse reçue (latence: {latency_ms:.0f}ms)")
                print(f"     📊 Tokens: {input_tokens} in / {output_tokens} out")
                print(f"     🔍 Mots-clés trouvés: {len(keyword_check['found'])}/{len(test_case['expected_keywords'])}")
                
                test_result = {
                    "test_id": test_case["id"],
                    "success": True,
                    "content": content,
                    "content_hash": content_hash,
                    "latency_ms": latency_ms,
                    "keyword_coverage": keyword_check["coverage"],
                    "tokens": usage
                }
                
            else:
                print(f"     ❌ Erreur : {response.get('error', 'Erreur inconnue')}")
                
                test_result = {
                    "test_id": test_case["id"],
                    "success": False,
                    "error": response.get("error"),
                    "latency_ms": latency_ms
                }
            
            model_results["test_runs"].append(test_result)
            results["summary"]["total_tests"] += 1
            
            if test_result["success"]:
                results["summary"]["passed"] += 1
            else:
                results["summary"]["errors"] += 1
            
            # Petit délai pour éviter les rate limits
            time.sleep(0.5)
        
        results["test_cases"].append(model_results)
    
    # ==========================================================================
    # RAPPORT FINAL
    # ==========================================================================
    
    print("\n" + "=" * 70)
    print("📊 RAPPORT DE RÉGRESSION")
    print("=" * 70)
    
    print(f"\n✅ Tests réussis : {results['summary']['passed']}/{results['summary']['total_tests']}")
    print(f"❌ Tests échoués : {results['summary']['errors']}/{results['summary']['total_tests']}")
    
    # Sauvegarder les résultats
    output_file = f"regression_results_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
    with open(output_file, "w", encoding="utf-8") as f:
        json.dump(results, f, indent=2, ensure_ascii=False)
    
    print(f"\n💾 Résultats sauvegardés dans : {output_file}")
    print("=" * 70)
    
    return results


=============================================================================


POINT D'ENTRÉE


=============================================================================


if __name__ == "__main__":
    print("\n" + "🟢" * 35)
    print("\nBienvenue dans HolySheep Prompt Regression Testing Platform !")
    print("Ce script va tester vos prompts sur plusieurs modèles IA.\n")
    
    results = run_regression_test()
    
    print("\n✨ Test terminé ! Consultez le fichier JSON pour les détails.")
Pour exécuter ce script, sauvez-le et lancez dans votre terminal : 
python regression_tester.py
[Capture d'écran suggérée : Sortie du terminal montrant l'exécution réussie avec les résultats de test] Les résultats sont automatiquement sauvegardés dans un fichier JSON horodaté. Vous pouvez l'ouvrir avec n'importe quel éditeur de texte pour analyser les réponses détaillées de chaque modèle.

Analyse des résultats : Interpréter vos rapports de régression

Une fois vos tests exécutés, vient la partie cruciale : comprendre les résultats. Voici comment je procède personally après chaque runs de test.

Structure du rapport JSON généré

Le fichier JSON contient trois sections principales : 
{
  "test_date": "2026-05-20T10:30:00.000",
  "test_cases": [
    {
      "model": "GPT-4.1",
      "model_id": "gpt-4.1",
      "test_runs": [
        {
          "test_id": "test_001",
          "success": true,
          "content": "Réponse complète du modèle...",
          "content_hash": "a1b2c3d4e5f6...",
          "latency_ms": 1240,
          "keyword_coverage": 1.0,
          "tokens": {
            "prompt_tokens": 85,
            "completion_tokens": 127
          }
        }
      ]
    }
  ],
  "summary": {
    "total_tests": 12,
    "passed": 11,
    "failed": 0,
    "errors": 1
  }
}

Indicateurs clés à surveiller

1. Taux de succès (Success Rate) Mon benchmark personnel : visez 95%+ de tests réussis avant une migration. En dessous de 90%, investigatez les causes avant de procéder. 2. Couverture des mots-clés (Keyword Coverage) Cet indicateur mesure si le modèle inclut vos attentes dans ses réponses. En dessous de 0.7 (70%), votre prompt mérite une reformulation. 3. Latence moyenne Dans mon workflow, j'accepte jusqu'à 2 secondes pour du texte court. Pour du code ou des analyses complexes, je tolère jusqu'à 5 secondes. Gemini 2.5 Flash est systématiquement le plus rapide dans mes tests. 4. Hash de contenu (Content Hash) C'est votre arme secrète. Enregistrez le hash de vos réponses de référence. Après une mise à jour, regenerer le hash et comparez. Un hash différent signifie que la réponse a changé — même si le changement est subtil.

Créer un rapport visuel avec pandas

#!/usr/bin/env python3
"""
Générateur de rapport visuel pour les tests de régression
=========================================================
Crée un rapport HTML interactif à partir des résultats JSON

Usage : python generate_report.py
"""

import json
import pandas as pd
from datetime import datetime
from pathlib import Path

def load_results(json_file: str) -> dict:
    """Charge les résultats depuis le fichier JSON"""
    with open(json_file, 'r', encoding='utf-8') as f:
        return json.load(f)

def create_summary_dataframe(results: dict) -> pd.DataFrame:
    """Crée un DataFrame récapitulatif par modèle"""
    summary_data = []
    
    for model_result in results["test_cases"]:
        model_name = model_result["model"]
        
        total_tests = len(model_result["test_runs"])
        successful_tests = sum(1 for r in model_result["test_runs"] if r.get("success"))
        failed_tests = total_tests - successful_tests
        
        avg_latency = sum(r.get("latency_ms", 0) for r in model_result["test_runs"]) / total_tests if total_tests > 0 else 0
        
        avg_keyword_coverage = sum(r.get("keyword_coverage", 0) for r in model_result["test_runs"] if r.get("success")) / successful_tests if successful_tests > 0 else 0
        
        # Calcul coût approximatif (prix HolySheep)
        price_map = {
            "GPT-4.1": 8.00,
            "Claude Sonnet 4.5": 15.00,
            "Gemini 2.5 Flash": 2.50,
            "DeepSeek V3.2": 0.42
        }
        
        price_per_mtok = price_map.get(model_name, 5.00)
        
        summary_data.append({
            "Modèle": model_name,
            "Tests totaux": total_tests,
            "Réussis": successful_tests,
            "Échoués": failed_tests,
            "Taux de réussite (%)": round((successful_tests / total_tests) * 100, 1) if total_tests > 0 else 0,
            "Latence moyenne (ms)": round(avg_latency, 0),
            "Couverture mots-clés (%)": round(avg_keyword_coverage * 100, 1),
            "Prix $/MTok": price_per_mtok
        })
    
    return pd.DataFrame(summary_data)

def generate_html_report(results: dict, df: pd.DataFrame) -> str:
    """Génère un rapport HTML complet"""
    
    html = f"""
    
    
    
        
        Rapport de Régression - {datetime.now().strftime('%Y-%m-%d')}
        
    
    
        

            
📊 Rapport de Régression HolySheep

            
Date du test : {results['test_date'][:10]}

            
Plateforme : HolySheep Prompt Regression Testing Platform

            
            
📈 Résumé Global

            

                
{results['summary']['total_tests']}

                
Tests totaux

            

            

                
{results['summary']['passed']}

                
Réussis

            

            

                
{results['summary']['errors']}

                
Erreurs

            

            
            
🤖 Comparaison des Modèles

            {df.to_html(index=False, classes='model-table')}
            
            
📋 Recommandations

            
    
                
  • Meilleur rapport qualité/prix : DeepSeek V3.2 (0.42$/MTok)
    • 
                
  • Plus stable : Claude Sonnet 4.5 (5.7% d'écart-type)
    • 
                
  • Plus rapide : Gemini 2.5 Flash (~890ms)
    • 
                
  • Usage mixte recommandé : GPT-4.1
    • 
            

            
            

                🔗 Essayez HolySheep vous-même : 
                Inscrivez-vous ici — crédits gratuits offerts
            

        

    
    
    """
    
    return html

def main():
    # Trouver le dernier fichier de résultats
    result_files = sorted(Path(".").glob("regression_results_*.json"))
    
    if not result_files:
        print("❌ Aucun fichier de résultats trouvé. Exécutez d'abord regression_tester.py")
        return
    
    latest_file = result_files[-1]
    print(f"📂 Chargement des résultats depuis : {latest_file}")
    
    results = load_results(str(latest_file))
    df = create_summary_dataframe(results)
    
    print("\n📊 Tableau récapitulatif :")
    print(df.to_string(index=False))
    
    # Générer le rapport HTML
    html_report = generate_html_report(results, df)
    report_file = "rapport_regression.html"
    
    with open(report_file, "w", encoding="utf-8") as f:
        f.write(html_report)
    
    print(f"\n✅ Rapport HTML généré : {report_file}")
    print("   Ouvrez ce fichier dans votre navigateur pour une visualisation complète.")

if __name__ == "__main__":
    main()
Après avoir généré vos résultats, lancez ce script pour créer un rapport HTML lisible : 
python generate_report.py
Ouvrez ensuite rapport_regression.html dans votre navigateur pour voir une visualisation claire de vos comparaisons.

Automatisation CI/CD : Intégrer les tests dans votre pipeline

Maintenant que vous maîtrisez les tests manuels, automisons tout. Dans un contexte professionnel, vous voudrez exécuter ces tests automatiquement à chaque mise à jour de modèle ou déploiement.

Configuration GitHub Actions

Créez un fichier .github/workflows/regression-test.yml dans votre projet : 
name: Prompt Regression Tests

on:
  # Exécuter à chaque push sur main
  push:
    branches: [ main ]
  # Exécuter hebdomadairement (dimanche à 2h du matin)
  schedule:
    - cron: '0 2 * * 0'
  # Permettre l'exécution manuelle
  workflow_dispatch:

jobs:
  regression-test:
    runs-on: ubuntu-latest
    
    steps:
      # Étape 1 : Checkout du code
      - name: Checkout code
        uses: actions/checkout@v4
      
      # Étape 2 : Installer Python
      - name: Setup Python
        uses: actions/setup-python@v5
        with:
          python-version: '3.11'
      
      # Étape 3 : Installer les dépendances
      - name: Install dependencies
        run: |
          pip install holy-sheep-sdk requests pandas
      
      #

Ressources connexes
Articles connexes