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

symai/imports.py

@@ -1,30 +1,31 @@
 import importlib
 import json
 import logging
-import os
 import shutil
 import stat
 import subprocess
 import sys
 from pathlib import Path
-from typing import List, Tuple, Union
 
 from loguru import logger
 
 from .backend.settings import HOME_PATH
 from .symbol import Expression
+from .utils import UserMessage
 
 logging.getLogger("subprocess").setLevel(logging.ERROR)
 
 
-__root_dir__  = HOME_PATH / 'packages'
-BASE_PACKAGE_MODULE = '' # use relative path
-BASE_PACKAGE_PATH = str(__root_dir__)
+__root_dir__ = HOME_PATH / "packages"
+BASE_PACKAGE_MODULE = ""  # use relative path
+BASE_PACKAGE_PATH = __root_dir__
 sys.path.append(str(__root_dir__))
 
 
 class Import(Expression):
-    def __init__(self, module: str, local_path: str | None = None, submodules: bool = False, *args, **kwargs):
+    def __init__(
+        self, module: str, local_path: str | None = None, submodules: bool = False, *args, **kwargs
+    ):
         super(self).__init__(*args, **kwargs)
         self.module = module
         self.local_path = local_path
@@ -33,10 +34,10 @@ class Import(Expression):
     @staticmethod
     def exists(module):
         # Check if module is a local path or a GitHub repo reference
-        if os.path.exists(module) and os.path.isdir(module):
-            return os.path.exists(f'{module}/package.json')
-        else:
-            return os.path.exists(f'{BASE_PACKAGE_PATH}/{module}/package.json')
+        module_path = Path(module)
+        if module_path.exists() and module_path.is_dir():
+            return (module_path / "package.json").exists()
+        return (BASE_PACKAGE_PATH / module / "package.json").exists()
 
     @staticmethod
     def get_from_local(module, local_path):
