Merge branch 'dev' into dependabot/pip/autogpt_platform/market/dev/de…

…velopment-dependencies-e67dc3eb19

.github/workflows/platform-backend-ci.yml

@@ -6,11 +6,13 @@ on:
     paths:
       - ".github/workflows/platform-backend-ci.yml"
       - "autogpt_platform/backend/**"
+      - "autogpt_platform/autogpt_libs/**"
   pull_request:
     branches: [master, dev, release-*]
     paths:
       - ".github/workflows/platform-backend-ci.yml"
       - "autogpt_platform/backend/**"
+      - "autogpt_platform/autogpt_libs/**"
   merge_group:
 
 concurrency:
@@ -77,6 +79,17 @@ jobs:
             echo "$HOME/.local/bin" >> $GITHUB_PATH
           fi
 
+      - name: Check poetry.lock
+        run: |
+          poetry lock --no-update
+
+          if ! git diff --quiet poetry.lock; then
+            echo "Error: poetry.lock not up to date."
+            echo
+            git diff poetry.lock
+            exit 1
+          fi
+
       - name: Install Python dependencies
         run: poetry install
 

.pre-commit-config.yaml

@@ -98,6 +98,11 @@ repos:
         files: ^autogpt_platform/autogpt_libs/
         args: [--fix]
 
+      - id: ruff-format
+        name: Format (Ruff) - AutoGPT Platform - Libs
+        alias: ruff-lint-platform-libs
+        files: ^autogpt_platform/autogpt_libs/
+
   - repo: local
     # isort needs the context of which packages are installed to function, so we
     # can't use a vendored isort pre-commit hook (which runs in its own isolated venv).
@@ -140,7 +145,7 @@ repos:
     # everything in .gitignore, so it works fine without any config or arguments.
     hooks:
       - id: black
-        name: Lint (Black)
+        name: Format (Black)
 
   - repo: https://github.com/PyCQA/flake8
     rev: 7.0.0

autogpt_platform/autogpt_libs/autogpt_libs/rate_limit/limiter.py

@@ -16,7 +16,7 @@ def __init__(
     ):
         self.redis = Redis(
             host=redis_host,
-            port=redis_port,
+            port=int(redis_port),
             password=redis_password,
             decode_responses=True,
         )

autogpt_platform/autogpt_libs/pyproject.toml

@@ -10,7 +10,7 @@ packages = [{ include = "autogpt_libs" }]
 colorama = "^0.4.6"
 expiringdict = "^1.2.2"
 google-cloud-logging = "^3.11.3"
-pydantic = "^2.10.2"
+pydantic = "^2.9.2"
 pydantic-settings = "^2.6.1"
 pyjwt = "^2.10.0"
 pytest-asyncio = "^0.24.0"
@@ -21,7 +21,7 @@ supabase = "^2.10.0"
 
 [tool.poetry.group.dev.dependencies]
 redis = "^5.2.0"
-ruff = "^0.8.0"
+ruff = "^0.8.1"
 
 [build-system]
 requires = ["poetry-core"]

autogpt_platform/backend/backend/blocks/__init__.py

@@ -15,10 +15,10 @@
     if f.is_file() and f.name != "__init__.py"
 ]
 for module in modules:
-    if not re.match("^[a-z_.]+$", module):
+    if not re.match("^[a-z0-9_.]+$", module):
         raise ValueError(
             f"Block module {module} error: module name must be lowercase, "
-            "separated by underscores, and contain only alphabet characters"
+            "and contain only alphanumeric characters and underscores."
         )
 
     importlib.import_module(f".{module}", package=__name__)

autogpt_platform/backend/backend/blocks/code_executor.py

