gpatruno
1546 lines
58 KiB
Python
1546 lines
58 KiB
Python
import json
|
||
import os
|
||
import subprocess
|
||
import sys
|
||
import threading
|
||
import time
|
||
from datetime import datetime
|
||
|
||
_ROOT = os.path.dirname(os.path.abspath(__file__))
|
||
if _ROOT not in sys.path:
|
||
sys.path.insert(0, _ROOT)
|
||
|
||
from flask import Flask, render_template, request, jsonify
|
||
from flask_socketio import SocketIO, emit
|
||
|
||
from fonction.first_class import IA_generator, messageTwitch, storage
|
||
from twitch_bot import chat_state
|
||
from twitch_bot.controller import bot_controller
|
||
from twitch_bot.interaction_chat import InteractionChatConfig
|
||
import requests
|
||
|
||
|
||
def _first_enabled_user_index(config_path: str = "config/user.json") -> int:
|
||
try:
|
||
with open(config_path, "r", encoding="utf-8") as f:
|
||
users = json.load(f) or []
|
||
for i, u in enumerate(users):
|
||
if isinstance(u, dict) and u.get("enabled", True):
|
||
return i
|
||
except Exception:
|
||
pass
|
||
return 0
|
||
|
||
|
||
def _read_json_file(path: str, default):
|
||
try:
|
||
with open(path, "r", encoding="utf-8") as f:
|
||
data = json.load(f)
|
||
return data if data is not None else default
|
||
except Exception:
|
||
return default
|
||
|
||
|
||
def _twitch_client_id() -> str:
|
||
cfg = _read_json_file("config/config.json", default={})
|
||
if isinstance(cfg, dict):
|
||
v = cfg.get("twitch_client_id") or cfg.get("twitch_clientId") or cfg.get("twitchClientId")
|
||
if isinstance(v, str):
|
||
return v.strip()
|
||
return ""
|
||
|
||
|
||
def _user_bearer_token(user_id: int) -> str:
|
||
users = _read_json_file("config/user.json", default=[])
|
||
if not isinstance(users, list) or user_id < 0 or user_id >= len(users):
|
||
raise ValueError("Utilisateur non trouvé")
|
||
u = users[user_id]
|
||
if not isinstance(u, dict):
|
||
raise ValueError("Utilisateur invalide")
|
||
raw = (u.get("tw_acc_token") or "").strip()
|
||
if raw.lower().startswith("oauth:"):
|
||
raw = raw.split(":", 1)[1].strip()
|
||
if not raw:
|
||
raise ValueError("Token OAuth manquant")
|
||
return raw
|
||
|
||
|
||
def _twitch_helix_headers(user_bearer: str) -> dict:
|
||
client_id = _twitch_client_id()
|
||
if not client_id:
|
||
raise ValueError("Client-ID Twitch manquant. Ajoutez `twitch_client_id` dans config/config.json")
|
||
return {
|
||
"Client-ID": client_id,
|
||
"Authorization": f"Bearer {user_bearer}",
|
||
}
|
||
|
||
|
||
def _twitch_get_user_id_by_login(login: str, user_bearer: str) -> str:
|
||
login = (login or "").strip().lstrip("@")
|
||
if not login:
|
||
raise ValueError("Nom de chaîne requis")
|
||
|
||
headers = _twitch_helix_headers(user_bearer)
|
||
r = requests.get("https://api.twitch.tv/helix/users", headers=headers, params={"login": login}, timeout=10)
|
||
try:
|
||
payload = r.json()
|
||
except Exception:
|
||
payload = None
|
||
|
||
if r.status_code >= 400:
|
||
msg = ""
|
||
if isinstance(payload, dict):
|
||
msg = payload.get("message") or payload.get("error") or ""
|
||
raise RuntimeError(f"Erreur Twitch /helix/users ({r.status_code}) {msg}".strip())
|
||
|
||
data = (payload or {}).get("data") if isinstance(payload, dict) else None
|
||
if not isinstance(data, list) or not data:
|
||
raise ValueError("Chaîne Twitch introuvable (login)")
|
||
user = data[0] or {}
|
||
broadcaster_id = user.get("id")
|
||
if not broadcaster_id:
|
||
raise RuntimeError("Réponse Twitch invalide: id manquant")
|
||
return str(broadcaster_id)
|
||
|
||
|
||
def _twitch_create_clip(broadcaster_id: str, user_bearer: str, has_delay: bool = False) -> dict:
|
||
headers = _twitch_helix_headers(user_bearer)
|
||
params = {"broadcaster_id": str(broadcaster_id), "has_delay": "true" if has_delay else "false"}
|
||
r = requests.post("https://api.twitch.tv/helix/clips", headers=headers, params=params, timeout=15)
|
||
try:
|
||
payload = r.json()
|
||
except Exception:
|
||
payload = None
|
||
|
||
if r.status_code >= 400:
|
||
msg = ""
|
||
if isinstance(payload, dict):
|
||
msg = payload.get("message") or payload.get("error") or ""
|
||
hint = ""
|
||
if r.status_code in (401, 403):
|
||
hint = " (vérifiez que le token a le scope `clips:edit` et qu'il n'est pas expiré)"
|
||
raise RuntimeError(f"Erreur Twitch /helix/clips ({r.status_code}) {msg}{hint}".strip())
|
||
|
||
data = (payload or {}).get("data") if isinstance(payload, dict) else None
|
||
if not isinstance(data, list) or not data:
|
||
raise RuntimeError("Réponse Twitch invalide: data manquant")
|
||
|
||
clip = data[0] or {}
|
||
clip_id = clip.get("id")
|
||
edit_url = clip.get("edit_url")
|
||
if not clip_id:
|
||
raise RuntimeError("Réponse Twitch invalide: clip id manquant")
|
||
|
||
# URL publique approximative (le retour officiel donne surtout edit_url)
|
||
public_url = f"https://clips.twitch.tv/{clip_id}"
|
||
return {
|
||
"id": clip_id,
|
||
"edit_url": edit_url,
|
||
"url": public_url,
|
||
}
|
||
|
||
app = Flask(__name__)
|
||
app.config['SECRET_KEY'] = 'your-secret-key-here'
|
||
socketio = SocketIO(app, cors_allowed_origins="*")
|
||
|
||
@app.route('/')
|
||
def index():
|
||
return render_template('index.html')
|
||
|
||
@app.route('/api/flux', methods=['GET'])
|
||
def get_flux():
|
||
return jsonify(bot_controller.get_flux_list())
|
||
|
||
@app.route('/api/flux', methods=['POST'])
|
||
def add_flux():
|
||
data = request.json
|
||
channel_name = data.get('channel_name')
|
||
record_audio = data.get('record_audio', True)
|
||
send_messages = bool(data.get('send_messages', True))
|
||
enable_ia = bool(data.get('enable_ia', True))
|
||
|
||
if not channel_name:
|
||
return jsonify({'error': 'Nom du canal requis'}), 400
|
||
|
||
try:
|
||
flux_id = bot_controller.add_flux(channel_name, record_audio, send_messages, enable_ia)
|
||
return jsonify({'success': True, 'flux_id': flux_id})
|
||
except Exception as e:
|
||
error_msg = f"Erreur lors de l'ajout du flux: {str(e)}"
|
||
print(f"Erreur API add_flux: {error_msg}")
|
||
return jsonify({'error': error_msg}), 500
|
||
|
||
@app.route('/api/flux/<int:flux_id>', methods=['DELETE'])
|
||
def remove_flux(flux_id):
|
||
if bot_controller.remove_flux(flux_id):
|
||
return jsonify({'success': True})
|
||
return jsonify({'error': 'Flux non trouvé'}), 404
|
||
|
||
@app.route('/api/flux/<int:flux_id>/status', methods=['GET'])
|
||
def get_flux_status(flux_id):
|
||
"""Obtenir le statut détaillé d'un flux spécifique"""
|
||
for flux in bot_controller.flux_list:
|
||
if flux['id'] == flux_id:
|
||
status = {
|
||
'id': flux_id,
|
||
'name': flux['name'],
|
||
'active': flux['active'],
|
||
'status': flux.get('status', 'unknown'),
|
||
'created_at': flux['created_at'],
|
||
'bots': {}
|
||
}
|
||
|
||
# Ajouter les informations des bots si disponibles
|
||
if flux_id in bot_controller.bots:
|
||
bots = bot_controller.bots[flux_id]
|
||
if bots['chat_bot']:
|
||
status['bots']['chat'] = {
|
||
'running': bots['chat_bot'].is_running if hasattr(bots['chat_bot'], 'is_running') else True
|
||
}
|
||
if bots['record_bot']:
|
||
status['bots']['record'] = {
|
||
'running': bots['record_bot'].running if hasattr(bots['record_bot'], 'running') else True
|
||
}
|
||
|
||
return jsonify(status)
|
||
|
||
return jsonify({'error': 'Flux non trouvé'}), 404
|
||
|
||
@app.route('/api/flux/<int:flux_id>/toggle', methods=['POST'])
|
||
def toggle_flux(flux_id):
|
||
"""Activer/désactiver un flux"""
|
||
for flux in bot_controller.flux_list:
|
||
if flux['id'] == flux_id:
|
||
flux['active'] = not flux['active']
|
||
|
||
# Arrêter/démarrer les bots selon le nouveau statut
|
||
if flux_id in bot_controller.bots:
|
||
bots = bot_controller.bots[flux_id]
|
||
if not flux['active']:
|
||
# Arrêter les bots
|
||
try:
|
||
if bots['chat_bot']:
|
||
bots['chat_bot'].stop()
|
||
if bots['record_bot']:
|
||
bots['record_bot'].stop()
|
||
if bots['subtitle_bot']:
|
||
bots['subtitle_bot'].stop()
|
||
if bots['ia_bot']:
|
||
bots['ia_bot'].stop()
|
||
if bots['message_bot']:
|
||
bots['message_bot'].stop()
|
||
except Exception as e:
|
||
print(f"Erreur lors de l'arrêt des bots: {e}")
|
||
else:
|
||
# Redémarrer les bots
|
||
try:
|
||
if bots['chat_bot']:
|
||
bots['chat_bot'].start_background()
|
||
if bots['record_bot']:
|
||
threading.Thread(target=bots['record_bot'].main, daemon=True).start()
|
||
if bots['subtitle_bot']:
|
||
bots['subtitle_bot'].start_main_loop()
|
||
if bool(flux.get("enable_ia", True)) and bots.get('ia_bot'):
|
||
bots['ia_bot'].start_main_loop()
|
||
# Respecter le flag par-flux send_messages
|
||
if bool(flux.get("send_messages", True)) and bool(flux.get("enable_ia", True)) and bots.get('message_bot'):
|
||
bots['message_bot'].start_loop_respond()
|
||
except Exception as e:
|
||
print(f"Erreur lors du redémarrage des bots: {e}")
|
||
|
||
return jsonify({'success': True, 'active': flux['active']})
|
||
|
||
return jsonify({'error': 'Flux non trouvé'}), 404
|
||
|
||
@app.route('/api/config/prompts', methods=['GET'])
|
||
def get_prompts():
|
||
return jsonify(bot_controller.config.get('list_prompt', []))
|
||
|
||
@app.route('/api/config/prompts', methods=['POST'])
|
||
def update_prompts():
|
||
data = request.json
|
||
prompts = data.get('prompts', [])
|
||
bot_controller.config['list_prompt'] = prompts
|
||
bot_controller.save_config()
|
||
return jsonify({'success': True})
|
||
|
||
|
||
@app.route('/api/config/settings', methods=['GET'])
|
||
def get_settings():
|
||
"""Récupérer les paramètres généraux (config/config.json)."""
|
||
try:
|
||
cfg = bot_controller.load_config()
|
||
return jsonify({
|
||
'success': True,
|
||
'settings': {
|
||
'twitch_message_max_chars': int(cfg.get('twitch_message_max_chars', 100)),
|
||
}
|
||
})
|
||
except Exception as e:
|
||
return jsonify({'success': False, 'error': str(e)}), 500
|
||
|
||
|
||
@app.route('/api/config/settings', methods=['POST'])
|
||
def save_settings():
|
||
"""Sauvegarder les paramètres généraux (config/config.json)."""
|
||
try:
|
||
data = request.json or {}
|
||
settings = data.get('settings') or {}
|
||
|
||
cfg = bot_controller.load_config()
|
||
try:
|
||
cfg['twitch_message_max_chars'] = int(settings.get('twitch_message_max_chars', cfg.get('twitch_message_max_chars', 100)))
|
||
except Exception:
|
||
cfg['twitch_message_max_chars'] = 100
|
||
|
||
bot_controller.config = cfg
|
||
bot_controller.save_config()
|
||
return jsonify({'success': True, 'settings': {'twitch_message_max_chars': cfg['twitch_message_max_chars']}})
|
||
except Exception as e:
|
||
return jsonify({'success': False, 'error': str(e)}), 500
|
||
|
||
@app.route('/api/config/users', methods=['GET'])
|
||
def get_users():
|
||
"""Récupérer la liste des utilisateurs"""
|
||
try:
|
||
with open('config/user.json', 'r') as file:
|
||
users = json.load(file)
|
||
return jsonify(users)
|
||
except FileNotFoundError:
|
||
return jsonify([])
|
||
except Exception as e:
|
||
return jsonify({'error': str(e)}), 500
|
||
|
||
@app.route('/api/config/users', methods=['POST'])
|
||
def add_user():
|
||
"""Ajouter un nouvel utilisateur"""
|
||
data = request.json
|
||
pseudo = data.get('tw_acc_pseudo')
|
||
token = data.get('tw_acc_token')
|
||
charactere = data.get('charactere', '😊')
|
||
enabled = bool(data.get('enabled', True))
|
||
interaction_bypass_antiloop = bool(data.get('interaction_bypass_antiloop', False))
|
||
|
||
if not pseudo or not token:
|
||
return jsonify({'error': 'Pseudo et token requis'}), 400
|
||
|
||
try:
|
||
with open('config/user.json', 'r') as file:
|
||
users = json.load(file)
|
||
|
||
# Vérifier si l'utilisateur existe déjà
|
||
for user in users:
|
||
if user['tw_acc_pseudo'] == pseudo:
|
||
return jsonify({'error': 'Cet utilisateur existe déjà'}), 400
|
||
|
||
# Ajouter le nouvel utilisateur
|
||
new_user = {
|
||
'tw_acc_pseudo': pseudo,
|
||
'tw_acc_token': token,
|
||
'charactere': charactere,
|
||
'enabled': enabled,
|
||
'interaction_bypass_antiloop': interaction_bypass_antiloop,
|
||
}
|
||
users.append(new_user)
|
||
|
||
# Sauvegarder
|
||
with open('config/user.json', 'w') as file:
|
||
json.dump(users, file, indent=4, ensure_ascii=False)
|
||
|
||
return jsonify({'success': True, 'user': new_user})
|
||
except Exception as e:
|
||
return jsonify({'error': str(e)}), 500
|
||
|
||
@app.route('/api/config/users/<int:user_id>', methods=['PUT'])
|
||
def update_user(user_id):
|
||
"""Modifier un utilisateur existant"""
|
||
data = request.json
|
||
pseudo = data.get('tw_acc_pseudo')
|
||
token = data.get('tw_acc_token')
|
||
charactere = data.get('charactere', '😊')
|
||
enabled = bool(data.get('enabled', True))
|
||
interaction_bypass_antiloop = bool(data.get('interaction_bypass_antiloop', False))
|
||
|
||
if not pseudo or not token:
|
||
return jsonify({'error': 'Pseudo et token requis'}), 400
|
||
|
||
try:
|
||
with open('config/user.json', 'r') as file:
|
||
users = json.load(file)
|
||
|
||
if user_id >= len(users):
|
||
return jsonify({'error': 'Utilisateur non trouvé'}), 404
|
||
|
||
# Vérifier si le pseudo existe déjà (sauf pour l'utilisateur actuel)
|
||
for i, user in enumerate(users):
|
||
if i != user_id and user['tw_acc_pseudo'] == pseudo:
|
||
return jsonify({'error': 'Ce pseudo est déjà utilisé'}), 400
|
||
|
||
# Mettre à jour l'utilisateur
|
||
users[user_id] = {
|
||
'tw_acc_pseudo': pseudo,
|
||
'tw_acc_token': token,
|
||
'charactere': charactere,
|
||
'enabled': enabled,
|
||
'interaction_bypass_antiloop': interaction_bypass_antiloop,
|
||
}
|
||
|
||
# Sauvegarder
|
||
with open('config/user.json', 'w') as file:
|
||
json.dump(users, file, indent=4, ensure_ascii=False)
|
||
|
||
return jsonify({'success': True, 'user': users[user_id]})
|
||
except Exception as e:
|
||
return jsonify({'error': str(e)}), 500
|
||
|
||
|
||
@app.route('/api/config/users/<int:user_id>/enabled', methods=['POST'])
|
||
def set_user_enabled(user_id):
|
||
"""Activer/désactiver un utilisateur sans toucher pseudo/token."""
|
||
try:
|
||
data = request.json or {}
|
||
enabled = bool(data.get('enabled', True))
|
||
|
||
with open('config/user.json', 'r', encoding='utf-8') as file:
|
||
users = json.load(file)
|
||
|
||
if user_id >= len(users):
|
||
return jsonify({'error': 'Utilisateur non trouvé'}), 404
|
||
|
||
if not isinstance(users[user_id], dict):
|
||
return jsonify({'error': 'Utilisateur invalide'}), 400
|
||
|
||
users[user_id]['enabled'] = enabled
|
||
|
||
with open('config/user.json', 'w', encoding='utf-8') as file:
|
||
json.dump(users, file, indent=4, ensure_ascii=False)
|
||
|
||
return jsonify({'success': True, 'user': users[user_id]})
|
||
except Exception as e:
|
||
return jsonify({'error': str(e)}), 500
|
||
|
||
|
||
@app.route('/api/config/users/<int:user_id>/interaction-bypass', methods=['POST'])
|
||
def set_user_interaction_bypass(user_id):
|
||
"""Autoriser un utilisateur à bypass l’anti-boucle Interaction chat."""
|
||
try:
|
||
data = request.json or {}
|
||
bypass = bool(data.get('interaction_bypass_antiloop', False))
|
||
|
||
with open('config/user.json', 'r', encoding='utf-8') as file:
|
||
users = json.load(file)
|
||
|
||
if user_id >= len(users):
|
||
return jsonify({'error': 'Utilisateur non trouvé'}), 404
|
||
|
||
if not isinstance(users[user_id], dict):
|
||
return jsonify({'error': 'Utilisateur invalide'}), 400
|
||
|
||
users[user_id]['interaction_bypass_antiloop'] = bypass
|
||
|
||
with open('config/user.json', 'w', encoding='utf-8') as file:
|
||
json.dump(users, file, indent=4, ensure_ascii=False)
|
||
|
||
return jsonify({'success': True, 'user': users[user_id]})
|
||
except Exception as e:
|
||
return jsonify({'error': str(e)}), 500
|
||
|
||
@app.route('/api/config/users/<int:user_id>', methods=['DELETE'])
|
||
def delete_user(user_id):
|
||
"""Supprimer un utilisateur"""
|
||
try:
|
||
with open('config/user.json', 'r') as file:
|
||
users = json.load(file)
|
||
|
||
if user_id >= len(users):
|
||
return jsonify({'error': 'Utilisateur non trouvé'}), 404
|
||
|
||
# Supprimer l'utilisateur
|
||
deleted_user = users.pop(user_id)
|
||
|
||
# Sauvegarder
|
||
with open('config/user.json', 'w') as file:
|
||
json.dump(users, file, indent=4, ensure_ascii=False)
|
||
|
||
return jsonify({'success': True, 'deleted_user': deleted_user})
|
||
except Exception as e:
|
||
return jsonify({'error': str(e)}), 500
|
||
|
||
@app.route('/api/subtitles', methods=['GET'])
|
||
def get_subtitles():
|
||
flux_id = request.args.get("flux_id")
|
||
channel = request.args.get("channel")
|
||
key = "subtitle_data"
|
||
if channel:
|
||
key = f"subtitle_data__{str(channel).strip().lower()}"
|
||
elif flux_id:
|
||
try:
|
||
fid = int(flux_id)
|
||
flux = next((f for f in bot_controller.flux_list if f.get("id") == fid), None)
|
||
if flux and flux.get("twitchname"):
|
||
key = f"subtitle_data__{str(flux.get('twitchname')).strip().lower()}"
|
||
except Exception:
|
||
pass
|
||
data = storage.read(key)
|
||
return jsonify(data if isinstance(data, dict) else {})
|
||
|
||
@app.route('/api/subtitles/last', methods=['GET'])
|
||
def get_last_subtitle():
|
||
"""Retourne le dernier sous-titre (clé + texte)."""
|
||
try:
|
||
flux_id = request.args.get("flux_id")
|
||
channel = request.args.get("channel")
|
||
key = "subtitle_data"
|
||
if channel:
|
||
key = f"subtitle_data__{str(channel).strip().lower()}"
|
||
elif flux_id:
|
||
try:
|
||
fid = int(flux_id)
|
||
flux = next((f for f in bot_controller.flux_list if f.get("id") == fid), None)
|
||
if flux and flux.get("twitchname"):
|
||
key = f"subtitle_data__{str(flux.get('twitchname')).strip().lower()}"
|
||
except Exception:
|
||
pass
|
||
|
||
subtitle_data = storage.read(key) or {}
|
||
if not isinstance(subtitle_data, dict) or not subtitle_data:
|
||
return jsonify({'success': True, 'last_key': None, 'last_subtitle': ''})
|
||
sorted_keys = sorted(subtitle_data.keys())
|
||
|
||
def _good_candidate(text: str) -> bool:
|
||
t = (text or "").strip()
|
||
if not t:
|
||
return False
|
||
# Heuristique: éviter les "bruits" très courts pour la génération IA
|
||
words = [w for w in t.split() if w]
|
||
return (len(t) >= 35) or (len(words) >= 8)
|
||
|
||
# Chercher le plus récent "utile", sinon fallback sur le tout dernier
|
||
picked_key = None
|
||
picked_text = ""
|
||
for k in reversed(sorted_keys):
|
||
t = subtitle_data.get(k, "")
|
||
if _good_candidate(str(t)):
|
||
picked_key = k
|
||
picked_text = str(t)
|
||
break
|
||
|
||
if picked_key is None:
|
||
picked_key = sorted_keys[-1]
|
||
picked_text = str(subtitle_data.get(picked_key, "") or "")
|
||
|
||
return jsonify({'success': True, 'last_key': picked_key, 'last_subtitle': picked_text})
|
||
except Exception as e:
|
||
return jsonify({'success': False, 'error': str(e)}), 500
|
||
|
||
@app.route('/api/subtitles/clear', methods=['POST'])
|
||
def clear_subtitles():
|
||
"""Nettoyer l'historique des sous-titres"""
|
||
try:
|
||
flux_id = request.args.get("flux_id")
|
||
channel = request.args.get("channel")
|
||
storage_key = "subtitle_data"
|
||
if channel:
|
||
storage_key = f"subtitle_data__{str(channel).strip().lower()}"
|
||
elif flux_id:
|
||
try:
|
||
fid = int(flux_id)
|
||
flux = next((f for f in bot_controller.flux_list if f.get("id") == fid), None)
|
||
if flux and flux.get("twitchname"):
|
||
storage_key = f"subtitle_data__{str(flux.get('twitchname')).strip().lower()}"
|
||
except Exception:
|
||
pass
|
||
|
||
# Récupérer toutes les clés de sous-titres
|
||
subtitle_data = storage.read(storage_key)
|
||
|
||
# Supprimer chaque clé une par une
|
||
for loop_key in list((subtitle_data or {}).keys()):
|
||
storage.delete(storage_key, loop_key)
|
||
|
||
# Supprimer également le fichier JSON s'il existe
|
||
storage_dir = "storage"
|
||
subtitle_file = os.path.join(storage_dir, f"{storage_key}.json")
|
||
if os.path.exists(subtitle_file):
|
||
os.remove(subtitle_file)
|
||
|
||
return jsonify({
|
||
'success': True,
|
||
'message': 'Historique des sous-titres nettoyé avec succès'
|
||
})
|
||
except Exception as e:
|
||
return jsonify({
|
||
'success': False,
|
||
'error': f'Erreur lors du nettoyage: {str(e)}'
|
||
}), 500
|
||
|
||
|
||
@app.route('/api/subtitles/rules/config', methods=['GET'])
|
||
def get_subtitle_rules_config():
|
||
try:
|
||
processor = None
|
||
for flux_id, bots in bot_controller.bots.items():
|
||
processor = bots.get('subtitle_rules')
|
||
if processor:
|
||
break
|
||
if not processor:
|
||
from twitch_bot.subtitle_rules import SubtitleRulesStorage, SubtitleRulesConfig
|
||
st = SubtitleRulesStorage()
|
||
cfg = SubtitleRulesConfig(st.read_json("subtitle_rules_config", default={}))
|
||
data = cfg.to_dict()
|
||
else:
|
||
data = processor.load_config().to_dict()
|
||
return jsonify({'success': True, 'config': data})
|
||
except Exception as e:
|
||
return jsonify({'success': False, 'error': str(e)}), 500
|
||
|
||
|
||
@app.route('/api/subtitles/rules/config', methods=['POST'])
|
||
def save_subtitle_rules_config():
|
||
try:
|
||
payload = request.json or {}
|
||
config_dict = payload.get('config') or {}
|
||
processor = None
|
||
for flux_id, bots in bot_controller.bots.items():
|
||
processor = bots.get('subtitle_rules')
|
||
if processor:
|
||
break
|
||
if processor:
|
||
cfg = processor.save_config(config_dict)
|
||
data = cfg.to_dict()
|
||
else:
|
||
from twitch_bot.subtitle_rules import SubtitleRulesStorage, SubtitleRulesConfig
|
||
st = SubtitleRulesStorage()
|
||
cfg = SubtitleRulesConfig(config_dict)
|
||
st.write_json("subtitle_rules_config", cfg.to_dict())
|
||
data = cfg.to_dict()
|
||
return jsonify({'success': True, 'config': data})
|
||
except Exception as e:
|
||
return jsonify({'success': False, 'error': str(e)}), 500
|
||
|
||
|
||
@app.route('/api/subtitles/rules/log', methods=['GET'])
|
||
def get_subtitle_rules_log():
|
||
try:
|
||
limit = int(request.args.get('limit', '120'))
|
||
limit = max(1, min(500, limit))
|
||
processor = None
|
||
for flux_id, bots in bot_controller.bots.items():
|
||
processor = bots.get('subtitle_rules')
|
||
if processor:
|
||
break
|
||
if processor:
|
||
logs = processor.read_log(limit=limit)
|
||
else:
|
||
from twitch_bot.subtitle_rules import SubtitleRulesStorage
|
||
st = SubtitleRulesStorage()
|
||
logs = st.read_json("subtitle_rules_log", default=[])
|
||
if not isinstance(logs, list):
|
||
logs = []
|
||
logs = logs[-limit:]
|
||
return jsonify({'success': True, 'logs': logs})
|
||
except Exception as e:
|
||
return jsonify({'success': False, 'error': str(e)}), 500
|
||
|
||
@app.route('/api/subtitles/process', methods=['POST'])
|
||
def process_subtitles():
|
||
"""Lancer manuellement le traitement des sous-titres"""
|
||
try:
|
||
import subprocess
|
||
import os
|
||
import json
|
||
from datetime import datetime
|
||
|
||
# Vérifier que le dossier record existe
|
||
record_dir = "record"
|
||
if not os.path.exists(record_dir):
|
||
return jsonify({
|
||
'success': False,
|
||
'error': 'Dossier record non trouvé'
|
||
}), 404
|
||
|
||
# Trouver les fichiers audio
|
||
audio_files = [f for f in os.listdir(record_dir) if f.endswith('.mp3')]
|
||
if not audio_files:
|
||
return jsonify({
|
||
'success': False,
|
||
'error': 'Aucun fichier audio trouvé'
|
||
}), 404
|
||
|
||
subtitles_created = 0
|
||
subtitles_data = {}
|
||
|
||
# Traiter chaque fichier audio
|
||
for audio_file in audio_files[:3]: # Limiter à 3 fichiers pour éviter de surcharger
|
||
audio_path = os.path.join(record_dir, audio_file)
|
||
|
||
try:
|
||
# Lancer Whisper
|
||
command = [
|
||
'whisper',
|
||
'--language', 'fr',
|
||
audio_path,
|
||
'--device', 'cuda',
|
||
'--model', 'large-v3'
|
||
]
|
||
|
||
result = subprocess.run(command, capture_output=True, text=True, timeout=60)
|
||
|
||
if result.returncode == 0:
|
||
# Lire le fichier .txt généré
|
||
txt_file = audio_file.replace('.mp3', '.txt')
|
||
if os.path.exists(txt_file):
|
||
with open(txt_file, 'r', encoding='utf-8') as f:
|
||
content = f.read().strip()
|
||
|
||
# Nettoyer le contenu
|
||
content = content.replace("'", "").replace('"', "").replace("\n", " ").replace(",", "")
|
||
|
||
# Supprimer les répétitions de mots
|
||
words = content.split()
|
||
seen = set()
|
||
result_words = []
|
||
for word in words:
|
||
if word not in seen:
|
||
result_words.append(word)
|
||
seen.add(word)
|
||
cleaned_content = " ".join(result_words)
|
||
|
||
# Sauvegarder dans le stockage
|
||
current_time = datetime.now().strftime('%H:%M:%S')
|
||
subtitles_data[current_time] = cleaned_content
|
||
|
||
# Sauvegarder dans le fichier de stockage
|
||
storage_dir = "storage"
|
||
if not os.path.exists(storage_dir):
|
||
os.makedirs(storage_dir)
|
||
|
||
subtitle_file = os.path.join(storage_dir, "subtitle_data.json")
|
||
try:
|
||
with open(subtitle_file, 'r', encoding='utf-8') as f:
|
||
existing_data = json.load(f)
|
||
except (FileNotFoundError, json.JSONDecodeError):
|
||
existing_data = {}
|
||
|
||
existing_data[current_time] = cleaned_content
|
||
|
||
with open(subtitle_file, 'w', encoding='utf-8') as f:
|
||
json.dump(existing_data, f, indent=4, ensure_ascii=False)
|
||
|
||
subtitles_created += 1
|
||
|
||
# Nettoyer les fichiers temporaires
|
||
os.remove(txt_file)
|
||
os.remove(audio_path) # Supprimer le fichier audio traité
|
||
|
||
except subprocess.TimeoutExpired:
|
||
continue # Passer au fichier suivant
|
||
except Exception as e:
|
||
continue # Passer au fichier suivant
|
||
|
||
return jsonify({
|
||
'success': True,
|
||
'message': f'Traitement terminé. {subtitles_created} sous-titre(s) créé(s).',
|
||
'subtitles': subtitles_data
|
||
})
|
||
|
||
except Exception as e:
|
||
return jsonify({
|
||
'success': False,
|
||
'error': f'Erreur lors du traitement: {str(e)}'
|
||
}), 500
|
||
|
||
@app.route('/api/generations', methods=['GET'])
|
||
def get_generations():
|
||
data = storage.read("IA_generator")
|
||
return jsonify(data)
|
||
|
||
@app.route('/api/send-message', methods=['POST'])
|
||
def send_message():
|
||
data = request.json
|
||
message = data.get('message')
|
||
channel = data.get('channel', 'default')
|
||
user_id = data.get('user_id', 0) # Nouveau paramètre pour choisir l'utilisateur
|
||
|
||
if not message:
|
||
return jsonify({'error': 'Message requis'}), 400
|
||
|
||
# Trouver le bot de message pour ce canal
|
||
try:
|
||
msg_bot = messageTwitch("config/user.json", channel)
|
||
# Utiliser send_message_user au lieu de send_message pour spécifier l'utilisateur
|
||
msg_bot.send_message_user(user_id, message)
|
||
return jsonify({'success': True})
|
||
except Exception as e:
|
||
return jsonify({'error': str(e)}), 500
|
||
|
||
@app.route('/api/generate-response', methods=['POST'])
|
||
def generate_response():
|
||
data = request.json
|
||
text = data.get('text', '')
|
||
|
||
try:
|
||
ia_gen = IA_generator("config/config.json")
|
||
ia_gen.main_ask(text)
|
||
return jsonify({'success': True})
|
||
except Exception as e:
|
||
return jsonify({'error': str(e)}), 500
|
||
|
||
@app.route('/api/chat/<int:flux_id>/messages', methods=['GET'])
|
||
def get_chat_messages(flux_id):
|
||
"""Récupérer les messages de chat d'un flux spécifique"""
|
||
try:
|
||
if flux_id not in bot_controller.bots:
|
||
return jsonify({'error': 'Flux non trouvé'}), 404
|
||
|
||
chat_bot = bot_controller.bots[flux_id]['chat_bot']
|
||
if not chat_bot:
|
||
return jsonify({'error': 'Bot de chat non disponible'}), 404
|
||
|
||
# Récupérer les messages du bot de chat
|
||
messages = []
|
||
for msg in chat_bot.messages[-50:]: # Derniers 50 messages
|
||
messages.append({
|
||
'timestamp': msg.timestamp.isoformat(),
|
||
'username': msg.username,
|
||
'content': msg.content
|
||
})
|
||
|
||
return jsonify({
|
||
'success': True,
|
||
'flux_id': flux_id,
|
||
'messages': messages
|
||
})
|
||
|
||
except Exception as e:
|
||
return jsonify({'error': str(e)}), 500
|
||
|
||
@app.route('/api/chat/<int:flux_id>/send', methods=['POST'])
|
||
def send_chat_message(flux_id):
|
||
"""Envoyer un message dans le chat d'un flux spécifique"""
|
||
data = request.json
|
||
message = data.get('message', '')
|
||
user_id = data.get('user_id', 0) # Nouveau paramètre pour choisir l'utilisateur
|
||
|
||
if not message:
|
||
return jsonify({'error': 'Message requis'}), 400
|
||
|
||
try:
|
||
# Trouver le flux
|
||
flux = None
|
||
for f in bot_controller.flux_list:
|
||
if f['id'] == flux_id:
|
||
flux = f
|
||
break
|
||
|
||
if not flux:
|
||
return jsonify({'error': 'Flux non trouvé'}), 404
|
||
|
||
if not bool(flux.get("send_messages", True)):
|
||
return jsonify({'error': 'Envoi de messages désactivé pour ce flux'}), 403
|
||
|
||
# Envoyer le message avec l'utilisateur spécifié
|
||
msg_bot = messageTwitch("config/user.json", flux['twitchname'])
|
||
msg_bot.send_message_user(user_id, message)
|
||
|
||
return jsonify({'success': True})
|
||
|
||
except Exception as e:
|
||
return jsonify({'error': str(e)}), 500
|
||
|
||
@app.route('/api/status', methods=['GET'])
|
||
def get_status():
|
||
status = {
|
||
'flux_count': len(bot_controller.flux_list),
|
||
'active_recordings': sum(1 for f in bot_controller.flux_list if f['record_audio'] and f['active']),
|
||
'chat_connections': sum(1 for f in bot_controller.flux_list if f['active']),
|
||
'last_subtitle': '',
|
||
'next_message': '',
|
||
'recent_messages': []
|
||
}
|
||
|
||
# Récupérer le dernier sous-titre
|
||
subtitle_data = storage.read("subtitle_data")
|
||
if subtitle_data:
|
||
sorted_keys = sorted(subtitle_data.keys())
|
||
if sorted_keys:
|
||
status['last_subtitle'] = subtitle_data[sorted_keys[-1]]
|
||
|
||
# Récupérer la dernière génération
|
||
generation_data = storage.read("IA_generator")
|
||
if generation_data:
|
||
sorted_keys = sorted(generation_data.keys())
|
||
if sorted_keys:
|
||
status['next_message'] = generation_data[sorted_keys[-1]]
|
||
|
||
return jsonify(status)
|
||
|
||
@socketio.on('connect')
|
||
def handle_connect():
|
||
print('Client connecté')
|
||
emit('status', {'message': 'Connecté au serveur'})
|
||
|
||
@socketio.on('disconnect')
|
||
def handle_disconnect():
|
||
print('Client déconnecté')
|
||
|
||
# Thread pour envoyer les mises à jour en temps réel
|
||
def background_updates():
|
||
while True:
|
||
try:
|
||
status = {
|
||
'timestamp': datetime.now().isoformat(),
|
||
'flux_count': len(bot_controller.flux_list),
|
||
'active_recordings': sum(1 for f in bot_controller.flux_list if f['record_audio'] and f['active']),
|
||
}
|
||
socketio.emit('status_update', status)
|
||
time.sleep(5) # Mise à jour toutes les 5 secondes
|
||
except Exception as e:
|
||
print(f"Erreur dans background_updates: {e}")
|
||
time.sleep(10)
|
||
|
||
# Variables globales pour la génération automatique
|
||
auto_subtitle_running = False
|
||
current_processing_file = None
|
||
|
||
# Variables globales pour l'envoi automatique de messages
|
||
auto_message_running = False
|
||
current_message_bot = None
|
||
|
||
@app.route('/api/subtitles/auto/start', methods=['POST'])
|
||
def start_auto_subtitle():
|
||
"""Démarrer la génération automatique de sous-titres"""
|
||
global auto_subtitle_running
|
||
try:
|
||
# Vérifier si déjà en cours
|
||
if auto_subtitle_running:
|
||
return jsonify({
|
||
'success': False,
|
||
'error': 'La génération automatique est déjà en cours'
|
||
}), 400
|
||
|
||
auto_subtitle_running = True
|
||
print(f"[{datetime.now().strftime('%H:%M:%S')}] Démarrage de la génération automatique de sous-titres")
|
||
|
||
# Démarrer le thread de génération automatique
|
||
threading.Thread(target=auto_subtitle_loop, daemon=True).start()
|
||
|
||
return jsonify({
|
||
'success': True,
|
||
'message': 'Génération automatique démarrée'
|
||
})
|
||
except Exception as e:
|
||
auto_subtitle_running = False
|
||
return jsonify({
|
||
'success': False,
|
||
'error': f'Erreur lors du démarrage: {str(e)}'
|
||
}), 500
|
||
|
||
@app.route('/api/subtitles/auto/stop', methods=['POST'])
|
||
def stop_auto_subtitle():
|
||
"""Arrêter la génération automatique de sous-titres"""
|
||
global auto_subtitle_running
|
||
try:
|
||
if not auto_subtitle_running:
|
||
return jsonify({
|
||
'success': False,
|
||
'error': 'La génération automatique n\'est pas en cours'
|
||
}), 400
|
||
|
||
print(f"[{datetime.now().strftime('%H:%M:%S')}] Arrêt de la génération automatique de sous-titres")
|
||
auto_subtitle_running = False
|
||
|
||
return jsonify({
|
||
'success': True,
|
||
'message': 'Génération automatique arrêtée'
|
||
})
|
||
except Exception as e:
|
||
return jsonify({
|
||
'success': False,
|
||
'error': f'Erreur lors de l\'arrêt: {str(e)}'
|
||
}), 500
|
||
|
||
@app.route('/api/subtitles/auto/force-stop', methods=['POST'])
|
||
def force_stop_auto_subtitle():
|
||
"""Forcer l'arrêt de la génération automatique de sous-titres"""
|
||
global auto_subtitle_running, current_processing_file
|
||
try:
|
||
print(f"[{datetime.now().strftime('%H:%M:%S')}] Arrêt forcé de la génération automatique de sous-titres")
|
||
auto_subtitle_running = False
|
||
current_processing_file = None
|
||
|
||
return jsonify({
|
||
'success': True,
|
||
'message': 'Arrêt forcé de la génération automatique de sous-titres'
|
||
})
|
||
except Exception as e:
|
||
return jsonify({
|
||
'success': False,
|
||
'error': f'Erreur lors de l\'arrêt forcé: {str(e)}'
|
||
}), 500
|
||
|
||
@app.route('/api/subtitles/auto/status', methods=['GET'])
|
||
def get_auto_subtitle_status():
|
||
"""Obtenir le statut de la génération automatique"""
|
||
global auto_subtitle_running, current_processing_file
|
||
return jsonify({
|
||
'running': auto_subtitle_running,
|
||
'current_file': current_processing_file
|
||
})
|
||
|
||
def auto_subtitle_loop():
|
||
"""Boucle de génération automatique de sous-titres"""
|
||
global auto_subtitle_running, current_processing_file
|
||
|
||
print(f"[{datetime.now().strftime('%H:%M:%S')}] Démarrage de la boucle de génération automatique de sous-titres")
|
||
|
||
while auto_subtitle_running:
|
||
try:
|
||
# Vérifier s'il y a des fichiers audio à traiter
|
||
record_dir = "record"
|
||
if not os.path.exists(record_dir):
|
||
time.sleep(5)
|
||
continue
|
||
|
||
audio_files = [f for f in os.listdir(record_dir) if f.endswith('.mp3')]
|
||
if not audio_files:
|
||
time.sleep(5)
|
||
continue
|
||
|
||
# Traiter le premier fichier
|
||
audio_file = audio_files[0]
|
||
current_processing_file = audio_file
|
||
|
||
print(f"[{datetime.now().strftime('%H:%M:%S')}] Traitement de: {audio_file}")
|
||
|
||
# Émettre l'événement de début de traitement
|
||
socketio.emit('subtitle_processing_start', {
|
||
'file': audio_file,
|
||
'timestamp': datetime.now().isoformat()
|
||
})
|
||
|
||
# Traiter le fichier
|
||
audio_path = os.path.join(record_dir, audio_file)
|
||
|
||
try:
|
||
# Lancer Whisper avec vérification périodique de l'arrêt
|
||
command = [
|
||
'whisper',
|
||
'--language', 'fr',
|
||
audio_path,
|
||
'--device', 'cuda',
|
||
'--model', 'large-v3'
|
||
]
|
||
|
||
# Utiliser Popen pour pouvoir interrompre le processus
|
||
process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
|
||
|
||
# Attendre la fin du processus avec vérification périodique
|
||
while process.poll() is None:
|
||
if not auto_subtitle_running:
|
||
print(f"[{datetime.now().strftime('%H:%M:%S')}] Arrêt demandé, interruption du processus Whisper")
|
||
process.terminate()
|
||
try:
|
||
process.wait(timeout=5)
|
||
except subprocess.TimeoutExpired:
|
||
process.kill()
|
||
break
|
||
time.sleep(1)
|
||
|
||
# Si la boucle a été arrêtée, sortir
|
||
if not auto_subtitle_running:
|
||
print(f"[{datetime.now().strftime('%H:%M:%S')}] Arrêt de la boucle de génération automatique")
|
||
break
|
||
|
||
result = process.returncode
|
||
stdout, stderr = process.communicate()
|
||
|
||
if result == 0:
|
||
# Lire le fichier .txt généré
|
||
txt_file = audio_file.replace('.mp3', '.txt')
|
||
if os.path.exists(txt_file):
|
||
with open(txt_file, 'r', encoding='utf-8') as f:
|
||
content = f.read().strip()
|
||
|
||
# Nettoyer le contenu
|
||
content = content.replace("'", "").replace('"', "").replace("\n", " ").replace(",", "")
|
||
|
||
# Supprimer les répétitions de mots
|
||
words = content.split()
|
||
seen = set()
|
||
result_words = []
|
||
for word in words:
|
||
if word not in seen:
|
||
result_words.append(word)
|
||
seen.add(word)
|
||
cleaned_content = " ".join(result_words)
|
||
|
||
# Sauvegarder dans le stockage
|
||
current_time = datetime.now().strftime('%H:%M:%S')
|
||
|
||
# Sauvegarder dans le fichier de stockage
|
||
storage_dir = "storage"
|
||
if not os.path.exists(storage_dir):
|
||
os.makedirs(storage_dir)
|
||
|
||
subtitle_file = os.path.join(storage_dir, "subtitle_data.json")
|
||
try:
|
||
with open(subtitle_file, 'r', encoding='utf-8') as f:
|
||
existing_data = json.load(f)
|
||
except (FileNotFoundError, json.JSONDecodeError):
|
||
existing_data = {}
|
||
|
||
existing_data[current_time] = cleaned_content
|
||
|
||
with open(subtitle_file, 'w', encoding='utf-8') as f:
|
||
json.dump(existing_data, f, indent=4, ensure_ascii=False)
|
||
|
||
# Émettre l'événement de fin de traitement
|
||
socketio.emit('subtitle_processing_complete', {
|
||
'file': audio_file,
|
||
'subtitle': cleaned_content,
|
||
'timestamp': current_time
|
||
})
|
||
|
||
print(f"[{datetime.now().strftime('%H:%M:%S')}] Sous-titre généré: {cleaned_content}")
|
||
|
||
# Nettoyer les fichiers temporaires
|
||
os.remove(txt_file)
|
||
os.remove(audio_path)
|
||
|
||
else:
|
||
# Émettre l'événement d'erreur
|
||
socketio.emit('subtitle_processing_error', {
|
||
'file': audio_file,
|
||
'error': 'Aucun fichier .txt généré'
|
||
})
|
||
print(f"[{datetime.now().strftime('%H:%M:%S')}] Erreur: Aucun fichier .txt généré")
|
||
|
||
else:
|
||
# Émettre l'événement d'erreur
|
||
socketio.emit('subtitle_processing_error', {
|
||
'file': audio_file,
|
||
'error': f'Erreur Whisper: {stderr}'
|
||
})
|
||
print(f"[{datetime.now().strftime('%H:%M:%S')}] Erreur Whisper: {stderr}")
|
||
|
||
except subprocess.TimeoutExpired:
|
||
socketio.emit('subtitle_processing_error', {
|
||
'file': audio_file,
|
||
'error': 'Timeout - Whisper a pris trop de temps'
|
||
})
|
||
print(f"[{datetime.now().strftime('%H:%M:%S')}] Timeout - Whisper a pris trop de temps")
|
||
except Exception as e:
|
||
socketio.emit('subtitle_processing_error', {
|
||
'file': audio_file,
|
||
'error': f'Erreur: {str(e)}'
|
||
})
|
||
print(f"[{datetime.now().strftime('%H:%M:%S')}] Erreur lors du traitement: {str(e)}")
|
||
|
||
current_processing_file = None
|
||
|
||
# Vérifier à nouveau si la boucle doit continuer
|
||
if not auto_subtitle_running:
|
||
print(f"[{datetime.now().strftime('%H:%M:%S')}] Arrêt de la boucle de génération automatique")
|
||
break
|
||
|
||
# Attendre avant de traiter le prochain fichier
|
||
time.sleep(2)
|
||
|
||
except Exception as e:
|
||
print(f"[{datetime.now().strftime('%H:%M:%S')}] Erreur dans la boucle de génération automatique: {e}")
|
||
time.sleep(5)
|
||
|
||
print(f"[{datetime.now().strftime('%H:%M:%S')}] Fin de la boucle de génération automatique de sous-titres")
|
||
|
||
@app.route('/api/messages/auto/start', methods=['POST'])
|
||
def start_auto_message():
|
||
"""Démarrer l'envoi automatique de messages"""
|
||
global auto_message_running
|
||
try:
|
||
# Vérifier si déjà en cours
|
||
if auto_message_running:
|
||
return jsonify({
|
||
'success': False,
|
||
'error': 'L\'envoi automatique est déjà en cours'
|
||
}), 400
|
||
|
||
auto_message_running = True
|
||
|
||
# Créer une instance du bot de messages
|
||
current_message_bot = messageTwitch("config/user.json", "default")
|
||
|
||
# Démarrer le thread d'envoi automatique
|
||
threading.Thread(target=auto_message_loop, daemon=True).start()
|
||
|
||
print(f"[{datetime.now().strftime('%H:%M:%S')}] Envoi automatique de messages démarré")
|
||
|
||
return jsonify({
|
||
'success': True,
|
||
'message': 'Envoi automatique de messages démarré'
|
||
})
|
||
except Exception as e:
|
||
auto_message_running = False
|
||
current_message_bot = None
|
||
return jsonify({
|
||
'success': False,
|
||
'error': f'Erreur lors du démarrage: {str(e)}'
|
||
}), 500
|
||
|
||
@app.route('/api/messages/auto/stop', methods=['POST'])
|
||
def stop_auto_message():
|
||
"""Arrêter l'envoi automatique de messages"""
|
||
global auto_message_running, current_message_bot
|
||
try:
|
||
if not auto_message_running:
|
||
return jsonify({
|
||
'success': False,
|
||
'error': 'L\'envoi automatique n\'est pas en cours'
|
||
}), 400
|
||
|
||
auto_message_running = False
|
||
current_message_bot = None
|
||
|
||
print(f"[{datetime.now().strftime('%H:%M:%S')}] Envoi automatique de messages arrêté")
|
||
|
||
return jsonify({
|
||
'success': True,
|
||
'message': 'Envoi automatique de messages arrêté'
|
||
})
|
||
except Exception as e:
|
||
return jsonify({
|
||
'success': False,
|
||
'error': f'Erreur lors de l\'arrêt: {str(e)}'
|
||
}), 500
|
||
|
||
@app.route('/api/messages/auto/force-stop', methods=['POST'])
|
||
def force_stop_auto_message():
|
||
"""Forcer l'arrêt de l'envoi automatique de messages"""
|
||
global auto_message_running, current_message_bot
|
||
try:
|
||
auto_message_running = False
|
||
current_message_bot = None
|
||
|
||
print(f"[{datetime.now().strftime('%H:%M:%S')}] Arrêt forcé de l'envoi automatique de messages")
|
||
|
||
return jsonify({
|
||
'success': True,
|
||
'message': 'Arrêt forcé de l\'envoi automatique de messages'
|
||
})
|
||
except Exception as e:
|
||
return jsonify({
|
||
'success': False,
|
||
'error': f'Erreur lors de l\'arrêt forcé: {str(e)}'
|
||
}), 500
|
||
|
||
@app.route('/api/messages/auto/status', methods=['GET'])
|
||
def get_auto_message_status():
|
||
"""Obtenir le statut de l'envoi automatique de messages"""
|
||
global auto_message_running
|
||
return jsonify({
|
||
'running': auto_message_running
|
||
})
|
||
|
||
def auto_message_loop():
|
||
"""Boucle d'envoi automatique de messages"""
|
||
global auto_message_running, current_message_bot
|
||
|
||
print(f"[{datetime.now().strftime('%H:%M:%S')}] Démarrage de la boucle d'envoi automatique")
|
||
|
||
while auto_message_running:
|
||
try:
|
||
# Vérifier s'il y a des générations disponibles
|
||
generation_data = storage.read("IA_generator")
|
||
if not generation_data:
|
||
time.sleep(5)
|
||
continue
|
||
|
||
# Récupérer la dernière génération
|
||
sorted_keys = sorted(generation_data.keys())
|
||
if not sorted_keys:
|
||
time.sleep(5)
|
||
continue
|
||
|
||
last_generation = generation_data[sorted_keys[-1]]
|
||
|
||
print(f"[{datetime.now().strftime('%H:%M:%S')}] Envoi automatique: {last_generation}")
|
||
|
||
# Émettre l'événement de début d'envoi
|
||
socketio.emit('message_sending_start', {
|
||
'message': last_generation,
|
||
'timestamp': datetime.now().isoformat()
|
||
})
|
||
|
||
# Envoyer le message
|
||
try:
|
||
if current_message_bot:
|
||
# Utiliser le premier utilisateur par défaut
|
||
current_message_bot.send_message_user(_first_enabled_user_index(), last_generation)
|
||
|
||
# Émettre l'événement de fin d'envoi
|
||
socketio.emit('message_sending_complete', {
|
||
'message': last_generation,
|
||
'timestamp': datetime.now().isoformat()
|
||
})
|
||
|
||
# Supprimer la génération envoyée
|
||
storage.delete("IA_generator", sorted_keys[-1])
|
||
|
||
print(f"[{datetime.now().strftime('%H:%M:%S')}] Message envoyé avec succès")
|
||
|
||
except Exception as e:
|
||
# Émettre l'événement d'erreur
|
||
socketio.emit('message_sending_error', {
|
||
'message': last_generation,
|
||
'error': str(e)
|
||
})
|
||
print(f"[{datetime.now().strftime('%H:%M:%S')}] Erreur d'envoi: {e}")
|
||
|
||
# Attendre avant d'envoyer le prochain message
|
||
time.sleep(10)
|
||
|
||
except Exception as e:
|
||
print(f"[{datetime.now().strftime('%H:%M:%S')}] Erreur dans la boucle d'envoi automatique: {e}")
|
||
time.sleep(5)
|
||
|
||
print(f"[{datetime.now().strftime('%H:%M:%S')}] Arrêt de la boucle d'envoi automatique")
|
||
|
||
@app.route('/api/chat/messages/enable', methods=['POST'])
|
||
def enable_chat_messages():
|
||
"""Activer l'envoi de messages dans le chat"""
|
||
try:
|
||
chat_state.chat_messages_enabled = True
|
||
return jsonify({
|
||
'success': True,
|
||
'message': 'Envoi de messages dans le chat activé'
|
||
})
|
||
except Exception as e:
|
||
return jsonify({
|
||
'success': False,
|
||
'error': f'Erreur lors de l\'activation: {str(e)}'
|
||
}), 500
|
||
|
||
@app.route('/api/chat/messages/disable', methods=['POST'])
|
||
def disable_chat_messages():
|
||
"""Désactiver l'envoi de messages dans le chat"""
|
||
try:
|
||
chat_state.chat_messages_enabled = False
|
||
return jsonify({
|
||
'success': True,
|
||
'message': 'Envoi de messages dans le chat désactivé'
|
||
})
|
||
except Exception as e:
|
||
return jsonify({
|
||
'success': False,
|
||
'error': f'Erreur lors de la désactivation: {str(e)}'
|
||
}), 500
|
||
|
||
@app.route('/api/chat/messages/status', methods=['GET'])
|
||
def get_chat_messages_status():
|
||
"""Obtenir le statut de l'envoi de messages dans le chat"""
|
||
return jsonify({
|
||
'enabled': chat_state.chat_messages_enabled
|
||
})
|
||
|
||
@app.route('/api/system-status', methods=['GET'])
|
||
def get_system_status():
|
||
"""Obtenir le statut de tous les composants"""
|
||
return jsonify(bot_controller.get_system_status())
|
||
|
||
|
||
@app.route('/api/clips/create', methods=['POST'])
|
||
def create_clip():
|
||
"""
|
||
Créer un clip Twitch via Helix.
|
||
Nécessite:
|
||
- `twitch_client_id` dans config/config.json
|
||
- un user token avec scope `clips:edit` (config/user.json, champ tw_acc_token)
|
||
"""
|
||
try:
|
||
data = request.json or {}
|
||
channel_login = (data.get("channel_login") or "").strip()
|
||
user_id = int(data.get("user_id", _first_enabled_user_index()))
|
||
has_delay = bool(data.get("has_delay", False))
|
||
|
||
bearer = _user_bearer_token(user_id)
|
||
broadcaster_id = _twitch_get_user_id_by_login(channel_login, bearer)
|
||
clip = _twitch_create_clip(broadcaster_id=broadcaster_id, user_bearer=bearer, has_delay=has_delay)
|
||
|
||
return jsonify({
|
||
"success": True,
|
||
"clip": {
|
||
"broadcaster_login": channel_login.lstrip("@"),
|
||
"broadcaster_id": broadcaster_id,
|
||
**clip,
|
||
}
|
||
})
|
||
except ValueError as e:
|
||
return jsonify({"success": False, "error": str(e)}), 400
|
||
except RuntimeError as e:
|
||
return jsonify({"success": False, "error": str(e)}), 502
|
||
except Exception as e:
|
||
return jsonify({"success": False, "error": str(e)}), 500
|
||
|
||
|
||
# === CLIPS AUTOMATION (stub for future) ===
|
||
_clips_automation_running = False
|
||
_clips_automation_mode = "manual"
|
||
|
||
|
||
@app.route('/api/clips/automation/status', methods=['GET'])
|
||
def clip_automation_status():
|
||
return jsonify({
|
||
"success": True,
|
||
"running": _clips_automation_running,
|
||
"mode": _clips_automation_mode,
|
||
})
|
||
|
||
|
||
@app.route('/api/clips/automation/start', methods=['POST'])
|
||
def clip_automation_start():
|
||
# Intentionally not implemented yet: future hook point.
|
||
return jsonify({
|
||
"success": False,
|
||
"error": "Automatisation clips: pas encore implémentée (stub prêt)",
|
||
}), 501
|
||
|
||
|
||
@app.route('/api/clips/automation/stop', methods=['POST'])
|
||
def clip_automation_stop():
|
||
# Intentionally not implemented yet: future hook point.
|
||
return jsonify({
|
||
"success": False,
|
||
"error": "Automatisation clips: pas encore implémentée (stub prêt)",
|
||
}), 501
|
||
|
||
@app.route('/api/interaction/config', methods=['GET'])
|
||
def get_interaction_config():
|
||
"""
|
||
Récupérer la config Interaction Chat (réponses préenregistrées + règles).
|
||
Stockée en JSON sous storage/interaction_chat_config.json.
|
||
"""
|
||
try:
|
||
# Utiliser le processor du premier flux actif si possible, sinon un "fallback" via une instance ad-hoc
|
||
processor = None
|
||
for flux_id, bots in bot_controller.bots.items():
|
||
processor = bots.get('interaction')
|
||
if processor:
|
||
break
|
||
|
||
if not processor:
|
||
# fallback: config globale, même fichier storage
|
||
from twitch_bot.interaction_chat import InteractionChatStorage
|
||
st = InteractionChatStorage()
|
||
cfg = InteractionChatConfig(st.read_json("interaction_chat_config", default={}))
|
||
data = cfg.to_dict()
|
||
else:
|
||
data = processor.load_config().to_dict()
|
||
|
||
# Comptes enregistrés (config/user.json)
|
||
try:
|
||
with open('config/user.json', 'r', encoding='utf-8') as f:
|
||
users = json.load(f)
|
||
registered = [u.get('tw_acc_pseudo') for u in (users or []) if isinstance(u, dict) and u.get('tw_acc_pseudo')]
|
||
except Exception:
|
||
registered = []
|
||
|
||
return jsonify({'success': True, 'config': data, 'registered_accounts': registered})
|
||
except Exception as e:
|
||
return jsonify({'success': False, 'error': str(e)}), 500
|
||
|
||
@app.route('/api/interaction/config', methods=['POST'])
|
||
def save_interaction_config():
|
||
"""Sauvegarder la config Interaction Chat."""
|
||
try:
|
||
payload = request.json or {}
|
||
config_dict = payload.get('config') or {}
|
||
|
||
# Sauvegarder via un processor si présent, sinon via stockage direct
|
||
processor = None
|
||
for flux_id, bots in bot_controller.bots.items():
|
||
processor = bots.get('interaction')
|
||
if processor:
|
||
break
|
||
|
||
if processor:
|
||
cfg = processor.save_config(config_dict)
|
||
else:
|
||
from twitch_bot.interaction_chat import InteractionChatStorage
|
||
st = InteractionChatStorage()
|
||
cfg = InteractionChatConfig(config_dict)
|
||
st.write_json("interaction_chat_config", cfg.to_dict())
|
||
|
||
return jsonify({'success': True, 'config': cfg.to_dict()})
|
||
except Exception as e:
|
||
return jsonify({'success': False, 'error': str(e)}), 500
|
||
|
||
@app.route('/api/interaction/log', methods=['GET'])
|
||
def get_interaction_log():
|
||
"""Lire les logs Interaction Chat."""
|
||
try:
|
||
limit = int(request.args.get('limit', '100'))
|
||
limit = max(1, min(500, limit))
|
||
|
||
processor = None
|
||
for flux_id, bots in bot_controller.bots.items():
|
||
processor = bots.get('interaction')
|
||
if processor:
|
||
break
|
||
|
||
if processor:
|
||
logs = processor.read_log(limit=limit)
|
||
else:
|
||
from twitch_bot.interaction_chat import InteractionChatStorage
|
||
st = InteractionChatStorage()
|
||
logs = st.read_json("interaction_chat_log", default=[])
|
||
if not isinstance(logs, list):
|
||
logs = []
|
||
logs = logs[-limit:]
|
||
|
||
return jsonify({'success': True, 'logs': logs})
|
||
except Exception as e:
|
||
return jsonify({'success': False, 'error': str(e)}), 500
|
||
|
||
@app.route('/api/ia-generator/start', methods=['POST'])
|
||
def start_ia_generator():
|
||
"""Démarrer le générateur IA"""
|
||
success, message = bot_controller.start_ia_generator()
|
||
if success:
|
||
# Synchroniser l'état de l'interface web
|
||
socketio.emit('ia_generator_status_changed', {
|
||
'running': True,
|
||
'message': message
|
||
})
|
||
return jsonify({'success': success, 'message': message})
|
||
|
||
@app.route('/api/ia-generator/stop', methods=['POST'])
|
||
def stop_ia_generator():
|
||
"""Arrêter le générateur IA"""
|
||
success, message = bot_controller.stop_ia_generator()
|
||
if success:
|
||
# Synchroniser l'état de l'interface web
|
||
socketio.emit('ia_generator_status_changed', {
|
||
'running': False,
|
||
'message': message
|
||
})
|
||
return jsonify({'success': success, 'message': message})
|
||
|
||
@app.route('/api/control-twitch/start', methods=['POST'])
|
||
def start_control_twitch():
|
||
"""Démarrer le contrôleur Twitch"""
|
||
success, message = bot_controller.start_control_twitch()
|
||
return jsonify({'success': success, 'message': message})
|
||
|
||
@app.route('/api/control-twitch/stop', methods=['POST'])
|
||
def stop_control_twitch():
|
||
"""Arrêter le contrôleur Twitch"""
|
||
success, message = bot_controller.stop_control_twitch()
|
||
return jsonify({'success': success, 'message': message})
|
||
|
||
if __name__ == '__main__':
|
||
# Démarrer les mises à jour en arrière-plan
|
||
update_thread = threading.Thread(target=background_updates, daemon=True)
|
||
update_thread.start()
|
||
|
||
# Démarrer l'application Flask
|
||
socketio.run(app, host='0.0.0.0', port=5000, debug=True) |