app.py

#Importation des packages et de nos constantes
import streamlit as st
import requests
import base64
from dotenv import load_dotenv
from googletrans import Translator
from gtts import gTTS 
from PIL import Image
import os 
import google.generativeai as genai

load_dotenv()
genai.configure(api_key=os.getenv('GOOGLE_API_KEY'))

API_URL = "https://api-inference.huggingface.co/models/openai/clip-vit-large-patch14"
headers = {"Authorization": "Bearer "}

st.set_page_config(page_title='TOUM SERENA SOLANGE MICHELLE _ Final Exam App')

# Définition des différentes applications Streamlit
def app1():
    st.title('Chatbot Intelligent')
    st.write(' Conçu pour répondre à une variété de questions et de requêtes, ce chatbot est alimenté par un modèle de génération de langage avancé. Alors, viens chatter avec mon application')

    model = genai.GenerativeModel('gemini-pro')
    chat = model.start_chat(history=[])

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

    if "messages" not in st.session_state:
        st.session_state.messages = []

    for message in st.session_state.messages:
        with st.chat_message(message["role"]):
            st.markdown(message["content"])

    if prompt := st.chat_input("Quoi de neuf?"):
        st.chat_message("utilisateur").markdown(prompt)
        st.session_state.messages.append({"role": "utilisateur", "content": prompt})

        response = get_gemini_response(prompt)
        with st.chat_message("assistant"):
            for chunk in response:
                st.write(chunk.text)
                st.session_state.messages.append({"role": "assistant", "content": chunk.text })

def app2():
    st.title('Text to Speech')
    st.write('Ceci est une application  pour la conversion texte en discours. Alors, qu/attends tu pour nous donner ton discours?')
    
    def get_text_to_speech(text):
        text_spanish = translate_text(text)
        tts = gTTS(text=text_spanish, lang='es', slow=False)
        tts.save("output.mp3")
        st.audio("output.mp3")

    def translate_text(text):
        translator = Translator()
        translation = translator.translate(text, dest="es")
        return translation.text

    def input_text_setup():
        text = st.text_input("Entrez le texte à convertir en parole :")
        return text

    text_to_convert = input_text_setup()

    if text_to_convert:
        translated_text = translate_text(text_to_convert)
        get_text_to_speech(translated_text)
        st.success("Texte converti en parole espagnole. Consultez votre console ou le fichier output.mp3 (si activé).")

def app3():
    st.title('Zero shot Image Classification')
    st.write('Ceci est une application  pour la classification d\'image. Entrez plusieurs groupes, et votre image et nous vous donnons la probabilité que votre image se rapproche plus d\'une classe')

    def query(data):
        with open(data["image_path"], "rb") as f:
            img = f.read()
        payload = {
            "parameters": data["parameters"],
            "inputs": base64.b64encode(img).decode("utf-8")
        }
        response = requests.post(API_URL, headers=headers, json=payload)
        return response.json()

    def split_phrase(phrase):
        words = phrase.split(',')
        clean_words = [word.strip() for word in words]
        return clean_words

    st.title("Application Streamlit pour envoyer une image à une API")
    class_label = st.text_input("Entrez l'étiquette de classe (séparée par des virgules):")
    cl = class_label.split(",")
    uploaded_file = st.file_uploader("Téléchargez une image", type=["jpg", "png", "jpeg"])

    if uploaded_file is not None:
        image_path = "temp_image.jpg"  
        with open(image_path, "wb") as f:
            f.write(uploaded_file.read())

        st.write("L'image a été téléchargée avec succès ! Son chemin est :", image_path)

        data = {
            "image_path": image_path,
            "parameters": {"candidate_labels": split_phrase(class_label)}
        }

        response = query(data) 
        st.write("Réponse de l'API:", response)

def app4():
    st.title('Image to text')
    st.write('Ceci est l\'application pour la conversion d\'image en texte. Donnes moi une image, que je te traduise ce que m\'exprime ton image')

    def get_gemini_response(input_prompt, image):
        model = genai.GenerativeModel('gemini-pro-vision')
        response = model.generate_content([input_prompt, image[0]])
        return response.text

    def input_image_setup(uploaded_file):
        if uploaded_file is not None:
            bytes_data = uploaded_file.getvalue()
            image_parts = [{'mime_type': uploaded_file.type,
                            'data': bytes_data}]
            return image_parts
        else:
            raise FileNotFoundError('No File Uploaded')

    st.header('SM_Image_to_text')
    uploaded_file = st.file_uploader('Choisissez une image.', type=['jpg', 'jpeg', 'png'])
    if uploaded_file is not None:
        image = Image.open(uploaded_file)
        st.image(image, caption="Fichier téléchargé", use_column_width=True)
    submit = st.button('Dites-moi à quoi correspond cette image')
    input_prompt = """
    une photographie de
    """
    if submit:
        image_data = input_image_setup(uploaded_file)
        response = get_gemini_response(input_prompt, image_data)
        st.subheader('La réponse est')
        st.write(response)

# Définition de la page d'accueil
def accueil():
    st.title('Page d\'accueil')
    st.write('Bienvenue sur SM ❤️ Apps !')
    st.write('Découvrez nos applications intelligentes conçues pour réinventer votre façon d\'interagir avec la technologie. Que vous soyez curieux d\'explorer un chatbot intelligent, fasciné par la magie de la conversion texte en discours, intrigué par la puissance de la classification d\'images , ou captivé par la transformation d\'images en texte, vous trouverez ici une expérience unique et enrichissante. Préparez-vous à être ébloui par la créativité de SM❤️_Apps. Plongez dans l\'aventure dès maintenant !".')
    st.write('Choisissez une application dans le menu déroulant à votre gauche.')

def home():
    # Liste des applications disponibles
    apps = {
        'Accueil': accueil,
        'Chatbot Intelligent': app1,
        'Text to Speech': app2,
        'Zero Shot Image': app3,
        'Image to Text': app4
    }
    
    # Création du selectbox pour choisir l'application
    selected_app = st.sidebar.selectbox('Sélectionnez une application :', list(apps.keys()), key="select_app")

    apps[selected_app]()

home()