I have the class inheritance going on like this...

     Base
      |
     Sub
      |
  ---------
  |       |
TaskA   TaskB

Base implements some loggers and Sub implements the config and Tasks implements the run methods. I wanted to catch all the exceptions raised by the tasks and handle them and return False.

I was hoping I would decorate the abstractmethod with a custom decorator so that I don't need all the inheriting Tasks to decorate them. But it is not working as expected.

from abc import ABC, abstractmethod
from functools import wraps

def catch_exceptions_decorator(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        try:
            return func(*args, **kwargs)
        except Exception as e:
            self = args[0]
            self.log_error("Error running the task.", e)
            return False
    return wrapper

class Base(ABC):

    def log_error(self, message, exception):
        """Log error."""
        print(f"ERROR: {message} {exception}")

    @abstractmethod
    def configure(self):
        """Configure."""
        pass

class Sub(Base):

    def configure(self):
        """Configure."""
        print("Configuring.")

    @abstractmethod
    @catch_exceptions_decorator
    def run(self):
        """Run."""
        pass

class TaskA(Sub):

    def run(self):
        """Run."""
        raise KeyError
        print("Running.")
        return True

task = TaskA()
assert not taskA.run()

I was expecting the KeyError to be caught by the catch_exceptions_decorator and return False insted of raising the exception as shown below.

Traceback (most recent call last):
  File "/Users/X/Desktop/abc_decorator.py", line 47, in <module>
    assert not task.run()
               ^^^^^^^^^^
  File "/Users/X/Desktop/abc_decorator.py", line 43, in run
    raise KeyError
KeyError

What am I doing wrong here ?

EDIT: Ended up using a metaclass and here is the final code if that's helpful to anyone.

from abc import ABC, ABCMeta, abstractmethod
from functools import wraps
from operator import call
from textwrap import wrap


class TaskMeta(type):

    def __new__(cls, name, bases, attrs):
        """Metaclass for tasks."""

        for attr_name, attr_value in attrs.items():
            if attr_name == "run" and callable(attr_value):
                attrs[attr_name] = cls.catch_exceptions_decorator(attr_value)
        return super().__new__(cls, name, bases, attrs)

    @staticmethod
    def catch_exceptions_decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            try:
                return func(*args, **kwargs)
            except Exception as e:
                self = args[0]
                self.log_error("Error running the task.", e)
                return False
        return wrapper


class BaseMeta(ABCMeta, TaskMeta):
    pass


class Base(metaclass=BaseMeta):

    def log_error(self, message, exception):
        """Log error."""
        print(f"ERROR: {message} {exception}")

    @abstractmethod
    def configure(self):
        """Configure."""
        pass


class Sub(Base):

    def configure(self):
        """Configure."""
        print("Configuring.")

    @abstractmethod
    def run(self):
        """Run."""
        pass


class Task(Sub):

    def run(self):
        """Run."""
        raise KeyError
        print("Running.")
        return True


task = Task()
assert not task.run()

Prints the error instead of raising exception.

ERROR: Error running the task.