Python SDK

from cyberdesk import CyberdeskClient

client = CyberdeskClient('YOUR_API_KEY')

client = CyberdeskClient('YOUR_API_KEY', base_url='https://api.your-domain.com')

async with CyberdeskClient('YOUR_API_KEY') as client:
    response = await client.runs.list()
    # Client automatically cleans up when done

# Async
response = await client.runs.create(data)

# Sync
response = client.runs.create_sync(data)

import asyncio
import base64
from cyberdesk import CyberdeskClient, RunCreate, FileInput, AttachmentType

async def main():
    async with CyberdeskClient("YOUR_API_KEY") as client:
        # 1. Prepare and upload the input file
        report_content = "This is the initial report content."
        encoded_content = base64.b64encode(report_content.encode()).decode()

        run_data = RunCreate(
            workflow_id="your-file-processing-workflow-id",
            file_inputs=[
                FileInput(filename="report.txt", content=encoded_content)
            ]
        )
        response = await client.runs.create(run_data)
        run = response.data
        print(f"Run started: {run.id}")

        # 2. Wait for the run to complete
        completed_run = await wait_for_run_completion(client, run.id)
        print("Run finished with status:", completed_run.status)

        # 3. Find and download the output attachment
        if completed_run.status == 'success':
            response = await client.run_attachments.list(
                run_id=completed_run.id,
                attachment_type=AttachmentType.OUTPUT
            )
            output_attachments = response.data.items
            
            if output_attachments:
                processed_report = output_attachments[0]
                
                # Option 1: Get a download URL (for web apps)
                url_response = await client.run_attachments.get_download_url(processed_report.id)
                if url_response.data:
                    print(f"Download URL: {url_response.data.url}")
                    print(f"Valid for: {url_response.data.expires_in} seconds")
                
                # Option 2: Download the processed file directly
                response = await client.run_attachments.download(processed_report.id)
                
                if not response.error:
                    # Decode and print the content
                    processed_content = response.data.decode()
                    print("\n--- Processed Report ---")
                    print(processed_content)
                    print("------------------------")
                else:
                    print(f"Failed to download processed file: {response.error}")
            else:
                print("No output files were generated.")

# Assuming wait_for_run_completion is defined as in the previous examples
asyncio.run(main())

{"$ref": "step1.outputs.result"}

from cyberdesk import CyberdeskClient, WorkflowChainCreate

client = CyberdeskClient(os.environ['CYBERDESK_API_KEY'])

chain = WorkflowChainCreate(
    shared_inputs={
        "search_query": "red panda facts"
    },
    # Filter machines by pools; or use machine_id to target one machine
    pool_ids=["pool-with-chrome", "customer-a"],
    keep_session_after_completion=False,
    steps=[
        {
            "workflow_id": "step-1-workflow-id",
            "session_alias": "step1",
            "inputs": {"topic": "red panda"}
        },
        {
            "workflow_id": "step-2-workflow-id",
            "session_alias": "step2",
            "inputs": {"search_query": {"$ref": "step1.outputs.result"}}
        }
    ]
)

resp = client.runs.chain_sync(chain)
print("session:", resp.data.session_id)
print("run_ids:", resp.data.run_ids)

chain = WorkflowChainCreate(
    session_id="existing-session-uuid",
    steps=[
        {"workflow_id": "wf-a", "session_alias": "warmup"},
        {"workflow_id": "wf-b", "session_alias": "extract", "inputs": {"query": "current patient"}},
    ]
)
client.runs.chain_sync(chain)

client.runs.chain_sync(WorkflowChainCreate(
    pool_ids=["customer-a"],
    keep_session_after_completion=True,
    steps=[ ... ]
))

# 1) Start a session and warm up the desktop
warmup = client.runs.create_sync(RunCreate(
    workflow_id='login-workflow-id',
    pool_ids=['customer-a'],
    start_session=True,
    input_values={'username': 'alice'}
)).data

session_id = warmup.session_id

