      """
  
      media_type = None
  
      def __init__(self, view):
          """
          Initialize the parser with the ``View`` instance as state,
          in case the parser needs to access any metadata on the :obj:`View` object.
          """
          self.view = view
 
</s> remove         parsers = as_tuple(self.parsers)

        for parser_cls in parsers:
            parser = parser_cls(self)
 </s> add         for parser in as_tuple(self.parsers): </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     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 def request_class_factory(request):
    """
    Builds and returns a request class, to be used as a replacement of Django's built-in.
    
    In fact :class:`request.Request` needs to be mixed-in with a subclass of `HttpRequest` for use,
    and we cannot do that before knowing which subclass of `HttpRequest` is used. So this function
    takes a request instance as only argument, and returns a properly mixed-in request class.
    """
    request_class = type(request)
    return type(request_class.__name__, (Request, request_class), {})


 </s> add  </s> remove     List of parsers the resource can parse the request with.
 </s> add     List of parser classes the resource can parse the request with.
    def __init__(self, view=None):
      """
  
      media_type = None
  
    def __init__(self, view=None):
          """
          Initialize the parser with the ``View`` instance as state,
          in case the parser needs to access any metadata on the :obj:`View` object.
          """
          self.view = view
keep keep keep keep replace keep keep keep keep keep
 cleaned Request/Response/mixins to have similar interface 
djangorestframework/parsers.py