minimal FastAPI Docker test v2 - match SpacesExamples pattern

Dockerfile

@@ -1,9 +1,11 @@
-FROM python:3.12-slim
+FROM python:3.9
 
-RUN pip install --no-cache-dir fastapi uvicorn
+WORKDIR /code
 
-COPY app.py .
+COPY ./requirements.txt /code/requirements.txt
 
-EXPOSE 7860
+RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
+
+COPY . .
 
 CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

app.py

@@ -1,8 +1,13 @@
-from fastapi import FastAPI
-from fastapi.responses import JSONResponse
+import http.server
+import json
 
-app = FastAPI()
+class Handler(http.server.BaseHTTPRequestHandler):
+    def do_GET(self):
+        self.send_response(200)
+        self.send_header("Content-Type", "application/json")
+        self.end_headers()
+        self.wfile.write(json.dumps({"status": "ok"}).encode())
 
-@app.get("/")
-async def root():
-    return JSONResponse({"status": "ok", "message": "Altamira is alive"})
+if __name__ == "__main__":
+    server = http.server.HTTPServer(("0.0.0.0", 7860), Handler)
+    server.serve_forever()

prestart.sh

@@ -1,2 +0,0 @@
-#!/bin/bash
-pip install huggingface_hub==0.25.2 --upgrade --quiet

router.py

@@ -1,94 +0,0 @@
-import asyncio
-import time
-from collections import deque
-
-
-class PredictiveContextFilter:
-    def __init__(self, capacity: int = 4096, threshold: float = 0.8):
-        self.capacity = capacity
-        self.threshold = threshold
-        self.window = deque(maxlen=100)
-
-    def estimate_tokens(self, text: str) -> int:
-        return len(text) // 4
-
-    def should_compact(self, text: str) -> bool:
-        ratio = self.estimate_tokens(text) / self.capacity
-        return ratio >= self.threshold
-
-    def compact(self, text: str, target_ratio: float = 0.5) -> str:
-        if not self.should_compact(text):
-            return text
-        target_len = int(self.capacity * target_ratio * 4)
-        if len(text) <= target_len:
-            return text
-        half = target_len // 2
-        return text[:half] + "\n... [compacted] ...\n" + text[-half:]
-
-    async def monitor(self, text: str) -> str:
-        loop_count = 0
-        while self.should_compact(text) and loop_count < 3:
-            text = self.compact(text)
-            loop_count += 1
-        return text
-
-
-class CircuitBreakerState:
-    CLOSED = "closed"
-    OPEN = "open"
-    HALF_OPEN = "half_open"
-
-
-class InferenceRouterCircuitBreaker:
-    def __init__(self, failure_threshold: int = 5, recovery_timeout: float = 30.0):
-        self.failure_threshold = failure_threshold
-        self.recovery_timeout = recovery_timeout
-        self.state = CircuitBreakerState.CLOSED
-        self.failure_count = 0
-        self.last_failure_time = 0.0
-
-    def record_success(self):
-        self.failure_count = 0
-        if self.state == CircuitBreakerState.HALF_OPEN:
-            self.state = CircuitBreakerState.CLOSED
-
-    def record_failure(self):
-        self.failure_count += 1
-        self.last_failure_time = time.time()
-        if self.failure_count >= self.failure_threshold:
-            self.state = CircuitBreakerState.OPEN
-
-    async def call(self, coro_factory, fallback=None):
-        if self.state == CircuitBreakerState.OPEN:
-            if time.time() - self.last_failure_time >= self.recovery_timeout:
-                self.state = CircuitBreakerState.HALF_OPEN
-            elif fallback is not None:
-                return fallback
-            else:
-                raise RuntimeError("Circuit breaker is OPEN")
-        try:
-            result = await coro_factory()
-            self.record_success()
-            return result
-        except Exception as e:
-            self.record_failure()
-            if fallback is not None:
-                return fallback
-            raise e
-
-
-class ParallelEngine:
-    def __init__(self, max_concurrency: int = 4):
-        self.semaphore = asyncio.Semaphore(max_concurrency)
-        self.filter = PredictiveContextFilter()
-        self.breaker = InferenceRouterCircuitBreaker()
-
-    async def run_with_filter(self, text: str, coro_factory) -> str:
-        compacted = await self.filter.monitor(text)
-        return await self.breaker.call(lambda: coro_factory(compacted))
-
-    async def run_parallel(self, tasks: list):
-        async def bounded(task):
-            async with self.semaphore:
-                return await task
-        return await asyncio.gather(*(bounded(t) for t in tasks))

