Update app.py

app.py

@@ -1,89 +1,14 @@
-import gradio as gr
-from PIL import Image, ImageDraw
-import torch
-from torchvision import models, transforms
-from simple_salesforce import Salesforce
-import base64
-from io import BytesIO
-import json
-from datetime import datetime
 import logging
 import requests
-from fpdf import FPDF
 
 # Setup logging
 logging.basicConfig(level=logging.INFO)
 
-# Salesforce Credentials
-SALESFORCE_USERNAME = "drone@sathkrutha.com"
-SALESFORCE_PASSWORD = "Komal1303@"
-SALESFORCE_SECURITY_TOKEN = "53AWRskW9EjWUsSL5LU6nFTy3"
-SALESFORCE_INSTANCE_URL = "https://sathikrutha-a-dev-ed.my.salesforce.com"
-
-# Replace with a valid Site__c record ID from your Salesforce org
-SITE_RECORD_ID = "a003000000xxxxx"  # TODO: Update with actual ID from Site__c
-
-# Connect to Salesforce
-try:
-    sf = Salesforce(
-        username=SALESFORCE_USERNAME,
-        password=SALESFORCE_PASSWORD,
-        security_token=SALESFORCE_SECURITY_TOKEN,
-        instance_url=SALESFORCE_INSTANCE_URL
-    )
-    logging.info("Salesforce connection established.")
-except Exception as e:
-    logging.error(f"Failed to connect to Salesforce: {str(e)}")
-    raise Exception(f"Failed to connect to Salesforce: {str(e)}")
-
-# Load model from Hugging Face (Assuming you have a YOLOv8 model hosted)
 MODEL_URL = "https://huggingface.co/your_huggingface_model_path"  # Replace with actual model URL
 HEADERS = {
     "Authorization": "Bearer YOUR_HUGGINGFACE_API_KEY"  # Replace with your Hugging Face API key
 }
 
-# Image transformations
-transform = transforms.Compose([
-    transforms.ToTensor(),
-])
-
-# Function to generate PDF report
-def generate_pdf_report(faults):
-    pdf = FPDF()
-    pdf.set_auto_page_break(auto=True, margin=15)
-    pdf.add_page()
-
-    pdf.set_font("Arial", size=12)
-    pdf.cell(200, 10, txt="Drone Fault Detection Report", ln=True, align='C')
-    
-    pdf.ln(10)
-    pdf.cell(200, 10, txt="Faults Detected:", ln=True)
-
-    for fault in faults:
-        pdf.cell(200, 10, txt=f"Defect: {fault['type']}, Severity: {fault['severity']}, Confidence: {fault['confidence']}", ln=True)
-
-    return pdf
-
-# Function to upload image to Salesforce as ContentVersion
-def upload_image_to_salesforce(image, filename="detected_image.jpg", record_id=None):
-    try:
-        buffered = BytesIO()
-        image.save(buffered, format="JPEG")
-        img_data = base64.b64encode(buffered.getvalue()).decode("utf-8")
-        
-        content_version = sf.ContentVersion.create({
-            "Title": filename,
-            "PathOnClient": filename,
-            "VersionData": img_data,
-            "FirstPublishLocationId": record_id if record_id else None
-        })
-        logging.info(f"Image uploaded to Salesforce with ContentVersion ID: {content_version['id']}")
-        return content_version["id"]
-    except Exception as e:
-        logging.error(f"Failed to upload image to Salesforce: {str(e)}")
-        raise Exception(f"Failed to upload image to Salesforce: {str(e)}")
-
-# Detect defects and integrate with Salesforce
 def detect_defects(image):
     if not image:
         return None, "No image provided"
@@ -96,7 +21,22 @@ def detect_defects(image):
 
         # Send image to Hugging Face hosted model for detection (assuming YOLOv8 model)
         response = requests.post(MODEL_URL, headers=HEADERS, json={"inputs": img_data})
