### Install Camelot from source

Source: https://github.com/camelot-dev/camelot/blob/master/docs/user/install.md

After cloning the repository and navigating into the directory, install Camelot using pip.

```bash
cd camelot
pip install "."
```

--------------------------------

### Install Development Dependencies

Source: https://github.com/camelot-dev/camelot/blob/master/docs/dev/contributing.md

Use this command to install the necessary dependencies for developing Camelot.

```bash
$ pip install "camelot-py[dev]"
```

--------------------------------

### Install Camelot

Source: https://github.com/camelot-dev/camelot/blob/master/examples/parser-comparison-notebook.ipynb

Installs the Camelot library. This is a prerequisite for using the library.

```python
!pip install camelot-py
```

--------------------------------

### Install from Cloned Repository

Source: https://github.com/camelot-dev/camelot/blob/master/docs/dev/contributing.md

After cloning the Camelot repository, use this command to install development dependencies.

```bash
$ pip install ".[dev]"
```

--------------------------------

### Install Camelot from source

Source: https://github.com/camelot-dev/camelot/blob/master/README.md

Clone the Camelot repository and install it locally. This is useful for development or using the latest unreleased code.

```bash
git clone https://github.com/camelot-dev/camelot.git
cd camelot
uv pip install "."  # or: pip install "."
```

--------------------------------

### Install Camelot using pip

Source: https://github.com/camelot-dev/camelot/blob/master/docs/user/install.md

Install Camelot from PyPI using pip. This is the most common installation method.

```bash
pip install "camelot-py"
```

--------------------------------

### Install Camelot with uv pip

Source: https://github.com/camelot-dev/camelot/blob/master/README.md

Use uv pip to install Camelot into the current environment. This is a quick way to get Camelot running.

```bash
uv pip install camelot-py
```

--------------------------------

### Install Ghostscript on Ubuntu

Source: https://github.com/camelot-dev/camelot/blob/master/docs/user/install-deps.md

Use this command to install Ghostscript on Ubuntu systems.

```bash
apt install ghostscript
```

--------------------------------

### Install Camelot and Tabulate

Source: https://github.com/camelot-dev/camelot/blob/master/examples/camelot-quickstart-notebook.ipynb

Installs the camelot-py library and the tabulate library, which is optionally used for pretty display of results in this notebook.

```python
# @title 🛠️ Install [camelot](https://github.com/camelot-dev/camelot)
!pip install camelot-py
# install tabulate (optional) only needed in this notebook for pretty display of results.
!pip install tabulate
```

--------------------------------

### Installing Camelot with ML and OCR Dependencies

Source: https://github.com/camelot-dev/camelot/blob/master/docs/user/migration.md

Install the 'ml' extra for the neural backend targeting borderless tables. For scanned or image-only PDFs, also install the 'ocr' extra. These pull heavier dependencies that are imported lazily.

```bash
pip install "camelot-py[ml]"
```

```bash
pip install "camelot-py[ml,ocr]"
```

--------------------------------

### Install Camelot with ML and OCR support

Source: https://github.com/camelot-dev/camelot/blob/master/docs/user/how-it-works.md

Install Camelot with the ML backend and optional OCR support for scanned documents. This command installs PyTorch as a dependency.

```bash
pip install 'camelot-py[ml]'
# Add [ocr] for scans: pip install 'camelot-py[ml,ocr]'
```

--------------------------------

### Install Camelot with ML and OCR extras

Source: https://github.com/camelot-dev/camelot/blob/master/README.md

Install Camelot with both 'ml' and 'ocr' extras for advanced borderless table extraction and OCR capabilities on scanned documents.

```bash
pip install "camelot-py[ml,ocr]"
```

--------------------------------

### Bootstrap and Import Camelot

Source: https://github.com/camelot-dev/camelot/blob/master/examples/parser-comparison-notebook.ipynb

Imports necessary libraries and sets up the environment to use Camelot. It ensures the local version of Camelot is preferred if available and prints the installed version.

```python
# Bootstrap and common imports
import sys, time, os

sys.path.insert(
    0, os.path.abspath("")
)  # Prefer the local version of camelot if available
import camelot

print(f"Using camelot v{camelot.__version__}.")
```

--------------------------------

### Install Camelot with uv

Source: https://github.com/camelot-dev/camelot/blob/master/README.md

Use uv to add Camelot to your project. This command installs the package and adds it to your project's dependencies.

```bash
uv add camelot-py
```

--------------------------------

### Core Setup for Complex Table Extraction

Source: https://github.com/camelot-dev/camelot/blob/master/examples/camelot-quickstart-notebook.ipynb

Imports necessary libraries like pandas and numpy, and sets up the output directory. This snippet serves as boilerplate for more complex table extraction scenarios.

```python
# import os
# from pathlib import Path
import pandas as pd
import numpy as np
from tabulate import tabulate

# Create output directory if it doesn't exist
output_dir = Path("/content/output")
output_dir.mkdir(parents=True, exist_ok=True)
```

