clovis 0.1.0__tar.gz → 0.2.0__tar.gz

{clovis-0.1.0 → clovis-0.2.0}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: clovis
-Version: 0.1.0
-Summary: cloooooo — personal LLM client, OpenAI-compatible interface over local Ollama
+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

{clovis-0.1.0 → clovis-0.2.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.2.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.2.0}/src/clovis/__init__.py

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

clovis-0.2.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.2.0/src/clovis/_client.py

@@ -0,0 +1,154 @@
+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/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.2.0/test_live.py

@@ -0,0 +1,78 @@
+"""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")

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)