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

symai/backend/engines/neurosymbolic/engine_groq.py

@@ -21,7 +21,7 @@ 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. "
+    '"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"
 )
@@ -33,44 +33,56 @@ class GroqEngine(Engine):
         self.config = deepcopy(SYMAI_CONFIG)
         # In case we use EngineRepository.register to inject the api_key and model => dynamically change the engine at runtime
         if api_key is not None and model is not None:
-            self.config['NEUROSYMBOLIC_ENGINE_API_KEY'] = api_key
-            self.config['NEUROSYMBOLIC_ENGINE_MODEL'] = model
-        if self.id() != 'neurosymbolic':
-            return # do not initialize if not neurosymbolic; avoids conflict with llama.cpp check in EngineRepository.register_from_package
-        openai.api_key = self.config['NEUROSYMBOLIC_ENGINE_API_KEY']
-        self.model = self.config['NEUROSYMBOLIC_ENGINE_MODEL'] # Keep the original config name to avoid confusion in downstream tasks
+            self.config["NEUROSYMBOLIC_ENGINE_API_KEY"] = api_key
+            self.config["NEUROSYMBOLIC_ENGINE_MODEL"] = model
+        if self.id() != "neurosymbolic":
+            return  # do not initialize if not neurosymbolic; avoids conflict with llama.cpp check in EngineRepository.register_from_package
+        openai.api_key = self.config["NEUROSYMBOLIC_ENGINE_API_KEY"]
+        self.model = self.config[
+            "NEUROSYMBOLIC_ENGINE_MODEL"
+        ]  # Keep the original config name to avoid confusion in downstream tasks
         self.seed = None
         self.name = self.__class__.__name__
 
         try:
-            self.client = openai.OpenAI(api_key=openai.api_key, base_url="https://api.groq.com/openai/v1")
+            self.client = openai.OpenAI(
+                api_key=openai.api_key, base_url="https://api.groq.com/openai/v1"
+            )
         except Exception as e:
-            UserMessage(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 \
-           self.config.get('NEUROSYMBOLIC_ENGINE_MODEL').startswith('groq'):
-                return 'neurosymbolic'
-        return super().id() # default to unregistered
+        if self.config.get("NEUROSYMBOLIC_ENGINE_MODEL") and self.config.get(
+            "NEUROSYMBOLIC_ENGINE_MODEL"
+        ).startswith("groq"):
+            return "neurosymbolic"
+        return super().id()  # default to unregistered
 
     def command(self, *args, **kwargs):
         super().command(*args, **kwargs)
-        if 'NEUROSYMBOLIC_ENGINE_API_KEY' in kwargs:
-            openai.api_key = kwargs['NEUROSYMBOLIC_ENGINE_API_KEY']
-        if 'NEUROSYMBOLIC_ENGINE_MODEL' in kwargs:
-            self.model = kwargs['NEUROSYMBOLIC_ENGINE_MODEL']
-        if 'seed' in kwargs:
-            self.seed = kwargs['seed']
+        if "NEUROSYMBOLIC_ENGINE_API_KEY" in kwargs:
+            openai.api_key = kwargs["NEUROSYMBOLIC_ENGINE_API_KEY"]
+        if "NEUROSYMBOLIC_ENGINE_MODEL" in kwargs:
+            self.model = kwargs["NEUROSYMBOLIC_ENGINE_MODEL"]
+        if "seed" in kwargs:
+            self.seed = kwargs["seed"]
 
     def compute_required_tokens(self, _messages):
-        UserMessage("Token counting not implemented for this engine.", raise_with=NotImplementedError)
+        UserMessage(
+            "Token counting not implemented for this engine.", raise_with=NotImplementedError
+        )
 
     def compute_remaining_tokens(self, _prompts: list) -> int:
-        UserMessage("Token counting not implemented for this engine.", raise_with=NotImplementedError)
+        UserMessage(
+            "Token counting not implemented for this engine.", raise_with=NotImplementedError
+        )
 
     def _handle_prefix(self, model_name: str) -> str:
         """Handle prefix for model name."""
-        return model_name.replace('groq:', '')
+        return model_name.replace("groq:", "")
 
     def _extract_thinking_content(self, output: list[str]) -> tuple[str | None, list[str]]:
         """Extract thinking content from model output if present and return cleaned output."""
@@ -81,7 +93,7 @@ class GroqEngine(Engine):
         if not content:
             return None, output
 
-        think_pattern = r'<think>(.*?)</think>'
+        think_pattern = r"<think>(.*?)</think>"
         match = re.search(think_pattern, content, re.DOTALL)
 
         thinking_content = None
@@ -90,57 +102,67 @@ class GroqEngine(Engine):
             if not thinking_content:
                 thinking_content = None
 
-        cleaned_content = re.sub(think_pattern, '', content, flags=re.DOTALL).strip()
+        cleaned_content = re.sub(think_pattern, "", content, flags=re.DOTALL).strip()
         cleaned_output = [cleaned_content, *output[1:]]
 
         return thinking_content, cleaned_output
 
-    # cumulative wait time is ~113s
-    @retry(tries=8, delay=0.5, backoff=2, max_delay=30, jitter=(0, 0.5))
+    # cumulative wait time is < 30s
+    @retry(tries=8, delay=0.5, backoff=1.5, max_delay=5, jitter=(0, 0.5))
     def forward(self, argument):
         kwargs = argument.kwargs
         messages = argument.prop.prepared_input
         payload = self._prepare_request_payload(messages, argument)
-        except_remedy = kwargs.get('except_remedy')
+        except_remedy = kwargs.get("except_remedy")
 
         try:
             res = self.client.chat.completions.create(**payload)
 
         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.'
+            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."
                 UserMessage(msg)
-                if self.config['NEUROSYMBOLIC_ENGINE_API_KEY'] is None or self.config['NEUROSYMBOLIC_ENGINE_API_KEY'] == '':
+                if (
+                    self.config["NEUROSYMBOLIC_ENGINE_API_KEY"] is None
+                    or self.config["NEUROSYMBOLIC_ENGINE_API_KEY"] == ""
+                ):
                     UserMessage(msg, raise_with=ValueError)
-                openai.api_key = self.config['NEUROSYMBOLIC_ENGINE_API_KEY']
+                openai.api_key = self.config["NEUROSYMBOLIC_ENGINE_API_KEY"]
 
             callback = self.client.chat.completions.create
-            kwargs['model'] = self._handle_prefix(kwargs['model']) if 'model' in kwargs else self._handle_prefix(self.model)
+            kwargs["model"] = (
+                self._handle_prefix(kwargs["model"])
+                if "model" in kwargs
+                else self._handle_prefix(self.model)
+            )
 
             if except_remedy is not None:
                 res = except_remedy(self, e, callback, argument)
             else:
-                UserMessage(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'):
+        metadata = {"raw_output": res}
+        if payload.get("tools"):
             metadata = self._process_function_calls(res, metadata)
 
         output = [r.message.content for r in res.choices]
         thinking, output = self._extract_thinking_content(output)
         if thinking:
-            metadata['thinking'] = thinking
+            metadata["thinking"] = thinking
 
         return output, metadata
 
     def _prepare_raw_input(self, argument):
         if not argument.prop.processed_input:
-            UserMessage('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 not isinstance(value, list):
             if not isinstance(value, dict):
-                value = {'role': 'user', 'content': str(value)}
+                value = {"role": "user", "content": str(value)}
             value = [value]
         return value
 
@@ -156,14 +178,14 @@ class GroqEngine(Engine):
         system, user_prompt = self._apply_self_prompt_if_needed(argument, system, user_prompt)
 
         argument.prop.prepared_input = [
-            { "role": "system", "content": system },
+            {"role": "system", "content": system},
             user_prompt,
         ]
 
     def _validate_response_format(self, argument) -> None:
         if argument.prop.response_format:
             response_format = argument.prop.response_format
-            assert response_format.get('type') is not None, (
+            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"
             )
@@ -206,36 +228,38 @@ class GroqEngine(Engine):
         return str(argument.prop.processed_input)
 
     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:
+        if argument.prop.instance._kwargs.get("self_prompt", False) or argument.prop.self_prompt:
             self_prompter = SelfPrompt()
-            res = self_prompter({'user': user_prompt['content'], 'system': system})
+            res = self_prompter({"user": user_prompt["content"], "system": system})
             if res is None:
                 UserMessage("Self-prompting failed!", raise_with=ValueError)
-            return res['system'], {"role": "user", "content": res['user']}
+            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')
+            hasattr(res, "choices")
             and res.choices
-            and hasattr(res.choices[0], 'message')
+            and hasattr(res.choices[0], "message")
             and res.choices[0].message
-            and hasattr(res.choices[0].message, 'tool_calls')
+            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 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.")
+                        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
+                    metadata["function_call"] = {
+                        "name": tool_call.function.name,
+                        "arguments": args_dict,
                     }
                     hit = True
         return metadata
@@ -253,43 +277,53 @@ class GroqEngine(Engine):
             "stream_options",
         ]:
             if param in kwargs:
-                UserMessage(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)
+        n = kwargs.get("n", 1)
         if n > 1:
-            UserMessage("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.
-        response_format = kwargs.get('response_format')
-        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'
+        response_format = kwargs.get("response_format")
+        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
 
         payload = {
             "messages": messages,
-            "model": self._handle_prefix(kwargs.get('model', self.model)),
-            "seed": kwargs.get('seed', self.seed),
-            "max_completion_tokens": kwargs.get('max_completion_tokens'),
-            "stop": kwargs.get('stop'),
-            "temperature": kwargs.get('temperature', 1), # Default temperature for gpt-oss-120b
-            "frequency_penalty": kwargs.get('frequency_penalty', 0),
-            "presence_penalty": kwargs.get('presence_penalty', 0),
-            "reasoning_effort": kwargs.get('reasoning_effort'),
-            "service_tier": kwargs.get('service_tier', 'on_demand'),
-            "top_p": kwargs.get('top_p', 1),
+            "model": self._handle_prefix(kwargs.get("model", self.model)),
+            "seed": kwargs.get("seed", self.seed),
+            "max_completion_tokens": kwargs.get("max_completion_tokens"),
+            "stop": kwargs.get("stop"),
+            "temperature": kwargs.get("temperature", 1),  # Default temperature for gpt-oss-120b
+            "frequency_penalty": kwargs.get("frequency_penalty", 0),
+            "presence_penalty": kwargs.get("presence_penalty", 0),
+            "reasoning_effort": kwargs.get("reasoning_effort"),
+            "service_tier": kwargs.get("service_tier", "on_demand"),
+            "top_p": kwargs.get("top_p", 1),
             "n": n,
             "tools": tools,
             "tool_choice": tool_choice,
             "response_format": response_format,
         }
 
-        if not self._handle_prefix(self.model).startswith('qwen') or not self._handle_prefix(self.model).startswith('openai'):
-            del payload['reasoning_effort']
+        if not self._handle_prefix(self.model).startswith("qwen") or not self._handle_prefix(
+            self.model
+        ).startswith("openai"):
+            del payload["reasoning_effort"]
 
         return payload

symai/backend/engines/neurosymbolic/engine_huggingface.py

@@ -18,31 +18,41 @@ class HFTokenizer:
 
     @staticmethod
     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,
-        })
+        res = requests.post(
+            f"{HFTokenizer._server_endpoint}/tokenize",
+            json={
+                "input": text,
+                "add_special_tokens": add_special_tokens,
+            },
+        )
 
         if res.status_code != 200:
-            UserMessage(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']
+        return res["tokens"]
 
     @staticmethod
     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,
-        })
+        res = requests.post(
+            f"{HFTokenizer._server_endpoint}/detokenize",
+            json={
+                "tokens": tokens,
+                "skip_special_tokens": skip_special_tokens,
+            },
+        )
 
         if res.status_code != 200:
-            UserMessage(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['text']
+        return res["text"]
 
 
 class HFEngine(Engine):
@@ -51,70 +61,90 @@ class HFEngine(Engine):
         self.config = deepcopy(SYMAI_CONFIG)
         # In case we use EngineRepository.register to inject the api_key and model => dynamically change the engine at runtime
         if model is not None:
-            self.config['NEUROSYMBOLIC_ENGINE_MODEL'] = model
-        if self.id() != 'neurosymbolic':
+            self.config["NEUROSYMBOLIC_ENGINE_MODEL"] = model
+        if self.id() != "neurosymbolic":
             return
-        if not SYMSERVER_CONFIG.get('online'):
-            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(...)
+        if not SYMSERVER_CONFIG.get("online"):
+            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__
 
     def id(self) -> str:
-        if self.config.get('NEUROSYMBOLIC_ENGINE_MODEL') and self.config.get('NEUROSYMBOLIC_ENGINE_MODEL').startswith('huggingface'):
-            return 'neurosymbolic'
-        return super().id() # default to unregistered
+        if self.config.get("NEUROSYMBOLIC_ENGINE_MODEL") and self.config.get(
+            "NEUROSYMBOLIC_ENGINE_MODEL"
+        ).startswith("huggingface"):
+            return "neurosymbolic"
+        return super().id()  # default to unregistered
 
     def command(self, *args, **kwargs):
         super().command(*args, **kwargs)
-        if 'NEUROSYMBOLIC_ENGINE_MODEL' in kwargs:
-            self.model = kwargs['NEUROSYMBOLIC_ENGINE_MODEL']
-        if 'seed' in kwargs:
-            self.seed = kwargs['seed']
-        if 'except_remedy' in kwargs:
-            self.except_remedy = kwargs['except_remedy']
+        if "NEUROSYMBOLIC_ENGINE_MODEL" in kwargs:
+            self.model = kwargs["NEUROSYMBOLIC_ENGINE_MODEL"]
+        if "seed" in kwargs:
+            self.seed = kwargs["seed"]
+        if "except_remedy" in kwargs:
+            self.except_remedy = kwargs["except_remedy"]
 
     def compute_required_tokens(self, _messages) -> int:
-        UserMessage('Not implemented for HFEngine. Please use the tokenizer directly to compute tokens.', raise_with=NotImplementedError)
+        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)
+        UserMessage(
+            "Not implemented for HFEngine. Please use the tokenizer directly to compute tokens.",
+            raise_with=NotImplementedError,
+        )
+
     def forward(self, argument):
