API Methods

def parse(
    files: Union[str, Path, bytes, BinaryIO, List[Union[str, Path, bytes, BinaryIO]]],
    mode: ProcessingMode = ProcessingMode.DEFAULT,
    progress_callback: Optional[Callable[[JobStatus], None]] = None,
    timeout: float = 60.0,
    poll_interval: float = 2.0
) -> DocumentBatch

from cerevox import Lexa, ProcessingMode

client = Lexa(api_key="your-api-key")

# Parse single file
documents = client.parse("document.pdf")

# Parse multiple files
documents = client.parse(["doc1.pdf", "doc2.docx", "doc3.txt"])

# Parse with custom settings
documents = client.parse(
    files=["document.pdf"],
    mode=ProcessingMode.ADVANCED,
    timeout=120.0,
    poll_interval=1.0
)

# Parse bytes content
with open("document.pdf", "rb") as f:
    content = f.read()
documents = client.parse(content)

# Parse with progress callback
def progress_callback(status):
    print(f"Status: {status.status}")

documents = client.parse(
    ["large-document.pdf"],
    progress_callback=progress_callback
)

def parse_urls(
    urls: Union[str, List[str]],
    mode: ProcessingMode = ProcessingMode.DEFAULT,
    progress_callback: Optional[Callable[[JobStatus], None]] = None,
    timeout: float = 120.0,
    poll_interval: float = 2.0
) -> DocumentBatch

# Parse single URL
documents = client.parse_urls("https://example.com/document.pdf")

# Parse multiple URLs
urls = [
    "https://example.com/doc1.pdf",
    "https://example.com/doc2.docx"
]
documents = client.parse_urls(urls)

# Parse with custom settings
documents = client.parse_urls(
    urls=["https://example.com/large-document.pdf"],
    mode=ProcessingMode.ADVANCED,
    timeout=300.0,
    poll_interval=5.0
)

def get_job_status(job_id: str) -> JobStatus

# Get job status
status = client.get_job_status("job_123456")
print(f"Status: {status.status}")
print(f"Progress: {status.progress}")

# Monitor job until completion
import time

while True:
    status = client.get_job_status("job_123456")
    print(f"Current status: {status.status}")
    
    if status.status in ["COMPLETED", "FAILED"]:
        break
    
    time.sleep(2)

def list_s3_buckets() -> S3BucketList

# List all buckets
buckets = client.list_s3_buckets()
print(f"Found {len(buckets.buckets)} buckets")

for bucket in buckets.buckets:
    print(f"Bucket: {bucket.name}")
    print(f"Created: {bucket.creation_date}")

def list_s3_folder(
    bucket: str,
    folder_path: str = "",
    max_items: int = 1000
) -> S3FolderContents

# List root folder
contents = client.list_s3_folder("my-bucket")

# List specific folder
contents = client.list_s3_folder("my-bucket", "documents/")

# List with custom limit
contents = client.list_s3_folder(
    bucket="my-bucket",
    folder_path="documents/",
    max_items=100
)

# Display contents
for item in contents.files:
    print(f"File: {item.key} ({item.size} bytes)")

def parse_s3_folder(
    bucket: str,
    folder_path: str = "",
    mode: ProcessingMode = ProcessingMode.DEFAULT,
    progress_callback: Optional[Callable[[JobStatus], None]] = None,
    timeout: float = 300.0,
    poll_interval: float = 5.0
) -> DocumentBatch

# Parse entire bucket
documents = client.parse_s3_folder("my-bucket")

# Parse specific folder
documents = client.parse_s3_folder("my-bucket", "documents/")

# Parse with progress monitoring
def progress_callback(status):
    print(f"Progress: {status.progress}")

documents = client.parse_s3_folder(
    bucket="my-bucket",
    folder_path="documents/",
    progress_callback=progress_callback,
    timeout=600.0
)

def list_sharepoint_sites() -> SharePointSiteList

# List all sites
sites = client.list_sharepoint_sites()

for site in sites.sites:
    print(f"Site: {site.name} (ID: {site.id})")
    print(f"URL: {site.web_url}")

def list_sharepoint_drives(site_id: str) -> SharePointDriveList

# List drives in a site
drives = client.list_sharepoint_drives("site-id-123")

for drive in drives.drives:
    print(f"Drive: {drive.name} (ID: {drive.id})")
    print(f"Type: {drive.drive_type}")

def parse_sharepoint_folder(
    site_id: str,
    drive_id: str,
    folder_path: str = "",
    mode: ProcessingMode = ProcessingMode.DEFAULT,
    progress_callback: Optional[Callable[[JobStatus], None]] = None,
    timeout: float = 300.0,
    poll_interval: float = 5.0
) -> DocumentBatch

# Parse SharePoint folder
documents = client.parse_sharepoint_folder(
    site_id="site-123",
    drive_id="drive-456",
    folder_path="Documents/"
)

# Parse with progress monitoring
documents = client.parse_sharepoint_folder(
    site_id="site-123",
    drive_id="drive-456",
    folder_path="Documents/",
    progress_callback=lambda status: print(f"Progress: {status.progress}"),
    mode=ProcessingMode.ADVANCED,
    timeout=600.0
)

def list_box_folders(parent_folder_id: str = "0") -> BoxFolderList

# List root folders
folders = client.list_box_folders()

# List specific folder contents
folders = client.list_box_folders("123456789")

for folder in folders.folders:
    print(f"Folder: {folder.name} (ID: {folder.id})")

def parse_box_folder(
    folder_id: str,
    mode: ProcessingMode = ProcessingMode.DEFAULT,
    progress_callback: Optional[Callable[[JobStatus], None]] = None,
    timeout: float = 300.0,
    poll_interval: float = 5.0
) -> DocumentBatch

# Parse Box folder
documents = client.parse_box_folder("123456789")

# Parse with custom settings
documents = client.parse_box_folder(
    folder_id="123456789",
    mode=ProcessingMode.ADVANCED,
    timeout=600.0
)

def list_dropbox_folders(folder_path: str = "") -> DropboxFolderList

# List root folders
folders = client.list_dropbox_folders()

# List specific folder
folders = client.list_dropbox_folders("/Documents")

for folder in folders.folders:
    print(f"Folder: {folder.name}")
    print(f"Path: {folder.path_display}")

def parse_dropbox_folder(
    folder_path: str,
    mode: ProcessingMode = ProcessingMode.DEFAULT,
    progress_callback: Optional[Callable[[JobStatus], None]] = None,
    timeout: float = 300.0,
    poll_interval: float = 5.0
) -> DocumentBatch

# Parse Dropbox folder
documents = client.parse_dropbox_folder("/Documents")

# Parse with progress monitoring
documents = client.parse_dropbox_folder(
    folder_path="/Documents",
    progress_callback=lambda status: print(f"Status: {status.status}"),
    mode=ProcessingMode.ADVANCED,
    timeout=600.0
)

import asyncio
from cerevox import AsyncLexa, ProcessingMode

async def main():
    async with AsyncLexa(api_key="your-api-key") as client:
        # All methods are available with await
        documents = await client.parse(["document.pdf"])
        
        # Concurrent processing
        tasks = [
            client.parse(["doc1.pdf"]),
            client.parse(["doc2.pdf"]),
            client.parse_urls(["https://example.com/doc.pdf"])
        ]
        
        results = await asyncio.gather(*tasks)
        all_documents = [doc for batch in results for doc in batch]
        
        return all_documents

asyncio.run(main())