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

symai/__init__.py

@@ -13,7 +13,7 @@ from rich.tree import Tree
 from .backend import settings
 from .menu.screen import show_intro_menu
 from .misc.console import ConsoleStyle
-from .utils import CustomUserWarning
+from .utils import UserMessage
 
 # do not remove - hides the libraries' debug messages
 logging.getLogger("urllib3").setLevel(logging.WARNING)
@@ -33,23 +33,19 @@ os.environ['TOKENIZERS_PARALLELISM'] = "false"
 # Create singleton instance
 config_manager = settings.SymAIConfig()
 
-SYMAI_VERSION = "0.21.0"
+SYMAI_VERSION = "1.0.0"
 __version__   = SYMAI_VERSION
 __root_dir__  = config_manager.config_dir
 
 def _start_symai():
-    global _symai_config_
-    global _symsh_config_
-    global _symserver_config_
-
     # Create config directories if they don't exist
-    os.makedirs(config_manager._env_config_dir, exist_ok=True)
-    os.makedirs(config_manager._home_config_dir, exist_ok=True)
+    config_manager._env_config_dir.mkdir(parents=True, exist_ok=True)
+    config_manager._home_config_dir.mkdir(parents=True, exist_ok=True)
 
     # CREATE THE SHELL CONFIGURATION FILE IF IT DOES NOT EXIST YET
     # *==============================================================================================================*
     _symsh_config_path_ = config_manager.get_config_path('symsh.config.json')
