Create app.py

app.py

@@ -0,0 +1,204 @@
+import gradio as gr
+import os
+import tempfile
+import logging
+import json
+
+# Import your dispatcher class from the local summarizer_tool.py file
+from summarizer_tool import AllInOneDispatcher
+
+# Configure logging for the Gradio app
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+# Initialize the dispatcher globally.
+# This ensures models are loaded only once when the Gradio app starts up.
+# This can take time, especially on CPU.
+try:
+    dispatcher = AllInOneDispatcher()
+    logging.info("AllInOneDispatcher initialized successfully for Gradio app.")
+except Exception as e:
+    logging.error(f"Failed to initialize AllInOneDispatcher: {e}")
+    # If dispatcher fails to initialize, the app might not work.
+    # Raise a runtime error to make the Space fail gracefully with a clear message.
+    raise RuntimeError(f"Failed to initialize AI models. Check logs for details: {e}") from e
+
+# --- Gradio Interface Functions ---
+
+# Function to handle Text Processing
+def process_text_task(text_input: str, task_name: str, max_summary_len: int, min_summary_len: int, max_gen_tokens: int, num_gen_sequences: int, tts_lang: str):
+    """Handles various text-based AI tasks."""
+    if not text_input.strip():
+        return "Please enter some text.", None # Return None for audio output
+
+    kwargs = {}
+    if task_name == "summarization":
+        kwargs["max_length"] = max_summary_len
+        kwargs["min_length"] = min_summary_len
+    elif task_name == "text-generation":
+        kwargs["max_new_tokens"] = max_gen_tokens
+        kwargs["num_return_sequences"] = num_gen_sequences
+    elif task_name == "tts":
+        kwargs["lang"] = tts_lang
+
+    try:
+        logging.info(f"Processing text with task: {task_name}")
+        result = dispatcher.process(text_input, task=task_name, **kwargs)
+        
+        if task_name == "tts":
+            # For TTS, dispatcher.process returns a file path
+            if os.path.exists(result):
+                return "Speech generated successfully!", result # Return text message and audio file path
+            else:
+                return "TTS failed to generate audio.", None
+        else:
+            # For other text tasks, return the JSON representation of the result
+            return json.dumps(result, indent=2), None
+    except Exception as e:
+        logging.error(f"Error processing text: {e}")
+        return f"An error occurred: {e}", None
+
+# Function to handle File Processing
+def process_file_task(file_obj, task_name: str):
+    """Handles image, audio, PDF, and limited video processing."""
+    if file_obj is None:
+        return "Please upload a file."
+
+    # Gradio passes the file path directly for type="filepath"
+    file_path = file_obj 
+
+    try:
+        logging.info(f"Processing file '{file_path}' with task: {task_name}")
+        result = dispatcher.process(file_path, task=task_name)
+
+        if task_name == "automatic-speech-recognition":
+            return result.get('text', 'No transcription found.')
+        elif task_name == "video":
+            # Video analysis returns a dict with image and audio results
+            return f"Video Analysis Result:\nImage Analysis: {json.dumps(result.get('image_analysis'), indent=2)}\nAudio Analysis: {json.dumps(result.get('audio_analysis'), indent=2)}"
+        else:
+            return json.dumps(result, indent=2) # Use json.dumps for structured output
+
+    except NotImplementedError as e:
+        logging.error(f"Task not implemented: {e}")
+        return f"Task not fully implemented: {e}. Video processing is complex and requires system-level ffmpeg."
+    except ValueError as e:
+        logging.error(f"Value error processing file: {e}")
+        return f"Error processing file: {e}. Ensure the file type matches the selected task."
+    except Exception as e:
+        logging.error(f"An unexpected error occurred during file processing: {e}")
+        return f"An unexpected error occurred: {e}"
+
+# NEW: Function to handle Dataset Processing
+def process_dataset_task(dataset_name: str, subset_name: str, split: str, column_to_process: str, task: str, num_samples: int):
+    """
+    Processes a specified column from a Hugging Face dataset using the dispatcher.
+    """
+    if not dataset_name.strip() or not column_to_process.strip():
+        return "Please provide a Dataset Name and Column to Process."
+
+    # Define allowed tasks for dataset processing (based on what your dispatcher can handle)
+    allowed_dataset_tasks = [
+        "sentiment-analysis", "summarization", "text-generation", "image-classification",
+        "object-detection", "automatic-speech-recognition", "translation_en_to_fr"
+        # "pdf" and "video" are file-specific, not direct dataset column tasks
+    ]
+    if task not in allowed_dataset_tasks:
+        return f"Selected task '{task}' is not supported for dataset processing. Choose from: {', '.join(allowed_dataset_tasks)}"
+
+    try:
+        logging.info(f"Starting dataset processing for {dataset_name}/{subset_name} on column '{column_to_process}' with task '{task}'.")
+        results = dispatcher.process_dataset_from_hub(
+            dataset_name=dataset_name,
+            subset_name=subset_name,
+            split=split,
+            column_to_process=column_to_process,
+            task=task,
+            num_samples=num_samples
+        )
+        return json.dumps(results, indent=2) # Return results as pretty-printed JSON
+    except Exception as e:
+        logging.error(f"Error during dataset processing: {e}")
+        return f"An error occurred during dataset processing: {e}"
+
+
+# --- Gradio Interface Definition ---
+
+# Text Processing Tab
+text_tab_inputs = [
+    gr.Textbox(lines=8, label="Enter Text", placeholder="Type your text here for summarization, sentiment analysis, etc."),
+    gr.Dropdown(
+        ["sentiment-analysis", "summarization", "text-generation", "tts", "translation_en_to_fr"],
+        label="Select Text Task",
+        value="sentiment-analysis"
+    ),
+    gr.Slider(minimum=10, maximum=200, value=50, step=1, label="Max Summary Length (for Summarization)"),
+    gr.Slider(minimum=5, maximum=100, value=10, step=1, label="Min Summary Length (for Summarization)"),
+    gr.Slider(minimum=10, maximum=200, value=50, step=1, label="Max Generated Tokens (for Text Generation)"),
+    gr.Slider(minimum=1, maximum=3, value=1, step=1, label="Number of Sequences (for Text Generation)"),
+    gr.Dropdown(["en", "fr", "es"], label="TTS Language", value="en")
+]
+text_tab_outputs = [
+    gr.Textbox(label="Analysis Result / Generated Text"),
+    gr.Audio(label="Generated Speech (for TTS)", type="filepath")
+]
+text_interface = gr.Interface(
+    fn=process_text_task,
+    inputs=text_tab_inputs,
+    outputs=text_tab_outputs,
+    title="📝 Text Processing",
+    description="Perform various NLP tasks like sentiment analysis, summarization, text generation, and text-to-speech."
+)
+
+# File Processing Tab
+file_tab_inputs = [
+    gr.File(label="Upload File", type="filepath", file_types=[".pdf", ".mp3", ".wav", ".jpg", ".jpeg", ".png", ".mov", ".mp4", ".avi", ".mkv"]),
+    gr.Dropdown(
+        ["image-classification", "object-detection", "automatic-speech-recognition", "pdf", "video"],
+        label="Select File Task",
+        value="image-classification"
+    )
+]
+file_tab_outputs = gr.Textbox(label="File Processing Result")
+file_interface = gr.Interface(
+    fn=process_file_task,
+    inputs=file_tab_inputs,
+    outputs=file_tab_outputs,
+    title="📁 File Processing",
+    description="Upload an image, audio, PDF, or video file for AI analysis."
+)
+
+# Dataset Processing Tab
+dataset_tab_inputs = [
+    gr.Textbox(label="Hugging Face Dataset Name", placeholder="e.g., 'glue', 'mnist', 'common_voice'"),
+    gr.Textbox(label="Dataset Subset (Optional)", placeholder="e.g., 'sst2' for 'glue', 'en' for 'common_voice'"),
+    gr.Dropdown(["train", "validation", "test"], label="Dataset Split", value="train"),
+    gr.Textbox(label="Column to Process", placeholder="e.g., 'sentence', 'image', 'audio'"),
+    gr.Dropdown(
+        ["sentiment-analysis", "summarization", "text-generation", "image-classification",
+         "object-detection", "automatic-speech-recognition", "translation_en_to_fr"],
+        label="AI Task for Dataset Column",
+        value="sentiment-analysis"
+    ),
+    gr.Slider(minimum=1, maximum=20, value=5, step=1, label="Number of Samples to Process (max 20 for demo)"),
+]
+dataset_tab_outputs = gr.Textbox(label="Dataset Processing Results (JSON)")
+dataset_interface = gr.Interface(
+    fn=process_dataset_task,
+    inputs=dataset_tab_inputs,
+    outputs=dataset_tab_outputs,
+    title="📊 Dataset Processing",
+    description="Load a dataset from Hugging Face Hub and apply an AI task to a specified column (processes a limited number of samples)."
+)
+
+
+# Combine all interfaces into a Tabbed Interface
+demo = gr.TabbedInterface(
+    [text_interface, file_interface, dataset_interface], # Include all three interfaces
+    ["Text Analyzer", "File Analyzer", "Dataset Analyzer"] # Tab titles
+)
+
+# --- Launch the Gradio App ---
+if __name__ == "__main__":
+    # For local testing, use demo.launch()
+    # For Hugging Face Spaces, ensure all dependencies are in requirements.txt
+    demo.launch(share=True) # share=True creates a public link for easy sharing (temporary)