Update app.py

Add: import gradio as gr
import requests
import asyncio
import edge_tts

# Fonction pour générer du texte avec PyBotChat API (simulée ici)
def generate_text(prompt):
# Simulation d'une génération de texte depuis Hugging Face (remplacer l'URL par une API réelle)
url = "https://huggingface.co/spaces/Sad44587/PyBotChat/resolve/main/app.py"

# Paramètres de la requête, ajuster selon le modèle spécifique
payload = {
"inputs": prompt,
"options": {"use_gpu": False}
}

response = requests.post(url, json=payload)

if response.status_code == 200:
response_data = response.json()
return response_data.get('generated_text', 'Désolé, je n\'ai pas pu générer de texte.')
else:
return "Erreur de génération du texte."

# Fonction pour générer la voix à partir du texte avec Edge TTS
async def generate_voice(text):
communicate = edge_tts.Communicate(text, voice="fr-FR-DeniseNeural", rate="0%")
await communicate.save("generated_audio.mp3")
return "generated_audio.mp3" # Retourne le chemin vers l'audio généré

# Fonction principale qui combine les deux processus
def generate_and_speak(prompt):
# Générer le texte avec PyBotChat API
generated_text = generate_text(prompt)

# Générer la voix à partir du texte généré
audio_path = asyncio.run(generate_voice(generated_text))

return generated_text, audio_path

# Interface Gradio
def create_interface():
with gr.Blocks() as demo:
gr.Markdown("### Chatbot avec génération vocale")

with gr.Row():
prompt_input = gr.Textbox(label="Entrez votre message", placeholder="Tapez ici...")
text_output = gr.Textbox(label="Réponse générée")
audio_output = gr.Audio(label="Réponse vocale")

prompt_input.submit(generate_and_speak, inputs=prompt_input, outputs=[text_output, audio_output])

return demo

# Lancer l'interface
if __name__ == "__main__":
demo = create_interface()
demo.launch()

app.py

@@ -1,107 +1,58 @@
 import gradio as gr
+import requests
 import asyncio
-import tempfile
 import edge_tts
-from huggingface_hub import InferenceClient
 
-# -------------------------
-# === Fast Chat (Gemma) ===
-# -------------------------
-client_fast = InferenceClient("google/gemma-1.1-2b-it")
-
-def fast_chat(query):
-    messages = [{
-        "role": "user",
-        "content": f"[SYSTEM] You are ASSISTANT who answers questions in a short and concise manner. [USER] {query}"
-    }]
-    response = ""
-    for message in client_fast.chat_completion(messages, max_tokens=2048, stream=True):
-        token = message.choices[0].delta.content
-        response += token
-        yield response
-
-# -----------------------------
-# === Critical Thinker Chat ===
-# -----------------------------
-client_critical = InferenceClient("mistralai/Mistral-Nemo-Instruct-2407")
-
-def critical_thinker(query):
-    budget = 10
-    prompt = f"""[INST] [SYSTEM] You are a French robot full of hope and enthusiasm for future projects...
-<QUERY> {query} [/INST] [ASSISTANT]"""
-    stream = client_critical.text_generation(prompt, max_new_tokens=4096, stream=True, details=True, return_full_text=False)
-    output = ""
-    for response in stream:
-        output += response.token.text
-    return output
-
-# -----------------
-# === Edge TTS ====
-# -----------------
-async def get_voices():
-    voices = await edge_tts.list_voices()
-    return {f"{v['ShortName']} - {v['Locale']} ({v['Gender']})": v['ShortName'] for v in voices}
-
-async def text_to_speech(text, voice, rate, pitch):
-    if not text.strip():
-        return None, gr.Warning("Please enter text to convert.")
-    if not voice:
-        return None, gr.Warning("Please select a voice.")
+# Fonction pour générer du texte avec PyBotChat API (simulée ici)
+def generate_text(prompt):
+    # Simulation d'une génération de texte depuis Hugging Face (remplacer l'URL par une API réelle)
+    url = "https://huggingface.co/spaces/Sad44587/PyBotChat/resolve/main/app.py"
     
