django-searchkit 1.2__tar.gz → 1.3__tar.gz

{django_searchkit-1.2/django_searchkit.egg-info → django_searchkit-1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: django-searchkit
-Version: 1.2
+Version: 1.3
 Summary: Finally a real searchkit for django!
 Home-page: https://github.com/thomst/django-searchkit
 Author: Thomas Leichtfuß

{django_searchkit-1.2 → django_searchkit-1.3/django_searchkit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: django-searchkit
-Version: 1.2
+Version: 1.3
 Summary: Finally a real searchkit for django!
 Home-page: https://github.com/thomst/django-searchkit
 Author: Thomas Leichtfuß

{django_searchkit-1.2 → django_searchkit-1.3}/django_searchkit.egg-info/SOURCES.txt

@@ -28,6 +28,7 @@ searchkit/filters.py
 searchkit/models.py
 searchkit/tests.py
 searchkit/urls.py
+searchkit/utils.py
 searchkit/views.py
 searchkit/forms/__init__.py
 searchkit/forms/fields.py

{django_searchkit-1.2 → django_searchkit-1.3}/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.2"
+__version__ = "1.3"

{django_searchkit-1.2 → django_searchkit-1.3}/searchkit/admin.py

@@ -1,15 +1,18 @@
 from django.contrib import admin
 from django.http import HttpResponseRedirect
 from django.urls import reverse
+from django.utils.html import format_html
 from .models import Search
 from .forms import SearchForm
 from .filters import SearchkitFilter
+from .filters import SearchableModelFilter
 
 
 @admin.register(Search)
 class SearchkitSearchAdmin(admin.ModelAdmin):
     form = SearchForm
-    list_display = ('name', 'contenttype', 'created_date')
+    list_display = ('name', 'contenttype', 'created_date', 'apply_search_view')
+    list_filter = (('contenttype', SearchableModelFilter),)
 
     def get_url_for_applied_search(self, obj):
         app_label = obj.contenttype.app_label
@@ -28,3 +31,14 @@ class SearchkitSearchAdmin(admin.ModelAdmin):
             return HttpResponseRedirect(self.get_url_for_applied_search(obj))
         else:
             return super().response_change(request, obj, *args, **kwargs)
+
+    def apply_search_view(self, obj):
+        """
+        Returns a link to apply the search.
+        """
+        return format_html(
+            '<a href="{}" >Apply search "{}"</a>',
+            self.get_url_for_applied_search(obj),
+            obj.name
+        )
+    apply_search_view.short_description = 'Apply Search'

{django_searchkit-1.2 → django_searchkit-1.3}/searchkit/filters.py

@@ -1,9 +1,10 @@
-from django.contrib.admin import SimpleListFilter
+from django.contrib import admin
 from django.contrib.contenttypes.models import ContentType
 from .models import Search
+from .utils import is_searchable_model
 
 
-class SearchkitFilter(SimpleListFilter):
+class SearchkitFilter(admin.SimpleListFilter):
     title = 'Searchkit Filter'
     parameter_name = 'search'
     template = 'searchkit/searchkit_filter.html'
@@ -26,3 +27,10 @@ class SearchkitFilter(SimpleListFilter):
         if self.value():
             search = Search.objects.get(id=int(self.value()))
             return queryset.filter(**search.as_lookups())
+
+
+class SearchableModelFilter(admin.filters.RelatedFieldListFilter):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        contenttypes = ContentType.objects.order_by('app_label', 'model')
+        self.lookup_choices = [(m.id, m) for m in contenttypes if is_searchable_model(m.model_class())]

{django_searchkit-1.2 → django_searchkit-1.3}/searchkit/forms/fields.py

@@ -1,4 +1,5 @@
 from django import forms
+from django.contrib.admin import widgets
 from django.utils.translation import gettext_lazy as _
 
 
@@ -46,10 +47,10 @@ class IntegerRangeField(BaseRangeField):
 class DateRangeField(BaseRangeField):
     incomplete_message = _("Enter the first and the last date.")
     field_type = forms.DateField
-    widget_type = forms.DateInput
+    widget_type = widgets.AdminDateWidget
 
 
-class DateTimeRangeField(BaseRangeField):
+class DateTimeRangeField(DateRangeField):
     incomplete_message = _("Enter the first and the last datetime.")
-    field_type = forms.DateTimeField
-    widget_type = forms.DateTimeInput
+    field_type = forms.SplitDateTimeField
+    widget_type = widgets.AdminSplitDateTime

{django_searchkit-1.2 → django_searchkit-1.3}/searchkit/forms/search.py

@@ -1,6 +1,5 @@
 from django import forms
 from django.utils.functional import cached_property
-from django.contrib.contenttypes.models import ContentType
 from ..models import Search
 from .searchkit import SearchkitModelForm
 from .searchkit import searchkit_formset_factory

{django_searchkit-1.2 → django_searchkit-1.3}/searchkit/forms/searchkit.py

@@ -1,19 +1,30 @@
 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 .utils import get_searchable_models
+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=get_searchable_models(),
+        queryset=ContentType.objects.all().order_by('app_label', 'model'),
         label=_('Model'),
         empty_label=_('Select a Model'),
         widget=forms.Select(attrs={
@@ -105,27 +116,19 @@ class BaseSearchkitForm(MediaMixin, CssClassMixin, forms.Form):
         return choices
 
     def _add_field_name_field(self):
-        initial = self.initial.get('field')
         choices = self._get_model_field_choices()
-        field = forms.ChoiceField(label=_('Model field'), choices=choices, initial=initial)
+        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):
-        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 = 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):
-        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
+        self.fields['value'] = self.field_plan[self.operator](self.model_field)
 
 
 class BaseSearchkitFormSet(CssClassMixin, forms.BaseFormSet):
@@ -143,6 +146,26 @@ class BaseSearchkitFormSet(CssClassMixin, forms.BaseFormSet):
     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))

django_searchkit-1.3/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"
+        ]

{django_searchkit-1.2 → django_searchkit-1.3}/searchkit/tests.py

@@ -49,7 +49,7 @@ INITIAL_DATA = [
     dict(
         field='datetime',
         operator='exact',
-        value='2025-05-14 08:45',
+        value=['2025-05-14', '08:45'],
     )
 ]
 

django_searchkit-1.3/searchkit/utils.py

@@ -0,0 +1,13 @@
+from django.contrib import admin
+
+
+def is_searchable_model(model):
+    """
+    Check if the model is searchable by Searchkit.
+    """
+    # We do not import SearchkitFilter to avoid circular imports. So we check
+    # the filter by its name.
+    return (
+        admin.site.is_registered(model)
+        and 'SearchkitFilter' in [getattr(f, '__name__', '') for f in admin.site._registry[model].list_filter]
+    )

django_searchkit-1.2/searchkit/forms/utils.py

@@ -1,178 +0,0 @@
-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 ..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 = {
-    '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': (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 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"
-        ]
-
-
-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():
-    """
-    Return a queryset of searchable models.
-    """
-    # 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()