-    if not os.path.exists(_symsh_config_path_):
+    if not _symsh_config_path_.exists():
         config_manager.save_config('symsh.config.json', {
             "colors": {
                 "completion-menu.completion.current": "bg:#323232 #212121",
@@ -71,23 +67,23 @@ def _start_symai():
     # CREATE A SERVER CONFIGURATION FILE IF IT DOES NOT EXIST YET
     # *==============================================================================================================*
     _symserver_config_path_ = config_manager.get_config_path('symserver.config.json')
-    if not os.path.exists(_symserver_config_path_):
+    if not _symserver_config_path_.exists():
         config_manager.save_config('symserver.config.json', {})
 
     # Get appropriate config path (debug mode handling is now in config_manager)
     _symai_config_path_ = config_manager.get_config_path('symai.config.json')
 
-    if not os.path.exists(_symai_config_path_):
+    if not _symai_config_path_.exists():
         setup_wizard(_symai_config_path_)
-        CustomUserWarning(f'No configuration file found for the environment. A new configuration file has been created at {_symai_config_path_}. Please configure your environment.')
+        UserMessage(f'No configuration file found for the environment. A new configuration file has been created at {_symai_config_path_}. Please configure your environment.')
         sys.exit(1)
 
     # Load and manage configurations
-    _symai_config_ = config_manager.load_config('symai.config.json')
+    symai_config = config_manager.load_config('symai.config.json')
 
     # MIGRATE THE ENVIRONMENT VARIABLES
     # *==========================================================================================================*
-    if 'COLLECTION_URI' not in _symai_config_:
+    if 'COLLECTION_URI' not in symai_config:
         updates = {
             'COLLECTION_URI': "mongodb+srv://User:vt3epocXitd6WlQ6@extensityai.c1ajxxy.mongodb.net/?retryWrites=true&w=majority",
             'COLLECTION_DB': "ExtensityAI",
@@ -101,57 +97,59 @@ def _start_symai():
 
     # POST-MIGRATION CHECKS
     # *==============================================================================================================*
-    if 'TEXT_TO_SPEECH_ENGINE_API_KEY' not in _symai_config_:
+    if 'TEXT_TO_SPEECH_ENGINE_API_KEY' not in symai_config:
         updates = {
-            'TEXT_TO_SPEECH_ENGINE_API_KEY': _symai_config_.get('NEUROSYMBOLIC_ENGINE_API_KEY', '')
+            'TEXT_TO_SPEECH_ENGINE_API_KEY': symai_config.get('NEUROSYMBOLIC_ENGINE_API_KEY', '')
         }
         config_manager.migrate_config('symai.config.json', updates)
 
     # Load all configurations
-    _symai_config_ = config_manager.load_config('symai.config.json')
-    _symsh_config_ = config_manager.load_config('symsh.config.json')
-    _symserver_config_ = config_manager.load_config('symserver.config.json')
+    symai_config = config_manager.load_config('symai.config.json')
+    symsh_config = config_manager.load_config('symsh.config.json')
+    symserver_config = config_manager.load_config('symserver.config.json')
 
     # MIGRATE THE SHELL SPLASH SCREEN CONFIGURATION
     # *==============================================================================================================*
-    if 'show-splash-screen' not in _symsh_config_:
+    if 'show-splash-screen' not in symsh_config:
         config_manager.migrate_config('symsh.config.json', {'show-splash-screen': True})
 
     # CHECK IF THE USER HAS A NEUROSYMBOLIC API KEY
     # *==============================================================================================================*
     if not (
-        _symai_config_['NEUROSYMBOLIC_ENGINE_MODEL'].lower().startswith('llama') or \
-        _symai_config_['NEUROSYMBOLIC_ENGINE_MODEL'].lower().startswith('huggingface')) \
+        symai_config['NEUROSYMBOLIC_ENGINE_MODEL'].lower().startswith('llama') or \
+        symai_config['NEUROSYMBOLIC_ENGINE_MODEL'].lower().startswith('huggingface')) \
         and \
             (
-            _symai_config_['NEUROSYMBOLIC_ENGINE_API_KEY'] is None or \
-            len(_symai_config_['NEUROSYMBOLIC_ENGINE_API_KEY']) == 0):
+            symai_config['NEUROSYMBOLIC_ENGINE_API_KEY'] is None or \
+            len(symai_config['NEUROSYMBOLIC_ENGINE_API_KEY']) == 0):
             # Try to fallback to the global (home) config if environment is not home
             if config_manager.config_dir != config_manager._home_config_dir:
                 show_intro_menu()
-                CustomUserWarning(f"You didn't configure your environment ({config_manager.config_dir})! Falling back to the global ({config_manager._home_config_dir}) configuration if it exists.")
+                UserMessage(f"You didn't configure your environment ({config_manager.config_dir})! Falling back to the global ({config_manager._home_config_dir}) configuration if it exists.")
                 # Force loading from home
-                _symai_config_ = config_manager.load_config('symai.config.json', fallback_to_home=True)
-                _symsh_config_ = config_manager.load_config('symsh.config.json', fallback_to_home=True)
-                _symserver_config_ = config_manager.load_config('symserver.config.json', fallback_to_home=True)
+                symai_config = config_manager.load_config('symai.config.json', fallback_to_home=True)
+                symsh_config = config_manager.load_config('symsh.config.json', fallback_to_home=True)
+                symserver_config = config_manager.load_config('symserver.config.json', fallback_to_home=True)
 
             # If still not valid, warn and exit
-            if not _symai_config_.get('NEUROSYMBOLIC_ENGINE_API_KEY'):
-                CustomUserWarning('The mandatory neuro-symbolic engine is not initialized. Please set NEUROSYMBOLIC_ENGINE_MODEL and NEUROSYMBOLIC_ENGINE_API_KEY.')
+            if not symai_config.get('NEUROSYMBOLIC_ENGINE_API_KEY'):
+                UserMessage('The mandatory neuro-symbolic engine is not initialized. Please set NEUROSYMBOLIC_ENGINE_MODEL and NEUROSYMBOLIC_ENGINE_API_KEY.')
                 sys.exit(1)
 
-    settings.SYMAI_CONFIG = _symai_config_
-    settings.SYMSH_CONFIG = _symsh_config_
-    settings.SYMSERVER_CONFIG = _symserver_config_
+    settings.SYMAI_CONFIG = symai_config
+    settings.SYMSH_CONFIG = symsh_config
+    settings.SYMSERVER_CONFIG = symserver_config
+    return symai_config, symsh_config, symserver_config
 
 
 def run_server():
     _symserver_config_ = {}
     if settings.SYMAI_CONFIG.get("NEUROSYMBOLIC_ENGINE_MODEL").startswith("llama") or settings.SYMAI_CONFIG.get("EMBEDDING_ENGINE_MODEL").startswith("llama"):
-        from .server.llama_cpp_server import llama_cpp_server
+        # Keep optional llama_cpp dependencies lazy.
+        from .server.llama_cpp_server import llama_cpp_server # noqa
 
         command, args = llama_cpp_server()
-        _symserver_config_.update(zip(args[::2], args[1::2]))
+        _symserver_config_.update(zip(args[::2], args[1::2], strict=False))
         _symserver_config_['online'] = True
 
         config_manager.save_config("symserver.config.json", _symserver_config_)
@@ -161,14 +159,15 @@ def run_server():
         try:
             subprocess.run(command, check=True)
         except KeyboardInterrupt:
-            print("Server stopped!")
+            UserMessage("Server stopped!")
         except Exception as e:
-            print(f"Error running server: {e}")
+            UserMessage(f"Error running server: {e}")
         finally:
             config_manager.save_config("symserver.config.json", {'online': False})
 
     elif settings.SYMAI_CONFIG.get("NEUROSYMBOLIC_ENGINE_MODEL").startswith("huggingface"):
-        from .server.huggingface_server import huggingface_server
+        # HuggingFace server stack is optional; import only when requested.
+        from .server.huggingface_server import huggingface_server # noqa
 
         command, args = huggingface_server()
         _symserver_config_.update(vars(args))
@@ -179,13 +178,17 @@ def run_server():
         try:
             command(host=args.host, port=args.port)
         except KeyboardInterrupt:
-            print("Server stopped!")
+            UserMessage("Server stopped!")
         except Exception as e:
-            print(f"Error running server: {e}")
+            UserMessage(f"Error running server: {e}")
         finally:
             config_manager.save_config("symserver.config.json", {'online': False})
     else:
-        raise CustomUserWarning("You're trying to run a local server without a valid neuro-symbolic engine model. Please set a valid model in your configuration file. Current available options are 'llamacpp' and 'huggingface'.")
+        msg = (
+            "You're trying to run a local server without a valid neuro-symbolic engine model. "
+            "Please set a valid model in your configuration file. Current available options are 'llamacpp' and 'huggingface'."
+        )
+        UserMessage(msg, raise_with=ValueError)
 
 
 # *==============================================================================================================*
@@ -218,7 +221,7 @@ def display_config():
     debug_branch = tree.add("[yellow]Debug Mode Config (CWD)[/yellow]")
     debug_config = config_manager._debug_dir / 'symai.config.json'
     if debug_config.exists():
-        with open(debug_config) as f:
+        with debug_config.open() as f:
             content = json.load(f)
         debug_branch.add(f"📄 [green]{debug_config}[/green]\n{format_config_content(content)}")
     else:
@@ -235,7 +238,7 @@ def display_config():
     for config_file, icon in env_configs.items():
         config_path = config_manager._env_config_dir / config_file
         if config_path.exists():
-            with open(config_path) as f:
+            with config_path.open() as f:
                 content = json.load(f)
             env_branch.add(f"{icon} [green]{config_path}[/green]\n{format_config_content(content)}")
         else:
@@ -246,7 +249,7 @@ def display_config():
     for config_file, icon in env_configs.items():
         config_path = config_manager._home_config_dir / config_file
         if config_path.exists():
-            with open(config_path) as f:
+            with config_path.open() as f:
                 content = json.load(f)
             home_branch.add(f"{icon} [green]{config_path}[/green]\n{format_config_content(content)}")
         else:
@@ -258,10 +261,10 @@ def display_config():
     summary.add_column("Active Path")
 
     active_paths = {
-        "Primary Config Dir": config_manager.config_dir,
-        "symai.config.json": config_manager.get_config_path('symai.config.json'),
-        "symsh.config.json": config_manager.get_config_path('symsh.config.json'),
-        "symserver.config.json": config_manager.get_config_path('symserver.config.json')
+        "Primary Config Dir": config_manager.get_active_config_dir(),
+        "symai.config.json": config_manager.get_active_path('symai.config.json'),
+        "symsh.config.json": config_manager.get_active_path('symsh.config.json'),
+        "symserver.config.json": config_manager.get_active_path('symserver.config.json')
     }
 
     for config_type, path in active_paths.items():
@@ -333,19 +336,48 @@ def setup_wizard(_symai_config_path_):
         "SUPPORT_COMMUNITY":              _support_comminity
     })
 
