Python API

Views

Base views for autocomplete widgets.

class dal.views.BaseQuerySetView(**kwargs)

Base view to get results from a QuerySet.

create_field

Name of the field to use to create missing values. For example, if create_field=’title’, and the user types in “foo”, then the autocomplete view will propose an option ‘Create “foo”’ if it can’t find any value matching “foo”. When the user does click ‘Create “foo”’, the autocomplete script should POST to this view to create the object and get back the newly created object id.

model_field_name

Name of the Model field to run filter against.

create_object(text)

Create an object given a text.

get_queryset()

Filter the queryset with GET[‘q’].

get_result_label(result)

Return the label of a result.

get_result_value(result)

Return the value of a result.

get_search_fields()

Get the fields to search over.

get_search_results(queryset, search_term)

Filter the results based on the query.

get_selected_result_label(result)

Return the label of a selected result.

has_add_permission(request)

Return True if the user has the permission to add a model.

has_more(context)

For widgets that have infinite-scroll feature.

lookup_needs_distinct(queryset, orm_lookups)

Return True if an orm_lookup requires calling qs.distinct().

validate(text)

Validate a given text for new option creation.

Raise ValidationError or return None.

class dal.views.ViewMixin

Common methods for autocomplete views.

It is assumed this view will be used in conjunction with a Django View based class that will implement OPTIONS.

forwarded

Dict of field values that were forwarded from the form, may be used to filter autocompletion results based on the form state. See linked_data example for reference.

q

Query string as typed by the user in the autocomplete field.

dispatch(request, *args, **kwargs)

Set forwarded and q.

Widgets

Autocomplete widgets bases.

class dal.widgets.QuerySetSelectMixin(url=None, forward=None, *args, **kwargs)

QuerySet support for choices.

filter_choices_to_render(selected_choices)

Filter out un-selected choices if choices is a QuerySet.

class dal.widgets.Select(url=None, forward=None, *args, **kwargs)

Replacement for Django’s Select to render only selected choices.

class dal.widgets.SelectMultiple(url=None, forward=None, *args, **kwargs)

Replacement SelectMultiple to render only selected choices.

class dal.widgets.WidgetMixin(url=None, forward=None, *args, **kwargs)

Base mixin for autocomplete widgets.

url

Absolute URL to the autocomplete view for the widget. It can be set to a URL name, in which case it will be reversed when the attribute is accessed.

forward

List of field names to forward to the autocomplete view, useful to filter results using values of other fields in the form.

Items of the list must be one of the following:

• string (e. g. “some_field”): forward a value from the field with named “some_field”;

• dal.forward.Field("some_field"): the same as above;

• dal.forward.Field("some_field", "dst_field"): forward a value from the field with named “some_field” as “dst_field”;

• dal.forward.Const("some_value", "dst_field"): forward a constant value “some_value” as “dst_field”.

autocomplete_function

Identifier of the javascript callback that should be executed when such a widget is loaded in the DOM, either on page load or dynamically.

build_attrs(*args, **kwargs)

Build HTML attributes for the widget.

filter_choices_to_render(selected_choices)

Filter choices to selected ones; inject values absent from the list.

optgroups(name, value, attrs=None)

Exclude unselected self.choices before calling the parent method.

Used by Django>=1.10.

render(name, value, attrs=None, renderer=None, **kwargs)

Call Django render together with render_forward_conf.

render_forward_conf(id)

Render forward configuration for the field.

Forward

Classes for class-based forward declaration.

class dal.forward.Const(val, dst)

Forward arbitrary constant value.

val

The value to forward. Must be JSON-serializable.

dst

The name of the key of the forwarded value.

to_dict()

Convert to dictionary which will be rendered as JSON.

class dal.forward.Field(src, dst=None)

Forward field value.

The type of the forwarded value from the field is either string, list of strings or boolean.

The following rules are used to deduce the forwarded type.

• If there is only one field in the form or subform with name src and this field is a checkbox without value HTML-attribute, then boolean value indicating if this checkbox is checked is forwarded.

• If there is only one field in the form or subform with name src and it has multiple HTML-attribute, then this field is forwarded as a list of strings, containing values from this field.

