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

symai/backend/engines/search/engine_perplexity.py

@@ -4,7 +4,7 @@ import logging
 import requests
 
 from ....symbol import Result
-from ....utils import CustomUserWarning
+from ....utils import UserMessage
 from ...base import Engine
 from ...settings import SYMAI_CONFIG
 
@@ -17,13 +17,13 @@ logging.getLogger("httpcore").setLevel(logging.ERROR)
 class SearchResult(Result):
     def __init__(self, value, **kwargs) -> None:
         super().__init__(value, **kwargs)
-        if value.get('error'):
-            CustomUserWarning(value['error'], raise_with=ValueError)
+        if value.get("error"):
+            UserMessage(value["error"], raise_with=ValueError)
         try:
-            self._value = value['choices'][0]['message']['content']
+            self._value = value["choices"][0]["message"]["content"]
         except Exception as e:
             self._value = None
-            CustomUserWarning(f"Failed to parse response: {e}", raise_with=ValueError)
+            UserMessage(f"Failed to parse response: {e}", raise_with=ValueError)
 
     def __str__(self) -> str:
         try:
@@ -35,80 +35,79 @@ class SearchResult(Result):
         try:
             return f"<pre>{json.dumps(self.raw, indent=2)}</pre>"
         except TypeError:
-            return f"<pre>{str(self.raw)}</pre>"
+            return f"<pre>{self.raw!s}</pre>"
 
 
 class PerplexityEngine(Engine):
     def __init__(self):
         super().__init__()
         self.config = SYMAI_CONFIG
-        self.api_key = self.config['SEARCH_ENGINE_API_KEY']
-        self.model = self.config['SEARCH_ENGINE_MODEL']
+        self.api_key = self.config["SEARCH_ENGINE_API_KEY"]
+        self.model = self.config["SEARCH_ENGINE_MODEL"]
         self.name = self.__class__.__name__
 
     def id(self) -> str:
-        if self.config.get('SEARCH_ENGINE_API_KEY') and self.config.get('SEARCH_ENGINE_MODEL').startswith("sonar"):
-            return 'search'
+        if self.config.get("SEARCH_ENGINE_API_KEY") and self.config.get(
+            "SEARCH_ENGINE_MODEL"
+        ).startswith("sonar"):
+            return "search"
         return super().id()  # default to unregistered
 
     def command(self, *args, **kwargs):
         super().command(*args, **kwargs)
-        if 'SEARCH_ENGINE_API_KEY' in kwargs:
-            self.api_key = kwargs['SEARCH_ENGINE_API_KEY']
-        if 'SEARCH_ENGINE_MODEL' in kwargs:
-            self.model = kwargs['SEARCH_ENGINE_MODEL']
+        if "SEARCH_ENGINE_API_KEY" in kwargs:
+            self.api_key = kwargs["SEARCH_ENGINE_API_KEY"]
+        if "SEARCH_ENGINE_MODEL" in kwargs:
+            self.model = kwargs["SEARCH_ENGINE_MODEL"]
 
     def forward(self, argument):
-        messages  = argument.prop.prepared_input
-        kwargs    = argument.kwargs
+        messages = argument.prop.prepared_input
+        kwargs = argument.kwargs
 
         payload = {
             "model": self.model,
             "messages": messages,
-            "max_tokens": kwargs.get('max_tokens', None),
-            "temperature": kwargs.get('temperature', 0.2),
-            "top_p": kwargs.get('top_p', 0.9),
-            "search_domain_filter": kwargs.get('search_domain_filter', []),
-            "return_images": kwargs.get('return_images', False),
-            "return_related_questions": kwargs.get('return_related_questions', False),
-            "search_recency_filter": kwargs.get('search_recency_filter', "month"),
-            "top_k": kwargs.get('top_k', 0),
-            "stream": kwargs.get('stream', False),
-            "presence_penalty": kwargs.get('presence_penalty', 0),
-            "frequency_penalty": kwargs.get('frequency_penalty', 1),
-            "response_format": kwargs.get('response_format', None)
+            "max_tokens": kwargs.get("max_tokens", None),
+            "temperature": kwargs.get("temperature", 0.2),
+            "top_p": kwargs.get("top_p", 0.9),
+            "search_domain_filter": kwargs.get("search_domain_filter", []),
+            "return_images": kwargs.get("return_images", False),
+            "return_related_questions": kwargs.get("return_related_questions", False),
+            "search_recency_filter": kwargs.get("search_recency_filter", "month"),
+            "top_k": kwargs.get("top_k", 0),
+            "stream": kwargs.get("stream", False),
+            "presence_penalty": kwargs.get("presence_penalty", 0),
+            "frequency_penalty": kwargs.get("frequency_penalty", 1),
+            "response_format": kwargs.get("response_format", None),
         }
