symbolicai 0.21.0__py3-none-any.whl → 1.1.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,78 +10,109 @@ 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
-    _default_parse_system_instructions          = False
-    _default_preview_value                      = False
+    _default_suppress_verbose_output = False
+    _default_parse_system_instructions = False
+    _default_preview_value = False
 
     def __init__(self, args, signature_kwargs, decorator_kwargs, **kwargs):
         super().__init__(**kwargs)
-        self.args             = args # there is only signature args
+        self.args = args  # there is only signature args
         self.signature_kwargs = signature_kwargs.copy()
         self.decorator_kwargs = decorator_kwargs.copy()
-        self.kwargs           = self._construct_kwargs(signature_kwargs=signature_kwargs,
-                                                       decorator_kwargs=decorator_kwargs)
-        self.prop             = Metadata()
+        self.kwargs = self._construct_kwargs(
+            signature_kwargs=signature_kwargs, 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({
-            'args': self.args,
-            'signature_kwargs': self.signature_kwargs,
-            'decorator_kwargs': self.decorator_kwargs,
-            'kwargs': self.kwargs,
-            'prop': self.prop
-        })
+        return Box(
+            {
+                "args": self.args,
+                "signature_kwargs": self.signature_kwargs,
+                "decorator_kwargs": self.decorator_kwargs,
+                "kwargs": self.kwargs,
+                "prop": self.prop,
+            }
+        )
 
     def _construct_kwargs(self, signature_kwargs, decorator_kwargs):
-        '''
+        """
         Combines and overrides the decorator args and kwargs with the runtime signature args and kwargs.
 
         Args:
@@ -89,7 +121,7 @@ class Argument(Expression):
 
         Returns:
             Dict: The combined and overridden kwargs.
-        '''
+        """
         # Initialize with the decorator kwargs
         kwargs = {**decorator_kwargs}
         # Override the decorator kwargs with the signature kwargs
@@ -98,1428 +130,2020 @@ class Argument(Expression):
         return kwargs
 
 
-def few_shot(prompt: str = '',
-             examples: prm.Prompt = [],
-             constraints: List[Callable] = [],
-             default: Any = None,
-             limit: int = 1,
-             pre_processors: Optional[List[pre.PreProcessor]] = None,
-             post_processors: Optional[List[post.PostProcessor]] = None,
-             **decorator_kwargs):
-    """"General decorator for the neural processing engine."""
+def few_shot(
+    prompt: str = "",
+    examples: prm.Prompt = None,
+    constraints: list[Callable] | None = None,
+    default: Any = None,
+    limit: int = 1,
+    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):
             # Construct container object for the arguments and kwargs
-            decorator_kwargs['prompt']   = prompt
-            decorator_kwargs['examples'] = examples
+            decorator_kwargs["prompt"] = prompt
+            decorator_kwargs["examples"] = examples
             argument = Argument(signature_args, signature_kwargs, decorator_kwargs)
             return EngineRepository.query(
-                                engine='neurosymbolic',
-                                instance=instance,
-                                func=func,
-                                constraints=constraints,
-                                default=default,
-                                limit=limit,
-                                pre_processors=pre_processors,
-                                post_processors=post_processors,
-                                argument=argument)
+                engine="neurosymbolic",
+                instance=instance,
+                func=func,
+                constraints=constraints,
+                default=default,
+                limit=limit,
+                pre_processors=pre_processors,
+                post_processors=post_processors,
+                argument=argument,
+            )
+
         return wrapper
+
     return decorator
 
 
-def zero_shot(prompt: str = '',
-              constraints: List[Callable] = [],
-              default: Optional[object] = None,
-              limit: int = 1,
-              pre_processors: Optional[List[pre.PreProcessor]] = None,
-              post_processors: Optional[List[post.PostProcessor]] = None,
-              **decorator_kwargs):
-    """"General decorator for the neural processing engine."""
-    return few_shot(prompt,
-                    examples=[],
-                    constraints=constraints,
-                    default=default,
-                    limit=limit,
-                    pre_processors=pre_processors,
-                    post_processors=post_processors,
-                    **decorator_kwargs)
-
-
-def prompt(message: str,
-           **decorator_kwargs):
+def zero_shot(
+    prompt: str = "",
+    constraints: list[Callable] | None = None,
+    default: object | None = None,
+    limit: int = 1,
+    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,
+        default=default,
+        limit=limit,
+        pre_processors=pre_processors,
+        post_processors=post_processors,
+        **decorator_kwargs,
+    )
+
+
+def prompt(message: str, **decorator_kwargs):
     """General decorator for the neural processing engine."""
