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

build/lib/build/lib/searchkit/views.py

@@ -0,0 +1,23 @@
+from django.utils.translation import gettext_lazy as _
+from django.http import HttpResponse
+from django.http import Http404, HttpResponseBadRequest
+from django.apps import apps
+from django.contrib.contenttypes.models import ContentType
+from django.views.generic import View
+from .forms import SearchkitModelForm
+from .forms import searchkit_formset_factory
+
+
+# FIXME: Check permissions and authentication.
+class SearchkitAjaxView(View):
+    """
+    Reload the formset via ajax.
+    """
+    def get(self, request, **kwargs):
+        model_form = SearchkitModelForm(data=self.request.GET)
+        if model_form.is_valid():
+            model = model_form.cleaned_data['searchkit_model'].model_class()
+            formset = searchkit_formset_factory(model=model)(data=request.GET)
+            return HttpResponse(formset.render())
+        else:
+            return HttpResponseBadRequest(_('Invalid searchkit-model-form.'))

build/lib/example/example/admin.py

@@ -7,7 +7,7 @@ from .models import ModelB
 @admin.register(ModelA)
 class ModelAAdmin(admin.ModelAdmin):
     list_display = [f.name for f in ModelA._meta.fields]
-    list_filter = [SearchkitFilter, 'chars_choices']
+    list_filter = [SearchkitFilter]
 
 
 @admin.register(ModelB)

build/lib/searchkit/__version__.py

@@ -13,4 +13,4 @@ Version 0.x should be considered a development version with an unstable API,
 and backwards compatibility is not guaranteed for minor versions.
 """
 
-__version__ = "1.0"
+__version__ = "1.2"

build/lib/searchkit/admin.py

@@ -1,14 +1,14 @@
 from django.contrib import admin
 from django.http import HttpResponseRedirect
 from django.urls import reverse
-from .models import SearchkitSearch
-from .forms import SearchkitSearchForm
+from .models import Search
+from .forms import SearchForm
 from .filters import SearchkitFilter
 
 
-@admin.register(SearchkitSearch)
+@admin.register(Search)
 class SearchkitSearchAdmin(admin.ModelAdmin):
-    form = SearchkitSearchForm
+    form = SearchForm
     list_display = ('name', 'contenttype', 'created_date')
 
     def get_url_for_applied_search(self, obj):

build/lib/searchkit/filters.py

@@ -1,8 +1,6 @@
 from django.contrib.admin import SimpleListFilter
 from django.contrib.contenttypes.models import ContentType
-from .models import SearchkitSearch
-from .forms import SearchkitFormSet
-from .forms.utils import get_filter_rules
+from .models import Search
 
 
 class SearchkitFilter(SimpleListFilter):
@@ -11,21 +9,20 @@ class SearchkitFilter(SimpleListFilter):
     template = 'searchkit/searchkit_filter.html'
 
     def __init__(self, request, params, model, model_admin):
-        # We need the app_label and model_name for the reverse url lookup in the
-        # template.
-        self.app_label = model._meta.app_label
-        self.model_name = model._meta.model_name
+        # We need the app_label and model as get parameter for the new search
+        # link.
+        self.searchkit_model = ContentType.objects.get_for_model(model)
         super().__init__(request, params, model, model_admin)
 
+    def has_output(self):
+        return True
+
     def lookups(self, request, model_admin):
-        # Fetch the last three objects from SearchkitSearch and return them as
-        # choices.
-        ct = ContentType.objects.get_for_model(model_admin.model)
-        searches = SearchkitSearch.objects.filter(contenttype=ct).order_by('-created_date')[:3]
+        searches = Search.objects.filter(contenttype=self.searchkit_model).order_by('-created_date')
         return [(str(obj.id), obj.name) for obj in searches]
 
     def queryset(self, request, queryset):
         # Filter the queryset based on the selected SearchkitSearch object
         if self.value():
-            search = SearchkitSearch.objects.get(id=int(self.value()))
-            return queryset.filter(**search.get_filter_rules())
+            search = Search.objects.get(id=int(self.value()))
+            return queryset.filter(**search.as_lookups())

build/lib/searchkit/forms/__init__.py

@@ -1,3 +1,5 @@
-from .search import SearchkitSearchForm
-from .searchkit import SearchkitFormSet
-from .searchkit import SearchkitForm
+from .search import SearchForm
+from .searchkit import SearchkitModelForm
+from .searchkit import BaseSearchkitFormSet
+from .searchkit import BaseSearchkitForm
+from .searchkit import searchkit_formset_factory

build/lib/searchkit/forms/search.py

@@ -1,22 +1,40 @@
 from django import forms
 from django.utils.functional import cached_property
-from ..models import SearchkitSearch
-from .searchkit import SearchkitFormSet
+from django.contrib.contenttypes.models import ContentType
+from ..models import Search
+from .searchkit import SearchkitModelForm
+from .searchkit import searchkit_formset_factory
+from .utils import MediaMixin
 
 
-class SearchkitSearchForm(forms.ModelForm):
+class SearchForm(MediaMixin, forms.ModelForm):
     """
     Represents a SearchkitSearch model. Using a SearchkitFormSet for the data
     json field.
     """
     class Meta:
-        model = SearchkitSearch
+        model = Search
         fields = ['name']
 
-    @property
-    def media(self):
-        # TODO: Check if child classes inherit those media files.
-        return self.formset.media
+    @cached_property
+    def searchkit_model(self):
+        if self.instance.pk:
+            return self.instance.contenttype.model_class()
+        elif self.searchkit_model_form.is_valid():
+            return self.searchkit_model_form.cleaned_data['searchkit_model'].model_class()
+        elif 'searchkit_model' in self.searchkit_model_form.initial:
+            value = self.searchkit_model_form.initial['searchkit_model']
+            try:
+                return self.searchkit_model_form.fields['searchkit_model'].clean(value).model_class()
+            except forms.ValidationError:
+                return None
+
+    @cached_property
+    def searchkit_model_form(self):
+        kwargs = dict(data=self.data or None, initial=self.initial or None)
+        if self.instance.pk:
+            kwargs['initial'] = dict(searchkit_model=self.instance.contenttype)
+        return SearchkitModelForm(**kwargs)
 
     @cached_property
     def formset(self):
@@ -24,19 +42,21 @@ class SearchkitSearchForm(forms.ModelForm):
         A searchkit formset for the model.
         """
         kwargs = dict()
