I'm trying to write an abstract class with unimplemented methods, which will force the inheriting children to return a value of a specific type when they override the method (defined in the decorator).
When I use the code shown below, the child method does not call the decorator. I assume this is because the method is being overridden, which makes a lot of sense. My question is basically this: Is there a way to make a decorator persist through method overriding?
I'm not opposed to using something other than a decorator, but this was a solution that quickly popped to mind and I'm curios to know if there's any way to make it work.
In case going with a decorator is the correct and possible choice, it will look something like this:
def decorator(returntype):
def real_decorator(function):
def wrapper(*args, **kwargs):
result = function(*args, **kwargs)
if not type(result) == returntype:
raise TypeError("Method must return {0}".format(returntype))
else:
return result
return wrapper
return real_decorator
I need my parent class to look similar to this one:
class Parent(ABC):
@decorator(int)
@abstractmethod
def aye(self, a):
raise NotImplementedError
And the child class will do something of this sort:
class Child(Parent):
def aye(self, a):
return a
I'd be more than happy to clarify my question better if needed, and thank you to everyone who takes the time to read this question in advance!
I'm not sure you can persists the effect of the decorator the way you want to, but you can still decorate a wrapper function in the Parent
class which will not be an abstractmethod
and let the children class implement the wrapped function like that :
from abc import ABC, abstractmethod
def decorator(returntype):
def real_decorator(function):
def wrapper(*args, **kwargs):
result = function(*args, **kwargs)
if not type(result) == returntype:
raise TypeError("Method must return {0}".format(returntype))
else:
return result
return wrapper
return real_decorator
class Parent(ABC):
@decorator(int)
def aye(self, a):
return self.impl_aye(a)
@abstractmethod
def impl_aye(self, a):
raise NotImplementedError
class Child(Parent):
def impl_aye(self, a):
return a
There is also solutions to protect the aye
method from the Parent
class to be overridden if you need it, see this answer for example.
Otherwise if you want to use type hints and check your code with mypy (an optional static type checker for Python) you can get error message if you try to implement a child class with a return type incompatible with its parent class :
from abc import ABC, abstractmethod
class Parent(ABC):
@abstractmethod
def aye(self, a) -> int:
raise NotImplementedError
class Child(Parent):
def aye(self, a) -> str :
return a
Output of mypy
:
a.py:9: error: Return type "str" of "aye" incompatible with return type "int" in supertype "Parent"
Found 1 error in 1 file (checked 1 source file)