# 类是 type 的实例
class MyClass:
    pass

print(type(MyClass))  # <class 'type'>
print(type(type))     # <class 'type'>

# 元类: 控制类的创建
class SingletonMeta(type):
    _instances = {}
    
    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            cls._instances[cls] = super().__call__(*args, **kwargs)
        return cls._instances[cls]

class Database(metaclass=SingletonMeta):
    def __init__(self, connection_string):
        self.conn = connection_string

db1 = Database("sqlite:///test.db")
db2 = Database("sqlite:///other.db")
print(db1 is db2)  # True (单例)

def add_repr(cls):
    """自动为类添加 __repr__"""
    def __repr__(self):
        attrs = ', '.join(f'{k}={v!r}' for k, v in self.__dict__.items())
        return f'{cls.__name__}({attrs})'
    cls.__repr__ = __repr__
    return cls

@add_repr
class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

p = Point(1, 2)
print(p)  # Point(x=1, y=2)

class PluginBase:
    _plugins = {}
    
    def __init_subclass__(cls, **kwargs):
        super().__init_subclass__(**kwargs)
        # 自动注册子类
        PluginBase._plugins[cls.__name__] = cls
    
    @classmethod
    def get_plugin(cls, name):
        return cls._plugins[name]

class JSONPlugin(PluginBase):
    def serialize(self, data):
        import json
        return json.dumps(data)

class YAMLPlugin(PluginBase):
    def serialize(self, data):
        import yaml
        return yaml.dump(data)

# 子类自动注册
print(PluginBase.get_plugin('JSONPlugin'))  # <class 'JSONPlugin'>

class ValidationMeta(type):
    def __new__(mcs, name, bases, namespace):
        # 收集所有带 __expected_type__ 的属性
        validators = {}
        for key, value in namespace.items():
            if hasattr(value, '__expected_type__'):
                validators[key] = value.__expected_type__
        
        # 创建类
        cls = super().__new__(mcs, name, bases, namespace)
        cls._validators = validators
        
        # 包装 __init__
        original_init = cls.__init__
        def validated_init(self, *args, **kwargs):
            original_init(self, *args, **kwargs)
            for attr, expected_type in self._validators.items():
                value = getattr(self, attr, None)
                if value is not None and not isinstance(value, expected_type):
                    raise TypeError(f"{attr} must be {expected_type.__name__}")
        
        cls.__init__ = validated_init
        return cls

class Validated(metaclass=ValidationMeta):
    pass