-        kwargs['data'] = self.data or None
-        kwargs['prefix'] = self.prefix
-        if self.instance.pk:
-            kwargs['model'] = self.instance.contenttype.model_class()
-            kwargs['initial'] = self.instance.data
-        return SearchkitFormSet(**kwargs)
+        if self.searchkit_model and self.data:
+            kwargs = dict(data=self.data)
+        elif self.searchkit_model and self.instance.pk:
+            kwargs = dict(initial=self.instance.data)
+
+        extra = 0 if self.instance.pk else 1
+        formset = searchkit_formset_factory(model=self.searchkit_model, extra=extra)
+        return formset(**kwargs)
 
     def is_valid(self):
-        return self.formset.is_valid() and super().is_valid()
+        return self.formset.is_valid() and self.searchkit_model_form.is_valid and super().is_valid()
 
     def clean(self):
-        if self.formset.contenttype_form.is_valid():
-            self.instance.contenttype = self.formset.contenttype_form.cleaned_data['contenttype']
+        if self.searchkit_model_form.is_valid():
+            self.instance.contenttype = self.searchkit_model_form.cleaned_data['searchkit_model']
         if self.formset.is_valid():
             self.instance.data = self.formset.cleaned_data
         return super().clean()

build/lib/searchkit/forms/searchkit.py

@@ -1,17 +1,29 @@
-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
+from .utils import CssClassMixin, FIELD_PLAN, OPERATOR_DESCRIPTION
+from .utils import SUPPORTED_FIELDS
+from .utils import ModelTree
+from .utils import MediaMixin
+from .utils import get_searchable_models
 
 
-# FIXME: Make this a setting
-RELATION_DEPTH = 3
+class SearchkitModelForm(forms.Form):
+    """
+    Form to select a content type.
+    """
+    searchkit_model = forms.ModelChoiceField(
+        queryset=get_searchable_models(),
+        label=_('Model'),
+        empty_label=_('Select a Model'),
+        widget=forms.Select(attrs={
+            "class": CssClassMixin.reload_on_change_css_class,
+            "data-total-forms": 1,
+        }),
+    )
 
 
-class SearchkitForm(CSS_CLASSES, forms.Form):
+class BaseSearchkitForm(MediaMixin, CssClassMixin, forms.Form):
     """
     Searchkit form representing a model field lookup based on the field name,
     the operator and one or two values.
@@ -24,9 +36,11 @@ class SearchkitForm(CSS_CLASSES, forms.Form):
 
     See the FIELD_PLAN variable for the logic of building the form.
     """
-    def __init__(self, model, *args, **kwargs):
+    model = None  # Set by the formset factory.
+
+    def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
-        self.model = model
+        self.model_tree = ModelTree(self.model)
         self.model_field = None
         self.field_plan = None
         self.operator = None
@@ -64,40 +78,44 @@ class SearchkitForm(CSS_CLASSES, forms.Form):
 
     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=[]):
+        field_name = path[-1]
+        if path[:-1]:
+            model = self.model_tree.get('__'.join(path[:-1])).model
+        else:
+            model = self.model
+        return model._meta.get_field(field_name)
+
+    def _get_model_field_choices(self):
         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])
+        label_path = list()
+        for node in self.model_tree.iterate():
+            label_path.append
+            for model_field in node.model._meta.fields:
+                if not any(isinstance(model_field, f) for f in SUPPORTED_FIELDS):
+                    continue
+                if node.is_root:
+                    lookup = model_field.name
+                    label = f'`{model_field.verbose_name}`'
+                else:
+                    lookup = f'{node.field_path}__{model_field.name}'
+                    get_field_name = lambda f: getattr(f, 'verbose_name', f.name)
+                    label_path = [f'`{get_field_name(n.field)}` => <{n.model._meta.verbose_name}>' for n in node.path[1:]]
+                    label = ".".join(label_path + [f'`{model_field.verbose_name}`'])
                 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)
