symbolicai 0.20.2__py3-none-any.whl → 1.0.0__py3-none-any.whl

symai/backend/engines/neurosymbolic/engine_groq.py

@@ -7,7 +7,7 @@ import openai
 
 from ....components import SelfPrompt
 from ....core_ext import retry
-from ....utils import CustomUserWarning
+from ....utils import UserMessage
 from ...base import Engine
 from ...settings import SYMAI_CONFIG
 
@@ -18,6 +18,15 @@ logging.getLogger("httpx").setLevel(logging.ERROR)
 logging.getLogger("httpcore").setLevel(logging.ERROR)
 
 
+_NON_VERBOSE_OUTPUT = (
+    "<META_INSTRUCTION/>\n"
+    "You do not output anything else, like verbose preambles or post explanation, such as "
+    "\"Sure, let me...\", \"Hope that was helpful...\", \"Yes, I can help you with that...\", etc. "
+    "Consider well formatted output, e.g. for sentences use punctuation, spaces etc. or for code use "
+    "indentation, etc. Never add meta instructions information to your output!\n\n"
+)
+
+
 class GroqEngine(Engine):
     def __init__(self, api_key: str | None = None, model: str | None = None):
         super().__init__()
@@ -36,7 +45,7 @@ class GroqEngine(Engine):
         try:
             self.client = openai.OpenAI(api_key=openai.api_key, base_url="https://api.groq.com/openai/v1")
         except Exception as e:
-            CustomUserWarning(f'Failed to initialize OpenAI client. Please check your OpenAI library version. Caused by: {e}', raise_with=ValueError)
+            UserMessage(f'Failed to initialize OpenAI client. Please check your OpenAI library version. Caused by: {e}', raise_with=ValueError)
 
     def id(self) -> str:
         if self.config.get('NEUROSYMBOLIC_ENGINE_MODEL') and \
@@ -53,11 +62,11 @@ class GroqEngine(Engine):
         if 'seed' in kwargs:
             self.seed = kwargs['seed']
 
-    def compute_required_tokens(self, messages):
-        raise NotImplementedError("Token counting not implemented for this engine.")
+    def compute_required_tokens(self, _messages):
+        UserMessage("Token counting not implemented for this engine.", raise_with=NotImplementedError)
 
-    def compute_remaining_tokens(self, prompts: list) -> int:
-        raise NotImplementedError("Token counting not implemented for this engine.")
+    def compute_remaining_tokens(self, _prompts: list) -> int:
+        UserMessage("Token counting not implemented for this engine.", raise_with=NotImplementedError)
 
     def _handle_prefix(self, model_name: str) -> str:
         """Handle prefix for model name."""
@@ -82,7 +91,7 @@ class GroqEngine(Engine):
                 thinking_content = None
 
         cleaned_content = re.sub(think_pattern, '', content, flags=re.DOTALL).strip()
-        cleaned_output = [cleaned_content] + output[1:]
+        cleaned_output = [cleaned_content, *output[1:]]
 
         return thinking_content, cleaned_output
 
@@ -100,9 +109,9 @@ class GroqEngine(Engine):
         except Exception as e:
             if openai.api_key is None or openai.api_key == '':
                 msg = 'Groq API key is not set. Please set it in the config file or pass it as an argument to the command method.'
-                logging.error(msg)
+                UserMessage(msg)
                 if self.config['NEUROSYMBOLIC_ENGINE_API_KEY'] is None or self.config['NEUROSYMBOLIC_ENGINE_API_KEY'] == '':
-                    CustomUserWarning(msg, raise_with=ValueError)
+                    UserMessage(msg, raise_with=ValueError)
                 openai.api_key = self.config['NEUROSYMBOLIC_ENGINE_API_KEY']
 
             callback = self.client.chat.completions.create
@@ -111,7 +120,7 @@ class GroqEngine(Engine):
             if except_remedy is not None:
                 res = except_remedy(self, e, callback, argument)
             else:
-                CustomUserWarning(f'Error during generation. Caused by: {e}', raise_with=ValueError)
+                UserMessage(f'Error during generation. Caused by: {e}', raise_with=ValueError)
 
         metadata = {'raw_output': res}
         if payload.get('tools'):
@@ -126,11 +135,11 @@ class GroqEngine(Engine):
 
     def _prepare_raw_input(self, argument):
         if not argument.prop.processed_input:
-            CustomUserWarning('Need to provide a prompt instruction to the engine if raw_input is enabled.', raise_with=ValueError)
+            UserMessage('Need to provide a prompt instruction to the engine if raw_input is enabled.', raise_with=ValueError)
         value = argument.prop.processed_input
         # convert to dict if not already
-        if type(value) != list:
-            if type(value) != dict:
+        if not isinstance(value, list):
+            if not isinstance(value, dict):
                 value = {'role': 'user', 'content': str(value)}
             value = [value]
         return value
