Context Management

Use isolated execution contexts in GravixLayer sandboxes to maintain separate variable scopes and execution environments within a single sandbox.

What are Contexts?

Contexts provide isolated execution environments within a sandbox, allowing you to:

Separate variable scopes - Variables in one context don’t affect another
Organize complex workflows - Different contexts for different tasks
Maintain state isolation - Each context maintains its own execution state
Set different working directories - Each context can have its own working directory

Creating Contexts

Basic Context Creation

Python
JavaScript

from gravixlayer import GravixLayer

# Create sandbox and client
client = GravixLayer()
sandbox = client.sandbox.sandboxes.create(
    provider="gravix",
    region="eu-west-1",
    template="python-base-v1"
)

try:
    # Create isolated execution context
    context = client.sandbox.sandboxes.create_code_context(
        sandbox.sandbox_id,
        language="python",
        cwd="/home/user/project"
    )
    
    print(f"Context ID: {context.context_id}")
    print(f"Language: {context.language}")
    print(f"Working Directory: {context.cwd}")
    
finally:
    # Clean up
    client.sandbox.sandboxes.kill(sandbox.sandbox_id)

import { GravixLayer } from 'gravixlayer';

// Create sandbox and client
const client = new GravixLayer();
const sandbox = await client.sandbox.sandboxes.create({
    provider: "gravix",
    region: "eu-west-1",
    template: "python-base-v1"
});

try {
    // Create isolated execution context
    const context = await client.sandbox.sandboxes.createCodeContext(
        sandbox.sandbox_id,
        {
            language: "python",
            cwd: "/home/user/project"
        }
    );
    
    console.log(`Context ID: ${context.context_id}`);
    console.log(`Language: ${context.language}`);
    console.log(`Working Directory: ${context.cwd}`);
    

    
} finally {
    // Clean up
    await client.sandbox.sandboxes.kill(sandbox.sandbox_id);
}

Context with Custom Configuration

Python
JavaScript

# Create context with specific settings
context = client.sandbox.sandboxes.create_code_context(
    sandbox.sandbox_id,
    language="python",
    cwd="/home/user/data_analysis",
    metadata={
        "purpose": "data_processing",
        "stage": "preprocessing"
    }
)

// Create context with specific settings
const context = await client.sandbox.sandboxes.createCodeContext(
    sandbox.sandbox_id,
    {
        language: "python",
        cwd: "/home/user/data_analysis",
        metadata: {
            purpose: "data_processing",
            stage: "preprocessing"
        }
    }
);

Expected Outcome

Context ID: ctx_abc123def456
Language: python
Working Directory: /home/user/project

Using Contexts

Executing Code in Contexts

Python
JavaScript

# Execute code in specific context
result = client.sandbox.sandboxes.run_code(
    sandbox.sandbox_id,
    code="x = 42\nprint(f'x in context: {x}')",
    language="python",
    context_id=context.context_id
)

print(result.logs['stdout'])

// Execute code in specific context
const result = await client.sandbox.sandboxes.runCode(
    sandbox.sandbox_id,
    {
        code: "x = 42\nprint(f'x in context: {x}')",
        language: "python",
        context_id: context.context_id
    }
);

console.log(result.logs.stdout);

Expected Outcome

['x in context: 42']

Context Isolation Example

Python
JavaScript

from gravixlayer import GravixLayer

client = GravixLayer()
sandbox = client.sandbox.sandboxes.create(
    provider="gravix",
    region="eu-west-1",
    template="python-base-v1"
)