-        kwargs  = argument.kwargs
+        kwargs = argument.kwargs
         prompts = argument.prop.prepared_input
 
-        stop               = kwargs.get('stop')
-        seed               = kwargs.get('seed')
-        temperature        = kwargs.get('temperature', 1.)
-        top_p              = kwargs.get('top_p', 1.)
-        top_k              = kwargs.get('top_k', 50)
-        max_tokens         = kwargs.get('max_tokens', 2048)
-        max_tokens_forcing = kwargs.get('max_tokens_forcing')
-        logprobs           = kwargs.get('logprobs', True)
-        do_sample          = kwargs.get('do_sample', True)
-        num_beams          = kwargs.get('num_beams', 1)
-        num_beam_groups    = kwargs.get('num_beam_groups', 1)
-        eos_token_id       = kwargs.get('eos_token_id')
-        except_remedy      = kwargs.get('except_remedy')
+        stop = kwargs.get("stop")
+        seed = kwargs.get("seed")
+        temperature = kwargs.get("temperature", 1.0)
+        top_p = kwargs.get("top_p", 1.0)
+        top_k = kwargs.get("top_k", 50)
+        max_tokens = kwargs.get("max_tokens", 2048)
+        max_tokens_forcing = kwargs.get("max_tokens_forcing")
+        logprobs = kwargs.get("logprobs", True)
+        do_sample = kwargs.get("do_sample", True)
+        num_beams = kwargs.get("num_beams", 1)
+        num_beam_groups = kwargs.get("num_beam_groups", 1)
+        eos_token_id = kwargs.get("eos_token_id")
+        except_remedy = kwargs.get("except_remedy")
 
         try:
-            res = requests.post(f"{self.server_endpoint}/chat", json={
-                "messages": prompts,
-                "temperature": temperature,
-                "top_p": top_p,
-                "stop": stop,
-                "seed": seed,
-                "max_tokens": max_tokens,
-                "max_tokens_forcing": max_tokens_forcing,
-                "top_k": top_k,
-                "logprobs": logprobs,
-                "do_sample": do_sample,
-                "num_beams": num_beams,
-                "num_beam_groups": num_beam_groups,
-                "eos_token_id": eos_token_id,
-            })
+            res = requests.post(
+                f"{self.server_endpoint}/chat",
+                json={
+                    "messages": prompts,
+                    "temperature": temperature,
+                    "top_p": top_p,
+                    "stop": stop,
+                    "seed": seed,
+                    "max_tokens": max_tokens,
+                    "max_tokens_forcing": max_tokens_forcing,
+                    "top_k": top_k,
+                    "logprobs": logprobs,
+                    "do_sample": do_sample,
+                    "num_beams": num_beams,
+                    "num_beam_groups": num_beam_groups,
+                    "eos_token_id": eos_token_id,
+                },
+            )
 
             if res.status_code != 200:
-                UserMessage(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()
 
@@ -122,21 +152,24 @@ class HFEngine(Engine):
             if except_remedy is not None:
                 res = except_remedy(self, e, argument)
             else:
-                UserMessage(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}
+        metadata = {"raw_output": res}
 
-        rsp    = [r['message']['content'] for r in res['choices']]
+        rsp = [r["message"]["content"] for r in res["choices"]]
         output = rsp if isinstance(prompts, list) else rsp[0]
         return output, metadata
 
     def _prepare_raw_input(self, argument):
         if not argument.prop.processed_input:
-            UserMessage('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 not isinstance(value, list):
             if not isinstance(value, dict):
-                value = {'role': 'user', 'content': str(value)}
+                value = {"role": "user", "content": str(value)}
             value = [value]
         return value
 
@@ -147,12 +180,12 @@ class HFEngine(Engine):
 
         _non_verbose_output = """<META_INSTRUCTION/>\n You will NOT output verbose preambles or post explanation, such as "Sure, let me...", "Hope that was helpful...", "Yes, I can help you with that...", etc. You will consider well formatted output, e.g. for sentences you will use punctuation, spaces, etc. or for code indentation, etc.\n"""
 
-        #@TODO: Non-trivial how to handle user/system/assistant roles;
+        # @TODO: Non-trivial how to handle user/system/assistant roles;
         user = ""
 
         if argument.prop.suppress_verbose_output:
             user += _non_verbose_output
-        user = f'{user}\n' if user and len(user) > 0 else ''
+        user = f"{user}\n" if user and len(user) > 0 else ""
 
         ref = argument.prop.instance
         static_ctxt, dyn_ctxt = ref.global_context
@@ -179,5 +212,5 @@ class HFEngine(Engine):
         user += str(argument.prop.processed_input)
 
         argument.prop.prepared_input = [
-            { "role": "user", "content": user },
+            {"role": "user", "content": user},
         ]