@@ -47,37 +48,43 @@ class Import(Expression):
             local_path: Path to local package directory
         """
         # If base package does not exist, create it
-        if not os.path.exists(BASE_PACKAGE_PATH):
-            os.makedirs(BASE_PACKAGE_PATH)
+        BASE_PACKAGE_PATH.mkdir(parents=True, exist_ok=True)
 
         # Create module directory
-        module_path = f'{BASE_PACKAGE_PATH}/{module}'
-        os.makedirs(os.path.dirname(module_path), exist_ok=True)
+        module_path = BASE_PACKAGE_PATH / module
+        module_path.parent.mkdir(parents=True, exist_ok=True)
 
         # Copy files from local path to package directory
         try:
-            if os.path.exists(module_path):
+            if module_path.exists():
                 shutil.rmtree(module_path)
             shutil.copytree(local_path, module_path)
             logger.info(f"Copied local package from {local_path} to {module_path}")
 
             # Install dependencies
-            if os.path.exists(f'{module_path}/package.json'):
-                with open(f'{module_path}/package.json') as f:
+            package_json = module_path / "package.json"
+            if package_json.exists():
+                with package_json.open() as f:
                     pkg = json.load(f)
-                    for dependency in pkg.get('dependencies', []):
+                    for dependency in pkg.get("dependencies", []):
                         # Update git_url for the dependency
-                        git_url_dependency = f'git@github.com:{dependency}.git'
-                        if not os.path.exists(f'{BASE_PACKAGE_PATH}/{dependency}'):
-                            subprocess.check_call(['git', 'clone', git_url_dependency, f'{BASE_PACKAGE_PATH}/{dependency}'])
+                        git_url_dependency = f"git@github.com:{dependency}.git"
+                        dependency_path = BASE_PACKAGE_PATH / dependency
+                        if not dependency_path.exists():
+                            subprocess.check_call(
+                                ["git", "clone", git_url_dependency, str(dependency_path)]
+                            )
 
                 # Install requirements
-                if os.path.exists(f'{module_path}/requirements.txt'):
-                    with open(f'{module_path}/requirements.txt') as f:
+                requirements_file = module_path / "requirements.txt"
+                if requirements_file.exists():
+                    with requirements_file.open() as f:
                         for dependency in f.readlines():
-                            dependency = dependency.strip()
-                            if dependency:
-                                subprocess.check_call([sys.executable, '-m', 'pip', 'install', dependency])
+                            dependency_name = dependency.strip()
+                            if dependency_name:
+                                subprocess.check_call(
+                                    [sys.executable, "-m", "pip", "install", dependency_name]
+                                )
         except Exception as e:
             logger.error(f"Error installing from local path: {e}")
             raise
@@ -85,64 +92,66 @@ class Import(Expression):
     @staticmethod
     def get_from_github(module, submodules=False):
         # if base package does not exist, create it
-        if not os.path.exists(BASE_PACKAGE_PATH):
-            os.makedirs(BASE_PACKAGE_PATH)
+        BASE_PACKAGE_PATH.mkdir(parents=True, exist_ok=True)
 
         # Clone repository
-        git_url = f'git@github.com:{module}.git'
-        clone_cmd = ['git', 'clone']
+        git_url = f"git@github.com:{module}.git"
+        clone_cmd = ["git", "clone"]
         if submodules:
-            clone_cmd.extend(['--recurse-submodules'])
-        clone_cmd.extend([git_url, f'{BASE_PACKAGE_PATH}/{module}'])
+            clone_cmd.extend(["--recurse-submodules"])
+        clone_cmd.extend([git_url, str(BASE_PACKAGE_PATH / module)])
         subprocess.check_call(clone_cmd)
 
         # Install dependencies
-        with open(f'{BASE_PACKAGE_PATH}/{module}/package.json') as f:
+        package_json = BASE_PACKAGE_PATH / module / "package.json"
+        with package_json.open() as f:
             pkg = json.load(f)
-            for dependency in pkg['dependencies']:
+            for dependency in pkg["dependencies"]:
                 # Update git_url for the dependency
-                git_url_dependency = f'git@github.com:{dependency}.git'
-                if not os.path.exists(f'{BASE_PACKAGE_PATH}/{dependency}'):
-                    subprocess.check_call(['git', 'clone', git_url_dependency, f'{BASE_PACKAGE_PATH}/{dependency}'])
+                git_url_dependency = f"git@github.com:{dependency}.git"
+                dependency_path = BASE_PACKAGE_PATH / dependency
+                if not dependency_path.exists():
+                    subprocess.check_call(
+                        ["git", "clone", git_url_dependency, str(dependency_path)]
+                    )
 
         # Install requirements
-        if os.path.exists(f'{BASE_PACKAGE_PATH}/{module}/requirements.txt'):
-            with open(f'{BASE_PACKAGE_PATH}/{module}/requirements.txt') as f:
+        requirements_file = BASE_PACKAGE_PATH / module / "requirements.txt"
+        if requirements_file.exists():
+            with requirements_file.open() as f:
                 for dependency in f.readlines():
-                    subprocess.check_call(['pip', 'install', dependency])
+                    subprocess.check_call(["pip", "install", dependency])
 
     @staticmethod
     def load_module_class(module):
         module_classes = []
         # Detect if module is a local path
-        is_local_path = os.path.exists(module) and os.path.isdir(module)
+        module_path_obj = Path(module)
+        is_local_path = module_path_obj.exists() and module_path_obj.is_dir()
 
-        if is_local_path:
-            package_path = module
-        else:
-            package_path = f'{BASE_PACKAGE_PATH}/{module}'
+        package_path = module_path_obj if is_local_path else BASE_PACKAGE_PATH / module
 
-        with open(f'{package_path}/package.json') as f:
+        with (package_path / "package.json").open() as f:
             pkg = json.load(f)
-            for expr in pkg['expressions']:
+            for expr in pkg["expressions"]:
                 if is_local_path:
-                    module_path = f'{package_path}/{expr["module"].replace("/", ".")}'
                     # For local modules, we need to add the path to sys.path
-                    parent_dir = os.path.dirname(package_path)
-                    if parent_dir not in sys.path:
-                        sys.path.append(parent_dir)
+                    parent_dir = package_path.parent
+                    if str(parent_dir) not in sys.path:
+                        sys.path.append(str(parent_dir))
                     # Use local module's name from the directory structure
-                    module_name = os.path.basename(package_path)
+                    module_name = package_path.name
                     relative_module_path = f"{module_name}.{expr['module'].replace('/', '.')}"
                 else:
-                    module_path = f'{BASE_PACKAGE_PATH}/{expr["module"].replace("/", ".")}'
-                    # Determine relative path and adjust namespace
-                    relative_module_path = module_path.replace(BASE_PACKAGE_PATH, '').replace('/', '.').lstrip('.')
-                    # Replace with actual username and package_name values
-                    relative_module_path = module.split('/')[0] + '.' + module.split('/')[1] + '.' + relative_module_path
+                    module_parts = module.split("/")
+                    relative_module_path = ".".join(
+                        [*module_parts, expr["module"].replace("/", ".")]
+                    )
 
                 try:
-                    module_class = getattr(importlib.import_module(relative_module_path), expr['type'])
+                    module_class = getattr(
+                        importlib.import_module(relative_module_path), expr["type"]
+                    )
                     module_classes.append(module_class)
                 except (ImportError, ModuleNotFoundError) as e:
                     logger.error(f"Error importing module {relative_module_path}: {e}")
@@ -150,66 +159,79 @@ class Import(Expression):
         return module_classes
 
     @staticmethod
-    def load_expression(module, expressions: Union[List[str] | Tuple[str] | str]) -> Union[List[Expression] | Expression]:
+    def _normalize_expressions(expressions: list[str] | tuple[str] | str) -> tuple[list[str], bool]:
+        if isinstance(expressions, str):
+            return [expressions], True
+        if isinstance(expressions, (list, tuple)):
+            expression_list = list(expressions)
+            return expression_list, len(expression_list) == 1
+        msg = "Invalid type for 'expressions'. Must be str, list or tuple."
+        UserMessage(msg)
+        raise Exception(msg)
+
+    @staticmethod
+    def load_expression(
+        module, expressions: list[str] | tuple[str] | str
+    ) -> list[Expression] | Expression:
+        expression_list, return_single = Import._normalize_expressions(expressions)
+        expected_count = len(expression_list)
+        expression_targets = set(expression_list)
         module_classes = []
         # Detect if module is a local path
-        is_local_path = os.path.exists(module) and os.path.isdir(module)
+        module_path_obj = Path(module)
+        is_local_path = module_path_obj.exists() and module_path_obj.is_dir()
+
+        package_path = module_path_obj if is_local_path else BASE_PACKAGE_PATH / module
 
         if is_local_path:
-            package_path = module
+            parent_dir = package_path.parent
+            if str(parent_dir) not in sys.path:
+                sys.path.append(str(parent_dir))
+            module_name = package_path.name
         else:
-            package_path = f'{BASE_PACKAGE_PATH}/{module}'
+            module_parts = module.split("/")
 
-        with open(f'{package_path}/package.json') as f:
+        with (package_path / "package.json").open() as f:
             pkg = json.load(f)
-            for expr in pkg['expressions']:
-                if is_local_path:
-                    # For local paths, need to handle imports differently
-                    parent_dir = os.path.dirname(package_path)
-                    if parent_dir not in sys.path:
-                        sys.path.append(parent_dir)
+            for expr in pkg["expressions"]:
+                relative_module_path = (
+                    f"{module_name}.{expr['module'].replace('/', '.')}"
+                    if is_local_path
+                    else ".".join([*module_parts, expr["module"].replace("/", ".")])
+                )
 
-                    # Use basename as module name
-                    module_name = os.path.basename(package_path)
-                    relative_module_path = f"{module_name}.{expr['module'].replace('/', '.')}"
-                else:
-                    # For GitHub packages
-                    module_path = f'{BASE_PACKAGE_MODULE}/{expr["module"].replace("/", ".")}'
-                    # Determine relative path and adjust namespace
-                    relative_module_path = module_path.replace(BASE_PACKAGE_MODULE, '').replace('/', '.').lstrip('.')
-                    # Add the organization/repo prefix
-                    relative_module_path = f"{module.split('/')[0]}.{module.split('/')[1]}.{relative_module_path}"
-
-                if isinstance(expressions, str):
-                    if expr['type'] == expressions:
-                        try:
-                            module_obj = importlib.import_module(relative_module_path)
-                            module_class = getattr(module_obj, expr['type'])
-                            return module_class
-                        except (ImportError, ModuleNotFoundError) as e:
-                            logger.error(f"Error importing module {relative_module_path}: {e}")
-                            raise
-                elif isinstance(expressions, list) or isinstance(expressions, tuple):
-                    if expr['type'] in expressions:
-                        try:
-                            module_obj = importlib.import_module(relative_module_path)
-                            module_class = getattr(module_obj, expr['type'])
-                            if len(expressions) == 1:
-                                return module_class
-                            module_classes.append(module_class)
-                        except (ImportError, ModuleNotFoundError) as e:
-                            logger.error(f"Error importing module {relative_module_path}: {e}")
-                            raise
-                else:
-                    raise Exception("Invalid type for 'expressions'. Must be str, list or tuple.")
+                if expr["type"] not in expression_targets:
+                    continue
+
+                try:
+                    module_obj = importlib.import_module(relative_module_path)
+                    module_class = getattr(module_obj, expr["type"])
+                except (ImportError, ModuleNotFoundError) as e:
+                    logger.error(f"Error importing module {relative_module_path}: {e}")
+                    raise
+
+                if return_single:
+                    return module_class
+                module_classes.append(module_class)
 
         assert len(module_classes) > 0, f"Expression '{expressions}' not found in module '{module}'"
         module_classes_names = [str(class_.__name__) for class_ in module_classes]
-        assert len(module_classes) == len(expressions), f"Not all expressions found in module '{module}'. Could not load {[expr for expr in expressions if expr not in module_classes_names]}"
+        missing_expressions = [expr for expr in expression_list if expr not in module_classes_names]
+        assert len(module_classes) == expected_count, (
+            f"Not all expressions found in module '{module}'. Could not load {missing_expressions}"
+        )
         return module_classes
 
-    def __new__(self, module, auto_clone: bool = True, verbose: bool = False, local_path: str | None = None,
-                submodules: bool = False, *args, **kwargs):
+    def __new__(
+        cls,
+        module,
+        auto_clone: bool = True,
+        verbose: bool = False,
+        local_path: str | None = None,
+        submodules: bool = False,
+        *args,
+        **kwargs,
+    ):
         """
         Import a module from GitHub or local path.
 
