A programming framework for agentic AI
Make Docker Jupyter support to the Version 0.4 as Version 0.2 (#6231)
masquerlin4a5dd9eec90a
diff --git a/python/packages/autogen-core/docs/src/reference/index.md b/python/packages/autogen-core/docs/src/reference/index.mdindex 98988b791..e0199903f 100644--- a/python/packages/autogen-core/docs/src/reference/index.md+++ b/python/packages/autogen-core/docs/src/reference/index.md@@ -66,6 +66,7 @@ python/autogen_ext.tools.semantic_kernelpython/autogen_ext.code_executors.localpython/autogen_ext.code_executors.dockerpython/autogen_ext.code_executors.jupyter+python/autogen_ext.code_executors.docker_jupyterpython/autogen_ext.code_executors.azurepython/autogen_ext.cache_store.diskcachepython/autogen_ext.cache_store.redisdiff --git a/python/packages/autogen-core/docs/src/reference/python/autogen_ext.code_executors.docker_jupyter.rst b/python/packages/autogen-core/docs/src/reference/python/autogen_ext.code_executors.docker_jupyter.rstnew file mode 100644index 000000000..003a5b987--- /dev/null+++ b/python/packages/autogen-core/docs/src/reference/python/autogen_ext.code_executors.docker_jupyter.rst@@ -0,0 +1,8 @@+autogen\_ext.code\_executors.docker_jupyter+===========================================+++.. automodule:: autogen_ext.code_executors.docker_jupyter+ :members:+ :undoc-members:+ :show-inheritance:diff --git a/python/packages/autogen-ext/pyproject.toml b/python/packages/autogen-ext/pyproject.tomlindex 5b08ab891..2df0a1db6 100644--- a/python/packages/autogen-ext/pyproject.toml+++ b/python/packages/autogen-ext/pyproject.toml@@ -78,6 +78,14 @@ jupyter-executor = ["nbclient>=0.10.2",]+docker-jupyter-executor = [+ "docker~=7.0",+ "asyncio_atexit>=1.0.1",+ "websockets>=15.0.1",+ "requests>=2.32.3",+ "aiohttp>=3.11.16",+]+task-centric-memory = ["chromadb>=1.0.0"]semantic-kernel-core = [diff --git a/python/packages/autogen-ext/src/autogen_ext/code_executors/docker_jupyter/__init__.py b/python/packages/autogen-ext/src/autogen_ext/code_executors/docker_jupyter/__init__.pynew file mode 100644index 000000000..549c178f1--- /dev/null+++ b/python/packages/autogen-ext/src/autogen_ext/code_executors/docker_jupyter/__init__.py@@ -0,0 +1,10 @@+from ._docker_jupyter import DockerJupyterCodeExecutor, DockerJupyterCodeResult+from ._jupyter_server import DockerJupyterServer, JupyterClient, JupyterKernelClient++__all__ = [+ "DockerJupyterCodeExecutor",+ "DockerJupyterServer",+ "JupyterClient",+ "JupyterKernelClient",+ "DockerJupyterCodeResult",+]diff --git a/python/packages/autogen-ext/src/autogen_ext/code_executors/docker_jupyter/_docker_jupyter.py b/python/packages/autogen-ext/src/autogen_ext/code_executors/docker_jupyter/_docker_jupyter.pynew file mode 100644index 000000000..2a971d76c--- /dev/null+++ b/python/packages/autogen-ext/src/autogen_ext/code_executors/docker_jupyter/_docker_jupyter.py@@ -0,0 +1,297 @@+import asyncio+import base64+import json+import os+import tempfile+import uuid+from dataclasses import dataclass+from pathlib import Path+from types import TracebackType+from typing import List, Optional, Union++from autogen_core import CancellationToken, Component+from autogen_core.code_executor import CodeBlock, CodeExecutor, CodeResult+from autogen_ext.code_executors._common import silence_pip+from pydantic import BaseModel+from typing_extensions import Self++from ._jupyter_server import JupyterClient, JupyterConnectable, JupyterConnectionInfo, JupyterKernelClient+++@dataclass+class DockerJupyterCodeResult(CodeResult):+ """(Experimental) A code result class for IPython code executor."""++ output_files: list[Path]+++class DockerJupyterCodeExecutorConfig(BaseModel):+ """Configuration for JupyterCodeExecutor"""++ jupyter_server: Union[JupyterConnectable, JupyterConnectionInfo]+ kernel_name: str = "python3"+ timeout: int = 60+ output_dir: Optional[Union[Path, str]] = None++ class Config:+ arbitrary_types_allowed = True+++class DockerJupyterCodeExecutor(CodeExecutor, Component[DockerJupyterCodeExecutorConfig]):+ """(Experimental) A code executor class that executes code statefully using+ a Jupyter server supplied to this class.++ Each execution is stateful and can access variables created from previous+ executions in the same session.++ To use this, you need to install the following dependencies:++ .. code-block:: shell++ pip install "autogen-ext[docker-jupyter-executor]"++ Args:+ jupyter_server (Union[JupyterConnectable, JupyterConnectionInfo]): The Jupyter server to use.+ kernel_name (str): The kernel name to use. Make sure it is installed.+ By default, it is "python3".+ timeout (int): The timeout for code execution, by default 60.+ output_dir (str): The directory to save output files, by default None.++ Example of using it directly:++ .. code-block:: python++ import asyncio+ from autogen_core import CancellationToken+ from autogen_core.code_executor import CodeBlock+ from autogen_ext.code_executors.docker_jupyter import DockerJupyterCodeExecutor, DockerJupyterServer+++ async def main() -> None:+ async with DockerJupyterServer() as jupyter_server:+ async with DockerJupyterCodeExecutor(jupyter_server=jupyter_server) as executor:+ code_blocks = [CodeBlock(code="print('hello world!')", language="python")]+ code_result = await executor.execute_code_blocks(code_blocks, cancellation_token=CancellationToken())+ print(code_result)+++ asyncio.run(main())++ Example of using it with your own jupyter image:++ .. code-block:: python++ import asyncio+ from autogen_core import CancellationToken+ from autogen_core.code_executor import CodeBlock+ from autogen_ext.code_executors.docker_jupyter import DockerJupyterCodeExecutor, DockerJupyterServer+++ async def main() -> None:+ async with DockerJupyterServer(custom_image_name="your_custom_images_name", expose_port=8888) as jupyter_server:+ async with DockerJupyterCodeExecutor(jupyter_server=jupyter_server) as executor:+ code_blocks = [CodeBlock(code="print('hello world!')", language="python")]+ code_result = await executor.execute_code_blocks(code_blocks, cancellation_token=CancellationToken())+ print(code_result)+++ asyncio.run(main())++ Example of using it with :class:`~autogen_ext.tools.code_execution.PythonCodeExecutionTool`:++ .. code-block:: python++ import asyncio+ from autogen_agentchat.agents import AssistantAgent+ from autogen_ext.code_executors.docker_jupyter import DockerJupyterCodeExecutor, DockerJupyterServer+ from autogen_ext.models.openai import OpenAIChatCompletionClient+ from autogen_ext.tools.code_execution import PythonCodeExecutionTool+++ async def main() -> None:+ async with DockerJupyterServer() as jupyter_server:+ async with DockerJupyterCodeExecutor(jupyter_server=jupyter_server) 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())++ Example of using it inside a :class:`~autogen_agentchat.agents._code_executor_agent.CodeExecutorAgent`:++ .. code-block:: python++ import asyncio+ from autogen_agentchat.agents import CodeExecutorAgent+ from autogen_agentchat.messages import TextMessage+ from autogen_ext.code_executors.docker_jupyter import DockerJupyterCodeExecutor, DockerJupyterServer+ from autogen_core import CancellationToken+++ async def main() -> None:+ async with DockerJupyterServer() as jupyter_server:+ async with DockerJupyterCodeExecutor(jupyter_server=jupyter_server) 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())++ """++ component_config_schema = DockerJupyterCodeExecutorConfig+ component_provider_override = "autogen_ext.code_executors.docker_jupyter.DockerJupyterCodeExecutor"++ def __init__(+ self,+ jupyter_server: Union[JupyterConnectable, JupyterConnectionInfo],+ kernel_name: str = "python3",+ timeout: int = 60,+ output_dir: Path | None = None,+ ):+ if timeout < 1:+ raise ValueError("Timeout must be greater than or equal to 1.")++ if isinstance(jupyter_server, JupyterConnectable):+ self._connection_info = jupyter_server.connection_info+ elif isinstance(jupyter_server, JupyterConnectionInfo):+ self._connection_info = jupyter_server+ else:+ raise ValueError("jupyter_server must be a JupyterConnectable or JupyterConnectionInfo.")++ self._output_dir = output_dir or getattr(jupyter_server, "_bind_dir", None)+ if not self._output_dir:+ with tempfile.TemporaryDirectory() as temp_dir:+ self._output_dir = Path(temp_dir)+ self._output_dir.mkdir(exist_ok=True)++ self._jupyter_client = JupyterClient(self._connection_info)++ self._kernel_name = kernel_name+ self._timeout = timeout+ self._async_jupyter_kernel_client: Optional[JupyterKernelClient] = None+ self._kernel_id: Optional[str] = None++ async def _ensure_async_kernel_client(self) -> JupyterKernelClient:+ """Ensure that an async kernel client exists and return it."""+ if self._kernel_id is None:+ await self.start()+ assert self._kernel_id is not None+ if self._async_jupyter_kernel_client is None:+ self._async_jupyter_kernel_client = await self._jupyter_client.get_kernel_client(self._kernel_id)+ return self._async_jupyter_kernel_client++ async def execute_code_blocks(+ self, code_blocks: List[CodeBlock], cancellation_token: CancellationToken+ ) -> DockerJupyterCodeResult:+ """(Experimental) Execute a list of code blocks and return the result.++ This method executes a list of code blocks as cells in the Jupyter kernel.+ See: https://jupyter-client.readthedocs.io/en/stable/messaging.html+ for the message protocol.++ Args:+ code_blocks (List[CodeBlock]): A list of code blocks to execute.++ Returns:+ DockerJupyterCodeResult: The result of the code execution.+ """+ kernel_client = await self._ensure_async_kernel_client()+ # Wait for kernel to be ready using async client+ is_ready = await kernel_client.wait_for_ready(timeout_seconds=self._timeout)+ if not is_ready:+ return DockerJupyterCodeResult(exit_code=1, output="ERROR: Kernel not ready", output_files=[])++ outputs: List[str] = []+ output_files: List[Path] = []+ for code_block in code_blocks:+ code = silence_pip(code_block.code, code_block.language)+ # Execute code using async client+ exec_task = asyncio.create_task(kernel_client.execute(code, timeout_seconds=self._timeout))+ cancellation_token.link_future(exec_task)+ result = await exec_task+ if result.is_ok:+ outputs.append(result.output)+ for data in result.data_items:+ if data.mime_type == "image/png":+ path = self._save_image(data.data)+ outputs.append(path)+ output_files.append(Path(path))+ elif data.mime_type == "text/html":+ path = self._save_html(data.data)+ outputs.append(path)+ output_files.append(Path(path))+ else:+ outputs.append(json.dumps(data.data))+ else:+ return DockerJupyterCodeResult(exit_code=1, output=f"ERROR: {result.output}", output_files=output_files)+ return DockerJupyterCodeResult(+ exit_code=0, output="\n".join([str(output) for output in outputs]), output_files=output_files+ )++ async def restart(self) -> None:+ """(Experimental) Restart a new session."""+ # Use async client to restart kernel+ if self._kernel_id is not None:+ await self._jupyter_client.restart_kernel(self._kernel_id)+ # Reset the clients to force recreation+ if self._async_jupyter_kernel_client is not None:+ await self._async_jupyter_kernel_client.stop()+ self._async_jupyter_kernel_client = None++ async def start(self) -> None:+ """(Experimental) Start a new session."""+ available_kernels = await self._jupyter_client.list_kernel_specs()+ if self._kernel_name not in available_kernels["kernelspecs"]:+ raise ValueError(f"Kernel {self._kernel_name} is not installed.")+ self._kernel_id = await self._jupyter_client.start_kernel(self._kernel_name)++ def _save_image(self, image_data_base64: str) -> str:+ """Save image data to a file."""+ image_data = base64.b64decode(image_data_base64)+ filename = f"{uuid.uuid4().hex}.png"+ path = os.path.join(str(self._output_dir), filename)+ with open(path, "wb") as f:+ f.write(image_data)+ return os.path.abspath(path)++ def _save_html(self, html_data: str) -> str:+ """Save html data to a file."""+ filename = f"{uuid.uuid4().hex}.html"+ path = os.path.join(str(self._output_dir), filename)+ with open(path, "w") as f:+ f.write(html_data)+ return os.path.abspath(path)++ async def stop(self) -> None:+ """Stop the kernel."""+ if self._kernel_id is not None:+ await self._jupyter_client.delete_kernel(self._kernel_id)+ if self._async_jupyter_kernel_client is not None:+ await self._async_jupyter_kernel_client.stop()+ self._async_jupyter_kernel_client = None+ await self._jupyter_client.close()++ async def __aenter__(self) -> Self:+ await self.start()+ return self++ async def __aexit__(+ self,+ exc_type: type[BaseException] | None,+ exc_val: BaseException | None,+ exc_tb: TracebackType | None,+ ) -> None:+ await self.stop()diff --git a/python/packages/autogen-ext/src/autogen_ext/code_executors/docker_jupyter/_jupyter_server.py b/python/packages/autogen-ext/src/autogen_ext/code_executors/docker_jupyter/_jupyter_server.pynew file mode 100644index 000000000..be7f15e2c--- /dev/null+++ b/python/packages/autogen-ext/src/autogen_ext/code_executors/docker_jupyter/_jupyter_server.py@@ -0,0 +1,430 @@+import asyncio+import atexit+import datetime+import io+import json+import logging+import os+import secrets+import uuid+from dataclasses import dataclass+from pathlib import Path+from time import sleep+from types import TracebackType+from typing import Any, Dict, List, Optional, Protocol, Type, Union, cast, runtime_checkable++import aiohttp+import docker+import docker.errors+import requests+import websockets+from requests.adapters import HTTPAdapter, Retry+from typing_extensions import Self+++@dataclass+class JupyterConnectionInfo:+ """(Experimental)"""++ host: str+ """`str` - Host of the Jupyter gateway server"""+ use_https: bool+ """`bool` - Whether to use HTTPS"""+ port: Optional[int] = None+ """`Optional[int]` - Port of the Jupyter gateway server. If None, the default port is used"""+ token: Optional[str] = None+ """`Optional[str]` - Token for authentication. If None, no token is used"""+++@runtime_checkable+class JupyterConnectable(Protocol):+ """(Experimental)"""++ @property+ def connection_info(self) -> JupyterConnectionInfo:+ """Return the connection information for this connectable."""+ ...+++class JupyterClient:+ def __init__(self, connection_info: JupyterConnectionInfo):+ """(Experimental) A client for communicating with a Jupyter gateway server.++ Args:+ connection_info (JupyterConnectionInfo): Connection information+ """+ self._connection_info = connection_info+ self._session = requests.Session()+ retries = Retry(total=5, backoff_factor=0.1)+ self._session.mount("http://", HTTPAdapter(max_retries=retries))+ # Create aiohttp session for async requests+ self._async_session: aiohttp.ClientSession | None = None++ async def _ensure_async_session(self) -> aiohttp.ClientSession:+ if self._async_session is None:+ self._async_session = aiohttp.ClientSession()+ return self._async_session++ def _get_headers(self) -> Dict[str, str]:+ if self._connection_info.token is None:+ return {}+ return {"Authorization": f"token {self._connection_info.token}"}++ def _get_api_base_url(self) -> str:+ protocol = "https" if self._connection_info.use_https else "http"+ port = f":{self._connection_info.port}" if self._connection_info.port else ""+ return f"{protocol}://{self._connection_info.host}{port}"++ def _get_ws_base_url(self) -> str:+ port = f":{self._connection_info.port}" if self._connection_info.port else ""+ return f"ws://{self._connection_info.host}{port}"++ async def list_kernel_specs(self) -> Dict[str, Dict[str, str]]:+ response = self._session.get(f"{self._get_api_base_url()}/api/kernelspecs", headers=self._get_headers())+ return cast(Dict[str, Dict[str, str]], response.json())++ async def list_kernels(self) -> List[Dict[str, str]]:+ response = self._session.get(f"{self._get_api_base_url()}/api/kernels", headers=self._get_headers())+ return cast(List[Dict[str, str]], response.json())++ async def start_kernel(self, kernel_spec_name: str) -> str:+ """Start a new kernel asynchronously.++ Args:+ kernel_spec_name (str): Name of the kernel spec to start++ Returns:+ str: ID of the started kernel+ """+ session = await self._ensure_async_session()+ async with session.post(+ f"{self._get_api_base_url()}/api/kernels",+ headers=self._get_headers(),+ json={"name": kernel_spec_name},+ ) as response:+ data = await response.json()+ return cast(str, data["id"])++ async def delete_kernel(self, kernel_id: str) -> None:+ session = await self._ensure_async_session()+ async with session.delete(+ f"{self._get_api_base_url()}/api/kernels/{kernel_id}", headers=self._get_headers()+ ) as response:+ response.raise_for_status()++ async def restart_kernel(self, kernel_id: str) -> None:+ session = await self._ensure_async_session()+ async with session.post(+ f"{self._get_api_base_url()}/api/kernels/{kernel_id}/restart", headers=self._get_headers()+ ) as response:+ response.raise_for_status()++ async def get_kernel_client(self, kernel_id: str) -> "JupyterKernelClient":+ ws_url = f"{self._get_ws_base_url()}/api/kernels/{kernel_id}/channels"+ # Using websockets library for async websocket connections+ ws = await websockets.connect(ws_url, additional_headers=self._get_headers())+ return JupyterKernelClient(ws)++ async def close(self) -> None:+ """Close the async session"""+ if self._async_session is not None:+ await self._async_session.close()+ self._async_session = None+ self._session.close()+++@dataclass+class DataItem:+ mime_type: str+ data: str+++@dataclass+class ExecutionResult:+ is_ok: bool+ output: str+ data_items: List[DataItem]+++class JupyterKernelClient:+ """An asynchronous client for communicating with a Jupyter kernel."""++ def __init__(self, websocket: websockets.ClientConnection) -> None:+ self._session_id = uuid.uuid4().hex+ self._websocket = websocket++ async def __aenter__(self) -> Self:+ return self++ async def __aexit__(+ self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType]+ ) -> None:+ await self.stop()++ async def stop(self) -> None:+ await self._websocket.close()++ async def _send_message(self, *, content: Dict[str, Any], channel: str, message_type: str) -> str:+ timestamp = datetime.datetime.now().isoformat()+ message_id = uuid.uuid4().hex+ message = {+ "header": {+ "username": "autogen",+ "version": "5.0",+ "session": self._session_id,+ "msg_id": message_id,+ "msg_type": message_type,+ "date": timestamp,+ },+ "parent_header": {},+ "channel": channel,+ "content": content,+ "metadata": {},+ "buffers": {},+ }+ await self._websocket.send(json.dumps(message))+ return message_id++ async def _receive_message(self, timeout_seconds: Optional[float]) -> Optional[Dict[str, Any]]:+ try:+ if timeout_seconds is not None:+ data = await asyncio.wait_for(self._websocket.recv(), timeout=timeout_seconds)+ else:+ data = await self._websocket.recv()+ if isinstance(data, bytes):+ return cast(Dict[str, Any], json.loads(data.decode("utf-8")))+ return cast(Dict[str, Any], json.loads(data))+ except asyncio.TimeoutError:+ return None++ async def wait_for_ready(self, timeout_seconds: Optional[float] = None) -> bool:+ message_id = await self._send_message(content={}, channel="shell", message_type="kernel_info_request")+ while True:+ message = await self._receive_message(timeout_seconds)+ # This means we timed out with no new messages.+ if message is None:+ return False+ if (+ message.get("parent_header", {}).get("msg_id") == message_id+ and message["msg_type"] == "kernel_info_reply"+ ):+ return True++ async def execute(self, code: str, timeout_seconds: Optional[float] = None) -> ExecutionResult:+ message_id = await self._send_message(+ content={+ "code": code,+ "silent": False,+ "store_history": True,+ "user_expressions": {},+ "allow_stdin": False,+ "stop_on_error": True,+ },+ channel="shell",+ message_type="execute_request",+ )++ text_output: List[str] = []+ data_output: List[DataItem] = []+ while True:+ message = await self._receive_message(timeout_seconds)+ if message is None:+ return ExecutionResult(+ is_ok=False, output="ERROR: Timeout waiting for output from code block.", data_items=[]+ )++ # Ignore messages that are not for this execution.+ if message.get("parent_header", {}).get("msg_id") != message_id:+ continue++ msg_type = message["msg_type"]+ content = message["content"]+ if msg_type in ["execute_result", "display_data"]:+ for data_type, data in content["data"].items():+ if data_type == "text/plain":+ text_output.append(data)+ elif data_type.startswith("image/") or data_type == "text/html":+ data_output.append(DataItem(mime_type=data_type, data=data))+ else:+ text_output.append(json.dumps(data))+ elif msg_type == "stream":+ text_output.append(content["text"])+ elif msg_type == "error":+ # Output is an error.+ return ExecutionResult(+ is_ok=False,+ output=f"ERROR: {content['ename']}: {content['evalue']}\n{content['traceback']}",+ data_items=[],+ )+ if msg_type == "status" and content["execution_state"] == "idle":+ break+ return ExecutionResult(+ is_ok=True, output="\n".join([str(output) for output in text_output]), data_items=data_output+ )+++class DockerJupyterServer(JupyterConnectable):+ DEFAULT_DOCKERFILE = """FROM quay.io/jupyter/docker-stacks-foundation++ SHELL ["/bin/bash", "-o", "pipefail", "-c"]++ USER ${NB_UID}+ RUN mamba install --yes jupyter_kernel_gateway ipykernel && \+ mamba clean --all -f -y && \+ fix-permissions "${CONDA_DIR}" && \+ fix-permissions "/home/${NB_USER}"++ ENV TOKEN="UNSET"+ CMD python -m jupyter kernelgateway --KernelGatewayApp.ip=0.0.0.0 \+ --KernelGatewayApp.port=8888 \+ --KernelGatewayApp.auth_token="${TOKEN}" \+ --JupyterApp.answer_yes=true \+ --JupyterWebsocketPersonality.list_kernels=true++ EXPOSE 8888++ WORKDIR "${HOME}"+ """++ class GenerateToken:+ pass++ def __init__(+ self,+ *,+ custom_image_name: Optional[str] = None,+ container_name: Optional[str] = None,+ auto_remove: bool = True,+ stop_container: bool = True,+ docker_env: Optional[Dict[str, str]] = None,+ expose_port: int = 8888,+ token: Optional[Union[str, GenerateToken]] = None,+ work_dir: Union[Path, str] = "/workspace",+ bind_dir: Optional[Union[Path, str]] = None,+ ):+ """Start a Jupyter kernel gateway server in a Docker container.++ Args:+ custom_image_name: Custom Docker image to use. If None, builds and uses bundled image.+ container_name: Name for the Docker container. Auto-generated if None.+ auto_remove: If True, container will be deleted when stopped.+ stop_container: If True, container stops on program exit or when context manager exits.+ docker_env: Additional environment variables for the container.+ expose_port: Port to expose for Jupyter connection.+ token: Authentication token. If GenerateToken, creates random token. Empty for no auth.+ work_dir: Working directory inside the container.+ bind_dir: Local directory to bind to container's work_dir.+ """+ # Generate container name if not provided+ container_name = container_name or f"autogen-jupyterkernelgateway-{uuid.uuid4()}"++ # Initialize Docker client+ client = docker.from_env()+ # Set up bind directory if specified+ self._bind_dir: Optional[Path] = None+ if bind_dir:+ self._bind_dir = Path(bind_dir) if isinstance(bind_dir, str) else bind_dir+ self._bind_dir.mkdir(exist_ok=True)+ os.chmod(bind_dir, 0o777)++ # Determine and prepare Docker image+ image_name = custom_image_name or "autogen-jupyterkernelgateway"+ if not custom_image_name:+ try:+ client.images.get(image_name)+ except docker.errors.ImageNotFound:+ # Build default image if not found+ here = Path(__file__).parent+ dockerfile = io.BytesIO(self.DEFAULT_DOCKERFILE.encode("utf-8"))+ logging.info(f"Building image {image_name}...")+ client.images.build(path=str(here), fileobj=dockerfile, tag=image_name)+ logging.info(f"Image {image_name} built successfully")+ else:+ # Verify custom image exists+ try:+ client.images.get(image_name)+ except docker.errors.ImageNotFound as err:+ raise ValueError(f"Custom image {image_name} does not exist") from err+ if docker_env is None:+ docker_env = {}+ if token is None:+ token = DockerJupyterServer.GenerateToken()+ # Set up authentication token+ self._token = secrets.token_hex(32) if isinstance(token, DockerJupyterServer.GenerateToken) else token++ # Prepare environment variables+ env = {"TOKEN": self._token}+ env.update(docker_env)++ # Define volume configuration if bind directory is specified+ volumes = {str(self._bind_dir): {"bind": str(work_dir), "mode": "rw"}} if self._bind_dir else None++ # Start the container+ container = client.containers.run(+ image_name,+ detach=True,+ auto_remove=auto_remove,+ environment=env,+ publish_all_ports=True,+ name=container_name,+ volumes=volumes,+ working_dir=str(work_dir),+ )++ # Wait for container to be ready+ self._wait_for_ready(container)++ # Store container information+ self._container = container+ self._port = int(container.ports[f"{expose_port}/tcp"][0]["HostPort"])+ self._container_id = container.id+ self._expose_port = expose_port++ if self._container_id is None:+ raise ValueError("Failed to obtain container id.")++ # Define cleanup function+ def cleanup() -> None:+ try:+ assert self._container_id is not None+ inner_container = client.containers.get(self._container_id)+ inner_container.stop()+ except docker.errors.NotFound:+ pass+ atexit.unregister(cleanup)++ # Register cleanup if container should be stopped automatically+ if stop_container:+ atexit.register(cleanup)++ self._cleanup_func = cleanup+ self._stop_container = stop_container++ @property+ def connection_info(self) -> JupyterConnectionInfo:+ return JupyterConnectionInfo(host="127.0.0.1", use_https=False, port=self._port, token=self._token)++ def _wait_for_ready(self, container: Any, timeout: int = 60, stop_time: float = 0.1) -> None:+ elapsed_time = 0.0+ while container.status != "running" and elapsed_time < timeout:+ sleep(stop_time)+ elapsed_time += stop_time+ container.reload()+ continue+ if container.status != "running":+ raise ValueError("Container failed to start")++ async def stop(self) -> None:+ loop = asyncio.get_event_loop()+ await loop.run_in_executor(None, self._cleanup_func)++ async def get_client(self) -> JupyterClient:+ return JupyterClient(self.connection_info)++ async def __aenter__(self) -> Self:+ return self++ async def __aexit__(+ self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType]+ ) -> None:+ await self.stop()diff --git a/python/packages/autogen-ext/tests/code_executors/test_docker_jupyter_code_executor.py b/python/packages/autogen-ext/tests/code_executors/test_docker_jupyter_code_executor.pynew file mode 100644index 000000000..ad4460a78--- /dev/null+++ b/python/packages/autogen-ext/tests/code_executors/test_docker_jupyter_code_executor.py@@ -0,0 +1,174 @@+import inspect+import os+import tempfile+from pathlib import Path+from typing import AsyncGenerator, TypeAlias++import pytest+import pytest_asyncio+from autogen_core import CancellationToken+from autogen_core.code_executor import CodeBlock+from autogen_ext.code_executors.docker_jupyter import (+ DockerJupyterCodeExecutor,+ DockerJupyterServer,+)+++def docker_tests_enabled() -> bool:+ if os.environ.get("SKIP_DOCKER", "unset").lower() == "true":+ return False++ try:+ import docker+ from docker.errors import DockerException+ except ImportError:+ return False++ try:+ client = docker.from_env()+ client.ping() # type: ignore+ return True+ except DockerException:+ return False+++@pytest_asyncio.fixture(scope="function") # type: ignore+async def executor_and_temp_dir(+ request: pytest.FixtureRequest,+) -> AsyncGenerator[tuple[DockerJupyterCodeExecutor, str], None]:+ if not docker_tests_enabled():+ pytest.skip("Docker tests are disabled")++ with tempfile.TemporaryDirectory() as temp_dir:+ async with DockerJupyterServer(bind_dir=temp_dir) as jupyter_server:+ async with DockerJupyterCodeExecutor(jupyter_server=jupyter_server) as executor:+ yield executor, temp_dir+++ExecutorFixture: TypeAlias = tuple[DockerJupyterCodeExecutor, str]++[email protected]("executor_and_temp_dir", ["docker"], indirect=True)+async def test_execute_code(executor_and_temp_dir: ExecutorFixture) -> None:+ executor, _temp_dir = executor_and_temp_dir+ # Test single code block.+ code_blocks = [CodeBlock(code="import sys; print('hello world!')", language="python")]+ code_result = await executor.execute_code_blocks(code_blocks, cancellation_token=CancellationToken())+ assert code_result.exit_code == 0 and "hello world!" in code_result.output++ # Test multiple code blocks.+ code_blocks = [+ CodeBlock(code="import sys; print('hello world!')", language="python"),+ CodeBlock(code="a = 100 + 100; print(a)", language="python"),+ ]+ code_result = await executor.execute_code_blocks(code_blocks, cancellation_token=CancellationToken())+ assert code_result.exit_code == 0 and "hello world!" in code_result.output and "200" in code_result.output++ # Test running code.+ file_lines = ["import sys", "print('hello world!')", "a = 100 + 100", "print(a)"]+ code_blocks = [CodeBlock(code="\n".join(file_lines), language="python")]+ code_result = await executor.execute_code_blocks(code_blocks, cancellation_token=CancellationToken())+ assert code_result.exit_code == 0 and "hello world!" in code_result.output and "200" in code_result.output++[email protected]("executor_and_temp_dir", ["docker"], indirect=True)+async def test_execute_code_and_persist_variable(executor_and_temp_dir: ExecutorFixture) -> None:+ with tempfile.TemporaryDirectory() as temp_dir:+ async with DockerJupyterServer(bind_dir=temp_dir) as jupyter_server:+ async with DockerJupyterCodeExecutor(jupyter_server=jupyter_server) as executor:+ code_blocks_first = [+ CodeBlock(code="a = 100 + 100; print(a)", language="python"),+ ]+ code_result_first = await executor.execute_code_blocks(+ code_blocks_first, cancellation_token=CancellationToken()+ )+ assert code_result_first.exit_code == 0 and "200" in code_result_first.output+ code_blocks_second = [+ CodeBlock(code="b = a + 100 ; print(b)", language="python"),+ ]+ code_result_second = await executor.execute_code_blocks(+ code_blocks_second, cancellation_token=CancellationToken()+ )+ assert code_result_second.exit_code == 0 and "300" in code_result_second.output++[email protected]("executor_and_temp_dir", ["docker"], indirect=True)+async def test_timeout(executor_and_temp_dir: ExecutorFixture) -> None:+ code_blocks = [CodeBlock(code="import time; time.sleep(10); print('hello world!')", language="python")]+ async with DockerJupyterServer() as jupyter_server:+ async with DockerJupyterCodeExecutor(jupyter_server=jupyter_server, timeout=1) as executor:+ code_result = await executor.execute_code_blocks(+ code_blocks=code_blocks, cancellation_token=CancellationToken()+ )++ assert code_result.exit_code and "Timeout" in code_result.output++[email protected]("executor_and_temp_dir", ["docker"], indirect=True)+async def test_canncellation(executor_and_temp_dir: ExecutorFixture) -> None:+ _executor, temp_dir = executor_and_temp_dir+ # Write code that sleep for 10 seconds and then write "hello world!"+ # to a file.+ code = """import time, os+time.sleep(10)+with open("hello.txt", "w") as f:+ f.write("hello world!")+ """+ code_blocks = [CodeBlock(code=code, language="python")]+ code_result = await _executor.execute_code_blocks(code_blocks, cancellation_token=CancellationToken())+ # Check if the file was created+ hello_file_path = Path(temp_dir) / "hello.txt"+ assert hello_file_path.exists() and code_result.exit_code == 0+++async def test_start_stop() -> None:+ if not docker_tests_enabled():+ pytest.skip("Docker tests are disabled")+ with tempfile.TemporaryDirectory() as temp_dir:+ jupyter_server = DockerJupyterServer(bind_dir=temp_dir)+ executor = DockerJupyterCodeExecutor(jupyter_server=jupyter_server)+ await executor.start()+ await executor.stop()+++async def test_invalid_timeout() -> None:+ if not docker_tests_enabled():+ pytest.skip("Docker tests are disabled")+ with pytest.raises(ValueError, match="Timeout must be greater than or equal to 1."):+ with tempfile.TemporaryDirectory() as temp_dir:+ async with DockerJupyterServer(bind_dir=temp_dir) as jupyter_server:+ _ = DockerJupyterCodeExecutor(jupyter_server=jupyter_server, timeout=0)+++async def test_execute_code_with_image_output() -> None:+ if not docker_tests_enabled():+ pytest.skip("Docker tests are disabled")+ with tempfile.TemporaryDirectory() as temp_dir:+ async with DockerJupyterServer(bind_dir=temp_dir) as jupyter_server:+ async with DockerJupyterCodeExecutor(jupyter_server=jupyter_server) as executor:+ code_blocks = [+ CodeBlock(+ code=inspect.cleandoc("""+ !pip install pillow+ from PIL import Image, ImageDraw+ img = Image.new("RGB", (100, 100), color="white")+ draw = ImageDraw.Draw(img)+ draw.rectangle((10, 10, 90, 90), outline="black", fill="blue")+ display(img)+ """),+ language="python",+ )+ ]++ code_result = await executor.execute_code_blocks(code_blocks, cancellation_token=CancellationToken())+ assert len(code_result.output_files) == 1+ assert code_result.exit_code == 0+ assert "<PIL.Image.Image image mode=RGB size=100x100>" in code_result.output+ assert str(Path(code_result.output_files[0]).parent) == temp_dirdiff --git a/python/uv.lock b/python/uv.lockindex 919821edd..45247d638 100644--- a/python/uv.lock+++ b/python/uv.lock@@ -145,7 +145,7 @@ wheels = [[[package]]name = "aiohttp"-version = "3.11.11"+version = "3.11.16"source = { registry = "https://pypi.org/simple" }dependencies = [{ name = "aiohappyeyeballs" },@@ -157,53 +157,56 @@ dependencies = [{ name = "propcache" },{ name = "yarl" },]-sdist = { url = "https://files.pythonhosted.org/packages/fe/ed/f26db39d29cd3cb2f5a3374304c713fe5ab5a0e4c8ee25a0c45cc6adf844/aiohttp-3.11.11.tar.gz", hash = "sha256:bb49c7f1e6ebf3821a42d81d494f538107610c3a705987f53068546b0e90303e", size = 7669618 }-wheels = [- { url = "https://files.pythonhosted.org/packages/75/7d/ff2e314b8f9e0b1df833e2d4778eaf23eae6b8cc8f922495d110ddcbf9e1/aiohttp-3.11.11-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:a60804bff28662cbcf340a4d61598891f12eea3a66af48ecfdc975ceec21e3c8", size = 708550 },- { url = "https://files.pythonhosted.org/packages/09/b8/aeb4975d5bba233d6f246941f5957a5ad4e3def8b0855a72742e391925f2/aiohttp-3.11.11-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:4b4fa1cb5f270fb3eab079536b764ad740bb749ce69a94d4ec30ceee1b5940d5", size = 468430 },- { url = "https://files.pythonhosted.org/packages/9c/5b/5b620279b3df46e597008b09fa1e10027a39467387c2332657288e25811a/aiohttp-3.11.11-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:731468f555656767cda219ab42e033355fe48c85fbe3ba83a349631541715ba2", size = 455593 },- { url = "https://files.pythonhosted.org/packages/d8/75/0cdf014b816867d86c0bc26f3d3e3f194198dbf33037890beed629cd4f8f/aiohttp-3.11.11-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cb23d8bb86282b342481cad4370ea0853a39e4a32a0042bb52ca6bdde132df43", size = 1584635 },- { url = "https://files.pythonhosted.org/packages/df/2f/95b8f4e4dfeb57c1d9ad9fa911ede35a0249d75aa339edd2c2270dc539da/aiohttp-3.11.11-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f047569d655f81cb70ea5be942ee5d4421b6219c3f05d131f64088c73bb0917f", size = 1632363 },- { url = "https://files.pythonhosted.org/packages/39/cb/70cf69ea7c50f5b0021a84f4c59c3622b2b3b81695f48a2f0e42ef7eba6e/aiohttp-3.11.11-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:dd7659baae9ccf94ae5fe8bfaa2c7bc2e94d24611528395ce88d009107e00c6d", size = 1668315 },- { url = "https://files.pythonhosted.org/packages/2f/cc/3a3fc7a290eabc59839a7e15289cd48f33dd9337d06e301064e1e7fb26c5/aiohttp-3.11.11-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:af01e42ad87ae24932138f154105e88da13ce7d202a6de93fafdafb2883a00ef", size = 1589546 },- { url = "https://files.pythonhosted.org/packages/15/b4/0f7b0ed41ac6000e283e7332f0f608d734b675a8509763ca78e93714cfb0/aiohttp-3.11.11-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:5854be2f3e5a729800bac57a8d76af464e160f19676ab6aea74bde18ad19d438", size = 1544581 },- { url = "https://files.pythonhosted.org/packages/58/b9/4d06470fd85c687b6b0e31935ef73dde6e31767c9576d617309a2206556f/aiohttp-3.11.11-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:6526e5fb4e14f4bbf30411216780c9967c20c5a55f2f51d3abd6de68320cc2f3", size = 1529256 },- { url = "https://files.pythonhosted.org/packages/61/a2/6958b1b880fc017fd35f5dfb2c26a9a50c755b75fd9ae001dc2236a4fb79/aiohttp-3.11.11-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:85992ee30a31835fc482468637b3e5bd085fa8fe9392ba0bdcbdc1ef5e9e3c55", size = 1536592 },- { url = "https://files.pythonhosted.org/packages/0f/dd/b974012a9551fd654f5bb95a6dd3f03d6e6472a17e1a8216dd42e9638d6c/aiohttp-3.11.11-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:88a12ad8ccf325a8a5ed80e6d7c3bdc247d66175afedbe104ee2aaca72960d8e", size = 1607446 },- { url = "https://files.pythonhosted.org/packages/e0/d3/6c98fd87e638e51f074a3f2061e81fcb92123bcaf1439ac1b4a896446e40/aiohttp-3.11.11-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:0a6d3fbf2232e3a08c41eca81ae4f1dff3d8f1a30bae415ebe0af2d2458b8a33", size = 1628809 },- { url = "https://files.pythonhosted.org/packages/a8/2e/86e6f85cbca02be042c268c3d93e7f35977a0e127de56e319bdd1569eaa8/aiohttp-3.11.11-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:84a585799c58b795573c7fa9b84c455adf3e1d72f19a2bf498b54a95ae0d194c", size = 1564291 },- { url = "https://files.pythonhosted.org/packages/0b/8d/1f4ef3503b767717f65e1f5178b0173ab03cba1a19997ebf7b052161189f/aiohttp-3.11.11-cp310-cp310-win32.whl", hash = "sha256:bfde76a8f430cf5c5584553adf9926534352251d379dcb266ad2b93c54a29745", size = 416601 },- { url = "https://files.pythonhosted.org/packages/ad/86/81cb83691b5ace3d9aa148dc42bacc3450d749fc88c5ec1973573c1c1779/aiohttp-3.11.11-cp310-cp310-win_amd64.whl", hash = "sha256:0fd82b8e9c383af11d2b26f27a478640b6b83d669440c0a71481f7c865a51da9", size = 442007 },- { url = "https://files.pythonhosted.org/packages/34/ae/e8806a9f054e15f1d18b04db75c23ec38ec954a10c0a68d3bd275d7e8be3/aiohttp-3.11.11-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:ba74ec819177af1ef7f59063c6d35a214a8fde6f987f7661f4f0eecc468a8f76", size = 708624 },- { url = "https://files.pythonhosted.org/packages/c7/e0/313ef1a333fb4d58d0c55a6acb3cd772f5d7756604b455181049e222c020/aiohttp-3.11.11-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:4af57160800b7a815f3fe0eba9b46bf28aafc195555f1824555fa2cfab6c1538", size = 468507 },- { url = "https://files.pythonhosted.org/packages/a9/60/03455476bf1f467e5b4a32a465c450548b2ce724eec39d69f737191f936a/aiohttp-3.11.11-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:ffa336210cf9cd8ed117011085817d00abe4c08f99968deef0013ea283547204", size = 455571 },- { url = "https://files.pythonhosted.org/packages/be/f9/469588603bd75bf02c8ffb8c8a0d4b217eed446b49d4a767684685aa33fd/aiohttp-3.11.11-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:81b8fe282183e4a3c7a1b72f5ade1094ed1c6345a8f153506d114af5bf8accd9", size = 1685694 },- { url = "https://files.pythonhosted.org/packages/88/b9/1b7fa43faf6c8616fa94c568dc1309ffee2b6b68b04ac268e5d64b738688/aiohttp-3.11.11-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3af41686ccec6a0f2bdc66686dc0f403c41ac2089f80e2214a0f82d001052c03", size = 1743660 },- { url = "https://files.pythonhosted.org/packages/2a/8b/0248d19dbb16b67222e75f6aecedd014656225733157e5afaf6a6a07e2e8/aiohttp-3.11.11-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:70d1f9dde0e5dd9e292a6d4d00058737052b01f3532f69c0c65818dac26dc287", size = 1785421 },- { url = "https://files.pythonhosted.org/packages/c4/11/f478e071815a46ca0a5ae974651ff0c7a35898c55063305a896e58aa1247/aiohttp-3.11.11-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:249cc6912405917344192b9f9ea5cd5b139d49e0d2f5c7f70bdfaf6b4dbf3a2e", size = 1675145 },- { url = "https://files.pythonhosted.org/packages/26/5d/284d182fecbb5075ae10153ff7374f57314c93a8681666600e3a9e09c505/aiohttp-3.11.11-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0eb98d90b6690827dcc84c246811feeb4e1eea683c0eac6caed7549be9c84665", size = 1619804 },- { url = "https://files.pythonhosted.org/packages/1b/78/980064c2ad685c64ce0e8aeeb7ef1e53f43c5b005edcd7d32e60809c4992/aiohttp-3.11.11-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:ec82bf1fda6cecce7f7b915f9196601a1bd1a3079796b76d16ae4cce6d0ef89b", size = 1654007 },- { url = "https://files.pythonhosted.org/packages/21/8d/9e658d63b1438ad42b96f94da227f2e2c1d5c6001c9e8ffcc0bfb22e9105/aiohttp-3.11.11-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:9fd46ce0845cfe28f108888b3ab17abff84ff695e01e73657eec3f96d72eef34", size = 1650022 },- { url = "https://files.pythonhosted.org/packages/85/fd/a032bf7f2755c2df4f87f9effa34ccc1ef5cea465377dbaeef93bb56bbd6/aiohttp-3.11.11-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:bd176afcf8f5d2aed50c3647d4925d0db0579d96f75a31e77cbaf67d8a87742d", size = 1732899 },- { url = "https://files.pythonhosted.org/packages/c5/0c/c2b85fde167dd440c7ba50af2aac20b5a5666392b174df54c00f888c5a75/aiohttp-3.11.11-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:ec2aa89305006fba9ffb98970db6c8221541be7bee4c1d027421d6f6df7d1ce2", size = 1755142 },- { url = "https://files.pythonhosted.org/packages/bc/78/91ae1a3b3b3bed8b893c5d69c07023e151b1c95d79544ad04cf68f596c2f/aiohttp-3.11.11-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:92cde43018a2e17d48bb09c79e4d4cb0e236de5063ce897a5e40ac7cb4878773", size = 1692736 },- { url = "https://files.pythonhosted.org/packages/77/89/a7ef9c4b4cdb546fcc650ca7f7395aaffbd267f0e1f648a436bec33c9b95/aiohttp-3.11.11-cp311-cp311-win32.whl", hash = "sha256:aba807f9569455cba566882c8938f1a549f205ee43c27b126e5450dc9f83cc62", size = 416418 },- { url = "https://files.pythonhosted.org/packages/fc/db/2192489a8a51b52e06627506f8ac8df69ee221de88ab9bdea77aa793aa6a/aiohttp-3.11.11-cp311-cp311-win_amd64.whl", hash = "sha256:ae545f31489548c87b0cced5755cfe5a5308d00407000e72c4fa30b19c3220ac", size = 442509 },- { url = "https://files.pythonhosted.org/packages/69/cf/4bda538c502f9738d6b95ada11603c05ec260807246e15e869fc3ec5de97/aiohttp-3.11.11-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:e595c591a48bbc295ebf47cb91aebf9bd32f3ff76749ecf282ea7f9f6bb73886", size = 704666 },- { url = "https://files.pythonhosted.org/packages/46/7b/87fcef2cad2fad420ca77bef981e815df6904047d0a1bd6aeded1b0d1d66/aiohttp-3.11.11-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:3ea1b59dc06396b0b424740a10a0a63974c725b1c64736ff788a3689d36c02d2", size = 464057 },- { url = "https://files.pythonhosted.org/packages/5a/a6/789e1f17a1b6f4a38939fbc39d29e1d960d5f89f73d0629a939410171bc0/aiohttp-3.11.11-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8811f3f098a78ffa16e0ea36dffd577eb031aea797cbdba81be039a4169e242c", size = 455996 },- { url = "https://files.pythonhosted.org/packages/b7/dd/485061fbfef33165ce7320db36e530cd7116ee1098e9c3774d15a732b3fd/aiohttp-3.11.11-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bd7227b87a355ce1f4bf83bfae4399b1f5bb42e0259cb9405824bd03d2f4336a", size = 1682367 },- { url = "https://files.pythonhosted.org/packages/e9/d7/9ec5b3ea9ae215c311d88b2093e8da17e67b8856673e4166c994e117ee3e/aiohttp-3.11.11-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d40f9da8cabbf295d3a9dae1295c69975b86d941bc20f0a087f0477fa0a66231", size = 1736989 },- { url = "https://files.pythonhosted.org/packages/d6/fb/ea94927f7bfe1d86178c9d3e0a8c54f651a0a655214cce930b3c679b8f64/aiohttp-3.11.11-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ffb3dc385f6bb1568aa974fe65da84723210e5d9707e360e9ecb51f59406cd2e", size = 1793265 },- { url = "https://files.pythonhosted.org/packages/40/7f/6de218084f9b653026bd7063cd8045123a7ba90c25176465f266976d8c82/aiohttp-3.11.11-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a8f5f7515f3552d899c61202d99dcb17d6e3b0de777900405611cd747cecd1b8", size = 1691841 },- { url = "https://files.pythonhosted.org/packages/77/e2/992f43d87831cbddb6b09c57ab55499332f60ad6fdbf438ff4419c2925fc/aiohttp-3.11.11-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3499c7ffbfd9c6a3d8d6a2b01c26639da7e43d47c7b4f788016226b1e711caa8", size = 1619317 },- { url = "https://files.pythonhosted.org/packages/96/74/879b23cdd816db4133325a201287c95bef4ce669acde37f8f1b8669e1755/aiohttp-3.11.11-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8e2bf8029dbf0810c7bfbc3e594b51c4cc9101fbffb583a3923aea184724203c", size = 1641416 },- { url = "https://files.pythonhosted.org/packages/30/98/b123f6b15d87c54e58fd7ae3558ff594f898d7f30a90899718f3215ad328/aiohttp-3.11.11-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:b6212a60e5c482ef90f2d788835387070a88d52cf6241d3916733c9176d39eab", size = 1646514 },- { url = "https://files.pythonhosted.org/packages/d7/38/257fda3dc99d6978ab943141d5165ec74fd4b4164baa15e9c66fa21da86b/aiohttp-3.11.11-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:d119fafe7b634dbfa25a8c597718e69a930e4847f0b88e172744be24515140da", size = 1702095 },- { url = "https://files.pythonhosted.org/packages/0c/f4/ddab089053f9fb96654df5505c0a69bde093214b3c3454f6bfdb1845f558/aiohttp-3.11.11-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:6fba278063559acc730abf49845d0e9a9e1ba74f85f0ee6efd5803f08b285853", size = 1734611 },- { url = "https://files.pythonhosted.org/packages/c3/d6/f30b2bc520c38c8aa4657ed953186e535ae84abe55c08d0f70acd72ff577/aiohttp-3.11.11-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:92fc484e34b733704ad77210c7957679c5c3877bd1e6b6d74b185e9320cc716e", size = 1694576 },- { url = "https://files.pythonhosted.org/packages/bc/97/b0a88c3f4c6d0020b34045ee6d954058abc870814f6e310c4c9b74254116/aiohttp-3.11.11-cp312-cp312-win32.whl", hash = "sha256:9f5b3c1ed63c8fa937a920b6c1bec78b74ee09593b3f5b979ab2ae5ef60d7600", size = 411363 },- { url = "https://files.pythonhosted.org/packages/7f/23/cc36d9c398980acaeeb443100f0216f50a7cfe20c67a9fd0a2f1a5a846de/aiohttp-3.11.11-cp312-cp312-win_amd64.whl", hash = "sha256:1e69966ea6ef0c14ee53ef7a3d68b564cc408121ea56c0caa2dc918c1b2f553d", size = 437666 },+sdist = { url = "https://files.pythonhosted.org/packages/f1/d9/1c4721d143e14af753f2bf5e3b681883e1f24b592c0482df6fa6e33597fa/aiohttp-3.11.16.tar.gz", hash = "sha256:16f8a2c9538c14a557b4d309ed4d0a7c60f0253e8ed7b6c9a2859a7582f8b1b8", size = 7676826 }+wheels = [+ { url = "https://files.pythonhosted.org/packages/b8/21/6bd4cb580a323b64cda3b11fcb3f68deba77568e97806727a858de57349d/aiohttp-3.11.16-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:fb46bb0f24813e6cede6cc07b1961d4b04f331f7112a23b5e21f567da4ee50aa", size = 708259 },+ { url = "https://files.pythonhosted.org/packages/96/8c/7b4b9debe90ffc31931b85ee8612a5c83f34d8fdc6d90ee3eb27b43639e4/aiohttp-3.11.16-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:54eb3aead72a5c19fad07219acd882c1643a1027fbcdefac9b502c267242f955", size = 468886 },+ { url = "https://files.pythonhosted.org/packages/13/da/a7fcd68e62acacf0a1930060afd2c970826f989265893082b6fb9eb25cb5/aiohttp-3.11.16-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:38bea84ee4fe24ebcc8edeb7b54bf20f06fd53ce4d2cc8b74344c5b9620597fd", size = 455846 },+ { url = "https://files.pythonhosted.org/packages/5d/12/b73d9423253f4c872d276a3771decb0722cb5f962352593bd617445977ba/aiohttp-3.11.16-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d0666afbe984f6933fe72cd1f1c3560d8c55880a0bdd728ad774006eb4241ecd", size = 1587183 },+ { url = "https://files.pythonhosted.org/packages/75/d3/291b57d54719d996e6cb8c1db8b13d01bdb24dca90434815ac7e6a70393f/aiohttp-3.11.16-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7ba92a2d9ace559a0a14b03d87f47e021e4fa7681dc6970ebbc7b447c7d4b7cd", size = 1634937 },+ { url = "https://files.pythonhosted.org/packages/be/85/4229eba92b433173065b0b459ab677ca11ead4a179f76ccfe55d8738b188/aiohttp-3.11.16-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3ad1d59fd7114e6a08c4814983bb498f391c699f3c78712770077518cae63ff7", size = 1667980 },+ { url = "https://files.pythonhosted.org/packages/2b/0d/d2423936962e3c711fafd5bb9172a99e6b07dd63e086515aa957d8a991fd/aiohttp-3.11.16-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:98b88a2bf26965f2015a771381624dd4b0839034b70d406dc74fd8be4cc053e3", size = 1590365 },+ { url = "https://files.pythonhosted.org/packages/ea/93/04209affc20834982c1ef4214b1afc07743667998a9975d69413e9c1e1c1/aiohttp-3.11.16-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:576f5ca28d1b3276026f7df3ec841ae460e0fc3aac2a47cbf72eabcfc0f102e1", size = 1547614 },+ { url = "https://files.pythonhosted.org/packages/f6/fb/194ad4e4cae98023ae19556e576347f402ce159e80d74cc0713d460c4a39/aiohttp-3.11.16-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:a2a450bcce4931b295fc0848f384834c3f9b00edfc2150baafb4488c27953de6", size = 1532815 },+ { url = "https://files.pythonhosted.org/packages/33/6d/a4da7adbac90188bf1228c73b6768a607dd279c146721a9ff7dcb75c5ac6/aiohttp-3.11.16-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:37dcee4906454ae377be5937ab2a66a9a88377b11dd7c072df7a7c142b63c37c", size = 1559005 },+ { url = "https://files.pythonhosted.org/packages/7e/88/2fa9fbfd23fc16cb2cfdd1f290343e085e7e327438041e9c6aa0208a854d/aiohttp-3.11.16-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:4d0c970c0d602b1017e2067ff3b7dac41c98fef4f7472ec2ea26fd8a4e8c2149", size = 1535231 },+ { url = "https://files.pythonhosted.org/packages/f5/8f/9623cd2558e3e182d02dcda8b480643e1c48a0550a86e3050210e98dba27/aiohttp-3.11.16-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:004511d3413737700835e949433536a2fe95a7d0297edd911a1e9705c5b5ea43", size = 1609985 },+ { url = "https://files.pythonhosted.org/packages/f8/a2/53a8d1bfc67130710f1c8091f623cdefe7f85cd5d09e14637ed2ed6e1a6d/aiohttp-3.11.16-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:c15b2271c44da77ee9d822552201180779e5e942f3a71fb74e026bf6172ff287", size = 1628842 },+ { url = "https://files.pythonhosted.org/packages/49/3a/35fb43d07489573c6c1f8c6a3e6c657196124a63223705b7feeddaea06f1/aiohttp-3.11.16-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:ad9509ffb2396483ceacb1eee9134724443ee45b92141105a4645857244aecc8", size = 1566929 },+ { url = "https://files.pythonhosted.org/packages/d5/82/bb3f4f2cc7677e790ba4c040db7dd8445c234a810ef893a858e217647d38/aiohttp-3.11.16-cp310-cp310-win32.whl", hash = "sha256:634d96869be6c4dc232fc503e03e40c42d32cfaa51712aee181e922e61d74814", size = 416935 },+ { url = "https://files.pythonhosted.org/packages/df/ad/a64db1c18063569d6dff474c46a7d4de7ab85ff55e2a35839b149b1850ea/aiohttp-3.11.16-cp310-cp310-win_amd64.whl", hash = "sha256:938f756c2b9374bbcc262a37eea521d8a0e6458162f2a9c26329cc87fdf06534", size = 442168 },+ { url = "https://files.pythonhosted.org/packages/b1/98/be30539cd84260d9f3ea1936d50445e25aa6029a4cb9707f3b64cfd710f7/aiohttp-3.11.16-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:8cb0688a8d81c63d716e867d59a9ccc389e97ac7037ebef904c2b89334407180", size = 708664 },+ { url = "https://files.pythonhosted.org/packages/e6/27/d51116ce18bdfdea7a2244b55ad38d7b01a4298af55765eed7e8431f013d/aiohttp-3.11.16-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:0ad1fb47da60ae1ddfb316f0ff16d1f3b8e844d1a1e154641928ea0583d486ed", size = 468953 },+ { url = "https://files.pythonhosted.org/packages/34/23/eedf80ec42865ea5355b46265a2433134138eff9a4fea17e1348530fa4ae/aiohttp-3.11.16-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:df7db76400bf46ec6a0a73192b14c8295bdb9812053f4fe53f4e789f3ea66bbb", size = 456065 },+ { url = "https://files.pythonhosted.org/packages/36/23/4a5b1ef6cff994936bf96d981dd817b487d9db755457a0d1c2939920d620/aiohttp-3.11.16-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cc3a145479a76ad0ed646434d09216d33d08eef0d8c9a11f5ae5cdc37caa3540", size = 1687976 },+ { url = "https://files.pythonhosted.org/packages/d0/5d/c7474b4c3069bb35276d54c82997dff4f7575e4b73f0a7b1b08a39ece1eb/aiohttp-3.11.16-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d007aa39a52d62373bd23428ba4a2546eed0e7643d7bf2e41ddcefd54519842c", size = 1752711 },+ { url = "https://files.pythonhosted.org/packages/64/4c/ee416987b6729558f2eb1b727c60196580aafdb141e83bd78bb031d1c000/aiohttp-3.11.16-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f6ddd90d9fb4b501c97a4458f1c1720e42432c26cb76d28177c5b5ad4e332601", size = 1791305 },+ { url = "https://files.pythonhosted.org/packages/58/28/3e1e1884070b95f1f69c473a1995852a6f8516670bb1c29d6cb2dbb73e1c/aiohttp-3.11.16-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0a2f451849e6b39e5c226803dcacfa9c7133e9825dcefd2f4e837a2ec5a3bb98", size = 1674499 },+ { url = "https://files.pythonhosted.org/packages/ad/55/a032b32fa80a662d25d9eb170ed1e2c2be239304ca114ec66c89dc40f37f/aiohttp-3.11.16-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8df6612df74409080575dca38a5237282865408016e65636a76a2eb9348c2567", size = 1622313 },+ { url = "https://files.pythonhosted.org/packages/b1/df/ca775605f72abbda4e4746e793c408c84373ca2c6ce7a106a09f853f1e89/aiohttp-3.11.16-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:78e6e23b954644737e385befa0deb20233e2dfddf95dd11e9db752bdd2a294d3", size = 1658274 },+ { url = "https://files.pythonhosted.org/packages/cc/6c/21c45b66124df5b4b0ab638271ecd8c6402b702977120cb4d5be6408e15d/aiohttp-3.11.16-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:696ef00e8a1f0cec5e30640e64eca75d8e777933d1438f4facc9c0cdf288a810", size = 1666704 },+ { url = "https://files.pythonhosted.org/packages/1d/e2/7d92adc03e3458edd18a21da2575ab84e58f16b1672ae98529e4eeee45ab/aiohttp-3.11.16-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:e3538bc9fe1b902bef51372462e3d7c96fce2b566642512138a480b7adc9d508", size = 1652815 },+ { url = "https://files.pythonhosted.org/packages/3a/52/7549573cd654ad651e3c5786ec3946d8f0ee379023e22deb503ff856b16c/aiohttp-3.11.16-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:3ab3367bb7f61ad18793fea2ef71f2d181c528c87948638366bf1de26e239183", size = 1735669 },+ { url = "https://files.pythonhosted.org/packages/d5/54/dcd24a23c7a5a2922123e07a296a5f79ea87ce605f531be068415c326de6/aiohttp-3.11.16-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:56a3443aca82abda0e07be2e1ecb76a050714faf2be84256dae291182ba59049", size = 1760422 },+ { url = "https://files.pythonhosted.org/packages/a7/53/87327fe982fa310944e1450e97bf7b2a28015263771931372a1dfe682c58/aiohttp-3.11.16-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:61c721764e41af907c9d16b6daa05a458f066015abd35923051be8705108ed17", size = 1694457 },+ { url = "https://files.pythonhosted.org/packages/ce/6d/c5ccf41059267bcf89853d3db9d8d217dacf0a04f4086cb6bf278323011f/aiohttp-3.11.16-cp311-cp311-win32.whl", hash = "sha256:3e061b09f6fa42997cf627307f220315e313ece74907d35776ec4373ed718b86", size = 416817 },+ { url = "https://files.pythonhosted.org/packages/e7/dd/01f6fe028e054ef4f909c9d63e3a2399e77021bb2e1bb51d56ca8b543989/aiohttp-3.11.16-cp311-cp311-win_amd64.whl", hash = "sha256:745f1ed5e2c687baefc3c5e7b4304e91bf3e2f32834d07baaee243e349624b24", size = 442986 },+ { url = "https://files.pythonhosted.org/packages/db/38/100d01cbc60553743baf0fba658cb125f8ad674a8a771f765cdc155a890d/aiohttp-3.11.16-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:911a6e91d08bb2c72938bc17f0a2d97864c531536b7832abee6429d5296e5b27", size = 704881 },+ { url = "https://files.pythonhosted.org/packages/21/ed/b4102bb6245e36591209e29f03fe87e7956e54cb604ee12e20f7eb47f994/aiohttp-3.11.16-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:6ac13b71761e49d5f9e4d05d33683bbafef753e876e8e5a7ef26e937dd766713", size = 464564 },+ { url = "https://files.pythonhosted.org/packages/3b/e1/a9ab6c47b62ecee080eeb33acd5352b40ecad08fb2d0779bcc6739271745/aiohttp-3.11.16-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fd36c119c5d6551bce374fcb5c19269638f8d09862445f85a5a48596fd59f4bb", size = 456548 },+ { url = "https://files.pythonhosted.org/packages/80/ad/216c6f71bdff2becce6c8776f0aa32cb0fa5d83008d13b49c3208d2e4016/aiohttp-3.11.16-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d489d9778522fbd0f8d6a5c6e48e3514f11be81cb0a5954bdda06f7e1594b321", size = 1691749 },+ { url = "https://files.pythonhosted.org/packages/bd/ea/7df7bcd3f4e734301605f686ffc87993f2d51b7acb6bcc9b980af223f297/aiohttp-3.11.16-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:69a2cbd61788d26f8f1e626e188044834f37f6ae3f937bd9f08b65fc9d7e514e", size = 1736874 },+ { url = "https://files.pythonhosted.org/packages/51/41/c7724b9c87a29b7cfd1202ec6446bae8524a751473d25e2ff438bc9a02bf/aiohttp-3.11.16-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cd464ba806e27ee24a91362ba3621bfc39dbbb8b79f2e1340201615197370f7c", size = 1786885 },+ { url = "https://files.pythonhosted.org/packages/86/b3/f61f8492fa6569fa87927ad35a40c159408862f7e8e70deaaead349e2fba/aiohttp-3.11.16-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1ce63ae04719513dd2651202352a2beb9f67f55cb8490c40f056cea3c5c355ce", size = 1698059 },+ { url = "https://files.pythonhosted.org/packages/ce/be/7097cf860a9ce8bbb0e8960704e12869e111abcd3fbd245153373079ccec/aiohttp-3.11.16-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:09b00dd520d88eac9d1768439a59ab3d145065c91a8fab97f900d1b5f802895e", size = 1626527 },+ { url = "https://files.pythonhosted.org/packages/1d/1d/aaa841c340e8c143a8d53a1f644c2a2961c58cfa26e7b398d6bf75cf5d23/aiohttp-3.11.16-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:7f6428fee52d2bcf96a8aa7b62095b190ee341ab0e6b1bcf50c615d7966fd45b", size = 1644036 },+ { url = "https://files.pythonhosted.org/packages/2c/88/59d870f76e9345e2b149f158074e78db457985c2b4da713038d9da3020a8/aiohttp-3.11.16-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:13ceac2c5cdcc3f64b9015710221ddf81c900c5febc505dbd8f810e770011540", size = 1685270 },+ { url = "https://files.pythonhosted.org/packages/2b/b1/c6686948d4c79c3745595efc469a9f8a43cab3c7efc0b5991be65d9e8cb8/aiohttp-3.11.16-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:fadbb8f1d4140825069db3fedbbb843290fd5f5bc0a5dbd7eaf81d91bf1b003b", size = 1650852 },+ { url = "https://files.pythonhosted.org/packages/fe/94/3e42a6916fd3441721941e0f1b8438e1ce2a4c49af0e28e0d3c950c9b3c9/aiohttp-3.11.16-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:6a792ce34b999fbe04a7a71a90c74f10c57ae4c51f65461a411faa70e154154e", size = 1704481 },+ { url = "https://files.pythonhosted.org/packages/b1/6d/6ab5854ff59b27075c7a8c610597d2b6c38945f9a1284ee8758bc3720ff6/aiohttp-3.11.16-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:f4065145bf69de124accdd17ea5f4dc770da0a6a6e440c53f6e0a8c27b3e635c", size = 1735370 },+ { url = "https://files.pythonhosted.org/packages/73/2a/08a68eec3c99a6659067d271d7553e4d490a0828d588e1daa3970dc2b771/aiohttp-3.11.16-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fa73e8c2656a3653ae6c307b3f4e878a21f87859a9afab228280ddccd7369d71", size = 1697619 },+ { url = "https://files.pythonhosted.org/packages/61/d5/fea8dbbfb0cd68fbb56f0ae913270a79422d9a41da442a624febf72d2aaf/aiohttp-3.11.16-cp312-cp312-win32.whl", hash = "sha256:f244b8e541f414664889e2c87cac11a07b918cb4b540c36f7ada7bfa76571ea2", size = 411710 },+ { url = "https://files.pythonhosted.org/packages/33/fb/41cde15fbe51365024550bf77b95a4fc84ef41365705c946da0421f0e1e0/aiohttp-3.11.16-cp312-cp312-win_amd64.whl", hash = "sha256:23a15727fbfccab973343b6d1b7181bfb0b4aa7ae280f36fd2f90f5476805682", size = 438012 },][[package]]@@ -608,6 +611,13 @@ docker = [{ name = "asyncio-atexit" },{ name = "docker" },]+docker-jupyter-executor = [+ { name = "aiohttp" },+ { name = "asyncio-atexit" },+ { name = "docker" },+ { name = "requests" },+ { name = "websockets" },+]file-surfer = [{ name = "autogen-agentchat" },{ name = "magika" },@@ -723,8 +733,10 @@ dev = [[package.metadata]requires-dist = [{ name = "aiofiles", marker = "extra == 'openai'" },+ { name = "aiohttp", marker = "extra == 'docker-jupyter-executor'", specifier = ">=3.11.16" },{ name = "anthropic", marker = "extra == 'anthropic'", specifier = ">=0.48" },{ name = "asyncio-atexit", marker = "extra == 'docker'", specifier = ">=1.0.1" },+ { name = "asyncio-atexit", marker = "extra == 'docker-jupyter-executor'", specifier = ">=1.0.1" },{ name = "autogen-agentchat", marker = "extra == 'file-surfer'", editable = "packages/autogen-agentchat" },{ name = "autogen-agentchat", marker = "extra == 'magentic-one'", editable = "packages/autogen-agentchat" },{ name = "autogen-agentchat", marker = "extra == 'video-surfer'", editable = "packages/autogen-agentchat" },@@ -738,6 +750,7 @@ requires-dist = [{ name = "chromadb", marker = "extra == 'task-centric-memory'", specifier = ">=1.0.0" },{ name = "diskcache", marker = "extra == 'diskcache'", specifier = ">=5.6.3" },{ name = "docker", marker = "extra == 'docker'", specifier = "~=7.0" },+ { name = "docker", marker = "extra == 'docker-jupyter-executor'", specifier = "~=7.0" },{ name = "ffmpeg-python", marker = "extra == 'video-surfer'" },{ name = "google-genai", marker = "extra == 'gemini'", specifier = ">=1.0.0" },{ name = "graphrag", marker = "extra == 'graphrag'", specifier = ">=1.0.1" },@@ -764,6 +777,7 @@ requires-dist = [{ name = "playwright", marker = "extra == 'magentic-one'", specifier = ">=1.48.0" },{ name = "playwright", marker = "extra == 'web-surfer'", specifier = ">=1.48.0" },{ name = "redis", marker = "extra == 'redis'", specifier = ">=5.2.1" },+ { name = "requests", marker = "extra == 'docker-jupyter-executor'", specifier = ">=2.32.3" },{ name = "rich", marker = "extra == 'rich'", specifier = ">=13.9.4" },{ name = "semantic-kernel", marker = "extra == 'semantic-kernel-core'", specifier = ">=1.17.1" },{ name = "semantic-kernel", extras = ["anthropic"], marker = "extra == 'semantic-kernel-anthropic'", specifier = ">=1.17.1" },@@ -778,6 +792,7 @@ requires-dist = [{ name = "semantic-kernel", extras = ["pandas"], marker = "extra == 'semantic-kernel-pandas'", specifier = ">=1.17.1" },{ name = "tiktoken", marker = "extra == 'ollama'", specifier = ">=0.8.0" },{ name = "tiktoken", marker = "extra == 'openai'", specifier = ">=0.8.0" },+ { name = "websockets", marker = "extra == 'docker-jupyter-executor'", specifier = ">=15.0.1" },][package.metadata.requires-dev]@@ -2416,16 +2431,20 @@ wheels = [[[package]]name = "google-genai"-version = "1.1.0"+version = "1.11.0"source = { registry = "https://pypi.org/simple" }dependencies = [+ { name = "anyio" },{ name = "google-auth" },+ { name = "httpx" },{ name = "pydantic" },{ name = "requests" },+ { name = "typing-extensions" },{ name = "websockets" },]+sdist = { url = "https://files.pythonhosted.org/packages/73/44/64c6c23724580add879cbcca81ffed500955c1c21850468cd4dcf9c62a03/google_genai-1.11.0.tar.gz", hash = "sha256:0643b2f5373fbeae945d0cd5a37d157eab0c172bb5e14e905f2f8d45aa51cabb", size = 160955 }wheels = [- { url = "https://files.pythonhosted.org/packages/6b/30/25443d2dec5fe4efd9f05440e13735ae68b19de2dea043b3b83a91a4e14b/google_genai-1.1.0-py3-none-any.whl", hash = "sha256:c48ac44612ad6aadc0bf96b12fa4314756baa16382c890fff793bcb53e9a9cc8", size = 130299 },+ { url = "https://files.pythonhosted.org/packages/dc/9b/55f97203720cbda5a1c8e0460793914980e41c6ca4859fea735dd66d2c3a/google_genai-1.11.0-py3-none-any.whl", hash = "sha256:34fbe3c85419adbcddcb8222f99514596b3a69c80ff1a4ae30a01a763da27acc", size = 159687 },][[package]]@@ -8137,50 +8156,50 @@ wheels = [[[package]]name = "websockets"-version = "14.2"-source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/94/54/8359678c726243d19fae38ca14a334e740782336c9f19700858c4eb64a1e/websockets-14.2.tar.gz", hash = "sha256:5059ed9c54945efb321f097084b4c7e52c246f2c869815876a69d1efc4ad6eb5", size = 164394 }-wheels = [- { url = "https://files.pythonhosted.org/packages/28/fa/76607eb7dcec27b2d18d63f60a32e60e2b8629780f343bb83a4dbb9f4350/websockets-14.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:e8179f95323b9ab1c11723e5d91a89403903f7b001828161b480a7810b334885", size = 163089 },- { url = "https://files.pythonhosted.org/packages/9e/00/ad2246b5030575b79e7af0721810fdaecaf94c4b2625842ef7a756fa06dd/websockets-14.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:0d8c3e2cdb38f31d8bd7d9d28908005f6fa9def3324edb9bf336d7e4266fd397", size = 160741 },- { url = "https://files.pythonhosted.org/packages/72/f7/60f10924d333a28a1ff3fcdec85acf226281331bdabe9ad74947e1b7fc0a/websockets-14.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:714a9b682deb4339d39ffa674f7b674230227d981a37d5d174a4a83e3978a610", size = 160996 },- { url = "https://files.pythonhosted.org/packages/63/7c/c655789cf78648c01ac6ecbe2d6c18f91b75bdc263ffee4d08ce628d12f0/websockets-14.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f2e53c72052f2596fb792a7acd9704cbc549bf70fcde8a99e899311455974ca3", size = 169974 },- { url = "https://files.pythonhosted.org/packages/fb/5b/013ed8b4611857ac92ac631079c08d9715b388bd1d88ec62e245f87a39df/websockets-14.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e3fbd68850c837e57373d95c8fe352203a512b6e49eaae4c2f4088ef8cf21980", size = 168985 },- { url = "https://files.pythonhosted.org/packages/cd/33/aa3e32fd0df213a5a442310754fe3f89dd87a0b8e5b4e11e0991dd3bcc50/websockets-14.2-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4b27ece32f63150c268593d5fdb82819584831a83a3f5809b7521df0685cd5d8", size = 169297 },- { url = "https://files.pythonhosted.org/packages/93/17/dae0174883d6399f57853ac44abf5f228eaba86d98d160f390ffabc19b6e/websockets-14.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:4daa0faea5424d8713142b33825fff03c736f781690d90652d2c8b053345b0e7", size = 169677 },- { url = "https://files.pythonhosted.org/packages/42/e2/0375af7ac00169b98647c804651c515054b34977b6c1354f1458e4116c1e/websockets-14.2-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:bc63cee8596a6ec84d9753fd0fcfa0452ee12f317afe4beae6b157f0070c6c7f", size = 169089 },- { url = "https://files.pythonhosted.org/packages/73/8d/80f71d2a351a44b602859af65261d3dde3a0ce4e76cf9383738a949e0cc3/websockets-14.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:7a570862c325af2111343cc9b0257b7119b904823c675b22d4ac547163088d0d", size = 169026 },- { url = "https://files.pythonhosted.org/packages/48/97/173b1fa6052223e52bb4054a141433ad74931d94c575e04b654200b98ca4/websockets-14.2-cp310-cp310-win32.whl", hash = "sha256:75862126b3d2d505e895893e3deac0a9339ce750bd27b4ba515f008b5acf832d", size = 163967 },- { url = "https://files.pythonhosted.org/packages/c0/5b/2fcf60f38252a4562b28b66077e0d2b48f91fef645d5f78874cd1dec807b/websockets-14.2-cp310-cp310-win_amd64.whl", hash = "sha256:cc45afb9c9b2dc0852d5c8b5321759cf825f82a31bfaf506b65bf4668c96f8b2", size = 164413 },- { url = "https://files.pythonhosted.org/packages/15/b6/504695fb9a33df0ca56d157f5985660b5fc5b4bf8c78f121578d2d653392/websockets-14.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:3bdc8c692c866ce5fefcaf07d2b55c91d6922ac397e031ef9b774e5b9ea42166", size = 163088 },- { url = "https://files.pythonhosted.org/packages/81/26/ebfb8f6abe963c795122439c6433c4ae1e061aaedfc7eff32d09394afbae/websockets-14.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:c93215fac5dadc63e51bcc6dceca72e72267c11def401d6668622b47675b097f", size = 160745 },- { url = "https://files.pythonhosted.org/packages/a1/c6/1435ad6f6dcbff80bb95e8986704c3174da8866ddb751184046f5c139ef6/websockets-14.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:1c9b6535c0e2cf8a6bf938064fb754aaceb1e6a4a51a80d884cd5db569886910", size = 160995 },- { url = "https://files.pythonhosted.org/packages/96/63/900c27cfe8be1a1f2433fc77cd46771cf26ba57e6bdc7cf9e63644a61863/websockets-14.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0a52a6d7cf6938e04e9dceb949d35fbdf58ac14deea26e685ab6368e73744e4c", size = 170543 },- { url = "https://files.pythonhosted.org/packages/00/8b/bec2bdba92af0762d42d4410593c1d7d28e9bfd952c97a3729df603dc6ea/websockets-14.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9f05702e93203a6ff5226e21d9b40c037761b2cfb637187c9802c10f58e40473", size = 169546 },- { url = "https://files.pythonhosted.org/packages/6b/a9/37531cb5b994f12a57dec3da2200ef7aadffef82d888a4c29a0d781568e4/websockets-14.2-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:22441c81a6748a53bfcb98951d58d1af0661ab47a536af08920d129b4d1c3473", size = 169911 },- { url = "https://files.pythonhosted.org/packages/60/d5/a6eadba2ed9f7e65d677fec539ab14a9b83de2b484ab5fe15d3d6d208c28/websockets-14.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:efd9b868d78b194790e6236d9cbc46d68aba4b75b22497eb4ab64fa640c3af56", size = 170183 },- { url = "https://files.pythonhosted.org/packages/76/57/a338ccb00d1df881c1d1ee1f2a20c9c1b5b29b51e9e0191ee515d254fea6/websockets-14.2-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:1a5a20d5843886d34ff8c57424cc65a1deda4375729cbca4cb6b3353f3ce4142", size = 169623 },- { url = "https://files.pythonhosted.org/packages/64/22/e5f7c33db0cb2c1d03b79fd60d189a1da044e2661f5fd01d629451e1db89/websockets-14.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:34277a29f5303d54ec6468fb525d99c99938607bc96b8d72d675dee2b9f5bf1d", size = 169583 },- { url = "https://files.pythonhosted.org/packages/aa/2e/2b4662237060063a22e5fc40d46300a07142afe30302b634b4eebd717c07/websockets-14.2-cp311-cp311-win32.whl", hash = "sha256:02687db35dbc7d25fd541a602b5f8e451a238ffa033030b172ff86a93cb5dc2a", size = 163969 },- { url = "https://files.pythonhosted.org/packages/94/a5/0cda64e1851e73fc1ecdae6f42487babb06e55cb2f0dc8904b81d8ef6857/websockets-14.2-cp311-cp311-win_amd64.whl", hash = "sha256:862e9967b46c07d4dcd2532e9e8e3c2825e004ffbf91a5ef9dde519ee2effb0b", size = 164408 },- { url = "https://files.pythonhosted.org/packages/c1/81/04f7a397653dc8bec94ddc071f34833e8b99b13ef1a3804c149d59f92c18/websockets-14.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:1f20522e624d7ffbdbe259c6b6a65d73c895045f76a93719aa10cd93b3de100c", size = 163096 },- { url = "https://files.pythonhosted.org/packages/ec/c5/de30e88557e4d70988ed4d2eabd73fd3e1e52456b9f3a4e9564d86353b6d/websockets-14.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:647b573f7d3ada919fd60e64d533409a79dcf1ea21daeb4542d1d996519ca967", size = 160758 },- { url = "https://files.pythonhosted.org/packages/e5/8c/d130d668781f2c77d106c007b6c6c1d9db68239107c41ba109f09e6c218a/websockets-14.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6af99a38e49f66be5a64b1e890208ad026cda49355661549c507152113049990", size = 160995 },- { url = "https://files.pythonhosted.org/packages/a6/bc/f6678a0ff17246df4f06765e22fc9d98d1b11a258cc50c5968b33d6742a1/websockets-14.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:091ab63dfc8cea748cc22c1db2814eadb77ccbf82829bac6b2fbe3401d548eda", size = 170815 },- { url = "https://files.pythonhosted.org/packages/d8/b2/8070cb970c2e4122a6ef38bc5b203415fd46460e025652e1ee3f2f43a9a3/websockets-14.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b374e8953ad477d17e4851cdc66d83fdc2db88d9e73abf755c94510ebddceb95", size = 169759 },- { url = "https://files.pythonhosted.org/packages/81/da/72f7caabd94652e6eb7e92ed2d3da818626e70b4f2b15a854ef60bf501ec/websockets-14.2-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a39d7eceeea35db85b85e1169011bb4321c32e673920ae9c1b6e0978590012a3", size = 170178 },- { url = "https://files.pythonhosted.org/packages/31/e0/812725b6deca8afd3a08a2e81b3c4c120c17f68c9b84522a520b816cda58/websockets-14.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:0a6f3efd47ffd0d12080594f434faf1cd2549b31e54870b8470b28cc1d3817d9", size = 170453 },- { url = "https://files.pythonhosted.org/packages/66/d3/8275dbc231e5ba9bb0c4f93144394b4194402a7a0c8ffaca5307a58ab5e3/websockets-14.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:065ce275e7c4ffb42cb738dd6b20726ac26ac9ad0a2a48e33ca632351a737267", size = 169830 },- { url = "https://files.pythonhosted.org/packages/a3/ae/e7d1a56755ae15ad5a94e80dd490ad09e345365199600b2629b18ee37bc7/websockets-14.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e9d0e53530ba7b8b5e389c02282f9d2aa47581514bd6049d3a7cffe1385cf5fe", size = 169824 },- { url = "https://files.pythonhosted.org/packages/b6/32/88ccdd63cb261e77b882e706108d072e4f1c839ed723bf91a3e1f216bf60/websockets-14.2-cp312-cp312-win32.whl", hash = "sha256:20e6dd0984d7ca3037afcb4494e48c74ffb51e8013cac71cf607fffe11df7205", size = 163981 },- { url = "https://files.pythonhosted.org/packages/b3/7d/32cdb77990b3bdc34a306e0a0f73a1275221e9a66d869f6ff833c95b56ef/websockets-14.2-cp312-cp312-win_amd64.whl", hash = "sha256:44bba1a956c2c9d268bdcdf234d5e5ff4c9b6dc3e300545cbe99af59dda9dcce", size = 164421 },- { url = "https://files.pythonhosted.org/packages/10/3d/91d3d2bb1325cd83e8e2c02d0262c7d4426dc8fa0831ef1aa4d6bf2041af/websockets-14.2-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:d7d9cafbccba46e768be8a8ad4635fa3eae1ffac4c6e7cb4eb276ba41297ed29", size = 160773 },- { url = "https://files.pythonhosted.org/packages/33/7c/cdedadfef7381939577858b1b5718a4ab073adbb584e429dd9d9dc9bfe16/websockets-14.2-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:c76193c1c044bd1e9b3316dcc34b174bbf9664598791e6fb606d8d29000e070c", size = 161007 },- { url = "https://files.pythonhosted.org/packages/ca/35/7a20a3c450b27c04e50fbbfc3dfb161ed8e827b2a26ae31c4b59b018b8c6/websockets-14.2-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fd475a974d5352390baf865309fe37dec6831aafc3014ffac1eea99e84e83fc2", size = 162264 },- { url = "https://files.pythonhosted.org/packages/e8/9c/e3f9600564b0c813f2448375cf28b47dc42c514344faed3a05d71fb527f9/websockets-14.2-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2c6c0097a41968b2e2b54ed3424739aab0b762ca92af2379f152c1aef0187e1c", size = 161873 },- { url = "https://files.pythonhosted.org/packages/3f/37/260f189b16b2b8290d6ae80c9f96d8b34692cf1bb3475df54c38d3deb57d/websockets-14.2-pp310-pypy310_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6d7ff794c8b36bc402f2e07c0b2ceb4a2424147ed4785ff03e2a7af03711d60a", size = 161818 },- { url = "https://files.pythonhosted.org/packages/ff/1e/e47dedac8bf7140e59aa6a679e850c4df9610ae844d71b6015263ddea37b/websockets-14.2-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:dec254fcabc7bd488dab64846f588fc5b6fe0d78f641180030f8ea27b76d72c3", size = 164465 },- { url = "https://files.pythonhosted.org/packages/7b/c8/d529f8a32ce40d98309f4470780631e971a5a842b60aec864833b3615786/websockets-14.2-py3-none-any.whl", hash = "sha256:7a6ceec4ea84469f15cf15807a747e9efe57e369c384fa86e022b3bea679b79b", size = 157416 },+version = "15.0.1"+source = { registry = "https://pypi.org/simple" }+sdist = { url = "https://files.pythonhosted.org/packages/21/e6/26d09fab466b7ca9c7737474c52be4f76a40301b08362eb2dbc19dcc16c1/websockets-15.0.1.tar.gz", hash = "sha256:82544de02076bafba038ce055ee6412d68da13ab47f0c60cab827346de828dee", size = 177016 }+wheels = [+ { url = "https://files.pythonhosted.org/packages/1e/da/6462a9f510c0c49837bbc9345aca92d767a56c1fb2939e1579df1e1cdcf7/websockets-15.0.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:d63efaa0cd96cf0c5fe4d581521d9fa87744540d4bc999ae6e08595a1014b45b", size = 175423 },+ { url = "https://files.pythonhosted.org/packages/1c/9f/9d11c1a4eb046a9e106483b9ff69bce7ac880443f00e5ce64261b47b07e7/websockets-15.0.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:ac60e3b188ec7574cb761b08d50fcedf9d77f1530352db4eef1707fe9dee7205", size = 173080 },+ { url = "https://files.pythonhosted.org/packages/d5/4f/b462242432d93ea45f297b6179c7333dd0402b855a912a04e7fc61c0d71f/websockets-15.0.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:5756779642579d902eed757b21b0164cd6fe338506a8083eb58af5c372e39d9a", size = 173329 },+ { url = "https://files.pythonhosted.org/packages/6e/0c/6afa1f4644d7ed50284ac59cc70ef8abd44ccf7d45850d989ea7310538d0/websockets-15.0.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0fdfe3e2a29e4db3659dbd5bbf04560cea53dd9610273917799f1cde46aa725e", size = 182312 },+ { url = "https://files.pythonhosted.org/packages/dd/d4/ffc8bd1350b229ca7a4db2a3e1c482cf87cea1baccd0ef3e72bc720caeec/websockets-15.0.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4c2529b320eb9e35af0fa3016c187dffb84a3ecc572bcee7c3ce302bfeba52bf", size = 181319 },+ { url = "https://files.pythonhosted.org/packages/97/3a/5323a6bb94917af13bbb34009fac01e55c51dfde354f63692bf2533ffbc2/websockets-15.0.1-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ac1e5c9054fe23226fb11e05a6e630837f074174c4c2f0fe442996112a6de4fb", size = 181631 },+ { url = "https://files.pythonhosted.org/packages/a6/cc/1aeb0f7cee59ef065724041bb7ed667b6ab1eeffe5141696cccec2687b66/websockets-15.0.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:5df592cd503496351d6dc14f7cdad49f268d8e618f80dce0cd5a36b93c3fc08d", size = 182016 },+ { url = "https://files.pythonhosted.org/packages/79/f9/c86f8f7af208e4161a7f7e02774e9d0a81c632ae76db2ff22549e1718a51/websockets-15.0.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:0a34631031a8f05657e8e90903e656959234f3a04552259458aac0b0f9ae6fd9", size = 181426 },+ { url = "https://files.pythonhosted.org/packages/c7/b9/828b0bc6753db905b91df6ae477c0b14a141090df64fb17f8a9d7e3516cf/websockets-15.0.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:3d00075aa65772e7ce9e990cab3ff1de702aa09be3940d1dc88d5abf1ab8a09c", size = 181360 },+ { url = "https://files.pythonhosted.org/packages/89/fb/250f5533ec468ba6327055b7d98b9df056fb1ce623b8b6aaafb30b55d02e/websockets-15.0.1-cp310-cp310-win32.whl", hash = "sha256:1234d4ef35db82f5446dca8e35a7da7964d02c127b095e172e54397fb6a6c256", size = 176388 },+ { url = "https://files.pythonhosted.org/packages/1c/46/aca7082012768bb98e5608f01658ff3ac8437e563eca41cf068bd5849a5e/websockets-15.0.1-cp310-cp310-win_amd64.whl", hash = "sha256:39c1fec2c11dc8d89bba6b2bf1556af381611a173ac2b511cf7231622058af41", size = 176830 },+ { url = "https://files.pythonhosted.org/packages/9f/32/18fcd5919c293a398db67443acd33fde142f283853076049824fc58e6f75/websockets-15.0.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:823c248b690b2fd9303ba00c4f66cd5e2d8c3ba4aa968b2779be9532a4dad431", size = 175423 },+ { url = "https://files.pythonhosted.org/packages/76/70/ba1ad96b07869275ef42e2ce21f07a5b0148936688c2baf7e4a1f60d5058/websockets-15.0.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:678999709e68425ae2593acf2e3ebcbcf2e69885a5ee78f9eb80e6e371f1bf57", size = 173082 },+ { url = "https://files.pythonhosted.org/packages/86/f2/10b55821dd40eb696ce4704a87d57774696f9451108cff0d2824c97e0f97/websockets-15.0.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d50fd1ee42388dcfb2b3676132c78116490976f1300da28eb629272d5d93e905", size = 173330 },+ { url = "https://files.pythonhosted.org/packages/a5/90/1c37ae8b8a113d3daf1065222b6af61cc44102da95388ac0018fcb7d93d9/websockets-15.0.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d99e5546bf73dbad5bf3547174cd6cb8ba7273062a23808ffea025ecb1cf8562", size = 182878 },+ { url = "https://files.pythonhosted.org/packages/8e/8d/96e8e288b2a41dffafb78e8904ea7367ee4f891dafc2ab8d87e2124cb3d3/websockets-15.0.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:66dd88c918e3287efc22409d426c8f729688d89a0c587c88971a0faa2c2f3792", size = 181883 },+ { url = "https://files.pythonhosted.org/packages/93/1f/5d6dbf551766308f6f50f8baf8e9860be6182911e8106da7a7f73785f4c4/websockets-15.0.1-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8dd8327c795b3e3f219760fa603dcae1dcc148172290a8ab15158cf85a953413", size = 182252 },+ { url = "https://files.pythonhosted.org/packages/d4/78/2d4fed9123e6620cbf1706c0de8a1632e1a28e7774d94346d7de1bba2ca3/websockets-15.0.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:8fdc51055e6ff4adeb88d58a11042ec9a5eae317a0a53d12c062c8a8865909e8", size = 182521 },+ { url = "https://files.pythonhosted.org/packages/e7/3b/66d4c1b444dd1a9823c4a81f50231b921bab54eee2f69e70319b4e21f1ca/websockets-15.0.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:693f0192126df6c2327cce3baa7c06f2a117575e32ab2308f7f8216c29d9e2e3", size = 181958 },+ { url = "https://files.pythonhosted.org/packages/08/ff/e9eed2ee5fed6f76fdd6032ca5cd38c57ca9661430bb3d5fb2872dc8703c/websockets-15.0.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:54479983bd5fb469c38f2f5c7e3a24f9a4e70594cd68cd1fa6b9340dadaff7cf", size = 181918 },+ { url = "https://files.pythonhosted.org/packages/d8/75/994634a49b7e12532be6a42103597b71098fd25900f7437d6055ed39930a/websockets-15.0.1-cp311-cp311-win32.whl", hash = "sha256:16b6c1b3e57799b9d38427dda63edcbe4926352c47cf88588c0be4ace18dac85", size = 176388 },+ { url = "https://files.pythonhosted.org/packages/98/93/e36c73f78400a65f5e236cd376713c34182e6663f6889cd45a4a04d8f203/websockets-15.0.1-cp311-cp311-win_amd64.whl", hash = "sha256:27ccee0071a0e75d22cb35849b1db43f2ecd3e161041ac1ee9d2352ddf72f065", size = 176828 },+ { url = "https://files.pythonhosted.org/packages/51/6b/4545a0d843594f5d0771e86463606a3988b5a09ca5123136f8a76580dd63/websockets-15.0.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:3e90baa811a5d73f3ca0bcbf32064d663ed81318ab225ee4f427ad4e26e5aff3", size = 175437 },+ { url = "https://files.pythonhosted.org/packages/f4/71/809a0f5f6a06522af902e0f2ea2757f71ead94610010cf570ab5c98e99ed/websockets-15.0.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:592f1a9fe869c778694f0aa806ba0374e97648ab57936f092fd9d87f8bc03665", size = 173096 },+ { url = "https://files.pythonhosted.org/packages/3d/69/1a681dd6f02180916f116894181eab8b2e25b31e484c5d0eae637ec01f7c/websockets-15.0.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:0701bc3cfcb9164d04a14b149fd74be7347a530ad3bbf15ab2c678a2cd3dd9a2", size = 173332 },+ { url = "https://files.pythonhosted.org/packages/a6/02/0073b3952f5bce97eafbb35757f8d0d54812b6174ed8dd952aa08429bcc3/websockets-15.0.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e8b56bdcdb4505c8078cb6c7157d9811a85790f2f2b3632c7d1462ab5783d215", size = 183152 },+ { url = "https://files.pythonhosted.org/packages/74/45/c205c8480eafd114b428284840da0b1be9ffd0e4f87338dc95dc6ff961a1/websockets-15.0.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0af68c55afbd5f07986df82831c7bff04846928ea8d1fd7f30052638788bc9b5", size = 182096 },+ { url = "https://files.pythonhosted.org/packages/14/8f/aa61f528fba38578ec553c145857a181384c72b98156f858ca5c8e82d9d3/websockets-15.0.1-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:64dee438fed052b52e4f98f76c5790513235efaa1ef7f3f2192c392cd7c91b65", size = 182523 },+ { url = "https://files.pythonhosted.org/packages/ec/6d/0267396610add5bc0d0d3e77f546d4cd287200804fe02323797de77dbce9/websockets-15.0.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:d5f6b181bb38171a8ad1d6aa58a67a6aa9d4b38d0f8c5f496b9e42561dfc62fe", size = 182790 },+ { url = "https://files.pythonhosted.org/packages/02/05/c68c5adbf679cf610ae2f74a9b871ae84564462955d991178f95a1ddb7dd/websockets-15.0.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:5d54b09eba2bada6011aea5375542a157637b91029687eb4fdb2dab11059c1b4", size = 182165 },+ { url = "https://files.pythonhosted.org/packages/29/93/bb672df7b2f5faac89761cb5fa34f5cec45a4026c383a4b5761c6cea5c16/websockets-15.0.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3be571a8b5afed347da347bfcf27ba12b069d9d7f42cb8c7028b5e98bbb12597", size = 182160 },+ { url = "https://files.pythonhosted.org/packages/ff/83/de1f7709376dc3ca9b7eeb4b9a07b4526b14876b6d372a4dc62312bebee0/websockets-15.0.1-cp312-cp312-win32.whl", hash = "sha256:c338ffa0520bdb12fbc527265235639fb76e7bc7faafbb93f6ba80d9c06578a9", size = 176395 },+ { url = "https://files.pythonhosted.org/packages/7d/71/abf2ebc3bbfa40f391ce1428c7168fb20582d0ff57019b69ea20fa698043/websockets-15.0.1-cp312-cp312-win_amd64.whl", hash = "sha256:fcd5cf9e305d7b8338754470cf69cf81f420459dbae8a3b40cee57417f4614a7", size = 176841 },+ { url = "https://files.pythonhosted.org/packages/02/9e/d40f779fa16f74d3468357197af8d6ad07e7c5a27ea1ca74ceb38986f77a/websockets-15.0.1-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:0c9e74d766f2818bb95f84c25be4dea09841ac0f734d1966f415e4edfc4ef1c3", size = 173109 },+ { url = "https://files.pythonhosted.org/packages/bc/cd/5b887b8585a593073fd92f7c23ecd3985cd2c3175025a91b0d69b0551372/websockets-15.0.1-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:1009ee0c7739c08a0cd59de430d6de452a55e42d6b522de7aa15e6f67db0b8e1", size = 173343 },+ { url = "https://files.pythonhosted.org/packages/fe/ae/d34f7556890341e900a95acf4886833646306269f899d58ad62f588bf410/websockets-15.0.1-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:76d1f20b1c7a2fa82367e04982e708723ba0e7b8d43aa643d3dcd404d74f1475", size = 174599 },+ { url = "https://files.pythonhosted.org/packages/71/e6/5fd43993a87db364ec60fc1d608273a1a465c0caba69176dd160e197ce42/websockets-15.0.1-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f29d80eb9a9263b8d109135351caf568cc3f80b9928bccde535c235de55c22d9", size = 174207 },+ { url = "https://files.pythonhosted.org/packages/2b/fb/c492d6daa5ec067c2988ac80c61359ace5c4c674c532985ac5a123436cec/websockets-15.0.1-pp310-pypy310_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b359ed09954d7c18bbc1680f380c7301f92c60bf924171629c5db97febb12f04", size = 174155 },+ { url = "https://files.pythonhosted.org/packages/68/a1/dcb68430b1d00b698ae7a7e0194433bce4f07ded185f0ee5fb21e2a2e91e/websockets-15.0.1-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:cad21560da69f4ce7658ca2cb83138fb4cf695a2ba3e475e0559e05991aa8122", size = 176884 },+ { url = "https://files.pythonhosted.org/packages/fa/a8/5b41e0da817d64113292ab1f8247140aac61cbf6cfd085d6a0fa77f4984f/websockets-15.0.1-py3-none-any.whl", hash = "sha256:f7a866fbc1e97b5c617ee4116daaa09b722101d4a3c170c787450ba409f9736f", size = 169743 },][[package]]