worker.py

@@ -1,94 +0,0 @@
-import asyncio
-import json
-import shutil
-import subprocess
-from pathlib import Path
-
-from fastapi import FastAPI, HTTPException, Request
-from huggingface_hub import HfApi
-
-app = FastAPI(title="Altamira Worker")
-
-CACHE_DIR = Path("/tmp/altamira-cache")
-WORKSPACE_DIR = Path("/tmp/altamira-workspace")
-STAGE_DIRS = [CACHE_DIR / "stage_0", CACHE_DIR / "stage_1", CACHE_DIR / "stage_2"]
-
-api = HfApi()
-
-
-def _ensure_dirs():
-    for d in [CACHE_DIR, WORKSPACE_DIR] + STAGE_DIRS:
-        d.mkdir(parents=True, exist_ok=True)
-
-
-def _rotate_stages():
-    for i in range(len(STAGE_DIRS) - 1, 0, -1):
-        src = STAGE_DIRS[i - 1]
-        dst = STAGE_DIRS[i]
-        if src.exists():
-            if dst.exists():
-                shutil.rmtree(dst)
-            shutil.copytree(src, dst, dirs_exist_ok=True)
-
-
-def _cleanup_stale(keep_last: int = 2):
-    for d in STAGE_DIRS[:-keep_last] if keep_last < len(STAGE_DIRS) else []:
-        if d.exists():
-            shutil.rmtree(d)
-
-
-@app.post("/sync")
-async def sync_repo(repo_id: str, local_path: str = "/tmp/altamira-checkout"):
-    _ensure_dirs()
-    try:
-        subprocess.run(
-            ["git", "clone", f"https://huggingface.co/spaces/{repo_id}", local_path],
-            capture_output=True, text=True, check=False
-        )
-        if not Path(local_path).exists():
-            subprocess.run(
-                ["git", "init", local_path],
-                capture_output=True, check=True,
-            )
-        _rotate_stages()
-        shutil.copytree(local_path, STAGE_DIRS[0], dirs_exist_ok=True)
-        _cleanup_stale()
-        return {"status": "synced", "repo": repo_id, "stage": str(STAGE_DIRS[0])}
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-@app.post("/rotate")
-async def rotate_cache():
-    _ensure_dirs()
-    _rotate_stages()
-    _cleanup_stale()
-    return {"status": "rotated", "stages": [str(d) for d in STAGE_DIRS]}
-
-
-@app.post("/webhook/results")
-async def receive_results(request: Request):
-    try:
-        payload = await request.json()
-        token = request.query_params.get("token")
-        if not token:
-            raise HTTPException(status_code=401, detail="Verification key required")
-        
-        # Log diagnostic payload to local file for Orchestrator to pull
-        log_file = Path("/tmp/altamira-results.json")
-        with open(log_file, "a") as f:
-            f.write(json.dumps(payload) + "\n")
-            
-        return {"status": "received", "payload_size": len(str(payload))}
-    except Exception as e:
-        raise HTTPException(status_code=400, detail=f"Invalid payload: {str(e)}")
-
-
-@app.get("/health")
-async def health():
-    return {"status": "healthy", "worker": "altamira"}
-
-
-if __name__ == "__main__":
-    import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=7860)