clovis 0.1.0__py3-none-any.whl

clovis/__init__.py

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

clovis/_cli.py

@@ -0,0 +1,114 @@
+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/_client.py

@@ -0,0 +1,68 @@
+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/_completions.py

@@ -0,0 +1,96 @@
+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/_conversation.py

@@ -0,0 +1,65 @@
+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/_models.py

@@ -0,0 +1,75 @@
+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/_server.py

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

clovis-0.1.0.dist-info/METADATA

@@ -0,0 +1,79 @@
+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.dist-info/RECORD

@@ -0,0 +1,11 @@
+clovis/__init__.py,sha256=w9har65j7dnnEb8-JAsCbW2M8TAwX4lKWKBgM-WrJyQ,76
+clovis/_cli.py,sha256=_XlP76I5SxUKEOvoTFpwn_Sti2sH7zowo9F3zvtYwTw,3708
+clovis/_client.py,sha256=m326IlzJb2_N_rOm5wlYTYndzwBgJPvcne9Ruq6wigI,2083
+clovis/_completions.py,sha256=Yg0PN17wB85_PmW-3mZyD2gCsGhgEl9NYEPzA8jDS00,2791
+clovis/_conversation.py,sha256=F-4TrtiwJJ_E7FipgXUuOgnBHXbxArE3wFA5w_0ZKcA,1990
+clovis/_models.py,sha256=UXieNAiiGGesC9c9WkA4Ig6lvPecOSOCZqdKtjjvxoU,2004
+clovis/_server.py,sha256=xhAHUqFnYM3oGLog4sCEDFmzg6dGqle-HHO8snR9pHY,4077
+clovis-0.1.0.dist-info/METADATA,sha256=p5Y-m1rwFT-zNjxzK7M6PLUfDR5eeUSlBrWCuXMAR3E,2108
+clovis-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+clovis-0.1.0.dist-info/entry_points.txt,sha256=BYk0CU0hLdsRV4Mc-XHPUwg3yHwo3M2MW4qELlZNUto,43
+clovis-0.1.0.dist-info/RECORD,,

clovis-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

clovis-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+clovis = clovis._cli:app