Code Interpreter

def run(
    code: str,
    language: Literal["python"],
    session_id: Optional[str] = None,
    files: Optional[List[Dict[str, Any]]] = None
) -> ExecuteResponse:
    """
    Execute a code snippet, optionally with files.
    
    Args:
        code: Code snippet to execute
        language: Programming language ("python" only currently supported)
        session_id: Identifier of current session for follow-up calls
        files: Files to upload before executing code
    
    Returns:
        ExecuteResponse: Object containing execution results and outputs
    
    Raises:
        ValidationError: If files don't conform to required structure
    """

from together import Together

client = Together()

# Execute simple Python code
response = client.code_interpreter.run(
    code="print('Hello, World!')\nresult = 42\nprint(f'The answer is {result}')",
    language="python"
)

# Access outputs
for output in response.data.outputs:
    if output.type == "stdout":
        print("Output:", output.data)

print(f"Session ID: {response.data.session_id}")

from together import Together

client = Together()

# First execution - creates a session
response1 = client.code_interpreter.run(
    code="x = 10\ny = 20\nprint(f'x = {x}, y = {y}')",
    language="python"
)

session_id = response1.data.session_id

# Second execution - reuses the session with variables preserved
response2 = client.code_interpreter.run(
    code="z = x + y\nprint(f'z = x + y = {z}')",
    language="python",
    session_id=session_id
)

# Variables from previous execution are still available
for output in response2.data.outputs:
    if output.type == "stdout":
        print("Persistent session output:", output.data)

import base64
from together import Together

client = Together()

# Prepare file inputs
files = [
    {
        "name": "data.txt",
        "encoding": "string",
        "content": "apple,banana,cherry\ndog,elephant,fox"
    },
    {
        "name": "config.json",
        "encoding": "string", 
        "content": '{"delimiter": ",", "header": false}'
    }
]

# Execute code with file inputs
response = client.code_interpreter.run(
    code="""
import json

# Read the data file
with open('data.txt', 'r') as f:
    data = f.read()

# Read the config file
with open('config.json', 'r') as f:
    config = json.load(f)

# Process the data
lines = data.strip().split('\\n')
delimiter = config['delimiter']

for line in lines:
    items = line.split(delimiter)
    print(f"Items: {items}")
    
print(f"Total lines processed: {len(lines)}")
    """,
    language="python",
    files=files
)

# Process outputs
for output in response.data.outputs:
    if output.type == "stdout":
        print("File processing output:", output.data)
    elif output.type == "stderr":
        print("Error:", output.data)

from together import Together

client = Together()

# Upload CSV data and analyze it
csv_data = """date,temperature,humidity
2024-01-01,22.5,65
2024-01-02,24.1,62
2024-01-03,21.8,68
2024-01-04,23.9,64
2024-01-05,25.2,61"""

files = [
    {
        "name": "weather.csv",
        "encoding": "string",
        "content": csv_data
    }
]

response = client.code_interpreter.run(
    code="""
import csv
import statistics

# Read and parse CSV data
data = []
with open('weather.csv', 'r') as f:
    reader = csv.DictReader(f)
    for row in reader:
        data.append({
            'date': row['date'],
            'temperature': float(row['temperature']),
            'humidity': int(row['humidity'])
        })

# Calculate statistics
temps = [d['temperature'] for d in data]
humidities = [d['humidity'] for d in data]

print(f"Temperature Statistics:")
print(f"  Average: {statistics.mean(temps):.1f}°C")
print(f"  Min: {min(temps)}°C")
print(f"  Max: {max(temps)}°C")

print(f"\\nHumidity Statistics:")
print(f"  Average: {statistics.mean(humidities):.1f}%")
print(f"  Min: {min(humidities)}%")
print(f"  Max: {max(humidities)}%")

# Find hottest day
hottest = max(data, key=lambda x: x['temperature'])
print(f"\\nHottest day: {hottest['date']} at {hottest['temperature']}°C")
    """,
    language="python",
    files=files
)

# Display results
for output in response.data.outputs:
    if output.type == "stdout":
        print("Analysis results:")
        print(output.data)

import base64
from together import Together

client = Together()

# Create a simple binary file (example: small image data)
# In practice, you'd read this from an actual file
binary_content = b"\\x89PNG\\r\\n\\x1a\\n\\x00\\x00\\x00\\rIHDR\\x00\\x00\\x00\\x01\\x00\\x00\\x00\\x01"
base64_content = base64.b64encode(binary_content).decode('utf-8')

files = [
    {
        "name": "small_image.png",
        "encoding": "base64",
        "content": base64_content
    }
]