--------------------------------

### Install Ghostscript on MacOS

Source: https://github.com/camelot-dev/camelot/blob/master/docs/user/install-deps.md

Use this command to install Ghostscript on MacOS systems using Homebrew.

```bash
brew install ghostscript
```

--------------------------------

### Install OCRmyPDF

Source: https://github.com/camelot-dev/camelot/blob/master/docs/user/advanced.md

Install OCRmyPDF using pipx or pip. This tool adds a text layer to image-based PDFs, making them readable by Camelot.

```shell
$ pipx install ocrmypdf  # or: pip install ocrmypdf
```

--------------------------------

### Install Camelot using conda

Source: https://github.com/camelot-dev/camelot/blob/master/docs/user/install.md

Install Camelot from the conda-forge channel using the conda package manager.

```bash
conda install -c conda-forge camelot-py
```

--------------------------------

### Install Camelot with ML extras

Source: https://github.com/camelot-dev/camelot/blob/master/README.md

Install Camelot with the 'ml' extra, which includes the Table Transformer model for enhanced borderless table extraction. This option requires PyTorch.

```bash
pip install "camelot-py[ml]"
```

--------------------------------

### Example Usage of per_page Parameter

Source: https://github.com/camelot-dev/camelot/blob/master/docs/api.md

Demonstrates how to use the 'per_page' argument to apply specific parsing settings to individual pages within a PDF. This is useful for documents with varying table structures across pages.

```python
tables = camelot.read_pdf(
    "report.pdf",
    pages="1-3",
    flavor="stream",
    split_text=True,
    per_page={
        2: {"table_areas": ["120, 210, 400, 90"]}
    },
)
```

--------------------------------

### Check Ghostscript Installation on Windows

Source: https://github.com/camelot-dev/camelot/blob/master/docs/user/install-deps.md

Run this Python code in the REPL to check if the Ghostscript library can be found on Windows. The output should not be empty.

```python
import ctypes
from ctypes.util import find_library
>>> find_library("".join(("gsdll", str(ctypes.sizeof(ctypes.c_voidp) * 8), ".dll")))
<name-of-ghostscript-library-on-windows>
```

--------------------------------

### Install Camelot with OCR extras

Source: https://github.com/camelot-dev/camelot/blob/master/README.md

Install Camelot with the 'ocr' extra for Optical Character Recognition, enabling text extraction from scanned PDFs. This is typically used in conjunction with the 'ml' extra.

```bash
pip install "camelot-py[ocr]"
```

--------------------------------

### Check Ghostscript Installation on Ubuntu/MacOS

Source: https://github.com/camelot-dev/camelot/blob/master/docs/user/install-deps.md

Run this Python code in the REPL to check if the Ghostscript library can be found on Ubuntu or MacOS. The output should not be empty.

```python
from ctypes.util import find_library
>>> find_library("gs")
"libgs.so.9"
```

--------------------------------

### Clone Camelot repository

Source: https://github.com/camelot-dev/camelot/blob/master/docs/user/install.md

Clone the Camelot GitHub repository to install from source code.

```bash
git clone https://www.github.com/camelot-dev/camelot
```

--------------------------------

### Install Camelot with Plot extras

Source: https://github.com/camelot-dev/camelot/blob/master/README.md

Install Camelot with the 'plot' extra to enable debugging plots using matplotlib. This helps visualize the extraction process.

```bash
pip install "camelot-py[plot]"
```

--------------------------------

### Configure PDF Analysis Parameters

Source: https://github.com/camelot-dev/camelot/blob/master/examples/hybrid-parser-step-by-step.ipynb

Defines variables for selecting a PDF file and its associated analysis parameters (kwargs). Several commented-out examples show how to configure different parsing options and select specific files.

