Update app.py

app.py

@@ -26,8 +26,12 @@ logger = logging.getLogger(__name__)
 
 # Load environment variables
 load_dotenv()
+
+# Configuration with validation
 HF_API_URL = os.getenv("HF_API_URL", "https://api-inference.huggingface.co/models/google/vit-base-patch16-224")
 HF_API_TOKEN = os.getenv("HF_API_TOKEN")
+if not HF_API_TOKEN:
+    logger.warning("HF_API_TOKEN is missing. Hugging Face API calls will be skipped, running in offline mode.")
 SF_CLIENT_ID = os.getenv("SF_CLIENT_ID")
 SF_CLIENT_SECRET = os.getenv("SF_CLIENT_SECRET")
 SF_USERNAME = os.getenv("SF_USERNAME")
@@ -35,7 +39,7 @@ SF_PASSWORD = os.getenv("SF_PASSWORD")
 SF_SECURITY_TOKEN = os.getenv("SF_SECURITY_TOKEN")
 SF_INSTANCE_URL = os.getenv("SF_INSTANCE_URL", "https://your-salesforce-instance.my.salesforce.com")
 if not all([SF_CLIENT_ID, SF_CLIENT_SECRET, SF_USERNAME, SF_PASSWORD, SF_SECURITY_TOKEN, SF_INSTANCE_URL]):
-    raise ValueError("Missing required Salesforce credentials or instance URL in the .env file.")
+    logger.warning("Missing Salesforce credentials. Salesforce integration will be queued for offline processing.")
 SALESFORCE_AUTH_URL = f"{SF_INSTANCE_URL}/services/oauth2/token"
 SALESFORCE_API_URL = f"{SF_INSTANCE_URL}/services/data/v52.0/sobjects/"
 SALESFORCE_ACCESS_TOKEN = None
@@ -51,27 +55,59 @@ except Exception as e:
     logger.error(f"Failed to load image processor from {model_name}: {str(e)}")
     raise
 
