Update app.py

app.py

@@ -5,11 +5,6 @@ from transformers import pipeline
 from simple_salesforce import Salesforce
 from dotenv import load_dotenv
 import base64
-import logging
-
-# Configure logging
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
-logger = logging.getLogger(__name__)
 
 # Load environment variables from .env
 load_dotenv()
@@ -18,178 +13,88 @@ load_dotenv()
 SF_USERNAME = os.getenv("SF_USERNAME")
 SF_PASSWORD = os.getenv("SF_PASSWORD")
 SF_SECURITY_TOKEN = os.getenv("SF_SECURITY_TOKEN")
-SF_INSTANCE_URL = os.getenv("SF_INSTANCE_URL", "https://login.salesforce.com")
+SF_LOGIN_URL = os.getenv("SF_LOGIN_URL", "https://login.salesforce.com")
 SF_OBJECT_NAME = os.getenv("SF_OBJECT_NAME", "Agent_Prospect__c")
 SF_SCORE_FIELD = os.getenv("SF_SCORE_FIELD", "Suitability_Score__c")
 SF_LINK_FIELD = os.getenv("SF_RESUME_FIELD_LINK", "Resume_File_Link__c")
-SF_OUTPUT_FIELD = os.getenv("SF_OUTPUT_FIELD", "Processing_Output__c")
 SF_RECORD_ID = os.getenv("SF_RECORD_ID")
 
 # Validate required credentials
 required = ["SF_USERNAME", "SF_PASSWORD", "SF_SECURITY_TOKEN", "SF_RECORD_ID"]
 missing = [var for var in required if not os.getenv(var)]
 if missing:
-    error_msg = f"Missing required .env variables: {', '.join(missing)}"
-    logger.error(error_msg)
-    raise ValueError(error_msg)
+    raise ValueError(f"Missing required .env variables: {', '.join(missing)}")
+
+# Determine domain
+domain = "login" if "login" in SF_LOGIN_URL else "test"
 
 # Connect to Salesforce
-try:
-    sf = Salesforce(
-        username=SF_USERNAME,
-        password=SF_PASSWORD,
-        security_token=SF_SECURITY_TOKEN,
-        instance_url=SF_INSTANCE_URL
-    )
-    logger.info("Successfully connected to Salesforce")
-except Exception as e:
-    error_msg = f"Failed to connect to Salesforce: {str(e)}"
-    logger.error(error_msg)
-    raise Exception(error_msg)
+sf = Salesforce(
+    username=SF_USERNAME,
+    password=SF_PASSWORD,
+    security_token=SF_SECURITY_TOKEN,
+    domain=domain
+)
 
 # Load Hugging Face model
-try:
-    classifier = pipeline("text-classification", model="nlptown/bert-base-multilingual-uncased-sentiment")
-    logger.info("Hugging Face model loaded successfully")
-except Exception as e:
-    error_msg = f"Failed to load Hugging Face model: {str(e)}"
-    logger.error(error_msg)
-    raise Exception(error_msg)
+classifier = pipeline("text-classification", model="nlptown/bert-base-multilingual-uncased-sentiment")
 
 def process_resume(file):
     try:
         record_id = SF_RECORD_ID
-        logger.info(f"Processing resume for record ID: {record_id}")
-
-        # Validate file
-        if not file:
-            output = "❌ No file uploaded."
-            logger.error(output)
-            update_salesforce_output(record_id, output)
-            return output
 
         # Extract text from PDF
-        try:
-            with pdfplumber.open(file.name) as pdf:
-                extracted_text = "\n".join([page.extract_text() or "" for page in pdf.pages])
-            logger.info("PDF text extracted successfully")
-        except Exception as e:
-            output = f"❌ Failed to extract text from PDF: {str(e)}"
-            logger.error(output)
-            update_salesforce_output(record_id, output)
-            return output
+        with pdfplumber.open(file.name) as pdf:
+            extracted_text = "\n".join([page.extract_text() or "" for page in pdf.pages])
 
         if not extracted_text.strip():
-            output = "❌ No extractable text found in the PDF."
-            logger.warning(output)
-            update_salesforce_output(record_id, output)
-            return output
+            return "❌ No extractable text found in the PDF."
 
         # Call Hugging Face model
-        try:
-            result = classifier(extracted_text[:1000])
-            label = result[0]['label']
-            score = round(float(result[0]['score']) * 100, 2)
-            summary = f"Predicted Label: {label}\nSuitability Score: {score:.2f}"
-            logger.info(f"Model prediction: {summary}")
-        except Exception as e:
-            output = f"❌ Failed to process text with model: {str(e)}"
-            logger.error(output)
-            update_salesforce_output(record_id, output)
-            return output
+        result = classifier(extracted_text[:1000])
+        label = result[0]['label']
+        score = round(float(result[0]['score']) * 100, 2)
+        summary = f"Predicted Label: {label}\nSuitability Score: {score:.2f}"
 
         # Encode PDF in base64