-    return few_shot(processed_input=message,
-                    raw_input=True,
-                    **decorator_kwargs)
-
-
-def summarize(prompt: str = 'Summarize the content of the following text:\n',
-              context: Optional[str] = None,
-              constraints: List[Callable] = [],
-              default: Optional[object] = None,
-              limit: int = 1,
-              stop: str | None = None,
-              pre_processors: Optional[List[pre.PreProcessor]] = [pre.SummaryPreProcessing()],
-              post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor()],
-              **decorator_kwargs):
+    return few_shot(processed_input=message, raw_input=True, **decorator_kwargs)
+
+
+def summarize(
+    prompt: str = "Summarize the content of the following text:\n",
+    context: str | None = None,
+    constraints: list[Callable] | None = None,
+    default: object | None = None,
+    limit: int = 1,
+    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."""
-    return few_shot(prompt,
-                    context=context,
-                    examples=[],
-                    constraints=constraints,
-                    default=default,
-                    limit=limit,
-                    stop=stop,
-                    pre_processors=pre_processors,
-                    post_processors=post_processors,
-                    **decorator_kwargs)
-
-
-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] = [],
-           limit: int = 1,
-           stop: str | None = None,
-           pre_processors: Optional[List[pre.PreProcessor]] = [pre.EqualsPreProcessor()],
-           post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor()],
-           **decorator_kwargs):
+    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=[],
+        constraints=constraints,
+        default=default,
+        limit=limit,
+        stop=stop,
+        pre_processors=pre_processors,
+        post_processors=post_processors,
+        **decorator_kwargs,
+    )
+
+
+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 = _PROMPT_FUZZY_EQUALS,
+    constraints: list[Callable] | None = None,
+    limit: int = 1,
+    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."""
-    return few_shot(prompt=prompt.format(context),
-                    examples=examples,
-                    constraints=constraints,
-                    default=default,
-                    limit=limit,
-                    stop=stop,
-                    max_tokens=None,
-                    pre_processors=pre_processors,
-                    post_processors=post_processors,
-                    **decorator_kwargs)
-
-
-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] = [],
-               limit: int = 1,
-               stop: str | None = None,
-               pre_processors: Optional[List[pre.PreProcessor]] = [pre.SufficientInformationPreProcessor()],
-               post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor()],
-               **decorator_kwargs) -> bool:
+    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,
+        default=default,
+        limit=limit,
+        stop=stop,
+        max_tokens=None,
+        pre_processors=pre_processors,
+        post_processors=post_processors,
+        **decorator_kwargs,
+    )
+
+
+def sufficient(
+    query: str,
+    prompt: str = "Consider if there is sufficient information to answer the query:\n",
+    default: bool = False,
+    examples: prm.Prompt = _PROMPT_SUFFICIENT_INFORMATION,
+    constraints: list[Callable] | None = None,
+    limit: int = 1,
+    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."""
-    return few_shot(prompt=prompt,
-                    query=query,
-                    examples=examples,
-                    constraints=constraints,
-                    default=default,
-                    limit=limit,
-                    stop=stop,
-                    max_tokens=None,
-                    pre_processors=pre_processors,
-                    post_processors=post_processors,
-                    **decorator_kwargs)
-
-
-def delitem(default: Optional[str] = None,
-            prompt: str = "Delete the items at the index position:\n",
-            examples: prm.Prompt = prm.RemoveIndex(),
-            constraints: List[Callable] = [],
-            limit: int = 1,
-            stop: str | None = None,
-            pre_processors: Optional[List[pre.PreProcessor]] = [pre.DeleteIndexPreProcessor()],
-            post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor()],
-            **decorator_kwargs):
+    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,
+        constraints=constraints,
+        default=default,
+        limit=limit,
+        stop=stop,
+        max_tokens=None,
+        pre_processors=pre_processors,
+        post_processors=post_processors,
+        **decorator_kwargs,
+    )
+
+
+def delitem(
+    default: str | None = None,
+    prompt: str = "Delete the items at the index position:\n",
+    examples: prm.Prompt = _PROMPT_REMOVE_INDEX,
+    constraints: list[Callable] | None = None,
+    limit: int = 1,
+    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."""
-    return few_shot(prompt=prompt,
-                    examples=examples,
-                    constraints=constraints,
-                    default=default,
-                    limit=limit,
-                    stop=stop,
-                    pre_processors=pre_processors,
-                    post_processors=post_processors,
-                    **decorator_kwargs)
-
-
-def setitem(default: Optional[str] = None,
-            prompt: str = "Set item at index position:\n",
-            examples: prm.Prompt = prm.SetIndex(),
-            constraints: List[Callable] = [],
-            limit: int = 1,
-            stop: str | None = None,
-            pre_processors: Optional[List[pre.PreProcessor]] = [pre.SetIndexPreProcessor()],
-            post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor()],
-            **decorator_kwargs):
+    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,
+        default=default,
+        limit=limit,
+        stop=stop,
+        pre_processors=pre_processors,
+        post_processors=post_processors,
+        **decorator_kwargs,
+    )
+
+
+def setitem(
+    default: str | None = None,
+    prompt: str = "Set item at index position:\n",
+    examples: prm.Prompt = _PROMPT_SET_INDEX,
+    constraints: list[Callable] | None = None,
+    limit: int = 1,
+    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."""
-    return few_shot(prompt=prompt,
-                    examples=examples,
-                    constraints=constraints,
-                    default=default,
-                    limit=limit,
-                    stop=stop,
-                    pre_processors=pre_processors,
-                    post_processors=post_processors,
-                    **decorator_kwargs)
-
-
-def getitem(default: Optional[str] = None,
-            prompt: str = "Get item at index position:\n",
-            examples: prm.Prompt = prm.Index(),
-            constraints: List[Callable] = [],
-            limit: int = 1,
-            stop: str | None = None,
-            pre_processors: Optional[List[pre.PreProcessor]] = [pre.IndexPreProcessor()],
-            post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor()],
-            **decorator_kwargs):
+    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,
+        default=default,
+        limit=limit,
+        stop=stop,
+        pre_processors=pre_processors,
+        post_processors=post_processors,
+        **decorator_kwargs,
+    )
+
+
+def getitem(
+    default: str | None = None,
+    prompt: str = "Get item at index position:\n",
+    examples: prm.Prompt = _PROMPT_INDEX,
+    constraints: list[Callable] | None = None,
+    limit: int = 1,
+    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."""
-    return few_shot(prompt=prompt,
-                    examples=examples,
-                    constraints=constraints,
-                    default=default,
-                    limit=limit,
-                    stop=stop,
-                    pre_processors=pre_processors,
-                    post_processors=post_processors,
-                    **decorator_kwargs)
-
-
-def modify(changes: str,
-           default: Optional[str] = None,
-           prompt: str = "Modify the text to match the criteria:\n",
-           examples: prm.Prompt = prm.Modify(),
-           constraints: List[Callable] = [],
-           limit: int = 1,
-           stop: str | None = None,
-           pre_processors: Optional[List[pre.PreProcessor]] = [pre.ModifyPreProcessor()],
-           post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor()],
-           **decorator_kwargs):
+    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,
+        default=default,
+        limit=limit,
+        stop=stop,
+        pre_processors=pre_processors,
+        post_processors=post_processors,
+        **decorator_kwargs,
+    )
+
+
+def modify(
+    changes: str,
+    default: str | None = None,
+    prompt: str = "Modify the text to match the criteria:\n",
+    examples: prm.Prompt = _PROMPT_MODIFY,
+    constraints: list[Callable] | None = None,
+    limit: int = 1,
+    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."""
-    return few_shot(prompt=prompt,
-                    changes=changes,
-                    examples=examples,
-                    constraints=constraints,
-                    default=default,
-                    limit=limit,
-                    stop=stop,
-                    pre_processors=pre_processors,
-                    post_processors=post_processors,
-                    **decorator_kwargs)
-
-
-def filtering(criteria: str,
-              include: bool = False,
-              default: Optional[str] = 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] = [],
-              limit: int = 1,
-              stop: str | None = None,
-              pre_processors: Optional[List[pre.PreProcessor]] = [pre.FilterPreProcessor()],
-              post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor()],
-              **decorator_kwargs):
+    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,
+        constraints=constraints,
+        default=default,
+        limit=limit,
+        stop=stop,
+        pre_processors=pre_processors,
+        post_processors=post_processors,
+        **decorator_kwargs,
+    )
+
+
+def filtering(
+    criteria: str,
+    include: bool = False,
+    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 = _PROMPT_FILTER,
+    constraints: list[Callable] | None = None,
+    limit: int = 1,
+    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."""
-    return few_shot(prompt=prompt,
-                    criteria=criteria,
-                    include=include,
-                    examples=examples,
-                    constraints=constraints,
-                    default=default,
-                    limit=limit,
-                    stop=stop,
-                    pre_processors=pre_processors,
-                    post_processors=post_processors,
-                    **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):
+    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,
+        examples=examples,
+        constraints=constraints,
+        default=default,
+        limit=limit,
+        stop=stop,
+        pre_processors=pre_processors,
+        post_processors=post_processors,
+        **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."""
-    return few_shot(prompt=prompt,
-                    examples=examples,
-                    constraints=constraints,
-                    default=default,
-                    limit=limit,
-                    stop=stop,
-                    context=instruction,
-                    pre_processors=pre_processors,
-                    post_processors=post_processors,
-                    **decorator_kwargs)
-
-
-def notify(subscriber: Dict[str, Callable],
-           default: Optional[object] = None,
-           prompt: str = "List the semantically related topics:\n",
-           examples: prm.Prompt = prm.SemanticMapping(),
-           constraints: List[Callable] = [],
-           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()],
-           **decorator_kwargs):
+    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,
+        default=default,
+        limit=limit,
+        stop=stop,
+        context=instruction,
+        pre_processors=pre_processors,
+        post_processors=post_processors,
+        **decorator_kwargs,
+    )
+
+
+def notify(
+    subscriber: dict[str, Callable],
+    default: object | None = None,
+    prompt: str = "List the semantically related topics:\n",
+    examples: prm.Prompt = _PROMPT_SEMANTIC_MAPPING,
+    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,
+):
     """Notify subscribers based on a set of topics if detected in the input text and matching the key of the subscriber."""
-    return few_shot(prompt=prompt,
-                    subscriber=subscriber,
-                    examples=examples,
-                    constraints=constraints,
-                    default=default,
-                    limit=limit,
-                    stop=stop,
-                    pre_processors=pre_processors,
-                    post_processors=post_processors,
-                    **decorator_kwargs)
-
-
-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] = [],
-            limit: int | None = 1,
-            stop: str | None = None,
-            pre_processors: Optional[List[pre.PreProcessor]] = [pre.ComparePreProcessor()],
-            post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor()],
-            **decorator_kwargs):
+    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,
+        constraints=constraints,
+        default=default,
+        limit=limit,
+        stop=stop,
+        pre_processors=pre_processors,
+        post_processors=post_processors,
+        **decorator_kwargs,
+    )
+
+
+def compare(
+    default: bool = False,
+    operator: str = ">",
+    prompt: str = "Compare 'A' and 'B' based on the operator:\n",
+    examples: prm.Prompt = _PROMPT_COMPARE_VALUES,
+    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,
+):
     """Compare two objects based on the specified operator."""
-    return few_shot(prompt=prompt,
-                    examples=examples,
-                    constraints=constraints,
-                    default=default,
-                    limit=limit,
-                    stop=stop,
-                    max_tokens=None,
-                    operator=operator,
-                    pre_processors=pre_processors,
-                    post_processors=post_processors,
-                    **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):
+    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,
+        default=default,
+        limit=limit,
+        stop=stop,
+        max_tokens=None,
+        operator=operator,
+        pre_processors=pre_processors,
+        post_processors=post_processors,
+        **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."""
-    return few_shot(prompt=prompt,
-                    examples=examples,
-                    constraints=constraints,
-                    default=default,
-                    limit=limit,
-                    stop=stop,
-                    format=format,
-                    pre_processors=pre_processors,
-                    post_processors=post_processors,
-                    **decorator_kwargs)
-
-
-def transcribe(modify: str,
-               default: Optional[str] = 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] = [],
-               limit: int | None = 1,
-               stop: str | None = None,
-               pre_processors: Optional[List[pre.PreProcessor]] = [pre.TranscriptionPreProcessor()],
-               post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor()],
-               **decorator_kwargs):
+    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,
+        default=default,
+        limit=limit,
+        stop=stop,
+        format=format,
+        pre_processors=pre_processors,
+        post_processors=post_processors,
+        **decorator_kwargs,
+    )
+
+
+def transcribe(
+    modify: str,
+    default: str | None = None,
+    prompt: str = "Transcribe the following text by only modifying the text by the provided instruction.\n",
+    examples: prm.Prompt = _PROMPT_TRANSCRIPTION,
+    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,
+):
     """Transcription operation of a text to another styled text."""
