Update app.py

app.py

@@ -1,120 +1,168 @@
-import os
-import requests
 import streamlit as st
-from PIL import Image
-from io import BytesIO
-from transformers import MBartForConditionalGeneration, MBart50Tokenizer
-import time
-
-# Fetch the API keys from Hugging Face Secrets
-HUGGINGFACE_TOKEN = os.getenv("Hugging_face_token")
-GROQ_API_KEY = os.getenv("Groq_api")
-
-# Hugging Face API endpoint
-HF_API_URL = "https://api-inference.huggingface.co/models/black-forest-labs/FLUX.1-dev"
-hf_headers = {"Authorization": f"Bearer {HUGGINGFACE_TOKEN}"}
-
-# Groq API endpoint
-groq_url = "https://api.groq.com/openai/v1/chat/completions"
-groq_headers = {
-    "Authorization": f"Bearer {GROQ_API_KEY}",
+import requests
+import os
+from transformers import MBartForConditionalGeneration, MBart50TokenizerFast
+
+# API keys for other features (optional)
+Image_Token = os.getenv('Image_generation')
+Content_Token = os.getenv('ContentGeneration')
+Image_prompt_token = os.getenv('Prompt_generation')
+
+# API Headers for external services (optional)
+Image_generation = {"Authorization": f"Bearer {Image_Token}"}
+Content_generation = {
+    "Authorization": f"Bearer {Content_Token}",
+    "Content-Type": "application/json"
+}
+Image_Prompt = {
+    "Authorization": f"Bearer {Image_prompt_token}",
     "Content-Type": "application/json"
 }
 
-# Function to query Hugging Face model for image generation
-def query_huggingface(payload):
-    try:
-        response = requests.post(HF_API_URL, headers=hf_headers, json=payload)
-        if response.status_code != 200:
-            return None
-        return response.content
-    except Exception:
-        return None
+# Text-to-Image Model API URLs
+image_generation_urls = {
+    "black-forest-labs/FLUX.1-schnell": "https://api-inference.huggingface.co/models/black-forest-labs/FLUX.1-schnell",
+    "CompVis/stable-diffusion-v1-4": "https://api-inference.huggingface.co/models/CompVis/stable-diffusion-v1-4",
+    "black-forest-labs/FLUX.1-dev": "https://api-inference.huggingface.co/models/black-forest-labs/FLUX.1-dev"
+}
+
+# Default content generation model
+content_models = {
+    "llama-3.1-70b-versatile": "llama-3.1-70b-versatile",
+    "llama3-8b-8192": "llama3-8b-8192",
+    "gemma2-9b-it": "gemma2-9b-it",
+    "mixtral-8x7b-32768": "mixtral-8x7b-32768"
+}
 
-# Function to generate text using Groq API
-def generate_response(prompt):
-    try:
-        payload = {
-            "model": "mixtral-8x7b-32768",
-            "messages": [
-                {"role": "system", "content": "You are a helpful assistant."},
-                {"role": "user", "content": prompt}
-            ],
-            "max_tokens": 100,
-            "temperature": 0.7
-        }
-        response = requests.post(groq_url, json=payload, headers=groq_headers)
-        if response.status_code == 200:
-            result = response.json()
-            return result['choices'][0]['message']['content']
-        else:
-            return None
-    except Exception:
+# Load the translation model and tokenizer locally
+@st.cache_resource
+def load_translation_model():
+    model = MBartForConditionalGeneration.from_pretrained("facebook/mbart-large-50-many-to-one-mmt")
+    tokenizer = MBart50TokenizerFast.from_pretrained("facebook/mbart-large-50-many-to-one-mmt")
+    return model, tokenizer
+
+# Function to perform translation locally
+def translate_text_local(text):
+    model, tokenizer = load_translation_model()
+    inputs = tokenizer(text, return_tensors="pt", max_length=512, truncation=True)
+    translated_tokens = model.generate(**inputs, forced_bos_token_id=tokenizer.lang_code_to_id["en_XX"])
+    translated_text = tokenizer.batch_decode(translated_tokens, skip_special_tokens=True)[0]
+    return translated_text
+
+# Function to query Groq content generation model (optional)
+def generate_content(english_text, max_tokens, temperature, model):
+    url = "https://api.groq.com/openai/v1/chat/completions"
+    payload = {
+        "model": model,
+        "messages": [
+            {"role": "system", "content": "You are a creative and insightful writer."},
+            {"role": "user", "content": f"Write educational content about {english_text} within {max_tokens} tokens."}
+        ],
+        "max_tokens": max_tokens,
+        "temperature": temperature
+    }
+    response = requests.post(url, json=payload, headers=Content_generation)
+    if response.status_code == 200:
+        result = response.json()
+        return result['choices'][0]['message']['content']
+    else:
+        st.error(f"Content Generation Error: {response.status_code}")
         return None
 
-# Function to translate Tamil to English using MBart model
-def translate_tamil_to_english(tamil_text):
-    try:
-        model_name = "facebook/mbart-large-50-many-to-one-mmt"
-        model = MBartForConditionalGeneration.from_pretrained(model_name)
-        tokenizer = MBart50Tokenizer.from_pretrained(model_name, src_lang="ta_IN")
-
-        inputs = tokenizer(tamil_text, return_tensors="pt")
-        translated = model.generate(**inputs, forced_bos_token_id=tokenizer.lang_code_to_id["en_XX"])
-        translated_text = tokenizer.decode(translated[0], skip_special_tokens=True)
-        return translated_text
-    except Exception:
+# Function to generate image prompt (optional)
+def generate_image_prompt(english_text):
+    payload = {
+        "model": "mixtral-8x7b-32768",
+        "messages": [
+            {"role": "system", "content": "You are a professional Text to image prompt generator."},
+            {"role": "user", "content": f"Create a text to image generation prompt about {english_text} within 30 tokens."}
+        ],
+        "max_tokens": 30
+    }
+    response = requests.post("https://api.groq.com/openai/v1/chat/completions", json=payload, headers=Image_Prompt)
+    if response.status_code == 200:
+        result = response.json()
+        return result['choices'][0]['message']['content']
+    else:
+        st.error(f"Prompt Generation Error: {response.status_code}")
         return None
 
-# Main function to generate text and image
-def generate_image_and_text(user_input):
-    with st.spinner("Generating results..."):
-        time.sleep(2)  # Simulate some processing time
-
-        # Translate Tamil to English
-        english_input = translate_tamil_to_english(user_input)
-        if not english_input:
-            st.warning("Sorry, the translation model is unavailable right now 😥😥😥. Please try again later.")
-        else:
-            st.markdown("### Translated English Text:")
-            st.write(english_input)
-
-        # Generate text description (100 tokens) using Groq API
-        if english_input:
-            full_text_description = generate_response(english_input)
-            if not full_text_description:
-                st.warning("Sorry, the text generation model is unavailable right now 😥😥😥. Please try again later.")
-            else:
-                st.markdown("### Generated Text Response:")
-                st.write(full_text_description)
-
-                # Create image prompt based on the full text description
-                image_prompt = generate_response(f"Create a concise image prompt from the following text: {full_text_description}")
-                if not image_prompt:
-                    st.warning("Sorry, the image prompt model is unavailable right now 😥😥😥. Please try again later.")
-                else:
-                    # Request an image based on the generated image prompt
-                    image_data = query_huggingface({"inputs": image_prompt})
-                    if not image_data:
-                        st.warning("Sorry, the image generation model is unavailable right now 😥😥😥. Please try again later.")
-                    else:
-                        try:
-                            # Load and display the image
-                            image = Image.open(BytesIO(image_data))
-                            st.image(image, caption="Generated Image", use_column_width=True)
-                        except Exception as e:
-                            st.error(f"Failed to display image: {e}")
-
-# Streamlit interface
-st.title("Multi-Modal Generator (Tamil to English)")
-st.write("Enter a prompt in Tamil to generate both text and an image.")
-
-# Input field for Tamil text
-user_input = st.text_input("Enter Tamil text here:")
-
-# Generate results when button is clicked
-if st.button("Generate"):
-    if user_input:
-        generate_image_and_text(user_input)
+# Function to generate an image from the prompt (optional)
+def generate_image(image_prompt, model_url):
+    data = {"inputs": image_prompt}
+    response = requests.post(model_url, headers=Image_generation, json=data)
+    if response.status_code == 200:
+        return response.content
     else:
-        st.error("Please enter a Tamil text.")
+        st.error(f"Image Generation Error {response.status_code}: {response.text}")
+        return None
+
+# User Guide Section
+def show_user_guide():
+    st.title("FusionMind User Guide")
+    st.write("""
+    ### Welcome to the FusionMind User Guide!
+
+### How to use this app:
+1. **Input Tamil Text**: Enter Tamil text to be translated and processed.
+2. **Generate Translations**: The app will automatically translate Tamil to English.
+3. **Generate Educational Content**: Use the translated English text to generate content.
+4. **Generate Images**: Optionally, generate an image related to the translated text.
+    """)
+
+# Main Streamlit app
+def main():
+    # Sidebar Menu
+    st.sidebar.title("FusionMind Options")
+    page = st.sidebar.radio("Select a page:", ["Main App", "User Guide"])
+
+    if page == "User Guide":
+        show_user_guide()
+        return
+
+    st.title("🅰️ℹ️ FusionMind ➡️ Multimodal")
+
+    # Sidebar for temperature, token adjustment, and model selection
+    st.sidebar.header("Settings")
+    temperature = st.sidebar.slider("Select Temperature", 0.1, 1.0, 0.7)
+    max_tokens = st.sidebar.slider("Max Tokens for Content Generation", 100, 400, 200)
+
+    # Content generation model selection
+    content_model = st.sidebar.selectbox("Select Content Generation Model", list(content_models.keys()), index=0)
+
+    # Image generation model selection
+    image_model = st.sidebar.selectbox("Select Image Generation Model", list(image_generation_urls.keys()), index=0)
+
+    # Suggested inputs
+    st.write("## Suggested Inputs")
+    suggestions = ["தரவு அறிவியல்", "உளவியல்", "ராக்கெட் எப்படி வேலை செய்கிறது"]
+    selected_suggestion = st.selectbox("Select a suggestion or enter your own:", [""] + suggestions)
+
+    # Input box for user
+    tamil_input = st.text_input("Enter Tamil text (or select a suggestion):", selected_suggestion)
+
+    if st.button("Generate"):
+        # Step 1: Translation (Tamil to English)
+        if tamil_input:
+            st.write("### Translated English Text:")
+            english_text = translate_text_local(tamil_input)
+            if english_text:
+                st.success(english_text)
+
+                # Step 2: Generate Educational Content
+                st.write("### Generated Content:")
+                with st.spinner('Generating content...'):
+                    content_output = generate_content(english_text, max_tokens, temperature, content_models[content_model])
+                    if content_output:
+                        st.success(content_output)
+
+                # Step 3: Generate Image from the prompt (optional)
+                st.write("### Generated Image:")
+                with st.spinner('Generating image...'):
+                    image_prompt = generate_image_prompt(english_text)
+                    image_data = generate_image(image_prompt, image_generation_urls[image_model])
+                    if image_data:
+                        st.image(image_data, caption="Generated Image")
+
+if __name__ == "__main__":
+    main()