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

syntaxmatrix/core.py

@@ -16,7 +16,6 @@ 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 SMXAI_CHAT_ID, SMXAI_CHAT_INSTRUCTIONS, SMXAI_WEBSITE_DESCRIPTION
 from typing import List, Generator
 from .auth import init_auth_db
 from . import profiles as _prof
@@ -28,20 +27,23 @@ from html import unescape
 from .plottings import render_plotly, pyplot, describe_plotly, describe_matplotlib
 from threading import RLock
 from syntaxmatrix.settings.model_map import GPT_MODELS_LATEST
-
+from syntaxmatrix.settings.prompts import(
+    SMXAI_CHAT_IDENTITY, 
+    SMXAI_CHAT_INSTRUCTIONS, 
+    SMXAI_WEBSITE_DESCRIPTION,
+)
+from syntaxmatrix.settings.client_items import read_client_file, getenv_api_key
 
 # ──────── framework‐local storage paths ────────
 # this ensures the key & data always live under the package dir,
-# regardless of where the developer `cd` into before launching.
 _CLIENT_DIR = detect_project_root()
 _HISTORY_DIR   = os.path.join(_CLIENT_DIR, "smx_history")
 os.makedirs(_HISTORY_DIR, exist_ok=True)
 
 _SECRET_PATH = os.path.join(_CLIENT_DIR, ".smx_secret_key")
 
-_CLIENT_DOTENV_PATH = os.path.join(str(_CLIENT_DIR.parent), ".env")
-if os.path.isfile(_CLIENT_DOTENV_PATH):
-    load_dotenv(_CLIENT_DOTENV_PATH, override=True)
+# OPENAI_API_KEY = getenv_api_key(_CLIENT_DIR, "OPENAI_API_KEY"))
+# dotenv_content = read_client_file(_CLIENT_DIR, ".env")
 
 _ICONS_PATH = os.path.join(_CLIENT_DIR, "static", "icons")
 os.makedirs(_ICONS_PATH, exist_ok=True)
@@ -53,9 +55,9 @@ class SyntaxMUI:
            host="127.0.0.1", 
             port="5080", 
             user_icon="👩🏿‍🦲",
-            bot_icon="<img src='/static/icons/favicon.png' width=20' alt='bot'/>",
+            bot_icon="<img src='/static/icons/bot-icon.png' width=20' alt='bot'/>",
             favicon="/static/icons/favicon.png",      
-            site_logo="<img src='/static/icons/logo.png' width='30' alt='logo'/>",           
+            site_logo="<img src='/static/icons/logo.png' width='45' alt='logo'/>",           
             site_title="SyntaxMatrix", 
             project_name="smxAI", 
             theme_name="light",
@@ -76,7 +78,7 @@ class SyntaxMUI:
         self.theme_toggle_enabled = False
         self.user_files_enabled = False
         self.registration_enabled = False
-        self.smxai_identity = SMXAI_CHAT_ID
+        self.smxai_identity = SMXAI_CHAT_IDENTITY
         self.smxai_instructions = SMXAI_CHAT_INSTRUCTIONS    
         self.website_description = SMXAI_WEBSITE_DESCRIPTION
         self._eda_output = {}      # {chat_id: html}
@@ -97,11 +99,15 @@ class SyntaxMUI:
         self._last_llm_usage = None 
         routes.setup_routes(self)
 
-        self._admin_profile = {}
-        self._chat_profile = {}
-        self._coding_profile = {}
-        self._classification_profile = {}
-        self._summarization_profile = {}
+        # LLM Profiles
+        self.admin_profile = {}
+        self.chat_profile = {}
+        self.classifier_profile = {}
+        self.summarizer_profile = {}
+        self.coder_profile = {}
+        self.imagetexter_profile = {}
+        self.textimager_profile = {}
+        self.imagereditor_profile = {}
             
         self._gpt_models_latest_prev_resp_ids = {}
         self.is_streaming = False
@@ -333,6 +339,7 @@ class SyntaxMUI:
     def set_favicon(self, icon):
         self.favicon = icon
 
+
     def set_site_logo(self, logo):
         self.site_logo = logo
 