-    return few_shot(prompt=prompt,
-                    examples=examples,
-                    constraints=constraints,
-                    default=default,
-                    limit=limit,
-                    stop=stop,
-                    modify=modify,
-                    pre_processors=pre_processors,
-                    post_processors=post_processors,
-                    **decorator_kwargs)
-
-
-def style(description: str,
-          libraries: List[str] = [],
-          default: Optional[str] = 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] = [],
-          limit: int | None = 1,
-          stop: str | None = None,
-          pre_processors: Optional[List[pre.PreProcessor]] = [pre.StylePreProcessor()],
-          post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor()],
-          **decorator_kwargs):
+    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,
+        default=default,
+        limit=limit,
+        stop=stop,
+        modify=modify,
+        pre_processors=pre_processors,
+        post_processors=post_processors,
+        **decorator_kwargs,
+    )
+
+
+def style(
+    description: str,
+    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] | 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,
+):
     """Styles a given text based on best practices and a given description."""
-    return few_shot(prompt=prompt,
-                    libraries=libraries,
-                    examples=None,
-                    constraints=constraints,
-                    default=default,
-                    limit=limit,
-                    stop=stop,
-                    description=description,
-                    pre_processors=pre_processors,
-                    post_processors=post_processors,
-                    **decorator_kwargs)
-
-
-def analyze(query: str,
-            exception: Exception,
-            default: Optional[str] = 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] = [],
-            limit: int | None = 1,
-            stop: str | None = None,
-            pre_processors: Optional[List[pre.PreProcessor]] = [pre.ExceptionPreProcessor()],
-            post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor()],
-            **decorator_kwargs):
+    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,
+        constraints=constraints,
+        default=default,
+        limit=limit,
+        stop=stop,
+        description=description,
+        pre_processors=pre_processors,
+        post_processors=post_processors,
+        **decorator_kwargs,
+    )
+
+
+def analyze(
+    query: str,
+    exception: Exception,
+    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 = _PROMPT_EXCEPTION_MAPPING,
+    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,
+):
     """Analyses an Exception and proposes a correction."""
-    return few_shot(prompt=prompt,
-                    query=query,
-                    exception=exception,
-                    examples=examples,
-                    constraints=constraints,
-                    default=default,
-                    limit=limit,
-                    stop=stop,
-                    pre_processors=pre_processors,
-                    post_processors=post_processors,
-                    **decorator_kwargs)
-
-
-def correct(context: str,
-            exception: Exception,
-            default: Optional[str] = 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] = [],
-            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()],
-            **decorator_kwargs):
+    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,
+        examples=examples,
+        constraints=constraints,
+        default=default,
+        limit=limit,
+        stop=stop,
+        pre_processors=pre_processors,
+        post_processors=post_processors,
+        **decorator_kwargs,
+    )
+
+
+def correct(
+    context: str,
+    exception: Exception,
+    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: prm.Prompt | None = None,
+    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,
+):
     """Analyses an Exception and proposes a correction."""
-    return few_shot(prompt=prompt,
-                    context=context,
-                    exception=exception,
-                    examples=examples,
-                    constraints=constraints,
-                    default=default,
-                    limit=limit,
-                    stop=stop,
-                    pre_processors=pre_processors,
-                    post_processors=post_processors,
-                    **decorator_kwargs)
-
-
-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] = [],
-              limit: int | None = 1,
-              stop: str | None = None,
-              pre_processors: Optional[List[pre.PreProcessor]] = [pre.LanguagePreProcessor()],
-              post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor()],
-              **decorator_kwargs):
+    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,
+        examples=examples,
+        constraints=constraints,
+        default=default,
+        limit=limit,
+        stop=stop,
+        pre_processors=pre_processors,
+        post_processors=post_processors,
+        **decorator_kwargs,
+    )
+
+
+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: prm.Prompt | None = None,
+    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,
+):
     """Translates a given text into a specified language."""
-    return few_shot(prompt=prompt,
-                    examples=examples,
-                    constraints=constraints,
-                    default=default,
-                    limit=limit,
-                    stop=stop,
-                    language=language,
-                    pre_processors=pre_processors,
-                    post_processors=post_processors,
-                    **decorator_kwargs)
-
-
-def rank(default: Optional[object] = 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] = [],
-         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()],
-         **decorator_kwargs):
+    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,
+        default=default,
+        limit=limit,
+        stop=stop,
+        language=language,
+        pre_processors=pre_processors,
+        post_processors=post_processors,
+        **decorator_kwargs,
+    )
+
+
+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 = _PROMPT_RANK_LIST,
+    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,
+):
     """Ranks a list of objects based on their quality measure and order literal."""
-    return few_shot(prompt=prompt,
-                    examples=examples,
-                    constraints=constraints,
-                    default=default,
-                    limit=limit,
-                    stop=stop,
-                    order=order,
-                    pre_processors=pre_processors,
-                    post_processors=post_processors,
-                    **decorator_kwargs)
-
-
-def replace(prompt: str = "Replace text parts by string pattern.\n",
-            default: Optional[str] = None,
-            examples: prm.Prompt = prm.ReplaceText(),
-            constraints: List[Callable] = [],
-            limit: int | None = 1,
-            stop: str | None = None,
-            pre_processors: Optional[List[pre.PreProcessor]] = [pre.ReplacePreProcessor()],
-            post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor()],
-            **decorator_kwargs):
+    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,
+        default=default,
+        limit=limit,
+        stop=stop,
+        order=order,
+        pre_processors=pre_processors,
+        post_processors=post_processors,
+        **decorator_kwargs,
+    )
+
+
+def replace(
+    prompt: str = "Replace text parts by string pattern.\n",
+    default: str | None = None,
+    examples: prm.Prompt = _PROMPT_REPLACE_TEXT,
+    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,
+):
     """Replaces text parts by a given string pattern."""
-    return few_shot(prompt=prompt,
-                    examples=examples,
-                    constraints=constraints,
-                    default=default,
-                    limit=limit,
-                    stop=stop,
-                    pre_processors=pre_processors,
-                    post_processors=post_processors,
-                    **decorator_kwargs)
-
-
-def include(prompt: str = "Include information based on description.\n",
-            default: Optional[str] = None,
-            examples: prm.Prompt = prm.IncludeText(),
-            constraints: List[Callable] = [],
-            limit: int | None = 1,
-            stop: str | None = None,
-            pre_processors: Optional[List[pre.PreProcessor]] = [pre.IncludePreProcessor()],
-            post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor()],
-            **decorator_kwargs):
+    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,
+        default=default,
+        limit=limit,
+        stop=stop,
+        pre_processors=pre_processors,
+        post_processors=post_processors,
+        **decorator_kwargs,
+    )
+
+
+def include(
+    prompt: str = "Include information based on description.\n",
+    default: str | None = None,
+    examples: prm.Prompt = _PROMPT_INCLUDE_TEXT,
+    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,
+):
     """Include information from a description."""
