Update app.py

app.py

@@ -1,140 +1,182 @@
-# Install the required libraries
-# pip install transformers gradio Pillow requests
-import os
+# Import required libraries
+import gradio as gr
 import requests
-from transformers import MarianMTModel, MarianTokenizer, AutoModelForCausalLM, AutoTokenizer
-from PIL import Image, ImageDraw
+from getpass import getpass
+import openai
+from PIL import Image
 import io
-import gradio as gr
-import torch
-
-# Detect if GPU is available
-device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
-
-# Load the MarianMT model and tokenizer for translation (Tamil to English)
-model_name = "Helsinki-NLP/opus-mt-mul-en"
-translation_model = MarianMTModel.from_pretrained(model_name).to(device)
-translation_tokenizer = MarianTokenizer.from_pretrained(model_name)
-
-# Load GPT-Neo for creative text generation
-text_generation_model_name = "EleutherAI/gpt-neo-1.3B"
-text_generation_model = AutoModelForCausalLM.from_pretrained(text_generation_model_name).to(device)
-text_generation_tokenizer = AutoTokenizer.from_pretrained(text_generation_model_name)
-
-# Add padding token to GPT-Neo tokenizer if not present
-if text_generation_tokenizer.pad_token is None:
-    text_generation_tokenizer.add_special_tokens({'pad_token': '[PAD]'})
-
-# Set your Hugging Face API key
-os.environ['HF_API_KEY'] = 'Your_HF_TOKEN'  # Replace with your actual API key
-api_key = os.getenv('HF_API_KEY')
-if api_key is None:
-    raise ValueError("Hugging Face API key is not set. Please set it in your environment.")
-
-headers = {"Authorization": f"Bearer {api_key}"}
-
-# Define the API URL for image generation (replace with actual model URL)
-API_URL = "https://api-inference.huggingface.co/models/black-forest-labs/FLUX.1-schnell"  # Replace with a valid image generation model
-
-# Query Hugging Face API to generate image with error handling
-def query(payload):
-    response = requests.post(API_URL, headers=headers, json=payload)
-    if response.status_code != 200:
-        print(f"Error: Received status code {response.status_code}")
-        print(f"Response: {response.text}")
-        return None
-    return response.content
-
-# Translate Tamil text to English
-def translate_text(tamil_text):
-    inputs = translation_tokenizer(tamil_text, return_tensors="pt", padding=True, truncation=True).to(device)
-    translated_tokens = translation_model.generate(**inputs)
-    translation = translation_tokenizer.decode(translated_tokens[0], skip_special_tokens=True)
-    return translation
-
-# Generate an image based on the translated text with error handling
-def generate_image(prompt):
-    image_bytes = query({"inputs": prompt})
-
-    if image_bytes is None:
-        # Return a blank image with error message
-        error_img = Image.new('RGB', (300, 300), color=(255, 0, 0))
-        d = ImageDraw.Draw(error_img)
-        d.text((10, 150), "Image Generation Failed", fill=(255, 255, 255))
-        return error_img
-
-    try:
-        image = Image.open(io.BytesIO(image_bytes))
-        return image
-    except Exception as e:
-        print(f"Error: {e}")
-        # Return an error image in case of failure
-        error_img = Image.new('RGB', (300, 300), color=(255, 0, 0))
-        d = ImageDraw.Draw(error_img)
-        d.text((10, 150), "Invalid Image Data", fill=(255, 255, 255))
-        return error_img
-
-# Generate creative text based on the translated English text
-def generate_creative_text(translated_text):
-    inputs = text_generation_tokenizer(translated_text, return_tensors="pt", padding=True, truncation=True).to(device)
-    generated_tokens = text_generation_model.generate(**inputs, max_length=100)
-    creative_text = text_generation_tokenizer.decode(generated_tokens[0], skip_special_tokens=True)
-    return creative_text
-
-# Function to handle the full workflow
-def translate_generate_image_and_text(tamil_text):
-    # Step 1: Translate Tamil to English
-    translated_text = translate_text(tamil_text)
-
-    # Step 2: Generate an image from the translated text
-    image = generate_image(translated_text)
-
-    # Step 3: Generate creative text from the translated text
-    creative_text = generate_creative_text(translated_text)
-
-    return translated_text, creative_text, image
-
-# Create a visually appealing Gradio interface
-css = """
-#transart-title {
-    font-size: 2.5em;
-    font-weight: bold;
-    color: #4CAF50;
-    text-align: center;
-    margin-bottom: 10px;
+
+# Input your Hugging Face and Groq tokens securely
+Transalate_token = getpass("Enter Hugging Face Translation Token: ")
+Image_Token = getpass("Enter Hugging Face Image Generation Token: ")
+Content_Token = getpass("Enter Groq Content Generation Token: ")
+Image_prompt_token = getpass("Enter Groq Prompt Generation Token: ")
+
+# API Keys for GPT and Gemini (replace with your actual keys)
+openai.api_key = getpass("Enter OpenAI API Key: ")
+# gemini_token = getpass("Enter Gemini API Key: ")  # Placeholder, you will need API access
+
+# API Headers
+Translate = {"Authorization": f"Bearer {Transalate_token}"}
+Image_generation = {"Authorization": f"Bearer {Image_Token}"}
+Content_generation = {
+    "Authorization": f"Bearer {Content_Token}",
+    "Content-Type": "application/json"
 }
-#transart-subtitle {
-    font-size: 1.25em;
-    text-align: center;
-    color: #555555;
-    margin-bottom: 20px;
+Image_Prompt = {
+    "Authorization": f"Bearer {Image_prompt_token}",
+    "Content-Type": "application/json"
 }
-body {
-    background-color: #f0f0f5;
+
+# Translation Model API URL (Tamil to English)
+translation_url = "https://api-inference.huggingface.co/models/facebook/mbart-large-50-many-to-one-mmt"
+
+# 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"
 }
-.gradio-container {
-    font-family: 'Arial', sans-serif;
+
+# Default image generation model
+default_image_model = "black-forest-labs/FLUX.1-schnell"
+
+# Content generation models
+content_models = {
+    "GPT-4 (OpenAI)": "gpt-4",
+    "Gemini-1 (DeepMind)": "gemini-1",
+    "llama-3.1-70b-versatile": "llama-3.1-70b-versatile",
+    "mixtral-8x7b-32768": "mixtral-8x7b-32768"
 }
-"""
-
-# Custom HTML for title and subtitle (can be displayed in Markdown)
-title_markdown = """
-# <div id="transart-title">TransArt</div>
-### <div id="transart-subtitle">Tamil to English Translation, Creative Text & Image Generation</div>
-"""
-
-# Gradio interface with customized layout and aesthetics
-with gr.Blocks(css=css) as interface:
-    gr.Markdown(title_markdown)  # Title and subtitle in Markdown
-    with gr.Row():
-        with gr.Column():
-            tamil_input = gr.Textbox(label="Enter Tamil Text", placeholder="Type Tamil text here...", lines=3)  # Input for Tamil text
-        with gr.Column():
-            translated_output = gr.Textbox(label="Translated Text", interactive=False)        # Output for translated text
-            creative_text_output = gr.Textbox(label="Creative Generated Text", interactive=False)  # Output for creative text
-            generated_image_output = gr.Image(label="Generated Image")  # Output for generated image
-
-    gr.Button("Generate").click(fn=translate_generate_image_and_text, inputs=tamil_input, outputs=[translated_output, creative_text_output, generated_image_output])
-
-# Launch the Gradio app
-interface.launch(debug=True, server_name="0.0.0.0")
+
+# Default content generation model
+default_content_model = "GPT-4 (OpenAI)"
+
+# Function to query Hugging Face translation model
+def translate_text(text):
+    payload = {"inputs": text}
+    response = requests.post(translation_url, headers=Translate, json=payload)
+    if response.status_code == 200:
+        result = response.json()
+        translated_text = result[0]['generated_text']
+        return translated_text
+    else:
+        return f"Translation Error {response.status_code}: {response.text}"
+
+# Function to generate content using GPT or Gemini
+def generate_content(english_text, max_tokens, temperature, model):
+    if model == "gpt-4":
+        # Using OpenAI's GPT model
+        response = openai.Completion.create(
+            engine=model,  # GPT model (like gpt-4)
+            prompt=f"Write educational content about {english_text} within {max_tokens} tokens.",
+            max_tokens=max_tokens,
+            temperature=temperature
+        )
+        return response.choices[0].text.strip()
+
+    # elif model == "gemini-1":
+    #     # Placeholder: Add code to call Gemini API here
+    #     # Using the Gemini API (this requires the correct endpoint and token from Google DeepMind)
+    #     # For example, you would create a POST request similar to OpenAI's API.
+    #     url = "https://api.deepmind.com/gemini/v1/generate"
+    #     headers = {
+    #         "Authorization": f"Bearer {gemini_token}",
+    #         "Content-Type": "application/json"
+    #     }
+    #     payload = {
+    #         "model": "gemini-1",
+    #         "input": f"Write educational content about {english_text} within {max_tokens} tokens.",
+    #         "temperature": temperature,
+    #         "max_tokens": max_tokens
+    #     }
+    #     response = requests.post(url, json=payload, headers=headers)
+    #     if response.status_code == 200:
+    #         return response.json()['choices'][0]['text']
+    #     else:
+    #         return f"Gemini Content Generation Error {response.status_code}: {response.text}"
+
+    else:
+        # Default to the Groq API or other models if selected
+        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:
+            return f"Content Generation Error: {response.status_code}"
+
+# Function to generate image prompt
+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:
+        return f"Prompt Generation Error: {response.status_code}"
+
+# Function to generate an image from the prompt
+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:
+        # Convert the image bytes to a PIL Image
+        image = Image.open(io.BytesIO(response.content))
+        # Save image to a temporary file-like object for Gradio
+        image.save("/tmp/generated_image.png")  # Save the image to a file
+        return "/tmp/generated_image.png"  # Return the path to the image
+    else:
+        return f"Image Generation Error {response.status_code}: {response.text}"
+
+# Gradio App
+def fusionmind_app(tamil_input, temperature, max_tokens, content_model, image_model):
+    # Step 1: Translation (Tamil to English)
+    english_text = translate_text(tamil_input)
+
+    # Step 2: Generate Educational Content
+    content_output = generate_content(english_text, max_tokens, temperature, content_models[content_model])
+
+    # Step 3: Generate Image from the prompt
+    image_prompt = generate_image_prompt(english_text)
+    image_data = generate_image(image_prompt, image_generation_urls[image_model])
+
+    return english_text, content_output, image_data
+
+# Gradio Interface
+interface = gr.Interface(
+    fn=fusionmind_app,
+    inputs=[
+        gr.Textbox(label="Enter Tamil Text"),
+        gr.Slider(minimum=0.1, maximum=1.0, value=0.7, label="Temperature"),
+        gr.Slider(minimum=100, maximum=400, value=200, label="Max Tokens for Content Generation"),
+        gr.Dropdown(list(content_models.keys()), label="Select Content Generation Model", value=default_content_model),
+        gr.Dropdown(list(image_generation_urls.keys()), label="Select Image Generation Model", value=default_image_model)
+    ],
+    outputs=[
+        gr.Textbox(label="Translated English Text"),
+        gr.Textbox(label="Generated Content"),
+        gr.Image(label="Generated Image")  # Display the generated image
+    ],
+    title="TransArt: A Multimodal Application for Vernacular Language Translation and Image Synthesis",
+    description="Translate Tamil to English, generate educational content, and generate related images!"
+)
+
+# Launch Gradio App
+interface.launch(debug=True)