-        try:
-            with open(file.name, "rb") as f:
-                encoded_pdf = base64.b64encode(f.read()).decode("utf-8")
-            logger.info("PDF encoded successfully")
-        except Exception as e:
-            output = f"❌ Failed to encode PDF: {str(e)}"
-            logger.error(output)
-            update_salesforce_output(record_id, output)
-            return output
+        with open(file.name, "rb") as f:
+            encoded_pdf = base64.b64encode(f.read()).decode("utf-8")
 
         # Upload file as ContentVersion
-        try:
-            content_result = sf.ContentVersion.create({
-                "Title": "Resume",
-                "PathOnClient": file.name,
-                "VersionData": encoded_pdf
-            })
-            version_id = content_result.get("id")
-            logger.info(f"ContentVersion created with ID: {version_id}")
-        except Exception as e:
-            output = f"❌ Failed to upload file to Salesforce: {str(e)}"
-            logger.error(output)
-            update_salesforce_output(record_id, output)
-            return output
+        content_result = sf.ContentVersion.create({
+            "Title": "Resume",
+            "PathOnClient": file.name,
+            "VersionData": encoded_pdf
+        })
 
         # Get ContentDocumentId from ContentVersion
-        try:
-            query_result = sf.query(
-                f"SELECT ContentDocumentId FROM ContentVersion WHERE Id = '{version_id}'"
-            )
-            content_doc_id = query_result["records"][0]["ContentDocumentId"]
-            logger.info(f"ContentDocumentId retrieved: {content_doc_id}")
-        except Exception as e:
-            output = f"❌ Failed to retrieve ContentDocumentId: {str(e)}"
-            logger.error(output)
-            update_salesforce_output(record_id, output)
-            return output
+        version_id = content_result.get("id")
+        query_result = sf.query(
+            f"SELECT ContentDocumentId FROM ContentVersion WHERE Id = '{version_id}'"
+        )
+        content_doc_id = query_result["records"][0]["ContentDocumentId"]
 
         # Link file to Salesforce record
-        try:
-            sf.ContentDocumentLink.create({
-                "ContentDocumentId": content_doc_id,
-                "LinkedEntityId": record_id,
-                "ShareType": "V",
-                "Visibility": "AllUsers"
-            })
-            logger.info("ContentDocument linked to record")
-        except Exception as e:
-            output = f"❌ Failed to link document to record: {str(e)}"
-            logger.error(output)
-            update_salesforce_output(record_id, output)
-            return output
+        sf.ContentDocumentLink.create({
+            "ContentDocumentId": content_doc_id,
+            "LinkedEntityId": record_id,
+            "ShareType": "V",
+            "Visibility": "AllUsers"
+        })
 
         # Create download link
-        download_link = f"{SF_INSTANCE_URL}/sfc/servlet.shepherd/document/download/{content_doc_id}"
-        logger.info(f"Download link generated: {download_link}")
-
-        # Prepare output for Salesforce
-        output = f"{summary}\n\n✅ Score and resume uploaded to Salesforce.\n📎 Download Resume: {download_link}"
-
-        # Update record with score, link, and output
-        try:
-            sf.__getattr__(SF_OBJECT_NAME).update(record_id, {
-                SF_SCORE_FIELD: score,
-                SF_LINK_FIELD: download_link,
-                SF_OUTPUT_FIELD: output
-            })
-            logger.info("Salesforce record updated successfully")
-        except Exception as e:
-            output = f"❌ Failed to update Salesforce record: {str(e)}"
-            logger.error(output)
-            update_salesforce_output(record_id, output)
-            return output
-
-        return output
+        download_link = f"https://{sf.sf_instance}/sfc/servlet.shepherd/document/download/{content_doc_id}"
 
-    except Exception as e:
-        output = f"❌ Unexpected error: {str(e)}"
-        logger.error(output)
-        update_salesforce_output(record_id, output)
-        return output
-
-def update_salesforce_output(record_id, output):
-    """Helper function to update Salesforce record with output in case of errors"""
-    try:
+        # Update record with score and link
         sf.__getattr__(SF_OBJECT_NAME).update(record_id, {
-            SF_OUTPUT_FIELD: output
+            SF_SCORE_FIELD: score,
+            SF_LINK_FIELD: download_link
         })
-        logger.info("Salesforce record updated with error output")
+
+        return f"{summary}\n\n✅ Score and resume uploaded to Salesforce.\n📎 [Download Resume]({download_link})"
+
     except Exception as e:
-        logger.error(f"Failed to update Salesforce with error output: {str(e)}")
+        return f"❌ Error: {str(e)}"
 
 # Gradio Interface
 gr.Interface(
@@ -197,5 +102,5 @@ gr.Interface(
     inputs=gr.File(label="Upload Resume (PDF)", file_types=[".pdf"]),
     outputs="text",
     title="LIC Resume AI Scorer",
-    description="Upload a resume PDF. It will be scored, stored in Salesforce, and the output will be saved."
-).launch(share=False)
+    description="Upload a resume PDF. It will be scored and stored in Salesforce automatically."
+).launch(share=False)