import os import shutil import base64 import time import concurrent.futures from PIL import Image from transformers import BlipProcessor, BlipForConditionalGeneration import torch from datetime import datetime from reportlab.lib.pagesizes import letter from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Image as PDFImage from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle from reportlab.lib import colors from simple_salesforce import Salesforce from dotenv import load_dotenv import gradio as gr # Load environment variables from .env file load_dotenv() # Salesforce credentials SF_USERNAME = os.getenv('SF_USERNAME') SF_PASSWORD = os.getenv('SF_PASSWORD') SF_SECURITY_TOKEN = os.getenv('SF_SECURITY_TOKEN') # Initialize Salesforce connection try: sf = Salesforce(username=SF_USERNAME, password=SF_PASSWORD, security_token=SF_SECURITY_TOKEN) except Exception as e: sf = None print(f"Failed to connect to Salesforce: {str(e)}") # Load BLIP model and processor device = "cuda" if torch.cuda.is_available() else "cpu" processor = BlipProcessor.from_pretrained("Salesforce/blip-image-captioning-base") model = BlipForConditionalGeneration.from_pretrained("Salesforce/blip-image-captioning-base") model.eval().to(device) # Inference function to generate captions dynamically based on image content def generate_captions_from_image(image): if image.mode != "RGB": image = image.convert("RGB") # Resize for faster processing image = image.resize((224, 224)) # Adjust to smaller resolution for faster inference # Preprocess the image and generate a caption inputs = processor(image, return_tensors="pt").to(device, torch.float16) output = model.generate(**inputs, max_length=50) caption = processor.decode(output[0], skip_special_tokens=True) return caption # Function to save DPR text to a PDF file def save_dpr_to_pdf(dpr_text, image_paths, captions, filename): try: # Create a PDF document doc = SimpleDocTemplate(filename, pagesize=letter) styles = getSampleStyleSheet() # Define custom styles title_style = ParagraphStyle( name='Title', fontSize=16, leading=20, alignment=1, # Center spaceAfter=20, textColor=colors.black, fontName='Helvetica-Bold' ) body_style = ParagraphStyle( name='Body', fontSize=12, leading=14, spaceAfter=10, textColor=colors.black, fontName='Helvetica' ) # Build the PDF content flowables = [] # Add title flowables.append(Paragraph("Daily Progress Report", title_style)) # Split DPR text into lines and add as paragraphs (excluding descriptions for images) for line in dpr_text.split('\n'): # Replace problematic characters for PDF line = line.replace('\u2019', "'").replace('\u2018', "'") if line.strip(): flowables.append(Paragraph(line, body_style)) else: flowables.append(Spacer(1, 12)) # Add images and captions in the correct order (no need to add description to dpr_text again) for img_path, caption in zip(image_paths, captions): try: # Add image first img = PDFImage(img_path, width=200, height=150) # Adjust image size if needed flowables.append(img) # Add description below the image description = f"Description: {caption}" flowables.append(Paragraph(description, body_style)) flowables.append(Spacer(1, 12)) # Add some space between images except Exception as e: flowables.append(Paragraph(f"Error loading image: {str(e)}", body_style)) # Build the PDF doc.build(flowables) return f"PDF saved successfully as {filename}", filename except Exception as e: return f"Error saving PDF: {str(e)}", None # Function to upload a file to Salesforce as ContentVersion def upload_file_to_salesforce(file_path, filename, sf_connection, file_type): try: # Read file content and encode in base64 with open(file_path, 'rb') as f: file_content = f.read() file_content_b64 = base64.b64encode(file_content).decode('utf-8') # Set description based on file type description = "Daily Progress Report PDF" if file_type == "pdf" else "Site Image" # Create ContentVersion content_version = sf_connection.ContentVersion.create({ 'Title': filename, 'PathOnClient': filename, 'VersionData': file_content_b64, 'Description': description }) # Get ContentDocumentId content_version_id = content_version['id'] content_document = sf_connection.query( f"SELECT ContentDocumentId FROM ContentVersion WHERE Id = '{content_version_id}'" ) content_document_id = content_document['records'][0]['ContentDocumentId'] # Generate a valid Salesforce URL for the ContentDocument content_document_url = f"https://{sf_connection.sf_instance}/sfc/servlet.shepherd/version/download/{content_version_id}" return content_document_id, content_document_url, f"File {filename} uploaded successfully" except Exception as e: return None, None, f"Error uploading {filename} to Salesforce: {str(e)}" # Function to generate the daily progress report (DPR), save as PDF, and upload to Salesforce def generate_dpr(files): dpr_text = [] captions = [] image_paths = [] current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S") # Add header to the DPR dpr_text.append(f"Daily Progress Report\nGenerated on: {current_time}\n") # Process images in parallel for faster performance with concurrent.futures.ThreadPoolExecutor() as executor: results = list(executor.map(lambda file: generate_captions_from_image(Image.open(file.name)), files)) for i, file in enumerate(files): caption = results[i] captions.append(caption) # Generate DPR section for this image with dynamic caption dpr_section = f"\nImage: {file.name}\nDescription: {caption}\n" dpr_text.append(dpr_section) # Save image path for embedding in the report image_paths.append(file.name) # Combine DPR text dpr_output = "\n".join(dpr_text) # Generate PDF filename with timestamp pdf_filename = f"DPR_{datetime.now().strftime('%Y-%m-%d_%H-%M-%S')}.pdf" # Save DPR text to PDF pdf_result, pdf_filepath = save_dpr_to_pdf(dpr_output, image_paths, captions, pdf_filename) if sf and pdf_filepath: try: # Create Daily_Progress_Reports__c record report_description = "; ".join(captions)[:255] # Concatenate captions, limit to 255 chars dpr_record = sf.Daily_Progress_Reports__c.create({ 'Detected_Activities__c': report_description # Store in Detected_Activities__c field }) dpr_record_id = dpr_record['id'] # Upload PDF to Salesforce pdf_content_document_id, pdf_url, pdf_upload_result = upload_file_to_salesforce( pdf_filepath, pdf_filename, sf, "pdf" ) # Link PDF to DPR record if pdf_content_document_id: sf.ContentDocumentLink.create({ 'ContentDocumentId': pdf_content_document_id, 'LinkedEntityId': dpr_record_id, 'ShareType': 'V' }) # Update the DPR record with the PDF URL if pdf_url: sf.Daily_Progress_Reports__c.update(dpr_record_id, { 'PDF_URL__c': pdf_url # Storing the PDF URL correctly }) # Upload images to Salesforce and link them to DPR record for file in files: image_filename = os.path.basename(file.name) image_content_document_id, image_url, image_upload_result = upload_file_to_salesforce( file.name, image_filename, sf, "image" ) if image_content_document_id: # Link image to the Daily Progress Report record (DPR) using ContentDocumentLink sf.ContentDocumentLink.create({ 'ContentDocumentId': image_content_document_id, 'LinkedEntityId': dpr_record_id, # Link image to DPR record 'ShareType': 'V' # 'V' means Viewer access }) # Now, update the DPR record with the ContentDocumentId in the Site_Images field (if it's a text or URL field) sf.Daily_Progress_Reports__c.update(dpr_record_id, { 'Site_Images__c': image_content_document_id # Storing the ContentDocumentId directly }) except Exception as e: pass # No output for Salesforce errors now # Return the PDF file for Gradio download (using shutil to copy and return the file) if pdf_filepath: # Copy the PDF file to a temporary directory for Gradio to serve it temp_pdf_path = "/tmp/" + os.path.basename(pdf_filepath) shutil.copy(pdf_filepath, temp_pdf_path) # Only return the DPR output and the PDF file path, excluding Salesforce upload details return ( dpr_output + f"\n\n{pdf_result}", # Removed Salesforce upload status temp_pdf_path # Returning the file path for download ) else: return ( dpr_output + f"\n\n{pdf_result}", # Removed Salesforce upload status None ) # Gradio interface for uploading multiple files, displaying DPR, and downloading PDF iface = gr.Interface( fn=generate_dpr, inputs=gr.Files(type="filepath", label="Upload Site Photos"), outputs=[ gr.Textbox(label="Daily Progress Report"), gr.File(label="Download PDF", interactive=False) ], title="Daily Progress Report Generator", description="Upload up to 10 site photos. The AI model will generate a text-based Daily Progress Report (DPR), save it as a PDF, and upload the PDF and images to Salesforce under Daily_Progress_Reports__c in the Files related list. Download the PDF locally if needed.", allow_flagging="never", css="#gradio-share-link-button-0 { display: none !important; }" ) if __name__ == "__main__": iface.launch()