"""Create fallback_executor
Generated by Phi-Octopus Eden
2025-11-07 09:38:18.207529
"""

```python
class FallbackExecutor:
    """
    A class for executing tasks with fallback support in case of errors.
    
    This executor attempts to execute a given function and if an error occurs,
    it falls back to a provided alternative function or method.

    :param func: The main function to be executed.
    :type func: Callable
    :param fallback_func: A backup function to be executed in case the main function fails. 
                          If not provided, no fallback is used and execution stops on error.
    :type fallback_func: Optional[Callable]
    
    Usage:
        >>> def divide(a, b):
        ...     return a / b
        ...
        >>> def safe_divide(a, b):
        ...     if b == 0:
        ...         print("Cannot divide by zero")
        ...         return None
        ...     else:
        ...         return a / b
        ...
        >>> executor = FallbackExecutor(divide, fallback_func=safe_divide)
        >>> result = executor.execute(10, 2)  # Normal execution
        5.0
        >>> result = executor.execute(10, 0)  # Error and fallback
        Cannot divide by zero
        None
    """
    
    def __init__(self, func: Callable, fallback_func: Optional[Callable] = None):
        self.func = func
        self.fallback_func = fallback_func
    
    def execute(self, *args, **kwargs) -> Any:
        try:
            return self.func(*args, **kwargs)
        except Exception as e:
            if self.fallback_func is not None:
                print(f"Error occurred: {e}")
                return self.fallback_func(*args, **kwargs)
            else:
                raise e

# Example usage
def multiply(a, b):
    """Multiply two numbers."""
    return a * b

def safe_multiply(a, b):
    """Safe version of multiplication that handles non-integer inputs."""
    if not all(isinstance(i, (int, float)) for i in [a, b]):
        print("Inputs must be integers or floats")
        return None
    else:
        return a * b

executor = FallbackExecutor(multiply, fallback_func=safe_multiply)
result = executor.execute(5, 3)  # Normal execution
print(result)

result = executor.execute('a', 'b')  # Error and fallback
```