-        response_data = response.json()
+
+        # Debugging the raw response
+        logging.info(f"Response Status Code: {response.status_code}")
+        logging.info(f"Response Text: {response.text}")  # Log the raw response
+
+        # Check for valid response
+        if response.status_code != 200:
+            logging.error(f"Error in API request: {response.status_code}")
+            return None, f"API Error: {response.status_code}"
+
+        # Attempt to parse the JSON response
+        try:
+            response_data = response.json()
+        except ValueError:
+            logging.error("API response is not valid JSON")
+            return None, "API response is not valid JSON"
 
         # Assuming response is a list of detected objects with bounding boxes, labels, and scores
         faults = []
@@ -119,79 +59,13 @@ def detect_defects(image):
             draw.rectangle(box, outline="red", width=3)
             draw.text((box[0], box[1]), f"{fault['type']}: {fault['severity']}", fill="red")
 
-        # Create Salesforce record if detections exist
-        if faults:
-            try:
-                current_date = datetime.now().strftime("%Y-%m-%d")
-                inspection_name = f"Inspection-{current_date}-{len(faults):03d}"
-
-                # Creating the Salesforce record with updated fields
-                inspection_record = sf.Drone_Structure_Inspection__c.create({
-                    "Inspection_Date__c": current_date,
-                    "Fault_Type__c": faults[0]["type"],  # Mapping defect type
-                    "Severity__c": faults[0]["severity"],  # Mapping severity
-                    "Fault_Summary__c": "\n".join([f"{fault['type']} (Confidence: {fault['confidence']})" for fault in faults]),  # Summarizing the defects
-                    "Status__c": "New",  # Default status
-                    "Annotated_Image_URL__c": "",  # Placeholder for image URL
-                    "Report_PDF__c": ""  # Placeholder for report PDF URL
-                })
-
-                record_id = inspection_record.get("id")
-                content_version_id = upload_image_to_salesforce(
-                    result_image,
-                    filename=f"detected_defect_{record_id}.jpg",
-                    record_id=record_id
-                )
-
-                # Generate and upload the PDF report
-                pdf = generate_pdf_report(faults)
-                pdf_output = "/tmp/report.pdf"
-                pdf.output(pdf_output)
-
-                # Upload the PDF report to Salesforce (ContentVersion)
-                with open(pdf_output, "rb") as f:
-                    report_data = f.read()
-
-                pdf_data = base64.b64encode(report_data).decode("utf-8")
-                content_version = sf.ContentVersion.create({
-                    "Title": f"Report_{record_id}.pdf",
-                    "PathOnClient": f"Report_{record_id}.pdf",
-                    "VersionData": pdf_data,
-                    "FirstPublishLocationId": record_id
-                })
-
-                if content_version:
-                    sf.Drone_Structure_Inspection__c.update(record_id, {
-                        "Report_PDF__c": f"/sfc/servlet.shepherd/version/download/{content_version['id']}",
-                        "Annotated_Image_URL__c": f"/sfc/servlet.shepherd/version/download/{content_version_id}"
-                    })
-
-                faults.append(f"Salesforce record ID: {record_id}")
-            except Exception as e:
-                faults.append(f"Failed to create Salesforce record: {str(e)}")
-
         # Return a more readable, text-based format instead of JSON
         result_text = "\nDetected Faults and Severities:\n"
         for fault in faults:
-            result_text += f"- {fault}\n"
+            result_text += f"- {fault['type']} (Confidence: {fault['confidence']}, Severity: {fault['severity']})\n"
 
         return result_image, result_text
 
     except Exception as e:
         logging.error(f"Processing failed: {str(e)}")
         return None, f"Processing failed: {str(e)}"
-
-# Gradio Interface
-demo = gr.Interface(
-    fn=detect_defects,
-    inputs=gr.Image(type="pil", label="Upload Drone Image"),
-    outputs=[
-        gr.Image(label="Detection Result"),
-        gr.Textbox(label="Detected Faults with Severity", lines=10)  # Updated to use text output
-    ],
-    title="Structural Defect Detection with Salesforce Integration",
-    description="Detects objects using YOLOv8 or Faster R-CNN hosted on Hugging Face and stores results in Salesforce. Fine-tune the model for structural defects like cracks, rust, and spalling."
-)
-
-if __name__ == "__main__":
-    demo.launch()