Skip to content

vignemail1/manage_challonge

BranchesTags

Folders and files

NameName
Last commit message
Last commit date

Latest commit

 

History

17 Commits
.gitignore
.gitignore
 
 
Pipfile
Pipfile
 
 
Pipfile.lock
Pipfile.lock
 
 
README.md
README.md
 
 
api_server.py
api_server.py
 
 
challonge.py
challonge.py
 
 
env.dist
env.dist
 
 

Repository files navigation

Script de gestion des tournois Challonge

Ce script Python permet de gérer les tournois sur Challonge via leur API.

Avec ce script vous pouvez :

  • créer un tournoi en single (winner only) ou double elimination (winner + loser brackets)
  • ajouter des participants en paramètre et/ou depuis une plage d'une feuille Google Sheet
  • supprimer tous les participants d'un tournoi
  • supprimer des tournois
  • lister vos tournois
  • mélanger la liste des participants d'un tournoi
  • voir le détail d'un tournoi
  • NOUVEAU: API REST pour automatiser les actions via HTTP

Avec ce script vous pouvez facilement envisager d'automatiser votre gestion de tournois jusqu'à programmer des touches de Stream Deck.

Prérequis

  • Python 3.8 ou supérieur (Python 3.12 recommandé)
  • pipenv

Installation de l'environnement python/pipenv

Windows

Option 1 : python dans Windows

  1. Installez Python depuis python.org

    • préférez la version 3.12 qui est la version testée sinon vous devrez ajuster le fichier Pipfile avec la version qui vous utilisez

  2. Ouvrez PowerShell et exécutez :

    pip install pipenv

Option 2 : python via WSL2

Avec WSL2 vous pouvez tourner une VM de type Linux Ubuntu qui monte vos lecteurs Windows C:\ (qui sera disponible en tant que /mnt/c/)... afin de rendre accessible vos fichiers Windows dans un contexte d'execution Linux. L'environnement Linux devient alors accessible dans votre terminal Powershell qui vous proposera d'ouvrir soit un terminal Powershell soit un terminal au sein de la VM Linux.

  1. Installez WSL2 via PowerShell :
    1. Appuyer sur Windows + S pour ouvrir la barre de recherche
    2. Taper "Turn Windows features on or off"
    3. Parcourir les résultats de recherche et aller sur "Windows Subsystem for Linux (WSL)"
    4. Cliquer sur Ok
    5. Ouvrir un terminal Powershell en tant qu'administrateur
    6. Taper wsl --install
    7. Taper ensuite wsl --set-default-version 2
  2. Installer une distribution Linux pour WSL2
    1. Ouvrir le store Microsoft
    2. Chercher "Ubuntu" et cliquer sur Install
    3. Lancer ensuite un terminal en choisissant un terminal de type Ubuntu
    4. Au premier lancement vous serez invité à créer un compte au sein du Linux

Maintenant que WSL2 et Ubuntu sont dispo, il vous suffit d'ouvrir un terminal Ubuntu pour avoir votre environnement qui démarre automatiquement.

Ensuite les instructions sont les mêmes que pour Linux (voir ci-dessous).

Linux

  1. Installez Python et pip avec votre gestionnaire de paquets. Par exemple, sur Ubuntu :

    sudo apt update
sudo apt install python3 python3-pip

  2. Installez pipenv :

    pip3 install pipenv

macOS

  1. Installez Homebrew si ce n'est pas déjà fait :

    /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

  2. Installez Python et pipenv :

    brew install python
pip3 install pipenv

Configuration de l'environnement

  1. Clonez ce dépôt ou téléchargez le script

  2. Dans le répertoire du script, créez l'environnement virtuel :

    pipenv install

Obtention de votre clé API Challonge

  1. Connectez-vous à votre compte Challonge
  2. Allez dans les paramètres de votre compte
  3. Dans la section "Developer API", copiez la Clé API (v1)

