Приведи пример использования metaclass

# Примеры использования Metaclass в Python

Metaclass — это "класс класса", то есть объект, который создаёт классы. Это продвинутый инструмент Python, который используется редко, но очень мощный. Рассмотрим практические примеры.

1. Что такое Metaclass

# Обычный класс
class Dog:
    species = "Canis familiaris"

dog = Dog()  # dog — это объект класса Dog

# Metaclass — это класс, который создаёт класс
class Meta(type):
    pass

class Cat(metaclass=Meta):
    species = "Felis catus"

cat = Cat()  # cat — объект класса Cat
# Cat — объект класса Meta
# Meta — объект класса type (встроенный metaclass)

Иерархия:

type (встроенный metaclass)
  ↑
  |
Meta (пользовательский metaclass)
  ↑
  |
Cat (класс, созданный Meta)
  ↑
  |
cat (объект класса Cat)

2. Пример 1: Автоматическая регистрация подклассов

Это популярный паттерн для плагинов и фабрик:

class PluginRegistry(type):
    """Metaclass, который автоматически регистрирует подклассы"""
    
    plugins = {}
    
    def __new__(mcs, name, bases, dct):
        cls = super().__new__(mcs, name, bases, dct)
        
        # Регистрируем класс если это не базовый класс
        if bases and bases[0].__name__ != 'Plugin':
            mcs.plugins[name] = cls
        
        return cls

class Plugin(metaclass=PluginRegistry):
    """Базовый класс для плагинов"""
    def execute(self):
        raise NotImplementedError

class EmailPlugin(Plugin):
    """Плагин для отправки email"""
    def execute(self):
        return "Sending email..."

class SlackPlugin(Plugin):
    """Плагин для отправки в Slack"""
    def execute(self):
        return "Sending to Slack..."

class TelegramPlugin(Plugin):
    """Плагин для отправки в Telegram"""
    def execute(self):
        return "Sending to Telegram..."

# Все плагины автоматически зарегистрированы
print(PluginRegistry.plugins)
# Output:
# {
#     'EmailPlugin': <class '__main__.EmailPlugin'>,
#     'SlackPlugin': <class '__main__.SlackPlugin'>,
#     'TelegramPlugin': <class '__main__.TelegramPlugin'>
# }

# Используем плагины
def send_notification(plugin_name, message):
    plugin_class = PluginRegistry.plugins.get(plugin_name)
    if plugin_class:
        plugin = plugin_class()
        return plugin.execute()
    return "Plugin not found"

print(send_notification('EmailPlugin', 'Hello'))  # Sending email...
print(send_notification('SlackPlugin', 'Hello'))   # Sending to Slack...

3. Пример 2: Синглтон (Singleton) через Metaclass

Обеспечивает, что класс имеет только один экземпляр:

class SingletonMeta(type):
    """Metaclass для создания Singleton"""
    _instances = {}
    
    def __call__(cls, *args, **kwargs):
        # Если экземпляр класса ещё не создан, создаём его
        if cls not in cls._instances:
            instance = super().__call__(*args, **kwargs)
            cls._instances[cls] = instance
        
        return cls._instances[cls]

class DatabaseConnection(metaclass=SingletonMeta):
    """Класс для подключения к БД (только один экземпляр)"""
    
    def __init__(self, host='localhost', port=5432):
        print(f"Connecting to {host}:{port}")
        self.host = host
        self.port = port
        self.connected = True
    
    def query(self, sql):
        if self.connected:
            return f"Executing: {sql}"
        return "Not connected"

# Все создания вернут один и тот же объект
db1 = DatabaseConnection()
db2 = DatabaseConnection()
db3 = DatabaseConnection('remote.db')

print(f"db1 is db2: {db1 is db2}")  # True
print(f"db2 is db3: {db2 is db3}")  # True
print(f"id(db1) == id(db2): {id(db1) == id(db2)}")  # True

# Вывод:
# Connecting to localhost:5432  (только один раз!)
# db1 is db2: True
# db2 is db3: True
# id(db1) == id(db2): True

4. Пример 3: Валидация атрибутов класса

Metaclass может проверять классы при их создании:

class ValidatedMeta(type):
    """Metaclass для валидации наличия определённых методов"""
    
    required_methods = ['execute', 'validate']
    
    def __new__(mcs, name, bases, dct):
        # Пропускаем базовый класс
        if bases:
            for method in mcs.required_methods:
                if method not in dct:
                    raise TypeError(
                        f"Class {name} must implement {method}() method"
                    )
        
        return super().__new__(mcs, name, bases, dct)

class Command(metaclass=ValidatedMeta):
    """Базовый класс для команд"""
    pass

# Правильно
class CreateUserCommand(Command):
    def execute(self):
        return "User created"
    
    def validate(self):
        return True