• If there are one or more fields in the form with name src and all of them are checkboxes with HTML-attribute value set the list of strings containing checked checkboxes is forwarded.

• Otherwise src field value forwarded as a string.

src

The name of the form field whose value will be forwarded to a view.

dst

The name of the key of the forwarded value from the src field in the forwarded dictionary. If this value is None, then the key is src.

to_dict()

Convert to dictionary which will be rendered as JSON.

class dal.forward.Forward

Base class for autocomplete forward declaration.

to_dict()

Convert to dictionary which will be rendered as JSON.

property type

Forward type. Should be implemented in subclasses.

class dal.forward.JavaScript(handler, dst=None)

Run registered javascript handler and forward its returned value.

You can register custom forward handler in your JS code as follows:

yl.registerForwardHandler("your_handler", function (autocompleteElement) {
    // your code here
});

Then if your add JavaScript("your_handler", "some_value") to your forwards declaration, your function will be called, autocomplete field HTML element will be passed as autocompleteElement and returned value will be added to forward dictionary with some_value key.

handler

The name of the registered handler.

dst

The name of the key of the forwarded value from the src field in the forwarded dictionary. If this value is None, then the key is handler.

to_dict()

Convert to dictionary which will be rendered as JSON.

class dal.forward.Self(dst=None)

Forward own value.

The same as Field, except that src is always this field itself.

dst

The name of the key of the forwarded value from the src field in the forwarded dictionary. If this value is None, then the key is self.

to_dict()

Convert to dictionary which will be rendered as JSON.

FutureModelForm

tl;dr: See FutureModelForm’s docstring.

Many apps provide new related managers to extend your django models with. For example, django-tagulous provides a TagField which abstracts an M2M relation with the Tag model, django-gm2m provides a GM2MField which abstracts an relation, django-taggit provides a TaggableManager which abstracts a relation too, django-generic-m2m provides RelatedObjectsDescriptor which abstracts a relation again.

While that works pretty well, it gets a bit complicated when it comes to encapsulating the business logic for saving such data in a form object. This is three-part problem:

• getting initial data,

• saving instance attributes,

• saving relations like reverse relations or many to many.

Django’s ModelForm calls the model field’s value_from_object() method to get the initial data. FutureModelForm tries the value_from_object() method from the form field instead, if defined. Unlike the model field, the form field doesn’t know its name, so FutureModelForm passes it when calling the form field’s value_from_object() method.

Django’s ModelForm calls the form field’s save_form_data() in two occasions:

• in _post_clean() for model fields in Meta.fields,

• in _save_m2m() for model fields in Meta.virtual_fields and Meta.many_to_many, which then operate on an instance which as a PK.

If we just added save_form_data() to form fields like for value_from_object() then it would be called twice, once in _post_clean() and once in _save_m2m(). Instead, FutureModelForm would call the following methods from the form field, if defined:

• save_object_data() in _post_clean(), to set object attributes for a given value,

• save_relation_data() in _save_m2m(), to save relations for a given value.

For example:

• a generic foreign key only sets instance attributes, its form field would do that in save_object_data(),

• a tag field saves relations, its form field would do that in save_relation_data().

class dal.forms.FutureModelForm(*args, **kwargs)

ModelForm which adds extra API to form fields.

Form fields may define new methods for FutureModelForm:

• FormField.value_from_object(instance, name) should return the initial value to use in the form, overrides ModelField.value_from_object() which is what ModelForm uses by default,

• FormField.save_object_data(instance, name, value) should set instance attributes. Called by save() before writing the database, when instance.pk may not be set, it overrides ModelField.save_form_data() which is normally used in this occasion for non-m2m and non-virtual model fields.

• FormField.save_relation_data(instance, name, value) should save relations required for value on the instance. Called by save() after writing the database, when instance.pk is necessarily set, it overrides ModelField.save_form_data() which is normally used in this occasion for m2m and virtual model fields.

For complete rationale, see this module’s docstring.

classmethod as_urls()

Create a list of url patterns, to be called in url.py.

Example:

urlpattern.append(*ModelForm.as_url())

Iterate over the fields to call the as_url() method from the GenericForeignKeyField

property media

Return all media required to render the widgets on this form.

dal_select2

This is a front-end module: it provides views and widgets.

Views

Select2 view implementation.

class dal_select2.views.Select2GroupListView(**kwargs)

View mixin for grouped options.

get(request, *args, **kwargs)

Return option list with children(s) json response.

get_item_as_group(entry)

Return the item with its group.

class dal_select2.views.Select2GroupQuerySetView(**kwargs)

List of grouped options for a Select2 widget.

group_by_related

Name of the field for the related Model on a One to Many relation

related_field_name

Name of the related Model field to run filter against.

get_results(context)

Return the options grouped by a common related model.

Raises ImproperlyConfigured if self.group_by_name is not configured

class dal_select2.views.Select2ListView(**kwargs)

Autocomplete from a list of items rather than a QuerySet.

autocomplete_results(results)

Return list of strings that match the autocomplete query.

get(request, *args, **kwargs)

Return option list json response.

get_list()

Return the list strings from which to autocomplete.

post(request, *args, **kwargs)

Add an option to the autocomplete list.

If ‘text’ is not defined in POST or self.create(text) fails, raises bad request. Raises ImproperlyConfigured if self.create if not defined.

results(results)

Return the result dictionary.

class dal_select2.views.Select2QuerySetView(**kwargs)

List options for a Select2 widget.

post(request, *args, **kwargs)

Create an object and return its id/text as JSON for Select2.

class dal_select2.views.Select2ViewMixin

View mixin to render a JSON response for Select2.

get_create_option(context, q)

Form the correct create_option to append to results.

get_results(context)

Return data for the ‘results’ key of the response.

render_to_response(context)

Return a JSON response in Select2 format.

Widgets

Select2 widget implementation module.

class dal_select2.widgets.ListSelect2(url=None, forward=None, *args, **kwargs)

Select widget for regular choices and Select2.

property media

Return JS/CSS resources for the widget.

class dal_select2.widgets.ModelSelect2(url=None, forward=None, *args, **kwargs)

Select widget for QuerySet choices and Select2.

property media

Return JS/CSS resources for the widget.

class dal_select2.widgets.ModelSelect2Multiple(url=None, forward=None, *args, **kwargs)

SelectMultiple widget for QuerySet choices and Select2.

filter_choices_to_render(selected_choices)

Filter choices preserving the order submitted by Select2.

property media

Return JS/CSS resources for the widget.

class dal_select2.widgets.Select2(url=None, forward=None, *args, **kwargs)

Select2 widget for regular choices.

property media

Return JS/CSS resources for the widget.

class dal_select2.widgets.Select2Multiple(url=None, forward=None, *args, **kwargs)

Select2Multiple widget for regular choices.

property media

Return JS/CSS resources for the widget.

class dal_select2.widgets.Select2WidgetMixin

Mixin for Select2 widgets.

build_attrs(*args, **kwargs)

Set data-autocomplete-light-language.

property media

Return JS/CSS resources for the widget.

class dal_select2.widgets.TagSelect2(url=None, forward=None, *args, **kwargs)

Select2 in tag mode.

build_attrs(*args, **kwargs)

Automatically set data-tags=1.

format_value(value)

Return the list of HTML option values for a form field value.

property media

Return JS/CSS resources for the widget.

optgroups(name, value, attrs=None)

Return a list of one optgroup and selected values.

option_value(value)

Return the HTML option value attribute for a value.

options(name, value, attrs=None)

Return only select options.

value_from_datadict(data, files, name)

Return a comma-separated list of options.

This is needed because Select2 uses a multiple select even in tag mode, and the model field expects a comma-separated list of tags.

dal_select2.widgets.get_i18n_name(lang_code)

Ensure lang_code is supported by Select2.

dal_select2.widgets.is_iterable(x)

An implementation independent way of checking for iterables

Fields

class dal_select2.fields.Select2ListChoiceField(choice_list=None, *args, **kwargs)

