corrected examples

Author: sid-rl

examples/async_devbox.py

@@ -22,7 +22,7 @@ async def demonstrate_basic_async():
     sdk = AsyncRunloopSDK()
 
     # Create a devbox with async context manager
-    async with sdk.devbox.create(name="async-example-devbox") as devbox:
+    async with await sdk.devbox.create(name="async-example-devbox") as devbox:
         print(f"Created devbox: {devbox.id}")
 
         # Execute command asynchronously
@@ -47,7 +47,7 @@ async def demonstrate_concurrent_commands():
 
     sdk = AsyncRunloopSDK()
 
-    async with sdk.devbox.create(name="concurrent-commands-devbox") as devbox:
+    async with await sdk.devbox.create(name="concurrent-commands-devbox") as devbox:
         print(f"Created devbox: {devbox.id}")
 
         # Execute multiple commands concurrently
@@ -76,7 +76,7 @@ async def demonstrate_multiple_devboxes():
 
     async def create_and_use_devbox(name: str, number: int):
         """Create a devbox, run a command, and return the result."""
-        async with sdk.devbox.create(name=name) as devbox:
+        async with await sdk.devbox.create(name=name) as devbox:
             print(f"Devbox {number} ({devbox.id}): Created")
 
             # Run a command
@@ -97,18 +97,18 @@ async def create_and_use_devbox(name: str, number: int):
 
 
 async def demonstrate_async_streaming():
-    """Demonstrate real-time command output streaming with async callbacks."""
+    """Demonstrate real-time command output streaming with synchronous callbacks."""
     print("=== Async Command Streaming ===")
 
     sdk = AsyncRunloopSDK()
 
-    async with sdk.devbox.create(name="streaming-devbox") as devbox:
+    async with await sdk.devbox.create(name="streaming-devbox") as devbox:
         print(f"Created devbox: {devbox.id}")
 
-        # Async callback to capture output
-        output_lines = []
+        # Synchronous callback to capture output (callbacks must be sync, not async)
+        output_lines: list[str] = []
 
-        async def capture_output(line: str):
+        def capture_output(line: str):
             print(f"[STREAM] {line.strip()}")
             output_lines.append(line)
 
@@ -128,7 +128,7 @@ async def demonstrate_async_execution():
 
     sdk = AsyncRunloopSDK()
 
-    async with sdk.devbox.create(name="async-exec-devbox") as devbox:
+    async with await sdk.devbox.create(name="async-exec-devbox") as devbox:
         print(f"Created devbox: {devbox.id}")
 
         # Start an async execution

examples/blueprint_example.py

@@ -13,6 +13,7 @@
 import os
 
 from runloop_api_client import RunloopSDK
+from runloop_api_client.sdk import Blueprint
 
 
 def create_simple_blueprint(sdk: RunloopSDK):
@@ -119,7 +120,7 @@ def create_blueprint_from_base(sdk: RunloopSDK):
     return base_blueprint, derived_blueprint
 
 
-def use_blueprint_to_create_devbox(sdk: RunloopSDK, blueprint):
+def use_blueprint_to_create_devbox(blueprint: Blueprint):
     """Create and use a devbox from a blueprint."""
     print("\n=== Creating Devbox from Blueprint ===")
 
@@ -157,7 +158,7 @@ def list_blueprints(sdk: RunloopSDK):
         print(f"  - {info.name} ({bp.id}): {info.status}")
 
 
-def cleanup_blueprints(sdk: RunloopSDK, blueprints):
+def cleanup_blueprints(blueprints: list[Blueprint]):
     """Delete blueprints to clean up."""
     print("\n=== Cleaning Up Blueprints ===")
 
@@ -176,7 +177,7 @@ def main():
     sdk = RunloopSDK()
     print("Initialized Runloop SDK\n")
 
-    created_blueprints = []
+    created_blueprints: list[Blueprint] = []
 
     try:
         # Create simple blueprint
@@ -192,15 +193,15 @@ def main():
         created_blueprints.extend([base_bp, derived_bp])
 
         # Use a blueprint to create a devbox
-        use_blueprint_to_create_devbox(sdk, simple_bp)
+        use_blueprint_to_create_devbox(simple_bp)
 
         # List all blueprints
         list_blueprints(sdk)
 
     finally:
         # Cleanup all created blueprints
         if created_blueprints:
-            cleanup_blueprints(sdk, created_blueprints)
+            cleanup_blueprints(created_blueprints)
 
     print("\nBlueprint example completed!")
 

examples/storage_example.py

@@ -14,6 +14,7 @@
 from pathlib import Path
 
 from runloop_api_client import RunloopSDK
+from runloop_api_client.sdk import StorageObject
 
 
 def demonstrate_text_upload(sdk: RunloopSDK):
@@ -90,7 +91,8 @@ def demonstrate_file_upload(sdk: RunloopSDK):
         info = obj.refresh()
         print(f"Object name: {info.name}")
         print(f"Content type: {info.content_type}")