try:
    # Create two separate contexts
    context1 = client.sandbox.sandboxes.create_code_context(
        sandbox.sandbox_id,
        language="python",
        cwd="/home/user/context1"
    )
    
    context2 = client.sandbox.sandboxes.create_code_context(
        sandbox.sandbox_id,
        language="python", 
        cwd="/home/user/context2"
    )
    
    # Set variable in context1
    client.sandbox.sandboxes.run_code(
        sandbox.sandbox_id,
        code="secret_value = 'context1_secret'",
        context_id=context1.context_id
    )
    
    # Set different variable in context2
    client.sandbox.sandboxes.run_code(
        sandbox.sandbox_id,
        code="secret_value = 'context2_secret'",
        context_id=context2.context_id
    )
    
    # Check values in each context
    result1 = client.sandbox.sandboxes.run_code(
        sandbox.sandbox_id,
        code="print(secret_value)",
        context_id=context1.context_id
    )
    
    result2 = client.sandbox.sandboxes.run_code(
        sandbox.sandbox_id,
        code="print(secret_value)",
        context_id=context2.context_id
    )
    
    print(f"Context 1: {result1.logs['stdout'][0]}")
    print(f"Context 2: {result2.logs['stdout'][0]}")
    
finally:
    client.sandbox.sandboxes.kill(sandbox.sandbox_id)

import { GravixLayer } from 'gravixlayer';

const client = new GravixLayer();
const sandbox = await client.sandbox.sandboxes.create({
    provider: "gravix",
    region: "eu-west-1",
    template: "python-base-v1"
});

try {
    // Create two separate contexts
    const context1 = await client.sandbox.sandboxes.createCodeContext(
        sandbox.sandbox_id,
        {
            language: "python",
            cwd: "/home/user/context1"
        }
    );
    
    const context2 = await client.sandbox.sandboxes.createCodeContext(
        sandbox.sandbox_id,
        {
            language: "python",
            cwd: "/home/user/context2"
        }
    );
    
    // Set variable in context1
    await client.sandbox.sandboxes.runCode(
        sandbox.sandbox_id,
        {
            code: "secret_value = 'context1_secret'",
            context_id: context1.context_id
        }
    );
    
    // Set different variable in context2
    await client.sandbox.sandboxes.runCode(
        sandbox.sandbox_id,
        {
            code: "secret_value = 'context2_secret'",
            context_id: context2.context_id
        }
    );
    
    // Check values in each context
    const result1 = await client.sandbox.sandboxes.runCode(
        sandbox.sandbox_id,
        {
            code: "print(secret_value)",
            context_id: context1.context_id
        }
    );
    
    const result2 = await client.sandbox.sandboxes.runCode(
        sandbox.sandbox_id,
        {
            code: "print(secret_value)",
            context_id: context2.context_id
        }
    );
    
    console.log(`Context 1: ${result1.logs.stdout[0]}`);
    console.log(`Context 2: ${result2.logs.stdout[0]}`);
    
} finally {
    await client.sandbox.sandboxes.kill(sandbox.sandbox_id);
}

Expected Outcome

Context 1: context1_secret
Context 2: context2_secret

Managing Contexts

List All Contexts

Python
JavaScript

# Get all contexts for a sandbox
contexts = client.sandbox.sandboxes.get_code_contexts(sandbox.sandbox_id)

print(f"Total contexts: {len(contexts.contexts)}")
for ctx in contexts.contexts:
    print(f"ID: {ctx.context_id}")
    print(f"Language: {ctx.language}")
    print(f"Working Directory: {ctx.cwd}")
    print(f"Created: {ctx.created_at}")
    print("---")

// Get all contexts for a sandbox
const contexts = await client.sandbox.sandboxes.getCodeContexts(sandbox.sandbox_id);

console.log(`Total contexts: ${contexts.contexts.length}`);
for (const ctx of contexts.contexts) {
    console.log(`ID: ${ctx.context_id}`);
    console.log(`Language: ${ctx.language}`);
    console.log(`Working Directory: ${ctx.cwd}`);
    console.log(`Created: ${ctx.created_at}`);
    console.log("---");
}

Expected Outcome