@@ -222,15 +244,18 @@ class Import(Expression):
             *args, **kwargs: Additional arguments to pass to the module constructor
         """
         # Detect if module is a local path
-        is_local_path = os.path.exists(module) and os.path.isdir(module)
+        module_path_obj = Path(module)
+        is_local_path = module_path_obj.exists() and module_path_obj.is_dir()
 
         if is_local_path:
             # If module is a local path
-            package_path = module
-            if not os.path.exists(f'{package_path}/package.json'):
-                raise ValueError(f"No package.json found in {module}")
+            package_path = module_path_obj
+            if not (package_path / "package.json").exists():
+                msg = f"No package.json found in {module}"
+                UserMessage(msg)
+                raise ValueError(msg)
 
-            with open(f'{package_path}/package.json') as f:
+            with (package_path / "package.json").open() as f:
                 pkg = json.load(f)
         else:
             # Module is a GitHub reference
@@ -240,27 +265,29 @@ class Import(Expression):
                 else:
                     Import.get_from_github(module, submodules)
 
-            with open(f'{BASE_PACKAGE_PATH}/{module}/package.json') as f:
+            with (BASE_PACKAGE_PATH / module / "package.json").open() as f:
                 pkg = json.load(f)
-        if 'run' not in pkg:
-            raise Exception(f"Module '{module}' has no 'run' expression defined.")
-        expr = pkg['run']
-        module_path = f'{expr["module"].replace("/", ".")}'
-        # Determine relative path and adjust namespace
-        relative_module_path = module_path.replace(BASE_PACKAGE_PATH, '').replace('/', '.').lstrip('.')
-        # Replace with actual username and package_name values
-        relative_module_path = module.split('/')[0] + '.' + module.split('/')[1] + '.' + relative_module_path
-        class_ = expr['type']
+        if "run" not in pkg:
+            msg = f"Module '{module}' has no 'run' expression defined."
+            UserMessage(msg)
+            raise Exception(msg)
+        expr = pkg["run"]
+        module_rel = expr["module"].replace("/", ".")
+        module_parts = module.split("/")
+        relative_module_path = ".".join([*module_parts, module_rel])
+        class_ = expr["type"]
         if verbose:
             logger.info(f"Loading module '{relative_module_path}.{expr['type']}'")
         module_class = getattr(importlib.import_module(relative_module_path), class_)
         return module_class(*args, **kwargs)
 
-    def __call__(self, *args, **kwargs):
-        raise Exception("Cannot call Import class directly. Use Import.load_module_class(module) instead.")
+    def __call__(self, *_args, **_kwargs):
+        msg = "Cannot call Import class directly. Use Import.load_module_class(module) instead."
+        UserMessage(msg)
+        raise Exception(msg)
 
     @staticmethod
-    def install(module: str, local_path: str = None, submodules: bool = False):
+    def install(module: str, local_path: str | None = None, submodules: bool = False):
         """Install a package from GitHub or a local path.
 
         Args:
@@ -269,11 +296,14 @@ class Import(Expression):
             submodules: Whether to initialize submodules for GitHub repos
         """
         # Determine if module is a local path
-        is_local_path = local_path is not None and os.path.exists(local_path) and os.path.isdir(local_path)
+        local_path_obj = Path(local_path) if local_path is not None else None
+        is_local_path = (
+            local_path_obj is not None and local_path_obj.exists() and local_path_obj.is_dir()
+        )
 
         if not Import.exists(module):
             if is_local_path:
-                Import.get_from_local(module, local_path)
+                Import.get_from_local(module, str(local_path_obj))
                 logger.success(f"Module '{module}' installed from local path.")
             else:
                 Import.get_from_github(module, submodules)
@@ -284,44 +314,54 @@ class Import(Expression):
     @staticmethod
     def remove(module: str):
         # Determine if module is a local path
-        is_local_path = os.path.exists(module) and os.path.isdir(module)
+        module_path_obj = Path(module)
+        is_local_path = module_path_obj.exists() and module_path_obj.is_dir()
 
         if is_local_path:
             # For local path, remove directly
-            if os.path.exists(module):
-                def del_rw(action, name, exc):
-                    os.chmod(name, stat.S_IWRITE)
-                    os.remove(name)
-                shutil.rmtree(module, onerror=del_rw)
+            if module_path_obj.exists():
+
+                def del_rw(_action, name, _exc):
+                    path_obj = Path(name)
+                    path_obj.chmod(stat.S_IWRITE)
+                    path_obj.unlink()
+
+                shutil.rmtree(module_path_obj, onerror=del_rw)
                 logger.success(f"Removed local module at '{module}'")
             else:
                 logger.error(f"Local module '{module}' not found.")
         else:
             # For GitHub modules, remove from packages directory
-            module_path = f'{BASE_PACKAGE_PATH}/{module}'
-            if os.path.exists(module_path):
-                def del_rw(action, name, exc):
-                    os.chmod(name, stat.S_IWRITE)
-                    os.remove(name)
+            module_path = BASE_PACKAGE_PATH / module
+            if module_path.exists():
+
+                def del_rw(_action, name, _exc):
+                    path_obj = Path(name)
+                    path_obj.chmod(stat.S_IWRITE)
+                    path_obj.unlink()
+
                 shutil.rmtree(module_path, onerror=del_rw)
                 logger.success(f"Removed module '{module}'")
 
                 # Check if folder is empty and remove it
-                parent_path = f'{BASE_PACKAGE_PATH}/{module.split("/")[0]}'
-                if os.path.exists(parent_path) and not os.listdir(parent_path):
-                    os.rmdir(parent_path)
+                parent_path = BASE_PACKAGE_PATH / module.split("/")[0]
+                if parent_path.exists() and not any(parent_path.iterdir()):
+                    parent_path.rmdir()
                     logger.info(f"Removed empty parent folder '{parent_path}'")
             else:
                 logger.error(f"Module '{module}' not found.")
 
     @staticmethod
     def list_installed():
-        base_dirs = [dir for dir in os.listdir(BASE_PACKAGE_PATH) if os.path.isdir(f'{BASE_PACKAGE_PATH}/{dir}')]
+        if not BASE_PACKAGE_PATH.exists():
+            return []
+        base_dirs = [entry for entry in BASE_PACKAGE_PATH.iterdir() if entry.is_dir()]
 
         sub_dirs = []
         for base_dir in base_dirs:
-            full_path = f'{BASE_PACKAGE_PATH}/{base_dir}'
-            sub_dirs.extend([f'{base_dir}/{dir}' for dir in os.listdir(full_path) if os.path.isdir(f'{full_path}/{dir}')])
+            sub_dirs.extend(
+                [f"{base_dir.name}/{entry.name}" for entry in base_dir.iterdir() if entry.is_dir()]
+            )
 
         return sub_dirs
 
@@ -335,19 +375,22 @@ class Import(Expression):
         """
         if Import.exists(module):
             # Determine if module is a local path
