syntaxmatrix 1.4.6__py3-none-any.whl → 2.5.5.4__py3-none-any.whl

syntaxmatrix/gpt_models_latest.py

@@ -0,0 +1,46 @@
+# --- Helper: robustly extract text from Responses API objects ---
+def extract_output_text(resp) -> str:
+    # Fast path
+    if hasattr(resp, "output_text") and resp.output_text:
+        return resp.output_text.strip()
+    # Fallback: parse .output for message->content blocks
+    text_parts = []
+    output = getattr(resp, "output", None) or []
+    for item in output:
+        if getattr(item, "type", "") != "message":
+            continue
+        for block in getattr(item, "content", []) or []:
+            btype = getattr(block, "type", "")
+            if btype in ("output_text", "text"):
+                t = (getattr(block, "text", "") or "").strip()
+                if t:
+                    text_parts.append(t)
+    return "\n".join(text_parts).strip()
+
+
+def set_args(
+        model, 
+        instructions, 
+        input, 
+        previous_id=None, 
+        store=False, 
+        reasoning_effort="medium",  # "minimal", "low", "medium", "high"
+        verbosity="medium",            # "low", "medium", "high"
+        truncation="auto",
+    ):
+    base_params = {
+            "model": model,
+            "instructions": instructions,
+            "input": input,
+            "previous_response_id": previous_id,
+            "store": store,
+            "truncation": truncation,
+    }
+    if model == "gpt-5.1-chat-latest":
+        args = base_params
+    else:
+        args = {**base_params,
+                "reasoning": {"effort": reasoning_effort},
+                "text": {"verbosity": verbosity}
+            }
+    return args

syntaxmatrix/history_store.py

@@ -11,7 +11,7 @@ from syntaxmatrix.project_root import detect_project_root
 
 _CLIENT_DIR =  detect_project_root()
 # ——— Anonymous-user JSON fallback store ——————————————
-_fallback_dir = os.path.join(_CLIENT_DIR, "data", "smx_history")
+_fallback_dir = os.path.join(_CLIENT_DIR, "smx_history")
 os.makedirs(_fallback_dir, exist_ok=True)
 
 # Persist chats.db under dev app’s data/ directory
@@ -79,17 +79,14 @@ class SQLHistoryStore:
         payload = json.dumps(history, ensure_ascii=False)
         now = datetime.utcnow().isoformat()
         # if caller didn’t supply a title, preserve existing or default
-        if title is not None:
-            conn.execute(
-                "INSERT OR REPLACE INTO chats (user_id, chat_id, title, history, updated_at) "
-                "VALUES (?, ?, ?, ?, ?)",
-                (user_id, chat_id, title, payload, now)
-            )
-        else:
-            conn.execute(
-                "UPDATE chats SET history = ?, updated_at = ? WHERE user_id = ? AND chat_id = ?",
-                (payload, now, user_id, chat_id)
-            )
+        if title is None:
+            cur = conn.execute("SELECT title FROM chats WHERE user_id=? AND chat_id=?", (user_id, chat_id))
+            row = cur.fetchone()
+            title = row[0] if row else "Current"
+        conn.execute(
+            "INSERT OR REPLACE INTO chats (user_id, chat_id, title, history, updated_at) VALUES (?, ?, ?, ?, ?)",
+            (user_id, chat_id, title, payload, now)
+        )
         conn.commit()
         conn.close()
     
@@ -173,20 +170,20 @@ class PersistentHistoryStore:
             os.remove(file_path)
 
 
