class ModelMixin(object):
    queryset = None

    def read(self, *args, **kwargs):
        model = self.resource.model

        try:
            if args:
                # If we have any none kwargs then assume the last represents the primrary key
                self.model_instance = model.objects.get(pk=args[-1], **kwargs)
            else:
                # Otherwise assume the kwargs uniquely identify the model
                filtered_keywords = kwargs.copy()
                if BaseRenderer._FORMAT_QUERY_PARAM in filtered_keywords:
                    del filtered_keywords[BaseRenderer._FORMAT_QUERY_PARAM]
                self.model_instance = model.objects.get(**filtered_keywords)
        except model.DoesNotExist:
            raise ErrorResponse(status.HTTP_404_NOT_FOUND)

        return self.model_instance


    def create(self, data, *args, **kwargs):
        model = self.resource.model

        # Copy the dict to keep original intact
        content = dict(data)
        m2m_data = {}

        for field in model._meta.fields:
            if isinstance(field, ForeignKey) and kwargs.has_key(field.name):
                # translate 'related_field' kwargs into 'related_field_id'
                kwargs[field.name + '_id'] = kwargs[field.name]
                del kwargs[field.name]

        for field in model._meta.many_to_many:
            if content.has_key(field.name):
                m2m_data[field.name] = (
                    field.m2m_reverse_field_name(), content[field.name]
                )
                del content[field.name]

        all_kw_args = dict(content.items() + kwargs.items())

        if args:
            instance = model(pk=args[-1], **all_kw_args)
        else:
            instance = model(**all_kw_args)
        instance.save()

        for fieldname in m2m_data:
            manager = getattr(instance, fieldname)

            if hasattr(manager, 'add'):
                manager.add(*m2m_data[fieldname][1])
            else:
                data = {}
                data[manager.source_field_name] = instance

                for related_item in m2m_data[fieldname][1]:
                    data[m2m_data[fieldname][0]] = related_item
                    manager.through(**data).save()

        return instance


    def update(self, data, *args, **kwargs):
        model = self.resource.model

        # TODO: update on the url of a non-existing resource url doesn't work correctly at the moment - will end up with a new url
        try:
            if args:
                # If we have any none kwargs then assume the last represents the primrary key
                self.model_instance = model.objects.get(pk=args[-1], **kwargs)
            else:
                # Otherwise assume the kwargs uniquely identify the model
                self.model_instance = model.objects.get(**kwargs)

            for (key, val) in data.items():
                setattr(self.model_instance, key, val)
        except model.DoesNotExist:
            self.model_instance = model(**data)
            self.model_instance.save()

        self.model_instance.save()
        return self.model_instance


    def deletion(self, *args, **kwargs):
        model = self.resource.model

        try:
            if args:
                # If we have any none kwargs then assume the last represents the primrary key
                instance = model.objects.get(pk=args[-1], **kwargs)
            else:
                # Otherwise assume the kwargs uniquely identify the model
                instance = model.objects.get(**kwargs)
        except model.DoesNotExist:
            raise ErrorResponse(status.HTTP_404_NOT_FOUND)

        instance.delete()
        return


    def list(self, *args, **kwargs):
        model = self.resource.model

        queryset = self.queryset if self.queryset is not None else model.objects.all()

        if hasattr(self, 'resource'):
            ordering = getattr(self.resource, 'ordering', None)
        else:
            ordering = None

        if ordering:
            args = as_tuple(ordering)
            queryset = queryset.order_by(*args)
        return queryset.filter(**kwargs)