-            is_local_path = os.path.exists(module) and os.path.isdir(module)
+            module_path_obj = Path(module)
+            is_local_path = module_path_obj.exists() and module_path_obj.is_dir()
 
             # Use the appropriate path based on whether it's local or not
-            module_path = module if is_local_path else f'{BASE_PACKAGE_PATH}/{module.replace(".","/")}'
+            module_path = (
+                module_path_obj if is_local_path else BASE_PACKAGE_PATH / module.replace(".", "/")
+            )
 
             # Construct the git pull command based on whether submodules should be included
-            pull_cmd = ['git', '-C', module_path]
+            pull_cmd = ["git", "-C", str(module_path)]
             if submodules:
-                pull_cmd.extend(['pull', '--recurse-submodules'])
+                pull_cmd.extend(["pull", "--recurse-submodules"])
                 subprocess.check_call(pull_cmd)
                 logger.success(f"Module '{module}' and its submodules updated.")
             else:
-                pull_cmd.extend(['pull'])
+                pull_cmd.extend(["pull"])
                 subprocess.check_call(pull_cmd)
                 logger.success(f"Module '{module}' updated.")
         else:

symai/interfaces.py

@@ -5,7 +5,7 @@ from .backend.mixin import OPENAI_CHAT_MODELS, OPENAI_REASONING_MODELS
 from .backend.settings import SYMAI_CONFIG
 from .imports import Import
 from .symbol import Expression
