Update app.py

app.py

@@ -1,66 +1,84 @@
-# Install necessary libraries if not already installed
-# !pip install transformers diffusers torch torchvision accelerate huggingface_hub matplotlib Pillow
-
-from huggingface_hub import login
-from transformers import MarianTokenizer, MarianMTModel
+import gradio as gr
+import requests
+from transformers import MarianMTModel, MarianTokenizer, AutoModelForCausalLM, AutoTokenizer
 from PIL import Image
 import torch
-from torchvision import transforms
-from transformers import BlipProcessor, BlipForConditionalGeneration
-import matplotlib.pyplot as plt
-
-# Step 1: Login to Hugging Face
-login("your_huggingface_token_here")  # 🔐 Replace this with your actual token
+import io
+import os
 
-# Step 2: Tamil to English Translation
-def translate_tamil_to_english(text):
-    model_name = "Helsinki-NLP/opus-mt-ta-en"
-    tokenizer = MarianTokenizer.from_pretrained(model_name)
-    model = MarianMTModel.from_pretrained(model_name)
+# Load Hugging Face API key securely
+HF_API_KEY = os.getenv("HF_API_KEY")   # give token
+if not HF_API_KEY:
+    raise ValueError("HF_API_KEY is not set. Add it in Hugging Face 'Variables and Secrets'.")
 
-    inputs = tokenizer(text, return_tensors="pt", padding=True)
-    translated = model.generate(**inputs)
-    english_text = tokenizer.decode(translated[0], skip_special_tokens=True)
-    return english_text
+# API Endpoint for Image Generation
+IMAGE_GEN_URL = "https://api-inference.huggingface.co/models/black-forest-labs/FLUX.1-schnell"
+HEADERS = {"Authorization": f"Bearer {HF_API_KEY}"}
 
-# Step 3: Generate Image (using any placeholder image here since BLIP is captioning-only)
-# You can download a sample image or use a real generation model like Stable Diffusion
-def get_sample_image():
-    img_url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/coco_sample.png"
-    img = Image.open(requests.get(img_url, stream=True).raw).convert('RGB')
-    return img
+# Check if GPU is available
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
 
-# Step 4: Describe the Image
-def describe_image(image):
-    processor = BlipProcessor.from_pretrained("Salesforce/blip-image-captioning-base")
-    model = BlipForConditionalGeneration.from_pretrained("Salesforce/blip-image-captioning-base")
+# Load Tamil-to-English Translation Model
+translator_model = "Helsinki-NLP/opus-mt-mul-en"
+translator = MarianMTModel.from_pretrained(translator_model).to(device)
+translator_tokenizer = MarianTokenizer.from_pretrained(translator_model)
 
-    inputs = processor(images=image, return_tensors="pt")
-    out = model.generate(**inputs)
-    caption = processor.decode(out[0], skip_special_tokens=True)
-    return caption
+# Load Text Generation Model
+generator_model = "EleutherAI/gpt-neo-1.3B"
+generator = AutoModelForCausalLM.from_pretrained(generator_model).to(device)
+generator_tokenizer = AutoTokenizer.from_pretrained(generator_model)
+if generator_tokenizer.pad_token is None:
+    generator_tokenizer.pad_token = generator_tokenizer.eos_token
 
-# === MAIN ===
-if __name__ == "__main__":
-    import requests
+def translate_tamil_to_english(text):
+    """Translates Tamil text to English."""
+    inputs = translator_tokenizer(text, return_tensors="pt", padding=True, truncation=True).to(device)
+    output = translator.generate(**inputs)
+    return translator_tokenizer.decode(output[0], skip_special_tokens=True)
 
-    # Step A: Input Tamil text
-    tamil_text = "ஒரு சிறிய வீடு கடற்கரைக்கு அருகிலுள்ளது"
-    print("Tamil Input:", tamil_text)
+def generate_text(prompt):
+    """Generates a creative text based on English input."""
+    inputs = generator_tokenizer(prompt, return_tensors="pt", padding=True, truncation=True).to(device)
+    output = generator.generate(**inputs, max_length=100)
+    return generator_tokenizer.decode(output[0], skip_special_tokens=True)
 
-    # Step B: Translate to English
-    english_translation = translate_tamil_to_english(tamil_text)
-    print("Translated English:", english_translation)
+def generate_image(prompt):
+    """Sends request to API for image generation."""
+    response = requests.post(IMAGE_GEN_URL, headers=HEADERS, json={"inputs": prompt})
+    if response.status_code == 200:
+        return Image.open(io.BytesIO(response.content))
+    return Image.new("RGB", (300, 300), "red")  # Placeholder image for errors
 
-    # Step C: Get sample image (placeholder for now, since we aren't using text-to-image yet)
-    image = get_sample_image()
+def process_input(tamil_text):
+    """Complete pipeline: Translation, Text Generation, and Image Generation."""
+    english_text = translate_tamil_to_english(tamil_text)
+    creative_text = generate_text(english_text)
+    image = generate_image(english_text)
+    return english_text, creative_text, image
 
-    # Step D: Describe the image
-    caption = describe_image(image)
-    print("Image Caption:", caption)
+# Create Gradio Interface
 
-    # Optional: Display the image
-    plt.imshow(image)
-    plt.title(caption)
-    plt.axis("off")
-    plt.show()
+# interface = gr.Interface(
+#     fn=process_input,
+#     inputs=gr.Textbox(label="Enter Tamil Text"),
+#     outputs=[
+#         gr.Textbox(label="Translated English Text"),
+#         gr.Textbox(label="Creative Text"),
+#         gr.Image(label="Generated Image")
+#     ],
+#     title="Tamil to English Translator & Image Generator",
+#     description="Enter Tamil text, and this app will translate it, generate a creative description, and create an image based on the text."
+# )
+interface = gr.Interface(
+    fn=process_input,
+    inputs=gr.Textbox(label="Enter Tamil Text"),
+    outputs=[
+        gr.Textbox(label="Translated English Text"),
+        gr.Textbox(label="Creative Text"),
+        gr.Image(label="Generated Image")
+    ],
+    title="Tamil to English Translator & Image Generator",
+    description="Enter Tamil text, and this app will translate it, generate a creative description, and create an image based on the text."
+)
+# Launch the Gradio app
+interface.launch()