# 2) Add another run in the same session — scheduling remains exclusive
client.runs.create_sync(RunCreate(
    workflow_id='search-workflow-id',
    session_id=session_id,
    input_values={'query': 'recent orders'}
))

# 3) Final run that releases the session when complete
client.runs.create_sync(RunCreate(
    workflow_id='cleanup-workflow-id',
    session_id=session_id,
    release_session_after=True,  # Release the session after this run completes
    input_values={'cleanup': 'true'}
))

# This run will release the session after it completes
final_run = client.runs.create_sync(RunCreate(
    workflow_id='final-workflow-id',
    session_id=existing_session_id,
    release_session_after=True,
    input_values={'finalize': 'true'}
))

chain = client.runs.chain_sync(...).data
for run_id in chain.run_ids:
    completed = wait_for_run_completion_sync(client, run_id, 600)
    print(completed.status, completed.output_data)

response = await client.runs.create(run_data)

if response.error:
    # Handle error
    print(f"Error details: {response.error}")
    
    # Handle specific error types
    if hasattr(response.error, 'status'):
        if response.error.status == 429:
            # Rate limited - wait and retry
            await asyncio.sleep(response.error.get('retry_after', 60))
            return await client.runs.create(run_data)
        elif response.error.status == 401:
            raise Exception("Invalid API key")
    
    raise Exception(f"Failed to create run: {response.error}")
else:
    # Use data
    print(f"Run created: {response.data.id}")

from cyberdesk import CyberdeskClient
import logging

logger = logging.getLogger(__name__)

async def safe_run_creation(client, run_data):
    """Create a run with proper error handling."""
    try:
        response = await client.runs.create(run_data)
        
        if response.error:
            # Log the error
            logger.error(f"API error: {response.error}")
            
            # Handle specific error types
            if hasattr(response.error, 'status'):
                if response.error.status == 429:
                    # Rate limited - wait and retry
                    await asyncio.sleep(response.error.get('retry_after', 60))
                    return await client.runs.create(run_data)
                elif response.error.status == 401:
                    raise Exception("Invalid API key")
            
            raise Exception(f"Failed to create run: {response.error}")
        
        return response.data
        
    except Exception as e:
        logger.exception("Unexpected error creating run")
        raise

from cyberdesk import (
    CyberdeskClient,
    RunResponse,
    RunStatus,
    MachineStatus,
    ConnectionStatus
)
from typing import Optional

def process_run(run: RunResponse) -> Optional[dict]:
    """Process a completed run."""
    if run.status == RunStatus.SUCCESS:
        # IDE knows output_data is available
        return run.output_data
    elif run.status == RunStatus.FAILED:
        print(f"Run failed: {', '.join(run.error or [])}")
        return None
    else:
        print(f"Run status: {run.status}")
        return None

# In Jupyter, use sync methods or nest async code
from cyberdesk import CyberdeskClient
import pandas as pd

client = CyberdeskClient('YOUR_API_KEY')

# Get recent runs
response = client.runs.list_sync(limit=10)
runs = response.data.items

# Convert to DataFrame for analysis
df = pd.DataFrame([
    {
        'id': run.id,
        'workflow_id': run.workflow_id,
        'status': run.status,
        'created_at': run.created_at,
        'duration': (run.completed_at - run.created_at).total_seconds() if run.completed_at else None
    }
    for run in runs
])

# Analyze run performance
df.groupby('status').agg({
    'id': 'count',
    'duration': 'mean'
})

import asyncio
from cyberdesk import CyberdeskClient

async def process_multiple_patients(patient_ids):
    """Process multiple patients concurrently."""
    async with CyberdeskClient(os.environ['CYBERDESK_API_KEY']) as client:
        # Create runs concurrently
        tasks = [
            create_patient_run(client, patient_id) 
            for patient_id in patient_ids
        ]
        runs = await asyncio.gather(*tasks)
        
        # Wait for all runs to complete
        results = await asyncio.gather(*[
            wait_for_run_completion(client, run.id) 
            for run in runs if run
        ])
        
        return results

# Process 10 patients in parallel
results = asyncio.run(process_multiple_patients(patient_ids[:10]))