-    return few_shot(prompt=prompt,
-                    examples=examples,
-                    constraints=constraints,
-                    default=default,
-                    limit=limit,
-                    stop=stop,
-                    pre_processors=pre_processors,
-                    post_processors=post_processors,
-                    **decorator_kwargs)
-
-
-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] = [],
-            limit: int | None = 1,
-            stop: str | None = None,
-            pre_processors: Optional[List[pre.PreProcessor]] = [pre.CombinePreProcessor()],
-            post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor()],
-            **decorator_kwargs):
+    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,
+        default=default,
+        limit=limit,
+        stop=stop,
+        pre_processors=pre_processors,
+        post_processors=post_processors,
+        **decorator_kwargs,
+    )
+
+
+def combine(
+    prompt: str = "Add the two data types in a logical way:\n",
+    default: str | None = None,
+    examples: prm.Prompt = _PROMPT_COMBINE_TEXT,
+    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,
+):
     """Combines two data types in a logical way."""
-    return few_shot(prompt=prompt,
-                    examples=examples,
-                    constraints=constraints,
-                    default=default,
-                    limit=limit,
-                    stop=stop,
-                    pre_processors=pre_processors,
-                    post_processors=post_processors,
-                    **decorator_kwargs)
-
-
-def negate(prompt: str = "Negate the following statement:\n",
-           default: Optional[str] = None,
-           examples: prm.Prompt = prm.NegateStatement(),
-           constraints: List[Callable] = [],
-           limit: int | None = 1,
-           stop: str | None = None,
-           pre_processors: Optional[List[pre.PreProcessor]] = [pre.NegatePreProcessor()],
-           post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor()],
-           **decorator_kwargs):
+    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,
+        default=default,
+        limit=limit,
+        stop=stop,
+        pre_processors=pre_processors,
+        post_processors=post_processors,
+        **decorator_kwargs,
+    )
+
+
+def negate(
+    prompt: str = "Negate the following statement:\n",
+    default: str | None = None,
+    examples: prm.Prompt = _PROMPT_NEGATE_STATEMENT,
+    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,
+):
     """Negates a given statement."""
-    return few_shot(prompt=prompt,
-                    examples=examples,
-                    constraints=constraints,
-                    default=default,
-                    limit=limit,
-                    stop=stop,
-                    pre_processors=pre_processors,
-                    post_processors=post_processors,
-                    **decorator_kwargs)
-
-
-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] = [],
-             limit: int | None = 1,
-             stop: str | None = None,
-             pre_processors: Optional[List[pre.PreProcessor]] = [pre.ContainsPreProcessor()],
-             post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor()],
-             **decorator_kwargs):
+    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,
+        default=default,
+        limit=limit,
+        stop=stop,
+        pre_processors=pre_processors,
+        post_processors=post_processors,
+        **decorator_kwargs,
+    )
+
+
+def contains(
+    default: bool = False,
+    prompt: str = "Is semantically the information of 'A' contained in 'B'?\n",
+    examples: prm.Prompt = _PROMPT_CONTAINS_VALUE,
+    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,
+):
     """Determines whether a given string contains another string."""
-    return few_shot(prompt=prompt,
-                    examples=examples,
-                    constraints=constraints,
-                    default=default,
-                    limit=limit,
-                    stop=stop,
-                    max_tokens=None,
-                    pre_processors=pre_processors,
-                    post_processors=post_processors,
-                    **decorator_kwargs)
-
-
-def isinstanceof(default: bool = False,
-                 prompt: str = "Is 'A' an instance of 'B'?\n",
-                 examples: prm.Prompt = prm.IsInstanceOf(),
-                 constraints: List[Callable] = [],
-                 limit: int | None = 1,
-                 stop: str | None = None,
-                 pre_processors: Optional[List[pre.PreProcessor]] = [pre.IsInstanceOfPreProcessor()],
-                 post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor()],
-                 **decorator_kwargs):
+    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,
+        default=default,
+        limit=limit,
+        stop=stop,
+        max_tokens=None,
+        pre_processors=pre_processors,
+        post_processors=post_processors,
+        **decorator_kwargs,
+    )
+
+
+def isinstanceof(
+    default: bool = False,
+    prompt: str = "Is 'A' an instance of 'B'?\n",
+    examples: prm.Prompt = _PROMPT_IS_INSTANCE_OF,
+    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,
+):
     """Detects if one object is an instance of another."""
-    return few_shot(prompt=prompt,
-                    examples=examples,
-                    constraints=constraints,
-                    default=default,
-                    limit=limit,
-                    stop=stop,
-                    max_tokens=None,
-                    pre_processors=pre_processors,
-                    post_processors=post_processors,
-                    **decorator_kwargs)
-
-
-def startswith(default: bool = False,
-               prompt: str = "Does 'A' start with 'B'?\n",
-               examples: prm.Prompt = prm.StartsWith(),
-               constraints: List[Callable] = [],
-               limit: int | None = 1,
-               stop: str | None = None,
-               pre_processors: Optional[List[pre.PreProcessor]] = [pre.StartsWithPreProcessor()],
-               post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor()],
-               **decorator_kwargs):
+    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,
+        default=default,
+        limit=limit,
+        stop=stop,
+        max_tokens=None,
+        pre_processors=pre_processors,
+        post_processors=post_processors,
+        **decorator_kwargs,
+    )
+
+
+def startswith(
+    default: bool = False,
+    prompt: str = "Does 'A' start with 'B'?\n",
+    examples: prm.Prompt = _PROMPT_STARTS_WITH,
+    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,
+):
     """Determines whether a string starts with a specified prefix."""
-    return few_shot(prompt=prompt,
-                    examples=examples,
-                    constraints=constraints,
-                    default=default,
-                    limit=limit,
-                    stop=stop,
-                    max_tokens=None,
-                    pre_processors=pre_processors,
-                    post_processors=post_processors,
-                    **decorator_kwargs)
-
-
-def endswith(default: bool = False,
-             prompt: str = "Does 'A' end with 'B'?\n",
-             examples: prm.Prompt = prm.EndsWith(),
-             constraints: List[Callable] = [],
-             limit: int | None = 1,
-             stop: str | None = None,
-             pre_processors: Optional[List[pre.PreProcessor]] = [pre.EndsWithPreProcessor()],
-             post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor()],
-             **decorator_kwargs):
+    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,
+        default=default,
+        limit=limit,
+        stop=stop,
+        max_tokens=None,
+        pre_processors=pre_processors,
+        post_processors=post_processors,
+        **decorator_kwargs,
+    )
+
+
+def endswith(
+    default: bool = False,
+    prompt: str = "Does 'A' end with 'B'?\n",
+    examples: prm.Prompt = _PROMPT_ENDS_WITH,
+    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,
+):
     """Determines whether a string ends with a specified suffix."""
-    return few_shot(prompt=prompt,
-                    examples=examples,
-                    constraints=constraints,
-                    default=default,
-                    limit=limit,
-                    stop=stop,
-                    max_tokens=None,
-                    pre_processors=pre_processors,
-                    post_processors=post_processors,
-                    **decorator_kwargs)
-
-
-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,
-         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()],
-         **decorator_kwargs):
+    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,
+        default=default,
+        limit=limit,
+        stop=stop,
+        max_tokens=None,
+        pre_processors=pre_processors,
+        post_processors=post_processors,
+        **decorator_kwargs,
+    )
+
+
+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: prm.Prompt | 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,
+):
     """Classifies a text according to one of the given categories."""
