Response

from pyzerox import zerox

result = await zerox(file_path="document.pdf")
# result is a ZeroxOutput object

@dataclass
class ZeroxOutput:
    completion_time: float
    file_name: str
    input_tokens: int
    output_tokens: int
    pages: List[Page]

@dataclass
class Page:
    content: str
    content_length: int
    page: int

ZeroxOutput(
    completion_time=9432.975,
    file_name='cs101',
    input_tokens=36877,
    output_tokens=515,
    pages=[
        Page(
            content='| Type    | Description                          | Wrapper Class |\n' +
                    '|---------|--------------------------------------|---------------|\n' +
                    '| byte    | 8-bit signed 2s complement integer   | Byte          |\n' +
                    '| short   | 16-bit signed 2s complement integer  | Short         |\n' +
                    '| int     | 32-bit signed 2s complement integer  | Integer       |\n' +
                    '| long    | 64-bit signed 2s complement integer  | Long          |\n' +
                    '| float   | 32-bit IEEE 754 floating point number| Float         |\n' +
                    '| double  | 64-bit floating point number         | Double        |\n' +
                    '| boolean | may be set to true or false          | Boolean       |\n' +
                    '| char    | 16-bit Unicode (UTF-16) character    | Character     |\n\n' +
                    'Table 26.2.: Primitive types in Java\n\n' +
                    '### 26.3.1. Declaration & Assignment\n\n' +
                    'Java is a statically typed language meaning that all variables must be declared before you can use ' +
                    'them or refer to them. In addition, when declaring a variable, you must specify both its type and ' +
                    'its identifier. For example:\n\n' +
                    '```java\n' +
                    'int numUnits;\n' +
                    'double costPerUnit;\n' +
                    'char firstInitial;\n' +
                    'boolean isStudent;\n' +
                    '```\n\n' +
                    'Each declaration specifies the variable\'s type followed by the identifier and ending with a ' +
                    'semicolon. The identifier rules are fairly standard: a name can consist of lowercase and ' +
                    'uppercase alphabetic characters, numbers, and underscores but may not begin with a numeric ' +
                    'character. We adopt the modern camelCasing naming convention for variables in our code. In ' +
                    'general, variables must be assigned a value before you can use them in an expression. You do not ' +
                    'have to immediately assign a value when you declare them (though it is good practice), but some ' +
                    'value must be assigned before they can be used or the compiler will issue an error.\n\n' +
                    'The assignment operator is a single equal sign, `=` and is a right-to-left assignment. That is, ' +
                    'the variable that we wish to assign the value to appears on the left-hand-side while the value ' +
                    '(literal, variable or expression) is on the right-hand-side. Using our variables from before, ' +
                    'we can assign them values:\n\n' +
                    '> 2 Instance variables, that is variables declared as part of an object do have default values. ' +
                    'For objects, the default is `null`, for all numeric types, zero is the default value. For the ' +
                    'boolean type, `false` is the default, and the default char value is `\\0`, the null-terminating ' +
                    'character (zero in the ASCII table).',
            content_length=2333,
            page=1
        )
    ]
)

result = await zerox(file_path="document.pdf")

# Get all page content as a single string
full_markdown = "\n\n".join(page.content for page in result.pages)

# Process each page individually
for page in result.pages:
    print(f"\n--- Page {page.page} ---")
    print(page.content[:200])  # Print first 200 characters
    print(f"Total length: {page.content_length} characters")

result = await zerox(file_path="document.pdf")

# Example pricing for gpt-4o-mini (as of 2024)
INPUT_COST_PER_1K = 0.00015   # $0.15 per 1M tokens
OUTPUT_COST_PER_1K = 0.0006    # $0.60 per 1M tokens

input_cost = (result.input_tokens / 1000) * INPUT_COST_PER_1K
output_cost = (result.output_tokens / 1000) * OUTPUT_COST_PER_1K
total_cost = input_cost + output_cost

print(f"Input tokens: {result.input_tokens:,} (${input_cost:.4f})")
print(f"Output tokens: {result.output_tokens:,} (${output_cost:.4f})")
print(f"Total cost: ${total_cost:.4f}")

result = await zerox(
    file_path="large-document.pdf",
    concurrency=10
)

time_in_seconds = result.completion_time / 1000
time_per_page = result.completion_time / len(result.pages)

print(f"Total time: {time_in_seconds:.2f}s")
print(f"Pages processed: {len(result.pages)}")
print(f"Average time per page: {time_per_page:.0f}ms")

result = await zerox(file_path="document.pdf")

# Find pages containing specific keywords
search_term = "invoice"
matching_pages = [
    page for page in result.pages 
    if search_term.lower() in page.content.lower()
]

print(f"Found '{search_term}' on {len(matching_pages)} pages:")
for page in matching_pages:
    print(f"  - Page {page.page}")

import aiofiles
import os

result = await zerox(file_path="document.pdf")

# Save each page as a separate markdown file
output_dir = "./output/pages"
os.makedirs(output_dir, exist_ok=True)

for page in result.pages:
    file_path = os.path.join(output_dir, f"page_{page.page}.md")
    async with aiofiles.open(file_path, "w") as f:
        await f.write(page.content)

print(f"Saved {len(result.pages)} pages to {output_dir}")

from typing import List
from pyzerox import zerox
from pyzerox.core.types import ZeroxOutput, Page

async def process_document(file_path: str) -> ZeroxOutput:
    result: ZeroxOutput = await zerox(file_path=file_path)
    return result

def analyze_pages(pages: List[Page]) -> None:
    for page in pages:
        print(f"Page {page.page}: {page.content_length} chars")

# Usage
result = await process_document("document.pdf")
analyze_pages(result.pages)