syntaxmatrix 2.6.4.3__py3-none-any.whl → 3.0.0__py3-none-any.whl

syntaxmatrix/premium/catalogue/__init__.py

@@ -0,0 +1,121 @@
+from __future__ import annotations
+
+import json
+import os
+from typing import Any, Dict, Optional, Tuple
+
+
+def _safe_json_loads(raw: str, default: Any) -> Any:
+    try:
+        return json.loads(raw)
+    except Exception:
+        return default
+
+
+def _read_json(path: str) -> Dict[str, Any]:
+    try:
+        with open(path, "r", encoding="utf-8") as f:
+            data = json.load(f)
+        return data if isinstance(data, dict) else {}
+    except Exception:
+        return {}
+
+
+def _catalogue_dir() -> str:
+    return os.path.join(os.path.dirname(__file__))
+
+
+def load_index() -> Dict[str, Any]:
+    """Load catalogue index.json (safe, returns empty dict on failure)."""
+    return _read_json(os.path.join(_catalogue_dir(), "index.json"))
+
+
+def load_catalogue(version: Optional[str] = None) -> Tuple[Dict[str, Any], str]:
+    """Load a catalogue for the requested version.
+
+    Returns: (catalogue_dict, resolved_version)
+    """
+    idx = load_index()
+    resolved = (version or "").strip() or str(idx.get("default") or "").strip()
+    versions = idx.get("versions") if isinstance(idx.get("versions"), dict) else {}
+    fname = versions.get(resolved) if isinstance(versions, dict) else None
+
+    if not fname:
+        # Fall back to default file name if index is missing or version unknown.
+        fname = "catalogue.v1.json"
+
+    cat = _read_json(os.path.join(_catalogue_dir(), str(fname)))
+    # If the loaded file advertises a version, prefer that.
+    advertised = str(cat.get("version") or "").strip()
+    if advertised:
+        resolved = advertised
+    return cat, resolved
+
+
+def ui_labels(version: Optional[str] = None) -> Dict[str, Any]:
+    cat, _ = load_catalogue(version)
+    ui = cat.get("ui") if isinstance(cat.get("ui"), dict) else {}
+    labels = ui.get("labels") if isinstance(ui.get("labels"), dict) else {}
+    return labels if isinstance(labels, dict) else {}
+
+
+def resolve_entitlements(
+    *,
+    plan_id: str,
+    version: Optional[str] = None,
+    addons: Optional[list] = None,
+    custom_overrides: Optional[Dict[str, Any]] = None,
+) -> Dict[str, Any]:
+    """Resolve final entitlements from catalogue.
+
+    This keeps entitlements data-driven:
+    - base entitlements come from the plan in the catalogue
+    - optional add-ons apply deltas/overrides
+    - optional custom_overrides apply last
+    """
+    pid = (plan_id or "free").strip().lower() or "free"
+    cat, resolved_version = load_catalogue(version)
+
+    plans = cat.get("plans") if isinstance(cat.get("plans"), dict) else {}
+    p = plans.get(pid) if isinstance(plans, dict) else None
+    base = {}
+    if isinstance(p, dict) and isinstance(p.get("entitlements"), dict):
+        base = dict(p.get("entitlements") or {})
+
+    # Always stamp plan + version for UI/debugging.
+    base["plan"] = pid
+    base["entitlement_version"] = resolved_version
+
+    # Apply add-ons.
+    addons_list = addons if isinstance(addons, list) else []
+    if addons_list:
+        addons_def = cat.get("addons") if isinstance(cat.get("addons"), dict) else {}
+        for addon_id in addons_list:
+            aid = str(addon_id or "").strip()
+            if not aid:
+                continue
+            a = addons_def.get(aid) if isinstance(addons_def, dict) else None
+            if not isinstance(a, dict):
+                continue
+            delta = a.get("entitlements_delta") if isinstance(a.get("entitlements_delta"), dict) else {}
+            for k, v in (delta or {}).items():
+                # Support "+N" increment for numeric limits.
+                if isinstance(v, str) and v.strip().startswith("+"):
+                    try:
+                        inc = int(v.strip()[1:])
+                        cur = int(base.get(k) or 0)
+                        base[k] = cur + inc
+                        continue
+                    except Exception:
+                        pass
+                base[k] = v
+        base["addons"] = addons_list
+
+    # Apply overrides last.
+    if isinstance(custom_overrides, dict) and custom_overrides:
+        for k, v in custom_overrides.items():
+            if k in ("sig",):
+                continue
+            base[k] = v
+
+    return base