+        choices = self._get_model_field_choices()
         field = forms.ChoiceField(label=_('Model field'), choices=choices, initial=initial)
-        field.widget.attrs.update({"class": CSS_CLASSES.reload_on_change_css_class})
+        field.widget.attrs.update({"class": self.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})
+        field.widget.attrs.update({"class": self.reload_on_change_css_class})
         self.fields['operator'] = field
 
     def _add_value_field(self):
@@ -110,80 +128,27 @@ class SearchkitForm(CSS_CLASSES, forms.Form):
         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):
+class BaseSearchkitFormSet(CssClassMixin, 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
+    model = None  # Set by the formset factory.
 
     def add_prefix(self, index):
-        if self.model:
-            return "%s-%s-%s" % (self.prefix, self.model._meta.model_name, index)
+        return "%s-%s-%s-%s" % (self.prefix, self.model._meta.app_label, 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()
+    def get_default_prefix(self):
+        return "searchkit"
 
 
-SearchkitFormSet = forms.formset_factory(
-        form=SearchkitForm,
-        formset=BaseSearchkitFormset,
+def searchkit_formset_factory(model, **kwargs):
+    form = type('SearchkitForm', (BaseSearchkitForm,), dict(model=model))
+    formset = type('SearchkitFormSet', (BaseSearchkitFormSet,), dict(model=model))
+    return forms.formset_factory(
+        form=form,
+        formset=formset,
+        **kwargs
     )

build/lib/searchkit/forms/utils.py

@@ -1,8 +1,23 @@
+from modeltree import ModelTree as BaseModelTree
+from collections import OrderedDict
+from django.apps import apps
+from django.contrib import admin
+from django.contrib.contenttypes.models import ContentType
 from django.db import models
+from django.db.utils import OperationalError
 from django import forms
 from django.utils.translation import gettext_lazy as _
-from collections import OrderedDict
-from searchkit.forms import fields as searchkit_fields
+from ..filters import SearchkitFilter
+from . import fields as  searchkit_fields
+
+
+class ModelTree(BaseModelTree):
+    MAX_DEPTH = 3
+    FOLLOW_ACROSS_APPS = True
+    RELATION_TYPES = [
+        'one_to_one',
+        'many_to_one',
+    ]
 
 
 OPERATOR_DESCRIPTION = {
@@ -29,10 +44,6 @@ SUPPORTED_FIELDS = [
     models.DateField,
     models.DateTimeField,
 ]
-SUPPORTED_RELATIONS = [
-    models.ForeignKey,
-    models.OneToOneField,
-]
 
 
 FIELD_PLAN = OrderedDict((
@@ -132,18 +143,36 @@ FIELD_PLAN = OrderedDict((
 ))
 
 
-class CSS_CLASSES:
+class CssClassMixin:
     reload_on_change_css_class = "searchkit-reload-on-change"
     reload_on_click_css_class = "searchkit-reload-on-click"
 
 
-def get_filter_rules(formset):
+class MediaMixin:
+    class Media:
+        js = [
+            'admin/js/vendor/jquery/jquery.min.js',
+            'admin/js/jquery.init.js',
+            "searchkit/searchkit.js"
+        ]
+
+
+def is_searchable_model(model):
+    """
+    Check if the model is searchable by Searchkit.
+    """
+    return admin.site.is_registered(model) and SearchkitFilter in admin.site._registry[model].list_filter
+
+
+def get_searchable_models():
     """
-    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
+    Return a queryset of searchable models.
     """
-    lookups = OrderedDict()
-    for data in formset.cleaned_data:
-        lookups[f'{data["field"]}__{data["operator"]}'] = data['value']
-    return lookups
+    # Before mirating the database we get an OperationalError when trying to
+    # access ContentType database table.
+    try:
+        models = [m for m in apps.get_models() if is_searchable_model(m)]
+        ids = [ContentType.objects.get_for_model(m).id for m in models]
+        return ContentType.objects.filter(pk__in=ids).order_by('app_label', 'model')
+    except OperationalError:
+        return ContentType.objects.all()

build/lib/searchkit/migrations/0002_rename_searchkitsearch_search.py

@@ -0,0 +1,18 @@
+# Generated by Django 5.1.3 on 2025-06-07 05:46
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('contenttypes', '0002_remove_content_type_name'),
+        ('searchkit', '0001_initial'),
+    ]
+
+    operations = [
+        migrations.RenameModel(
+            old_name='SearchkitSearch',
+            new_name='Search',
+        ),
+    ]

build/lib/searchkit/models.py

@@ -5,9 +5,7 @@ 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):
+class Search(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'))
@@ -16,7 +14,7 @@ class SearchkitSearch(models.Model):
     class Meta:
         unique_together = ('name', 'contenttype')
 
-    def get_filter_rules(self):
+    def as_lookups(self):
         lookups = OrderedDict()
         for data in self.data:
             lookups[f'{data["field"]}__{data["operator"]}'] = data['value']

build/lib/searchkit/templatetags/searchkit.py

@@ -1,36 +1,9 @@
 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):
     """