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

symai/core_ext.py

@@ -26,6 +26,7 @@ logging.getLogger("multiprocessing").setLevel(logging.ERROR)
 _pool_registry: dict[int, mp.pool.Pool] = {}
 _pool_lock = threading.Lock()
 
+
 def _get_pool(workers: int) -> mp.pool.Pool:
     pool = _pool_registry.get(workers)
     if pool is not None:
@@ -37,28 +38,33 @@ def _get_pool(workers: int) -> mp.pool.Pool:
             _pool_registry[workers] = pool
     return pool
 
+
 @atexit.register
 def _shutdown_pools() -> None:
     for pool in _pool_registry.values():
         pool.close()
         pool.join()
 
+
 def _run_in_process(expr, func, args, kwargs):
     expr = dill.loads(expr)
     func = dill.loads(func)
     return func(expr, *args, **kwargs)
 
+
 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)
+    pickled_func = dill.dumps(func)
     pool = _get_pool(worker)
+
     def proxy_function(*args, **kwargs):
         return pool.starmap(
-                _run_in_process,
-                [(expr, pickled_func, args, kwargs) for expr in pickled_exprs]
-            )
+            _run_in_process, [(expr, pickled_func, args, kwargs) for expr in pickled_exprs]
+        )
+
     return proxy_function
 