Total contexts: 2
ID: ctx_abc123def456
Language: python
Working Directory: /home/user/context1
Created: 2024-01-15T10:30:00Z
---
ID: ctx_def456ghi789
Language: python
Working Directory: /home/user/context2
Created: 2024-01-15T10:31:00Z
---

Get Context Information

Python
JavaScript

# Get specific context details
context_info = client.sandbox.sandboxes.get_code_context(
    sandbox.sandbox_id,
    context.context_id
)

print(f"Context ID: {context_info.context_id}")
print(f"Language: {context_info.language}")
print(f"Working Directory: {context_info.cwd}")
print(f"Status: {context_info.status}")
print(f"Metadata: {context_info.metadata}")

// Get specific context details
const contextInfo = await client.sandbox.sandboxes.getCodeContext(
    sandbox.sandbox_id,
    context.context_id
);

console.log(`Context ID: ${contextInfo.context_id}`);
console.log(`Language: ${contextInfo.language}`);
console.log(`Working Directory: ${contextInfo.cwd}`);
console.log(`Status: ${contextInfo.status}`);
console.log(`Metadata: ${JSON.stringify(contextInfo.metadata)}`);

Expected Outcome

Context ID: ctx_abc123def456
Language: python
Working Directory: /home/user/project
Status: active
Metadata: {'purpose': 'data_processing', 'stage': 'preprocessing'}

Delete Context

Python
JavaScript

# Delete a specific context
client.sandbox.sandboxes.delete_code_context(
    sandbox.sandbox_id,
    context.context_id
)

print("Context deleted successfully")

// Delete a specific context
await client.sandbox.sandboxes.deleteCodeContext(
    sandbox.sandbox_id,
    context.context_id
);

console.log("Context deleted successfully");

Expected Outcome

Context deleted successfully

Advanced Context Usage

Multi-Stage Data Processing

Python
JavaScript

from gravixlayer import GravixLayer

client = GravixLayer()
sandbox = client.sandbox.sandboxes.create(
    provider="gravix",
    region="eu-west-1",
    template="python-base-v1"
)

try:
    # Create contexts for different processing stages
    ingestion_ctx = client.sandbox.sandboxes.create_code_context(
        sandbox.sandbox_id,
        language="python",
        cwd="/home/user/ingestion",
        metadata={"stage": "data_ingestion"}
    )
    
    processing_ctx = client.sandbox.sandboxes.create_code_context(
        sandbox.sandbox_id,
        language="python",
        cwd="/home/user/processing",
        metadata={"stage": "data_processing"}
    )
    
    analysis_ctx = client.sandbox.sandboxes.create_code_context(
        sandbox.sandbox_id,
        language="python",
        cwd="/home/user/analysis",
        metadata={"stage": "data_analysis"}
    )
    
    # Stage 1: Data Ingestion
    client.sandbox.sandboxes.run_code(
        sandbox.sandbox_id,
        code="""
import pandas as pd
import json

# Simulate data ingestion
raw_data = {
    'users': [
        {'id': 1, 'name': 'Alice', 'age': 25},
        {'id': 2, 'name': 'Bob', 'age': 30},
        {'id': 3, 'name': 'Charlie', 'age': 35}
    ]
}

# Save raw data
with open('/home/user/shared/raw_data.json', 'w') as f:
    json.dump(raw_data, f)

print("Data ingestion completed")
""",
        context_id=ingestion_ctx.context_id
    )
    
    # Stage 2: Data Processing
    client.sandbox.sandboxes.run_code(
        sandbox.sandbox_id,
        code="""
import pandas as pd
import json

# Load raw data
with open('/home/user/shared/raw_data.json', 'r') as f:
    raw_data = json.load(f)

# Process data
df = pd.DataFrame(raw_data['users'])
df['age_group'] = df['age'].apply(lambda x: 'Young' if x < 30 else 'Adult')

# Save processed data
df.to_csv('/home/user/shared/processed_data.csv', index=False)

print("Data processing completed")
print(f"Processed {len(df)} records")
""",
        context_id=processing_ctx.context_id
    )
    
    # Stage 3: Data Analysis
    result = client.sandbox.sandboxes.run_code(
        sandbox.sandbox_id,
        code="""
import pandas as pd

# Load processed data
df = pd.read_csv('/home/user/shared/processed_data.csv')

# Perform analysis
age_distribution = df['age_group'].value_counts()
average_age = df['age'].mean()

print("Analysis Results:")
print(f"Average age: {average_age:.1f}")
print("Age distribution:")
for group, count in age_distribution.items():
    print(f"  {group}: {count}")

# Save analysis results
analysis_results = {
    'average_age': average_age,
    'age_distribution': age_distribution.to_dict()
}

import json
with open('/home/user/shared/analysis_results.json', 'w') as f:
    json.dump(analysis_results, f)

print("Analysis completed")
""",
        context_id=analysis_ctx.context_id
    )
    
    # Print results
    for line in result.logs['stdout']:
        print(line)
        
