Upload 5 files

ui/__init__.py

@@ -0,0 +1,2 @@
+"""UI package for moderation interface."""
+

ui/sidebar.py

@@ -0,0 +1,35 @@
+"""Sidebar UI component with app description and authentication."""
+
+import os
+import sys
+
+import gradio as gr
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+
+def build_sidebar() -> dict:
+    """Build the sidebar UI with app description and login."""
+    with gr.Sidebar():
+        gr.Markdown("## About")
+        gr.Markdown(
+            """
+            This interface allows you to test moderation models with custom content policies.
+            
+            **🧪 Testing Tab**: Enter content to test against your policy. View model predictions, categories, reasoning traces, and raw responses.
+            
+            **📋 Policy Definition Tab**: Define your content policy by uploading a markdown file, entering it manually, or selecting from preset examples.
+            
+            **⚙️ Configuration Tab**: Select models, adjust generation parameters, and customize system prompts and response formats.
+            """
+        )
+        
+        gr.Markdown("---")
+        gr.Markdown("### Authentication")
+        login_button = gr.LoginButton(value="Log in to Hugging Face")
+        gr.Markdown("*Log in with your Hugging Face to be able to query models through Inference Providers.*")
+    
+    return {
+        "login_button": login_button,
+    }
+

ui/tab_config.py

@@ -0,0 +1,106 @@
+"""Configuration tab UI components."""
+
+import os
+import sys
+
+import gradio as gr
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from utils.constants import MODELS, REASONING_EFFORTS, RESPONSE_FORMAT
+from utils.model_interface import extract_model_id, get_default_system_prompt
+
+
+def build_config_tab() -> dict:
+    """Build the configuration tab UI."""
+    with gr.Tab("⚙️ Configuration"):
+        gr.Markdown("### Model Selection")
+
+        model_choices = [f"{m['name']} ({m['id']})" for m in MODELS]
+        model_dropdown = gr.Dropdown(label="Model", choices=model_choices, value=model_choices[0])
+        reasoning_effort = gr.Dropdown(label="Reasoning Effort (GPT-OSS only)", choices=REASONING_EFFORTS, value="Low", visible=True)
+
+        def update_reasoning_visibility(choice):
+            """Update reasoning effort visibility based on selected model."""
+            if not choice:
+                return gr.update(visible=False)
+            model_id = extract_model_id(choice)
+            return gr.update(visible=model_id.startswith("openai/gpt-oss") if model_id else False)
+
+        def update_system_prompt(model_choice, reasoning_effort_val):
+            """Update system prompt when model or reasoning effort changes."""
+            if not model_choice:
+                return ""
+            model_id = extract_model_id(model_choice)
+            return get_default_system_prompt(model_id, reasoning_effort_val)
+
+        # Initialize system prompt with default for first model
+        initial_model_id = extract_model_id(model_choices[0])
+        initial_system_prompt = get_default_system_prompt(initial_model_id, "Low")
+
+        gr.Markdown("---")
+        gr.Markdown("### System Prompt & Response Format")
+        gr.Markdown("*Edit the prompts below. System prompt varies by model type; response format is used for GPT-OSS developer channel and Qwen.*")
+
+        with gr.Row():
+            with gr.Column():
+                system_prompt_textbox = gr.Textbox(
+                    label="System Prompt",
+                    placeholder="System prompt will be auto-generated based on model...",
+                    lines=10,
+                    value=initial_system_prompt,
+                    interactive=True,
+                )
+            
+            with gr.Column():
+                response_format_textbox = gr.Textbox(
+                    label="Response Format",
+                    placeholder="Response format instructions...",
+                    lines=10,
+                    value=RESPONSE_FORMAT,
+                    interactive=True,
+                )
+        
+        gr.Markdown("*Edit the prompts above. Values are used directly when running tests.*")
+
+        def update_on_model_change(choice, reasoning_effort_val):
+            """Update both reasoning visibility and system prompt when model changes."""
+            visibility_update = update_reasoning_visibility(choice)
+            system_prompt_update = update_system_prompt(choice, reasoning_effort_val)
+            return visibility_update, system_prompt_update
+
+        # Update reasoning visibility and system prompt when model changes
+        model_dropdown.change(
+            update_on_model_change,
+            inputs=[model_dropdown, reasoning_effort],
+            outputs=[reasoning_effort, system_prompt_textbox],
+        )
+
+        # Update system prompt when reasoning effort changes (for GPT-OSS)
+        def update_on_reasoning_change(choice, effort):
+            """Update system prompt when reasoning effort changes."""
+            if not choice:
+                return ""
+            return update_system_prompt(choice, effort)
+        
+        reasoning_effort.change(
+            update_on_reasoning_change,
+            inputs=[model_dropdown, reasoning_effort],
+            outputs=system_prompt_textbox,
+        )
+
+        gr.Markdown("---")
+        with gr.Accordion("Generation Parameters", open=False):
+            max_tokens = gr.Number(label="Max Tokens", value=4096, precision=0)
+            temperature = gr.Slider(label="Temperature", minimum=0.0, maximum=1.0, value=0.1, step=0.1)
+            top_p = gr.Slider(label="Top P", minimum=0.0, maximum=1.0, value=0.9, step=0.1)
+
+    return {
+        "model_dropdown": model_dropdown,
+        "reasoning_effort": reasoning_effort,
+        "system_prompt_textbox": system_prompt_textbox,
+        "response_format_textbox": response_format_textbox,
+        "max_tokens": max_tokens,
+        "temperature": temperature,
+        "top_p": top_p,
+    }

