app.py

import gradio as gr
import os
import json

# Directory to store submissions
DATA_DIR = "submissions"
os.makedirs(DATA_DIR, exist_ok=True)

# Predefined task types
TASK_TYPES = ["Classification", "Regression", "Translation"]

# Function to handle task submission
def submit_task(task_type, description, yaml_text):
    if not yaml_text.strip():
        return "YAML/Text input cannot be empty."

    # Prepare data
    data = {
        "task_type": task_type,
        "description": description,
        "yaml": yaml_text
    }
    file_path = os.path.join(DATA_DIR, f"{task_type}_{len(os.listdir(DATA_DIR))}.json")
    
    try:
        with open(file_path, "w") as f:
            json.dump(data, f)
        print(f"Saved file: {file_path}, Contents: {data}")  # Debug line
        return f"Task submitted successfully under type '{task_type}'!"
    except Exception as e:
        return f"Error saving task: {e}"

# Function to get tasks by type
def get_tasks_by_type(task_type):
    tasks = []
    for file in os.listdir(DATA_DIR):
        # Skip non-JSON files
        if not file.endswith(".json"):
            continue
        
        try:
            with open(os.path.join(DATA_DIR, file), "r") as f:
                data = json.load(f)
                # Filter by task type
                if data.get("task_type") == task_type:
                    print(f"Retrieved task: {data}")  # Debug line
                    tasks.append(data)
        except (json.JSONDecodeError, KeyError):
            # Skip invalid or corrupted files
            print(f"Skipped invalid file: {file}")
    return tasks

# Function to dynamically add a new task type
def add_new_task_type(new_type):
    if new_type and new_type not in TASK_TYPES:
        TASK_TYPES.append(new_type)
        return gr.update(choices=TASK_TYPES), f"Task type '{new_type}' added successfully!"
    return gr.update(choices=TASK_TYPES), "Task type already exists or invalid input."

# Function to switch tabs
def switch_tab(tab_name):
    return gr.Tabs.update(visible_tab=tab_name)

# Gradio App
with gr.Blocks() as app:
    gr.Markdown("# Task Configuration Sharing Space")

    with gr.Tabs() as tabs:
        with gr.Tab("Submit Task"):
            gr.Markdown("## Submit a New Task Configuration")
            
            # Input fields for the task submission
            task_type_input = gr.Dropdown(
                label="Task Type",
                choices=TASK_TYPES,
                value="Classification",
                interactive=True
            )
            new_task_input = gr.Textbox(
                label="Add New Task Type",
                placeholder="Enter a new task type",
                interactive=True
            )
            add_task_button = gr.Button("Add Task Type")
            add_task_status = gr.Textbox(label="Status", interactive=False)

            description_input = gr.Textbox(
                label="Task Description",
                placeholder="Provide a brief description of the task.",
                lines=3
            )
            yaml_input = gr.Textbox(
                label="YAML/Text Input",
                placeholder="Paste your YAML or text configuration here.",
                lines=10
            )
            submit_button = gr.Button("Submit Task")
            go_to_view_tab = gr.Button("Go to View Tasks")
            submission_status = gr.Textbox(label="Status", interactive=False)

            # Handle adding new task type
            add_task_button.click(
                add_new_task_type,
                inputs=[new_task_input],
                outputs=[task_type_input, add_task_status]
            )

            # Handle task submission
            submit_button.click(
                submit_task,
                inputs=[task_type_input, description_input, yaml_input],
                outputs=[submission_status]
            )

            # Button to switch to "View Tasks" tab
            go_to_view_tab.click(
                lambda: gr.Tabs.update(visible_tab="View Tasks"),
                inputs=None,
                outputs=[tabs]
            )

        with gr.Tab("View Tasks"):
            gr.Markdown("## View Submitted Tasks")

            task_type_filter = gr.Dropdown(
                label="Filter by Task Type",
                choices=TASK_TYPES,
                value="Classification",
                interactive=True
            )
            view_button = gr.Button("View Tasks")
            task_table = gr.Dataframe(headers=["Task Type", "Description", "YAML/Text"], interactive=False)
            go_to_submit_tab = gr.Button("Go to Submit Task")

            # Function to filter tasks by type
            def filter_tasks(task_type):
                tasks = get_tasks_by_type(task_type)
                for task in tasks:  # Debug line
                    print(f"Task to display: {task}")  # Debug line
                return [{"Task Type": t["task_type"], "Description": t["description"], "YAML/Text": t["yaml"]} for t in tasks]

            # Handle task filtering
            view_button.click(
                filter_tasks,
                inputs=[task_type_filter],
                outputs=[task_table]
            )

            # Button to switch to "Submit Task" tab
            go_to_submit_tab.click(
                lambda: gr.Tabs.update(visible_tab="Submit Task"),
                inputs=None,
                outputs=[tabs]
            )

app.launch()