update

Dockerfile

@@ -1,43 +1,16 @@
-# Dockerfile optimisé pour Hugging Face Spaces
 FROM python:3.10-slim
 
-# Variables d'environnement
-ENV DEBIAN_FRONTEND=noninteractive \
-    OLLAMA_HOST=0.0.0.0 \
-    OLLAMA_KEEP_ALIVE=24h \
-    HF_SPACE=true
-
 # Installer les dépendances système
-RUN apt-get update && apt-get install -y \
-    curl \
-    ca-certificates \
-    zstd \
-    gnupg \
-    wget \
-    && apt-get clean \
-    && rm -rf /var/lib/apt/lists/*
+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 pour Hugging Face
-RUN useradd -m -u 1000 -s /bin/bash user
-USER user
-WORKDIR /home/user
-
 # Copier l'application
-COPY --chown=user:user app.py .
-COPY --chown=user:user requirements.txt .
+COPY app.py .
 
-# Installer les dépendances Python
-RUN pip install --no-cache-dir --user -r requirements.txt
-
-# Exposer les ports (Hugging Face utilise 7860)
+# Exposer le port
 EXPOSE 7860
-EXPOSE 11434
-
-# Script de démarrage optimisé pour HF
-COPY --chown=user:user start.sh .
-RUN chmod +x start.sh
 
-CMD ["./start.sh"]
+# Démarrer
+CMD ["sh", "-c", "ollama serve & sleep 30 && ollama pull deepseek-coder:1.3b && python app.py"]

app.py

@@ -1,267 +1,60 @@
-import gradio as gr
-import requests
+#!/usr/bin/env python3
+"""
+Serveur HTTP minimal pour DeepSeek-Coder
+"""
+import http.server
+import socketserver
 import json
+import subprocess
+import threading
 import time
-from typing import Generator
-import asyncio
-import aiohttp
 
-# Configuration
-OLLAMA_URL = "http://localhost:11434"
-MODEL_NAME = "deepseek-coder:1.3b"
-CUSTOM_MODEL = "deepseek-coder-custom"
-
-class OllamaClient:
-    def __init__(self):
-        self.base_url = OLLAMA_URL
-    
-    def check_health(self) -> bool:
-        """Vérifier si Ollama est en ligne"""
-        try:
-            response = requests.get(f"{self.base_url}/api/tags", timeout=5)
-            return response.status_code == 200
-        except:
-            return False
-    
-    def generate(self, prompt: str, temperature: float = 0.2, max_tokens: int = 1024) -> str:
-        """Générer du texte"""
-        try:
-            payload = {
-                "model": CUSTOM_MODEL,
-                "prompt": prompt,
-                "stream": False,
-                "options": {
-                    "temperature": temperature,
-                    "num_predict": max_tokens,
-                    "top_p": 0.95,
-                    "repeat_penalty": 1.1
-                }
-            }
+# Démarrer Ollama
+def start_ollama():
+    subprocess.run(["ollama", "serve"])
+
+# Lancer Ollama en thread
+threading.Thread(target=start_ollama, daemon=True).start()
+time.sleep(30)
+
+# Télécharger le modèle
+print("Téléchargement du modèle...")
+subprocess.run(["ollama", "pull", "deepseek-coder:1.3b"], capture_output=True)
+
+# HTML simple
+HTML = open("index.html").read() if os.path.exists("index.html") else "<h1>DeepSeek-Coder 1.3B</h1>"
+
+class OllamaHandler(http.server.SimpleHTTPRequestHandler):
+    def do_GET(self):
+        if self.path == "/":
+            self.send_response(200)
+            self.send_header("Content-type", "text/html")
+            self.end_headers()
+            self.wfile.write(HTML.encode())
+        else:
+            super().do_GET()
+    
+    def do_POST(self):
+        if self.path == "/generate":
+            content_length = int(self.headers['Content-Length'])
+            post_data = self.rfile.read(content_length)
+            data = json.loads(post_data)
             
-            response = requests.post(
-                f"{self.base_url}/api/generate",
-                json=payload,
-                timeout=120
+            # Appeler Ollama
+            result = subprocess.run(
+                ["ollama", "run", "deepseek-coder:1.3b", data.get("prompt", "")],
+                capture_output=True,
+                text=True
             )
             
-            if response.status_code == 200:
-                return response.json()["response"]
-            else:
-                return f"Erreur: {response.status_code} - {response.text}"
-                
-        except Exception as e:
-            return f"Erreur de connexion: {str(e)}"
-    
-    async def generate_stream(self, prompt: str, temperature: float = 0.2) -> Generator[str, None, None]:
-        """Générer en streaming"""
-        payload = {
-            "model": CUSTOM_MODEL,
-            "prompt": prompt,
-            "stream": True,
-            "options": {
-                "temperature": temperature,
-                "num_predict": 1024
-            }
-        }
-        
-        async with aiohttp.ClientSession() as session:
-            async with session.post(
-                f"{self.base_url}/api/generate",
-                json=payload,
-                timeout=60
-            ) as response:
-                async for line in response.content:
-                    if line:
-                        try:
-                            data = json.loads(line.decode('utf-8'))
-                            yield data.get("response", "")
-                        except:
-                            continue
-
-# Initialiser le client
-client = OllamaClient()
-
-# Fonctions pour Gradio
-def generate_code(prompt, temperature, language):
-    """Générer du code"""
-    if not prompt.strip():
-        return "❌ Veuillez entrer un prompt"
-    
-    # Ajouter le contexte du langage
-    enhanced_prompt = prompt
-    if language != "auto":
-        enhanced_prompt = f"Écrire en {language}:\n{prompt}"
-    
-    # Vérifier la santé d'Ollama
-    if not client.check_health():
-        return "⚠️ Ollama n'est pas disponible. Veuillez patienter..."
-    
-    # Générer la réponse
-    result = client.generate(enhanced_prompt, temperature)
-    return result
-
-async def generate_stream_ui(prompt, temperature):
-    """Interface de streaming"""
-    if not prompt.strip():
-        yield "❌ Veuillez entrer un prompt"
-        return
-    
-    full_response = ""
-    async for chunk in client.generate_stream(prompt, temperature):
-        full_response += chunk
-        yield full_response
-
-def get_model_info():
-    """Obtenir les informations du modèle"""
-    try:
-        response = requests.get(f"{OLLAMA_URL}/api/tags")
-        if response.status_code == 200:
-            models = response.json().get("models", [])
-            return "\n".join([f"📦 {m['name']} ({m.get('size', 'N/A')})" for m in models])
-        return "⚠️ Impossible de récupérer les informations"
-    except:
-        return "❌ Erreur de connexion"
-
-# Interface Gradio
-with gr.Blocks(
-    theme=gr.themes.Soft(),
-    title="🤖 DeepSeek-Coder 1.3B - Hugging Face",
-    css=".gradio-container {max-width: 900px !important}"
-) as demo:
-    
-    gr.Markdown("""
-    # 🚀 DeepSeek-Coder 1.3B
-    ### Générateur de code IA local sur Hugging Face Spaces
-    
-    Ce modèle fonctionne localement avec **Ollama**. Il génère du code dans plusieurs langages de programmation.
-    """)
-    
-    with gr.Row():
-        with gr.Column(scale=2):
-            # Zone d'entrée
-            prompt = gr.Textbox(
-                label="📝 Prompt",
-                placeholder="Écrire une fonction Python qui calcule la factorielle...",
-                lines=6,
-                max_lines=10
-            )
-            
-            with gr.Row():
-                temperature = gr.Slider(
-                    label="🌡️ Température",
-                    minimum=0.1,
-                    maximum=1.0,
-                    value=0.2,
-                    step=0.1
-                )
-                
-                language = gr.Dropdown(
-                    label="💻 Langage",
-                    choices=[
-                        "auto", "python", "javascript", "java", "cpp", 
-                        "go", "rust", "html", "css", "sql", "bash"
-                    ],
-                    value="auto"
-                )
-            
-            with gr.Row():
-                generate_btn = gr.Button("✨ Générer", variant="primary")
-                stream_btn = gr.Button("⚡ Générer en streaming")
-                clear_btn = gr.Button("🧹 Effacer")
-        
-        with gr.Column(scale=3):
-            # Zone de sortie
-            output = gr.Code(
-                label="📄 Code généré",
-                language="python",
-                lines=15,
-                interactive=False
-            )
-            
-            # Zone de streaming
-            stream_output = gr.Textbox(
-                label="⚡ Streaming",
-                visible=False,
-                lines=15
-            )
-    
-    # Section d'informations
-    with gr.Accordion("ℹ️ Informations système", open=False):
-        with gr.Row():
-            model_info = gr.Textbox(
-                label="Modèles disponibles",
-                value="Chargement...",
-                interactive=False
-            )
-            health_status = gr.Textbox(
-                label="Statut Ollama",
-                value="Vérification...",
-                interactive=False
-            )
-        
-        refresh_btn = gr.Button("🔄 Actualiser")
-    
-    # Section d'exemples
-    with gr.Accordion("📚 Exemples", open=True):
-        examples = gr.Examples(
-            examples=[
-                ["Écrire une fonction qui inverse une chaîne de caractères", "python", 0.2],
-                ["Créer un composant React pour un bouton", "javascript", 0.2],
-                ["Implémenter une liste chaînée en C++", "cpp", 0.2],
-                ["Faire une requête SQL pour trouver les utilisateurs actifs", "sql", 0.2],
-                ["Script bash pour sauvegarder une base de données MySQL", "bash", 0.2]
-            ],
-            inputs=[prompt, language, temperature],
-            outputs=output
-        )
-    
-    # Événements
-    generate_btn.click(
-        fn=generate_code,
-        inputs=[prompt, temperature, language],
-        outputs=output
-    )
-    
-    stream_btn.click(
-        fn=lambda: gr.update(visible=False),
-        outputs=output
-    ).then(
-        fn=lambda: gr.update(visible=True),
-        outputs=stream_output
-    ).then(
-        fn=generate_stream_ui,
-        inputs=[prompt, temperature],
-        outputs=stream_output
-    )
-    
-    clear_btn.click(
-        fn=lambda: ("", "", ""),
-        outputs=[prompt, output, stream_output]
-    )
-    
-    refresh_btn.click(
-        fn=get_model_info,
-        outputs=model_info
-    ).then(
-        fn=lambda: "✅ En ligne" if client.check_health() else "❌ Hors ligne",
-        outputs=health_status
-    )
-    
-    # Initialisation
-    demo.load(
-        fn=get_model_info,
-        outputs=model_info
-    ).then(
-        fn=lambda: "✅ En ligne" if client.check_health() else "❌ Hors ligne",
-        outputs=health_status
-    )
+            self.send_response(200)
+            self.send_header("Content-type", "application/json")
+            self.end_headers()
+            self.wfile.write(json.dumps({"response": result.stdout}).encode())
 
+# Démarrer le serveur
 if __name__ == "__main__":
-    # Démarrer Gradio
-    demo.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=False,
-        debug=False,
-        show_error=True
-    )
+    PORT = 7860
+    with socketserver.TCPServer(("", PORT), OllamaHandler) as httpd:
+        print(f"Serveur démarré sur le port {PORT}")
+        httpd.serve_forever()

requirements.txt

@@ -1,4 +1,4 @@
-gradio==4.19.1
+gradio==3.50.2
 requests==2.31.0
 aiohttp==3.9.1
-websockets>=10.0,<12.0  # Compatible avec gradio
+huggingface-hub==0.20.3