Spaces:
Runtime error
Runtime error
File size: 5,686 Bytes
3265f46 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 | import json
import os
from uuid import uuid4
from datetime import datetime
from httpx import HTTPStatusError
import time
import asyncio
# Gestion des sessions
sessions = {}
# HISTORY_FILE = 'E:\work\Vocal-Telma\TMSpeechTextML\chat\chat_history.json'
HISTORY_FILE = "chat_history.json"
# Fonction pour charger les données historiques au démarrage de l'application
def load_history():
"""Charge les sessions existantes depuis le fichier JSON."""
global sessions
if os.path.exists(HISTORY_FILE):
try:
with open(HISTORY_FILE, "r") as f:
sessions = json.load(f)
except json.JSONDecodeError:
# Si le fichier est corrompu ou invalide, on initialise avec un dictionnaire vide
sessions = {}
else:
sessions = {} # Si le fichier n'existe pas, on crée un dictionnaire vide
# Initialisation du fichier JSON si non existant
def initialize_history_file():
"""Initialise le fichier historique s'il n'existe pas."""
if not os.path.exists(HISTORY_FILE):
with open(HISTORY_FILE, "w") as f:
json.dump({}, f)
# Fonction pour créer une nouvelle session
def create_session():
session_id = str(uuid4())
sessions[session_id] = {"created_at": str(datetime.now()), "history": []}
_save_history() # Toujours sauvegarder après avoir créé une session
return session_id
# Fonction pour obtenir une session existante
def get_session(session_id):
return sessions.get(session_id, None)
# Fonction pour ajouter des entrées dans l'historique
def add_to_history(session_id, user_input, response, result):
session = get_session(session_id)
if session:
session["history"].append({
"timestamp": str(datetime.now()),
"input": user_input,
"output": response,
"Offer": result
})
_save_history() # Toujours sauvegarder après avoir ajouté des données
# Sauvegarde de l'historique dans le fichier JSON
def _save_history():
"""Sauvegarde l'état actuel des sessions dans le fichier JSON sans écraser l'historique."""
try:
with open(HISTORY_FILE, "w") as f:
json.dump(sessions, f, indent=4)
except Exception as e:
print(f"Erreur lors de la sauvegarde de l'historique: {e}")
# Fonction pour obtenir la valeur d'une clé par ordre de priorité
def get_priority_value(json_data, priority_keys):
if isinstance(json_data, dict):
for key in priority_keys:
if key in json_data:
return json_data[key] # Renvoie la valeur de la première clé trouvée
if isinstance(json_data, str):
try:
# Convertir la chaîne JSON en dictionnaire
json_data = json.loads(json_data)
for key in priority_keys:
if key in json_data:
return json_data[key]
except json.JSONDecodeError as e:
print(f"Erreur lors de la conversion du JSON: {e}")
json_data = {}
else:
print("Erreur: json_data n'est pas un dictionnaire.")
return None
# Retry logic for API calls
async def invoke_with_retry(retrieval_chain, input_query, max_retries=3, wait_time=5):
for attempt in range(max_retries):
try:
response = retrieval_chain.invoke({"input": input_query})
return response
except HTTPStatusError as e:
if e.response.status_code == 429:
print(f"Rate limit exceeded. Retrying in {wait_time} seconds... (Attempt {attempt + 1}/{max_retries})")
# time.sleep(wait_time)
await asyncio.sleep(wait_time)
else:
raise e
raise Exception("Max retries exceeded. Could not process the request due to repeated rate limiting.")
async def invoke_with_retry_payment(model, formatted_input, max_retries=3, wait_time=5):
"""
Attempts to invoke the model. If a rate limit (429) error occurs,
waits for a specified time and retries the request.
Parameters:
model: The language model responsible for processing the input query.
formatted_input: The formatted input query to process.
max_retries: The maximum number of retries allowed (default is 3).
wait_time: Time in seconds to wait before retrying after a 429 error (default is 40 seconds).
Returns:
The response from the model or raises an exception if retries are exhausted.
"""
for attempt in range(max_retries):
try:
# Attempt to invoke the model
response = model.invoke(formatted_input)
return response # Return the response if successful
except HTTPStatusError as e:
# Check for the rate limit error (429)
if e.response.status_code == 429:
print(f"Rate limit exceeded. Retrying in {wait_time} seconds... (Attempt {attempt + 1}/{max_retries})")
# time.sleep(wait_time) # Wait for the specified time before retrying
await asyncio.sleep(wait_time)
else:
# Raise the exception if it's not a rate limit error
raise e
# If all retries are exhausted, raise an exception
raise Exception("Max retries exceeded. Could not process the request due to repeated rate limiting.")
# Initialisation au démarrage de l'application
initialize_history_file() # Vérifie et initialise le fichier JSON si nécessaire
load_history() # Charge l'historique existant lors du démarrage
|