Update troubleshooting.py

troubleshooting.py

@@ -34,19 +34,20 @@ def test_api_connection():
         data = response.json()
         
         # Print the entire response structure for examination
-        print("Full response structure:")
-        print(json.dumps(data, indent=2)[:500] + "..." if len(json.dumps(data)) > 500 else json.dumps(data, indent=2))
+        print("First 500 characters of the response structure:")
+        response_str = json.dumps(data, indent=2)
+        print(response_str[:500] + "..." if len(response_str) > 500 else response_str)
         
-        # Determine if the API call was successful based on response structure
-        if isinstance(data, list) and len(data) > 0 and isinstance(data[0], dict) and data[0].get("status") == "Success":
-            print("API connection successful!")
-            return True
-        elif isinstance(data, dict) and data.get("Header", {}).get("status") == "Success":
-            print("API connection successful!")
-            return True
-        else:
-            print("API connection failed: Unable to determine success status")
-            return False
+        # Specific handling for the observed response structure
+        if isinstance(data, dict) and "Header" in data and isinstance(data["Header"], list) and len(data["Header"]) > 0:
+            header = data["Header"][0]
+            if header.get("status") == "Success":
+                print("API connection successful!")
+                return True
+        
+        print("API connection failed: Response format not as expected")
+        print("Full response keys:", list(data.keys()) if isinstance(data, dict) else "Not a dictionary")
+        return False
     except Exception as e:
         print(f"Exception during API connection test: {e}")
         return False
@@ -66,31 +67,13 @@ def test_state_lookup(state_code):
         response = requests.get(endpoint, params=params)
         data = response.json()
         
-        # Handle the response based on its structure
-        if isinstance(data, list) and len(data) > 0 and isinstance(data[0], dict) and data[0].get("status") == "Success":
-            header = data[0]
-            states_data = data[1:] if len(data) > 1 else []
-            print(f"Found {len(states_data)} states in the API")
-            
-            # Look for the specific state
-            matching_states = [s for s in states_data if str(s.get("code")) == str(state_code) or s.get("value") == state_code]
-            if matching_states:
-                print(f"Found matching state: {matching_states[0]}")
-                return matching_states[0]
-            else:
-                print(f"No matching state found for code: {state_code}")
-                print("Available state codes (first 10):")
-                for s in states_data[:10]:  # Print first 10 for brevity
-                    print(f"  {s.get('code')} - {s.get('value')}")
-                if len(states_data) > 10:
-                    print(f"  ... and {len(states_data)-10} more")
-                return None
-        elif isinstance(data, dict) and data.get("Header", {}).get("status") == "Success":
-            states = data.get("Data", [])
+        # Handle the specific response structure we observed
+        if isinstance(data, dict) and "Data" in data and isinstance(data["Data"], list):
+            states = data["Data"]
             print(f"Found {len(states)} states in the API")
             
             # Look for the specific state
-            matching_states = [s for s in states if str(s.get("state_code")) == str(state_code) or s.get("value") == state_code]
+            matching_states = [s for s in states if str(s.get("code")) == str(state_code) or s.get("value_represented") == state_code]
             if matching_states:
                 print(f"Found matching state: {matching_states[0]}")
                 return matching_states[0]
@@ -98,12 +81,12 @@ def test_state_lookup(state_code):
                 print(f"No matching state found for code: {state_code}")
                 print("Available state codes (first 10):")
                 for s in states[:10]:  # Print first 10 for brevity
-                    print(f"  {s.get('state_code')} - {s.get('value')}")
+                    print(f"  {s.get('code')} - {s.get('value_represented')}")
                 if len(states) > 10:
                     print(f"  ... and {len(states)-10} more")
                 return None
         else:
-            print("API lookup failed: Unable to determine success status")
+            print("API lookup failed: Unexpected response format")
             return None
     except Exception as e:
         print(f"Exception during state lookup: {e}")
@@ -125,22 +108,19 @@ def test_counties_lookup(state_code):
         response = requests.get(endpoint, params=params)
         data = response.json()
         
