Update data_service.py

data_service.py

@@ -5,10 +5,15 @@ from gpt_analyzer import GPTAnalyzer
 
 class DataAssessmentService:
     def __init__(self, api_key: str):
+        print("Initializing DataAssessmentService")
+        print(f"API Key available: {bool(api_key)}")
         self.analyzer = GPTAnalyzer(api_key)
         self.web_data = WEB_DATA_REPORTS
+        print(f"Available categories: {list(self.web_data.keys())}")
 
     def check_data_availability(self, analysis_result: dict) -> dict:
+        print(f"Checking availability for analysis: {analysis_result}")
+        
         availability = {
             "available_in_webdata": [],
             "needs_datalake": [],
@@ -16,16 +21,30 @@ class DataAssessmentService:
             "access_instructions": []
         }
 
+        if "error" in analysis_result:
+            print(f"Error in analysis result: {analysis_result['error']}")
+            return availability
+
+        if not analysis_result.get("required_reports"):
+            print("No required_reports in analysis result")
+            return availability
+
         for required in analysis_result.get("required_reports", []):
-            category = required["category"]
-            report_type = required["report_type"]
+            print(f"Processing required report: {required}")
+            category = required.get("category")
+            report_type = required.get("report_type")
 
+            print(f"Checking category: {category}")
             if category in self.web_data:
                 matching_reports = []
                 for report_name, report_details in self.web_data[category].items():
+                    print(f"Checking report: {report_name}")
                     required_fields = set(required.get("fields_needed", []))
                     available_fields = set(report_details["fields"].keys())
 
+                    print(f"Required fields: {required_fields}")
+                    print(f"Available fields: {available_fields}")
+
                     if required_fields.issubset(available_fields):
                         matching_reports.append({
                             "report_name": report_name,
@@ -53,23 +72,30 @@ class DataAssessmentService:
                     "reason": "Category not found in Web Data"
                 })
 
+        print(f"Final availability result: {availability}")
         return availability
 
     def assess_request(self, request_text: str) -> Dict[str, Any]:
+        print(f"Assessing request: {request_text}")
+        
         # 1. Analyze the request
         analysis = self.analyzer.analyze_request(request_text, list(self.web_data.keys()))
+        print(f"Analysis result: {analysis}")
+        
         if "error" in analysis:
+            print(f"Error in analysis: {analysis['error']}")
             return {"status": "error", "message": analysis["error"]}
 
         # 2. Check data availability
         availability = self.check_data_availability(analysis)
+        print(f"Availability check result: {availability}")
 
         # 3. Generate response
         response = {
             "status": "success",
             "request_analysis": {
-                "interpretation": analysis["interpretation"],
-                "confidence": analysis["confidence_score"]
+                "interpretation": analysis.get("interpretation", ""),
+                "confidence": analysis.get("confidence_score", "LOW")
             },
             "data_availability": {
                 "available_reports": availability["available_in_webdata"],
@@ -87,4 +113,5 @@ class DataAssessmentService:
         if availability["not_available"]:
             response["unavailable_data"] = availability["not_available"]
 
+        print(f"Final response: {response}")
         return response