clovis 0.1.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.1.0 → clovis-0.3.0}/pyproject.toml

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

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

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

clovis-0.3.0/src/clovis/_cli.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+import os
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.live import Live
+from rich.markdown import Markdown
+
+app = typer.Typer(help="cloooooo — LLM personnel", add_completion=True)
+console = Console()
+
+
+def _ai():
+    from ._client import cloooooo
+    return cloooooo()
+
+
+@app.callback(invoke_without_command=True)
+def main(
+    ctx: typer.Context,
+    prompt: Optional[str] = typer.Argument(None),
+    negative: Optional[str] = typer.Option(None, "--no", "-n", help="Ce qu'il faut éviter"),
+    thinking: bool = typer.Option(False, "--think", "-t", help="Active le mode réflexion"),
+    context: Optional[str] = typer.Option(None, "--ctx", "-c", help="System prompt"),
+):
+    """Envoie un prompt directement : clovis \"Bonjour\""""
+    if ctx.invoked_subcommand is not None:
+        return
+    if not prompt:
+        console.print(ctx.get_help())
+        return
+
+    ai = _ai()
+    text = ""
+    with Live(console=console, refresh_per_second=20) as live:
+        for token in ai.stream(prompt, negative_prompt=negative, thinking=thinking, context=context):
+            text += token
+            live.update(Markdown(text))
+
+
+@app.command()
+def repl(
+    context: Optional[str] = typer.Option(None, "--ctx", "-c", help="System prompt"),
+):
+    """Conversation interactive."""
+    ai = _ai()
+    conv = ai.conversation(context=context)
+    console.print("[bold]cloooooo[/] — [dim]Ctrl+C pour quitter · /reset pour vider[/]\n")
+
+    while True:
+        try:
+            prompt = typer.prompt("Vous")
+        except (typer.Abort, KeyboardInterrupt):
+            console.print("\n[dim]Au revoir.[/]")
+            break
+
+        if prompt.strip() == "/reset":
+            conv.reset()
+            console.print("[dim]Historique vidé.[/]")
+            continue
+
+        text = ""
+        console.print("[bold cyan]cloooooo[/] ", end="")
+        with Live(console=console, refresh_per_second=20) as live:
+            for token in conv.stream(prompt):
+                text += token
+                live.update(text)
+        console.print()
+
+
+@app.command()
+def serve(
+    port: int = typer.Option(8000, "--port", "-p"),
+    host: str = typer.Option("0.0.0.0", "--host"),
+    api_key: Optional[str] = typer.Option(None, "--key", envvar="CLOVIS_API_KEY"),
+):
+    """Lance le serveur sur /ia."""
+    from ._server import start_server
+    start_server(host=host, port=port, api_key=api_key)

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/src/clovis/_server.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+import os
+from typing import Optional
+
+import uvicorn
+from fastapi import Depends, FastAPI, HTTPException
+from fastapi.responses import StreamingResponse
+from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
+from pydantic import BaseModel
+
+from ._client import cloooooo
+
+_bearer = HTTPBearer(auto_error=False)
+
+
+class IARequest(BaseModel):
+    prompt: str
+    negative_prompt: Optional[str] = None
+    thinking: bool = False
+    context: Optional[str] = None
+    stream: bool = False
+
+
+def build_app(api_key: Optional[str] = None) -> FastAPI:
+    app = FastAPI(title="cloooooo", version="0.1.0")
+    ai = cloooooo()
+
+    def _check_key(creds: Optional[HTTPAuthorizationCredentials] = Depends(_bearer)):
+        if api_key and (not creds or creds.credentials != api_key):
+            raise HTTPException(status_code=401, detail="Clé API invalide")
+
+    @app.post("/ia", dependencies=[Depends(_check_key)])
+    async def ia(req: IARequest):
+        kwargs = dict(
+            negative_prompt=req.negative_prompt,
+            thinking=req.thinking,
+            context=req.context,
+        )
+        if req.stream:
+            def generate():
+                for token in ai.stream(req.prompt, **kwargs):
+                    yield token
+            return StreamingResponse(generate(), media_type="text/plain")
+
+        return {"response": ai(req.prompt, **kwargs)}
+
+    @app.get("/")
+    def root():
+        return {"status": "ok", "endpoint": "/ia"}
+
+    return app
+
+
+def start_server(host: str = "0.0.0.0", port: int = 8000, api_key: Optional[str] = None) -> None:
+    app = build_app(api_key=api_key)
+    print(f"cloooooo API → http://{host}:{port}/ia")
+    uvicorn.run(app, host=host, port=port)

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.1.0/PKG-INFO

