🐫 CAMEL: The first and the best multi-agent framework. Finding the Scaling Law of Agents. https://www.camel-ai.org
Python agentai-societiesartificial-intelligencecommunicative-aicooperative-aideep-learninglarge-language-modelsmulti-agent-systemsnatural-language-processing
feat: integrating daytona runtime (#2261)
JINO ROHIT0b6925485199
diff --git a/camel/runtime/__init__.py b/camel/runtime/__init__.pyindex 3159a1c9d..9b8383722 100644--- a/camel/runtime/__init__.py+++ b/camel/runtime/__init__.py@@ -13,6 +13,7 @@# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========from .base import BaseRuntimefrom .configs import TaskConfig+from .daytona_runtime import DaytonaRuntimefrom .docker_runtime import DockerRuntimefrom .llm_guard_runtime import LLMGuardRuntimefrom .remote_http_runtime import RemoteHttpRuntime@@ -28,4 +29,5 @@ __all__ = ["LLMGuardRuntime","TaskConfig","UbuntuDockerRuntime",+ "DaytonaRuntime",]diff --git a/camel/runtime/daytona_runtime.py b/camel/runtime/daytona_runtime.pynew file mode 100644index 000000000..448ae6f6e--- /dev/null+++ b/camel/runtime/daytona_runtime.py@@ -0,0 +1,248 @@+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========+# Licensed under the Apache License, Version 2.0 (the "License");+# you may not use this file except in compliance with the License.+# You may obtain a copy of the License at+#+# http://www.apache.org/licenses/LICENSE-2.0+#+# Unless required by applicable law or agreed to in writing, software+# distributed under the License is distributed on an "AS IS" BASIS,+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+# See the License for the specific language governing permissions and+# limitations under the License.+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========++import inspect+import json+import os+from functools import wraps+from typing import Any, Dict, List, Optional, Union++from pydantic import BaseModel++from camel.logger import get_logger+from camel.runtime import BaseRuntime+from camel.toolkits.function_tool import FunctionTool++logger = get_logger(__name__)+++class DaytonaRuntime(BaseRuntime):+ r"""A runtime that executes functions in a Daytona sandbox environment.+ Requires the Daytona server to be running and an API key configured.++ Args:+ api_key (Optional[str]): The Daytona API key for authentication. If not+ provided, it will try to use the DAYTONA_API_KEY environment+ variable. (default: :obj: `None`)+ api_url (Optional[str]): The URL of the Daytona server. If not+ provided, it will try to use the DAYTONA_API_URL environment+ variable. If none is provided, it will use "http://localhost:8000".+ (default: :obj: `None`)+ language (Optional[str]): The programming language for the sandbox.+ (default: :obj: `"python"`)+ """++ def __init__(+ self,+ api_key: Optional[str] = None,+ api_url: Optional[str] = None,+ language: Optional[str] = "python",+ ):+ from daytona_sdk import Daytona, DaytonaConfig++ super().__init__()+ self.api_key = api_key or os.environ.get('DAYTONA_API_KEY')+ self.api_url = api_url or os.environ.get('DAYTONA_API_URL')+ self.language = language+ self.config = DaytonaConfig(api_key=self.api_key, api_url=self.api_url)+ self.daytona = Daytona(self.config)+ self.sandbox = None+ self.entrypoint: Dict[str, str] = dict()++ def build(self) -> "DaytonaRuntime":+ r"""Create and start a Daytona sandbox.++ Returns:+ DaytonaRuntime: The current runtime.+ """+ from daytona_sdk import CreateSandboxParams++ try:+ params = CreateSandboxParams(language=self.language)+ self.sandbox = self.daytona.create(params)+ if self.sandbox is None:+ raise RuntimeError("Failed to create sandbox.")+ logger.info(f"Sandbox created with ID: {self.sandbox.id}")+ except Exception as e:+ logger.error(f"Failed to create sandbox: {e!s}")+ raise RuntimeError(f"Daytona sandbox creation failed: {e!s}")+ return self++ def _cleanup(self):+ r"""Clean up the sandbox when exiting."""+ if self.sandbox:+ try:+ self.daytona.remove(self.sandbox)+ logger.info(f"Sandbox {self.sandbox.id} removed")+ self.sandbox = None+ except Exception as e:+ logger.error(f"Failed to remove sandbox: {e!s}")++ def add(+ self,+ funcs: Union[FunctionTool, List[FunctionTool]],+ entrypoint: str,+ arguments: Optional[Dict[str, Any]] = None,+ ) -> "DaytonaRuntime":+ r"""Add a function or list of functions to the runtime.++ Args:+ funcs (Union[FunctionTool, List[FunctionTool]]): The function or+ list of functions to add.+ entrypoint (str): The entrypoint for the function.+ arguments (Optional[Dict[str, Any]]): The arguments for the+ function. (default: :obj: `None`)++ Returns:+ DaytonaRuntime: The current runtime.+ """+ if not isinstance(funcs, list):+ funcs = [funcs]+ if arguments is not None:+ entrypoint += json.dumps(arguments, ensure_ascii=False)++ def make_wrapper(inner_func, func_name, func_code):+ r"""Creates a wrapper for a function to execute it in the+ Daytona sandbox.++ Args:+ inner_func (Callable): The function to wrap.+ func_name (str): The name of the function.+ func_code (str): The source code of the function.++ Returns:+ Callable: A wrapped function that executes in the sandbox.+ """++ @wraps(inner_func)+ def wrapper(*args, **kwargs):+ if not self.sandbox:+ raise RuntimeError(+ "Sandbox not initialized. Call build() first."+ )++ try:+ for key, value in kwargs.items():+ if isinstance(value, BaseModel):+ kwargs[key] = value.model_dump()+ args_str = json.dumps(args, ensure_ascii=True)+ kwargs_str = json.dumps(kwargs, ensure_ascii=True)+ except (TypeError, ValueError) as e:+ logger.error(f"Failed to serialize arguments: {e!s}")+ return {"error": f"Argument serialization failed: {e!s}"}++ # Upload function code to the sandbox+ script_path = f"/home/daytona/{func_name}.py"+ try:+ self.sandbox.fs.upload_file(+ script_path, func_code.encode()+ )+ except Exception as e:+ logger.error(+ f"Failed to upload function {func_name}: {e!s}"+ )+ return {"error": f"Upload failed: {e!s}"}++ exec_code = (+ f"import sys\n"+ f"sys.path.append('/home/daytona')\n"+ f"import json\n"+ f"from {func_name} import {func_name}\n"+ f"args = json.loads('{args_str}')\n"+ f"kwargs = json.loads('{kwargs_str}')\n"+ f"result = {func_name}(*args, **kwargs)\n"+ f"print(json.dumps(result) if result is not "+ f"None else 'null')"+ )++ # Execute the function in the sandbox+ try:+ response = self.sandbox.process.code_run(exec_code)+ return (+ json.loads(response.result)+ if response.result+ else None+ )+ except json.JSONDecodeError as e:+ logger.error(+ f"Failed to decode JSON response for {func_name}"+ )+ return {"error": f"JSON decoding failed: {e!s}"}+ except Exception as e:+ logger.error(+ f"Failed to execute function {func_name}: {e!s}"+ )+ return {"error": f"Execution failed: {e!s}"}++ return wrapper++ for func in funcs:+ inner_func = func.func+ func_name = func.get_function_name()+ func_code = inspect.getsource(inner_func).strip()++ func.func = make_wrapper(inner_func, func_name, func_code)+ self.tools_map[func_name] = func+ self.entrypoint[func_name] = entrypoint++ return self++ def info(self) -> str:+ r"""Get information about the current sandbox.++ Returns:+ str: Information about the sandbox.++ Raises:+ RuntimeError: If the sandbox is not initialized.+ """+ if self.sandbox is None:+ raise RuntimeError("Failed to create sandbox.")+ info = self.sandbox.info()+ return (+ f"Sandbox {info.name}:\n"+ f"State: {info.state}\n"+ f"Resources: {info.resources.cpu} CPU, {info.resources.memory} RAM"+ )++ def __del__(self):+ r"""Clean up the sandbox when the object is deleted."""+ if hasattr(self, 'sandbox'):+ self._cleanup()++ def stop(self) -> "DaytonaRuntime":+ r"""Stop and remove the sandbox.++ Returns:+ DaytonaRuntime: The current runtime.+ """+ self._cleanup()+ return self++ def reset(self) -> "DaytonaRuntime":+ r"""Reset the sandbox by stopping and rebuilding it.++ Returns:+ DaytonaRuntime: The current runtime.+ """+ return self.stop().build()++ @property+ def docs(self) -> str:+ r"""Get the URL for the Daytona API documentation.++ Returns:+ str: The URL for the API documentation.+ """+ return "https://www.daytona.io/docs/python-sdk/daytona/"diff --git a/examples/runtime/daytona_runtime.py b/examples/runtime/daytona_runtime.pynew file mode 100644index 000000000..777d53d9b--- /dev/null+++ b/examples/runtime/daytona_runtime.py@@ -0,0 +1,106 @@+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========+# Licensed under the Apache License, Version 2.0 (the "License");+# you may not use this file except in compliance with the License.+# You may obtain a copy of the License at+#+# http://www.apache.org/licenses/LICENSE-2.0+#+# Unless required by applicable law or agreed to in writing, software+# distributed under the License is distributed on an "AS IS" BASIS,+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+# See the License for the specific language governing permissions and+# limitations under the License.+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========++import os++from colorama import Fore++from camel.agents import ChatAgent+from camel.models import ModelFactory+from camel.runtime import DaytonaRuntime+from camel.toolkits.code_execution import CodeExecutionToolkit+from camel.toolkits.function_tool import FunctionTool+from camel.types import ModelPlatformType, ModelType+++def sample_function(x: int, y: int) -> int:+ return x + y+++# Initialize toolkit+toolkit = CodeExecutionToolkit(verbose=True)++# Initialize the runtime with the API key+runtime = DaytonaRuntime(+ api_key=os.environ.get('DAYTONA_API_KEY'),+ api_url=os.environ.get('DAYTONA_API_URL'),+ language="python",+)++# Build the sandbox+runtime.build()++# Add toolkit to runtime+runtime.add(+ funcs=FunctionTool(sample_function),+ entrypoint="sample_function_entry",+)++# Get tools from runtime+tools = runtime.get_tools()++model = ModelFactory.create(+ model_platform=ModelPlatformType.DEFAULT,+ model_type=ModelType.DEFAULT,+)++# Set up agent with system message+assistant_sys_msg = (+ "You are a personal math tutor and programmer. "+ "When asked a math question, "+ "write and run Python code to answer the question."+)++agent = ChatAgent(+ assistant_sys_msg,+ model,+ tools=tools,+)+agent.reset()++# Use the agent with runtime+prompt = (+ "Weng earns $12 an hour for babysitting. "+ "Yesterday, she just did 51 minutes of babysitting. How much did she earn?"+)+print(Fore.YELLOW + f"user prompt:\n{prompt}\n")++response = agent.step(prompt)++print(response)++# Clean up+runtime.stop()+++"""+===============================================================================+user prompt:+Weng earns $12 an hour for babysitting. Yesterday, she just did 51 minutes of+babysitting. How much did she earn?++msgs=[BaseMessage(role_name='Assistant', role_type=<RoleType.ASSISTANT:+'assistant'>, meta_dict={}, content='Weng earned $10.20 for her 51 minutes of+babysitting.', video_bytes=None, image_list=None, image_detail='auto',+video_detail='low', parsed=None)] terminated=False info={'id':+'chatcmpl-BTDAKaCAYvs6KFsxe9NmmxMHQiaxx', 'usage': {'completion_tokens': 18,+'prompt_tokens': 122, 'total_tokens': 140, 'completion_tokens_details':+{'accepted_prediction_tokens': 0, 'audio_tokens': 0, 'reasoning_tokens': 0,+'rejected_prediction_tokens': 0}, 'prompt_tokens_details': {'audio_tokens': 0,+'cached_tokens': 0}}, 'termination_reasons': ['stop'], 'num_tokens': 99,+'tool_calls': [ToolCallingRecord(tool_name='sample_function', args={'x': 12,+'y': 51}, result=63, tool_call_id='call_clugUYSbh37yVAwpggG8Dwe0')],+'external_tool_call_requests': None}+===============================================================================+"""diff --git a/pyproject.toml b/pyproject.tomlindex 912ba62a5..7189e2249 100644--- a/pyproject.toml+++ b/pyproject.toml@@ -164,6 +164,7 @@ dev_tools = ["tree-sitter>=0.23.2,<0.24","typer>=0.15.2","mcp>=1.3.0",+ "daytona-sdk==0.14.0",]model_platforms = ["litellm>=1.38.1,<2",@@ -356,6 +357,7 @@ all = ["pyautogui>=0.9.54,<0.10","pyobvector>=0.1.18","scrapegraph-py>=1.12.0,<2",+ "daytona-sdk==0.14.0","ibm-watsonx-ai>=1.3.11",]@@ -543,6 +545,7 @@ module = ["crawl4ai.*","pyautogui","pyobvector.*",+ "daytona_sdk","scrapegraph_py.*","ibm_watsonx_ai.*",]diff --git a/test/runtime/test_daytona_runtime.py b/test/runtime/test_daytona_runtime.pynew file mode 100644index 000000000..a3cf8001a--- /dev/null+++ b/test/runtime/test_daytona_runtime.py@@ -0,0 +1,181 @@+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========+# Licensed under the Apache License, Version 2.0 (the "License");+# you may not use this file except in compliance with the License.+# You may obtain a copy of the License at+#+# http://www.apache.org/licenses/LICENSE-2.0+#+# Unless required by applicable law or agreed to in writing, software+# distributed under the License is distributed on an "AS IS" BASIS,+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+# See the License for the specific language governing permissions and+# limitations under the License.+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========++import os+import unittest+from unittest.mock import MagicMock, patch++from camel.runtime import DaytonaRuntime+from camel.toolkits.function_tool import FunctionTool+++def sample_function(x: int, y: int) -> int:+ r"""Sample function for testing."""+ return x + y+++@patch('daytona_sdk.Daytona')+@patch('daytona_sdk.DaytonaConfig')+def test_init_with_explicit_params(mock_config, mock_daytona):+ r"""Test initialization with explicit parameters."""+ runtime = DaytonaRuntime(+ api_key="test_key", api_url="http://test-url", language="python"+ )++ # Assert parameters are set correctly+ assert runtime.api_key == "test_key"+ assert runtime.api_url == "http://test-url"+ assert runtime.language == "python"++ # Assert config was created with correct parameters+ mock_config.assert_called_once_with(+ api_key="test_key", api_url="http://test-url"+ )++ # Assert Daytona client was initialized+ mock_daytona.assert_called_once()+++ os.environ,+ {'DAYTONA_API_KEY': 'env_key', 'DAYTONA_API_URL': 'http://env-url'},+)+@patch('daytona_sdk.Daytona')+@patch('daytona_sdk.DaytonaConfig')+def test_init_with_env_vars(mock_config, mock_daytona):+ r"""Test initialization with environment variables."""+ runtime = DaytonaRuntime()++ # Assert parameters are set from environment+ assert runtime.api_key == "env_key"+ assert runtime.api_url == "http://env-url"+ assert runtime.language == "python" # Default value++ # Assert config was created with correct parameters+ mock_config.assert_called_once_with(+ api_key="env_key", api_url="http://env-url"+ )+++@patch('daytona_sdk.CreateSandboxParams')+@patch('daytona_sdk.Daytona')+@patch('daytona_sdk.DaytonaConfig')+def test_build_success(mock_config, mock_daytona, mock_params):+ r"""Test successful sandbox creation."""+ # Setup mock+ mock_sandbox = MagicMock()+ mock_sandbox.id = "test-sandbox-id"+ mock_daytona_instance = mock_daytona.return_value+ mock_daytona_instance.create.return_value = mock_sandbox++ # Create runtime and build sandbox+ runtime = DaytonaRuntime(api_key="test_key")+ result = runtime.build()++ # Assert sandbox was created+ mock_daytona_instance.create.assert_called_once()+ assert runtime.sandbox == mock_sandbox+ assert result == runtime # Should return self+++@patch('daytona_sdk.CreateSandboxParams')+@patch('daytona_sdk.Daytona')+@patch('daytona_sdk.DaytonaConfig')+def test_build_failure(mock_config, mock_daytona, mock_params):+ r"""Test sandbox creation failure."""+ # Setup mock to raise exception+ mock_daytona_instance = mock_daytona.return_value+ mock_daytona_instance.create.side_effect = Exception("Test error")++ # Create runtime+ runtime = DaytonaRuntime(api_key="test_key")++ # Assert exception is raised+ with unittest.TestCase().assertRaises(RuntimeError) as context:+ runtime.build()++ assert "Daytona sandbox creation failed" in str(context.exception)+++@patch('daytona_sdk.Daytona')+@patch('daytona_sdk.DaytonaConfig')+def test_stop(mock_config, mock_daytona):+ r"""Test stopping and removing the sandbox."""+ # Setup mock+ mock_sandbox = MagicMock()+ mock_daytona_instance = mock_daytona.return_value++ # Create runtime with sandbox+ runtime = DaytonaRuntime(api_key="test_key")+ runtime.sandbox = mock_sandbox++ # Stop sandbox+ result = runtime.stop()++ # Assert sandbox was removed+ mock_daytona_instance.remove.assert_called_once_with(mock_sandbox)+ assert runtime.sandbox is None+ assert result == runtime # Should return self+++@patch('daytona_sdk.Daytona')+@patch('daytona_sdk.DaytonaConfig')+def test_add_function(mock_config, mock_daytona):+ r"""Test adding a function to the runtime."""+ # Setup mock+ mock_sandbox = MagicMock()+ mock_daytona_instance = mock_daytona.return_value+ mock_daytona_instance.create.return_value = mock_sandbox++ # Create runtime and build sandbox+ runtime = DaytonaRuntime(api_key="test_key")+ runtime.build()++ # Add function+ tool = FunctionTool(sample_function)+ result = runtime.add(funcs=tool, entrypoint="test_entry")++ # Assert function was added+ assert "sample_function" in runtime.tools_map+ assert runtime.entrypoint["sample_function"] == "test_entry"+ assert result == runtime # Should return self+++@patch('daytona_sdk.Daytona')+@patch('daytona_sdk.DaytonaConfig')+def test_reset(mock_config, mock_daytona):+ r"""Test resetting the sandbox."""+ # Setup mock+ mock_sandbox = MagicMock()+ mock_daytona_instance = mock_daytona.return_value+ mock_daytona_instance.create.return_value = mock_sandbox++ # Create runtime with sandbox+ runtime = DaytonaRuntime(api_key="test_key")+ runtime.sandbox = mock_sandbox++ # Mock the build method to verify it's called+ original_build = runtime.build+ runtime.build = MagicMock(return_value=runtime)++ # Reset sandbox+ result = runtime.reset()++ # Assert sandbox was removed and rebuilt+ mock_daytona_instance.remove.assert_called_once_with(mock_sandbox)+ assert runtime.build.called+ assert result == runtime # Should return self++ # Restore original build method+ runtime.build = original_builddiff --git a/uv.lock b/uv.lockindex ad69018b6..21fffdf65 100644--- a/uv.lock+++ b/uv.lock@@ -571,6 +571,7 @@ all = [{ name = "datacommons" },{ name = "datacommons-pandas" },{ name = "datasets" },+ { name = "daytona-sdk" },{ name = "diffusers" },{ name = "discord-py" },{ name = "docker" },@@ -709,6 +710,7 @@ dev = []dev-tools = [{ name = "agentops" },+ { name = "daytona-sdk" },{ name = "docker" },{ name = "e2b-code-interpreter" },{ name = "ipykernel" },@@ -922,6 +924,8 @@ requires-dist = [{ name = "datasets", marker = "extra == 'all'", specifier = ">=3,<4" },{ name = "datasets", marker = "extra == 'huggingface'", specifier = ">=3,<4" },{ name = "datasets", marker = "extra == 'owl'", specifier = ">=3,<4" },+ { name = "daytona-sdk", marker = "extra == 'all'", specifier = "==0.14.0" },+ { name = "daytona-sdk", marker = "extra == 'dev-tools'", specifier = "==0.14.0" },{ name = "diffusers", marker = "extra == 'all'", specifier = ">=0.25.0,<0.26" },{ name = "diffusers", marker = "extra == 'huggingface'", specifier = ">=0.25.0,<0.26" },{ name = "discord-py", marker = "extra == 'all'", specifier = ">=2.3.2,<3" },@@ -1665,6 +1669,40 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/b4/83/50abe521eb75744a01efe2ebe836a4b61f4df37941a776f650f291aabdf9/datasets-3.5.0-py3-none-any.whl", hash = "sha256:b3b7f163acc6ac4e01a1b00eef26d48bd4039288ceea3601d169272bd5581006", size = 491167 },]+[[package]]+name = "daytona-api-client"+version = "0.16.0"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "pydantic" },+ { name = "python-dateutil" },+ { name = "typing-extensions" },+ { name = "urllib3" },+]+sdist = { url = "https://files.pythonhosted.org/packages/97/67/0532ab97f5cbf802d19bbcbcf0e7307d787d1af9b14967c6ed32f960f6eb/daytona_api_client-0.16.0.tar.gz", hash = "sha256:0a4ad32934144402b5a47bd5c3a3b1450674e85584623386a3d6c2560ea146b2", size = 63662 }+wheels = [+ { url = "https://files.pythonhosted.org/packages/0d/ee/2107f820f3087693dc07eca3cd611b8ab40860def70e54b0ec4e76504bb6/daytona_api_client-0.16.0-py3-none-any.whl", hash = "sha256:31d31409102aa009517d2a0e1ba85f47aadf41b84b7b3732c15cf1ad4c30f19b", size = 165352 },+]++[[package]]+name = "daytona-sdk"+version = "0.14.0"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "daytona-api-client" },+ { name = "deprecated" },+ { name = "environs" },+ { name = "httpx" },+ { name = "marshmallow" },+ { name = "pydantic" },+ { name = "python-dateutil" },+ { name = "urllib3" },+]+sdist = { url = "https://files.pythonhosted.org/packages/66/2c/1b48a7343168802dc9ae60d4bf5cda75c4755ca7fab39a444df2bcbaf3be/daytona_sdk-0.14.0.tar.gz", hash = "sha256:1df3eaa664dc793a33690a2361cf5262713ca5ff1f1c5730eb00b4940f11b6e8", size = 41874 }+wheels = [+ { url = "https://files.pythonhosted.org/packages/47/ae/8ff649b3aa26ee2dbbf2f1243f7f17ca0b39e2c899d3d946a416313e3ee9/daytona_sdk-0.14.0-py3-none-any.whl", hash = "sha256:a6e5c8d56b8d2342a1a630de93b7346ce2a6bc81cb21a928988964a7b3ce7b0d", size = 46536 },+]+[[package]]name = "debugpy"version = "1.8.14"@@ -1917,6 +1955,19 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/91/db/a0335710caaa6d0aebdaa65ad4df789c15d89b7babd9a30277838a7d9aac/emoji-2.14.1-py3-none-any.whl", hash = "sha256:35a8a486c1460addb1499e3bf7929d3889b2e2841a57401903699fef595e942b", size = 590617 },]+[[package]]+name = "environs"+version = "9.5.0"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "marshmallow" },+ { name = "python-dotenv" },+]+sdist = { url = "https://files.pythonhosted.org/packages/d4/e3/c3c6c76f3dbe3e019e9a451b35bf9f44690026a5bb1232f7b77097b72ff5/environs-9.5.0.tar.gz", hash = "sha256:a76307b36fbe856bdca7ee9161e6c466fd7fcffc297109a118c59b54e27e30c9", size = 20795 }+wheels = [+ { url = "https://files.pythonhosted.org/packages/ca/5e/f0f217dc393372681bfe05c50f06a212e78d0a3fee907a74ab451ec1dcdb/environs-9.5.0-py2.py3-none-any.whl", hash = "sha256:1e549569a3de49c05f856f40bce86979e7d5ffbbc4398e7f338574c220189124", size = 12548 },+]+[[package]]name = "et-xmlfile"version = "2.0.0"