Metaprogramming complete

Author: yuchdev

10_class/03-staticmethod.py

@@ -0,0 +1,65 @@
+__doc__ = """Let's emulate decorator @staticmethod using metaprogramming
+Python @staticmethod is a decorator that is used to define a static method for a function in a class.
+It's quite useless in general, because you very rarely need to call a static method and not a regular function.
+
+Decorator @classmethod is much more useful, because it allows you to call a method of a class,
+instead of a method of an instance of a class.
+Let's emulate it as well 
+
+We may use @classmethod to create a factory method, which is a method that returns an instance of a class.
+"""
+
+
+# noinspection PyPep8Naming, PyShadowingBuiltins
+class staticmethod(object):
+    """
+    Python @staticmethod is a decorator that is used to define a static method for a function in a class.
+    It is just a regular function that is defined inside a class.
+    """
+
+    def __init__(self, function):
+        self.function = function
+
+    def __get__(self, obj, cls=None):
+        return self.function
+
+
+# noinspection PyPep8Naming,PyShadowingBuiltins
+class classmethod(object):
+    def __init__(self, function):
+        self.function = function
+
+    def __get__(self, obj, cls=None):
+        if cls is None:
+            cls = type(obj)
+
+        def new_function(*args, **kwargs):
+            return self.function(cls, *args, **kwargs)
+
+        return new_function
+
+
+# Example 1: Static Method
+class UseStatic:
+    def __init__(self):
+        pass
+
+    @staticmethod
+    def foo():
+        print("foo")
+
+
+UseStatic.foo()
+
+
+# Example 2: Class Method
+class UseClassMethod:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def foo(cls):
+        print(f"cls is {cls}")
+
+
+UseClassMethod.foo()

10_class/04-call.py

@@ -0,0 +1,86 @@
+__doc__ = """In order to make instance callable, we need to implement __call__ method.
+Class `type` use `__call__` method for creating new instances of the class.
+
+Let's emulate it using metaprogramming (in reality its implementation is written in C).
+
+This feature can be used in many powerful design patterns, e.g. Singleton, Factory, etc.
+Let's implement Singleton using the same technique
+
+Method `__new__` is static by definition, so we need to pass cls explicitly
+It reminds of a constructor of the class, but actually it's not.
+`__new__` is a static method that takes the class as a first parameter,
+it's not necessarily to return a new instance of the class.
+"""
+
+
+# Example 1. Create a class using `type` metaclass
+# noinspection PyPep8Naming, PyShadowingBuiltins, PyArgumentList
+class type(object):
+
+    def __call__(self, *args, **kwargs):
+        """
+        :param args: arguments to be passed to the constructor of the class
+        :param kwargs: keyword arguments to be passed to the constructor of the class
+        :return: instance of the class
+        """
+        # Create a new instance of the class
+        obj = self.__new__(self, *args, **kwargs)
+        # Initialize the instance of the class
+        obj.__init__(*args, **kwargs)
+        # Return the instance of the class
+        return obj
+
+
+class UseType:
+    """
+    We don't mention metaclass explicitly, because our `type` shadows the built-in `type`
+    """
+    def __init__(self, a, b):
+        self.a = a
+        self.b = b
+
+    def __repr__(self):
+        return f"UseType(a={self.a}, b={self.b})"
+
+
+c = UseType(1, 2)
+print(c)
+
+
+# Example 2. Create a Singleton class
+class Singleton:
+    """
+    Singleton is a design pattern that restricts the instantiation of a class to one object.
+    It is useful when exactly one object is needed to coordinate actions across the system.
+    """
+    _instance = None
+
+    def __new__(cls, *args, **kwargs):
+        """
+        :param args: arguments to be passed to the constructor of the class
+        :param kwargs: keyword arguments to be passed to the constructor of the class
+        :return: instance of the class
+        """
+        if cls._instance is None:
+            cls._instance = object.__new__(cls)
+            cls._instance.__init__(*args, **kwargs)
+        return cls._instance
+
+    def __init__(self, a, b):
+        self.a = a
+        self.b = b
+
+    def print_params(self):
+        print(f"a == {self.a}, b == {self.b}")
+
+
+singleton = Singleton(1, 2)
+print(singleton)
+singleton.print_params()
+
+singleton2 = Singleton(3, 4)
+print(singleton2)
+singleton2.print_params()
+
+
+assert singleton is singleton2