-        print(f"Metadata: {info.metadata}")
+        # TODO: Add metadata to the object
+        # print(f"Metadata: {info.metadata}")
 
         return obj
     finally:
@@ -110,7 +112,7 @@ def demonstrate_manual_upload(sdk: RunloopSDK):
     )
 
     print(f"Created storage object: {obj.id}")
-    print(f"Upload URL: {obj.upload_url[:50]}...")
+    print(f"Upload URL: {obj.upload_url[:50] if obj.upload_url is not None else 'None'}...")
 
     # Step 2: Upload content to the presigned URL
     content = b"This content was uploaded manually using the upload flow."
@@ -242,7 +244,7 @@ def list_storage_objects(sdk: RunloopSDK):
         print(f"  - {info.name} ({obj.id}): {info.content_type}")
 
 
-def cleanup_storage_objects(sdk: RunloopSDK, objects):
+def cleanup_storage_objects(objects: list[StorageObject]):
     """Delete storage objects to clean up."""
     print("\n=== Cleaning Up Storage Objects ===")
 
@@ -261,7 +263,7 @@ def main():
     sdk = RunloopSDK()
     print("Initialized Runloop SDK\n")
 
-    created_objects = []
+    created_objects: list[StorageObject] = []
 
     try:
         # Demonstrate different upload methods
@@ -290,7 +292,7 @@ def main():
     finally:
         # Cleanup all created objects
         if created_objects:
-            cleanup_storage_objects(sdk, created_objects)
+            cleanup_storage_objects(created_objects)
 
     print("\nStorage object example completed!")
 

examples/streaming_output.py

@@ -7,7 +7,7 @@
 - Streaming stderr
 - Streaming combined output
 - Processing output line-by-line
-- Async streaming callbacks
+- Using synchronous callbacks (async callbacks not supported)
 """
 
 import os
@@ -76,7 +76,7 @@ def demonstrate_combined_streaming(sdk: RunloopSDK):
         print(f"Created devbox: {devbox.id}\n")
 
         # Track all output
-        all_output = []
+        all_output: list[tuple[str, str]] = []
 
         def capture_all(line: str):
             timestamp = datetime.now().strftime("%H:%M:%S.%f")[:-3]
@@ -159,7 +159,7 @@ def demonstrate_long_running_stream(sdk: RunloopSDK):
     with sdk.devbox.create(name="streaming-longrun-devbox") as devbox:
         print(f"Created devbox: {devbox.id}\n")
 
-        progress_items = []
+        progress_items: list[str] = []
 
         def track_progress(line: str):
             line = line.rstrip()
@@ -188,46 +188,35 @@ def track_progress(line: str):
 
 
 async def demonstrate_async_streaming():
-    """Demonstrate async streaming with async callbacks."""
-    print("\n=== Async Streaming ===")
+    """Demonstrate async devbox with synchronous callbacks.
+
+    Note: Callbacks must be synchronous functions, not async.
+    Use thread-safe queues if you need to process output asynchronously.
+    """
+    print("\n=== Async Devbox with Synchronous Callbacks ===")
 
     sdk = AsyncRunloopSDK()
 
-    async with sdk.devbox.create(name="async-streaming-devbox") as devbox:
+    async with await sdk.devbox.create(name="async-streaming-devbox") as devbox:
         print(f"Created devbox: {devbox.id}\n")
 
-        # Async callback with async operations
-        output_queue = asyncio.Queue()
-
-        async def async_capture(line: str):
-            # Simulate async processing (e.g., writing to a database)
-            await asyncio.sleep(0.01)
-            await output_queue.put(line.rstrip())
-            print(f"[ASYNC] {line.rstrip()}")
-
-        # Start processing task
-        async def process_queue():
-            processed = []
-            while True:
-                try:
-                    line = await asyncio.wait_for(output_queue.get(), timeout=2.0)
-                    processed.append(line)
-                except asyncio.TimeoutError:
-                    break
-            return processed
-
-        processor = asyncio.create_task(process_queue())
-
-        # Execute with async streaming
-        print("Streaming with async callbacks:")
+        # Synchronous callback (callbacks must be sync, not async)
+        output_lines: list[str] = []
+
+        def capture_output(line: str):
+            # Callback must be synchronous
+            output_lines.append(line.rstrip())
+            print(f"[CAPTURED] {line.rstrip()}")
+
+        # Execute with synchronous callback
+        print("Streaming with synchronous callbacks:")
         await devbox.cmd.exec(
-            'for i in 1 2 3 4 5; do echo "Async line $i"; sleep 0.2; done',
-            stdout=async_capture,
+            'for i in 1 2 3 4 5; do echo "Line $i"; sleep 0.2; done',
+            stdout=capture_output,
         )
 
-        # Wait for queue processing
-        processed = await processor
-        print(f"\nProcessed {len(processed)} lines asynchronously")
+        print(f"\nCaptured {len(output_lines)} lines")
+        print(f"Output: {output_lines}")
 
 
 def main():