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

symai/endpoints/api.py

@@ -1,65 +1,67 @@
 import importlib
 import inspect
 import pickle
-import redis
+from typing import Any, Generic, TypeVar
 
-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'
-PORT  = 6379
+HOST = "localhost"
+PORT = 6379
 DEBUG = True
-API_KEY = settings.SYMAI_CONFIG.get('FASTAPI_API_KEY', None)
+API_KEY = settings.SYMAI_CONFIG.get("FASTAPI_API_KEY", None)
+
 
 def is_redis_running(host: str, port: int) -> bool:
     """Check if a Redis server is running at the given host and port."""
     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')
+T = TypeVar("T")
 
 
 class GenericRepository(Generic[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.use_redis     = use_redis
-        self.id_key        = id_key  # Key used for storing the incremental ID counter
-        self.redis_client  = redis_client
+        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
         if self.use_redis:
-            self.set       = self._store_redis
-            self.get       = self._retrieve_redis
-            self.delete    = self._delete_redis
-            self.uid       = self._generate_id_redis
+            self.set = self._store_redis
+            self.get = self._retrieve_redis
+            self.delete = self._delete_redis
+            self.uid = self._generate_id_redis
         else:
-            self.set       = self._store_memory
-            self.get       = self._retrieve_memory
-            self.delete    = self._delete_memory
-            self.uid       = self._generate_id_memory
+            self.set = self._store_memory
+            self.get = self._retrieve_memory
+            self.delete = self._delete_memory
+            self.uid = self._generate_id_memory
 
     def _deserialize_object(self, serialized_item: bytes) -> 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:
@@ -76,7 +78,7 @@ class GenericRepository(Generic[T]):
 
     def _generate_id_memory(self) -> str:
         id_ = len(self.storage) + 1
-        return f'{self.id_key}:{id_}'
+        return f"{self.id_key}:{id_}"
 
     def _store_redis(self, item_id: str, item: T) -> None:
         item = self._serialize_object(item_id, item)
@@ -85,8 +87,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:
@@ -94,39 +95,67 @@ class GenericRepository(Generic[T]):
 
     def _generate_id_redis(self) -> str:
         id_ = self.redis_client.incr(self.id_key)
-        return f'{self.id_key}:{id_}'
+        return f"{self.id_key}:{id_}"
 
 
 # Initialize the Redis client
 redis_client = redis.Redis(
-    host=HOST,   # Or use the host where your Redis server is running
-    port=PORT,   # The default Redis port number
-    db=0         # The default database index
+    host=HOST,  # Or use the host where your Redis server is running
+    port=PORT,  # The default Redis port number
+    db=0,  # The default database index
 )
 
 # Initialize the FastAPI app and API router
-app                           = FastAPI(title="SymbolicAI API", version="1.0")
-api_key_header                = APIKeyHeader(name="X-API-Key")
-router                        = APIRouter()
-use_redis                     = is_redis_running(HOST, PORT)
+app = FastAPI(title="SymbolicAI API", version="1.0")
+api_key_header = APIKeyHeader(name="X-API-Key")
+router = APIRouter()
+use_redis = is_redis_running(HOST, PORT)
 
 # Instantiate the generic repositories with the counter keys
-symbol_repository             = GenericRepository[Symbol](redis_client, "sym_id", use_redis=use_redis)
-expression_repository         = GenericRepository[Expression](redis_client, "expr_id", use_redis=use_redis)
+symbol_repository = GenericRepository[Symbol](redis_client, "sym_id", use_redis=use_redis)
+expression_repository = GenericRepository[Expression](redis_client, "expr_id", use_redis=use_redis)
 # Register all types which subclass Expression and offer a get() method with default=None
 component_class_types = {
-    name: cls for name, cls in inspect.getmembers(importlib.import_module('symai.components'), inspect.isclass) if issubclass(cls, Expression)
+    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
+)
 
-app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_credentials=True, allow_methods=["*"], allow_headers=["*"])
+
+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=["*"],
+)
 
 ### Symbols Endpoints ###
 
 
 class CreateSymbolRequest(BaseModel):
-    value: Optional[Any]          = None
-    static_context: Optional[str] = ''
+    value: Any | None = None
+    static_context: str | None = ""
 
 
 class UpdateSymbolRequest(BaseModel):
@@ -135,11 +164,12 @@ 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
@@ -148,8 +178,9 @@ def get_api_key(api_key_header: str = Security(api_key_header) if API_KEY else N
         detail="Invalid or missing API Key",
     )
 
+
 @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 +188,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 +196,9 @@ 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 +209,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,13 +218,20 @@ 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")
     method = getattr(symbol, method_name, None)
     if method is None or not callable(method):
-        raise HTTPException(status_code=404, detail=f"Method {method_name} not found or is not callable")
+        raise HTTPException(
+            status_code=404, detail=f"Method {method_name} not found or is not callable"
+        )
     result = method(*method_request.args, **method_request.kwargs)
     return {"result": result.json() if isinstance(result, Symbol) else result}
 
@@ -200,7 +240,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 +248,9 @@ 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 +258,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 +267,9 @@ 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,19 +280,30 @@ 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")
     method = getattr(expression, method_name, None)
     if method is None or not callable(method):
-        raise HTTPException(status_code=404, detail=f"Method {method_name} not found or is not callable")
+        raise HTTPException(
+            status_code=404, detail=f"Method {method_name} not found or is not callable"
+        )
     result = method(*method_request.args, **method_request.kwargs)
     return {"result": result.json() if isinstance(result, Symbol) else result}
 
 
 @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 +314,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 +333,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:
@@ -305,12 +360,14 @@ def create_component(request: CreateComponentGenericRequest, api_key: str = Secu
     instance = cls(*request.init_args, **request.init_kwargs)
     # Store the instance with a generated ID and return the ID
     instance_id = component_instance_repository.uid()
-    component_instance_repository.set(instance_id, instance)  # Assuming component_instance_repository exists
+    component_instance_repository.set(
+        instance_id, instance
+    )  # Assuming component_instance_repository exists
     return {"id": instance_id}
 
 
 @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 +378,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')
+    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 +398,9 @@ 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 +411,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,33 +420,29 @@ 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)
+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
+)
 
 
 # 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 +458,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 +466,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 +477,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 +498,9 @@ 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,11 +513,13 @@ 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:
-        raise HTTPException(status_code=404, detail="Extended instance not found or already deleted")
+        raise HTTPException(
+            status_code=404, detail="Extended instance not found or already deleted"
+        )
     return {"message": "Extended instance deleted successfully"}
 
 

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