```python
# Select a pdf to analyze.
kwargs = {}
data = None
# pdf_file = "vertical_header.pdf"  # test_network_vertical_header
# pdf_file, kwargs = "vertical_header.pdf", {"pages": "all"}  # test_network_vertical_headerpages
# pdf_file, kwargs = "background_lines_1.pdf", {"process_background": True} # {"process_background": True}  # test_lattice_process_background

# pdf_file, kwargs, data = "superscript.pdf", {"flag_size": True}, data_stream_flag_size  # test_network_flag_size
# pdf_file, kwargs = "superscript.pdf", {"flag_size": True} # , data_stream_flag_size  # test_network_flag_size
# pdf_file = "health.pdf"  # test_network
# pdf_file = "clockwise_table_2.pdf"
# pdf_file = "clockwise_table_1.pdf"
# pdf_file = "foo.pdf"
# pdf_file, kwargs = "saturation_threshold.pdf", {"process_color_background": False, "process_background": True, "saturation_threshold": 5, "threshold_blocksize": 25}  # "process_background": True,

# pdf_file = "birdisland.pdf"
# pdf_file, kwargs = "diesel_engines.pdf", {"pages": "4-5"} # containing multiple pages 2-4 = hybrid error same for 3-4,2-3

# pdf_file, kwargs = "column_span_1.pdf", {"copy_text": "h"}
# pdf_file = "tabula/12s0324.pdf"  # interesting because contains two separate tables
# pdf_file, kwargs = "tabula/12s0324.pdf", {"strip_text": " ,\n"}   # interesting because contains two separate tables
# pdf_file, kwargs = "tabula/us-007.pdf", {"table_regions": ["320,335,573,505"]} # test_network_table_regions
# pdf_file, kwargs = "tabula/us-007.pdf", {"table_areas": ["320,500,573,335"]} # test_network_table_areas
# pdf_file, kwargs = "detect_vertical_false.pdf", {"strip_text": " ,\n"}  # data_stream_strip_text
# pdf_file = "detect_vertical_false.pdf" #
# pdf_file, kwargs, data = "tabula/m27.pdf", {"columns": ["72,95,209,327,442,529,566,606,683"], "split_text": True, }, data_stream_split_text  # data_stream_split_text
# pdf_file, kwargs= "tabula/m27.pdf", {"columns": ["72,95,209,327,442,529,566,606,683"], "split_text": True, } # , data_stream_split_text  # data_stream_split_text

# pdf_file = "clockwise_table_2.pdf"  # test_network_table_rotated / test_stream_table_rotated
# pdf_file, kwargs = "clockwise_table_2.pdf", {"edge_tol": 10}  # configurable vgap header search not working
# edge_tol 0 gives an error
# pdf_file = "vertical_header.pdf"

# pdf_file = "twotables_2.pdf"
# pdf_file = "camelot-issue-132-multiple-tables.pdf"
# pdf_file = "multiple_tables.pdf" # fixes issue 132
# pdf_file, kwargs, data = "edge_tol.pdf", {"edge_tol": 500}, data_stream_edge_tol
# pdf_file, kwargs = "edge_tol.pdf", {"edge_tol": 500} # , data_stream_edge_tol
# pdf_file, kwargs, data = "edge_tol.pdf", {}, data_stream_edge_tol

# pdf_file = "tabula/arabic.pdf"
# pdf_file = "tabula/indictb1h_14.pdf" # interesting mixed type table
# pdf_file = "tabula/m27.pdf" # one table spanning multiple pages
# pdf_file = "tabula/mednine.pdf" # one table spanning multiple pages

# pdf_file = "tabula/spreadsheet_no_bounding_frame.pdf
# pdf_file, kwargs = "diesel_engines.pdf", {"pages": "4-5"} # containing multiple pages

# pdf_file, kwargs = "tabula/schools.pdf", {"pages": "all"}  # network parser hangs on contour plot

pdf_file = "vertical_header.pdf"
```

--------------------------------

### Visualize Table Growth

Source: https://github.com/camelot-dev/camelot/blob/master/examples/hybrid-parser-step-by-step.ipynb

Visualizes the iterative growth process of the table body starting from the seed.

```python
if tables is not None:
    fig, ax = init_figure_and_axis(f"Growth steps for table in PDF\n{pdf_file}")
    camelot.plot(tables[0], kind="network_table_search", ax=ax)
else:
    print("No table found for this document.")
```

--------------------------------

### Install camelot-py Correctly

Source: https://github.com/camelot-dev/camelot/blob/master/docs/user/faq.md

This command sequence resolves `AttributeError: module 'camelot' has no attribute 'read_pdf'` by uninstalling the incorrect 'camelot' package and installing the correct 'camelot-py' package with base dependencies.

```bash
$ pip uninstall camelot camelot-py
$ pip install "camelot-py[base]"
```

--------------------------------

### Bootstrap and Common Imports

Source: https://github.com/camelot-dev/camelot/blob/master/examples/camelot-quickstart-notebook.ipynb

Imports necessary libraries and checks the installed Camelot version. It also ensures the local version of Camelot is preferred if available.

```python
# Bootstrap and common imports
import os, sys, time

sys.path.insert(0, os.path.abspath(""))  # Prefer the local version if available

import camelot

print(f"Using camelot v{camelot.__version__}.")
```

--------------------------------

### Run Camelot CLI Ad-Hoc with uvx

Source: https://github.com/camelot-dev/camelot/blob/master/docs/user/cli.md

Execute the Camelot CLI without installing it using uvx. This is useful for quick, one-off tasks.

```bash
$ uvx camelot-py lattice --output tables.csv document.pdf
```

--------------------------------

### Infer Output Format from Extension

Source: https://github.com/camelot-dev/camelot/blob/master/docs/user/cli.md

Camelot can automatically detect the output format based on the file extension provided to the --output option. This example uses '.xlsx' to specify Excel format.