finally:
    client.sandbox.sandboxes.kill(sandbox.sandbox_id)

import { GravixLayer } from 'gravixlayer';

const client = new GravixLayer();
const sandbox = await client.sandbox.sandboxes.create({
    provider: "gravix",
    region: "eu-west-1",
    template: "python-base-v1"
});

try {
    // Create contexts for different processing stages
    const ingestionCtx = await client.sandbox.sandboxes.createCodeContext(
        sandbox.sandbox_id,
        {
            language: "python",
            cwd: "/home/user/ingestion",
            metadata: { stage: "data_ingestion" }
        }
    );
    
    const processingCtx = await client.sandbox.sandboxes.createCodeContext(
        sandbox.sandbox_id,
        {
            language: "python",
            cwd: "/home/user/processing",
            metadata: { stage: "data_processing" }
        }
    );
    
    const analysisCtx = await client.sandbox.sandboxes.createCodeContext(
        sandbox.sandbox_id,
        {
            language: "python",
            cwd: "/home/user/analysis",
            metadata: { stage: "data_analysis" }
        }
    );
    
    // Stage 1: Data Ingestion
    await client.sandbox.sandboxes.runCode(
        sandbox.sandbox_id,
        {
            code: `
import pandas as pd
import json

# Simulate data ingestion
raw_data = {
    'users': [
        {'id': 1, 'name': 'Alice', 'age': 25},
        {'id': 2, 'name': 'Bob', 'age': 30},
        {'id': 3, 'name': 'Charlie', 'age': 35}
    ]
}

# Save raw data
with open('/home/user/shared/raw_data.json', 'w') as f:
    json.dump(raw_data, f)

print("Data ingestion completed")
`,
            context_id: ingestionCtx.context_id
        }
    );
    
    // Stage 2: Data Processing
    await client.sandbox.sandboxes.runCode(
        sandbox.sandbox_id,
        {
            code: `
import pandas as pd
import json

# Load raw data
with open('/home/user/shared/raw_data.json', 'r') as f:
    raw_data = json.load(f)

# Process data
df = pd.DataFrame(raw_data['users'])
df['age_group'] = df['age'].apply(lambda x: 'Young' if x < 30 else 'Adult')

# Save processed data
df.to_csv('/home/user/shared/processed_data.csv', index=False)

print("Data processing completed")
print(f"Processed {len(df)} records")
`,
            context_id: processingCtx.context_id
        }
    );
    
    // Stage 3: Data Analysis
    const result = await client.sandbox.sandboxes.runCode(
        sandbox.sandbox_id,
        {
            code: `
import pandas as pd

# Load processed data
df = pd.read_csv('/home/user/shared/processed_data.csv')

# Perform analysis
age_distribution = df['age_group'].value_counts()
average_age = df['age'].mean()

print("Analysis Results:")
print(f"Average age: {average_age:.1f}")
print("Age distribution:")
for group, count in age_distribution.items():
    print(f"  {group}: {count}")

# Save analysis results
analysis_results = {
    'average_age': average_age,
    'age_distribution': age_distribution.to_dict()
}

import json
with open('/home/user/shared/analysis_results.json', 'w') as f:
    json.dump(analysis_results, f)

print("Analysis completed")
`,
            context_id: analysisCtx.context_id
        }
    );
    
    // Print results
    for (const line of result.logs.stdout) {
        console.log(line);
    }
        
} finally {
    await client.sandbox.sandboxes.kill(sandbox.sandbox_id);
}