@@ -1,79 +0,0 @@
-Metadata-Version: 2.4
-Name: clovis
-Version: 0.1.0
-Summary: cloooooo — personal LLM client, OpenAI-compatible 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.1.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.1.0/src/clovis/_cli.py

@@ -1,114 +0,0 @@
-from __future__ import annotations
-
-import os
-import sys
-from typing import Optional
-
-import typer
-from rich.console import Console
-from rich.live import Live
-from rich.markdown import Markdown
-
-app = typer.Typer(help="cloooooo — personal LLM CLI")
-console = Console()
-
-
-def _get_client():
-    from ._client import cloooooo
-    return cloooooo(
-        api_key=os.getenv("CLOVIS_API_KEY"),
-        ollama_url=os.getenv("CLOVIS_OLLAMA_URL", "http://localhost:11434"),
-        model=os.getenv("CLOVIS_MODEL", "qwen3-72b-q5km"),
-    )
-
-
-@app.command(name="chat")
-def cmd_chat(
-    prompt: str = typer.Argument(..., help="Message à envoyer"),
-    model: Optional[str] = typer.Option(None, "--model", "-m"),
-    no_stream: bool = typer.Option(False, "--no-stream"),
-    markdown: bool = typer.Option(True, "--markdown/--no-markdown"),
-):
-    """Envoie un message au LLM."""
-    client = _get_client()
-    if model:
-        client.model = model
-
-    if no_stream:
-        resp = client.chat.completions.create(
-            messages=[{"role": "user", "content": prompt}]
-        )
-        text = resp.choices[0].message.content
-        console.print(Markdown(text) if markdown else text)
-        return
-
-    text = ""
-    with Live(console=console, refresh_per_second=15) as live:
-        for chunk in client.chat.completions.create(
-            messages=[{"role": "user", "content": prompt}],
-            stream=True,
-        ):
-            text += chunk.choices[0].delta.get("content", "")
-            live.update(Markdown(text) if markdown else text)
-
-
-@app.command(name="serve")
-def cmd_serve(
-    port: int = typer.Option(8000, "--port", "-p"),
-    host: str = typer.Option("0.0.0.0", "--host"),
-    api_key: Optional[str] = typer.Option(None, "--api-key", envvar="CLOVIS_API_KEY"),
-    ollama_url: str = typer.Option("http://localhost:11434", "--ollama-url", envvar="CLOVIS_OLLAMA_URL"),
-):
-    """Lance le serveur API OpenAI-compatible."""
-    from ._server import start_server
-    console.print(f"[bold green]cloooooo API[/] démarré sur [bold]http://{host}:{port}[/]")
-    if api_key:
-        console.print(f"[dim]Clé API : {api_key[:12]}...[/]")
-    start_server(host=host, port=port, ollama_url=ollama_url, api_key=api_key)
-
-
-@app.command(name="repl")
-def cmd_repl(
-    system: Optional[str] = typer.Option(None, "--system", "-s", help="System prompt"),
-    model: Optional[str] = typer.Option(None, "--model", "-m"),
-):
-    """Lance une conversation interactive (REPL)."""
-    client = _get_client()
-    if model:
-        client.model = model
-
-    conv = client.conversation(system=system)
-    console.print("[bold]cloooooo REPL[/] — [dim]Ctrl+C pour quitter, /reset pour vider l'historique[/]\n")
-
-    while True:
-        try:
-            prompt = typer.prompt("You")
-        except (typer.Abort, KeyboardInterrupt):
-            console.print("\n[dim]Au revoir.[/]")
-            break
-
-        if prompt.strip() == "/reset":
-            conv.reset()
-            console.print("[dim]Historique réinitialisé.[/]")
-            continue
-
-        text = ""
-        console.print("[bold cyan]cloooooo[/] ", end="")
-        with Live(console=console, refresh_per_second=15) as live:
-            for chunk in conv.stream(prompt):
-                text += chunk
-                live.update(text)
-        console.print()
-
-
-# Allow: clovis "question" (shortcut without subcommand)
-@app.callback(invoke_without_command=True)
-def main(
-    ctx: typer.Context,
-    prompt: Optional[str] = typer.Argument(None),
-):
-    if ctx.invoked_subcommand is None:
-        if prompt:
-            cmd_chat(prompt=prompt, model=None, no_stream=False, markdown=True)
-        else:
-            console.print(ctx.get_help())