class dal_select2.fields.Select2ListCreateChoiceField(choice_list=None, *args, **kwargs)

Test tools

Helpers for DAL user story based tests.

class dal_select2.test.Select2Story

Define Select2 CSS selectors.

clean_label(label)

Remove the “remove” character used in select2.

wait_script()

Wait for scripts to be loaded and ready to work.

dal_contenttypes

Fields

Model choice fields that take a ContentType too: for generic relations.

class dal_contenttypes.fields.ContentTypeModelFieldMixin

Common methods for form fields for GenericForeignKey.

ModelChoiceFieldMixin expects options to look like:

<option value="4">Model #4</option>

With a ContentType of id 3 for that model, it becomes:

<option value="3-4">Model #4</option>

prepare_value(value)

Return a ctypeid-objpk string for value.

class dal_contenttypes.fields.ContentTypeModelMultipleFieldMixin

Same as ContentTypeModelFieldMixin, but supports value list.

prepare_value(value)

Run the parent’s method for each value.

class dal_contenttypes.fields.GenericModelMixin

GenericForeignKey support for form fields, with FutureModelForm.

GenericForeignKey enforce editable=false, this class implements save_object_data() and value_from_object() to allow FutureModelForm to compensate.

save_object_data(instance, name, value)

Set the attribute, for FutureModelForm.

value_from_object(instance, name)

Get the attribute, for FutureModelForm.

dal_select2_queryset_sequence

Views

View for a Select2 widget and QuerySetSequence-based business logic.

class dal_select2_queryset_sequence.views.Select2QuerySetSequenceAutoView(**kwargs)

Select2QuerySetSequenceAutoView class.

Filter the queryset based on the models and filter attributes of the GenericForeignKeyModelField

self.model_choice is generated from the Select2GenericForeignKeyModelField, see it’s docstring

get_queryset()

Return queryset.

class dal_select2_queryset_sequence.views.Select2QuerySetSequenceView(**kwargs)

Combines support QuerySetSequence and Select2 in a single view.

Example usage:

url(
    '^your-generic-autocomplete/$',
    autocomplete.Select2QuerySetSequenceView.as_view(
        queryset=autocomplete.QuerySetSequence(
            Group.objects.all(),
            TestModel.objects.all(),
        )
    ),
    name='your-generic-autocomplete',
)

It is compatible with the widgets and the fields of fields, suits generic relation autocompletes.

get_results(context)

Return a list of results usable by Select2.

It will render as a list of one <optgroup> per different content type containing a list of one <option> per model.

Fields

Autocomplete fields for Select2GenericForeignKey choices.

class dal_select2_queryset_sequence.fields.Select2GenericForeignKeyModelField(*args, **kwargs)

Select2GenericForeignKeyModelField class.

Field that generate automatically the view for the QuerySetSequenceSelect2 widget

as_url(form)

Return url.

Wigets

Widgets for Select2 and QuerySetSequence.

They combine Select2WidgetMixin and QuerySetSequenceSelectMixin with Django’s Select and SelectMultiple widgets, and are meant to be used with generic model form fields such as those in dal_contenttypes.fields.

class dal_select2_queryset_sequence.widgets.QuerySetSequenceSelect2(url=None, forward=None, *args, **kwargs)

Single model select for a generic select2 autocomplete.

property media

Return JS/CSS resources for the widget.

class dal_select2_queryset_sequence.widgets.QuerySetSequenceSelect2Multiple(url=None, forward=None, *args, **kwargs)

Multiple model select for a generic select2 autocomplete.

property media

Return JS/CSS resources for the widget.

dal_queryset_sequence

Views

View that supports QuerySetSequence.

class dal_queryset_sequence.views.BaseQuerySetSequenceView(**kwargs)

Base view that uses a QuerySetSequence.

Compatible with form fields which use a ContentType id as well as a model pk to identify a value.

mixup

Cause the autocomplete to show a few results of each querysets.

get_model_name(model)

Return the name of the model, fetch parent if model is a proxy.

get_paginate_by(queryset)

Don’t paginate if mixup.

get_queryset()

Mix results from all querysets in QuerySetSequence if self.mixup.

