App.py

import streamlit as st
from streamlit_option_menu import option_menu
from dotenv import load_dotenv
load_dotenv()
import os
import google.generativeai as genai
import requests


from PIL import Image
from io import BytesIO
import numpy as np
import base64

from dataclasses import dataclass

st.set_page_config(page_title="TechVerse",layout="wide")




# 1. as sidebar menu
with st.sidebar:
    selected = option_menu("Main Menu", ["Home", 'A Propos'], 
        icons=['house', 'info'], menu_icon="app-indicator", default_index=1)
    selected


if selected == 'Home':
# 2. horizontal menu
    st.title(":green[TechVerse]: Explorez l'Infini")
    st.write("Bienvenue dans notre monde d'innovation et de découverte, où l'IA et l'ingéniosité humaine fusionnent pour vous offrir une expérience unique. Plongez dans une aventure où les mots prennent vie grâce à notre chatbot intelligent, prêt à répondre à vos questions et à vous guider à travers une multitude de sujets passionnants. Transformez vos idées en une symphonie numérique avec notre conversion texte en parole, donnant une voix à votre créativité. Explorez le monde visuel qui vous entoure avec notre incroyable capacité de classification d'images en un instant. Quelle que soit votre curiosité, notre application est là pour stimuler votre imagination et ouvrir de nouvelles perspectives passionnantes. Bienvenue dans notre monde d'intelligence infinie !")
   