clovis-0.1.0/src/clovis/_client.py

@@ -1,68 +0,0 @@
-from __future__ import annotations
-
-import os
-from typing import Optional
-
-import httpx
-
-from ._completions import Chat
-from ._conversation import Conversation
-
-
-class cloooooo:
-    """
-    Personal LLM client — OpenAI-compatible interface over a local Ollama instance.
-
-    Usage::
-
-        from clovis import cloooooo
-
-        client = cloooooo(api_key="sk-clovis-...")
-        resp = client.chat.completions.create(
-            model="qwen3-72b",
-            messages=[{"role": "user", "content": "Bonjour !"}]
-        )
-        print(resp.choices[0].message.content)
-    """
-
-    def __init__(
-        self,
-        api_key: Optional[str] = None,
-        ollama_url: str = "http://localhost:11434",
-        model: str = "qwen3-72b-q5km",
-    ) -> None:
-        self.api_key = api_key or os.getenv("CLOVIS_API_KEY")
-        self.ollama_url = ollama_url or os.getenv("CLOVIS_OLLAMA_URL", "http://localhost:11434")
-        self.model = model or os.getenv("CLOVIS_MODEL", "qwen3-72b-q5km")
-
-        self._http = httpx.Client()
-        self.chat = Chat(self)
-
-    def conversation(
-        self,
-        system: Optional[str] = None,
-        model: Optional[str] = None,
-    ) -> Conversation:
-        """Return a new conversation with persistent history."""
-        return Conversation(self, system=system, model=model)
-
-    @classmethod
-    def serve(
-        cls,
-        port: int = 8000,
-        host: str = "0.0.0.0",
-        ollama_url: str = "http://localhost:11434",
-        api_key: Optional[str] = None,
-    ) -> None:
-        """Start an OpenAI-compatible HTTP API server."""
-        from ._server import start_server
-        start_server(host=host, port=port, ollama_url=ollama_url, api_key=api_key)
-
-    def models(self) -> list[str]:
-        """List available models from Ollama."""
-        resp = self._http.get(f"{self.ollama_url}/api/tags", timeout=10)
-        resp.raise_for_status()
-        return [m["name"] for m in resp.json().get("models", [])]
-
-    def __repr__(self) -> str:
-        return f"cloooooo(model={self.model!r}, ollama_url={self.ollama_url!r})"

clovis-0.1.0/src/clovis/_completions.py

