"""Create fallback_executor
Generated by Phi-Octopus Eden
2025-11-06 15:32:46.274856
"""

```python
class FallbackExecutor:
    """
    A class for executing tasks with fallback mechanisms in case of errors.

    Args:
        primary_func (Callable): The primary function to execute.
        backup_funcs (List[Callable]): List of functions to try if the primary fails.
        error_types (Tuple[type, ...], optional): Specific exceptions to catch. Defaults to (Exception,).

    Methods:
        run: Execute the task with fallbacks if needed.
    """

    def __init__(self, primary_func: Callable, backup_funcs: List[Callable], error_types: Tuple[type, ...] = (Exception,)):
        self.primary_func = primary_func
        self.backup_funcs = backup_funcs
        self.error_types = error_types

    def run(self, *args, **kwargs) -> Any:
        """
        Execute the task with fallbacks if needed.

        Args:
            args: Arguments to pass to the functions.
            kwargs: Keyword arguments to pass to the functions.

        Returns:
            The result of the successful function execution or None if all fail.
        """
        try:
            return self.primary_func(*args, **kwargs)
        except self.error_types as e:
            for func in self.backup_funcs:
                try:
                    return func(*args, **kwargs)
                except self.error_types:
                    continue
            return None

# Example usage
def primary_task(x: int) -> int:
    """
    A sample function that might fail due to incorrect input.
    
    Args:
        x (int): An integer value.

    Returns:
        int: The doubled value of the input if successful.
    """
    if x < 0:
        raise ValueError("Input must be positive")
    return x * 2

def backup_task_1(x: int) -> int:
    """
    A sample backup function that can handle negative inputs.

    Args:
        x (int): An integer value.

    Returns:
        int: The tripled value of the input.
    """
    return x * 3

def backup_task_2(x: int) -> int:
    """
    Another backup function, in this case simply returns a constant value.
    
    Args:
        x (int): Ignored as this function always returns a fixed value.

    Returns:
        int: The number 10.
    """
    return 10

# Create an instance of FallbackExecutor
executor = FallbackExecutor(
    primary_task,
    [backup_task_1, backup_task_2],
)

# Example calls
print(executor.run(5))  # Output should be 10 as the input is positive and no exception occurs in primary_task.
print(executor.run(-3))  # Output should be -9 from backup_task_1 as primary_task raises an error.
```