-
-_start_symai()
-
-from .backend.base import Engine
-from .components import Function, PrimitiveDisabler
-from .core import few_shot, zero_shot
-from .extended import Conversation
-from .functional import EngineRepository
-from .imports import Import
-from .interfaces import Interface
-from .post_processors import PostProcessor
-from .pre_processors import PreProcessor
-from .prompts import Prompt, PromptLanguage, PromptRegistry
-from .shell import Shell
-from .strategy import Strategy
-from .symbol import Call, Expression, GlobalSymbolPrimitive, Metadata, Symbol
+_symai_config_, _symsh_config_, _symserver_config_ = _start_symai()
+
+from .backend.base import Engine # noqa
+from .components import Function, PrimitiveDisabler  # noqa
+from .core import few_shot, zero_shot  # noqa
+from .extended import Conversation  # noqa
+from .functional import EngineRepository  # noqa
+from .imports import Import  # noqa
+from .interfaces import Interface  # noqa
+from .post_processors import PostProcessor  # noqa
+from .pre_processors import PreProcessor  # noqa
+from .prompts import Prompt, PromptLanguage, PromptRegistry  # noqa
+from .shell import Shell  # noqa
+from .strategy import Strategy  # noqa
+from .symbol import Call, Expression, GlobalSymbolPrimitive, Metadata, Symbol  # noqa
+
+__all__ = [
+    "SYMAI_VERSION",
+    "Call",
+    "Conversation",
+    "Engine",
+    "EngineRepository",
+    "Expression",
+    "Function",
+    "GlobalSymbolPrimitive",
+    "Import",
+    "Interface",
+    "Metadata",
+    "PostProcessor",
+    "PreProcessor",
+    "PrimitiveDisabler",
+    "Prompt",
+    "PromptLanguage",
+    "PromptRegistry",
+    "Shell",
+    "Strategy",
+    "Symbol",
+    "__root_dir__",
+    "__version__",
+    "config_manager",
+    "few_shot",
+    "run_server",
+    "setup_wizard",
+    "zero_shot",
+]

