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

build/lib/build/lib/build/lib/build/lib/searchkit/forms/searchkit.py

@@ -0,0 +1,177 @@
+from django import forms
+from django.apps import apps
+from django.contrib.admin import widgets
+from django.contrib.contenttypes.models import ContentType
+from django.utils.translation import gettext_lazy as _
+from django.utils.functional import cached_property
+from .utils import CssClassMixin, FIELD_PLAN, OPERATOR_DESCRIPTION
+from .utils import SUPPORTED_FIELDS
+from .utils import ModelTree
+from .utils import MediaMixin
+from .fields import DateRangeField
+from ..utils import is_searchable_model
+
+
+class SearchkitModelForm(forms.Form):
+    """
+    Form to select a content type.
+    """
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        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]
+        queryset = self.fields['searchkit_model'].queryset.filter(pk__in=ids)
+        self.fields['searchkit_model'].queryset = queryset
+
+    searchkit_model = forms.ModelChoiceField(
+        queryset=ContentType.objects.all().order_by('app_label', 'model'),
+        label=_('Model'),
+        empty_label=_('Select a Model'),
+        widget=forms.Select(attrs={
+            "class": CssClassMixin.reload_on_change_css_class,
+            "data-total-forms": 1,
+        }),
+    )
+
+
+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.
+
+    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.
+    """
+    model = None  # Set by the formset factory.
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.model_tree = ModelTree(self.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('__')
+        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()
+        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))
+        return choices
+
+    def _add_field_name_field(self):
+        choices = self._get_model_field_choices()
+        field = forms.ChoiceField(label=_('Model field'), choices=choices)
+        field.widget.attrs.update({"class": self.reload_on_change_css_class})
+        self.fields['field'] = field
+
+    def _add_operator_field(self):
+        choices = [(o, OPERATOR_DESCRIPTION[o]) for o in self.field_plan.keys()]
+        field = forms.ChoiceField(label=_('Operator'), choices=choices)
+        field.widget.attrs.update({"class": self.reload_on_change_css_class})
+        self.fields['operator'] = field
+
+    def _add_value_field(self):
+        self.fields['value'] = self.field_plan[self.operator](self.model_field)
+
+
+class BaseSearchkitFormSet(CssClassMixin, forms.BaseFormSet):
+    """
+    Formset holding all searchkit forms.
+    """
+    template_name = "searchkit/searchkit.html"
+    template_name_div = "searchkit/searchkit.html"
+    model = None  # Set by the formset factory.
+
+    def add_prefix(self, index):
+        return "%s-%s-%s-%s" % (self.prefix, self.model._meta.app_label, self.model._meta.model_name, index)
+
+    @classmethod
+    def get_default_prefix(self):
+        return "searchkit"
+
+    @cached_property
+    def uses_date_widget(self):
+        """
+        Check if the form uses a date widget.
+        """
+        for form in self.forms:
+            for field in form.fields.values():
+                if isinstance(field.widget, (widgets.AdminDateWidget, widgets.AdminSplitDateTime)):
+                    return True
+                elif isinstance(field, DateRangeField):
+                    return True
+        return False
+
+    @cached_property
+    def forms(self):
+        if self.model:
+            return super().forms
+        else:
+            return []
+
+
+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/build/lib/build/lib/build/lib/searchkit/forms/utils.py

@@ -0,0 +1,154 @@
+from modeltree import ModelTree as BaseModelTree
+from collections import OrderedDict
+from django.contrib.admin.widgets import AdminDateWidget, AdminSplitDateTime
+from django.db import models
+from django import forms
+from django.utils.translation import gettext_lazy as _
+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 = {
+    '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,
+]
+
+
+FIELD_PLAN = OrderedDict((
+    (
+        lambda f: isinstance(f, models.BooleanField),
+        {
+            'exact': lambda f: forms.NullBooleanField() if f.null else forms.BooleanField(),
+        }
+    ),
+    (
+        lambda f: isinstance(f, models.CharField) and f.choices,
+        {
+            'exact': lambda f: forms.ChoiceField(choices=f.choices),
+            'contains': lambda f: forms.CharField(),
+            'startswith': lambda f: forms.CharField(),
+            'endswith': lambda f: forms.CharField(),
+            'regex': lambda f: forms.CharField(),
+            'in': lambda f: forms.MultipleChoiceField(choices=f.choices),
+        }
+    ),
+    (
+        lambda f: isinstance(f, models.CharField),
+        {
+            'exact': lambda f: forms.CharField(),
+            'contains': lambda f: forms.CharField(),
+            'startswith': lambda f: forms.CharField(),
+            'endswith': lambda f: forms.CharField(),
+            'regex': lambda f: forms.CharField(),
+        }
+    ),
+    (
+        lambda f: isinstance(f, models.IntegerField) and f.choices,
+        {
+            'exact': lambda f: forms.ChoiceField(choices=f.choices),
+            'gt': lambda f: forms.IntegerField(),
+            'gte': lambda f: forms.IntegerField(),
+            'lt': lambda f: forms.IntegerField(),
+            'lte': lambda f: forms.IntegerField(),
+            'range': lambda f: searchkit_fields.IntegerRangeField(),
+            'in': lambda f: forms.MultipleChoiceField(choices=f.choices),
+        }
+    ),
+    (
+        lambda f: isinstance(f, models.IntegerField),
+        {
+            'exact': lambda f: forms.IntegerField(),
+            'gt': lambda f: forms.IntegerField(),
+            'gte': lambda f: forms.IntegerField(),
+            'lt': lambda f: forms.IntegerField(),
+            'lte': lambda f: forms.IntegerField(),
+            'range': lambda f: searchkit_fields.IntegerRangeField(),
+        }
+    ),
+    (
+        lambda f: isinstance(f, models.FloatField),
+        {
+            'exact': lambda f: forms.FloatField(),
+            'gt': lambda f: forms.FloatField(),
+            'gte': lambda f: forms.FloatField(),
+            'lt': lambda f: forms.FloatField(),
+            'lte': lambda f: forms.FloatField(),
+            'range': lambda f: searchkit_fields.IntegerRangeField(),
+        }
+    ),
+    (
+        lambda f: isinstance(f, models.DecimalField),
+        {
+            'exact': lambda f: forms.DecimalField(),
+            'gt': lambda f: forms.DecimalField(),
+            'gte': lambda f: forms.DecimalField(),
+            'lt': lambda f: forms.DecimalField(),
+            'lte': lambda f: forms.DecimalField(),
+            'range': lambda f: searchkit_fields.IntegerRangeField(),
+        }
+    ),
+    (
+        lambda f: isinstance(f, models.DateTimeField),
+        {
+            'exact': lambda f: forms.SplitDateTimeField(widget=AdminSplitDateTime()),
+            'gt': lambda f: forms.SplitDateTimeField(widget=AdminSplitDateTime()),
+            'gte': lambda f: forms.SplitDateTimeField(widget=AdminSplitDateTime()),
+            'lt': lambda f: forms.SplitDateTimeField(widget=AdminSplitDateTime()),
+            'lte': lambda f: forms.SplitDateTimeField(widget=AdminSplitDateTime()),
+            'range': lambda f: searchkit_fields.DateTimeRangeField(),
+        }
+    ),
+    (
+        lambda f: isinstance(f, models.DateField),
+        {
+            'exact': lambda f: forms.DateField(widget=AdminDateWidget()),
+            'gt': lambda f: forms.DateField(widget=AdminDateWidget()),
+            'gte': lambda f: forms.DateField(widget=AdminDateWidget()),
+            'lt': lambda f: forms.DateField(widget=AdminDateWidget()),
+            'lte': lambda f: forms.DateField(widget=AdminDateWidget()),
+            'range': lambda f: searchkit_fields.DateRangeField(),
+        }
+    ),
+))
+
+
+class CssClassMixin:
+    reload_on_change_css_class = "searchkit-reload-on-change"
+    reload_on_click_css_class = "searchkit-reload-on-click"
+
+
+class MediaMixin:
+    class Media:
+        js = [
+            'admin/js/vendor/jquery/jquery.min.js',
+            'admin/js/jquery.init.js',
+            "searchkit/searchkit.js"
+        ]

build/lib/build/lib/build/lib/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/build/lib/build/lib/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/build/lib/build/lib/build/lib/searchkit/models.py

@@ -0,0 +1,21 @@
+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 _
+
+
+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'))
+    created_date = models.DateTimeField(auto_now_add=True)
+
+    class Meta:
+        unique_together = ('name', 'contenttype')
+
+    def as_lookups(self):
+        lookups = OrderedDict()
+        for data in self.data:
+            lookups[f'{data["field"]}__{data["operator"]}'] = data['value']
+        return lookups

build/lib/build/lib/build/lib/build/lib/searchkit/templatetags/searchkit.py

@@ -0,0 +1,20 @@
+from django.template import Library
+from django.contrib.admin.helpers import Fieldset
+
+
+register = Library()
+
+@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