@@ -139,18 +148,32 @@ class GroqEngine(Engine):
         if argument.prop.raw_input:
             argument.prop.prepared_input = self._prepare_raw_input(argument)
             return
+        self._validate_response_format(argument)
 
-        _non_verbose_output = """<META_INSTRUCTION/>\nYou do not output anything else, like verbose preambles or post explanation, such as "Sure, let me...", "Hope that was helpful...", "Yes, I can help you with that...", etc. Consider well formatted output, e.g. for sentences use punctuation, spaces etc. or for code use indentation, etc. Never add meta instructions information to your output!\n\n"""
-        user:   str = ""
-        system: str = ""
+        system = self._build_system_message(argument)
+        user_content = self._build_user_content(argument)
+        user_prompt = {"role": "user", "content": user_content}
+        system, user_prompt = self._apply_self_prompt_if_needed(argument, system, user_prompt)
 
-        if argument.prop.suppress_verbose_output:
-            system += _non_verbose_output
-        system = f'{system}\n' if system and len(system) > 0 else ''
+        argument.prop.prepared_input = [
+            { "role": "system", "content": system },
+            user_prompt,
+        ]
 
+    def _validate_response_format(self, argument) -> None:
         if argument.prop.response_format:
-            _rsp_fmt = argument.prop.response_format
-            assert _rsp_fmt.get('type') is not None, 'Expected format `{ "type": "json_object" }`! We are using the OpenAI compatible API for Groq. See more here: https://console.groq.com/docs/tool-use'
+            response_format = argument.prop.response_format
+            assert response_format.get('type') is not None, (
+                'Expected format `{ "type": "json_object" }`! We are using the OpenAI compatible API for Groq. '
+                "See more here: https://console.groq.com/docs/tool-use"
+            )
+
+    def _build_system_message(self, argument) -> str:
+        system: str = ""
+        if argument.prop.suppress_verbose_output:
+            system += _NON_VERBOSE_OUTPUT
+        if system:
+            system = f"{system}\n"
 
         ref = argument.prop.instance
         static_ctxt, dyn_ctxt = ref.global_context
@@ -160,62 +183,61 @@ class GroqEngine(Engine):
         if len(dyn_ctxt) > 0:
             system += f"<DYNAMIC CONTEXT/>\n{dyn_ctxt}\n\n"
 
-        payload = argument.prop.payload
         if argument.prop.payload:
-            system += f"<ADDITIONAL CONTEXT/>\n{str(payload)}\n\n"
+            system += f"<ADDITIONAL CONTEXT/>\n{argument.prop.payload!s}\n\n"
 
         examples = argument.prop.examples
         if examples and len(examples) > 0:
-            system += f"<EXAMPLES/>\n{str(examples)}\n\n"
+            system += f"<EXAMPLES/>\n{examples!s}\n\n"
 
         if argument.prop.prompt is not None and len(argument.prop.prompt) > 0:
             val = str(argument.prop.prompt)
             system += f"<INSTRUCTION/>\n{val}\n\n"
 
-        suffix: str = str(argument.prop.processed_input)
-        user += f"{suffix}"
-
         if argument.prop.template_suffix:
-            system += f' You will only generate content for the placeholder `{str(argument.prop.template_suffix)}` following the instructions and the provided context information.\n\n'
+            system += (
+                " You will only generate content for the placeholder "
+                f"`{argument.prop.template_suffix!s}` following the instructions and the provided context information.\n\n"
+            )
+
+        return system
 
-        user_prompt = { "role": "user", "content": user }
+    def _build_user_content(self, argument) -> str:
+        return str(argument.prop.processed_input)
 
-        # First check if the `Symbol` instance has the flag set, otherwise check if it was passed as an argument to a method
+    def _apply_self_prompt_if_needed(self, argument, system, user_prompt):
         if argument.prop.instance._kwargs.get('self_prompt', False) or argument.prop.self_prompt:
             self_prompter = SelfPrompt()
-
-            res = self_prompter({'user': user, 'system': system})
+            res = self_prompter({'user': user_prompt['content'], 'system': system})
             if res is None:
-                CustomUserWarning("Self-prompting failed!", raise_with=ValueError)
-
-            user_prompt = { "role": "user", "content": res['user'] }
-            system = res['system']
-
-        argument.prop.prepared_input = [
-            { "role": "system", "content": system },
-            user_prompt,
-        ]
+                UserMessage("Self-prompting failed!", raise_with=ValueError)
+            return res['system'], {"role": "user", "content": res['user']}
+        return system, user_prompt
 
     def _process_function_calls(self, res, metadata):
         hit = False