-    return few_shot(prompt=prompt,
-                    examples=examples,
-                    default=default,
-                    limit=limit,
-                    stop=stop,
-                    pre_processors=pre_processors,
-                    post_processors=post_processors,
-                    enum=enum,
-                    **decorator_kwargs)
-
-
-def extract(prompt: str = "Extract a pattern from text:\n",
-            default: Optional[str] = None,
-            examples: prm.Prompt = prm.ExtractPattern(),
-            constraints: List[Callable] = [],
-            limit: int | None = 1,
-            stop: str | None = None,
-            pre_processors: Optional[List[pre.PreProcessor]] = [pre.ExtractPatternPreProcessor()],
-            post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor()],
-            **decorator_kwargs):
+    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,
+        limit=limit,
+        stop=stop,
+        pre_processors=pre_processors,
+        post_processors=post_processors,
+        enum=enum,
+        **decorator_kwargs,
+    )
+
+
+def extract(
+    prompt: str = "Extract a pattern from text:\n",
+    default: str | None = None,
+    examples: prm.Prompt = _PROMPT_EXTRACT_PATTERN,
+    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,
+):
     """Extracts a pattern from text."""
-    return few_shot(prompt=prompt,
-                    examples=examples,
-                    constraints=constraints,
-                    default=default,
-                    limit=limit,
-                    stop=stop,
-                    pre_processors=pre_processors,
-                    post_processors=post_processors,
-                    **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()],
-               **decorator_kwargs):
+    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,
+        default=default,
+        limit=limit,
+        stop=stop,
+        pre_processors=pre_processors,
+        post_processors=post_processors,
+        **decorator_kwargs,
+    )
+
+
+def expression(
+    prompt: str = "Evaluate the symbolic expressions:\n",
+    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):
             # Construct container object for the arguments and kwargs
-            decorator_kwargs['prompt'] = prompt
+            decorator_kwargs["prompt"] = prompt
             argument = Argument(signature_args, signature_kwargs, decorator_kwargs)
             return EngineRepository.query(
-                                engine='symbolic',
-                                instance=instance,
-                                func=func,
-                                default=default,
-                                pre_processors=pre_processors,
-                                post_processors=post_processors,
-                                argument=argument)
+                engine="symbolic",
+                instance=instance,
+                func=func,
+                default=default,
+                pre_processors=pre_processors,
+                post_processors=post_processors,
+                argument=argument,
+            )
+
         return wrapper
+
     return decorator
 
 
-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] = [],
-              limit: int | None = 1,
-              stop: str | None = None,
-              pre_processors: Optional[List[pre.PreProcessor]] = [pre.InterpretExpressionPreProcessor()],
-              post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor()],
-              **decorator_kwargs):
+def interpret(
+    prompt: str = "Evaluate the symbolic expressions and return only the result:\n",
+    default: str | None = None,
+    examples: prm.Prompt = _PROMPT_SIMPLE_SYMBOLIC_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,
+):
     """Evaluates the symbolic expressions by interpreting the semantic meaning."""
-    return few_shot(prompt=prompt,
-                    examples=examples,
-                    constraints=constraints,
-                    default=default,
-                    limit=limit,
-                    stop=stop,
-                    pre_processors=pre_processors,
-                    post_processors=post_processors,
-                    **decorator_kwargs)
-
-
-def logic(prompt: str = "Evaluate the logic expressions:\n",
-          operator: str = 'and',
-          default: Optional[str] = None,
-          examples: prm.Prompt = prm.LogicExpression(),
-          constraints: List[Callable] = [],
-          limit: int | None = 1,
-          stop: str | None = None,
-          pre_processors: Optional[List[pre.PreProcessor]] = [pre.LogicExpressionPreProcessor()],
-          post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor()],
-          **decorator_kwargs):
+    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,
+        default=default,
+        limit=limit,
+        stop=stop,
+        pre_processors=pre_processors,
+        post_processors=post_processors,
+        **decorator_kwargs,
+    )
+
+
+def logic(
+    prompt: str = "Evaluate the logic expressions:\n",
+    operator: str = "and",
+    default: str | None = None,
+    examples: prm.Prompt = _PROMPT_LOGIC_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,
+):
     """Evaluates a logic expression."""
-    return few_shot(prompt=prompt,
-                    examples=examples,
-                    operator=operator,
-                    constraints=constraints,
-                    default=default,
-                    limit=limit,
-                    stop=stop,
-                    pre_processors=pre_processors,
-                    post_processors=post_processors,
-                    **decorator_kwargs)
-
-
-def invert(prompt: str = "Invert the logic of the content:\n",
-           default: Optional[str] = None,
-           examples: prm.Prompt = prm.InvertExpression(),
-           constraints: List[Callable] = [],
-           limit: int | None = 1,
-           stop: str | None = None,
-           pre_processors: Optional[List[pre.PreProcessor]] = [pre.ArrowMessagePreProcessor()],
-           post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor()],
-           **decorator_kwargs):
+    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,
+        constraints=constraints,
+        default=default,
+        limit=limit,
+        stop=stop,
+        pre_processors=pre_processors,
+        post_processors=post_processors,
+        **decorator_kwargs,
+    )
+
+
+def invert(
+    prompt: str = "Invert the logic of the content:\n",
+    default: str | None = None,
+    examples: prm.Prompt = _PROMPT_INVERT_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,
+):
     """Inverts the logic of a statement."""
-    return few_shot(prompt=prompt,
-                    examples=examples,
-                    constraints=constraints,
-                    default=default,
-                    limit=limit,
-                    stop=stop,
-                    pre_processors=pre_processors,
-                    post_processors=post_processors,
-                    **decorator_kwargs)
-
-
-def simulate(prompt: str = "Simulate the following code:\n",
-             default: Optional[str] = None,
-             examples: prm.Prompt = prm.SimulateCode(),
-             constraints: List[Callable] = [],
-             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()],
-             **decorator_kwargs):
+    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,
+        default=default,
+        limit=limit,
+        stop=stop,
+        pre_processors=pre_processors,
+        post_processors=post_processors,
+        **decorator_kwargs,
+    )
+
+
+def simulate(
+    prompt: str = "Simulate the following code:\n",
+    default: str | None = None,
+    examples: prm.Prompt = _PROMPT_SIMULATE_CODE,
+    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,
+):
     """Simulates code and returns the result."""
-    return few_shot(prompt=prompt,
-                    examples=examples,
-                    constraints=constraints,
-                    default=default,
-                    limit=limit,
-                    stop=stop,
-                    pre_processors=pre_processors,
-                    post_processors=post_processors,
-                    **decorator_kwargs)
-
-
-def code(prompt: str = "Generate code that solves the following problems:\n",
-         default: Optional[str] = None,
-         examples: prm.Prompt = prm.GenerateCode(),
-         constraints: List[Callable] = [],
-         limit: int | None = 1,
-         stop: str | None = None,
-         pre_processors: Optional[List[pre.PreProcessor]] = [pre.GenerateCodePreProcessor()],
-         post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor()],
-         **decorator_kwargs):
+    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,
+        default=default,
+        limit=limit,
+        stop=stop,
+        pre_processors=pre_processors,
+        post_processors=post_processors,
+        **decorator_kwargs,
+    )
+
+
+def code(
+    prompt: str = "Generate code that solves the following problems:\n",
+    default: str | None = None,
+    examples: prm.Prompt = _PROMPT_GENERATE_CODE,
+    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,
+):
     """Generates code that solves a given problem."""
-    return few_shot(prompt=prompt,
-                    examples=examples,
-                    constraints=constraints,
-                    default=default,
-                    limit=limit,
-                    stop=stop,
-                    pre_processors=pre_processors,
-                    post_processors=post_processors,
-                    **decorator_kwargs)
-
-
-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] = [],
-            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()],
-            **decorator_kwargs):
+    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,
+        default=default,
+        limit=limit,
+        stop=stop,
+        pre_processors=pre_processors,
+        post_processors=post_processors,
+        **decorator_kwargs,
+    )
+
+
+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 = None,
+    examples: prm.Prompt = _PROMPT_TEXT_TO_OUTLINE,
+    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,
+):
     """Outlines the essential content as a short list of bullets."""
