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

symai/backend/engines/neurosymbolic/engine_deepseekX_reasoning.py

@@ -1,15 +1,10 @@
 import logging
-import re
 from copy import deepcopy
-from typing import List, Optional
 
-from annotated_types import Not
 from openai import OpenAI
 
 from ....components import SelfPrompt
-from ....misc.console import ConsoleStyle
-from ....symbol import Symbol
-from ....utils import CustomUserWarning, encode_media_frames
+from ....utils import UserMessage
 from ...base import Engine
 from ...mixin.deepseek import DeepSeekMixin
 from ...settings import SYMAI_CONFIG
@@ -22,7 +17,7 @@ logging.getLogger("httpcore").setLevel(logging.ERROR)
 
 
 class DeepSeekXReasoningEngine(Engine, DeepSeekMixin):
-    def __init__(self, api_key: Optional[str] = None, model: Optional[str] = None):
+    def __init__(self, api_key: str | None = None, 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
@@ -42,7 +37,7 @@ class DeepSeekXReasoningEngine(Engine, DeepSeekMixin):
         try:
             self.client = OpenAI(api_key=self.api_key, base_url="https://api.deepseek.com")
         except Exception as e:
-            CustomUserWarning(f'Failed to initialize the DeepSeek client. Please check your library version. Caused by: {e}', raise_with=RuntimeError)
+            UserMessage(f'Failed to initialize the DeepSeek client. Please check your library version. Caused by: {e}', raise_with=RuntimeError)
 
     def id(self) -> str:
         if self.config.get('NEUROSYMBOLIC_ENGINE_MODEL') and \
@@ -59,14 +54,14 @@ class DeepSeekXReasoningEngine(Engine, DeepSeekMixin):
         if 'seed' in kwargs:
             self.seed = kwargs['seed']
 
-    def compute_required_tokens(self, messages):
-        CustomUserWarning('Method "compute_required_tokens" not implemented for DeepSeekXReasoningEngine.', raise_with=NotImplementedError)
+    def compute_required_tokens(self, _messages):
+        UserMessage('Method "compute_required_tokens" not implemented for DeepSeekXReasoningEngine.', raise_with=NotImplementedError)
 
-    def compute_remaining_tokens(self, prompts: list) -> int:
-        CustomUserWarning('Method "compute_remaining_tokens" not implemented for DeepSeekXReasoningEngine.', raise_with=NotImplementedError)
+    def compute_remaining_tokens(self, _prompts: list) -> int:
+        UserMessage('Method "compute_remaining_tokens" not implemented for DeepSeekXReasoningEngine.', raise_with=NotImplementedError)
 
-    def truncate(self, prompts: list[dict], truncation_percentage: float | None, truncation_type: str) -> list[dict]:
-        CustomUserWarning('Method "truncate" not implemented for DeepSeekXReasoningEngine.', raise_with=NotImplementedError)
+    def truncate(self, _prompts: list[dict], _truncation_percentage: float | None, _truncation_type: str) -> list[dict]:
+        UserMessage('Method "truncate" not implemented for DeepSeekXReasoningEngine.', raise_with=NotImplementedError)
 
     def forward(self, argument):
         kwargs = argument.kwargs
@@ -80,18 +75,18 @@ class DeepSeekXReasoningEngine(Engine, DeepSeekMixin):
         except Exception as e:
             if self.api_key is None or self.api_key == '':
                 msg = 'DeepSeek 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)
                 self.api_key = self.config['NEUROSYMBOLIC_ENGINE_API_KEY']
 
             callback = self.client.chat.completions.create
-            kwargs['model'] = kwargs['model'] if 'model' in kwargs else self.model
+            kwargs['model'] = kwargs.get('model', self.model)
 
             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)
 
         reasoning_content = res.choices[0].message.reasoning_content
         content = res.choices[0].message.content
@@ -101,36 +96,32 @@ class DeepSeekXReasoningEngine(Engine, DeepSeekMixin):
 
     def _prepare_raw_input(self, argument):
         if not argument.prop.processed_input:
-            CustomUserWarning('A prompt instruction is required for DeepSeekXReasoningEngine when raw_input is enabled.', raise_with=ValueError)
+            UserMessage('A prompt instruction is required for DeepSeekXReasoningEngine when 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
 
-    def prepare(self, argument):
-        if argument.prop.raw_input:
-            argument.prop.prepared_input = self._prepare_raw_input(argument)
-            return
-
+    def _build_system_prompt(self, 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 = ""
+        prop = argument.prop
 
-        if argument.prop.suppress_verbose_output:
+        if prop.suppress_verbose_output:
             system += _non_verbose_output
         system = f'{system}\n' if system and len(system) > 0 else ''
 
-        if argument.prop.response_format:
-            _rsp_fmt = argument.prop.response_format
+        if prop.response_format:
+            _rsp_fmt = prop.response_format
             if not (_rsp_fmt.get('type') is not None):
-                CustomUserWarning('Response format type is required! Expected format `{"type": "json_object"}` or other supported types.', raise_with=AssertionError)
+                UserMessage('Response format type is required! Expected format `{"type": "json_object"}` or other supported types.', raise_with=AssertionError)
             system += _non_verbose_output
             system += f'<RESPONSE_FORMAT/>\n{_rsp_fmt["type"]}\n\n'
 
-        ref = argument.prop.instance
+        ref = prop.instance
         static_ctxt, dyn_ctxt = ref.global_context
         if len(static_ctxt) > 0:
             system += f"<STATIC CONTEXT/>\n{static_ctxt}\n\n"
@@ -138,36 +129,49 @@ class DeepSeekXReasoningEngine(Engine, DeepSeekMixin):
         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"
+        payload = prop.payload
+        if prop.payload:
+            system += f"<ADDITIONAL CONTEXT/>\n{payload!s}\n\n"
 
-        examples: List[str] = argument.prop.examples
+        examples: list[str] = 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)
+        if prop.prompt is not None and len(prop.prompt) > 0:
+            val = str(prop.prompt)
             system += f"<INSTRUCTION/>\n{val}\n\n"
 
-        user += f"{str(argument.prop.processed_input)}"
+        if prop.template_suffix:
+            system += f' You will only generate content for the placeholder `{prop.template_suffix!s}` following the instructions and the provided context information.\n\n'
 
-        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'
+        return system
 
-        user_prompt = { "role": "user", "content": user }
+    def _build_user_prompt(self, argument):
+        return {"role": "user", "content": f"{argument.prop.processed_input!s}"}
 
-        # First check if the `Symbol` instance has the flag set, otherwise check if it was passed as an argument to a method
-        if argument.prop.instance._kwargs.get('self_prompt', False) or argument.prop.self_prompt:
+    def _apply_self_prompt(self, argument, system, user_prompt):
+        prop = argument.prop
+        if prop.instance._kwargs.get('self_prompt', False) or 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 for DeepSeekXReasoningEngine.", raise_with=ValueError)
+                UserMessage("Self-prompting failed for DeepSeekXReasoningEngine.", raise_with=ValueError)
 
             user_prompt = { "role": "user", "content": res['user'] }
             system = res['system']
 
+        return system, user_prompt
+
+    def prepare(self, argument):
+        if argument.prop.raw_input:
+            argument.prop.prepared_input = self._prepare_raw_input(argument)
+            return
+
+        system = self._build_system_prompt(argument)
+        user_prompt = self._build_user_prompt(argument)
+        system, user_prompt = self._apply_self_prompt(argument, system, user_prompt)
+
         argument.prop.prepared_input = [
             { "role": "system", "content": system },
             user_prompt,
@@ -177,8 +181,8 @@ class DeepSeekXReasoningEngine(Engine, DeepSeekMixin):
         """Prepares the request payload from the argument."""
         kwargs = argument.kwargs
         # 16/03/2025
-        # Not Supported Features：Function Call、Json Output、FIM (Beta)
-        # Not Supported Parameters：temperature、top_p、presence_penalty、frequency_penalty、logprobs、top_logprobs
+        # Not Supported Features: Function Call、Json Output、FIM (Beta)
+        # Not Supported Parameters: temperature、top_p、presence_penalty、frequency_penalty、logprobs、top_logprobs
         return {
             "model": kwargs.get('model', self.model),
             "seed": kwargs.get('seed', self.seed),