symai/backend/base.py

@@ -1,16 +1,23 @@
 import logging
-import os
 import time
-
-from abc import ABC
-from typing import Any, List, Tuple
-from .settings import HOME_PATH
+from abc import ABC, abstractmethod
+from typing import Any
 
 from ..collect import CollectionRepository, rec_serialize
-
+from ..utils import UserMessage
+from .settings import HOME_PATH
 
 ENGINE_UNREGISTERED = '<UNREGISTERED/>'
 
+COLLECTION_LOGGING_ENGINES = {
+    'GPTXChatEngine',
+    'GPTXCompletionEngine',
+    'SerpApiEngine',
+    'WolframAlphaEngine',
+    'SeleniumEngine',
+    'OCREngine',
+}
+
 class Engine(ABC):
     def __init__(self) -> None:
         super().__init__()
@@ -22,7 +29,7 @@ class Engine(ABC):
         self.collection.connect()
         # create formatter
         __root_dir__  = HOME_PATH
-        os.makedirs(__root_dir__, exist_ok=True)
+        __root_dir__.mkdir(parents=True, exist_ok=True)
         __file_path__ = __root_dir__ / "engine.log"
         logging.basicConfig(filename=__file_path__, filemode="a", format='%(asctime)s %(name)s %(levelname)s %(message)s')
         self.logger     = logging.getLogger()
