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

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

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "opsiom-cli"
-version = "1.2.5"
+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.5 → opsiom_cli-1.3.0}/src/opsiom_cli/cli.py

@@ -39,12 +39,18 @@ try:
 except ImportError:
     readline = None  # absent par défaut sur certains Windows (pyreadline3 comble le manque)
 
-VERSION = "1.2.5"
+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"}
 
 
 # ----------------------------------------------------------------------------
@@ -141,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:
@@ -280,13 +288,13 @@ def resolve_settings(args):
 
 
 # ----------------------------------------------------------------------------
-# 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).
+# 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):
@@ -309,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:
@@ -324,28 +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_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."""
+    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)
-    usage[key_id] = {
-        "date": today_str(),
-        "tokens_used": max(0, DAILY_TOKEN_QUOTA - remaining),
-    }
+    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)
 
 
@@ -597,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."))
@@ -623,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
@@ -659,14 +711,18 @@ def run_chat(client: OpsiomClient, url, api_key):
         except requests.HTTPError as e:
             if spinner_running:
                 spinner.stop()
-            if e.response is not None and e.response.status_code in (401, 403):
+            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:
-                detail = None
-                try:
-                    detail = e.response.json().get("error")
-                except (ValueError, AttributeError):
-                    pass
+            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))
@@ -688,9 +744,9 @@ def run_chat(client: OpsiomClient, url, api_key):
         used_model = final_event.get("model", current_model or "?")
         print(f"  {muted(format_elapsed(elapsed_ms))}")
 
-        remaining_quota = final_event.get("remaining_quota")
-        if remaining_quota is not None:
-            record_authoritative_remaining(api_key, remaining_quota)
+        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
@@ -700,12 +756,16 @@ def run_chat(client: OpsiomClient, url, api_key):
             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 = {**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')}")
+        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.5 → 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.5
+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