Update data_service.py

data_service.py

@@ -1,4 +1,5 @@
 # data_service.py
+import traceback
 from typing import Dict, List, Any
 from data_structures import WEB_DATA_REPORTS
 from gpt_analyzer import GPTAnalyzer
@@ -10,9 +11,11 @@ class DataAssessmentService:
         self.analyzer = GPTAnalyzer(api_key)
         self.web_data = WEB_DATA_REPORTS
         print(f"Available categories: {list(self.web_data.keys())}")
+        print(f"Web data structure loaded: {bool(self.web_data)}")
 
     def check_data_availability(self, analysis_result: dict) -> dict:
-        print(f"Checking availability for analysis: {analysis_result}")
+        print(f"Checking data availability for analysis result")
+        print(f"Analysis result: {analysis_result}")
         
         availability = {
             "available_in_webdata": [],
@@ -21,97 +24,108 @@ 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", []):
-            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,
-                            "description": report_details["description"],
-                            "access_path": f"/web-data/{category.lower()}/{report_name}",
-                            "filters": report_details["filters"]
+        try:
+            for required in analysis_result.get("required_reports", []):
+                print(f"Processing required report: {required}")
+                category = required.get("category")
+                report_type = required.get("report_type")
+
+                if not category or not report_type:
+                    print(f"Missing category or report_type in required report")
+                    continue
+
+                print(f"Checking category: {category} for report type: {report_type}")
+                if category in self.web_data:
+                    matching_reports = []
+                    for report_name, report_details in self.web_data[category].items():
+                        required_fields = set(required.get("fields_needed", []))
+                        available_fields = set(report_details["fields"].keys())
+
+                        print(f"Checking report {report_name}")
+                        print(f"Required fields: {required_fields}")
+                        print(f"Available fields: {available_fields}")
+
+                        if required_fields.issubset(available_fields):
+                            matching_reports.append({
+                                "name": report_details["name"],
+                                "description": report_details["description"],
+                                "access_path": f"/web-data/{category.lower()}/{report_name}",
+                                "filters": report_details["filters"]
+                            })
+                            print(f"Found matching report: {report_name}")
+
+                    if matching_reports:
+                        availability["available_in_webdata"].extend(matching_reports)
+                        filters_list = ', '.join(matching_reports[0]['filters'])
+                        availability["access_instructions"].append(
+                            f"Access {category} data through Web Data portal using filters: {filters_list}"
+                        )
+                    else:
+                        availability["needs_datalake"].append({
+                            "category": category,
+                            "report_type": report_type,
+                            "reason": "Required fields not available in Web Data"
                         })
-
-                if matching_reports:
-                    availability["available_in_webdata"].extend(matching_reports)
-                    availability["access_instructions"].append(
-                        f"Access {category} data through Web Data portal using filters: "
-                        f"{', '.join(matching_reports[0]['filters'])}"
-                    )
                 else:
-                    availability["needs_datalake"].append({
+                    availability["not_available"].append({
                         "category": category,
                         "report_type": report_type,
-                        "reason": "Required fields not available in Web Data"
+                        "reason": "Category not found in Web Data"
                     })
-            else:
-                availability["not_available"].append({
-                    "category": category,
-                    "report_type": report_type,
-                    "reason": "Category not found in Web Data"
-                })
+
+        except Exception as e:
+            print(f"Error in check_data_availability: {str(e)}")
+            print(traceback.format_exc())
+            availability["error"] = str(e)
 
         print(f"Final availability result: {availability}")
         return availability
 
     def assess_request(self, request_text: str) -> Dict[str, Any]:
-        print(f"Assessing request: {request_text}")
+        print(f"Starting assessment of 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.get("interpretation", ""),
-                "confidence": analysis.get("confidence_score", "LOW")
-            },
-            "data_availability": {
-                "available_reports": availability["available_in_webdata"],
-                "access_instructions": availability["access_instructions"]
+        try:
+            # 1. Analyze the request
+            analysis = self.analyzer.analyze_request(request_text, list(self.web_data.keys()))
+            print(f"Analysis completed: {analysis}")
+            
+            if "error" in analysis:
+                return {"status": "error", "message": analysis["error"]}
+
+            # 2. Check data availability
+            availability = self.check_data_availability(analysis)
+            print(f"Availability check completed: {availability}")
+
+            # 3. Generate response
+            response = {
+                "status": "success",
+                "request_analysis": {
+                    "interpretation": analysis.get("interpretation", ""),
+                    "confidence": analysis.get("confidence_score", "LOW")
+                },
+                "data_availability": {
+                    "available_reports": availability["available_in_webdata"],
+                    "access_instructions": availability["access_instructions"]
+                }
             }
-        }
-
-        if availability["needs_datalake"]:
-            response["data_lake_requirements"] = {
-                "reports_needed": availability["needs_datalake"],
-                "estimated_processing_time": "2-3 business days",
-                "requires_it_support": True
-            }
-
-        if availability["not_available"]:
-            response["unavailable_data"] = availability["not_available"]
 
-        print(f"Final response: {response}")
-        return response
+            if availability["needs_datalake"]:
+                response["data_lake_requirements"] = {
+                    "reports_needed": availability["needs_datalake"],
+                    "estimated_processing_time": "2-3 business days",
+                    "requires_it_support": True
+                }
+
+            if availability["not_available"]:
+                response["unavailable_data"] = availability["not_available"]
+
+            print(f"Final response prepared: {response}")
+            return response
+            
+        except Exception as e:
+            print(f"Error in assess_request: {str(e)}")
+            print(traceback.format_exc())
+            return {
+                "status": "error",
+                "message": f"Error processing request: {str(e)}"
+            }