get_result_value(result)

Return ctypeid-objectid for result.

has_more(context)

Return False if mixup.

lookup_needs_distinct(queryset, orm_lookups)

Return True if a orm_lookups requires calling qs.distinct().

mixup_querysets(qs)

Return a queryset with different model types.

Fields

Autocomplete fields for QuerySetSequence choices.

class dal_queryset_sequence.fields.GenericForeignKeyModelField(*args, **kwargs)

Field that generate automatically the view for compatible widgets.

as_url(form)

Return url.

class dal_queryset_sequence.fields.QuerySetSequenceFieldMixin

Base methods for QuerySetSequence fields.

get_content_type_id_object_id(value)

Return a tuple of ctype id, object id for value.

get_queryset_for_content_type(content_type_id)

Return the QuerySet from the QuerySetSequence for a ctype.

raise_invalid_choice(params=None)

Raise a ValidationError for invalid_choice.

The validation error left imprecise about the exact error for security reasons, to prevent an attacker doing information gathering to reverse valid content type and object ids.

class dal_queryset_sequence.fields.QuerySetSequenceModelField(queryset, *, empty_label='---------', required=True, widget=None, label=None, initial=None, help_text='', to_field_name=None, limit_choices_to=None, blank=False, **kwargs)

Replacement for ModelChoiceField supporting QuerySetSequence choices.

to_python(value)

Given a string like ‘3-5’, return the model of ctype #3 and pk 5.

Note that in the case of ModelChoiceField, to_python is also in charge of security, it’s important to get the results from self.queryset.

class dal_queryset_sequence.fields.QuerySetSequenceModelMultipleField(queryset, **kwargs)

ModelMultipleChoiceField with support for QuerySetSequence choices.

Widgets

Widget mixin that only renders selected options with QuerySetSequence.

For details about why this is required, see dal.widgets.

class dal_queryset_sequence.widgets.QuerySetSequenceSelect(url=None, forward=None, *args, **kwargs)

Select widget for QuerySetSequence choices.

class dal_queryset_sequence.widgets.QuerySetSequenceSelectMixin(url=None, forward=None, *args, **kwargs)

Support QuerySetSequence in WidgetMixin.

filter_choices_to_render(selected_choices)

Overwrite self.choices to exclude unselected values.

label_from_instance(obj)

Convert an object into string. Override it to customize display.

class dal_queryset_sequence.widgets.QuerySetSequenceSelectMultiple(url=None, forward=None, *args, **kwargs)

SelectMultiple widget for QuerySetSequence choices.

dal_select2_taggit

Fields

Widgets for Select2 and django-taggit.

class dal_select2_taggit.widgets.TaggitSelect2(url=None, forward=None, *args, **kwargs)

Select2 tag widget for taggit’s TagField.

build_attrs(*args, **kwargs)

Add data-tags=”,”.

property media

Return JS/CSS resources for the widget.

option_value(value)

Return tag.name attribute of value.

render_options(*args)

Render only selected tags.

Remove when Django < 1.10 support is dropped.

value_from_datadict(data, files, name)

Handle multi-word tag.

Insure there’s a comma when there’s only a single multi-word tag, or tag “Multi word” would end up as “Multi” and “word”.

dal_alight

Views

class dal_alight.views.AlightGroupListView(**kwargs)

Grouped list view — mirrors Select2GroupListView.

get_list() should return items of the form ((group_id, group_label), [(value, label), …]) or plain strings grouped by a leading group item.

Simpler usage: return [(group, item), …] tuples where the first element is the group name and the second is the item string or (value, label) tuple. Items with group=None are ungrouped.

class dal_alight.views.AlightGroupQuerySetView(**kwargs)

Grouped queryset view — mirrors Select2GroupQuerySetView.

Results are rendered as:

<div class="autocomplete-light-group">Group label</div>
<div data-value="pk">Label</div>
…

Group header divs carry no data-value so the component treats them as non-selectable.

get_queryset()

Filter the queryset with GET[‘q’].

class dal_alight.views.AlightListView(**kwargs)

Autocomplete from a list of strings or (value, label) pairs.

