With this Daytona The SDK tutorial leverages Daytona’s safe sandbox setting to offer a sensible walkthrough to soundly run unreliable or AI-generated Python code. Notes. Beginning with a easy sandbox creation and primary code execution, this information reveals you the way to isolate processes, set up dependencies, and run easy scripts with out placing your host setting in danger. Because the tutorial progresses, we’ll dig into knowledge processing with PANDAS, file operations similar to studying and writing JSON information, and working complicated AI-generated snippets similar to recursive capabilities and sorting algorithms. Lastly, we’ll present you the way to run parallel duties throughout a number of sandboxes and supply correct cleanup steps to make sure that all sources are managed and discarded accurately.
import os
import time
import json
from typing import Checklist, Dict, Any
attempt:
import daytona_sdk
besides ImportError:
print("Putting in Daytona SDK...")
!pip set up daytona-sdk
import daytona_sdk
from daytona_sdk import Daytona, DaytonaConfig, CreateSandboxParamsSet up and import the Daytona SDK (if it would not exist already) and initialize the core Daytona courses (Daytona, Daytonaconfig, and CreateSandboxParams) to configure and create a safe Python sandbox. It’s also possible to use commonplace utilities similar to OS, Time, and JSON inside these sandboxes.
class DaytonaTutorial:
"""Full tutorial for Daytona SDK - Safe AI Code Execution Platform"""
def __init__(self, api_key: str):
"""Initialize Daytona shopper"""
self.config = DaytonaConfig(api_key=api_key)
self.daytona = Daytona(self.config)
self.sandboxes: Checklist[Any] = []
def basic_sandbox_demo(self):
"""Demo 1: Fundamental sandbox creation and code execution"""
print("🚀 Demo 1: Fundamental Sandbox Operations")
print("-" * 40)
attempt:
sandbox = self.daytona.create(CreateSandboxParams(language="python"))
self.sandboxes.append(sandbox)
print(f"✅ Created sandbox: {sandbox.id}")
code="print("Good day from Daytona Sandbox!")nprint(f"2 + 2 = {2 + 2}")"
response = sandbox.course of.code_run(code)
if response.exit_code == 0:
print(f"📝 Output: {response.end result}")
else:
print(f"❌ Error: {response.end result}")
besides Exception as e:
print(f"❌ Error in primary demo: {e}")
def data_processing_demo(self):
"""Demo 2: Information processing in remoted setting"""
print("n📊 Demo 2: Safe Information Processing")
print("-" * 40)
attempt:
sandbox = self.daytona.create(CreateSandboxParams(language="python"))
self.sandboxes.append(sandbox)
install_cmd = "import subprocess; subprocess.run(['pip', 'install', 'pandas'])"
response = sandbox.course of.code_run(install_cmd)
data_code = """
import pandas as pd
import json
# Create pattern dataset
knowledge = {
'identify': ['Alice', 'Bob', 'Charlie', 'Diana'],
'age': [25, 30, 35, 28],
'wage': [50000, 60000, 70000, 55000]
}
df = pd.DataFrame(knowledge)
end result = {
'total_records': len(df),
'avg_age': df['age'].imply(),
'avg_salary': df['salary'].imply(),
'abstract': df.describe().to_dict()
}
print(json.dumps(end result, indent=2))
"""
response = sandbox.course of.code_run(data_code)
if response.exit_code == 0:
print("✅ Information processing accomplished:")
print(response.end result)
else:
print(f"❌ Error: {response.end result}")
besides Exception as e:
print(f"❌ Error in knowledge processing demo: {e}")
def file_operations_demo(self):
"""Demo 3: File operations inside sandbox"""
print("n📁 Demo 3: File Operations")
print("-" * 40)
attempt:
sandbox = self.daytona.create(CreateSandboxParams(language="python"))
self.sandboxes.append(sandbox)
file_code = """
import os
import json
# Create a pattern file
knowledge = {'message': 'Good day from Daytona!', 'timestamp': '2025-06-13'}
with open('pattern.json', 'w') as f:
json.dump(knowledge, f, indent=2)
# Learn and show file contents
with open('pattern.json', 'r') as f:
content material = f.learn()
print("File contents:")
print(content material)
# Checklist information in present listing
information = os.listdir('.')
print(f"nFiles in listing: {information}")
"""
response = sandbox.course of.code_run(file_code)
if response.exit_code == 0:
print("✅ File operations accomplished:")
print(response.end result)
else:
print(f"❌ Error: {response.end result}")
besides 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)])",
"# Type algorithmndef bubble_sort(arr):n n = len(arr)n for i in vary(n):n for j in vary(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]))",
"# Information analysisnimport mathndata = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]nmean = sum(knowledge) / len(knowledge)nvariance = sum((x - imply) ** 2 for x in knowledge) / len(knowledge)nstd_dev = math.sqrt(variance)nprint(f'Imply: {imply}, Std Dev: {std_dev:.2f}')"
]
attempt:
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.course of.code_run(code)
if response.exit_code == 0:
print(f"✅ Output: {response.end result}")
else:
print(f"❌ Error: {response.end result}")
time.sleep(1)
besides Exception as e:
print(f"❌ Error in AI code execution demo: {e}")
def parallel_execution_demo(self):
"""Demo 5: A number of sandboxes for parallel processing"""
print("n⚡ Demo 5: Parallel Execution")
print("-" * 40)
duties = [
"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('Activity 2: String processing')ntext="Good day Daytona World"nprint(f'Reversed: {textual content[::-1]}')nprint(f'Phrase rely: {len(textual content.break up())}')",
"print('Activity 3: Mathematical calculations')nimport mathnresult = sum(math.sqrt(i) for i in vary(1, 101))nprint(f'Sum of sq. roots 1-100: {end result:.2f}')"
]
attempt:
parallel_sandboxes = []
for i in vary(len(duties)):
sandbox = self.daytona.create(CreateSandboxParams(language="python"))
parallel_sandboxes.append(sandbox)
self.sandboxes.append(sandbox)
outcomes = []
for i, (sandbox, process) in enumerate(zip(parallel_sandboxes, duties)):
print(f"n🏃 Beginning parallel process {i+1}")
response = sandbox.course of.code_run(process)
outcomes.append((i+1, response))
for task_num, response in outcomes:
if response.exit_code == 0:
print(f"✅ Activity {task_num} accomplished: {response.end result}")
else:
print(f"❌ Activity {task_num} failed: {response.end result}")
besides Exception as e:
print(f"❌ Error in parallel execution demo: {e}")
def cleanup_sandboxes(self):
"""Clear up all created sandboxes"""
print("n🧹 Cleansing up sandboxes...")
print("-" * 40)
for sandbox in self.sandboxes:
attempt:
self.daytona.take away(sandbox)
print(f"✅ Eliminated sandbox: {sandbox.id}")
besides Exception as e:
print(f"❌ Error eradicating sandbox {sandbox.id}: {e}")
self.sandboxes.clear()
print("🎉 Cleanup accomplished!")
def run_full_tutorial(self):
"""Run the whole Daytona tutorial"""
print("🎯 Daytona SDK Full Tutorial")
print("=" * 50)
print("Safe & Remoted 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 accomplished efficiently!")
print("Key Daytona options demonstrated:")
print("• Safe sandbox creation")
print("• Remoted code execution")
print("• File system operations")
print("• Parallel processing")
print("• Useful resource cleanup")This Daytonatutorial Class encapsulates an entire end-to-end information for utilizing the Daytona SDK. Initializes a safe sandbox shopper utilizing API keys to point code-behind execution (from Pandas knowledge processing and file I/O to AI-generated snippets). Every methodology is self-contained and introduces main Daytona options, creating sandboxes, putting in dependencies, working safely, and cleansing up sources. Notes.
def essential():
"""Important perform to run the tutorial"""
print("🔑 Daytona Setup Directions:")
print("1. Go to: https://app.daytona.io")
print("2. Create an account")
print("3. Generate API key at: https://app.daytona.io/dashboard/keys")
print("4. Change 'YOUR_API_KEY' under along with your precise key")
print("-" * 50)
API_KEY = "Use Your API Key Right here"
if API_KEY == "YOUR_API_KEY":
print("⚠️ Please set your Daytona API key earlier than working the tutorial!")
print(" Replace the API_KEY variable along with your key from https://app.daytona.io/dashboard/keys")
return
attempt:
tutorial = DaytonaTutorial(API_KEY)
tutorial.run_full_tutorial()
besides Exception as e:
print(f"❌ Tutorial failed: {e}")
print("💡 Ensure that your API key's legitimate and you've got community entry")The Important() perform outlines the preliminary setup steps, guides the person to create a Daytona account and generates an API key, and validates that the important thing was offered earlier than instantiating the Daytonatutorial class and performing a full walkthrough. If the API key’s lacking or invalid, print clear directions and abort to make sure a easy first time expertise.
if __name__ == "__main__":
essential()
Lastly, the usual Python entry level test above ensures that Important() is barely referred to as when working the script straight, and the Daytona tutorial workflow begins in a transparent and managed method.
In conclusion, by following this tutorial, builders can have a complete understanding of Daytona’s core options. Preserve strict separation from the host system whereas creating orphaned Python sandboxes, performing safe knowledge operations, managing file I/O, executing arbitrary or AI formation code, and modifying even workloads all. Cleanup routines spotlight the significance of useful resource hygiene in long-term workflows. Customers with these primary expertise can confidently combine Daytona into bigger machine studying pipelines, automated testing frameworks, or any state of affairs that requires the safe execution of dynamic code.
Please test Notes. All credit for this examine will likely be despatched to researchers on this venture. Additionally, please be at liberty to observe us Twitter And remember to hitch us 99k+ ml subreddit And subscribe Our Newsletter.
Asif Razzaq is CEO of Marktechpost Media Inc.. As a visionary entrepreneur and engineer, ASIF is dedicated to leveraging the probabilities of synthetic intelligence for social advantages. His newest efforts are the launch of MarkTechPost, a synthetic intelligence media platform. That is distinguished by its detailed protection of machine studying and deep studying information, and is straightforward to know by a technically sound and extensive viewers. The platform has over 2 million views every month, indicating its recognition amongst viewers.