@@ -34,7 +41,7 @@ class Engine(ABC):
         stream.setFormatter(streamformat)
         self.logger.addHandler(stream)
 
-    def __call__(self, argument: Any) -> Tuple[List[str], dict]:
+    def __call__(self, argument: Any) -> tuple[list[str], dict]:
         log = {
             'Input': {
                 'self': self,
@@ -44,64 +51,67 @@ class Engine(ABC):
         }
         start_time = time.time()
 
-        # check for global object based input handler
-        if hasattr(argument.prop.instance, '_metadata') and hasattr(argument.prop.instance._metadata, 'input_handler'):
-            input_handler = argument.prop.instance._metadata.input_handler if hasattr(argument.prop.instance._metadata, 'input_handler') else None
-            if input_handler is not None:
-                input_handler((argument.prop.processed_input, argument))
-        # check for kwargs based input handler
-        if argument.prop.input_handler is not None:
-            argument.prop.input_handler((argument.prop.processed_input, argument))
+        self._trigger_input_handlers(argument)
 
-        # execute the engine
         res, metadata = self.forward(argument)
 
-        # compute time
         req_time = time.time() - start_time
         metadata['time'] = req_time
         if self.time_clock:
-            print(f"{argument.prop.func}: {req_time} sec")
+            UserMessage(f"{argument.prop.func}: {req_time} sec")
         log['Output'] = res
         if self.verbose:
             view   = {k: v for k, v in list(log['Input'].items()) if k != 'self'}
-            input_ = f"{str(log['Input']['self'])[:50]}, {str(argument.prop.func)}, {str(view)}"
-            print(input_[:150], str(log['Output'])[:100])
+            input_ = f"{str(log['Input']['self'])[:50]}, {argument.prop.func!s}, {view!s}"
+            UserMessage(f"{input_[:150]} {str(log['Output'])[:100]}")
         if self.logging:
             self.logger.log(self.log_level, log)
 
-        # share data statistics with the collection repository
-        if     str(self) == 'GPTXChatEngine' \
-            or str(self) == 'GPTXCompletionEngine' \
-            or str(self) == 'SerpApiEngine' \
-            or str(self) == 'WolframAlphaEngine' \
-            or str(self) == 'SeleniumEngine' \
-            or str(self) == 'OCREngine':
-            self.collection.add(
-                forward={'args': rec_serialize(argument.args), 'kwds': rec_serialize(argument.kwargs)},
-                engine=str(self),
-                metadata={
-                    'time': req_time,
-                    'data': rec_serialize(metadata),
-                    'argument': rec_serialize(argument)
-                }
-            )
-
-        # check for global object based output handler
-        if hasattr(argument.prop.instance, '_metadata') and hasattr(argument.prop.instance._metadata, 'output_handler'):
-            output_handler = argument.prop.instance._metadata.output_handler if hasattr(argument.prop.instance._metadata, 'output_handler') else None
-            if output_handler:
-                output_handler(res)
-        # check for kwargs based output handler
-        if argument.prop.output_handler:
-            argument.prop.output_handler((res, metadata))
+        if str(self) in COLLECTION_LOGGING_ENGINES:
+            self._record_collection_entry(argument, metadata, req_time)
+
+        self._trigger_output_handlers(argument, res, metadata)
         return res, metadata
 
+    def _trigger_input_handlers(self, argument: Any) -> None:
+        instance_metadata = getattr(argument.prop.instance, '_metadata', None)
+        if instance_metadata is not None:
+            input_handler = getattr(instance_metadata, 'input_handler', None)
+            if input_handler is not None:
+                input_handler((argument.prop.processed_input, argument))
+        argument_handler = argument.prop.input_handler
+        if argument_handler is not None:
+            argument_handler((argument.prop.processed_input, argument))
+
+    def _trigger_output_handlers(self, argument: Any, result: Any, metadata: dict | None) -> None:
+        instance_metadata = getattr(argument.prop.instance, '_metadata', None)
+        if instance_metadata is not None:
+            output_handler = getattr(instance_metadata, 'output_handler', None)
+            if output_handler:
+                output_handler(result)
+        argument_handler = argument.prop.output_handler
+        if argument_handler:
+            argument_handler((result, metadata))
+
+    def _record_collection_entry(self, argument: Any, metadata: dict, req_time: float) -> None:
+        self.collection.add(
+            forward={'args': rec_serialize(argument.args), 'kwds': rec_serialize(argument.kwargs)},
+            engine=str(self),
+            metadata={
+                'time': req_time,
+                'data': rec_serialize(metadata),
+                'argument': rec_serialize(argument)
+            }
+        )
+
     def id(self) -> str:
         return ENGINE_UNREGISTERED
 
     def preview(self, argument):
-        # used here to avoid circular import
-        from ..symbol import Symbol
+        # Used here to avoid backend.base <-> symbol circular import.
+        from ..symbol import ( # noqa
+            Symbol,
+        )
         class Preview(Symbol):
             def __repr__(self) -> str:
                 '''
@@ -117,20 +127,22 @@ class Engine(ABC):
 
         return Preview(argument), {}
 
-    def forward(self, *args: Any, **kwds: Any) -> List[str]:
-        raise NotADirectoryError()
+    @abstractmethod
+    def forward(self, *args: Any, **kwds: Any) -> list[str]:
+        raise NotADirectoryError
 
+    @abstractmethod
     def prepare(self, argument):
-        raise NotImplementedError()
+        raise NotImplementedError
 
-    def command(self, *args, **kwargs):
-        if kwargs.get('verbose', None):
+    def command(self, *_args, **kwargs):
+        if kwargs.get('verbose'):
             self.verbose = kwargs['verbose']
-        if kwargs.get('logging', None):
+        if kwargs.get('logging'):
             self.logging = kwargs['logging']
-        if kwargs.get('log_level', None):
+        if kwargs.get('log_level'):
             self.log_level = kwargs['log_level']
-        if kwargs.get('time_clock', None):
+        if kwargs.get('time_clock'):
             self.time_clock = kwargs['time_clock']
 
     def __str__(self) -> str:
@@ -155,41 +167,42 @@ class BatchEngine(Engine):
         self.time_clock = True
         self.allows_batching = True
 
-    def __call__(self, arguments: List[Any]) -> List[Tuple[Any, dict]]:
+    def __call__(self, arguments: list[Any]) -> list[tuple[Any, dict]]:
         start_time = time.time()
         for arg in arguments:
-            if hasattr(arg.prop.instance, '_metadata') and hasattr(arg.prop.instance._metadata, 'input_handler'):
-                input_handler = getattr(arg.prop.instance._metadata, 'input_handler', None)
-                if input_handler is not None:
-                    input_handler((arg.prop.processed_input, arg))
-            if arg.prop.input_handler is not None:
-                arg.prop.input_handler((arg.prop.processed_input, arg))
+            self._trigger_input_handlers(arg)
 
-        try:
-            results, metadata_list = self.forward(arguments)
-        except Exception as e:
-            results = [e] * len(arguments)
-            metadata_list = [None] * len(arguments)
+        results, metadata_list = self._execute_batch(arguments)
 
         total_time = time.time() - start_time
         if self.time_clock:
-            print(f"Total execution time: {total_time} sec")
+            UserMessage(f"Total execution time: {total_time} sec")
 
-        return_list = []
+        return self._prepare_batch_results(arguments, results, metadata_list, total_time)
 
-        for arg, result, metadata in zip(arguments, results, metadata_list):
+    def _execute_batch(self, arguments: list[Any]) -> tuple[list[Any], list[dict | None]]:
+        try:
+            return self.forward(arguments)
+        except Exception as error:
+            return [error] * len(arguments), [None] * len(arguments)
+
+    def _prepare_batch_results(
+        self,
+        arguments: list[Any],
+        results: list[Any],
+        metadata_list: list[dict | None],
+        total_time: float,
+    ) -> list[tuple[Any, dict | None]]:
+        return_list = []
+        for arg, result, metadata in zip(arguments, results, metadata_list, strict=False):
             if metadata is not None:
                 metadata['time'] = total_time / len(arguments)
 
-            if hasattr(arg.prop.instance, '_metadata') and hasattr(arg.prop.instance._metadata, 'output_handler'):
-                output_handler = getattr(arg.prop.instance._metadata, 'output_handler', None)
-                if output_handler:
-                    output_handler(result)
-            if arg.prop.output_handler:
-                arg.prop.output_handler((result, metadata))
-
+            self._trigger_output_handlers(arg, result, metadata)
             return_list.append((result, metadata))
         return return_list
 
-    def forward(self, arguments: List[Any]) -> Tuple[List[Any], List[dict]]:
-        raise NotImplementedError("Subclasses must implement forward method")
+    def forward(self, _arguments: list[Any]) -> tuple[list[Any], list[dict]]:
+        msg = "Subclasses must implement forward method"
+        UserMessage(msg)
+        raise NotImplementedError(msg)

symai/backend/engines/drawing/engine_bfl.py

@@ -1,11 +1,12 @@
 import logging
 import tempfile
 import time
-from typing import Optional
+from pathlib import Path
 
 import requests
 
 from ....symbol import Result
+from ....utils import UserMessage
 from ...base import Engine
 from ...settings import SYMAI_CONFIG
 
@@ -19,17 +20,18 @@ class FluxResult(Result):
     def __init__(self, value, **kwargs):
         super().__init__(value, **kwargs)
         # unpack the result
-        path = tempfile.NamedTemporaryFile(suffix=".png", delete=False).name
+        with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as tmp_file:
+            path = tmp_file.name
         url = value.get('result').get('sample')
         request = requests.get(url, allow_redirects=True)
         request.raise_for_status()
-        with open(path, "wb") as f:
+        with Path(path).open("wb") as f:
             f.write(request.content)
         self._value = [path]
 
 
 class DrawingEngine(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['DRAWING_ENGINE_API_KEY'] if api_key is None else api_key
@@ -51,16 +53,12 @@ class DrawingEngine(Engine):
     def forward(self, argument):
         prompt = argument.prop.prepared_input
         kwargs = argument.kwargs
-        model = kwargs.get('model', self.model)
         width = kwargs.get('width', 1024)
         height = kwargs.get('height', 768)
         steps = kwargs.get('steps', 40)
-        prompt_upsampling = kwargs.get('prompt_upsampling', False)
         seed = kwargs.get('seed', None)
         guidance = kwargs.get('guidance', None)
         safety_tolerance = kwargs.get('safety_tolerance', 2)
-        interval = kwargs.get('interval', None)
-        output_format = kwargs.get('output_format', 'png')
         except_remedy = kwargs.get('except_remedy', None)
 
         headers = {
@@ -93,7 +91,10 @@ class DrawingEngine(Engine):
                 data = response.json()
                 request_id = data.get("id")
                 if not request_id:
-                    raise Exception(f"Failed to get request ID! Response payload: {data}")
+                    UserMessage(
+                        f"Failed to get request ID! Response payload: {data}",
+                        raise_with=Exception,
+                    )
 
                 while True:
                     time.sleep(5)
@@ -118,8 +119,8 @@ class DrawingEngine(Engine):
 
             metadata = {}
             return [rsp], metadata
-        else:
-            raise Exception(f"Unknown operation: {kwargs['operation']}")
+        UserMessage(f"Unknown operation: {kwargs['operation']}", raise_with=Exception)
+        return [], {}
 
     def prepare(self, argument):
         argument.prop.prepared_input = str(argument.prop.processed_input)