+
 # Decorator
 def parallel(expressions: list[Callable], worker: int = mp.cpu_count() // 2):
     def decorator_parallel(func):
@@ -68,34 +74,31 @@ def parallel(expressions: list[Callable], worker: int = mp.cpu_count() // 2):
             parallel_func = _parallel(func, expressions, worker=worker)
             # Call the proxy function to execute in parallel and capture results
             return parallel_func(*args, **kwargs)
+
         return wrapper
+
     return decorator_parallel
 
+
 def bind(engine: str, property: str):
-    '''
+    """
     Bind to an engine and retrieve one of its properties.
-    '''
+    """
+
     def decorator(func):
         @functools.wraps(func)
         def wrapper(*_args, **_kwargs):
-            return EngineRepository.bind_property(
-                    engine=engine,
-                    property=property
-                )
+            return EngineRepository.bind_property(engine=engine, property=property)
+
         return wrapper
+
     return decorator
 
 
 def retry(
-    exceptions=Exception,
-    tries=-1,
-    delay=0,
-    max_delay=-1,
-    backoff=1,
-    jitter=0,
-    graceful=False
+    exceptions=Exception, tries=-1, delay=0, max_delay=-1, backoff=1, jitter=0, graceful=False
 ):
-    '''
+    """
     Returns a retry decorator for both async and sync functions.
 
     :param exceptions: an exception or a tuple of exceptions to catch. default: Exception.
@@ -108,9 +111,11 @@ def retry(
     :param graceful:   whether to raise an exception if all attempts fail or return with None. default: False.
 
     Credits to invlpg (https://pypi.org/project/retry)
-    '''
+    """
+
     def decorator(func):
         if asyncio.iscoroutinefunction(func):
+
             @functools.wraps(func)
             async def async_wrapper(*args, **kwargs):
                 return await _aretry_func(
@@ -121,9 +126,11 @@ def retry(
                     max_delay=max_delay,
                     backoff=backoff,
                     jitter=jitter,
-                    graceful=graceful
+                    graceful=graceful,
                 )
+
             return async_wrapper
+
         @functools.wraps(func)
         def sync_wrapper(*args, **kwargs):
             return _retry_func(
@@ -134,9 +141,11 @@ def retry(
                 max_delay=max_delay,
                 backoff=backoff,
                 jitter=jitter,
-                graceful=graceful
+                graceful=graceful,
             )
+
         return sync_wrapper
+
     return decorator
 
 
@@ -148,7 +157,7 @@ def _retry_func(
     max_delay: int,
     backoff: int,
     jitter: int,
-    graceful: bool
+    graceful: bool,
 ):
     _tries, _delay = tries, delay
     while _tries:
@@ -182,7 +191,7 @@ async def _aretry_func(
     max_delay: int,
     backoff: int,
     jitter: int,
-    graceful: bool
+    graceful: bool,
 ):
     _tries, _delay = tries, delay
     while _tries:
@@ -208,52 +217,42 @@ async def _aretry_func(
     return None
 
 
-def cache(
-    in_memory:  bool,
-    cache_path: str = __root_dir__ / 'cache'
-):
-    '''
+def cache(in_memory: bool, cache_path: str = __root_dir__ / "cache"):
+    """
     Cache the result of a *any* function call. This is very useful in cost optimization (e.g. computing embeddings).
-    '''
+    """
+
     def decorator(func):
         @functools.wraps(func)
         def wrapper(instance):
-            return _cache_registry_func(
-                    in_memory,
-                    cache_path,
-                    func,
-                    instance
-                )
+            return _cache_registry_func(in_memory, cache_path, func, instance)
+
         return wrapper
-    return decorator
 
+    return decorator
 
-def _cache_registry_func(
-        in_memory: bool,
-        cache_path: str,
-        func: Callable,
-        *args, **kwargs
-    ):
 
+def _cache_registry_func(in_memory: bool, cache_path: str, func: Callable, *args, **kwargs):
     cache_dir = Path(cache_path)
     cache_dir.mkdir(parents=True, exist_ok=True)
     cache_file = cache_dir / func.__qualname__
 
     if in_memory and cache_file.exists():
-        with cache_file.open('rb') as f:
+        with cache_file.open("rb") as f:
             return pickle.load(f)
 
     call = func(*args, **kwargs)
-    with cache_file.open('wb') as f:
-        pickle.dump(call , f)
+    with cache_file.open("wb") as f:
+        pickle.dump(call, f)
 
     return call
 
 
 def error_logging(debug: bool = False):
-    '''
+    """
     Log the error of a function call.
-    '''
+    """
+
     def dec(func):
         @functools.wraps(func)
         def _dec(*args, **kwargs):
@@ -263,11 +262,13 @@ def error_logging(debug: bool = False):
                 logger.error(e)
                 if debug:
                     # Simple message:
-                    UserMessage(f'Function: {func.__name__} call failed. Error: {e}')
+                    UserMessage(f"Function: {func.__name__} call failed. Error: {e}")
                     # print traceback
                     traceback.print_exc()
                 raise e
+
         return _dec
+
     return dec
 
 
@@ -289,18 +290,21 @@ def deprecated(reason: str = ""):
             @deprecated("Use new_method() instead")
             def old_method(self): pass
     """
+
     def decorator(obj):
         if isinstance(obj, type):
             # If obj is a class
             original_init = obj.__init__
+
             @functools.wraps(original_init)
             def new_init(self, *args, **kwargs):
                 logger.warning(
                     f"{obj.__name__} is deprecated and will be removed in future versions. {reason}",
                     category=DeprecationWarning,
-                    stacklevel=2
+                    stacklevel=2,
                 )
                 original_init(self, *args, **kwargs)
+
             obj.__init__ = new_init
             return obj
 
@@ -310,9 +314,10 @@ def deprecated(reason: str = ""):
             logger.warning(
                 f"{obj.__name__} is deprecated and will be removed in future versions. {reason}",
                 category=DeprecationWarning,
-                stacklevel=2
+                stacklevel=2,
             )
             return obj(*args, **kwargs)
+
         return wrapper
 
     return decorator

symai/endpoints/api.py

@@ -1,7 +1,7 @@
 import importlib
 import inspect
 import pickle
-from typing import Any
+from typing import Any, Generic, TypeVar
 
 import redis
 from fastapi import APIRouter, FastAPI, HTTPException, Security, status
@@ -17,10 +17,11 @@ 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."""
@@ -30,26 +31,31 @@ def is_redis_running(host: str, port: int) -> bool:
         UserMessage(f"Redis server is running at {host}:{port}")
         return True
     except RedisConnectionError:
-        UserMessage(f"Redis server is not running at {host}:{port} or is not reachable - falling back to in-memory storage")
+        UserMessage(
+            f"Redis server is not running at {host}:{port} or is not reachable - falling back to in-memory storage"
+        )
         return False
 
 
-class GenericRepository[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.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."""
@@ -72,7 +78,7 @@ class GenericRepository[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)
@@ -89,38 +95,44 @@ class GenericRepository[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[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')
+    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,
@@ -129,14 +141,21 @@ def _load_extended_types():
         sales_module.ErikJames,
     ]
 
-app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_credentials=True, allow_methods=["*"], allow_headers=["*"])
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
 
 ### Symbols Endpoints ###
 
 
 class CreateSymbolRequest(BaseModel):
-    value: Any | None          = None
-    static_context: str | None = ''
+    value: Any | None = None
+    static_context: str | None = ""
 
 
 class UpdateSymbolRequest(BaseModel):
@@ -148,6 +167,7 @@ class SymbolMethodRequest(BaseModel):
     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 is None:
         return True
@@ -158,6 +178,7 @@ 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)):
     symbol = Symbol(symbol_request.value, static_context=symbol_request.static_context)
@@ -175,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")
@@ -195,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}
 
@@ -218,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)
@@ -235,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:
@@ -246,19 +280,30 @@ def call_expression(expression_id: str, method_request: SymbolMethodRequest, _ap
 
 @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")
@@ -288,17 +333,17 @@ 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_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):
@@ -315,7 +360,9 @@ def create_component(request: CreateComponentGenericRequest, _api_key: str = Sec
     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}
 
 
@@ -333,7 +380,7 @@ def get_component(instance_id: str, _api_key: str = Security(get_api_key)):
 @core_ext.error_logging(debug=DEBUG)
 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):
@@ -351,7 +398,9 @@ def generic_forward(request: GenericRequest, _api_key: str = Security(get_api_ke
 
 
 @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")
@@ -374,14 +423,16 @@ def delete_component(instance_id: str, _api_key: str = Security(get_api_key)):
 # 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_args: list[Any] = []
     init_kwargs: dict[str, Any] = {}
 
 
@@ -447,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:
@@ -464,7 +517,9 @@ 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"}