1java -version

1choco install openjdk

1brew install openjdk

1sudo apt-get install default-jre

1pip install tabula-py

1import tabula
2
3# Extract all tables from a PDF
4tables = tabula.read_pdf("financial_report.pdf", pages='all')
5
6# tables is a list of DataFrames, one per table found
7for i, df in enumerate(tables):
8    print(f"Table {i + 1}:")
9    print(df.head())
10    print("\n")

1import tabula
2
3# Extract tables from specific pages
4tables = tabula.read_pdf(
5    "report.pdf",
6    pages='1,3,5',  # Pages 1, 3, and 5
7    multiple_tables=True
8)
9
10# Or a range of pages
11tables = tabula.read_pdf(
12    "report.pdf",
13    pages='10-20',  # Pages 10 through 20
14    multiple_tables=True
15)

1import tabula
2
3# Use lattice mode for tables with clear borders
4df = tabula.read_pdf(
5    "report.pdf",
6    pages='1',
7    lattice=True,  # Better for tables with grid lines
8    multiple_tables=False
9)
10
11# Or stream mode for tables without borders
12df = tabula.read_pdf(
13    "report.pdf",
14    pages='1',
15    stream=True,  # Better for tables without grid lines
16    multiple_tables=False
17)

1import tabula
2
3# Define table area: [top, left, bottom, right] in points
4# (0,0) is top-left corner of page
5df = tabula.read_pdf(
6    "report.pdf",
7    pages='1',
8    area=[100, 50, 500, 550],  # Coordinates in points
9    multiple_tables=False
10)

1import tabula
2
3# Extract and save directly to CSV
4tabula.convert_into(
5    "report.pdf",
6    "output.csv",
7    output_format="csv",
8    pages='all'
9)
10
11# Or save each table to separate CSV files
12tabula.convert_into_by_batch(
13    "input_directory",
14    output_format="csv",
15    pages='all'
16)

1import tabula
2import pandas as pd
3
4# Extract tables
5tables = tabula.read_pdf("report.pdf", pages='all')
6
7# Save to Excel with multiple sheets
8with pd.ExcelWriter('extracted_tables.xlsx', engine='openpyxl') as writer:
9    for i, df in enumerate(tables):
10        df.to_excel(writer, sheet_name=f'Table_{i+1}', index=False)
11
12print("✅ Tables saved to extracted_tables.xlsx")

1import tabula
2import json
3
4tables = tabula.read_pdf("report.pdf", pages='all')
5
6# Convert to JSON
7output = []
8for i, df in enumerate(tables):
9    output.append({
10        'table_number': i + 1,
11        'data': df.to_dict('records')
12    })
13
14with open('tables.json', 'w') as f:
15    json.dump(output, f, indent=2)