10_class/05-meta.py

@@ -0,0 +1,110 @@
+__doc__ = """In Python we can use meta-programming to create classes and functions dynamically.
+By default, Python uses `type` metaclass to create classes.
+It can be changed by specifying `metaclass` keyword argument in the class definition.
+
+Usually metaclass is derived from `type` metaclass, but technically it's not necessary.
+Metaclass must provide `__call__` method, which is called when the class is instantiated.
+On this place can be any callable, e.g. function, class, lambda, etc.
+
+Method `__prepare__` is called before `__new__` and `__init__`
+It must return a mapping object that will be used as a namespace for the class.
+
+Useful metaclasses:
+* `abc.ABCMeta` - abstract base classes
+* Iterable - `collections.abc.Iterable` throws an exception if `__iter__` is not implemented
+"""
+
+import abc
+
+
+class Base:
+    pass
+
+
+# noinspection PyUnresolvedReferences
+class UseMetaLambda(Base, var=92, metaclass=lambda *args, **kwargs: print(f"meta({args}, {kwargs})")):
+    """
+    Pass lambda object as a metaclass
+    It's enough as it's just another callable
+    It prints: class name, base classes, keyword arguments, etc.
+    """
+
+    def __init__(self, a, b):
+        self.a = a
+        self.b = b
+
+    def print_me(self):
+        print(f"a == {self.a}, b == {self.b}")
+
+
+# Don't create instance of this class, it won't work
+# print() as a metaclass is not a good idea, because it returns None
+# However class declaration itself is enough to call metaclass
+
+
+# noinspection PyUnresolvedReferences
+class Meta(type):
+    """
+    Typical metaclass implementing `__call__`, `__new__` and `__prepare__` methods
+    """
+
+    def __new__(mcs, name, bases, namespace, **kwargs):
+        """
+        :param mcs: metaclass
+        :param name: name of the class
+        :param bases: base classes
+        :param namespace: namespace of the class
+        :param kwargs: keyword arguments
+        :return: new instance of the class
+        """
+        print(f"Meta.__new__({mcs}, {name}, {bases}, {namespace}, {kwargs})")
+        return super().__new__(mcs, name, bases, namespace)
+
+    def __init__(cls, name, bases, namespace, **kwargs):
+        """
+        `__init__` can be compared to "decorator" of metaclass, because
+        it's called after the class is created, but before it's returned as a result
+        in order to modify the behavior
+        :param cls: class
+        :param name: name of the class
+        :param bases: base classes
+        :param namespace: namespace of the class
+        :param kwargs: keyword arguments
+        """
+        print(f"Meta.__init__({cls}, {name}, {bases}, {namespace}, {kwargs})")
+        super().__init__(name, bases, namespace)
+
+    @classmethod
+    def __prepare__(mcs, name, bases, **kwargs):
+        """
+        Before Python 3.7. it specified the namespace of the class as an OrderedDict.
+        After 3.7 dict is ordered by default, so it's not necessary anymore.
+        :param mcs: metaclass
+        :param name: name of the class
+        :param bases: base classes
+        :param kwargs: keyword arguments
+        :return: mapping object that will be used as a namespace for the class
+        """
+        print(f"Meta.__prepare__({mcs}, {name}, {bases}, {kwargs})")
+        return super().__prepare__(name, bases)
+
+    def __call__(cls, *args, **kwargs):
+        """
+        :param cls: class
+        :param args: arguments to be passed to the constructor of the class
+        :param kwargs: keyword arguments to be passed to the constructor of the class
+        :return: instance of the class
+        """
+        print(f"Meta.__call__({cls}, {args}, {kwargs})")
+        obj = cls.__new__(cls, *args, **kwargs)
+
+
+# noinspection PyUnresolvedReferences
+class Iterable(metaclass=abc.ABCMeta):
+    """
+    Metaclass is used to check that the class implements `__iter__` method
+    You also can check method signature using `inspect.signature` module
+    """
+    @abc.abstractmethod
+    def __iter__(self):
+        raise NotImplementedError()