-        # Print the entire response structure for examination
-        print("Full response structure:")
-        print(json.dumps(data, indent=2)[:500] + "..." if len(json.dumps(data)) > 500 else json.dumps(data, indent=2))
+        # Print the beginning of the response structure for examination
+        print("First 500 characters of the response structure:")
+        response_str = json.dumps(data, indent=2)
+        print(response_str[:500] + "..." if len(response_str) > 500 else response_str)
         
-        # Handle both list and dictionary response structures
         counties = []
-        if isinstance(data, list) and len(data) > 0:
-            if data[0].get("status") == "Success":
-                counties = data[1:] if len(data) > 1 else []
-        elif isinstance(data, dict) and data.get("Header", {}).get("status") == "Success":
-            counties = data.get("Data", [])
+        if isinstance(data, dict) and "Data" in data and isinstance(data["Data"], list):
+            counties = data["Data"]
         
         print(f"Found {len(counties)} counties for state {state_code}")
         
         if counties:
-            print("Sample counties:")
+            print("Sample counties (first 5):")
             for c in counties[:5]:  # Print first 5 for brevity
                 print(f"  {c}")
             if len(counties) > 5:
@@ -171,17 +151,14 @@ def test_monitors_lookup(state_code):
         response = requests.get(endpoint, params=params)
         data = response.json()
         
-        # Print the entire response structure for examination
-        print("First part of response structure:")
-        print(json.dumps(data, indent=2)[:500] + "..." if len(json.dumps(data)) > 500 else json.dumps(data, indent=2))
+        # Print the beginning of the response structure for examination
+        print("First 500 characters of the response structure:")
+        response_str = json.dumps(data, indent=2)
+        print(response_str[:500] + "..." if len(response_str) > 500 else response_str)
         
-        # Handle both list and dictionary response structures
         monitors = []
-        if isinstance(data, list) and len(data) > 0:
-            if data[0].get("status") == "Success":
-                monitors = data[1:] if len(data) > 1 else []
-        elif isinstance(data, dict) and data.get("Header", {}).get("status") == "Success":
-            monitors = data.get("Data", [])
+        if isinstance(data, dict) and "Data" in data and isinstance(data["Data"], list):
+            monitors = data["Data"]
         
         print(f"Found {len(monitors)} monitors for state {state_code}")
         
@@ -193,33 +170,11 @@ def test_monitors_lookup(state_code):
             # Check keys that might be causing issues
             print("\nChecking critical keys for indexing issues:")
             expected_keys = ["state_code", "county_code", "site_number", "parameter_code", "parameter_name", "latitude", "longitude", "local_site_name"]
-            
-            # Handle different potential key names
-            alternative_keys = {
-                "state_code": ["state_code", "state", "code"],
-                "county_code": ["county_code", "county", "county_id"],
-                "site_number": ["site_number", "site_num", "site", "site_id"],
-                "parameter_code": ["parameter_code", "param_code", "param"],
-                "parameter_name": ["parameter_name", "param_name", "parameter"],
-                "latitude": ["latitude", "lat"],
-                "longitude": ["longitude", "long", "lon"],
-                "local_site_name": ["local_site_name", "site_name", "name"]
-            }
-            
             for key in expected_keys:
-                # Try the primary key and alternatives
-                found = False
-                value = None
-                
-                for alt_key in alternative_keys.get(key, [key]):
-                    if alt_key in sample_monitor:
-                        found = True
-                        value = sample_monitor[alt_key]
-                        print(f"  ✓ '{key}' found as '{alt_key}': {value}")
-                        break
-                
-                if not found:
-                    print(f"  ✗ '{key}' missing (also tried alternatives: {alternative_keys.get(key, [key])})")
+                if key in sample_monitor:
+                    print(f"  ✓ '{key}' found: {sample_monitor[key]}")
+                else:
+                    print(f"  ✗ '{key}' missing!")
         else:
             print("No monitors found for this state")
         
@@ -238,8 +193,8 @@ def run_tests():
         for state_code in ["06", "36", "CA", "NY"]:
             state_info = test_state_lookup(state_code)
             if state_info:
-                # Use the correct state code format based on the response
-                state_code_to_use = state_info.get("code") or state_info.get("state_code")
+                # Use the state code according to what was found
+                state_code_to_use = state_info.get("code")
                 if state_code_to_use:
                     test_counties_lookup(state_code_to_use)
                     test_monitors_lookup(state_code_to_use)