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

symai/functional.py

@@ -49,13 +49,12 @@ class ProbabilisticBooleanMode(Enum):
 ENGINE_PROBABILISTIC_BOOLEAN_MODE = ProbabilisticBooleanMode.MEDIUM
 
 
-
 def _probabilistic_bool(rsp: str, mode=ProbabilisticBooleanMode.TOLERANT) -> bool:
     if rsp is None:
         return False
     # check if rsp is a string / hard match
     val = str(rsp).lower()
-    if   mode == ProbabilisticBooleanMode.STRICT:
+    if mode == ProbabilisticBooleanMode.STRICT:
         return val == ProbabilisticBooleanModeStrict
     if mode == ProbabilisticBooleanMode.MEDIUM:
         return val in ProbabilisticBooleanModeMedium
@@ -73,7 +72,9 @@ def _cast_collection_response(rsp: Any, return_constraint: type) -> Any:
         logger.warning(f"Failed to cast return type to {return_constraint} for {rsp!s}")
         warnings.warn(f"Failed to cast return type to {return_constraint}", stacklevel=2)
         res = rsp
-    assert res is not None, f"Return type cast failed! Check if the return type is correct or post_processors output matches desired format: {rsp!s}"
+    assert res is not None, (
+        f"Return type cast failed! Check if the return type is correct or post_processors output matches desired format: {rsp!s}"
+    )
     return res
 
 
@@ -93,7 +94,9 @@ def _cast_with_fallback(rsp: Any, return_constraint: type) -> Any:
         return rsp
 
 
-def _cast_return_type(rsp: Any, return_constraint: type, engine_probabilistic_boolean_mode: ProbabilisticBooleanMode) -> Any:
+def _cast_return_type(
+    rsp: Any, return_constraint: type, engine_probabilistic_boolean_mode: ProbabilisticBooleanMode
+) -> Any:
     if return_constraint is inspect._empty:
         return rsp
     if issubclass(return_constraint, BaseModel):
