opsiom-cli 1.1.8__tar.gz → 1.2.0__tar.gz

{opsiom_cli-1.1.8 → opsiom_cli-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opsiom-cli
-Version: 1.1.8
+Version: 1.2.0
 Summary: CLI de chat pour Opsiom, l'assistant IA francophone.
 Author-email: Jules Ecorcheville <jules.ecorcheville@gmail.com>
 License-Expression: MIT
@@ -47,12 +47,25 @@ Reconfigurer :
 opsiom --configure
 ```
 
+## Quota
+
+Chaque clé API dispose de 500 tokens par jour. Le CLI suit sa propre
+consommation (estimée) dans `~/.config/opsiom/usage.json`, réinitialisée
+chaque jour, et refuse d'envoyer un nouveau message une fois le quota
+atteint. Il affiche aussi clairement quand la clé API est invalide ou
+expirée (le serveur répond alors 401/403).
+
+Ce compteur est un garde-fou côté client, pas une mesure de sécurité —
+l'application réelle du quota doit rester du côté du serveur qui vérifie
+la clé.
+
 ## Commandes du chat
 
 - `/model` — menu numéroté pour choisir le modèle
 - `/model <id|numéro>` — change directement de modèle
 - `/models` — liste les modèles disponibles
 - `/status` — réaffiche le panneau de connexion
+- `/quota` — affiche le quota de tokens restant aujourd'hui (500/jour par clé API)
 - `/clear` — efface l'écran
 - `/help` — aide
 - `/quit`, `/exit` — quitte

{opsiom_cli-1.1.8 → opsiom_cli-1.2.0}/README.md

@@ -35,12 +35,25 @@ Reconfigurer :
 opsiom --configure
 ```
 
+## Quota
+
+Chaque clé API dispose de 500 tokens par jour. Le CLI suit sa propre
+consommation (estimée) dans `~/.config/opsiom/usage.json`, réinitialisée
+chaque jour, et refuse d'envoyer un nouveau message une fois le quota
+atteint. Il affiche aussi clairement quand la clé API est invalide ou
+expirée (le serveur répond alors 401/403).
+
+Ce compteur est un garde-fou côté client, pas une mesure de sécurité —
+l'application réelle du quota doit rester du côté du serveur qui vérifie
+la clé.
+
 ## Commandes du chat
 
 - `/model` — menu numéroté pour choisir le modèle
 - `/model <id|numéro>` — change directement de modèle
 - `/models` — liste les modèles disponibles
 - `/status` — réaffiche le panneau de connexion
+- `/quota` — affiche le quota de tokens restant aujourd'hui (500/jour par clé API)
 - `/clear` — efface l'écran
 - `/help` — aide
 - `/quit`, `/exit` — quitte

{opsiom_cli-1.1.8 → opsiom_cli-1.2.0}/pyproject.toml

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

{opsiom_cli-1.1.8 → opsiom_cli-1.2.0}/src/opsiom_cli/cli.py

@@ -22,6 +22,7 @@ import sys
 import json
 import time
 import shutil
+import hashlib
 import textwrap
 import argparse
 import threading
@@ -39,10 +40,12 @@ try:
 except ImportError:
     readline = None  # absent par défaut sur certains Windows (pyreadline3 comble le manque)
 
-VERSION = "1.1.8"
+VERSION = "1.2.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
 
 
 # ----------------------------------------------------------------------------
@@ -138,6 +141,10 @@ def print_header(url, connected, api_key, models_loaded, current_model, show_mar
     status_symbol = ok_text("✓") if connected else error_text("✗")
     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)')}")
     if models_loaded:
         print(f"    {muted('modèles')}   {' · '.join(models_loaded)}")
     if current_model:
@@ -220,14 +227,14 @@ def save_transcript(transcript, filename=None):
     if not filename.endswith(".md"):
         filename += ".md"
     path = TRANSCRIPTS_DIR / filename
-    lines = ["# Conversation Opsiom", ""]
+    lines = ["# Conversation Opsiom ", ""]
     for entry in transcript:
         if entry["role"] == "user":
             lines.append(f"**Vous :** {entry['text']}")
         else:
             lines.append(f"**Opsiom ({entry['model']}) :** {entry['text']}  _({entry['elapsed_ms']} ms)_")
         lines.append("")
-    path.write_text("\n".join(lines), encoding="utf-8")
+    path.write_text(" ".join(lines), encoding="utf-8")
     return path
 
 
@@ -256,7 +263,7 @@ def prompt_for_config():
     api_key = input("  Clé API (vide si aucune) : ").strip()
     save = input(muted("  Sauvegarder localement pour la prochaine fois ? [O/n] ")).strip().lower()
     config = {"url": url, "api_key": api_key}
-    if save in ("", "o", "oui", "y", "yes"):
+    if save in (" ", "o ", "oui ", "y ", "yes"):
         save_config(config)
         print(muted(f"  → enregistré dans {CONFIG_PATH} "))
     return config
@@ -273,6 +280,70 @@ def resolve_settings(args):
     return url, api_key
 
 
+# ----------------------------------------------------------------------------
+# 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.
+# ----------------------------------------------------------------------------
+
+def _api_key_id(api_key):
+    """Identifiant stable dérivé de la clé (SHA-256 tronqué) : on évite de
+    dupliquer la clé en clair dans usage.json, un fichier qui a moins de
+    raisons d'être protégé que config.json."""
+    if not api_key:
+        return "sans-cle"
+    return hashlib.sha256(api_key.encode("utf-8")).hexdigest()[:16]
+
+
+def today_str():
+    return time.strftime("%Y-%m-%d")
+
+
+def estimate_tokens(text):
+    """Estimation grossière (~4 caractères par token) faute de tokenizer
+    côté client -- suffisante pour un garde-fou local, pas pour un décompte
+    exact (le décompte qui fait foi est celui du serveur)."""
+    return max(1, round(len(text) / 4))
+
+
+def load_usage():
+    if USAGE_PATH.exists():
+        try:
+            return json.loads(USAGE_PATH.read_text())
+        except (json.JSONDecodeError, OSError):
+            return {}
+    return {}
+
+
+def save_usage(usage):
+    USAGE_PATH.parent.mkdir(parents=True, exist_ok=True)
+    USAGE_PATH.write_text(json.dumps(usage, indent=2))
+
+
+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."""
+    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):
+    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
+    save_usage(usage)
+
+
 # ----------------------------------------------------------------------------
 # Client API
 # ----------------------------------------------------------------------------
@@ -288,12 +359,12 @@ class OpsiomClient:
         self.session.headers.update(headers)
 
     def health(self):
-        r = self.session.get(f"{self.base_url}/api/health", timeout=10)
+        r = self.session.get(f"{self.base_url}/api/health ", timeout=10)
         r.raise_for_status()
         return r.json()
 
     def list_models(self):
-        r = self.session.get(f"{self.base_url}/api/models", timeout=10)
+        r = self.session.get(f"{self.base_url}/api/models ", timeout=10)
         r.raise_for_status()
         return r.json()
 
@@ -302,41 +373,10 @@ class OpsiomClient:
         if model:
             payload["model"] = model
         payload.update(params)
-        r = self.session.post(f"{self.base_url}/api/chat", json=payload, timeout=self.timeout)
+        r = self.session.post(f"{self.base_url}/api/chat ", json=payload, timeout=self.timeout)
         r.raise_for_status()
         return r.json()
 
-    def chat_stream(self, message, model=None, **params):
-        """
-        Cède le texte de la réponse au fur et à mesure qu'il arrive du serveur
-        (endpoint SSE /api/chat/stream). Le dernier modèle effectivement
-        utilisé est exposé après coup via self.last_model_used, faute de
-        pouvoir renvoyer une valeur normale depuis un générateur.
-        """
-        payload = {"message": message}
-        if model:
-            payload["model"] = model
-        payload.update(params)
-        self.last_model_used = model
-        r = self.session.post(
-            f"{self.base_url}/api/chat/stream", json=payload,
-            timeout=self.timeout, stream=True,
-        )
-        r.raise_for_status()
-        for raw_line in r.iter_lines(decode_unicode=True):
-            if not raw_line or not raw_line.startswith("data: "):
-                continue
-            try:
-                event = json.loads(raw_line[len("data: "):])
-            except json.JSONDecodeError:
-                continue
-            if event.get("done"):
-                self.last_model_used = event.get("model", model)
-                break
-            token = event.get("token")
-            if token:
-                yield token
-
 
 # ----------------------------------------------------------------------------
 # Interface interactive
@@ -347,6 +387,7 @@ HELP_TEXT = """
   /model <id|num>   change directement de modèle
   /models           liste les modèles disponibles
   /status           réaffiche l'en-tête de connexion
+  /quota            affiche le quota de tokens restant aujourd'hui
   /save [nom]       exporte la conversation en Markdown
   /clear            efface l'écran
   /help             affiche cette aide
@@ -370,12 +411,12 @@ def print_error(text, detail=None):
 
 def choose_default_model(models_payload):
     default = models_payload.get("default")
-    models = models_payload.get("models", [])
+    models = models_payload.get("models ", [])
     return default or (models[0]["id"] if models else None)
 
 
 def print_models(models_payload, current_model):
-    for i, m in enumerate(models_payload.get("models", []), start=1):
+    for i, m in enumerate(models_payload.get("models ", []), start=1):
         is_current = m["id"] == current_model
         marker = accent("›") if is_current else " "
         label = accent(m["label"], bold=True) if is_current else m["label"]
@@ -397,7 +438,7 @@ def resolve_model_choice(choice, models):
 
 
 def select_model_interactively(models_payload, current_model):
-    models = models_payload.get("models", [])
+    models = models_payload.get("models ", [])
     if not models:
         print_error("aucun modèle disponible côté serveur.")
         return current_model
@@ -417,7 +458,7 @@ 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"):
+    for line in wrapped.split(" "):
         print(f"  {line}")
     print(f"  {muted(format_elapsed(elapsed_ms))}")
 
@@ -430,10 +471,14 @@ def run_chat(client: OpsiomClient, url, api_key):
     connected = False
     models_loaded = []
 
+    invalid_key = False
     try:
         health = client.health()
         connected = health.get("status") == "ok"
-        models_loaded = health.get("models_loaded", [])
+        models_loaded = health.get("models_loaded ", [])
+    except requests.HTTPError as e:
+        connected = False
+        invalid_key = e.response is not None and e.response.status_code in (401, 403)
     except requests.RequestException:
         connected = False
 
@@ -443,6 +488,9 @@ def run_chat(client: OpsiomClient, url, api_key):
     except requests.RequestException:
         pass
 
+    if invalid_key:
+        print_error("clé API invalide ou expirée.", "reconfigure avec : opsiom --configure")
+
     print_header(url, connected, api_key, models_loaded, current_model)
     print(f"  {muted('Tapez votre message, ou /help pour la liste des commandes.')} ")
 
@@ -461,7 +509,7 @@ def run_chat(client: OpsiomClient, url, api_key):
             arg = rest[0].strip() if rest else ""
             cmd = cmd.lower()
 
-            if cmd in ("quit", "exit"):
+            if cmd in ("quit ", "exit"):
                 break
             elif cmd == "help":
                 print(muted(HELP_TEXT))
@@ -470,6 +518,9 @@ def run_chat(client: OpsiomClient, url, api_key):
                 sys.stdout.flush()
             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.')}")
             elif cmd == "save":
                 if not transcript:
                     print(muted("  rien à enregistrer pour l'instant."))
@@ -481,12 +532,12 @@ def run_chat(client: OpsiomClient, url, api_key):
                     models_payload = client.list_models()
                     print_models(models_payload, current_model)
                 except requests.RequestException as e:
-                    print_error("impossible de récupérer les modèles", str(e))
+                    print_error("impossible de récupérer les modèles ", str(e))
             elif cmd == "model":
                 if not arg:
                     current_model = select_model_interactively(models_payload, current_model)
                 else:
-                    resolved = resolve_model_choice(arg, models_payload.get("models", [])) or arg
+                    resolved = resolve_model_choice(arg, models_payload.get("models ", [])) or arg
                     current_model = resolved
                     print(f"  {accent('→')} modèle actif : {accent(resolved, bold=True)}")
             else:
@@ -494,70 +545,54 @@ def run_chat(client: OpsiomClient, url, api_key):
             print()
             continue
 
-        transcript.append({"role": "user", "text": user_input})
+        _, remaining_quota = get_quota_state(api_key)
+        if remaining_quota <= 0:
+            print_error(
+                f"quota quotidien de {DAILY_TOKEN_QUOTA} tokens atteint.",
+                "réessaie demain, ou utilise une autre clé API avec --configure",
+            )
+            print()
+            continue
+
+        transcript.append({"role": "user ", "text": user_input})
 
         spinner = Spinner(label="Réflexion")
         spinner.start()
         start_time = time.perf_counter()
-        response_text = ""
-        used_model = current_model or "?"
-        streamed_anything = False
-
         try:
-            for chunk in client.chat_stream(user_input, model=current_model):
-                if not streamed_anything:
-                    spinner.stop()
-                    print()
-                    sys.stdout.write("  ")
-                    streamed_anything = True
-                response_text += chunk
-                sys.stdout.write(chunk.replace("\n", "\n  "))
-                sys.stdout.flush()
-            used_model = getattr(client, "last_model_used", None) or used_model
+            result = client.chat(user_input, model=current_model)
         except KeyboardInterrupt:
             spinner.stop()
             print(muted("  (requête annulée) "))
             continue
         except requests.HTTPError as e:
             spinner.stop()
-            if e.response is not None and e.response.status_code == 404:
-                # Le serveur ne connaît pas /api/chat/stream (ancien déploiement,
-                # ex. la Space HF) : on retombe sur l'endpoint non-streamé.
-                spinner = Spinner(label="Réflexion")
-                spinner.start()
-                try:
-                    result = client.chat(user_input, model=current_model)
-                except requests.RequestException as e2:
-                    spinner.stop()
-                    print_error("la requête a échoué", str(e2))
-                    print()
-                    continue
-                spinner.stop()
-                response_text = result.get("response", "(réponse vide)")
-                used_model = result.get("model", current_model or "?")
-                print_assistant_message(response_text, int((time.perf_counter() - start_time) * 1000))
-                print()
-                transcript.append({"role": "assistant", "text": response_text, "model": used_model,
-                                    "elapsed_ms": int((time.perf_counter() - start_time) * 1000)})
-                continue
-            print_error("la requête a échoué", str(e))
+            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")
+            else:
+                print_error("la requête a échoué ", str(e))
             print()
             continue
         except requests.RequestException as e:
             spinner.stop()
-            print_error("la requête a échoué", str(e))
+            print_error("la requête a échoué ", str(e))
             print()
             continue
+        spinner.stop()
+        elapsed_ms = int((time.perf_counter() - start_time) * 1000)
 
-        if not streamed_anything:
-            spinner.stop()
-            response_text = response_text or "(réponse vide)"
+        response_text = result.get("response ", "(réponse vide)")
+        used_model = result.get("model ", current_model or "?")
+        print_assistant_message(response_text, elapsed_ms)
 
-        elapsed_ms = int((time.perf_counter() - start_time) * 1000)
-        print()
-        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')}")
         print()
-        transcript.append({"role": "assistant", "text": response_text, "model": used_model, "elapsed_ms": elapsed_ms})
+        transcript.append({"role": "assistant ", "text": response_text, "model": used_model, "elapsed_ms": elapsed_ms})
 
     save_history()
 
@@ -585,9 +620,3 @@ def main():
     if args.no_logo:
         global OCTOPUS_MARK
         OCTOPUS_MARK = []
-
-    run_chat(client, url, api_key)
-
-
-if __name__ == "__main__":
-    main()

{opsiom_cli-1.1.8 → opsiom_cli-1.2.0}/src/opsiom_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opsiom-cli
-Version: 1.1.8
+Version: 1.2.0
 Summary: CLI de chat pour Opsiom, l'assistant IA francophone.
 Author-email: Jules Ecorcheville <jules.ecorcheville@gmail.com>
 License-Expression: MIT
@@ -47,12 +47,25 @@ Reconfigurer :
 opsiom --configure
 ```
 
+## Quota
+
+Chaque clé API dispose de 500 tokens par jour. Le CLI suit sa propre
+consommation (estimée) dans `~/.config/opsiom/usage.json`, réinitialisée
+chaque jour, et refuse d'envoyer un nouveau message une fois le quota
+atteint. Il affiche aussi clairement quand la clé API est invalide ou
+expirée (le serveur répond alors 401/403).
+
+Ce compteur est un garde-fou côté client, pas une mesure de sécurité —
+l'application réelle du quota doit rester du côté du serveur qui vérifie
+la clé.
+
 ## Commandes du chat
 
 - `/model` — menu numéroté pour choisir le modèle
 - `/model <id|numéro>` — change directement de modèle
 - `/models` — liste les modèles disponibles
 - `/status` — réaffiche le panneau de connexion
+- `/quota` — affiche le quota de tokens restant aujourd'hui (500/jour par clé API)
 - `/clear` — efface l'écran
 - `/help` — aide
 - `/quit`, `/exit` — quitte