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

symai/core.py

@@ -1,5 +1,6 @@
 import functools
-from typing import Any, Callable, Dict, List, Optional, Type
+from collections.abc import Callable
+from typing import Any
 
 from box import Box
 
@@ -9,6 +10,44 @@ from . import prompts as prm
 from .functional import EngineRepository
 from .symbol import Expression, Metadata
 
+# Module-level singletons used to provide default prompt and processor instances.
+_PREPROCESSOR_EXPAND_FUNCTION = pre.ExpandFunctionPreProcessor()
+_PROMPT_CLEAN_TEXT = prm.CleanText()
+_PROMPT_COMBINE_TEXT = prm.CombineText()
+_PROMPT_COMPARE_VALUES = prm.CompareValues()
+_PROMPT_CONTAINS_VALUE = prm.ContainsValue()
+_PROMPT_ENDS_WITH = prm.EndsWith()
+_PROMPT_EXCEPTION_MAPPING = prm.ExceptionMapping()
+_PROMPT_EXPAND_FUNCTION = prm.ExpandFunction()
+_PROMPT_EXTRACT_PATTERN = prm.ExtractPattern()
+_PROMPT_FILTER = prm.Filter()
+_PROMPT_FOR_EACH = prm.ForEach()
+_PROMPT_FORMAT = prm.Format()
+_PROMPT_FUZZY_EQUALS = prm.FuzzyEquals()
+_PROMPT_GENERATE_CODE = prm.GenerateCode()
+_PROMPT_INCLUDE_TEXT = prm.IncludeText()
+_PROMPT_INDEX = prm.Index()
+_PROMPT_INVERT_EXPRESSION = prm.InvertExpression()
+_PROMPT_IS_INSTANCE_OF = prm.IsInstanceOf()
+_PROMPT_LIST_OBJECTS = prm.ListObjects()
+_PROMPT_LOGIC_EXPRESSION = prm.LogicExpression()
+_PROMPT_MAP_CONTENT = prm.MapContent()
+_PROMPT_MAP_EXPRESSION = prm.MapExpression()
+_PROMPT_MODIFY = prm.Modify()
+_PROMPT_NEGATE_STATEMENT = prm.NegateStatement()
+_PROMPT_RANK_LIST = prm.RankList()
+_PROMPT_REMOVE_INDEX = prm.RemoveIndex()
+_PROMPT_REPLACE_TEXT = prm.ReplaceText()
+_PROMPT_SEMANTIC_MAPPING = prm.SemanticMapping()
+_PROMPT_SET_INDEX = prm.SetIndex()
+_PROMPT_SIMPLE_SYMBOLIC_EXPRESSION = prm.SimpleSymbolicExpression()
+_PROMPT_SIMULATE_CODE = prm.SimulateCode()
+_PROMPT_STARTS_WITH = prm.StartsWith()
+_PROMPT_SUFFICIENT_INFORMATION = prm.SufficientInformation()
+_PROMPT_TEXT_TO_OUTLINE = prm.TextToOutline()
+_PROMPT_TRANSCRIPTION = prm.Transcription()
+_PROMPT_UNIQUE_KEY = prm.UniqueKey()
+
 
 class Argument(Expression):
     _default_suppress_verbose_output            = False
@@ -24,51 +63,41 @@ class Argument(Expression):
                                                        decorator_kwargs=decorator_kwargs)
         self.prop             = Metadata()
         self._set_all_kwargs_as_properties()
-        # Set default values if not specified for backend processing
-        # Reserved keywords
-        if 'preview' not in self.kwargs: # used for previewing the input (also for operators)
-            self.prop.preview = Argument._default_preview_value
-        if 'raw_input' not in self.kwargs:
-            self.prop.raw_input = False
-        if 'raw_output' not in self.kwargs:
-            self.prop.raw_output = False
-        if 'return_metadata' not in self.kwargs:
-            self.prop.return_metadata = False
-        if 'logging' not in self.kwargs:
-            self.prop.logging = False
-        if 'verbose' not in self.kwargs:
-            self.prop.verbose = False
-        if 'self_prompt' not in self.kwargs:
-            self.prop.self_prompt = False
-        if 'truncation_percentage' not in self.kwargs:
-            self.prop.truncation_percentage = None
-        if 'truncation_type' not in self.kwargs:
-            self.prop.truncation_type = 'tail'
-        if 'response_format' not in self.kwargs:
-            self.prop.response_format = None
-        if 'log_level' not in self.kwargs:
-            self.prop.log_level = None
-        if 'time_clock' not in self.kwargs:
-            self.prop.time_clock = None
-        if 'payload' not in self.kwargs:
-            self.prop.payload = None
-        if 'processed_input' not in self.kwargs:
-            self.prop.processed_input = None
-        if 'template_suffix' not in self.kwargs:
-            self.prop.template_suffix = None
-        if 'input_handler' not in self.kwargs:
-            self.prop.input_handler = None
-        if 'output_handler' not in self.kwargs:
-            self.prop.output_handler = None
-        if 'suppress_verbose_output' not in self.kwargs:
-            self.prop.suppress_verbose_output = Argument._default_suppress_verbose_output
-        if 'parse_system_instructions' not in self.kwargs:
-            self.prop.parse_system_instructions = Argument._default_parse_system_instructions
+        self._apply_default_properties()
 
     def _set_all_kwargs_as_properties(self):
         for key, value in self.kwargs.items():
             setattr(self.prop, key, value)
 
