update

Dockerfile

@@ -1,34 +1,18 @@
 FROM python:3.10-slim
 
-# Installer les dépendances système
-RUN apt-get update && apt-get install -y \
-    curl \
-    ca-certificates \
-    zstd \
-    && apt-get clean \
-    && rm -rf /var/lib/apt/lists/*
+# Installer curl et zstd pour Ollama
+RUN apt-get update && apt-get install -y curl zstd && rm -rf /var/lib/apt/lists/*
 
 # Installer Ollama
 RUN curl -fsSL https://ollama.ai/install.sh | sh
 
-# Créer un utilisateur non-root
-RUN useradd -m -u 1000 user
-USER user
-WORKDIR /home/user
+# Copier l'API
+COPY api.py .
 
-# Copier l'application
-COPY --chown=user:user api.py .
-COPY --chown=user:user requirements.txt .
-
-# Installer TOUTES les dépendances Python
-RUN pip install --no-cache-dir --user \
-    fastapi==0.104.1 \
-    uvicorn[standard]==0.24.0 \
-    pydantic==2.5.0 \
-    aiohttp==3.9.1 \
-    requests==2.31.0
+# Installer seulement FastAPI et requests
+RUN pip install fastapi uvicorn requests
 
 EXPOSE 7860
 
 # Démarrer
-CMD ["sh", "-c", "ollama serve & sleep 30 && ollama pull deepseek-coder:1.3b && uvicorn api:app --host 0.0.0.0 --port 7860"]
+CMD ["sh", "-c", "ollama serve & sleep 40 && ollama pull deepseek-coder:1.3b && uvicorn api:app --host 0.0.0.0 --port 7860"]

api.py

@@ -1,262 +1,23 @@
-"""
-API Ollama + DeepSeek-Coder 1.3B - Version simplifiée
-"""
-import asyncio
-import json
+from fastapi import FastAPI
+import requests
 import time
-import aiohttp
-from typing import Optional, List, Dict, Any
-from contextlib import asynccontextmanager
 
-from fastapi import FastAPI, HTTPException
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import JSONResponse, StreamingResponse
-from pydantic import BaseModel
+app = FastAPI()
+OLLAMA_URL = "http://localhost:11434"
 
-# ========== MODÈLES ==========
-class GenerateRequest(BaseModel):
-    prompt: str
-    model: str = "deepseek-coder:1.3b"
-    stream: bool = False
-    temperature: float = 0.2
-    max_tokens: int = 512
-
-class ChatMessage(BaseModel):
-    role: str
-    content: str
-
-class ChatRequest(BaseModel):
-    messages: List[ChatMessage]
-    model: str = "deepseek-coder:1.3b"
-    stream: bool = False
-    temperature: float = 0.2
-    max_tokens: int = 512
-
-# ========== CLIENT OLLAMA ==========
-class OllamaClient:
-    def __init__(self):
-        self.base_url = "http://localhost:11434"
-        self.session = None
-    
-    async def get_session(self):
-        if not self.session or self.session.closed:
-            self.session = aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=300))
-        return self.session
-    
-    async def close(self):
-        if self.session and not self.session.closed:
-            await self.session.close()
-    
-    async def health_check(self):
-        """Vérifier si Ollama est en ligne"""
-        try:
-            session = await self.get_session()
-            async with session.get(f"{self.base_url}/api/tags", timeout=10) as resp:
-                return resp.status == 200
-        except:
-            return False
-    
-    async def generate(self, request: Dict) -> Dict:
-        """Génération simple"""
-        try:
-            session = await self.get_session()
-            async with session.post(
-                f"{self.base_url}/api/generate",
-                json=request,
-                timeout=120
-            ) as response:
-                if response.status == 200:
-                    return await response.json()
-                else:
-                    return {"error": f"HTTP {response.status}: {await response.text()}"}
-        except Exception as e:
-            return {"error": str(e)}
-    
-    async def generate_stream(self, request: Dict):
-        """Génération en streaming"""
-        async def stream_generator():
-            try:
-                session = await self.get_session()
-                async with session.post(
-                    f"{self.base_url}/api/generate",
-                    json=request,
-                    timeout=300
-                ) as response:
-                    async for line in response.content:
-                        if line:
-                            yield f"data: {line.decode()}\n\n"
-            except Exception as e:
-                yield f"data: {json.dumps({'error': str(e)})}\n\n"
-        
-        return StreamingResponse(
-            stream_generator(),
-            media_type="text/event-stream"
-        )
-    
-    async def chat(self, request: Dict) -> Dict:
-        """Chat"""
-        try:
-            session = await self.get_session()
-            async with session.post(
-                f"{self.base_url}/api/chat",
-                json=request,
-                timeout=120
-            ) as response:
-                if response.status == 200:
-                    return await response.json()
-                else:
-                    return {"error": f"HTTP {response.status}: {await response.text()}"}
-        except Exception as e:
-            return {"error": str(e)}
-    
-    async def list_models(self) -> List[str]:
-        """Lister les modèles"""
-        try:
-            session = await self.get_session()
-            async with session.get(f"{self.base_url}/api/tags") as response:
-                if response.status == 200:
-                    data = await response.json()
-                    return [m["name"] for m in data.get("models", [])]
-                return []
-        except:
-            return []
-
-# ========== APPLICATION ==========
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    # Démarrage
-    app.state.client = OllamaClient()
-    app.state.start_time = time.time()
-    
-    print("⏳ Attente d'Ollama...")
-    for i in range(30):
-        if await app.state.client.health_check():
-            print("✅ Ollama prêt!")
-            break
-        print(f"  Tentative {i+1}/30")
-        await asyncio.sleep(2)
-    
-    yield
-    
-    # Nettoyage
-    await app.state.client.close()
-
-# Créer l'app
-app = FastAPI(
-    title="DeepSeek-Coder API",
-    description="API pour DeepSeek-Coder 1.3B via Ollama",
-    version="1.0.0",
-    lifespan=lifespan
-)
-
-# CORS
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-# ========== ROUTES ==========
 @app.get("/")
-async def root():
-    return {
-        "service": "DeepSeek-Coder 1.3B API",
-        "endpoints": {
-            "GET /": "Cette page",
-            "GET /health": "Vérifier la santé",
-            "GET /models": "Liste des modèles",
-            "POST /generate": "Générer du texte",
-            "POST /chat": "Chat conversationnel",
-            "GET /docs": "Documentation Swagger"
-        },
-        "model": "deepseek-coder:1.3b",
-        "note": "Le modèle peut prendre 2-3 minutes pour démarrer"
-    }
-
-@app.get("/health")
-async def health():
-    ollama_ready = await app.state.client.health_check()
-    models = await app.state.client.list_models()
-    
-    return {
-        "status": "healthy" if ollama_ready else "starting",
-        "ollama_ready": ollama_ready,
-        "models": models,
-        "uptime": time.time() - app.state.start_time
-    }
-
-@app.get("/models")
-async def get_models():
-    models = await app.state.client.list_models()
-    return {"models": models}
+def root():
+    return {"message": "DeepSeek-Coder API"}
 
 @app.post("/generate")
-async def generate(request: GenerateRequest):
-    """Générer du texte/code"""
-    
-    payload = {
-        "model": request.model,
-        "prompt": request.prompt,
-        "stream": request.stream,
-        "options": {
-            "temperature": request.temperature,
-            "num_predict": request.max_tokens
-        }
-    }
-    
-    if request.stream:
-        return await app.state.client.generate_stream(payload)
-    else:
-        result = await app.state.client.generate(payload)
-        return JSONResponse(content=result)
-
-@app.post("/chat")
-async def chat(request: ChatRequest):
-    """Chat conversationnel"""
-    
-    payload = {
-        "model": request.model,
-        "messages": [msg.dict() for msg in request.messages],
-        "stream": request.stream,
-        "options": {
-            "temperature": request.temperature,
-            "num_predict": request.max_tokens
-        }
-    }
-    
-    if request.stream:
-        return await app.state.client.generate_stream(payload)
-    else:
-        result = await app.state.client.chat(payload)
-        return JSONResponse(content=result)
-
-# Routes compatibles Ollama
-@app.get("/api/tags")
-async def ollama_tags():
-    models = await app.state.client.list_models()
-    return {"models": [{"name": m} for m in models]}
-
-@app.post("/api/generate")
-async def ollama_generate(request: dict):
-    """Route compatible avec l'API Ollama"""
-    if request.get("stream", False):
-        return await app.state.client.generate_stream(request)
-    else:
-        result = await app.state.client.generate(request)
-        return JSONResponse(content=result)
-
-@app.post("/api/chat")
-async def ollama_chat(request: dict):
-    """Route compatible avec l'API Ollama"""
-    if request.get("stream", False):
-        return await app.state.client.generate_stream(request)
-    else:
-        result = await app.state.client.chat(request)
-        return JSONResponse(content=result)
+def generate(prompt: str):
+    response = requests.post(f"{OLLAMA_URL}/api/generate", json={
+        "model": "deepseek-coder:1.3b",
+        "prompt": prompt,
+        "stream": False
+    })
+    return response.json()
 
-# ========== DÉMARRAGE ==========
 if __name__ == "__main__":
     import uvicorn
-    print("🚀 Démarrage de l'API DeepSeek-Coder...")
-    uvicorn.run(app, host="0.0.0.0", port=7860, log_level="info")
+    uvicorn.run(app, host="0.0.0.0", port=7860)