10_class/06-strict.py

@@ -0,0 +1,56 @@
+__doc__ = """Python is a dynamically typed language, which means that the type of a variable is determined at runtime.
+However, it also features descriptor protocol, which allows to implement strict typing of class attributes.
+Here's an example of a class that enforces strict typing of class attributes.
+
+Starting from Python 3.6 descriptors can be implemented using `__set_name__` method
+which is used for setting the name of the attribute in the class.
+
+Rules of using meta-programming:
+* Metaclass is always one
+* Metaclass can be derived from other metaclass
+* Real metaclass is the most derived metaclass
+* Metaclass often inherits from `type` metaclass, however you can completely redefine its behavior yourself
+* You can use base `abc.ABCMeta` metaclass to create abstract classes
+
+Metaclass can be conflicting, if different classes in the inheritance hierarchy
+have different metaclasses.
+"""
+
+
+# Example 1: Strict Integer using descriptor protocol
+class Integer:
+    def __init__(self, value=0):
+        self.value = value
+
+    def __get__(self, instance, owner):
+        return self.value
+
+    def __set__(self, instance, value):
+        if not isinstance(value, int):
+            raise TypeError(f"{value} is not an integer")
+        self.value = value
+
+    def __delete__(self, instance):
+        del self.value
+
+    def __set_name__(self, owner, name):
+        """
+        Note: `type.__new__` calls `__set_name__` on the descriptor
+        """
+        self.name = name
+
+    def __str__(self):
+        return str(self.value)
+
+
+x = Integer(10)
+print(f"x == {x}")
+
+x = 42
+print(f"x == {x}")
+
+y = Integer()
+x = y
+print(f"x == {x}")
+
+# TODO: useful metaclasses, last 10 minutes of the video

10_class/07-hooks.py

@@ -0,0 +1,46 @@
+__doc__ = """Python hooks are used to implement custom behavior on some events.
+It can replace metaclasses in most cases, as just another way of doing the same thing.
+
+__init_subclass__ hook is called when a class is subclassed in the MRO order
+
+As soon as you inherited from a class with __init_subclass__ hook,
+it will be called on the subclass automatically
+E.g. let's create class to check the coding style of the code to be PEP8 compliant (e.g. `variable_name`)
+"""
+
+
+class CodeStyleChecker:
+    def __init_subclass__(cls, **kwargs):
+        print(f"CodeStyleChecker.__init_subclass__({cls}, {kwargs})")
+        super().__init_subclass__(**kwargs)
+
+        # check we use only lower case letters and underscore
+        for name in dir(cls):
+            if name.startswith("__"):
+                continue
+            if not name.islower():
+                raise ValueError(f"Invalid name: {name}")
+
+    def __init__(self, **kwargs):
+        print(f"CodeStyleChecker.__init__({self}, {kwargs})")
+        super().__init__(**kwargs)
+
+
+class MyClass(CodeStyleChecker):
+    """
+    Defining methods like `def IncorrectName(self)` will raise an exception
+    """
+    def __init__(self, a, b, **kwargs):
+        super().__init__(**kwargs)
+        self.a = a
+        self.b = b
+
+    def print_me(self):
+        print(f"a == {self.a}, b == {self.b}")
+
+    def __str__(self):
+        return f"MyClass(a={self.a}, b={self.b})"
+
+
+c = MyClass(10, 20)
+print(f"c == {c}")