@@ -0,0 +1,191 @@
+from enum import Enum
+from typing import Literal
+
+from e2b_code_interpreter import Sandbox
+from pydantic import SecretStr
+
+from backend.data.block import Block, BlockCategory, BlockOutput, BlockSchema
+from backend.data.model import (
+    APIKeyCredentials,
+    CredentialsField,
+    CredentialsMetaInput,
+    SchemaField,
+)
+
+TEST_CREDENTIALS = APIKeyCredentials(
+    id="01234567-89ab-cdef-0123-456789abcdef",
+    provider="e2b",
+    api_key=SecretStr("mock-e2b-api-key"),
+    title="Mock E2B API key",
+    expires_at=None,
+)
+TEST_CREDENTIALS_INPUT = {
+    "provider": TEST_CREDENTIALS.provider,
+    "id": TEST_CREDENTIALS.id,
+    "type": TEST_CREDENTIALS.type,
+    "title": TEST_CREDENTIALS.type,
+}
+
+
+class ProgrammingLanguage(Enum):
+    PYTHON = "python"
+    JAVASCRIPT = "js"
+    BASH = "bash"
+    R = "r"
+    JAVA = "java"
+
+
+class CodeExecutionBlock(Block):
+    # TODO : Add support to upload and download files
+    # Currently, You can customized the CPU and Memory, only by creating a pre customized sandbox template
+    class Input(BlockSchema):
+        credentials: CredentialsMetaInput[Literal["e2b"], Literal["api_key"]] = (
+            CredentialsField(
+                provider="e2b",
+                supported_credential_types={"api_key"},
+                description="Enter your api key for the E2B Sandbox. You can get it in here - https://e2b.dev/docs",
+            )
+        )
+
+        # Todo : Option to run commond in background
+        setup_commands: list[str] = SchemaField(
+            description=(
+                "Shell commands to set up the sandbox before running the code. "
+                "You can use `curl` or `git` to install your desired Debian based "
+                "package manager. `pip` and `npm` are pre-installed.\n\n"
+                "These commands are executed with `sh`, in the foreground."
+            ),
+            placeholder="pip install cowsay",
+            default=[],
+            advanced=False,
+        )
+
+        code: str = SchemaField(
+            description="Code to execute in the sandbox",
+            placeholder="print('Hello, World!')",
+            default="",
+            advanced=False,
+        )
+
+        language: ProgrammingLanguage = SchemaField(
+            description="Programming language to execute",
+            default=ProgrammingLanguage.PYTHON,
+            advanced=False,
+        )
+
+        timeout: int = SchemaField(
+            description="Execution timeout in seconds", default=300
+        )
+
+        template_id: str = SchemaField(
+            description=(
+                "You can use an E2B sandbox template by entering its ID here. "
+                "Check out the E2B docs for more details: "
+                "[E2B - Sandbox template](https://e2b.dev/docs/sandbox-template)"
+            ),
+            default="",
+            advanced=True,
+        )
+
+    class Output(BlockSchema):
+        response: str = SchemaField(description="Response from code execution")
+        stdout_logs: str = SchemaField(
+            description="Standard output logs from execution"
+        )
+        stderr_logs: str = SchemaField(description="Standard error logs from execution")
+        error: str = SchemaField(description="Error message if execution failed")
+
+    def __init__(self):
+        super().__init__(
+            id="0b02b072-abe7-11ef-8372-fb5d162dd712",
+            description="Executes code in an isolated sandbox environment with internet access.",
+            categories={BlockCategory.DEVELOPER_TOOLS},
+            input_schema=CodeExecutionBlock.Input,
+            output_schema=CodeExecutionBlock.Output,
+            test_credentials=TEST_CREDENTIALS,
+            test_input={
+                "credentials": TEST_CREDENTIALS_INPUT,
+                "code": "print('Hello World')",
+                "language": ProgrammingLanguage.PYTHON.value,
+                "setup_commands": [],
+                "timeout": 300,
+                "template_id": "",
+            },
+            test_output=[
+                ("response", "Hello World"),
+                ("stdout_logs", "Hello World\n"),
+            ],
+            test_mock={
+                "execute_code": lambda code, language, setup_commands, timeout, api_key, template_id: (
+                    "Hello World",
+                    "Hello World\n",
+                    "",
+                ),
+            },
+        )
+
+    def execute_code(
+        self,
+        code: str,
+        language: ProgrammingLanguage,
+        setup_commands: list[str],
+        timeout: int,
+        api_key: str,
+        template_id: str,
+    ):
+        try:
+            sandbox = None
+            if template_id:
+                sandbox = Sandbox(
+                    template=template_id, api_key=api_key, timeout=timeout
+                )
+            else:
+                sandbox = Sandbox(api_key=api_key, timeout=timeout)
+
+            if not sandbox:
+                raise Exception("Sandbox not created")
+
+            # Running setup commands
+            for cmd in setup_commands:
+                sandbox.commands.run(cmd)
+
+            # Executing the code
+            execution = sandbox.run_code(
+                code,
+                language=language.value,
+                on_error=lambda e: sandbox.kill(),  # Kill the sandbox if there is an error
+            )
+
+            if execution.error:
+                raise Exception(execution.error)
+
+            response = execution.text
+            stdout_logs = "".join(execution.logs.stdout)
+            stderr_logs = "".join(execution.logs.stderr)
+
+            return response, stdout_logs, stderr_logs
+
+        except Exception as e:
+            raise e
+
+    def run(
+        self, input_data: Input, *, credentials: APIKeyCredentials, **kwargs
+    ) -> BlockOutput:
+        try:
+            response, stdout_logs, stderr_logs = self.execute_code(
+                input_data.code,
+                input_data.language,
+                input_data.setup_commands,
+                input_data.timeout,
+                credentials.api_key.get_secret_value(),
+                input_data.template_id,
+            )
+
+            if response:
+                yield "response", response
+            if stdout_logs:
+                yield "stdout_logs", stdout_logs
+            if stderr_logs:
+                yield "stderr_logs", stderr_logs
+        except Exception as e:
+            yield "error", str(e)

