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