code: def add_methods(source_class, blacklist=()):
      
  
      def wrap(wrapped_fx):
          """Wrap a GAPIC method; preserve its name and docstring."""
          # If this is a static or class method, then we need to *not*
          # send self as the first argument.
          #
          # Similarly, for instance methods, we need to send self.api rather
          # than self, since that is where the actual methods were declared.
          instance_method = True
  
          # If this is a bound method it's a classmethod.
          self = getattr(wrapped_fx, "__self__", None)
          if issubclass(type(self), type):
              instance_method = False
  
          # Okay, we have figured out what kind of method this is; send
          # down the correct wrapper function.
          if instance_method:
              fx = lambda self, *a, **kw: wrapped_fx(self.api, *a, **kw)  # noqa
              return functools.wraps(wrapped_fx)(fx)
  
          fx = lambda *a, **kw: wrapped_fx(*a, **kw)  # noqa
          return staticmethod(functools.wraps(wrapped_fx)(fx))
  
      def actual_decorator(cls):
          # Reflectively iterate over most of the methods on the source class
          # (the GAPIC) and make wrapped versions available on this client.
          for name in dir(source_class):
              # Ignore all private and magic methods.
              if name.startswith("_"):
                  continue
  
              # Ignore anything on our blacklist.
              if name in blacklist:
                  continue
  
              # Retrieve the attribute, and ignore it if it is not callable.
              attr = getattr(source_class, name)
              if not callable(attr):
                  continue
  
              # Add a wrapper method to this object.
              fx = wrap(getattr(source_class, name))
              setattr(cls, name, fx)
  
          # Return the augmented class.
          return cls
  
      # Simply return the actual decorator; this is returned from this method
      # and actually used to decorate the class.
      return actual_decorator
docs: Add wrapped versions of the `api` member's methods to the class.
  
      Any methods passed in `blacklist` are not added.
      Additionally, any methods explicitly defined on the wrapped class are
      not added.