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

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