```bash
$ camelot-py lattice --output tables.xlsx document.pdf
# equivalent to: camelot-py lattice --format excel --output tables.xlsx document.pdf
```

--------------------------------

### Create Directories and Clean Up Sample Data

Source: https://github.com/camelot-dev/camelot/blob/master/examples/camelot-quickstart-notebook.ipynb

Sets up the necessary input and output directories for processing PDF files. It also deletes the '/content/sample_data' directory if it exists to ensure a clean environment.

```python
# @title 📂 Create necessary directories and delete `sample_data` if exists

import os
import shutil
from pathlib import Path


# Function to delete a directory and its contents
def delete_directory(path):
    try:
        shutil.rmtree(path)
        print(f"Deleted directory: {path}")
    except FileNotFoundError:
        print(f"Directory not found: {path}")
    except Exception as e:
        print(f"Error deleting directory {path}: {e}")


# Delete /content/sample_data if it exists
sample_data_dir = Path("/content/sample_data")
if sample_data_dir.exists():
    print("Deleting /content/sample_data directory...")
    delete_directory(sample_data_dir)

# Create the necessary directories
os.makedirs("/content/output", exist_ok=True)
os.makedirs("/content/sample_pdfs", exist_ok=True)

# Define input and output directories
input_dir = Path("/content/sample_pdfs")
output_dir = Path("/content/output")

print("Directories set up complete.")
print(f"Input directory: {input_dir}")
print(f"Output directory: {output_dir}")
```

--------------------------------

### Uninstall conflicting OpenCV and install Camelot

Source: https://github.com/camelot-dev/camelot/blob/master/docs/user/install.md

If you have the full opencv-python package installed, uninstall it first to avoid conflicts before installing camelot-py.

```bash
pip uninstall opencv-python
pip install camelot-py
```

--------------------------------

### Print Camelot CLI Help

Source: https://github.com/camelot-dev/camelot/blob/master/docs/user/cli.md

Display the main help information for the Camelot CLI.

```bash
camelot --help
```

--------------------------------

### TableList Initialization and Access

Source: https://github.com/camelot-dev/camelot/blob/master/docs/api.md

Demonstrates how to initialize an empty TableList and access its number of tables (n).

```python
>>> from camelot.core import TableList
>>> tables = TableList([])
>>> tables.n
0
>>> tables
<TableList n=0>
```

--------------------------------

### Enable mypyc Compilation in setup.py

Source: https://github.com/camelot-dev/camelot/blob/master/docs/dev/mypyc.md

This shim in setup.py enables mypyc compilation for specified modules when the CAMELOT_MYPYC environment variable is set. It integrates with setuptools to extend the build process.

```python
# setup.py
import os
from setuptools import setup
ext_modules = []
if os.environ.get("CAMELOT_MYPYC"):
    from mypyc.build import mypycify
    ext_modules = mypycify(
        ["camelot/utils.py"],
        opt_level="3",
        debug_level="1",
    )
setup(ext_modules=ext_modules)
```

--------------------------------

### Camelot CLI Usage Template

Source: https://github.com/camelot-dev/camelot/blob/master/docs/user/cli.md

Illustrates the general structure for using the Camelot CLI with options and commands.

```shell
camelot [OPTIONS] COMMAND [ARGS]...
```

--------------------------------

### Print Command Help

Source: https://github.com/camelot-dev/camelot/blob/master/docs/user/cli.md

Display help information for a specific Camelot command.

```bash
camelot <command> --help
```

--------------------------------

### Main Script Execution for PDF Processing

Source: https://github.com/camelot-dev/camelot/blob/master/examples/camelot-quickstart-notebook.ipynb

Sets up input and output directories, finds all PDF files in the input directory, and processes each PDF using the `process_pdf` function. Ensures the output directory exists.

```python
# Define input_dir and output_dir
input_dir = Path("/content/sample_pdfs")
output_dir = Path("/content/output")

print(f"Input directory: {input_dir}")
print(f"Output directory: {output_dir}")

# Ensure output directory exists
output_dir.mkdir(exist_ok=True)

# Process each PDF in the input directory
pdf_files = list(input_dir.glob("*.pdf"))
print(f"Found {len(pdf_files)} PDF files")

if len(pdf_files) == 0:
    print("No PDF files found in the input directory.")
    logging.warning("No PDF files found in the input directory.")
else:
    for pdf_file in pdf_files:
        process_pdf(pdf_file, output_dir)

    print("Processing complete. Check the 'output' folder for results.")
    logging.info("Processing complete. Check the 'output' folder for results.")

print("Script execution finished.")
```

--------------------------------

### Run Tests with Pytest

Source: https://github.com/camelot-dev/camelot/blob/master/docs/dev/contributing.md

Execute all tests for Camelot using the setup.py script, which utilizes pytest.

```bash
$ python setup.py test
```

--------------------------------

### Use Alternative Image Conversion Backends