-    voice_short_name = voice.split(" - ")[0]
-    rate_str = f"{rate:+d}%"
-    pitch_str = f"{pitch:+d}Hz"
-    communicate = edge_tts.Communicate(text, voice_short_name, rate=rate_str, pitch=pitch_str)
-    with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp_file:
-        tmp_path = tmp_file.name
-        await communicate.save(tmp_path)
-    return tmp_path, None
-
-def tts_interface(text, voice, rate, pitch):
-    audio, warning = asyncio.run(text_to_speech(text, voice, rate, pitch))
-    return audio, warning
-
-# -------------------------------
-# === Interface Gradio globale ==
-# -------------------------------
-async def main():
-    voices = await get_voices()
-
-    # Onglet 1 : Chat Rapide
-    with gr.Blocks() as fast_tab:
-        gr.Markdown("# 💬 Fast Chat")
-        gr.Interface(fn=fast_chat, inputs=gr.Textbox(label="Your message"), outputs="text")
-
-    # Onglet 2 : Chat Critique
-    with gr.Blocks() as critical_tab:
-        gr.Markdown("# 🤖 Critical Thinker")
-        gr.Interface(fn=critical_thinker, inputs=gr.Textbox(label="Your question"), outputs="text")
+    # Paramètres de la requête, ajuster selon le modèle spécifique
+    payload = {
+        "inputs": prompt,
+        "options": {"use_gpu": False}
+    }
+    
+    response = requests.post(url, json=payload)
+    
+    if response.status_code == 200:
+        response_data = response.json()
+        return response_data.get('generated_text', 'Désolé, je n\'ai pas pu générer de texte.')
+    else:
+        return "Erreur de génération du texte."
+
+# Fonction pour générer la voix à partir du texte avec Edge TTS
+async def generate_voice(text):
+    communicate = edge_tts.Communicate(text, voice="fr-FR-DeniseNeural", rate="0%")
+    await communicate.save("generated_audio.mp3")
+    return "generated_audio.mp3"  # Retourne le chemin vers l'audio généré
+
+# Fonction principale qui combine les deux processus
+def generate_and_speak(prompt):
+    # Générer le texte avec PyBotChat API
+    generated_text = generate_text(prompt)
+    
+    # Générer la voix à partir du texte généré
+    audio_path = asyncio.run(generate_voice(generated_text))
+    
+    return generated_text, audio_path
 
-    # Onglet 3 : TTS
-    with gr.Blocks() as tts_tab:
-        gr.Markdown("# 🔊 Text-to-Speech")
-        gr.Interface(
-            fn=tts_interface,
-            inputs=[
-                gr.Textbox(label="Text to Speak", lines=5),
-                gr.Dropdown(choices=[""] + list(voices.keys()), label="Select Voice"),
-                gr.Slider(minimum=-50, maximum=50, value=0, label="Rate (%)"),
-                gr.Slider(minimum=-20, maximum=20, value=0, label="Pitch (Hz)")
-            ],
-            outputs=[
-                gr.Audio(label="Generated Audio", type="filepath"),
-                gr.Markdown(label="Warning", visible=False)
-            ]
-        )
+# Interface Gradio
+def create_interface():
+    with gr.Blocks() as demo:
+        gr.Markdown("### Chatbot avec génération vocale")
+        
+        with gr.Row():
+            prompt_input = gr.Textbox(label="Entrez votre message", placeholder="Tapez ici...")
+            text_output = gr.Textbox(label="Réponse générée")
+            audio_output = gr.Audio(label="Réponse vocale")
 
-    # Tabs Fusionnées
-    app = gr.TabbedInterface(
-        interface_list=[fast_tab, critical_tab, tts_tab],
-        tab_names=["Fast Chat", "Critical Thinker", "TTS"]
-    )
+        prompt_input.submit(generate_and_speak, inputs=prompt_input, outputs=[text_output, audio_output])
 
-    app.queue()
-    app.launch()
+    return demo
 
+# Lancer l'interface
 if __name__ == "__main__":
-    asyncio.run(main())
+    demo = create_interface()
+    demo.launch()