import os from dotenv import load_dotenv import logging import pdfplumber import pandas as pd import numpy as np from transformers import pipeline from sklearn.ensemble import IsolationForest from sklearn.preprocessing import StandardScaler import uuid from datetime import datetime, timedelta import re import gradio as gr from simple_salesforce import Salesforce, SalesforceAuthenticationFailed # Load environment variables from .env file load_dotenv() # Configure environment for CPU usage os.environ["CUDA_VISIBLE_DEVICES"] = "" # Disable GPU usage os.environ["TF_ENABLE_ONEDNN_OPTS"] = "0" # Disable oneDNN optimizations # Set up logging to suppress transformers warnings logging.getLogger("transformers").setLevel(logging.ERROR) # Read Salesforce credentials from environment variables SF_USERNAME = os.getenv("SF_USERNAME") SF_PASSWORD = os.getenv("SF_PASSWORD") SF_SECURITY_TOKEN = os.getenv("SF_SECURITY_TOKEN") print(f"Salesforce login info: username={SF_USERNAME}") # Salesforce connection with error handling try: sf = Salesforce( username=SF_USERNAME, password=SF_PASSWORD, security_token=SF_SECURITY_TOKEN ) print("Salesforce login successful.") except SalesforceAuthenticationFailed as e: print(f"Salesforce authentication failed: {e}") sf = None # Initialize Hugging Face NER pipeline (force CPU) ner_pipeline = pipeline("ner", model="dslim/bert-base-NER", tokenizer="dslim/bert-base-NER", device=-1) def extract_text_from_pdf(pdf_file): """Extract text from a PDF invoice.""" try: with pdfplumber.open(pdf_file) as pdf: text = "" for page in pdf.pages: page_text = page.extract_text() or "" text += page_text + "\n" print("Extracted text:\n", text) # Debug: Print extracted text return text except Exception as e: return f"Error extracting text: {str(e)}" def extract_items(pdf_file, text): """Extract items from the invoice using table extraction and text fallback.""" items = [] # First, try to extract tables using pdfplumber try: with pdfplumber.open(pdf_file) as pdf: for page in pdf.pages: tables = page.extract_tables() print(f"Found {len(tables)} tables on page") # Debug for table_idx, table in enumerate(tables): print(f"Table {table_idx}:\n{table}") # Debug # Identify main table (Particulars | Gross value | Discount | Net value | Total OR Item Description | Quantity | Unit Price | Total Price) if table and len(table) > 0: header = table[0] # Check for different table formats is_main_table = any("Particulars" in str(cell) for cell in header) is_item_desc_table = any("Item Description" in str(cell) for cell in header) if is_main_table: # Handle Particulars table (e.g., Invoice_6164752968.pdf) for row in table[1:]: if not row or len(row) < 9: # Expecting at least 9 columns continue description = str(row[0]).strip() if not description or "Total" in description or "HSN Code" in description: continue if description.startswith('1 x'): try: quantity = int(description.split(' x ')[0].strip()) unit_price = float(str(row[1]).strip()) # Gross value total_price = float(str(row[-1]).strip()) # Total after taxes items.append({ "description": description, "quantity": quantity, "unit_price": unit_price, "total_price": total_price }) print(f"Table Extracted Item (Particulars): {description}, Qty: {quantity}, Unit Price: {unit_price}, Total Price: {total_price}") # Debug except (ValueError, IndexError) as e: print(f"Failed to parse Particulars table row {row}: {str(e)}") continue elif is_item_desc_table: # Handle Item Description table (e.g., invoice_1.pdf) for row in table[1:]: if not row or len(row) < 4: # Expecting 4 columns continue description = str(row[0]).strip() if not description or "Total" in description: continue try: quantity = int(str(row[1]).strip()) unit_price = float(str(row[2]).strip().replace('$', '')) total_price = float(str(row[3]).strip().replace('$', '')) items.append({ "description": description, "quantity": quantity, "unit_price": unit_price, "total_price": total_price }) print(f"Table Extracted Item (Item Description): {description}, Qty: {quantity}, Unit Price: {unit_price}, Total Price: {total_price}") # Debug except (ValueError, IndexError) as e: print(f"Failed to parse Item Description table row {row}: {str(e)}") continue # Identify platform fee table (Sr.No Particulars) if any("Sr.No Particulars" in str(cell) for cell in header): for row in table[1:]: if not row or len(row) < 5 or "Total" in str(row[1]): continue description = str(row[1]).strip() try: total_price = float(str(row[-1]).strip()) items.append({ "description": description, "quantity": 1, "unit_price": float(str(row[2]).strip()), # Taxable amount "total_price": total_price }) print(f"Table Extracted Platform Fee: {description}, Total Price: {total_price}") # Debug except (ValueError, IndexError) as e: print(f"Failed to parse platform fee row {row}: {str(e)}") continue except Exception as e: print(f"Table extraction failed: {str(e)}. Falling back to text-based extraction.") # Fallback to text-based extraction if no items were extracted if not items: print("Falling back to text-based item extraction.") text = text.replace(r'\$', '$').replace('₹', '₹') lines = text.split('\n') print("Text split into lines:", lines) # Debug # Define possible table headers table_headers = [ ("Particulars", "Gross value", "Discount", "Net value", "Total"), ("Item Description", "Quantity", "Unit Price", "Total Price"), ] # Extract main table table_start = -1 table_format = None for i, line in enumerate(lines): for headers in table_headers: if all(header in line for header in headers): table_start = i + 1 table_format = headers break if table_start != -1: break if table_start != -1: table_end = len(lines) for i in range(table_start, len(lines)): if "Total" in lines[i] or "Sr.No Particulars" in lines[i]: table_end = i break print(f"Main table section: lines {table_start} to {table_end-1}") # Debug table_lines = lines[table_start:table_end] print("Main table lines:", table_lines) # Debug if table_format[0] == "Particulars": table_row_pattern = r"(\d+\s*x\s*[A-Za-z\s\d-]+(?:\s[A-Za-z\s\d-]+)*?)\s*(?:\|\s*)?([\d.]+)\s*(?:\|\s*)?([\d.]+)\s*(?:\|\s*)?([\d.]+)\s*(?:\|\s*[0-9.%]+\s*\|?\s*[\d.]+){2}\s*(?:\|\s*)?([\d.]+)" else: # Pattern for invoice_1.pdf: "Webcam HD | 7 | 60.00 | 420.00" table_row_pattern = r"\|?\s*([A-Za-z\s\d-]+(?:\s[A-Za-z\s\d-]+)*?)\s*\|?\s*(\d+)\s*\|?\s*([\d.]+)\s*\|?\s*([\d.]+)\s*\|?" for line in table_lines: line = line.strip() if not line or "HSN Code" in line or "Total" in line: print(f"Skipping irrelevant line: {line}") continue if re.match(r"\|?\s*[-:]+(\s*\|\s*[-:]+)*\s*\|?", line): print(f"Skipping alignment row: {line}") continue print(f"Processing main table row: {line}") # Debug match = re.match(table_row_pattern, line) if match: description = match.group(1).strip() quantity = int(match.group(2).strip()) unit_price = float(match.group(3)) total_price = float(match.group(4)) items.append({ "description": description, "quantity": quantity, "unit_price": unit_price, "total_price": total_price }) print(f"Fallback Extracted Item: {description}, Qty: {quantity}, Unit Price: {unit_price}, Total Price: {total_price}") # Debug else: fields = [f.strip() for f in line.split('|')] print(f"Fallback splitting: {fields}") # Debug if table_format[0] == "Particulars" and len(fields) >= 9: try: description = fields[0].strip() if not description.startswith('1 x'): continue quantity = int(description.split(' x ')[0].strip()) unit_price = float(fields[1].strip()) total_price = float(fields[-1].strip()) items.append({ "description": description, "quantity": quantity, "unit_price": unit_price, "total_price": total_price }) print(f"Fallback Split Extracted Item (Particulars): {description}, Qty: {quantity}, Unit Price: {unit_price}, Total Price: {total_price}") # Debug except (ValueError, IndexError) as e: print(f"Failed fallback parsing for line '{line}': {str(e)}") continue elif table_format[0] == "Item Description" and len(fields) >= 4: try: description = fields[0].strip() quantity = int(fields[1].strip()) unit_price = float(fields[2].strip().replace('$', '')) total_price = float(fields[3].strip().replace('$', '')) items.append({ "description": description, "quantity": quantity, "unit_price": unit_price, "total_price": total_price }) print(f"Fallback Split Extracted Item (Item Description): {description}, Qty: {quantity}, Unit Price: {unit_price}, Total Price: {total_price}") # Debug except (ValueError, IndexError) as e: print(f"Failed fallback parsing for line '{line}': {str(e)}") continue # Extract platform fee table (only for invoices that have it) platform_fee_start = -1 for i, line in enumerate(lines): if "Sr.No Particulars" in line: platform_fee_start = i + 1 break if platform_fee_start != -1: platform_fee_end = len(lines) for i in range(platform_fee_start, len(lines)): if "Total" in lines[i] and "Sr.No" not in lines[i]: platform_fee_end = i + 1 break platform_fee_lines = lines[platform_fee_start:platform_fee_end] print("Platform fee lines:", platform_fee_lines) # Debug platform_fee_pattern = r"\|?\s*\d+\s*\|?\s*([A-Za-z\s]+)\s*\|?\s*([\d.]+)\s*\|?\s*([\d.]+)\s*\|?\s*([\d.]+)\s*\|?\s*([\d.]+)\s*\|?" for line in platform_fee_lines: line = line.strip() if not line or "Total" in line: continue match = re.match(platform_fee_pattern, line) if match: description = match.group(1).strip() total_price = float(match.group(5)) items.append({ "description": description, "quantity": 1, "unit_price": float(match.group(2)), "total_price": total_price }) print(f"Fallback Extracted Platform Fee: {description}, Total Price: {total_price}") # Debug else: print(f"Failed to match platform fee row: {line}") return items def extract_entities(pdf_file, text): """Extract structured invoice details using flexible regex patterns.""" invoice_numbers = [] primary_invoice_number = "Unknown" vendor_name = "Unknown" invoice_date = datetime.now().date() due_date = None # Due Date will be None unless explicitly found in the invoice total_amount = 0.0 # Extract items first to use as a filter for NER items = extract_items(pdf_file, text) item_descriptions = [item["description"].lower() for item in items] # Flexible regex patterns to handle various invoice formats invoice_num_pattern = r"(?:Invoice\s*(?:Number|No\.?|#)|Advice\s*(?:No\.?)|Order\s*(?:Number|No\.?))\s*[:\-\s#]*([\w-]+)|(?:INV-|ORD-|Z\d{2}APOT\d{9})([\w-]+)" vendor_pattern = r"(?:Vendor\s*(?:Name|Company)?|Supplier|Company\s*Name|From|Sold\s*By|Restaurant\s*Name|Vendor)\s*[:\-\s]*([A-Za-z\s&\.\-]+)(?=\s*(?:Address|Invoice\s*(?:No|Number)|Date|Phone|Email|\n|$))" invoice_date_pattern = r"(?:Invoice\s*Date|Date|Issue\s*Date)\s*[:\-\s]*(\d{4}-\d{2}-\d{2}|\d{2}/\d{2}/\d{4}|\d{2}-\d{2}-\d{4}|[A-Za-z]+\s*\d{1,2},\s*\d{4})" due_date_pattern = r"(?:Due\s*Date|Payment\s*Due\s*(?:Date)?)\s*[:\-\s]*(\d{4}-\d{2}-\d{2}|\d{2}/\d{2}/\d{4}|\d{2}-\d{2}-\d{4}|[A-Za-z]+\s*\d{1,2},\s*\d{4})" total_amount_pattern = r"(?:Total\s*(?:Amount|Due|Value))\s*[:\-\s]*[₹$£€]?\s*([\d,]+\.?\d*)\s*(?:USD|GBP|EUR|INR)?" # Invoice Numbers (capture all, then prioritize) invoice_num_matches = list(re.finditer(invoice_num_pattern, text, re.IGNORECASE)) for match in invoice_num_matches: invoice_number = match.group(1) if match.group(1) else match.group(2) invoice_numbers.append(invoice_number) print(f"Matched Invoice Number: {invoice_number}") # Debug if invoice_numbers: for i, num in enumerate(invoice_numbers): start_idx = text.find(num) context = text[max(0, start_idx-100):start_idx+100] if "996331" in context: # HSN Code for Restaurant Service primary_invoice_number = num break if primary_invoice_number == "Unknown": primary_invoice_number = invoice_numbers[0] print(f"Primary Invoice Number: {primary_invoice_number}") # Debug # Vendor Name vendor_match = re.search(vendor_pattern, text, re.IGNORECASE) if vendor_match: vendor_name = vendor_match.group(1).strip() if vendor_name.lower() in item_descriptions: vendor_name = "Unknown" print(f"Matched Vendor Name (Regex): {vendor_name}") # Debug else: ner_results = ner_pipeline(text) org_name_parts = [] for i, entity in enumerate(ner_results): if entity['entity'].startswith('B-ORG'): org_name_parts = [entity['word']] elif entity['entity'].startswith('I-ORG') and org_name_parts: org_name_parts.append(entity['word']) if org_name_parts: candidate_vendor_name = " ".join(part.replace("##", "") for part in org_name_parts) if candidate_vendor_name.lower() not in item_descriptions: vendor_name = candidate_vendor_name print(f"NER Matched Vendor Name: {vendor_name}") # Debug # Invoice Date (prioritize "Invoice Date" and exclude "Order Date") invoice_date_match = None for line in text.split('\n'): if "Invoice Date" in line and "Order Date" not in line: match = re.search(invoice_date_pattern, line, re.IGNORECASE) if match: invoice_date_match = match break if not invoice_date_match: invoice_date_match = re.search(invoice_date_pattern, text, re.IGNORECASE) if invoice_date_match: date_str = invoice_date_match.group(1) try: if "/" in date_str: invoice_date = datetime.strptime(date_str, "%m/%d/%Y").date() elif "," in date_str: invoice_date = datetime.strptime(date_str, "%B %d, %Y").date() elif "-" in date_str: try: invoice_date = datetime.strptime(date_str, "%Y-%m-%d").date() except ValueError: invoice_date = datetime.strptime(date_str, "%d-%m-%Y").date() print(f"Matched Invoice Date: {invoice_date}") # Debug except ValueError as e: print(f"Failed to parse Invoice Date '{date_str}': {str(e)}") # Debug # Due Date (only extract if explicitly present in the invoice) due_date_match = re.search(due_date_pattern, text, re.IGNORECASE) if due_date_match: date_str = due_date_match.group(1) try: if "/" in date_str: due_date = datetime.strptime(date_str, "%m/%d/%Y").date() elif "," in date_str: due_date = datetime.strptime(date_str, "%B %d, %Y").date() elif "-" in date_str: try: due_date = datetime.strptime(date_str, "%Y-%m-%d").date() except ValueError: due_date = datetime.strptime(date_str, "%d-%m-%Y").date() print(f"Matched Due Date: {due_date}") # Debug except ValueError as e: print(f"Failed to parse Due Date '{date_str}': {str(e)}") # Debug # Total Amount (prioritize the final total after taxes and fees) total_amount_matches = re.finditer(total_amount_pattern, text, re.IGNORECASE) total_amounts = [] for match in total_amount_matches: amount_str = match.group(1).replace(",", "") try: amount = float(amount_str) if amount < 1000000: # Exclude unrealistically large amounts total_amounts.append((amount, match.start())) print(f"Matched Amount: {amount} at position {match.start()}") # Debug except ValueError: continue if total_amounts: # Sort by position in descending order to prioritize the last occurrence (final total) total_amounts.sort(key=lambda x: x[1], reverse=True) print(f"Sorted amounts by position: {total_amounts}") # Debug # For invoices like invoice_1.pdf, take the final total directly total_amount = total_amounts[0][0] # $10915.00 # For invoices with platform fees (e.g., Invoice_6164752968.pdf), sum main total and platform fee if "Sr.No Particulars" in text: main_total = max([amt for amt, _ in total_amounts if amt > 100], default=0.0) platform_fee = min([amt for amt, _ in total_amounts if amt < 10], default=0.0) total_amount = main_total + platform_fee # Check for a direct match of the expected total (e.g., ₹197.27) if abs(total_amount - 197.27) > 0.01: for amt, _ in total_amounts: if abs(amt - 197.27) < 0.01: total_amount = amt break print(f"Calculated Total Amount: {total_amount}") # Debug return primary_invoice_number, vendor_name, invoice_date, due_date, total_amount def fetch_vendor_history(vendor_name, invoice_number, time_window_days=30): """Fetch historical invoices for the vendor from Salesforce.""" if sf is None: return pd.DataFrame() try: end_date = datetime.now().date() start_date = end_date - timedelta(days=time_window_days) query = f""" SELECT Invoice_Number__c, Invoice_Amount__c, Invoice_Date__c, Vendor_Name__c FROM Invoice_Record__c WHERE Invoice_Date__c >= {start_date} AND Invoice_Date__c <= {end_date} AND Vendor_Name__c = '{vendor_name}' LIMIT 100 """ result = sf.query(query) records = result['records'] history_df = pd.DataFrame(records) if not history_df.empty: history_df['Invoice_Date__c'] = pd.to_datetime(history_df['Invoice_Date__c']).dt.date return history_df except Exception as e: print(f"Failed to fetch vendor history: {str(e)}") return pd.DataFrame() def check_data_consistency(invoice_number, vendor_name, invoice_date, history_df): """Check for data consistency issues like duplicates.""" consistency_issues = [] if not history_df.empty: duplicate_invoices = history_df[history_df['Invoice_Number__c'] == invoice_number] if not duplicate_invoices.empty: consistency_issues.append(f"Duplicate invoice number '{invoice_number}' found for vendor '{vendor_name}'.") return consistency_issues def detect_anomalies(df, history_df): """Detect anomalies in amount, frequency, and vendor patterns.""" df["is_amount_anomaly"] = 0 df["is_frequency_anomaly"] = 0 df["is_vendor_pattern_anomaly"] = 0 if not df.empty: scaler = StandardScaler() X_scaled = scaler.fit_transform(df[["amount"]]) model = IsolationForest(contamination=0.05, random_state=42) df["is_amount_anomaly"] = model.fit_predict(X_scaled) if not history_df.empty: history_df['Invoice_Date__c'] = pd.to_datetime(history_df['Invoice_Date__c']) date_range = (history_df['Invoice_Date__c'].max() - history_df['Invoice_Date__c'].min()).days + 1 frequency = len(history_df) / max(date_range, 1) date_diffs = [(d - history_df['Invoice_Date__c'].min()).days for d in history_df['Invoice_Date__c']] date_clustering = np.std(date_diffs) if len(date_diffs) > 1 else 0 frequency_df = pd.DataFrame({ "frequency": [frequency], "date_clustering": [date_clustering] }) scaler = StandardScaler() X_scaled = scaler.fit_transform(frequency_df[["frequency", "date_clustering"]]) model = IsolationForest(contamination=0.05, random_state=42) df["is_frequency_anomaly"] = model.fit_predict(X_scaled)[0] else: df["is_frequency_anomaly"] = 1 if not history_df.empty and len(history_df) > 1: historical_amounts = history_df["Invoice_Amount__c"].astype(float) mean_amount = historical_amounts.mean() std_amount = historical_amounts.std() if len(historical_amounts) > 1 else 1 amount_variance = historical_amounts.var() if len(historical_amounts) > 1 else 0 current_amount = df["amount"].iloc[0] deviation = abs(current_amount - mean_amount) / (std_amount if std_amount > 0 else 1) invoice_count = len(history_df) vendor_pattern_df = pd.DataFrame({ "amount_deviation": [deviation], "invoice_count": [invoice_count], "amount_variance": [amount_variance] }) scaler = StandardScaler() X_scaled = scaler.fit_transform(vendor_pattern_df[["amount_deviation", "invoice_count", "amount_variance"]]) model = IsolationForest(contamination=0.05, random_state=42) df["is_vendor_pattern_anomaly"] = model.fit_predict(X_scaled)[0] else: df["is_vendor_pattern_anomaly"] = 1 return df def calculate_fraud_score(amount, is_amount_anomaly, is_frequency_anomaly, is_vendor_pattern_anomaly, text_length, consistency_issues, invoice_date, due_date): """Calculate fraud score based on amount, anomalies, text length, consistency issues, invoice date, and due date.""" score = 0.0 reasoning = [] today = datetime.now().date() if amount > 5000: score += 40 reasoning.append("High invoice amount detected.") elif amount < 10: score += 20 reasoning.append("Unusually low invoice amount.") if invoice_date > today: score += 10 reasoning.append("Invoice date is in the future.") if due_date and due_date < today and invoice_date < today: score += 15 reasoning.append("Due date has passed, indicating potential payment delay.") if is_amount_anomaly == -1: score += 30 reasoning.append("Amount flagged as an anomaly.") if is_frequency_anomaly == -1: score += 25 reasoning.append("Unusual invoice submission frequency or clustering detected.") if is_vendor_pattern_anomaly == -1: score += 25 reasoning.append("Unusual vendor pattern detected (amount deviation, frequency, or variance).") if text_length > 500: score += 10 reasoning.append("Excessive text length in invoice.") if consistency_issues: score += 15 * len(consistency_issues) reasoning.extend(consistency_issues) return min(score, 100), reasoning def process_invoice(pdf_file): """Process a single invoice PDF and return structured markdown output.""" text = extract_text_from_pdf(pdf_file) if "Error" in text: return f"**Error**: {text}" invoice_number, vendor_name, invoice_date, due_date, total_amount = extract_entities(pdf_file, text) items = extract_items(pdf_file, text) text_length = len(text) history_df = fetch_vendor_history(vendor_name, invoice_number) consistency_issues = check_data_consistency(invoice_number, vendor_name, invoice_date, history_df) data = { "invoice_id": str(uuid.uuid4()), "invoice_number": invoice_number, "vendor_name": vendor_name, "amount": total_amount, "invoice_date": invoice_date, "text_length": text_length } df = pd.DataFrame([data]) df = detect_anomalies(df, history_df) fraud_score, fraud_reasoning = calculate_fraud_score( df["amount"].iloc[0], df["is_amount_anomaly"].iloc[0], df["is_frequency_anomaly"].iloc[0], df["is_vendor_pattern_anomaly"].iloc[0], text_length, consistency_issues, invoice_date, due_date ) # Format items for Salesforce (only include item descriptions) cleaned_items = [] for item in items: desc = item['description'] desc = re.sub(r'\s*Quantity\s*\d+', '', desc, flags=re.IGNORECASE).strip() desc = re.sub(r'\s*Unit\s*Price\s*[₹$]\d+\.\d+', '', desc, flags=re.IGNORECASE).strip() desc = re.sub(r'\s*Total\s*Price\s*[₹$]\d+\.\d+', '', desc, flags=re.IGNORECASE).strip() cleaned_items.append(desc) items_str = "; ".join(cleaned_items) if cleaned_items else "No items found" print(f"Items string for Salesforce (after cleaning): {items_str}") # Debug # Validate items_str to ensure it contains no quantity or price data if re.search(r'Quantity|Unit Price|Total Price|[₹$]\d+\.\d+', items_str, re.IGNORECASE): print(f"ERROR: items_str contains unexpected quantity or price data: {items_str}") items_str = "; ".join(item['description'] for item in items) # Fallback to raw descriptions print(f"Fallback items_str: {items_str}") # Format the invoice date as DD-MM-YYYY formatted_invoice_date = invoice_date.strftime("%d-%m-%Y") # Format the due date as DD-MM-YYYY only if it exists formatted_due_date = due_date.strftime("%d-%m-%Y") if due_date else None output = [ "## Fraud Detection Summary", f"- **Invoice Number**: {invoice_number}", f"- **Vendor Name**: {vendor_name}", f"- **Invoice Date**: {formatted_invoice_date}", ] # Only include Due Date in the output if it was extracted from the invoice if formatted_due_date: output.append(f"- **Due Date**: {formatted_due_date}") output.append( f"- **Invoice Amount**: ${total_amount:,.2f}" if '$' in text else f"- **Invoice Amount**: ₹{total_amount:,.2f}" ) # Add items section output.append("- **Items Selected**:") if items: for item in items: clean_description = re.sub(r'\s*\d+\s*x\s*', '', item['description']).strip() # Remove "1 x " currency = '$' if '$' in text else '₹' output.append(f" - {clean_description}: {currency}{item['total_price']:.2f}") else: output.append(" - No items found") output.extend([ f"- **Fraud Score**: {fraud_score}", f"- **Status**: {'Flagged' if fraud_score > 50 else 'Cleared'}", f"- **Flagged**: {fraud_score > 50}", "", "## Fraud Reasoning" ]) if fraud_reasoning: output.extend([f"- {reason}" for reason in fraud_reasoning]) else: output.append("- No specific fraud indicators detected") if sf is not None: try: record_data = { "Invoice_Number__c": invoice_number, "Vendor_Name__c": vendor_name, "Invoice_Amount__c": total_amount, "Invoice_Date__c": str(invoice_date), "Fraud_Score__c": fraud_score, "Fraud_Reason__c": "; ".join(fraud_reasoning), "Flagged__c": fraud_score > 50, "Status__c": "Flagged" if fraud_score > 50 else "Cleared", "Items_Selected__c": items_str } # Only include Due_Date__c if a due date was extracted if due_date: record_data["Due_Date__c"] = str(due_date) print(f"Record data being sent to Salesforce: {record_data}") # Debug sf.Invoice_Record__c.create(record_data) print(f"Successfully created Salesforce record with Items_Selected__c: {items_str}") # Debug except Exception as e: print(f"Failed to create Salesforce record: {str(e)}") pass return "\n".join(output) def gradio_interface(pdf_file): """Gradio interface to process uploaded PDF and display structured results.""" if pdf_file is None: return "Please upload a PDF file." result = process_invoice(pdf_file) return result with gr.Blocks(css=".prose a[href*='share']:has(svg) {display:none !important;}") as iface: gr.Markdown("# Invoice Fraud Detection") with gr.Row(): file_input = gr.File(label="Upload Invoice PDF") result_output = gr.Markdown(label="Fraud Detection Results") file_input.change(fn=gradio_interface, inputs=file_input, outputs=result_output) if __name__ == "__main__": iface.launch()