opsiom-cli 1.2.4__tar.gz → 1.2.5__tar.gz

{opsiom_cli-1.2.4 → opsiom_cli-1.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opsiom-cli
-Version: 1.2.4
+Version: 1.2.5
 Summary: CLI de chat pour Opsiom, l'assistant IA francophone.
 Author-email: Jules Ecorcheville <jules.ecorcheville@gmail.com>
 License-Expression: MIT

{opsiom_cli-1.2.4 → opsiom_cli-1.2.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "opsiom-cli"
-version = "1.2.4"
+version = "1.2.5"
 description = "CLI de chat pour Opsiom, l'assistant IA francophone."
 readme = "README.md"
 requires-python = ">=3.9"

{opsiom_cli-1.2.4 → opsiom_cli-1.2.5}/src/opsiom_cli/cli.py

@@ -23,7 +23,6 @@ import json
 import time
 import shutil
 import hashlib
-import textwrap
 import argparse
 import threading
 import itertools
@@ -40,7 +39,7 @@ try:
 except ImportError:
     readline = None  # absent par défaut sur certains Windows (pyreadline3 comble le manque)
 
-VERSION = "1.2.4"
+VERSION = "1.2.5"
 CONFIG_PATH = Path.home() / ".config" / "opsiom" / "config.json"
 HISTORY_PATH = Path.home() / ".local" / "share" / "opsiom" / "history"
 TRANSCRIPTS_DIR = Path.home() / "opsiom-conversations"
@@ -281,11 +280,13 @@ def resolve_settings(args):
 
 
 # ----------------------------------------------------------------------------
-# Quota local — 500 tokens/jour par clé API. C'est un garde-fou côté client
-# (pratique pour prévenir l'utilisateur avant d'envoyer une requête inutile),
-# pas une mesure de sécurité : le fichier usage.json est modifiable à la main.
-# L'application réelle du quota doit se faire côté serveur (là où la clé est
-# vérifiée), ceci n'est qu'un affichage/avertissement local.
+# Quota — 500 tokens/jour par clé API. Le fichier usage.json ne sert plus
+# qu'à AFFICHER un dernier quota connu avant la toute première requête de la
+# session (utile pour /quota juste après le lancement) : dès qu'une réponse
+# arrive, c'est le "remaining_quota" renvoyé par le serveur (lui-même décompté
+# côté Octix) qui fait foi et remplace la valeur locale. Un utilisateur qui
+# modifierait usage.json à la main ne gagnerait donc plus rien : le serveur
+# refuse désormais les requêtes une fois son propre compteur à zéro (429).
 # ----------------------------------------------------------------------------
 
 def _api_key_id(api_key):
@@ -333,14 +334,18 @@ def get_quota_state(api_key):
     return used, max(0, DAILY_TOKEN_QUOTA - used)
 
 
-def record_usage(api_key, tokens_used):
+def record_authoritative_remaining(api_key, remaining):
+    """Remplace le compteur local par le quota restant renvoyé par le
+    serveur (lui-même décompté côté Octix) — c'est la seule valeur qui
+    compte désormais, le fichier local n'est qu'un cache d'affichage."""
+    if remaining is None:
+        return
     usage = load_usage()
     key_id = _api_key_id(api_key)
-    entry = usage.get(key_id, {})
-    if entry.get("date") != today_str():
-        entry = {"date": today_str(), "tokens_used": 0}
-    entry["tokens_used"] = entry.get("tokens_used", 0) + tokens_used
-    usage[key_id] = entry
+    usage[key_id] = {
+        "date": today_str(),
+        "tokens_used": max(0, DAILY_TOKEN_QUOTA - remaining),
+    }
     save_usage(usage)
 
 
@@ -377,6 +382,33 @@ class OpsiomClient:
         r.raise_for_status()
         return r.json()
 
+    def chat_stream(self, message, model=None, **params):
+        """Générateur : cède chaque fragment de texte au fur et à mesure,
+        puis le dict final {'done', 'model', 'tokens_used', 'remaining_quota'}.
+        Lève requests.HTTPError si le serveur refuse la requête (401/429/...) —
+        dans ce cas rien n'a encore été cédé, l'appelant peut afficher l'erreur
+        comme pour un appel non-streamé.
+        """
+        payload = {"message": message}
+        if model:
+            payload["model"] = model
+        payload.update(params)
+        r = self.session.post(
+            f"{self.base_url}/api/chat/stream", json=payload,
+            timeout=self.timeout, stream=True,
+        )
+        r.raise_for_status()
+        for line in r.iter_lines(decode_unicode=True):
+            if not line or not line.startswith("data: "):
+                continue
+            event = json.loads(line[len("data: "):])
+            if event.get("done"):
+                yield event
+                return
+            token = event.get("token")
+            if token:
+                yield token
+
 
 # ----------------------------------------------------------------------------
 # Interface interactive
@@ -454,13 +486,59 @@ def select_model_interactively(models_payload, current_model):
     return resolved
 
 
-def print_assistant_message(text, elapsed_ms):
-    width = max(term_width() - 4, 30)
-    wrapped = textwrap.fill(text, width=width)
-    print()
-    for line in wrapped.split("\n"):
-        print(f"  {line}")
-    print(f"  {muted(format_elapsed(elapsed_ms))}")
+class StreamPrinter:
+    """Affiche la réponse au fur et à mesure qu'elle arrive (streaming),
+    avec un retour à la ligne automatique à la largeur du terminal.
+
+    Contrairement à un `textwrap.fill` relancé à chaque fragment reçu (qui
+    réimprimerait tout depuis le début et ferait scintiller le terminal),
+    on ne pousse en sortie que du texte jamais encore affiché, mot par mot.
+    """
+
+    def __init__(self, indent="  "):
+        self.indent = indent
+        self.width = max(term_width() - len(indent), 30)
+        self.line_len = 0
+        self.buffer = ""
+        self.started = False
+
+    def _flush_word(self, word):
+        if not self.started:
+            sys.stdout.write("\n" + self.indent)
+            self.started = True
+        if self.line_len > 0 and self.line_len + 1 + len(word) > self.width:
+            sys.stdout.write("\n" + self.indent)
+            self.line_len = 0
+        elif self.line_len > 0:
+            sys.stdout.write(" ")
+            self.line_len += 1
+        sys.stdout.write(word)
+        self.line_len += len(word)
+        sys.stdout.flush()
+
+    def feed(self, chunk):
+        self.buffer += chunk
+        while True:
+            idx = next((i for i, c in enumerate(self.buffer) if c in " \n"), None)
+            if idx is None:
+                break
+            word, sep = self.buffer[:idx], self.buffer[idx]
+            if word:
+                self._flush_word(word)
+            if sep == "\n":
+                if not self.started:
+                    sys.stdout.write("\n" + self.indent)
+                    self.started = True
+                sys.stdout.write("\n" + self.indent)
+                self.line_len = 0
+                sys.stdout.flush()
+            self.buffer = self.buffer[idx + 1:]
+
+    def close(self):
+        if self.buffer:
+            self._flush_word(self.buffer)
+            self.buffer = ""
+        print()
 
 
 def run_chat(client: OpsiomClient, url, api_key):
@@ -559,37 +637,74 @@ def run_chat(client: OpsiomClient, url, api_key):
         spinner = Spinner(label="Réflexion")
         spinner.start()
         start_time = time.perf_counter()
+        printer = StreamPrinter()
+        response_parts = []
+        final_event = {}
+        spinner_running = True
         try:
-            result = client.chat(user_input, model=current_model)
+            for piece in client.chat_stream(user_input, model=current_model):
+                if isinstance(piece, dict):
+                    final_event = piece
+                    break
+                if spinner_running:
+                    spinner.stop()
+                    spinner_running = False
+                response_parts.append(piece)
+                printer.feed(piece)
         except KeyboardInterrupt:
-            spinner.stop()
-            print(muted("  (requête annulée) "))
+            if spinner_running:
+                spinner.stop()
+            print(muted("\n  (requête annulée) "))
             continue
         except requests.HTTPError as e:
-            spinner.stop()
+            if spinner_running:
+                spinner.stop()
             if e.response is not None and e.response.status_code in (401, 403):
                 print_error("clé API invalide ou expirée.", "reconfigure avec : opsiom --configure")
             elif e.response is not None and e.response.status_code == 429:
-                print_error("quota dépassé côté serveur.", "réessaie plus tard")
+                detail = None
+                try:
+                    detail = e.response.json().get("error")
+                except (ValueError, AttributeError):
+                    pass
+                print_error("quota dépassé côté serveur.", detail or "réessaie plus tard")
             else:
                 print_error("la requête a échoué ", str(e))
             print()
             continue
         except requests.RequestException as e:
-            spinner.stop()
+            if spinner_running:
+                spinner.stop()
             print_error("la requête a échoué ", str(e))
             print()
             continue
-        spinner.stop()
+
+        if spinner_running:
+            spinner.stop()  # réponse vide reçue sans le moindre fragment
+        printer.close()
         elapsed_ms = int((time.perf_counter() - start_time) * 1000)
 
-        response_text = result.get("response", "(réponse vide)")
-        used_model = result.get("model", current_model or "?")
-        print_assistant_message(response_text, elapsed_ms)
+        response_text = "".join(response_parts) or "(réponse vide)"
+        used_model = final_event.get("model", current_model or "?")
+        print(f"  {muted(format_elapsed(elapsed_ms))}")
 
-        tokens_used = result.get("tokens_used") or (estimate_tokens(user_input) + estimate_tokens(response_text))
-        record_usage(api_key, tokens_used)
-        _, remaining_quota = get_quota_state(api_key)
+        remaining_quota = final_event.get("remaining_quota")
+        if remaining_quota is not None:
+            record_authoritative_remaining(api_key, remaining_quota)
+        else:
+            # Le serveur n'a pas renvoyé de quota faisant autorité (Octix
+            # injoignable côté serveur, p. ex.) : on retombe sur l'estimation
+            # locale plutôt que de ne rien afficher.
+            estimated = estimate_tokens(user_input) + estimate_tokens(response_text)
+            usage = load_usage()
+            key_id = _api_key_id(api_key)
+            entry = usage.get(key_id, {})
+            if entry.get("date") != today_str():
+                entry = {"date": today_str(), "tokens_used": 0}
+            entry["tokens_used"] = entry.get("tokens_used", 0) + estimated
+            usage[key_id] = entry
+            save_usage(usage)
+            _, remaining_quota = get_quota_state(api_key)
         print(f"  {muted(f'{remaining_quota} tokens restants aujourd’hui')}")
         print()
         transcript.append({"role": "assistant", "text": response_text, "model": used_model, "elapsed_ms": elapsed_ms})

{opsiom_cli-1.2.4 → opsiom_cli-1.2.5}/src/opsiom_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opsiom-cli
-Version: 1.2.4
+Version: 1.2.5
 Summary: CLI de chat pour Opsiom, l'assistant IA francophone.
 Author-email: Jules Ecorcheville <jules.ecorcheville@gmail.com>
 License-Expression: MIT