syntaxmatrix-core 1.0.8__tar.gz → 1.0.9__tar.gz

{syntaxmatrix_core-1.0.8/syntaxmatrix_core.egg-info → syntaxmatrix_core-1.0.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: syntaxmatrix-core
-Version: 1.0.8
+Version: 1.0.9
 Summary: SyntaxMatrix: A Framework for  building owned AI Platform.
 Author: Bob Nti
 Author-email: info@syntaxmatrix.net

{syntaxmatrix_core-1.0.8 → syntaxmatrix_core-1.0.9}/setup.py

@@ -8,7 +8,7 @@ with open(os.path.join(this_directory, "README.md"), encoding="utf-8") as f:
 
 setup(
     name="syntaxmatrix-core",
-    version="1.0.8",
+    version="1.0.9",
     license="MIT",
     classifiers=[
         "Operating System :: OS Independent",

{syntaxmatrix_core-1.0.8 → syntaxmatrix_core-1.0.9}/syntaxmatrix/agentic/agents_orchestrer.py

@@ -92,10 +92,11 @@ class OrchestrateMLSystem:
                 def reasoning_and_verbosity():
                     reasoning_effort, verbosity = "medium", "medium" 
                     if "mini" not in model:
-                        if model == "gpt-5-nano":
+                        if "nano" in model:
                             reasoning_effort = "low"
-                        else: reasoning_effort, verbosity = "high", "high" 
-                                        
+                        elif "high" in model:
+                            reasoning_effort, verbosity = "high", "high" 
+                                    
                     return reasoning_effort, verbosity
 
                 reasoning, verbosity = reasoning_and_verbosity()
@@ -324,7 +325,7 @@ class OrchestrateMLSystem:
         if not coder_profile:
             return "Error!: Set an appropriate coder profile"
         
-        thought, raw_code, usage = self._generate_ml_response(coder_profile ,system_prompt, user_prompt)
+        thought, raw_code, usage = self._generate_ml_response(coder_profile,system_prompt, user_prompt)
 
         # Robustly strip any potential markdown formatting
         code = re.sub(r'```python|```', '', raw_code).strip()

syntaxmatrix_core-1.0.9/syntaxmatrix/premium/__init__.py

@@ -0,0 +1,18 @@
+"""Premium support.
+
+This package contains runtime plumbing for premium features (entitlements +
+plugin loading).
+
+Key idea:
+- FeatureGate reads a single entitlement dict from env/db/licence.json
+- ensure_premium_state() resolves trial + plan entitlements and writes them
+  into app_settings so the rest of the app can safely gate routes + navbar.
+
+Premium implementations (e.g. non-SQLite DB backends) should live in separate,
+private distributions.
+"""
+
+from .gate import FeatureGate
+from .state import ensure_premium_state, PremiumState, clear_premium_state_cache
+
+__all__ = ["FeatureGate", "ensure_premium_state", "PremiumState", "clear_premium_state_cache"]

syntaxmatrix_core-1.0.9/syntaxmatrix/premium/catalogue/__init__.py

@@ -0,0 +1,267 @@
+from __future__ import annotations
+
+import json
+import os
+from typing import Any, Dict, Optional, Tuple
+from importlib import resources as _resources
+
+
+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 _read_json_resource(name: str) -> Dict[str, Any]:
+    """Read JSON packaged with the module (works even when running from a wheel)."""
+    try:
+        raw = _resources.files(__package__).joinpath(name).read_text(encoding="utf-8")
+        data = _safe_json_loads(raw, {})
+        return data if isinstance(data, dict) else {}
+    except Exception:
+        return {}
+
+
+_FALLBACK_INDEX: Dict[str, Any] = {
+    "default": "2026-01-19",
+    "versions": {"2026-01-19": "catalogue.v1.json"},
+}
+
+_FALLBACK_CATALOGUE_V1: Dict[str, Any] = {
+    "schema": "smx-premium-catalogue/v1",
+    "version": "2026-01-19",
+    "currency": "EUR",
+    "plans": {
+        "trial": {
+            "display_name": "Trial",
+            "entitlements": {
+                "docs": True,
+                "ml_lab": True,
+                "registration": True,
+                "theme_toggle": True,
+                "branding_controls": True,
+                "plugins": True,
+                "premium_db_backends": True,
+                "audit_export": True,
+                "max_users": 9999,
+                "max_pages": 9999,
+                "max_upload_mb": 9999,
+                "max_pdf_pages_per_doc": 999999,
+                "max_vector_records": 999999999,
+            },
+        },
+        "free": {
+            "display_name": "Free",
+            "entitlements": {
+                "docs": False,
+                "ml_lab": False,
+                "registration": False,
+                "theme_toggle": False,
+                "branding_controls": False,
+                "plugins": False,
+                "premium_db_backends": False,
+                "audit_export": False,
+                "max_users": 1,
+                "max_pages": 3,
+                "max_upload_mb": 5,
+                "max_pdf_pages_per_doc": 20,
+                "max_vector_records": 1500,
+            },
+        },
+        "pro": {
+            "display_name": "Pro",
+            "entitlements": {
+                "docs": True,
+                "ml_lab": True,
+                "registration": True,
+                "theme_toggle": True,
+                "branding_controls": True,
+                "plugins": True,
+                "premium_db_backends": False,
+                "audit_export": True,
+                "max_users": 10,
+                "max_pages": 50,
+                "max_upload_mb": 200,
+                "max_pdf_pages_per_doc": 300,
+                "max_vector_records": 50000,
+            },
+        },
+        "business": {
+            "display_name": "Business",
+            "entitlements": {
+                "docs": True,
+                "ml_lab": True,
+                "registration": True,
+                "theme_toggle": True,
+                "branding_controls": True,
+                "plugins": True,
+                "premium_db_backends": True,
+                "audit_export": True,
+                "max_users": 25,
+                "max_pages": 150,
+                "max_upload_mb": 500,
+                "max_pdf_pages_per_doc": 750,
+                "max_vector_records": 200000,
+            },
+        },
+        "enterprise": {
+            "display_name": "Enterprise",
+            "entitlements": {
+                "docs": True,
+                "ml_lab": True,
+                "registration": True,
+                "theme_toggle": True,
+                "branding_controls": True,
+                "plugins": True,
+                "premium_db_backends": True,
+                "audit_export": True,
+                "max_users": 200,
+                "max_pages": 500,
+                "max_upload_mb": 2000,
+                "max_pdf_pages_per_doc": 2000,
+                "max_vector_records": 500000,
+            },
+        },
+    },
+    "addons": {},
+    "ui": {
+        "labels": {
+            "docs": {"name": "Docs", "category": "Features", "type": "bool"},
+            "ml_lab": {"name": "ML Lab", "category": "Features", "type": "bool"},
+            "registration": {"name": "Registration", "category": "Features", "type": "bool"},
+            "theme_toggle": {"name": "Theme toggle", "category": "Features", "type": "bool"},
+            "branding_controls": {"name": "Branding controls", "category": "Features", "type": "bool"},
+            "plugins": {"name": "Plugins", "category": "Features", "type": "bool"},
+            "premium_db_backends": {"name": "Premium DB backends", "category": "Features", "type": "bool"},
+            "audit_export": {"name": "Audit/export", "category": "Features", "type": "bool"},
+            "max_users": {"name": "Max users", "category": "Limits", "type": "int", "unit": "users"},
+            "max_pages": {"name": "Max pages", "category": "Limits", "type": "int", "unit": "pages"},
+            "max_upload_mb": {"name": "Max upload size", "category": "Limits", "type": "int", "unit": "MB"},
+            "max_pdf_pages_per_doc": {
+                "name": "Max PDF pages per document",
+                "category": "Limits",
+                "type": "int",
+                "unit": "pages",
+            },
+            "max_vector_records": {"name": "Max vector records", "category": "Limits", "type": "int", "unit": "records"},
+        }
+    },
+}
+#########################################
+
+def _catalogue_dir() -> str:
+    return os.path.join(os.path.dirname(__file__))
+
+
+def load_index() -> Dict[str, Any]:
+    """Load catalogue index.json (safe, returns fallback on failure)."""
+    data = _read_json(os.path.join(_catalogue_dir(), "index.json"))
+    if data:
+        return data
+    data = _read_json_resource("index.json")
+    return data if data else dict(_FALLBACK_INDEX)
+
+
+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 not cat:
+        cat = _read_json_resource(str(fname))
+    if not cat:
+        cat = dict(_FALLBACK_CATALOGUE_V1)
+
+    # 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_core-1.0.8 → syntaxmatrix_core-1.0.9}/syntaxmatrix/premium/gate.py

@@ -3,8 +3,12 @@ from __future__ import annotations
 import json
 import os
 from dataclasses import dataclass
+from datetime import datetime
 from typing import Any, Dict, Optional
 
+from .verify import verify_licence_payload
+from .runtime_paths import runtime_lease_path
+
 
 def _safe_json_loads(raw: str, *, default: Any) -> Any:
     try:
@@ -15,24 +19,14 @@ def _safe_json_loads(raw: str, *, default: Any) -> Any:
 
 @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")
+    
+    lease_file_relpath: str = os.path.join("premium", "runtime_lease.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.
+    The gate now trusts only a signed runtime lease that is bound to the
+    instance and current runtime fingerprint.
     """
 
     def __init__(
@@ -47,45 +41,36 @@ class FeatureGate:
         self._sources = sources or GateSources()
         self._cache: Optional[Dict[str, Any]] = None
 
-    def _load_from_env(self) -> Optional[Dict[str, Any]]:
-        raw = os.environ.get(self._sources.env_json)
-        if not raw:
+    def _normalise(self, data: Optional[Dict[str, Any]]) -> Optional[Dict[str, Any]]:
+        if not isinstance(data, dict):
             return None
-        data = _safe_json_loads(raw, default=None)
-        return data if isinstance(data, dict) else None
-
-    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 data if isinstance(data, dict) else 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_file(self) -> Optional[Dict[str, Any]]:
-        p = os.path.join(self._client_dir, self._sources.licence_file_relpath)
+        p = runtime_lease_path(self._client_dir)
         if not os.path.exists(p):
             return None
         try:
             with open(p, "r", encoding="utf-8") as f:
                 data = json.load(f)
-            return data if isinstance(data, dict) else None
         except Exception:
             return None
 
+        verified = verify_licence_payload(data, now=datetime.utcnow(), allow_unsigned=False)
+        if not verified.ok:
+            return None
+        return self._normalise(verified.entitlements)
+
     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()
+        ent = self._load_from_file()
         if ent is None:
             ent = {}
 
@@ -93,7 +78,6 @@ class FeatureGate:
         return ent
 
     def enabled(self, key: str) -> bool:
-        """True if entitlement exists and is truthy."""
         key = (key or "").strip()
         if not key:
             return False

syntaxmatrix_core-1.0.9/syntaxmatrix/premium/runtime_paths.py

@@ -0,0 +1,109 @@
+from __future__ import annotations
+
+import hashlib
+import os
+import tempfile
+from typing import Dict
+
+
+_RUNTIME_ENV_NAMES = ("SMX_PREMIUM_RUNTIME_DIR", "SMX_RUNTIME_DIR")
+_AUDIT_ENV_NAME = "SMX_PREMIUM_AUDIT_DIR"
+
+
+def _clean(value: str) -> str:
+    return str(value or "").strip()
+
+
+def _ensure_dir(path: str) -> str:
+    if not path:
+        return path
+    os.makedirs(path, exist_ok=True)
+    return path
+
+
+def _stable_runtime_bucket_name(client_dir: str) -> str:
+    raw = _clean(client_dir) or "default"
+    digest = hashlib.sha256(raw.encode("utf-8")).hexdigest()[:16]
+    return f"smx_runtime_{digest}"
+
+
+def _default_runtime_root(client_dir: str) -> str:
+    base_tmp = tempfile.gettempdir()
+    leaf = _stable_runtime_bucket_name(client_dir)
+    return os.path.join(base_tmp, leaf)
+
+
+def resolve_runtime_root(client_dir: str, *, ensure: bool = True) -> str:
+    root = ""
+    for env_name in _RUNTIME_ENV_NAMES:
+        candidate = _clean(os.environ.get(env_name))
+        if candidate:
+            root = candidate
+            break
+
+    if not root:
+        root = _default_runtime_root(client_dir)
+
+    if ensure and root:
+        try:
+            _ensure_dir(root)
+        except Exception:
+            pass
+    return root
+
+
+def resolve_runtime_premium_dir(client_dir: str, *, ensure: bool = True) -> str:
+    root = resolve_runtime_root(client_dir, ensure=ensure)
+    path = os.path.join(root, "premium") if root else os.path.join("premium")
+    if ensure:
+        try:
+            _ensure_dir(path)
+        except Exception:
+            pass
+    return path
+
+
+def resolve_audit_root(client_dir: str, *, ensure: bool = True) -> str:
+    root = _clean(os.environ.get(_AUDIT_ENV_NAME)) or _clean(client_dir)
+    if ensure and root:
+        try:
+            _ensure_dir(root)
+        except Exception:
+            pass
+    return root
+
+
+def resolve_audit_premium_dir(client_dir: str, *, ensure: bool = True) -> str:
+    root = resolve_audit_root(client_dir, ensure=ensure)
+    path = os.path.join(root, "premium") if root else os.path.join("premium")
+    if ensure:
+        try:
+            _ensure_dir(path)
+        except Exception:
+            pass
+    return path
+
+
+def runtime_lease_path(client_dir: str) -> str:
+    return os.path.join(resolve_runtime_premium_dir(client_dir), "runtime_lease.json")
+
+
+def tamper_queue_path(client_dir: str) -> str:
+    return os.path.join(resolve_runtime_premium_dir(client_dir), "tamper_queue.jsonl")
+
+
+def tamper_audit_path(client_dir: str) -> str:
+    return os.path.join(resolve_audit_premium_dir(client_dir), "tamper_audit.log")
+
+
+def describe_premium_paths(client_dir: str) -> Dict[str, str]:
+    runtime_root = resolve_runtime_root(client_dir, ensure=False)
+    audit_root = resolve_audit_root(client_dir, ensure=False)
+    return {
+        "client_dir": _clean(client_dir),
+        "runtime_root": runtime_root,
+        "runtime_lease_path": os.path.join(runtime_root, "premium", "runtime_lease.json") if runtime_root else "",
+        "tamper_queue_path": os.path.join(runtime_root, "premium", "tamper_queue.jsonl") if runtime_root else "",
+        "audit_root": audit_root,
+        "tamper_audit_path": os.path.join(audit_root, "premium", "tamper_audit.log") if audit_root else "",
+    }