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

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,8 +14,14 @@ 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']
         return lookups
+
+    def as_queryset(self):
+        """
+        Returns a filtered queryset for the model.
+        """
+        return self.contenttype.model_class().objects.filter(**self.as_lookups())

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):
     """