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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opsiom-cli
-Version: 1.2.4
+Version: 1.3.0
 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.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "opsiom-cli"
-version = "1.2.4"
+version = "1.3.0"
 description = "CLI de chat pour Opsiom, l'assistant IA francophone."
 readme = "README.md"
 requires-python = ">=3.9"
@@ -20,4 +20,4 @@ Homepage = "https://github.com/ton-compte/opsiom-cli"
 opsiom = "opsiom_cli.cli:main"
 
 [tool.setuptools.packages.find]
-where = ["src"]
+where = ["src"]

{opsiom_cli-1.2.4 → opsiom_cli-1.3.0}/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,12 +39,18 @@ try:
 except ImportError:
     readline = None  # absent par défaut sur certains Windows (pyreadline3 comble le manque)
 
-VERSION = "1.2.4"
+VERSION = "1.3.0"
 CONFIG_PATH = Path.home() / ".config" / "opsiom" / "config.json"
 HISTORY_PATH = Path.home() / ".local" / "share" / "opsiom" / "history"
 TRANSCRIPTS_DIR = Path.home() / "opsiom-conversations"
 USAGE_PATH = Path.home() / ".config" / "opsiom" / "usage.json"
-DAILY_TOKEN_QUOTA = 500
+# Quota de repli (= forfait Free, voir plans.py côté front) : utilisé UNIQUEMENT
+# tant que le serveur n'a pas encore renvoyé la vraie limite du compte. La
+# limite réelle dépend du forfait (Free 2000 / Plus 10 000 / Pro 50 000 tokens
+# par jour) et fait foi dès la première réponse du serveur.
+DAILY_TOKEN_QUOTA = 2000
+UNLIMITED_THRESHOLD = 10**9   # même valeur que UNLIMITED_REMAINING côté front
+PLAN_LABELS = {"free": "Opsiom Free", "plus": "Opsiom Plus", "pro": "Opsiom Pro"}
 
 
 # ----------------------------------------------------------------------------
