          if not hasattr(self, '_files'):
              self._load_data_and_files()
          return self._files
  
      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
  
      def _load_data_and_files(self):
          """
          Parses the request content into self.DATA and self.FILES.
          """
          if not hasattr(self, '_content_type'):
 
</s> remove             self._method = self._raw_method
 </s> add             self._method = self.request.method </s> remove         if not self._USE_FORM_OVERLOADING or self._raw_method != 'POST' or not is_form_media_type(self._content_type):
 </s> add         if (not self._USE_FORM_OVERLOADING or self.request.method != 'POST'
                                or not is_form_media_type(self._content_type)): </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
          if not hasattr(self, '_files'):
              self._load_data_and_files()
          return self._files
  
















      def _load_data_and_files(self):
          """
          Parses the request content into self.DATA and self.FILES.
          """
          if not hasattr(self, '_content_type'):
keep keep keep keep replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace keep keep keep keep keep
 cleaned Request/Response/mixins to have similar interface 
djangorestframework/request.py