操作指南：上传（高级）

math.ceiling(float(21136250) / float(4))
# 5284063 bytes

# Where we are going to queue new files.
FILE_QUEUE = Queue()
# Where we are going to queue new chunks.
CHUNK_QUEUE = Queue()
# The http session that will handle TCP 
# connection pooling for us.
HTTP_SESSION = http.Session()
def take_picture():
    """Snaps a picture for the user."""
    image = MY_DEVICE.capture()
    file_path = MY_DEVICE.write_image(image)
    FILE_QUEUE.add(file_path)
def task_register_assets():
    """
    Pulls snapped pictures from the FILE_QUEUE, registers
    with Frame.io, and adds the chunks to the CHUNK_QUEUE.
    """
    while True:
        # Get the latest file added to the queue and register 
        # a C2C Asset for it.
        new_file = FILE_QUEUE.get()
        asset = c2c.crete_asset_for_file(HTTP_SESSION, new_file)
        # Calculate the size for each chunk
        chunk_size = c2c.calculate_chunk_size(asset, new_file)
        # Create a message for each chunk with it's parameters 
        # and add it to the 
        # queue.
        chunk_start = 0
        for chunk_url in asset.upload_urls:
            message = {
                "file_path": new_file,
                "chunk_url": chunk_url,
                "chunk_start": chunk_start,
                "chunk_size": chunk_size,
            }
            # Put the message in the queue and 
            CHUNK_QUEUE.put(message)
            chunk_start += chunk_size
def task_upload_chunk():
    """Takes a chunks and uploads them."""
    while True:
        info = CHUNK_QUEUE.get()
        c2c.upload_chunk(HTTP_SESSION, info)
def launch_upload_tasks():
    """Lauches our Frame.io upload tasks."""
    # Create a list to hold all of our tasks.
    tasks = list()
    # Create one task for registering assets.
    asset_task = run_task_in_thread(task_register_assets)
    tasks.append(asset_task)
    # Create 2 tasks per CPU core for uploading chunks.
    for _ in range(0, GET_CPU_COUNT() * 2):
        chunk_task = run_task_in_thread(task_upload_chunk)
        tasks.append(chunk_task)
    # Run these tasks until shutdown
    run_forever(tasks)

# 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)