@@ -142,9 +147,11 @@ def print_header(url, connected, api_key, models_loaded, current_model, show_mar
     print(f"  {status_symbol} {muted('connecté à')} {url}")
     print(f"    {muted('auth')}      {muted('clé API' if api_key else 'aucune')}")
     if api_key:
-        used, remaining = get_quota_state(api_key)
-        quota_color = error_text if remaining <= 0 else muted
-        print(f"    {muted('quota')}     {quota_color(f'{used}/{DAILY_TOKEN_QUOTA} tokens aujourd’hui ({remaining} restants)')}")
+        state = get_quota_state(api_key)
+        quota_color = error_text if (not state["unlimited"] and state["remaining"] <= 0) else muted
+        if state["plan"]:
+            print(f"    {muted('forfait')}   {accent(plan_label(state['plan']))}")
+        print(f"    {muted('quota')}     {quota_color(format_quota(state))}")
     if models_loaded:
         print(f"    {muted('modèles')}   {' · '.join(models_loaded)}")
     if current_model:
@@ -281,11 +288,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 — dépend du FORFAIT du compte (Free 2000 / Plus 10 000 / Pro 50 000
+# tokens par jour ; les comptes administrateurs sont illimités). La limite
+# n'est plus codée en dur : le serveur renvoie la limite et le quota restant
+# avec chaque réponse, et c'est cette valeur qui fait foi. Le fichier
+# usage.json ne sert que de cache d'affichage (par exemple pour /quota juste
+# après le lancement, avant la toute première requête de la session). Le
+# serveur refuse de toute façon les requêtes une fois son compteur à zéro (429).
 # ----------------------------------------------------------------------------
 
 def _api_key_id(api_key):
@@ -308,6 +317,10 @@ def estimate_tokens(text):
     return max(1, round(len(text) / 4))
 
 
+def plan_label(plan_id):
+    return PLAN_LABELS.get(plan_id, str(plan_id))
+
+
 def load_usage():
     if USAGE_PATH.exists():
         try:
@@ -323,24 +336,61 @@ def save_usage(usage):
 
 
 def get_quota_state(api_key):
-    """(tokens utilisés aujourd'hui, tokens restants). Le compteur se
-    réinitialise tout seul dès que la date enregistrée n'est plus celle
-    du jour -- pas besoin de tâche planifiée."""
+    """État du quota sous forme de dict : used, remaining, limit, plan,
+    unlimited. Le compteur d'usage se réinitialise tout seul dès que la date
+    enregistrée n'est plus celle du jour ; la limite et le forfait, eux,
+    restent ceux du dernier échange avec le serveur."""
     entry = load_usage().get(_api_key_id(api_key), {})
-    if entry.get("date") != today_str():
-        return 0, DAILY_TOKEN_QUOTA
-    used = entry.get("tokens_used", 0)
-    return used, max(0, DAILY_TOKEN_QUOTA - used)
-
-
-def record_usage(api_key, tokens_used):
+    limit = entry.get("limit") or DAILY_TOKEN_QUOTA
+    unlimited = bool(entry.get("unlimited"))
+    plan = entry.get("plan")
+    used = entry.get("tokens_used", 0) if entry.get("date") == today_str() else 0
+    remaining = UNLIMITED_THRESHOLD if unlimited else max(0, limit - used)
+    return {"used": used, "remaining": remaining, "limit": limit, "plan": plan, "unlimited": unlimited}
+
+
+def format_quota(state):
+    if state["unlimited"]:
+        return "illimité"
+    return f"{state['used']}/{state['limit']} tokens aujourd’hui ({state['remaining']} restants)"
+
+
+def parse_quota_event(event):
+    """Extrait (remaining, limit, plan, unlimited) de l'événement final du
+    flux. Accepte à la fois les champs à plat (remaining_quota, quota_limit,
+    plan) et un objet `quota` au format du front : {used, limit, remaining,
+    plan, unlimited}. Les champs absents valent None."""
+    q = event.get("quota") if isinstance(event.get("quota"), dict) else {}
+    remaining = event.get("remaining_quota")
+    if remaining is None:
+        remaining = q.get("remaining")
+    limit = event.get("quota_limit", event.get("limit"))
+    if limit is None:
+        limit = q.get("limit")
+    plan = event.get("plan") or q.get("plan")
+    unlimited = bool(event.get("unlimited") or q.get("unlimited"))
+    if remaining is not None and remaining >= UNLIMITED_THRESHOLD:
+        unlimited = True
+    return remaining, limit, plan, unlimited
+
+
+def record_authoritative_quota(api_key, remaining, limit=None, plan=None, unlimited=False):
+    """Enregistre ce que le serveur vient de dire (quota restant, et si
+    fournis : limite du forfait et nom du forfait). Si la limite n'est pas
+    renvoyée, on garde la dernière connue plutôt que de retomber sur la
+    valeur de repli."""
+    if remaining is None and not unlimited:
+        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
+    previous = usage.get(key_id, {})
+    if unlimited:
+        usage[key_id] = {"date": today_str(), "tokens_used": 0, "unlimited": True,
+                         "limit": previous.get("limit") or DAILY_TOKEN_QUOTA, "plan": plan or previous.get("plan")}
+    else:
+        eff_limit = limit or previous.get("limit") or DAILY_TOKEN_QUOTA
+        usage[key_id] = {"date": today_str(), "tokens_used": max(0, eff_limit - remaining),
+                         "limit": eff_limit, "unlimited": False, "plan": plan or previous.get("plan")}
     save_usage(usage)
 
 
@@ -377,6 +427,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 +531,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):
@@ -519,8 +642,14 @@ def run_chat(client: OpsiomClient, url, api_key):
             elif cmd == "status":
                 print_header(url, connected, api_key, models_loaded, current_model, show_mark=False)
             elif cmd == "quota":
-                used, remaining = get_quota_state(api_key)
-                print(f"  {muted(f'{used}/{DAILY_TOKEN_QUOTA} tokens utilisés aujourd’hui — {remaining} restants.')}")
+                state = get_quota_state(api_key)
+                if state["plan"]:
+                    print(f"  {muted('forfait :')} {accent(plan_label(state['plan']))}")
+                if state["unlimited"]:
+                    print(f"  {muted('quota illimité.')}")
+                else:
+                    u, lim, rem = state["used"], state["limit"], state["remaining"]
+                    print(f"  {muted(f'{u}/{lim} tokens utilisés aujourd’hui — {rem} restants.')}")
             elif cmd == "save":
                 if not transcript:
                     print(muted("  rien à enregistrer pour l'instant."))
@@ -545,11 +674,12 @@ def run_chat(client: OpsiomClient, url, api_key):
             print()
             continue
 
-        _, remaining_quota = get_quota_state(api_key)
-        if remaining_quota <= 0:
+        state = get_quota_state(api_key)
+        if not state["unlimited"] and state["remaining"] <= 0:
+            plan_txt = f" ({plan_label(state['plan'])})" if state["plan"] else ""
             print_error(
-                f"quota quotidien de {DAILY_TOKEN_QUOTA} tokens atteint.",
-                "réessaie demain, ou utilise une autre clé API avec --configure",
+                f"quota quotidien de {state['limit']} tokens atteint{plan_txt}.",
+                "réessaie demain, ou débloque un forfait supérieur via les missions Opsiom",
             )
             print()
             continue
@@ -559,38 +689,83 @@ 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 e.response is not None and e.response.status_code in (401, 403):
+            if spinner_running:
+                spinner.stop()
+            status = e.response.status_code if e.response is not None else None
+            detail = None
+            try:
+                detail = e.response.json().get("error")
+            except (ValueError, AttributeError):
+                pass
+            if status == 403 and detail and "modèle" in detail.lower():
+                # Le forfait du compte n'inclut pas ce modèle (ex. Free : pas de Large).
+                print_error(detail, "choisis un autre modèle avec /model, ou débloque un forfait supérieur")
+            elif status 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")
+            elif status == 429:
+                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)
-        print(f"  {muted(f'{remaining_quota} tokens restants aujourd’hui')}")
+        remaining_quota, limit, plan, unlimited = parse_quota_event(final_event)
+        if remaining_quota is not None or unlimited:
+            record_authoritative_quota(api_key, remaining_quota, limit, plan, unlimited)
+        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 = {**entry, "date": today_str(), "tokens_used": 0}
+            entry["tokens_used"] = entry.get("tokens_used", 0) + estimated
+            usage[key_id] = entry
+            save_usage(usage)
+        state = get_quota_state(api_key)
+        if state["unlimited"]:
+            print(f"  {muted('quota illimité')}")
+        else:
+            rem = state["remaining"]
+            print(f"  {muted(f'{rem} 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.3.0}/src/opsiom_cli.egg-info/PKG-INFO

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