ui/tab_policy.py

@@ -0,0 +1,70 @@
+"""Policy definition tab UI components."""
+
+import os
+import sys
+
+import gradio as gr
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from utils.helpers import load_policy_from_file, load_preset_policy
+
+
+def build_policy_tab(base_dir: str) -> dict:
+    """Build the policy definition tab UI."""
+    with gr.Tab("📋 Policy Definition"):
+        input_method = gr.Radio(label="Input Method", choices=["Upload Markdown", "Enter Manually", "Select Preset"], value="Select Preset")
+
+        upload_file = gr.File(label="Upload Markdown File", file_types=[".md"], visible=False)
+        upload_preview = gr.Textbox(label="File Preview", lines=10, interactive=False, visible=False)
+        load_upload_btn = gr.Button("Load Policy", visible=False)
+
+        manual_text = gr.Textbox(label="Policy Text", placeholder="Enter policy markdown...", lines=20, visible=False)
+        save_manual_btn = gr.Button("Save Policy", visible=False)
+
+        preset_dropdown = gr.Dropdown(
+            label="Select Preset", choices=["Hate Speech Policy", "Violence Policy", "Toxicity Policy"], value="Hate Speech Policy", visible=True
+        )
+        preset_preview = gr.Markdown(value="*Select a preset to preview*", visible=True)
+        load_preset_btn = gr.Button("Load Preset", visible=True)
+
+        gr.Markdown("---")
+        gr.Markdown("### Current Policy")
+        current_policy = gr.Markdown(value="*No policy loaded*")
+        clear_policy_btn = gr.Button("Clear Policy", variant="secondary")
+
+        current_policy_state = gr.State(value="")
+
+        def update_ui(method):
+            return (
+                gr.update(visible=(method == "Upload Markdown")),
+                gr.update(visible=(method == "Upload Markdown")),
+                gr.update(visible=(method == "Upload Markdown")),
+                gr.update(visible=(method == "Enter Manually")),
+                gr.update(visible=(method == "Enter Manually")),
+                gr.update(visible=(method == "Select Preset")),
+                gr.update(visible=(method == "Select Preset")),
+                gr.update(visible=(method == "Select Preset")),
+            )
+
+        input_method.change(update_ui, inputs=input_method, outputs=[upload_file, upload_preview, load_upload_btn, manual_text, save_manual_btn, preset_dropdown, preset_preview, load_preset_btn])
+
+        # Policy loading handlers
+        load_preset_btn.click(
+            lambda name: load_preset_policy(name, base_dir),
+            inputs=preset_dropdown,
+            outputs=[current_policy_state, current_policy],
+        )
+        load_upload_btn.click(
+            lambda f: load_policy_from_file(f.name) if f else ("", ""),
+            inputs=upload_file,
+            outputs=[current_policy_state, current_policy],
+        )
+        upload_file.change(lambda f: open(f.name).read() if f else "", inputs=upload_file, outputs=upload_preview)
+        save_manual_btn.click(lambda t: (t, t), inputs=manual_text, outputs=[current_policy_state, current_policy])
+        clear_policy_btn.click(lambda: ("", "*No policy loaded*"), outputs=[current_policy_state, current_policy])
+
+    return {
+        "current_policy_state": current_policy_state,
+        "current_policy": current_policy,
+    }