-# Disease recommendations
+# Disease recommendations (aligned with Salesforce picklist values)
 disease_recommendations = {
     "Apple Scab": {"treatment": "Use captan or myclobutanil fungicide", "fertilizer": "10-10-10 balanced fertilizer", "symptoms": ["olive-colored spots", "scabby lesions"]},
-    # ... (rest of the dictionary remains unchanged)
+    "Anthracnose": {"treatment": "Prune infected leaves, copper fungicide", "fertilizer": "Nitrogen-rich fertilizer", "symptoms": ["leaf spots", "wilting"]},
+    "Bacterial Leaf Scorch": {"treatment": "Remove infected branches, apply bactericide", "fertilizer": "Low-nitrogen organic fertilizer", "symptoms": ["scorched margins", "yellowing"]},
+    "Beech Bark Disease": {"treatment": "Remove infected trees, insecticide for scale", "fertilizer": "Slow-release fertilizer", "symptoms": ["bark lesions", "scale infestation"]},
+    "Cedar Apple Rust": {"treatment": "Fungicide in early spring", "fertilizer": "Balanced NPK fertilizer", "symptoms": ["yellow spots", "orange galls"]},
+    "Chestnut Blight": {"treatment": "Prune affected limbs, biological control", "fertilizer": "Slow-release fertilizer in spring", "symptoms": ["cankers", "wilting"]},
+    "Citrus Canker": {"treatment": "Copper-based sprays, remove infected trees", "fertilizer": "Citrus-specific fertilizer", "symptoms": ["corky lesions", "water spots"]},
+    "Dutch Elm Disease": {"treatment": "Systemic fungicides, prune infected limbs", "fertilizer": "Low-nitrogen fertilizer", "symptoms": ["wilting", "yellow leaves"]},
+    "Dogwood Anthracnose": {"treatment": "Fungicide, remove infected tissue", "fertilizer": "Balanced fertilizer in early spring", "symptoms": ["leaf spots", "dieback"]},
+    "Fire Blight": {"treatment": "Prune during dormancy, copper sprays", "fertilizer": "Avoid excess nitrogen", "symptoms": ["blackened leaves", "scorched shoots"]},
+    "Fusarium Wilt": {"treatment": "Remove infected plants, soil solarization", "fertilizer": "Potassium-rich fertilizer", "symptoms": ["wilting", "yellowing"]},
+    "Gummosis": {"treatment": "Improve drainage, copper sprays", "fertilizer": "Citrus or stone fruit fertilizer", "symptoms": ["gummy exudates", "bark cracks"]},
+    "Huanglongbing (Citrus Greening)": {"treatment": "Remove infected trees, insecticide", "fertilizer": "Micronutrient mix for citrus", "symptoms": ["yellow mottling", "asymmetric fruit"]},
+    "Leaf Spot": {"treatment": "Fungicide sprays, remove debris", "fertilizer": "General-purpose fertilizer", "symptoms": ["small spots", "yellow halos"]},
+    "Oak Wilt": {"treatment": "Trenching, systemic fungicides", "fertilizer": "Minimal fertilization, compost mulch", "symptoms": ["vein browning", "leaf wilt"]},
+    "Pine Wilt": {"treatment": "Remove infested trees, control beetles", "fertilizer": "No fertilization during stress", "symptoms": ["needle browning", "tree decline"]},
+    "Powdery Mildew": {"treatment": "Sulfur-based sprays", "fertilizer": "Avoid high-nitrogen fertilizers", "symptoms": ["white powdery coating", "white patches"]},
+    "Phytophthora Root Rot": {"treatment": "Improve soil drainage, fungicide", "fertilizer": "Organic compost, no excess water", "symptoms": ["root decay", "wilting"]},
+    "Sooty Mold": {"treatment": "Control insect pests, wash off mold", "fertilizer": "Supportive fertilization (10-10-10)", "symptoms": ["black mold", "sticky residue"]},
+    "Sudden Oak Death": {"treatment": "Phosphonates, sanitation", "fertilizer": "Organic mulch, avoid excess nitrogen", "symptoms": ["cankers", "leaf loss"]},
+    "Verticillium Wilt": {"treatment": "Remove infected branches, crop rotation", "fertilizer": "Low-nitrogen balanced fertilizer", "symptoms": ["sudden wilting", "branch dieback"]},
+    "Thousand Cankers Disease": {"treatment": "Remove infected trees", "fertilizer": "Mulch and deep water during drought", "symptoms": ["cankers", "wilting"]},
+    "Tar Spot": {"treatment": "Rake and destroy leaves, fungicide", "fertilizer": "General-purpose fertilizer", "symptoms": ["black tar spots", "shiny spots"]},
+    "Rusts": {"treatment": "Fungicides during early infection", "fertilizer": "Balanced fertilizer to boost immunity", "symptoms": ["orange pustules", "rusty spots"]},
+    "Needle Cast": {"treatment": "Fungicides (chlorothalonil), remove infected needles", "fertilizer": "Conifer-specific fertilizer", "symptoms": ["needle spots", "yellow bands"]},
+    "White Pine Blister Rust": {"treatment": "Remove alternate hosts, fungicides", "fertilizer": "Minimal fertilization", "symptoms": ["blister-like swellings", "needle drop"]},
+    "Root Rot": {"treatment": "Improve drainage, avoid overwatering", "fertilizer": "Compost and balanced fertilizer", "symptoms": ["root decay", "stunted growth"]},
+    "Black Knot": {"treatment": "Prune 2-4 inches below knots", "fertilizer": "Spring fertilization with 10-10-10", "symptoms": ["black swellings", "rough knots"]},
+    "Botryosphaeria Canker": {"treatment": "Remove infected branches", "fertilizer": "Avoid over-fertilization", "symptoms": ["cankers", "discolored bark"]},
     "Armillaria Root Rot": {"treatment": "Remove stumps, improve drainage", "fertilizer": "Compost-based organic fertilizer", "symptoms": ["root decay", "mushroom growth"]}
 }
 
+# Critical diseases
 critical_diseases = [
     "Fire Blight", "Oak Wilt", "Bacterial Leaf Scorch", "Sudden Oak Death", "Verticillium Wilt",
     "Pine Wilt", "Dutch Elm Disease", "Citrus Canker", "Phytophthora Root Rot", "Chestnut Blight"
 ]
 
+# id2label mapping
 id2label = {i: disease for i, disease in enumerate(disease_recommendations.keys())}
 
+# Offline queue for API calls
 offline_queue = queue.Queue()
 is_online = True
 RETRY_INTERVAL = 5
 
