<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
 def augments(cls_cpp):
 """Attach methods of a Python support class to an existing class This monkeypatches all methods defined in the support class onto an existing class. Example: .. code-block:: python @augments(ClassDefinedInCpp) class SupportClass: def foo(self):
 pass The Python method 'foo' will be monkeypatched on ClassDefinedInCpp. SupportClass has no meaning on its own and should not be used, but gets returned from this function so IDE code inspection doesn't get too confused. We don't subclass because it's much more convenient to monkeypatch Python methods onto the existing Python binding of the C++ class. For one thing, this allows the implementation to be moved from Python to C++ or vice versa. It saves having to implement an intermediate Python subclass and then ensures that the C++ superclass never 'leaks' to pikepdf users. Finally, wrapper classes and subclasses can become problematic if the call stack crosses the C++/Python boundary multiple times. Any existing methods may be used, regardless of whether they defined elsewhere in the support class or in the target class. The target class does not have to be C++ or derived from pybind11. """


    def class_augment(cls, cls_cpp=cls_cpp):
        for name, fn in inspect.getmembers(cls, inspect.isfunction):
            fn.__qualname__ = fn.__qualname__.replace(cls.__name__, cls_cpp.__name__)
            setattr(cls_cpp, name, fn)
        for name, fn in inspect.getmembers(cls, inspect.isdatadescriptor):
            setattr(cls_cpp, name, fn)

        def block_init(self):
            # Prevent initialization of the support class
            raise NotImplementedError(self.__class__.__name__ + '.__init__')

        cls.__init__ = block_init
        return cls

    return class_augment