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

symai/core_ext.py

@@ -3,22 +3,20 @@ import atexit
 import functools
 import logging
 import multiprocessing as mp
-import os
 import pickle
 import random
-import sys
-import time
 import threading
+import time
 import traceback
+from collections.abc import Callable
 from pathlib import Path
-from typing import Callable, List
 
 import dill
 from loguru import logger
-from pathos.multiprocessing import ProcessingPool as PPool
 
 from . import __root_dir__
 from .functional import EngineRepository
+from .utils import UserMessage
 
 logging.getLogger("multiprocessing").setLevel(logging.ERROR)
 
@@ -50,7 +48,7 @@ def _run_in_process(expr, func, args, kwargs):
     func = dill.loads(func)
     return func(expr, *args, **kwargs)
 
-def _parallel(func: Callable, expressions: List[Callable], worker: int = mp.cpu_count() // 2):
+def _parallel(func: Callable, expressions: list[Callable], worker: int = mp.cpu_count() // 2):
     pickled_exprs = [dill.dumps(expr) for expr in expressions]
     pickled_func  = dill.dumps(func)
     pool = _get_pool(worker)
@@ -62,15 +60,14 @@ def _parallel(func: Callable, expressions: List[Callable], worker: int = mp.cpu_
     return proxy_function
 
 # Decorator
-def parallel(expressions: List[Callable], worker: int = mp.cpu_count() // 2):
+def parallel(expressions: list[Callable], worker: int = mp.cpu_count() // 2):
     def decorator_parallel(func):
         @functools.wraps(func)
         def wrapper(*args, **kwargs):
             # Run expressions in parallel
             parallel_func = _parallel(func, expressions, worker=worker)
             # Call the proxy function to execute in parallel and capture results
-            results = parallel_func(*args, **kwargs)
-            return results
+            return parallel_func(*args, **kwargs)
         return wrapper
     return decorator_parallel
 
@@ -80,7 +77,7 @@ def bind(engine: str, property: str):
     '''
     def decorator(func):
         @functools.wraps(func)
-        def wrapper(*args, **kwargs):
+        def wrapper(*_args, **_kwargs):
             return EngineRepository.bind_property(
                     engine=engine,
                     property=property
@@ -127,20 +124,19 @@ def retry(
                     graceful=graceful
                 )
             return async_wrapper
-        else:
-            @functools.wraps(func)
-            def sync_wrapper(*args, **kwargs):
-                return _retry_func(
-                    functools.partial(func, *args, **kwargs),
-                    exceptions=exceptions,
-                    tries=tries,
-                    delay=delay,
-                    max_delay=max_delay,
-                    backoff=backoff,
-                    jitter=jitter,
-                    graceful=graceful
-                )
-            return sync_wrapper
+        @functools.wraps(func)
+        def sync_wrapper(*args, **kwargs):
+            return _retry_func(
+                functools.partial(func, *args, **kwargs),
+                exceptions=exceptions,
+                tries=tries,
+                delay=delay,
+                max_delay=max_delay,
+                backoff=backoff,
+                jitter=jitter,
+                graceful=graceful
+            )
+        return sync_wrapper
     return decorator
 
 
@@ -158,7 +154,7 @@ def _retry_func(
     while _tries:
         try:
             return func()
-        except exceptions as e:
+        except exceptions:
             _tries -= 1
             if not _tries:
                 if graceful:
@@ -175,6 +171,7 @@ def _retry_func(
 
             if max_delay >= 0:
                 _delay = min(_delay, max_delay)
+    return None
 
 
 async def _aretry_func(
@@ -191,7 +188,7 @@ async def _aretry_func(
     while _tries:
         try:
             return await func()
-        except exceptions as e:
+        except exceptions:
             _tries -= 1
             if not _tries:
                 if graceful:
@@ -208,6 +205,7 @@ async def _aretry_func(
 
             if max_delay >= 0:
                 _delay = min(_delay, max_delay)
+    return None
 
 
 def cache(
@@ -237,16 +235,16 @@ def _cache_registry_func(
         *args, **kwargs
     ):
 
-    if not os.path.exists(cache_path): os.makedirs(cache_path)
-
-    if in_memory and os.path.exists(Path(cache_path) / func.__qualname__):
-        with open(Path(cache_path) / func.__qualname__, 'rb') as f:
-            call = pickle.load(f)
+    cache_dir = Path(cache_path)
+    cache_dir.mkdir(parents=True, exist_ok=True)
+    cache_file = cache_dir / func.__qualname__
 
-        return call
+    if in_memory and cache_file.exists():
+        with cache_file.open('rb') as f:
+            return pickle.load(f)
 
     call = func(*args, **kwargs)
-    with open(Path(cache_path) / func.__qualname__, 'wb') as f:
+    with cache_file.open('wb') as f:
         pickle.dump(call , f)
 
     return call
@@ -265,7 +263,7 @@ def error_logging(debug: bool = False):
                 logger.error(e)
                 if debug:
                     # Simple message:
-                    print('Function: {} call failed. Error: {}'.format(func.__name__, e))
+                    UserMessage(f'Function: {func.__name__} call failed. Error: {e}')
                     # print traceback
                     traceback.print_exc()
                 raise e

symai/endpoints/api.py

@@ -1,20 +1,20 @@
 import importlib
 import inspect
 import pickle
-import redis
+from typing import Any
 
-from redis.exceptions import ConnectionError
-from fastapi import FastAPI, APIRouter, HTTPException, Security, status
-from fastapi.security import APIKeyHeader
+import redis
+from fastapi import APIRouter, FastAPI, HTTPException, Security, status
 from fastapi.middleware.cors import CORSMiddleware
+from fastapi.security import APIKeyHeader
 from pydantic import BaseModel
-from typing import Any, Generic, TypeVar, Dict, List, Optional, Union
+from redis.exceptions import ConnectionError as RedisConnectionError
 
 from symai.backend import settings
 
 from .. import core_ext
-from ..symbol import Symbol, Expression
-
+from ..symbol import Expression, Symbol
+from ..utils import UserMessage
 
 # Configure Redis server connection parameters and executable path
 HOST  = 'localhost'
@@ -27,20 +27,16 @@ def is_redis_running(host: str, port: int) -> bool:
     try:
         r = redis.Redis(host=host, port=port)
         r.ping()
-        print(f"Redis server is running at {host}:{port}")
+        UserMessage(f"Redis server is running at {host}:{port}")
         return True
-    except ConnectionError:
-        print(f"Redis server is not running at {host}:{port} or is not reachable - falling back to in-memory storage")
+    except RedisConnectionError:
+        UserMessage(f"Redis server is not running at {host}:{port} or is not reachable - falling back to in-memory storage")
         return False
 
 
-# Create a generic type variable
-T = TypeVar('T')
-
-
-class GenericRepository(Generic[T]):
+class GenericRepository[T]:
     def __init__(self, redis_client: redis.Redis, id_key: str, use_redis: bool = True):
-        self.storage: Dict[str, T] = {}  # In-memory dictionary to mock Redis
+        self.storage: dict[str, T] = {}  # In-memory dictionary to mock Redis
         self.use_redis     = use_redis
         self.id_key        = id_key  # Key used for storing the incremental ID counter
         self.redis_client  = redis_client
@@ -59,7 +55,7 @@ class GenericRepository(Generic[T]):
         """Deserialize the byte object back into a Python object of type T."""
         return pickle.loads(serialized_item)
 
-    def _serialize_object(self, item_id: str, item: T) -> None:
+    def _serialize_object(self, _item_id: str, item: T) -> None:
         return pickle.dumps(item)
 
     def _store_memory(self, item_id: str, item: T) -> None:
@@ -85,8 +81,7 @@ class GenericRepository(Generic[T]):
     def _retrieve_redis(self, item_id: str) -> T:
         item = self.redis_client.get(item_id)
         if item:
-            item = self._deserialize_object(item)
-            return item
+            return self._deserialize_object(item)
         return None
 
     def _delete_redis(self, item_id: str) -> bool:
@@ -117,7 +112,22 @@ expression_repository         = GenericRepository[Expression](redis_client, "exp
 component_class_types = {
     name: cls for name, cls in inspect.getmembers(importlib.import_module('symai.components'), inspect.isclass) if issubclass(cls, Expression)
 }
-component_instance_repository = GenericRepository[Union[Symbol, Expression]](redis_client, "comp_id", use_redis=use_redis)
+component_instance_repository = GenericRepository[Symbol | Expression](redis_client, "comp_id", use_redis=use_redis)
+
+
+def _load_extended_types():
+    """Load extended classes lazily to avoid premature engine initialization."""
+    extended_module = importlib.import_module('symai.extended')
+    personas_module = importlib.import_module('symai.extended.personas')
+    sales_module = importlib.import_module('symai.extended.personas.sales')
+    student_module = importlib.import_module('symai.extended.personas.student')
+    return [
+        extended_module.Conversation,
+        personas_module.Persona,
+        personas_module.Dialogue,
+        student_module.MaxTenner,
+        sales_module.ErikJames,
+    ]
 
 app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_credentials=True, allow_methods=["*"], allow_headers=["*"])
 
@@ -125,8 +135,8 @@ app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_credentials=True,
 
 
 class CreateSymbolRequest(BaseModel):
-    value: Optional[Any]          = None
-    static_context: Optional[str] = ''
+    value: Any | None          = None
+    static_context: str | None = ''
 
 
 class UpdateSymbolRequest(BaseModel):
@@ -135,11 +145,11 @@ class UpdateSymbolRequest(BaseModel):
 
 
 class SymbolMethodRequest(BaseModel):
-    args: List[Any] = []
-    kwargs: Dict[str, Any] = {}
+    args: list[Any] = []
+    kwargs: dict[str, Any] = {}
 
 def get_api_key(api_key_header: str = Security(api_key_header) if API_KEY else None) -> str:
-    if API_KEY == None:
+    if API_KEY is None:
         return True
     if api_key_header == API_KEY:
         return api_key_header
@@ -149,7 +159,7 @@ def get_api_key(api_key_header: str = Security(api_key_header) if API_KEY else N
     )
 
 @app.post("/symbol/")
-def create_symbol(symbol_request: CreateSymbolRequest, api_key: str = Security(get_api_key)):
+def create_symbol(symbol_request: CreateSymbolRequest, _api_key: str = Security(get_api_key)):
     symbol = Symbol(symbol_request.value, static_context=symbol_request.static_context)
     symbol_id = symbol_repository.uid()
     symbol_repository.set(symbol_id, symbol)
@@ -157,7 +167,7 @@ def create_symbol(symbol_request: CreateSymbolRequest, api_key: str = Security(g
 
 
 @app.get("/symbol/{symbol_id}/")
-def get_symbol(symbol_id: str, api_key: str = Security(get_api_key)):
+def get_symbol(symbol_id: str, _api_key: str = Security(get_api_key)):
     symbol = symbol_repository.get(symbol_id)
     if symbol is None:
         raise HTTPException(status_code=404, detail="Symbol not found")
@@ -165,7 +175,7 @@ def get_symbol(symbol_id: str, api_key: str = Security(get_api_key)):
 
 
 @app.patch("/symbol/{symbol_id}/")
-def update_symbol(symbol_id: str, update_request: UpdateSymbolRequest, api_key: str = Security(get_api_key)):
+def update_symbol(symbol_id: str, update_request: UpdateSymbolRequest, _api_key: str = Security(get_api_key)):
     symbol = symbol_repository.get(symbol_id)
     if symbol is None:
         raise HTTPException(status_code=404, detail="Symbol not found")
@@ -176,7 +186,7 @@ def update_symbol(symbol_id: str, update_request: UpdateSymbolRequest, api_key:
 
 
 @app.delete("/symbol/{symbol_id}/")
-def delete_symbol(symbol_id: str, api_key: str = Security(get_api_key)):
+def delete_symbol(symbol_id: str, _api_key: str = Security(get_api_key)):
     symbol = symbol_repository.delete(symbol_id)
     if symbol is None:
         raise HTTPException(status_code=404, detail="Symbol not found")
@@ -185,7 +195,7 @@ def delete_symbol(symbol_id: str, api_key: str = Security(get_api_key)):
 
 @app.post("/symbol/{symbol_id}/{method_name}/")
 @core_ext.error_logging(debug=DEBUG)
-def operate_on_symbol(symbol_id: str, method_name: str, method_request: SymbolMethodRequest, api_key: str = Security(get_api_key)):
+def operate_on_symbol(symbol_id: str, method_name: str, method_request: SymbolMethodRequest, _api_key: str = Security(get_api_key)):
     symbol = symbol_repository.get(symbol_id)
     if symbol is None:
         raise HTTPException(status_code=404, detail="Symbol not found")
@@ -200,7 +210,7 @@ def operate_on_symbol(symbol_id: str, method_name: str, method_request: SymbolMe
 
 
 class CreateExpressionRequest(BaseModel):
-    value: Optional[Any] = None
+    value: Any | None = None
 
 
 class UpdateExpressionRequest(BaseModel):
@@ -208,7 +218,7 @@ class UpdateExpressionRequest(BaseModel):
 
 
 @app.post("/expression/")
-def create_expression(expression_request: CreateExpressionRequest, api_key: str = Security(get_api_key)):
+def create_expression(expression_request: CreateExpressionRequest, _api_key: str = Security(get_api_key)):
     expression = Expression(expression_request.value)
     expression_id = expression_repository.uid()
     expression_repository.set(expression_id, expression)
@@ -216,7 +226,7 @@ def create_expression(expression_request: CreateExpressionRequest, api_key: str
 
 
 @app.get("/expression/{expression_id}/")
-def get_expression(expression_id: str, api_key: str = Security(get_api_key)):
+def get_expression(expression_id: str, _api_key: str = Security(get_api_key)):
     expression = expression_repository.get(expression_id)
     if expression is None:
         raise HTTPException(status_code=404, detail="Expression not found")
@@ -225,7 +235,7 @@ def get_expression(expression_id: str, api_key: str = Security(get_api_key)):
 
 @app.post("/expression/{expression_id}/call/")
 @core_ext.error_logging(debug=DEBUG)
-def call_expression(expression_id: str, method_request: SymbolMethodRequest, api_key: str = Security(get_api_key)):
+def call_expression(expression_id: str, method_request: SymbolMethodRequest, _api_key: str = Security(get_api_key)):
     # Retrieve the expression instance by ID
     expression = expression_repository.get(expression_id)
     if expression is None:
@@ -236,7 +246,7 @@ def call_expression(expression_id: str, method_request: SymbolMethodRequest, api
 
 @app.post("/expression/{expression_id}/{method_name}/")
 @core_ext.error_logging(debug=DEBUG)
-def operate_on_expression(expression_id: str, method_name: str, method_request: SymbolMethodRequest, api_key: str = Security(get_api_key)):
+def operate_on_expression(expression_id: str, method_name: str, method_request: SymbolMethodRequest, _api_key: str = Security(get_api_key)):
     expression = expression_repository.get(expression_id)
     if expression is None:
         raise HTTPException(status_code=404, detail="Expression not found")
@@ -248,7 +258,7 @@ def operate_on_expression(expression_id: str, method_name: str, method_request:
 
 
 @app.patch("/expression/{expression_id}/")
-def update_expression(expression_id: str, update_request: UpdateExpressionRequest, api_key: str = Security(get_api_key)):
+def update_expression(expression_id: str, update_request: UpdateExpressionRequest, _api_key: str = Security(get_api_key)):
     expression = expression_repository.get(expression_id)
     if expression is None:
         raise HTTPException(status_code=404, detail="Expression not found")
@@ -259,7 +269,7 @@ def update_expression(expression_id: str, update_request: UpdateExpressionReques
 
 
 @app.delete("/expression/{expression_id}/")
-def delete_expression(expression_id: str, api_key: str = Security(get_api_key)):
+def delete_expression(expression_id: str, _api_key: str = Security(get_api_key)):
     expression = expression_repository.delete(expression_id)
     if expression is None:
         raise HTTPException(status_code=404, detail="Expression not found")
@@ -278,25 +288,25 @@ class AddComponentRequest(BaseModel):
 # Endpoint to instantiate a generic component class and get the ID
 class CreateComponentGenericRequest(BaseModel):
     class_name: str
-    init_args: List[Any]        = []
-    init_kwargs: Dict[str, Any] = {}
+    init_args: list[Any]        = []
+    init_kwargs: dict[str, Any] = {}
 
 
 # Modify the existing GenericRequest
 class GenericRequest(BaseModel):
     class_name: str
-    init_args: List[Any]            = {}
-    init_kwargs: Dict[str, Any]     = {}
-    forward_args: List[ Any]        = {}
-    forward_kwargs: Dict[str, Any]  = {}
+    init_args: list[Any]            = {}
+    init_kwargs: dict[str, Any]     = {}
+    forward_args: list[ Any]        = {}
+    forward_kwargs: dict[str, Any]  = {}
 
 
 class UpdateComponentRequest(BaseModel):
-    update_kwargs: Dict[str, Any] = {}
+    update_kwargs: dict[str, Any] = {}
 
 
 @app.post("/components/")
-def create_component(request: CreateComponentGenericRequest, api_key: str = Security(get_api_key)):
+def create_component(request: CreateComponentGenericRequest, _api_key: str = Security(get_api_key)):
     # Retrieve the class from the repository
     cls = component_class_types.get(request.class_name)
     if cls is None:
@@ -310,7 +320,7 @@ def create_component(request: CreateComponentGenericRequest, api_key: str = Secu
 
 
 @app.get("/components/{instance_id}/")
-def get_component(instance_id: str, api_key: str = Security(get_api_key)):
+def get_component(instance_id: str, _api_key: str = Security(get_api_key)):
     # Retrieve an instance by its ID from the repository
     instance = component_instance_repository.get(instance_id)
     if instance is None:
@@ -321,13 +331,15 @@ def get_component(instance_id: str, api_key: str = Security(get_api_key)):
 # Endpoint to execute a command on a component instance
 @app.post("/components/call/")
 @core_ext.error_logging(debug=DEBUG)
-def generic_forward(request: GenericRequest, api_key: str = Security(get_api_key)):
+def generic_forward(request: GenericRequest, _api_key: str = Security(get_api_key)):
     # Dynamically import the class from components module based on request.class_name
     components_module = importlib.import_module('.components', package='symai')
     cls = getattr(components_module, request.class_name)
     # Check if cls is subclass of Expression and instantiate
     if not issubclass(cls, components_module.Expression):
-        raise ValueError("The provided class name must be a subclass of Expression")
+        msg = "The provided class name must be a subclass of Expression"
+        UserMessage(msg)
+        raise ValueError(msg)
     # Initialize the class with provided init_args, requiring unpacking **kwargs
     instance = cls(*request.init_args, **request.init_kwargs)
     # Call the forward method with provided forward_args, requiring unpacking **kwargs
@@ -339,7 +351,7 @@ def generic_forward(request: GenericRequest, api_key: str = Security(get_api_key
 
 
 @app.patch("/components/{instance_id}/")
-def update_component(instance_id: str, update_request: UpdateComponentRequest, api_key: str = Security(get_api_key)):
+def update_component(instance_id: str, update_request: UpdateComponentRequest, _api_key: str = Security(get_api_key)):
     instance = component_instance_repository.get(instance_id)
     if instance is None:
         raise HTTPException(status_code=404, detail="Component instance not found")
@@ -350,7 +362,7 @@ def update_component(instance_id: str, update_request: UpdateComponentRequest, a
 
 
 @app.delete("/components/{instance_id}/")
-def delete_component(instance_id: str, api_key: str = Security(get_api_key)):
+def delete_component(instance_id: str, _api_key: str = Security(get_api_key)):
     instance = component_instance_repository.delete(instance_id)
     if instance is None:
         raise HTTPException(status_code=404, detail="Component instance not found")
@@ -359,14 +371,8 @@ def delete_component(instance_id: str, api_key: str = Security(get_api_key)):
 
 ### Selectively register the endpoints with the API router ###
 
-# extended imports
-from ..extended import Conversation
-from ..extended.personas import Persona, Dialogue
-from ..extended.personas.student import MaxTenner
-from ..extended.personas.sales import ErikJames
-
-
-extended_types = [Conversation, Persona, Dialogue, MaxTenner, ErikJames]
+# extended types loaded lazily to avoid early engine configuration
+extended_types = _load_extended_types()
 # Register only the extended types from the extended_types Union
 extended_class_types         = {c.__name__: c for c in extended_types}
 extended_instance_repository = GenericRepository[extended_types](redis_client, "ext_id", use_redis=use_redis)
@@ -375,17 +381,17 @@ extended_instance_repository = GenericRepository[extended_types](redis_client, "
 # Model definitions for extended classes
 class CreateExtendedRequest(BaseModel):
     class_name: str
-    init_args: List[Any]        = []
-    init_kwargs: Dict[str, Any] = {}
+    init_args: list[Any]        = []
+    init_kwargs: dict[str, Any] = {}
 
 
 class UpdateExtendedRequest(BaseModel):
-    update_kwargs: Dict[str, Any] = {}
+    update_kwargs: dict[str, Any] = {}
 
 
 # Create endpoints for each of the extended classes
 @app.post("/extended/")
-def create_extended(request: CreateExtendedRequest, api_key: str = Security(get_api_key)):
+def create_extended(request: CreateExtendedRequest, _api_key: str = Security(get_api_key)):
     # Dynamically retrieve the extended class
     extended_class = extended_class_types.get(request.class_name)
     if extended_class is None:
@@ -401,7 +407,7 @@ def create_extended(request: CreateExtendedRequest, api_key: str = Security(get_
 # Endpoint to execute a command on a component instance
 @app.post("/extended/call/")
 @core_ext.error_logging(debug=DEBUG)
-def extended_forward(request: GenericRequest, api_key: str = Security(get_api_key)):
+def extended_forward(request: GenericRequest, _api_key: str = Security(get_api_key)):
     # Dynamically import the class from components module based on request.class_name
     try:
         # get request.class_name from extended_types if it's a type of extended_types
@@ -409,7 +415,9 @@ def extended_forward(request: GenericRequest, api_key: str = Security(get_api_ke
         # look for the class in the extended module if not found in extended_types
         # iterate over the extended_type Union and check if the class name is in the __dict__
         if cls is None:
-            raise ImportError(f"Class {request.class_name} not found in extended types")
+            msg = f"Class {request.class_name} not found in extended types"
+            UserMessage(msg)
+            raise ImportError(msg)
         # Initialize the class with provided init_args and init_kwargs
         instance = cls(*request.init_args, **request.init_kwargs)
         # Call the 'forward' or similar method with provided forward_args and forward_kwargs
@@ -418,20 +426,19 @@ def extended_forward(request: GenericRequest, api_key: str = Security(get_api_ke
         # Check if the type of the result is within extended types or a primitive that can be serialized directly
         if isinstance(result, Symbol):
             return result.json()  # Convert to dictionary if it's a complex type
-        else:
-            return {"result": result}  # Return as is if it's a primitive type
+        return {"result": result}  # Return as is if it's a primitive type
     except ImportError as e:
-        raise HTTPException(status_code=404, detail=f"Module not found: {str(e)}")
+        raise HTTPException(status_code=404, detail=f"Module not found: {e!s}") from e
     except AttributeError as e:
-        raise HTTPException(status_code=404, detail=str(e))
+        raise HTTPException(status_code=404, detail=str(e)) from e
     except TypeError as e:
-        raise HTTPException(status_code=422, detail=str(e))
+        raise HTTPException(status_code=422, detail=str(e)) from e
     except Exception as e:
-        raise HTTPException(status_code=500, detail=f"An error occurred: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"An error occurred: {e!s}") from e
 
 
 @app.get("/extended/{instance_id}/")
-def get_extended(instance_id: str, api_key: str = Security(get_api_key)):
+def get_extended(instance_id: str, _api_key: str = Security(get_api_key)):
     # Retrieve an instance by its ID
     extended_instance = extended_instance_repository.get(instance_id)
     if extended_instance is None:
@@ -440,7 +447,7 @@ def get_extended(instance_id: str, api_key: str = Security(get_api_key)):
 
 
 @app.patch("/extended/{instance_id}/")
-def update_extended(instance_id: str, update_request: UpdateExtendedRequest, api_key: str = Security(get_api_key)):
+def update_extended(instance_id: str, update_request: UpdateExtendedRequest, _api_key: str = Security(get_api_key)):
     # Retrieve the instance by its ID
     extended_instance = extended_instance_repository.get(instance_id)
     if extended_instance is None:
@@ -453,7 +460,7 @@ def update_extended(instance_id: str, update_request: UpdateExtendedRequest, api
 
 
 @app.delete("/extended/{instance_id}/")
-def delete_extended(instance_id: str, api_key: str = Security(get_api_key)):
+def delete_extended(instance_id: str, _api_key: str = Security(get_api_key)):
     # Attempt to delete the instance by its ID
     success = extended_instance_repository.delete(instance_id)
     if not success:

symai/extended/__init__.py

@@ -1,16 +1,50 @@
-from .arxiv_pdf_parser import *
-from .conversation import *
-from .document import *
-from .file_merger import *
-from .graph import *
-from .html_style_template import *
-from .packages import *
-from .repo_cloner import *
-from .solver import *
-from .summarizer import *
-from .personas import *
+from importlib import import_module as _import_module
+
 from .api_builder import APIBuilder, APIExecutor
+from .bibtex_parser import BibTexParser
 from .os_command import OSCommand
 from .taypan_interpreter import TaypanInterpreter
-from .bibtex_parser import BibTexParser
 from .vectordb import VectorDB
+
+__all__ = [
+    "APIBuilder",
+    "APIExecutor",
+    "BibTexParser",
+    "OSCommand",
+    "TaypanInterpreter",
+    "VectorDB",
+]
+
+_seen_names = set(__all__)
+
+
+def _export_module(module_name: str, seen_names: set[str] = _seen_names) -> None:
+    module = _import_module(f"{__name__}.{module_name}")
+    public_names = getattr(module, "__all__", None)
+    if public_names is None:
+        public_names = [name for name in dir(module) if not name.startswith("_")]
+    for name in public_names:
+        globals()[name] = getattr(module, name)
+        if name not in seen_names:
+            __all__.append(name)
+            seen_names.add(name)
+
+
+for _module_name in [
+    "arxiv_pdf_parser",
+    "conversation",
+    "document",
+    "file_merger",
+    "graph",
+    "html_style_template",
+    "packages",
+    "repo_cloner",
+    "solver",
+    "summarizer",
+]:
+    _export_module(_module_name)
+
+
+del _export_module
+del _module_name
+del _seen_names

symai/extended/api_builder.py

@@ -1,9 +1,9 @@
 from .. import core
-from ..pre_processors import PreProcessor
+from ..components import Execute
 from ..post_processors import CodeExtractPostProcessor
+from ..pre_processors import PreProcessor
 from ..symbol import Expression, Symbol
-from ..components import Execute
-
+from ..utils import UserMessage
 
 API_BUILDER_DESCRIPTION = """[Description]
 You are an API coding tool for Python that creates API calls to any web URL based on user requests.
@@ -64,7 +64,7 @@ res = run(value) # [MANAGED] must contain this line, do not change
 
 class APIBuilderPreProcessor(PreProcessor):
     def __call__(self, argument):
-        return '$> {} =>'.format(str(argument.args[0]))
+        return f'$> {argument.args[0]!s} =>'
 
 
 class APIBuilder(Expression):
@@ -126,14 +126,17 @@ class APIExecutor(Expression):
     def _runnable(self):
         return self.executor._runnable
 
-    def forward(self, request: Symbol, **kwargs) -> Symbol:
+    def forward(self, request: Symbol, **_kwargs) -> Symbol:
         self._request = self._to_symbol(request)
-        if self._verbose: print('[REQUEST]', self._request)
+        if self._verbose:
+            UserMessage(f'[REQUEST] {self._request}')
         # Generate the code to implement the API call
         self._code    = self.builder(self._request)
-        if self._verbose: print('[GENERATED_CODE]', self._code)
+        if self._verbose:
+            UserMessage(f'[GENERATED_CODE] {self._code}')
         # Execute the code to define the 'run' function
         self._result  = self.executor(self._code, request=self._request)
-        if self._verbose: print('[RESULT]:', self._result)
+        if self._verbose:
+            UserMessage(f'[RESULT]: {self._result}')
         self._value   = self._result
         return self