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

syntaxmatrix/db_backends/sqlite_backend.py

@@ -0,0 +1,258 @@
+from __future__ import annotations
+import sqlite3
+import os
+import json
+from werkzeug.utils import secure_filename
+from syntaxmatrix.project_root import detect_project_root
+
+
+_CLIENT_DIR = detect_project_root()
+DB_PATH = os.path.join(_CLIENT_DIR, "data", "syntaxmatrix.db")
+os.makedirs(os.path.dirname(DB_PATH), exist_ok=True)
+
+TEMPLATES_DIR = os.path.join(_CLIENT_DIR, "templates")
+os.makedirs(TEMPLATES_DIR, exist_ok=True)
+
+
+# ------------ Utils ------------
+def connect_db():
+    conn = sqlite3.connect(DB_PATH)
+    conn.row_factory = sqlite3.Row
+    return conn
+
+def _col_exists(conn, table: str, col: str) -> bool:
+    cur = conn.execute(f"PRAGMA table_info({table})")
+    cols = [r["name"] for r in cur.fetchall()]
+    return col in cols
+
+def _ensure_column(conn, table: str, col: str, col_sql: str):
+    if not _col_exists(conn, table, col):
+        conn.execute(f"ALTER TABLE {table} ADD COLUMN {col} {col_sql}")
+
+def _ensure_index(conn, idx_sql: str):
+    try:
+        conn.execute(idx_sql)
+    except Exception:
+        pass
+
+
+# ------------ Schema init ------------
+def init_db():
+    conn = connect_db()
+    conn.execute("""
+        CREATE TABLE IF NOT EXISTS pages (
+            name TEXT PRIMARY KEY,
+            content TEXT NOT NULL,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )
+    """)
+    conn.execute("""
+        CREATE TABLE IF NOT EXISTS page_layouts (
+            name TEXT PRIMARY KEY,
+            layout_json TEXT NOT NULL,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )
+    """)
+    conn.execute("""
+        CREATE TABLE IF NOT EXISTS settings (
+            key TEXT PRIMARY KEY,
+            value TEXT NOT NULL,
+            updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )
+    """)
+    conn.execute("""
+        CREATE TABLE IF NOT EXISTS audit_log (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            action TEXT NOT NULL,
+            subject TEXT,
+            meta TEXT,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )
+    """)
+
+    _init_media_assets_table(conn)
+
+    conn.commit()
+    conn.close()
+
+
+# ------------ Pages ------------
+def get_pages():
+    conn = connect_db()
+    cur = conn.execute("SELECT name FROM pages ORDER BY name")
+    rows = [r["name"] for r in cur.fetchall()]
+    conn.close()
+    return rows
+
+def get_page(name: str):
+    conn = connect_db()
+    cur = conn.execute("SELECT name, content FROM pages WHERE name = ?", (name,))
+    row = cur.fetchone()
+    conn.close()
+    return dict(row) if row else None
+
+def add_page(name: str, content: str):
+    conn = connect_db()
+    conn.execute("INSERT OR REPLACE INTO pages (name, content) VALUES (?, ?)", (name, content))
+    conn.commit()
+    conn.close()
+
+def update_page(name: str, content: str):
+    conn = connect_db()
+    conn.execute("UPDATE pages SET content = ?, updated_at = CURRENT_TIMESTAMP WHERE name = ?", (content, name))
+    conn.commit()
+    conn.close()
+
+def delete_page(name: str):
+    conn = connect_db()
+    conn.execute("DELETE FROM pages WHERE name = ?", (name,))
+    conn.execute("DELETE FROM page_layouts WHERE name = ?", (name,))
+    conn.commit()
+    conn.close()
+
+def rename_page(old_name: str, new_name: str):
+    conn = connect_db()
+    conn.execute("UPDATE pages SET name = ? WHERE name = ?", (new_name, old_name))
+    conn.execute("UPDATE page_layouts SET name = ? WHERE name = ?", (new_name, old_name))
+    conn.commit()
+    conn.close()
+
+
+# ------------ Layouts ------------
+def upsert_page_layout(name: str, layout_json: str):
+    conn = connect_db()
+    conn.execute(
+        "INSERT OR REPLACE INTO page_layouts (name, layout_json) VALUES (?, ?)",
+        (name, layout_json)
+    )
+    conn.commit()
+    conn.close()
+
+def get_page_layout(name: str):
+    conn = connect_db()
+    cur = conn.execute("SELECT name, layout_json FROM page_layouts WHERE name = ?", (name,))
+    row = cur.fetchone()
+    conn.close()
+    return dict(row) if row else None
+
+def get_all_page_layouts():
+    conn = connect_db()
+    cur = conn.execute("SELECT name, layout_json FROM page_layouts ORDER BY name")
+    rows = [dict(r) for r in cur.fetchall()]
+    conn.close()
+    return rows
+
+
+# ------------ Settings ------------
+def get_setting(key: str, default=None):
+    conn = connect_db()
+    cur = conn.execute("SELECT value FROM settings WHERE key = ?", (key,))
+    row = cur.fetchone()
+    conn.close()
+    if not row:
+        return default
+    try:
+        return json.loads(row["value"])
+    except Exception:
+        return row["value"]
+
+def set_setting(key: str, value):
+    conn = connect_db()
+    conn.execute(
+        "INSERT OR REPLACE INTO settings (key, value, updated_at) VALUES (?, ?, CURRENT_TIMESTAMP)",
+        (key, json.dumps(value))
+    )
+    conn.commit()
+    conn.close()
+
+def delete_setting(key: str):
+    conn = connect_db()
+    conn.execute("DELETE FROM settings WHERE key = ?", (key,))
+    conn.commit()
+    conn.close()
+
+
+# ------------ Audit log ------------
+def audit(action: str, subject: str = "", meta: dict | None = None):
+    conn = connect_db()
+    conn.execute(
+        "INSERT INTO audit_log (action, subject, meta) VALUES (?, ?, ?)",
+        (action, subject, json.dumps(meta or {}))
+    )
+    conn.commit()
+    conn.close()
+
+
+# ------------ Media assets (dedupe + metadata) ------------
+MEDIA_DIR = os.path.join(_CLIENT_DIR, "uploads", "media")
+os.makedirs(MEDIA_DIR, exist_ok=True)
+
+MEDIA_IMAGES_DIR = os.path.join(MEDIA_DIR, "images")
+os.makedirs(MEDIA_IMAGES_DIR, exist_ok=True)
+
+MEDIA_THUMBS_DIR = os.path.join(MEDIA_DIR, "thumbs")
+os.makedirs(MEDIA_THUMBS_DIR, exist_ok=True)
+
+def _init_media_assets_table(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,
+            bytes      INTEGER,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )
+    """)
+    _ensure_index(conn, "CREATE INDEX IF NOT EXISTS idx_media_assets_kind ON media_assets(kind)")
+    _ensure_index(conn, "CREATE INDEX IF NOT EXISTS idx_media_assets_sha256 ON media_assets(sha256)")
+    _ensure_index(conn, "CREATE INDEX IF NOT EXISTS idx_media_assets_dhash ON media_assets(dhash)")
+
+def upsert_media_asset(kind: str, rel_path: str, thumb_path: str | None = None,
+                       sha256: str | None = None, dhash: str | None = None,
+                       width: int | None = None, height: int | None = None, bytes_: int | None = None):
+    conn = connect_db()
+    _init_media_assets_table(conn)
+    conn.execute(
+        """
+        INSERT INTO media_assets (kind, rel_path, thumb_path, sha256, dhash, width, height, bytes)
+        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,
+            bytes=excluded.bytes
+        """,
+        (kind, rel_path, thumb_path, sha256, dhash, width, height, bytes_)
+    )
+    conn.commit()
+    conn.close()
+
+def get_media_asset_by_rel_path(rel_path: str):
+    conn = connect_db()
+    cur = conn.execute("SELECT * FROM media_assets WHERE rel_path = ?", (rel_path,))
+    row = cur.fetchone()
+    conn.close()
+    return dict(row) if row else None
+
+def list_media_assets(kind: str = "image"):
+    conn = connect_db()
+    cur = conn.execute("SELECT * FROM media_assets WHERE kind = ? ORDER BY id DESC", (kind,))
+    rows = [dict(r) for r in cur.fetchall()]
+    conn.close()
+    return rows
+
+def normalise_media_filename(filename: str) -> str:
+    filename = secure_filename(filename or "file")
+    if not filename:
+        filename = "file"
+    return filename

syntaxmatrix/db_contract.py

@@ -0,0 +1,71 @@
+# syntaxmatrix/db_contract.py
+from __future__ import annotations
+
+from typing import Dict, Iterable, Optional
+
+
+# Keep this list tight: only functions that the framework truly depends on.
+# If we add more later, we do it deliberately.
+CORE_REQUIRED_FUNCTIONS = (
+    # Pages
+    "get_pages",
+    "get_page_html",
+    "add_page",
+    "update_page",
+    "delete_page",
+
+    # Secrets
+    "get_secrets",
+    "set_secret",
+    "delete_secret",
+
+    # Nav
+    "get_nav_links",
+    "set_nav_links",
+
+    # Page layouts (builder)
+    "get_page_layout",
+    "upsert_page_layout",
+    "delete_page_layout",
+
+    # Media library
+    "add_media_file",
+    "list_media_files",
+    "delete_media_file",
+
+    # Generic settings (used by branding + profiles + other admin toggles)
+    "get_setting",
+    "set_setting",
+
+    # Optional: some backends may want init, but we do not force it here.
+)
+
+
+def assert_backend_implements_core_api(ns: Dict[str, object], *, provider: str = "") -> None:
+    """
+    Validate that the loaded backend provides the minimum required surface.
+
+    `ns` is usually `globals()` from syntaxmatrix.db (the facade module).
+
+    We keep this strict for non-SQLite providers, because:
+    - SQLite is the built-in reference backend.
+    - Premium/Cloud backends must be complete, or we fail fast with a clear error.
+    """
+    missing = []
+    for fn in CORE_REQUIRED_FUNCTIONS:
+        obj = ns.get(fn)
+        if not callable(obj):
+            missing.append(fn)
+
+    if missing:
+        prov = provider or "unknown"
+        raise RuntimeError(
+            "SyntaxMatrix DB backend validation failed.\n"
+            f"Provider: {prov}\n"
+            "Missing required functions:\n"
+            f"  - " + "\n  - ".join(missing) + "\n\n"
+            "Fix:\n"
+            "- If you are using the premium Postgres backend, ensure the premium package is installed\n"
+            "  and that your backend module's install(ns) correctly injects these functions.\n"
+            "- If you are writing your own backend, implement the missing functions.\n"
+        )

syntaxmatrix/kernel_manager.py

@@ -44,135 +44,46 @@ class SyntaxMatrixKernelManager:
     def cleanup_all(cls):
         for sid in list(cls._kernels):
             cls.shutdown_kernel(sid)
+    
+    def _prefer_display_over_to_html(code: str) -> str:
+        """
+        Convert common 'print(df.to_html())' patterns into IPython display(df).
+        Best-effort only; avoids breaking code.
+        """
+        if not code or "to_html" not in code:
+            return code
+
+        # Replace print(X.to_html()) -> display(X)
+        code2 = _re.sub(
+            r"print\(\s*([A-Za-z_][A-Za-z0-9_\.]*)\s*\.to_html\(\s*\)\s*\)",
+            r"display(\1)",
+            code,
+            flags=_re.IGNORECASE,
+        )
 
+        # Replace print(pd.DataFrame(...).to_html()) -> display(pd.DataFrame(...))
+        code2 = _re.sub(
+            r"print\(\s*(pd\.DataFrame\([^\)]*\))\s*\.to_html\(\s*\)\s*\)",
+            r"display(\1)",
+            code2,
+            flags=_re.IGNORECASE,
+        )
 
-_df_cache = None
-
-def execute_code_in_kernel(kc, code, timeout=120):
-
-    _local_stdout = ""
-    _local_stderr = ""
+        # If we introduced display(), ensure import exists
+        if "display(" in code2 and "from IPython.display import display" not in code2:
+            code2 = "from IPython.display import display\n" + code2
 
-    global _df_cache
-    exec_namespace = {}
+        return code2
 
-    if not hasattr(_pd.core.generic.NDFrame, "_patch_safe_reduce"):
-        _AGG_FUNCS = (
-            "sum", "mean", "median", "std", "var",
-            "min", "max", "prod",
-        )
 
-        def _make_wrapper(name):
-            orig = getattr(_pd.core.generic.NDFrame, name)
-
-            @wraps(orig)
-            def _wrapper(self, *args, **kwargs):
-                try:
-                    return orig(self, *args, **kwargs)
-
-                except TypeError as exc:
-                    msg = str(exc)
-                    if (
-                        "can only concatenate str" not in msg
-                        and "could not convert"   not in msg
-                    ):
-                        raise  # - not the error we’re guarding against
-
-                    # Caller already supplied numeric_only (positional or kw) → re-raise
-                    if len(args) >= 3 or "numeric_only" in kwargs:
-                        raise
-
-                    kwargs = dict(kwargs)
-                    kwargs["numeric_only"] = True
-                    return orig(self, *args, **kwargs)
-
-            return _wrapper
-
-        for _fn in _AGG_FUNCS:
-            setattr(
-                _pd.core.generic.NDFrame,
-                f"_orig_{_fn}",
-                getattr(_pd.core.generic.NDFrame, _fn),
-            )
-            setattr(
-                _pd.core.generic.NDFrame,
-                _fn,
-                _make_wrapper(_fn),
-            )
-
-        # marker so we don’t patch twice in the same kernel
-        _pd.core.generic.NDFrame._patch_safe_reduce = True
-
-    if "_pandas_sum_patched" not in exec_namespace:
-
-        if not hasattr(_pd.core.generic.NDFrame, "_orig_sum"):
-            _pd.core.generic.NDFrame._orig_sum  = _pd.core.generic.NDFrame.sum
-            _pd.core.generic.NDFrame._orig_mean = _pd.core.generic.NDFrame.mean   # ← NEW
-
-            def _safe_agg(orig_func):
-                def wrapper(self, *args, **kwargs):
-                    try:
-                        return orig_func(self, *args, **kwargs)
-
-                    except TypeError as exc:
-                        # Only rescue the classic mixed-dtype failure
-                        if ("can only concatenate"   not in str(exc) and
-                            "could not convert"      not in str(exc)):
-                            raise
-
-                        # Caller already gave numeric_only → we must not override
-                        if "numeric_only" in kwargs or len(args) >= 3:
-                            raise
-
-                        kwargs = dict(kwargs)
-                        kwargs["numeric_only"] = True
-                        return orig_func(self, *args, **kwargs)
-                return wrapper
-
-            _pd.core.generic.NDFrame.sum  = _safe_agg(_pd.core.generic.NDFrame._orig_sum)
-            _pd.core.generic.NDFrame.mean = _safe_agg(_pd.core.generic.NDFrame._orig_mean)
-
-        exec_namespace["_pandas_sum_patched"] = True
-
-    # inject cached df if we have one
-    if _df_cache is not None:
-        exec_namespace["df"] = _df_cache
-    
-    try:
-        # Prevent any print()/stdout/stderr from hitting your server console
-        _buf_out, _buf_err = io.StringIO(), io.StringIO()
-        with contextlib.redirect_stdout(_buf_out), contextlib.redirect_stderr(_buf_err):
-            exec(code, exec_namespace, exec_namespace)
-        
-        _local_stdout = _buf_out.getvalue()
-        _local_stderr = _buf_err.getvalue()
-
-    # ── show a friendly “missing package” hint ────
-    except (ModuleNotFoundError, ImportError) as e:
-        missing = getattr(e, "name", None) or str(e).split("'")[1]
-        hint = (
-
-            f"<div style='color:red; font-weight:bold;'>"
-            f"Missing package: <code>{missing}</code><br>"
-            f"Activate this virtual-env and run:<br>"
-            f"<code>pip install {missing}</code><br>"
-            f"then re-run your query.</div>"
-        )
-        return [hint], []      
-    
-    except Exception:
-        pass
+_df_cache = None
 
-   # cache df for next call
-    if "df" in exec_namespace:
-        _df_cache = exec_namespace["df"]
+def execute_code_in_kernel(kc, code, timeout=120):
 
-    # Auto-import display if needed (original code) :contentReference[oaicite:0]{index=0}
+    code = SyntaxMatrixKernelManager._prefer_display_over_to_html(code)
     if "display(" in code and "from IPython.display import display" not in code:
         code = "from IPython.display import display\n" + code
 
-    # ------------------------------------------------------------------
-    # everything below is the original while-loop message collector
     msg_id = kc.execute(
         code,
         user_expressions={"_last": "(_)",},
@@ -211,18 +122,6 @@ def execute_code_in_kernel(kc, code, timeout=120):
             if txt:
                 output_blocks.append(f"<pre>{_html.escape(txt)}</pre>")
 
-        # elif mtype in ("execute_result", "display_data"):
-        #     data = content["data"]
-        #     if "text/html" in data:
-        #         output_blocks.append(data["text/html"])
-        #     elif "image/png" in data:
-        #         output_blocks.append(
-        #             f"<img src='data:image/png;base64,{data['image/png']}' "
-        #             f"style='max-width:100%;'/>"
-        #         )
-        #     else:
-        #         output_blocks.append(f"<pre>{data.get('text/plain','')}</pre>")
-
         elif mtype in ("execute_result", "display_data"):
             data = content.get("data", {})
             if "text/html" in data:
@@ -246,38 +145,163 @@ def execute_code_in_kernel(kc, code, timeout=120):
             # keep the traceback html-friendly
             traceback_html = "<br>".join(content["traceback"])
             errors.append(f"<pre style='color:red;'>{traceback_html}</pre>")
-    # --- surface the locally captured commentary (stdout/stderr) back to the UI ---
-    if _local_stdout.strip():
-        # Put commentary first so the user sees it above plots/tables
-        output_blocks.insert(0, f"<pre>{_html.escape(_local_stdout)}</pre>")
-    if _local_stderr.strip():
-        errors.insert(0, f"<pre style='color:#b00;'>{_html.escape(_local_stderr)}</pre>")
 
     def _smx_strip_display_reprs(text: str) -> str:
-        if not text:
-            return text
-        # remove tokens like "<IPython.core.display.HTML object>"
-        text = _re.sub(r"<IPython\.core\.display\.[A-Za-z]+\s+object>", "", text)
-        # if these were printed as lists, remove leftover brackets/commas
-        text = _re.sub(r"[\[\],]", " ", text)
-        # collapse whitespace
-        text = _re.sub(r"\s+", " ", text).strip()
+        """Remove noisy Jupyter display reprs while keeping line breaks readable."""
+        if text is None:
+            return ""
+        # Strip common display wrappers that sometimes leak into stdout
+        text = text.replace("<IPython.core.display.HTML object>", "")
+        text = text.replace("<IPython.core.display.Markdown object>", "")
+        text = text.replace("<IPython.core.display.Image object>", "")
+
+        # Normalise line endings but KEEP newlines
+        text = text.replace("\r\n", "\n").replace("\r", "\n")
+
+        # Collapse runs of spaces/tabs per line (do not flatten newlines)
+        lines = []
+        for ln in text.split("\n"):
+            ln = _re.sub(r"[\t ]{2,}", " ", ln).rstrip()
+            lines.append(ln)
+
+        text = "\n".join(lines).strip()
+
+        # Avoid huge blank sections
+        text = _re.sub(r"\n{3,}", "\n\n", text)
         return text
 
+    def _sanitize_table_html(table_html: str) -> str:
+        """Best-effort sanitiser for DataFrame-style HTML tables (blocks scripts/events)."""
+        if not table_html:
+            return ""
+        # Remove scripts and styles outright
+        table_html = _re.sub(
+            r"<\s*script[^>]*>.*?<\s*/\s*script\s*>",
+            "",
+            table_html,
+            flags=_re.IGNORECASE | _re.DOTALL,
+        )
+        table_html = _re.sub(
+            r"<\s*style[^>]*>.*?<\s*/\s*style\s*>",
+            "",
+            table_html,
+            flags=_re.IGNORECASE | _re.DOTALL,
+        )
+
+        # Drop inline event handlers (onload=, onclick=, etc.)
+        table_html = _re.sub(r"\son\w+\s*=\s*\"[^\"]*\"", "", table_html, flags=_re.IGNORECASE)
+        table_html = _re.sub(r"\son\w+\s*=\s*\'[^\']*\'", "", table_html, flags=_re.IGNORECASE)
+
+        # Block javascript: URLs
+        table_html = _re.sub(r"javascript\s*:", "", table_html, flags=_re.IGNORECASE)
+        return table_html.strip()
+
+
+    def _smx_ensure_table_class(table_html: str) -> str:
+        """Ensure DataFrame tables pick up the dashboard's .smx-table styling."""
+        if not table_html:
+            return ""
+
+        def _inject_class(m):
+            tag = m.group(0)
+
+            # If there's already a class="", append smx-table
+            if _re.search(r"\bclass\s*=", tag, flags=_re.IGNORECASE):
+                tag = _re.sub(
+                    r'(class\s*=\s*["\'])([^"\']*)(["\'])',
+                    lambda mm: f"{mm.group(1)}{mm.group(2)} smx-table{mm.group(3)}",
+                    tag,
+                    count=1,
+                    flags=_re.IGNORECASE,
+                )
+            else:
+                # add class attr
+                tag = tag[:-1] + ' class="smx-table">'
+
+            # Remove noisy border attr if present (optional)
+            tag = _re.sub(r'\sborder\s*=\s*["\']?\d+["\']?', "", tag, flags=_re.IGNORECASE)
+            return tag
+
+        return _re.sub(r"<table\b[^>]*>", _inject_class, table_html, count=1, flags=_re.IGNORECASE)
+
+    def _smx_wrap_df_table(table_html: str, max_h: int = 460) -> str:
+        """
+        Wrap table in a scroll box and apply the same table class the dashboard already styles.
+        """
+        table_html = _smx_ensure_table_class(table_html)
+        if not table_html:
+            return ""
+        return (
+            f"<div class='smx-scroll' style='overflow:auto; max-height:{int(max_h)}px;'>"
+            f"{table_html}"
+            f"</div>"
+        )
+
+    def _split_text_and_tables(text: str):
+        """Yield (kind, chunk) where kind is 'text' or 'table'."""
+        if not text:
+            return [("text", "")]
+        out = []
+        last = 0
+        for m in _TABLE_RE.finditer(text):
+            if m.start() > last:
+                out.append(("text", text[last:m.start()]))
+            out.append(("table", m.group(1)))
+            last = m.end()
+        if last < len(text):
+            out.append(("text", text[last:]))
+        return out
+
+    _TABLE_RE = _re.compile(r"(<table\b.*?</table>)", flags=_re.IGNORECASE | _re.DOTALL)
+
     _cleaned_blocks = []
     for blk in output_blocks:
         # pre-wrapped plaintext
         if blk.startswith("<pre>") and blk.endswith("</pre>"):
             inner = blk[5:-6]