Mirrors Select2ListView but returns HTML fragments instead of JSON.

Override get_list() to return your items. Each item may be a plain string (value == label) or a (value, label) tuple/list.

Define create(text) on the view to enable POST-based creation; it should return the created text/value or raise an error.

class dal_alight.views.AlightQuerySetView(**kwargs)

Autocomplete view returning HTML fragments for autocomplete-light.

Each result is rendered as <div data-value="{pk}">{label}</div>. When create_field is set and the query has no case-insensitive exact match on page 1, a <div data-create>Create "…"</div> is appended. POST is handled by the inherited BaseQuerySetView.post() which creates the object and returns a <div data-value="…">…</div> HTML fragment.

post(request, *args, **kwargs)

Create an object and return an HTML fragment for the new choice.

class dal_alight.views.AlightTagAutocompleteView(**kwargs)

Convenience base for taggit tag autocomplete views.

Returns result.name as the option value so TaggitAlight can match tags by name rather than by PK.

get_result_value(result)

Return the value of a result.

Widgets

class dal_alight.widgets.Alight(url=None, forward=None, *args, **kwargs)

Single-select autocomplete for arbitrary choices.

Without a url the component filters <option> elements locally in JS — no server round-trip needed. With a url it fetches from the view as usual.

class dal_alight.widgets.AlightMultiple(url=None, forward=None, *args, **kwargs)

Multiple-select autocomplete for arbitrary choices.

class dal_alight.widgets.AlightWidgetMixin

Mixin that renders the autocomplete-light web component shell.

Wraps the underlying <select> (rendered by super().render()) in:

<autocomplete-select>
  <select slot="select">…</select>
  <div slot="deck"></div>
  <autocomplete-select-input slot="input" [url="…"]>
    <input …/>
  </autocomplete-select-input>
  <div class="dal-forward-conf">…</div>
</autocomplete-select>

class dal_alight.widgets.ListAlight(url=None, forward=None, *args, **kwargs)

Single-select autocomplete backed by AlightListView.

Use alongside AlightListView on the server.

class dal_alight.widgets.ModelAlight(url=None, forward=None, *args, **kwargs)

Single-select autocomplete widget backed by a QuerySet.

class dal_alight.widgets.ModelAlightMultiple(url=None, forward=None, *args, **kwargs)

Multi-select autocomplete widget backed by a QuerySet.

class dal_alight.widgets.TagAlight(url=None, forward=None, *args, **kwargs)

Free-text tag widget — value stored as comma-separated text.

AlightInitialRenderMixin is intentionally omitted: tags are not PKs so the queryset-filter approach would break; optgroups() handles initial values directly via _iter_tag_values().

Tags are not backed by a model: the tag text IS the option value. Use alongside AlightListView with a create() method, or any view that returns HTML fragments.

The stored field value is a comma-separated string (same as TagSelect2).

format_value(value)

Return selected values as a list.

optgroups(name, value, attrs=None)

Exclude unselected self.choices before calling the parent method.

Used by Django>=1.10.

value_from_datadict(data, files, name)

Given a dictionary of data and this widget’s name, return the value of this widget or None if it’s not provided.

class dal_alight.widgets.TaggitAlight(url=None, forward=None, *args, **kwargs)

value_from_datadict(data, files, name)

Given a dictionary of data and this widget’s name, return the value of this widget or None if it’s not provided.

Fields

class dal_alight.fields.AlightListChoiceField(choice_list=None, *args, **kwargs)

class dal_alight.fields.AlightListCreateChoiceField(choice_list=None, *args, **kwargs)

Test tools

Test helpers for dal_alight — mirrors dal_select2.test without select2.

class dal_alight.test.AlightStory

CSS selectors and wait logic for the autocomplete-light web component.

Drop-in replacement for Select2Story. Mix into AutocompleteTestCase subclasses instead of Select2Story.

HTML structure produced by AlightWidgetMixin:

<autocomplete-select>
  <select slot="select" id="id_{field}">…</select>
  <div slot="deck">
    <div data-value="1">Label<span class="clear">×</span></div>
  </div>
  <autocomplete-select-input slot="input" url="…">
    <input name="{field}-input" slot="input" class="vTextField" />
  </autocomplete-select-input>
