feat: code interpreter

examples/code_interpreter_demo.py

@@ -0,0 +1,53 @@
+from together import Together
+
+client = Together()
+
+# Create a code interpreter instance
+code_interpreter = client.code_interpreter
+
+# Example 1: Simple print statement
+print("Example 1: Simple print")
+response = code_interpreter.run(code='print("Hello from Together!")', language="python")
+print(f"Status: {response.data.status}")
+for output in response.data.outputs:
+    print(f"{output.type}: {output.data}")
+if response.data.errors:
+    print(f"Errors: {response.data.errors}")
+print("\n")
+
+# Example 2: Using session for maintaining state
+print("Example 2: Using session for state")
+response1 = code_interpreter.run(code="x = 42", language="python")
+session_id = response1.data.session_id
+
+response2 = code_interpreter.run(
+    code='print(f"The value of x is {x}")', language="python", session_id=session_id
+)
+for output in response2.data.outputs:
+    print(f"{output.type}: {output.data}")
+if response2.data.errors:
+    print(f"Errors: {response2.data.errors}")
+print("\n")
+
+# Example 3: More complex computation
+print("Example 3: Complex computation")
+code = """
+!pip install numpy
+import numpy as np
+
+# Create a random matrix
+matrix = np.random.rand(3, 3)
+print("Random matrix:")
+print(matrix)
+
+# Calculate eigenvalues
+eigenvalues = np.linalg.eigvals(matrix)
+print("\\nEigenvalues:")
+print(eigenvalues)
+"""
+
+response = code_interpreter.run(code=code, language="python")
+for output in response.data.outputs:
+    print(f"{output.type}: {output.data}")
+if response.data.errors:
+    print(f"Errors: {response.data.errors}")

pyproject.toml

@@ -13,9 +13,7 @@ build-backend = "poetry.masonry.api"
 [tool.poetry]
 name = "together"
 version = "1.5.3"
-authors = [
-    "Together AI <[email protected]>"
-]
+authors = ["Together AI <[email protected]>"]
 description = "Python client for Together's Cloud Platform!"
 readme = "README.md"
 license = "Apache-2.0"
@@ -65,6 +63,7 @@ optional = true
 [tool.poetry.group.tests.dependencies]
 pytest = ">=7.4.2,<9.0.0"
 pytest-watch = "^4.2.0"
+pytest-mock = "^3.14.0"
 tox = "^4.14.1"
 
 [tool.poetry.group.examples]

src/together/client.py

@@ -7,6 +7,7 @@
 from together import resources
 from together.constants import BASE_URL, MAX_RETRIES, TIMEOUT_SECS
 from together.error import AuthenticationError
+from together.resources.code_interpreter import CodeInterpreter
 from together.types import TogetherClient
 from together.utils import enforce_trailing_slash
 from together.utils.api_helpers import get_google_colab_secret
@@ -22,6 +23,7 @@ class Together:
     fine_tuning: resources.FineTuning
     rerank: resources.Rerank
     audio: resources.Audio
+    code_interpreter: CodeInterpreter
 
     # client options
     client: TogetherClient
@@ -87,6 +89,7 @@ def __init__(
         self.rerank = resources.Rerank(self.client)
         self.audio = resources.Audio(self.client)
         self.endpoints = resources.Endpoints(self.client)
+        self.code_interpreter = CodeInterpreter(self.client)
 
 
 class AsyncTogether:
@@ -98,6 +101,7 @@ class AsyncTogether:
     models: resources.AsyncModels
     fine_tuning: resources.AsyncFineTuning
     rerank: resources.AsyncRerank
+    code_interpreter: CodeInterpreter
 
     # client options
     client: TogetherClient
@@ -161,6 +165,7 @@ def __init__(
         self.models = resources.AsyncModels(self.client)
         self.fine_tuning = resources.AsyncFineTuning(self.client)
         self.rerank = resources.AsyncRerank(self.client)
+        self.code_interpreter = CodeInterpreter(self.client)
 
 
 Client = Together

src/together/resources/code_interpreter.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+from typing import Dict, Literal, Optional
+
+from together.abstract import api_requestor
+from together.together_response import TogetherResponse
+from together.types import TogetherClient, TogetherRequest
+from together.types.code_interpreter import ExecuteResponse
+
+
+class CodeInterpreter:
+    """Code Interpreter resource for executing code snippets."""
+
+    def __init__(self, client: TogetherClient) -> None:
+        self._client = client
+
+    def run(
+        self,
+        code: str,
+        language: Literal["python"],
+        session_id: Optional[str] = None,
+    ) -> ExecuteResponse:
+        """Execute a code snippet.
+
+        Args:
+            code (str): Code snippet to execute
+            language (str): Programming language for the code to execute. Currently only supports Python.
+            session_id (str, optional): Identifier of the current session. Used to make follow-up calls.
+
+        Returns:
+            ExecuteResponse: Object containing execution results and outputs
+        """
+        requestor = api_requestor.APIRequestor(
+            client=self._client,
+        )
+
+        data: Dict[str, str] = {
+            "code": code,
+            "language": language,
+        }
+
+        if session_id is not None:
+            data["session_id"] = session_id
+
+        # Use absolute URL to bypass the /v1 prefix
+        response, _, _ = requestor.request(
+            options=TogetherRequest(
+                method="POST",
+                url="/tci/execute",
+                params=data,
+            ),
+            stream=False,
+        )
+
+        assert isinstance(response, TogetherResponse)
+
+        # Return the response data directly since our types match the API structure
+        return ExecuteResponse(**response.data)

src/together/types/code_interpreter.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+from typing import Any, Dict, Literal, Union
+
+from pydantic import Field
+
+from together.types.endpoints import TogetherJSONModel
+
+
+class InterpreterOutput(TogetherJSONModel):
+    """Base class for interpreter output types."""
+
+    type: Literal["stdout", "stderr", "error", "display_data", "execute_result"] = (
+        Field(description="The type of output")
+    )
+    data: Union[str, Dict[str, Any]] = Field(description="The output data")
+
+
+class ExecuteResponseData(TogetherJSONModel):
+    """Data from code execution response."""
+
+    outputs: list[InterpreterOutput] = Field(
+        description="List of outputs from execution", default_factory=list
+    )
+    errors: Union[str, None] = Field(
+        description="Any errors that occurred during execution", default=None
+    )
+    session_id: str = Field(
+        description="Identifier of the current session. Used to make follow-up calls."
+    )
+    status: str = Field(description="Status of the execution", default="completed")
+
+
+class ExecuteResponse(TogetherJSONModel):
+    """Response from code execution."""
+
+    data: ExecuteResponseData = Field(
+        description="The response data containing outputs and session information"
+    )
+
+
+__all__ = [
+    "InterpreterOutput",
+    "ExecuteResponseData",
+    "ExecuteResponse",
+]