Création d'un accès pour Google Sheet (fonction --import-gsheet)

  1. Activer Google Sheets API:
    • Aller sur Google Cloud Console.
    • Créer un nouveau projet ou sélectionner un projet existant selon besoin.
    • Naviguer dans "APIs & Services" > "Bibliothèque".
    • Rechercher "Google Sheets API" et l'activer.
  2. Créer un compte d'accès :
    • Aller dans "APIs & Services" > "Identités".
    • Cliquer "Créer une identité" et choisir "Compte de service".
    • Définir un nom et un identifiant unique de compte de service et cliquer sur Ok.
    • Une fois créé, aller dans la liste des comptes de service puis cliquer sur votre compte de service pour accéder à ses propriétés
    • Se rendre dans l'onglet Clés et créer une clé au format JSON. Une fois créée il vous faudra immédiatement télécharger le fichier .json et l'ajouter dans le dossier du projet.
    • c'est ce fichier JSON qu'il faudra renseigner dans le fichier env.txt.
  3. Partagez votre Google Sheet:
    • Ouvrir Google Sheet.
    • Cliquez sur "Partage" et ajoutez l'email associé au compte de service nouvellement créé (vous pouvez le retrouver dans le fichier JSON) avec le rôle Lecteur (pas besoin de plus).

Voilà, vous avez créé un accès en lecture à votre Google Sheet via API pour que le script puisse faire une lecture de la plage à récupérer pour la fonction --import-gsheet.

Configuration du script

  1. Créez un fichier env.txt dans le même répertoire que le script

    • vous pouvez aussi par simplicité, dupliquer le fichier exemple env.dist en env.txt et éditer les valeurs dans env.txt
    • attention ne pas y mettre de caractères accentués dans le fichier env.txt car le module python-dotenv utilisé pour lire le fichier env.txt ne le supporte pas sous Windows.

  2. Ajoutez votre clé API dans ce fichier :

    CHALLONGE_API_KEY=votre_clé_api_ici

  3. (optionnel) Vous changez également la Timezone dans laquelle vous voulez la sortie des dates/heures en ajoutant dans env.txt :

    TIMEZONE=Europe/Paris

  4. (optionnel) si vous souhaitez faire un import depuis un Google Sheet et que vous avez créer votre compte de service, ajoutez les éléments suivants dans le fichier env.txt :

    GOOGLE_APPLICATION_CREDENTIALS=nom_fichier_credential_service_account.json
# pour un document d'url https://docs.google.com/spreadsheets/d/{{GOOGLE_SHEET_ID}}/edit?gid=0#gid=0
GOOGLE_SHEET_ID={{GOOGLE_SHEET_ID}}
GOOGLE_SHEET_WORKSHEET=feuille_dans_spreadsheet
GOOGLE_SHEET_RANGE=plage_colonne_au_format_A2:A33

  5. (optionnel) Configuration API REST :

    # Configuration pour l'API REST (optionnel)
API_HOST=0.0.0.0
API_PORT=5000
API_DEBUG=True

Utilisation du script

Exécutez le script avec la commande souhaitée.

