code: def augments(cls_cpp):
      
  
      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
docs: 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.