-from .utils import CustomUserWarning
+from .utils import UserMessage
 
 
 class Interface(Expression):
@@ -13,19 +13,19 @@ class Interface(Expression):
         super().__init__(*args, **kwargs)
         self.logger = logging.getLogger(__name__)
 
-    def __new__(self, module: str, *args, **kwargs):
+    def __new__(cls, module: str, *args, **kwargs):
         module = str(module)
         # if `/` in module, assume github repo; else assume local module
         if "/" in module:
             return Import(module)
         module = module.lower()
         module = module.replace("-", "_")
-        self._module = module
-        self.module_path = f"symai.extended.interfaces.{module}"
-        return Interface.load_module_class(self.module_path, self._module)(*args, **kwargs)
+        cls._module = module
+        cls.module_path = f"symai.extended.interfaces.{module}"
+        return Interface.load_module_class(cls.module_path, cls._module)(*args, **kwargs)
 
-    def __call__(self, *args, **kwargs):
-        CustomUserWarning(f"Interface {self._module} is not callable.", raise_with=NotImplementedError)
+    def __call__(self, *_args, **_kwargs):
+        UserMessage(f"Interface {self._module} is not callable.", raise_with=NotImplementedError)
 
     @staticmethod
     def load_module_class(module_path, class_name):
@@ -33,39 +33,68 @@ class Interface(Expression):
         return getattr(module_, class_name)
 
 