Expected Outcome

Data ingestion completed
Data processing completed
Processed 3 records
Analysis Results:
Average age: 30.0
Age distribution:
   Adult: 2
   Young: 1
Analysis completed

Best Practices

1. Use Contexts for Logical Separation

# ✅ Good: Separate contexts for different purposes
data_context = client.sandbox.sandboxes.create_code_context(
    sandbox_id, language="python", cwd="/home/user/data"
)

model_context = client.sandbox.sandboxes.create_code_context(
    sandbox_id, language="python", cwd="/home/user/models"
)

visualization_context = client.sandbox.sandboxes.create_code_context(
    sandbox_id, language="python", cwd="/home/user/viz"
)

2. Clean Up Contexts

# ✅ Delete contexts when no longer needed
try:
    # Use context
    pass
finally:
    client.sandbox.sandboxes.delete_code_context(sandbox_id, context_id)

3. Use Metadata for Organization

# ✅ Add meaningful metadata
context = client.sandbox.sandboxes.create_code_context(
    sandbox_id,
    language="python",
    metadata={
        "purpose": "ml_training",
        "model_type": "random_forest",
        "dataset": "customer_data",
        "created_by": "data_team"
    }
)

Context Limitations

Resource Sharing: All contexts within a sandbox share the same CPU, memory, and disk resources
File System: Contexts can access the same file system (use different directories for isolation)
Network: All contexts share the same network interface
Packages: Installed packages are available across all contexts in the sandbox

Next Steps

Code Execution

Advanced code execution patterns

File Operations

Manage files and directories

Templates

Explore available environment templates

Sandbox Management

Advanced sandbox configuration

Getting Started

Core Features

Advanced Usage

Resources

Context Management

What are Contexts?

Creating Contexts

Basic Context Creation

Context with Custom Configuration

Using Contexts

Executing Code in Contexts

Context Isolation Example

Managing Contexts

List All Contexts

Get Context Information

Delete Context

Advanced Context Usage

Multi-Stage Data Processing

Best Practices

1. Use Contexts for Logical Separation

2. Clean Up Contexts

3. Use Metadata for Organization

Context Limitations

Next Steps

Code Execution

File Operations

Templates

Sandbox Management

Getting Started

Core Features

Advanced Usage

Resources

​What are Contexts?

​Creating Contexts

​Basic Context Creation

​Context with Custom Configuration

​Using Contexts

​Executing Code in Contexts

​Context Isolation Example

​Managing Contexts

​List All Contexts

​Get Context Information

​Delete Context

​Advanced Context Usage

​Multi-Stage Data Processing

​Best Practices

​1. Use Contexts for Logical Separation

​2. Clean Up Contexts

​3. Use Metadata for Organization

​Context Limitations

​Next Steps

Code Execution

File Operations

Templates

Sandbox Management

What are Contexts?

Creating Contexts

Basic Context Creation

Context with Custom Configuration

Using Contexts

Executing Code in Contexts

Context Isolation Example

Managing Contexts

List All Contexts

Get Context Information

Delete Context

Advanced Context Usage

Multi-Stage Data Processing

Best Practices

1. Use Contexts for Logical Separation

2. Clean Up Contexts

3. Use Metadata for Organization

Context Limitations

Next Steps