@@ -596,18 +603,17 @@ class SyntaxMUI:
 
 
     def classify_query_intent(self, query: str) -> str:
-        from syntaxmatrix.gpt_models_latest import extract_output_text as _out, set_args 
    
-        if not self._classification_profile:
-            classification_profile = _prof.get_profile('classification') or _prof.get_profile('admin')
-            if not classification_profile:
-                return {"Error": "Set a profile for Classification"}
-            self._classification_profile = classification_profile
-            self._classification_profile['client'] = _prof.get_client(classification_profile)
+        if not self.classifier_profile:
+            classifier_profile = _prof.get_profile('classifier') or _prof.get_profile('chat') or _prof.get_profile('summarizer') or _prof.get_profile('admin')
+            if not classifier_profile:
+                return "Error: Set a profile for Classification"
+            self.classifier_profile = classifier_profile
+            self.classifier_profile['client'] = _prof.get_client(classifier_profile)
 
-        _client = self._classification_profile['client']
-        _provider = self._classification_profile['provider']
-        _model = self._classification_profile['model']
+        _client = self.classifier_profile['client']
+        _provider = self.classifier_profile['provider']
+        _model = self.classifier_profile['model']
 
         # New instruction format with hybrid option
         _intent_profile = "You are an intent classifier. Respond ONLY with the intent name."
@@ -701,35 +707,36 @@ class SyntaxMUI:
 
     def generate_contextual_title(self, chat_history):
         
-        if not self._summarization_profile:
-            summarization_profile = _prof.get_profile('summarization') or _prof.get_profile('chat') or _prof.get_profile('admin') 
-            if not summarization_profile:
-                return {"Error": "Chat profile not set yet."}
+        if not self.summarizer_profile:
+            summarizer_profile = _prof.get_profile('summarizer') or _prof.get_profile('classifier') or _prof.get_profile('chat') or _prof.get_profile('admin') 
+            if not summarizer_profile:
+                return "<code style='color:red;'>Error: No Agent setup yet.</code>"
             
-            self._summarization_profile = summarization_profile
-            self._summarization_profile['client'] = _prof.get_client(summarization_profile)
+            self.summarizer_profile = summarizer_profile
+            self.summarizer_profile['client'] = _prof.get_client(summarizer_profile)
 
         conversation = "\n".join([f"{role}: {msg}" for role, msg in chat_history])
         _title_profile = "You are a title generator that creates concise and relevant titles for the given conversations."
+
         _instructions = f"""
             Generate a contextual title (5 short words max) from the given Conversation History 
             The title should be concise - with no preamble, relevant, and capture the essence of this Conversation: \n{conversation}.\n\n
             return only the title.
         """
         
-        _client = self._summarization_profile['client']
-        _provider = self._summarization_profile['provider']
-        _model = self._summarization_profile['model']
+        _client = self.summarizer_profile['client']
+        _provider = self.summarizer_profile['provider']
+        _model = self.summarizer_profile['model']
 
         def google_generated_title():
             try:
                 response = _client.models.generate_content(
                     model=_model,
-                    contents=f"{_title_profile}\n{_instructions}"
+                    contents=f"{_title_profile}\n\n{_instructions}"
                 )
                 return response.text.strip()
             except Exception as e:
-                return f"Summary agent error!"
+                return f"Google Summary agent error!"
 
         def gpt_models_latest_generated_title():
             try:                 
@@ -744,7 +751,7 @@ class SyntaxMUI:
                 resp = _client.responses.create(**args)
                 return _out(resp).strip()
             except Exception as e:
-                return f"Summary agent error!"
+                return f"OpenAI 5s Summary agent error!"
         
         def anthropic_generated_title():       
             try:
@@ -757,7 +764,7 @@ class SyntaxMUI:
                 )
                 return response.content[0].text.strip()  
             except Exception as e:
-                return f"Summary agent error!"
+                return f"Anthropic Summary agent error!"
             
         def openai_sdk_generated_title():     
             prompt = [
@@ -771,10 +778,14 @@ class SyntaxMUI:
                     temperature=0.3,
                     max_tokens=50
                 ) 
