prompture 1.0.45.dev2__tar.gz → 1.0.46.dev1__tar.gz

{prompture-1.0.45.dev2 → prompture-1.0.46.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: prompture
-Version: 1.0.45.dev2
+Version: 1.0.46.dev1
 Summary: Ask LLMs to return structured JSON and run cross-model tests. API-first.
 Author-email: Juan Denis <juan@vene.co>
 License-Expression: MIT

{prompture-1.0.45.dev2 → prompture-1.0.46.dev1}/prompture/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '1.0.45.dev2'
-__version_tuple__ = version_tuple = (1, 0, 45, 'dev2')
+__version__ = version = '1.0.46.dev1'
+__version_tuple__ = version_tuple = (1, 0, 46, 'dev1')
 
 __commit_id__ = commit_id = None

{prompture-1.0.45.dev2 → prompture-1.0.46.dev1}/prompture/infra/__init__.py

@@ -31,6 +31,7 @@ from .model_rates import (
     ModelCapabilities,
     get_model_capabilities,
     get_model_info,
+    get_model_lifecycle,
     get_model_rates,
     refresh_rates_cache,
 )
@@ -69,6 +70,7 @@ __all__ = [
     "get_cache",
     "get_model_capabilities",
     "get_model_info",
+    "get_model_lifecycle",
     "get_model_rates",
     "get_recently_used_models",
     "get_tracker",

{prompture-1.0.45.dev2 → prompture-1.0.46.dev1}/prompture/infra/discovery.py

@@ -166,7 +166,8 @@ def get_available_models(
             return cached  # type: ignore[no-any-return]
 
     logger.debug("Discovery cache miss for key=%s — querying providers", cache_key)
-    available_models: set[str] = set()
+    # Maps model string → source ("api", "static", "catalog"). First source wins.
+    model_sources: dict[str, str] = {}
     configured_providers: set[str] = set()
     # Providers where list_models() returned an authoritative model list.
     # For these, we trust the API response and skip MODEL_PRICING / models.dev additions.
@@ -265,7 +266,9 @@ def get_available_models(
                     api_succeeded = True
                     api_authoritative_providers.add(provider)
                     for model_id in api_models:
-                        available_models.add(f"{provider}/{model_id}")
+                        model_str = f"{provider}/{model_id}"
+                        if model_str not in model_sources:
+                            model_sources[model_str] = "api"
             except Exception as e:
                 logger.warning("list_models() failed for %s: %s", provider, e)
 
@@ -277,7 +280,9 @@ def get_available_models(
                 for model_id in pricing:
                     if model_id == "default":
                         continue
-                    available_models.add(f"{provider}/{model_id}")
+                    model_str = f"{provider}/{model_id}"
+                    if model_str not in model_sources:
+                        model_sources[model_str] = "static"
 
         except Exception as e:
             logger.warning(f"Error detecting models for provider {provider}: {e}")
@@ -293,9 +298,11 @@ def get_available_models(
     for prompture_name, api_name in PROVIDER_MAP.items():
         if prompture_name in configured_providers and prompture_name not in api_authoritative_providers:
             for model_id in get_all_provider_models(api_name):
-                available_models.add(f"{prompture_name}/{model_id}")
+                model_str = f"{prompture_name}/{model_id}"
+                if model_str not in model_sources:
+                    model_sources[model_str] = "catalog"
 
-    sorted_models = sorted(available_models)
+    sorted_models = sorted(model_sources.keys())
 
     # --- verified_only filtering ---
     verified_set: set[str] | None = None
@@ -316,8 +323,8 @@ def get_available_models(
         _discovery_cache.set(cache_key, sorted_models, ttl=ttl)
         return sorted_models
 
-    # Build enriched dicts with capabilities from models.dev
-    from .model_rates import get_model_capabilities
+    # Build enriched dicts with capabilities and lifecycle from models.dev
+    from .model_rates import get_model_capabilities, get_model_lifecycle
 
     # Fetch all ledger stats for annotation (keyed by model_name)
     ledger_stats: dict[str, dict[str, Any]] = {}
@@ -348,12 +355,20 @@ def get_available_models(
         caps = get_model_capabilities(provider, model_id)
         caps_dict = dataclasses.asdict(caps) if caps is not None else None
 
+        lifecycle = get_model_lifecycle(provider, model_id)
+
         entry: dict[str, Any] = {
             "model": model_str,
             "provider": provider,
             "model_id": model_id,
             "capabilities": caps_dict,
+            "source": model_sources.get(model_str, "unknown"),
             "verified": verified_set is not None and model_str in verified_set,
+            "status": lifecycle.get("status") if lifecycle else None,
+            "family": lifecycle.get("family") if lifecycle else None,
+            "release_date": lifecycle.get("release_date") if lifecycle else None,
+            "superseded_by": lifecycle.get("superseded_by") if lifecycle else None,
+            "end_of_support": lifecycle.get("end_of_support") if lifecycle else None,
         }
 
         stats = ledger_stats.get(model_str)

{prompture-1.0.45.dev2 → prompture-1.0.46.dev1}/prompture/infra/model_rates.py

@@ -44,6 +44,10 @@ _lock = threading.Lock()
 _data: Optional[dict[str, Any]] = None
 _loaded = False
 
+# Lifecycle cache: maps models.dev provider name → {model_id: lifecycle_dict}
+_lifecycle_cache: dict[str, dict[str, dict[str, Any]]] = {}
+_lifecycle_lock = threading.Lock()
+
 
 def _get_ttl_days() -> int:
     """Get TTL from settings if available, otherwise default to 7."""
@@ -321,6 +325,9 @@ def refresh_rates_cache(force: bool = False) -> bool:
             _data = fresh
             _write_cache(fresh)
             _loaded = True
+            # Clear lifecycle cache so it's recomputed from fresh data
+            with _lifecycle_lock:
+                _lifecycle_cache.clear()
             return True
 
         return False
@@ -482,3 +489,154 @@ def get_model_capabilities(provider: str, model_id: str) -> Optional[ModelCapabi
 
     # models.dev unavailable — fall back to KB
     return kb_entry
+
+
+# ── Model Lifecycle / Deprecation ──────────────────────────────────────────
+
+
+def _compute_family_status(provider_api_name: str) -> dict[str, dict[str, Any]]:
+    """Compute lifecycle status for every model of a provider from models.dev data.
+
+    Groups models by ``family`` field, sorts each family by ``release_date``
+    descending, and assigns statuses:
+
+    - ``"current"`` — newest model in the family (or has ``"(latest)"`` marker).
+    - ``"legacy"`` — >6 months old with a newer sibling.
+    - ``"deprecated"`` — >18 months old with a newer sibling, or explicitly
+      marked ``status: "deprecated"`` in models.dev.
+
+    Returns a dict mapping ``model_id`` → lifecycle metadata dict with keys:
+    ``status``, ``family``, ``release_date``, ``superseded_by``, ``end_of_support``.
+    """
+    from datetime import timedelta
+
+    data = _ensure_loaded()
+    if data is None:
+        return {}
+
+    provider_data = data.get(provider_api_name)
+    if not isinstance(provider_data, dict):
+        return {}
+
+    models = provider_data.get("models", provider_data)
+    if not isinstance(models, dict):
+        return {}
+
+    now = datetime.now(timezone.utc)
+
+    # Build per-family lists: {family: [(model_id, entry, release_date, is_latest_marker), ...]}
+    families: dict[str, list[tuple[str, dict[str, Any], Optional[datetime], bool]]] = {}
+    for model_id, entry in models.items():
+        if not isinstance(entry, dict):
+            continue
+
+        family = entry.get("family") or _infer_family(model_id)
+        name = entry.get("name", "")
+        is_latest_marker = "(latest)" in name.lower() if name else False
+
+        release_date: Optional[datetime] = None
+        raw_date = entry.get("release_date")
+        if raw_date:
+            with contextlib.suppress(Exception):
+                release_date = datetime.fromisoformat(str(raw_date).replace("Z", "+00:00"))
+                if release_date.tzinfo is None:
+                    release_date = release_date.replace(tzinfo=timezone.utc)
+
+        families.setdefault(family, []).append((model_id, entry, release_date, is_latest_marker))
+
+    result: dict[str, dict[str, Any]] = {}
+
+    for family, members in families.items():
+        # Sort by release_date descending (None dates go last)
+        members.sort(key=lambda m: m[2] or datetime.min.replace(tzinfo=timezone.utc), reverse=True)
+
+        # Identify the "current" model: explicit (latest) marker wins, else newest by date
+        current_idx = 0
+        for i, (_, _, _, is_latest) in enumerate(members):
+            if is_latest:
+                current_idx = i
+                break
+
+        for i, (model_id, entry, release_date, _) in enumerate(members):
+            # Check explicit status from models.dev
+            explicit_status = entry.get("status")
+            if isinstance(explicit_status, str) and explicit_status.lower() == "deprecated":
+                status = "deprecated"
+            elif i == current_idx:
+                status = "current"
+            elif release_date is not None:
+                age = now - release_date
+                has_newer = i > current_idx  # there's a newer sibling
+                if has_newer and age > timedelta(days=548):  # ~18 months
+                    status = "deprecated"
+                elif has_newer and age > timedelta(days=183):  # ~6 months
+                    status = "legacy"
+                else:
+                    status = "current"
+            else:
+                # No date info — if not the current one, mark as unknown
+                status = "current" if i == current_idx else "unknown"
+
+            # Compute superseded_by: next newer model in the family
+            superseded_by: Optional[str] = None
+            if i > current_idx and i > 0:
+                superseded_by = members[i - 1][0]
+
+            # Estimate end_of_support for legacy/deprecated: release_date + 24 months
+            end_of_support: Optional[str] = None
+            if status in ("legacy", "deprecated") and release_date is not None:
+                eos = release_date + timedelta(days=730)  # ~24 months
+                end_of_support = eos.strftime("%Y-%m-%d")
+
+            result[model_id] = {
+                "status": status,
+                "family": family,
+                "release_date": release_date.strftime("%Y-%m-%d") if release_date else None,
+                "superseded_by": superseded_by,
+                "end_of_support": end_of_support,
+            }
+
+    return result
+
+
+def _infer_family(model_id: str) -> str:
+    """Infer a family name from a model ID by stripping date/version suffixes.
+
+    Examples:
+    - ``claude-3-haiku-20240307`` → ``claude-3-haiku``
+    - ``gpt-4o-2024-08-06`` → ``gpt-4o``
+    - ``gemini-1.5-pro`` → ``gemini-1.5-pro``  (no suffix to strip)
+    """
+    import re
+
+    # Strip trailing date patterns: -YYYYMMDD or -YYYY-MM-DD
+    stripped = re.sub(r"-\d{4}-?\d{2}-?\d{2}$", "", model_id)
+    return stripped
+
+
+def get_model_lifecycle(provider: str, model_id: str) -> Optional[dict[str, Any]]:
+    """Return lifecycle/deprecation metadata for a model.
+
+    Returns a dict with keys: ``status``, ``family``, ``release_date``,
+    ``superseded_by``, ``end_of_support``.  Returns ``None`` for unknown models.
+
+    Results are cached per-provider; call :func:`refresh_rates_cache` to clear.
+    """
+    api_provider = PROVIDER_MAP.get(provider, provider)
+
+    with _lifecycle_lock:
+        if api_provider not in _lifecycle_cache:
+            _lifecycle_cache[api_provider] = _compute_family_status(api_provider)
+
+    family_status = _lifecycle_cache.get(api_provider, {})
+
+    # Exact match
+    if model_id in family_status:
+        return dict(family_status[model_id])
+
+    # Try base model fallback (date-stripped)
+    base = _strip_to_base_model(model_id)
+    if base is not None and base in family_status:
+        return dict(family_status[base])
+
+    return None

{prompture-1.0.45.dev2 → prompture-1.0.46.dev1}/prompture.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: prompture
-Version: 1.0.45.dev2
+Version: 1.0.46.dev1
 Summary: Ask LLMs to return structured JSON and run cross-model tests. API-first.
 Author-email: Juan Denis <juan@vene.co>
 License-Expression: MIT