</autocomplete-select>

The dropdown box is appended to <body> by the component:

<div class="autocomplete-light-box">
  <div data-value="1">Label</div>
  <div data-create data-value="foo">Create "foo"</div>
</div>

clean_label(label)

Remove the × clear button text from a label string.

get_create_option_selector(name)

Return a selector for the create option that matches name exactly.

Using [data-value="name"] prevents clicking a stale create option left over from a previous query before the new XHR has returned.

toggle_autocomplete_widget(selector)

Open the autocomplete, ensuring focus fires even if already focused.

For alight, focus on the text input is what triggers the XHR. When the input already has focus (e.g. after a previous call in refresh_autocomplete), a plain Selenium click does not re-fire focus. Blurring first resets the focus state so the subsequent click fires a real focus event and starts a fresh XHR.

wait_script()

Wait until all alight web components have finished connectedCallback.

autocomplete-select.connectedCallback fires before its child autocomplete-select-input’s callback (parent-first connection order), so it schedules a 100 ms retry. We must wait for BOTH elements to have data-bound before interacting: autocomplete-select installs the autocompleteChoiceSelected listener only on its own retry, and clicking an option before that listener exists silently does nothing.

dal_alight_queryset_sequence

Views

Views for autocomplete-light widget and QuerySetSequence-based business logic.

class dal_alight_queryset_sequence.views.AlightQuerySetSequenceAutoView(**kwargs)

AlightQuerySetSequenceAutoView class.

Filters the queryset based on the models and filter attributes defined on an AlightGenericForeignKeyModelField.

self.model_choice is generated from that field; see its docstring for the expected structure.

get_queryset()

Return queryset filtered according to self.model_choice.

class dal_alight_queryset_sequence.views.AlightQuerySetSequenceView(**kwargs)

Combines QuerySetSequence support with autocomplete-light HTML fragments.

Returns results grouped by model type, rendered as HTML divs instead of JSON. Group headers use class="autocomplete-light-group"; individual results carry a data-value attribute with the ctype_pk-object_pk composite identifier used by dal_queryset_sequence.

Example usage:

path(
    'your-generic-autocomplete/',
    autocomplete.AlightQuerySetSequenceView.as_view(
        queryset=autocomplete.QuerySetSequence(
            Group.objects.all(),
            TestModel.objects.all(),
        )
    ),
    name='your-generic-autocomplete',
)

Compatible with widgets and the fields of fields for generic-relation autocompletes.

render_to_response(context)

Return an HTML fragment grouped by model type.

Widgets

Widgets for autocomplete-light and QuerySetSequence.

They combine AlightWidgetMixin and QuerySetSequenceSelectMixin with Django’s Select and SelectMultiple widgets, and are meant to be used with generic model form fields such as those in dal_contenttypes.fields.

class dal_alight_queryset_sequence.widgets.QuerySetSequenceAlight(url=None, forward=None, *args, **kwargs)

Single-select autocomplete-light widget for QuerySetSequence.

class dal_alight_queryset_sequence.widgets.QuerySetSequenceAlightMultiple(url=None, forward=None, *args, **kwargs)

Multi-select autocomplete-light widget for QuerySetSequence.

Fields

Autocomplete fields for AlightGenericForeignKey choices.

class dal_alight_queryset_sequence.fields.AlightGenericForeignKeyModelField(*args, **kwargs)

AlightGenericForeignKeyModelField class.

Field that automatically generates the view for the QuerySetSequenceAlight widget.

Parameters:

• model_choice –

  [(Model, 'filter_by', [('forwardfield_name', 'filter_by')]), …]

  List of tuples, one per model to include in the autocomplete. Model is the Django model class; 'filter_by' is the field name used for icontains filtering. The optional third element is a list of (forwarded_field_name, model_field_name) pairs for forwarding form fields to the view.

• field_id – Optional stable identifier; defaults to id(self).

as_url(form)

Return url pattern for the auto-generated autocomplete view.