-        web_search_options = kwargs.get('web_search_options', None)
+        web_search_options = kwargs.get("web_search_options", None)
         if web_search_options is not None:
             payload["web_search_options"] = web_search_options
 
-        headers = {
-            "Authorization": f"Bearer {self.api_key}",
-            "Content-Type": "application/json"
-        }
+        headers = {"Authorization": f"Bearer {self.api_key}", "Content-Type": "application/json"}
 
         try:
-            res = requests.post("https://api.perplexity.ai/chat/completions", json=payload, headers=headers)
+            res = requests.post(
+                "https://api.perplexity.ai/chat/completions", json=payload, headers=headers
+            )
             res = SearchResult(res.json())
         except Exception as e:
-            CustomUserWarning(f"Failed to make request: {e}", raise_with=ValueError)
+            UserMessage(f"Failed to make request: {e}", raise_with=ValueError)
 
         metadata = {"raw_output": res.raw}
-        output   = [res]
+        output = [res]
 
         return output, metadata
 
     def prepare(self, argument):
-        system_message = "You are a helpful AI assistant. Be precise and informative." if argument.kwargs.get('system_message') is None else argument.kwargs.get('system_message')
+        system_message = (
+            "You are a helpful AI assistant. Be precise and informative."
+            if argument.kwargs.get("system_message") is None
+            else argument.kwargs.get("system_message")
+        )
 
         res = [
-            {
-                "role": "system",
-                "content": system_message
-            },
-            {
-                "role": "user",
-                "content": f"{argument.prop.query}"
-            }
+            {"role": "system", "content": system_message},
+            {"role": "user", "content": f"{argument.prop.query}"},
         ]
         argument.prop.prepared_input = res

symai/backend/engines/search/engine_serpapi.py

@@ -3,34 +3,34 @@ import json
 from IPython.utils import io
 
 from ....symbol import Result
-from ....utils import CustomUserWarning
+from ....utils import UserMessage
 from ...base import Engine
 from ...settings import SYMAI_CONFIG
 
 try:
     from serpapi import GoogleSearch
-except:
+except ImportError:
     GoogleSearch = None
 
 
 class SearchResult(Result):
     def __init__(self, value, **kwargs) -> None:
         super().__init__(value, **kwargs)
-        if 'answer_box' in value.keys() and 'answer' in value['answer_box'].keys():
-            self._value = value['answer_box']['answer']
-        elif 'answer_box' in value.keys() and 'snippet' in value['answer_box'].keys():
-            self._value = value['answer_box']['snippet']
-        elif 'answer_box' in value.keys() and 'snippet_highlighted_words' in value['answer_box'].keys():
-            self._value = value['answer_box']["snippet_highlighted_words"][0]
-        elif 'organic_results' in value and 'snippet' in value["organic_results"][0].keys():
-            self._value = value["organic_results"][0]['snippet']
+        if "answer_box" in value and "answer" in value["answer_box"]:
+            self._value = value["answer_box"]["answer"]
+        elif "answer_box" in value and "snippet" in value["answer_box"]:
+            self._value = value["answer_box"]["snippet"]
+        elif "answer_box" in value and "snippet_highlighted_words" in value["answer_box"]:
+            self._value = value["answer_box"]["snippet_highlighted_words"][0]
+        elif "organic_results" in value and "snippet" in value["organic_results"][0]:
+            self._value = value["organic_results"][0]["snippet"]
         else:
             self._value = value
 
