syntaxmatrix 2.5.8.2__py3-none-any.whl → 2.6.0__py3-none-any.whl

syntaxmatrix/db.py

@@ -14,9 +14,10 @@ TEMPLATES_DIR = os.path.join(_CLIENT_DIR, "templates")
 os.makedirs(TEMPLATES_DIR, exist_ok=True)
 
 
-# ***************************************
-# Pages Table Functions
-# ***************************************
+
+# ─────────────────────────────────────────────────────────
+# Page 
+# ─────────────────────────────────────────────────────────
 def init_db():
     conn = sqlite3.connect(DB_PATH)
     
@@ -38,10 +39,42 @@ def init_db():
         )
     """)
 
+    conn.execute("""
+        CREATE TABLE IF NOT EXISTS secretes (
+            name TEXT PRIMARY KEY,
+            value TEXT NOT NULL,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )
+    """)
+
+    conn.execute("""
+        CREATE TABLE IF NOT EXISTS media_assets (
+            id         INTEGER PRIMARY KEY AUTOINCREMENT,
+            kind       TEXT NOT NULL DEFAULT 'image',
+            rel_path   TEXT NOT NULL UNIQUE,
+            thumb_path TEXT,
+            sha256     TEXT,
+            dhash      TEXT,
+            width      INTEGER,
+            height     INTEGER,
+            mime       TEXT,
+            source     TEXT,
+            source_url TEXT,
+            author     TEXT,
+            licence    TEXT,
+            tags       TEXT,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )
+    """)
+
     conn.commit()
     conn.close()
 
 
+# ***************************************
+# Pages Helpers
+# ***************************************
 def get_pages():
     """Return {page_name: html} resolving relative paths under syntaxmatrixdir/templates."""
     import sqlite3
@@ -62,6 +95,44 @@ def get_pages():
     return pages
 
 
+def get_page_html(name: str):
+    """
+    Return the latest HTML for a single page by reading the file path stored in DB.
+    This avoids stale in-memory cache (smx.pages) across Gunicorn workers.
+    """
+    if not name:
+        return None
+
+    conn = sqlite3.connect(DB_PATH)
+    try:
+        row = conn.execute(
+            "SELECT content FROM pages WHERE lower(name) = lower(?)",
+            (name.strip(),)
+        ).fetchone()
+    finally:
+        conn.close()
+
+    if not row:
+        return None
+
+    stored = (row[0] or "").strip()
+    if not stored:
+        return None
+
+    # Backwards compatible: if DB ever stored raw HTML instead of a file path
+    if stored.lstrip().startswith("<"):
+        return stored
+
+    # Resolve path (relative under syntaxmatrixdir)
+    abs_path = stored if os.path.isabs(stored) else os.path.join(_CLIENT_DIR, stored)
+
+    try:
+        with open(abs_path, "r", encoding="utf-8") as f:
+            return f.read()
+    except Exception:
+        return None
+
+
 def add_page(name, html):
     """Create templates/<slug>.html and store a relative path in the DB."""
     filename = secure_filename(name.lower()) + ".html"
@@ -151,4 +222,345 @@ def delete_page(name):
 
     cur.execute("DELETE FROM pages WHERE name = ?", (name,))
     conn.commit()
-    conn.close()
+    conn.close()
+
+
+# ***************************************
+# Secrete Helpers
+# ***************************************
+def set_secret(name: str, value: str) -> None:
+    """Create/update a secret in the local SyntaxMatrix DB."""
+    if not name:
+        return
+    name = name.strip().upper()
+    conn = sqlite3.connect(DB_PATH)
+    try:
+        with conn:
+            conn.execute(
+                """
+                INSERT INTO secretes (name, value, updated_at)
+                VALUES (?, ?, CURRENT_TIMESTAMP)
+                ON CONFLICT(name) DO UPDATE SET
+                    value = excluded.value,
+                    updated_at = CURRENT_TIMESTAMP
+                """,
+                (name, value),
+            )
+    finally:
+        conn.close()
+
+
+def get_secret(name: str) -> str | None:
+    """Get a secret value, or None if missing."""
+    if not name:
+        return None
+    name = name.strip().upper()
+    conn = sqlite3.connect(DB_PATH)
+    try:
+        row = conn.execute("SELECT value FROM secretes WHERE name = ?", (name,)).fetchone()
+        return row[0] if row else None
+    finally:
+        conn.close()
+
+
+def delete_secret(name: str) -> None:
+    if not name:
+        return
+    name = name.strip().upper()
+    conn = sqlite3.connect(DB_PATH)
+    try:
+        with conn:
+            conn.execute("DELETE FROM secretes WHERE name = ?", (name,))
+    finally:
+        conn.close()
+
+
+def list_secret_names() -> list[str]:
+    """Return secret names only (never values)."""
+    conn = sqlite3.connect(DB_PATH)
+    try:
+        rows = conn.execute("SELECT name FROM secretes ORDER BY name").fetchall()
+        return [r[0] for r in rows]
+    finally:
+        conn.close()
+
+
+# ─────────────────────────────────────────────────────────
+# Page navigation metadata (show_in_nav / nav_label)
+# ─────────────────────────────────────────────────────────
+def _init_page_nav_table():
+    """Ensure the page_nav table exists and has all expected columns."""
+    import sqlite3  # safe if already imported at top
+    conn = sqlite3.connect(DB_PATH)
+    try:
+        with conn:
+            # Create table if missing (with nav_order already defined)
+            conn.execute("""
+                CREATE TABLE IF NOT EXISTS page_nav (
+                    page_name   TEXT PRIMARY KEY,
+                    show_in_nav INTEGER NOT NULL DEFAULT 1,
+                    nav_label   TEXT,
+                    nav_order   INTEGER
+                )
+            """)
+
+            # If table existed before, make sure nav_order column is present
+            cur = conn.execute("PRAGMA table_info(page_nav)")
+            cols = [row[1] for row in cur.fetchall()]
+            if "nav_order" not in cols:
+                conn.execute("ALTER TABLE page_nav ADD COLUMN nav_order INTEGER")
+    finally:
+        conn.close()
+
+
+def set_page_nav(
+    page_name: str,
+    show_in_nav: bool = True,
+    nav_label: str | None = None,
+    nav_order: int | None = None,
+) -> None:
+    """
+    Upsert navigation preferences for a page.
+    """
+    if not page_name:
+        return
+    _init_page_nav_table()
+    import sqlite3
+    conn = sqlite3.connect(DB_PATH)
+    try:
+        with conn:
+            conn.execute("""
+                INSERT INTO page_nav (page_name, show_in_nav, nav_label, nav_order)
+                VALUES (?, ?, ?, ?)
+                ON CONFLICT(page_name) DO UPDATE SET
+                    show_in_nav = excluded.show_in_nav,
+                    nav_label   = excluded.nav_label,
+                    nav_order   = excluded.nav_order
+                """, (page_name.lower(), 1 if show_in_nav else 0, nav_label, nav_order),
+            )
+    finally:
+        conn.close()
+
+
+def get_page_nav_map() -> dict:
+    """
+    Return a dict mapping page_name -> {"show_in_nav": bool, "nav_label": str|None, "nav_order": int|None}.
+    """
+    _init_page_nav_table()
+    import sqlite3
+    conn = sqlite3.connect(DB_PATH)
+    try:
+        cur = conn.cursor()
+        cur.execute("SELECT page_name, show_in_nav, nav_label, nav_order FROM page_nav")
+        rows = cur.fetchall()
+    finally:
+        conn.close()
+
+    result = {}
+    for name, show, label, order_val in rows:
+        if not name:
+            continue
+        result[name.lower()] = {
+            "show_in_nav": bool(show),
+            "nav_label": label,
+            "nav_order": order_val,
+        }
+    return result
+
+
+# ─────────────────────────────────────────────────────────
+# Page layouts (builder JSON) kept separate from final HTML
+# ─────────────────────────────────────────────────────────
+def _init_page_layouts_table():
+    import sqlite3
+    conn = sqlite3.connect(DB_PATH)
+    try:
+        with conn:
+            conn.execute("""
+                CREATE TABLE IF NOT EXISTS page_layouts (
+                    page_name   TEXT PRIMARY KEY,
+                    layout_json TEXT NOT NULL,
+                    is_detached INTEGER NOT NULL DEFAULT 0,
+                    updated_at  TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+                )
+            """)
+    finally:
+        conn.close()
+
+
+def upsert_page_layout(page_name: str, layout_json: str, is_detached: bool | None = None) -> None:
+    if not page_name:
+        return
+    _init_page_layouts_table()
+    import sqlite3
+    conn = sqlite3.connect(DB_PATH)
+    try:
+        with conn:
+            if is_detached is None:
+                conn.execute(
+                    """
+                    INSERT INTO page_layouts (page_name, layout_json)
+                    VALUES (?, ?)
+                    ON CONFLICT(page_name) DO UPDATE SET
+                        layout_json = excluded.layout_json,
+                        updated_at  = CURRENT_TIMESTAMP
+                    """,
+                    (page_name.lower(), layout_json),
+                )
+            else:
+                conn.execute(
+                    """
+                    INSERT INTO page_layouts (page_name, layout_json, is_detached)
+                    VALUES (?, ?, ?)
+                    ON CONFLICT(page_name) DO UPDATE SET
+                        layout_json = excluded.layout_json,
+                        is_detached = excluded.is_detached,
+                        updated_at  = CURRENT_TIMESTAMP
+                    """,
+                    (page_name.lower(), layout_json, 1 if is_detached else 0),
+                )
+    finally:
+        conn.close()
+
+
+def get_page_layout(page_name: str) -> dict | None:
+    if not page_name:
+        return None
+    _init_page_layouts_table()
+    import sqlite3
+    conn = sqlite3.connect(DB_PATH)
+    try:
+        row = conn.execute(
+            "SELECT page_name, layout_json, is_detached, updated_at FROM page_layouts WHERE page_name = ?",
+            (page_name.lower(),),
+        ).fetchone()
+        if not row:
+            return None
+        return {
+            "page_name": row[0],
+            "layout_json": row[1],
+            "is_detached": bool(row[2]),
+            "updated_at": row[3],
+        }
+    finally:
+        conn.close()
+
+
+def _init_media_assets_table() -> None:
+    import sqlite3
+    conn = sqlite3.connect(DB_PATH)
+    try:
+        with conn:
+            conn.execute(
+                """
+                CREATE TABLE IF NOT EXISTS media_assets (
+                    id         INTEGER PRIMARY KEY AUTOINCREMENT,
+                    kind       TEXT NOT NULL DEFAULT 'image',
+                    rel_path   TEXT NOT NULL UNIQUE,
+                    thumb_path TEXT,
+                    sha256     TEXT,
+                    dhash      TEXT,
+                    width      INTEGER,
+                    height     INTEGER,
+                    mime       TEXT,
+                    source     TEXT,
+                    source_url TEXT,
+                    author     TEXT,
+                    licence    TEXT,
+                    tags       TEXT,
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+                )
+                """
+            )
+    finally:
+        conn.close()
+
+
+def upsert_media_asset(
+    *,
+    rel_path: str,
+    kind: str = "image",
+    thumb_path: str | None = None,
+    sha256: str | None = None,
+    dhash: str | None = None,
+    width: int | None = None,
+    height: int | None = None,
+    mime: str | None = None,
+    source: str | None = None,
+    source_url: str | None = None,
+    author: str | None = None,
+    licence: str | None = None,
+    tags: str | None = None,
+) -> None:
+    if not rel_path:
+        return
+    _init_media_assets_table()
+    import sqlite3
+    conn = sqlite3.connect(DB_PATH)
+    try:
+        with conn:
+            conn.execute(
+                """
+                INSERT INTO media_assets (
+                    kind, rel_path, thumb_path, sha256, dhash, width, height, mime,
+                    source, source_url, author, licence, tags
+                )
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                ON CONFLICT(rel_path) DO UPDATE SET
+                    kind       = excluded.kind,
+                    thumb_path = excluded.thumb_path,
+                    sha256     = excluded.sha256,
+                    dhash      = excluded.dhash,
+                    width      = excluded.width,
+                    height     = excluded.height,
+                    mime       = excluded.mime,
+                    source     = excluded.source,
+                    source_url = excluded.source_url,
+                    author     = excluded.author,
+                    licence    = excluded.licence,
+                    tags       = excluded.tags
+                """,
+                (
+                    kind, rel_path, thumb_path, sha256, dhash, width, height, mime,
+                    source, source_url, author, licence, tags,
+                ),
+            )
+    finally:
+        conn.close()
+
+
+def get_media_asset_by_rel_path(rel_path: str) -> dict | None:
+    if not rel_path:
+        return None
+    _init_media_assets_table()
+    import sqlite3
+    conn = sqlite3.connect(DB_PATH)
+    try:
+        row = conn.execute(
+            """
+            SELECT kind, rel_path, thumb_path, sha256, dhash, width, height, mime,
+                   source, source_url, author, licence, tags, created_at
+            FROM media_assets WHERE rel_path = ?
+            """,
+            (rel_path,),
+        ).fetchone()
+        if not row:
+            return None
+        return {
+            "kind": row[0],
+            "rel_path": row[1],
+            "thumb_path": row[2],
+            "sha256": row[3],
+            "dhash": row[4],
+            "width": row[5],
+            "height": row[6],
+            "mime": row[7],
+            "source": row[8],
+            "source_url": row[9],
+            "author": row[10],
+            "licence": row[11],
+            "tags": row[12],
+            "created_at": row[13],
+        }
+    finally:
+        conn.close()

syntaxmatrix/{display.py → display_html.py}

@@ -28,8 +28,6 @@ except Exception:  # pragma: no cover
 __all__ = ["show"]
 
 
-# ---- internal helpers -------------------------------------------------------
-
 
 def _wrap_html_table(html: str) -> str:
     """Apply consistent UI styling and horizontal scrolling."""
@@ -47,10 +45,7 @@ def _wrap_html_table(html: str) -> str:
     )
 
 
-# ---- public API -------------------------------------------------------------
-
-
-def show(obj: Any) -> None:
+def show_table(obj: Any) -> None:
     """
     Render common objects so the Dashboard (or chat) always shows output.
 
@@ -104,3 +99,4 @@ def show(obj: Any) -> None:
     # 6) Fallback: show as preformatted text (safe and predictable)
     display(HTML(f"<pre>{obj}</pre>"))
     return None
+

syntaxmatrix/gpt_models_latest.py

@@ -36,7 +36,7 @@ def set_args(
             "store": store,
             "truncation": truncation,
     }
-    if model == "gpt-5.1-chat-latest":
+    if model == "gpt-5.1-chat-latest" or "gpt-5.2-chat-latest":
         args = base_params
     else:
         args = {**base_params,