          self._content_type = self.META.get('HTTP_CONTENT_TYPE', self.META.get('CONTENT_TYPE', ''))
          self._perform_form_overloading()
          # if the HTTP method was not overloaded, we take the raw HTTP method 
          if not hasattr(self, '_method'):
              self._method = self._raw_method
  
      def _get_stream(self):
          """
          Returns an object that may be used to stream the request content.
          """
 
</s> remove     def _load_post_and_files(self):
        """
        Overrides the parent's `_load_post_and_files` to isolate it 
        from the form overloading mechanism (see: `_perform_form_overloading`).
        """
        # When self.POST or self.FILES are called they need to know the original
        # HTTP method, not our overloaded HTTP method. So, we save our overloaded
        # HTTP method and restore it after the call to parent.
        method_mem = getattr(self, '_method', None)
        self._method = self._raw_method
        super(Request, self)._load_post_and_files()
        if method_mem is None:
            del self._method
        else:
            self._method = method_mem

 </s> add  </s> remove         Returns a subclass of Django's `HttpRequest` with a richer API,
        as described in :mod:`request`.
 </s> add         Instantiates and returns the list of parsers that will be used by the request
        to parse its content. </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         if not hasattr(self, '_request_class'):
            self._request_class = request_class_factory(self.request)
            self._request_class._USE_FORM_OVERLOADING = self._USE_FORM_OVERLOADING
            self._request_class._METHOD_PARAM = self._METHOD_PARAM
            self._request_class._CONTENTTYPE_PARAM = self._CONTENTTYPE_PARAM
            self._request_class._CONTENT_PARAM = self._CONTENT_PARAM
            self._request_class.parsers = self.parsers
        return self._request_class
 </s> add         if not hasattr(self, '_parsers'):
            self._parsers = [r(self) for r in self.parser_classes]
        return self._parsers
            self._method = self.request.method
          self._content_type = self.META.get('HTTP_CONTENT_TYPE', self.META.get('CONTENT_TYPE', ''))
          self._perform_form_overloading()
          # if the HTTP method was not overloaded, we take the raw HTTP method 
          if not hasattr(self, '_method'):
            self._method = self.request.method
  
      def _get_stream(self):
          """
          Returns an object that may be used to stream the request content.
          """
keep keep keep keep replace keep keep keep keep keep
 cleaned Request/Response/mixins to have similar interface 
djangorestframework/request.py