ui/tab_testing.py

@@ -0,0 +1,179 @@
+"""Testing tab UI components."""
+
+import os
+import sys
+
+import gradio as gr
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+import json
+
+from utils.constants import MODELS, TEST_EXAMPLES
+from utils.model_interface import extract_model_id, get_model_info
+
+
+def parse_json_response(response: str) -> dict:
+    """Parse JSON response, handling code blocks."""
+    response = response.strip()
+    try:
+        if "```json" in response:
+            response = response.split("```json")[1].split("```")[0]
+        elif "```" in response:
+            response = response.split("```")[1].split("```")[0]
+        return json.loads(response)
+    except json.JSONDecodeError:
+        return {"label": -1, "categories": []}
+
+
+def format_model_info(model_choice, reasoning_effort) -> str:
+    """Format model information markdown."""
+    if not model_choice:
+        return "*Select a model in Configuration tab*"
+    
+    model_id = extract_model_id(model_choice)
+    if not model_id:
+        return "*Select a model in Configuration tab*"
+    
+    model_info = get_model_info(model_id)
+    
+    if not model_info:
+        return f"*Model: {model_id}*"
+    
+    model_name = model_info.get("name", model_id)
+    is_thinking = model_info.get("is_thinking", False)
+    supports_reasoning_level = model_info.get("supports_reasoning_level", False)
+    
+    # Handle None or invalid reasoning_effort
+    reasoning_effort_val = reasoning_effort if reasoning_effort else "Low"
+    
+    info_lines = [
+        f"**Model:** {model_name}",
+        f"- **Thinking Model:** {'Yes' if is_thinking else 'No'}",
+        f"- **Supports Reasoning Level:** {'Yes' if supports_reasoning_level else 'No'}",
+    ]
+    
+    if supports_reasoning_level:
+        info_lines.append(f"- **Reasoning Effort:** {reasoning_effort_val}")
+    
+    return "\n".join(info_lines)
+
+def format_reasoning_info(model_choice, reasoning_text) -> tuple[str, bool]:
+    """Format reasoning info markdown and visibility."""
+    if not model_choice:
+        return "", False
+    
+    model_id = extract_model_id(model_choice)
+    model_info = get_model_info(model_id)
+    
+    if not model_info:
+        return "", False
+    
+    is_thinking = model_info.get("is_thinking", False)
+    
+    # For non-thinking models, always show the message
+    if not is_thinking:
+        return "*This model does not provide reasoning traces.*", True
+    
+    # For thinking models, only show info if there's no reasoning text
+    if not reasoning_text or not reasoning_text.strip():
+        return "", False
+    
+    return "", False
+
+
+def format_test_result(result: dict) -> tuple[str, dict, str, str, str]:
+    """
+    Format test result for display.
+    
+    Returns:
+        Tuple of (label_text, parsed_json, categories_text, reasoning_text, raw_response)
+    """
+    raw_content = result.get("content", "")
+    parsed = parse_json_response(raw_content)
+    label = parsed.get("label", -1)
+    categories = parsed.get("categories", [])
+
+    label_text = (
+        "## ❌ Policy Violation Detected" if label == 1
+        else "## ✅ No Policy Violation" if label == 0
+        else "## ⚠️ Unable to determine label"
+    )
+
+    if categories and len(categories) > 0:
+        cat_text = "### Categories:\n\n"
+        for cat in categories:
+            category_name = cat.get('category', 'Unknown')
+            reasoning_text = cat.get('reasoning', 'No reasoning provided')
+            policy_source = cat.get('policy_source', '')
+            
+            cat_text += f"- **Category:** {category_name}\n"
+            cat_text += f"- **Explanation:** {reasoning_text}\n"
+            if policy_source:
+                cat_text += f"- **Policy Source:** {policy_source}\n"
+            cat_text += "\n\n"
+    else:
+        cat_text = "*No categories found in response*\n\n"
+        cat_text += "This output expects a valid JSON response, as specified for example in the default prompt.\n\n"
+        cat_text += "The raw response can be seen in the Model Response section below."
+
+    reasoning = result.get("reasoning", "")
+    
+    # Format raw response for display
+    raw_response_text = f"```\n{raw_content}\n```"
+    
+    return label_text, parsed, cat_text, reasoning or "", raw_response_text
+
+
+def build_testing_tab() -> dict:
+    """Build the testing tab UI and set up simple handlers."""
+    with gr.Tab("🧪 Testing"):
+        with gr.Row():
+            with gr.Column(scale=1):
+                gr.Markdown("### Input")
+                with gr.Group():
+                    test_input = gr.Textbox(label="Test Content", placeholder="Enter content to test...", lines=5)
+                    example_dropdown = gr.Dropdown(label="Load Example", choices=list(TEST_EXAMPLES.keys()))
+                    load_example_btn = gr.Button("Load Example", variant="secondary")
+                run_test_btn = gr.Button("Run Test", variant="primary")
+                # Initialize with default model info
+                initial_model = f"{MODELS[0]['name']} ({MODELS[0]['id']})"
+                initial_info_lines = [
+                    f"**Model:** {MODELS[0]['name']}",
+                    f"- **Thinking Model:** {'Yes' if MODELS[0]['is_thinking'] else 'No'}",
+                    f"- **Supports Reasoning Level:** {'Yes' if MODELS[0]['supports_reasoning_level'] else 'No'}",
+                ]
+                if MODELS[0]['supports_reasoning_level']:
+                    initial_info_lines.append("- **Reasoning Effort:** Low")
+                model_info_display = gr.Markdown(value="\n".join(initial_info_lines))
+
+            with gr.Column(scale=2):
+                gr.Markdown("### Results")
+                label_display = gr.Markdown(value="*Run a test to see results*")
+                with gr.Accordion("Categories & Reasoning", open=True):
+                    categories_display = gr.Markdown(value="*No categories yet*")
+                with gr.Accordion("Model Response", open=False):
+                    model_response_display = gr.Markdown(value="*No response yet*")
+                with gr.Accordion("Reasoning Trace", open=False):
+                    reasoning_info = gr.Markdown(value="", visible=False)
+                    reasoning_display = gr.Code(label="", language=None, value="", visible=False)
+
+        # Simple handlers that don't need cross-tab coordination
+        load_example_btn.click(
+            lambda name: TEST_EXAMPLES.get(name, ""),
+            inputs=example_dropdown,
+            outputs=test_input,
+        )
+
+    return {
+        "test_input": test_input,
+        "example_dropdown": example_dropdown,
+        "load_example_btn": load_example_btn,
+        "run_test_btn": run_test_btn,
+        "model_info_display": model_info_display,
+        "label_display": label_display,
+        "categories_display": categories_display,
+        "model_response_display": model_response_display,
+        "reasoning_info": reasoning_info,
+        "reasoning_display": reasoning_display,
+    }