print("CreateUserCommand OK")

# Ошибка!
try:
    class DeleteUserCommand(Command):
        def execute(self):
            return "User deleted"
        # Забыли implement validate()
except TypeError as e:
    print(f"Error: {e}")  # Error: Class DeleteUserCommand must implement validate() method

5. Пример 4: ORM поля (как в Django)

Metaclass используется в Django ORM для создания полей модели:

class Field:
    """Простой Field класс"""
    def __init__(self, field_type=str, required=True):
        self.field_type = field_type
        self.required = required

class ModelMetaclass(type):
    """Metaclass для создания моделей похоже на Django ORM"""
    
    def __new__(mcs, name, bases, namespace):
        fields = {}
        
        # Ищем Field объекты
        for key, value in list(namespace.items()):
            if isinstance(value, Field):
                fields[key] = value
                namespace.pop(key)  # Удаляем из класса
        
        namespace['_fields'] = fields
        return super().__new__(mcs, name, bases, namespace)

class Model(metaclass=ModelMetaclass):
    """Базовый класс для моделей"""
    
    def __init__(self, **kwargs):
        for key, value in kwargs.items():
            if key in self._fields:
                setattr(self, key, value)
    
    def validate(self):
        for field_name, field in self._fields.items():
            if field.required and not hasattr(self, field_name):
                raise ValueError(f"{field_name} is required")
        return True
    
    def to_dict(self):
        return {k: getattr(self, k, None) for k in self._fields}

# Определяем модель
class User(Model):
    name = Field(field_type=str, required=True)
    email = Field(field_type=str, required=True)
    age = Field(field_type=int, required=False)

print(f"User._fields: {User._fields}")
# Output: {'name': <Field>, 'email': <Field>, 'age': <Field>}

# Используем модель
user = User(name="John", email="john@example.com", age=30)
user.validate()
print(user.to_dict())
# Output: {'name': 'John', 'email': 'john@example.com', 'age': 30}

# Ошибка валидации
try:
    user2 = User(name="Jane")
    user2.validate()
except ValueError as e:
    print(f"Validation error: {e}")  # Validation error: email is required

6. Пример 5: Автоматическое создание repr

class ReprMeta(type):
    """Metaclass для автоматического создания красивого __repr__"""
    
    def __new__(mcs, name, bases, namespace):
        # Получаем аннотации типов
        annotations = namespace.get('__annotations__', {})
        
        def __repr__(self):
            items = []
            for attr_name in annotations:
                if hasattr(self, attr_name):
                    value = getattr(self, attr_name)
                    items.append(f"{attr_name}={value!r}")
            return f"{name}({', '.join(items)})"
        
        namespace['__repr__'] = __repr__
        return super().__new__(mcs, name, bases, namespace)

class Point(metaclass=ReprMeta):
    def __init__(self, x: int, y: int, z: int):
        self.x = x
        self.y = y
        self.z = z

p = Point(10, 20, 30)
print(repr(p))  # Point(x=10, y=20, z=30)

7. Когда использовать Metaclass

✓ Используй когда:

• Регистрация плагинов — автоматическая регистрация подклассов
• Singleton pattern — один экземпляр класса
• ORM модели — Django, SQLAlchemy используют metaclass
• Валидация классов — проверка структуры класса при определении
• Автоматическая генерация методов — repr, eq, и т.д.
• Фреймворки — пользовательские DSL и API

✗ Избегай когда:

• Можно решить через обычное наследование
• Можно решить через декораторы классов
• Это усложнит понимание кода
• Есть более простое решение

8. Альтернативы Metaclass

Декоратор класса (часто лучше)

# Вместо metaclass используй декоратор
def register_plugin(cls):
    PLUGINS[cls.__name__] = cls
    return cls

@register_plugin
class MyPlugin:
    pass

# Проще и понятнее!

Наследование

# Вместо сложного metaclass
class BaseModel:
    def __init_subclass__(cls, **kwargs):
        super().__init_subclass__(**kwargs)
        # Код при создании подкласса
        print(f"Subclass {cls.__name__} created")

class MyModel(BaseModel):
    pass

# Output: Subclass MyModel created

Итоги

1. Metaclass — это "классы классов", очень мощный инструмент
2. Используй редко — только когда нужна реальная необходимость
3. Регистрация плагинов — самый частый use case
4. Singleton — часто реализуют через metaclass
5. ORM модели — Django, SQLAlchemy используют metaclass
6. Альтернативы — декораторы и __init_subclass__ часто проще
7. Цитата: "Metaclasses are deeper magic than 99% of users should ever need to think about" — Tim Peters

Помни: если тебе нужен metaclass, ты, вероятно, знаешь, зачем. Если не уверен — используй декоратор или наследование.