-def cfg_to_interface():
-    """Maps configuration to interface."""
-    mapping = {}
+def _add_symbolic_interface(mapping):
     symbolic_api_key = SYMAI_CONFIG.get("SYMBOLIC_ENGINE_API_KEY")
     if symbolic_api_key is not None:
         mapping["symbolic"] = Interface("wolframalpha")
 
+
+def _resolve_drawing_interface_name(drawing_engine_model):
+    if drawing_engine_model.startswith("flux"):
+        return "flux"
+    if drawing_engine_model.startswith("dall-e-"):
+        return "dall_e"
+    if drawing_engine_model.startswith("gpt-image-"):
+        return "gpt_image"
+    return None
+
+
+def _add_drawing_interface(mapping):
     drawing_engine_api_key = SYMAI_CONFIG.get("DRAWING_ENGINE_API_KEY")
-    if drawing_engine_api_key is not None:
-        drawing_engine_model = SYMAI_CONFIG.get("DRAWING_ENGINE_MODEL")
-        if drawing_engine_model.startswith("flux"):
-            mapping["drawing"] = Interface("flux")
-        elif drawing_engine_model.startswith("dall-e-"):
-            mapping["drawing"] = Interface("dall_e")
-        elif drawing_engine_model.startswith("gpt-image-"):
-            mapping["drawing"] = Interface("gpt_image")
+    if drawing_engine_api_key is None:
+        return
+    drawing_engine_model = SYMAI_CONFIG.get("DRAWING_ENGINE_MODEL")
+    interface_name = _resolve_drawing_interface_name(drawing_engine_model)
+    if interface_name is not None:
+        mapping["drawing"] = Interface(interface_name)
+
+
+def _resolve_search_interface_name(search_engine_model):
+    if search_engine_model.startswith("google"):
+        return "serpapi"
+    if search_engine_model.startswith("sonar"):
+        return "perplexity"
+    if search_engine_model in OPENAI_REASONING_MODELS + OPENAI_CHAT_MODELS:
+        return "openai_search"
+    return None
 
+
+def _add_search_interface(mapping):
     search_engine_api_key = SYMAI_CONFIG.get("SEARCH_ENGINE_API_KEY")
-    if search_engine_api_key is not None:
-        search_engine_model = SYMAI_CONFIG.get("SEARCH_ENGINE_MODEL")
-        if search_engine_model.startswith("google"):
-            mapping["search"] = Interface("serpapi")
-        elif search_engine_model.startswith("sonar"):
-            mapping["search"] = Interface("perplexity")
-        elif search_engine_model in OPENAI_REASONING_MODELS + OPENAI_CHAT_MODELS:
-            mapping["search"] = Interface("openai_search")
+    if search_engine_api_key is None:
+        return
+    search_engine_model = SYMAI_CONFIG.get("SEARCH_ENGINE_MODEL")
+    interface_name = _resolve_search_interface_name(search_engine_model)
+    if interface_name is not None:
+        mapping["search"] = Interface(interface_name)
+
 
+def _add_tts_interface(mapping):
     tts_engine_api_key = SYMAI_CONFIG.get("TEXT_TO_SPEECH_ENGINE_API_KEY")
-    if tts_engine_api_key is not None: # TODO: add tests for this engine
+    if tts_engine_api_key is not None:  # TODO: add tests for this engine
         mapping["tts"] = Interface("tts")
 
+
+def cfg_to_interface():
+    """Maps configuration to interface."""
+    mapping = {}
+    _add_symbolic_interface(mapping)
+    _add_drawing_interface(mapping)
+    _add_search_interface(mapping)
+    _add_tts_interface(mapping)
+
     mapping["indexing"] = Interface("naive_vectordb")
-    mapping["scraper"] = Interface("naive_webscraping")
+    mapping["scraper"] = Interface("naive_scrape")
     mapping["stt"] = Interface("whisper")
     mapping["file"] = Interface("file")