          return self._renderers
  
      def prepare_response(self, response):
          """
          Prepares the response for the response cycle. This has no effect if the 
          response is not an instance of :class:`response.Response`.
          """
          if hasattr(response, 'request') and response.request is None:
              response.request = self.request
  
          # Always add these headers.
 
</s> remove             self.prepare_response(response)
 </s> add             response = self.prepare_response(response) </s> remove     parsers = ()
    """
    The set of parsers that the request can handle.

    Should be a tuple/list of classes as described in the :mod:`parsers` module.
    """

    def __init__(self, request):
        # this allows to "copy" a request object into a new instance
        # of our custom request class.

        # First, we prepare the attributes to copy.
        attrs_dict = request.__dict__.copy()
        attrs_dict.pop('method', None)
        attrs_dict['_raw_method'] = request.method

        # Then, put them in the instance's own __dict__
        self.__dict__ = attrs_dict
 </s> add     def __init__(self, request=None, parsers=None):
        """
        `parsers` is a list/tuple of parser instances and represents the set of psrsers
        that the response can handle.
        """
        self.request = request
        if parsers is not None:
            self.parsers = parsers </s> remove         return request_class(original_request)
 </s> add         rkwargs = {}
        if parsers is not None:
            rkwargs['parsers'] = parsers
        request = Request(original_request, **rkwargs)
        # TODO: Just a hack because the parsers need a view. This will be fixed in the future
        class Obj(object): pass
        obj = Obj()
        obj.request = request
        for p in request.parsers:
            p.view = obj
        return request </s> remove     @property
    def _default_renderer(self):
        """
        Return the view's default renderer class.
        """
        return self.get_renderers()[0]

    @property
    def headers(self):
        """
        Dictionary of headers to set on the response.
        This is useful when the response doesn't exist yet, but you
        want to memorize some headers to set on it when it will exist.
        """
        if not hasattr(self, '_headers'):
            self._headers = {}
        return self._headers

 </s> add 
        Prepares the response for the response cycle, and returns the prepared response. 
        This has no effect if the response is not an instance of :class:`response.Response`.
          return self._renderers
  
      def prepare_response(self, response):
          """
        Prepares the response for the response cycle, and returns the prepared response. 
        This has no effect if the response is not an instance of :class:`response.Response`.
        Prepares the response for the response cycle, and returns the prepared response. 
        This has no effect if the response is not an instance of :class:`response.Response`.
          """
          if hasattr(response, 'request') and response.request is None:
              response.request = self.request
  
          # Always add these headers.
keep keep keep keep replace replace keep keep keep keep keep
 cleaned Request/Response/mixins to have similar interface 
djangorestframework/mixins.py