-            inner = _smx_strip_display_reprs(_html.unescape(inner))
-            if inner:
-                _cleaned_blocks.append(f"<pre>{_html.escape(inner)}</pre>")
-            # if empty after cleaning, drop it
+            inner = _html.unescape(inner)
+
+            # If stdout contains HTML tables (e.g., DataFrame.to_html()), render them as tables
+            # rather than showing the raw <table> markup inside a <pre> block.
+            low = inner.lower()
+            if "<table" in low and "</table>" in low:
+                parts = _split_text_and_tables(inner)
+            else:
+                parts = [("text", inner)]
+
+            for kind, chunk in parts:
+                if not chunk:
+                    continue
+                if kind == "table":
+                    safe_tbl = _sanitize_table_html(chunk)
+                    if safe_tbl:
+                        _cleaned_blocks.append(_smx_wrap_df_table(safe_tbl))
+                else:
+                    txt = _smx_strip_display_reprs(chunk)
+                    if txt:
+                        _cleaned_blocks.append(f"<pre>{_html.escape(txt)}</pre>")
+
             continue
 
         # html/img payloads: just remove stray repr tokens if they slipped in
         cleaned = _re.sub(r"<IPython\.core\.display\.[A-Za-z]+\s+object>", "", blk)
-        _cleaned_blocks.append(cleaned)
+        low = cleaned.lower()
+        if "<table" in low and "</table>" in low:
+            parts = _split_text_and_tables(cleaned)
+            for kind, chunk in parts:
+                if not chunk:
+                    continue
+                if kind == "table":
+                    safe_tbl = _sanitize_table_html(chunk)
+                    wrapped = _smx_wrap_df_table(safe_tbl)
+                    if wrapped:
+                        _cleaned_blocks.append(wrapped)
+                else:
+                    # keep non-table html as-is
+                    if chunk.strip():
+                        _cleaned_blocks.append(chunk)
+        else:
+            _cleaned_blocks.append(cleaned)
     output_blocks = _cleaned_blocks
 
     return output_blocks, errors