Update app.py

app.py

@@ -15,8 +15,8 @@ from utils import extract_kyc_fields
 SF_USERNAME = "[email protected]"
 SF_PASSWORD = "Lic@2025"
 SF_SECURITY_TOKEN = "AmmfRcd6IiYaRtSGntBnzNMQU"
-SF_DOMAIN = "login"   # "login" for prod, "test" for sandbox
-SF_API_VERSION = "60.0"  # safe current Partner/REST version
+SF_DOMAIN = "login"   # "login" for prod, "test" for sandbox (we will auto-try both)
+SF_API_VERSION = "60.0"  # REST & Partner SOAP API version
 # -------------------------------------------------------------------------------
 
 
@@ -57,14 +57,12 @@ def _parse_birthdate(dob_text: str):
     return None
 
 
-def _soap_login(username: str, password: str, token: str, domain: str = "login", api_version: str = SF_API_VERSION):
+def _soap_login_once(username: str, password: str, domain: str, api_version: str):
     """
-    Login via Salesforce Partner SOAP API (no connected app needed).
-    Returns (instance_url, access_token) on success; raises on error.
+    One SOAP login attempt with given password (already concatenated or not).
+    Returns (instance_url, session_id) on success; raises RuntimeError on failure with fault details.
     """
     endpoint = f"https://{domain}.salesforce.com/services/Soap/u/{api_version}"
-    combined_password = f"{password}{token}"
-
     envelope = f"""<?xml version="1.0" encoding="utf-8" ?>
 <env:Envelope xmlns:xsd="http://www.w3.org/2001/XMLSchema"
               xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
@@ -72,7 +70,7 @@ def _soap_login(username: str, password: str, token: str, domain: str = "login",
   <env:Body>
     <n1:login xmlns:n1="urn:partner.soap.sforce.com">
       <n1:username>{username}</n1:username>
-      <n1:password>{combined_password}</n1:password>
+      <n1:password>{password}</n1:password>
     </n1:login>
   </env:Body>
 </env:Envelope>"""
