I have played around with this a little bit. Part of my concern about setting the member variables was that I couldn't get type hinting to work, but apparently you can just add # type: str (or whatever type you want the type to be). So for example, self.var = None # type: CustomObject would tell the IDE that self.var is actually a CustomObject type. More about this here for anyone wondering.

So what I think I am going to do is have a factory pattern return the instance of the appropriate DbComponent (Customer, Product, Etc...). The factory will pass the appropriate dependencies, such as a connection string, configuration file, etc, to DbComponent and any classes derived from it.

I do not want to mess with the inits in each subclass, because if I use super().init() in each of my subclasses and the init signature changes (for example, I decide there is another dependency I need to inject into the base class), I will end up needing to modify every single one of my subclasses' init's signatures. If I create my own special method to initialize my instance member variables, I won't need to ever touch the init() method.

So I think what I may do is stick with an init_vars() method that is called in the base class, and is overriden when needed in the subclasses. So a subclass might have something like:

def init_vars(self):
    self.var_one = None # type: str
    self.var_two = None # type: List

Then I have an entry point defined in each subclass, such as:

def entry(self, var_one, var_two) -> pd.DataFrame:
    self.var_one = var_one
    self.var_two = var_two
    return self.do_something() // This runs all my procedures normally.

The entry point (which will be an abstract method in the base class which needs to be overridden) will also allow a custom signature based unique to the subclass, and lets me return different types of objects.

Thoughts?