django-searchkit 0.1__py3-none-any.whl → 1.0__py3-none-any.whl

build/lib/searchkit/forms/searchkit.py

@@ -0,0 +1,189 @@
+from collections import OrderedDict
+from django import forms
+from django.utils.translation import gettext_lazy as _
+from django.utils.functional import cached_property
+from django.contrib.contenttypes.models import ContentType
+from .utils import CSS_CLASSES, FIELD_PLAN, OPERATOR_DESCRIPTION
+from .utils import SUPPORTED_FIELDS, SUPPORTED_RELATIONS
+
+
+# FIXME: Make this a setting
+RELATION_DEPTH = 3
+
+
+class SearchkitForm(CSS_CLASSES, forms.Form):
+    """
+    Searchkit form representing a model field lookup based on the field name,
+    the operator and one or two values.
+
+    The unbound form is composed of an index field (the count of the searchkit
+    form) and a choice field offering the names of the model fields.
+
+    The bound form is dynamically extended by the operator field or the operator and
+    the value field depending on the provided data
+
+    See the FIELD_PLAN variable for the logic of building the form.
+    """
+    def __init__(self, model, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.model = model
+        self.model_field = None
+        self.field_plan = None
+        self.operator = None
+        self._add_field_name_field()
+        lookup = self._preload_clean_data('field')
+        self.model_field = self._get_model_field(lookup)
+        self.field_plan = next(iter([p for t, p in FIELD_PLAN.items() if t(self.model_field)]))
+        self._add_operator_field()
+        self.operator = self._preload_clean_data('operator')
+        self._add_value_field()
+
+    @cached_property
+    def unprefixed_data(self):
+        data = dict()
+        for key, value in self.data.items():
+            if key.startswith(self.prefix):
+                data[key[len(self.prefix) + 1:]] = value
+        return data
+
+    def _preload_clean_data(self, field_name):
+        # Try the initial value first since it is already cleaned.
+        if self.initial and field_name in self.initial:
+            return self.initial[field_name]
+        # Otherwise look up the data dict.
+        elif field_name in self.unprefixed_data:
+            try:
+                # Do we have a valid value?
+                return self.fields[field_name].clean(self.unprefixed_data[field_name])
+            except forms.ValidationError:
+                return self.fields[field_name].choices[0][0]
+        else:
+            # At last simply return the first option which will be the selected
+            # one.
+            return self.fields[field_name].choices[0][0]
+
+    def _get_model_field(self, lookup):
+        path = lookup.split('__')
+        model = self.model
+        for index, field_name in enumerate(path, 1):
+            field = model._meta.get_field(field_name)
+            if index < len(path):
+                model = field.remote_field.model
+        return field
+
+    def _get_model_field_choices(self, model, fields=[]):
+        choices = list()
+        for model_field in model._meta.fields:
+            if any(isinstance(model_field, f) for f in SUPPORTED_FIELDS):
+                lookup = '__'.join([f.name for f in [*fields, model_field]])
+                label = ' -> '.join(f.verbose_name for f in [*fields, model_field])
+                choices.append((lookup, label))
+        if len(fields) < RELATION_DEPTH:
+            for model_field in model._meta.fields:
+                if any(isinstance(model_field, f) for f in SUPPORTED_RELATIONS):
+                    related_model = model_field.remote_field.model
+                    fields = [*fields, model_field]
+                    choices += self._get_model_field_choices(related_model, fields)
+        return choices
+
+    def _add_field_name_field(self):
+        initial = self.initial.get('field')
+        choices = self._get_model_field_choices(self.model)
+        field = forms.ChoiceField(label=_('Model field'), choices=choices, initial=initial)
+        field.widget.attrs.update({"class": CSS_CLASSES.reload_on_change_css_class})
+        self.fields['field'] = field
+
+    def _add_operator_field(self):
+        initial = self.initial.get('operator')
+        choices = [(o, OPERATOR_DESCRIPTION[o]) for o in self.field_plan.keys()]
+        field = forms.ChoiceField(label=_('Operator'), choices=choices, initial=initial)
+        field.widget.attrs.update({"class": CSS_CLASSES.reload_on_change_css_class})
+        self.fields['operator'] = field
+
+    def _add_value_field(self):
+        initial = self.initial.get('value')
+        field_class = self.field_plan[self.operator][0]
+        if getattr(field_class, 'choices', None) and getattr(self.model_field, 'choices', None):
+            field = field_class(choices=self.model_field.choices, initial=initial)
+        else:
+            field = field_class()
+        self.fields['value'] = field
+
+
+class ContentTypeForm(CSS_CLASSES, forms.Form):
+    """
+    Form to select a content type.
+    """
+    contenttype = forms.ModelChoiceField(
+        queryset=ContentType.objects.all(),  # FIXME: Limit choices to models that can be filtered.
+        label=_('Model'),
+        empty_label=_('Select a Model'),
+        widget=forms.Select(attrs={"class": CSS_CLASSES.reload_on_change_css_class}),
+    )
+
+    class Media:
+        js = [
+            'admin/js/vendor/jquery/jquery.min.js',
+            'admin/js/jquery.init.js',
+            "searchkit/searchkit.js"
+        ]
+
+
+class BaseSearchkitFormset(CSS_CLASSES, forms.BaseFormSet):
+    """
+    Formset holding all searchkit forms.
+    """
+    template_name = "searchkit/searchkit.html"
+    template_name_div = "searchkit/searchkit.html"
+    default_prefix = 'searchkit'
+    form = SearchkitForm
+    contenttype_form_class = ContentTypeForm
+
+    def __init__(self, *args, **kwargs):
+        self.model = kwargs.pop('model', None)
+        super().__init__(*args, **kwargs)
+        self.contenttype_form = self.get_conttenttype_form(kwargs)
+        if not self.model and self.contenttype_form.is_valid():
+            self.model = self.contenttype_form.cleaned_data.get('contenttype').model_class()
+        if self.initial:
+            self.extra = 0
+
+    def get_conttenttype_form(self, kwargs):
+        ct_kwargs = dict()
+        ct_kwargs['data'] = self.data or None
+        ct_kwargs['prefix'] = self.prefix
+        if self.model:
+            contenttype = ContentType.objects.get_for_model(self.model)
+            ct_kwargs['initial'] = dict(contenttype=contenttype)
+        return self.contenttype_form_class(**ct_kwargs)
+
+    def get_form_kwargs(self, index):
+        kwargs = self.form_kwargs.copy()
+        kwargs['model'] = self.model
+        return kwargs
+
+    def add_prefix(self, index):
+        if self.model:
+            return "%s-%s-%s" % (self.prefix, self.model._meta.model_name, index)
+
+    @classmethod
+    def get_default_prefix(cls):
+        return cls.default_prefix
+
+    @cached_property
+    def forms(self):
+        # We won't render any forms if we got no model.
+        return super().forms if self.model else []
+
+    @property
+    def media(self):
+        return self.contenttype_form.media
+
+    def is_valid(self):
+        return self.contenttype_form.is_valid() and self.forms and super().is_valid()
+
+
+SearchkitFormSet = forms.formset_factory(
+        form=SearchkitForm,
+        formset=BaseSearchkitFormset,
+    )

build/lib/searchkit/forms/utils.py

@@ -0,0 +1,149 @@
+from django.db import models
+from django import forms
+from django.utils.translation import gettext_lazy as _
+from collections import OrderedDict
+from searchkit.forms import fields as searchkit_fields
+
+
+OPERATOR_DESCRIPTION = {
+    'exact': _('is exact'),
+    'contains': _('contains'),
+    'startswith': _('starts with'),
+    'endswith': _('ends with'),
+    'regex': _('matches regular expression'),
+    'gt': _('is greater than'),
+    'gte': _('is greater than or equal'),
+    'lt': _('is lower than'),
+    'lte': _('is lower than or equal'),
+    'range': _('is between'),
+    'in': _('is one of'),
+}
+
+
+SUPPORTED_FIELDS = [
+    models.BooleanField,
+    models.CharField,
+    models.IntegerField,
+    models.FloatField,
+    models.DecimalField,
+    models.DateField,
+    models.DateTimeField,
+]
+SUPPORTED_RELATIONS = [
+    models.ForeignKey,
+    models.OneToOneField,
+]
+
+
+FIELD_PLAN = OrderedDict((
+    (
+        lambda f: isinstance(f, models.BooleanField),
+        {
+            'exact': (forms.NullBooleanField,),
+        }
+    ),
+    (
+        lambda f: isinstance(f, models.CharField) and f.choices,
+        {
+            'exact': (forms.ChoiceField,),
+            'contains': (forms.CharField,),
+            'startswith': (forms.CharField,),
+            'endswith': (forms.CharField,),
+            'regex': (forms.CharField,),
+            'in': (forms.MultipleChoiceField,),
+        }
+    ),
+    (
+        lambda f: isinstance(f, models.CharField),
+        {
+            'exact': (forms.CharField,),
+            'contains': (forms.CharField,),
+            'startswith': (forms.CharField,),
+            'endswith': (forms.CharField,),
+            'regex': (forms.CharField,),
+        }
+    ),
+    (
+        lambda f: isinstance(f, models.IntegerField) and f.choices,
+        {
+            'exact': (forms.ChoiceField,),
+            'contains': (forms.IntegerField,),
+            'startswith': (forms.IntegerField,),
+            'endswith': (forms.IntegerField,),
+            'regex': (forms.IntegerField,),
+            'in': (forms.MultipleChoiceField,),
+        }
+    ),
+    (
+        lambda f: isinstance(f, models.IntegerField),
+        {
+            'exact': (forms.IntegerField,),
+            'gt': (forms.IntegerField,),
+            'gte': (forms.IntegerField,),
+            'lt': (forms.IntegerField,),
+            'lte': (forms.IntegerField,),
+            'range': (searchkit_fields.IntegerRangeField,),
+        }
+    ),
+    (
+        lambda f: isinstance(f, models.FloatField),
+        {
+            'exact': (forms.FloatField,),
+            'gt': (forms.FloatField,),
+            'gte': (forms.FloatField,),
+            'lt': (forms.FloatField,),
+            'lte': (forms.FloatField,),
+            'range': (searchkit_fields.IntegerRangeField,),
+        }
+    ),
+    (
+        lambda f: isinstance(f, models.DecimalField),
+        {
+            'exact': (forms.DecimalField,),
+            'gt': (forms.DecimalField,),
+            'gte': (forms.DecimalField,),
+            'lt': (forms.DecimalField,),
+            'lte': (forms.DecimalField,),
+            'range': (searchkit_fields.IntegerRangeField,),
+        }
+    ),
+    (
+        lambda f: isinstance(f, models.DateTimeField),
+        {
+            'exact': (forms.DateTimeField,),
+            'gt': (forms.DateTimeField,),
+            'gte': (forms.DateTimeField,),
+            'lt': (forms.DateTimeField,),
+            'lte': (forms.DateTimeField,),
+            'range': (searchkit_fields.DateTimeRangeField,),
+        }
+    ),
+    (
+        lambda f: isinstance(f, models.DateField),
+        {
+            'exact': (forms.DateField,),
+            'gt': (forms.DateField,),
+            'gte': (forms.DateField,),
+            'lt': (forms.DateField,),
+            'lte': (forms.DateField,),
+            'range': (searchkit_fields.DateRangeField,),
+        }
+    ),
+))
+
+
+class CSS_CLASSES:
+    reload_on_change_css_class = "searchkit-reload-on-change"
+    reload_on_click_css_class = "searchkit-reload-on-click"
+
+
+def get_filter_rules(formset):
+    """
+    Build filter rules out of the cleaned data of the formset.
+    :param formset: Formset to extract filter rules from.
+    :return: OrderedDict with filter rule pairs: field__operator: value
+    """
+    lookups = OrderedDict()
+    for data in formset.cleaned_data:
+        lookups[f'{data["field"]}__{data["operator"]}'] = data['value']
+    return lookups

build/lib/searchkit/migrations/0001_initial.py

@@ -0,0 +1,30 @@
+# Generated by Django 5.1.3 on 2025-05-22 19:04
+
+import django.db.models.deletion
+import picklefield.fields
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+        ('contenttypes', '0002_remove_content_type_name'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='SearchkitSearch',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('name', models.CharField(max_length=255, verbose_name='Search name')),
+                ('data', picklefield.fields.PickledObjectField(editable=False, verbose_name='Serialized filter rule data')),
+                ('created_date', models.DateTimeField(auto_now_add=True)),
+                ('contenttype', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='contenttypes.contenttype', verbose_name='Model')),
+            ],
+            options={
+                'unique_together': {('name', 'contenttype')},
+            },
+        ),
+    ]

