Say I have a project with class Subscriber that I implement with constructors and methods that I need at this time of my project.
Later my functionality needs a subclass of Subscriber, let's say Gold_subscriber that has methods that have different needs for arguments, for example more arguments, keyword arguments etc.
I would like most parts of my program to be ignorant if instances are of certain class or it's subclass, so that I wouldn't have to do type checks or other to check needed arguments for class methods.
I think this could be achieved by defining routinely *args and **kwargs to methods in the class (and subclasses) - I only use them in subclasses when I need them and ignore them if they are not relevant? If I need the arguments in the future, I don't have to tamper with most of the code calling class methods.
However, nobody seems to do this ever and I agree that this sounds messy and awkward..
There must be something I haven't thought of that leads to problems. Why isn't this done?
I guess you are ok with unused **kwargs if those are at least commented in the code (space for future expansion) - but it is not the same for *args: adding positional arguments in specialized classes is much more problematic, due to possible conflicting arguments down the tree, and it would kill the possibility of multiple inheritance with different arguments as well.
Also, if there is any chance your classes are composable, you should just call the methods in super() and pass **kwargs ahead anyway. And that applies even if you are writing a class you think of as the base for a hyerarchy: you might come up later with mixin classes, that could be inserted before your "base" when composing subclasses.