Create app.py

app.py

@@ -0,0 +1,514 @@
+import os
+import time
+import logging
+from logging.handlers import RotatingFileHandler
+import re
+from datetime import datetime
+from dotenv import load_dotenv
+from cryptography.fernet import Fernet
+from simple_salesforce import Salesforce
+from transformers import pipeline, AutoTokenizer, AutoModelForSeq2SeqLM
+from sentence_transformers import SentenceTransformer, util
+from PIL import Image
+import pytesseract
+import pandas as pd
+from docx import Document
+import PyPDF2
+import gradio as gr
+from pdf2image import convert_from_path
+import tempfile
+from pytz import timezone
+import shutil
+
+# Setup logging with rotation
+log_file = os.path.join(tempfile.gettempdir(), 'app.log')
+handler = RotatingFileHandler(log_file, maxBytes=10*1024*1024, backupCount=5)
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    handlers=[
+        handler,
+        logging.StreamHandler()
+    ]
+)
+logger = logging.getLogger(__name__)
+
+# Check dependencies at startup
+def check_dependencies():
+    missing_deps = []
+    try:
+        import pytesseract, pandas, openpyxl, xlrd, docx, PyPDF2, pdf2image
+        # Check Tesseract
+        try:
+            tesseract_path = shutil.which('tesseract')
+            if tesseract_path:
+                pytesseract.pytesseract.tesseract_cmd = tesseract_path
+                tesseract_version = pytesseract.get_tesseract_version()
+                logger.info(f"Tesseract found at {tesseract_path}, version: {tesseract_version}")
+            else:
+                logger.warning("Tesseract not found in PATH. Install with 'sudo apt install tesseract-ocr'. OCR-dependent files (JPEG, PNG, scanned PDFs) will not be processed.")
+                missing_deps.append("Tesseract")
+        except Exception as e:
+            logger.warning(f"Tesseract unavailable: {str(e)}. Install with 'sudo apt install tesseract-ocr'. OCR-dependent files (JPEG, PNG, scanned PDFs) will not be processed.")
+            missing_deps.append("Tesseract")
+        # Check Poppler
+        try:
+            poppler_path = shutil.which('pdfinfo')
+            if poppler_path:
+                logger.info(f"Poppler found at {poppler_path}")
+            else:
+                logger.warning("Poppler not found in PATH. Install with 'sudo apt install poppler-utils'. Scanned PDFs will fail.")
+                missing_deps.append("Poppler")
+        except Exception as e:
+            logger.warning(f"Poppler unavailable: {str(e)}. Install with 'sudo apt install poppler-utils'. Scanned PDFs will fail.")
+            missing_deps.append("Poppler")
+        logger.info("Required Python packages installed")
+    except ImportError as e:
+        logger.error(f"Missing Python dependency: {str(e)}. Install via pip.")
+        raise ImportError(f"Missing Python dependency: {str(e)}")
+    return missing_deps
+
+missing_deps = check_dependencies()
+
+# Load environment variables
+load_dotenv()
+required_env_vars = [
+    'ENCRYPTION_KEY', 'SALESFORCE_USERNAME', 'SALESFORCE_PASSWORD',
+    'SALESFORCE_SECURITY_TOKEN', 'SALESFORCE_DOMAIN'
+]
+env = {var: os.getenv(var) for var in required_env_vars}
+if missing := [k for k in required_env_vars if not env[k]]:
+    logger.error(f"Missing environment variables: {', '.join(missing)}")
+    raise ValueError(f"Missing environment variables: {', '.join(missing)}")
+
+# Setup encryption
+try:
+    fernet = Fernet(env['ENCRYPTION_KEY'].encode())
+except Exception as e:
+    logger.error(f"Invalid encryption key: {e}")
+    raise ValueError(f"Invalid encryption key: {e}")
+
+# Salesforce connection retry
+def init_salesforce(max_retries=3, delay=3):
+    for attempt in range(max_retries):
+        try:
+            sf = Salesforce(
+                username=env['SALESFORCE_USERNAME'],
+                password=env['SALESFORCE_PASSWORD'],
+                security_token=env['SALESFORCE_SECURITY_TOKEN'],
+                domain=env['SALESFORCE_DOMAIN'],
+                version='58.0'
+            )
+            logger.info("Connected to Salesforce")
+            return sf
+        except Exception as e:
+            logger.error(f"Salesforce connection attempt {attempt + 1} failed: {str(e)}")
+            if attempt < max_retries - 1:
+                time.sleep(delay)
+    logger.error("Salesforce connection failed after retries")
+    raise ValueError("Salesforce connection failed after retries")
+
+# Initialize models
+def init_models():
+    try:
+        summarizer = pipeline(
+            "summarization",
+            model=AutoModelForSeq2SeqLM.from_pretrained("t5-base"),
+            tokenizer=AutoTokenizer.from_pretrained("t5-base")
+        )
+        sentence_model = SentenceTransformer('all-MiniLM-L6-v2')
+        logger.info("NLP models initialized successfully")
+        return summarizer, sentence_model
+    except Exception as e:
+        logger.error(f"Model initialization failed: {str(e)}")
+        raise
+
+# Clean text for better processing
+def clean_text(text):
+    try:
+        if not text:
+            return ""
+        text = re.sub(r'\s+', ' ', text.strip())  # Normalize whitespace
+        text = re.sub(r'[^\x00-\x7F]+', ' ', text)  # Remove non-ASCII
+        text = re.sub(r'\b\d+\b(?!\s*,\s*\d{4})', ' ', text)  # Remove standalone numbers
+        return text
+    except Exception as e:
+        logger.error(f"Text cleaning failed: {str(e)}")
+        return ""
+
+# Validate file readability
+def validate_file(file_path):
+    try:
+        ext = os.path.splitext(file_path)[1].lower()
+        if ext not in ['.pdf', '.docx', '.png', '.jpg', '.jpeg', '.csv', '.xls', '.xlsx']:
+            return False, f"Unsupported file type: {ext}"
+        if not os.path.exists(file_path):
+            return False, f"File not found: {file_path}"
+        if os.path.getsize(file_path) == 0:
+            return False, f"File is empty: {file_path}"
+        return True, None
+    except Exception as e:
+        logger.error(f"File validation failed for {file_path}: {str(e)}")
+        return False, f"File validation failed: {str(e)}"
+
+# Extract text from file
+def extract_text(file_path):
+    is_valid, error = validate_file(file_path)
+    if not is_valid:
+        logger.error(error)
+        return None, error
+    ext = os.path.splitext(file_path)[1].lower()
+    try:
+        logger.debug(f"Extracting text from {file_path} (type: {ext})")
+        if ext == '.pdf':
+            with open(file_path, 'rb') as f:
+                pdf_reader = PyPDF2.PdfReader(f)
+                text = "".join([p.extract_text() or "" for p in pdf_reader.pages])
+                if not text or len(text.strip()) < 50:
+                    logger.warning(f"PDF text extraction failed or too short, attempting OCR")
+                    if 'Tesseract' in missing_deps or 'Poppler' in missing_deps:
+                        return None, "OCR unavailable: Tesseract or Poppler not installed. Install with 'sudo apt install tesseract-ocr poppler-utils'."
+                    try:
+                        images = convert_from_path(file_path)
+                        text = ""
+                        for i, img in enumerate(images):
+                            logger.debug(f"Processing page {i+1} for OCR")
+                            img = img.convert('L')  # Convert to grayscale
+                            img = img.resize((img.width // 2, img.height // 2))  # Optimize size
+                            text += pytesseract.image_to_string(img, config='--psm 6') + "\n"
+                    except Exception as ocr_err:
+                        logger.error(f"OCR failed: {str(ocr_err)}")
+                        return None, f"OCR failed for {file_path}: {str(ocr_err)}"
+        elif ext == '.docx':
+            doc = Document(file_path)
+            text = "\n".join([p.text for p in doc.paragraphs if p.text])
+            for table in doc.tables:
+                for row in table.rows:
+                    for cell in row.cells:
+                        text += "\n" + cell.text
+        elif ext in ['.png', '.jpg', '.jpeg']:
+            if 'Tesseract' in missing_deps:
+                return None, "OCR unavailable: Tesseract not installed. Install with 'sudo apt install tesseract-ocr'."
+            try:
+                img = Image.open(file_path).convert('L')
+                img = img.resize((img.width // 2, img.height // 2))  # Optimize size
+                text = pytesseract.image_to_string(img, config='--psm 6')
+            except Exception as ocr_err:
+                logger.error(f"OCR failed for {file_path}: {str(ocr_err)}")
+                return None, f"OCR failed for {file_path}: {str(ocr_err)}"
+        elif ext in ['.csv', '.xls', '.xlsx']:
+            try:
+                df = pd.read_excel(file_path) if ext in ['.xls', '.xlsx'] else pd.read_csv(file_path)
+                logger.debug(f"Excel/CSV columns: {df.columns.tolist()}")
+                text = df.to_string(index=False)
+            except Exception as e:
+                logger.error(f"Excel/CSV processing failed for {file_path}: {str(e)}")
+                return None, f"Excel/CSV processing failed: {str(e)}"
+        text = clean_text(text)
+        if not text or len(text) < 50:
+            logger.error(f"Extracted text is empty or too short: {len(text)} characters")
+            return None, f"Text extraction failed: No valid text extracted from {file_path}"
+        logger.debug(f"Extracted text length: {len(text)} characters")
+        return text, None
+    except Exception as e:
+        logger.error(f"Text extraction failed for {file_path}: {str(e)}")
+        return None, f"Text extraction failed: {str(e)}"
+
+# Parse dates with IST timezone
+def parse_dates(text):
+    ist = timezone('Asia/Kolkata')
+    current_date = datetime.now(ist).replace(hour=18, minute=33, second=0, microsecond=0)  # 06:33 PM IST, June 26, 2025
+    try:
+        date_patterns = [
+            r'\b(?:Jan(?:uary)?|Feb(?:ruary)?|Mar(?:ch)?|Apr(?:il)?|May|Jun(?:e)?|Jul(?:y)?|Aug(?:ust)?|Sep(?:tember)?|Oct(?:ober)?|Nov(?:ember)?|Dec(?:ember)?)\s+\d{1,2}(?:-|\s*,?\s*)\d{4}\b',
+            r'\b\d{1,2}/\d{1,2}/\d{4}\b',
+            r'\b\d{4}-\d{2}-\d{2}\b',
+            r'\b(?:Jan(?:uary)?|Feb(?:ruary)?|Mar(?:ch)?|Apr(?:il)?|May|Jun(?:e)?|Jul(?:y)?|Aug(?:ust)?|Sep(?:tember)?|Oct(?:ober)?|Nov(?:ember)?|Dec(?:ember)?)\s*\d{4}\b',
+            r'\b\d{4}\b'
+        ]
+        dates = []
+        unparseable_dates = []
+        for pattern in date_patterns:
+            found_dates = re.findall(pattern, text, re.IGNORECASE)
+            dates.extend(found_dates)
+            if found_dates:
+                logger.debug(f"Found dates with pattern {pattern}: {found_dates}")
+        parsed_dates = []
+        for date in dates:
+            try:
+                if '/' in date:
+                    parsed = datetime.strptime(date, '%m/%d/%Y').replace(tzinfo=ist)
+                elif '-' in date and len(date.split('-')) == 3:
+                    parsed = datetime.strptime(date, '%Y-%m-%d').replace(tzinfo=ist)
+                elif re.match(r'\b\w+\s+\d{4}\b', date):
+                    month_year = re.sub(r'\s+', ' ', date.strip())
+                    parsed = datetime.strptime(month_year, '%b %Y').replace(day=1, tzinfo=ist)
+                elif ',' in date:
+                    parsed = datetime.strptime(date, '%B %d, %Y').replace(tzinfo=ist)
+                else:
+                    parsed = datetime.strptime(date, '%Y').replace(month=1, day=1, tzinfo=ist)
+                parsed_dates.append(parsed.strftime('%Y-%m-%d'))
+            except Exception as e:
+                logger.debug(f"Unparseable date '{date}': {str(e)}")
+                unparseable_dates.append(date)
+        if unparseable_dates:
+            logger.warning(f"Found {len(unparseable_dates)} unparseable dates: {unparseable_dates}")
+        if not parsed_dates:
+            logger.warning("No valid dates extracted, using current date")
+            parsed_dates.append(current_date.strftime('%Y-%m-%d'))
+        while len(parsed_dates) < 2:
+            parsed_dates.append(parsed_dates[0] if parsed_dates else current_date.strftime('%Y-%m-%d'))
+        logger.debug(f"Extracted {len(parsed_dates)} valid dates: {parsed_dates}")
+        return parsed_dates[:2]
+    except Exception as e:
+        logger.error(f"Date parsing failed: {str(e)}")
+        return [current_date.strftime('%Y-%m-%d'), current_date.strftime('%Y-%m-%d')]
+
+# Summarize contract
+def summarize_contract(text, summarizer, sentence_model):
+    aspects = ["parties", "payment terms", "obligations", "termination clauses"]
+    try:
+        if not text or len(text.strip()) < 50:
+            logger.error("Input text is empty or too short")
+            return {
+                "full_summary": "No summary generated due to insufficient text",
+                "aspect_summaries": {asp: "Not extracted" for asp in aspects},
+                "dates": parse_dates(text)
+            }, None
+        text = clean_text(text)[:4096]
+        try:
+            summary_result = summarizer(f"summarize: {text}", max_length=150, min_length=50, do_sample=False)[0]['summary_text']
+            if summary_result.strip() == text.strip()[:len(summary_result)]:
+                logger.warning("Summary identical to input, generating fallback")
+                summary_result = f"Summary: {text[:150]}..." if len(text) > 150 else text
+            logger.debug(f"Generated summary: {summary_result[:50]}...")
+            full_summary = summary_result
+        except Exception as e:
+            logger.error(f"Summarizer failed: {str(e)}")
+            full_summary = f"Summary failed: {text[:150]}..." if len(text) > 150 else text
+        aspect_summaries = {}
+        aspect_synonyms = {
+            "parties": ["contractor", "client", "party", "signatory", "entity"],
+            "payment terms": ["payment", "compensation", "fees", "billing", "invoicing"],
+            "obligations": ["duties", "responsibilities", "obligations", "commitments"],
+            "termination clauses": ["termination", "cancellation", "end of contract", "exit"]
+        }
+        if aspects:
+            sentences = [s.strip() for s in re.split(r'[.!?]+', text) if s.strip() and len(s.strip()) > 10]
+            if sentences:
+                logger.debug(f"Extracted {len(sentences)} sentences for aspect summarization")
+                emb = sentence_model.encode(sentences, convert_to_tensor=True)
+                for asp in aspects:
+                    asp_texts = [asp] + aspect_synonyms.get(asp, [])
+                    asp_embs = sentence_model.encode(asp_texts, convert_to_tensor=True)
+                    sims = util.cos_sim(asp_embs, emb).max(dim=0).values
+                    top = sims.argsort(descending=True)[:5]
+                    asp_text = ". ".join([sentences[i] for i in top if sims[i] > 0.05])
+                    if asp_text:
+                        aspect_summaries[asp] = asp_text[:200]
+                        logger.debug(f"Aspect '{asp}' matched {len([i for i in top if sims[i] > 0.05])} sentences")
+                    else:
+                        logger.warning(f"No sentences matched aspect '{asp}'")
+                        aspect_summaries[asp] = "Not extracted"
+            else:
+                logger.warning("No valid sentences for aspect summarization")
+                for asp in aspects:
+                    aspect_summaries[asp] = "Not extracted"
+        return {
+            "full_summary": full_summary,
+            "aspect_summaries": aspect_summaries,
+            "dates": parse_dates(text)
+        }, None
+    except Exception as e:
+        logger.error(f"Summarization failed: {str(e)}")
+        return {
+            "full_summary": f"Summary generation failed: {text[:150]}..." if len(text) > 150 else text,
+            "aspect_summaries": {asp: "Not extracted" for asp in aspects},
+            "dates": parse_dates(text)
+        }, None
+
+# Create Contract Document record
+def create_contract_document(sf, file_name, file_url=None):
+    ist = timezone('Asia/Kolkata')
+    current_time = datetime.now(ist).replace(hour=18, minute=33, second=0, microsecond=0)  # 06:33 PM IST, June 26, 2025
+    try:
+        escaped_file_name = file_name.replace("'", "\\'")
+        today_datetime = current_time.strftime('%Y-%m-%dT%H:%M:%SZ')
+        query_datetime = f"SELECT Id, Upload_Date__c FROM Contract_Document__c WHERE Name = '{escaped_file_name}' AND Upload_Date__c = {today_datetime} LIMIT 1"
+        logger.debug(f"Executing SOQL query (dateTime): {query_datetime}")
+        try:
+            result = sf.query(query_datetime)
+            if result['totalSize'] > 0:
+                doc_id = result['records'][0]['Id']
+                logger.info(f"Contract Document exists for {file_name} on {today_datetime}, ID {doc_id}")
+                return doc_id, None
+        except Exception as e:
+            logger.warning(f"dateTime query failed: {str(e)}. Trying Date format.")
+            today_date = current_time.strftime('%Y-%m-%d')
+            query_date = f"SELECT Id, Upload_Date__c FROM Contract_Document__c WHERE Name = '{escaped_file_name}' AND Upload_Date__c = '{today_date}' LIMIT 1"
+            logger.debug(f"Executing SOQL query (Date): {query_date}")
+            result = sf.query(query_date)
+            if result['totalSize'] > 0:
+                doc_id = result['records'][0]['Id']
+                logger.info(f"Contract Document exists for {file_name} on {today_date}, ID {doc_id}")
+                return doc_id, None
+        record = {
+            'Name': file_name,
+            'Document_URL__c': file_url or '',
+            'Upload_Date__c': today_datetime,
+            'Status__c': 'Uploaded'
+        }
+        result = sf.Contract_Document__c.create(record)
+        logger.info(f"Created Contract Document for {file_name} with ID {result['id']}")
+        return result['id'], None
+    except Exception as e:
+        logger.error(f"Failed to create Contract Document for {file_name}: {str(e)}")
+        return None, f"Failed to create Contract Document: {str(e)}"
+
+# Store summary in Salesforce
+def store_in_salesforce(sf, summary_data, file_name, contract_document_id):
+    try:
+        query = f"SELECT Id FROM Contract_Summary__c WHERE Contract_Document__c = '{contract_document_id}' LIMIT 1"
+        logger.debug(f"Executing SOQL query: {query}")
+        result = sf.query(query)
+        if result['totalSize'] > 0:
+            logger.info(f"Summary exists for Contract Document ID {contract_document_id}, ID {result['records'][0]['Id']}")
+            return {'id': result['records'][0]['Id']}, None
+        encrypted_summary = fernet.encrypt(summary_data['full_summary'].encode()).decode()
+        def truncate(text, length=2000):
+            return text[:length] if text else 'Not extracted'
+        record = {
+            'Name': file_name,
+            'Contract_Document__c': contract_document_id,
+            'Parties__c': truncate(summary_data['aspect_summaries'].get('parties', 'Not extracted')),
+            'Payment_Terms__c': truncate(summary_data['aspect_summaries'].get('payment terms', 'Not extracted')),
+            'Obligations__c': truncate(summary_data['aspect_summaries'].get('obligations', 'Not extracted')),
+            'Termination_Clause__c': truncate(summary_data['aspect_summaries'].get('termination clauses', 'Not extracted')),
+            'Custom_Field_1__c': encrypted_summary,
+            'Validation_Status__c': 'Pending',
+            'Start_Date__c': summary_data['dates'][0][:10] if summary_data['dates'] and len(summary_data['dates']) > 0 else None,
+            'End_Date__c': summary_data['dates'][1][:10] if summary_data['dates'] and len(summary_data['dates']) > 1 else summary_data['dates'][0][:10] if summary_data['dates'] else None,
+        }
+        logger.debug(f"Record to be created: {record}")
+        if not any(record.get(field) not in ['', 'Not extracted'] for field in ['Parties__c', 'Payment_Terms__c', 'Obligations__c', 'Termination_Clause__c']):
+            logger.warning(f"No valid aspects extracted for {file_name}, storing with full summary only")
+        result = sf.Contract_Summary__c.create(record)
+        logger.info(f"Stored summary for {file_name} with ID {result['id']}")
+        return result, None
+    except Exception as e:
+        logger.error(f"Failed to store summary for {file_name}: {str(e)}")
+        return None, f"Failed to store in Salesforce: {str(e)}. Check {log_file}"
+
+# Generate CSV report
+def generate_report(sf, output_file, contract_document_id):
+    try:
+        query = (
+            f"SELECT Id, Name, Parties__c, Payment_Terms__c, Obligations__c, Termination_Clause__c, Custom_Field_1__c, "
+            f"Validation_Status__c, Start_Date__c, End_Date__c "
+            f"FROM Contract_Summary__c WHERE Contract_Document__c = '{contract_document_id}' LIMIT 1"
+        )
+        logger.debug(f"Executing SOQL query: {query}")
+        results = sf.query(query)['records']
+        logger.info(f"Retrieved {len(results)} records for Contract_Document__c ID {contract_document_id}")
+        rows = []
+        for r in results:
+            try:
+                decrypted_summary = fernet.decrypt(r.get('Custom_Field_1__c', '').encode()).decode() if r.get('Custom_Field_1__c') else 'Not extracted'
+            except Exception as e:
+                logger.error(f"Decryption failed for record {r.get('Id', 'unknown')}: {str(e)}")
+                decrypted_summary = 'Decryption failed'
+            row = {
+                'Contract_Name': r.get('Name', 'Not extracted'),
+                'Parties': r.get('Parties__c', 'Not extracted')[:50],
+                'Payment_Terms': r.get('Payment_Terms__c', 'Not extracted')[:50],
+                'Obligations': r.get('Obligations__c', 'Not extracted')[:50],
+                'Termination_Clause': r.get('Termination_Clause__c', 'Not extracted')[:50],
+                'Full_Summary': decrypted_summary[:100],
+                'Validation_Status': r.get('Validation_Status__c', 'Not extracted'),
+                'Start_Date': r.get('Start_Date__c', 'Not extracted'),
+                'End_Date': r.get('End_Date__c', 'Not extracted'),
+            }
+            rows.append(row)
+        if not rows:
+            logger.warning(f"No summary found for Contract_Document__c ID {contract_document_id}")
+            return pd.DataFrame(columns=['Contract_Name', 'Parties', 'Payment_Terms', 'Obligations', 'Termination_Clause', 'Full_Summary', 'Validation_Status', 'Start_Date', 'End_Date']), None
+        df = pd.DataFrame(rows)
+        logger.info(f"Generated DataFrame with {len(df)} record(s) for {contract_document_id}")
+        df.to_csv(output_file, index=False, encoding='utf-8')
+        logger.info(f"Saved report to {output_file}")
+        return df, output_file
+    except Exception as e:
+        logger.error(f"Report generation failed: {str(e)}")
+        return pd.DataFrame(columns=['Contract_Name', 'Parties', 'Payment_Terms', 'Obligations', 'Termination_Clause', 'Full_Summary', 'Validation_Status', 'Start_Date', 'End_Date']), None
+
+# Gradio interface function
+def gradio_process(file, progress=gr.Progress()):
+    try:
+        if not file:
+            logger.error("No file uploaded")
+            return "Error: No file uploaded.", pd.DataFrame(), None
+        file_path = file.name if hasattr(file, 'name') else file
+        file_name = os.path.basename(file_path)
+        progress(0.1, desc="Validating file...")
+        is_valid, error = validate_file(file_path)
+        if not is_valid:
+            logger.error(error)
+            return f"Error: {error}", pd.DataFrame(), None
+        progress(0.2, desc="Extracting text...")
+        text, error = extract_text(file_path)
+        if error:
+            logger.error(f"Text extraction failed: {error}")
+            return f"Error extracting text from {file_name}: {error}. Check {log_file}", pd.DataFrame(), None
+        progress(0.4, desc="Initializing Salesforce and models...")
+        sf = init_salesforce()
+        summarizer, sentence_model = init_models()
+        progress(0.6, desc="Summarizing contract...")
+        summary_data, err = summarize_contract(text, summarizer, sentence_model)
+        if err:
+            logger.error(f"Summarization failed: {err}")
+            return f"Error summarizing {file_name}: {err}. Check {log_file}", pd.DataFrame(), None
+        progress(0.8, desc="Storing data in Salesforce...")
+        contract_doc_id, err = create_contract_document(sf, file_name)
+        if err:
+            logger.error(f"Contract document creation failed: {err}")
+            return f"Error creating Contract Document for {file_name}: {err}. Check {log_file}", pd.DataFrame(), None
+        result, err = store_in_salesforce(sf, summary_data, file_name, contract_doc_id)
+        if err:
+            logger.error(f"Salesforce storage failed: {err}")
+            return f"Error storing summary for {file_name}: {err}. Check {log_file}", pd.DataFrame(), None
+        progress(0.9, desc="Generating report...")
+        csv_path = os.path.join(tempfile.gettempdir(), f"contract_summary_{file_name}.csv")
+        report_df, csv_path = generate_report(sf, csv_path, contract_doc_id)
+        if report_df.empty:
+            logger.warning(f"No valid report data generated for {file_name}")
+            return f"Success! Summary stored for {file_name} with ID {result['id']}. No report data.", pd.DataFrame(), None
+        progress(1.0, desc="Complete!")
+        return (
+            f"Success! Summary stored for {file_name} with ID {result['id']}. Report generated.",
+            report_df,
+            csv_path
+        )
+    except Exception as e:
+        logger.error(f"Processing error for {file_name if 'file_name' in locals() else 'unknown file'}: {str(e)}")
+        return f"Error processing {file_name if 'file_name' in locals() else 'file'}: {str(e)}. Check {log_file}", pd.DataFrame(), None
+
+# Gradio UI setup
+with gr.Blocks(title="AI-Powered Contract Summarizer with Salesforce Integration") as iface:
+    gr.Markdown("AI Contract Summarizer")
+    with gr.Row():
+        file_input = gr.File(label="Upload Contract File (PDF, DOCX, PNG, JPG, CSV, XLS/XLSX)")
+    submit_btn = gr.Button("Submit", elem_classes=["bg-orange-500"])
+    result_output = gr.Textbox(label="Result", lines=5)
+    report_output = gr.DataFrame(label="Contract Summary Report", headers=['Contract_Name', 'Parties', 'Payment_Terms', 'Obligations', 'Termination_Clause', 'Full_Summary', 'Validation_Status', 'Start_Date', 'End_Date'], interactive=False)
+    csv_output = gr.File(label="Download CSV Report")
+    submit_btn.click(
+        fn=gradio_process,
+        inputs=[file_input],
+        outputs=[result_output, report_output, csv_output]
+    )
+
+if __name__ == "__main__":
+    logger.info(f"Starting Gradio interface. Logs saved to {log_file}")
+    if missing_deps:
+        logger.warning(f"Application running with limited functionality due to missing dependencies: {', '.join(missing_deps)}")
+    iface.launch()