build/lib/searchkit/models.py

@@ -0,0 +1,23 @@
+from collections import OrderedDict
+from picklefield.fields import PickledObjectField
+from django.db import models
+from django.contrib.contenttypes.models import ContentType
+from django.utils.translation import gettext_lazy as _
+
+
+# Create your models here.
+# TODO: Use pickled cleaned data with a char field.
+class SearchkitSearch(models.Model):
+    name = models.CharField(_('Search name'), max_length=255)
+    contenttype = models.ForeignKey(ContentType, on_delete=models.CASCADE, verbose_name=_('Model'))
+    data = PickledObjectField(_('Serialized filter rule data'))
+    created_date = models.DateTimeField(auto_now_add=True)
+
+    class Meta:
+        unique_together = ('name', 'contenttype')
+
+    def get_filter_rules(self):
+        lookups = OrderedDict()
+        for data in self.data:
+            lookups[f'{data["field"]}__{data["operator"]}'] = data['value']
+        return lookups

build/lib/searchkit/templatetags/searchkit.py

@@ -0,0 +1,47 @@
+from django.template import Library
+from django.urls import reverse
+from django.contrib.admin.helpers import Fieldset
+from ..forms.utils import CSS_CLASSES
+
+
+register = Library()
+
+
+@register.simple_tag
+def searchkit_url(formset):
+    """
+    Return url to reload the formset.
+    """
+    app_label = formset.model._meta.app_label
+    model_name = formset.model._meta.model_name
+    url = reverse('searchkit_form', args=[app_label, model_name])
+    return url
+
+@register.simple_tag
+def on_change_class():
+    """
+    Return css class for on change handler.
+    """
+    return CSS_CLASSES.reload_on_change_css_class
+
+@register.simple_tag
+def on_click_class():
+    """
+    Return css class for on click handler.
+    """
+    return CSS_CLASSES.reload_on_click_css_class
+
+@register.inclusion_tag("admin/includes/fieldset.html")
+def as_fieldset(form, heading_level=2, prefix='', id_prefix=0, id_suffix='', **fieldset_kwargs):
+    """
+    Create and render a fieldset for form.
+    """
+    fieldset = Fieldset(form, fields=form.fields, **fieldset_kwargs)
+    context = dict(
+        fieldset=fieldset,
+        heading_level=heading_level,
+        prefix=prefix,
+        id_prefix=id_prefix,
+        id_suffix=id_suffix,
+    )
+    return context