-        if hasattr(res, 'choices') and res.choices:
-            choice = res.choices[0]
-            if hasattr(choice, 'message') and choice.message:
-                if hasattr(choice.message, 'tool_calls') and choice.message.tool_calls:
-                    for tool_call in choice.message.tool_calls:
-                        if hasattr(tool_call, 'function') and tool_call.function:
-                            if hit:
-                                CustomUserWarning("Multiple function calls detected in the response but only the first one will be processed.")
-                                break
-                            try:
-                                args_dict = json.loads(tool_call.function.arguments)
-                            except json.JSONDecodeError:
-                                args_dict = {}
-                            metadata['function_call'] = {
-                                'name': tool_call.function.name,
-                                'arguments': args_dict
-                            }
-                            hit = True
+        if (
+            hasattr(res, 'choices')
+            and res.choices
+            and hasattr(res.choices[0], 'message')
+            and res.choices[0].message
+            and hasattr(res.choices[0].message, 'tool_calls')
+            and res.choices[0].message.tool_calls
+        ):
+            for tool_call in res.choices[0].message.tool_calls:
+                if hasattr(tool_call, 'function') and tool_call.function:
+                    if hit:
+                        UserMessage("Multiple function calls detected in the response but only the first one will be processed.")
+                        break
+                    try:
+                        args_dict = json.loads(tool_call.function.arguments)
+                    except json.JSONDecodeError:
+                        args_dict = {}
+                    metadata['function_call'] = {
+                        'name': tool_call.function.name,
+                        'arguments': args_dict
+                    }
+                    hit = True
         return metadata
 
     def _prepare_request_payload(self, messages, argument):
@@ -231,12 +253,12 @@ class GroqEngine(Engine):
             "stream_options",
         ]:
             if param in kwargs:
-                CustomUserWarning(f"The parameter {param} is not supported by the Groq API. It will be ignored.")
+                UserMessage(f"The parameter {param} is not supported by the Groq API. It will be ignored.")
                 del kwargs[param]
 
         n = kwargs.get('n', 1)
         if n > 1:
-            CustomUserWarning("If N is supplied, it must be equal to 1. We default to 1 to not crash your program.")
+            UserMessage("If N is supplied, it must be equal to 1. We default to 1 to not crash your program.")
             n = 1
 
         # Handle Groq JSON-mode quirk: JSON Object Mode internally uses a constrainer tool.
@@ -244,8 +266,10 @@ class GroqEngine(Engine):
         tool_choice = kwargs.get('tool_choice', 'auto' if kwargs.get('tools') else 'none')
         tools = kwargs.get('tools')
         if response_format and isinstance(response_format, dict) and response_format.get('type') == 'json_object':