-                title = response.choices[0].message.content.strip().lower()
-                return title if title else ""
+                print("\nRESPONSE:\n", response)
+
+                title = response.choices[0].message.content
+
+                print("\nTITLE:\n", title)
+                return title 
             except Exception as e:
-               return f"Summary agent error!"
+               return f"SDK Summary agent error!"
 
         if _provider == "google":
             title = google_generated_title()
@@ -796,18 +807,18 @@ class SyntaxMUI:
 
     def process_query_stream(self, query: str, context: str, history: list, stream=True) -> Generator[str, None, None]:
        
-        if not self._chat_profile:
+        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 None
-            self._chat_profile = chat_profile
-            self._chat_profile['client'] = _prof.get_client(chat_profile)
+            self.chat_profile = chat_profile
+            self.chat_profile['client'] = _prof.get_client(chat_profile)
 
-        _provider = self._chat_profile['provider']
-        _client = self._chat_profile['client']
-        _model = self._chat_profile['model']
+        _provider = self.chat_profile['provider']
+        _client = self.chat_profile['client']
+        _model = self.chat_profile['model']
 
         _contents = f"""
             {self.smxai_instructions}\n\n 
@@ -881,18 +892,18 @@ class SyntaxMUI:
     
     def process_query(self, query, context, history, stream=False):
 
-        if not self._chat_profile:
+        if not self.chat_profile:
             chat_profile = _prof.get_profile("chat") or _prof.get_profile("admin")
             if not chat_profile:
                 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
                  
-            self._chat_profile = chat_profile
-            self._chat_profile['client'] = _prof.get_client(chat_profile) 
-        _provider = self._chat_profile['provider']
-        _client = self._chat_profile['client']
-        _model = self._chat_profile['model']
+            self.chat_profile = chat_profile
+            self.chat_profile['client'] = _prof.get_client(chat_profile) 
+        _provider = self.chat_profile['provider']
+        _client = self.chat_profile['client']
+        _model = self.chat_profile['model']
         _contents = f"""
                     {self.smxai_instructions}\n\n
                     Question: {query}\n
@@ -1031,7 +1042,7 @@ class SyntaxMUI:
             return code
         _prompt = f"```python\n{code}\n```"
                   
-        repair_profile = _prof.get_profile("vision2text") or _prof.get_profile("admin")
+        repair_profile = self.coder_profile 
         if not repair_profile:
             return (
                 '<div class="smx-alert smx-alert-warn">'
@@ -1141,22 +1152,27 @@ class SyntaxMUI:
         tasks = [str(t).strip().lower() for t in tasks if str(t).strip()]
 
         ai_profile = """
-        - You are a Python expert specializing in Data Science (DS) and Machine Learning (ML).
-        - Your task is to generate a single, complete, production-quality, executable Python script for a Jupyter-like Python kernel, based on the given instructions. 
+        - You are a Python expert specialising in Data Science (DS) and Machine Learning (ML).
+        - Your task is to generate a single, complete, production-ready Python script that can be executed in a Jupyter-like Python kernel, based on the given instructions.
         - The dataset is already loaded as a pandas DataFrame named `df` (no file I/O or file uploads).
-        - Make a copy of `df` and name it `df_copy`. 
-        - Make sure `df_copy` is preprocessed and cleaned, and name it `df_cleaned`, if not already done so. 
+        - Make a copy of `df` and name it `df_copy`.
+        - Make sure `df_copy` is preprocessed and cleaned, and name it `df_cleaned`, if not already done so.
         - Work only with `df_cleaned` to perform the ML tasks described in the given context.
-        - Select your features and targets, from `df_cleaned`, with care and name it `required_cols`
-        - Create your 'df_filtered by doing: df_filtered = df_cleaned[required_cols].
-        - Use the {TEMPLATE_CATALOGUE} below to educate yourself on which visualizations you will implement in the code, and ensure the implementations are in the code you generate.
-        - The final output MUST BE the complete, executable Python code only, enclosed in a single markdown code block (```python ... ```), and MUST BE able to fulfill the user's request: {tasks}.
+
+        - Always treat modelling as features `X` and target `y`:
+            * Choose ONE target column in `df_cleaned` (the value to be predicted) and refer to it as `target_col` or `y`.
+            * Build the feature matrix `X` from `df_cleaned` WITHOUT including the target column or any direct transformation of it.
+            * Examples of forbidden feature leakage: if predicting `sellingprice`, do NOT include `sellingprice`, `log_sellingprice`, `margin = sellingprice - mmr`, or any other direct function of `sellingprice` in `X`.
+            * You may create target-derived columns (margins, flags, percentage differences) for descriptive tables or plots, but NEVER use them as model inputs.
+
+        - When you need a modelling frame, define `required_cols = [target_col] + feature_cols` where `feature_cols` excludes the target and its transforms, and then create `df_filtered = df_cleaned[required_cols]`.
+
+        - Use the {TEMPLATE_CATALOGUE} below to educate yourself about available helper functions and reference code, and ensure the implementations are in the code you generate.
+        - The final output MUST BE the complete, executable Python code for the requested analysis, wrapped in a single fenced Python code block (```python ... ```), and MUST BE able to fulfil the user's request: {tasks}.
         - Do not include any explanatory text or markdown outside the code block.
         """
 
         TEMPLATE_CATALOGUE = """
-        ### Available SyntaxMatrix templates (use these instead of inventing new helpers)
-
         Visualisation templates:
         - viz_pie(df, category_col=None, top_k=8): pie/donut shares within a category.
         - viz_stacked_bar(df, x=None, hue=None, normalise=True): composition across groups.
@@ -1316,9 +1332,9 @@ class SyntaxMUI:
             - And ends with at least 3 visible output (`show(...)` and/or `plt.show()`).
         """)
 