build/lib/searchkit/tests.py

@@ -0,0 +1,250 @@
+from django.test import TestCase
+from django.contrib.contenttypes.models import ContentType
+from django import forms
+from example.models import ModelA
+from searchkit.forms.utils import FIELD_PLAN
+from searchkit.forms.utils import SUPPORTED_FIELDS
+from searchkit.forms.utils import SUPPORTED_RELATIONS
+from searchkit.forms import SearchkitSearchForm
+from searchkit.forms import SearchkitForm
+from searchkit.forms import SearchkitFormSet
+
+
+INITIAL_DATA = [
+    dict(
+        field='model_b__chars',
+        operator='exact',
+        value='anytext',
+    ),
+    dict(
+        field='integer',
+        operator='range',
+        value=[1, 123],
+    ),
+    dict(
+        field='float',
+        operator='exact',
+        value='0.3',
+    ),
+    dict(
+        field='decimal',
+        operator='exact',
+        value='1.23',
+    ),
+    dict(
+        field='date',
+        operator='exact',
+        value='2025-05-14',
+    ),
+    dict(
+        field='datetime',
+        operator='exact',
+        value='2025-05-14 08:45',
+    )
+]
+
+add_prefix = lambda i: SearchkitFormSet(model=ModelA).add_prefix(i)
+DEFAULT_PREFIX = SearchkitFormSet.get_default_prefix()
+FORM_DATA = {
+    'name': 'test search',                  # The name of the search.
+    f'{DEFAULT_PREFIX}-TOTAL_FORMS': '6',   # Data for the managment form.
+    f'{DEFAULT_PREFIX}-INITIAL_FORMS': '1', # Data for the managment form.
+    f'{DEFAULT_PREFIX}-contenttype': f'{ContentType.objects.get_for_model(ModelA).pk}',
+    f'{add_prefix(1)}-value_0': '1',        # Data for the range operator.
+    f'{add_prefix(1)}-value_1': '123',      # Data for the range operator.
+}
+for i, data in enumerate(INITIAL_DATA, 0):
+    prefix = SearchkitFormSet(model=ModelA).add_prefix(i)
+    for key, value in data.items():
+        FORM_DATA.update({f'{prefix}-{key}': value})
+
+
+class CheckFormMixin:
+    """
+    Mixin to check the form fields and their choices.
+    """
+    def check_form(self, form):
+        # Three fields should be generated on instantiation.
+        self.assertIn('field', form.fields)
+        self.assertIn('operator', form.fields)
+        self.assertIn('value', form.fields)
+        self.assertEqual(len(form.fields), 3)
+
+        # Check choices of the model_field.
+        form_model_field = form.fields['field']
+        self.assertTrue(form_model_field.choices)
+        options = [c[0] for c in form_model_field.choices]
+        for model_field in ModelA._meta.fields:
+            if isinstance(model_field, tuple(SUPPORTED_FIELDS)):
+                self.assertIn(model_field.name, options)
+
+        # Check choices for relational lookups.
+        for model_field in ModelA._meta.fields:
+            if isinstance(model_field, tuple(SUPPORTED_RELATIONS)):
+                remote_fields = model_field.remote_field.model._meta.fields
+                for remote_field in remote_fields:
+                    if isinstance(model_field, tuple(SUPPORTED_FIELDS)):
+                        lookup_path = f'{model_field.name}__{remote_field.name}'
+                        self.assertIn(lookup_path, options)
+
+        # Check the field_plan choosen based on the model_field.
+        field_plan = next(iter([p for t, p in FIELD_PLAN.items() if t(form.model_field)]))
+        self.assertEqual(form.field_plan, field_plan)
+
+        # Check choices of the operator field based on the field_plan.
+        operator_field = form.fields['operator']
+        self.assertTrue(operator_field.choices)
+        self.assertEqual(len(operator_field.choices), len(form.field_plan))
+        for operator in form.field_plan.keys():
+            self.assertIn(operator, [c[0] for c in operator_field.choices])
+
+
+class SearchkitFormTestCase(CheckFormMixin, TestCase):
+
+    def test_blank_searchkitform(self):
+        form = SearchkitForm(ModelA, prefix=add_prefix(0))
+        self.check_form(form)
+
+        # Form should not be bound or valid.
+        self.assertFalse(form.is_bound)
+        self.assertFalse(form.is_valid())
+
+    def test_searchkitform_with_invalid_model_field_data(self):
+        data = {
+            f'{add_prefix(0)}-field': 'foobar',
+        }
+        form = SearchkitForm(ModelA, data, prefix=add_prefix(0))
+        self.check_form(form)
+
+        # Form should be invalid.
+        self.assertFalse(form.is_valid())
+
+        # Check error message in html.
+        errors = ['Select a valid choice. foobar is not one of the available choices.']
+        self.assertIn(errors, form.errors.values())
+
+    def test_searchkitform_with_valid_model_field_data(self):
+        data = {
+            f'{add_prefix(0)}-field': 'integer',
+        }
+        form = SearchkitForm(ModelA, data, prefix=add_prefix(0))
+        self.check_form(form)
+
+        # Form should be invalid since no value data is provieded.
+        self.assertFalse(form.is_valid())
+
+    def test_searchkitform_with_invalid_operator_data(self):
+        data = {
+            f'{add_prefix(0)}-field': 'integer',
+            f'{add_prefix(0)}-operator': 'foobar',
+        }
+        form = SearchkitForm(ModelA, data, prefix=add_prefix(0))
+        self.check_form(form)
+
+        # Form should be invalid.
+        self.assertFalse(form.is_valid())
+
+        # Check error message in html.
+        errors = ['Select a valid choice. foobar is not one of the available choices.']
+        self.assertIn(errors, form.errors.values())
+
+    def test_searchkitform_with_valid_operator_data(self):
+        data = {
+            f'{add_prefix(0)}-field': 'integer',
+            f'{add_prefix(0)}-operator': 'exact',
+        }
+        form = SearchkitForm(ModelA, data, prefix=add_prefix(0))
+        self.check_form(form)
+
+        # Form should be invalid since no value data is provieded.
+        self.assertFalse(form.is_valid())
+
+    def test_searchkitform_with_valid_data(self):
+        data = {
+            f'{add_prefix(0)}-field': 'integer',
+            f'{add_prefix(0)}-operator': 'exact',
+            f'{add_prefix(0)}-value': '123',
+        }
+        form = SearchkitForm(ModelA, data, prefix=add_prefix(0))
+        self.check_form(form)
+
+        # Form should be valid.
+        self.assertTrue(form.is_valid())
+
+    def test_searchkitform_with_invalid_data(self):
+        data = {
+            f'{add_prefix(0)}-field': 'integer',
+            f'{add_prefix(0)}-operator': 'exact',
+            f'{add_prefix(0)}-value': 'foobar',
+        }
+        form = SearchkitForm(ModelA, data, prefix=add_prefix(0))
+        self.check_form(form)
+
+        # Form should be invalid.
+        self.assertFalse(form.is_valid())
+
+        # Check error message in html.
+        errors = ['Enter a whole number.']
+        self.assertIn(errors, form.errors.values())
+
+
+class SearchkitFormSetTestCase(CheckFormMixin, TestCase):
+    def test_blank_searchkitform(self):
+        # Instantiating the formset neither with a model instance nor with model
+        # related data or initial data should result in a formset without forms,
+        # that is invalid and unbound.
+        formset = SearchkitFormSet()
+        self.assertFalse(formset.is_bound)
+        self.assertFalse(formset.is_valid())
+
+    def test_searchkit_formset_with_valid_data(self):
+        formset = SearchkitFormSet(FORM_DATA)
+        self.assertTrue(formset.is_valid())
+
+    def test_searchkit_formset_with_invalid_data(self):
+        data = FORM_DATA.copy()
+        del data[f'{add_prefix(0)}-value']
+        formset = SearchkitFormSet(data, model=ModelA)
+        self.assertFalse(formset.is_valid())
+
+        # Check error message in html.
+        errors = ['This field is required.']
+        self.assertIn(errors, formset.forms[0].errors.values())
+
+    def test_searchkit_formset_with_initial_data(self):
+        formset = SearchkitFormSet(initial=INITIAL_DATA, model=ModelA)
+        self.assertFalse(formset.is_bound)
+        self.assertFalse(formset.is_valid())
+        self.assertEqual(len(formset.forms), len(INITIAL_DATA))
+        for i, form in enumerate(formset.forms):
+            self.assertEqual(form.initial, INITIAL_DATA[i])
+            self.check_form(form)
+
+
+class SearchkitSearchFormTestCase(TestCase):
+    def test_searchkit_search_form_without_data(self):
+        form = SearchkitSearchForm()
+        self.assertFalse(form.is_bound)
+        self.assertFalse(form.is_valid())
+        self.assertIsInstance(form.formset, SearchkitFormSet)
+        self.assertEqual(form.formset.model, None)
+
+    def test_searchkit_search_form_with_data(self):
+        form = SearchkitSearchForm(FORM_DATA)
+        self.assertTrue(form.is_bound)
+        self.assertTrue(form.is_valid())
+        self.assertIsInstance(form.formset, SearchkitFormSet)
+        self.assertEqual(form.formset.model, ModelA)
+        self.assertEqual(form.instance.data, form.formset.cleaned_data)
+
+        # Saving the instance works.
+        form.instance.save()
+        self.assertTrue(form.instance.pk)
+
+        # Using the instance data as filter rules works.
+        filter_rules = form.instance.get_filter_rules()
+        self.assertEqual(len(filter_rules), len(INITIAL_DATA))
+        for data in INITIAL_DATA:
+            self.assertIn(f"{data['field']}__{data['operator']}", filter_rules)
+        queryset = form.formset.model.objects.filter(**filter_rules)
+        self.assertTrue(queryset.model == ModelA)