-    return few_shot(prompt=prompt,
-                    examples=examples,
-                    constraints=constraints,
-                    default=default,
-                    limit=limit,
-                    stop=stop,
-                    pre_processors=pre_processors,
-                    post_processors=post_processors,
-                    **decorator_kwargs)
-
-
-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] = [],
-           limit: int | None = 1,
-           stop: str | None = None,
-           pre_processors: Optional[List[pre.PreProcessor]] = [pre.UniquePreProcessor()],
-           post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor()],
-           **decorator_kwargs):
+    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,
+        default=default,
+        limit=limit,
+        stop=stop,
+        pre_processors=pre_processors,
+        post_processors=post_processors,
+        **decorator_kwargs,
+    )
+
+
+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 = None,
+    default: list[str] | None = None,
+    examples: prm.Prompt = _PROMPT_UNIQUE_KEY,
+    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,
+):
     """Creates a short, unique key that captures the essential topic from the given statements and does not collide with the list of keys."""
-    return few_shot(prompt=prompt,
-                    keys=keys,
-                    examples=examples,
-                    constraints=constraints,
-                    default=default,
-                    limit=limit,
-                    stop=stop,
-                    pre_processors=pre_processors,
-                    post_processors=post_processors,
-                    **decorator_kwargs)
-
-
-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] = [],
-          limit: int | None = 1,
-          stop: str | None = None,
-          pre_processors: Optional[List[pre.PreProcessor]] = [pre.CleanTextMessagePreProcessor()],
-          post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor()],
-          **decorator_kwargs):
+    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,
+        constraints=constraints,
+        default=default,
+        limit=limit,
+        stop=stop,
+        pre_processors=pre_processors,
+        post_processors=post_processors,
+        **decorator_kwargs,
+    )
+
+
+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 = None,
+    examples: prm.Prompt = _PROMPT_CLEAN_TEXT,
+    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,
+):
     """Cleans up a text from special characters and escape sequences."""
-    return few_shot(prompt=prompt,
-                    examples=examples,
-                    constraints=constraints,
-                    default=default,
-                    limit=limit,
-                    stop=stop,
-                    pre_processors=pre_processors,
-                    post_processors=post_processors,
-                    **decorator_kwargs)
-
-
-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] = [],
-            limit: int | None = 1,
-            stop: str | None = None,
-            pre_processors: Optional[List[pre.PreProcessor]] = [pre.GenerateTextPreProcessor()],
-            post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor()],
-            **decorator_kwargs):
+    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,
+        default=default,
+        limit=limit,
+        stop=stop,
+        pre_processors=pre_processors,
+        post_processors=post_processors,
+        **decorator_kwargs,
+    )
+
+
+def compose(
+    prompt: str = "Create a coherent text based on the facts listed in the outline:\n",
+    default: str | None = None,
+    examples: prm.Prompt | None = None,
+    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,
+):
     """Compose a coherent text based on an outline."""
-    return few_shot(prompt=prompt,
-                    examples=examples,
-                    constraints=constraints,
-                    default=default,
-                    limit=limit,
-                    stop=stop,
-                    pre_processors=pre_processors,
-                    post_processors=post_processors,
-                    **decorator_kwargs)
-
-
-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] = [],
-            limit: int | None = 1,
-            stop: str | None = None,
-            pre_processors: Optional[List[pre.PreProcessor]] = [pre.ForEachPreProcessor()],
-            post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor()],
-            **decorator_kwargs):
+    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,
+        default=default,
+        limit=limit,
+        stop=stop,
+        pre_processors=pre_processors,
+        post_processors=post_processors,
+        **decorator_kwargs,
+    )
+
+
+def foreach(
+    condition: str,
+    apply: str,
+    prompt: str = "Iterate over each element and apply operation based on condition:\n",
+    default: str | None = None,
+    examples: prm.Prompt = _PROMPT_FOR_EACH,
+    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,
+):
     """Applies an operation based on a given condition to each element in a list."""
-    return few_shot(prompt=prompt,
-                    condition=condition,
-                    apply=apply,
-                    examples=examples,
-                    constraints=constraints,
-                    default=default,
-                    limit=limit,
-                    stop=stop,
-                    pre_processors=pre_processors,
-                    post_processors=post_processors,
-                    **decorator_kwargs)
-
-
-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] = [],
-               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()],
-               **decorator_kwargs):
+    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,
+        examples=examples,
+        constraints=constraints,
+        default=default,
+        limit=limit,
+        stop=stop,
+        pre_processors=pre_processors,
+        post_processors=post_processors,
+        **decorator_kwargs,
+    )
+
+
+def dictionary(
+    context: str,
+    prompt: str = "Map related content together under a common abstract topic. Do not remove content:\n",
+    default: str | None = None,
+    examples: prm.Prompt = _PROMPT_MAP_CONTENT,
+    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,
+):
     """Maps related content together under a common abstract topic."""
-    return few_shot(prompt=prompt,
-                    context=context,
-                    examples=examples,
-                    constraints=constraints,
-                    default=default,
-                    limit=limit,
-                    stop=stop,
-                    pre_processors=pre_processors,
-                    post_processors=post_processors,
-                    **decorator_kwargs)
-
-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,
-            limit: int | None = 1,
-            pre_processors: Optional[List[pre.PreProcessor]] = [pre.ListPreProcessor()],
-            post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor()],
-            **decorator_kwargs):
+    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,
+        constraints=constraints,
+        default=default,
+        limit=limit,
+        stop=stop,
+        pre_processors=pre_processors,
+        post_processors=post_processors,
+        **decorator_kwargs,
+    )
+
+
+def listing(
+    condition: str,
+    prompt: str = "List each element contained in the text or list based on condition:\n",
+    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: 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."""
-    return few_shot(prompt=prompt,
-                    condition=condition,
-                    examples=examples,
-                    constraints=constraints,
-                    default=default,
-                    stop=stop,
-                    limit=limit,
-                    pre_processors=pre_processors,
-                    post_processors=post_processors,
-                    **decorator_kwargs)
-
-
-def query(context: str,
-          prompt: Optional[str] = None,
-          examples: Optional[prm.Prompt] = None,
-          constraints: List[Callable] = [],
-          default: Optional[object] = None,
-          stop: str | None = None,
-          limit: int | None = 1,
-          pre_processors: Optional[List[pre.PreProcessor]] = [pre.QueryPreProcessor()],
-          post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor()],
-          **decorator_kwargs):
+    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,
+        constraints=constraints,
+        default=default,
+        stop=stop,
+        limit=limit,
+        pre_processors=pre_processors,
+        post_processors=post_processors,
+        **decorator_kwargs,
+    )
+
+
+def query(
+    context: str,
+    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: list[pre.PreProcessor] | None = None,
+    post_processors: list[post.PostProcessor] | None = None,
+    **decorator_kwargs,
+):
     """Performs a query given a context."""
-    return few_shot(prompt=prompt,
-                    context=context,
-                    examples=examples,
-                    constraints=constraints,
-                    default=default,
-                    stop=stop,
-                    limit=limit,
-                    pre_processors=pre_processors,
-                    post_processors=post_processors,
-                    **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,
-           limit: int | None = 1,
-           pre_processors: Optional[List[pre.PreProcessor]] = pre.ExpandFunctionPreProcessor(),
-           post_processors: Optional[List[post.PostProcessor]] = [post.StripPostProcessor(), post.ExpandFunctionPostProcessor()],
-           **decorator_kwargs):
+    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,
+        constraints=constraints,
+        default=default,
+        stop=stop,
+        limit=limit,
+        pre_processors=pre_processors,
+        post_processors=post_processors,
+        **decorator_kwargs,
+    )
+
+
+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: 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."""
-    return few_shot(prompt=prompt,
-                    examples=examples,
-                    constraints=constraints,
-                    default=default,
-                    stop=stop,
-                    limit=limit,
-                    pre_processors=pre_processors,
-                    post_processors=post_processors,
-                    **decorator_kwargs)
-
-
-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,
-           **decorator_kwargs):
+    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,
+        default=default,
+        stop=stop,
+        limit=limit,
+        pre_processors=pre_processors,
+        post_processors=post_processors,
+        **decorator_kwargs,
+    )
+
+
+def search(
+    query: str,
+    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):
             # Construct container object for the arguments and kwargs
