autogen_ext.code_executors.jupyter

class JupyterCodeExecutor(kernel_name: str = 'python3', timeout: int = 60, output_dir: Path | str | None = None)

Bases: CodeExecutor, Component[JupyterCodeExecutorConfig]

Eine Code-Executor-Klasse, die Code zustandsbehaftet mithilfe von [nbclient](jupyter/nbclient) ausführt.

Gefahr

Dies führt Code auf dem lokalen Rechner aus. Bei Verwendung mit LLM-generiertem Code ist Vorsicht geboten.

Beispiel für die direkte Verwendung

import asyncio
from autogen_core import CancellationToken
from autogen_core.code_executor import CodeBlock
from autogen_ext.code_executors.jupyter import JupyterCodeExecutor


async def main() -> None:
    async with JupyterCodeExecutor() as executor:
        cancel_token = CancellationToken()
        code_blocks = [CodeBlock(code="print('hello world!')", language="python")]
        code_result = await executor.execute_code_blocks(code_blocks, cancel_token)
        print(code_result)


asyncio.run(main())

Beispiel für die Verwendung mit PythonCodeExecutionTool

import asyncio
from autogen_agentchat.agents import AssistantAgent
from autogen_ext.code_executors.jupyter import JupyterCodeExecutor
from autogen_ext.models.openai import OpenAIChatCompletionClient
from autogen_ext.tools.code_execution import PythonCodeExecutionTool


async def main() -> None:
    async with JupyterCodeExecutor() as executor:
        tool = PythonCodeExecutionTool(executor)
        model_client = OpenAIChatCompletionClient(model="gpt-4o")
        agent = AssistantAgent("assistant", model_client=model_client, tools=[tool])
        result = await agent.run(task="What is the 10th Fibonacci number? Use Python to calculate it.")
        print(result)


asyncio.run(main())

Beispiel für die Verwendung innerhalb eines CodeExecutorAgent

import asyncio
from autogen_agentchat.agents import CodeExecutorAgent
from autogen_agentchat.messages import TextMessage
from autogen_ext.code_executors.jupyter import JupyterCodeExecutor
from autogen_core import CancellationToken


async def main() -> None:
    async with JupyterCodeExecutor() as executor:
        code_executor_agent = CodeExecutorAgent("code_executor", code_executor=executor)
        task = TextMessage(
            content='''Here is some code
    ```python
    print('Hello world')
    ```
    ''',
            source="user",
        )
        response = await code_executor_agent.on_messages([task], CancellationToken())
        print(response.chat_message)


asyncio.run(main())

Parameter:

• kernel_name (str) – Der zu verwendende Kernelname. Standardmäßig „python3“.

• timeout (int) – Das Timeout für die Codeausführung, standardmäßig 60.

• output_dir (Path) – Das Verzeichnis zum Speichern von Ausgabedateien, standardmäßig ein temporäres Verzeichnis.

Hinweis

Die Verwendung des aktuellen Verzeichnisses („.“) als Ausgabeverzeichnis ist veraltet. Bei Verwendung wird eine Deprecation-Warnung ausgegeben.

component_config_schema

alias von JupyterCodeExecutorConfig

component_provider_override: ClassVar[str | None] = 'autogen_ext.code_executors.jupyter.JupyterCodeExecutor'

Überschreibe den Anbieter-String für die Komponente. Dies sollte verwendet werden, um zu verhindern, dass interne Modulnamen Teil des Modulnamens werden.

async execute_code_blocks(code_blocks: list[CodeBlock], cancellation_token: CancellationToken) → JupyterCodeResult

Führt Codeblöcke aus und gibt das Ergebnis zurück.

Parameter:

code_blocks (list[CodeBlock]) – Die auszuführenden Codeblöcke.

Gibt zurück:

JupyterCodeResult – Das Ergebnis der Codeausführung.

async restart() → None

Startet den Code-Executor neu.

async start() → None

(Experimentell) Startet den Code-Executor.

Initialisiert die Jupyter Notebook-Ausführungsumgebung, indem ein neues Notebook erstellt und mit dem angegebenen Jupyter Kernel eingerichtet wird. Markiert den Executor als gestartet, was die Codeausführung ermöglicht. Diese Methode sollte vor der Ausführung von Codeblöcken aufgerufen werden.

async stop() → None

(Experimentell) Stoppt den Code-Executor.

Beendet die Jupyter Notebook-Ausführung, indem der Kernel-Kontext beendet und die zugehörigen Ressourcen bereinigt werden.

property output_dir: Path

class JupyterCodeResult(exit_code: int, output: str, output_files: list[Path])

Bases: CodeResult

Eine Code-Ergebnisklasse für den Jupyter-Code-Executor.

output_files: list[Path]