1#!/usr/bin/env python3
2"""
3PDF Table Extractor - Extract tables from PDF files automatically.
4Author: Alex Rodriguez
5
6Usage:
7    python pdf_extractor.py input.pdf
8"""
9
10import sys
11import tabula
12import pandas as pd
13from pathlib import Path
14
15
16def extract_pdf_tables(pdf_path, output_format='excel', output_dir=None):
17    """
18    Extract all tables from a PDF file.
19    
20    Args:
21        pdf_path: Path to input PDF file
22        output_format: 'excel', 'csv', or 'json'
23        output_dir: Directory for output files (default: same as PDF)
24    
25    Returns:
26        List of extracted DataFrames
27    """
28    
29    # Validate input file
30    pdf_file = Path(pdf_path)
31    if not pdf_file.exists():
32        raise FileNotFoundError(f"PDF file not found: {pdf_path}")
33    
34    # Set output directory
35    if output_dir is None:
36        output_dir = pdf_file.parent
37    else:
38        output_dir = Path(output_dir)
39        output_dir.mkdir(parents=True, exist_ok=True)
40    
41    print(f"📄 Extracting tables from: {pdf_file.name}")
42    
43    # Try both lattice and stream modes
44    tables = []
45    
46    # Try lattice mode first (works well with bordered tables)
47    try:
48        print("   Trying lattice mode (bordered tables)...")
49        tables = tabula.read_pdf(
50            str(pdf_path),
51            pages='all',
52            lattice=True,
53            multiple_tables=True
54        )
55        if tables:
56            print(f"   ✅ Found {len(tables)} table(s) using lattice mode")
57    except Exception as e:
58        print(f"   ⚠️  Lattice mode failed: {e}")
59    
60    # If lattice failed, try stream mode
61    if not tables:
62        try:
63            print("   Trying stream mode (tables without borders)...")
64            tables = tabula.read_pdf(
65                str(pdf_path),
66                pages='all',
67                stream=True,
68                multiple_tables=True
69            )
70            if tables:
71                print(f"   ✅ Found {len(tables)} table(s) using stream mode")
72        except Exception as e:
73            print(f"   ⚠️  Stream mode failed: {e}")
74    
75    if not tables:
76        print("   ❌ No tables found in PDF")
77        return []
78    
79    # Clean and save tables
80    cleaned_tables = []
81    
82    for i, df in enumerate(tables, 1):
83        # Skip empty tables
84        if df.empty:
85            continue
86        
87        # Clean column names
88        df.columns = df.columns.str.strip()
89        
90        # Remove completely empty rows
91        df = df.dropna(how='all')
92        
93        cleaned_tables.append(df)
94        
95        print(f"\n📊 Table {i}:")
96        print(f"   Dimensions: {df.shape[0]} rows × {df.shape[1]} columns")
97        print(f"   Columns: {', '.join(df.columns.tolist())}")
98    
99    # Save based on output format
100    base_name = pdf_file.stem
101    
102    if output_format == 'excel':
103        output_file = output_dir / f"{base_name}_extracted.xlsx"
104        
105        with pd.ExcelWriter(output_file, engine='openpyxl') as writer:
106            for i, df in enumerate(cleaned_tables, 1):
107                sheet_name = f'Table_{i}'[:31]  # Excel sheet name limit
108                df.to_excel(writer, sheet_name=sheet_name, index=False)
109        
110        print(f"\n💾 Saved to: {output_file}")
111        
112    elif output_format == 'csv':
113        if len(cleaned_tables) == 1:
114            output_file = output_dir / f"{base_name}_extracted.csv"
115            cleaned_tables[0].to_csv(output_file, index=False)
116            print(f"\n💾 Saved to: {output_file}")
117        else:
118            for i, df in enumerate(cleaned_tables, 1):
119                output_file = output_dir / f"{base_name}_table_{i}.csv"
120                df.to_csv(output_file, index=False)
121                print(f"💾 Saved Table {i} to: {output_file}")
122    
123    elif output_format == 'json':
124        output_file = output_dir / f"{base_name}_extracted.json"
125        
126        output_data = []
127        for i, df in enumerate(cleaned_tables, 1):
128            output_data.append({
129                'table_number': i,
130                'rows': df.shape[0],
131                'columns': df.shape[1],
132                'data': df.to_dict('records')
133            })
134        
135        import json
136        with open(output_file, 'w') as f:
137            json.dump(output_data, f, indent=2)
138        
139        print(f"\n💾 Saved to: {output_file}")
140    
141    return cleaned_tables
142
143
144def batch_extract(input_dir, output_format='excel', output_dir=None):
145    """Extract tables from all PDFs in a directory."""
146    
147    input_path = Path(input_dir)
148    pdf_files = list(input_path.glob('*.pdf'))
149    
150    if not pdf_files:
151        print(f"No PDF files found in {input_dir}")
152        return
153    
154    print(f"Found {len(pdf_files)} PDF file(s)")
155    print("-" * 50)
156    
157    for pdf_file in pdf_files:
158        try:
159            extract_pdf_tables(pdf_file, output_format, output_dir)
160            print("-" * 50)
161        except Exception as e:
162            print(f"❌ Error processing {pdf_file.name}: {e}")
163            print("-" * 50)
164
165
166def main():
167    """Main entry point."""
168    
169    if len(sys.argv) < 2:
170        print("Usage: python pdf_extractor.py <pdf_file_or_directory> [format]")
171        print("\nFormats: excel (default), csv, json")
172        print("\nExamples:")
173        print("  python pdf_extractor.py report.pdf")
174        print("  python pdf_extractor.py report.pdf csv")
175        print("  python pdf_extractor.py pdf_folder/ excel")
176        sys.exit(1)
177    
178    input_path = sys.argv[1]
179    output_format = sys.argv[2] if len(sys.argv) > 2 else 'excel'
180    
181    if output_format not in ['excel', 'csv', 'json']:
182        print(f"Invalid format: {output_format}")
183        print("Valid formats: excel, csv, json")
184        sys.exit(1)
185    
186    # Check if input is file or directory
187    path = Path(input_path)
188    
189    if path.is_file():
190        extract_pdf_tables(input_path, output_format)
191    elif path.is_dir():
192        batch_extract(input_path, output_format)
193    else:
194        print(f"Input not found: {input_path}")
195        sys.exit(1)
196
197
198if __name__ == "__main__":
199    main()

1import tabula
2
3# Define multiple table areas on same page
4areas = [
5    [50, 50, 250, 550],   # Table 1 coordinates
6    [300, 50, 500, 550],  # Table 2 coordinates
7]
8
9for i, area in enumerate(areas):
10    df = tabula.read_pdf(
11        "report.pdf",
12        pages='1',
13        area=area,
14        multiple_tables=False
15    )
16    df.to_csv(f'table_{i+1}.csv', index=False)

1import tabula
2
3# Extract from password-protected PDF
4df = tabula.read_pdf(
5    "protected_report.pdf",
6    pages='all',
7    password='your_password',
8    multiple_tables=True
9)

1import tabula
2
3# Force specific column positions (in points from left edge)
4df = tabula.read_pdf(
5    "report.pdf",
6    pages='1',
7    columns=[100, 200, 300, 400],  # Column boundaries
8    stream=True
9)

1# For scanned PDFs, use OCR first
2import pytesseract
3from pdf2image import convert_from_path
4
5# Convert PDF to images
6images = convert_from_path('scanned_report.pdf')
7
8# OCR each page
9for i, image in enumerate(images):
10    text = pytesseract.image_to_string(image)
11    # Process extracted text...

1import tabula
2
3# Process pages in parallel
4tables = tabula.read_pdf(
5    "huge_report.pdf",
6    pages='all',
7    multiple_tables=True,
8    java_options=["-Xmx4096m"]  # Increase Java heap size
9)
10
11# Or process page ranges separately
12page_ranges = ['1-10', '11-20', '21-30']
13all_tables = []
14
15for page_range in page_ranges:
16    tables = tabula.read_pdf(
17        "huge_report.pdf",
18        pages=page_range,
19        multiple_tables=True
20    )
21    all_tables.extend(tables)

1# Create a batch file: extract_reports.bat
2python C:\scripts\pdf_extractor.py C:\reports\weekly_report.pdf excel

1# Add to crontab (run every Monday at 9 AM)
20 9 * * 1 /usr/bin/python3 /home/user/scripts/pdf_extractor.py /home/user/reports/weekly_report.pdf excel