Python3.5: инициализация класса с использованием наследования

TL;DR — у вас действительно будет RuntimeError: super(): empty __class__ cell..., если вы попытаетесь использовать пустой вызов super из методов метакласса __new__ или __init__: на этом этапе неявная «магическая» переменная __class__, которая super используется внутри, еще не создана. (Проверив это, я только что узнал, что это было исправлено в Python 3.6, то есть: методы классов, использующие super без параметров, могут быть вызваны из метакласса __init__ в Python 3.6, но дают эту ошибку в 3.5)

Если на данный момент это единственное, что вам мешает, просто жестко закодируйте вызов метода суперкласса, как это было необходимо до создания super в Python. (Использование подробной формы super также не сработает).

--

Ваша предпоследняя идея об использовании методов классов в качестве декораторов классов для регистрации может быть реализована путем автоматического создания атрибута SubManagers с метаклассом с помощью простого преобразования имен Python для автоматического создания уникального атрибута SubManagers каждого класса менеджера путем проверки одного собственное пространство имен класса в его __dict__ (и это можно сделать и без метакласса)

Используя метаклассы, просто добавьте эти 2 строки в конец вашего метакласса __init__:

if getattr(cls, "SubManagers") and not "SubManagers" in cls.__dict__:
    cls.SubManagers = []

Если ваш подход к классу-декоратору в противном случае исключает метаклассы, вам не нужно использовать метакласс только для этого - измените свой метод регистрации, чтобы выполнить вышеуказанное создание "собственного" списка подменеджеров:

@classmethod
def RegisterSubManager(cls, manager):
   if not "SubManagers" in cls.__dict__:
       cls.SubManagers = []
   cls.SubManagers.append(manager)

Если вам нужно дополнительное поведение для ваших типов Manager, возможно, вы хотите, чтобы у них был свой собственный, более совершенный метакласс, а не просто тот, который они унаследовали от Component. Попробуйте написать метакласс MetaManager, который наследуется от MetaComponent. Вы даже можете переместить методы класса из Manager1 в метакласс (где они станут обычными методами):

class MetaManager(MetaComponent):
    def __init__(cls, *args, **kwargs):
        super().__init__(*args, **kwargs)
        cls.SubManagers = [] # each class gets its own SubManagers list

    def ListSubManagers(cls):
        for manager in cls.SubManagers:
            print(manager)

    def RegisterSubManager(cls, manager):
        cls.SubManagers.append(manager)
        return manager

class Manager(Component, metaclass=MetaManager): # inherit from this to get the metaclass
    pass

class Manager1(Manager):
    pass

@Manager1.RegisterSubManager
class Manager2(Manager):
    pass

@Manager2.RegisterSubManager
class Manager3(Manager):
    pass

Итак, после некоторых экспериментов мне удалось предоставить «исправление», чтобы разрешить инициализацию класса, позволяющую использовать super().

Во-первых, модуль для «исправления» метода инициализации:

# ./PythonFix.py
import inspect
import types

def IsCellEmpty(cell):
    """Lets keep going, deeper !"""
    try:
        cell.cell_contents
        return False
    except ValueError:
        return True

def ClosureFix(cls, functionContainer):
    """This is where madness happens.
    I didn't want to come here. But hey, lets get mad.
    Had to do this to correct a closure problem occuring in
     Python < 3.6, joy.
    Huge thanks: https://stackoverflow.com/a/4885951/7983255
    """

    # Is the class decorated with @classmethod somehow
    isclassmethod = inspect.ismethod(functionContainer) and functionContainer.__self__ is cls
    if isclassmethod:
        function = functionContainer.__func__
    else:
        function = functionContainer

    # Get cells and prepare a cell holding ref to __class__
    ClosureCells = function.__closure__ or ()
    ClassCell_Fix = (lambda: cls).__closure__[0]

    # Shortcut
    c = function.__code__
    HasClassFreevar = '__class__' in c.co_freevars
    HasEmptyCells = any(IsCellEmpty(cell) for cell in ClosureCells)
    if HasClassFreevar and not HasEmptyCells: # No fix required.
        return classmethod(function)

    Freevars_Fixed = c.co_freevars
    Closure_Fixed = ClosureCells

    if not HasClassFreevar:
        Freevars_Fixed += ('__class__',)
        Closure_Fixed += (ClassCell_Fix,)

    elif HasEmptyCells: # This is silly, but for what I'm doing its ok.
        Closure_Fixed = tuple(ClassCell_Fix if IsCellEmpty(cell) else cell for cell in ClosureCells)

    # Now the real fun begins
    PyCode_fixedFreevars = types.CodeType(
        c.co_argcount, c.co_kwonlyargcount, c.co_nlocals,
        c.co_stacksize, c.co_flags, c.co_code, c.co_consts, c.co_names,
        c.co_varnames, c.co_filename, c.co_name, c.co_firstlineno,
        c.co_lnotab, Freevars_Fixed, c.co_cellvars
    )

    # Lets fetch the last closure to add our __class__ fix
    FixedFunction = types.FunctionType(
        PyCode_fixedFreevars, function.__globals__, function.__name__,
        function.__defaults__, Closure_Fixed
    )

    # Lets rewrap it so it is an actual classmethod (which it should be):
    return classmethod(FixedFunction)

А теперь код компонента:

class MetaComponent(type):
    def __init__(cls:type, *args, **kargs) -> None:
        super().__init__(*args, **kargs)
        if hasattr(cls, 'classinit'):
            cls.classinit = PythonFix.ClosureFix(cls, cls.classinit)
            cls.classinit(**kargs)
        RegisterComponent(cls)

    def classinit(cls:type, **kargs) -> None:
        """The default classinit method."""
        pass

class Component(metaclass=MetaComponent):
    """This class self registers, inherit from this"""

Честно говоря, я доволен тем, что это сделано. Надеюсь, это поможет кому-то, кто тоже хочет инициализировать классы (по крайней мере, в среде до Python3.6...).