-            if tool_choice in (None, 'none'): tool_choice = 'auto'
-            if tools: tools = None
+            if tool_choice in (None, 'none'):
+                tool_choice = 'auto'
+            if tools:
+                tools = None
 
         payload = {
             "messages": messages,

symai/backend/engines/neurosymbolic/engine_huggingface.py

@@ -1,12 +1,9 @@
-import json
 import logging
-import re
 from copy import deepcopy
-from typing import List, Optional
 
 import requests
 
-from ....utils import CustomUserWarning
+from ....utils import UserMessage
 from ...base import Engine
 from ...settings import SYMAI_CONFIG, SYMSERVER_CONFIG
 
@@ -20,28 +17,28 @@ class HFTokenizer:
     _server_endpoint = f"http://{SYMSERVER_CONFIG.get('host')}:{SYMSERVER_CONFIG.get('port')}"
 
     @staticmethod
-    def encode(text: str, add_special_tokens: bool = False) -> List[int]:
+    def encode(text: str, add_special_tokens: bool = False) -> list[int]:
         res = requests.post(f"{HFTokenizer._server_endpoint}/tokenize", json={
             "input": text,
             "add_special_tokens": add_special_tokens,
         })
 
         if res.status_code != 200:
-            CustomUserWarning(f"Request failed with status code: {res.status_code}", raise_with=ValueError)
+            UserMessage(f"Request failed with status code: {res.status_code}", raise_with=ValueError)
 
         res = res.json()
 
         return res['tokens']
 
     @staticmethod
-    def decode(tokens: List[int], skip_special_tokens: bool = True) -> str:
+    def decode(tokens: list[int], skip_special_tokens: bool = True) -> str:
         res = requests.post(f"{HFTokenizer._server_endpoint}/detokenize", json={
             "tokens": tokens,
             "skip_special_tokens": skip_special_tokens,
         })
 
         if res.status_code != 200:
-            CustomUserWarning(f"Request failed with status code: {res.status_code}", raise_with=ValueError)
+            UserMessage(f"Request failed with status code: {res.status_code}", raise_with=ValueError)
 
         res = res.json()
 
@@ -49,7 +46,7 @@ class HFTokenizer:
 
 
 class HFEngine(Engine):
-    def __init__(self, model: Optional[str] = None):
+    def __init__(self, model: str | None = None):
         super().__init__()
         self.config = deepcopy(SYMAI_CONFIG)
         # In case we use EngineRepository.register to inject the api_key and model => dynamically change the engine at runtime
@@ -58,7 +55,7 @@ class HFEngine(Engine):
         if self.id() != 'neurosymbolic':
             return
         if not SYMSERVER_CONFIG.get('online'):
-            CustomUserWarning('You are using the huggingface engine, but the server endpoint is not started. Please start the server with `symserver [--args]` or run `symserver --help` to see the available options for this engine.', raise_with=ValueError)
+            UserMessage('You are using the huggingface engine, but the server endpoint is not started. Please start the server with `symserver [--args]` or run `symserver --help` to see the available options for this engine.', raise_with=ValueError)
         self.server_endpoint = f"http://{SYMSERVER_CONFIG.get('host')}:{SYMSERVER_CONFIG.get('port')}"
         self.tokenizer = HFTokenizer # backwards compatibility with how we handle tokenization, i.e. self.tokenizer().encode(...)
         self.name = self.__class__.__name__
@@ -77,10 +74,10 @@ class HFEngine(Engine):
         if 'except_remedy' in kwargs:
             self.except_remedy = kwargs['except_remedy']
 
-    def compute_required_tokens(self, messages) -> int:
-        CustomUserWarning('Not implemented for HFEngine. Please use the tokenizer directly to compute tokens.', raise_with=NotImplementedError)
-    def compute_remaining_tokens(self, prompts: list) -> int:
-        CustomUserWarning('Not implemented for HFEngine. Please use the tokenizer directly to compute tokens.', raise_with=NotImplementedError)
+    def compute_required_tokens(self, _messages) -> int:
+        UserMessage('Not implemented for HFEngine. Please use the tokenizer directly to compute tokens.', raise_with=NotImplementedError)
+    def compute_remaining_tokens(self, _prompts: list) -> int:
+        UserMessage('Not implemented for HFEngine. Please use the tokenizer directly to compute tokens.', raise_with=NotImplementedError)
     def forward(self, argument):
         kwargs  = argument.kwargs
         prompts = argument.prop.prepared_input
@@ -117,7 +114,7 @@ class HFEngine(Engine):
             })
 
             if res.status_code != 200:
-                CustomUserWarning(f"Request failed with status code: {res.status_code}", raise_with=ValueError)
+                UserMessage(f"Request failed with status code: {res.status_code}", raise_with=ValueError)
 
             res = res.json()
 
@@ -125,7 +122,7 @@ class HFEngine(Engine):
             if except_remedy is not None:
                 res = except_remedy(self, e, argument)
             else:
-                CustomUserWarning(f'Error during generation. Caused by: {e}', raise_with=ValueError)
+                UserMessage(f'Error during generation. Caused by: {e}', raise_with=ValueError)
 
         metadata = {'raw_output': res}
 
@@ -135,10 +132,10 @@ class HFEngine(Engine):
 
     def _prepare_raw_input(self, argument):
         if not argument.prop.processed_input:
-            CustomUserWarning('Need to provide a prompt instruction to the engine if raw_input is enabled.', raise_with=ValueError)
+            UserMessage('Need to provide a prompt instruction to the engine if raw_input is enabled.', raise_with=ValueError)
         value = argument.prop.processed_input
-        if type(value) != list:
-            if type(value) != dict:
+        if not isinstance(value, list):
+            if not isinstance(value, dict):
                 value = {'role': 'user', 'content': str(value)}
             value = [value]
         return value
@@ -167,17 +164,17 @@ class HFEngine(Engine):
 
         payload = argument.prop.payload
         if argument.prop.payload:
-            user += f"<ADDITIONAL_CONTEXT/>\n{str(payload)}\n\n"
+            user += f"<ADDITIONAL_CONTEXT/>\n{payload!s}\n\n"
 
-        examples: List[str] = argument.prop.examples
+        examples: list[str] = argument.prop.examples
         if examples and len(examples) > 0:
-            user += f"<EXAMPLES/>\n{str(examples)}\n\n"
+            user += f"<EXAMPLES/>\n{examples!s}\n\n"
 
         if argument.prop.prompt is not None and len(argument.prop.prompt) > 0:
-            user += f"<INSTRUCTION/>\n{str(argument.prop.prompt)}\n\n"
+            user += f"<INSTRUCTION/>\n{argument.prop.prompt!s}\n\n"
 
         if argument.prop.template_suffix:
-            user += f" You will only generate content for the placeholder `{str(argument.prop.template_suffix)}` following the instructions and the provided context information.\n\n"
+            user += f" You will only generate content for the placeholder `{argument.prop.template_suffix!s}` following the instructions and the provided context information.\n\n"
 
         user += str(argument.prop.processed_input)