autogpt_platform/backend/backend/blocks/fal/ai_video_generator.py

@@ -1,7 +1,7 @@
 import logging
 import time
 from enum import Enum
-from typing import Any, Dict
+from typing import Any
 
 import httpx
 
@@ -64,16 +64,16 @@ def __init__(self):
             },
         )
 
-    def _get_headers(self, api_key: str) -> Dict[str, str]:
+    def _get_headers(self, api_key: str) -> dict[str, str]:
         """Get headers for FAL API requests."""
         return {
             "Authorization": f"Key {api_key}",
             "Content-Type": "application/json",
         }
 
     def _submit_request(
-        self, url: str, headers: Dict[str, str], data: Dict[str, Any]
-    ) -> Dict[str, Any]:
+        self, url: str, headers: dict[str, str], data: dict[str, Any]
+    ) -> dict[str, Any]:
         """Submit a request to the FAL API."""
         try:
             response = httpx.post(url, headers=headers, json=data)
@@ -83,7 +83,7 @@ def _submit_request(
             logger.error(f"FAL API request failed: {str(e)}")
             raise RuntimeError(f"Failed to submit request: {str(e)}")
 
-    def _poll_status(self, status_url: str, headers: Dict[str, str]) -> Dict[str, Any]:
+    def _poll_status(self, status_url: str, headers: dict[str, str]) -> dict[str, Any]:
         """Poll the status endpoint until completion or failure."""
         try:
             response = httpx.get(status_url, headers=headers)

autogpt_platform/backend/backend/blocks/github/triggers.py

@@ -111,7 +111,9 @@ class Output(GitHubTriggerBase.Output):
     def __init__(self):
         from backend.integrations.webhooks.github import GithubWebhookType
 
-        example_payload = json.loads(self.EXAMPLE_PAYLOAD_FILE.read_text())
+        example_payload = json.loads(
+            self.EXAMPLE_PAYLOAD_FILE.read_text(encoding="utf-8")
+        )
 
         super().__init__(
             id="6c60ec01-8128-419e-988f-96a063ee2fea",