morphcloud 0.1.76__tar.gz → 0.1.78__tar.gz

{morphcloud-0.1.76 → morphcloud-0.1.78}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: morphcloud
-Version: 0.1.76
+Version: 0.1.78
 Summary: A Python SDK and CLI tool for creating, managing, and interacting with Morph Cloud VMs.
 Author-email: Morph Labs <jobs@morph.so>
 License: Apache-2.0

{morphcloud-0.1.76 → morphcloud-0.1.78}/morphcloud/experimental/browser.py

@@ -513,6 +513,7 @@ class BrowserSession:
 
             # Start instance (don't use context manager to keep it running)
             instance = snapshot.start(metadata={"name": name}, ttl_seconds=ttl_seconds)
+            instance.wait_until_ready()
 
             # Verify Chrome installation
             if verbose:
@@ -670,6 +671,9 @@ class BrowserSession:
             return session
 
         except Exception as e:
+            import traceback
+
+            print(traceback.format_exc(e))
             raise RuntimeError(f"Failed to create browser session: {e}")
 
 

{morphcloud-0.1.76 → morphcloud-0.1.78}/morphcloud/sandbox/__init__.py

@@ -1 +1 @@
-from ._sandbox import ExecutionResult, LanguageSupport, OutputType, Sandbox
+from ._sandbox import ExecutionResult, LanguageSupport, OutputType, Sandbox, SandboxAPI

{morphcloud-0.1.76 → morphcloud-0.1.78}/morphcloud/sandbox/_sandbox.py

@@ -266,9 +266,52 @@ class Sandbox:
         self._ws_connections = ws_connections
         self._session_id = session_id
 
+    def _discover_existing_kernels(self) -> None:
+        """
+        Discover and reconnect to existing kernels on the Jupyter server.
+        This preserves kernel state when getting an existing sandbox instance.
+        """
+        try:
+            # Get list of existing kernels from Jupyter server
+            response = requests.get(f"{self.jupyter_url}/api/kernels", timeout=10.0)
+            response.raise_for_status()
+            existing_kernels = response.json()
+            
+            # Map kernel specs to our supported languages
+            kernel_to_language = {}
+            for language in LanguageSupport.get_supported_languages():
+                kernel_name = LanguageSupport.get_kernel_name(language)
+                kernel_to_language[kernel_name] = language
+            
+            # Connect to existing kernels that match our supported languages
+            for kernel_info in existing_kernels:
+                kernel_id = kernel_info.get("id")
+                kernel_spec = kernel_info.get("name")
+                
+                if kernel_spec in kernel_to_language:
+                    language = kernel_to_language[kernel_spec]
+                    # Only connect if we don't already have a kernel for this language
+                    if language not in self._kernel_ids:
+                        self._kernel_ids[language] = kernel_id
+                        # Connect WebSocket to existing kernel
+                        try:
+                            self._connect_websocket(kernel_id)
+                        except ConnectionError:
+                            # If we can't connect, remove from our tracking
+                            del self._kernel_ids[language]
+                            
+        except requests.RequestException:
+            # If we can't discover existing kernels, that's okay
+            # New kernels will be created as needed
+            pass
+        except Exception:
+            # Any other error during discovery should not prevent connection
+            pass
+
     def connect(self, timeout_seconds: int = 60) -> Sandbox:
         """Ensure Jupyter service is running and accessible"""
         self.wait_for_jupyter(timeout_seconds)
+        self._discover_existing_kernels()
         return self
 
     def wait_for_jupyter(self, timeout: int = 60) -> bool:

{morphcloud-0.1.76 → morphcloud-0.1.78}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "morphcloud"
-version = "0.1.76"
+version = "0.1.78"
 description = "A Python SDK and CLI tool for creating, managing, and interacting with Morph Cloud VMs."
 authors = [
     {name = "Morph Labs", email = "jobs@morph.so"}

morphcloud-0.1.78/tests/integration/test_sandbox.py

@@ -0,0 +1,315 @@
+"""
+Function-scoped tests for Sandbox functionality in MorphCloud SDK.
+"""
+import pytest
+import logging
+import uuid
+import os
+import pytest_asyncio
+
+from morphcloud.api import MorphCloudClient
+from morphcloud.sandbox import Sandbox, SandboxAPI
+
+logger = logging.getLogger("morph-tests")
+
+# Mark all tests as asyncio tests
+pytestmark = pytest.mark.asyncio
+
+# Configure pytest-asyncio
+def pytest_configure(config):
+    config.option.asyncio_default_fixture_loop_scope = "function"
+
+
+@pytest.fixture
+def api_key():
+    """Get API key from environment variable."""
+    key = os.environ.get("MORPH_API_KEY")
+    if not key:
+        pytest.fail("MORPH_API_KEY environment variable must be set")
+    return key
+
+
+@pytest.fixture
+def base_url():
+    """Get base URL from environment variable."""
+    return os.environ.get("MORPH_BASE_URL")
+
+
+@pytest_asyncio.fixture
+async def client(api_key, base_url):
+    """Create a MorphCloudClient."""
+    client = MorphCloudClient(api_key=api_key, base_url=base_url)
+    logger.info("Created MorphCloud client")
+    return client
+
+
+@pytest_asyncio.fixture
+async def sandbox_api(client):
+    """Create a SandboxAPI instance."""
+    api = SandboxAPI(client)
+    logger.info("Created SandboxAPI")
+    return api
+
+
+async def test_sandbox_creation_and_connection(client):
+    """Test basic sandbox creation and connection."""
+    logger.info("Testing sandbox creation and connection")
+    
+    try:
+        # Create a new sandbox
+        sandbox = Sandbox.new(client=client, ttl_seconds=600)
+        logger.info(f"Created sandbox: {sandbox._instance.id}")
+        
+        # Connect to the sandbox
+        sandbox.connect()
+        logger.info("Connected to sandbox successfully")
+        
+        # Verify sandbox properties
+        assert sandbox._instance.id.startswith("morphvm_"), "Sandbox ID should start with 'morphvm_'"
+        assert sandbox.jupyter_url is not None, "Sandbox should have a Jupyter URL"
+        assert isinstance(sandbox._kernel_ids, dict), "Sandbox should have kernel_ids dictionary"
+        
+        logger.info("Sandbox creation and connection test passed")
+        
+    finally:
+        # Clean up
+        if 'sandbox' in locals():
+            try:
+                logger.info(f"Cleaning up sandbox {sandbox._instance.id}")
+                sandbox.close()
+                sandbox.shutdown()
+                logger.info("Sandbox cleaned up successfully")
+            except Exception as e:
+                logger.error(f"Error cleaning up sandbox: {e}")
+
+
+async def test_sandbox_code_execution(client):
+    """Test code execution in sandbox."""
+    logger.info("Testing sandbox code execution")
+    
+    try:
+        # Create and connect to sandbox
+        sandbox = Sandbox.new(client=client, ttl_seconds=600)
+        sandbox.connect()
+        logger.info(f"Created and connected to sandbox: {sandbox._instance.id}")
+        
+        # Test Python code execution
+        test_value = uuid.uuid4().hex[:8]
+        result = sandbox.run_code(f"test_var = '{test_value}'", language="python")
+        assert result.success, f"Python code execution failed: {result.error}"
+        logger.info("Python variable assignment successful")
+        
+        # Verify the variable was set
+        result = sandbox.run_code("print(test_var)", language="python")
+        assert result.success, f"Python variable retrieval failed: {result.error}"
+        assert test_value in result.text, f"Expected '{test_value}' in output, got: {result.text}"
+        logger.info("Python variable retrieval successful")
+        
+        # Test JavaScript code execution
+        result = sandbox.run_code("console.log('hello from js');", language="javascript")
+        assert result.success, f"JavaScript code execution failed: {result.error}"
+        assert "hello from js" in result.text, f"Expected 'hello from js' in output, got: {result.text}"
+        logger.info("JavaScript code execution successful")
+        
+        logger.info("Sandbox code execution test passed")
+        
+    finally:
+        if 'sandbox' in locals():
+            try:
+                sandbox.close()
+                sandbox.shutdown()
+            except Exception as e:
+                logger.error(f"Error cleaning up sandbox: {e}")
+
+
+async def test_kernel_persistence_across_get_calls(client, sandbox_api):
+    """Test that kernel state persists when using .get() to retrieve a sandbox."""
+    logger.info("Testing kernel persistence across .get() calls")
+    
+    try:
+        # Create and connect to first sandbox instance
+        sandbox1 = Sandbox.new(client=client, ttl_seconds=600)
+        sandbox1.connect()
+        logger.info(f"Created sandbox1: {sandbox1._instance.id}")
+        
+        # Set a variable in Python
+        test_value = f"kernel_test_{uuid.uuid4().hex[:8]}"
+        result1 = sandbox1.run_code(f"persistent_var = '{test_value}'", language="python")
+        assert result1.success, f"Failed to set variable: {result1.error}"
+        logger.info(f"Set persistent_var to '{test_value}'")
+        
+        # Get the kernel ID for verification
+        original_kernel_id = sandbox1._kernel_ids.get("python")
+        assert original_kernel_id is not None, "No Python kernel ID found"
+        logger.info(f"Original Python kernel ID: {original_kernel_id}")
+        
+        # Retrieve the same sandbox using .get()
+        sandbox2 = sandbox_api.get(sandbox1._instance.id)
+        sandbox2.connect()
+        logger.info(f"Retrieved sandbox2 via .get(): {sandbox2._instance.id}")
+        
+        # Verify kernel ID is preserved
+        retrieved_kernel_id = sandbox2._kernel_ids.get("python")
+        assert retrieved_kernel_id == original_kernel_id, (
+            f"Kernel IDs don't match: original={original_kernel_id}, "
+            f"retrieved={retrieved_kernel_id}"
+        )
+        logger.info("Kernel ID preservation verified")
+        
+        # Verify variable state is preserved
+        result2 = sandbox2.run_code("print(persistent_var)", language="python")
+        assert result2.success, f"Failed to access persistent variable: {result2.error}"
+        assert test_value in result2.text, (
+            f"Persistent variable not found. Expected '{test_value}' in output: {result2.text}"
+        )
+        logger.info("Variable state preservation verified")
+        
+        logger.info("Kernel persistence test passed")
+        
+    finally:
+        # Clean up
+        for i, sandbox in enumerate([s for s in [locals().get('sandbox1'), locals().get('sandbox2')] if s]):
+            try:
+                logger.info(f"Cleaning up sandbox{i+1}: {sandbox._instance.id}")
+                sandbox.close()
+                if i == 0:  # Only shutdown once
+                    sandbox.shutdown()
+            except Exception as e:
+                logger.error(f"Error cleaning up sandbox{i+1}: {e}")
+
+
+async def test_multiple_language_kernel_persistence(client, sandbox_api):
+    """Test kernel persistence works for multiple programming languages."""
+    logger.info("Testing multiple language kernel persistence")
+    
+    try:
+        # Create and connect to sandbox
+        sandbox1 = Sandbox.new(client=client, ttl_seconds=600)
+        sandbox1.connect()
+        logger.info(f"Created sandbox1: {sandbox1._instance.id}")
+        
+        # Set variables in different languages
+        python_value = f"py_{uuid.uuid4().hex[:8]}"
+        js_value = f"js_{uuid.uuid4().hex[:8]}"
+        
+        python_result = sandbox1.run_code(f"py_var = '{python_value}'", language="python")
+        assert python_result.success, f"Python execution failed: {python_result.error}"
+        
+        js_result = sandbox1.run_code(f"var js_var = '{js_value}';", language="javascript")
+        assert js_result.success, f"JavaScript execution failed: {js_result.error}"
+        
+        logger.info(f"Set variables - Python: {python_value}, JavaScript: {js_value}")
+        
+        # Store original kernel IDs
+        original_kernels = sandbox1._kernel_ids.copy()
+        logger.info(f"Original kernel IDs: {original_kernels}")
+        
+        # Retrieve sandbox and verify all kernels are preserved
+        sandbox2 = sandbox_api.get(sandbox1._instance.id)
+        sandbox2.connect()
+        logger.info(f"Retrieved sandbox2: {sandbox2._instance.id}")
+        logger.info(f"Retrieved kernel IDs: {sandbox2._kernel_ids}")
+        
+        # Check that kernel IDs match for all languages
+        for language, kernel_id in original_kernels.items():
+            retrieved_kernel_id = sandbox2._kernel_ids.get(language)
+            assert retrieved_kernel_id == kernel_id, (
+                f"Kernel ID mismatch for {language}: "
+                f"original={kernel_id}, retrieved={retrieved_kernel_id}"
+            )
+        
+        # Verify variables are accessible
+        py_check = sandbox2.run_code("print(py_var)", language="python")
+        assert py_check.success and python_value in py_check.text, (
+            f"Python variable not preserved: {py_check.text}"
+        )
+        
+        js_check = sandbox2.run_code("console.log(js_var);", language="javascript")
+        assert js_check.success and js_value in js_check.text, (
+            f"JavaScript variable not preserved: {js_check.text}"
+        )
+        
+        logger.info("Multiple language kernel persistence test passed")
+        
+    finally:
+        # Clean up
+        for i, sandbox in enumerate([s for s in [locals().get('sandbox1'), locals().get('sandbox2')] if s]):
+            try:
+                sandbox.close()
+                if i == 0:  # Only shutdown once
+                    sandbox.shutdown()
+            except Exception as e:
+                logger.error(f"Error cleaning up sandbox{i+1}: {e}")
+
+
+async def test_kernel_discovery_with_fresh_sandbox(client, sandbox_api):
+    """Test that kernel discovery handles fresh sandboxes correctly."""
+    logger.info("Testing kernel discovery with fresh sandbox")
+    
+    try:
+        # Create sandbox but don't connect yet
+        sandbox1 = Sandbox.new(client=client, ttl_seconds=600)
+        logger.info(f"Created fresh sandbox: {sandbox1._instance.id}")
+        
+        # Get the sandbox without any prior kernel creation
+        sandbox2 = sandbox_api.get(sandbox1._instance.id)
+        sandbox2.connect()
+        logger.info("Connected to fresh sandbox via .get()")
+        
+        # Should be able to run code (will create new kernel)
+        test_value = f"fresh_{uuid.uuid4().hex[:8]}"
+        result = sandbox2.run_code(f"print('{test_value}')", language="python")
+        assert result.success, f"Failed to run code on fresh sandbox: {result.error}"
+        assert test_value in result.text, f"Expected '{test_value}' in output: {result.text}"
+        
+        logger.info("Fresh sandbox kernel discovery test passed")
+        
+    finally:
+        # Clean up
+        for sandbox in [locals().get('sandbox1'), locals().get('sandbox2')]:
+            if sandbox:
+                try:
+                    sandbox.close()
+                    sandbox.shutdown()
+                    break  # Only shutdown once
+                except Exception as e:
+                    logger.error(f"Error cleaning up sandbox: {e}")
+
+
+async def test_sandbox_error_handling(client):
+    """Test error handling in sandbox operations."""
+    logger.info("Testing sandbox error handling")
+    
+    try:
+        # Create and connect to sandbox
+        sandbox = Sandbox.new(client=client, ttl_seconds=600)
+        sandbox.connect()
+        logger.info(f"Created sandbox: {sandbox._instance.id}")
+        
+        # Test code with syntax error
+        result = sandbox.run_code("print('missing quote)", language="python")
+        assert not result.success, "Code with syntax error should fail"
+        assert result.error is not None, "Failed code should have error message"
+        logger.info("Syntax error handling verified")
+        
+        # Test unsupported language
+        result = sandbox.run_code("print('test')", language="unsupported")
+        assert not result.success, "Unsupported language should fail"
+        assert "Unsupported language" in result.error, f"Expected unsupported language error: {result.error}"
+        logger.info("Unsupported language handling verified")
+        
+        # Verify sandbox is still functional after errors
+        result = sandbox.run_code("print('still works')", language="python")
+        assert result.success, "Sandbox should remain functional after errors"
+        assert "still works" in result.text, f"Expected 'still works' in output: {result.text}"
+        logger.info("Sandbox resilience after errors verified")
+        
+        logger.info("Sandbox error handling test passed")
+        
+    finally:
+        if 'sandbox' in locals():
+            try:
+                sandbox.close()
+                sandbox.shutdown()
+            except Exception as e:
+                logger.error(f"Error cleaning up sandbox: {e}")

{morphcloud-0.1.76 → morphcloud-0.1.78}/uv.lock

@@ -113,11 +113,11 @@ wheels = [
 
 [[package]]
 name = "certifi"
-version = "2025.6.15"
+version = "2025.7.9"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/73/f7/f14b46d4bcd21092d7d3ccef689615220d8a08fb25e564b65d20738e672e/certifi-2025.6.15.tar.gz", hash = "sha256:d747aa5a8b9bbbb1bb8c22bb13e22bd1f18e9796defa16bab421f7f7a317323b", size = 158753, upload-time = "2025-06-15T02:45:51.329Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/de/8a/c729b6b60c66a38f590c4e774decc4b2ec7b0576be8f1aa984a53ffa812a/certifi-2025.7.9.tar.gz", hash = "sha256:c1d2ec05395148ee10cf672ffc28cd37ea0ab0d99f9cc74c43e588cbd111b079", size = 160386, upload-time = "2025-07-09T02:13:58.874Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/84/ae/320161bd181fc06471eed047ecce67b693fd7515b16d495d8932db763426/certifi-2025.6.15-py3-none-any.whl", hash = "sha256:2e0c7ce7cb5d8f8634ca55d2ba7e6ec2689a2fd6537d8dec1296a477a4910057", size = 157650, upload-time = "2025-06-15T02:45:49.977Z" },
+    { url = "https://files.pythonhosted.org/packages/66/f3/80a3f974c8b535d394ff960a11ac20368e06b736da395b551a49ce950cce/certifi-2025.7.9-py3-none-any.whl", hash = "sha256:d842783a14f8fdd646895ac26f719a061408834473cfc10203f6a575beb15d39", size = 159230, upload-time = "2025-07-09T02:13:57.007Z" },
 ]
 
 [[package]]
@@ -576,7 +576,7 @@ wheels = [
 
 [[package]]
 name = "morphcloud"
-version = "0.1.76"
+version = "0.1.78"
 source = { editable = "." }
 dependencies = [
     { name = "anthropic" },