How to: Upload (Advanced)

# Our persistence layer for queuing uploads, potentially using SQLite 
# or another embedded database
C2C_UPLOAD_STORE = NewC2CUploadStore()

# HTTP session for connection pooling
HTTP_SESSION = http.Session()

def take_picture():
    """Captures an image and adds it to the upload queue."""
    image = MY_DEVICE.capture()
    file_path = MY_DEVICE.write_image(image)

    # Register the file with our persistent store
    C2C_UPLOAD_STORE.add_file(file_path)

def task_register_assets():
    """
    Processes files from persistent storage and registers
    them with Frame.io for upload.
    """
    while True:
        # Get the next available file from our store
        file_record = C2C_UPLOAD_STORE.get_file()

        try:
            # Register the asset with Frame.io
            asset = c2c.create_asset_for_file(HTTP_SESSION, file_record)
            chunk_size = c2c.calculate_chunk_size(asset, file_record)

            # Create entries for each chunk in our persistent store
            chunk_start = 0
            for chunk_url in asset.upload_urls:
                message = {
                    "file_path": file_record,
                    "chunk_url": chunk_url,
                    "chunk_start": chunk_start,
                    "chunk_size": chunk_size,
                }
                
                C2C_UPLOAD_STORE.new_chunk(message)
                chunk_start += chunk_size
                
        except BaseException as error:
            # Record the error in our persistent store
            C2C_UPLOAD_STORE.file_asset_create_error(file_record, error)
        else:
            # Mark the asset as successfully created
            C2C_UPLOAD_STORE.file_asset_created(file_record)

def task_upload_chunk():
    """Uploads individual file chunks from the persistent queue."""
    while True:
        # Get the next chunk, marking it as "in progress" to prevent 
        # other tasks from processing it simultaneously
        chunk_record = C2C_UPLOAD_STORE.get_chunk()

        try:
            c2c.upload_chunk(HTTP_SESSION, chunk_record)
        except BaseException as error:
            # Record the error for potential retry
            C2C_UPLOAD_STORE.chunk_error(chunk_record, error)
        else:
            # Mark successful completion
            C2C_UPLOAD_STORE.chunk_success(chunk_record)

def launch_upload_tasks():
    """Launches Frame.io upload processing tasks."""
    tasks = []

    # Asset registration task
    asset_task = run_task_in_thread(task_register_assets)
    tasks.append(asset_task)

    # Multiple parallel chunk upload tasks
    worker_count = GET_CPU_COUNT() * 2
    for _ in range(worker_count):
        chunk_task = run_task_in_thread(task_upload_chunk)
        tasks.append(chunk_task)

    # Run indefinitely
    run_forever(tasks)