Update app.py

app.py

@@ -1,230 +1,161 @@
-from flask import Flask, request, jsonify, redirect, url_for
-import pdfplumber
-from transformers import pipeline
-import sqlite3
-import json
-import requests
-from simple_salesforce import Salesforce
-import urllib.parse
-from dotenv import load_dotenv
+import gradio as gr
 import os
-import logging
-
-# Set up logging
-logging.basicConfig(level=logging.DEBUG, filename='app.log', filemode='a',
-                    format='%(asctime)s - %(levelname)s - %(message)s')
-logger = logging.getLogger(__name__)
-
-app = Flask(__name__)
-
-# Load environment variables
-load_dotenv()
-SALESFORCE_OAUTH_URL = os.getenv('SALESFORCE_OAUTH_URL')
-SF_CLIENT_ID = os.getenv('SF_CLIENT_ID')
-SF_CLIENT_SECRET = os.getenv('SF_CLIENT_SECRET')
-SALESFORCE_REDIRECT_URI = os.getenv('SALESFORCE_REDIRECT_URI')
-SF_USERNAME = os.getenv('SF_USERNAME')
-SF_PASSWORD = os.getenv('SF_PASSWORD')
-SF_DOMAIN = os.getenv('SF_DOMAIN')
-
-# Validate environment variables
-required_env_vars = [SALESFORCE_OAUTH_URL, SF_CLIENT_ID, SF_CLIENT_SECRET, SALESFORCE_REDIRECT_URI]
-if None in required_env_vars:
-    logger.error("Missing required environment variables")
-    raise ValueError("Missing required environment variables in .env file")
-
-# Database connection (SQLite)
-try:
-    conn = sqlite3.connect('contracts.db')
-    cursor = conn.cursor()
-    cursor.execute('''
-        CREATE TABLE IF NOT EXISTS contracts (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            content TEXT NOT NULL,
-            entities TEXT,
-            compliance TEXT,
-            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-        )
-    ''')
-    conn.commit()
-    logger.info("SQLite database initialized")
-except Exception as e:
-    logger.error(f"Failed to initialize SQLite database: {str(e)}")
-    raise
-
-# Initialize Hugging Face pipelines
-try:
-    ner_pipeline = pipeline("ner", model="dslim/bert-base-NER", aggregation_strategy="simple")
-    compliance_pipeline = pipeline("text-classification", model="facebook/bart-large-mnli")
-    logger.info("Hugging Face pipelines initialized")
-except Exception as e:
-    logger.error(f"Failed to initialize Hugging Face pipelines: {str(e)}")
-    raise
-
-# Store OAuth tokens
-access_token = None
-instance_url = None
-
-@app.route('/login')
-def login():
-    logger.debug("Initiating Salesforce OAuth login")
-    params = {
-        'client_id': SF_CLIENT_ID,
-        'redirect_uri': SALESFORCE_REDIRECT_URI,
-        'response_type': 'code',
-        'scope': 'api refresh_token'
-    }
-    auth_url = f"https://login.salesforce.com/services/oauth2/authorize?{urllib.parse.urlencode(params)}"
-    return redirect(auth_url)
-
-@app.route('/callback')
-def oauth_callback():
-    global access_token, instance_url
-    code = request.args.get('code')
-    if not code:
-        logger.error("Authorization code not found")
-        return jsonify({"error": "Authorization code not found"}), 400
-    
-    logger.debug(f"Received OAuth code: {code}")
-    data = {
-        'grant_type': 'authorization_code',
-        'client_id': SF_CLIENT_ID,
-        'client_secret': SF_CLIENT_SECRET,
-        'redirect_uri': SALESFORCE_REDIRECT_URI,
-        'code': code
-    }
-    try:
-        response = requests.post(SALESFORCE_OAUTH_URL, data=data)
-        response.raise_for_status()
-        token_data = response.json()
-        access_token = token_data['access_token']
-        instance_url = token_data['instance_url']
-        logger.info(f"Successfully obtained Salesforce access token. Instance URL: {instance_url}")
-        return redirect(url_for('index'))
-    except Exception as e:
-        logger.error(f"Failed to obtain access token: {str(e)}")
-        return jsonify({"error": "Failed to obtain access token", "details": str(e)}), 500
-
-@app.route('/')
-def index():
-    logger.debug("Accessing root endpoint")
-    return jsonify({"message": "Welcome to Contract Analyzer. Please log in to Salesforce."})
-
-def extract_text_from_pdf(file):
-    try:
-        with pdfplumber.open(file) as pdf:
-            text = ""
-            for page in pdf.pages:
-                extracted = page.extract_text()
-                if extracted:
-                    text += extracted + "\n"
-        logger.debug(f"Extracted text from PDF: {text[:100]}...")
-        return text
-    except Exception as e:
-        logger.error(f"Failed to extract text from PDF: {str(e)}")
-        return str(e)
-
-@app.route('/upload_contract', methods=['POST'])
-def upload_contract():
-    global access_token, instance_url
-    if not access_token or not instance_url:
-        logger.error("Not authenticated with Salesforce")
-        return jsonify({"error": "Please authenticate with Salesforce first"}), 401
-    
-    if 'contract' not in request.files:
-        logger.error("No file uploaded")
-        return jsonify({"error": "No file uploaded"}), 400
-    
-    file = request.files['contract']
-    logger.debug(f"Received file: {file.filename}")
-    text = extract_text_from_pdf(file)
-    if not text or isinstance(text, str) and text.startswith("Error"):
-        logger.error(f"Failed to extract text: {text}")
-        return jsonify({"error": "Failed to extract text from PDF", "details": text}), 500
-    
-    # Extract entities
-    try:
-        entities = ner_pipeline(text)
-        extracted_data = [{"entity": ent['word'], "type": ent['entity_group']} for ent in entities]
-        logger.info(f"Extracted {len(extracted_data)} entities")
-    except Exception as e:
-        logger.error(f"Entity extraction failed: {str(e)}")
-        return jsonify({"error": "Entity extraction failed", "details": str(e)}), 500
-    
-    # Analyze compliance
-    try:
-        compliance_results = []
-        sentences = [s.strip() for s in text.split('\n') if s.strip()]
-        for sentence in sentences[:10]:  # Limit for demo
-            result = compliance_pipeline(sentence, candidate_labels=["low_risk", "high_risk"])
-            compliance_results.append({
-                "text": sentence[:100],
-                "risk": result['labels'][0],
-                "score": result['scores'][0]
-            })
-        logger.info(f"Analyzed compliance for {len(compliance_results)} sentences")
-    except Exception as e:
-        logger.error(f"Compliance analysis failed: {str(e)}")
-        return jsonify({"error": "Compliance analysis failed", "details": str(e)}), 500
-    
-    # Store in SQLite
-    try:
-        cursor.execute(
-            "INSERT INTO contracts (content, entities, compliance) VALUES (?, ?, ?)",
-            (text, json.dumps(extracted_data), json.dumps(compliance_results))
-        )
-        contract_id = cursor.lastrowid
-        conn.commit()
-        logger.info(f"Stored contract in SQLite with ID: {contract_id}")
-    except Exception as e:
-        conn.rollback()
-        logger.error(f"Database error: {str(e)}")
-        return jsonify({"error": f"Database error: {str(e)}"}), 500
-    
-    # Push to Salesforce
-    try:
-        sf = Salesforce(instance_url=instance_url, session_id=access_token)
-        sf_response = sf.Contract__c.create({
-            'Content__c': text[:1000],  # Truncate for Salesforce field limit
-            'Entities__c': json.dumps(extracted_data),
-            'Compliance__c': json.dumps(compliance_results)
-        })
-        logger.info(f"Stored contract in Salesforce with ID: {sf_response['id']}")
-    except Exception as e:
-        logger.error(f"Failed to save to Salesforce: {str(e)}")
-        return jsonify({"error": f"Failed to save to Salesforce: {str(e)}"}), 500
-    
-    return jsonify({
-        "contract_id": contract_id,
-        "salesforce_id": sf_response['id'],
-        "entities": extracted_data,
-        "compliance": compliance_results
-    })
-
-@app.route('/get_contract/<int:id>', methods=['GET'])
-def get_contract(id):
+from utils import (
+    get_salesforce_client, get_salesforce_objects, get_object_fields,
+    extract_text_from_pdf, extract_key_value_pairs, map_fields,
+    create_record, attach_pdf, log_failure
+)
+
+# Ensure uploads directory exists
+os.makedirs("uploads", exist_ok=True)
+
+# Gradio Interface Functions
+def upload_pdfs(*files):
+    uploaded_files = []
+    for file in files:
+        if file is not None:
+            file_path = f"uploads/{file.name}"
+            with open(file_path, "wb") as f:
+                f.write(file.read())
+            uploaded_files.append(file_path)
+    return f"Uploaded {len(uploaded_files)} PDF(s): {', '.join(uploaded_files)}"
+
+def fetch_objects():
+    sf, error = get_salesforce_client()
+    if error:
+        return gr.Dropdown.update(choices=[]), f"Error: {error}"
+    objects, error = get_salesforce_objects(sf)
+    if error:
+        return gr.Dropdown.update(choices=[]), f"Error: {error}"
+    return gr.Dropdown.update(choices=objects), "Objects fetched successfully"
+
+def fetch_fields(object_name):
+    sf, error = get_salesforce_client()
+    if error:
+        return gr.CheckboxGroup.update(choices=[]), f"Error: {error}"
+    fields, error = get_object_fields(sf, object_name)
+    if error:
+        return gr.CheckboxGroup.update(choices=[]), f"Error: {error}"
+    return gr.CheckboxGroup.update(choices=fields), "Fields fetched successfully"
+
+def process_pdf(pdf_path):
+    text_data, error = extract_text_from_pdf(pdf_path)
+    if error:
+        return f"Error: {error}"
+    kv_pairs, error = extract_key_value_pairs(pdf_path)
+    if error:
+        return f"Error: {error}"
+    return f"Text: {text_data}\nKey-Value Pairs: {kv_pairs}"
+
+def display_mappings(pdf_path, object_name):
+    sf, error = get_salesforce_client()
+    if error:
+        return f"Error: {error}"
+    fields, error = get_object_fields(sf, object_name)
+    if error:
+        return f"Error: {error}"
+    extracted_data, error = extract_key_value_pairs(pdf_path)
+    if error:
+        return f"Error: {error}"
+    mappings, confidence_scores, error = map_fields(extracted_data, fields)
+    if error:
+        return f"Error: {error}"
+    output = ""
+    for key, field in mappings.items():
+        output += f"{key} -> {field} (Confidence: {confidence_scores[key]})\n"
+    return output
+
+def migrate_to_salesforce(pdf_path, object_name):
+    sf, error = get_salesforce_client()
+    if error:
+        log_failure(pdf_path, object_name, error)
+        return f"Error: {error}"
+    extracted_data, error = extract_key_value_pairs(pdf_path)
+    if error:
+        log_failure(pdf_path, object_name, error)
+        return f"Error: {error}"
+    fields, error = get_object_fields(sf, object_name)
+    if error:
+        log_failure(pdf_path, object_name, error)
+        return f"Error: {error}"
+    mappings, _, error = map_fields(extracted_data, fields)
+    if error:
+        log_failure(pdf_path, object_name, error)
+        return f"Error: {error}"
+    data = {mappings[key]: value for key, value in zip(extracted_data[0]["keys"], extracted_data[0]["values"])}
+    record_id, error = create_record(sf, object_name, data)
+    if error:
+        log_failure(pdf_path, object_name, error)
+        return f"Error: {error}"
+    attach_status, error = attach_pdf(sf, record_id, pdf_path)
+    if error:
+        log_failure(pdf_path, object_name, error)
+        return f"Error: {error}"
+    return f"Record Created: {record_id}\n{attach_status}"
+
+def display_failures():
     try:
-        cursor.execute("SELECT content, entities, compliance FROM contracts WHERE id = ?", (id,))
-        result = cursor.fetchone()
-        if result:
-            logger.info(f"Retrieved contract ID: {id} from SQLite")
-            return jsonify({
-                "content": result[0],
-                "entities": json.loads(result[1]),
-                "compliance": json.loads(result[2])
-            })
-        logger.warning(f"Contract ID {id} not found")
-        return jsonify({"error": "Contract not found"}), 404
-    except Exception as e:
-        logger.error(f"Error retrieving contract: {str(e)}")
-        return jsonify({"error": str(e)}), 500
-
-@app.teardown_appcontext
-def close_db(exception):
-    cursor.close()
-    conn.close()
-    logger.debug("Closed SQLite database connection")
-
-if __name__ == '__main__':
-    logger.info("Starting Flask application")
-    app.run(debug=True, host='0.0.0.0', port=8080)
+        with open("failures.json", "r") as f:
+            failures = [json.loads(line) for line in f]
+        output = ""
+        for idx, failure in enumerate(failures):
+            output += f"Failure {idx + 1}: PDF={failure['pdf']}, Object={failure['object']}, Error={failure['error']}\n"
+        return output
+    except FileNotFoundError:
+        return "No failures logged"
+
+def retry_migration(pdf_path, object_name):
+    return migrate_to_salesforce(pdf_path, object_name)
+
+# Gradio UI
+with gr.Blocks() as app:
+    gr.Markdown("# Smart Contract Migrator")
+
+    # PDF Upload Section
+    gr.Markdown("## Upload PDFs")
+    pdf_upload = gr.File(label="Upload Contract PDFs", file_count="multiple", file_types=[".pdf"])
+    upload_status = gr.Textbox(label="Upload Status")
+    pdf_upload.change(upload_pdfs, inputs=pdf_upload, outputs=upload_status)
+
+    # Salesforce Object Selection
+    gr.Markdown("## Salesforce Object Selection")
+    object_dropdown = gr.Dropdown(label="Select Salesforce Object")
+    fetch_objects_button = gr.Button("Fetch Objects")
+    object_status = gr.Textbox(label="Object Fetch Status")
+    fetch_objects_button.click(fetch_objects, outputs=[object_dropdown, object_status])
+
+    # Field Selection
+    field_checkboxes = gr.CheckboxGroup(label="Select Fields")
+    fetch_fields_button = gr.Button("Fetch Fields")
+    field_status = gr.Textbox(label="Field Fetch Status")
+    fetch_fields_button.click(fetch_fields, inputs=object_dropdown, outputs=[field_checkboxes, field_status])
+
+    # PDF Processing
+    gr.Markdown("## Process PDF")
+    process_button = gr.Button("Process PDF")
+    process_output = gr.Textbox(label="Extracted Data")
+    process_button.click(process_pdf, inputs=pdf_upload, outputs=process_output)
+
+    # Field Mapping
+    gr.Markdown("## Field Mapping")
+    map_button = gr.Button("Map Fields")
+    mapping_output = gr.Textbox(label="Field Mappings")
+    map_button.click(display_mappings, inputs=[pdf_upload, object_dropdown], outputs=mapping_output)
+
+    # Salesforce Migration
+    gr.Markdown("## Migrate to Salesforce")
+    migrate_button = gr.Button("Migrate to Salesforce")
+    migrate_output = gr.Textbox(label="Migration Status")
+    migrate_button.click(migrate_to_salesforce, inputs=[pdf_upload, object_dropdown], outputs=migrate_output)
+
+    # Reconciliation Dashboard
+    gr.Markdown("## Reconciliation Dashboard")
+    show_failures_button = gr.Button("Show Failures")
+    failures_output = gr.Textbox(label="Failed Migrations")
+    pdf_path_input = gr.Textbox(label="PDF Path to Retry")
+    retry_button = gr.Button("Retry Migration")
+    retry_output = gr.Textbox(label="Retry Status")
+    show_failures_button.click(display_failures, outputs=failures_output)
+    retry_button.click(retry_migration, inputs=[pdf_path_input, object_dropdown], outputs=retry_output)
+
+app.launch()