Source: https://github.com/camelot-dev/camelot/blob/master/docs/user/advanced.md

Specify the image conversion backend for line recognition when using the Lattice flavor. 'pdfium' is the default, but 'ghostscript' can also be used.

```python
>>> tables = camelot.read_pdf(filename, backend="pdfium")  # default
```

```python
>>> tables = camelot.read_pdf(filename, backend="ghostscript")
```

--------------------------------

### Download Sample PDF Document

Source: https://github.com/camelot-dev/camelot/blob/master/examples/camelot-quickstart-notebook.ipynb

Downloads a sample PDF file from a GitHub URL and saves it to the '/content/sample_pdfs' directory. It includes a helper function to convert GitHub URLs to raw content URLs and handles potential errors during download.

```python
# @title ⬇📕 Download Sample .PDF Document (Optional)

# import os
import requests

# from pathlib import Path


def convert_github_url_to_raw(url):
    if "github.com" in url and "/blob/" in url:
        raw_url = url.replace("github.com", "raw.githubusercontent.com").replace(
            "/blob/", "/"
        )
        return raw_url
    else:
        return "Invalid GitHub URL"


# Sample .pdf data from GitHub
pdf_url = "https://github.com/camelot-dev/camelot/blob/master/docs/_static/pdf/foo.pdf"  # @param {type:"string"}

# Convert the GitHub URL to the raw content URL
pdf_url = convert_github_url_to_raw(pdf_url)

# Check if the URL is valid
if pdf_url == "Invalid GitHub URL":
    raise ValueError("The provided GitHub URL is invalid.")

# Create the /content/sample_pdfs directory if it doesn't exist
sample_pdfs_dir = Path("/content/sample_pdfs")
sample_pdfs_dir.mkdir(parents=True, exist_ok=True)

# Download the PDF
response = requests.get(pdf_url)
response.raise_for_status()  # Check if the request was successful

# Extract the filename from the URL
filename = os.path.basename(pdf_url)

# Specify the file path in the /content/sample_pdfs directory
pdf_file_path = sample_pdfs_dir / filename

# Save the file, overwriting if it already exists
with open(pdf_file_path, "wb") as file:
    file.write(response.content)

print(f"PDF file downloaded and saved to: {pdf_file_path}")
```

--------------------------------

### Fix Ghostscript Library Not Found on MacOS

Source: https://github.com/camelot-dev/camelot/blob/master/docs/user/install-deps.md

These commands can resolve issues where the ghostscript module is not found on MacOS after installation.

```bash
mkdir -p ~/lib
```

```bash
ln -s "$(brew --prefix gs)/lib/libgs.dylib" ~/lib
```

--------------------------------

### Import Camelot

Source: https://github.com/camelot-dev/camelot/blob/master/docs/user/quickstart.md

Import the Camelot library to begin using its functionalities.

```python
import camelot
```

--------------------------------

### Get Camelot and Dependency Versions

Source: https://github.com/camelot-dev/camelot/blob/master/docs/dev/contributing.md

Use this code snippet to gather version information for Camelot and its dependencies, which is crucial for bug reports.

```default
import platform; print(platform.platform())
import sys; print('Python', sys.version)
import numpy; print('NumPy', numpy.__version__)
import cv2; print('OpenCV', cv2.__version__)
import camelot; print('Camelot', camelot.__version__)
```

--------------------------------

### Set up Logging for Camelot

Source: https://github.com/camelot-dev/camelot/blob/master/examples/camelot-quickstart-notebook.ipynb

Configures basic logging for the 'camelot' library to display DEBUG level messages and format the output.

```python
logging.getLogger("camelot").setLevel(logging.DEBUG)
logging.basicConfig(
    level=logging.DEBUG, format="%(asctime)s - %(levelname)s - %(message)s"
)
```

--------------------------------

### Supply Custom Image Conversion Backend

Source: https://github.com/camelot-dev/camelot/blob/master/docs/user/advanced.md

Provide a custom class that implements the image conversion logic if the default backends do not meet your needs. The custom backend must have a 'convert' method.

```python
>>> class ConversionBackend(object):
>>>     def convert(pdf_path, png_path):
>>>         # read pdf page from pdf_path
>>>         # convert pdf page to image
>>>         # write image to png_path
>>>         pass
>>>
>>> tables = camelot.read_pdf(filename, backend=ConversionBackend())
```

--------------------------------

### Read PDF with Increased Line Scale

Source: https://github.com/camelot-dev/camelot/blob/master/docs/user/advanced.md

When small lines are not detected, increase the `line_scale` parameter to improve detection accuracy. This example shows how to set `line_scale` to 40.

```python
>>> tables = camelot.read_pdf('short_lines.pdf', line_scale=40)
>>> camelot.plot(tables[0], kind='grid').show()
```

--------------------------------

### Set up Plotting

