Convert Flask to Gradio

Dockerfile

@@ -37,8 +37,8 @@ RUN python -c "from transformers import AutoTokenizer, AutoModelForCausalLM; \
 # ✅ Ensure cache directory is writable after model download
 RUN chmod -R 777 /app/cache
 
-# ✅ Expose correct port
+# ✅ Expose Gradio port
 EXPOSE 7860
 
-# ✅ Run app
-CMD ["gunicorn", "--bind", "0.0.0.0:7860", "--workers", "1", "--timeout", "120", "app:app"]
+# ✅ Run Gradio app directly (no need for gunicorn)
+CMD ["python", "app.py"]

app.py

@@ -1,6 +1,4 @@
-from flask import Flask, request, jsonify
-from flask_cors import CORS
-from model.generate import generate_test_cases, get_generator, monitor_memory
+import gradio as gr
 import os
 import logging
 import gc
@@ -8,21 +6,16 @@ import psutil
 from functools import wraps
 import time
 import threading
+import json
+from model.generate import generate_test_cases, get_generator, monitor_memory
 
-# Configure logging for Railway
+# Configure logging
 logging.basicConfig(
     level=logging.INFO,
     format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
 )
 logger = logging.getLogger(__name__)
 
-app = Flask(__name__)
-CORS(app)
-
-# Configuration for Railway
-app.config['JSON_SORT_KEYS'] = False
-app.config['JSONIFY_PRETTYPRINT_REGULAR'] = False  # Reduce response size
-
 # Thread-safe initialization
 _init_lock = threading.Lock()
 _initialized = False
@@ -32,7 +25,7 @@ def init_model():
     try:
         # Skip AI model loading in low memory environments
         memory_mb = psutil.Process().memory_info().rss / 1024 / 1024
-        if memory_mb > 200 or os.environ.get('RAILWAY_ENVIRONMENT'):
+        if memory_mb > 200 or os.environ.get('HUGGINGFACE_SPACE'):
             logger.info("⚠️ Skipping AI model loading due to memory constraints")
             logger.info("🔧 Using template-based generation mode")
             return True
@@ -76,10 +69,10 @@ def smart_memory_monitor(func):
             return result
         except Exception as e:
             logger.error(f"❌ Error in {func.__name__}: {str(e)}")
-            return jsonify({
+            return {
                 "error": "Internal server error occurred",
                 "message": "Please try again or contact support"
-            }), 500
+            }
         finally:
             final_memory = psutil.Process().memory_info().rss / 1024 / 1024
             execution_time = time.time() - start_time
@@ -99,7 +92,7 @@ def ensure_initialized():
     if not _initialized:
         with _init_lock:
             if not _initialized:
-                logger.info("🚀 Flask app starting up on Railway...")
+                logger.info("🚀 Gradio app starting up on Hugging Face Spaces...")
                 success = init_model()
                 if success:
                     logger.info("✅ Startup completed successfully")
@@ -107,71 +100,21 @@ def ensure_initialized():
                     logger.warning("⚠️ Model initialization failed, using template mode")
                 _initialized = True
 
-@app.before_request
-def before_request():
-    """Initialize model on first request (Flask 2.2+ compatible)"""
-    ensure_initialized()
+# Initialize on startup
+ensure_initialized()
 
-@app.route('/')
-def home():
-    """Health check endpoint with system status"""
-    health_data = check_health()
-    try:
-        generator = get_generator()
-        model_info = generator.get_model_info()
-    except Exception:
-        model_info = {
-            "model_name": "Template-Based Generator",
-            "status": "template_mode",
-            "optimization": "memory_safe"
-        }
-
-    return jsonify({
-        "message": "AI Test Case Generator Backend is running",
-        "status": health_data["status"],
-        "memory_usage": health_data["memory_usage"],
-        "model": {
-            "name": model_info["model_name"],
-            "status": model_info["status"],
-            "optimization": model_info.get("optimization", "standard")
-        },
-        "version": "1.0.0-railway-optimized"
-    })
-
-@app.route('/health')
-def health():
-    """Dedicated health check for Railway monitoring"""
-    health_status = check_health()
-    try:
-        generator = get_generator()
-        model_info = generator.get_model_info()
-        model_loaded = model_info["status"] == "loaded"
-    except Exception:
-        model_loaded = False
-
-    return jsonify({
-        "status": health_status["status"],
-        "memory": health_status["memory_usage"],
-        "model_loaded": model_loaded,
-        "uptime": "ok"
-    })
-
-@app.route('/generate_test_cases', methods=['POST'])
 @smart_memory_monitor
