Python Hierarchical data structure with inheritance

I would to like to create a metaclass for a hierarchical data structure and write a framework for others to use.

I found this answer very helpful: https://codereview.stackexchange.com/a/162702/275475
It seems close to solving my problem, but if I inherit, for example, Submodule class, it will show assertion error at line: assert isinstance(parent, self._parent_class)

below is the code (copied from the answer in the link above and added my class defines)

class ModuleMetaClass(type):
""" Metaclass that is instantiated once for each class """
_metaclass_instances = None
def __init__(cls, name, bases, attrs):
if cls._metaclass_instances is None:
# First instance is ModuleBaseClass
cls._parent_class = None
cls._metaclass_instances = [type(None)]
else:
# parent class is the previously declared class
cls._parent_class = cls._metaclass_instances[-1]
# if not at the top of the tree, then we are our parent's child
if cls._parent_class != type(None):
cls._parent_class._child_class = cls
# store this class in the list of classes
cls._metaclass_instances.append(cls)
# no child class yet
cls._child_class = None
# call our base (meta) class init
super().__init__(name, bases, attrs)
class ModuleBaseClass(metaclass=ModuleMetaClass):
""" Base class for each of the derived classes in our tree """
def __init__(self, name, parent):
assert isinstance(parent, self._parent_class)
self.name = name
self._parent = parent
if self._child_class is not None:
self._children = {}
# child class variable plural is used to add a common name
plural = getattr(self._child_class, '_plural')
if plural is not None:
setattr(self, plural, self._children)
# add self to our parents collection
if parent is not None:
parent._add_child(self)
# add an access attribute for each of the nodes above us in the tree
while parent is not None:
setattr(self, type(parent).__name__.lower(), parent)
parent = parent._parent
def _add_child(self, child):
assert isinstance(child, self._child_class)
assert child.name not in self._children
self._children[child.name] = child
# --------------------------------
class Module(ModuleBaseClass):
def __init__(self, name, lang):
super().__init__(name, None)
assert lang in ['fr', 'en']
self.lang = lang
class Submodule(ModuleBaseClass):
_plural = 'submodules'
class Ability(ModuleBaseClass):
_plural = 'abilities'
class Template(ModuleBaseClass):
_plural = 'templates'
def __init__(self, name, ability):
super().__init__(name, ability)
self.lang = module.lang
# --------------------------------
# add my class defines
class MyModule(Module):
pass
class MySubmodule(Submodule):
pass
# --------------------------------
# changed instantiation to my class defines, then it would show the assertion error.
module = MyModule('module1', 'fr')
sub_module1 = MySubmodule('sub_module1', module)
sub_module2 = MySubmodule('sub_module2', module)
ability = Ability('ability1', sub_module1)
template = Template('template1', ability)
print(template.lang)

I checked _metaclass_instances, it is [<class 'NoneType'>, <class '__main__.Module'>, <class '__main__.Submodule'>, <class '__main__.Ability'>, <class '__main__.Template'>, <class '__main__.MyModule'>, <class '__main__.MySubmodule'>], and MyModule's parent class is Template, this is obviously not correct, but I have no idea how to modify the code.

The thing is that you are trying to annotate things in different data structures, that not only are hard to follow, but also expect a linear inheritance (only one child to each class), when you actually have a tree: one class can have multiple children.

The fact is that Python already annotates all, or most, of this data automatically - there is no need for a metaclass at all in this case (and even if there is some custom annotation needed at class creation time, a __init_subclass__ method should suffice in this case.

Parent classes to a class can be found in the .__mro__ class attribute, and immediate subclasses to a class in the .__subclasses__() class method. If you don't want your final code to call those directly, you can use properties to get the values you want:

So, try this instead, without a metaclass - give or take marking the ends of your chain explicitly with a None:

class ModuleBaseClass:
""" Base class for each of the derived classes in our tree """
def __init__(self, name, parent):
assert isinstance(parent, self._parent_class)
self.name = name
self._parent = parent
if self._child_classes:
self._children = {}
# child class variable plural is used to add a common name
plural = getattr(self._child_class, '_plural')
if plural is not None:
setattr(self, plural, self._children)
# add self to our parents collection
if parent is not None:
parent._add_child(self)
# add an access attribute for each of the nodes above us in the tree
while parent is not None:
setattr(self, type(parent).__name__.lower(), parent)
parent = parent._parent
@property
def _parent_class(self):
return type(self).__mro__[1]
@property
def _child_classes(self):
return tuple(type(self).__subclasses__())
def _add_child(self, child):
assert isinstance(child, self._child_classes)
assert child.name not in self._children
self._children[child.name] = child
def __getattr__(self, name):
try:
return self._children[name]
except KeyError as error:
raise AttributeError from error
def __len__(self):
return len(self.chilren)

I added the special __getattr__ and __len__ calls there, as I think they may be convenient to your use case.