      _METHOD_PARAM = '_method'
      _CONTENTTYPE_PARAM = '_content_type'
      _CONTENT_PARAM = '_content'
  
      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
  
      @property
      def method(self):
          """
          Returns the HTTP method.
 
</s> remove     _USE_FORM_OVERLOADING = True
    _METHOD_PARAM = '_method'
    _CONTENTTYPE_PARAM = '_content_type'
    _CONTENT_PARAM = '_content'

    parsers = ()
 </s> add     parser_classes = () </s> remove     The set of parsers that the request can handle.
 </s> add     The set of parsers that the view can handle. </s> remove     def get_request_class(self):
 </s> add     request_class = Request
    """
    The class to use as a wrapper for the original request object.
    """

    def get_parsers(self): </s> remove             self.request = request = self.get_request()
 </s> add             request = self.prepare_request(request) </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 
    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
      _METHOD_PARAM = '_method'
      _CONTENTTYPE_PARAM = '_content_type'
      _CONTENT_PARAM = '_content'
  
    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
    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
    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
    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
    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
    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
    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
    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
    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
    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
    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
    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
    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
    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
    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
    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
    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
    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
  
      @property
      def method(self):
          """
          Returns the HTTP method.
keep keep keep keep replace replace 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