-            decorator_kwargs['query'] = query
+            decorator_kwargs["query"] = query
             argument = Argument(signature_args, signature_kwargs, decorator_kwargs)
             return EngineRepository.query(
-                                engine='search',
-                                instance=instance,
-                                func=func,
-                                constraints=constraints,
-                                default=default,
-                                pre_processors=pre_processors,
-                                post_processors=post_processors,
-                                argument=argument)
+                engine="search",
+                instance=instance,
+                func=func,
+                constraints=constraints,
+                default=default,
+                pre_processors=pre_processors,
+                post_processors=post_processors,
+                argument=argument,
+            )
+
         return wrapper
+
     return decorator
 
 
-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()],
-            **decorator_kwargs):
+def opening(
+    path: str,
+    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):
             # Construct container object for the arguments and kwargs
-            decorator_kwargs['path'] = path
+            decorator_kwargs["path"] = path
             argument = Argument(signature_args, signature_kwargs, decorator_kwargs)
             return EngineRepository.query(
-                                engine='files',
-                                instance=instance,
-                                func=func,
-                                constraints=constraints,
-                                default=default,
-                                pre_processors=pre_processors,
-                                post_processors=post_processors,
-                                argument=argument)
+                engine="files",
+                instance=instance,
+                func=func,
+                constraints=constraints,
+                default=default,
+                pre_processors=pre_processors,
+                post_processors=post_processors,
+                argument=argument,
+            )
+
         return wrapper
+
     return decorator
 
 
-def embed(entries: List[str],
-          pre_processors: Optional[List[pre.PreProcessor]] = [pre.UnwrapListSymbolsPreProcessor()],
-          post_processors: Optional[List[post.PostProcessor]] = None,
-          **decorator_kwargs):
+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):
             # Construct container object for the arguments and kwargs
-            decorator_kwargs['entries'] = entries
+            decorator_kwargs["entries"] = entries
             argument = Argument(signature_args, signature_kwargs, decorator_kwargs)
             return EngineRepository.query(
-                                engine='embedding',
-                                instance=instance,
-                                func=func,
-                                pre_processors=pre_processors,
-                                post_processors=post_processors,
-                                argument=argument)
+                engine="embedding",
+                instance=instance,
+                func=func,
+                pre_processors=pre_processors,
+                post_processors=post_processors,
+                argument=argument,
+            )
+
         return wrapper
+
     return decorator
 
 
