feat: push

app.py

@@ -0,0 +1,356 @@
+import os
+import shutil
+from datetime import datetime
+import gradio as gr
+import pandas as pd
+import time
+import random
+import uuid
+
+def save_uploaded_files(files, session_id):
+    """Save uploaded files to telemetry directory with session ID."""
+    save_dir = os.path.join("telemetry_files", session_id)
+    os.makedirs(save_dir, exist_ok=True)
+    
+    saved_paths = []
+    for file in files:
+        if file is not None:
+            filename = os.path.basename(file.name)
+            save_path = os.path.join(save_dir, filename)
+            shutil.copy2(file.name, save_path)
+            saved_paths.append(save_path)
+    
+    return saved_paths
+
+def mock_process_documents(files, chunk_size, num_questions, question_types, complexity_types, 
+                         difficulty, selected_models):
+    """Mock processing function that simulates document processing."""
+    time.sleep(5)  # Simulate 5 seconds of processing
+    
+    # Create session ID and save files
+    session_id = f"{datetime.now().strftime('%Y%m%d_%H%M%S')}_{uuid.uuid4().hex[:8]}"
+    saved_files = save_uploaded_files(files, session_id)
+    
+    data = []
+    for _ in range(num_questions):
+        # Since question_types is now a list of selected values, we can use it directly
+        question_type = random.choice(question_types)
+        complexity = random.choice(complexity_types)
+        model = random.choice(selected_models)
+        
+        question = f"[{complexity}] Sample {question_type} question {_+1} (Difficulty: {difficulty:.1f}, Model: {model})"
+        answer = f"This is a sample answer for question {_+1}. Files processed: {', '.join(saved_files)}"
+        data.append({
+            "question_type": question_type,
+            "complexity": complexity,
+            "question": question,
+            "answer": answer,
+            "model": model,
+            "difficulty": difficulty
+        })
+    
+    return pd.DataFrame(data)
+
+def generate_csv_file(df, session_id):
+    """Generate and save CSV file for the results."""
+    if df.empty:
+        return None
+    
+    # Create session directory
+    session_dir = os.path.join("telemetry_files", session_id)
+    os.makedirs(session_dir, exist_ok=True)
+    
+    # Save CSV
+    csv_path = os.path.join(session_dir, "results.csv")
+    df.to_csv(csv_path, index=False)
+    return csv_path
+
+def process_files(
+    input_files, chunk_size, num_questions,
+    question_types_dict, complexity_types_dict,
+    difficulty_level, model_selection_dict
+):
+    """Process files with the given configuration."""
+    if not input_files:
+        return pd.DataFrame(), "Error: No files uploaded", None
+    
+    # Convert checkbox groups to lists of selected values
+    question_types = question_types_dict
+    complexity_types = complexity_types_dict
+    selected_models = model_selection_dict
+    
+    if not question_types or not complexity_types or not selected_models:
+        return pd.DataFrame(), "Error: Please select at least one option from each category", None
+    
+    start_time = time.time()
+    results_df = mock_process_documents(
+        input_files, chunk_size, num_questions,
+        question_types, complexity_types,
+        difficulty_level, selected_models
+    )
+    processing_time = time.time() - start_time
+    
+    # Generate CSV file
+    session_id = f"{datetime.now().strftime('%Y%m%d_%H%M%S')}_{uuid.uuid4().hex[:8]}"
+    csv_path = generate_csv_file(results_df, session_id)
+    
+    return (
+        results_df, 
+        f"Processing completed in {processing_time:.2f} seconds",
+        csv_path if csv_path else None
+    )
+
+# Create custom theme
+theme = gr.themes.Base(
+    primary_hue="blue",
+    secondary_hue="indigo",
+    neutral_hue="slate",
+    font=gr.themes.GoogleFont("Inter"),
+    radius_size=gr.themes.sizes.radius_sm,
+).set(
+    body_background_fill="*neutral_50",
+    body_background_fill_dark="*neutral_950",
+    button_primary_background_fill="*primary_600",
+    button_primary_background_fill_hover="*primary_700",
+    button_primary_text_color="white",
+    button_primary_text_color_dark="white",
+    block_label_text_weight="600",
+    block_title_text_weight="600",
+    input_background_fill="white",
+    input_background_fill_dark="*neutral_800",
+    input_border_color="*neutral_200",
+    input_border_color_dark="*neutral_700",
+)
+
+# Create the Gradio interface
+with gr.Blocks(
+    title="Yourbench - Dynamic Question Generation",
+    theme=theme,
+    css="""
+        .gradio-container {max-width: 1400px !important; margin-left: auto; margin-right: auto}
+        .contain { display: flex; flex-direction: column; }
+        .contain > * { flex: 1}
+        .gap { margin-top: 1rem !important }
+        footer {display: none !important}
+        .citation-box { 
+            background-color: #f8fafc;
+            border: 1px solid #e2e8f0;
+            border-radius: 0.5rem;
+            padding: 1rem;
+            margin-top: 2rem;
+            font-family: monospace;
+        }
+        .citation-box pre {
+            margin: 0;
+            white-space: pre-wrap;
+        }
+        .main-panel { min-height: 600px }
+        .output-panel { min-height: 400px }
+        .checkbox-group { max-height: 200px; overflow-y: auto }
+        .model-select { max-height: 150px }
+        .download-btn { margin-top: 1rem !important }
+    """
+) as demo:
+    # Header with description
+    gr.Markdown("""
+    # 📚 Yourbench: Dynamic Question Generation Tool
+    
+    Generate high-quality questions and answers from your documents using state-of-the-art language models.
+    This tool helps create diverse question types with varying complexity levels, perfect for educational
+    assessment and content understanding.
+    """)
+    
+    with gr.Row():
+        # Left column for configuration
+        with gr.Column(scale=2, elem_classes="main-panel"):
+            # Document Upload Section
+            with gr.Group():
+                gr.Markdown("### 📄 Document Upload")
+                input_files = gr.File(
+                    label="Upload Documents (PDF/TXT)",
+                    file_types=[".txt", ".pdf"],
+                    file_count="multiple",
+                    elem_id="file_upload",
+                    scale=2
+                )
+            
+            # Core Parameters Section
+            with gr.Group():
+                gr.Markdown("### ⚙️ Core Parameters")
+                with gr.Row():
+                    chunk_size = gr.Slider(
+                        minimum=100,
+                        maximum=1000,
+                        value=500,
+                        step=50,
+                        label="Chunk Size",
+                        info="Number of tokens per chunk",
+                        elem_id="chunk_size"
+                    )
+                    num_questions = gr.Slider(
+                        minimum=1,
+                        maximum=20,
+                        value=5,
+                        step=1,
+                        label="Number of Questions",
+                        info="How many questions to generate",
+                        elem_id="num_questions"
+                    )
+                
+                difficulty_level = gr.Slider(
+                    minimum=1,
+                    maximum=5,
+                    value=3,
+                    step=0.1,
+                    label="Average Difficulty",
+                    info="1: Easy, 5: Very Hard",
+                    elem_id="difficulty"
+                )
+            
+            with gr.Row():
+                # Question Types Section
+                with gr.Column():
+                    gr.Markdown("### 🎯 Question Types")
+                    question_types_dict = gr.CheckboxGroup(
+                        choices=[
+                            "Analytical", "Application Based", "Conceptual",
+                            "Counterfactual", "Factual", "Open Ended",
+                            "True False", "False Premise", "Clarification",
+                            "Edge Case"
+                        ],
+                        value=["Analytical", "Factual", "Conceptual", "Application Based"],
+                        label="Select Types",
+                        elem_id="question_types",
+                        elem_classes="checkbox-group"
+                    )
+                
+                # Complexity and Models Section
+                with gr.Column():
+                    with gr.Group():
+                        gr.Markdown("### 🔄 Complexity")
+                        complexity_types_dict = gr.CheckboxGroup(
+                            choices=["Single Shot", "Multi Hop"],
+                            value=["Single Shot", "Multi Hop"],
+                            label="Select Complexity",
+                            elem_id="complexity_types"
+                        )
+                    
+                    with gr.Group():
+                        gr.Markdown("### 🤖 Models")
+                        model_selection_dict = gr.CheckboxGroup(
+                            choices=[
+                                "Mistral Large",
+                                "Llama-3 70B",
+                                "GPT-4",
+                                "Claude 3.5 Sonnet",
+                                "Gemini Pro"
+                            ],
+                            value=["Mistral Large", "GPT-4", "Claude 3.5 Sonnet"],
+                            label="Select Models",
+                            elem_id="models",
+                            elem_classes="model-select"
+                        )
+            
+            process_btn = gr.Button(
+                "🚀 Generate Questions",
+                variant="primary",
+                size="lg",
+                elem_id="generate_btn"
+            )
+        
+        # Right column for outputs
+        with gr.Column(scale=3, elem_classes="output-panel"):
+            with gr.Group():
+                gr.Markdown("### 📊 Generated Questions")
+                output_status = gr.Textbox(
+                    label="Status",
+                    elem_id="status"
+                )
+                output_table = gr.Dataframe(
+                    headers=["question_type", "complexity", "question", "answer", "model", "difficulty"],
+                    label="Questions and Answers",
+                    elem_id="results_table",
+                    wrap=True
+                )
+                csv_output = gr.File(
+                    label="Download Results",
+                    elem_id="csv_download",
+                    elem_classes="download-btn",
+                    interactive=False
+                )
+    
+    # Instructions Section
+    with gr.Accordion("📝 Instructions", open=False):
+        gr.Markdown("""
+        1. **Upload Documents**: Support for .txt and .pdf files
+        2. **Configure Parameters**:
+           - Set chunk size for document processing
+           - Choose number of questions to generate
+           - Adjust difficulty level (1: Easy to 5: Very Hard)
+        3. **Select Question Types**: Choose from various question categories
+        4. **Set Complexity**: Single-shot or multi-hop reasoning
+        5. **Choose Models**: Select AI models for ensemble generation
+        6. Click '🚀 Generate Questions' to start
+        7. Download results as CSV for further use
+        """)
+    
+    # Citation Section
+    gr.Markdown("""
+    ### 📚 Citation
+    If you find this work helpful in your research or applications, please cite:
+    """)
+    
+    with gr.Group(elem_classes="citation-box"):
+        gr.Markdown("""```bibtex
+@misc{yourbench2024,
+    title={Yourbench: A Dynamic Question Generation Framework for Document Understanding},
+    author={Your Team},
+    year={2024},
+    publisher={GitHub},
+    journal={GitHub repository},
+    howpublished={\\url{https://github.com/yourbench/yourbench}},
+}
+```""")
+    
+    # API Information
+    gr.Markdown("""
+    ### 🔌 API Usage
+    
+    This tool can be used programmatically through its API. Here's how to interact with it:
+    
+    ```python
+    import gradio_client
+    
+    client = gradio_client.Client("YOUR_SPACE_URL")
+    
+    result = client.predict(
+        ["document.pdf"],                      # Input files
+        500,                                   # Chunk size
+        5,                                     # Number of questions
+        ["Analytical", "Factual"],             # Question types
+        ["Single Shot"],                       # Complexity types
+        3.0,                                   # Difficulty level
+        ["GPT-4", "Claude 3.5 Sonnet"],        # Models
+        api_name="/predict"
+    )
+    ```
+    
+    Replace `YOUR_SPACE_URL` with the actual deployment URL. The API endpoint accepts the same parameters
+    as the web interface and returns a tuple containing the results DataFrame, status message, and CSV file path.
+    """)
+    
+    
+    # Event handler
+    process_btn.click(
+        process_files,
+        inputs=[
+            input_files, chunk_size, num_questions,
+            question_types_dict, complexity_types_dict,
+            difficulty_level, model_selection_dict
+        ],
+        outputs=[output_table, output_status, csv_output]
+    )
+
+if __name__ == "__main__":
+    demo.launch(share=True)
+