-        if 'organic_results' in value.keys():
-            self.results = value['organic_results']
+        if "organic_results" in value:
+            self.results = value["organic_results"]
             if len(self.results) > 0:
-                self.links = [r['link'] for r in self.results]
+                self.links = [r["link"] for r in self.results]
             else:
                 self.links = []
         else:
@@ -38,42 +38,45 @@ class SearchResult(Result):
             self.links = []
 
     def __str__(self) -> str:
-        json_str = json.dumps(self.raw, indent=2)
-        return json_str
+        return json.dumps(self.raw, indent=2)
 
     def _repr_html_(self) -> str:
-        json_str = json.dumps(self.raw, indent=2)
-        return json_str
+        return json.dumps(self.raw, indent=2)
 
 
 class SerpApiEngine(Engine):
     def __init__(self):
         super().__init__()
         self.config = SYMAI_CONFIG
-        self.api_key = self.config['SEARCH_ENGINE_API_KEY']
-        self.engine = self.config['SEARCH_ENGINE_MODEL']
+        self.api_key = self.config["SEARCH_ENGINE_API_KEY"]
+        self.engine = self.config["SEARCH_ENGINE_MODEL"]
         self.name = self.__class__.__name__
 
     def id(self) -> str:
-        if self.config.get('SEARCH_ENGINE_API_KEY') and self.config.get('SEARCH_ENGINE_MODEL') == "google": # only support Google for now
+        if (
+            self.config.get("SEARCH_ENGINE_API_KEY")
+            and self.config.get("SEARCH_ENGINE_MODEL") == "google"
+        ):  # only support Google for now
             if GoogleSearch is None:
-                CustomUserWarning('SerpApi is not installed. Please install it with `pip install symbolicai[serpapi]`')
-            return 'search'
-        return super().id() # default to unregistered
+                UserMessage(
+                    "SerpApi is not installed. Please install it with `pip install symbolicai[serpapi]`"
+                )
+            return "search"
+        return super().id()  # default to unregistered
 
     def command(self, *args, **kwargs):
         super().command(*args, **kwargs)
-        if 'SEARCH_ENGINE_API_KEY' in kwargs:
-            self.api_key = kwargs['SEARCH_ENGINE_API_KEY']
-        if 'SEARCH_ENGINE_MODEL' in kwargs:
-            self.engine  = kwargs['SEARCH_ENGINE_MODEL']
+        if "SEARCH_ENGINE_API_KEY" in kwargs:
+            self.api_key = kwargs["SEARCH_ENGINE_API_KEY"]
+        if "SEARCH_ENGINE_MODEL" in kwargs:
+            self.engine = kwargs["SEARCH_ENGINE_MODEL"]
 
     def forward(self, argument):
-        queries  = argument.prop.prepared_input
-        kwargs   = argument.kwargs
+        queries = argument.prop.prepared_input
+        kwargs = argument.kwargs
         queries_ = queries if isinstance(queries, list) else [queries]
-        rsp      = []
-        engine   = kwargs['engine'] if 'engine' in kwargs else self.engine
+        rsp = []
+        engine = kwargs.get("engine", self.engine)
 
         for q in queries_:
             query = {
@@ -82,11 +85,11 @@ class SerpApiEngine(Engine):
                 "q": q,
                 "google_domain": "google.com",
                 "gl": "us",
-                "hl": "en"
+                "hl": "en",
             }
 
             # send to Google
-            with io.capture_output() as captured: # disables prints from GoogleSearch
+            with io.capture_output():  # disables prints from GoogleSearch
                 search = GoogleSearch(query)
                 res = search.get_dict()
 
@@ -100,7 +103,7 @@ class SerpApiEngine(Engine):
         return output, metadata
 
     def prepare(self, argument):
-        res  = ''
+        res = ""
         res += str(argument.prop.query)
         res += str(argument.prop.processed_input)
         argument.prop.prepared_input = res

symai/backend/engines/speech_to_text/engine_local_whisper.py

@@ -1,22 +1,21 @@
-import logging
+import contextlib
 import re
+from collections.abc import Iterable
 from itertools import takewhile
