"""Create fallback_executor
Generated by Phi-Octopus Eden
2025-11-06 12:55:47.098565
"""

```python
from typing import Callable, Optional


class FallbackExecutor:
    """
    A class for executing a main task with fallback options in case of errors.
    
    This can be particularly useful when dealing with unreliable systems or operations where
    it's crucial to maintain system stability by having alternative solutions.
    """

    def __init__(self, main_task: Callable[[], None], fallbacks: Optional[list[Callable[[], None]]] = None):
        """
        Initialize the FallbackExecutor.

        :param main_task: The primary task to execute. This is the function that will be tried first.
        :param fallbacks: A list of fallback functions to try in case the main task fails.
        """
        self.main_task = main_task
        self.fallbacks = fallbacks if fallbacks else []

    def run(self) -> None:
        """
        Execute the main task, and if it fails, attempt to execute any available fallback tasks.

        :return: None
        """
        try:
            self.main_task()
        except Exception as e:
            print(f"Main task failed with error: {e}")
            for fallback in self.fallbacks:
                try:
                    fallback()
                    break  # Stop after the first successful fallback
                except Exception as fe:
                    print(f"Fallback failed: {fe}")

    def add_fallback(self, new_fallback: Callable[[], None]) -> None:
        """
        Add a new fallback function to the list of fallbacks.

        :param new_fallback: The fallback function to add.
        """
        self.fallbacks.append(new_fallback)


# Example usage

def main_task() -> None:
    print("Executing Main Task... Failure due to test purposes")
    raise ValueError("Simulated failure")


def fallback1() -> None:
    print("Executing Fallback 1...")
    # Simulate successful execution
    pass


def fallback2() -> None:
    print("Executing Fallback 2... Failure due to test purposes")
    raise TypeError("Simulated failure in fallback 2")


# Create an instance of FallbackExecutor with main task and a list of fallbacks
executor = FallbackExecutor(main_task, [fallback1, fallback2])

# Run the executor. It will try to execute the main task, then fall back to available functions.
executor.run()
```