Avant toute exécution, il faut :

  • soit se mettre dans l'environnement pipenv créé avec pipenv shell depuis le dossier du projet pour lancer directement des commandes ./challonge <command> [options]
  • soit préfixer par pipenv run (méthode ici documentée et recommandée surtout pour des appels depuis d'autres programmes)

Pour voir toutes les commandes disponibles :

pipenv run challonge --help

Lister les tournois

# usage: challonge list [-h] [--start_date START_DATE] [--end_date END_DATE] [--participants_count PARTICIPANTS_COUNT] [--state {all,pending,in_progress,ended}] [--short] [--full_url] [--json] [--full_json] [--last]

# Lister les tournois
pipenv run challonge list

Sortie exemple :

╒══════════╤═════════╤════════════════════╤══════════════════════════╤══════════════════════╤═════════╕
│ url      │ title   │ tournament_type    │ created_at               │ participants_count   │ state   │
╞══════════╪═════════╪════════════════════╪══════════════════════════╪══════════════════════╪═════════╡
│ pl888gdr │ double  │ double elimination │ 2024-10-12 14:25:26 CEST│ 0                    │ pending │
├──────────┼─────────┼────────────────────┼──────────────────────────┼──────────────────────┼─────────┤
│ sf901z3a │ single  │ single elimination │ 2024-10-12 14:21:30 CEST│ 0                    │ pending │
╘══════════╧═════════╧════════════════════╧══════════════════════════╧══════════════════════╧═════════╛

# NOUVEAU: Filtrer par état du tournoi
pipenv run challonge list --state pending
pipenv run challonge list --state in_progress
pipenv run challonge list --state ended

# Liste les tournois au format JSON
pipenv run challonge list --json

# Liste les tournois au format JSON avec participants
pipenv run challonge list --json --full_json

# Lister les tournois avec URL complète
pipenv run challonge list --full_url

# Lister les tournois depuis une date
pipenv run challonge list --start_date 2024-09-01

# NOUVEAU: Dernier tournoi en attente uniquement
pipenv run challonge list --last --short --state pending

Supprimer les tournois

# usage: challonge delete [-h] (--urls URLS [URLS ...] | --start_date START_DATE) [--end_date END_DATE]

# Tous les tournois à partir d'une date
pipenv run challonge delete --start_date 2024-09-01

# Les tournois spécifiés par leur fin d'url
pipenv run challonge delete --urls bbkdcbam

Créer un tournoi à élimination simple

# usage: challonge create_single [-h] --name NAME [--generate_participants GENERATE_PARTICIPANTS]
pipenv run challonge create_single --name "Switcharoo"
pipenv run challonge create_single --name "Test 12 teams" --generate_participants 12

Créer un tournoi à double élimination

# usage: challonge create_double [-h] --name NAME [--generate_participants GENERATE_PARTICIPANTS]
pipenv run challonge create_double --name "Switcharoo"
pipenv run challonge create_double --name "Test 8 teams" --generate_participants 8

Ajouter des participants à un tournoi

# usage: challonge add_participants [-h] --url URL [--participants [PARTICIPANTS ...]] [--import-gsheet] [--generate_participants GENERATE_PARTICIPANTS]

# Ajout manuel des participants
pipenv run challonge add_participants --url bbkdcbam --participants "player1 x player2" "player3 x player4" "player5 x player6" "player7 x player8"

# Ajout automatique depuis le google Sheet référencé
pipenv run challonge add_participants --url bbkdcbam --import-gsheet

# Ajout de 12 équipes au format TeamXXX
pipenv run challonge add_participants --url yg1rl9df --generate_participants 12

Supprimer tous les participants d'un tournoi

# usage: challonge remove_participants [-h] (--url URL | --last) [--accept]
pipenv run challonge remove_participants --url bbkdcba

# ou bien
pipenv run challonge remove_participants --last

# ou bien
pipenv run challonge remove_participants --last --accept

Changer le type d'elimination d'un tournoi

# usage: challonge toggle_type [-h] --url URL
pipenv run challonge toggle_type --url bbkdcbam

Mélanger la liste des participants

# usage: challonge randomize [-h] --url URL
pipenv run challonge randomize --url bbkdcbam

API REST

NOUVEAU : Une API REST est maintenant disponible pour automatiser les actions via HTTP.

Démarrage de l'API

# Démarrer l'API REST
pipenv run api

# L'API sera disponible sur http://localhost:5000

Authentification

Toutes les requêtes API nécessitent un token d'authentification utilisant votre clé API Challonge :

?token=YOUR_CHALLONGE_API_KEY

Endpoints disponibles

Mélanger les participants d'un tournoi

# Mélanger le dernier tournoi créé
curl -X POST "http://localhost:5000/randomize?token=YOUR_API_KEY"

# Mélanger le dernier tournoi en attente
curl -X POST "http://localhost:5000/randomize?token=YOUR_API_KEY&state=pending"

# Mélanger un tournoi spécifique
curl -X POST "http://localhost:5000/randomize/bbkdcbam?token=YOUR_API_KEY"

Récupérer le dernier tournoi

# Format JSON (par défaut)
curl "http://localhost:5000/last?token=YOUR_API_KEY"

# Format texte brut (uniquement l'URL)
curl "http://localhost:5000/last?token=YOUR_API_KEY&format=text"

# Dernier tournoi avec un état spécifique
curl "http://localhost:5000/last?token=YOUR_API_KEY&state=pending&format=text"

Santé de l'API

# Vérifier que l'API fonctionne
curl "http://localhost:5000/health"

Documentation de l'API

# Obtenir la documentation complète
curl "http://localhost:5000/"

Paramètres API

Paramètre state

Filtre les tournois par état :

  • all (par défaut) : tous les états
  • pending : tournois en attente
  • in_progress : tournois en cours
  • ended : tournois terminés

Paramètre format (endpoint /last uniquement)

Format de la réponse :

  • json (par défaut) : réponse JSON complète
  • text : uniquement l'URL du tournoi en texte brut

Exemples d'intégration

Script bash utilisant l'API

#!/bin/bash
API_TOKEN="your_challonge_api_key"

# Récupérer le dernier tournoi en attente
TOURNAMENT_URL=$(curl -s "http://localhost:5000/last?token=${API_TOKEN}&state=pending&format=text")

if [ $? -eq 0 ] && [ ! -z "$TOURNAMENT_URL" ]; then
    echo "Mélange du tournoi: $TOURNAMENT_URL"
    curl -X POST "http://localhost:5000/randomize/${TOURNAMENT_URL}?token=${API_TOKEN}"
else
    echo "Aucun tournoi en attente trouvé"
fi

Script PowerShell pour Windows

# Script PowerShell d'exemple d'intégration avec l'API Challonge
$API_TOKEN = "your_challonge_api_key"
$API_BASE_URL = "http://localhost:5000"

# Fonction pour faire des requêtes HTTP avec gestion d'erreurs
function Invoke-ChallongeAPI {
    param(
        [string]$Endpoint,
        [string]$Method = "GET",
        [hashtable]$Params = @{}
    )
    
    # Ajouter le token à tous les paramètres
    $Params["token"] = $API_TOKEN
    
    # Construire l'URL avec les paramètres
    $Uri = "$API_BASE_URL$Endpoint"
    if ($Params.Count -gt 0) {
        $QueryString = ($Params.GetEnumerator() | ForEach-Object { "$($_.Key)=$($_.Value)" }) -join "&"
        $Uri = "$Uri?$QueryString"
    }
    
    try {
        $Response = Invoke-RestMethod -Uri $Uri -Method $Method -ErrorAction Stop
        return $Response
    }
    catch {
        Write-Error "Erreur API: $($_.Exception.Message)"
        return $null
    }
}

# Exemple 1: Récupérer le dernier tournoi en attente
Write-Host "=== Récupération du dernier tournoi en attente ==="
$LastTournament = Invoke-ChallongeAPI -Endpoint "/last" -Params @{
    "state" = "pending"
    "format" = "text"
}

if ($LastTournament) {
    Write-Host "Dernier tournoi trouvé: $LastTournament" -ForegroundColor Green
    
    # Exemple 2: Mélanger ce tournoi
    Write-Host "=== Mélange des participants ==="
    $Result = Invoke-ChallongeAPI -Endpoint "/randomize/$LastTournament" -Method "POST"
    if ($Result) {
        Write-Host "Participants mélangés avec succès!" -ForegroundColor Green
        Write-Host "Message: $($Result.message)" -ForegroundColor Cyan
    }
} else {
    Write-Host "Aucun tournoi en attente trouvé" -ForegroundColor Yellow
}

# Exemple 3: Vérifier la santé de l'API
Write-Host "=== Vérification de l'API ==="
$Health = Invoke-ChallongeAPI -Endpoint "/health"
if ($Health -and $Health.status -eq "healthy") {
    Write-Host "API opérationnelle: $($Health.message)" -ForegroundColor Green
} else {
    Write-Host "Problème avec l'API" -ForegroundColor Red
}

# Exemple 4: Fonctions utilitaires pour Stream Deck ou autres automatisations

# Fonction pour mélanger le dernier tournoi (tous états)
function Start-RandomizeLastTournament {
    Write-Host "Mélange du dernier tournoi..."
    $Result = Invoke-ChallongeAPI -Endpoint "/randomize" -Method "POST"
    if ($Result) {
        Write-Host "✓ $($Result.message)" -ForegroundColor Green
        return $Result.tournament_url
    }
    return $null
}

# Fonction pour mélanger le dernier tournoi en attente seulement
function Start-RandomizePendingTournament {
    Write-Host "Mélange du dernier tournoi en attente..."
    $Result = Invoke-ChallongeAPI -Endpoint "/randomize" -Method "POST" -Params @{"state" = "pending"}
    if ($Result) {
        Write-Host "✓ $($Result.message)" -ForegroundColor Green
        return $Result.tournament_url
    }
    return $null
}

# Fonction pour obtenir l'URL du dernier tournoi avec état spécifique
function Get-LastTournamentUrl {
    param([string]$State = "all")
    
    $Tournament = Invoke-ChallongeAPI -Endpoint "/last" -Params @{
        "state" = $State
        "format" = "text"
    }
    return $Tournament
}

# Exemples d'utilisation des fonctions utilitaires
Write-Host "`n=== Exemples d'utilisation ==="

# Utilisation simple
$TournamentUrl = Start-RandomizeLastTournament
if ($TournamentUrl) {
    Write-Host "Tournoi mélangé: $TournamentUrl"
}

# Récupération d'URL pour usage ultérieur
$PendingTournament = Get-LastTournamentUrl -State "pending"
if ($PendingTournament) {
    Write-Host "URL du dernier tournoi en attente: $PendingTournament"
}

Utilisation avec des tâches planifiées Windows

# Exemple de script pour tâche planifiée qui mélange automatiquement 
# le dernier tournoi en attente toutes les heures

$API_TOKEN = "your_challonge_api_key"

try {
    $Response = Invoke-RestMethod -Uri "http://localhost:5000/randomize?token=$API_TOKEN&state=pending" -Method POST
    
    # Log du résultat
    $LogMessage = "$(Get-Date -Format 'yyyy-MM-dd HH:mm:ss') - $($Response.message)"
    Add-Content -Path "C:\temp\challonge_auto.log" -Value $LogMessage
    
    Write-Host $Response.message
} catch {
    $ErrorMessage = "$(Get-Date -Format 'yyyy-MM-dd HH:mm:ss') - Erreur: $($_.Exception.Message)"
    Add-Content -Path "C:\temp\challonge_auto.log" -Value $ErrorMessage
    Write-Error $_.Exception.Message
}

Intégration Windows avancée

Avec PowerShell ISE ou Visual Studio Code

  • Utilise l'IntelliSense pour auto-compléter les commandes API
  • Débogage interactif avec points d'arrêt
  • Intégration native avec les services Windows

Avec le Planificateur de tâches Windows

REM Créer une tâche planifiée qui exécute le script PowerShell
schtasks /create /tn "ChallongeMix" /tr "powershell.exe -ExecutionPolicy Bypass -File C:\scripts\challonge-mix.ps1" /sc hourly

Avec Stream Deck (Windows)

Utilise l'action "System > Open" avec comme paramètre :

powershell.exe -Command "Invoke-RestMethod -Uri 'http://localhost:5000/randomize?token=YOUR_TOKEN&state=pending' -Method POST"

Variables d'environnement Windows

REM Définir le token dans les variables d'environnement système
setx CHALLONGE_API_KEY "your_api_key_here" /M

REM Utiliser dans PowerShell
$env:CHALLONGE_API_KEY

Configuration Stream Deck

L'API peut être facilement intégrée avec un Stream Deck pour automatiser les actions :

  • Bouton "Mélanger dernier tournoi" : POST /randomize?token=...
  • Bouton "Mélanger tournois en attente" : POST /randomize?token=...&state=pending

Codes de réponse HTTP

  • 200 : Succès
  • 400 : Paramètres invalides
  • 401 : Token manquant
  • 403 : Token invalide
  • 404 : Ressource non trouvée
  • 405 : Méthode HTTP non autorisée
  • 500 : Erreur interne

Configuration avancée de l'API

Dans votre fichier env.txt, vous pouvez personnaliser l'API :

# Configuration API (optionnel)
API_HOST=0.0.0.0          # Adresse d'écoute (défaut: 0.0.0.0)
API_PORT=5000             # Port d'écoute (défaut: 5000)
API_DEBUG=True            # Mode debug (défaut: True)

About

Script de gestion des tournois Challonge

Topics

api-client python3 challonge tourney

Resources

Readme
Activity

Stars

0 stars

Watchers

1 watching

Forks

0 forks
Report repository

Releases 6

v1.0.6 - API server Latest
Sep 11, 2025
+ 5 releases

Packages

No packages published

Languages