-        if not self._coding_profile:
-            coding_profile = _prof.get_profile("coding")  # or _prof.get_profile("admin")
-            if not coding_profile:
+        if not self.coder_profile:
+            _coder_profile = _prof.get_profile("coder")  
+            if not _coder_profile:
                 return (
                     '<div class="smx-alert smx-alert-warn">'
                         'No LLM profile configured for <code>coding</code> <br>'
@@ -1326,11 +1342,11 @@ class SyntaxMUI:
                     '</div>'
                 )
 
-            self._coding_profile = coding_profile
-            self._coding_profile['client'] = _prof.get_client(coding_profile)
+            self.coder_profile = _coder_profile
+            self.coder_profile['client'] = _prof.get_client(_coder_profile)
 
         # code = mlearning_agent(instructions, ai_profile, self._coding_profile)
-        code, usage = mlearning_agent(instructions, ai_profile, self._coding_profile)
+        code, usage = mlearning_agent(instructions, ai_profile, self.coder_profile)
         self._last_llm_usage = usage
 
         if code:
@@ -1378,7 +1394,22 @@ class SyntaxMUI:
             return code.strip()
 
         return "Error: AI code generation failed."
+    
+
+    def get_image_generator_profile(self):
+        if not self._fullvision_profile:
+            fullvision_profile = _prof.get_profile("fullvision")
+            if not fullvision_profile:
+                return (
+                    '<div class="smx-alert smx-alert-warn">'
+                        'No Full Vision profile configured for <code>coding</code> <br>'
+                        'Please, add it inside the admin panel or contact your Administrator.'
+                    '</div>'
+                )          
+            self._fullvision_profile = fullvision_profile
+            self._fullvision_profile['client'] = _prof.get_client(fullvision_profile) 
 
+        return self._fullvision_profile
 
     def sanitize_rough_to_markdown_task(self, rough: str) -> str:
         """
@@ -1414,7 +1445,13 @@ class SyntaxMUI:
 
         # Drop optional <rough> wrapper
         return out.replace("<rough>", "").replace("</rough>", "").strip()
-
+        
+    def current_profile(self, agency):
+        current_profile = _prof.get_profile(agency) or _prof.get_profile('admin') 
+        if not current_profile:
+            return "Error: Configure the valid LLM profile."
+        current_profile['client'] = _prof.get_client(current_profile)
+        return current_profile
 
     def run(self):
         url = f"http://{self.host}:{self.port}/"