Upload folder using huggingface_hub

Dockerfile

@@ -0,0 +1,12 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+EXPOSE 7860
+
+CMD ["python", "app.py"]

app.py

@@ -0,0 +1,167 @@
+"""
+HuggingFace Space: Code Execution
+Sandboxed Python code execution service
+"""
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+import subprocess
+import tempfile
+import os
+from typing import Optional
+
+app = FastAPI(
+    title="Code Execution Space",
+    description="Sandboxed Python code execution"
+)
+
+
+class CodeRequest(BaseModel):
+    code: str
+    language: str = "python"
+    timeout: int = 10  # seconds
+
+
+class CodeResponse(BaseModel):
+    stdout: str
+    stderr: str
+    returncode: int
+    error: Optional[str] = None
+
+
+# Allowed modules for security
+ALLOWED_MODULES = {
+    "math", "datetime", "json", "re", "random", "collections",
+    "itertools", "functools", "string", "statistics", "decimal",
+    "fractions", "numbers", "operator", "copy", "pprint",
+    "textwrap", "unicodedata", "difflib", "enum", "typing",
+    "dataclasses", "abc", "contextlib", "hashlib", "base64"
+}
+
+
+def validate_code(code: str) -> Optional[str]:
+    """Basic security validation"""
+    
+    # Blocked patterns
+    blocked = [
+        "import os", "import sys", "import subprocess",
+        "__import__", "eval(", "exec(", "compile(",
+        "open(", "file(", "input(",
+        "globals(", "locals(", "vars(",
+        "__builtins__", "__class__", "__bases__",
+        "breakpoint", "exit", "quit"
+    ]
+    
+    for pattern in blocked:
+        if pattern in code:
+            return f"Blocked: {pattern} not allowed"
+    
+    return None
+
+
+@app.get("/")
+async def root():
+    return {
+        "status": "running",
+        "service": "code_execution",
+        "allowed_modules": list(ALLOWED_MODULES)
+    }
+
+
+@app.post("/api/execute", response_model=CodeResponse)
+async def execute_code(request: CodeRequest):
+    """Execute Python code in sandbox"""
+    
+    # Validate
+    error = validate_code(request.code)
+    if error:
+        return CodeResponse(
+            stdout="",
+            stderr=error,
+            returncode=1,
+            error=error
+        )
+    
+    # Only Python supported
+    if request.language != "python":
+        return CodeResponse(
+            stdout="",
+            stderr=f"Unsupported language: {request.language}",
+            returncode=1,
+            error="Only Python is supported"
+        )
+    
+    try:
+        # Write to temp file
+        with tempfile.NamedTemporaryFile(
+            mode="w",
+            suffix=".py",
+            delete=False
+        ) as f:
+            f.write(request.code)
+            temp_path = f.name
+        
+        try:
+            # Execute with resource limits
+            result = subprocess.run(
+                ["python", temp_path],
+                capture_output=True,
+                text=True,
+                timeout=request.timeout,
+                cwd=tempfile.gettempdir(),
+                env={
+                    "PATH": os.environ.get("PATH", ""),
+                    "PYTHONDONTWRITEBYTECODE": "1"
+                }
+            )
+            
+            return CodeResponse(
+                stdout=result.stdout[:10000],  # Limit output
+                stderr=result.stderr[:10000],
+                returncode=result.returncode
+            )
+            
+        finally:
+            # Clean up
+            os.unlink(temp_path)
+            
+    except subprocess.TimeoutExpired:
+        return CodeResponse(
+            stdout="",
+            stderr=f"Execution timeout ({request.timeout}s)",
+            returncode=1,
+            error="Timeout"
+        )
+    except Exception as e:
+        return CodeResponse(
+            stdout="",
+            stderr=str(e),
+            returncode=1,
+            error=str(e)
+        )
+
+
+# For Gradio interface (HF Spaces requirement)
+def gradio_interface():
+    import gradio as gr
+    
+    def execute_wrapper(code):
+        response = execute_code(CodeRequest(code=code))
+        if response.returncode == 0:
+            return response.stdout
+        else:
+            return f"Error: {response.stderr}"
+    
+    iface = gr.Interface(
+        fn=execute_wrapper,
+        inputs=gr.Textbox(lines=10, label="Python Code"),
+        outputs=gr.Textbox(lines=10, label="Output"),
+        title="Code Execution",
+        description="Run Python code in a sandbox"
+    )
+    
+    return iface
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)

requirements.txt

@@ -0,0 +1,4 @@
+fastapi>=0.104.0
+uvicorn>=0.24.0
+pydantic>=2.5.0
+gradio>=4.0.0