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

symai/backend/engines/search/engine_perplexity.py

@@ -17,10 +17,10 @@ logging.getLogger("httpcore").setLevel(logging.ERROR)
 class SearchResult(Result):
     def __init__(self, value, **kwargs) -> None:
         super().__init__(value, **kwargs)
-        if value.get('error'):
-            UserMessage(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
             UserMessage(f"Failed to parse response: {e}", raise_with=ValueError)
@@ -42,73 +42,72 @@ 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:
             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

@@ -16,21 +16,21 @@ except ImportError:
 class SearchResult(Result):
     def __init__(self, value, **kwargs) -> None:
         super().__init__(value, **kwargs)
-        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']
+        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:
-            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:
@@ -48,30 +48,35 @@ 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:
-                UserMessage('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.get('engine', self.engine)
+        rsp = []
+        engine = kwargs.get("engine", self.engine)
 
         for q in queries_:
             query = {
@@ -80,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(): # disables prints from GoogleSearch
+            with io.capture_output():  # disables prints from GoogleSearch
                 search = GoogleSearch(query)
                 res = search.get_dict()
 
@@ -98,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

@@ -15,7 +15,7 @@ try:
     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
 
 
@@ -36,7 +36,9 @@ class WhisperTimestampsFormatter(Expression):
                     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
@@ -47,7 +49,9 @@ class WhisperTimestampsFormatter(Expression):
                     start += prev_end
                 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]:
@@ -88,7 +92,7 @@ class WhisperResult(Result):
         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)
 
 
@@ -96,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:
-                UserMessage(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:
-                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
+                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."
@@ -140,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:
                 # Suppress tqdm warning; keep optional dependency lazy.
-                from tqdm import tqdm # noqa
+                from tqdm import tqdm  # noqa
+
                 pbar = tqdm(self._get_chunks(audio))
             else:
                 pbar = self._get_chunks(audio)
@@ -163,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]
@@ -186,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)
 
@@ -196,7 +206,7 @@ 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):
         with contextlib.suppress(Exception):

symai/backend/engines/symbolic/engine_wolframalpha.py

@@ -8,7 +8,10 @@ from ...settings import SYMAI_CONFIG
 try:
     import wolframalpha as wa
 except ImportError:
-    UserMessage("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:
-            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)
+            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

@@ -14,33 +14,29 @@ class TTSEngine(Engine):
     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):
         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 = {}
 
@@ -51,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)

symai/backend/engines/text_vision/engine_clip.py

@@ -17,22 +17,22 @@ logging.getLogger("PIL").setLevel(logging.WARNING)
 class CLIPEngine(Engine):
     def __init__(self, model: str | None = None):
         super().__init__()
-        self.model =  None # lazy loading
-        self.preprocessor = None # lazy loading
+        self.model = None  # lazy loading
+        self.preprocessor = None  # lazy loading
         self.config = SYMAI_CONFIG
-        self.model_id = self.config['VISION_ENGINE_MODEL'] if model is None else model
-        self.old_model_id = self.config['VISION_ENGINE_MODEL'] if model is None else model
+        self.model_id = self.config["VISION_ENGINE_MODEL"] if model is None else model
+        self.old_model_id = self.config["VISION_ENGINE_MODEL"] if model is None else model
         self.name = self.__class__.__name__
 
     def id(self) -> str:
-        if self.config['VISION_ENGINE_MODEL']:
-            return 'text_vision'
-        return super().id() # default to unregistered
+        if self.config["VISION_ENGINE_MODEL"]:
+            return "text_vision"
+        return super().id()  # default to unregistered
 
     def command(self, *args, **kwargs):
         super().command(*args, **kwargs)
-        if 'VISION_ENGINE_MODEL' in kwargs:
-            self.model_id     = kwargs['VISION_ENGINE_MODEL']
+        if "VISION_ENGINE_MODEL" in kwargs:
+            self.model_id = kwargs["VISION_ENGINE_MODEL"]
 
     def load_images(self, image):
         images = []
@@ -43,35 +43,41 @@ class CLIPEngine(Engine):
             if isinstance(img, bytes):
                 images.append(Image.open(BytesIO(img)))
             elif isinstance(img, str):
-                image_source = requests.get(img, stream=True).raw if img.startswith('http') else img
+                image_source = requests.get(img, stream=True).raw if img.startswith("http") else img
                 image = Image.open(image_source)
                 images.append(image)
         return images
 
     def forward(self, argument):
-        image_url, text       = argument.prop.prepared_input
+        image_url, text = argument.prop.prepared_input
 
         if self.model is None or self.model_id != self.old_model_id:
-            self.device       = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-            self.model        = CLIPModel.from_pretrained(self.model_id).to(self.device)
-            self.processor    = CLIPProcessor.from_pretrained(self.model_id)
+            self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+            self.model = CLIPModel.from_pretrained(self.model_id).to(self.device)
+            self.processor = CLIPProcessor.from_pretrained(self.model_id)
             self.old_model_id = self.model_id
 
         if text is None and image_url is not None:
-            image             = self.load_images(image_url)
-            inputs            = self.processor(images=image, return_tensors="pt").to(self.device)
-            rsp               = self.model.get_image_features(**inputs)
+            image = self.load_images(image_url)
+            inputs = self.processor(images=image, return_tensors="pt").to(self.device)
+            rsp = self.model.get_image_features(**inputs)
         elif image_url is None and text is not None:
-            inputs            = self.processor(text=text, return_tensors="pt").to(self.device)
-            rsp               = self.model.get_text_features(**inputs)
+            inputs = self.processor(text=text, return_tensors="pt").to(self.device)
+            rsp = self.model.get_text_features(**inputs)
         elif image_url is not None and text is not None:
-            image             = self.load_images(image_url)
-            inputs            = self.processor(text=text, images=image, return_tensors="pt", padding=True).to(self.device)
-            outputs           = self.model(**inputs)
-            logits_per_image  = outputs.logits_per_image  # this is the image-text similarity score
-            rsp               = logits_per_image.softmax(dim=1)  # we can take the softmax to get the label probabilities
+            image = self.load_images(image_url)
+            inputs = self.processor(text=text, images=image, return_tensors="pt", padding=True).to(
+                self.device
+            )
+            outputs = self.model(**inputs)
+            logits_per_image = outputs.logits_per_image  # this is the image-text similarity score
+            rsp = logits_per_image.softmax(
+                dim=1
+            )  # we can take the softmax to get the label probabilities
         else:
-            UserMessage("CLIPEngine requires either image or text input.", raise_with=NotImplementedError)
+            UserMessage(
+                "CLIPEngine requires either image or text input.", raise_with=NotImplementedError
+            )
 
         rsp = rsp.squeeze().detach().cpu().numpy()
 
@@ -81,7 +87,7 @@ class CLIPEngine(Engine):
 
     def prepare(self, argument):
         assert not argument.prop.processed_input, "CLIPEngine does not support processed_input."
-        kwargs     = argument.kwargs
-        image_url  = argument.kwargs['image'] if 'image' in kwargs else None
-        text       = argument.kwargs['text']  if 'text'  in kwargs else None
+        kwargs = argument.kwargs
+        image_url = argument.kwargs["image"] if "image" in kwargs else None
+        text = argument.kwargs["text"] if "text" in kwargs else None
         argument.prop.prepared_input = (image_url, text)

symai/backend/engines/userinput/engine_console.py

@@ -1,4 +1,3 @@
-
 from ....utils import UserMessage
 from ...base import Engine
 
@@ -9,14 +8,14 @@ class UserInputEngine(Engine):
         self.name = self.__class__.__name__
 
     def id(self) -> str:
-        return 'userinput'
+        return "userinput"
 
     def forward(self, argument):
         msg = argument.prop.prepared_input
         kwargs = argument.kwargs
 
-        mock = kwargs.get('mock', False)
-        if mock: # mock user input
+        mock = kwargs.get("mock", False)
+        if mock:  # mock user input
             UserMessage(msg)
             rsp = mock
         else:

symai/backend/mixin/__init__.py

@@ -1,5 +1,7 @@
 from .anthropic import SUPPORTED_CHAT_MODELS as ANTHROPIC_CHAT_MODELS
 from .anthropic import SUPPORTED_REASONING_MODELS as ANTHROPIC_REASONING_MODELS
+from .cerebras import SUPPORTED_CHAT_MODELS as CEREBRAS_CHAT_MODELS
+from .cerebras import SUPPORTED_REASONING_MODELS as CEREBRAS_REASONING_MODELS
 from .deepseek import SUPPORTED_CHAT_MODELS as DEEPSEEK_CHAT_MODELS
 from .deepseek import SUPPORTED_REASONING_MODELS as DEEPSEEK_REASONING_MODELS
 from .google import SUPPORTED_CHAT_MODELS as GOOGLE_CHAT_MODELS
@@ -12,6 +14,8 @@ from .openai import SUPPORTED_REASONING_MODELS as OPENAI_REASONING_MODELS
 __all__ = [
     "ANTHROPIC_CHAT_MODELS",
     "ANTHROPIC_REASONING_MODELS",
+    "CEREBRAS_CHAT_MODELS",
+    "CEREBRAS_REASONING_MODELS",
     "DEEPSEEK_CHAT_MODELS",
     "DEEPSEEK_REASONING_MODELS",
     "GOOGLE_CHAT_MODELS",