Source: https://github.com/camelot-dev/camelot/blob/master/examples/hybrid-parser-step-by-step.ipynb

Imports the matplotlib library for plotting and defines a constant for plot height. This is used for visualizing parsing results.

```python
# Set up plotting options
import matplotlib.pyplot as plt

# %matplotlib inline
PLOT_HEIGHT = 12
```

--------------------------------

### Parse PDF with Network Flavor

Source: https://github.com/camelot-dev/camelot/blob/master/examples/hybrid-parser-step-by-step.ipynb

Initializes the network parser and visualizes text elements found in the document.

```python
# Parse file
flavor = "network"
timer_before_parse = time.perf_counter()
tables = camelot.read_pdf(filename, flavor=flavor, debug=True, **kwargs)
timer_after_parse = time.perf_counter()

if tables is not None:
    fig, ax = init_figure_and_axis(f"Text elements in PDF\n{pdf_file}")
    camelot.plot(tables[0], kind="text", ax=ax)
else:
    print("No table found for this document.")
```

--------------------------------

### Read PDF with Lattice Method

Source: https://github.com/camelot-dev/camelot/blob/master/docs/user/quickstart.md

Read a PDF file and extract tables using the Lattice method, suitable for tables with clear lines. Camelot defaults to Lattice if no flavor is specified.

```python
tables = camelot.read_pdf('foo.pdf')
```

--------------------------------

### Reading PDFs from Memory with Camelot

Source: https://github.com/camelot-dev/camelot/blob/master/docs/user/advanced.md

Demonstrates how to pass PDF content directly to `read_pdf()` using bytes, bytearray, io.BytesIO, or binary streams.

```python
import io, requests, camelot

# Bytes you already have in memory
data = open('doc.pdf', 'rb').read()
camelot.read_pdf(data)

# An io.BytesIO
camelot.read_pdf(io.BytesIO(data))

# Straight from an HTTP response
resp = requests.get('https://example.org/doc.pdf')
camelot.read_pdf(io.BytesIO(resp.content))
```

--------------------------------

### Supply Custom Image Conversion Backend for Lattice

Source: https://github.com/camelot-dev/camelot/blob/master/docs/user/faq.md

When using the Lattice flavor, you can provide a custom image conversion backend by defining a class with a 'convert' method.

```python
>>> class ConversionBackend(object):
>>>     def convert(pdf_path, png_path):
>>>         # read pdf page from pdf_path
>>>         # convert pdf page to image
>>>         # write image to png_path
>>>         pass
>>>
>>> tables = camelot.read_pdf(filename, backend=ConversionBackend())

```

--------------------------------

### Reading PDFs with the Neural Backend (flavor='ml')

Source: https://github.com/camelot-dev/camelot/blob/master/docs/user/migration.md

Use flavor='ml' to leverage the Table Transformer model for table structure and cell text extraction, particularly useful for borderless tables. Optional device specification like 'cuda' or 'xpu' can be provided.

```python
tables = camelot.read_pdf("report.pdf", flavor="ml")  # device="cuda"/"xpu" optional
```

--------------------------------

### Add and Commit Changes

Source: https://github.com/camelot-dev/camelot/blob/master/docs/dev/contributing.md

Stage your modified files using 'git add' and then commit them with 'git commit'.

```bash
$ git add modified_files
$ git commit
```

--------------------------------

### Configure PDF File and Parsing Options

Source: https://github.com/camelot-dev/camelot/blob/master/examples/parser-comparison-notebook.ipynb

Sets the PDF file to be analyzed and configures parsing parameters. This section allows for customization of table extraction based on specific PDF characteristics or desired output.

