Create TransArt.py

TransArt.py

@@ -0,0 +1,182 @@
+# Import required libraries
+import gradio as gr
+import requests
+from getpass import getpass
+import openai
+from PIL import Image
+import io
+
+# 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"
+}
+
+# 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"
+}
+
+# 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"
+}
+
+# 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)