Extracting Tables from PDFs

namespace PdfTableExtractor

module PodmanExtractor =
    open FSharp.Data
    open System.IO
    open System.Diagnostics

    // Function to convert PDF to HTML using pdf2htmlEX via Podman
    let convertPdfToHtml (pdfPath: string) =
        let pdfDir = Path.GetDirectoryName(pdfPath)
        let pdfName = Path.GetFileName(pdfPath)
        let htmlName = Path.ChangeExtension(pdfName, ".html")
        
        printfn "PDF Directory: %s" pdfDir
        printfn "PDF Name: %s" pdfName
        printfn "HTML Name: %s" htmlName
        
        // podman run -ti --rm -v C:\avera:/pdf docker.io/bwits/pdf2htmlex pdf2htmlEX UserGuide.pdf
        // use proc = new Process()
        // proc.StartInfo.FileName <- "podman"
        // proc.StartInfo.Arguments <- sprintf "run -ti --rm -v \"%s\":/pdf docker.io/bwits/pdf2htmlex pdf2htmlEX --zoom 1.3 %s %s" pdfDir pdfName htmlName
        
        // proc.StartInfo.RedirectStandardError <- true
        // proc.StartInfo.RedirectStandardOutput <- true
        // proc.StartInfo.UseShellExecute <- false
        
        // // Start the process
        // printfn "Starting process with command: %s %s" proc.StartInfo.FileName proc.StartInfo.Arguments
        // proc.Start() |> ignore
        
        // // Read and display output
        // let output = proc.StandardOutput.ReadToEnd()
        // let error = proc.StandardError.ReadToEnd()
        
        // printfn "Process Output:\n%s" output
        // printfn "Process Error:\n%s" error
        
        // proc.WaitForExit()
        
        let outputPath = Path.Combine(pdfDir, htmlName)
        Some outputPath
        // printfn "Expected output path: %s" outputPath
        
        // if proc.ExitCode = 0 && File.Exists(outputPath) then 
        //     printfn "Conversion successful"
        //     Some outputPath 
        // else 
        //     printfn "Conversion failed with exit code: %d" proc.ExitCode
        //     None

    // Function to extract tables from HTML
    let extractTablesFromHtml (htmlPath: string) =
        let html = HtmlDocument.Load(htmlPath)
        html.Descendants ["table"]
        |> Seq.mapi (fun i table ->
            let rows = 
                table.Descendants ["tr"]
                |> Seq.map (fun row ->
                    row.Descendants ["td"; "th"]
                    |> Seq.map (fun cell -> cell.InnerText().Trim())
                    |> String.concat "\t")
                |> String.concat "\n"
            sprintf "Table %d:\n%s\n" (i + 1) rows)
        |> String.concat "\n"

    // Main function to process a PDF file
    let processPdf pdfPath =
        if File.Exists(pdfPath) then
            try
                printfn "Converting PDF to HTML using pdf2htmlEX (via Podman)..."
                match convertPdfToHtml pdfPath with
                | Some htmlPath ->
                    let tables = extractTablesFromHtml htmlPath
                    // Clean up the temporary HTML file
                    File.Delete htmlPath
                    Ok tables
                | None ->
                    Error "Error converting PDF to HTML. Make sure Podman is installed and running."
            with
            | ex -> Error $"Error processing PDF: {ex.Message}"
        else
            Error "File does not exist"

module Program =
    [<EntryPoint>]
    let main argv =
        match argv with
        | [|pdfPath|] ->
            match PodmanExtractor.processPdf pdfPath with
            | Ok tables ->
                printfn "Extracted tables:\n%s" tables
                0
            | Error msg ->
                eprintfn "%s" msg
                1
        | _ ->
            eprintfn "Usage: PdfTableExtractor <path-to-pdf>"
            1

def extract_tables_from_pdf(pdf_path):
    """
    Extract tables from a PDF file using Camelot.
    
    Args:
        pdf_path (str): Path to the PDF file
        
    Returns:
        list: List of pandas DataFrames containing the extracted tables
    """
    # Extract tables using Camelot
    tables = camelot.read_pdf(pdf_path, pages='all')
    
    # Convert Camelot tables to pandas DataFrames
    dataframes = []
    for table in tables:
        df = table.df
        dataframes.append(df)
    
    return dataframes

def main():
    # Example usage
    pdf_path = "c:/pdfs/UserGuide.pdf"  # Replace with your PDF path
    
    try:
        tables = extract_tables_from_pdf(pdf_path)
        print(f"Extracted {len(tables)} tables from the PDF")
        
        # Save each table to a CSV file
        for i, table in enumerate(tables):
            table.to_csv(f"table_{i+1}.csv", index=False)
            print(f"Saved table {i+1} to table_{i+1}.csv")
    except Exception as e:
        print(f"Error extracting tables: {str(e)}")

if __name__ == "__main__":
    main()