-from typing import Iterable
 
 import torch
 
 from ....symbol import Expression, Result
-from ....utils import CustomUserWarning
+from ....utils import UserMessage
 from ...base import Engine
 from ...settings import SYMAI_CONFIG
 
 try:
     import whisper
-    from whisper.audio import \
-        N_SAMPLES  # @NOTE: sample_rate (16_000) * chunk_length (30) = 480_000
+    from whisper.audio import N_SAMPLES  # @NOTE: sample_rate (16_000) * chunk_length (30) = 480_000
     from whisper.tokenizer import get_tokenizer
 except ImportError:
-    whisper   = None
+    whisper = None
     N_SAMPLES = 16_000 * 30
 
 
@@ -27,17 +26,19 @@ class WhisperTimestampsFormatter(Expression):
     def forward(self, response: list[str]) -> str:
         result = []
         for i, interval in enumerate(response):
-            interval = self._filter_empty_string(interval)
+            interval_tokens = self._filter_empty_string(interval)
             prev_end = 0.0
             prev_start = 0.0
-            for head, tail in zip(interval[::2], interval[1::2]):
+            for head, tail in zip(interval_tokens[::2], interval_tokens[1::2], strict=False):
                 start = self._get_timestamp(head)
                 end = self._get_timestamp(tail)
                 if start >= prev_end:
                     start = prev_end
                     prev_end = end
                     prev_start = start
-                    result.append(f"{self._format_to_hours(start + (i*30))} {self._get_sentence(head)}")
+                    result.append(
+                        f"{self._format_to_hours(start + (i * 30))} {self._get_sentence(head)}"
+                    )
                     continue
                 if start < prev_start:
                     continue
@@ -46,12 +47,11 @@ class WhisperTimestampsFormatter(Expression):
                     start = prev_end
                 else:
                     start += prev_end
-                if start + delta > 30:
-                    end = 30
-                else:
-                    end = start + delta
+                end = 30 if start + delta > 30 else start + delta
                 prev_end = end
-                result.append(f"{self._format_to_hours(start + (i*30))} {self._get_sentence(head)}")
+                result.append(
+                    f"{self._format_to_hours(start + (i * 30))} {self._get_sentence(head)}"
+                )
         return "\n".join(result)
 
     def _filter_empty_string(self, s: str) -> list[str]:
@@ -68,8 +68,7 @@ class WhisperTimestampsFormatter(Expression):
         seconds %= 3600
         minutes = int(seconds // 60)
         seconds %= 60
-        formatted_time = "{:02d}:{:02d}:{:02d}".format(hours, minutes, int(seconds))
-        return formatted_time
+        return f"{hours:02d}:{minutes:02d}:{int(seconds):02d}"
 
 
 class WhisperResult(Result):
@@ -80,20 +79,20 @@ class WhisperResult(Result):
 
     def get_bins(self, bin_size_s: int = 5 * 60) -> list[str]:
         tmps = list(map(self._seconds, re.findall(r"\b\d{2}:\d{2}:\d{2}\b", self._value)))
-        value_pairs = list(zip(tmps, self._value.split("\n")))
-        bin = []
+        value_pairs = list(zip(tmps, self._value.split("\n"), strict=False))
+        bin_segments = []
         result = []
         for tmp, seg in value_pairs:
-            bin.append(seg)
+            bin_segments.append(seg)
             if tmp == 0 or (tmp - bin_size_s) % bin_size_s != 0:
                 continue
-            result.append("\n".join(bin))
-            bin = []
-        result.append("\n".join(bin))
+            result.append("\n".join(bin_segments))
+            bin_segments = []
+        result.append("\n".join(bin_segments))
         return result
 
     def _seconds(self, tmp: str) -> int:
-        h, m ,s = tmp.split(":")
+        h, m, s = tmp.split(":")
         return int(h) * 3600 + int(m) * 60 + int(s)
 
 
@@ -101,37 +100,44 @@ class WhisperEngine(Engine):
     def __init__(self, model: str | None = None, to_device: str | None = None):
         super().__init__()
         self.config = SYMAI_CONFIG
-        self.model = None # lazy loading
-        self.model_id = self.config['SPEECH_TO_TEXT_ENGINE_MODEL'] if model is None else model
-        self.old_model_id = self.config['SPEECH_TO_TEXT_ENGINE_MODEL'] if model is None else model
+        self.model = None  # lazy loading
+        self.model_id = self.config["SPEECH_TO_TEXT_ENGINE_MODEL"] if model is None else model
+        self.old_model_id = self.config["SPEECH_TO_TEXT_ENGINE_MODEL"] if model is None else model
         self.tokens = []
         self.text = []
         self.formatter = WhisperTimestampsFormatter()
         self.name = self.__class__.__name__
         if self.model is None or self.model_id != self.old_model_id:
-            device_fallback = 'cpu'
+            device_fallback = "cpu"
             device = "cuda" if torch.cuda.is_available() else device_fallback
-            device = to_device if to_device is not None else device_fallback # user preference over auto detection
+            device = (
+                to_device if to_device is not None else device_fallback
+            )  # user preference over auto detection
             try:
                 self.model = whisper.load_model(self.model_id, device=device)
             except RuntimeError:
-                CustomUserWarning(f"Whisper failed to load model on device {device}. Fallback to {device_fallback}.")
+                UserMessage(
+                    f"Whisper failed to load model on device {device}. Fallback to {device_fallback}."
+                )
                 self.model = whisper.load_model(self.model_id, device=device_fallback)
             self.old_model_id = self.model_id
 
         self._try_compile()
 
     def id(self) -> str:
-        if self.config['SPEECH_TO_TEXT_ENGINE_MODEL']:
+        if self.config["SPEECH_TO_TEXT_ENGINE_MODEL"]:
             if whisper is None:
-                CustomUserWarning("Whisper is not installed. Please install it with `pip install symbolicai[whisper]`", raise_with=ImportError)
-            return 'speech-to-text'
-        return super().id() # default to unregistered
+                UserMessage(
+                    "Whisper is not installed. Please install it with `pip install symbolicai[whisper]`",
+                    raise_with=ImportError,
+                )
+            return "speech-to-text"
+        return super().id()  # default to unregistered
 
     def command(self, *args, **kwargs):
         super().command(*args, **kwargs)
-        if 'SPEECH_TO_TEXT_ENGINE_MODEL' in kwargs:
-            self.model_id = kwargs['SPEECH_TO_TEXT_ENGINE_MODEL']
+        if "SPEECH_TO_TEXT_ENGINE_MODEL" in kwargs:
+            self.model_id = kwargs["SPEECH_TO_TEXT_ENGINE_MODEL"]
 
     def forward(self, argument):
         assert whisper is not None, "Whisper is not installed. Please install it first."
@@ -145,16 +151,17 @@ class WhisperEngine(Engine):
         without_timestamps = kwargs.get("without_timestamps", False)
 
         raw_result = []
-        if prompt == 'detect_language':
-            #@NOTE: the accuracy of mel spectrogram is not good enough; don't use it to transcribe
+        if prompt == "detect_language":
+            # @NOTE: the accuracy of mel spectrogram is not good enough; don't use it to transcribe
             audio = whisper.pad_or_trim(audio)
             mel = whisper.log_mel_spectrogram(audio).to(self.model.device)
             _, probs = self.model.detect_language(mel)
             rsp = max(probs, key=probs.get)
-        elif prompt == 'decode':
+        elif prompt == "decode":
             if show_pbar:
-                # supress tqdm warning
-                from tqdm import tqdm
+                # Suppress tqdm warning; keep optional dependency lazy.
+                from tqdm import tqdm  # noqa
+
                 pbar = tqdm(self._get_chunks(audio))
             else:
                 pbar = self._get_chunks(audio)
@@ -168,11 +175,9 @@ class WhisperEngine(Engine):
                 )
                 raw_result.append(result)
                 self.text.append(result["text"])
-                self.tokens.append([
-                    token
-                    for segment in result["segments"]
-                    for token in segment["tokens"]
-                ])
+                self.tokens.append(
+                    [token for segment in result["segments"] for token in segment["tokens"]]
+                )
             if without_timestamps is not None:
                 tokenizer = get_tokenizer(self.model.is_multilingual)
                 tokens = [tokenizer.decode_with_timestamps(t) for t in self.tokens]
