Update app.py to add logging

app.py

@@ -1,44 +1,101 @@
+import logging
+import json
 from transformers import pipeline
 import gradio as gr
 
-# Load the model
-model_name = "google/flan-t5-base"  # Choose your desired model
-generator = pipeline("text2text-generation", model=model_name)
-
-# Function to generate test cases
-def generate_test_cases(method, url, headers, payload = ""):
-    prompt = f"""
-    Generate comprehensive API test cases:
-    Method: {method}
-    URL: {url}
-    Headers: {headers}
-    Payload: {payload}
-
-    Include:
-    - Happy path
-    - Negative test cases
-    - Performance scenarios
-    - Boundary conditions
-    """
+# Configure logging
+logging.basicConfig(level=logging.DEBUG, 
+                    format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# Load the model with explicit logging
+try:
+    model_name = "google/flan-t5-base"
+    logger.info(f"Attempting to load model: {model_name}")
+    generator = pipeline("text2text-generation", model=model_name)
+    logger.info("Model loaded successfully")
+except Exception as model_load_error:
+    logger.error(f"Failed to load model: {model_load_error}")
+    generator = None
+
+def generate_test_cases(method, url, headers, payload=""):
     try:
-        response = generator(prompt, max_length=500)
-        return response[0]['generated_text']
-    except Exception as e:
-        return f"Error generating test cases: {str(e)}"
+        # Log input parameters
+        logger.info(f"Generating test cases for:")
+        logger.info(f"Method: {method}")
+        logger.info(f"URL: {url}")
+        logger.info(f"Headers: {headers}")
+        logger.info(f"Payload: {payload}")
+
+        # Validate inputs
+        if not method or not url:
+            logger.warning("Method or URL is missing")
+            return "Error: Method and URL are required"
+
+        # Attempt to parse headers and payload as JSON
+        try:
+            headers_dict = json.loads(headers) if headers else {}
+            payload_dict = json.loads(payload) if payload else {}
+        except json.JSONDecodeError as json_error:
+            logger.error(f"JSON parsing error: {json_error}")
+            return f"JSON Parsing Error: {json_error}"
+
+        # Prepare the prompt
+        prompt = f"""
+        Generate comprehensive API test cases:
+        Method: {method}
+        URL: {url}
+        Headers: {headers_dict}
+        Payload: {payload_dict}
+        Include:
+        - Happy path scenarios
+        - Negative test cases
+        - Performance test considerations
+        - Boundary condition tests
+        - Error handling scenarios
+        """
+
+        # Check if generator is available
+        if generator is None:
+            logger.error("Model generator is not initialized")
+            return "Error: Model generator not initialized"
+
+        # Generate test cases
+        logger.info("Attempting to generate test cases")
+        try:
+            response = generator(prompt, max_length=500)
+            generated_text = response[0]['generated_text']
+            
+            logger.info("Test cases generated successfully")
+            logger.debug(f"Generated Text: {generated_text}")
+            
+            return generated_text
+        except Exception as generation_error:
+            logger.error(f"Test case generation error: {generation_error}")
+            return f"Error generating test cases: {generation_error}"
+
+    except Exception as overall_error:
+        logger.error(f"Unexpected error: {overall_error}")
+        return f"Unexpected error: {overall_error}"
 
 # Create the Gradio interface
 iface = gr.Interface(
     fn=generate_test_cases,
     inputs=[
-        gr.Textbox(label="HTTP Method (GET, POST, etc.)"),
-        gr.Textbox(label="API URL"),
-        gr.Textbox(label="Headers (JSON format)"),
-        gr.Textbox(label="Payload (JSON format)"),
+        gr.Textbox(label="HTTP Method (GET, POST, etc.)", placeholder="e.g., GET, POST"),
+        gr.Textbox(label="API URL", placeholder="e.g., https://api.example.com/endpoint"),
+        gr.Textbox(label="Headers (JSON format)", placeholder='e.g., {"Content-Type": "application/json"}'),
+        gr.Textbox(label="Payload (JSON format)", placeholder='e.g., {"key": "value"}', optional=True),
     ],
     outputs="text",
     title="API Test Case Generator",
     description="Generate structured test cases for APIs using Hugging Face models."
 )
 
+# Main execution
 if __name__ == "__main__":
-    iface.launch()
+    try:
+        logger.info("Starting Gradio interface")
+        iface.launch()
+    except Exception as launch_error:
+        logger.error(f"Failed to launch Gradio interface: {launch_error}")