@@ -84,7 +82,12 @@ def _soap_login(username: str, password: str, token: str, domain: str = "login",
 
     resp = requests.post(endpoint, data=envelope.encode("utf-8"), headers=headers, timeout=30)
     if resp.status_code != 200:
-        raise RuntimeError(f"SOAP login HTTP {resp.status_code}: {resp.text[:400]}")
+        # Try to parse a SOAP fault if present
+        faultcode, faultstring = _extract_fault(resp.text)
+        msg = f"HTTP {resp.status_code}"
+        if faultcode or faultstring:
+            msg += f" | faultcode={faultcode} | faultstring={faultstring}"
+        raise RuntimeError(msg)
 
     # Parse XML to find sessionId and serverUrl
     try:
@@ -92,7 +95,6 @@ def _soap_login(username: str, password: str, token: str, domain: str = "login",
     except ET.ParseError as e:
         raise RuntimeError(f"SOAP login parse error: {e}")
 
-    # Find tags by localname to avoid namespace headaches
     session_id = None
     server_url = None
     for elem in root.iter():
@@ -103,16 +105,68 @@ def _soap_login(username: str, password: str, token: str, domain: str = "login",
             server_url = elem.text
 
     if not session_id or not server_url:
-        raise RuntimeError(f"SOAP login failed: sessionId/serverUrl not found. Raw: {resp.text[:600]}")
+        faultcode, faultstring = _extract_fault(resp.text)
+        raise RuntimeError(f"SOAP login failed: sessionId/serverUrl not found | faultcode={faultcode} | faultstring={faultstring}")
 
     parsed = urlparse(server_url)
     instance_url = f"{parsed.scheme}://{parsed.netloc}"
     return instance_url, session_id
 
 
-def _rest_create(instance_url: str, access_token: str, object_api: str, payload: dict, api_version: str = SF_API_VERSION):
+def _extract_fault(xml_text: str):
     """
-    Create a record via REST API. Returns a dict with success flag and details.
+    Extract SOAP faultcode and faultstring for clearer errors.
+    """
+    try:
+        root = ET.fromstring(xml_text)
+    except Exception:
+        return None, None
+    faultcode = None
+    faultstring = None
+    for elem in root.iter():
+        tag = elem.tag.split('}', 1)[-1]
+        if tag == "faultcode":
+            faultcode = elem.text
+        elif tag == "faultstring":
+            faultstring = elem.text
+    return faultcode, faultstring
+
+
+def soap_login_all_paths(username: str, password: str, token: str, preferred_domain: str = "login", api_version: str = SF_API_VERSION):
+    """
+    Try multiple safe login permutations:
+      1) preferred_domain with password+token
+      2) preferred_domain with password only
+      3) alternate domain with password+token
+      4) alternate domain with password only
+
+    Returns (instance_url, session_id, diagnostics) on success.
+    On failure, raises RuntimeError with aggregated diagnostics.
+    """
+    domains = [preferred_domain] + [d for d in ["login", "test"] if d != preferred_domain]
+    attempts = []
+    for domain in domains:
+        for mode in ["pw_token", "pw_only"]:
+            pw = f"{password}{token}" if mode == "pw_token" else password
+            try:
+                instance_url, session_id = _soap_login_once(username, pw, domain, api_version)
+                diag = {"domain": domain, "mode": mode, "result": "success"}
+                attempts.append(diag)
+                return instance_url, session_id, attempts
+            except Exception as e:
+                # Collect reason but keep trying
+                attempts.append({"domain": domain, "mode": mode, "result": "fail", "reason": str(e)})
+
+    # If we’re here, all attempts failed
+    raise RuntimeError(json.dumps({
+        "message": "All SOAP login attempts failed",
+        "attempts": attempts
+    }))
+
+
+def rest_create(instance_url: str, access_token: str, object_api: str, payload: dict, api_version: str = SF_API_VERSION):
+    """
+    Create a record via REST API. Returns dict with success flag and full details.
     """
     url = f"{instance_url}/services/data/v{api_version}/sobjects/{object_api}"
     headers = {
@@ -130,7 +184,6 @@ def _rest_create(instance_url: str, access_token: str, object_api: str, payload:
         rec_id = body.get("id") if isinstance(body, dict) else None
         return {"success": True, "id": rec_id, "status_code": resp.status_code, "url": url, "response_json": body}
     else:
-        # Salesforce error lists come back as JSON arrays usually
         return {
             "success": False,
             "status_code": resp.status_code,
@@ -143,7 +196,7 @@ def _rest_create(instance_url: str, access_token: str, object_api: str, payload:
 def sf_push_kyc_record(ocr_results: dict):
     """
     Combine Aadhaar + PAN into one KYC_Record__c and create via REST.
-    Fields expected in SF (API names):
+    Fields expected (API names):
       Aadhaar_Number__c, Aadhaar_Name__c, Aadhaar_DOB__c (Date)
       PAN_Number__c,    Pan_Name__c,     Pan_DOB__c     (Date)
     """
@@ -168,17 +221,21 @@ def sf_push_kyc_record(ocr_results: dict):
     }
     payload = {k: v for k, v in payload.items() if v is not None}
 
-    # 1) SOAP login
-    instance_url, access_token = _soap_login(SF_USERNAME, SF_PASSWORD, SF_SECURITY_TOKEN, SF_DOMAIN, SF_API_VERSION)
+    # 1) SOAP login (auto-tries domains & password modes)
+    instance_url, access_token, diagnostics = soap_login_all_paths(
+        SF_USERNAME, SF_PASSWORD, SF_SECURITY_TOKEN, preferred_domain=SF_DOMAIN, api_version=SF_API_VERSION
+    )
     # 2) REST create
-    return _rest_create(instance_url, access_token, "KYC_Record__c", payload, SF_API_VERSION)
+    rest_res = rest_create(instance_url, access_token, "KYC_Record__c", payload, SF_API_VERSION)
+    rest_res["login_diagnostics"] = diagnostics
+    return rest_res
 
 
 # ---------- gradio callback ----------
 def process_documents(aadhaar_file, pan_file, push_to_sf):
     """
     - Runs OCR on Aadhaar and PAN separately.
-    - Optionally pushes a single KYC_Record__c to Salesforce via SOAP+REST (no simple-salesforce).
+    - Optionally pushes a single KYC_Record__c to Salesforce via SOAP+REST.
     """
     results = {"aadhaar": None, "pan": None}
 
@@ -210,7 +267,10 @@ def process_documents(aadhaar_file, pan_file, push_to_sf):
             created = sf_push_kyc_record(results)
             output["salesforce"] = {"pushed": created.get("success", False), **created}
         except Exception as e:
-            output["salesforce"] = {"pushed": False, "error": {"type": e.__class__.__name__, "message": str(e)}}
+            output["salesforce"] = {
+                "pushed": False,
+                "error": {"type": e.__class__.__name__, "message": str(e)}
+            }
 
     return output
 
@@ -250,10 +310,11 @@ with gr.Blocks(title="Smart KYC OCR → Salesforce (KYC_Record__c)") as demo:
     gr.Markdown("---")
     gr.Markdown(
         """
-        You’ll see `status_code`, `url`, and Salesforce’s `response_json` on errors (e.g., wrong field API name or permissions).
+        On failure you’ll see a `login_diagnostics` list (each attempt with domain+mode+reason)
+        and REST `status_code/url/response_json`. This eliminates the SDK TypeError and pinpoints issues fast.
         """
     )
 
-# Keep `demo` at module level for Spaces too
+# Keep `demo` available for local run / Spaces
 if __name__ == "__main__":
     demo.launch()