+# In-memory storage for prediction data
 prediction_logs = []
 
 def authenticate_salesforce(max_retries=3, retry_delay=5):
+    """Authenticate with Salesforce with retry logic."""
     global SALESFORCE_ACCESS_TOKEN, SALESFORCE_REFRESH_TOKEN
     password_with_token = f"{SF_PASSWORD}{SF_SECURITY_TOKEN}"
     payload = {
@@ -96,18 +132,16 @@ def authenticate_salesforce(max_retries=3, retry_delay=5):
             if attempt < max_retries - 1:
                 logger.info(f"Retrying authentication in {retry_delay} seconds... (Attempt {attempt + 2}/{max_retries})")
                 time.sleep(retry_delay)
+            else:
+                logger.error("Salesforce authentication failed after all retries.")
+                return False
         except Exception as e:
             logger.error(f"Unexpected error during Salesforce authentication: {str(e)}")
-    logger.warning("Salesforce authentication failed after all retries. Retrying in background...")
-    threading.Thread(target=retry_authentication_periodically, daemon=True).start()
+            return False
     return False
 
-def retry_authentication_periodically():
-    while not SALESFORCE_ACCESS_TOKEN:
-        time.sleep(60)
-        authenticate_salesforce()
-
 def refresh_salesforce_token():
+    """Refresh Salesforce access token."""
     global SALESFORCE_ACCESS_TOKEN
     if not SALESFORCE_REFRESH_TOKEN:
         logger.error("No refresh token available for Salesforce.")
@@ -130,11 +164,13 @@ def refresh_salesforce_token():
         return False
 
 def encrypt_sensitive_data(data):
+    """Encrypt sensitive data."""
     if data and data != "Not provided":
         return cipher.encrypt(data.encode()).decode()
     return data
 
 def decrypt_sensitive_data(encrypted_data):
+    """Decrypt sensitive data."""
     if encrypted_data and encrypted_data != "Not provided":
         try:
             return cipher.decrypt(encrypted_data.encode()).decode()
@@ -143,6 +179,7 @@ def decrypt_sensitive_data(encrypted_data):
     return encrypted_data
 
 def check_network_status():
+    """Check network status."""
     global is_online
     try:
         response = requests.get("https://www.google.com", timeout=2)
@@ -152,39 +189,74 @@ def check_network_status():
     return is_online
 
 def sync_offline_logs():
+    """Sync offline logs, updates, and cases to Salesforce."""
     if not is_online or not SALESFORCE_ACCESS_TOKEN:
         logger.warning("Skipping sync: Either offline or no Salesforce access token.")
         return
+    try:
+        with open("offline_logs.json", "r") as f:
+            logs = [json.loads(line) for line in f if line.strip()]
+        for log in logs:
+            headers = {"Authorization": f"Bearer {SALESFORCE_ACCESS_TOKEN}", "Content-Type": "application/json"}
+            response = requests.post(f"{SALESFORCE_API_URL}DiagnosisLog__c", headers=headers, json=log, timeout=10)
+            if response.status_code == 201:
+                logger.info(f"Synced offline log for inspection {log['TreeInspection__c']}")
+            else:
+                logger.error(f"Failed to sync offline log: {response.text}, Status: {response.status_code}")
+    except FileNotFoundError:
+        logger.info("No offline_logs.json file found to sync.")
+    except Exception as e:
+        logger.error(f"Error syncing offline logs: {str(e)}")
+
+    try:
+        with open("offline_updates.json", "r") as f:
+            updates = [json.loads(line) for line in f if line.strip()]
+        for update in updates:
+            headers = {"Authorization": f"Bearer {SALESFORCE_ACCESS_TOKEN}", "Content-Type": "application/json"}
+            response = requests.patch(f"{SALESFORCE_API_URL}TreeInspection__c/{update['inspection_id']}", headers=headers, json=update["data"], timeout=10)
+            if response.status_code == 204:
+                logger.info(f"Synced offline update for inspection {update['inspection_id']}")
+            else:
+                logger.error(f"Failed to sync offline update: {response.text}, Status: {response.status_code}")
+    except FileNotFoundError:
+        logger.info("No offline_updates.json file found to sync.")
+    except Exception as e:
+        logger.error(f"Error syncing offline updates: {str(e)}")
+
+    try:
+        with open("offline_cases.json", "r") as f:
+            cases = [json.loads(line) for line in f if line.strip()]
+        for case in cases:
+            headers = {"Authorization": f"Bearer {SALESFORCE_ACCESS_TOKEN}", "Content-Type": "application/json"}
+            response = requests.post(f"{SALESFORCE_API_URL}Case", headers=headers, json=case, timeout=10)
+            if response.status_code == 201:
+                logger.info(f"Synced offline case for inspection {case['TreeInspection__c']}")
+            else:
+                logger.error(f"Failed to sync offline case: {response.text}, Status: {response.status_code}")
+    except FileNotFoundError:
+        logger.info("No offline_cases.json file found to sync.")
+    except Exception as e:
+        logger.error(f"Error syncing offline cases: {str(e)}")
+
+    # Clear files after successful sync
     for filename in ["offline_logs.json", "offline_updates.json", "offline_cases.json"]:
         try:
-            with open(filename, "r") as f:
-                records = [json.loads(line) for line in f if line.strip()]
-            for record in records:
-                headers = {"Authorization": f"Bearer {SALESFORCE_ACCESS_TOKEN}", "Content-Type": "application/json"}
-                if filename == "offline_logs.json":
-                    endpoint = f"{SALESFORCE_API_URL}DiagnosisLog__c"
-                elif filename == "offline_updates.json":
-                    endpoint = f"{SALESFORCE_API_URL}TreeInspection__c/{record['inspection_id']}"
-                    record = record["data"]
-                elif filename == "offline_cases.json":
-                    endpoint = f"{SALESFORCE_API_URL}Case"
-                response = requests.post(endpoint, headers=headers, json=record, timeout=10) if filename != "offline_updates.json" else requests.patch(endpoint, headers=headers, json=record, timeout=10)
-                if response.status_code in (201, 204):
-                    logger.info(f"Synced {filename.split('.')[0]} for inspection {record.get('TreeInspection__c', 'N/A')}")
-                else:
-                    logger.error(f"Failed to sync {filename}: {response.text}, Status: {response.status_code}")
             open(filename, "w").close()
-        except FileNotFoundError:
-            logger.info(f"No {filename} file found to sync.")
         except Exception as e:
-            logger.error(f"Error syncing {filename}: {str(e)}")
+            logger.error(f"Failed to clear {filename}: {str(e)}")
 
 def process_offline_queue():
+    """Process queued API calls when online."""
     while not offline_queue.empty() and is_online and SALESFORCE_ACCESS_TOKEN and HF_API_TOKEN:
         request_data = offline_queue.get()
         try:
             headers = {"Authorization": f"Bearer {HF_API_TOKEN}", "Content-Type": "application/json"}
-            response = requests.post(HF_API_URL, headers=headers, json=request_data["payload"], timeout=10)
+            response = requests.post(
+                HF_API_URL,
+                headers=headers,
+                json=request_data["payload"],
+                timeout=10
+            )
             if response.status_code == 200:
                 result = response.json()
                 logger.info(f"Processed offline queue item, response: {result}")
@@ -194,12 +266,15 @@ def process_offline_queue():
                     create_salesforce_case(request_data["inspection_id"], result)
             else:
                 logger.error(f"Failed to process offline queue item: {response.text}, Status: {response.status_code}")
+                log_to_salesforce(request_data["inspection_id"], request_data["payload"], response.text, "Failed")
                 offline_queue.put(request_data)
         except Exception as e:
             logger.error(f"Error processing offline queue: {str(e)}")
+            log_to_salesforce(request_data["inspection_id"], request_data["payload"], str(e), "Failed")
             offline_queue.put(request_data)
 
 def log_to_salesforce(inspection_id, payload, response, status):
+    """Log request and response to Salesforce DiagnosisLog__c."""
     log_data = {
         "TreeInspection__c": inspection_id,
         "PayloadSent__c": json.dumps(payload),
@@ -229,6 +304,7 @@ def log_to_salesforce(inspection_id, payload, response, status):
             f.write("\n")
 
 def update_salesforce_record(inspection_id, response):
+    """Update TreeInspection__c record in Salesforce with Hugging Face prediction data."""
     disease = response.get("disease_prediction")
     if not disease or not isinstance(disease, str):
         logger.warning(f"Invalid or missing disease_prediction in response: {response}. Defaulting to 'Unknown'.")
@@ -269,6 +345,7 @@ def update_salesforce_record(inspection_id, response):
             f.write("\n")
 
 def create_salesforce_case(inspection_id, response):
+    """Create a follow-up case in Salesforce."""
     disease = response.get("disease_prediction", "Unknown")
     if not isinstance(disease, str) or disease not in disease_recommendations:
         logger.warning(f"Invalid disease for case creation: {disease}. Using 'Unknown'.")
@@ -302,6 +379,7 @@ def create_salesforce_case(inspection_id, response):
             f.write("\n")
 
 def create_salesforce_inspection_record(tree_type, location, date, region, officer, field_team):
+    """Create a new TreeInspection__c record in Salesforce."""
     inspection_id = str(uuid.uuid4())
     record_data = {
         "TreeName__c": tree_type or "Not provided",
@@ -325,11 +403,12 @@ def create_salesforce_inspection_record(tree_type, location, date, region, offic
                 with open("offline_updates.json", "a") as f:
                     json.dump({"inspection_id": inspection_id, "data": record_data}, f)
                     f.write("\n")
+                return inspection_id
         else:
             with open("offline_updates.json", "a") as f:
                 json.dump({"inspection_id": inspection_id, "data": record_data}, f)
                 f.write("\n")
-        return inspection_id
+            return inspection_id
     except Exception as e:
         logger.error(f"Error creating Salesforce inspection record: {str(e)}")
         with open("offline_updates.json", "a") as f:
@@ -338,6 +417,7 @@ def create_salesforce_inspection_record(tree_type, location, date, region, offic
         return inspection_id
 
 def integrate_hf_with_salesforce(inspection_id, image_base64, tree_type, location, date, region, officer, field_team):
+    """Integrate Hugging Face prediction with Salesforce by saving records."""
     try:
         if not HF_API_TOKEN:
             logger.warning("Hugging Face API token is missing. Skipping API call and queuing data.")
@@ -361,6 +441,8 @@ def integrate_hf_with_salesforce(inspection_id, image_base64, tree_type, locatio
 
         payload = {"image": image_base64}
         headers = {"Authorization": f"Bearer {HF_API_TOKEN}", "Content-Type": "application/json"}
+
+        # Call Hugging Face API with retry logic
         max_retries = 3
         for attempt in range(max_retries):
             try:
@@ -368,7 +450,7 @@ def integrate_hf_with_salesforce(inspection_id, image_base64, tree_type, locatio
                 response.raise_for_status()
                 break
             except requests.exceptions.RequestException as e:
-                logger.error(f"Hugging Face API call failed (Attempt {attempt + 1}/{max_retries}): {str(e)}")
+                logger.error(f"Hugging Face API call failed (Attempt {attempt + 1}/{max_retries}): {str(e)}, Response: {getattr(e.response, 'text', 'No response')}")
                 if attempt == max_retries - 1:
                     log_to_salesforce(inspection_id, payload, str(e), "Failed")
                     return None
@@ -376,15 +458,17 @@ def integrate_hf_with_salesforce(inspection_id, image_base64, tree_type, locatio
 
         try:
             hf_response = response.json()
+            logger.info(f"Hugging Face response for inspection {inspection_id}: {hf_response}")
             if "disease_prediction" not in hf_response or "confidence" not in hf_response:
-                logger.error(f"Invalid Hugging Face response format: {hf_response}")
+                logger.error(f"Invalid Hugging Face response format: {hf_response}. Expected 'disease_prediction' and 'confidence'.")
                 log_to_salesforce(inspection_id, payload, "Invalid response format", "Failed")
                 return None
         except json.JSONDecodeError as e:
-            logger.error(f"Failed to decode Hugging Face response: {str(e)}")
+            logger.error(f"Failed to decode Hugging Face response: {str(e)}, Raw response: {response.text}")
             log_to_salesforce(inspection_id, payload, str(e), "Failed")
             return None
 
+        # Validate and normalize disease name
         disease = hf_response.get("disease_prediction")
         if not disease or not isinstance(disease, str):
             logger.warning(f"Invalid or missing disease_prediction in response: {hf_response}. Defaulting to 'Unknown'.")
@@ -426,13 +510,13 @@ def integrate_hf_with_salesforce(inspection_id, image_base64, tree_type, locatio
                     }
                     log_response = requests.post(f"{SALESFORCE_API_URL}DiagnosisLog__c", headers=headers, json=log_data, timeout=10)
                     if log_response.status_code != 201:
-                        logger.error(f"Failed to log to DiagnosisLog__c: {log_response.text}")
+                        logger.error(f"Failed to log to DiagnosisLog__c: {log_response.text}, Status: {log_response.status_code}")
                     if disease in critical_diseases or confidence < 0.6:
                         create_salesforce_case(updated_id, {"disease_prediction": disease, "confidence": confidence})
                     return updated_id
                 else:
                     error_msg = create_response.text
-                    logger.error(f"Failed to save to Salesforce: {error_msg}")
+                    logger.error(f"Failed to save to Salesforce: {error_msg}, Status: {create_response.status_code}")
                     log_to_salesforce(inspection_id, payload, error_msg, "Failed")
                     return None
             else:
@@ -457,12 +541,15 @@ def predict_tree_disease(image=None, base64_image="", tree_type="", location="",
         start_time = time.time()
         inspection_id = create_salesforce_inspection_record(tree_type, location, date, region, officer, field_team)
 
+        # Encrypt sensitive data
         location_enc = encrypt_sensitive_data(location)
         officer_enc = encrypt_sensitive_data(officer)
 
+        # Validate input
         if image is None and not base64_image:
             return ("Error: No image or Base64 string provided.", None, None, None, None, None, None, None, None)
 
+        # Convert Base64 to PIL image if provided
         if base64_image:
             try:
                 image_data = base64.b64decode(base64_image)
@@ -472,6 +559,7 @@ def predict_tree_disease(image=None, base64_image="", tree_type="", location="",
         elif image is None:
             return ("Error: No valid image provided.", None, None, None, None, None, None, None, None)
 
+        # Validate and preprocess image
         image = image.convert("RGB")
         img_array = np.array(image)
         if img_array.ndim != 3 or img_array.shape[2] != 3:
@@ -480,6 +568,7 @@ def predict_tree_disease(image=None, base64_image="", tree_type="", location="",
         if image.size[0] < 224 or image.size[1] < 224:
             return ("Error: Image resolution too low. Minimum 224x224 required.", None, None, None, None, None, None, None, None)
 
+        # Preprocess image using ViTImageProcessor
         inputs = image_processor(images=image, return_tensors="pt")
         pixel_values = inputs["pixel_values"].squeeze(0).numpy()
         pixel_values = ((pixel_values - pixel_values.min()) * 255 / (pixel_values.max() - pixel_values.min())).astype(np.uint8)
@@ -489,13 +578,16 @@ def predict_tree_disease(image=None, base64_image="", tree_type="", location="",
         image_base64 = base64.b64encode(buffered.getvalue()).decode("utf-8")
         payload = {"image": image_base64}
 
+        # Debug: Log image shapes and payload
         logger.info(f"Original Image shape: {img_array.shape}")
         logger.info(f"Preprocessed Pixel Values shape: {pixel_values.shape}")
 
+        # Integrate with Hugging Face and save to Salesforce
         updated_id = integrate_hf_with_salesforce(inspection_id, image_base64, tree_type, location, date, region, officer, field_team)
         if not updated_id:
             return ("Error: Failed to integrate with Hugging Face and save to Salesforce. Check logs for details.", None, None, None, None, None, None, None, None)
 
+        # Fetch the saved record to get prediction data
         if is_online and SALESFORCE_ACCESS_TOKEN:
             headers = {"Authorization": f"Bearer {SALESFORCE_ACCESS_TOKEN}", "Content-Type": "application/json"}
             get_response = requests.get(f"{SALESFORCE_API_URL}TreeInspection__c/{updated_id}", headers=headers, timeout=10)
@@ -506,7 +598,7 @@ def predict_tree_disease(image=None, base64_image="", tree_type="", location="",
                 treatment = record.get("TreatmentPlan__c", "")
                 fertilizer = record.get("Fertilizer__c", "")
             else:
-                logger.error(f"Failed to retrieve Salesforce record: {get_response.text}")
+                logger.error(f"Failed to retrieve Salesforce record: {get_response.text}, Status: {get_response.status_code}")
                 predicted_label = "Unknown"
                 confidence_score = 0.0
                 treatment = ""
@@ -517,10 +609,12 @@ def predict_tree_disease(image=None, base64_image="", tree_type="", location="",
             treatment = ""
             fertilizer = ""
 
+        # Convert image to JPEG for Base64 output
         buffered_output = BytesIO()
         image.save(buffered_output, format="JPEG")
         output_base64 = base64.b64encode(buffered_output.getvalue()).decode("utf-8")
 
+        # Format metadata
         metadata_summary = (
             f"Tree Type: {tree_type or 'Not provided'}\n"
             f"Location: {decrypt_sensitive_data(location_enc) or 'Not provided'}\n"
@@ -530,6 +624,7 @@ def predict_tree_disease(image=None, base64_image="", tree_type="", location="",
             f"Field Team: {field_team or 'Not provided'}"
         )
 
+        # Alert Generation
         alert_status = "No alert triggered."
         logger.info(f"Checking alert: predicted_label={predicted_label}, confidence_score={confidence_score}")
         if predicted_label in critical_diseases or confidence_score < 0.6:
@@ -550,6 +645,7 @@ def predict_tree_disease(image=None, base64_image="", tree_type="", location="",
             prediction_logs.append(case_details)
             logger.info(f"Added to prediction_logs: {case_details}")
 
+        # Ensure prediction_logs has at least one entry for testing
         if not prediction_logs:
             prediction_logs.append({
                 "case_id": str(uuid.uuid4()),
@@ -565,6 +661,7 @@ def predict_tree_disease(image=None, base64_image="", tree_type="", location="",
             })
             logger.info("Added default entry to prediction_logs")
 
+        # Save prediction log locally
         try:
             with open("prediction_logs.json", "w") as f:
                 json.dump(prediction_logs, f, indent=2)
@@ -572,6 +669,7 @@ def predict_tree_disease(image=None, base64_image="", tree_type="", location="",
         except Exception as e:
             logger.error(f"Error saving prediction log: {str(e)}")
 
+        # Check response time
         response_time = time.time() - start_time
         if response_time > 5:
             logger.warning(f"Response time {response_time:.2f} seconds exceeds 5-second requirement.")
@@ -595,29 +693,35 @@ def generate_report():
     if not prediction_logs:
         logger.info("No data available for reporting.")
         return "Tree Health Report:\n\nNo data available for reporting."
+    
     regions = {}
     diseases = {}
     confidences = []
     fertilizers = {}
     critical_alerts = 0
+
     for log in prediction_logs:
         region = log["region"]
         disease = log["disease"]
         confidence = log["confidence"]
         fertilizer = disease_recommendations.get(disease, {}).get("fertilizer", "Unknown")
+        
         regions[region] = regions.get(region, 0) + 1
         diseases[disease] = diseases.get(disease, 0) + 1
         confidences.append(confidence)
         fertilizers[fertilizer] = fertilizers.get(fertilizer, 0) + 1
         if disease in critical_diseases or confidence < 0.6:
             critical_alerts += 1
+
     report = "Tree Health Report:\n\n"
     report += "1. Tree Inspection Volume by Region (Last 30 Days):\n"
     for region, count in regions.items():
         report += f"  - {region}: {count} inspections\n"
+    
     report += "\n2. Most Frequent Diseases (Last 90 Days):\n"
     for disease, count in sorted(diseases.items(), key=lambda x: x[1], reverse=True)[:5]:
         report += f"  - {disease}: {count} cases\n"
+    
     report += "\n3. Confidence Distribution (Last 30 Days):\n"
     confidence_bins = {"0.5-0.7": 0, "0.7-0.9": 0, "0.9-1.0": 0}
     for c in confidences:
@@ -629,9 +733,11 @@ def generate_report():
             confidence_bins["0.9-1.0"] += 1
     for bin_range, count in confidence_bins.items():
         report += f"  - {bin_range}: {count} cases\n"
+    
     report += "\n4. Fertilizer Usage (Last 60 Days):\n"
     for fertilizer, count in sorted(fertilizers.items(), key=lambda x: x[1], reverse=True):
         report += f"  - {fertilizer}: {count} recommendations\n"
+    
     report += f"\n5. Critical Disease Alerts: {critical_alerts} alerts\n"
     logger.info(f"Generated report with {len(regions)} regions, {len(diseases)} diseases")
     return report
@@ -640,27 +746,33 @@ def render_dashboard(region_filter="", officer_filter="", field_team_filter=""):
     if not prediction_logs:
         logger.info("No data available for dashboard.")
         return "Tree Health Intelligence Dashboard:\n\nNo data available for dashboard."
+    
     filtered_logs = [log for log in prediction_logs if
                      (not region_filter or log["region"] == region_filter) and
                      (not officer_filter or log["officer"] == decrypt_sensitive_data(officer_filter)) and
                      (not field_team_filter or log["field_team"] == field_team_filter)]
+    
     if not filtered_logs:
         logger.info("No data matches the selected filters.")
         return "Tree Health Intelligence Dashboard:\n\nNo data matches the selected filters."
+    
     dashboard = "Tree Health Intelligence Dashboard:\n\n"
     dashboard += f"Total Entries: {len(filtered_logs)}\n"
+    
     regions = {}
     for log in filtered_logs:
         regions[log["region"]] = regions.get(log["region"], 0) + 1
     dashboard += "\nRegional Activity:\n"
     for region, count in regions.items():
         dashboard += f"  - {region}: {count} inspections\n"
+    
     diseases = {}
     for log in filtered_logs:
         diseases[log["disease"]] = diseases.get(log["disease"], 0) + 1
     dashboard += "\nDisease Patterns:\n"
     for disease, count in sorted(diseases.items(), key=lambda x: x[1], reverse=True):
         dashboard += f"  - {disease}: {count} cases\n"
+    
     confidence_bins = {"0.5-0.7": 0, "0.7-0.9": 0, "0.9-1.0": 0}
     for log in filtered_logs:
         c = log["confidence"]
@@ -673,6 +785,7 @@ def render_dashboard(region_filter="", officer_filter="", field_team_filter=""):
     dashboard += "\nModel Confidence Spread:\n"
     for bin_range, count in confidence_bins.items():
         dashboard += f"  - {bin_range}: {count} cases\n"
+    
     fertilizers = {}
     for log in filtered_logs:
         fertilizer = disease_recommendations.get(log["disease"], {}).get("fertilizer", "Unknown")
@@ -680,29 +793,29 @@ def render_dashboard(region_filter="", officer_filter="", field_team_filter=""):
     dashboard += "\nFertilizer Insights:\n"
     for fertilizer, count in sorted(fertilizers.items(), key=lambda x: x[1], reverse=True):
         dashboard += f"  - {fertilizer}: {count} recommendations\n"
+    
     critical_cases = [log for log in filtered_logs if log["disease"] in critical_diseases or log["confidence"] < 0.6]
     dashboard += f"\nCritical Disease Alerts: {len(critical_cases)} alerts\n"
     for log in critical_cases[:5]:
         dashboard += f"  - {log['disease']} (Confidence: {log['confidence']:.2f}) at {log['timestamp']}\n"
+    
     logger.info(f"Generated dashboard with {len(filtered_logs)} entries")
     return dashboard
 
 def offline_queue_processor():
+    """Process offline queue and sync logs when online."""
     while True:
         if check_network_status() and SALESFORCE_ACCESS_TOKEN and HF_API_TOKEN:
             sync_offline_logs()
             process_offline_queue()
         time.sleep(RETRY_INTERVAL)
 
-def check_and_sync():
-    if check_network_status() and authenticate_salesforce():
-        sync_offline_logs()
-        process_offline_queue()
-
+# Initialize Salesforce authentication
 if not authenticate_salesforce():
-    logger.warning("Salesforce authentication failed initially. Retrying in background.")
-threading.Thread(target=retry_authentication_periodically, daemon=True).start()
-threading.Thread(target=lambda: [check_and_sync(), time.sleep(60)], daemon=True).start()
+    logger.warning("Salesforce authentication failed. Running in offline mode.")
+
+# Start offline queue processor
+threading.Thread(target=offline_queue_processor, daemon=True).start()
 
 iface = gr.Interface(
     fn=predict_tree_disease,