              raise ResponseException(status.HTTP_403_FORBIDDEN,
                                      {'detail': 'You do not have permission to access this resource. ' +
                                       'You may need to login or otherwise authenticate the request.'})
  
      def get_form(self, data=None):
          """Optionally return a Django Form instance, which may be used for validation
          and/or rendered by an HTML/XHTML emitter.
          
          If data is not None the form will be bound to data."""
  
          if self.form:
              if data:
                  return self.form(data)
              else:
                  return self.form()
          return None
    
    
      def cleanup_request(self, data, form_instance):
          """Perform any resource-specific data deserialization and/or validation
          after the initial HTTP content-type deserialization has taken place.
          
          Returns a tuple containing the cleaned up data, and optionally a form bound to that data.
          
          By default this uses form validation to filter the basic input into the required types."""
  
          if form_instance is None:
              return data
          
          # Default form validation does not check for additional invalid fields
          non_existent_fields = []
          for key in set(data.keys()) - set(form_instance.fields.keys()):
              non_existent_fields.append(key)
  
          if not form_instance.is_valid() or non_existent_fields:
              if not form_instance.errors and not non_existent_fields:
                  # If no data was supplied the errors property will be None
                  details = 'No content was supplied'
                  
              else:
                  # Add standard field errors
                  details = dict((key, map(unicode, val)) for (key, val) in form_instance.errors.iteritems() if key != '__all__')
  
                  # Add any non-field errors
                  if form_instance.non_field_errors():
                      details['errors'] = form_instance.non_field_errors()
  
                  # Add any non-existent field errors
                  for key in non_existent_fields:
                      details[key] = ['This field does not exist']
  
              # Bail.  Note that we will still serialize this response with the appropriate content type 
              raise ResponseException(status.HTTP_400_BAD_REQUEST, {'detail': details})
  
          return form_instance.cleaned_data
  
  
      def cleanup_response(self, data):
          """Perform any resource-specific data filtering prior to the standard HTTP
          content-type serialization.
  
 
</s> remove         form_instance = resource.form_instance

        # Otherwise if this isn't an error response
        # then attempt to get a form bound to the response object
        if not form_instance and resource.response.has_content_body:
            try:
                form_instance = resource.get_form(resource.response.raw_content)
                if form_instance:
                    form_instance.is_valid()
            except:
                form_instance = None
        
        # If we still don't have a form instance then try to get an unbound form
        if not form_instance:
            try:
                form_instance = self.resource.get_form()
            except:
                pass
 </s> add         #form_instance = resource.form_instance
        # TODO! Reinstate this

        form_instance = None

        if isinstance(self, FormValidatorMixin):
            # Otherwise if this isn't an error response
            # then attempt to get a form bound to the response object
            if not form_instance and resource.response.has_content_body:
                try:
                    form_instance = resource.get_bound_form(resource.response.raw_content)
                    if form_instance:
                        form_instance.is_valid()
                except:
                    form_instance = None
            
            # If we still don't have a form instance then try to get an unbound form
            if not form_instance:
                try:
                    form_instance = self.resource.get_bound_form()
                except:
                    pass </s> remove     def determine_parser(self, request):
        """Return the appropriate parser for the input, given the client's 'Content-Type' header,
        and the content types that this Resource knows how to parse."""
        content_type = request.META.get('CONTENT_TYPE', 'application/x-www-form-urlencoded')
        raw_content = request.raw_post_data
    
        split = content_type.split(';', 1)
        if len(split) > 1:
            content_type = split[0]
        content_type = content_type.strip()
        
        # If CONTENTTYPE_PARAM is turned on, and this is a standard POST form then allow the content type to be overridden
        if (content_type == 'application/x-www-form-urlencoded' and
            request.method == 'POST' and
            self.CONTENTTYPE_PARAM and
            self.CONTENT_PARAM and
            request.POST.get(self.CONTENTTYPE_PARAM, None) and
            request.POST.get(self.CONTENT_PARAM, None)):
            raw_content = request.POST[self.CONTENT_PARAM]
            content_type = request.POST[self.CONTENTTYPE_PARAM]

        # Create a list of list of (media_type, Parser) tuples
        media_type_to_parser = dict([(parser.media_type, parser) for parser in self.parsers])

        try:
            return (media_type_to_parser[content_type], raw_content)
        except KeyError:
            raise ResponseException(status.HTTP_415_UNSUPPORTED_MEDIA_TYPE,
                                    {'detail': 'Unsupported media type \'%s\'' % content_type})


 </s> add  </s> remove     
    
    def determine_method(self, request):
        """Determine the HTTP method that this request should be treated as.
        Allows PUT and DELETE tunneling via the _method parameter if METHOD_PARAM is set."""
        method = request.method.upper()

        if method == 'POST' and self.METHOD_PARAM and request.POST.has_key(self.METHOD_PARAM):
            method = request.POST[self.METHOD_PARAM].upper()
        
        return method
 </s> add  </s> remove     FORM_PARAM_CONTENTTYPE = '_contenttype'
 </s> add     CONTENTTYPE_PARAM = '_contenttype' </s> remove     @property
    def parsed_media_types(self):
        """Return an list of all the media types that this resource can emit."""
        return [parser.media_type for parser in self.parsers]
    
    @property
    def default_parser(self):
        """Return the resource's most prefered emitter.
        (This has no behavioural effect, but is may be used by documenting emitters)"""        
        return self.parsers[0]


 </s> add 
              raise ResponseException(status.HTTP_403_FORBIDDEN,
                                      {'detail': 'You do not have permission to access this resource. ' +
                                       'You may need to login or otherwise authenticate the request.'})
  




















































  
      def cleanup_response(self, data):
          """Perform any resource-specific data filtering prior to the standard HTTP
          content-type serialization.
  
keep keep keep keep replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace keep keep keep keep keep
 Refactor a bunch of stuff into mixins, more tests 
djangorestframework/resource.py