-@atexit.register
-def _clear_anonymous_history_on_exit() -> None:
-    """
-    On clean shutdown, delete all JSON chat files for anonymous users
-    under data/smx_history/, leaving chats.db untouched.
-    """
-    history_dir = Path(_fallback_dir)
-    if not history_dir.is_dir():
-        return
-
-    for file_path in history_dir.glob("*.json"):
-        try:
-            file_path.unlink()
-        except Exception as e:
-            logging.warning(
-                f"syntaxmatrix: failed to delete anonymous history file {file_path}: {e}"
-            )
+    @atexit.register
+    def _clear_anonymous_history_on_exit() -> None:
+        """
+        On clean shutdown, delete all JSON chat files for anonymous users
+        under data/smx_history/, leaving chats.db untouched.
+        """
+        history_dir = Path(_fallback_dir)
+        if not history_dir.is_dir():
+            return
+
+        for file_path in history_dir.glob("*.json"):
+            try:
+                file_path.unlink()
+            except Exception as e:
+                logging.warning(
+                    f"syntaxmatrix: failed to delete anonymous history file {file_path}: {e}"
+                )

syntaxmatrix/kernel_manager.py

@@ -2,12 +2,15 @@
 
 import jupyter_client
 import nest_asyncio
-import uuid
-import time
-import re    
+import io, contextlib
+import time   
 from functools import wraps
 import inspect, pandas as _pd
-
+from functools import wraps
+import inspect, pandas as _pd
+import io, contextlib
+import html as _html
+import re as _re
 
 nest_asyncio.apply()
 
@@ -42,11 +45,13 @@ class SyntaxMatrixKernelManager:
         for sid in list(cls._kernels):
             cls.shutdown_kernel(sid)
 
-nest_asyncio.apply()
 
 _df_cache = None
 
-def execute_code_in_kernel(kc, code, timeout=8):
+def execute_code_in_kernel(kc, code, timeout=120):
+
+    _local_stdout = ""
+    _local_stderr = ""
 
     global _df_cache
     exec_namespace = {}
@@ -134,7 +139,13 @@ def execute_code_in_kernel(kc, code, timeout=8):
         exec_namespace["df"] = _df_cache
     
     try:
-        exec(code, exec_namespace, exec_namespace)
+        # 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:
@@ -152,7 +163,7 @@ def execute_code_in_kernel(kc, code, timeout=8):
     except Exception:
         pass
 
-    # cache df for next call
+   # cache df for next call
     if "df" in exec_namespace:
         _df_cache = exec_namespace["df"]
 
@@ -171,34 +182,102 @@ def execute_code_in_kernel(kc, code, timeout=8):
     start_time = time.time()
 
     while True:
+        # Block until a message is available; if `timeout` is None this will block.
         try:
             msg = kc.get_iopub_msg(timeout=timeout)
         except Exception:
-            break                              # timeout reached
+            break   # only trips if a numeric timeout was provided                             # timeout reached
 
         if msg["parent_header"].get("msg_id") != msg_id:
             continue
 
         mtype, content = msg["msg_type"], msg["content"]
+        # Stop cleanly when the kernel reports it is idle (execution finished)        
+        if mtype == 'status' and content.get('execution_state') == 'idle':
+            break
+
+        # if mtype == "stream":
+        #     output_blocks.append(f"<pre>{content['text']}</pre>")
 
         if mtype == "stream":
-            output_blocks.append(f"<pre>{content['text']}</pre>")
+            raw = content.get("text", "")
+            # Remove noisy reprs from printed HTML/Markdown display objects
+            lines = [
+                ln for ln in raw.splitlines()
+                if ("IPython.core.display.HTML object" not in ln
+                    and "IPython.core.display.Markdown object" not in ln)
+            ]
+            txt = "\n".join(lines).strip()
+            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["data"]
+            data = content.get("data", {})
             if "text/html" in data:
-                output_blocks.append(data["text/html"])
+                 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%;'/>"
-                )
+                 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>")
+                 # Clean up plain-text reprs like "<IPython.core.display.HTML object>"
+                txt = data.get("text/plain", "") or ""
+                if ("IPython.core.display.HTML object" in txt
+                    or "IPython.core.display.Markdown object" in txt):
+                    # skip useless reprs entirely
+                    continue
+                output_blocks.append(f"<pre>{_html.escape(txt)}</pre>")
 
         elif mtype == "error":
             # 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()