# Création du select box pour choisir l'application



    selected2 = option_menu(None, ['Chatbot Intelligent', 'Text to Speech', 'Zero Shot Image Classification', 'Image to Text']
    , 
        icons=['chat-left-quote', 'music-note-list', "images", 'pencil-square'], 
        menu_icon="cast", default_index=0, orientation="horizontal")

    if selected2 == "Chatbot Intelligent":
        
        
        @dataclass
        class Message:
            actor: str
            payload: str

        USER = "user"
        ASSISTANT = "ai"
        MESSAGES = "messages"

        def initialize_chat():
            if MESSAGES not in st.session_state:
                st.session_state[MESSAGES] = [Message(actor=ASSISTANT, payload="Salut! Comment puis-je t'etre utile?")]

    
        def process_user_input(prompt):
            if prompt:
                st.session_state[MESSAGES].append(Message(actor=USER, payload=prompt))
                st.chat_message(USER).write(prompt)
                response = get_gemini_response(prompt)
                st.session_state[MESSAGES].append(Message(actor=ASSISTANT, payload=response))
                st.chat_message(ASSISTANT).write(response)

        def get_gemini_response(question):
            response = chat.send_message(question, stream=True)
            return "\n".join([chunk.text for chunk in response])

        genai.configure(api_key=st.secrests['TechVerse_T'])
        model = genai.GenerativeModel("gemini-pro")
        chat = model.start_chat(history=[])

        initialize_chat()

        prompt = st.chat_input("Enter a prompt here")

        if prompt:
            process_user_input(prompt)
            
        
        
        



    elif selected2 == 'Text to Speech':



        

        API_URL = "https://api-inference.huggingface.co/models/facebook/mms-tts-spa"
        headers = {"Authorization": "Bearer "+st.secrets['TechVerse_T']}

        def query(payload):
            response = requests.post(API_URL, headers=headers, json=payload)
            return response.content
        
        genai.configure(api_key=st.secrets['TechVerse_T'])
        model = genai.GenerativeModel("gemini-pro")
        chat = model.start_chat(history=[])


        def get_gemini_response(question):
            response = chat.send_message(question, stream=True)
            return response

        def get_gemini_answer(question):
            question = "translate in spanish :" + question
            response = chat.send_message(question, stream=True)
            return response
        
        def get_gemini_answerss(question):
            question = "translate in spanish :" + question
            response = chat.send_message(question, stream=True)
            return response



        service_selected = st.radio("Select Service:", ("Speech Translation in Spanish Only", "Speech Conversation in Spanish"))

        if service_selected == "Speech Translation in Spanish Only":
            
            input1 = st.text_input('Ecris un texte en la langue souhaitée ici 👇 pour traduction vocale en espagnole:', key='input1')

            if input1:
                T_active = ""
                answer = get_gemini_answer(input1)
                for yes in answer:
                    
                    T_active += yes.text

                audio_bytes = query({"inputs": T_active})

                st.markdown("#### retranscription vocale espagnole")
                st.audio(audio_bytes)

        elif service_selected == "Speech Conversation in Spanish":
            input2 = st.text_input('Ecris un texte en la langue souhaitée ici 👇 pour entamer la conversation:', key='input2')

            if input2:
                response = get_gemini_response(input2)
                talk = ""
                for chunk in response:
                    
                    talk += chunk.text

                T_active = ""
                answer = get_gemini_answer(talk)
                for yes in answer:
                    
                    T_active += yes.text

                audio = query({"inputs": T_active})
                st.markdown("#### Reponse vocale en espagnole")
                st.audio(audio)
                st.markdown("### Traduction ecrite")
                st.info(talk)

            
    
                
            
    elif selected2 =="Zero Shot Image Classification":
        

        API_URL = "https://api-inference.huggingface.co/models/openai/clip-vit-large-patch14"
        headers = {"Authorization": "Bearer "+st.secrets['TechVerse_T']}

        def load_image(image):
            if isinstance(image, str):  # Si l'entrée est une URL
                response = requests.get(image)
                image = Image.open(BytesIO(response.content))
            elif isinstance(image, np.ndarray):  # Si l'entrée est un tableau numpy
                image = Image.fromarray(image)
            else:  # Si l'entrée est un fichier local
                image = Image.open(image)
            return image

        def query(image, parameters):
            image = load_image(image)
            img_buffer = BytesIO()
            image.save(img_buffer, format="PNG")
            img_base64 = base64.b64encode(img_buffer.getvalue()).decode("utf-8")

            payload = {
                "parameters": {"candidate_labels": parameters},
                "inputs": img_base64
            }

            response = requests.post(API_URL, headers=headers, json=payload)
            return response.json()

        images = st.file_uploader("",type=["jpg", "png"])

        if images is None:
            st.text("")
        else:
            st.image(images, width=500,use_column_width='always')

        parametres = st.text_input("Entrez les classes séparées par des virgules")

        if parametres == "":
            st.warning("Veuillez renseigner au moins deux classe séparées par une virgule.",icon="⚠️")
        else:
            classes = [item.strip() for item in parametres.split(",")]
            if len(classes)< 2:
                st.warning("Veuillez renseigner au moins deux classe séparées par une virgule.",icon="⚠️")
            else :
                try:
                    result = query(images, classes)
                    if result:
                        max_score_label = max(result, key=lambda x: x["score"])
                       

                        
                        st.info(f"nous sommes à {max_score_label['score']*100}% certains que l'image que vous avez renseigné est une " + max_score_label["label"])
                except Exception as e:
                    st.error("Une erreur s'est produite lors de la requête API : {}".format(str(e)))

            
    

    

    else:
        API_URL = "https://api-inference.huggingface.co/models/Salesforce/blip-image-captioning-large"
        headers = {"Authorization": "Bearer "+st.secrets['TechVerse_T']}

        def load_image(image):
            if isinstance(image, str):  # Si l'entrée est une URL
                response = requests.get(image)
                image = Image.open(BytesIO(response.content))
            elif isinstance(image, np.ndarray):  # Si l'entrée est un tableau numpy
                image = Image.fromarray(image)
            else:  # Si l'entrée est un fichier local
                image = Image.open(image)
            return image

        def query(image):
            if image is None:
                raise ValueError("Aucune image n'a été fournie.")
            
            try:
                image = load_image(image)
                img_buffer = BytesIO()
                image.save(img_buffer, format="PNG")
                img_data = img_buffer.getvalue()

                response = requests.post(API_URL, headers=headers, data=img_data)
                response.raise_for_status()  # Gérer les erreurs HTTP

                return response.json()
            except Exception as e:
                raise RuntimeError("Une erreur s'est produite lors du traitement de l'image : {}".format(str(e)))

        images = st.file_uploader("Uploader une image", type=["jpg", "png"])
        if images is None:
            st.text("Veuillez charger une image.")
        else:
            st.image(images, width=500,use_column_width='always')

        try:
            output = query(images)
            st.markdown(output[0]["generated_text"])
        except Exception as e:
            st.error("Une erreur s'est produite : {}".format(str(e)))

else:
    pass