@@ -1,96 +0,0 @@
-from __future__ import annotations
-
-import json
-from typing import TYPE_CHECKING, Iterator, Optional
-
-import httpx
-
-from ._models import (
-    ChatCompletion,
-    ChatCompletionChunk,
-    ChatCompletionRequest,
-    DeltaChoice,
-    Message,
-)
-
-if TYPE_CHECKING:
-    from ._client import cloooooo
-
-
-class ChatCompletions:
-    def __init__(self, client: "cloooooo") -> None:
-        self._client = client
-
-    def create(
-        self,
-        model: Optional[str] = None,
-        messages: Optional[list[dict]] = None,
-        stream: bool = False,
-        temperature: float = 0.7,
-        max_tokens: Optional[int] = None,
-        top_p: float = 0.9,
-        **_,
-    ) -> ChatCompletion | Iterator[ChatCompletionChunk]:
-        model = model or self._client.model
-        parsed = [Message(**m) for m in (messages or [])]
-
-        payload = {
-            "model": model,
-            "messages": [m.model_dump() for m in parsed],
-            "stream": stream,
-            "options": {
-                "temperature": temperature,
-                "top_p": top_p,
-                **({"num_predict": max_tokens} if max_tokens else {}),
-            },
-        }
-
-        if stream:
-            return self._stream(model, payload)
-        return self._sync(model, payload)
-
-    def _sync(self, model: str, payload: dict) -> ChatCompletion:
-        resp = self._client._http.post(
-            f"{self._client.ollama_url}/api/chat",
-            json=payload,
-            timeout=600,
-        )
-        resp.raise_for_status()
-        return ChatCompletion.from_ollama(resp.json(), model)
-
-    def _stream(self, model: str, payload: dict) -> Iterator[ChatCompletionChunk]:
-        chunk_id = None
-        with self._client._http.stream(
-            "POST",
-            f"{self._client.ollama_url}/api/chat",
-            json=payload,
-            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", "")
-                done = data.get("done", False)
-
-                chunk = ChatCompletionChunk(
-                    model=model,
-                    choices=[DeltaChoice(
-                        delta={"content": token} if token else {},
-                        finish_reason="stop" if done else None,
-                    )],
-                )
-                if chunk_id is None:
-                    chunk_id = chunk.id
-                else:
-                    chunk.id = chunk_id
-
-                yield chunk
-                if done:
-                    break
-
-
-class Chat:
-    def __init__(self, client: "cloooooo") -> None:
-        self.completions = ChatCompletions(client)

clovis-0.1.0/src/clovis/_conversation.py

@@ -1,65 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Iterator, Optional
-
-from ._models import ChatCompletionChunk, Message
-
-if TYPE_CHECKING:
-    from ._client import cloooooo
-
-
-class Conversation:
-    """Persistent conversation with automatic history."""
-
-    def __init__(
-        self,
-        client: "cloooooo",
-        system: Optional[str] = None,
-        model: Optional[str] = None,
-    ) -> None:
-        self._client = client
-        self._model = model or client.model
-        self._history: list[dict] = []
-        if system:
-            self._history.append({"role": "system", "content": system})
-
-    def chat(self, message: str, **kwargs) -> str:
-        self._history.append({"role": "user", "content": message})
-        resp = self._client.chat.completions.create(
-            model=self._model,
-            messages=self._history,
-            **kwargs,
-        )
-        content = resp.choices[0].message.content
-        self._history.append({"role": "assistant", "content": content})
-        return content
-
-    def stream(self, message: str, **kwargs) -> Iterator[str]:
-        self._history.append({"role": "user", "content": message})
-        full = ""
-        for chunk in self._client.chat.completions.create(
-            model=self._model,
-            messages=self._history,
-            stream=True,
-            **kwargs,
-        ):
-            token = chunk.choices[0].delta.get("content", "")
-            full += token
-            yield token
-        self._history.append({"role": "assistant", "content": full})
-
-    def reset(self, keep_system: bool = True) -> None:
-        if keep_system and self._history and self._history[0]["role"] == "system":
-            self._history = [self._history[0]]
-        else:
-            self._history = []
-
-    @property
-    def history(self) -> list[dict]:
-        return list(self._history)
-
-    def __enter__(self) -> "Conversation":
-        return self
-
-    def __exit__(self, *_) -> None:
-        pass

clovis-0.1.0/src/clovis/_models.py

@@ -1,75 +0,0 @@
-from __future__ import annotations
-
-import time
-import uuid
-from typing import Iterator, Literal, Optional
-
-from pydantic import BaseModel, Field
-
-
-class Message(BaseModel):
-    role: Literal["system", "user", "assistant"]
-    content: str
-
-
-class ChatCompletionRequest(BaseModel):
-    model: str
-    messages: list[Message]
-    stream: bool = False
-    temperature: float = 0.7
-    max_tokens: Optional[int] = None
-    top_p: float = 0.9
-    top_k: int = 20
-
-
-class Choice(BaseModel):
-    index: int = 0
-    message: Message
-    finish_reason: str = "stop"
-
-
-class DeltaChoice(BaseModel):
-    index: int = 0
-    delta: dict
-    finish_reason: Optional[str] = None
-
-
-class Usage(BaseModel):
-    prompt_tokens: int = 0
-    completion_tokens: int = 0
-    total_tokens: int = 0
-
-
-class ChatCompletion(BaseModel):
-    id: str = Field(default_factory=lambda: f"chatcmpl-{uuid.uuid4().hex[:12]}")
-    object: str = "chat.completion"
-    created: int = Field(default_factory=lambda: int(time.time()))
-    model: str
-    choices: list[Choice]
-    usage: Usage
-
-    @classmethod
-    def from_ollama(cls, data: dict, model: str) -> "ChatCompletion":
-        return cls(
-            model=model,
-            choices=[Choice(
-                message=Message(
-                    role=data["message"]["role"],
-                    content=data["message"]["content"],
-                ),
-                finish_reason="stop" if data.get("done") else "length",
-            )],
-            usage=Usage(
-                prompt_tokens=data.get("prompt_eval_count", 0),
-                completion_tokens=data.get("eval_count", 0),
-                total_tokens=(data.get("prompt_eval_count", 0) + data.get("eval_count", 0)),
-            ),
-        )
-
-
-class ChatCompletionChunk(BaseModel):
-    id: str = Field(default_factory=lambda: f"chatcmpl-{uuid.uuid4().hex[:12]}")
-    object: str = "chat.completion.chunk"
-    created: int = Field(default_factory=lambda: int(time.time()))
-    model: str
-    choices: list[DeltaChoice]

clovis-0.1.0/src/clovis/_server.py

@@ -1,117 +0,0 @@
-from __future__ import annotations
-
-import json
-import time
-import uuid
-from typing import Optional
-
-import httpx
-import uvicorn
-from fastapi import Depends, FastAPI, HTTPException, Request
-from fastapi.responses import StreamingResponse
-from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
-
-from ._models import ChatCompletionRequest
-
-_bearer = HTTPBearer(auto_error=False)
-
-
-def build_app(ollama_url: str, api_key: Optional[str]) -> FastAPI:
-    app = FastAPI(title="cloooooo API", version="0.1.0")
-
-    def _check_key(creds: Optional[HTTPAuthorizationCredentials] = Depends(_bearer)):
-        if api_key and (not creds or creds.credentials != api_key):
-            raise HTTPException(status_code=401, detail="Invalid API key")
-
-    @app.get("/v1/models", dependencies=[Depends(_check_key)])
-    def list_models():
-        resp = httpx.get(f"{ollama_url}/api/tags", timeout=10)
-        models = [m["name"] for m in resp.json().get("models", [])]
-        return {
-            "object": "list",
-            "data": [{"id": m, "object": "model", "owned_by": "clovis"} for m in models],
-        }
-
-    @app.post("/v1/chat/completions", dependencies=[Depends(_check_key)])
-    async def chat_completions(req: ChatCompletionRequest, raw: Request):
-        payload = {
-            "model": req.model,
-            "messages": [m.model_dump() for m in req.messages],
-            "stream": req.stream,
-            "options": {
-                "temperature": req.temperature,
-                "top_p": req.top_p,
-                **({"num_predict": req.max_tokens} if req.max_tokens else {}),
-            },
-        }
-
-        if req.stream:
-            return StreamingResponse(
-                _stream_ollama(ollama_url, payload, req.model),
-                media_type="text/event-stream",
-            )
-
-        async with httpx.AsyncClient() as client:
-            resp = await client.post(
-                f"{ollama_url}/api/chat", json=payload, timeout=600
-            )
-            resp.raise_for_status()
-            data = resp.json()
-
-        cid = f"chatcmpl-{uuid.uuid4().hex[:12]}"
-        return {
-            "id": cid,
-            "object": "chat.completion",
-            "created": int(time.time()),
-            "model": req.model,
-            "choices": [{
-                "index": 0,
-                "message": data["message"],
-                "finish_reason": "stop",
-            }],
-            "usage": {
-                "prompt_tokens": data.get("prompt_eval_count", 0),
-                "completion_tokens": data.get("eval_count", 0),
-                "total_tokens": data.get("prompt_eval_count", 0) + data.get("eval_count", 0),
-            },
-        }
-
-    return app
-
-
-async def _stream_ollama(ollama_url: str, payload: dict, model: str):
-    cid = f"chatcmpl-{uuid.uuid4().hex[:12]}"
-    async with httpx.AsyncClient() as client:
-        async with client.stream("POST", f"{ollama_url}/api/chat", json=payload, timeout=600) as resp:
-            async for line in resp.aiter_lines():
-                if not line:
-                    continue
-                data = json.loads(line)
-                token = data.get("message", {}).get("content", "")
-                done = data.get("done", False)
-
-                chunk = {
-                    "id": cid,
-                    "object": "chat.completion.chunk",
-                    "created": int(time.time()),
-                    "model": model,
-                    "choices": [{
-                        "index": 0,
-                        "delta": {"content": token} if token else {},
-                        "finish_reason": "stop" if done else None,
-                    }],
-                }
-                yield f"data: {json.dumps(chunk)}\n\n"
-                if done:
-                    break
-    yield "data: [DONE]\n\n"
-
-
-def start_server(
-    host: str = "0.0.0.0",
-    port: int = 8000,
-    ollama_url: str = "http://localhost:11434",
-    api_key: Optional[str] = None,
-) -> None:
-    app = build_app(ollama_url=ollama_url, api_key=api_key)
-    uvicorn.run(app, host=host, port=port)