Upload 6 files

Dockerfile

@@ -0,0 +1,23 @@
+FROM python:3.12-slim
+
+# Set environment variables
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1
+
+# Set the working directory
+WORKDIR /app
+
+# Copy requirements file
+COPY requirements.txt .
+
+# Install dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the application code
+COPY . .
+
+# Expose the port the app runs on
+EXPOSE 8001
+
+# Command to run the application
+CMD ["python", "server.py"]

README.md

@@ -1,11 +1 @@
----
-title: Python Enviroment
-emoji: 📚
-colorFrom: gray
-colorTo: gray
-sdk: docker
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# GenAi-web-builder-pyhton-server

requirements.txt

@@ -0,0 +1,4 @@
+fastapi
+uvicorn
+websockets
+psutil

runner.py

@@ -0,0 +1,143 @@
+import asyncio
+import os
+import subprocess
+import sys
+import uuid
+import venv
+import shutil
+from typing import Callable, Optional, Awaitable
+
+class ProcessRunner:
+    def __init__(self, project_id: str, base_dir: str):
+        self.project_id = project_id
+        self.project_path = os.path.join(base_dir, project_id)
+        self.venv_path = os.path.join(self.project_path, "venv")
+        self.process: Optional[asyncio.subprocess.Process] = None
+        self.is_running = False
+
+    async def setup(self, files: list[dict]):
+        if not os.path.exists(self.project_path):
+            os.makedirs(self.project_path)
+
+        for file_info in files:
+            file_path = file_info.get("path")
+            content = file_info.get("content", "")
+            
+            if not file_path:
+                continue
+
+            full_path = os.path.join(self.project_path, file_path)
+            os.makedirs(os.path.dirname(full_path), exist_ok=True)
+            
+            with open(full_path, "w") as f:
+                f.write(content)
+
+        # Create venv if not exists
+        if not os.path.exists(self.venv_path):
+            venv.create(self.venv_path, with_pip=True)
+
+    async def install_dependencies(self, log_callback: Callable[[str], Awaitable[None]]):
+        req_file = os.path.join(self.project_path, "requirements.txt")
+        if not os.path.exists(req_file):
+            return
+
+        pip_path = os.path.join(self.venv_path, "bin", "pip")
+        if sys.platform == "win32":
+            pip_path = os.path.join(self.venv_path, "Scripts", "pip.exe")
+
+        cmd = [pip_path, "install", "-r", req_file]
+        await log_callback(f"Running: {' '.join(cmd)}\n")
+
+        process = await asyncio.create_subprocess_exec(
+            *cmd,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE
+        )
+
+        async def stream_output(stream, prefix=""):
+            while True:
+                line = await stream.readline()
+                if not line:
+                    break
+                await log_callback(line.decode())
+
+        await asyncio.gather(
+            stream_output(process.stdout),
+            stream_output(process.stderr)
+        )
+        await process.wait()
+
+    def detect_command(self):
+        # Look for entry points in the project path
+        python_path = os.path.join(self.venv_path, "bin", "python")
+        if sys.platform == "win32":
+            python_path = os.path.join(self.venv_path, "Scripts", "python.exe")
+
+        entry_point = "app.py"
+        if os.path.exists(os.path.join(self.project_path, "main.py")):
+            entry_point = "main.py"
+        
+        with open(os.path.join(self.project_path, entry_point), "r") as f:
+            code = f.read()
+
+        if "FastAPI" in code:
+            uvicorn_path = os.path.join(self.venv_path, "bin", "uvicorn")
+            if sys.platform == "win32":
+                uvicorn_path = os.path.join(self.venv_path, "Scripts", "uvicorn.exe")
+            # Handle main vs app module
+            module = entry_point.replace(".py", "")
+            return [uvicorn_path, f"{module}:app", "--host", "0.0.0.0", "--port", "8000"]
+        
+        if "Flask(" in code:
+            return [python_path, entry_point]
+        
+        if "django" in code.lower():
+            return [python_path, "manage.py", "runserver", "0.0.0.0:8000"]
+
+        return [python_path, entry_point]
+
+    async def run(self, log_callback: Callable[[str], Awaitable[None]]):
+        if self.process:
+            try:
+                self.process.terminate()
+                await self.process.wait()
+            except:
+                pass
+
+        cmd = self.detect_command()
+        await log_callback(f"Starting process: {' '.join(cmd)}\n")
+
+        self.process = await asyncio.create_subprocess_exec(
+            *cmd,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+            cwd=self.project_path
+        )
+        self.is_running = True
+
+        async def stream_output(stream):
+            while True:
+                line = await stream.readline()
+                if not line:
+                    break
+                await log_callback(line.decode())
+
+        # Run streams in background
+        asyncio.create_task(stream_output(self.process.stdout))
+        asyncio.create_task(stream_output(self.process.stderr))
+
+    async def stop(self):
+        if self.process:
+            try:
+                self.process.terminate()
+                await self.process.wait()
+            except ProcessLookupError:
+                pass
+            except Exception as e:
+                print(f"Error stopping process: {e}")
+            self.process = None
+        self.is_running = False
+
+    def cleanup(self):
+        if os.path.exists(self.project_path):
+            shutil.rmtree(self.project_path)