+    def _apply_default_properties(self):
+        # Set default values if not specified for backend processing
+        # Reserved keywords
+        default_properties = {
+            # used for previewing the input (also for operators)
+            'preview': Argument._default_preview_value,
+            'raw_input': False,
+            'raw_output': False,
+            'return_metadata': False,
+            'logging': False,
+            'verbose': False,
+            'self_prompt': False,
+            'truncation_percentage': None,
+            'truncation_type': 'tail',
+            'response_format': None,
+            'log_level': None,
+            'time_clock': None,
+            'payload': None,
+            'processed_input': None,
+            'template_suffix': None,
+            'input_handler': None,
+            'output_handler': None,
+            'suppress_verbose_output': Argument._default_suppress_verbose_output,
+            'parse_system_instructions': Argument._default_parse_system_instructions,
+        }
+        for key, default_value in default_properties.items():
+            if key not in self.kwargs:
+                setattr(self.prop, key, default_value)
+
     @property
     def value(self):
         return Box({
@@ -99,14 +128,18 @@ class Argument(Expression):
 
 
 def few_shot(prompt: str = '',
-             examples: prm.Prompt = [],
-             constraints: List[Callable] = [],
+             examples: prm.Prompt = None,
+             constraints: list[Callable] | None = None,
              default: Any = None,
              limit: int = 1,
-             pre_processors: Optional[List[pre.PreProcessor]] = None,
-             post_processors: Optional[List[post.PostProcessor]] = None,
+             pre_processors: list[pre.PreProcessor] | None = None,
+             post_processors: list[post.PostProcessor] | None = None,
              **decorator_kwargs):
     """"General decorator for the neural processing engine."""
+    if constraints is None:
+        constraints = []
+    if examples is None:
+        examples = []
     def decorator(func):
         @functools.wraps(func)
         def wrapper(instance, *signature_args, **signature_kwargs):
@@ -129,13 +162,15 @@ def few_shot(prompt: str = '',
 
 
 def zero_shot(prompt: str = '',
-              constraints: List[Callable] = [],
-              default: Optional[object] = None,
+              constraints: list[Callable] | None = None,
+              default: object | None = None,
               limit: int = 1,
-              pre_processors: Optional[List[pre.PreProcessor]] = None,
-              post_processors: Optional[List[post.PostProcessor]] = None,
+              pre_processors: list[pre.PreProcessor] | None = None,
+              post_processors: list[post.PostProcessor] | None = None,
               **decorator_kwargs):
     """"General decorator for the neural processing engine."""
+    if constraints is None:
+        constraints = []
     return few_shot(prompt,
                     examples=[],
                     constraints=constraints,
@@ -155,15 +190,21 @@ def prompt(message: str,
 
 
 def summarize(prompt: str = 'Summarize the content of the following text:\n',
-              context: Optional[str] = None,
-              constraints: List[Callable] = [],
-              default: Optional[object] = None,
+              context: str | None = None,
+              constraints: list[Callable] | None = None,
+              default: object | None = None,
               limit: int = 1,
-              stop: str | None = None,
-              pre_processors: Optional[List[pre.PreProcessor]] = [pre.SummaryPreProcessing()],
-              post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor()],
+              stop: str | list[str] = '',
+              pre_processors: list[pre.PreProcessor] | None = None,
+              post_processors: list[post.PostProcessor] | None = None,
               **decorator_kwargs):
     """Summarizes the content of a text."""
+    if post_processors is None:
+        post_processors = [post.StripPostProcessor()]
+    if pre_processors is None:
+        pre_processors = [pre.SummaryPreProcessing()]
+    if constraints is None:
+        constraints = []
     return few_shot(prompt,
                     context=context,
                     examples=[],
@@ -179,14 +220,20 @@ def summarize(prompt: str = 'Summarize the content of the following text:\n',
 def equals(context: str = 'contextually',
            default: bool = False,
            prompt: str = "Make a fuzzy equals comparison; are the following objects {} the same?\n",
-           examples: prm.Prompt = prm.FuzzyEquals(),
-           constraints: List[Callable] = [],
+           examples: prm.Prompt = _PROMPT_FUZZY_EQUALS,
+           constraints: list[Callable] | None = None,
            limit: int = 1,
-           stop: str | None = None,
-           pre_processors: Optional[List[pre.PreProcessor]] = [pre.EqualsPreProcessor()],
-           post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor()],
+           stop: str | list[str] = '',
+           pre_processors: list[pre.PreProcessor] | None = None,
+           post_processors: list[post.PostProcessor] | None = None,
            **decorator_kwargs):
     """Equality function for two objects."""
+    if post_processors is None:
+        post_processors = [post.StripPostProcessor()]
+    if pre_processors is None:
+        pre_processors = [pre.EqualsPreProcessor()]
+    if constraints is None:
+        constraints = []
     return few_shot(prompt=prompt.format(context),
                     examples=examples,
                     constraints=constraints,
@@ -202,14 +249,20 @@ def equals(context: str = 'contextually',
 def sufficient(query: str,
                prompt: str = "Consider if there is sufficient information to answer the query:\n",
                default: bool = False,
-               examples: prm.Prompt = prm.SufficientInformation(),
-               constraints: List[Callable] = [],
+               examples: prm.Prompt = _PROMPT_SUFFICIENT_INFORMATION,
+               constraints: list[Callable] | None = None,
                limit: int = 1,
-               stop: str | None = None,
-               pre_processors: Optional[List[pre.PreProcessor]] = [pre.SufficientInformationPreProcessor()],
-               post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor()],
+               stop: str | list[str] = '',
+               pre_processors: list[pre.PreProcessor] | None = None,
+               post_processors: list[post.PostProcessor] | None = None,
                **decorator_kwargs) -> bool:
     """Determines if there is sufficient information to answer the given query."""
+    if post_processors is None:
+        post_processors = [post.StripPostProcessor()]
+    if pre_processors is None:
+        pre_processors = [pre.SufficientInformationPreProcessor()]
+    if constraints is None:
+        constraints = []
     return few_shot(prompt=prompt,
                     query=query,
                     examples=examples,
@@ -223,16 +276,22 @@ def sufficient(query: str,
                     **decorator_kwargs)
 
 
-def delitem(default: Optional[str] = None,
+def delitem(default: str | None = None,
             prompt: str = "Delete the items at the index position:\n",
-            examples: prm.Prompt = prm.RemoveIndex(),
-            constraints: List[Callable] = [],
+            examples: prm.Prompt = _PROMPT_REMOVE_INDEX,
+            constraints: list[Callable] | None = None,
             limit: int = 1,
-            stop: str | None = None,
-            pre_processors: Optional[List[pre.PreProcessor]] = [pre.DeleteIndexPreProcessor()],
-            post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor()],
+            stop: str | list[str] = '',
+            pre_processors: list[pre.PreProcessor] | None = None,
+            post_processors: list[post.PostProcessor] | None = None,
             **decorator_kwargs):
     """Deletes the items at the specified index position."""
+    if post_processors is None:
+        post_processors = [post.StripPostProcessor()]
+    if pre_processors is None:
+        pre_processors = [pre.DeleteIndexPreProcessor()]
+    if constraints is None:
+        constraints = []
     return few_shot(prompt=prompt,
                     examples=examples,
                     constraints=constraints,
@@ -244,16 +303,22 @@ def delitem(default: Optional[str] = None,
                     **decorator_kwargs)
 
 
-def setitem(default: Optional[str] = None,
+def setitem(default: str | None = None,
             prompt: str = "Set item at index position:\n",
-            examples: prm.Prompt = prm.SetIndex(),
-            constraints: List[Callable] = [],
+            examples: prm.Prompt = _PROMPT_SET_INDEX,
+            constraints: list[Callable] | None = None,
             limit: int = 1,
-            stop: str | None = None,
-            pre_processors: Optional[List[pre.PreProcessor]] = [pre.SetIndexPreProcessor()],
-            post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor()],
+            stop: str | list[str] = '',
+            pre_processors: list[pre.PreProcessor] | None = None,
+            post_processors: list[post.PostProcessor] | None = None,
             **decorator_kwargs):
     """Sets an item at a given index position in a sequence."""
+    if post_processors is None:
+        post_processors = [post.StripPostProcessor()]
+    if pre_processors is None:
+        pre_processors = [pre.SetIndexPreProcessor()]
+    if constraints is None:
+        constraints = []
     return few_shot(prompt=prompt,
                     examples=examples,
                     constraints=constraints,
@@ -265,16 +330,22 @@ def setitem(default: Optional[str] = None,
                     **decorator_kwargs)
 
 
-def getitem(default: Optional[str] = None,
+def getitem(default: str | None = None,
             prompt: str = "Get item at index position:\n",
-            examples: prm.Prompt = prm.Index(),
-            constraints: List[Callable] = [],
+            examples: prm.Prompt = _PROMPT_INDEX,
+            constraints: list[Callable] | None = None,
             limit: int = 1,
-            stop: str | None = None,
-            pre_processors: Optional[List[pre.PreProcessor]] = [pre.IndexPreProcessor()],
-            post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor()],
+            stop: str | list[str] = '',
+            pre_processors: list[pre.PreProcessor] | None = None,
+            post_processors: list[post.PostProcessor] | None = None,
             **decorator_kwargs):
     """Retrieves the item at the given index position."""
+    if post_processors is None:
+        post_processors = [post.StripPostProcessor()]
+    if pre_processors is None:
+        pre_processors = [pre.IndexPreProcessor()]
+    if constraints is None:
+        constraints = []
     return few_shot(prompt=prompt,
                     examples=examples,
                     constraints=constraints,
@@ -287,16 +358,22 @@ def getitem(default: Optional[str] = None,
 
 
 def modify(changes: str,
-           default: Optional[str] = None,
+           default: str | None = None,
            prompt: str = "Modify the text to match the criteria:\n",
-           examples: prm.Prompt = prm.Modify(),
-           constraints: List[Callable] = [],
+           examples: prm.Prompt = _PROMPT_MODIFY,
+           constraints: list[Callable] | None = None,
            limit: int = 1,
-           stop: str | None = None,
-           pre_processors: Optional[List[pre.PreProcessor]] = [pre.ModifyPreProcessor()],
-           post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor()],
+           stop: str | list[str] = '',
+           pre_processors: list[pre.PreProcessor] | None = None,
+           post_processors: list[post.PostProcessor] | None = None,
            **decorator_kwargs):
     """A function to modify a text based on a set of criteria."""
+    if post_processors is None:
+        post_processors = [post.StripPostProcessor()]
+    if pre_processors is None:
+        pre_processors = [pre.ModifyPreProcessor()]
+    if constraints is None:
+        constraints = []
     return few_shot(prompt=prompt,
                     changes=changes,
                     examples=examples,
@@ -311,16 +388,22 @@ def modify(changes: str,
 
 def filtering(criteria: str,
               include: bool = False,
-              default: Optional[str] = None,
+              default: str | None = None,
               prompt: str = "Filter the information from the text based on the filter criteria. Leave sentences unchanged if they are unrelated to the filter criteria:\n",
-              examples: prm.Prompt = prm.Filter(),
-              constraints: List[Callable] = [],
+              examples: prm.Prompt = _PROMPT_FILTER,
+              constraints: list[Callable] | None = None,
               limit: int = 1,
-              stop: str | None = None,
-              pre_processors: Optional[List[pre.PreProcessor]] = [pre.FilterPreProcessor()],
-              post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor()],
+              stop: str | list[str] = '',
+              pre_processors: list[pre.PreProcessor] | None = None,
+              post_processors: list[post.PostProcessor] | None = None,
               **decorator_kwargs):
     """Filter information from a text based on a set of criteria."""
+    if post_processors is None:
+        post_processors = [post.StripPostProcessor()]
+    if pre_processors is None:
+        pre_processors = [pre.FilterPreProcessor()]
+    if constraints is None:
+        constraints = []
     return few_shot(prompt=prompt,
                     criteria=criteria,
                     include=include,
@@ -334,17 +417,24 @@ def filtering(criteria: str,
                     **decorator_kwargs)
 
 
-def map(instruction: str,
-       default: str | None = None,
-       prompt: str = "Transform each element in the input based on the instruction. Preserve container type and elements that don't match the instruction:\n",
-       examples: prm.Prompt = prm.MapExpression(),
-       constraints: list[Callable] = [],
-       limit: int | None = 1,
-       stop: str | None = None,
-       pre_processors: list[pre.PreProcessor] | None = [pre.MapExpressionPreProcessor()],
-       post_processors: list[post.PostProcessor] | None = [post.StripPostProcessor(), post.ASTPostProcessor()],
-       **decorator_kwargs):
+def map( # noqa: A001
+        instruction: str,
+        default: str | None = None,
+        prompt: str = "Transform each element in the input based on the instruction. Preserve container type and elements that don't match the instruction:\n",
+        examples: prm.Prompt = _PROMPT_MAP_EXPRESSION,
+        constraints: list[Callable] | None = None,
+        limit: int | None = 1,
+        stop: str | list[str] = '',
+        pre_processors: list[pre.PreProcessor] | None = None,
+        post_processors: list[post.PostProcessor] | None = None,
+        **decorator_kwargs):
     """Semantic mapping operation that applies an instruction to each element in an iterable."""
+    if post_processors is None:
+        post_processors = [post.StripPostProcessor(), post.ASTPostProcessor()]
+    if pre_processors is None:
+        pre_processors = [pre.MapExpressionPreProcessor()]
+    if constraints is None:
+        constraints = []
     return few_shot(prompt=prompt,
                     examples=examples,
                     constraints=constraints,
@@ -357,17 +447,23 @@ def map(instruction: str,
                     **decorator_kwargs)
 
 
-def notify(subscriber: Dict[str, Callable],
-           default: Optional[object] = None,
+def notify(subscriber: dict[str, Callable],
+           default: object | None = None,
            prompt: str = "List the semantically related topics:\n",
-           examples: prm.Prompt = prm.SemanticMapping(),
-           constraints: List[Callable] = [],
+           examples: prm.Prompt = _PROMPT_SEMANTIC_MAPPING,
+           constraints: list[Callable] | None = None,
            limit: int | None = 1,
-           stop: str | None = None,
-           pre_processors: Optional[List[pre.PreProcessor]] = [pre.SemanticMappingPreProcessor()],
-           post_processors: Optional[List[post.PostProcessor]] = [post.SplitPipePostProcessor(), post.NotifySubscriberPostProcessor()],
+           stop: str | list[str] = '',
+           pre_processors: list[pre.PreProcessor] | None = None,
+           post_processors: list[post.PostProcessor] | None = None,
            **decorator_kwargs):
     """Notify subscribers based on a set of topics if detected in the input text and matching the key of the subscriber."""
+    if post_processors is None:
+        post_processors = [post.SplitPipePostProcessor(), post.NotifySubscriberPostProcessor()]
+    if pre_processors is None:
+        pre_processors = [pre.SemanticMappingPreProcessor()]
+    if constraints is None:
+        constraints = []
     return few_shot(prompt=prompt,
                     subscriber=subscriber,
                     examples=examples,
@@ -383,14 +479,20 @@ def notify(subscriber: Dict[str, Callable],
 def compare(default: bool = False,
             operator: str = '>',
             prompt: str = "Compare 'A' and 'B' based on the operator:\n",
-            examples: prm.Prompt = prm.CompareValues(),
-            constraints: List[Callable] = [],
+            examples: prm.Prompt = _PROMPT_COMPARE_VALUES,
+            constraints: list[Callable] | None = None,
             limit: int | None = 1,
-            stop: str | None = None,
-            pre_processors: Optional[List[pre.PreProcessor]] = [pre.ComparePreProcessor()],
-            post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor()],
+            stop: str | list[str] = '',
+            pre_processors: list[pre.PreProcessor] | None = None,
+            post_processors: list[post.PostProcessor] | None = None,
             **decorator_kwargs):
     """Compare two objects based on the specified operator."""
+    if post_processors is None:
+        post_processors = [post.StripPostProcessor()]
+    if pre_processors is None:
+        pre_processors = [pre.ComparePreProcessor()]
+    if constraints is None:
+        constraints = []
     return few_shot(prompt=prompt,
                     examples=examples,
                     constraints=constraints,
@@ -404,17 +506,24 @@ def compare(default: bool = False,
                     **decorator_kwargs)
 
 
-def convert(format: str,
-            default: Optional[str] = None,
-            prompt: str = "Translate the following text into {} format.\n",
-            examples: prm.Prompt = prm.Format(),
-            constraints: List[Callable] = [],
-            limit: int | None = 1,
-            stop: str | None = None,
-            pre_processors: Optional[List[pre.PreProcessor]] = [pre.TextFormatPreProcessor()],
-            post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor()],
-            **decorator_kwargs):
+def convert(
+        format: str,
+        default: str | None = None,
+        prompt: str = "Translate the following text into {} format.\n",
+        examples: prm.Prompt = _PROMPT_FORMAT,
+        constraints: list[Callable] | None = None,
+        limit: int | None = 1,
+        stop: str | list[str] = '',
+        pre_processors: list[pre.PreProcessor] | None = None,
+        post_processors: list[post.PostProcessor] | None = None,
+        **decorator_kwargs):
     """Transformation operation from one format to another."""
+    if post_processors is None:
+        post_processors = [post.StripPostProcessor()]
+    if pre_processors is None:
+        pre_processors = [pre.TextFormatPreProcessor()]
+    if constraints is None:
+        constraints = []
     return few_shot(prompt=prompt,
                     examples=examples,
                     constraints=constraints,
@@ -428,16 +537,22 @@ def convert(format: str,
 
 
 def transcribe(modify: str,
-               default: Optional[str] = None,
+               default: str | None = None,
                prompt: str = "Transcribe the following text by only modifying the text by the provided instruction.\n",
-               examples: prm.Prompt = prm.Transcription(),
-               constraints: List[Callable] = [],
+               examples: prm.Prompt = _PROMPT_TRANSCRIPTION,
+               constraints: list[Callable] | None = None,
                limit: int | None = 1,
-               stop: str | None = None,
-               pre_processors: Optional[List[pre.PreProcessor]] = [pre.TranscriptionPreProcessor()],
-               post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor()],
+               stop: str | list[str] = '',
+               pre_processors: list[pre.PreProcessor] | None = None,
+               post_processors: list[post.PostProcessor] | None = None,
                **decorator_kwargs):
     """Transcription operation of a text to another styled text."""
+    if post_processors is None:
+        post_processors = [post.StripPostProcessor()]
+    if pre_processors is None:
+        pre_processors = [pre.TranscriptionPreProcessor()]
+    if constraints is None:
+        constraints = []
     return few_shot(prompt=prompt,
                     examples=examples,
                     constraints=constraints,
@@ -451,16 +566,24 @@ def transcribe(modify: str,
 
 
 def style(description: str,
-          libraries: List[str] = [],
-          default: Optional[str] = None,
+          libraries: list[str] | None = None,
+          default: str | None = None,
           prompt: str = "Style the [DATA] based on best practices and the descriptions in [...] brackets. Do not remove content from the data! Do not add libraries or other descriptions. \n",
-          constraints: List[Callable] = [],
+          constraints: list[Callable] | None = None,
           limit: int | None = 1,
-          stop: str | None = None,
-          pre_processors: Optional[List[pre.PreProcessor]] = [pre.StylePreProcessor()],
-          post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor()],
+          stop: str | list[str] = '',
+          pre_processors: list[pre.PreProcessor] | None = None,
+          post_processors: list[post.PostProcessor] | None = None,
           **decorator_kwargs):
     """Styles a given text based on best practices and a given description."""
+    if post_processors is None:
+        post_processors = [post.StripPostProcessor()]
+    if pre_processors is None:
+        pre_processors = [pre.StylePreProcessor()]
+    if constraints is None:
+        constraints = []
+    if libraries is None:
+        libraries = []
     return few_shot(prompt=prompt,
                     libraries=libraries,
                     examples=None,
@@ -476,16 +599,22 @@ def style(description: str,
 
 def analyze(query: str,
             exception: Exception,
-            default: Optional[str] = None,
+            default: str | None = None,
             prompt: str = "Only analyze the error message and suggest a potential correction, however, do NOT provide the code!\n",
-            examples: prm.Prompt = prm.ExceptionMapping(),
-            constraints: List[Callable] = [],
+            examples: prm.Prompt = _PROMPT_EXCEPTION_MAPPING,
+            constraints: list[Callable] | None = None,
             limit: int | None = 1,
-            stop: str | None = None,
-            pre_processors: Optional[List[pre.PreProcessor]] = [pre.ExceptionPreProcessor()],
-            post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor()],
+            stop: str | list[str] = '',
+            pre_processors: list[pre.PreProcessor] | None = None,
+            post_processors: list[post.PostProcessor] | None = None,
             **decorator_kwargs):
     """Analyses an Exception and proposes a correction."""
+    if post_processors is None:
+        post_processors = [post.StripPostProcessor()]
+    if pre_processors is None:
+        pre_processors = [pre.ExceptionPreProcessor()]
+    if constraints is None:
+        constraints = []
     return few_shot(prompt=prompt,
                     query=query,
                     exception=exception,
@@ -501,16 +630,22 @@ def analyze(query: str,
 
 def correct(context: str,
             exception: Exception,
-            default: Optional[str] = None,
+            default: str | None = None,
             prompt: str = "Correct the code according to the context description. Use markdown syntax to format the code; do not provide any other text.\n",
-            examples: Optional[prm.Prompt] = None,
-            constraints: List[Callable] = [],
+            examples: prm.Prompt | None = None,
+            constraints: list[Callable] | None = None,
             limit: int | None = 1,
-            stop: str | None = None,
-            pre_processors: Optional[List[pre.PreProcessor]] = [pre.CorrectionPreProcessor()],
-            post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor(), post.CodeExtractPostProcessor()],
+            stop: str | list[str] = '',
+            pre_processors: list[pre.PreProcessor] | None = None,
+            post_processors: list[post.PostProcessor] | None = None,
             **decorator_kwargs):
     """Analyses an Exception and proposes a correction."""
+    if post_processors is None:
+        post_processors = [post.StripPostProcessor(), post.CodeExtractPostProcessor()]
+    if pre_processors is None:
+        pre_processors = [pre.CorrectionPreProcessor()]
+    if constraints is None:
+        constraints = []
     return few_shot(prompt=prompt,
                     context=context,
                     exception=exception,
@@ -527,14 +662,20 @@ def correct(context: str,
 def translate(language: str = 'English',
               default: str = "Sorry, I do not understand the given language.",
               prompt: str = "Your task is to translate and **only** translate the text into {}:\n",
-              examples: Optional[prm.Prompt] = None,
-              constraints: List[Callable] = [],
+              examples: prm.Prompt | None = None,
+              constraints: list[Callable] | None = None,
               limit: int | None = 1,
-              stop: str | None = None,
-              pre_processors: Optional[List[pre.PreProcessor]] = [pre.LanguagePreProcessor()],
-              post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor()],
+              stop: str | list[str] = '',
+              pre_processors: list[pre.PreProcessor] | None = None,
+              post_processors: list[post.PostProcessor] | None = None,
               **decorator_kwargs):
     """Translates a given text into a specified language."""
+    if post_processors is None:
+        post_processors = [post.StripPostProcessor()]
+    if pre_processors is None:
+        pre_processors = [pre.LanguagePreProcessor()]
+    if constraints is None:
+        constraints = []
     return few_shot(prompt=prompt,
                     examples=examples,
                     constraints=constraints,
@@ -547,17 +688,23 @@ def translate(language: str = 'English',
                     **decorator_kwargs)
 
 
-def rank(default: Optional[object] = None,
+def rank(default: object | None = None,
          order: str = 'desc',
          prompt: str = "Order the list of objects based on their quality measure and oder literal:\n",
-         examples: prm.Prompt = prm.RankList(),
-         constraints: List[Callable] = [],
+         examples: prm.Prompt = _PROMPT_RANK_LIST,
+         constraints: list[Callable] | None = None,
          limit: int | None = 1,
-         stop: str | None = None,
-         pre_processors: Optional[List[pre.PreProcessor]] = [pre.RankPreProcessor()],
-         post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor(), post.ASTPostProcessor()],
+         stop: str | list[str] = '',
+         pre_processors: list[pre.PreProcessor] | None = None,
+         post_processors: list[post.PostProcessor] | None = None,
          **decorator_kwargs):
     """Ranks a list of objects based on their quality measure and order literal."""
+    if post_processors is None:
+        post_processors = [post.StripPostProcessor(), post.ASTPostProcessor()]
+    if pre_processors is None:
+        pre_processors = [pre.RankPreProcessor()]
+    if constraints is None:
+        constraints = []
     return few_shot(prompt=prompt,
                     examples=examples,
                     constraints=constraints,
@@ -571,15 +718,21 @@ def rank(default: Optional[object] = None,
 
 
 def replace(prompt: str = "Replace text parts by string pattern.\n",
-            default: Optional[str] = None,
-            examples: prm.Prompt = prm.ReplaceText(),
-            constraints: List[Callable] = [],
+            default: str | None = None,
+            examples: prm.Prompt = _PROMPT_REPLACE_TEXT,
+            constraints: list[Callable] | None = None,
             limit: int | None = 1,
-            stop: str | None = None,
-            pre_processors: Optional[List[pre.PreProcessor]] = [pre.ReplacePreProcessor()],
-            post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor()],
+            stop: str | list[str] = '',
+            pre_processors: list[pre.PreProcessor] | None = None,
+            post_processors: list[post.PostProcessor] | None = None,
             **decorator_kwargs):
     """Replaces text parts by a given string pattern."""
+    if post_processors is None:
+        post_processors = [post.StripPostProcessor()]
+    if pre_processors is None:
+        pre_processors = [pre.ReplacePreProcessor()]
+    if constraints is None:
+        constraints = []
     return few_shot(prompt=prompt,
                     examples=examples,
                     constraints=constraints,
@@ -592,15 +745,21 @@ def replace(prompt: str = "Replace text parts by string pattern.\n",
 
 
 def include(prompt: str = "Include information based on description.\n",
-            default: Optional[str] = None,
-            examples: prm.Prompt = prm.IncludeText(),
-            constraints: List[Callable] = [],
+            default: str | None = None,
+            examples: prm.Prompt = _PROMPT_INCLUDE_TEXT,
+            constraints: list[Callable] | None = None,
             limit: int | None = 1,
-            stop: str | None = None,
-            pre_processors: Optional[List[pre.PreProcessor]] = [pre.IncludePreProcessor()],
-            post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor()],
+            stop: str | list[str] = '',
+            pre_processors: list[pre.PreProcessor] | None = None,
+            post_processors: list[post.PostProcessor] | None = None,
             **decorator_kwargs):
     """Include information from a description."""
+    if post_processors is None:
+        post_processors = [post.StripPostProcessor()]
+    if pre_processors is None:
+        pre_processors = [pre.IncludePreProcessor()]
+    if constraints is None:
+        constraints = []
     return few_shot(prompt=prompt,
                     examples=examples,
                     constraints=constraints,
@@ -613,15 +772,21 @@ def include(prompt: str = "Include information based on description.\n",
 
 
 def combine(prompt: str = "Add the two data types in a logical way:\n",
-            default: Optional[str] = None,
-            examples: prm.Prompt = prm.CombineText(),
-            constraints: List[Callable] = [],
+            default: str | None = None,
+            examples: prm.Prompt = _PROMPT_COMBINE_TEXT,
+            constraints: list[Callable] | None = None,
             limit: int | None = 1,
-            stop: str | None = None,
-            pre_processors: Optional[List[pre.PreProcessor]] = [pre.CombinePreProcessor()],
-            post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor()],
+            stop: str | list[str] = '',
+            pre_processors: list[pre.PreProcessor] | None = None,
+            post_processors: list[post.PostProcessor] | None = None,
             **decorator_kwargs):
     """Combines two data types in a logical way."""
+    if post_processors is None:
+        post_processors = [post.StripPostProcessor()]
+    if pre_processors is None:
+        pre_processors = [pre.CombinePreProcessor()]
+    if constraints is None:
+        constraints = []
     return few_shot(prompt=prompt,
                     examples=examples,
                     constraints=constraints,
@@ -634,15 +799,21 @@ def combine(prompt: str = "Add the two data types in a logical way:\n",
 
 
 def negate(prompt: str = "Negate the following statement:\n",
-           default: Optional[str] = None,
-           examples: prm.Prompt = prm.NegateStatement(),
-           constraints: List[Callable] = [],
+           default: str | None = None,
+           examples: prm.Prompt = _PROMPT_NEGATE_STATEMENT,
+           constraints: list[Callable] | None = None,
            limit: int | None = 1,
-           stop: str | None = None,
-           pre_processors: Optional[List[pre.PreProcessor]] = [pre.NegatePreProcessor()],
-           post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor()],
+           stop: str | list[str] = '',
+           pre_processors: list[pre.PreProcessor] | None = None,
+           post_processors: list[post.PostProcessor] | None = None,
            **decorator_kwargs):
     """Negates a given statement."""
+    if post_processors is None:
+        post_processors = [post.StripPostProcessor()]
+    if pre_processors is None:
+        pre_processors = [pre.NegatePreProcessor()]
+    if constraints is None:
+        constraints = []
     return few_shot(prompt=prompt,
                     examples=examples,
                     constraints=constraints,
@@ -656,14 +827,20 @@ def negate(prompt: str = "Negate the following statement:\n",
 
 def contains(default: bool = False,
              prompt: str = "Is semantically the information of 'A' contained in 'B'?\n",
-             examples: prm.Prompt = prm.ContainsValue(),
-             constraints: List[Callable] = [],
+             examples: prm.Prompt = _PROMPT_CONTAINS_VALUE,
+             constraints: list[Callable] | None = None,
              limit: int | None = 1,
-             stop: str | None = None,
-             pre_processors: Optional[List[pre.PreProcessor]] = [pre.ContainsPreProcessor()],
-             post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor()],
+             stop: str | list[str] = '',
+             pre_processors: list[pre.PreProcessor] | None = None,
+             post_processors: list[post.PostProcessor] | None = None,
              **decorator_kwargs):
     """Determines whether a given string contains another string."""
+    if post_processors is None:
+        post_processors = [post.StripPostProcessor()]
+    if pre_processors is None:
+        pre_processors = [pre.ContainsPreProcessor()]
+    if constraints is None:
+        constraints = []
     return few_shot(prompt=prompt,
                     examples=examples,
                     constraints=constraints,
@@ -678,14 +855,20 @@ def contains(default: bool = False,
 
 def isinstanceof(default: bool = False,
                  prompt: str = "Is 'A' an instance of 'B'?\n",
-                 examples: prm.Prompt = prm.IsInstanceOf(),
-                 constraints: List[Callable] = [],
+                 examples: prm.Prompt = _PROMPT_IS_INSTANCE_OF,
+                 constraints: list[Callable] | None = None,
                  limit: int | None = 1,
-                 stop: str | None = None,
-                 pre_processors: Optional[List[pre.PreProcessor]] = [pre.IsInstanceOfPreProcessor()],
-                 post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor()],
+                 stop: str | list[str] = '',
+                 pre_processors: list[pre.PreProcessor] | None = None,
+                 post_processors: list[post.PostProcessor] | None = None,
                  **decorator_kwargs):
     """Detects if one object is an instance of another."""
+    if post_processors is None:
+        post_processors = [post.StripPostProcessor()]
+    if pre_processors is None:
+        pre_processors = [pre.IsInstanceOfPreProcessor()]
+    if constraints is None:
+        constraints = []
     return few_shot(prompt=prompt,
                     examples=examples,
                     constraints=constraints,
@@ -700,14 +883,20 @@ def isinstanceof(default: bool = False,
 
 def startswith(default: bool = False,
                prompt: str = "Does 'A' start with 'B'?\n",
-               examples: prm.Prompt = prm.StartsWith(),
-               constraints: List[Callable] = [],
+               examples: prm.Prompt = _PROMPT_STARTS_WITH,
+               constraints: list[Callable] | None = None,
                limit: int | None = 1,
-               stop: str | None = None,
-               pre_processors: Optional[List[pre.PreProcessor]] = [pre.StartsWithPreProcessor()],
-               post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor()],
+               stop: str | list[str] = '',
+               pre_processors: list[pre.PreProcessor] | None = None,
+               post_processors: list[post.PostProcessor] | None = None,
                **decorator_kwargs):
     """Determines whether a string starts with a specified prefix."""
+    if post_processors is None:
+        post_processors = [post.StripPostProcessor()]
+    if pre_processors is None:
+        pre_processors = [pre.StartsWithPreProcessor()]
+    if constraints is None:
+        constraints = []
     return few_shot(prompt=prompt,
                     examples=examples,
                     constraints=constraints,
@@ -722,14 +911,20 @@ def startswith(default: bool = False,
 
 def endswith(default: bool = False,
              prompt: str = "Does 'A' end with 'B'?\n",
-             examples: prm.Prompt = prm.EndsWith(),
-             constraints: List[Callable] = [],
+             examples: prm.Prompt = _PROMPT_ENDS_WITH,
+             constraints: list[Callable] | None = None,
              limit: int | None = 1,
-             stop: str | None = None,
-             pre_processors: Optional[List[pre.PreProcessor]] = [pre.EndsWithPreProcessor()],
-             post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor()],
+             stop: str | list[str] = '',
+             pre_processors: list[pre.PreProcessor] | None = None,
+             post_processors: list[post.PostProcessor] | None = None,
              **decorator_kwargs):
     """Determines whether a string ends with a specified suffix."""
+    if post_processors is None:
+        post_processors = [post.StripPostProcessor()]
+    if pre_processors is None:
+        pre_processors = [pre.EndsWithPreProcessor()]
+    if constraints is None:
+        constraints = []
     return few_shot(prompt=prompt,
                     examples=examples,
                     constraints=constraints,
@@ -742,16 +937,20 @@ def endswith(default: bool = False,
                     **decorator_kwargs)
 
 
-def case(enum: List[str],
+def case(enum: list[str],
          default: str,
          prompt: str = "Classify the text according to one of the following categories and return only the category name: ",
-         examples: Optional[prm.Prompt] = None,
+         examples: prm.Prompt | None = None,
          limit: int | None = 1,
-         stop: str | None = None,
-         pre_processors: Optional[List[pre.PreProcessor]] = [pre.EnumPreProcessor(), pre.TextMessagePreProcessor(), pre.PredictionMessagePreProcessor()],
-         post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor(), post.CaseInsensitivePostProcessor()],
+         stop: str | list[str] = '',
+         pre_processors: list[pre.PreProcessor] | None = None,
+         post_processors: list[post.PostProcessor] | None = None,
          **decorator_kwargs):
     """Classifies a text according to one of the given categories."""
+    if post_processors is None:
+        post_processors = [post.StripPostProcessor(), post.CaseInsensitivePostProcessor()]
+    if pre_processors is None:
+        pre_processors = [pre.EnumPreProcessor(), pre.TextMessagePreProcessor(), pre.PredictionMessagePreProcessor()]
     return few_shot(prompt=prompt,
                     examples=examples,
                     default=default,
@@ -764,15 +963,21 @@ def case(enum: List[str],
 
 
 def extract(prompt: str = "Extract a pattern from text:\n",
-            default: Optional[str] = None,
-            examples: prm.Prompt = prm.ExtractPattern(),
-            constraints: List[Callable] = [],
+            default: str | None = None,
+            examples: prm.Prompt = _PROMPT_EXTRACT_PATTERN,
+            constraints: list[Callable] | None = None,
             limit: int | None = 1,
-            stop: str | None = None,
-            pre_processors: Optional[List[pre.PreProcessor]] = [pre.ExtractPatternPreProcessor()],
-            post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor()],
+            stop: str | list[str] = '',
+            pre_processors: list[pre.PreProcessor] | None = None,
+            post_processors: list[post.PostProcessor] | None = None,
             **decorator_kwargs):
     """Extracts a pattern from text."""
+    if post_processors is None:
+        post_processors = [post.StripPostProcessor()]
+    if pre_processors is None:
+        pre_processors = [pre.ExtractPatternPreProcessor()]
+    if constraints is None:
+        constraints = []
     return few_shot(prompt=prompt,
                     examples=examples,
                     constraints=constraints,
@@ -784,11 +989,15 @@ def extract(prompt: str = "Extract a pattern from text:\n",
                     **decorator_kwargs)
 
 def expression(prompt: str = "Evaluate the symbolic expressions:\n",
-               default: Optional[str] = None,
-               pre_processors: Optional[List[pre.PreProcessor]] = [],
-               post_processors: Optional[List[post.PostProcessor]] = [post.WolframAlphaPostProcessor()],
+               default: str | None = None,
+               pre_processors: list[pre.PreProcessor] | None = None,
+               post_processors: list[post.PostProcessor] | None = None,
                **decorator_kwargs):
     """Evaluates the symbolic expressions."""
+    if post_processors is None:
+        post_processors = [post.WolframAlphaPostProcessor()]
+    if pre_processors is None:
+        pre_processors = []
     def decorator(func):
         @functools.wraps(func)
         def wrapper(instance, *signature_args, **signature_kwargs):
@@ -808,15 +1017,21 @@ def expression(prompt: str = "Evaluate the symbolic expressions:\n",
 
 
 def interpret(prompt: str = "Evaluate the symbolic expressions and return only the result:\n",
-              default: Optional[str] = None,
-              examples: prm.Prompt = prm.SimpleSymbolicExpression(),
-              constraints: List[Callable] = [],
+              default: str | None = None,
+              examples: prm.Prompt = _PROMPT_SIMPLE_SYMBOLIC_EXPRESSION,
+              constraints: list[Callable] | None = None,
               limit: int | None = 1,
-              stop: str | None = None,
-              pre_processors: Optional[List[pre.PreProcessor]] = [pre.InterpretExpressionPreProcessor()],
-              post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor()],
+              stop: str | list[str] = '',
+              pre_processors: list[pre.PreProcessor] | None = None,
+              post_processors: list[post.PostProcessor] | None = None,
               **decorator_kwargs):
     """Evaluates the symbolic expressions by interpreting the semantic meaning."""
+    if post_processors is None:
+        post_processors = [post.StripPostProcessor()]
+    if pre_processors is None:
+        pre_processors = [pre.InterpretExpressionPreProcessor()]
+    if constraints is None:
+        constraints = []
     return few_shot(prompt=prompt,
                     examples=examples,
                     constraints=constraints,
@@ -830,15 +1045,21 @@ def interpret(prompt: str = "Evaluate the symbolic expressions and return only t
 
 def logic(prompt: str = "Evaluate the logic expressions:\n",
           operator: str = 'and',
-          default: Optional[str] = None,
-          examples: prm.Prompt = prm.LogicExpression(),
-          constraints: List[Callable] = [],
+          default: str | None = None,
+          examples: prm.Prompt = _PROMPT_LOGIC_EXPRESSION,
+          constraints: list[Callable] | None = None,
           limit: int | None = 1,
-          stop: str | None = None,
-          pre_processors: Optional[List[pre.PreProcessor]] = [pre.LogicExpressionPreProcessor()],
-          post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor()],
+          stop: str | list[str] = '',
+          pre_processors: list[pre.PreProcessor] | None = None,
+          post_processors: list[post.PostProcessor] | None = None,
           **decorator_kwargs):
     """Evaluates a logic expression."""
+    if post_processors is None:
+        post_processors = [post.StripPostProcessor()]
+    if pre_processors is None:
+        pre_processors = [pre.LogicExpressionPreProcessor()]
+    if constraints is None:
+        constraints = []
     return few_shot(prompt=prompt,
                     examples=examples,
                     operator=operator,
@@ -852,15 +1073,21 @@ def logic(prompt: str = "Evaluate the logic expressions:\n",
 
 
 def invert(prompt: str = "Invert the logic of the content:\n",
-           default: Optional[str] = None,
-           examples: prm.Prompt = prm.InvertExpression(),
-           constraints: List[Callable] = [],
+           default: str | None = None,
+           examples: prm.Prompt = _PROMPT_INVERT_EXPRESSION,
+           constraints: list[Callable] | None = None,
            limit: int | None = 1,
-           stop: str | None = None,
-           pre_processors: Optional[List[pre.PreProcessor]] = [pre.ArrowMessagePreProcessor()],
-           post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor()],
+           stop: str | list[str] = '',
+           pre_processors: list[pre.PreProcessor] | None = None,
+           post_processors: list[post.PostProcessor] | None = None,
            **decorator_kwargs):
     """Inverts the logic of a statement."""
+    if post_processors is None:
+        post_processors = [post.StripPostProcessor()]
+    if pre_processors is None:
+        pre_processors = [pre.ArrowMessagePreProcessor()]
+    if constraints is None:
+        constraints = []
     return few_shot(prompt=prompt,
                     examples=examples,
                     constraints=constraints,
@@ -873,15 +1100,21 @@ def invert(prompt: str = "Invert the logic of the content:\n",
 
 
 def simulate(prompt: str = "Simulate the following code:\n",
-             default: Optional[str] = None,
-             examples: prm.Prompt = prm.SimulateCode(),
-             constraints: List[Callable] = [],
+             default: str | None = None,
+             examples: prm.Prompt = _PROMPT_SIMULATE_CODE,
+             constraints: list[Callable] | None = None,
              limit: int | None = 1,
-             stop: str | None = None,
-             pre_processors: Optional[List[pre.PreProcessor]] = [pre.SimulateCodePreProcessor()],
-             post_processors: Optional[List[post.PostProcessor]] = [post.SplitPipePostProcessor(), post.TakeLastPostProcessor()],
+             stop: str | list[str] = '',
+             pre_processors: list[pre.PreProcessor] | None = None,
+             post_processors: list[post.PostProcessor] | None = None,
              **decorator_kwargs):
     """Simulates code and returns the result."""
+    if post_processors is None:
+        post_processors = [post.SplitPipePostProcessor(), post.TakeLastPostProcessor()]
+    if pre_processors is None:
+        pre_processors = [pre.SimulateCodePreProcessor()]
+    if constraints is None:
+        constraints = []
     return few_shot(prompt=prompt,
                     examples=examples,
                     constraints=constraints,
@@ -894,15 +1127,21 @@ def simulate(prompt: str = "Simulate the following code:\n",
 
 
 def code(prompt: str = "Generate code that solves the following problems:\n",
-         default: Optional[str] = None,
-         examples: prm.Prompt = prm.GenerateCode(),
-         constraints: List[Callable] = [],
+         default: str | None = None,
+         examples: prm.Prompt = _PROMPT_GENERATE_CODE,
+         constraints: list[Callable] | None = None,
          limit: int | None = 1,
-         stop: str | None = None,
-         pre_processors: Optional[List[pre.PreProcessor]] = [pre.GenerateCodePreProcessor()],
-         post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor()],
+         stop: str | list[str] = '',
+         pre_processors: list[pre.PreProcessor] | None = None,
+         post_processors: list[post.PostProcessor] | None = None,
          **decorator_kwargs):
     """Generates code that solves a given problem."""
+    if post_processors is None:
+        post_processors = [post.StripPostProcessor()]
+    if pre_processors is None:
+        pre_processors = [pre.GenerateCodePreProcessor()]
+    if constraints is None:
+        constraints = []
     return few_shot(prompt=prompt,
                     examples=examples,
                     constraints=constraints,
@@ -915,15 +1154,21 @@ def code(prompt: str = "Generate code that solves the following problems:\n",
 
 
 def outline(prompt: str = "Outline only the essential content as a short list of bullets. Each bullet is in a new line:\n",
-            default: List[str] = None,
-            examples: prm.Prompt = prm.TextToOutline(),
-            constraints: List[Callable] = [],
+            default: list[str] | None = None,
+            examples: prm.Prompt = _PROMPT_TEXT_TO_OUTLINE,
+            constraints: list[Callable] | None = None,
             limit: int | None = 1,
-            stop: str | None = None,
-            pre_processors: Optional[List[pre.PreProcessor]] = [pre.TextToOutlinePreProcessor()],
-            post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor(), post.SplitNewLinePostProcessor()],
+            stop: str | list[str] = '',
+            pre_processors: list[pre.PreProcessor] | None = None,
+            post_processors: list[post.PostProcessor] | None = None,
             **decorator_kwargs):
     """Outlines the essential content as a short list of bullets."""
+    if post_processors is None:
+        post_processors = [post.StripPostProcessor(), post.SplitNewLinePostProcessor()]
+    if pre_processors is None:
+        pre_processors = [pre.TextToOutlinePreProcessor()]
+    if constraints is None:
+        constraints = []
     return few_shot(prompt=prompt,
                     examples=examples,
                     constraints=constraints,
@@ -936,16 +1181,22 @@ def outline(prompt: str = "Outline only the essential content as a short list of
 
 
 def unique(prompt: str = "Create a short unique key that captures the essential topic from the following statements and does not collide with the list of keys:\n",
-           keys: List[str] = None,
-           default: List[str] = None,
-           examples: prm.Prompt = prm.UniqueKey(),
-           constraints: List[Callable] = [],
+           keys: list[str] | None = None,
+           default: list[str] | None = None,
+           examples: prm.Prompt = _PROMPT_UNIQUE_KEY,
+           constraints: list[Callable] | None = None,
            limit: int | None = 1,
-           stop: str | None = None,
-           pre_processors: Optional[List[pre.PreProcessor]] = [pre.UniquePreProcessor()],
-           post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor()],
+           stop: str | list[str] = '',
+           pre_processors: list[pre.PreProcessor] | None = None,
+           post_processors: list[post.PostProcessor] | None = None,
            **decorator_kwargs):
     """Creates a short, unique key that captures the essential topic from the given statements and does not collide with the list of keys."""
+    if post_processors is None:
+        post_processors = [post.StripPostProcessor()]
+    if pre_processors is None:
+        pre_processors = [pre.UniquePreProcessor()]
+    if constraints is None:
+        constraints = []
     return few_shot(prompt=prompt,
                     keys=keys,
                     examples=examples,
@@ -959,15 +1210,21 @@ def unique(prompt: str = "Create a short unique key that captures the essential
 
 
 def clean(prompt: str = "Clean up the text from special characters or escape sequences. DO NOT change any words or sentences! Keep original semantics:\n",
-          default: List[str] = None,
-          examples: prm.Prompt = prm.CleanText(),
-          constraints: List[Callable] = [],
+          default: list[str] | None = None,
+          examples: prm.Prompt = _PROMPT_CLEAN_TEXT,
+          constraints: list[Callable] | None = None,
           limit: int | None = 1,
-          stop: str | None = None,
-          pre_processors: Optional[List[pre.PreProcessor]] = [pre.CleanTextMessagePreProcessor()],
-          post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor()],
+          stop: str | list[str] = '',
+          pre_processors: list[pre.PreProcessor] | None = None,
+          post_processors: list[post.PostProcessor] | None = None,
           **decorator_kwargs):
     """Cleans up a text from special characters and escape sequences."""
+    if post_processors is None:
+        post_processors = [post.StripPostProcessor()]
+    if pre_processors is None:
+        pre_processors = [pre.CleanTextMessagePreProcessor()]
+    if constraints is None:
+        constraints = []
     return few_shot(prompt=prompt,
                     examples=examples,
                     constraints=constraints,
@@ -980,15 +1237,21 @@ def clean(prompt: str = "Clean up the text from special characters or escape seq
 
 
 def compose(prompt: str = "Create a coherent text based on the facts listed in the outline:\n",
-            default: Optional[str] = None,
-            examples: Optional[prm.Prompt] = None,
-            constraints: List[Callable] = [],
+            default: str | None = None,
+            examples: prm.Prompt | None = None,
+            constraints: list[Callable] | None = None,
             limit: int | None = 1,
-            stop: str | None = None,
-            pre_processors: Optional[List[pre.PreProcessor]] = [pre.GenerateTextPreProcessor()],
-            post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor()],
+            stop: str | list[str] = '',
+            pre_processors: list[pre.PreProcessor] | None = None,
+            post_processors: list[post.PostProcessor] | None = None,
             **decorator_kwargs):
     """Compose a coherent text based on an outline."""
+    if post_processors is None:
+        post_processors = [post.StripPostProcessor()]
+    if pre_processors is None:
+        pre_processors = [pre.GenerateTextPreProcessor()]
+    if constraints is None:
+        constraints = []
     return few_shot(prompt=prompt,
                     examples=examples,
                     constraints=constraints,
@@ -1003,15 +1266,21 @@ def compose(prompt: str = "Create a coherent text based on the facts listed in t
 def foreach(condition: str,
             apply: str,
             prompt: str = "Iterate over each element and apply operation based on condition:\n",
-            default: Optional[str] = None,
-            examples: prm.Prompt = prm.ForEach(),
-            constraints: List[Callable] = [],
+            default: str | None = None,
+            examples: prm.Prompt = _PROMPT_FOR_EACH,
+            constraints: list[Callable] | None = None,
             limit: int | None = 1,
-            stop: str | None = None,
-            pre_processors: Optional[List[pre.PreProcessor]] = [pre.ForEachPreProcessor()],
-            post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor()],
+            stop: str | list[str] = '',
+            pre_processors: list[pre.PreProcessor] | None = None,
+            post_processors: list[post.PostProcessor] | None = None,
             **decorator_kwargs):
     """Applies an operation based on a given condition to each element in a list."""
+    if post_processors is None:
+        post_processors = [post.StripPostProcessor()]
+    if pre_processors is None:
+        pre_processors = [pre.ForEachPreProcessor()]
+    if constraints is None:
+        constraints = []
     return few_shot(prompt=prompt,
                     condition=condition,
                     apply=apply,
@@ -1027,15 +1296,21 @@ def foreach(condition: str,
 
 def dictionary(context: str,
                prompt: str = "Map related content together under a common abstract topic. Do not remove content:\n",
-               default: Optional[str] = None,
-               examples: prm.Prompt = prm.MapContent(),
-               constraints: List[Callable] = [],
+               default: str | None = None,
+               examples: prm.Prompt = _PROMPT_MAP_CONTENT,
+               constraints: list[Callable] | None = None,
                limit: int | None = 1,
-               stop: str | None = None,
-               pre_processors: Optional[List[pre.PreProcessor]] = [pre.MapPreProcessor()],
-               post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor(), post.ASTPostProcessor()],
+               stop: str | list[str] = '',
+               pre_processors: list[pre.PreProcessor] | None = None,
+               post_processors: list[post.PostProcessor] | None = None,
                **decorator_kwargs):
     """Maps related content together under a common abstract topic."""
+    if post_processors is None:
+        post_processors = [post.StripPostProcessor(), post.ASTPostProcessor()]
+    if pre_processors is None:
+        pre_processors = [pre.MapPreProcessor()]
+    if constraints is None:
+        constraints = []
     return few_shot(prompt=prompt,
                     context=context,
                     examples=examples,
@@ -1049,15 +1324,21 @@ def dictionary(context: str,
 
 def listing(condition: str,
             prompt: str = "List each element contained in the text or list based on condition:\n",
-            default: Optional[str] = None,
-            examples: prm.Prompt = prm.ListObjects(),
-            constraints: List[Callable] = [],
-            stop: str | None = None,
+            default: str | None = None,
+            examples: prm.Prompt = _PROMPT_LIST_OBJECTS,
+            constraints: list[Callable] | None = None,
+            stop: str | list[str] = '',
             limit: int | None = 1,
-            pre_processors: Optional[List[pre.PreProcessor]] = [pre.ListPreProcessor()],
-            post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor()],
+            pre_processors: list[pre.PreProcessor] | None = None,
+            post_processors: list[post.PostProcessor] | None = None,
             **decorator_kwargs):
     """Lists each element contained in the text or list based on the given condition."""
+    if post_processors is None:
+        post_processors = [post.StripPostProcessor()]
+    if pre_processors is None:
+        pre_processors = [pre.ListPreProcessor()]
+    if constraints is None:
+        constraints = []
     return few_shot(prompt=prompt,
                     condition=condition,
                     examples=examples,
@@ -1071,16 +1352,22 @@ def listing(condition: str,
 
 
 def query(context: str,
-          prompt: Optional[str] = None,
-          examples: Optional[prm.Prompt] = None,
-          constraints: List[Callable] = [],
-          default: Optional[object] = None,
-          stop: str | None = None,
+          prompt: str | None = None,
+          examples: prm.Prompt | None = None,
+          constraints: list[Callable] | None = None,
+          default: object | None = None,
+          stop: str | list[str] = '',
           limit: int | None = 1,
-          pre_processors: Optional[List[pre.PreProcessor]] = [pre.QueryPreProcessor()],
-          post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor()],
+          pre_processors: list[pre.PreProcessor] | None = None,
+          post_processors: list[post.PostProcessor] | None = None,
           **decorator_kwargs):
     """Performs a query given a context."""
+    if post_processors is None:
+        post_processors = [post.StripPostProcessor()]
+    if pre_processors is None:
+        pre_processors = [pre.QueryPreProcessor()]
+    if constraints is None:
+        constraints = []
     return few_shot(prompt=prompt,
                     context=context,
                     examples=examples,
@@ -1093,16 +1380,20 @@ def query(context: str,
                     **decorator_kwargs)
 
 
-def expand(prompt: Optional[str] = 'Write a self-contained function (with all imports) to solve a specific user problem task. Label the function with a name that describes the task.',
-           examples: Optional[prm.Prompt] = prm.ExpandFunction(),
-           constraints: List[Callable] = [],
-           default: Optional[object] = None,
-           stop: str | None = None,
+def expand(prompt: str | None = 'Write a self-contained function (with all imports) to solve a specific user problem task. Label the function with a name that describes the task.',
+           examples: prm.Prompt | None = _PROMPT_EXPAND_FUNCTION,
+           constraints: list[Callable] | None = None,
+           default: object | None = None,
+           stop: str | list[str] = '',
            limit: int | None = 1,
-           pre_processors: Optional[List[pre.PreProcessor]] = pre.ExpandFunctionPreProcessor(),
-           post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor(), post.ExpandFunctionPostProcessor()],
+           pre_processors: list[pre.PreProcessor] | None = _PREPROCESSOR_EXPAND_FUNCTION,
+           post_processors: list[post.PostProcessor] | None = None,
            **decorator_kwargs):
     """Performs a expand command given a context to generate new prompts."""
+    if post_processors is None:
+        post_processors = [post.StripPostProcessor(), post.ExpandFunctionPostProcessor()]
+    if constraints is None:
+        constraints = []
     return few_shot(prompt=prompt,
                     examples=examples,
                     constraints=constraints,
@@ -1115,12 +1406,14 @@ def expand(prompt: Optional[str] = 'Write a self-contained function (with all im
 
 
 def search(query: str,
-           constraints: List[Callable] = [],
-           default: Optional[object] = None,
-           pre_processors: Optional[List[pre.PreProcessor]] = None,
-           post_processors: Optional[List[post.PostProcessor]] = None,
+           constraints: list[Callable] | None = None,
+           default: object | None = None,
+           pre_processors: list[pre.PreProcessor] | None = None,
+           post_processors: list[post.PostProcessor] | None = None,
            **decorator_kwargs):
     """Searches for a given query on the internet."""
+    if constraints is None:
+        constraints = []
     def decorator(func):
         @functools.wraps(func)
         def wrapper(instance, *signature_args, **signature_kwargs):
@@ -1141,12 +1434,16 @@ def search(query: str,
 
 
 def opening(path: str,
-            constraints: List[Callable] = [],
-            default: Optional[object] = None,
-            pre_processors: Optional[List[pre.PreProcessor]] = None,
-            post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor()],
+            constraints: list[Callable] | None = None,
+            default: object | None = None,
+            pre_processors: list[pre.PreProcessor] | None = None,
+            post_processors: list[post.PostProcessor] | None = None,
             **decorator_kwargs):
     """Opens a file and applies a given function to it."""
+    if post_processors is None:
+        post_processors = [post.StripPostProcessor()]
+    if constraints is None:
+        constraints = []
     def decorator(func):
         @functools.wraps(func)
         def wrapper(instance, *signature_args, **signature_kwargs):
@@ -1166,11 +1463,13 @@ def opening(path: str,
     return decorator
 
 
-def embed(entries: List[str],
-          pre_processors: Optional[List[pre.PreProcessor]] = [pre.UnwrapListSymbolsPreProcessor()],
-          post_processors: Optional[List[post.PostProcessor]] = None,
+def embed(entries: list[str],
+          pre_processors: list[pre.PreProcessor] | None = None,
+          post_processors: list[post.PostProcessor] | None = None,
           **decorator_kwargs):
     """Embeds the entries provided in a decorated function."""
+    if pre_processors is None:
+        pre_processors = [pre.UnwrapListSymbolsPreProcessor()]
     def decorator(func):
         @functools.wraps(func)
         def wrapper(instance, *signature_args, **signature_kwargs):
@@ -1188,11 +1487,15 @@ def embed(entries: List[str],
     return decorator
 
 
-def cluster(entries: List[str],
-            pre_processors: Optional[List[pre.PreProcessor]] = [pre.UnwrapListSymbolsPreProcessor()],
-            post_processors: Optional[List[post.PostProcessor]] = [post.ClusterPostProcessor()],
+def cluster(entries: list[str],
+            pre_processors: list[pre.PreProcessor] | None = None,
+            post_processors: list[post.PostProcessor] | None = None,
             **decorator_kwargs):
     """Embeds and clusters the input entries."""
+    if post_processors is None:
+        post_processors = [post.ClusterPostProcessor()]
+    if pre_processors is None:
+        pre_processors = [pre.UnwrapListSymbolsPreProcessor()]
     assert any(isinstance(pr, post.ClusterPostProcessor) for pr in post_processors), "At least one post processor must be a 'ClusterPostProcessor' for clustering!"
     for post_pr in post_processors:
         if isinstance(post_pr, post.ClusterPostProcessor):
@@ -1206,10 +1509,12 @@ def cluster(entries: List[str],
 
 def draw(operation: str = 'create',
          prompt: str = '',
-         pre_processors: Optional[List[pre.PreProcessor]] = [pre.ValuePreProcessor()],
-         post_processors: Optional[List[post.PostProcessor]] = None,
+         pre_processors: list[pre.PreProcessor] | None = None,
+         post_processors: list[post.PostProcessor] | None = None,
          **decorator_kwargs):
     """Draws an image provided in a decorated function."""
+    if pre_processors is None:
+        pre_processors = [pre.ValuePreProcessor()]
     def decorator(func):
         @functools.wraps(func)
         def wrapper(instance, *signature_args, **signature_kwargs):
@@ -1228,10 +1533,10 @@ def draw(operation: str = 'create',
     return decorator
 
 
-def text_vision(image: Optional[str|bytes] = None,
-                text: List[str] = None,
-                pre_processors: Optional[List[pre.PreProcessor]] = None,
-                post_processors: Optional[List[post.PostProcessor]] = None,
+def text_vision(image: str | bytes | None = None,
+                text: list[str] | None = None,
+                pre_processors: list[pre.PreProcessor] | None = None,
+                post_processors: list[post.PostProcessor] | None = None,
                 **decorator_kwargs):
     """Performs vision-related associative tasks. Currently limited to CLIP model embeddings."""
     def decorator(func):
@@ -1253,8 +1558,8 @@ def text_vision(image: Optional[str|bytes] = None,
 
 
 def ocr(image: str,
-        pre_processors: Optional[List[pre.PreProcessor]] = None,
-        post_processors: Optional[List[post.PostProcessor]] = None,
+        pre_processors: list[pre.PreProcessor] | None = None,
+        post_processors: list[post.PostProcessor] | None = None,
         **decorator_kwargs):
     """Performs Optical Character Recognition (OCR) on an image."""
     def decorator(func):
@@ -1275,8 +1580,8 @@ def ocr(image: str,
 
 
 def speech_to_text(prompt: str = 'decode',
-                   pre_processors: Optional[List[pre.PreProcessor]] = None,
-                   post_processors: Optional[List[post.PostProcessor]] = None,
+                   pre_processors: list[pre.PreProcessor] | None = None,
+                   post_processors: list[post.PostProcessor] | None = None,
                    **decorator_kwargs):
     """Decorates the given function for speech recognition."""
     def decorator(func):
@@ -1299,8 +1604,8 @@ def speech_to_text(prompt: str = 'decode',
 def text_to_speech(prompt: str,
                    path: str,
                    voice: str = 'nova',
-                   pre_processors: Optional[List[pre.PreProcessor]] = None,
-                   post_processors: Optional[List[post.PostProcessor]] = None,
+                   pre_processors: list[pre.PreProcessor] | None = None,
+                   post_processors: list[post.PostProcessor] | None = None,
                    **decorator_kwargs):
     """Decorates the given function for text to speech synthesis."""
     def decorator(func):
@@ -1322,12 +1627,18 @@ def text_to_speech(prompt: str,
     return decorator
 
 
-def output(constraints: List[Callable] = [],
-           default: Optional[object] = None,
-           pre_processors: Optional[List[pre.PreProcessor]] = [pre.ConsolePreProcessor()],
-           post_processors: Optional[List[post.PostProcessor]] = [post.ConsolePostProcessor()],
+def output(constraints: list[Callable] | None = None,
+           default: object | None = None,
+           pre_processors: list[pre.PreProcessor] | None = None,
+           post_processors: list[post.PostProcessor] | None = None,
            **decorator_kwargs):
     """Offers an output stream for writing results."""
+    if post_processors is None:
+        post_processors = [post.ConsolePostProcessor()]
+    if pre_processors is None:
+        pre_processors = [pre.ConsolePreProcessor()]
+    if constraints is None:
+        constraints = []
     def decorator(func):
         @functools.wraps(func)
         def wrapper(instance, *signature_args, **signature_kwargs):
@@ -1347,12 +1658,18 @@ def output(constraints: List[Callable] = [],
 
 
 def scrape(url: str,
-          constraints: List[Callable] = [],
-          default: Optional[object] = None,
-          pre_processors: Optional[List[pre.PreProcessor]] = [],
-          post_processors: Optional[List[post.PostProcessor]] = [],
+          constraints: list[Callable] | None = None,
+          default: object | None = None,
+          pre_processors: list[pre.PreProcessor] | None = None,
+          post_processors: list[post.PostProcessor] | None = None,
           **decorator_kwargs):
     """Fetches data from a given URL and applies the provided post-processors."""
+    if post_processors is None:
+        post_processors = []
+    if pre_processors is None:
+        pre_processors = []
+    if constraints is None:
+        constraints = []
     def decorator(func):
         @functools.wraps(func)
         def wrapper(instance, *signature_args, **signature_kwargs):
@@ -1371,12 +1688,18 @@ def scrape(url: str,
     return decorator
 
 
-def userinput(constraints: List[Callable] = [],
-              default: Optional[object] = None,
-              pre_processors: Optional[List[pre.PreProcessor]] = [pre.ConsoleInputPreProcessor()],
-              post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor()],
+def userinput(constraints: list[Callable] | None = None,
+              default: object | None = None,
+              pre_processors: list[pre.PreProcessor] | None = None,
+              post_processors: list[post.PostProcessor] | None = None,
               **decorator_kwargs):
     """Prompts for user input and returns the user response through a decorator."""
+    if post_processors is None:
+        post_processors = [post.StripPostProcessor()]
+    if pre_processors is None:
+        pre_processors = [pre.ConsoleInputPreProcessor()]
+    if constraints is None:
+        constraints = []
     def decorator(func):
         @functools.wraps(func)
         def wrapper(instance, *signature_args, **signature_kwargs):
@@ -1395,12 +1718,18 @@ def userinput(constraints: List[Callable] = [],
     return decorator
 
 
-def execute(default: Optional[str] = None,
-            constraints: List[Callable] = [],
-            pre_processors: List[pre.PreProcessor] = [],
-            post_processors: List[post.PostProcessor] = [],
+def execute(default: str | None = None,
+            constraints: list[Callable] | None = None,
+            pre_processors: list[pre.PreProcessor] | None = None,
+            post_processors: list[post.PostProcessor] | None = None,
             **decorator_kwargs):
     """Executes a given function after applying constraints, pre-processing and post-processing."""
+    if post_processors is None:
+        post_processors = []
+    if pre_processors is None:
+        pre_processors = []
+    if constraints is None:
+        constraints = []
     def decorator(func):
         @functools.wraps(func)
         def wrapper(instance, *signature_args, **signature_kwargs):
@@ -1422,12 +1751,18 @@ def execute(default: Optional[str] = None,
 def index(prompt: Any,
           index_name: str,
           operation: str = 'search', # | add | config
-          default: Optional[str] = None,
-          constraints: List[Callable] = [],
-          pre_processors: List[pre.PreProcessor] = [],
-          post_processors: List[post.PostProcessor] = [],
+          default: str | None = None,
+          constraints: list[Callable] | None = None,
+          pre_processors: list[pre.PreProcessor] | None = None,
+          post_processors: list[post.PostProcessor] | None = None,
           **decorator_kwargs):
     """Query for a given index and returns the result through a decorator."""
+    if post_processors is None:
+        post_processors = []
+    if pre_processors is None:
+        pre_processors = []
+    if constraints is None:
+        constraints = []
     def decorator(func):
         @functools.wraps(func)
         def wrapper(instance, *signature_args, **signature_kwargs):
@@ -1449,8 +1784,10 @@ def index(prompt: Any,
     return decorator
 
 
-def command(engines: List[str] = ['all'], **decorator_kwargs):
+def command(engines: list[str] | None = None, **decorator_kwargs):
     """Decorates a function to forward commands to the engine backends."""
+    if engines is None:
+        engines = ['all']
     def decorator(func):
         @functools.wraps(func)
         def wrapper(instance):
@@ -1464,7 +1801,7 @@ def command(engines: List[str] = ['all'], **decorator_kwargs):
     return decorator
 
 
-def register(engines: Dict[str, Any]):
+def register(engines: dict[str, Any]):
     """Decorates a function to initialize custom engines as backends."""
     def decorator(func):
         @functools.wraps(func)
@@ -1480,8 +1817,8 @@ def register(engines: Dict[str, Any]):
 
 
 def tune(operation: str = 'create',
-         pre_processors: Optional[List[pre.PreProcessor]] = None,
-         post_processors: Optional[List[post.PostProcessor]] = None,
+         pre_processors: list[pre.PreProcessor] | None = None,
+         post_processors: list[post.PostProcessor] | None = None,
          **decorator_kwargs):
     """Fine tune a LLM."""
     def decorator(func):
@@ -1503,10 +1840,12 @@ def tune(operation: str = 'create',
 
 def caption(image: str,
             prompt: str,
-            pre_processors: Optional[List[pre.PreProcessor]] = [pre.ValuePreProcessor()],
-            post_processors: Optional[List[post.PostProcessor]] = None,
+            pre_processors: list[pre.PreProcessor] | None = None,
+            post_processors: list[post.PostProcessor] | None = None,
             **decorator_kwargs):
     """Caption the content of an image."""
+    if pre_processors is None:
+        pre_processors = [pre.ValuePreProcessor()]
     def decorator(func):
         @functools.wraps(func)
         def wrapper(instance, *signature_args, **signature_kwargs):