response = client.code_interpreter.run(
    code="""
import os

# Check file exists and get info
if os.path.exists('small_image.png'):
    size = os.path.getsize('small_image.png')
    print(f"File 'small_image.png' exists with size: {size} bytes")
    
    # Read binary data
    with open('small_image.png', 'rb') as f:
        data = f.read()
    
    print(f"First 10 bytes: {data[:10]}")
else:
    print("File not found")
    """,
    language="python",
    files=files
)

for output in response.data.outputs:
    if output.type == "stdout":
        print("Binary file output:", output.data)

from together import Together

client = Together()

response = client.code_interpreter.run(
    code="""
# stdout output
print("This goes to stdout")

# stderr output  
import sys
print("This goes to stderr", file=sys.stderr)

# Return value
42

# Error handling
try:
    1 / 0
except ZeroDivisionError as e:
    print(f"Caught error: {e}")
    """,
    language="python"
)

for output in response.data.outputs:
    print(f"Type: {output.type}")
    print(f"Data: {output.data}")
    print("---")

class FileInput:
    name: str
    encoding: Literal["string", "base64"]
    content: str

class InterpreterOutput:
    type: Literal["stdout", "stderr", "error", "display_data", "execute_result"]
    data: Union[str, Dict[str, Any]]

class ExecuteResponseData:
    outputs: List[InterpreterOutput]
    errors: Optional[str]
    session_id: str
    status: str

class ExecuteResponse:
    data: ExecuteResponseData

from together import Together
from together.error import APIError

client = Together()

# Invalid file input example
try:
    response = client.code_interpreter.run(
        code="print('Hello')",
        language="python",
        files=[
            {
                "name": "test.txt",
                # Missing required 'encoding' field
                "content": "test content"
            }
        ]
    )
except ValueError as e:
    print(f"File validation error: {e}")

# Handle execution errors
response = client.code_interpreter.run(
    code="raise ValueError('This is a test error')",
    language="python"
)

if response.data.errors:
    print(f"Execution error: {response.data.errors}")

for output in response.data.outputs:
    if output.type == "error":
        print(f"Error output: {output.data}")

from together import Together

client = Together()

# Start a session with imports and setup
setup_response = client.code_interpreter.run(
    code="""
import math
import random

# Setup some variables
pi_value = math.pi
random.seed(42)
setup_complete = True

print("Session initialized")
    """,
    language="python"
)

session_id = setup_response.data.session_id

# Use the session for calculations
calc_response = client.code_interpreter.run(
    code="""
# Variables from previous execution are available
print(f"Pi value: {pi_value}")
print(f"Setup complete: {setup_complete}")

# Generate some random numbers with the seeded generator
numbers = [random.randint(1, 100) for _ in range(5)]
print(f"Random numbers: {numbers}")

# Use math functions
area = pi_value * (5 ** 2)
print(f"Area of circle with radius 5: {area:.2f}")
    """,
    language="python",
    session_id=session_id
)

# Continue the session
final_response = client.code_interpreter.run(
    code="""
# Previous variables and state are still available
print(f"Previously generated numbers: {numbers}")
print(f"Sum of numbers: {sum(numbers)}")
    """,
    language="python", 
    session_id=session_id
)

from together import Together

client = Together()

# Step 1: Data preparation
response1 = client.code_interpreter.run(
    code="""
import numpy as np
import statistics

# Generate sample data
np.random.seed(42)
data = np.random.normal(100, 15, 1000)
print(f"Generated {len(data)} data points")
print(f"Mean: {np.mean(data):.2f}")
print(f"Std: {np.std(data):.2f}")
    """,
    language="python"
)

session_id = response1.data.session_id

# Step 2: Data analysis  
response2 = client.code_interpreter.run(
    code="""
# Analyze the data (data variable from previous step)
percentiles = [25, 50, 75, 90, 95, 99]
for p in percentiles:
    value = np.percentile(data, p)
    print(f"{p}th percentile: {value:.2f}")

# Find outliers (values beyond 2 standard deviations)
mean = np.mean(data)
std = np.std(data)
outliers = data[(data < mean - 2*std) | (data > mean + 2*std)]
print(f"\\nFound {len(outliers)} outliers")
    """,
    language="python",
    session_id=session_id
)

# Step 3: Generate report
response3 = client.code_interpreter.run(
    code="""
# Generate summary report
report = f'''
Data Analysis Report
===================
Sample size: {len(data)}
Mean: {np.mean(data):.2f}
Median: {np.median(data):.2f}
Standard deviation: {np.std(data):.2f}
Min value: {np.min(data):.2f}
Max value: {np.max(data):.2f}
Outliers detected: {len(outliers)}
'''

print(report)

# Save report to file
with open('analysis_report.txt', 'w') as f:
    f.write(report)
    
print("Report saved to analysis_report.txt")
    """,
    language="python",
    session_id=session_id
)