server.py

@@ -0,0 +1,101 @@
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect
+from fastapi.middleware.cors import CORSMiddleware
+import json
+import asyncio
+import os
+import uuid
+import shutil
+from runner import ProcessRunner
+
+app = FastAPI()
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+PROJECTS_DIR = os.path.join(os.path.dirname(__file__), "projects")
+if not os.path.exists(PROJECTS_DIR):
+    os.makedirs(PROJECTS_DIR)
+
+active_runners = {}
+
+def cleanup_old_projects():
+    try:
+        projects = []
+        for name in os.listdir(PROJECTS_DIR):
+            path = os.path.join(PROJECTS_DIR, name)
+            if os.path.isdir(path):
+                mtime = os.stat(path).st_mtime
+                projects.append((mtime, name, path))
+        
+        # Sort by modification time, newest first
+        projects.sort(reverse=True)
+        
+        # Keep the 4 newest, delete the rest so we have max 5 after creating a new one
+        for _, name, path in projects[4:]:
+            if name not in active_runners:
+                shutil.rmtree(path, ignore_errors=True)
+    except Exception as e:
+        print(f"Error cleaning up projects: {e}")
+
+@app.websocket("/ws/run")
+async def websocket_endpoint(websocket: WebSocket):
+    await websocket.accept()
+    cleanup_old_projects()
+    project_id = str(uuid.uuid4())
+    runner = ProcessRunner(project_id, PROJECTS_DIR)
+    active_runners[project_id] = runner
+    
+    try:
+        while True:
+            data = await websocket.receive_text()
+            payload = json.loads(data)
+            
+            files = payload.get("files", [])
+            
+            if not files:
+                await websocket.send_text(json.dumps({"type": "error", "message": "No files provided"}))
+                continue
+
+            async def log_callback(msg: str):
+                await websocket.send_text(json.dumps({"type": "log", "content": msg}))
+
+            await log_callback(f"✦ Preparing environment for project {project_id}...\n")
+            await runner.setup(files)
+            
+            await log_callback("✦ Synchronizing dependencies...\n")
+            await runner.install_dependencies(log_callback)
+            
+            await log_callback("🚀 Launching application...\n")
+            await runner.run(log_callback)
+            
+            # Keep connection open and monitor for timeout or closure
+            # In a real production app, we'd have more complex process management here
+            try:
+                # Wait for disconnect or some signal from client
+                while True:
+                    await asyncio.wait_for(websocket.receive_text(), timeout=3600)
+            except asyncio.TimeoutError:
+                await log_callback("\n[System] Session heartbeat timeout (1 hour).\n")
+
+    except WebSocketDisconnect:
+        print(f"Client disconnected: {project_id}")
+    except Exception as e:
+        print(f"Error: {e}")
+        try:
+            await websocket.send_text(json.dumps({"type": "error", "message": str(e)}))
+        except:
+            pass
+    finally:
+        await runner.stop()
+        # runner.cleanup() # Optional: keep files for debugging or clean them up
+        if project_id in active_runners:
+            del active_runners[project_id]
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8001)

verify_runner.py

@@ -0,0 +1,46 @@
+import asyncio
+import websockets
+import json
+
+async def test_runner():
+    uri = "ws://localhost:8001/ws/run"
+    async with websockets.connect(uri) as websocket:
+        code = """
+from flask import Flask
+app = Flask(__name__)
+
+@app.route('/')
+def hello():
+    return "Hello from Backend Python Runner!"
+
+if __name__ == '__main__':
+    app.run(host='0.0.0.0', port=5000)
+"""
+        payload = {
+            "code": code,
+            "requirements": "flask"
+        }
+        
+        print("Sending payload...")
+        await websocket.send(json.dumps(payload))
+        
+        print("Waiting for logs...")
+        try:
+            while True:
+                response = await websocket.recv()
+                data = json.loads(response)
+                
+                if data["type"] == "log":
+                    print(f"LOG: {data['content']}", end="")
+                    # Check if Flask started
+                    if "Running on http" in data["content"]:
+                        print("\n[SUCCESS] Flask is running!")
+                        break
+                elif data["type"] == "error":
+                    print(f"ERROR: {data['message']}")
+                    break
+        except Exception as e:
+            print(f"Exception: {e}")
+
+if __name__ == "__main__":
+    asyncio.run(test_runner())