Синглтон в Python без ошибок: метакласс, __call__ и значения по умолчанию

Разбираем, почему __call__ метакласса ломает значения по умолчанию в __init__, как исправить синглтон без ошибок и когда лучше без метакласса в Python.

Когда нужен объект наподобие синглтона, который принимает обязательные параметры, но при этом поддерживает значение по умолчанию, легко запутаться в механике создания объектов в Python. Типичная ловушка — перехватывать создание в метаклассе и случайно затенять дефолты самого класса; из‑за этого конструктор без аргументов падает, хотя в __init__ задано значение по умолчанию.

Проблема

Задача проста: создать класс с обязательными параметрами и значением по умолчанию, сохранить семантику синглтона и при повторных попытках инстанцирования обновлять уже существующий объект. В исходном подходе ниже метакласс обеспечивает единственный экземпляр, но вызов класса без аргументов всё равно приводит к ошибке, несмотря на дефолт в __init__.

class MapMeta(type):
    cache = {}
    def __init__(self, payload, *args, **kwargs):
        super().__init__(payload, *args, **kwargs)
    def __call__(cls, payload, *args, **kwargs):
        if cls not in cls.cache:
            cls.cache[cls] = super().__call__(payload, *args, **kwargs)
            return cls.cache[cls]
        else:
            cls.cache[cls].refresh(payload)
            return cls.cache[cls]
class PanelSR(metaclass=MapMeta):
    BASE = 0x40002000
    def __init__(self, payload=b'\x20\x00\x00\x00'):
        self.refresh(payload)
    def refresh(self, payload):
        self.word = int.from_bytes(payload, 'little')
        self.ENABLE = self.word & 1
        self.SOF = (self.word >> 1) & 1
        self.UDR = (self.word >> 2) & 1
        self.UDD = (self.word >> 3) & 1
        self.RDY = (self.word >> 4) & 1
        self.FCRSF = (self.word >> 5) & 1
    def __repr__(self):
        return ''.join([
            'ENS | ' if self.ENABLE else '',
            'SOF | ' if self.SOF else '',
            'UDR | ' if self.UDR else '',
            'UDD | ' if self.UDD else '',
            'RDY | ' if self.RDY else '',
            'FCRSF' if self.FCRSF else '\b\b\b   ',
        ])
if __name__ == '__main__':
    obj = PanelSR()  # падает, хотя в __init__ есть значение по умолчанию

Почему это ломается

Инстанцирование сначала проходит через __call__ метакласса. Там payload объявлен обязательным аргументом. Это обходит обычную обработку аргументов Python и не даёт сработать значению по умолчанию из __init__ класса. До места, где мог бы примениться дефолт в PanelSR.__init__, дело не доходит — метакласс уже отклонил вызов.

Кроме того, в MapMeta.__init__ лишняя сложность — он ничего не добавляет. Для синглтонов метаклассы часто избыточны и усложняют понимание кода.

Исправление при подходе с метаклассом

Метакласс не должен диктовать набор аргументов вовсе. Пусть __init__ самого класса обрабатывает значения по умолчанию: просто пробрасывайте всё как есть через *args и **kwargs. Если экземпляр уже существует, вызовите его __init__, чтобы повторно использовать ту же логику аргументов и обновить состояние.

class MapMeta(type):
    cache = {}
    def __call__(cls, *args, **kwargs):
        if cls not in cls.cache:
            inst = cls.cache[cls] = super().__call__(*args, **kwargs)
        else:
            inst = cls.cache[cls]
            inst.__init__(*args, **kwargs)
        return inst
class PanelSR(metaclass=MapMeta):
    BASE = 0x40002000
    def __init__(self, payload=b'\x20\x00\x00\x00'):
        self.refresh(payload)
    def refresh(self, payload):
        self.word = int.from_bytes(payload, 'little')
        self.ENABLE = self.word & 1
        self.SOF = (self.word >> 1) & 1
        self.UDR = (self.word >> 2) & 1
        self.UDD = (self.word >> 3) & 1
        self.RDY = (self.word >> 4) & 1
        self.FCRSF = (self.word >> 5) & 1
    def __repr__(self):
        return ''.join([
            'ENS | ' if self.ENABLE else '',
            'SOF | ' if self.SOF else '',
            'UDR | ' if self.UDR else '',
            'UDD | ' if self.UDD else '',
            'RDY | ' if self.RDY else '',
            'FCRSF' if self.FCRSF else '\b\b\b   ',
        ])

Так сохраняется поведение синглтона и устраняется проблема с аргументом по умолчанию без изменения семантики класса.

Предпочтительный вариант без метакласса

Синглтоны в Python не требуют метаклассов. Более простой и поддерживаемый путь — создать единственный экземпляр на уровне модуля и использовать его везде. Если хочется той же «вызываемости», что у класса, дайте экземпляру метод __call__, который обновляет состояние.

class _PanelSR:
    ADDR = 0x40002000
    def __init__(self, payload=b'\x20\x00\x00\x00'):
        self.refresh(payload)
    def refresh(self, payload):
        self.word = int.from_bytes(payload, 'little')
        self.ENABLE = self.word & 1
        self.SOF = (self.word >> 1) & 1
        self.UDR = (self.word >> 2) & 1
        self.UDD = (self.word >> 3) & 1
        self.RDY = (self.word >> 4) & 1
        self.FCRSF = (self.word >> 5) & 1
    def __call__(self, payload=b'\x20\x00\x00\x00'):
        self.refresh(payload)
        return self
    def __repr__(self):
        return ''.join([
            'ENS | ' if self.ENABLE else '',
            'SOF | ' if self.SOF else '',
            'UDR | ' if self.UDR else '',
            'UDD | ' if self.UDD else '',
            'RDY | ' if self.RDY else '',
            'FCRSF' if self.FCRSF else '\b\b\b   ',
        ])
PANEL_SR = _PanelSR()
del _PanelSR
if __name__ == '__main__':
    s = PANEL_SR()

Так модель объектов остаётся простой. Вы всегда работаете с PANEL_SR, а его вызов обновляет данные — это отражает требование «повторное создание обновляет состояние» без какой-либо метаклассовой механики.

Почему это важно

Понимание того, что __call__ метакласса выполняется раньше, чем __init__ класса, помогает избежать тонких багов, когда будто бы «пропадают» значения по умолчанию. Позволяя механизму обработки аргументов Python делать свою работу и пробрасывая *args и **kwargs, вы держите правила конструирования в одном месте. Не менее важно, что синглтоны можно реализовать без метаклассов — это снижает когнитивную нагрузку и уменьшает вероятность сложных для отладки проблем жизненного цикла.

Итоги

Если вам действительно нужен синглтон, навязанный метаклассом, не указывайте параметры в __call__ метакласса; пробрасывайте всё как есть и переиспользуйте __init__ экземпляра для обновления состояния. Если можете — предпочитайте обычный класс с единственным экземпляром на уровне модуля и экземплярным __call__ для обновлений. Прямолинейный путь создания соответствует сильным сторонам Python и приводит к коду, которым проще пользоваться и проще сопровождать.