Mastering Metaclasses in Python using real-life scenarios

class MetaClass(type):
    def __new__(cls, name, bases, dct):
        """
        The __new__ method is called when a new class is created (not when an instance is created). It takes four arguments:

        - cls: The metaclass itself.
        - name: The name of the class being created.
        - bases: A tuple of the base/parent classes of the class being created.
        - dct: A dictionary containing all the attributes and methods of the class.

        The purpose of __new__ is to customize the creation of the class object. You can modify the
        attributes or alter the class structure before it is created.
        """
        # Custom logic for creating the class object, modifying attributes, or altering the structure
        return super().__new__(cls, name, bases, dct)

    def __call__(cls, *args, **kwargs):
        """
        The __call__ method is called when an instance of the class is created. It takes three arguments:

        - cls: The class itself.
        - args: The positional arguments passed to the class constructor.
        - kwargs: The keyword arguments passed to the class constructor.

        The purpose of __call__ is to customize the creation or initialization of instances. You can
        perform additional logic before or after instance creation.
        """
        # Custom logic for creating or initializing instances
        return super().__call__(cls, *args, **kwargs)

class NamingConventionMeta(type):
    def __new__(cls, name, bases, dct):
        first_letter = name[0]
        if not first_letter.isupper():
            raise NameError("Class names must start with an uppercase letter.")
        return super().__new__(cls, name, bases, dct)

class GoodClassName(metaclass=NamingConventionMeta):
    pass

# will raise NameError
class bad_className(metaclass=NamingConventionMeta):
    pass

class DocstringMeta(type):
    def __new__(cls, name, bases, dct):
        for attr_name, attr_value in dct.items():
            if callable(attr_value) and not attr_value.__doc__:
                raise TypeError(f"Method '{attr_name}' must have a docstring.")
        return super().__new__(cls, name, bases, dct)

class ExampleClass(metaclass=DocstringMeta):

    def good_method(self):
        """ It contains docstring """
        pass

    # will raise TypeError that docstring is missing
    def bad_method(self):
        pass

class StandardClass(CamelCase, DocstringMeta):  # Inherited from various Meta classes
    pass

class GoodClass(metaclass=StandardClass):
    def good_method(self):
        """ It contains docstring """
        pass

class MethodCountMeta(type):
    max_method_count = 2

    def __new__(cls, name, bases, dct):
        method_count = sum(callable(attr_value) for attr_value in dct.values())
        if method_count > cls.max_method_count:
            raise ValueError(f"Class '{name}' exceeds the maximum allowed method count.")
        return super().__new__(cls, name, bases, dct)

class ExampleClass(metaclass=MethodCountMeta):
    def method1(self):
        pass

    def method2(self):
        pass

    # Raises a ValueError since it exceeds the limit
    def method3(self):
        pass

class DeprecationMeta(type):
    def __new__(cls, name, bases, dct):
        deprecated_methods = {'old_method': 'Use new_method instead'}
        for deprecated_method, message in deprecated_methods.items():
            if deprecated_method in dct and callable(dct[deprecated_method]):
                dct[deprecated_method] = cls._deprecate_method(dct[deprecated_method], message)
        return super().__new__(cls, name, bases, dct)

    @staticmethod
    def _deprecate_method(func, message):
        def wrapper(*args, **kwargs):
            import warnings
            warnings.warn(f"DeprecationWarning: {message}", DeprecationWarning, stacklevel=2)
            return func(*args, **kwargs)
        return wrapper

class Example(metaclass=DeprecationMeta):

    def old_method(self):
        pass

    def new_method(self):
        pass

instance = Example()
instance.new_method()

# will raise DeprecationWarning to use new_method instead
instance.old_method()

class SingletonMeta(type):
    _instances = {}

    def __call__(cls, *args, **kwargs):
        # If an instance of this class doesn't exist, create one and store it
        if cls not in cls._instances:
            instance = super().__call__(*args, **kwargs)
            cls._instances[cls] = instance
        # Return the existing instance
        return cls._instances[cls]

class SingletonClass(metaclass=SingletonMeta):
    pass

instance1 = SingletonClass()
instance2 = SingletonClass()

print(instance1 is instance2)  # Output: True