-def generate():
-    """Generate test cases with enhanced error handling"""
-    if not request.is_json:
-        return jsonify({"error": "Request must be JSON"}), 400
-
-    data = request.get_json()
-    if not data:
-        return jsonify({"error": "No JSON data provided"}), 400
-
-    srs_text = data.get('srs', '').strip()
-
-    if not srs_text:
-        return jsonify({"error": "No SRS or prompt content provided"}), 400
+def generate_test_cases_api(srs_text):
+    """Main API function for generating test cases"""
+    if not srs_text or not srs_text.strip():
+        return {
+            "error": "No SRS or prompt content provided",
+            "test_cases": [],
+            "count": 0
+        }
 
+    srs_text = srs_text.strip()
+    
     if len(srs_text) > 5000:
         logger.warning(f"SRS text truncated from {len(srs_text)} to 5000 characters")
         srs_text = srs_text[:5000]
@@ -182,7 +125,11 @@ def generate():
 
         if not test_cases or len(test_cases) == 0:
             logger.error("No test cases generated")
-            return jsonify({"error": "Failed to generate test cases"}), 500
+            return {
+                "error": "Failed to generate test cases",
+                "test_cases": [],
+                "count": 0
+            }
 
         try:
             generator = get_generator()
@@ -208,66 +155,300 @@ def generate():
 
         logger.info(f"✅ Successfully generated {len(test_cases)} test cases")
 
-        return jsonify({
+        return {
             "test_cases": test_cases,
             "count": len(test_cases),
             "model_used": model_used,
             "generation_method": generation_method,
             "model_algorithm": model_algorithm,
             "model_reason": model_reason
-        })
+        }
 
     except Exception as e:
         logger.error(f"❌ Test case generation failed: {str(e)}")
-        return jsonify({
+        return {
             "error": "Failed to generate test cases",
-            "message": "Please try again with different input"
-        }), 500
+            "message": "Please try again with different input",
+            "test_cases": [],
+            "count": 0
+        }
 
-@app.route('/model_info')
-def model_info():
-    """Get current model information"""
+def format_test_cases_output(result):
+    """Format the test cases for display"""
+    if "error" in result:
+        return f"❌ Error: {result['error']}", ""
+    
+    test_cases = result.get("test_cases", [])
+    if not test_cases:
+        return "No test cases generated", ""
+    
+    # Format test cases for display
+    formatted_output = f"✅ Generated {result['count']} Test Cases\n\n"
+    formatted_output += f"🤖 Model: {result['model_used']}\n"
+    formatted_output += f"🔧 Algorithm: {result['model_algorithm']}\n"
+    formatted_output += f"💡 Reason: {result['model_reason']}\n\n"
+    
+    formatted_output += "=" * 50 + "\n"
+    formatted_output += "TEST CASES:\n"
+    formatted_output += "=" * 50 + "\n\n"
+    
+    for i, tc in enumerate(test_cases, 1):
+        formatted_output += f"🔹 Test Case {i}:\n"
+        formatted_output += f"   ID: {tc.get('id', f'TC_{i:03d}')}\n"
+        formatted_output += f"   Title: {tc.get('title', 'N/A')}\n"
+        formatted_output += f"   Description: {tc.get('description', 'N/A')}\n"
+        
+        steps = tc.get('steps', [])
+        if isinstance(steps, list):
+            formatted_output += f"   Steps:\n"
+            for j, step in enumerate(steps, 1):
+                formatted_output += f"      {j}. {step}\n"
+        else:
+            formatted_output += f"   Steps: {steps}\n"
+        
+        formatted_output += f"   Expected Result: {tc.get('expected', 'N/A')}\n\n"
+    
+    # Return JSON for API access
+    json_output = json.dumps(result, indent=2)
+    
+    return formatted_output, json_output
+
+def gradio_generate_test_cases(srs_text):
+    """Gradio interface function"""
+    result = generate_test_cases_api(srs_text)
+    return format_test_cases_output(result)
+
+def get_system_status():
+    """Get system status information"""
+    health_data = check_health()
+    try:
+        generator = get_generator()
+        model_info = generator.get_model_info()
+    except Exception:
+        model_info = {
+            "model_name": "Template-Based Generator",
+            "status": "template_mode",
+            "optimization": "memory_safe"
+        }
+
+    status_info = f"""
+🏥 SYSTEM STATUS
+================
+Status: {health_data["status"]}
+Memory Usage: {health_data["memory_usage"]}
+Memory Limit: 512MB
+
+🤖 MODEL INFORMATION
+===================
+Model Name: {model_info["model_name"]}
+Status: {model_info["status"]}
+Optimization: {model_info.get("optimization", "standard")}
+
+🚀 APPLICATION INFO
+==================
+Version: 1.0.0-spaces-optimized
+Environment: Hugging Face Spaces
+Backend: Gradio
+    """
+    return status_info
+
+def get_model_info_detailed():
+    """Get detailed model information"""
     try:
         generator = get_generator()
         info = generator.get_model_info()
         health_data = check_health()
 
