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

symai/pre_processors.py

@@ -1,17 +1,17 @@
 import traceback
-from typing import Any, List, Optional
+from typing import Any
 
 from .utils import prep_as_str
 
 
 class PreProcessor:
     def __call__(self, argument) -> Any:
-        raise NotImplementedError()
+        raise NotImplementedError
 
 
 class RawInputPreProcessor(PreProcessor):
     def __call__(self, argument) -> Any:
-        return f"{str(argument.prop.prompt)}"
+        return f"{argument.prop.prompt!s}"
 
 
 class JsonPreProcessor(PreProcessor):
@@ -19,7 +19,7 @@ class JsonPreProcessor(PreProcessor):
         assert len(argument.args) == 1
         self.format = format
         value = str(argument.args[0])
-        return f'{value} => [JSON_BEGIN]'
+        return f"{value} => [JSON_BEGIN]"
 
 
 class FormatPreProcessor(PreProcessor):
@@ -36,7 +36,7 @@ class EqualsPreProcessor(PreProcessor):
         assert len(argument.args) == 1
         a = prep_as_str(argument.prop.instance)
         b = prep_as_str(argument.args[0])
-        return f'{a} == {b} =>'
+        return f"{a} == {b} =>"
 
 
 class InterpretExpressionPreProcessor(PreProcessor):
@@ -50,7 +50,7 @@ class IndexPreProcessor(PreProcessor):
         assert len(argument.args) == 1
         a = prep_as_str(argument.prop.instance)
         b = prep_as_str(argument.args[0])
-        return f'{a} index {b} =>'
+        return f"{a} index {b} =>"
 
 
 class SetIndexPreProcessor(PreProcessor):
@@ -59,7 +59,7 @@ class SetIndexPreProcessor(PreProcessor):
         a = prep_as_str(argument.prop.instance)
         b = prep_as_str(argument.args[0])
         c = prep_as_str(argument.args[1])
-        return f'{a} index {b} set {c} =>'
+        return f"{a} index {b} set {c} =>"
 
 
 class DeleteIndexPreProcessor(PreProcessor):
@@ -67,7 +67,7 @@ class DeleteIndexPreProcessor(PreProcessor):
         assert len(argument.args) == 1
         a = prep_as_str(argument.prop.instance)
         b = prep_as_str(argument.args[0])
-        return f'{a} remove {b} =>'
+        return f"{a} remove {b} =>"
 
 
 class PromptPreProcessor(PreProcessor):
@@ -81,7 +81,7 @@ class ComparePreProcessor(PreProcessor):
         comp = argument.prop.operator
         a = prep_as_str(argument.prop.instance)
         b = prep_as_str(argument.args[0])
-        return f"{a} {str(comp)} {b} =>"
+        return f"{a} {comp!s} {b} =>"
 
 
 class RankPreProcessor(PreProcessor):
@@ -91,22 +91,22 @@ class RankPreProcessor(PreProcessor):
         measure = argument.prop.measure if argument.prop.measure else argument.args[0]
         list_ = prep_as_str(argument.prop.instance)
         # convert to list if not already a list
-        if '|' in list_ and not '[' in list_:
-            list_ = [v.strip() for v in list_.split('|') if len(v.strip()) > 0]
+        if "|" in list_ and "[" not in list_:
+            list_ = [v.strip() for v in list_.split("|") if len(v.strip()) > 0]
             list_ = str(list_)
-        return f"order: '{str(order)}' measure: '{str(measure)}' list: {list_} =>"
+        return f"order: '{order!s}' measure: '{measure!s}' list: {list_} =>"
 
 
 class ReplacePreProcessor(PreProcessor):
     def __call__(self, argument) -> Any:
         assert len(argument.args) == 2
-        return f"text '{argument.prop.instance}' replace '{str(argument.args[0])}' with '{str(argument.args[1])}'=>"
+        return f"text '{argument.prop.instance}' replace '{argument.args[0]!s}' with '{argument.args[1]!s}'=>"
 
 
 class IncludePreProcessor(PreProcessor):
     def __call__(self, argument) -> Any:
         assert len(argument.args) == 1
-        return f"text '{argument.prop.instance}' include '{str(argument.args[0])}' =>"
+        return f"text '{argument.prop.instance}' include '{argument.args[0]!s}' =>"
 
 
 class CombinePreProcessor(PreProcessor):
