Feature/python execution

backend/Dockerfile.python

@@ -0,0 +1,15 @@
+FROM python:3.12-slim
+WORKDIR /app
+
+# Create non-root user
+RUN adduser --disabled-password --gecos "" executor
+
+# Create execution directory with proper permissions
+RUN mkdir /app/execution && chown executor:executor /app/execution
+
+# Switch to non-root user
+USER executor
+WORKDIR /app/execution
+
+# Keep container running
+CMD ["tail", "-f", "/dev/null"]

backend/openui/code_executor.py

@@ -0,0 +1,102 @@
+from typing import Dict, Any
+from pydantic import BaseModel
+import docker
+from docker.errors import APIError, ContainerError
+from . import config
+
+class CodeExecutionRequest(BaseModel):
+    """Request model for code execution."""
+    code: str
+    language: str = "python"  # "python" or "bash"
+    timeout: int = 30  # seconds
+
+class CodeExecutionResponse(BaseModel):
+    """Response model for code execution results."""
+    output: str
+    error: str | None = None
+    status: str
+
+class CodeExecutor:
+    """Handles code execution in isolated Docker containers."""
+
+    def __init__(self):
+        """Initialize Docker client."""
+        try:
+            self.client = docker.from_env()
+        except Exception as e:
+            raise RuntimeError(f"Failed to initialize Docker client: {e}")
+
+    async def execute(self, request: CodeExecutionRequest) -> CodeExecutionResponse:
+        """
+        Execute code in an isolated Docker container.
+
+        Args:
+            request: CodeExecutionRequest containing code and execution parameters
+
+        Returns:
+            CodeExecutionResponse with execution results
+        """
+        try:
+            # Configure container based on language
+            if request.language == "python":
+                command = ["python", "-c", request.code]
+                image = "python:3.12-slim"
+            elif request.language == "bash":
+                command = ["bash", "-c", request.code]
+                image = "ubuntu:22.04"
+            else:
+                return CodeExecutionResponse(
+                    output="",
+                    error=f"Unsupported language: {request.language}",
+                    status="error"
+                )
+
+            # Run code in isolated container
+            container = self.client.containers.run(
+                image,
+                command,
+                remove=True,
+                detach=True,
+                network_disabled=True,
+                mem_limit="512m",
+                pids_limit=50,
+                stdout=True,
+                stderr=True
+            )
+
+            try:
+                # Wait for container to finish with timeout
+                container.wait(timeout=request.timeout)
+                # Get execution output
+                output = container.logs(stdout=True, stderr=True).decode()
+                return CodeExecutionResponse(
+                    output=output,
+                    status="success"
+                )
+            finally:
+                try:
+                    container.remove(force=True)
+                except:
+                    pass  # Container might already be removed
+        except ContainerError as e:
+            # Handle container execution errors
+            error_msg = str(e)
+            return CodeExecutionResponse(
+                output="",
+                error=error_msg,
+                status="error"
+            )
+        except APIError as e:
+            # Handle Docker API errors
+            return CodeExecutionResponse(
+                output="",
+                error=str(e),
+                status="error"
+            )
+        except Exception as e:
+            # Handle unexpected errors
+            return CodeExecutionResponse(
+                output="",
+                error=f"Unexpected error: {str(e)}",
+                status="error"
+            )

backend/openui/db/models.py

@@ -13,6 +13,7 @@
 )
 import uuid
 import datetime
+from pathlib import Path
 from playhouse.sqlite_ext import SqliteExtDatabase, JSONField
 from playhouse.migrate import SqliteMigrator, migrate
 from openui import config
@@ -34,6 +35,7 @@ class Meta:
 
 
 class SchemaMigration(BaseModel):
+    id = BinaryUUIDField(primary_key=True)
     version = CharField()
 
 
@@ -81,6 +83,7 @@ class Usage(BaseModel):
     output_tokens = IntegerField()
     day = DateField()
     user = ForeignKeyField(User, backref="usage")
+    user_id = BinaryUUIDField()  # Explicit field for foreign key
 
     class Meta:
         primary_key = CompositeKey("user", "day")
@@ -122,13 +125,20 @@ def alter(schema: SchemaMigration, ops: list[list], version: str) -> bool:
     except OperationalError as e:
         print("Migration failed", e)
         return False
-    schema.version = version
-    schema.save()
+    # Update version through model API
+    schema.update(version=version).where(SchemaMigration.id == schema.id).execute()
     print(f"Migrated {version}")
     return version != CURRENT_VERSION
 
 
 def perform_migration(schema: SchemaMigration) -> bool:
+    """Perform database schema migration.
+
+    Args:
+        schema: Current schema migration record
+    Returns:
+        bool: True if migration was performed, False otherwise
+    """
     if schema.version == "2024-03-08":
         version = "2024-03-12"
         aaguid = CharField(null=True)
@@ -142,18 +152,21 @@ def perform_migration(schema: SchemaMigration) -> bool:
             version,
         )
         if altered:
-            perform_migration(schema)
+            return perform_migration(schema)
+        return True
     if schema.version == "2024-03-12":
         version = "2024-05-14"
         database.create_tables([Vote])
-        schema.version = version
-        schema.save()
+        schema.update(version=version).where(SchemaMigration.id == schema.id).execute()
         if version != CURRENT_VERSION:
-            perform_migration(schema)
+            return perform_migration(schema)
+        return True
+    return False  # No migration needed
 
 
 def ensure_migrated():
-    if not config.DB.exists():
+    db_path = Path(config.DB)
+    if not db_path.exists():
         database.create_tables(
             [User, Credential, Session, Component, SchemaMigration, Usage, Vote]
         )

backend/openui/litellm.py

@@ -1,7 +1,7 @@
 import yaml
 import os
 import tempfile
-import openai
+from openai._client import AsyncOpenAI as OpenAI
 from .logs import logger
 
 
@@ -98,7 +98,7 @@ def generate_config():
         )
 
     if "OPENAI_COMPATIBLE_ENDPOINT" in os.environ:
-        client = openai.OpenAI(
+        client = OpenAI(
             api_key=os.getenv("OPENAI_COMPATIBLE_API_KEY"),
             base_url=os.getenv("OPENAI_COMPATIBLE_ENDPOINT"),
         )

backend/openui/openai.py

@@ -1,8 +1,7 @@
 import json
-from openai import AsyncStream
-from openai.types.chat import (
-    ChatCompletionChunk,
-)
+from openai._streaming import AsyncStream
+from openai.types.chat import ChatCompletionChunk
+from typing import AsyncGenerator
 from .db.models import Usage
 
 
@@ -11,7 +10,7 @@ async def openai_stream_generator(
     input_tokens: int,
     user_id: str,
     multiplier: int = 1,
-):
+) -> AsyncGenerator[str, None]:
     # async for chunk in subscription.response.aiter_bytes():
     #    yield chunk
     output_tokens = 0