Spaces:
Sleeping
Sleeping
| import os | |
| #os.environ["PATH"] += os.pathsep + "/usr/bin" + os.pathsep + "/usr/local/bin" #Removed redundant path setting | |
| print(f"Current PATH: {os.environ['PATH']}") | |
| import streamlit as st | |
| from PyPDF2 import PdfMerger | |
| from google.cloud import vision | |
| from google.oauth2 import service_account | |
| import fitz | |
| from PIL import Image | |
| from io import BytesIO | |
| import tempfile | |
| import json | |
| from streamlit_sortables import sort_items | |
| import subprocess | |
| from tqdm import tqdm | |
| import base64 | |
| # Check if /usr/bin/pdfinfo exists | |
| if os.path.exists("/usr/bin/pdfinfo"): | |
| print("pdfinfo exists at /usr/bin/pdfinfo") | |
| # Check the file permissions | |
| permissions = os.stat("/usr/bin/pdfinfo").st_mode | |
| print(f"File permissions: {oct(permissions)}") | |
| else: | |
| print("pdfinfo does not exist at /usr/bin/pdfinfo") | |
| # Load Google Cloud Vision credentials from secret | |
| credentials_json = os.getenv("GOOGLE_CREDENTIALS_JSON") | |
| if credentials_json: | |
| credentials_dict = json.loads(credentials_json) | |
| credentials = service_account.Credentials.from_service_account_info(credentials_dict) | |
| client = vision.ImageAnnotatorClient(credentials=credentials) | |
| else: | |
| client = None | |
| # Function to extract text using Google Cloud Vision | |
| def extract_text_with_google_vision(image_bytes): | |
| """Extracts text using Google Cloud Vision.""" | |
| image = vision.Image(content=image_bytes) | |
| response = client.document_text_detection(image=image) | |
| if response.error.message: | |
| raise Exception(f"Google Cloud Vision API Error: {response.error.message}") | |
| return response.full_text_annotation.text if response.full_text_annotation else "" | |
| # Function to process PDF for transcription | |
| def process_pdf(file): | |
| """Converts PDF pages to images and extracts text.""" | |
| text = "" | |
| with tempfile.NamedTemporaryFile(suffix=".pdf", delete=False) as temp_pdf: | |
| temp_pdf.write(file.read()) | |
| temp_pdf_path = temp_pdf.name | |
| try: | |
| doc = fitz.open(temp_pdf_path) | |
| for i in tqdm(range(len(doc)), desc="Processing pages"): | |
| page = doc.load_page(i) | |
| pix = page.get_pixmap() | |
| image = Image.frombytes("RGB", [pix.width, pix.height], pix.samples) | |
| image_bytes = BytesIO() | |
| image.save(image_bytes, format="PNG") | |
| image_bytes.seek(0) | |
| try: | |
| page_text = extract_text_with_google_vision(image_bytes.getvalue()) | |
| text += f"--- Page {i + 1} ---\n{page_text}\n\n" | |
| except Exception as e: | |
| st.error(f"Error on page {i + 1}: {e}") | |
| finally: | |
| os.remove(temp_pdf_path) | |
| return text | |
| # Function to generate thumbnail from PDF | |
| def get_pdf_thumbnail(uploaded_file): | |
| """Generates a thumbnail image of the first page of a PDF.""" | |
| uploaded_file.seek(0) | |
| doc = fitz.open(stream=uploaded_file.read(), filetype="pdf") | |
| page = doc.load_page(0) | |
| pix = page.get_pixmap() | |
| img = Image.frombytes("RGB", [pix.width, pix.height], pix.samples) | |
| img.thumbnail((100, 140)) | |
| return img | |
| # Function to merge PDFs | |
| def merge_pdfs(reordered_files): | |
| """Merges multiple PDFs into one.""" | |
| merger = PdfMerger() | |
| for file in reordered_files: | |
| file.seek(0) | |
| merger.append(file) | |
| output_filename = "combined_document.pdf" | |
| with open(output_filename, "wb") as output_file: | |
| merger.write(output_file) | |
| return output_filename | |
| def download_file(output_file, file_name, mime_type): | |
| with open(output_file, "rb") as f: | |
| st.download_button( | |
| label="Download File", | |
| data=f, | |
| file_name=file_name, | |
| mime=mime_type, | |
| ) | |
| def add_signature_to_pdf(pdf_file, signature_image, x, y): | |
| """Adds a signature image to the PDF at the given coordinates.""" | |
| with tempfile.NamedTemporaryFile(suffix=".pdf", delete=False) as temp_pdf: | |
| try: | |
| temp_pdf.write(pdf_file.read()) | |
| temp_pdf_path = temp_pdf.name | |
| print(f"temp file name: {temp_pdf_path}") | |
| except Exception as e: | |
| print(f"Error creating temp file: {e}") | |
| return None | |
| try: | |
| doc = fitz.open(temp_pdf_path) | |
| page = doc[0] # Operate on the first page for simplicity | |
| rect = fitz.Rect(x, y, x + 200, y + 100) # Size for the signature | |
| img = Image.open(BytesIO(base64.b64decode(signature_image))) | |
| img_bytes = BytesIO() | |
| img.save(img_bytes, format="PNG") | |
| img_bytes.seek(0) | |
| page.insert_image(rect, stream=img_bytes.read(), keep_proportion=True) | |
| output_filename = "signed_document.pdf" | |
| doc.save(output_filename) | |
| os.remove(temp_pdf_path) | |
| return output_filename | |
| except Exception as e: | |
| print(f"Error with pdf: {e}") | |
| return None | |
| def pdf_signer_ui(pdf_file, signature_image_data): | |
| """Handles the UI and logic for PDF signing.""" | |
| if st.button("Preview PDF"): | |
| with tempfile.NamedTemporaryFile(suffix=".pdf", delete=False) as temp_pdf: | |
| try: | |
| temp_pdf.write(pdf_file.read()) | |
| temp_pdf_path = temp_pdf.name | |
| print(f"temp file name: {temp_pdf_path}") | |
| except Exception as e: | |
| print(f"Error creating temporary file: {e}") | |
| st.error("Could not create temporary file. Please make sure your uploaded file is valid") | |
| return | |
| try: | |
| doc = fitz.open(temp_pdf_path) | |
| page = doc[0] | |
| pix = page.get_pixmap() | |
| img = Image.frombytes("RGB", [pix.width, pix.height], pix.samples) | |
| clicked = st.image(img, use_container_width=True) | |
| if clicked: | |
| x = clicked.x | |
| y = clicked.y | |
| if st.button("Add Signature"): | |
| with st.spinner("Adding Signature..."): | |
| if pdf_file and signature_image_data: # Check for file existence | |
| output_file = add_signature_to_pdf(pdf_file, signature_image_data, x, y) | |
| if output_file: | |
| st.success("Signature added successfully") | |
| download_file(output_file, "signed_document.pdf", "application/pdf") | |
| os.remove(output_file) | |
| else: | |
| st.error("An Error occurred when creating the signed PDF") | |
| else: | |
| st.error("Please upload both a PDF file and a signature image") | |
| os.remove(temp_pdf_path) | |
| except Exception as e: | |
| print(f"Error with pdf: {e}") | |
| st.error(f"Could not open PDF file {e}") | |
| os.remove(temp_pdf_path) | |
| # Sidebar Navigation | |
| st.sidebar.title("Tool Selector") | |
| selection = st.sidebar.radio("Choose a tool:", ["PDF Combiner", "PDF Transcriber", "PDF Signer"]) | |
| # PDF Combiner with Preview and Reordering | |
| if selection == "PDF Combiner": | |
| st.title("PDF Combiner with Preview & Reordering") | |
| st.write("Upload individual PDF pages, visualize them, reorder, and merge into a single PDF.") | |
| uploaded_files = st.file_uploader("Upload PDF pages", type="pdf", accept_multiple_files=True) | |
| if uploaded_files: | |
| # Generate thumbnails and filenames for each uploaded PDF | |
| thumbnails = [] | |
| filenames = [] | |
| for file in uploaded_files: | |
| thumbnails.append(get_pdf_thumbnail(file)) | |
| filenames.append(file.name) | |
| # Display thumbnails with filenames for reordering | |
| st.write("**Drag and drop to reorder the PDFs:**") | |
| reordered_filenames = sort_items(filenames) | |
| # Map the filenames back to the corresponding files | |
| reordered_files = [uploaded_files[filenames.index(name)] for name in reordered_filenames] | |
| # Display the thumbnails in the new order | |
| st.write("**Preview of selected order:**") | |
| cols = st.columns(len(reordered_files)) | |
| for idx, file in enumerate(reordered_files): | |
| with cols[idx]: | |
| st.image(get_pdf_thumbnail(file), caption=file.name, use_container_width=True) | |
| # Merge PDFs in the specified order | |
| if st.button("Merge PDFs"): | |
| output_file = merge_pdfs(reordered_files) | |
| st.success("PDF pages combined successfully!") | |
| download_file(output_file, "combined_document.pdf", "application/pdf") | |
| os.remove(output_file) | |
| # PDF Transcriber Tool | |
| elif selection == "PDF Transcriber": | |
| st.title("PDF Transcriber Tool") | |
| st.write("Upload a scanned PDF to transcribe the text.") | |
| if not client: | |
| st.error("Google Cloud credentials are not set. Please configure the secret.") | |
| uploaded_file = st.file_uploader("Upload a PDF", type=["pdf"]) | |
| if uploaded_file and st.button("Transcribe PDF"): | |
| with st.spinner("Processing..."): | |
| pdf_text = process_pdf(uploaded_file) | |
| st.success("Text extraction complete!") | |
| st.text_area("Extracted Text", pdf_text, height=400) | |
| output_file_name = f"(T){os.path.splitext(uploaded_file.name)[0]}.txt" | |
| download_file(output_file_name, f"(T){os.path.splitext(uploaded_file.name)[0]}.txt", "text/plain") | |
| # PDF Signer Tool | |
| elif selection == "PDF Signer": | |
| st.title("PDF Signer") | |
| st.write("Upload a PDF and place a signature on it by clicking the preview.") | |
| pdf_file = st.file_uploader("Upload PDF", type=["pdf"]) | |
| signature_image = st.file_uploader("Upload Signature Image", type=["png", "jpg", "jpeg"]) | |
| if pdf_file and signature_image: | |
| signature_image_data = base64.b64encode(signature_image.read()).decode("utf-8") | |
| pdf_signer_ui(pdf_file, signature_image_data) |