syntaxmatrix 2.2.3__tar.gz → 2.2.5__tar.gz

{syntaxmatrix-2.2.3 → syntaxmatrix-2.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: syntaxmatrix
-Version: 2.2.3
+Version: 2.2.5
 Summary: SyntaxMUI: A customizable framework for Python AI Assistant Projects.
 Home-page: https://github.com/bobganti/syntaxmatrix_demo
 Author: Bob Nti

{syntaxmatrix-2.2.3 → syntaxmatrix-2.2.5}/SyntaxMatrix.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: syntaxmatrix
-Version: 2.2.3
+Version: 2.2.5
 Summary: SyntaxMUI: A customizable framework for Python AI Assistant Projects.
 Home-page: https://github.com/bobganti/syntaxmatrix_demo
 Author: Bob Nti

{syntaxmatrix-2.2.3 → syntaxmatrix-2.2.5}/SyntaxMatrix.egg-info/SOURCES.txt

@@ -59,7 +59,7 @@ syntaxmatrix/static/js/sidebar.js
 syntaxmatrix/static/js/widgets.js
 syntaxmatrix/templates/code_cell.html
 syntaxmatrix/templates/dashboard.html
-syntaxmatrix/templates/docs_page_embed.html
+syntaxmatrix/templates/docs.html
 syntaxmatrix/templates/error.html
 syntaxmatrix/templates/login.html
 syntaxmatrix/templates/register.html

{syntaxmatrix-2.2.3 → syntaxmatrix-2.2.5}/setup.py

@@ -8,7 +8,7 @@ with open(os.path.join(this_directory, "README.md"), encoding="utf-8") as f:
 
 setup(
     name="syntaxmatrix",
-    version="2.2.3",
+    version="2.2.5",
     author="Bob Nti",
     author_email="bob.nti@syntaxmatrix.com",
     description="SyntaxMUI: A customizable framework for Python AI Assistant Projects.",

{syntaxmatrix-2.2.3 → syntaxmatrix-2.2.5}/syntaxmatrix/commentary.py

@@ -169,11 +169,11 @@ Question:
 Visible context strings (titles, axes, legends, headers):
 {ctx}
 
-Write a concise conclusion (~140-200 words) with:
-- Headline (one sentence answering the question).
-- Evidence (4-5 bullets referencing panels/axes/legend groups seen in the figures).
-- Limitations (1-2 bullets; avoid quoting numbers unless present in context).
-- Next step (1 bullet).
+Write a concise conclusion (~200-260 words) with:
+- <strong>Headline</strong> (one sentence answering the question).
+- <strong>Evidence</strong> (6-8 bullets referencing panels/axes/legend groups seen in the figures and explaining the plots/tables  vis-a-vis the query). Explain all the oupupt comprehensively in details.
+- <strong>Limitations</strong> (1 bullets; avoid quoting numbers unless present in context).
+- <strong>Next step</strong> (1 bullet).
 """
 
 def phrase_commentary_vision(context: Dict[str, Any], images_b64: List[str]) -> str:
@@ -188,18 +188,18 @@ def phrase_commentary_vision(context: Dict[str, Any], images_b64: List[str]) ->
         ctx=json.dumps(visible, ensure_ascii=False, indent=2)
     )
 
-    prof = _prof.get_profile("vision2text") or _prof.get_profile("admin")
+    prof = _prof.get_profile("image2text") or _prof.get_profile("admin") 
     if not prof:    
         return (
             "<div class='smx-alert smx-alert-warn'>"
-                "No LLM profile configured for 'Vision2Text'. Please contact your Administrator."
+                "No LLM profile is configured for Image2Text. Please, do that in the Admin panel or contact your Administrator."
             "</div>"
         )
     _client = _prof.get_client(prof)
     _provider = (prof.get("provider") or "").lower()
     _model = prof.get("model") or ""
 
-    # Google GenAI (Gemini) — multimodal
+    # Google
     if _provider == "google":
         try:
             parts = [types.Part.from_text(text=user)]
@@ -216,8 +216,9 @@ def phrase_commentary_vision(context: Dict[str, Any], images_b64: List[str]) ->
             if txt.strip():
                 return txt.strip()
         except Exception:
-            pass  # fall through to text-only
+             pass  # Fall through to the chat.completions fallback implemented below.
     
+    # Openai
     elif _provider == "openai" and _model in GPT_MODELS_LATEST:
         # Use the Responses API with multimodal input (text + up to 4 images)
         try:
@@ -240,10 +241,8 @@ def phrase_commentary_vision(context: Dict[str, Any], images_b64: List[str]) ->
             if txt.strip():
                 return txt.strip()
         except Exception:
-            # If the Responses path fails for any reason, fall through to the
-            # chat.completions fallback implemented below.
-            pass
-    
+            pass  # Fall through to the chat.completions fallback implemented below.
+                
     # Anthropic
     elif _provider == "anthropic":
         try:
@@ -261,8 +260,9 @@ def phrase_commentary_vision(context: Dict[str, Any], images_b64: List[str]) ->
             )
             return response.content[0].text.strip()   
         except Exception:
-            pass  # fall through
-
+             pass  # Fall through to the chat.completions fallback implemented below.
+    
+    # OpenAI SDK
     else: # provider in {"openai","xai","deepseek","moonshotai","alibaba"}:
         try:
             parts = [{"type":"text","text": user}]
@@ -271,7 +271,7 @@ def phrase_commentary_vision(context: Dict[str, Any], images_b64: List[str]) ->
                     parts.append({"type":"image_url","image_url":{"url": f"data:image/png;base64,{b64}"}})
             resp = _client.chat.completions.create(
                 model=_model,
-                temperature=0.2,
+                temperature=0.3,
                 messages=[
                     {"role":"system","content":_SYSTEM_VISION},
                     {"role":"user","content":parts},
@@ -280,29 +280,10 @@ def phrase_commentary_vision(context: Dict[str, Any], images_b64: List[str]) ->
             )
             return (resp.choices[0].message.content or "").strip()
         except Exception:
-            pass  # fall through
+             pass  # Fall through to the chat.completions fallback implemented below.
 
     # Text-only fallback via Responses API
-    try:
-        args = set_args(model=_model, instructions=_SYSTEM_VISION,
-                        input=user, previous_id=None, store=False,
-                        reasoning_effort="minimal", verbosity="low")
-        resp = _client.responses.create(**args)
-        return _out(resp)
-    except Exception:
-        # Classic chat fallback
-        try:
-            resp = _client.chat.completions.create(
-                model=_model,
-                temperature=0.2,
-                messages=[{"role":"system","content":_SYSTEM_VISION},
-                          {"role":"user","content":user}],
-                max_tokens=600,
-            )
-            return (resp.choices[0].message.content or "").strip()
-        except Exception:
-            return "Insufficient context to comment usefully."
-
+    return "Insufficient context to comment usefully."
 
 def wrap_html(card_text: str) -> str:
     return f"""

{syntaxmatrix-2.2.3 → syntaxmatrix-2.2.5}/syntaxmatrix/core.py

@@ -14,7 +14,7 @@ from .file_processor import process_admin_pdf_files
 from google.genai import types
 from .vector_db import query_embeddings
 from .vectorizer import embed_text
-from syntaxmatrix.settings.prompts import SMX_PROMPT_PROFILE, SMX_PROMPT_INSTRUCTIONS, SMX_WEBSITE_DESCRIPTION
+from syntaxmatrix.settings.prompts import SMXAI_CHAT_ID, SMXAI_CHAT_INSTRUCTIONS, SMX_WEBSITE_DESCRIPTION
 from typing import List, Generator
 from .auth import init_auth_db
 from . import profiles as _prof
@@ -69,8 +69,8 @@ class SyntaxMUI:
         self.ui_mode = ui_mode
         self.theme_toggle_enabled = False
         self.user_files_enabled = False
-        self.prompt_profile = SMX_PROMPT_PROFILE
-        self.prompt_instructions = SMX_PROMPT_INSTRUCTIONS    
+        self.ai_chat_id = SMXAI_CHAT_ID
+        self.ai_chat_instructions = SMXAI_CHAT_INSTRUCTIONS    
         self.website_description = SMX_WEBSITE_DESCRIPTION
 
         db.init_db()
@@ -443,11 +443,11 @@ class SyntaxMUI:
     #  *********** LLM CLIENT HELPERS  **********************
     # ──────────────────────────────────────────────────────────────
     def set_prompt_profile(self, profile):
-        self.prompt_profile = profile
+        self.ai_chat_id = profile
     
 
     def set_prompt_instructions(self, instructions):
-        self.prompt_instructions = instructions
+        self.ai_chat_instructions = instructions
 
 
     def set_website_description(self, desc):
@@ -733,7 +733,7 @@ class SyntaxMUI:
         _model = self._chat_profile['model']
 
         _contents = f"""
-            {self.prompt_instructions}\n\n 
+            {self.ai_chat_instructions}\n\n 
             Question: {query}\n
             Context: {context}\n\n
             History: {history}\n\n
@@ -746,7 +746,7 @@ class SyntaxMUI:
                     types.Content(
                         role="user",
                         parts=[
-                            types.Part.from_text(text=f"{self.prompt_profile}\n\n{_contents}"),
+                            types.Part.from_text(text=f"{self.ai_chat_id}\n\n{_contents}"),
                         ],
                     ),
                 ]
@@ -759,14 +759,14 @@ class SyntaxMUI:
         
             elif _provider == "openai" and _model in self.gpt_models_latest():  # GPt 5 series
                 input_prompt = (
-                    f"{self.prompt_instructions}\n\n"
+                    f"{self.ai_chat_instructions}\n\n"
                     f"Generate a response to this query:\n{query}\n"
                     f"based on this given context:\n{context}\n\n"
                     f"(Use conversation continuity if available.)"
                 )
                 sid = self.get_session_id()
                 prev_id = self._gpt_models_latest_prev_resp_ids.get(sid)
-                args = set_args(model=_model, instructions=self.prompt_profile, input=input_prompt, previous_id=prev_id, store=True)
+                args = set_args(model=_model, instructions=self.ai_chat_id, input=input_prompt, previous_id=prev_id, store=True)
                 
                 with _client.responses.stream(**args) as s:
                     for event in s:
@@ -781,7 +781,7 @@ class SyntaxMUI:
             elif _provider == "anthropic":
                 with _client.messages.stream(
                     max_tokens=1024,
-                    messages=[{"role": "user", "content":f"{self.prompt_profile}\n\n {_contents}"},],
+                    messages=[{"role": "user", "content":f"{self.ai_chat_id}\n\n {_contents}"},],
                     model=_model,
                 ) as stream:
                     for text in stream.text_stream:
@@ -790,15 +790,15 @@ class SyntaxMUI:
                     response = _client.messages.create(
                     model=_model,
                     max_tokens=1024,
-                    system=self.prompt_profile,
+                    system=self.ai_chat_id,
                     messages=[{"role": "user", "content":_contents}],
                     stream=False,
                 )
                     
             else:  # Assumes standard openai_sdk
                 openai_sdk_prompt = [
-                    {"role": "system", "content": self.prompt_profile},
-                    {"role": "user", "content": f"{self.prompt_instructions}\n\nGenerate response to this query: {query}\nbased on this context:\n{context}\nand history:\n{history}\n\nUse conversation continuity if available.)"},
+                    {"role": "system", "content": self.ai_chat_id},
+                    {"role": "user", "content": f"{self.ai_chat_instructions}\n\nGenerate response to this query: {query}\nbased on this context:\n{context}\nand history:\n{history}\n\nUse conversation continuity if available.)"},
                 ]
                 response = _client.chat.completions.create(
                     model=_model, 
@@ -818,7 +818,7 @@ class SyntaxMUI:
         if not self._chat_profile:
             chat_profile = _prof.get_profile("chat") or _prof.get_profile("admin")
             if not chat_profile:
-                yield """<p style='color:red;'>Error: Chat profile is not configured. Add a chat profile inside the admin panel or contact your administrator.</p>
+                return """<p style='color:red;'>Error: Chat profile is not configured. Add a chat profile inside the admin panel or contact your administrator.</p>
                 """
                 return
                  
@@ -826,7 +826,7 @@ class SyntaxMUI:
             self._chat_profile['client'] = _prof.get_client(chat_profile) 
         
         _contents = f"""
-                    {self.prompt_instructions}\n\n 
+                    {self.ai_chat_instructions}\n\n 
                     Question: {query}\n
                     Context: {context}\n\n
                     History: {history}\n\n
@@ -834,8 +834,8 @@ class SyntaxMUI:
                 """
         
         openai_sdk_prompt = [
-                {"role": "system", "content": self.prompt_profile},
-                {"role": "user", "content": f"""{self.prompt_instructions}\n\n
+                {"role": "system", "content": self.ai_chat_id},
+                {"role": "user", "content": f"""{self.ai_chat_instructions}\n\n
                                                 Generate response to this query: {query}\n
                                                 based on this context:\n{context}\n
                                                 and history:\n{history}\n\n
@@ -852,7 +852,7 @@ class SyntaxMUI:
             try:
                 response = _client.models.generate_content(
                     model=_model,
-                    contents=f"{self.prompt_profile}\n\n{_contents}"
+                    contents=f"{self.ai_chat_id}\n\n{_contents}"
                 )
                 answer = response.text
                 
@@ -867,7 +867,7 @@ class SyntaxMUI:
             """
             # Prepare the prompt with conversation history and context
             input = (
-                f"{self.prompt_instructions}\n\n"
+                f"{self.ai_chat_instructions}\n\n"
                 f"Generate a response to this query:\n{query}\n"
                 f"based on this given context:\n{context}\n\n"
                 f"(Use conversation continuity if available.)"
@@ -878,7 +878,7 @@ class SyntaxMUI:
             
             args = set_args(
                 model=_model,
-                instructions=self.prompt_profile,
+                instructions=self.ai_chat_id,
                 input=input,
                 previous_id=prev_id,
                 store=True,
@@ -903,7 +903,7 @@ class SyntaxMUI:
                 response = _client.messages.create(
                     model=_model,
                     max_tokens=1024,
-                    system=self.prompt_profile,
+                    system=self.ai_chat_id,
                     messages=[{"role": "user", "content":_contents}],
                     stream=False,
                 )
@@ -936,7 +936,7 @@ class SyntaxMUI:
         return openai_sdk_process_query()
 
 
-    def ai_generate_code(self, question, df):
+    def ai_generate_code(self, question, intent, df):
     
         if not self._coding_profile:            
             coding_profile = _prof.get_profile("coding") or _prof.get_profile("admin")
@@ -957,62 +957,53 @@ class SyntaxMUI:
         _model = self._coding_profile['model']
 
         context = f"Columns: {list(df.columns)}\n\nDtypes: {df.dtypes.astype(str).to_dict()}\n\n"
-        
-        Linear_regression = """
-            <Instruction for Generating Multiple Linear Regression Analysis Code>
-                You are a data science code generation assistant. Your task is to produce a complete, executable Python script that performs a multiple linear regression analysis based on a user's specific request, using a provided dataset (`df`).
-        
-            <Steps to Generate the Code>
-                <dataset loading>:
-                Assume the dataset is accessible (e.g., via an uploaded file or a provided path).
-                Use pandas (pd) to load the dataset into a DataFrame named df. The specific loading command (pd.read_csv, etc.) should match the dataset's format as implied by the user (e.g., if the user mentions diabetes_dataset.csv, use pd.read_csv('diabetes_dataset.csv')).
-                Print the first few rows (df.head()) and descriptive statistics (df.describe()) of the loaded DataFrame to verify successful loading.
-
-                <Variable Identification>:
-                    <carefully analyze the user's query to identify>:
-                    The target variable (dependent variable) to be predicted (e.g., "predict the level of the liver enzyme GGT").
-                    The specific predictor variables (independent variables) to be used in the model (e.g., "BMI, Waist_Circumference, Alcohol_Consumption, and HbA1c").
-                    Examine the column names of the loaded DataFrame (df.columns) to find the exact column names corresponding to the variables identified in the query. Ensure the column names used in the code exactly match those in the dataset.
-
-                <Data Preparation>:
-                    Select the identified predictor variables and create a feature matrix X.
-                    Select the identified target variable and create a target vector y.
-                    Handle any potential missing values if necessary (e.g., using dropna() or imputation, though for simplicity, dropping rows with missing values in relevant columns is often acceptable for initial analysis).
-                
-                <Model Creation and Training>:
-                    Import necessary modules from sklearn (train_test_split, LinearRegression, mean_squared_error, r2_score).
-                    Split the data into training and testing sets using train_test_split (e.g., 80% train, 20% test).
-                    Instantiate a LinearRegression model.
-                    Fit the model to the training data (model.fit(X_train, y_train)).
-                    Model Evaluation:
-                    Use the trained model to make predictions on the test set (y_pred = model.predict(X_test)).
-                    Calculate performance metrics like R-squared (r2_score) and Mean Squared Error (mean_squared_error) to evaluate how well the model fits the data on the test set.
-                    
-                <Result Interpretation>:
-                    Extract the model's coefficients (model.coef_) and intercept (model.intercept_).
-                    Print the intercept and a list of feature names paired with their corresponding coefficients.
-                    Calculate the absolute values of the coefficients to assess the relative importance of each predictor variable.
-                    Provide a clear interpretation:
-                    Explain what each coefficient means in the context of the problem (e.g., "A 1 unit increase in [Feature Name], holding other variables constant, is associated with a [Coefficient Value] unit change in [Target Variable Name]").
-                    Rank the predictor variables by the absolute value of their coefficients to indicate their relative contribution to the prediction.
-                    
-                <Output Formatting>:
-                    Structure the printed output clearly using section headers (e.g., "=== Multiple Linear Regression Results ===", "=== Interpretation ===").
-                    Ensure the final code is self-contained, uses appropriate variable names, and includes necessary import statements.
-                    Add a comment reminding the user to ensure column names match their actual dataset if they adapt the code.
-        """
-        
+        ALLOWED_COLUMNS = list(df.columns)
+
         ai_profile = f"""
-        You are a data science code generation assistant. Your task is to produce a complete, executable Python script that performs a multiple linear regression analysis based on a user's specific request, using a provided dataset (`df`).
+        You are a senior Python data scientist writing production-quality, **runnable** code for a Jupyter-like kernel. You are given a pandas DataFrame named `df`. Begin ONLY the data already in `df` (no file I/O).
         """
 
         instructions = f"""
-            Write clean, working Python code that answers the question below. 
-            DO NOT explain, just output the code only.
-            Question: {question}\n
-            Context: {context}\n\n
-            Output only the working code needed. Assume df is already defined.
-            Produce at least one visible result: (syntaxmatrix.display.show(), display(), plt.show()).
+        ### Context
+        - Schema (names → dtypes): {context}
+        - Row count: {len(df)}
+        - Task: {question}
+        - Task type: {intent}
+        - Allowed columns: {ALLOWED_COLUMNS}
+
+        ### Hard requirements
+        1) **Code only**. No markdown, no comments, no explanations.
+        2) Import everything you use explicitly. Assume: pandas≥2, numpy≥1.25, matplotlib≥3.8, seaborn≥0.13, scikit-learn≥1.4 are available.
+        3) **Avoid deprecated / removed APIs**, e.g.:
+        - pandas: do not use `.append`, `.ix`, `.as_matrix`, `DataFrame.select_dtypes(include='category')` is OK, but prefer current patterns.
+        - seaborn: do not use `distplot`, `pairplot` on very large data without sampling; prefer `histplot`, `displot`, `regplot`, or FacetGrid with `.map_dataframe`.
+        - scikit-learn: import from `sklearn.model_selection` (not `sklearn.cross_validation`); for confusion matrices use `ConfusionMatrixDisplay.from_estimator`; set `random_state=42` where relevant.
+        4) Be **defensive**:
+        - Verify required columns exist; if any are missing, raise `ValueError("Missing columns: ...")` early.
+        - Handle missing values sensibly (e.g., drop rows for simple EDA; use `ColumnTransformer` + `SimpleImputer` for modeling).
+        - For categorical features in ML, use `OneHotEncoder(handle_unknown="ignore")` inside a `Pipeline`/`ColumnTransformer` (no `LabelEncoder` on features).
+        5) Keep it **fast** (kernel timeout ~8s):
+        - For plots on large frames (>20k rows), downsample to ~1,000 rows (`df.sample(1000, random_state=42)`) unless aggregation is more appropriate.
+        - Prefer vectorized ops; avoid O(n²) Python loops.
+        6) Always **produce at least one visible result** at the end:
+        - If plotting with matplotlib/seaborn: call `plt.tight_layout(); plt.show()`.
+        - If producing a table or metrics: from `syntaxmatrix.display import show` then `show(object_or_dataframe)`.
+        7) Follow task type conventions:
+        - **EDA/Stats**: compute the requested stat, then show a relevant table (e.g., summary/crosstab) or plot.
+        - **Classification**: train/valid split (`train_test_split`), build a pipeline with scaling/encoding as needed, fit, show accuracy **and** a confusion matrix via `ConfusionMatrixDisplay.from_estimator(...); plt.show()`. Also show `classification_report` as a dataframe if short.
+        - **Regression**: train/valid split, pipeline as needed, fit, show R² and MAE; plot predicted vs actual scatter.
+        - **Correlation/Chi-square/ANOVA**: compute the statistic + p-value and show a concise result table (with `show(...)`) and, when sensible, a small plot (heatmap/bar).
+        8) Don't mutate or recreate target columns if they already exist (e.g., if asked to “predict TARGET”, use `y = df['TARGET']` as-is).
+        9) Keep variable names short and clear; prefer `num_cols` / `cat_cols` discovery by dtype.
+        10) You MUST NOT reference any column outside Allowed columns: {ALLOWED_COLUMNS}\n. 
+        11) If asked to predict/classify, choose the target by matching the task text to Allowed columns: {ALLOWED_COLUMNS}\n and never invent a new name (e.g., 'whether', 'the').
+
+        ### Output
+        Return **only runnable Python** that:
+        - Imports what it needs,
+        - Validates columns,
+        - Solves: {question},
+        - And ends with at least one visible output (`show(...)` and/or `plt.show()`).
         """
 
         def google_generate_code():
@@ -1059,7 +1050,7 @@ class SyntaxMUI:
                         {"role": "system", "content": ai_profile},
                         {"role": "user", "content": instructions},
                         ],
-                    temperature=0.0,
+                    temperature=0.3,
                     max_tokens=2048,
                 )
                 return response.choices[0].message.content

syntaxmatrix-2.2.5/syntaxmatrix/display.py

@@ -0,0 +1,54 @@
+ # -----------------------------------------------------------------
+#  Paste *inside* syntaxmatrix/display.py – only the show() body
+# -----------------------------------------------------------------
+def show(obj):
+    """
+    Render common objects so the Dashboard (or chat) always shows output.
+    """
+    import io, base64, numbers
+    from IPython.display import display, HTML
+    import pandas as pd
+    import matplotlib.figure as mpfig
+
+    # ── matplotlib Figure ─────────────────────────────────────────
+    if isinstance(obj, mpfig.Figure):
+        display(obj)                  
+        return None
+    
+    if isinstance(obj, (pd.Series, pd.DataFrame)):
+
+        html = obj.to_html(classes="smx-table", border=0)
+        wrapped_html = (
+            "<style>"
+            ".smx-table{border-collapse:collapse;font-size:0.9em;white-space:nowrap;}"
+            ".smx-table th{background:#f0f2f5;text-align:left;padding:6px 8px;border:1px solid gray;}"
+            ".smx-table td{border:1px solid #ddd;padding:6px 8px;}"
+            ".smx-table tbody tr:nth-child(even){background-color:#f9f9f9;}"
+            "</style>"
+            "<div style='overflow-x:auto; max-width:100%; margin-bottom:1rem;'>"
+            + html +
+            "</div>"
+        )
+        display(HTML(wrapped_html))
+        return None
+
+    # ── dict of scalars → pretty 2-col table ─────────────────────
+    if isinstance(obj, dict) and all(isinstance(v, numbers.Number) for v in obj.values()):
+        df_ = pd.DataFrame({"metric": list(obj.keys()),
+                            "value":  list(obj.values())})
+        display(df_)
+        return None
+
+    # ── 2-tuple of numbers (mse, r²) ─────────────────────────────
+    if (isinstance(obj, tuple) and len(obj) == 2 and
+            all(isinstance(v, numbers.Number) for v in obj)):
+        mse, r2 = obj
+        df_ = pd.DataFrame({"metric": ["Mean-squared error", "R²"],
+                            "value":  [mse, r2]})
+        display(df_)
+        return None
+
+    # ── fallback ─────────────────────────────────────────────────
+    display(HTML(f"<pre>{obj}</pre>"))
+
+    return None

{syntaxmatrix-2.2.3 → syntaxmatrix-2.2.5}/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=None):
+def execute_code_in_kernel(kc, code, timeout=90):
+
+    _local_stdout = ""
+    _local_stderr = ""
 
     global _df_cache
     exec_namespace = {}
@@ -134,7 +139,13 @@ def execute_code_in_kernel(kc, code, timeout=None):
         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=None):
     except Exception:
         pass
 
-    # cache df for next call
+   # cache df for next call
     if "df" in exec_namespace:
         _df_cache = exec_namespace["df"]
 
@@ -172,7 +183,6 @@ def execute_code_in_kernel(kc, code, timeout=None):
 
     while True:
         # Block until a message is available; if `timeout` is None this will block.
-        # (You can set a numeric timeout here if you want a failsafe.)
         try:
             msg = kc.get_iopub_msg(timeout=timeout)
         except Exception:
@@ -186,24 +196,88 @@ def execute_code_in_kernel(kc, code, timeout=None):
         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