@@ -122,9 +122,12 @@ class TemplatePreProcessor(PreProcessor):
         placeholder = argument.prop.placeholder
         template = argument.prop.template
         parts = str(template).split(placeholder)
-        assert len(parts) == 2, f"Your template must contain exactly one placeholder '{placeholder}' split:" + str(len(parts))
+        assert len(parts) == 2, (
+            f"Your template must contain exactly one placeholder '{placeholder}' split:"
+            + str(len(parts))
+        )
         argument.prop.template_suffix = parts[1]
-        return f'----------\n[Template]:\n{parts[0]}'
+        return f"----------\n[Template]:\n{parts[0]}"
 
 
 class NegatePreProcessor(PreProcessor):
@@ -168,14 +171,14 @@ class IsInstanceOfPreProcessor(PreProcessor):
 class ExtractPatternPreProcessor(PreProcessor):
     def __call__(self, argument) -> Any:
         assert len(argument.args) == 1
-        return f"from '{str(argument.prop.instance)}' extract '{str(argument.args[0])}' =>"
+        return f"from '{argument.prop.instance!s}' extract '{argument.args[0]!s}' =>"
 
 
 class SimpleSymbolicExpressionPreProcessor(PreProcessor):
     def __call__(self, argument) -> Any:
         assert len(argument.args) >= 1
         val = str(argument.args[0])
-        val = val.replace('self', str(argument.prop.instance))
+        val = val.replace("self", str(argument.prop.instance))
         return f"expr :{val} =: =>"
 
 
@@ -193,87 +196,89 @@ class SemanticMappingPreProcessor(PreProcessor):
         assert len(argument.args) >= 1
         topics = list(argument.prop.subscriber.keys())
         assert len(topics) > 0
-        return f"topics {str(topics)} in\ntext: '{str(argument.args[0])}' =>"
+        return f"topics {topics!s} in\ntext: '{argument.args[0]!s}' =>"
 
 
 class SimulateCodePreProcessor(PreProcessor):
     def __call__(self, argument) -> Any:
-        val = argument.args[0] if len(argument.args) > 0 else ''
-        return f"code '{str(argument.prop.instance)}' params '{str(val)}' =>"
+        val = argument.args[0] if len(argument.args) > 0 else ""
+        return f"code '{argument.prop.instance!s}' params '{val!s}' =>"
 
 
 class GenerateCodePreProcessor(PreProcessor):
     def __call__(self, argument) -> Any:
-        return f"description '{str(argument.prop.instance)}' =>"
+        return f"description '{argument.prop.instance!s}' =>"
 
 
 class TextToOutlinePreProcessor(PreProcessor):
     def __call__(self, argument) -> Any:
-        return f"text '{str(argument.prop.instance)}' =>"
+        return f"text '{argument.prop.instance!s}' =>"
 
 
 class UniquePreProcessor(PreProcessor):
     def __call__(self, argument) -> Any:
         unique = argument.prop.keys
-        val = f'List of keys: {unique}\n'
-        return f"{val}text '{str(argument.prop.instance)}' =>"
+        val = f"List of keys: {unique}\n"
+        return f"{val}text '{argument.prop.instance!s}' =>"
 
 
 class GenerateTextPreProcessor(PreProcessor):
     def __call__(self, argument) -> Any:
-        return f"{str(argument.prop.instance)}"
+        return f"{argument.prop.instance!s}"
 
 
 class ClusterPreProcessor(PreProcessor):
     def __call__(self, argument) -> Any:
-        assert isinstance(argument.prop.instance.value, list), "ClusterPreProcessor can only be applied to a list"
+        assert isinstance(argument.prop.instance.value, list), (
+            "ClusterPreProcessor can only be applied to a list"
+        )
         return argument.prop.instance.value
 
 
 class ForEachPreProcessor(PreProcessor):
     def __call__(self, argument) -> Any:
-        val   = prep_as_str(argument.prop.instance)
-        cond  = argument.prop.condition
+        val = prep_as_str(argument.prop.instance)
+        cond = argument.prop.condition
         apply = argument.prop.apply
         return f"{val} foreach '{cond}' apply '{apply}' =>"
 
 
 class MapPreProcessor(PreProcessor):
     def __call__(self, argument) -> Any:
-        val     = prep_as_str(argument.prop.instance)
+        val = prep_as_str(argument.prop.instance)
         context = argument.prop.context
-        return f"{val} map '{str(context)}' =>"
+        return f"{val} map '{context!s}' =>"
 
 
 class ListPreProcessor(PreProcessor):
     def __call__(self, argument) -> Any:
-        val  = prep_as_str(argument.prop.instance)
+        val = prep_as_str(argument.prop.instance)
         cond = argument.prop.condition
         return f"{val} list '{cond}' =>"
 
 
 class QueryPreProcessor(PreProcessor):
     def __call__(self, argument) -> Any:
-        val   = f'Data:\n{str(argument.prop.instance)}\n'
+        val = f"Data:\n{argument.prop.instance!s}\n"
         query = f"Context: {argument.prop.context}\n"
         return f"{val}{query}Answer:"
 
 
 class SufficientInformationPreProcessor(PreProcessor):
     def __call__(self, argument) -> Any:
-        val   = prep_as_str(argument.prop.instance)
+        val = prep_as_str(argument.prop.instance)
         query = prep_as_str(argument.prop.query)
-        return f'query {query} content {val} =>'
+        return f"query {query} content {val} =>"
 
 
 class ExpandFunctionPreProcessor(PreProcessor):
     def __call__(self, argument) -> Any:
         val = prep_as_str(argument.prop.instance)
-        return f'{val} =>\ndef'
+        return f"{val} =>\ndef"
 
 
 class ArgsPreProcessor(PreProcessor):
-    def __init__(self, format: str = '') -> None:
+    def __init__(self, format: str = "") -> None:
         self.format = format
 
     def __call__(self, argument) -> Any:
@@ -285,14 +290,14 @@ class ArgsPreProcessor(PreProcessor):
 class ModifyPreProcessor(PreProcessor):
     def __call__(self, argument) -> Any:
         changes = argument.prop.changes
-        return f"text '{str(argument.prop.instance)}' modify '{str(changes)}'=>"
+        return f"text '{argument.prop.instance!s}' modify '{changes!s}'=>"
 
 
 class FilterPreProcessor(PreProcessor):
     def __call__(self, argument) -> Any:
         criteria = argument.prop.criteria
-        include = 'include' if argument.prop.include else 'remove'
-        return f"text '{str(argument.prop.instance)}' {include} '{str(criteria)}' =>"
+        include = "include" if argument.prop.include else "remove"
+        return f"text '{argument.prop.instance!s}' {include} '{criteria!s}' =>"
 
 
 class MapExpressionPreProcessor(PreProcessor):
@@ -303,58 +308,56 @@ class MapExpressionPreProcessor(PreProcessor):
 
 
 class ArgsToInputPreProcessor(PreProcessor):
-    def __init__(self, skip: Optional[List[int]] = None) -> None:
+    def __init__(self, skip: list[int] | None = None) -> None:
         super().__init__()
         skip = [skip] if skip and isinstance(skip, int) else skip
         self.skip = skip if skip is not None else []
 
     def __call__(self, argument) -> Any:
-        input_ = ''
+        input_ = ""
         for i, arg in enumerate(argument.args):
             if i in self.skip:
                 continue
-            input_ += f"{str(arg)}\n"
+            input_ += f"{arg!s}\n"
         return input_
 
 
 class SelfToInputPreProcessor(PreProcessor):
-    def __init__(self, skip: Optional[List[int]] = None) -> None:
+    def __init__(self, skip: list[int] | None = None) -> None:
         super().__init__()
         skip = [skip] if skip and isinstance(skip, int) else skip
         self.skip = skip if skip is not None else []
 
     def __call__(self, argument) -> Any:
-        input_ = f'{str(argument.prop.instance)}\n'
-        return input_
+        return f"{argument.prop.instance!s}\n"
 
 
 class DataTemplatePreProcessor(PreProcessor):
-    def __init__(self, skip: Optional[List[int]] = None) -> None:
+    def __init__(self, skip: list[int] | None = None) -> None:
         super().__init__()
         self.skip = skip if skip is not None else []
 
     def __call__(self, argument) -> Any:
-        input_ = f'[Data]:\n{str(argument.prop.instance)}\n'
+        input_ = f"[Data]:\n{argument.prop.instance!s}\n"
         for i, arg in enumerate(argument.args):
             if i in self.skip:
                 continue
-            input_ += f"{str(arg)}\n"
+            input_ += f"{arg!s}\n"
         return input_
 
 
 class ConsoleInputPreProcessor(PreProcessor):
-    def __init__(self, skip: Optional[List[int]] = None) -> None:
+    def __init__(self, skip: list[int] | None = None) -> None:
         super().__init__()
         skip = [skip] if skip and isinstance(skip, int) else skip
         self.skip = skip if skip is not None else []
 
     def __call__(self, argument) -> Any:
-        input_ = f'\n{str(argument.args[0])}\n$> '
-        return input_
+        return f"\n{argument.args[0]!s}\n$> "
 
 
 class ConsolePreProcessor(PreProcessor):
-    def __init__(self, skip: Optional[List[int]] = None) -> None:
+    def __init__(self, skip: list[int] | None = None) -> None:
         super().__init__()
         skip = [skip] if skip and isinstance(skip, int) else skip
         self.skip = skip if skip is not None else []
@@ -363,10 +366,10 @@ class ConsolePreProcessor(PreProcessor):
         # _func is called as: _func(self, self.value, *method_args, **method_kwargs)
         # argument.args[0] == symbol value, argument.prop.instance == Symbol object
         if argument.args:
-            symbol_obj   = argument.prop.instance
+            symbol_obj = argument.prop.instance
             symbol_value = argument.args[0]
-            method_args  = argument.args[1:]
-            object_ = f"symbol_value: {repr(symbol_value)}"
+            method_args = argument.args[1:]
+            object_ = f"symbol_value: {symbol_value!r}"
 
             # kwargs passed at Symbol-construction time (e.g. test_kwarg=…)
             if symbol_obj._kwargs:
@@ -381,13 +384,11 @@ class ConsolePreProcessor(PreProcessor):
         return object_
 
 
-
-
 class LanguagePreProcessor(PreProcessor):
     def __call__(self, argument) -> Any:
         language = argument.prop.language
         argument.prop.prompt = argument.prop.prompt.format(language)
-        return f"{str(argument.prop.instance)}"
+        return f"{argument.prop.instance!s}"
 
 
 class TextFormatPreProcessor(PreProcessor):
@@ -408,15 +409,18 @@ class TranscriptionPreProcessor(PreProcessor):
 class StylePreProcessor(PreProcessor):
     def __call__(self, argument) -> Any:
         description = argument.prop.description
-        text = f'[FORMAT]: {description}\n'
-        libs = ', '.join(argument.prop.libraries)
+        text = f"[FORMAT]: {description}\n"
+        libs = ", ".join(argument.prop.libraries)
         libraries = f"[LIBRARIES]: {libs}\n"
-        content = f'[DATA]:\n{str(argument.prop.instance)}\n\n'
+        content = f"[DATA]:\n{argument.prop.instance!s}\n\n"
         if argument.prop.template:
             placeholder = argument.prop.placeholder
-            template    = argument.prop.template
-            parts       = str(template).split(placeholder)
-            assert len(parts) == 2, f"Your template must contain exactly one placeholder '{placeholder}'  split:" + str(len(parts))
+            template = argument.prop.template
+            parts = str(template).split(placeholder)
+            assert len(parts) == 2, (
+                f"Your template must contain exactly one placeholder '{placeholder}'  split:"
+                + str(len(parts))
+            )
             argument.prop.template_suffix = parts[1]
             return f'f"{text}{libraries}{content}"----------\n[TEMPLATE]:\n{parts[0]}'
         return f"{text}{libraries}{content}"
@@ -439,9 +443,9 @@ class UnwrapListSymbolsPreProcessor(PreProcessor):
 class ExceptionPreProcessor(PreProcessor):
     def __call__(self, argument) -> Any:
         ctxt = prep_as_str(argument.prop.instance)
-        ctxt = f"{ctxt}\n" if ctxt and len(ctxt) > 0 else ''
-        val  = argument.prop.query
-        e    = argument.prop.exception
+        ctxt = f"{ctxt}\n" if ctxt and len(ctxt) > 0 else ""
+        val = argument.prop.query
+        e = argument.prop.exception
         exception = "".join(traceback.format_exception_only(type(e), e)).strip()
         return f"context '{val}' exception '{exception}' code'{ctxt}' =>"
 
@@ -449,47 +453,47 @@ class ExceptionPreProcessor(PreProcessor):
 class CorrectionPreProcessor(PreProcessor):
     def __call__(self, argument) -> Any:
         ctxt = prep_as_str(argument.prop.instance)
-        ctxt = f"{ctxt}\n" if ctxt and len(ctxt) > 0 else ''
-        val  = argument.prop.context
-        exception = ''
+        ctxt = f"{ctxt}\n" if ctxt and len(ctxt) > 0 else ""
+        val = argument.prop.context
+        exception = ""
         if not argument.prop.exception:
-            e         = argument.prop.exception
-            err_msg   = "".join(traceback.format_exception_only(type(e), e)).strip()
+            e = argument.prop.exception
+            err_msg = "".join(traceback.format_exception_only(type(e), e)).strip()
             exception = f" exception '{err_msg}'"
         return f'context "{val}"{exception} code "{ctxt}" =>'
 
 
 class EnumPreProcessor(PreProcessor):
     def __call__(self, argument) -> Any:
-        return f'[{", ".join([str(x) for x in argument.prop.enum])}]\n'
+        return f"[{', '.join([str(x) for x in argument.prop.enum])}]\n"
 
 
 class TextMessagePreProcessor(PreProcessor):
     def __call__(self, argument) -> Any:
-        return f'Text: {str(argument.prop.instance)}\n'
+        return f"Text: {argument.prop.instance!s}\n"
 
 
 class SummaryPreProcessing(PreProcessor):
     def __call__(self, argument) -> Any:
-        ctxt = f"Context: {argument.prop.context} " if argument.prop.context else ''
-        return f'{ctxt}Text: {str(argument.prop.instance)}\n'
+        ctxt = f"Context: {argument.prop.context} " if argument.prop.context else ""
+        return f"{ctxt}Text: {argument.prop.instance!s}\n"
 
 
 class CleanTextMessagePreProcessor(PreProcessor):
     def __call__(self, argument) -> Any:
-        return f"Text: '{str(argument.prop.instance)}' =>"
+        return f"Text: '{argument.prop.instance!s}' =>"
 
 
 class PredictionMessagePreProcessor(PreProcessor):
-    def __call__(self, argument) -> Any:
-        return f'Prediction:'
+    def __call__(self, _argument) -> Any:
+        return "Prediction:"
 
 
 class ArrowMessagePreProcessor(PreProcessor):
     def __call__(self, argument) -> Any:
-        return f'{str(argument.prop.instance)} =>'
+        return f"{argument.prop.instance!s} =>"
 
 
 class ValuePreProcessor(PreProcessor):
     def __call__(self, argument) -> Any:
-        return f'{str(argument.prop.instance)}'
+        return f"{argument.prop.instance!s}"

symai/processor.py

@@ -1,17 +1,18 @@
-from typing import Any, Optional, List, Union
-from .pre_processors import PreProcessor
+from typing import Any
+
 from .post_processors import PostProcessor
+from .pre_processors import PreProcessor
 
 
 class ProcessorPipeline:
-    '''
+    """
     Base class for all processors.
 
     Args:
         processors: A list of processors to be applied to the response.
-    '''
+    """
 
-    def __init__(self, processors: Optional[List[Union[PreProcessor, PostProcessor]]] = None) -> None:
+    def __init__(self, processors: list[PreProcessor | PostProcessor] | None = None) -> None:
         self.processors = processors
 
     def __call__(self, *args: Any, **kwds: Any) -> Any:
@@ -20,18 +21,25 @@ class ProcessorPipeline:
 
         if isinstance(self.processors[0], PreProcessor):
             assert len(args) == 1, f"Expected 1 argument of type Argument, got {len(args)}"
-            processed_input               = ''
+            processed_input = ""
             for processor in self.processors:
-                assert isinstance(processor, PreProcessor), f"Expected PreProcessor, got {type(processor)}"
-                argument         = args[0]
-                t                = processor(argument, **kwds)
-                processed_input += t if t is not None else ''
+                assert isinstance(processor, PreProcessor), (
+                    f"Expected PreProcessor, got {type(processor)}"
+                )
+                argument = args[0]
+                t = processor(argument, **kwds)
+                processed_input += t if t is not None else ""
             return processed_input
 
-        elif isinstance(self.processors[0], PostProcessor):
-            assert len(args) == 2, f"Expected 2 arguments of type Response and Argument, got {len(args)}"
+        if isinstance(self.processors[0], PostProcessor):
+            assert len(args) == 2, (
+                f"Expected 2 arguments of type Response and Argument, got {len(args)}"
+            )
             response, argument = args
             for processor in self.processors:
-                assert isinstance(processor, PostProcessor), f"Expected PostProcessor, got {type(processor)}"
+                assert isinstance(processor, PostProcessor), (
+                    f"Expected PostProcessor, got {type(processor)}"
+                )
                 response = processor(response, argument, **kwds)
             return response
+        return None