Build a Secure AI Code Execution Workflow Using Daytona SDK

import os
import time
import json
from typing import List, Dict, Any


try:
    import daytona_sdk
except ImportError:
    print("Installing Daytona SDK...")
    !pip install daytona-sdk
    import daytona_sdk


from daytona_sdk import Daytona, DaytonaConfig, CreateSandboxParams

class DaytonaTutorial:
    """Complete tutorial for Daytona SDK - Secure AI Code Execution Platform"""


    def __init__(self, api_key: str):
        """Initialize Daytona client"""
        self.config = DaytonaConfig(api_key=api_key)
        self.daytona = Daytona(self.config)
        self.sandboxes: List[Any] = []


    def basic_sandbox_demo(self):
        """Demo 1: Basic sandbox creation and code execution"""
        print(" Demo 1: Basic Sandbox Operations")
        print("-" * 40)


        try:
            sandbox = self.daytona.create(CreateSandboxParams(language="python"))
            self.sandboxes.append(sandbox)


            print(f" Created sandbox: {sandbox.id}")


            code = 'print("Hello from Daytona Sandbox!")nprint(f"2 + 2 = {2 + 2}")'
            response = sandbox.process.code_run(code)


            if response.exit_code == 0:
                print(f" Output: {response.result}")
            else:
                print(f" Error: {response.result}")


        except Exception as e:
            print(f" Error in basic demo: {e}")


    def data_processing_demo(self):
        """Demo 2: Data processing in isolated environment"""
        print("n Demo 2: Secure Data Processing")
        print("-" * 40)


        try:
            sandbox = self.daytona.create(CreateSandboxParams(language="python"))
            self.sandboxes.append(sandbox)


            install_cmd = "import subprocess; subprocess.run(['pip', 'install', 'pandas'])"
            response = sandbox.process.code_run(install_cmd)


            data_code = """
import pandas as pd
import json


# Create sample dataset
data = {
    'name': ['Alice', 'Bob', 'Charlie', 'Diana'],
    'age': [25, 30, 35, 28],
    'salary': [50000, 60000, 70000, 55000]
}


df = pd.DataFrame(data)
result = {
    'total_records': len(df),
    'avg_age': df['age'].mean(),
    'avg_salary': df['salary'].mean(),
    'summary': df.describe().to_dict()
}


print(json.dumps(result, indent=2))
"""


            response = sandbox.process.code_run(data_code)
            if response.exit_code == 0:
                print(" Data processing completed:")
                print(response.result)
            else:
                print(f" Error: {response.result}")


        except Exception as e:
            print(f" Error in data processing demo: {e}")


    def file_operations_demo(self):
        """Demo 3: File operations within sandbox"""
        print("n Demo 3: File Operations")
        print("-" * 40)


        try:
            sandbox = self.daytona.create(CreateSandboxParams(language="python"))
            self.sandboxes.append(sandbox)


            file_code = """
import os
import json


# Create a sample file
data = {'message': 'Hello from Daytona!', 'timestamp': '2025-06-13'}
with open('sample.json', 'w') as f:
    json.dump(data, f, indent=2)


# Read and display file contents
with open('sample.json', 'r') as f:
    content = f.read()
    print("File contents:")
    print(content)


# List files in current directory
files = os.listdir('.')
print(f"\nFiles in directory: {files}")
"""


            response = sandbox.process.code_run(file_code)
            if response.exit_code == 0:
                print(" File operations completed:")
                print(response.result)
            else:
                print(f" Error: {response.result}")


        except Exception as e:
            print(f" Error in file operations demo: {e}")


    def ai_code_execution_demo(self):
        """Demo 4: Simulated AI-generated code execution"""
        print("n Demo 4: AI-Generated Code Execution")
        print("-" * 40)


        ai_codes = [
            "# Calculate fibonacci sequencendef fib(n):n    if n <= 1: return nn    return fib(n-1) + fib(n-2)nprint([fib(i) for i in range(10)])",
            "# Sort algorithmndef bubble_sort(arr):n    n = len(arr)n    for i in range(n):n        for j in range(0, n-i-1):n            if arr[j] > arr[j+1]:n                arr[j], arr[j+1] = arr[j+1], arr[j]n    return arrnprint(bubble_sort([64, 34, 25, 12, 22, 11, 90]))",
            "# Data analysisnimport mathndata = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]nmean = sum(data) / len(data)nvariance = sum((x - mean) ** 2 for x in data) / len(data)nstd_dev = math.sqrt(variance)nprint(f'Mean: {mean}, Std Dev: {std_dev:.2f}')"
        ]


        try:
            sandbox = self.daytona.create(CreateSandboxParams(language="python"))
            self.sandboxes.append(sandbox)


            for i, code in enumerate(ai_codes, 1):
                print(f"n Executing AI Code Snippet {i}:")
                response = sandbox.process.code_run(code)


                if response.exit_code == 0:
                    print(f" Output: {response.result}")
                else:
                    print(f" Error: {response.result}")


                time.sleep(1)


        except Exception as e:
            print(f" Error in AI code execution demo: {e}")


    def parallel_execution_demo(self):
        """Demo 5: Multiple sandboxes for parallel processing"""
        print("n Demo 5: Parallel Execution")
        print("-" * 40)


        tasks = [
            "print('Task 1: Computing prime numbers')nprimes = [i for i in range(2, 50) if all(i % j != 0 for j in range(2, int(i**0.5) + 1))]nprint(f'Primes: {primes[:10]}')",
            "print('Task 2: String processing')ntext = 'Hello Daytona World'nprint(f'Reversed: {text[::-1]}')nprint(f'Word count: {len(text.split())}')",
            "print('Task 3: Mathematical calculations')nimport mathnresult = sum(math.sqrt(i) for i in range(1, 101))nprint(f'Sum of square roots 1-100: {result:.2f}')"
        ]


        try:
            parallel_sandboxes = []
            for i in range(len(tasks)):
                sandbox = self.daytona.create(CreateSandboxParams(language="python"))
                parallel_sandboxes.append(sandbox)
                self.sandboxes.append(sandbox)


            results = []
            for i, (sandbox, task) in enumerate(zip(parallel_sandboxes, tasks)):
                print(f"n Starting parallel task {i+1}")
                response = sandbox.process.code_run(task)
                results.append((i+1, response))


            for task_num, response in results:
                if response.exit_code == 0:
                    print(f" Task {task_num} completed: {response.result}")
                else:
                    print(f" Task {task_num} failed: {response.result}")


        except Exception as e:
            print(f" Error in parallel execution demo: {e}")


    def cleanup_sandboxes(self):
        """Clean up all created sandboxes"""
        print("n Cleaning up sandboxes...")
        print("-" * 40)


        for sandbox in self.sandboxes:
            try:
                self.daytona.remove(sandbox)
                print(f" Removed sandbox: {sandbox.id}")
            except Exception as e:
                print(f" Error removing sandbox {sandbox.id}: {e}")


        self.sandboxes.clear()
        print(" Cleanup completed!")


    def run_full_tutorial(self):
        """Run the complete Daytona tutorial"""
        print(" Daytona SDK Complete Tutorial")
        print("=" * 50)
        print("Secure & Isolated AI Code Execution Platform")
        print("=" * 50)


        self.basic_sandbox_demo()
        self.data_processing_demo()
        self.file_operations_demo()
        self.ai_code_execution_demo()
        self.parallel_execution_demo()
        self.cleanup_sandboxes()


        print("n Tutorial completed successfully!")
        print("Key Daytona features demonstrated:")
        print("• Secure sandbox creation")
        print("• Isolated code execution")
        print("• File system operations")
        print("• Parallel processing")
        print("• Resource cleanup")

def main():
    """Main function to run the tutorial"""


    print(" Daytona Setup Instructions:")
    print("1. Visit: https://app.daytona.io")
    print("2. Create an account")
    print("3. Generate API key at: https://app.daytona.io/dashboard/keys")
    print("4. Replace 'YOUR_API_KEY' below with your actual key")
    print("-" * 50)


    API_KEY = "Use Your API Key Here"


    if API_KEY == "YOUR_API_KEY":
        print("  Please set your Daytona API key before running the tutorial!")
        print("   Update the API_KEY variable with your key from https://app.daytona.io/dashboard/keys")
        return


    try:
        tutorial = DaytonaTutorial(API_KEY)
        tutorial.run_full_tutorial()


    except Exception as e:
        print(f" Tutorial failed: {e}")
        print(" Make sure your API key is valid and you have network access")

if __name__ == "__main__":
    main()