Update app.py

app.py

@@ -87,7 +87,7 @@ Important:
 Resume: {resume}
 Job Description: {jd}
 [/INST]""".format(
-            resume=resume_text[:3000],  # Truncate to prevent token limit issues
+            resume=resume_text[:3000],
             jd=job_description[:1000]
         )
 
@@ -99,37 +99,41 @@ Job Description: {jd}
                 "inputs": prompt,
                 "parameters": {
                     "max_new_tokens": 800,
-                    "temperature": 0.3,  # Lower for more consistent JSON
-                    "do_sample": False   # Disable randomness
+                    "temperature": 0.3,
+                    "do_sample": False
                 }
             },
-            timeout=45  # Increased timeout
+            timeout=45
         )
 
         # Handle API errors
         if response.status_code != 200:
             error_msg = response.json().get("error", "Unknown API error")
-            return {"error": f"API request failed: {error_msg}"}
+            return {
+                "error": f"API request failed: {error_msg}",
+                "api_response": response.text
+            }
 
         # Process response
         raw_output = response.json()[0]['generated_text']
+        
+        # Try to extract JSON
         result = extract_json_from_text(raw_output)
         
-        if not result:
-            return {
-                "error": "Could not extract valid JSON",
-                "raw_response": raw_output  # Include raw response for debugging
-            }
+        if result:
+            # Validate JSON structure
+            required_keys = {"analysis", "overall_score"}
+            if all(key in result for key in required_keys):
+                return {
+                    "structured_result": result,
+                    "raw_response": raw_output
+                }
         
-        # Validate JSON structure
-        required_keys = {"analysis", "overall_score"}
-        if not all(key in result for key in required_keys):
-            return {
-                "error": "Incomplete analysis in response",
-                "partial_response": result
-            }
-            
-        return result
+        # If JSON extraction failed, return raw output
+        return {
+            "raw_response": raw_output,
+            "error": "Could not extract valid JSON"
+        }
 
     except requests.exceptions.RequestException as e:
         return {"error": f"Network error: {str(e)}"}
@@ -138,8 +142,7 @@ Job Description: {jd}
 
 # Enhanced Gradio Interface
 with gr.Blocks(title="ATS Resume Analyzer", theme=gr.themes.Soft()) as demo:
-    gr.Markdown("""# ATS Resume Analyzer  
-    Upload your resume and job description to get ATS compatibility analysis""")
+    gr.Markdown("""# ATS Resume Analyzer""")
     
     with gr.Row():
         with gr.Column():
@@ -158,47 +161,59 @@ with gr.Blocks(title="ATS Resume Analyzer", theme=gr.themes.Soft()) as demo:
         with gr.Column():
             output_tabs = gr.Tabs()
             with output_tabs:
-                with gr.Tab("Structured Analysis", id="json"):
-                    json_output = gr.JSON(label="Analysis Results")
-                with gr.Tab("Raw Response", id="raw"):
-                    raw_output = gr.Textbox(label="API Response", interactive=False)
+                with gr.Tab("Analysis Results"):
+                    json_output = gr.JSON(label="Structured Analysis")
+                    summary_output = gr.Textbox(label="Summary", interactive=False)
+                with gr.Tab("API Response"):
+                    raw_output = gr.Textbox(label="Raw API Response", lines=10)
+                with gr.Tab("Debug Info"):
+                    status_output = gr.Textbox(label="Status Info", lines=5)
             status = gr.Textbox(label="Status", interactive=False)
 
     def display_results(file, job_description):
         """Handle results display with proper error handling"""
         result = analyze_with_huggingface(file, job_description)
         
+        output = {
+            json_output: None,
+            summary_output: None,
+            raw_output: None,
+            status_output: None,
+            status: ""
+        }
+        
         if "error" in result:
-            return {
-                json_output: None,
-                raw_output: result.get("raw_response", str(result)),
-                status: f"Error: {result['error']}"
-            }
+            output.update({
+                status: f"Error: {result['error']}",
+                status_output: str(result),
+                raw_output: result.get("api_response") or result.get("raw_response") or ""
+            })
+        elif "structured_result" in result:
+            structured = result["structured_result"]
+            output.update({
+                json_output: structured["analysis"],
+                summary_output: structured.get("summary", ""),
+                raw_output: result["raw_response"],
+                status: "Analysis complete!",
+                status_output: "Successfully parsed JSON response"
+            })
+        else:
+            output.update({
+                raw_output: result.get("raw_response", "No response received"),
+                status: "Received non-JSON response",
+                status_output: "The API returned a response but it couldn't be parsed as JSON"
+            })
         
-        return {
-            json_output: result,
-            raw_output: json.dumps(result, indent=2),
-            status: "Analysis complete!"
-        }
+        return output
 
     analyze_btn.click(
         fn=display_results,
         inputs=[file_input, jd_input],
-        outputs=[json_output, raw_output, status]
+        outputs=[json_output, summary_output, raw_output, status_output, status]
     )
 
-# ... (all your existing code remains the same until the launch part) ...
-
 if __name__ == "__main__":
-    # Configure queue (choose one option):
-    
-    # Option 1: Simple queue
-    demo.queue()
-    
-  
-    
-    # Then launch
-    demo.launch(
+    demo.queue().launch(
         allowed_paths=["*"],
-       
+        
     )