syntaxmatrix/premium/gate.py

@@ -0,0 +1,119 @@
+from __future__ import annotations
+
+import json
+import os
+from dataclasses import dataclass
+from typing import Any, Dict, Optional
+
+
+def _safe_json_loads(raw: str, *, default: Any) -> Any:
+    try:
+        return json.loads(raw)
+    except Exception:
+        return default
+
+
+@dataclass
+class GateSources:
+    """Where the gate reads entitlements from.
+
+    Precedence (highest first):
+      1) env_json
+      2) db_setting_key
+      3) licence_file
+    """
+
+    env_json: str = "SMX_PREMIUM_ENTITLEMENTS"
+    db_setting_key: str = "premium.entitlements"
+    licence_file_relpath: str = os.path.join("premium", "licence.json")
+
+
+class FeatureGate:
+    """Runtime entitlement checks for premium features.
+
+    This is intentionally small, dependency-free, and safe:
+    - If anything fails, it returns 'not entitled' rather than crashing the app.
+    """
+
+    def __init__(
+        self,
+        *,
+        client_dir: str,
+        db: Optional[object] = None,
+        sources: Optional[GateSources] = None,
+    ):
+        self._client_dir = client_dir
+        self._db = db
+        self._sources = sources or GateSources()
+        self._cache: Optional[Dict[str, Any]] = None
+
+    def _normalise(self, data: Optional[Dict[str, Any]]) -> Optional[Dict[str, Any]]:
+        if not isinstance(data, dict):
+            return None
+        if isinstance(data.get("entitlements"), dict):
+            ent = dict(data.get("entitlements") or {})
+            if data.get("plan") and not ent.get("plan"):
+                ent["plan"] = data.get("plan")
+            return ent
+        return data
+
+
+    def _load_from_env(self) -> Optional[Dict[str, Any]]:
+        raw = os.environ.get(self._sources.env_json)
+        if not raw:
+            return None
+        data = _safe_json_loads(raw, default=None)
+        return self._normalise(data)
+
+
+    def _load_from_db(self) -> Optional[Dict[str, Any]]:
+        if not self._db:
+            return None
+        get_setting = getattr(self._db, "get_setting", None)
+        if not callable(get_setting):
+            return None
+
+        raw = get_setting(self._sources.db_setting_key, "{}")
+        data = _safe_json_loads(str(raw or "{}"), default={})
+        return self._normalise(data)
+
+    def _load_from_file(self) -> Optional[Dict[str, Any]]:
+        p = os.path.join(self._client_dir, self._sources.licence_file_relpath)
+        if not os.path.exists(p):
+            return None
+        try:
+            with open(p, "r", encoding="utf-8") as f:
+                data = json.load(f)
+            return self._normalise(data)
+        except Exception:
+            return None
+
+    def entitlements(self, *, refresh: bool = False) -> Dict[str, Any]:
+        """Returns entitlement dict (possibly empty)."""
+        if self._cache is not None and not refresh:
+            return self._cache
+
+        ent = self._load_from_env()
+        if ent is None:
+            ent = self._load_from_db()
+        if ent is None:
+            ent = self._load_from_file()
+        if ent is None:
+            ent = {}
+
+        self._cache = ent
+        return ent
+
+    def enabled(self, key: str) -> bool:
+        """True if entitlement exists and is truthy."""
+        key = (key or "").strip()
+        if not key:
+            return False
+        ent = self.entitlements()
+        return bool(ent.get(key))
+
+    def get(self, key: str, default: Any = None) -> Any:
+        key = (key or "").strip()
+        if not key:
+            return default
+        return self.entitlements().get(key, default)