+        return text
+
+    _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
+            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)
+    output_blocks = _cleaned_blocks
 
     return output_blocks, errors

syntaxmatrix/llm_store.py

@@ -12,7 +12,7 @@ from syntaxmatrix.project_root import detect_project_root
 #   Ensures a stable encryption key, no env var needed.
 # ------------------------------------------------------------------
 _CLIENT_DIR = detect_project_root()
-KEY_PATH = os.path.join(_CLIENT_DIR, "data", "fernet.key")
+KEY_PATH = os.path.join(_CLIENT_DIR, "fernet.key")
 if os.path.exists(KEY_PATH):
     __FERNET = Fernet(open(KEY_PATH, "rb").read())
 else:

syntaxmatrix/plottings.py

@@ -14,6 +14,12 @@ warnings.filterwarnings(
     message="FigureCanvasAgg is non-interactive"
 )
 
+def describe_matplotlib():
+    pass
+
+def describe_plotly():
+    pass
+
 # ── Matplotlib Integration (static PNGs) ────────────────────────────────
 
 def figure(*args, **kwargs):

syntaxmatrix/profiles.py

@@ -1,18 +1,74 @@
 # syntaxmatrix/profiles.py
+from openai import OpenAI
+from google import genai
+import anthropic
 
 from syntaxmatrix.llm_store import list_profiles, load_profile
 
 # Preload once at import-time
 _profiles: dict[str, dict] = {}
-for entry in list_profiles():
-    prof = load_profile(entry["name"])
-    if prof:
-        _profiles[entry["purpose"]] = prof
 
+def _refresh_profiles() -> None:
+    _profiles.clear()
+    for p in list_profiles():
+        prof = load_profile(p["name"])
+        if prof:
+            _profiles[prof["purpose"]] = prof
+
+def refresh_profiles_cache() -> None:
+    _refresh_profiles()
+            
 def get_profile(purpose: str) -> dict:
+    prof = _profiles.get(purpose)
+    if prof:
+        return prof
+    _refresh_profiles()
+    return _profiles.get(purpose)
+
+def get_profiles():
+    return list_profiles()
+
+def get_client(profile):
+    
+    provider = profile["provider"].lower()
+    api_key = profile["api_key"]
+
+    #1 - Google - gemini series
+    if provider == "google":    
+        return  genai.Client(api_key=api_key)
+    
+    #2 OpenAI gpt-5 series
+    if provider == "openai":    
+        return OpenAI(api_key=api_key)
+    
+    #3 - xAI - grok series
+    if provider == "xai":   
+        return OpenAI(api_key=api_key, base_url="https://api.x.ai/v1")
+    
+    #4 - DeepSeek chat model
+    if provider == "deepseek":  
+        return OpenAI(api_key=api_key, base_url="https://api.deepseek.com")
+    
+    #5 - Moonshot chat model
+    if provider == "moonshot":  #5
+        return OpenAI(api_key=api_key, base_url="https://api.moonshot.ai/v1")
+    
+    #6 - Alibaba qwen series
+    if provider == "alibaba":   #6
+        return OpenAI(api_key=api_key, base_url="https://dashscope-intl.aliyuncs.com/compatible-mode/v1",)
+    
+    #7 - Anthropic claude series
+    if provider == "anthropic": #7
+        return anthropic.Anthropic(api_key=api_key)
+    
+def drop_cached_profile_by_name(profile_name: str) -> bool:
     """
-    Return the full profile dict for that purpose (e.g. "chat", "embedding").
-    Returns None if no such profile exists.
+    Remove the cached profile with this name (if present) from the in-memory map.
+    Returns True if something was removed.
     """
-    prof = _profiles.get(purpose, None)
-    return prof
+    removed = False
+    for purpose, prof in list(_profiles.items()):
+        if isinstance(prof, dict) and prof.get("name") == profile_name:
+            _profiles.pop(purpose, None)
+            removed = True
+    return removed