```python
kwargs = {}
data = None
# pdf_file = "vertical_header.pdf"  # test_network_vertical_header
# pdf_file, kwargs = "vertical_header.pdf", {"pages": "all"}  # test_network_vertical_headerpages
# pdf_file, kwargs = "background_lines_1.pdf", {"process_background": True} # {"process_background": True}  # test_lattice_process_background

# pdf_file, kwargs, data = "superscript.pdf", {"flag_size": True}, data_stream_flag_size  # test_network_flag_size
# pdf_file, kwargs = "superscript.pdf", {"flag_size": True} # , data_stream_flag_size  # test_network_flag_size
# pdf_file = "health.pdf"  # test_network
# pdf_file = "clockwise_table_2.pdf"
# pdf_file = "clockwise_table_1.pdf"
# pdf_file = "foo.pdf"
# pdf_file, kwargs = "saturation_threshold.pdf", {"process_color_background": False, "process_background": True, "saturation_threshold": 5, "threshold_blocksize": 25}  # "process_background": True, 

# pdf_file = "birdisland.pdf"
# pdf_file, kwargs = "diesel_engines.pdf", {"pages": "4-5"} # containing multiple pages 2-4 = hybrid error same for 3-4,2-3

# pdf_file, kwargs = "column_span_1.pdf", {"copy_text": "h"}
# pdf_file = "tabula/12s0324.pdf"  # interesting because contains two separate tables
# pdf_file, kwargs = "tabula/12s0324.pdf", {"strip_text": " ,\n"}   # interesting because contains two separate tables
# pdf_file, kwargs = "tabula/us-007.pdf", {"table_regions": ["320,335,573,505"]} # test_network_table_regions
# pdf_file, kwargs = "tabula/us-007.pdf", {"table_areas": ["320,500,573,335"]} # test_network_table_areas
# pdf_file, kwargs = "detect_vertical_false.pdf", {"strip_text": " ,\n"}  # data_stream_strip_text
# pdf_file = "detect_vertical_false.pdf" #
# pdf_file, kwargs, data = "tabula/m27.pdf", {"columns": ["72,95,209,327,442,529,566,606,683"], "split_text": True, }, data_stream_split_text  # data_stream_split_text
# pdf_file, kwargs= "tabula/m27.pdf", {"columns": ["72,95,209,327,442,529,566,606,683"], "split_text": True, } # , data_stream_split_text  # data_stream_split_text

# pdf_file = "clockwise_table_2.pdf"  # test_network_table_rotated / test_stream_table_rotated
# pdf_file, kwargs = "clockwise_table_2.pdf", {"edge_tol": 10}  # configurable vgap header search not working
# edge_tol 0 gives an error
pdf_file = "vertical_header.pdf"

# pdf_file = "twotables_2.pdf"
# pdf_file = "camelot-issue-132-multiple-tables.pdf"
# pdf_file = "multiple_tables.pdf" # fixes issue 132
# pdf_file, kwargs, data = "edge_tol.pdf", {"edge_tol": 500}, data_stream_edge_tol
# pdf_file, kwargs = "edge_tol.pdf", {"edge_tol": 500} # , data_stream_edge_tol
# pdf_file, kwargs, data = "edge_tol.pdf", {}, data_stream_edge_tol

# pdf_file = "tabula/arabic.pdf"
# pdf_file = "tabula/indictb1h_14.pdf" # interesting mixed type table
# pdf_file = "tabula/m27.pdf" # one table spanning multiple pages
# pdf_file = "tabula/mednine.pdf" # one table spanning multiple pages

# pdf_file = "tabula/spreadsheet_no_bounding_frame.pdf
# pdf_file, kwargs = "diesel_engines.pdf", {"pages": "4-5"} # containing multiple pages
```

--------------------------------

### prepare_page_parse

Source: https://github.com/camelot-dev/camelot/blob/master/docs/api.md

Prepares the current page for the parsing process by setting up necessary layout and page information.

```APIDOC
## prepare_page_parse(filename, layout, dimensions, page_idx, images, horizontal_text, vertical_text, rotation, layout_kwargs)

### Description
Prepare the page for parsing.
```

--------------------------------

### camelot.parsers.Hybrid.prepare_page_parse

Source: https://github.com/camelot-dev/camelot/blob/master/docs/api.md

Call this method to prepare the page parsing.

```APIDOC
## prepare_page_parse(filename, layout, dimensions, page_idx, images, horizontal_text, vertical_text, rotation, layout_kwargs)

Call this method to prepare the page parsing .

### Parameters:
* **filename** ( *[**type* *]*) – [description]
* **layout** ( *[**type* *]*) – [description]
* **dimensions** ( *[**type* *]*) – [description]
* **page_idx** ( *[**type* *]*) – [description]
* **layout_kwargs** ( *[**type* *]*) – [description]
```

--------------------------------

### Use 'combined' engine with 'hybrid' flavor

Source: https://github.com/camelot-dev/camelot/blob/master/docs/user/advanced.md

The 'combined' engine also works with the 'hybrid' flavor, driving the lattice half of the hybrid parser to improve table detection in mixed-layout documents.

```python
>>> tables = camelot.read_pdf(
...     'mixed_layout.pdf',
...     flavor='hybrid',
...     engine='combined',
... )
```

--------------------------------

### Create a New Branch

Source: https://github.com/camelot-dev/camelot/blob/master/docs/dev/contributing.md

Create a new branch for your feature or contribution. Always branch out from 'master'.

```bash
$ git checkout -b my-feature
```

--------------------------------

### Run Comparison Benchmarking Script

Source: https://github.com/camelot-dev/camelot/blob/master/docs/user/comparison.md

Execute the Python script to benchmark Camelot and other importable table extractors against a canonical corpus. The script measures table count and timing.

```default
$ python bench/comparison.py
```

--------------------------------

### Improving Table Row Grouping with row_tol

Source: https://github.com/camelot-dev/camelot/blob/master/docs/user/advanced.md

Demonstrates how to use the `row_tol` parameter to group rows closer together for better table structure detection.

```python
tables = camelot.read_pdf('group_rows.pdf', flavor='stream')
tables[0].df
```

