Update app.py

app.py

@@ -1,182 +1,280 @@
-# Import required libraries
-import gradio as gr
+import os
+import io
 import requests
-from getpass import getpass
+import gradio as gr
+from groq import Groq
+from transformers import MarianMTModel, MarianTokenizer, AutoModelForCausalLM, AutoTokenizer
+from deep_translator import GoogleTranslator
+from PIL import Image, ImageDraw
+import joblib
+import time
+from indic_transliteration import sanscript
+from indic_transliteration.sanscript import transliterate
 import openai
-from PIL import Image
-import io
+import torch
+import warnings
+from huggingface_hub import InferenceApi
 
-# 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"
-}
-Image_Prompt = {
-    "Authorization": f"Bearer {Image_prompt_token}",
-    "Content-Type": "application/json"
+# Detect if GPU is available
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+# Set up Groq API key
+api_key = os.getenv("GROQ_API_KEY")
+client = Groq(api_key=api_key)
+
+# Set your Hugging Face API key
+os.environ['HF_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.")
+
+# Set OpenAI API key for text generation
+openai.api_key = os.getenv('OPENAI_API_KEY')
+
+headers = {"Authorization": f"Bearer {api_key}"}
+
+# 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]'})
+
+# Define the API URL for image generation
+API_URL = "https://api-inference.huggingface.co/models/CompVis/stable-diffusion-v1-4"
+
+# Load the trained sentiment analysis model and preprocessing steps
+with warnings.catch_warnings():
+    warnings.simplefilter("ignore")
+    model = joblib.load('model.pkl')
+
+# Function to query Hugging Face API
+def query(payload, max_retries=5):
+    for attempt in range(max_retries):
+        response = requests.post(API_URL, headers=headers, json=payload)
+
+        if response.status_code == 503:
+            print(f"Model is still loading, retrying... Attempt {attempt + 1}/{max_retries}")
+            estimated_time = min(response.json().get("estimated_time", 60), 60)
+            time.sleep(estimated_time)
+            continue
+
+        if response.status_code != 200:
+            print(f"Error: Received status code {response.status_code}")
+            print(f"Response: {response.text}")
+            return None
+
+        return response.content
+
+    print(f"Failed to generate image after {max_retries} attempts.")
+    return None
+
+# Function to generate image
+def generate_image(prompt):
+    image_bytes = query({"inputs": prompt})
+
+    if image_bytes is None:
+        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}")
+        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
+
+# Tamil Audio to Tamil text
+def transcribe_audio(audio_path):
+    if audio_path is None:
+        return "Please upload an audio file."
+    try:
+        with open(audio_path, "rb") as file:
+            transcription = client.audio.transcriptions.create(
+                file=(os.path.basename(audio_path), file.read()),
+                model="whisper-large-v3",
+                response_format="verbose_json",
+            )
+        return transcription.text
+    except Exception as e:
+        return f"An error occurred: {str(e)}"
+
+# Transliterate Romanized Tamil (in English letters) to Tamil script
+def transliterate_to_tamil(romanized_text):
+    try:
+        # Step 1: Normalize the input for better transliteration results
+        romanized_text = romanized_text.strip().lower()  # Remove extra spaces and convert to lowercase
+
+        # Step 2: Handle common punctuation that might interrupt transliteration
+        romanized_text = romanized_text.replace(".", " ").replace(",", " ").replace("?", " ").replace("!", " ")
+
+        # Step 3: Apply ITRANS transliteration
+        tamil_text = transliterate(romanized_text, sanscript.ITRANS, sanscript.TAMIL)
+
+        return tamil_text
+    except Exception as e:
+        return f"An error occurred during transliteration: {str(e)}"
+
+# Function to translate Tamil text to English using deep-translator
+def translate_tamil_to_english(tamil_text):
+    if not tamil_text:
+        return "Please provide text to translate."
+    try:
+        translator = GoogleTranslator(source='ta', target='en')
+        translated_text = translator.translate(tamil_text)
+
+        # Predict sentiment from translated text
+        sentiment_result = predict_sentiment(translated_text)
+
+        return translated_text, sentiment_result, translated_text
+    except Exception as e:
+        return f"An error occurred during translation: {str(e)}", None, None
+
+# Function to predict sentiment from English text
+def predict_sentiment(english_text):
+    if not english_text:
+        return "No text provided for sentiment analysis."
+    try:
+        sentiment = model.predict([english_text])[0]
+        return f"Sentiment: {sentiment}"
+    except Exception as e:
+        return f"An error occurred during sentiment prediction: {str(e)}"
+
+# Generate creative text based on the translated English text
+def generate_creative_text(english_text):
+    if not english_text:
+        return "Please provide text to generate creative content."
+
+    try:
+        inputs = text_generation_tokenizer(english_text, return_tensors="pt", padding=True, truncation=True).to(device)
+
+        # Set parameters to control the output and avoid repetition
+        generated_tokens = text_generation_model.generate(
+            **inputs,
+            max_length=60,
+            num_return_sequences=1,
+            no_repeat_ngram_size=3,
+            temperature=0.7,
+            top_p=0.9,
+            do_sample=True,
+            early_stopping=True
+        )
+
+        creative_text = text_generation_tokenizer.decode(generated_tokens[0], skip_special_tokens=True).strip()
+        return creative_text
+
+    except Exception as e:
+        return f"An error occurred during text generation: {str(e)}"
+
+# Create Gradio interface
+with gr.Blocks() as demo:
+    gr.Markdown(
+        """
+        <h1 style='color: #4CAF50;'>🎙️ Tamil Audio Transcription, Translation, Sentiment Prediction, Creative Text Generation, and Image Generation</h1>
+        <p style='color: #000080;'>Upload an audio file to get the Tamil transcription, edit the transcription or type Romanized Tamil to convert it to Tamil script, translate it to English, predict the sentiment of the translated text, generate creative English text, and generate an image.</p>
+        """
+    )
+
+    # Input for audio file
+    with gr.Row():
+        audio_input = gr.Audio(type="filepath", label="Upload Audio File")
+        transcribe_button = gr.Button("Transcribe Audio", elem_id="transcribe_btn")
+
+    # Output field for Tamil transcription with ability to edit or type Romanized Tamil
+    transcription_output = gr.Textbox(label="Transcription (Tamil or Romanized Tamil)", interactive=True ,elem_id="transcription_output")
+
+    # Button for transliterating Romanized Tamil to Tamil script
+    transliterate_button = gr.Button("Convert to Tamil Script", elem_id="transliterate_btn")
+
+    # Input field for Tamil text and translate button
+    with gr.Row():
+        translate_button = gr.Button("Translate to English", elem_id="translate_btn")
+
+    # Output field for English translation
+    translation_output = gr.Textbox(label="Translation (English)", elem_id="translation_output")
+
+    # Output field for sentiment prediction
+    sentiment_output = gr.Textbox(label="Sentiment", elem_id="sentiment_output")
+
+    # Button to generate creative text
+    creative_text_button = gr.Button("Generate Creative Text", elem_id="creative_btn")
+
+    # Output field for creative text
+    creative_text_output = gr.Textbox(label="Creative Text", elem_id="creative_output")
+
+    # Button to generate image
+    generate_button = gr.Button("Generate Image", elem_id="generate_btn")
+
+    # Output field for image file
+    image_output = gr.Image(label="Generated Image")
+
+    # Define variable to hold the translated English text
+    translated_text_var = gr.State()
+
+    # Define button click actions
+    transcribe_button.click(
+        fn=transcribe_audio,
+        inputs=audio_input,
+        outputs=transcription_output,
+    )
+
+    transliterate_button.click(
+        fn=transliterate_to_tamil,
+        inputs=transcription_output,
+        outputs=transcription_output,
+    )
+
+    translate_button.click(
+        fn=translate_tamil_to_english,
+        inputs=transcription_output,
+        outputs=[translation_output, sentiment_output, translated_text_var],
+    )
+
+    creative_text_button.click(
+        fn=generate_creative_text,
+        inputs=translated_text_var,
+        outputs=creative_text_output,
+    )
+
+    generate_button.click(
+        fn=generate_image,
+        inputs=translated_text_var,
+        outputs=image_output,
+    )
+
+# Apply custom CSS
+demo.css = """
+#transcribe_btn, #transliterate_btn, #translate_btn, #creative_btn, #generate_btn {
+    background-color: #05907B; /* Change button color */
+    color: white; /* Change text color */
 }
 
-# Translation Model API URL (Tamil to English)
-translation_url = "https://api-inference.huggingface.co/models/facebook/mbart-large-50-many-to-one-mmt"
+#translation_output,#transcription_output, #sentiment_output, #creative_output {
+    background-color: #f0f8ff; /* Change background color of text areas */
+}
 
-# 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"
+h1 {
+    color: #4CAF50; /* Main heading color */
 }
 
-# Default image generation model
-default_image_model = "black-forest-labs/FLUX.1-schnell"
+p {
+    color: #000080; /* Plain text color */
+}
 
-# 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"
+/* Add thick border to entire app */
+.gradio-container {
+    border: 5px solid #05907B; /* Thick border color */
+    padding: 10px; /* Padding inside the border */
+    border-radius: 10px; /* Optional: add rounded corners */
 }
+"""
 
-# 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)
+# Launch the interface and ensure code stops afterward
+demo.launch(share=True)