-        return jsonify({
-            "model": info,
-            "system": health_data
-        })
+        detailed_info = f"""
+🔧 DETAILED MODEL INFORMATION
+============================
+Model Name: {info.get('model_name', 'N/A')}
+Status: {info.get('status', 'N/A')}
+Memory Usage: {info.get('memory_usage', 'N/A')}
+Optimization Level: {info.get('optimization', 'N/A')}
+
+📊 SYSTEM METRICS
+================
+System Status: {health_data['status']}
+Current Memory: {health_data['memory_usage']}
+Memory Limit: {health_data.get('memory_limit', 'N/A')}
+
+⚙️ CONFIGURATION
+===============
+Environment: {"Hugging Face Spaces" if os.environ.get('SPACE_ID') else "Local"}
+Backend: Gradio
+Threading: Enabled
+Memory Monitoring: Active
+        """
+        return detailed_info
     except Exception as e:
-        logger.error(f"Error getting model info: {e}")
-        return jsonify({"error": "Unable to get model information"}), 500
-
-@app.errorhandler(404)
-def not_found(error):
-    return jsonify({"error": "Endpoint not found"}), 404
-
-@app.errorhandler(405)
-def method_not_allowed(error):
-    return jsonify({"error": "Method not allowed"}), 405
-
-@app.errorhandler(500)
-def internal_error(error):
-    logger.error(f"Internal server error: {error}")
-    return jsonify({"error": "Internal server error"}), 500
-
-if __name__ == '__main__':
-    port = int(os.environ.get("PORT", 5000))
-    debug_mode = os.environ.get("FLASK_ENV") == "development"
-
-    logger.info(f"🚀 Starting Flask app on port {port}")
-    logger.info(f"🔧 Debug mode: {debug_mode}")
-    logger.info(f"🖥️ Environment: {'Railway' if os.environ.get('RAILWAY_ENVIRONMENT') else 'Local'}")
-
-    if not os.environ.get('RAILWAY_ENVIRONMENT'):
-        ensure_initialized()
-
-    app.run(
-        host='0.0.0.0',
-        port=port,
-        debug=debug_mode,
-        threaded=True,
-        use_reloader=False
+        return f"❌ Error getting model info: {str(e)}"
+
+# Create Gradio interface
+with gr.Blocks(title="AI Test Case Generator", theme=gr.themes.Soft()) as app:
+    gr.Markdown("""
+    # 🧪 AI Test Case Generator
+    
+    Generate comprehensive test cases from Software Requirements Specification (SRS) documents using AI models.
+    
+    **Features:**
+    - 🤖 AI-powered test case generation
+    - 📝 Template-based fallback for low memory environments  
+    - 🔧 Memory-optimized processing
+    - 📊 Real-time system monitoring
+    """)
+    
+    with gr.Tab("🧪 Generate Test Cases"):
+        with gr.Row():
+            with gr.Column(scale=2):
+                srs_input = gr.Textbox(
+                    label="📋 Software Requirements Specification (SRS)",
+                    placeholder="Enter your SRS document or requirements here...\n\nExample:\nThe system shall provide user authentication with username and password. Users should be able to login, logout, and reset passwords. The system should validate input and display appropriate error messages for invalid credentials.",
+                    lines=10,
+                    max_lines=20
+                )
+                
+                generate_btn = gr.Button("🚀 Generate Test Cases", variant="primary", size="lg")
+            
+            with gr.Column(scale=3):
+                output_display = gr.Textbox(
+                    label="📋 Generated Test Cases",
+                    lines=20,
+                    max_lines=30,
+                    interactive=False
+                )
+        
+        with gr.Row():
+            json_output = gr.Textbox(
+                label="📄 JSON Output (for API use)",
+                lines=10,
+                max_lines=15,
+                interactive=False
+            )
+    
+    with gr.Tab("📊 System Status"):
+        with gr.Column():
+            status_display = gr.Textbox(
+                label="🏥 System Health & Status",
+                lines=15,
+                interactive=False
+            )
+            refresh_status_btn = gr.Button("🔄 Refresh Status", variant="secondary")
+    
+    with gr.Tab("🔧 Model Information"):
+        with gr.Column():
+            model_info_display = gr.Textbox(
+                label="🤖 Detailed Model Information",
+                lines=20,
+                interactive=False
+            )
+            refresh_model_btn = gr.Button("🔄 Refresh Model Info", variant="secondary")
+    
+    with gr.Tab("📚 API Documentation"):
+        gr.Markdown("""
+        ## 🔌 API Endpoints
+        
+        This Gradio app automatically creates API endpoints for all functions:
+        
+        ### Generate Test Cases
+        **Endpoint:** `/api/predict`  
+        **Method:** POST  
+        **Body:**
+        ```json
+        {
+          "data": ["Your SRS text here"]
+        }
+        ```
+        
+        **Response:**
+        ```json
+        {
+          "data": [
+            "Formatted test cases output",
+            "JSON output with test cases"
+          ]
+        }
+        ```
+        
+        ### Example Usage (Python):
+        ```python
+        import requests
+        
+        response = requests.post(
+            "YOUR_SPACE_URL/api/predict",
+            json={"data": ["User login system requirements..."]}
+        )
+        result = response.json()
+        test_cases = result["data"][1]  # JSON output
+        ```
+        
+        ### Example Usage (cURL):
+        ```bash
+        curl -X POST "YOUR_SPACE_URL/api/predict" \\
+          -H "Content-Type: application/json" \\
+          -d '{"data":["Your SRS text here"]}'
+        ```
+        
+        ## 📋 Response Format
+        
+        The API returns test cases in this format:
+        ```json
+        {
+          "test_cases": [
+            {
+              "id": "TC_001",
+              "title": "Test Case Title", 
+              "description": "Test description",
+              "steps": ["Step 1", "Step 2"],
+              "expected": "Expected result"
+            }
+          ],
+          "count": 3,
+          "model_used": "distilgpt2",
+          "model_algorithm": "Transformer-based LM",
+          "model_reason": "Selected for balanced performance..."
+        }
+        ```
+        """)
+    
+    # Event handlers
+    generate_btn.click(
+        fn=gradio_generate_test_cases,
+        inputs=[srs_input],
+        outputs=[output_display, json_output]
+    )
+    
+    refresh_status_btn.click(
+        fn=get_system_status,
+        outputs=[status_display]
+    )
+    
+    refresh_model_btn.click(
+        fn=get_model_info_detailed,
+        outputs=[model_info_display]
     )
+    
+    # Load initial status
+    app.load(
+        fn=get_system_status,
+        outputs=[status_display]
+    )
+    
+    app.load(
+        fn=get_model_info_detailed,
+        outputs=[model_info_display]
+    )
+
+# Launch the app
+if __name__ == "__main__":
+    port = int(os.environ.get("PORT", 7860))
+    
+    logger.info(f"🚀 Starting Gradio app on port {port}")
+    logger.info(f"🖥️ Environment: {'Hugging Face Spaces' if os.environ.get('SPACE_ID') else 'Local'}")
+    
+    app.launch(
+        server_name="0.0.0.0",
+        server_port=port,
+        share=False,
+        show_error=True
+    )