clovis 0.2.0__tar.gz → 0.3.0__tar.gz

clovis-0.3.0/PKG-INFO

@@ -0,0 +1,98 @@
+Metadata-Version: 2.4
+Name: clovis
+Version: 0.3.0
+Summary: cloooooo — personal LLM client, prompt/context/thinking interface over local Ollama
+Author: Clovis Sfeir
+License: MIT
+Keywords: ai,llm,local-ai,ollama,openai
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Requires-Dist: fastapi>=0.111
+Requires-Dist: httpx>=0.27
+Requires-Dist: pydantic>=2.0
+Requires-Dist: rich>=13.0
+Requires-Dist: typer>=0.12
+Requires-Dist: uvicorn[standard]>=0.30
+Description-Content-Type: text/markdown
+
+# clovis
+
+Client Python personnel pour un LLM local via [Ollama](https://ollama.com). Interface ultra-simple : `prompt`, `negative_prompt`, `thinking`, `context`.
+
+## Install
+
+```bash
+pip install clovis
+```
+
+## Usage
+
+```python
+from clovis import cloooooo
+
+ai = cloooooo()
+
+# Appel direct
+print(ai("Explique les trous noirs"))
+
+# Avec options
+print(ai(
+    "Génère un poème sur la mer",
+    negative_prompt="pas de rimes",
+    thinking=True,
+    context="Tu es un poète du 19e siècle.",
+))
+
+# Streaming token par token
+for token in ai.stream("Raconte une histoire courte"):
+    print(token, end="", flush=True)
+
+# Conversation avec mémoire
+conv = ai.conversation(context="Tu es un expert en finance.")
+conv("Explique le CAPM")
+conv("Et ses limites ?")  # se souvient de la réponse précédente
+```
+
+## CLI
+
+```bash
+clovis "Explique les trous noirs"           # question directe
+clovis "Génère un poème" --no "sans rimes"  # avec negative prompt
+clovis "Résous ce problème" --think          # mode réflexion
+clovis repl                                  # conversation interactive
+clovis serve --port 8000                     # démarre le serveur API
+```
+
+## API server
+
+```bash
+clovis serve --port 8000 --key sk-montoken
+```
+
+Requête :
+
+```bash
+curl -X POST http://localhost:8000/ia \
+  -H "Authorization: Bearer sk-montoken" \
+  -H "Content-Type: application/json" \
+  -d '{"prompt": "Bonjour !", "thinking": false}'
+```
+
+Réponse : `{"response": "Bonjour ! Comment puis-je t'aider ?"}`
+
+Streaming : ajouter `"stream": true` → réponse en `text/plain` token par token.
+
+## Config
+
+```bash
+export CLOVIS_MODEL="qwen3-72b-q5km"        # modèle Ollama
+export CLOVIS_OLLAMA_URL="http://localhost:11434"
+export CLOVIS_API_KEY="sk-..."              # clé API pour le serveur
+```

clovis-0.3.0/README.md

@@ -0,0 +1,74 @@
+# clovis
+
+Client Python personnel pour un LLM local via [Ollama](https://ollama.com). Interface ultra-simple : `prompt`, `negative_prompt`, `thinking`, `context`.
+
+## Install
+
+```bash
+pip install clovis
+```
+
+## Usage
+
+```python
+from clovis import cloooooo
+
+ai = cloooooo()
+
+# Appel direct
+print(ai("Explique les trous noirs"))
+
+# Avec options
+print(ai(
+    "Génère un poème sur la mer",
+    negative_prompt="pas de rimes",
+    thinking=True,
+    context="Tu es un poète du 19e siècle.",
+))
+
+# Streaming token par token
+for token in ai.stream("Raconte une histoire courte"):
+    print(token, end="", flush=True)
+
+# Conversation avec mémoire
+conv = ai.conversation(context="Tu es un expert en finance.")
+conv("Explique le CAPM")
+conv("Et ses limites ?")  # se souvient de la réponse précédente
+```
+
+## CLI
+
+```bash
+clovis "Explique les trous noirs"           # question directe
+clovis "Génère un poème" --no "sans rimes"  # avec negative prompt
+clovis "Résous ce problème" --think          # mode réflexion
+clovis repl                                  # conversation interactive
+clovis serve --port 8000                     # démarre le serveur API
+```
+
+## API server
+
+```bash
+clovis serve --port 8000 --key sk-montoken
+```
+
+Requête :
+
+```bash
+curl -X POST http://localhost:8000/ia \
+  -H "Authorization: Bearer sk-montoken" \
+  -H "Content-Type: application/json" \
+  -d '{"prompt": "Bonjour !", "thinking": false}'
+```
+
+Réponse : `{"response": "Bonjour ! Comment puis-je t'aider ?"}`
+
+Streaming : ajouter `"stream": true` → réponse en `text/plain` token par token.
+
+## Config
+
+```bash
+export CLOVIS_MODEL="qwen3-72b-q5km"        # modèle Ollama
+export CLOVIS_OLLAMA_URL="http://localhost:11434"
+export CLOVIS_API_KEY="sk-..."              # clé API pour le serveur
+```

{clovis-0.2.0 → clovis-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "clovis"
-version = "0.2.0"
+version = "0.3.0"
 description = "cloooooo — personal LLM client, prompt/context/thinking interface over local Ollama"
 readme = "README.md"
 license = { text = "MIT" }

{clovis-0.2.0 → clovis-0.3.0}/src/clovis/__init__.py

@@ -1,4 +1,4 @@
 from ._client import cloooooo
 
 __all__ = ["cloooooo"]
-__version__ = "0.2.0"
+__version__ = "0.3.0"

clovis-0.3.0/src/clovis/_client.py

@@ -0,0 +1,170 @@
+from __future__ import annotations
+
+import json
+import os
+from typing import Iterator, Optional
+
+import httpx
+
+_SERVER_URL = "https://cloooooo.com"   # API publique par défaut
+_OLLAMA_URL = "http://localhost:11434"  # fallback local
+_MODEL = "qwen3:14b"
+
+
+def _build_messages(
+    prompt: str,
+    context: Optional[str],
+    negative_prompt: Optional[str],
+    thinking: bool,
+    history: list[dict],
+) -> list[dict]:
+    system_parts = []
+    if context:
+        system_parts.append(context)
+    if negative_prompt:
+        system_parts.append(f"Évite absolument dans ta réponse : {negative_prompt}")
+    if thinking:
+        system_parts.append("Réfléchis étape par étape avant de répondre.")
+
+    messages = []
+    if system_parts:
+        messages.append({"role": "system", "content": "\n".join(system_parts)})
+    messages.extend(history)
+    messages.append({"role": "user", "content": prompt})
+    return messages
+
+
+class Conversation:
+    def __init__(self, ai: "cloooooo", context: Optional[str] = None) -> None:
+        self._ai = ai
+        self._context = context
+        self._history: list[dict] = []
+
+    def __call__(self, prompt: str, *, negative_prompt: Optional[str] = None, thinking: bool = False) -> str:
+        messages = _build_messages(prompt, self._context, negative_prompt, thinking, self._history)
+        reply = self._ai._send(messages)
+        self._history += [{"role": "user", "content": prompt}, {"role": "assistant", "content": reply}]
+        return reply
+
+    def stream(self, prompt: str, *, negative_prompt: Optional[str] = None, thinking: bool = False) -> Iterator[str]:
+        messages = _build_messages(prompt, self._context, negative_prompt, thinking, self._history)
+        full = ""
+        for token in self._ai._stream(messages):
+            full += token
+            yield token
+        self._history += [{"role": "user", "content": prompt}, {"role": "assistant", "content": full}]
+
+    def reset(self) -> None:
+        self._history.clear()
+
+
+class cloooooo:
+    """
+    from clovis import cloooooo
+
+    ai = cloooooo()                        # → cloooooo.com (aucune config requise)
+    ai = cloooooo(local=True)              # → localhost:11434
+    ai = cloooooo(server="http://...")     # → serveur custom
+
+    print(ai("Explique les trous noirs"))
+    print(ai("Écris un poème", negative_prompt="sans rimes", thinking=True))
+    for token in ai.stream("Raconte une histoire"): print(token, end="", flush=True)
+    conv = ai.conversation(context="Tu es un expert en finance")
+    conv("Explique le CAPM") ; conv("Et ses limites ?")
+    """
+
+    def __init__(
+        self,
+        server: Optional[str] = None,
+        *,
+        local: bool = False,
+        ollama_url: Optional[str] = None,
+        model: str = _MODEL,
+    ) -> None:
+        # Priorité : server arg > CLOVIS_SERVER env > cloooooo.com
+        # Si local=True ou CLOVIS_OLLAMA_URL défini → mode Ollama direct
+        env_server = os.getenv("CLOVIS_SERVER")
+        env_ollama = os.getenv("CLOVIS_OLLAMA_URL")
+
+        if local or ollama_url or env_ollama:
+            self._mode = "ollama"
+            self._url = ollama_url or env_ollama or _OLLAMA_URL
+            self._model = os.getenv("CLOVIS_MODEL", model)
+        else:
+            self._mode = "server"
+            self._url = server or env_server or _SERVER_URL
+
+        self._http = httpx.Client()
+
+    def __call__(self, prompt: str, *, negative_prompt: Optional[str] = None, thinking: bool = False, context: Optional[str] = None) -> str:
+        if self._mode == "server":
+            return self._call_server(prompt, negative_prompt=negative_prompt, thinking=thinking, context=context)
+        messages = _build_messages(prompt, context, negative_prompt, thinking, [])
+        return self._send(messages)
+
+    def stream(self, prompt: str, *, negative_prompt: Optional[str] = None, thinking: bool = False, context: Optional[str] = None) -> Iterator[str]:
+        if self._mode == "server":
+            yield from self._stream_server(prompt, negative_prompt=negative_prompt, thinking=thinking, context=context)
+            return
+        messages = _build_messages(prompt, context, negative_prompt, thinking, [])
+        yield from self._stream(messages)
+
+    def conversation(self, context: Optional[str] = None) -> Conversation:
+        return Conversation(self, context=context)
+
+    # --- mode server (cloooooo.com/ia) ---
+
+    def _call_server(self, prompt: str, **kwargs) -> str:
+        resp = self._http.post(
+            f"{self._url}/ia",
+            json={"prompt": prompt, **{k: v for k, v in kwargs.items() if v is not None}},
+            timeout=120,
+        )
+        resp.raise_for_status()
+        return resp.json()["response"]
+
+    def _stream_server(self, prompt: str, **kwargs) -> Iterator[str]:
+        with self._http.stream(
+            "POST",
+            f"{self._url}/ia",
+            json={"prompt": prompt, "stream": True, **{k: v for k, v in kwargs.items() if v is not None}},
+            timeout=120,
+        ) as resp:
+            resp.raise_for_status()
+            for chunk in resp.iter_text():
+                if chunk:
+                    yield chunk
+
+    # --- mode ollama (local) ---
+
+    def _send(self, messages: list[dict]) -> str:
+        resp = self._http.post(
+            f"{self._url}/api/chat",
+            json={"model": self._model, "messages": messages, "stream": False, "think": False},
+            timeout=120,
+        )
+        resp.raise_for_status()
+        return resp.json()["message"]["content"]
+
+    def _stream(self, messages: list[dict]) -> Iterator[str]:
+        with self._http.stream(
+            "POST",
+            f"{self._url}/api/chat",
+            json={"model": self._model, "messages": messages, "stream": True, "think": False},
+            timeout=120,
+        ) as resp:
+            resp.raise_for_status()
+            for line in resp.iter_lines():
+                if not line:
+                    continue
+                data = json.loads(line)
+                token = data.get("message", {}).get("content", "")
+                if token:
+                    yield token
+                if data.get("done"):
+                    break
+
+    @classmethod
+    def serve(cls, port: int = 8000, host: str = "0.0.0.0", api_key: Optional[str] = None) -> None:
+        from ._server import start_server
+        start_server(host=host, port=port, api_key=api_key)

clovis-0.3.0/test_live.py

@@ -0,0 +1,108 @@
+"""Test live end-to-end — lance avec : python3 test_live.py"""
+import os
+import sys
+
+
+def test_import():
+    from clovis import cloooooo
+    ai = cloooooo()
+    print(f"  import OK — modèle: {ai._model}, url: {ai._url}")
+
+
+def test_basic_call():
+    from clovis import cloooooo
+    ai = cloooooo()
+    resp = ai('Réponds uniquement par le mot "ok".')
+    assert isinstance(resp, str) and len(resp) > 0
+    print(f"  appel OK — réponse: {resp!r}")
+
+
+def test_negative_prompt():
+    from clovis import cloooooo
+    ai = cloooooo()
+    resp = ai("Présente-toi en 10 mots.", negative_prompt="ne mentionne pas ton nom")
+    assert isinstance(resp, str) and len(resp) > 0
+    print(f"  negative_prompt OK — réponse: {resp!r}")
+
+
+def test_thinking():
+    from clovis import cloooooo
+    ai = cloooooo()
+    resp = ai("Combien font 17 × 23 ?", thinking=True)
+    assert isinstance(resp, str) and len(resp) > 0
+    print(f"  thinking OK — réponse: {resp!r}")
+
+
+def test_context():
+    from clovis import cloooooo
+    ai = cloooooo()
+    resp = ai("Comment ça va ?", context="Tu es un pirate des Caraïbes. Réponds toujours en argot de marin.")
+    assert isinstance(resp, str) and len(resp) > 0
+    print(f"  context OK — réponse: {resp!r}")
+
+
+def test_stream():
+    from clovis import cloooooo
+    ai = cloooooo()
+    tokens = list(ai.stream("Compte jusqu'à 5, un nombre par ligne."))
+    assert len(tokens) > 0
+    full = "".join(tokens)
+    assert len(full) > 0
+    print(f"  stream OK — {len(tokens)} tokens, texte: {full!r}")
+
+
+def test_conversation():
+    from clovis import cloooooo
+    ai = cloooooo()
+    conv = ai.conversation(context="Réponds toujours en une seule phrase courte.")
+    r1 = conv("Mon prénom est Clovis.")
+    r2 = conv("Quel est mon prénom ?")
+    assert "Clovis" in r2 or "clovis" in r2.lower(), f"Prénom pas mémorisé: {r2!r}"
+    print(f"  conversation OK — mémoire: {r2!r}")
+
+
+def test_conversation_stream():
+    from clovis import cloooooo
+    ai = cloooooo()
+    conv = ai.conversation()
+    tokens = list(conv.stream("Dis bonjour en 3 langues."))
+    full = "".join(tokens)
+    assert len(full) > 0
+    print(f"  conversation stream OK — {len(tokens)} tokens")
+
+
+def test_conversation_reset():
+    from clovis import cloooooo
+    ai = cloooooo()
+    conv = ai.conversation()
+    conv("Mon prénom est Clovis.")
+    conv.reset()
+    assert len(conv._history) == 0
+    print("  conversation reset OK")
+
+
+if __name__ == "__main__":
+    tests = [
+        test_import,
+        test_basic_call,
+        test_negative_prompt,
+        test_thinking,
+        test_context,
+        test_stream,
+        test_conversation,
+        test_conversation_stream,
+        test_conversation_reset,
+    ]
+    passed = 0
+    for t in tests:
+        print(f"\n{t.__name__}")
+        try:
+            t()
+            passed += 1
+        except Exception as e:
+            print(f"  FAILED: {e}")
+            import traceback; traceback.print_exc()
+
+    print(f"\n{'='*40}")
+    print(f"Résultat: {passed}/{len(tests)} tests passés")
+    sys.exit(0 if passed == len(tests) else 1)

clovis-0.2.0/PKG-INFO

@@ -1,79 +0,0 @@
-Metadata-Version: 2.4
-Name: clovis
-Version: 0.2.0
-Summary: cloooooo — personal LLM client, prompt/context/thinking interface over local Ollama
-Author: Clovis Sfeir
-License: MIT
-Keywords: ai,llm,local-ai,ollama,openai
-Classifier: Development Status :: 3 - Alpha
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
-Requires-Python: >=3.10
-Requires-Dist: fastapi>=0.111
-Requires-Dist: httpx>=0.27
-Requires-Dist: pydantic>=2.0
-Requires-Dist: rich>=13.0
-Requires-Dist: typer>=0.12
-Requires-Dist: uvicorn[standard]>=0.30
-Description-Content-Type: text/markdown
-
-# clovis
-
-OpenAI-compatible Python client over a local [Ollama](https://ollama.com) instance.
-
-## Install
-
-```bash
-pip install clovis
-```
-
-## Usage
-
-```python
-from clovis import cloooooo
-
-client = cloooooo()  # connects to localhost:11434 by default
-
-# Chat
-resp = client.chat.completions.create(
-    model="qwen3-72b",
-    messages=[{"role": "user", "content": "Bonjour !"}]
-)
-print(resp.choices[0].message.content)
-
-# Streaming
-for chunk in client.chat.completions.create(
-    messages=[{"role": "user", "content": "Écris un poème"}],
-    stream=True,
-):
-    print(chunk.choices[0].delta.get("content", ""), end="", flush=True)
-
-# Conversation with auto history
-with client.conversation(system="Tu es un expert en finance.") as conv:
-    print(conv.chat("Explique le CAPM"))
-    print(conv.chat("Et ses limites ?"))  # remembers context
-
-# Start API server
-cloooooo.serve(port=8000, api_key="sk-...")
-```
-
-## CLI
-
-```bash
-clovis "Explique les trous noirs"   # direct question
-clovis repl                          # interactive conversation
-clovis serve --port 8000             # start API server
-```
-
-## Config
-
-```bash
-export CLOVIS_MODEL="qwen3-72b"
-export CLOVIS_OLLAMA_URL="http://localhost:11434"
-export CLOVIS_API_KEY="sk-..."
-```

clovis-0.2.0/README.md

@@ -1,55 +0,0 @@
-# clovis
-
-OpenAI-compatible Python client over a local [Ollama](https://ollama.com) instance.
-
-## Install
-
-```bash
-pip install clovis
-```
-
-## Usage
-
-```python
-from clovis import cloooooo
-
-client = cloooooo()  # connects to localhost:11434 by default
-
-# Chat
-resp = client.chat.completions.create(
-    model="qwen3-72b",
-    messages=[{"role": "user", "content": "Bonjour !"}]
-)
-print(resp.choices[0].message.content)
-
-# Streaming
-for chunk in client.chat.completions.create(
-    messages=[{"role": "user", "content": "Écris un poème"}],
-    stream=True,
-):
-    print(chunk.choices[0].delta.get("content", ""), end="", flush=True)
-
-# Conversation with auto history
-with client.conversation(system="Tu es un expert en finance.") as conv:
-    print(conv.chat("Explique le CAPM"))
-    print(conv.chat("Et ses limites ?"))  # remembers context
-
-# Start API server
-cloooooo.serve(port=8000, api_key="sk-...")
-```
-
-## CLI
-
-```bash
-clovis "Explique les trous noirs"   # direct question
-clovis repl                          # interactive conversation
-clovis serve --port 8000             # start API server
-```
-
-## Config
-
-```bash
-export CLOVIS_MODEL="qwen3-72b"
-export CLOVIS_OLLAMA_URL="http://localhost:11434"
-export CLOVIS_API_KEY="sk-..."
-```

clovis-0.2.0/src/clovis/_client.py

@@ -1,154 +0,0 @@
-from __future__ import annotations
-
-import json
-import os
-from typing import Iterator, Optional
-
-import httpx
-
-_OLLAMA_URL = "http://localhost:11434"
-_MODEL = "qwen3-72b-q5km"
-
-
-def _build_messages(
-    prompt: str,
-    context: Optional[str],
-    negative_prompt: Optional[str],
-    thinking: bool,
-    history: list[dict],
-) -> list[dict]:
-    system_parts = []
-    if context:
-        system_parts.append(context)
-    if negative_prompt:
-        system_parts.append(f"Évite absolument dans ta réponse : {negative_prompt}")
-    if thinking:
-        system_parts.append("Réfléchis étape par étape avant de répondre.")
-
-    messages = []
-    if system_parts:
-        messages.append({"role": "system", "content": "\n".join(system_parts)})
-    messages.extend(history)
-    messages.append({"role": "user", "content": prompt})
-    return messages
-
-
-class Conversation:
-    def __init__(self, ai: "cloooooo", context: Optional[str] = None) -> None:
-        self._ai = ai
-        self._context = context
-        self._history: list[dict] = []
-
-    def __call__(
-        self,
-        prompt: str,
-        *,
-        negative_prompt: Optional[str] = None,
-        thinking: bool = False,
-    ) -> str:
-        messages = _build_messages(prompt, self._context, negative_prompt, thinking, self._history)
-        reply = self._ai._send(messages)
-        self._history += [{"role": "user", "content": prompt}, {"role": "assistant", "content": reply}]
-        return reply
-
-    def stream(
-        self,
-        prompt: str,
-        *,
-        negative_prompt: Optional[str] = None,
-        thinking: bool = False,
-    ) -> Iterator[str]:
-        messages = _build_messages(prompt, self._context, negative_prompt, thinking, self._history)
-        full = ""
-        for token in self._ai._stream(messages):
-            full += token
-            yield token
-        self._history += [{"role": "user", "content": prompt}, {"role": "assistant", "content": full}]
-
-    def reset(self) -> None:
-        self._history.clear()
-
-
-class cloooooo:
-    """
-    Usage::
-
-        from clovis import cloooooo
-
-        ai = cloooooo()
-        print(ai("Explique les trous noirs"))
-        print(ai("Génère un poème", negative_prompt="pas de rimes", thinking=True))
-
-        for token in ai.stream("Raconte une histoire"):
-            print(token, end="", flush=True)
-
-        conv = ai.conversation(context="Tu es un expert en finance")
-        conv("Explique le CAPM")
-        conv("Et ses limites ?")  # se souvient du contexte
-    """
-
-    def __init__(
-        self,
-        ollama_url: str = _OLLAMA_URL,
-        model: str = _MODEL,
-    ) -> None:
-        self._url = os.getenv("CLOVIS_OLLAMA_URL", ollama_url)
-        self._model = os.getenv("CLOVIS_MODEL", model)
-        self._http = httpx.Client()
-
-    def __call__(
-        self,
-        prompt: str,
-        *,
-        negative_prompt: Optional[str] = None,
-        thinking: bool = False,
-        context: Optional[str] = None,
-    ) -> str:
-        messages = _build_messages(prompt, context, negative_prompt, thinking, [])
-        return self._send(messages)
-
-    def stream(
-        self,
-        prompt: str,
-        *,
-        negative_prompt: Optional[str] = None,
-        thinking: bool = False,
-        context: Optional[str] = None,
-    ) -> Iterator[str]:
-        messages = _build_messages(prompt, context, negative_prompt, thinking, [])
-        return self._stream(messages)
-
-    def conversation(self, context: Optional[str] = None) -> Conversation:
-        return Conversation(self, context=context)
-
-    def _send(self, messages: list[dict]) -> str:
-        resp = self._http.post(
-            f"{self._url}/api/chat",
-            json={"model": self._model, "messages": messages, "stream": False},
-            timeout=600,
-        )
-        resp.raise_for_status()
-        return resp.json()["message"]["content"]
-
-    def _stream(self, messages: list[dict]) -> Iterator[str]:
-        with self._http.stream(
-            "POST",
-            f"{self._url}/api/chat",
-            json={"model": self._model, "messages": messages, "stream": True},
-            timeout=600,
-        ) as resp:
-            resp.raise_for_status()
-            for line in resp.iter_lines():
-                if not line:
-                    continue
-                data = json.loads(line)
-                token = data.get("message", {}).get("content", "")
-                if token:
-                    yield token
-                if data.get("done"):
-                    break
-
-    @classmethod
-    def serve(cls, port: int = 8000, host: str = "0.0.0.0", api_key: Optional[str] = None) -> None:
-        from ._server import start_server
-        start_server(host=host, port=port, api_key=api_key)

clovis-0.2.0/test_live.py

@@ -1,78 +0,0 @@
-"""Test live end-to-end — lance avec : python3 test_live.py"""
-from clovis import cloooooo, ClovisConnectionError, ClovisModelNotFound
-
-TEST_MODEL = "gemma3:4b"  # petit modèle pour le test, qwen3-72b-q5km après
-
-def test_basic_chat():
-    client = cloooooo(model=TEST_MODEL)
-    resp = client.chat.completions.create(
-        messages=[{"role": "user", "content": "Réponds juste 'ok' et rien d'autre."}]
-    )
-    assert resp.choices[0].message.content
-    assert resp.choices[0].message.role == "assistant"
-    assert resp.usage.total_tokens > 0
-    print(f"  chat OK — réponse : {resp.choices[0].message.content!r}")
-
-def test_streaming():
-    client = cloooooo(model=TEST_MODEL)
-    chunks = list(client.chat.completions.create(
-        messages=[{"role": "user", "content": "Dis juste 'bonjour'."}],
-        stream=True,
-    ))
-    full = "".join(c.choices[0].delta.get("content", "") for c in chunks)
-    assert len(full) > 0
-    print(f"  streaming OK — {len(chunks)} chunks, texte : {full!r}")
-
-def test_conversation():
-    client = cloooooo(model=TEST_MODEL)
-    with client.conversation(system="Réponds toujours en une seule phrase.") as conv:
-        r1 = conv.chat("Mon prénom est Clovis.")
-        r2 = conv.chat("Quel est mon prénom ?")
-    assert "Clovis" in r2 or "clovis" in r2.lower()
-    assert len(conv.history) == 5  # system + 2x (user+assistant)
-    print(f"  conversation OK — mémoire : {r2!r}")
-
-def test_models_list():
-    client = cloooooo(model=TEST_MODEL)
-    models = client.models()
-    assert isinstance(models, list)
-    assert len(models) > 0
-    print(f"  models() OK — {models}")
-
-def test_model_not_found():
-    client = cloooooo(model="inexistant:99b")
-    try:
-        client.chat.completions.create(
-            messages=[{"role": "user", "content": "test"}]
-        )
-        assert False, "Aurait dû lever ClovisModelNotFound"
-    except ClovisModelNotFound as e:
-        print(f"  ClovisModelNotFound OK — {e}")
-
-def test_connection_error():
-    try:
-        cloooooo(ollama_url="http://localhost:9999")
-        assert False, "Aurait dû lever ClovisConnectionError"
-    except ClovisConnectionError as e:
-        print(f"  ClovisConnectionError OK — {e}")
-
-if __name__ == "__main__":
-    tests = [
-        test_basic_chat,
-        test_streaming,
-        test_conversation,
-        test_models_list,
-        test_model_not_found,
-        test_connection_error,
-    ]
-    passed = 0
-    for t in tests:
-        print(f"\n{t.__name__}")
-        try:
-            t()
-            passed += 1
-        except Exception as e:
-            print(f"  FAILED: {e}")
-
-    print(f"\n{'='*40}")
-    print(f"Résultat : {passed}/{len(tests)} tests passés")