```python
tables = camelot.read_pdf('group_rows.pdf', flavor='stream', row_tol=10)
tables[0].df
```

--------------------------------

### Read PDF and Plot Grid

Source: https://github.com/camelot-dev/camelot/blob/master/docs/user/advanced.md

Use this snippet to read a PDF and visualize the detected table grid. It's useful for initial inspection and understanding how Camelot interprets table structures.

```python
>>> tables = camelot.read_pdf('short_lines.pdf')
>>> camelot.plot(tables[0], kind='grid').show()
```

--------------------------------

### Compare PDF Parsing Flavors

Source: https://github.com/camelot-dev/camelot/blob/master/examples/parser-comparison-notebook.ipynb

Iterates through different Camelot parsing flavors to extract tables from a PDF, measuring the time taken and reporting the number of tables found. It also checks for duplicate tables across flavors.

```python
FLAVORS = ["stream", "lattice", "network", "hybrid", "auto"]
tables_parsed = {}
parses = {}
max_tables = 0
for idx, flavor in enumerate(FLAVORS):
    timer_before_parse = time.perf_counter()
    error, tables = None, []
    try:
        tables = camelot.read_pdf(filename, flavor=flavor, debug=True, **kwargs)
    except ValueError as value_error:
        error = f"Invalid argument for parser {flavor}: {value_error}"
        print(error)
    timer_after_parse = time.perf_counter()
    max_tables = max(max_tables, len(tables))

    parses[flavor] = {
        "tables": tables,
        "time": timer_after_parse - timer_before_parse,
        "error": error,
    }

    print(f"##### {flavor} ####")
    print(f"Found {len(tables)} table(s):")
    for idx, table in enumerate(tables):
        flavors_matching = []
        for previous_flavor, previous_tables in tables_parsed.items():
            for prev_idx, previous_table in enumerate(previous_tables):
                if previous_table.df.equals(table.df):
                    flavors_matching.append(f"{previous_flavor} table {prev_idx}")
        print(f"## Table {idx} ##")
        report = table.parsing_report
        print(
            f"  accuracy={report.get(\"accuracy\", 0):.1f}% "
            f"whitespace={report.get(\"whitespace\", 0):.1f}% "
            f"confidence={report.get(\"confidence\", 0):.2f}"
        )
        if flavors_matching:
            print(f"Same as {', '.join(flavors_matching)}.")
        else:
            display(table.df)
            print("")
    tables_parsed[flavor] = tables
```

--------------------------------

### Select Parser and Page Range

Source: https://github.com/camelot-dev/camelot/blob/master/docs/api.md

Extracts tables from a PDF file using the 'lattice' parser and specifies a page range from 1 to 3.

```python
>>> tables = camelot.read_pdf(  # xdoctest: +SKIP
...     "foo.pdf", flavor="lattice", pages="1-3"
... )
```

--------------------------------

### Use 'combined' engine for faint vector lines

Source: https://github.com/camelot-dev/camelot/blob/master/docs/user/advanced.md

Use the 'combined' engine with the 'lattice' flavor to detect tables with faintly rendered vector lines that the default 'raster' engine might miss. This is safe to try on any lattice PDF as it includes raster detection.

```python
>>> # Recover a faintly-ruled vector table that 'raster' misses
>>> tables = camelot.read_pdf(
...     'vector_ruled.pdf',
...     flavor='lattice',
...     engine='combined',
... )
```

--------------------------------

### Read PDF and Export Table Data

Source: https://github.com/camelot-dev/camelot/blob/master/README.md

This snippet demonstrates the basic workflow of reading a PDF, accessing table data, and exporting it to a CSV file. It also shows how to access parsing reports and convert the table to a pandas DataFrame.

```python
import camelot
tables = camelot.read_pdf('foo.pdf')
print(tables)

tables.export('foo.csv', f='csv', compress=True) # json, excel, html, markdown, sqlite

print(tables[0])
print(tables[0].parsing_report)

tables[0].to_csv('foo.csv') # to_json, to_excel, to_html, to_markdown, to_sqlite
print(tables[0].df) # get a pandas DataFrame!
```

--------------------------------

### Parse PDF with Lattice Parser

Source: https://github.com/camelot-dev/camelot/blob/master/examples/hybrid-parser-step-by-step.ipynb

Parses a PDF file using the Lattice parser to detect table structures based on solid lines. Requires the 'lattice' flavor and optionally accepts debug mode and other keyword arguments.

```python
flavor = "lattice"
timer_before_parse = time.perf_counter()
tables = camelot.read_pdf(filename, flavor=flavor, debug=True, **kwargs)
timer_after_parse = time.perf_counter()

if tables is not None:
    fig, ax = init_figure_and_axis(f"Line structure in PDF\n{pdf_file}")
    camelot.plot(tables[0], kind="line", ax=ax)
else:
    print("No table found for this document.")
```