def METHOD_NAME(self, func, *args, **kwargs):
    """Watch an API resource and stream the result back via a generator.
    Note that watching an API resource can expire. The method tries to
    resume automatically once from the last result, but if that last result
    is too old as well, an `ApiException` exception will be thrown with
    ``code`` 410. In that case you have to recover yourself, probably
    by listing the API resource to obtain the latest state and then
    watching from that state on by setting ``resource_version`` to
    one returned from listing.
    :param func: The API function pointer. Any parameter to the function
                 can be passed after this parameter.
    :return: Event object with these keys:
               'type': The type of event such as "ADDED", "DELETED", etc.
               'raw_object': a dict representing the watched object.
               'object': A model representation of raw_object. The name of
                         model will be determined based on
                         the func's doc string. If it cannot be determined,
                         'object' value will be the same as 'raw_object'.
    Example:
        v1 = kubernetes.client.CoreV1Api()
        watch = kubernetes.watch.Watch()
        for e in watch.stream(v1.list_namespace, resource_version=1127):
            type = e['type']
            object = e['object']  # object is one of type return_type
            raw_object = e['raw_object']  # raw_object is a dict
            ...
            if should_stop:
                watch.stop()
    """
    self._stop = False
    return_type = self.get_return_type(func)
    watch_arg = self.get_watch_argument_name(func)
    kwargs[watch_arg] = True
    kwargs['_preload_content'] = False
    if 'resource_version' in kwargs:
        self.resource_version = kwargs['resource_version']
    # Do not attempt retries if user specifies a timeout.
    # We want to ensure we are returning within that timeout.
    disable_retries = ('timeout_seconds' in kwargs)
    retry_after_410 = False
    while True:
        resp = func(*args, **kwargs)
        try:
            for line in iter_resp_lines(resp):
                # unmarshal when we are receiving events from watch,
                # return raw string when we are streaming log
                if watch_arg == "watch":
                    event = self.unmarshal_event(line, return_type)
                    if isinstance(event, dict) \
                            and event['type'] == 'ERROR':
                        obj = event['raw_object']
                        # Current request expired, let's retry, (if enabled)
                        # but only if we have not already retried.
                        if not disable_retries and not retry_after_410 and \
                                obj['code'] == HTTP_STATUS_GONE:
                            retry_after_410 = True
                            break
                        else:
                            reason = "%s: %s" % (
                                obj['reason'], obj['message'])
                            raise client.rest.ApiException(
                                status=obj['code'], reason=reason)
                    else:
                        retry_after_410 = False
                        yield event
                else:
                    yield line
                if self._stop:
                    break
        finally:
            resp.close()
            resp.release_conn()
            if self.resource_version is not None:
                kwargs['resource_version'] = self.resource_version
            else:
                self._stop = True
        if self._stop or disable_retries:
            break