621 lines
24 KiB
Python
621 lines
24 KiB
Python
#!/usr/bin/env python3
|
||
"""
|
||
facilitator.py — Sliding Pipeline v3 · Pernod Ricard
|
||
=====================================================
|
||
Orchestre les 3 agents du nouveau pipeline :
|
||
|
||
The Narrator (Agent 1) → Markdown narratif
|
||
↓ approbation Bastien
|
||
The Designer (Agent 2) → Plan de présentation texte
|
||
↓ approbation optionnelle
|
||
The Encoder (Agent 3) → YAML valide
|
||
↓
|
||
render_engine.py → PPTX
|
||
|
||
Variables .env requises :
|
||
MISTRAL_API_KEY
|
||
NARRATOR_AGENT_ID
|
||
DESIGNER_AGENT_ID
|
||
ENCODER_AGENT_ID
|
||
OUTPUT_DIR (dossier de sortie des YAML/PPTX, défaut : ./output)
|
||
THEME_PATH (défaut : theme.yaml)
|
||
COMPONENTS_PATH (défaut : components.yaml)
|
||
LAYOUTS_PATH (défaut : layouts.yaml)
|
||
"""
|
||
|
||
import json
|
||
import os
|
||
import re
|
||
import sys
|
||
import textwrap
|
||
from datetime import datetime
|
||
from pathlib import Path
|
||
|
||
import requests
|
||
import yaml
|
||
from dotenv import load_dotenv
|
||
from typing import Optional, Tuple, Dict, Union, List
|
||
|
||
load_dotenv()
|
||
|
||
# ─────────────────────────────────────────────────────────────────────────────
|
||
# CONFIGURATION
|
||
# ─────────────────────────────────────────────────────────────────────────────
|
||
|
||
API_KEY = os.getenv("MISTRAL_API_KEY")
|
||
NARRATOR_ID = os.getenv("NARRATOR_AGENT_ID")
|
||
DESIGNER_ID = os.getenv("DESIGNER_AGENT_ID")
|
||
ENCODER_ID = os.getenv("ENCODER_AGENT_ID")
|
||
OUTPUT_DIR = Path(os.getenv("OUTPUT_DIR", "./output"))
|
||
THEME_PATH = os.getenv("THEME_PATH", "theme.yaml")
|
||
COMPONENTS_PATH = os.getenv("COMPONENTS_PATH", "components.yaml")
|
||
LAYOUTS_PATH = os.getenv("LAYOUTS_PATH", "layouts.yaml")
|
||
|
||
HEADERS = {
|
||
"Authorization": f"Bearer {API_KEY}",
|
||
"Content-Type": "application/json",
|
||
}
|
||
|
||
VERSION = "3.0"
|
||
|
||
OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
|
||
|
||
|
||
# ─────────────────────────────────────────────────────────────────────────────
|
||
# UTILITAIRES D'AFFICHAGE
|
||
# ─────────────────────────────────────────────────────────────────────────────
|
||
|
||
def banner():
|
||
print("\n" + "═" * 62)
|
||
print(f" SLIDING PIPELINE v{VERSION} — Pernod Ricard")
|
||
print(f" {datetime.now().strftime('%d/%m/%Y %H:%M')}")
|
||
print("═" * 62 + "\n")
|
||
|
||
|
||
def section(title: str):
|
||
print(f"\n{'─' * 62}")
|
||
print(f" {title}")
|
||
print(f"{'─' * 62}\n")
|
||
|
||
|
||
def info(msg: str):
|
||
print(f" ℹ {msg}")
|
||
|
||
|
||
def ok(msg: str):
|
||
print(f" ✓ {msg}")
|
||
|
||
|
||
def warn(msg: str):
|
||
print(f" ⚠ {msg}")
|
||
|
||
|
||
def ask(prompt: str) -> str:
|
||
try:
|
||
return input(f"\n {prompt} ").strip()
|
||
except (EOFError, KeyboardInterrupt):
|
||
print("\n Session interrompue.")
|
||
sys.exit(0)
|
||
|
||
|
||
def display_markdown(text: str, max_lines: int = 60):
|
||
"""Affiche le Markdown avec un max de lignes."""
|
||
lines = text.splitlines()
|
||
if len(lines) <= max_lines:
|
||
print(textwrap.indent(text, " "))
|
||
else:
|
||
preview = "\n".join(lines[:max_lines])
|
||
print(textwrap.indent(preview, " "))
|
||
print(f"\n ... [{len(lines) - max_lines} lignes supplémentaires — "
|
||
f"choisissez [4] pour tout voir]")
|
||
|
||
|
||
def display_plan(text: str, max_lines: int = 80):
|
||
"""Affiche le plan du Designer — extrait les lignes SLIDE pour un résumé rapide."""
|
||
slides = [l for l in text.splitlines() if l.strip().startswith("SLIDE")]
|
||
if slides:
|
||
print(" Résumé du plan :\n")
|
||
for s in slides:
|
||
print(f" {s.strip()}")
|
||
print(f"\n ({len(slides)} slides au total)")
|
||
else:
|
||
display_markdown(text, max_lines)
|
||
|
||
|
||
# ─────────────────────────────────────────────────────────────────────────────
|
||
# APPEL AGENT MISTRAL (avec gestion PAUSE/continue)
|
||
# ─────────────────────────────────────────────────────────────────────────────
|
||
|
||
def call_agent(agent_id: str, messages: list) -> str:
|
||
"""
|
||
Appelle un agent Mistral et gère la pagination PAUSE/continue.
|
||
Retourne la réponse complète concaténée.
|
||
"""
|
||
full_response = ""
|
||
current_messages = messages.copy()
|
||
|
||
while True:
|
||
resp = requests.post(
|
||
"https://api.mistral.ai/v1/agents/completions",
|
||
headers=HEADERS,
|
||
json={"agent_id": agent_id, "messages": current_messages},
|
||
timeout=120,
|
||
)
|
||
resp.raise_for_status()
|
||
content = resp.json()["choices"][0]["message"]["content"]
|
||
full_response += content
|
||
|
||
# Détection pagination
|
||
if "PAUSE" in content and "FIN —" not in content:
|
||
info("Pagination détectée → continuation automatique...")
|
||
current_messages.append({"role": "assistant", "content": content})
|
||
current_messages.append({"role": "user", "content": "continue"})
|
||
else:
|
||
break
|
||
|
||
return full_response
|
||
|
||
|
||
def call_with_feedback(agent_id: str, initial_message: str,
|
||
feedback: str, previous_output: str) -> str:
|
||
"""Relance un agent avec le feedback utilisateur et la sortie précédente."""
|
||
messages = [
|
||
{"role": "user", "content": initial_message},
|
||
{"role": "assistant", "content": previous_output},
|
||
{"role": "user", "content": feedback},
|
||
]
|
||
return call_agent(agent_id, messages)
|
||
|
||
|
||
# ─────────────────────────────────────────────────────────────────────────────
|
||
# VALIDATION YAML (The Encoder)
|
||
# ─────────────────────────────────────────────────────────────────────────────
|
||
|
||
def extract_yaml(raw: str) -> str:
|
||
"""
|
||
Extrait le bloc YAML d'une réponse (enlève les ```yaml ... ``` si présents).
|
||
"""
|
||
# Bloc markdown yaml
|
||
match = re.search(r"```ya?ml\s*(.*?)```", raw, re.DOTALL | re.IGNORECASE)
|
||
if match:
|
||
return match.group(1).strip()
|
||
# Pas de bloc → retourne tel quel
|
||
return raw.strip()
|
||
|
||
|
||
def validate_yaml(raw: str, layouts: dict) -> tuple[bool, str, Optional[dict]]:
|
||
"""
|
||
Valide la syntaxe YAML et vérifie les contraintes de base.
|
||
Retourne (is_valid, message_erreur, data_parsée).
|
||
"""
|
||
try:
|
||
content = extract_yaml(raw)
|
||
data = yaml.safe_load(content)
|
||
except yaml.YAMLError as e:
|
||
return False, f"Erreur de syntaxe YAML : {e}", None
|
||
|
||
if not isinstance(data, dict):
|
||
return False, "Le YAML doit être un dictionnaire à la racine.", None
|
||
|
||
slides = data.get("slides")
|
||
if not slides:
|
||
return False, "Clé 'slides' manquante ou vide.", None
|
||
|
||
errors = []
|
||
valid_layouts = set(layouts.keys())
|
||
|
||
for i, slide in enumerate(slides):
|
||
pos = slide.get("position", i + 1)
|
||
layout = slide.get("layout", "")
|
||
|
||
if not layout:
|
||
errors.append(f"Slide {pos} : clé 'layout' manquante")
|
||
continue
|
||
|
||
if layout not in valid_layouts:
|
||
errors.append(f"Slide {pos} : layout '{layout}' inconnu "
|
||
f"(valides : {', '.join(sorted(valid_layouts)[:5])}...)")
|
||
continue
|
||
|
||
# Vérification des champs requis
|
||
schema = layouts[layout].get("json_schema", {})
|
||
required_fields = schema.get("required", [])
|
||
for field in required_fields:
|
||
if field not in slide:
|
||
errors.append(f"Slide {pos} ({layout}) : champ requis '{field}' manquant")
|
||
|
||
if errors:
|
||
return False, "\n ".join(errors), data
|
||
|
||
return True, f"{len(slides)} slides valides.", data
|
||
|
||
|
||
# ─────────────────────────────────────────────────────────────────────────────
|
||
# SAUVEGARDE
|
||
# ─────────────────────────────────────────────────────────────────────────────
|
||
|
||
def save_output(content: str, suffix: str, ext: str) -> Path:
|
||
"""Sauvegarde un fichier de sortie avec timestamp."""
|
||
timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
|
||
filename = OUTPUT_DIR / f"sliding_{timestamp}_{suffix}.{ext}"
|
||
filename.write_text(content, encoding="utf-8")
|
||
ok(f"Sauvegardé : {filename}")
|
||
return filename
|
||
|
||
|
||
# ─────────────────────────────────────────────────────────────────────────────
|
||
# CHARGEMENT DES LAYOUTS (pour validation)
|
||
# ─────────────────────────────────────────────────────────────────────────────
|
||
|
||
def load_layouts() -> dict:
|
||
if not os.path.exists(LAYOUTS_PATH):
|
||
warn(f"layouts.yaml introuvable ({LAYOUTS_PATH}) — validation désactivée")
|
||
return {}
|
||
with open(LAYOUTS_PATH, encoding="utf-8") as f:
|
||
data = yaml.safe_load(f)
|
||
return data.get("layouts", {})
|
||
|
||
|
||
# ─────────────────────────────────────────────────────────────────────────────
|
||
# ÉTAPE 1 — THE NARRATOR
|
||
# ─────────────────────────────────────────────────────────────────────────────
|
||
|
||
def run_narrator(brief: str) -> str:
|
||
"""
|
||
Lance The Narrator sur le brief.
|
||
Boucle d'approbation : valider / feedback / régénérer / afficher.
|
||
Retourne le Markdown approuvé.
|
||
"""
|
||
section("ÉTAPE 1 — THE NARRATOR")
|
||
info("Génération du Markdown narratif...")
|
||
|
||
messages = [{"role": "user", "content": brief}]
|
||
output = call_agent(NARRATOR_ID, messages)
|
||
ok(f"Markdown généré ({len(output)} caractères)")
|
||
|
||
while True:
|
||
print()
|
||
display_markdown(output)
|
||
|
||
print("\n [1] Valider → passer au Designer")
|
||
print(" [2] Donner du feedback au Narrator")
|
||
print(" [3] Régénérer complètement")
|
||
print(" [4] Afficher le Markdown complet")
|
||
print(" [5] Sauvegarder le Markdown")
|
||
|
||
choix = ask("Votre choix :")
|
||
|
||
if choix == "1":
|
||
ok("Markdown approuvé. Passage au Designer...")
|
||
save_output(output, "narrator", "md")
|
||
return output
|
||
|
||
elif choix == "2":
|
||
feedback = ask("Votre feedback :")
|
||
if not feedback:
|
||
continue
|
||
info("Envoi du feedback au Narrator...")
|
||
output = call_with_feedback(NARRATOR_ID, brief, feedback, output)
|
||
ok(f"Nouveau Markdown ({len(output)} caractères)")
|
||
|
||
elif choix == "3":
|
||
info("Régénération depuis le brief...")
|
||
messages = [{"role": "user", "content": brief}]
|
||
output = call_agent(NARRATOR_ID, messages)
|
||
ok(f"Nouveau Markdown ({len(output)} caractères)")
|
||
|
||
elif choix == "4":
|
||
print()
|
||
print(textwrap.indent(output, " "))
|
||
|
||
elif choix == "5":
|
||
save_output(output, "narrator_draft", "md")
|
||
|
||
else:
|
||
warn("Choix invalide. Entrez 1 à 5.")
|
||
|
||
|
||
# ─────────────────────────────────────────────────────────────────────────────
|
||
# ÉTAPE 2 — THE DESIGNER
|
||
# ─────────────────────────────────────────────────────────────────────────────
|
||
|
||
def run_designer(markdown: str) -> str:
|
||
"""
|
||
Lance The Designer sur le Markdown approuvé.
|
||
Boucle d'approbation légère : valider / feedback / afficher.
|
||
Retourne le plan texte structuré.
|
||
"""
|
||
section("ÉTAPE 2 — THE DESIGNER")
|
||
info("Génération du plan de présentation...")
|
||
|
||
messages = [{"role": "user", "content": markdown}]
|
||
output = call_agent(DESIGNER_ID, messages)
|
||
ok(f"Plan généré ({len(output)} caractères)")
|
||
|
||
while True:
|
||
print()
|
||
display_plan(output)
|
||
|
||
print("\n [1] Valider → passer à l'Encoder")
|
||
print(" [2] Donner du feedback au Designer")
|
||
print(" [3] Afficher le plan complet")
|
||
print(" [4] Sauvegarder le plan")
|
||
print(" [0] Revenir au Narrator (modifier le Markdown)")
|
||
|
||
choix = ask("Votre choix :")
|
||
|
||
if choix == "1":
|
||
ok("Plan approuvé. Passage à l'Encoder...")
|
||
save_output(output, "designer", "txt")
|
||
return output
|
||
|
||
elif choix == "2":
|
||
feedback = ask("Votre feedback :")
|
||
if not feedback:
|
||
continue
|
||
info("Envoi du feedback au Designer...")
|
||
output = call_with_feedback(DESIGNER_ID, markdown, feedback, output)
|
||
ok(f"Nouveau plan ({len(output)} caractères)")
|
||
|
||
elif choix == "3":
|
||
print()
|
||
print(textwrap.indent(output, " "))
|
||
|
||
elif choix == "4":
|
||
save_output(output, "designer_draft", "txt")
|
||
|
||
elif choix == "0":
|
||
return None # Signal : retour au Narrator
|
||
|
||
else:
|
||
warn("Choix invalide. Entrez 0 à 4.")
|
||
|
||
|
||
# ─────────────────────────────────────────────────────────────────────────────
|
||
# ÉTAPE 3 — THE ENCODER
|
||
# ─────────────────────────────────────────────────────────────────────────────
|
||
|
||
def run_encoder(plan: str, layouts: dict) -> tuple[str, dict]:
|
||
"""
|
||
Lance The Encoder sur le plan du Designer.
|
||
Valide le YAML produit. Boucle jusqu'à YAML valide ou abandon.
|
||
Retourne (yaml_string, yaml_dict).
|
||
"""
|
||
section("ÉTAPE 3 — THE ENCODER")
|
||
info("Encodage du plan en YAML...")
|
||
|
||
messages = [{"role": "user", "content": plan}]
|
||
output = call_agent(ENCODER_ID, messages)
|
||
ok(f"YAML brut reçu ({len(output)} caractères)")
|
||
|
||
attempts = 0
|
||
max_attempts = 3
|
||
|
||
while attempts < max_attempts:
|
||
is_valid, message, data = validate_yaml(output, layouts)
|
||
|
||
if is_valid:
|
||
ok(f"YAML valide : {message}")
|
||
yaml_clean = extract_yaml(output)
|
||
save_output(yaml_clean, "encoder", "yaml")
|
||
return yaml_clean, data
|
||
|
||
else:
|
||
attempts += 1
|
||
warn(f"YAML invalide (tentative {attempts}/{max_attempts}) :")
|
||
print(f" {message}\n")
|
||
|
||
if attempts >= max_attempts:
|
||
warn("Nombre maximum de tentatives atteint.")
|
||
break
|
||
|
||
info("Correction automatique...")
|
||
correction_msg = (
|
||
f"Le YAML que tu as généré contient des erreurs :\n\n"
|
||
f"{message}\n\n"
|
||
f"Corrige ces erreurs et renvoie uniquement le YAML corrigé "
|
||
f"sans aucun texte avant ou après."
|
||
)
|
||
output = call_with_feedback(ENCODER_ID, plan, correction_msg, output)
|
||
ok(f"YAML corrigé reçu ({len(output)} caractères)")
|
||
|
||
# Après max_attempts : choix utilisateur
|
||
print()
|
||
print(" [1] Accepter le YAML tel quel (avec erreurs)")
|
||
print(" [2] Donner un feedback manuel à l'Encoder")
|
||
print(" [0] Abandonner et revenir au Designer")
|
||
|
||
choix = ask("Votre choix :")
|
||
|
||
if choix == "1":
|
||
yaml_clean = extract_yaml(output)
|
||
save_output(yaml_clean, "encoder_unvalidated", "yaml")
|
||
try:
|
||
data = yaml.safe_load(yaml_clean) or {}
|
||
except Exception:
|
||
data = {}
|
||
return yaml_clean, data
|
||
|
||
elif choix == "2":
|
||
feedback = ask("Votre feedback :")
|
||
output = call_with_feedback(ENCODER_ID, plan, feedback, output)
|
||
yaml_clean = extract_yaml(output)
|
||
save_output(yaml_clean, "encoder_manual", "yaml")
|
||
try:
|
||
data = yaml.safe_load(yaml_clean) or {}
|
||
except Exception:
|
||
data = {}
|
||
return yaml_clean, data
|
||
|
||
else:
|
||
return None, None # Signal : retour au Designer
|
||
|
||
|
||
# ─────────────────────────────────────────────────────────────────────────────
|
||
# ÉTAPE 4 — RENDER ENGINE
|
||
# ─────────────────────────────────────────────────────────────────────────────
|
||
|
||
def run_render(yaml_data: dict) -> Optional[Path]:
|
||
"""
|
||
Appelle render_engine.py avec le YAML validé.
|
||
Retourne le chemin du PPTX généré, ou None si erreur.
|
||
"""
|
||
section("ÉTAPE 4 — RENDER ENGINE")
|
||
|
||
# Vérifie que render_engine.py est accessible
|
||
render_path = Path("render_engine.py")
|
||
if not render_path.exists():
|
||
warn("render_engine.py introuvable dans le dossier courant.")
|
||
warn("Vérifiez que render_engine.py est dans le même dossier que facilitator.py")
|
||
return None
|
||
|
||
# Vérifie les YAML de config
|
||
for path in [THEME_PATH, COMPONENTS_PATH, LAYOUTS_PATH]:
|
||
if not os.path.exists(path):
|
||
warn(f"Fichier YAML manquant : {path}")
|
||
return None
|
||
|
||
# Sauvegarde temporaire du YAML pour render_engine
|
||
timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
|
||
yaml_tmp = OUTPUT_DIR / f"sliding_{timestamp}_input.yaml"
|
||
pptx_out = OUTPUT_DIR / f"sliding_{timestamp}.pptx"
|
||
|
||
if not yaml_data:
|
||
warn("yaml_data est vide — impossible de générer le PPTX.")
|
||
return None
|
||
|
||
yaml_content = yaml.dump(yaml_data, allow_unicode=True, default_flow_style=False)
|
||
yaml_tmp.write_text(yaml_content, encoding="utf-8")
|
||
|
||
# Vérification que le fichier n'est pas vide
|
||
if yaml_tmp.stat().st_size == 0:
|
||
warn(f"Fichier YAML temporaire vide : {yaml_tmp}")
|
||
return None
|
||
|
||
info(f"Lancement de render_engine.py...")
|
||
info(f"Sortie : {pptx_out}")
|
||
|
||
import subprocess
|
||
result = subprocess.run(
|
||
[
|
||
sys.executable, str(render_path),
|
||
str(yaml_tmp), str(pptx_out),
|
||
"--theme", THEME_PATH,
|
||
"--components", COMPONENTS_PATH,
|
||
"--layouts", LAYOUTS_PATH,
|
||
],
|
||
capture_output=True,
|
||
text=True,
|
||
)
|
||
|
||
if result.returncode == 0:
|
||
ok(result.stdout.strip() or f"PPTX généré : {pptx_out}")
|
||
return pptx_out
|
||
else:
|
||
warn("Erreur dans render_engine.py :")
|
||
print(textwrap.indent(result.stderr or result.stdout, " "))
|
||
return None
|
||
|
||
|
||
# ─────────────────────────────────────────────────────────────────────────────
|
||
# BOUCLE PRINCIPALE
|
||
# ─────────────────────────────────────────────────────────────────────────────
|
||
|
||
def run():
|
||
banner()
|
||
|
||
# Vérification config minimale
|
||
missing = [k for k, v in {
|
||
"MISTRAL_API_KEY": API_KEY,
|
||
"NARRATOR_AGENT_ID": NARRATOR_ID,
|
||
"DESIGNER_AGENT_ID": DESIGNER_ID,
|
||
"ENCODER_AGENT_ID": ENCODER_ID,
|
||
}.items() if not v]
|
||
|
||
if missing:
|
||
for m in missing:
|
||
warn(f"Variable .env manquante : {m}")
|
||
sys.exit(1)
|
||
|
||
# Chargement layouts pour validation
|
||
layouts = load_layouts()
|
||
if layouts:
|
||
ok(f"layouts.yaml chargé — {len(layouts)} layouts")
|
||
|
||
print(" Commandes : brief libre | quit")
|
||
print(" Tapez votre brief pour démarrer une nouvelle présentation.\n")
|
||
|
||
# ── Boucle de session ─────────────────────────────────────
|
||
while True:
|
||
try:
|
||
brief = input(" Vous : ").strip()
|
||
except (EOFError, KeyboardInterrupt):
|
||
print("\n Session terminée.")
|
||
break
|
||
|
||
if brief.lower() in ("quit", "exit", "q"):
|
||
print(" Au revoir.")
|
||
break
|
||
|
||
if not brief:
|
||
continue
|
||
|
||
# ── Pipeline complet ──────────────────────────────────
|
||
|
||
# ÉTAPE 1 — Narrator
|
||
markdown = run_narrator(brief)
|
||
if not markdown:
|
||
continue
|
||
|
||
# ÉTAPE 2 — Designer (avec possibilité de revenir au Narrator)
|
||
while True:
|
||
plan = run_designer(markdown)
|
||
|
||
if plan is None:
|
||
# Retour au Narrator
|
||
section("RETOUR AU NARRATOR")
|
||
info("Donnez un feedback pour modifier le Markdown :")
|
||
feedback = ask("Feedback :")
|
||
if feedback:
|
||
markdown = call_with_feedback(
|
||
NARRATOR_ID, brief, feedback, markdown)
|
||
ok(f"Markdown mis à jour ({len(markdown)} caractères)")
|
||
continue
|
||
|
||
# ÉTAPE 3 — Encoder (avec possibilité de revenir au Designer)
|
||
yaml_str, yaml_data = run_encoder(plan, layouts)
|
||
|
||
if yaml_str is None:
|
||
# Retour au Designer
|
||
info("Retour au Designer...")
|
||
continue
|
||
|
||
break # YAML OK → on sort de la boucle Designer/Encoder
|
||
|
||
# ÉTAPE 4 — Render
|
||
if yaml_data:
|
||
pptx_path = run_render(yaml_data)
|
||
|
||
if pptx_path and pptx_path.exists():
|
||
section("PRÉSENTATION GÉNÉRÉE")
|
||
ok(f"Fichier PPTX : {pptx_path}")
|
||
ok(f"Taille : {pptx_path.stat().st_size / 1024:.1f} Ko")
|
||
else:
|
||
warn("Le PPTX n'a pas pu être généré.")
|
||
info("Le YAML est disponible dans le dossier output/.")
|
||
|
||
# ── Prochaine présentation ? ──────────────────────────
|
||
print()
|
||
suite = ask("Générer une nouvelle présentation ? (o/n) :").lower()
|
||
if suite not in ("o", "oui", "y", "yes"):
|
||
print(" Au revoir.")
|
||
break
|
||
|
||
|
||
# ─────────────────────────────────────────────────────────────────────────────
|
||
# POINT D'ENTRÉE
|
||
# ─────────────────────────────────────────────────────────────────────────────
|
||
|
||
if __name__ == "__main__":
|
||
run()
|