-def cluster(entries: List[str],
-            pre_processors: Optional[List[pre.PreProcessor]] = [pre.UnwrapListSymbolsPreProcessor()],
-            post_processors: Optional[List[post.PostProcessor]] = [post.ClusterPostProcessor()],
-            **decorator_kwargs):
+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."""
-    assert any(isinstance(pr, post.ClusterPostProcessor) for pr in post_processors), "At least one post processor must be a 'ClusterPostProcessor' for clustering!"
+    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):
             post_pr.set(decorator_kwargs)
 
-    return embed(entries=entries,
-                 pre_processors=pre_processors,
-                 post_processors=post_processors,
-                 **decorator_kwargs)
-
-
-def draw(operation: str = 'create',
-         prompt: str = '',
-         pre_processors: Optional[List[pre.PreProcessor]] = [pre.ValuePreProcessor()],
-         post_processors: Optional[List[post.PostProcessor]] = None,
-         **decorator_kwargs):
+    return embed(
+        entries=entries,
+        pre_processors=pre_processors,
+        post_processors=post_processors,
+        **decorator_kwargs,
+    )
+
+
+def draw(
+    operation: str = "create",
+    prompt: str = "",
+    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):
             # Construct container object for the arguments and kwargs
-            decorator_kwargs['operation'] = operation
-            decorator_kwargs['prompt']    = prompt
+            decorator_kwargs["operation"] = operation
+            decorator_kwargs["prompt"] = prompt
             argument = Argument(signature_args, signature_kwargs, decorator_kwargs)
             return EngineRepository.query(
-                                engine='drawing',
-                                instance=instance,
-                                func=func,
-                                pre_processors=pre_processors,
-                                post_processors=post_processors,
-                                argument=argument)
+                engine="drawing",
+                instance=instance,
+                func=func,
+                pre_processors=pre_processors,
+                post_processors=post_processors,
+                argument=argument,
+            )
+
         return wrapper
+
     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,
-                **decorator_kwargs):
+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):
         @functools.wraps(func)
         def wrapper(instance, *signature_args, **signature_kwargs):
             # Construct container object for the arguments and kwargs
-            decorator_kwargs['image'] = image
-            decorator_kwargs['text']  = text
+            decorator_kwargs["image"] = image
+            decorator_kwargs["text"] = text
             argument = Argument(signature_args, signature_kwargs, decorator_kwargs)
             return EngineRepository.query(
-                                engine='text_vision',
-                                instance=instance,
-                                func=func,
-                                pre_processors=pre_processors,
-                                post_processors=post_processors,
-                                argument=argument)
+                engine="text_vision",
+                instance=instance,
+                func=func,
+                pre_processors=pre_processors,
+                post_processors=post_processors,
+                argument=argument,
+            )
+
         return wrapper
+
     return decorator
 
 
-def ocr(image: str,
-        pre_processors: Optional[List[pre.PreProcessor]] = None,
-        post_processors: Optional[List[post.PostProcessor]] = None,
-        **decorator_kwargs):
+def ocr(
+    image: str,
+    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):
         @functools.wraps(func)
         def wrapper(instance, *signature_args, **signature_kwargs):
             # Construct container object for the arguments and kwargs
-            decorator_kwargs['image'] = image
+            decorator_kwargs["image"] = image
             argument = Argument(signature_args, signature_kwargs, decorator_kwargs)
             return EngineRepository.query(
-                                engine='ocr',
-                                instance=instance,
-                                func=func,
-                                pre_processors=pre_processors,
-                                post_processors=post_processors,
-                                argument=argument)
+                engine="ocr",
+                instance=instance,
+                func=func,
+                pre_processors=pre_processors,
+                post_processors=post_processors,
+                argument=argument,
+            )
+
         return wrapper
+
     return decorator
 
 
-def speech_to_text(prompt: str = 'decode',
-                   pre_processors: Optional[List[pre.PreProcessor]] = None,
-                   post_processors: Optional[List[post.PostProcessor]] = None,
-                   **decorator_kwargs):
+def speech_to_text(
+    prompt: str = "decode",
+    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):
         @functools.wraps(func)
         def wrapper(instance, *signature_args, **signature_kwargs):
             # Construct container object for the arguments and kwargs
-            decorator_kwargs['prompt'] = prompt
+            decorator_kwargs["prompt"] = prompt
             argument = Argument(signature_args, signature_kwargs, decorator_kwargs)
             return EngineRepository.query(
-                                engine='speech-to-text',
-                                instance=instance,
-                                func=func,
-                                pre_processors=pre_processors,
-                                post_processors=post_processors,
-                                argument=argument)
+                engine="speech-to-text",
+                instance=instance,
+                func=func,
+                pre_processors=pre_processors,
+                post_processors=post_processors,
+                argument=argument,
+            )
+
         return wrapper
+
     return decorator
 
 
-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,
-                   **decorator_kwargs):
+def text_to_speech(
+    prompt: str,
+    path: str,
+    voice: str = "nova",
+    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):
         @functools.wraps(func)
         def wrapper(instance, *signature_args, **signature_kwargs):
             # Construct container object for the arguments and kwargs
-            decorator_kwargs['path']   = path
-            decorator_kwargs['voice']  = voice
-            decorator_kwargs['prompt'] = prompt
+            decorator_kwargs["path"] = path
+            decorator_kwargs["voice"] = voice
+            decorator_kwargs["prompt"] = prompt
             argument = Argument(signature_args, signature_kwargs, decorator_kwargs)
             return EngineRepository.query(
-                                engine='text-to-speech',
-                                instance=instance,
-                                func=func,
-                                pre_processors=pre_processors,
-                                post_processors=post_processors,
-                                argument=argument)
+                engine="text-to-speech",
+                instance=instance,
+                func=func,
+                pre_processors=pre_processors,
+                post_processors=post_processors,
+                argument=argument,
+            )
+
         return wrapper
+
     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()],
-           **decorator_kwargs):
+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):
             # Construct container object for the arguments and kwargs
             argument = Argument(signature_args, signature_kwargs, decorator_kwargs)
             return EngineRepository.query(
-                                engine='output',
-                                instance=instance,
-                                func=func,
-                                constraints=constraints,
-                                default=default,
-                                pre_processors=pre_processors,
-                                post_processors=post_processors,
-                                argument=argument)
+                engine="output",
+                instance=instance,
+                func=func,
+                constraints=constraints,
+                default=default,
+                pre_processors=pre_processors,
+                post_processors=post_processors,
+                argument=argument,
+            )
+
         return wrapper
+
     return decorator
 
 
-def scrape(url: str,
-          constraints: List[Callable] = [],
-          default: Optional[object] = None,
-          pre_processors: Optional[List[pre.PreProcessor]] = [],
-          post_processors: Optional[List[post.PostProcessor]] = [],
-          **decorator_kwargs):
+def scrape(
+    url: str,
+    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):
-            decorator_kwargs['url'] = url
+            decorator_kwargs["url"] = url
             argument = Argument(signature_args, signature_kwargs, decorator_kwargs)
             return EngineRepository.query(
-                                engine='webscraping',
-                                instance=instance,
-                                func=func,
-                                constraints=constraints,
-                                default=default,
-                                pre_processors=pre_processors,
-                                post_processors=post_processors,
-                                argument=argument)
+                engine="scrape",
+                instance=instance,
+                func=func,
+                constraints=constraints,
+                default=default,
+                pre_processors=pre_processors,
+                post_processors=post_processors,
+                argument=argument,
+            )
+
         return wrapper
+
     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()],
-              **decorator_kwargs):
+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):
             # Construct container object for the arguments and kwargs
             argument = Argument(signature_args, signature_kwargs, decorator_kwargs)
             return EngineRepository.query(
-                                engine='userinput',
-                                instance=instance,
-                                func=func,
-                                constraints=constraints,
-                                default=default,
-                                pre_processors=pre_processors,
-                                post_processors=post_processors,
-                                argument=argument)
+                engine="userinput",
+                instance=instance,
+                func=func,
+                constraints=constraints,
+                default=default,
+                pre_processors=pre_processors,
+                post_processors=post_processors,
+                argument=argument,
+            )
+
         return wrapper
+
     return decorator
 
 
-def execute(default: Optional[str] = None,
-            constraints: List[Callable] = [],
-            pre_processors: List[pre.PreProcessor] = [],
-            post_processors: List[post.PostProcessor] = [],
-            **decorator_kwargs):
+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):
             # Construct container object for the arguments and kwargs
             argument = Argument(signature_args, signature_kwargs, decorator_kwargs)
             return EngineRepository.query(
-                                engine='execute',
-                                instance=instance,
-                                func=func,
-                                constraints=constraints,
-                                default=default,
-                                pre_processors=pre_processors,
-                                post_processors=post_processors,
-                                argument=argument)
+                engine="execute",
+                instance=instance,
+                func=func,
+                constraints=constraints,
+                default=default,
+                pre_processors=pre_processors,
+                post_processors=post_processors,
+                argument=argument,
+            )
+
         return wrapper
+
     return decorator
 
 
-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] = [],
-          **decorator_kwargs):
+def index(
+    prompt: Any,
+    index_name: str,
+    operation: str = "search",  # | add | config
+    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):
             # Construct container object for the arguments and kwargs
-            decorator_kwargs['operation']  = operation
-            decorator_kwargs['prompt']     = prompt
-            decorator_kwargs['index_name'] = index_name
+            decorator_kwargs["operation"] = operation
+            decorator_kwargs["prompt"] = prompt
+            decorator_kwargs["index_name"] = index_name
             argument = Argument(signature_args, signature_kwargs, decorator_kwargs)
             return EngineRepository.query(
-                                engine='index',
-                                instance=instance,
-                                func=func,
-                                constraints=constraints,
-                                default=default,
-                                pre_processors=pre_processors,
-                                post_processors=post_processors,
-                                argument=argument)
+                engine="index",
+                instance=instance,
+                func=func,
+                constraints=constraints,
+                default=default,
+                pre_processors=pre_processors,
+                post_processors=post_processors,
+                argument=argument,
+            )
+
         return wrapper
+
     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):
             return EngineRepository.command(
-                    engines=engines,
-                    instance=instance,
-                    func=func,
-                    **decorator_kwargs
-                )
+                engines=engines, instance=instance, func=func, **decorator_kwargs
+            )
+
         return wrapper
+
     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)
         def wrapper(instance, **kwargs):
             return EngineRepository.register(
-                    engines=engines,
-                    engine_instance=instance,
-                    func=func,
-                    **kwargs
-                )
+                engines=engines, engine_instance=instance, func=func, **kwargs
+            )
+
         return wrapper
+
     return decorator
 
 
-def tune(operation: str = 'create',
-         pre_processors: Optional[List[pre.PreProcessor]] = None,
-         post_processors: Optional[List[post.PostProcessor]] = None,
-         **decorator_kwargs):
+def tune(
+    operation: str = "create",
+    pre_processors: list[pre.PreProcessor] | None = None,
+    post_processors: list[post.PostProcessor] | None = None,
+    **decorator_kwargs,
+):
     """Fine tune a LLM."""
+
     def decorator(func):
         @functools.wraps(func)
         def wrapper(instance, *signature_args, **signature_kwargs):
-            decorator_kwargs['__cmd__'] = operation #TODO: update engine
+            decorator_kwargs["__cmd__"] = operation  # TODO: update engine
             # Construct container object for the arguments and kwargs
             argument = Argument(signature_args, signature_kwargs, decorator_kwargs)
             return EngineRepository.query(
-                                engine='finetune',
-                                instance=instance,
-                                func=func,
-                                pre_processors=pre_processors,
-                                post_processors=post_processors,
-                                argument=argument)
+                engine="finetune",
+                instance=instance,
+                func=func,
+                pre_processors=pre_processors,
+                post_processors=post_processors,
+                argument=argument,
+            )
+
         return wrapper
+
     return decorator
 
 
-def caption(image: str,
-            prompt: str,
-            pre_processors: Optional[List[pre.PreProcessor]] = [pre.ValuePreProcessor()],
-            post_processors: Optional[List[post.PostProcessor]] = None,
-            **decorator_kwargs):
+def caption(
+    image: str,
+    prompt: str,
+    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):
             # Construct container object for the arguments and kwargs
-            decorator_kwargs['image']  = image
-            decorator_kwargs['prompt'] = prompt
+            decorator_kwargs["image"] = image
+            decorator_kwargs["prompt"] = prompt
             argument = Argument(signature_args, signature_kwargs, decorator_kwargs)
             return EngineRepository.query(
-                                engine='imagecaptioning',
-                                instance=instance,
-                                func=func,
-                                pre_processors=pre_processors,
-                                post_processors=post_processors,
-                                argument=argument)
+                engine="imagecaptioning",
+                instance=instance,
+                func=func,
+                pre_processors=pre_processors,
+                post_processors=post_processors,
+                argument=argument,
+            )
+
         return wrapper
+
     return decorator