@@ -180,7 +185,7 @@ class WhisperEngine(Engine):
             else:
                 rsp = " ".join(self.text)
         else:
-            CustomUserWarning(f"Unknown whisper command prompt: {prompt}", raise_with=ValueError)
+            UserMessage(f"Unknown whisper command prompt: {prompt}", raise_with=ValueError)
 
         metadata = {}
         rsp = WhisperResult(rsp)
@@ -191,7 +196,7 @@ class WhisperEngine(Engine):
     def prepare(self, argument):
         assert not argument.prop.processed_input, "Whisper does not support processed_input."
         assert argument.prop.audio, "Whisper requires audio input."
-        audio_file  = str(argument.prop.audio)
+        audio_file = str(argument.prop.audio)
         audio = whisper.load_audio(audio_file)
         argument.prop.prepared_input = (audio_file, audio)
 
@@ -201,10 +206,8 @@ class WhisperEngine(Engine):
         """
         size = len(it)
         for i in range(0, size, batch):
-            yield torch.tensor(it[i:min(i + batch, size)]).to(self.model.device)
+            yield torch.tensor(it[i : min(i + batch, size)]).to(self.model.device)
 
     def _try_compile(self):
-        try:
+        with contextlib.suppress(Exception):
             self.model = torch.compile(self.model)
-        except Exception:
-            pass

symai/backend/engines/symbolic/engine_wolframalpha.py

@@ -1,14 +1,17 @@
 from copy import deepcopy
 
 from ....symbol import Result
-from ....utils import CustomUserWarning
+from ....utils import UserMessage
 from ...base import Engine
 from ...settings import SYMAI_CONFIG
 
 try:
     import wolframalpha as wa
 except ImportError:
-    CustomUserWarning("WolframAlpha is not installed. Please install it with `pip install symbolicai[wolframalpha]`", raise_with=ImportError)
+    UserMessage(
+        "WolframAlpha is not installed. Please install it with `pip install symbolicai[wolframalpha]`",
+        raise_with=ImportError,
+    )
 
 
 class WolframResult(Result):
@@ -22,19 +25,19 @@ class WolframAlphaEngine(Engine):
     def __init__(self, api_key: str | None = None):
         super().__init__()
         self.config = deepcopy(SYMAI_CONFIG)
-        self.api_key = self.config['SYMBOLIC_ENGINE_API_KEY'] if api_key is None else api_key
+        self.api_key = self.config["SYMBOLIC_ENGINE_API_KEY"] if api_key is None else api_key
         self.client = wa.Client(self.api_key)
         self.name = self.__class__.__name__
 
     def id(self) -> str:
-        if self.config['SYMBOLIC_ENGINE_API_KEY']:
-            return 'symbolic'
-        return super().id() # default to unregistered
+        if self.config["SYMBOLIC_ENGINE_API_KEY"]:
+            return "symbolic"
+        return super().id()  # default to unregistered
 
     def command(self, *args, **kwargs):
         super().command(*args, **kwargs)
-        if 'SYMBOLIC_ENGINE_API_KEY' in kwargs:
-            self.api_key = kwargs['SYMBOLIC_ENGINE_API_KEY']
+        if "SYMBOLIC_ENGINE_API_KEY" in kwargs:
+            self.api_key = kwargs["SYMBOLIC_ENGINE_API_KEY"]
             self.client = wa.Client(self.api_key)
 
     def forward(self, argument):
@@ -45,7 +48,10 @@ class WolframAlphaEngine(Engine):
             rsp = self.client.query(queries)
             rsp = WolframResult(rsp)
         except Exception as e:
-            CustomUserWarning(f'Failed to interact with WolframAlpha: {e}.\n\n If you are getting an error related to "assert", that is a well-known issue with WolframAlpha. There is a manual fix for this issue: https://github.com/jaraco/wolframalpha/pull/34/commits/6eb3828ee812f65592e00629710fc027d40e7bd1', raise_with=ValueError)
+            UserMessage(
+                f'Failed to interact with WolframAlpha: {e}.\n\n If you are getting an error related to "assert", that is a well-known issue with WolframAlpha. There is a manual fix for this issue: https://github.com/jaraco/wolframalpha/pull/34/commits/6eb3828ee812f65592e00629710fc027d40e7bd1',
+                raise_with=ValueError,
+            )
 
         metadata = {}
 

symai/backend/engines/text_to_speech/engine_openai.py

@@ -1,48 +1,42 @@
 import logging
 
 from openai import OpenAI
-from typing import Optional
-
-# suppress openai logging
-logging.getLogger("openai").setLevel(logging.WARNING)
 
+from ....symbol import Result
 from ...base import Engine
 from ...settings import SYMAI_CONFIG
-from ....symbol import Result
+
+# suppress openai logging
+logging.getLogger("openai").setLevel(logging.WARNING)
 
 
 class TTSEngine(Engine):
-    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 = SYMAI_CONFIG
-        self.api_key = self.config['TEXT_TO_SPEECH_ENGINE_API_KEY'] if api_key is None else api_key
-        self.model_id = self.config['TEXT_TO_SPEECH_ENGINE_MODEL'] if model is None else model
+        self.api_key = self.config["TEXT_TO_SPEECH_ENGINE_API_KEY"] if api_key is None else api_key
+        self.model_id = self.config["TEXT_TO_SPEECH_ENGINE_MODEL"] if model is None else model
         self.tokens = []
         self.text = []
         self.client = OpenAI(api_key=self.api_key)
         self.name = self.__class__.__name__
 
     def id(self) -> str:
-        if self.config['TEXT_TO_SPEECH_ENGINE_API_KEY']:
-            return 'text-to-speech'
-        return super().id() # default to unregistered
+        if self.config["TEXT_TO_SPEECH_ENGINE_API_KEY"]:
+            return "text-to-speech"
+        return super().id()  # default to unregistered
 
     def command(self, *args, **kwargs):
         super().command(*args, **kwargs)
-        if 'TEXT_TO_SPEECH_ENGINE_API_KEY' in kwargs:
-            self.api_key = kwargs['TEXT_TO_SPEECH_ENGINE_API_KEY']
-        if 'TEXT_TO_SPEECH_ENGINE_MODEL' in kwargs:
-            self.model_id = kwargs['TEXT_TO_SPEECH_ENGINE_MODEL']
+        if "TEXT_TO_SPEECH_ENGINE_API_KEY" in kwargs:
+            self.api_key = kwargs["TEXT_TO_SPEECH_ENGINE_API_KEY"]
+        if "TEXT_TO_SPEECH_ENGINE_MODEL" in kwargs:
+            self.model_id = kwargs["TEXT_TO_SPEECH_ENGINE_MODEL"]
 
     def forward(self, argument):
-        kwargs              = argument.kwargs
         voice, path, prompt = argument.prop.prepared_input
 
-        rsp = self.client.audio.speech.create(
-            model=self.model_id,
-            voice=voice,
-            input=prompt
-        )
+        rsp = self.client.audio.speech.create(model=self.model_id, voice=voice, input=prompt)
 
         metadata = {}
 
@@ -53,9 +47,9 @@ class TTSEngine(Engine):
 
     def prepare(self, argument):
         assert not argument.prop.processed_input, "TTSEngine does not support processed_input."
-        assert 'voice' in argument.kwargs, "TTS requires voice selection."
-        assert 'path' in argument.kwargs, "TTS requires path selection."
-        voice       = str(argument.kwargs['voice']).lower()
-        audio_file  = str(argument.kwargs['path'])
-        prompt      = str(argument.prop.prompt)
+        assert "voice" in argument.kwargs, "TTS requires voice selection."
+        assert "path" in argument.kwargs, "TTS requires path selection."
+        voice = str(argument.kwargs["voice"]).lower()
+        audio_file = str(argument.kwargs["path"])
+        prompt = str(argument.prop.prompt)
         argument.prop.prepared_input = (voice, audio_file, prompt)