@@ -109,7 +112,10 @@ def _cast_return_type(rsp: Any, return_constraint: type, engine_probabilistic_bo
         return _cast_with_fallback(rsp, return_constraint)
     return rsp
 
-def _apply_postprocessors(outputs, return_constraint, post_processors, argument, mode=ENGINE_PROBABILISTIC_BOOLEAN_MODE):
+
+def _apply_postprocessors(
+    outputs, return_constraint, post_processors, argument, mode=ENGINE_PROBABILISTIC_BOOLEAN_MODE
+):
     if argument.prop.preview:
         return outputs
 
@@ -118,7 +124,7 @@ def _apply_postprocessors(outputs, return_constraint, post_processors, argument,
     argument.prop.metadata = metadata
 
     if argument.prop.raw_output:
-        return metadata.get('raw_output'), metadata
+        return metadata.get("raw_output"), metadata
 
     if post_processors:
         for pp in post_processors:
@@ -127,29 +133,36 @@ def _apply_postprocessors(outputs, return_constraint, post_processors, argument,
 
     for constraint in argument.prop.constraints:
         if not constraint(rsp):
-            UserMessage(f"Constraint not satisfied for value {rsp!r} with constraint {constraint}", raise_with=ConstraintViolationException)
+            UserMessage(
+                f"Constraint not satisfied for value {rsp!r} with constraint {constraint}",
+                raise_with=ConstraintViolationException,
+            )
     return rsp, metadata
 
 
 def _apply_preprocessors(argument, instance: Any, pre_processors: list[PreProcessor] | None) -> str:
-    processed_input = ''
+    processed_input = ""
     if pre_processors and not argument.prop.raw_input:
         argument.prop.instance = instance
         for pp in pre_processors:
             t = pp(argument)
-            processed_input += t if t is not None else ''
+            processed_input += t if t is not None else ""
     else:
         if argument.args and len(argument.args) > 0:
-            processed_input      += ' '.join([str(a) for a in argument.args])
+            processed_input += " ".join([str(a) for a in argument.args])
     return processed_input
 
 
 def _limit_number_results(rsp: Any, argument, return_type):
-    limit_ = argument.prop.limit if argument.prop.limit else (len(rsp) if hasattr(rsp, '__len__') else None)
+    limit_ = (
+        argument.prop.limit
+        if argument.prop.limit
+        else (len(rsp) if hasattr(rsp, "__len__") else None)
+    )
     # the following line is different from original code to make it work for iterable return types when the limit is 1
     if limit_ is not None:
         if return_type is str and isinstance(rsp, list):
-            return '\n'.join(rsp[:limit_])
+            return "\n".join(rsp[:limit_])
         if return_type is list:
             return rsp[:limit_]
         if return_type is dict:
@@ -162,25 +175,38 @@ def _limit_number_results(rsp: Any, argument, return_type):
     return rsp
 
 
-def _prepare_argument(argument: Any, engine: Any, instance: Any, func: Callable, constraints: list[Callable], default: Any, limit: int, trials: int, pre_processors: list[PreProcessor] | None, post_processors: list[PostProcessor] | None) -> Any:
+def _prepare_argument(
+    argument: Any,
+    engine: Any,
+    instance: Any,
+    func: Callable,
+    constraints: list[Callable],
+    default: Any,
+    limit: int,
+    trials: int,
+    pre_processors: list[PreProcessor] | None,
+    post_processors: list[PostProcessor] | None,
+) -> Any:
     # check signature for return type
     sig = inspect.signature(func)
     return_constraint = sig._return_annotation
-    assert 'typing' not in str(return_constraint), "Return type must be of base type not generic Typing object, e.g. int, str, list, etc."
+    assert "typing" not in str(return_constraint), (
+        "Return type must be of base type not generic Typing object, e.g. int, str, list, etc."
+    )
 
     # prepare argument container
-    argument.prop.engine            = engine
-    argument.prop.instance          = instance
-    argument.prop.instance_type     = type(instance)
-    argument.prop.signature         = sig
-    argument.prop.func              = func
-    argument.prop.constraints       = constraints
+    argument.prop.engine = engine
+    argument.prop.instance = instance
+    argument.prop.instance_type = type(instance)
+    argument.prop.signature = sig
+    argument.prop.func = func
+    argument.prop.constraints = constraints
     argument.prop.return_constraint = return_constraint
-    argument.prop.default           = default
-    argument.prop.limit             = limit
-    argument.prop.trials            = trials
-    argument.prop.pre_processors    = pre_processors
-    argument.prop.post_processors   = post_processors
+    argument.prop.default = default
+    argument.prop.limit = limit
+    argument.prop.trials = trials
+    argument.prop.pre_processors = pre_processors
+    argument.prop.post_processors = post_processors
     return argument
 
 
@@ -209,16 +235,18 @@ def _execute_query_fallback(func, instance, argument, error=None, stack_trace=No
     raise error from None
 
 
-def _process_query_single(engine,
-                          instance,
-                          func: Callable,
-                          constraints: list[Callable] | None = None,
-                          default: object | None = None,
-                          limit: int = 1,
-                          trials: int = 1,
-                          pre_processors: list[PreProcessor] | None = None,
-                          post_processors: list[PostProcessor] | None = None,
-                          argument=None):
+def _process_query_single(
+    engine,
+    instance,
+    func: Callable,
+    constraints: list[Callable] | None = None,
+    default: object | None = None,
+    limit: int = 1,
+    trials: int = 1,
+    pre_processors: list[PreProcessor] | None = None,
+    post_processors: list[PostProcessor] | None = None,
+    argument=None,
+):
     if constraints is None:
         constraints = []
     if pre_processors and not isinstance(pre_processors, list):
@@ -226,7 +254,18 @@ def _process_query_single(engine,
     if post_processors and not isinstance(post_processors, list):
         post_processors = [post_processors]
 
-    argument = _prepare_argument(argument, engine, instance, func, constraints, default, limit, trials, pre_processors, post_processors)
+    argument = _prepare_argument(
+        argument,
+        engine,
+        instance,
+        func,
+        constraints,
+        default,
+        limit,
+        trials,
+        pre_processors,
+        post_processors,
+    )
 
     preprocessed_input = _apply_preprocessors(argument, instance, pre_processors)
     argument.prop.processed_input = preprocessed_input
@@ -237,14 +276,18 @@ def _process_query_single(engine,
     for _ in range(trials):
         try:
             outputs = engine.executor_callback(argument)
-            result, metadata = _apply_postprocessors(outputs, argument.prop.return_constraint, post_processors, argument)
+            result, metadata = _apply_postprocessors(
+                outputs, argument.prop.return_constraint, post_processors, argument
+            )
             break
         except Exception as e:
             stack_trace = traceback.format_exc()
             logger.error(f"Failed to execute query: {e!s}")
             logger.error(f"Stack trace: {stack_trace}")
             if _ == trials - 1:
-                result = _execute_query_fallback(func, instance, argument, error=e, stack_trace=stack_trace)
+                result = _execute_query_fallback(
+                    func, instance, argument, error=e, stack_trace=stack_trace
+                )
                 if result is None:
                     raise e
 
@@ -254,8 +297,10 @@ def _process_query_single(engine,
     return limited_result
 
 
-def _normalize_processors(pre_processors: list[PreProcessor] | PreProcessor | None,
-                          post_processors: list[PostProcessor] | PostProcessor | None) -> tuple[list[PreProcessor] | None, list[PostProcessor] | None]:
+def _normalize_processors(
+    pre_processors: list[PreProcessor] | PreProcessor | None,
+    post_processors: list[PostProcessor] | PostProcessor | None,
+) -> tuple[list[PreProcessor] | None, list[PostProcessor] | None]:
     if pre_processors and not isinstance(pre_processors, list):
         pre_processors = [pre_processors]
     if post_processors and not isinstance(post_processors, list):
@@ -264,14 +309,14 @@ def _normalize_processors(pre_processors: list[PreProcessor] | PreProcessor | No
 
 
 def _run_query_with_retries(
-        engine: Engine,
-        argument: Any,
-        func: Callable,
-        instance: Any,
-        trials: int,
-        return_constraint: type,
-        post_processors: list[PostProcessor] | None,
-    ) -> tuple[Any, Any]:
+    engine: Engine,
+    argument: Any,
+    func: Callable,
+    instance: Any,
+    trials: int,
+    return_constraint: type,
+    post_processors: list[PostProcessor] | None,
+) -> tuple[Any, Any]:
     try_cnt = 0
     rsp = None
     metadata = None
@@ -279,7 +324,9 @@ def _run_query_with_retries(
         try_cnt += 1
         try:
             outputs = _execute_query(engine, argument)
-            rsp, metadata = _apply_postprocessors(outputs, return_constraint, post_processors, argument)
+            rsp, metadata = _apply_postprocessors(
+                outputs, return_constraint, post_processors, argument
+            )
             break
         except Exception as error:
             stack_trace = traceback.format_exc()
@@ -287,7 +334,9 @@ def _run_query_with_retries(
             logger.error(f"Stack trace: {stack_trace}")
             if try_cnt < trials:
                 continue
-            rsp = _execute_query_fallback(func, instance, argument, error=error, stack_trace=stack_trace)
+            rsp = _execute_query_fallback(
+                func, instance, argument, error=error, stack_trace=stack_trace
+            )
             metadata = None
     return rsp, metadata
 
@@ -297,34 +346,46 @@ def _execute_query(engine, argument) -> list[object]:
     engine.prepare(argument)
     if argument.prop.preview:
         return engine.preview(argument)
-    return engine(argument) # currently only supports single query
+    return engine(argument)  # currently only supports single query
 
 
 def _process_query(
-        engine: Engine,
-        instance: Any,
-        func: Callable,
-        constraints: list[Callable] | None = None,
-        default: object | None = None,
-        limit: int | None = None,
-        trials: int = 1,
-        pre_processors: list[PreProcessor] | None = None,
-        post_processors: list[PostProcessor] | None = None,
-        argument: Argument = None,
-    ) -> Any:
-
+    engine: Engine,
+    instance: Any,
+    func: Callable,
+    constraints: list[Callable] | None = None,
+    default: object | None = None,
+    limit: int | None = None,
+    trials: int = 1,
+    pre_processors: list[PreProcessor] | None = None,
+    post_processors: list[PostProcessor] | None = None,
+    argument: Argument = None,
+) -> Any:
     if constraints is None:
         constraints = []
     pre_processors, post_processors = _normalize_processors(pre_processors, post_processors)
 
-    argument = _prepare_argument(argument, engine, instance, func, constraints, default, limit, trials, pre_processors, post_processors)
+    argument = _prepare_argument(
+        argument,
+        engine,
+        instance,
+        func,
+        constraints,
+        default,
+        limit,
+        trials,
+        pre_processors,
+        post_processors,
+    )
     return_constraint = argument.prop.return_constraint
     # if prep_processors is empty or none this returns an empty string
     processed_input = _apply_preprocessors(argument, instance, pre_processors)
     if not argument.prop.raw_input:
         argument.prop.processed_input = processed_input
 
-    rsp, metadata = _run_query_with_retries(engine, argument, func, instance, trials, return_constraint, post_processors)
+    rsp, metadata = _run_query_with_retries(
+        engine, argument, func, instance, trials, return_constraint, post_processors
+    )
     if argument.prop.preview:
         if argument.prop.return_metadata:
             return rsp, metadata
@@ -341,7 +402,7 @@ class EngineRepository:
     _instance = None
 
     def __init__(self):
-        if '_engines' not in self.__dict__:  # ensures _engines is only set once
+        if "_engines" not in self.__dict__:  # ensures _engines is only set once
             self._engines: dict[str, Engine] = {}
 
     def __new__(cls, *_args, **_kwargs):
@@ -355,31 +416,50 @@ class EngineRepository:
         self = EngineRepository()
         # Check if the engine is already registered
         if id in self._engines and not allow_engine_override:
-            UserMessage(f"Engine {id} is already registered. Set allow_engine_override to True to override.", raise_with=ValueError)
+            UserMessage(
+                f"Engine {id} is already registered. Set allow_engine_override to True to override.",
+                raise_with=ValueError,
+            )
 
         self._engines[id] = engine_instance
 
     @staticmethod
-    def register_from_plugin(id: str, plugin: str, selected_engine: str | None = None, allow_engine_override: bool = False, *args, **kwargs) -> None:
+    def register_from_plugin(
+        id: str,
+        plugin: str,
+        selected_engine: str | None = None,
+        allow_engine_override: bool = False,
+        *args,
+        **kwargs,
+    ) -> None:
         # Lazy import keeps functional -> imports -> symbol -> core -> functional cycle broken.
-        from .imports import Import # noqa
+        from .imports import Import  # noqa
+
         types = Import.load_module_class(plugin)
         # filter out engine class type
         engines = [t for t in types if issubclass(t, Engine) and t is not Engine]
         if len(engines) > 1 and selected_engine is None:
-            UserMessage(f"Multiple engines found in plugin {plugin}. Please specify the engine to use.", raise_with=ValueError)
+            UserMessage(
+                f"Multiple engines found in plugin {plugin}. Please specify the engine to use.",
+                raise_with=ValueError,
+            )
         if len(engines) > 1 and selected_engine is not None:
             engine = [e for e in engines if selected_engine in str(e)]
             if len(engine) <= 0:
-                UserMessage(f"No engine named {selected_engine} found in plugin {plugin}.", raise_with=ValueError)
+                UserMessage(
+                    f"No engine named {selected_engine} found in plugin {plugin}.",
+                    raise_with=ValueError,
+                )
         engine = engines[0](*args, **kwargs)
         EngineRepository.register(id, engine, allow_engine_override=allow_engine_override)
 
     @staticmethod
-    def register_from_package(package: ModuleType, allow_engine_override: bool = False, *args, **kwargs) -> None:
+    def register_from_package(
+        package: ModuleType, allow_engine_override: bool = False, *args, **kwargs
+    ) -> None:
         self = EngineRepository()
         # Iterate over all modules in the given package and import them
-        for _, module_name, _ in pkgutil.iter_modules(package.__path__, package.__name__ + '.'):
+        for _, module_name, _ in pkgutil.iter_modules(package.__path__, package.__name__ + "."):
             module = importlib.import_module(module_name)
 
             # Check all classes defined in the module
@@ -387,25 +467,35 @@ class EngineRepository:
                 attribute = getattr(module, attribute_name)
 
                 # Register class if it is a subclass of Engine (but not Engine itself)
-                if inspect.isclass(attribute) and issubclass(attribute, Engine) and attribute is not Engine:
+                if (
+                    inspect.isclass(attribute)
+                    and issubclass(attribute, Engine)
+                    and attribute is not Engine
+                ):
                     try:
-                        instance = attribute(*args, **kwargs) # Create an instance of the engine class
+                        instance = attribute(
+                            *args, **kwargs
+                        )  # Create an instance of the engine class
                         # Assume the class has an 'init' static method to initialize it
-                        engine_id_func_ = getattr(instance, 'id', None)
+                        engine_id_func_ = getattr(instance, "id", None)
                         if engine_id_func_ is None:
-                            UserMessage(f"Engine {instance!s} does not have an id. Please add a method id() to the class.", raise_with=ValueError)
+                            UserMessage(
+                                f"Engine {instance!s} does not have an id. Please add a method id() to the class.",
+                                raise_with=ValueError,
+                            )
                         # call engine_() to get the id of the engine
                         id_ = engine_id_func_()
                         # only registered configured engine
                         if id_ != ENGINE_UNREGISTERED:
                             # register new engine
-                            self.register(id_, instance, allow_engine_override=allow_engine_override)
+                            self.register(
+                                id_, instance, allow_engine_override=allow_engine_override
+                            )
                     except Exception as e:
                         logger.error(f"Failed to register engine {attribute!s}: {e!s}")
 
     @staticmethod
     def get(engine_name: str, *_args, **_kwargs):
-
         self = EngineRepository()
         # First check if we're in the context manager that dynamically changes models
         if engine_name == "neurosymbolic":
@@ -415,10 +505,13 @@ class EngineRepository:
 
         # Otherwise, fallback to normal lookup:
         if engine_name not in self._engines:
-            subpackage_name = engine_name.replace('-', '_')
+            subpackage_name = engine_name.replace("-", "_")
             subpackage = importlib.import_module(f"{engines.__package__}.{subpackage_name}", None)
             if subpackage is None:
-                UserMessage(f"The symbolicai library does not contain the engine named {engine_name}.", raise_with=ValueError)
+                UserMessage(
+                    f"The symbolicai library does not contain the engine named {engine_name}.",
+                    raise_with=ValueError,
+                )
             self.register_from_package(subpackage)
         engine = self._engines.get(engine_name, None)
         if engine is None:
@@ -435,7 +528,7 @@ class EngineRepository:
         self = EngineRepository()
         if isinstance(engines, str):
             engines = [engines]
-        if 'all' in engines:
+        if "all" in engines:
             # Call the command function for all registered engines with provided arguments
             return [engine.command(*args, **kwargs) for name, engine in self._engines.items()]
         # Call the command function for the engine with provided arguments
@@ -452,7 +545,7 @@ class EngineRepository:
         self = EngineRepository()
         engine = self.get(engine)
         if engine:
-            engine_allows_batching = getattr(engine, 'allows_batching', False)
+            engine_allows_batching = getattr(engine, "allows_batching", False)
             if engine_allows_batching:
                 return _process_query_single(engine, *args, **kwargs)
             return _process_query(engine, *args, **kwargs)
@@ -480,14 +573,19 @@ class EngineRepository:
 
         # 2) Fallback: walk ONLY current thread frames (legacy behavior)
         # Keeping DynamicEngine import lazy prevents functional importing components before it finishes loading.
-        from .components import DynamicEngine # noqa
+        from .components import DynamicEngine  # noqa
+
         try:
             frame = sys._getframe()
         except Exception:
             return None
         while frame:
             try:
-                locals_copy = frame.f_locals.copy() if hasattr(frame.f_locals, 'copy') else dict(frame.f_locals)
+                locals_copy = (
+                    frame.f_locals.copy()
+                    if hasattr(frame.f_locals, "copy")
+                    else dict(frame.f_locals)
+                )
             except Exception:
                 UserMessage(
                     "Unexpected failure copying frame locals while resolving DynamicEngine.",
@@ -495,7 +593,7 @@ class EngineRepository:
                 )
                 locals_copy = {}
             for value in locals_copy.values():
-                if isinstance(value, DynamicEngine) and getattr(value, '_entered', False):
+                if isinstance(value, DynamicEngine) and getattr(value, "_entered", False):
                     return value.engine_instance
             frame = frame.f_back
         return None