syntaxmatrix/project_root.py

@@ -1,61 +1,73 @@
-# syntaxmatrix/project_root.py
-
+# syntaxmatrix/project_root.py 
 import os
 import inspect
 from pathlib import Path
 import syntaxmatrix
 
-
 def scandir() -> Path:
-    """
-    Find the first stack frame outside of the syntaxmatrix package
-    whose filename is a real .py file on disk, and return its parent dir.
-    """
     framework_dir = Path(syntaxmatrix.__file__).resolve().parent
-
     for frame in inspect.stack():
         fname = frame.filename
-
-        # 1) skip internal frames (<frozen ...>) or empty names
-        if not fname or fname.startswith("<"):
+        if not fname or not isinstance(fname, str):
             continue
-
-        candidate = Path(fname)
-
-        # 2) skip non-.py or non-existent paths
-        if candidate.suffix != ".py" or not candidate.exists():
-            continue
-
+        p = Path(fname)
         try:
-            candidate = candidate.resolve()
-        except (OSError, RuntimeError):
-            # if for some reason resolve() fails, skip it
+            if p.is_file() and framework_dir not in p.parents:
+                return p.parent
+        except Exception:
             continue
+    return framework_dir
 
-        # 3) skip anything inside the framework itself
-        if framework_dir in candidate.parents:
-            continue
-
-        # FOUND: a user file (e.g. app.py, manage.py, etc.)
-        return candidate.parent
-
-    # fallback: whatever cwd() is
-    return Path(os.getcwd()).resolve()
-
+def _writable(p: Path) -> bool:
+    try:
+        p.mkdir(parents=True, exist_ok=True)
+        test = p / ".smx_write_test"
+        with open(test, "w", encoding="utf-8") as f:
+            f.write("ok")
+        test.unlink(missing_ok=True)
+        return True
+    except Exception:
+        return False
 
 def detect_project_root() -> Path:
     """
-    Returns the consumer project's syntaxmatrixdir folder, creating it if necessary.
-    All framework data & uploads live here.
+    Return the consumer project's 'syntaxmatrixdir' folder, creating it if necessary.
+    Resolution order:
+      1) SMX_CLIENT_DIR (if set and writable)
+      2) ./syntaxmatrixdir under current working dir (if writable)
+      3) GCS Fuse standard mounts (if present & writable)
+      4) /tmp/syntaxmatrixdir (always writable on Cloud Run)
+      5) Fallback near the first non-framework caller (if writable)
     """
-    # 1) First check the CWD (where your app:app is running)
+
+    # 1) Explicit override (keeps local stable; handy in Cloud Run)
+    env = os.environ.get("SMX_CLIENT_DIR")
+    if env:
+        p = Path(env)
+        if _writable(p):
+            return p
+
+    # 2) CWD-based
     cwd = Path.cwd()
-    candidate = cwd / "syntaxmatrixdir"
-    if candidate.exists():
-        return candidate
-
-    # 2) Otherwise fall back to the old logic (e.g. inside site-packages)
-    proj_root = scandir()
-    fw_root = proj_root / "syntaxmatrixdir"
-    fw_root.mkdir(exist_ok=True)
-    return fw_root
+    p = cwd / "syntaxmatrixdir"
+    if _writable(p):
+        return p
+
+    # 3) Common GCS Fuse mount points (Gen2)
+    for candidate in [Path("/mnt/gcs/syntaxmatrixdir"),
+                      Path("/mnt/disks/gcs/syntaxmatrixdir")]:
+        if _writable(candidate):
+            return candidate
+
+    # 4) Cloud Run safe default
+    tmp = Path("/tmp/syntaxmatrixdir")
+    if _writable(tmp):
+        return tmp
+
+    # 5) Fallback alongside caller
+    fallback = scandir() / "syntaxmatrixdir"
+    if _writable(fallback):
+        return fallback
+
+    # Last resort: return /tmp anyway (avoids import-time crashes)
+    return tmp