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

symai/imports.py

@@ -1,25 +1,24 @@
 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__)
+BASE_PACKAGE_PATH = __root_dir__
 sys.path.append(str(__root_dir__))
 
 
@@ -33,10 +32,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 +46,39 @@ 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', []):
                         # 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}'])
+                        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,29 +86,31 @@ 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']
         if submodules:
             clone_cmd.extend(['--recurse-submodules'])
-        clone_cmd.extend([git_url, f'{BASE_PACKAGE_PATH}/{module}'])
+        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']:
                 # 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}'])
+                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])
 
@@ -115,31 +118,25 @@ class Import(Expression):
     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']:
                 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'])
@@ -150,65 +147,66 @@ 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)
+                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,
+    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 +220,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 +241,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.")
+            msg = f"Module '{module}' has no 'run' expression defined."
+            UserMessage(msg)
+            raise Exception(msg)
         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
+        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 +272,12 @@ 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 +288,48 @@ 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,13 +343,14 @@ 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'])
                 subprocess.check_call(pull_cmd)

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,37 +33,66 @@ 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["stt"] = Interface("whisper")

symai/memory.py

@@ -1,8 +1,7 @@
-from typing import List
 
 from . import core_ext
-from .symbol import Expression, Symbol
 from .components import Function
+from .symbol import Expression, Symbol
 
 
 class Memory(Expression):
@@ -25,24 +24,24 @@ class Memory(Expression):
 class SlidingWindowListMemory(Memory):
     def __init__(self, window_size: int = 10, max_size: int = 1000, **kwargs):
         super().__init__(**kwargs)
-        self._memory: List[str] = []
+        self._memory: list[str] = []
         self._window_size: int  = window_size
         self._max_size: int     = max_size
 
-    def store(self, query: str, *args, **kwargs):
+    def store(self, query: str, *_args, **_kwargs):
         self._memory.append(query)
         if len(self._memory) > self._max_size:
             self._memory = self._memory[-self._max_size:]
 
-    def forget(self, query: Symbol, *args, **kwargs):
+    def forget(self, query: Symbol, *_args, **_kwargs):
         self._memory.remove(query)
 
-    def recall(self, *args, **kwargs):
+    def recall(self, *_args, **_kwargs):
         return self._memory[-self._window_size:]
 
 
 class SlidingWindowStringConcatMemory(Memory):
-    def __init__(self, *args, **kwargs):
+    def __init__(self, *_args, **kwargs):
         super().__init__(**kwargs)
         self._memory: str       = ''
         self.marker: str        = '[--++=|=++--]'
@@ -71,9 +70,9 @@ class SlidingWindowStringConcatMemory(Memory):
 
     def store(self, query: str):
         # append to string to memory
-        self._memory += f'{str(query)}{self.marker}'
+        self._memory += f'{query!s}{self.marker}'
 
-    def forget(self, query: Symbol, *args, **kwargs):
+    def forget(self, query: Symbol, *_args, **_kwargs):
         # remove substring from memory
         sym = Symbol(self._memory)
         self._memory = str(sym - query)
@@ -101,13 +100,15 @@ class VectorDatabaseMemory(Memory):
         self.top_k: int    = top_k
         self.index_name    = index_name
 
-    def store(self, query: str , *args, **kwargs):
-        if not self.enabled: return
+    def store(self, query: str , *_args, **_kwargs):
+        if not self.enabled:
+            return
 
         self.add(Symbol(query).zip(), index_name=self.index_name)
 
-    def recall(self, query: str, *args, **kwargs):
-        if not self.enabled: return
+    def recall(self, query: str, *_args, **_kwargs):
+        if not self.enabled:
+            return None
 
         res = self.get(Symbol(query).embed().value, index_top_k=self.top_k, index_name=self.index_name).ast()