jazzband / django-smart-selects / 253

pending completion

Build # 253

Build Type

Pull #283

travis-ci

Committed by

web-flow

Commit Message

<a href="https://github.com/jazzband/django-smart-selects/commit/<a class=hub.com/jazzband/django-smart-selects/commit/fd97ceaf38d012455af4c4db98a46efa0af4f51e">fd97ceaf3<a href="https://github.com/jazzband/django-smart-selects/commit/fd97ceaf38d012455af4c4db98a46efa0af4f51e">">Merge </a><a class="double-link" href="https://github.com/jazzband/django-smart-selects/commit/<a class="double-link" href="https://github.com/jazzband/django-smart-selects/commit/3660e7567f51ec3934b4ee774ff5a2ae95573601">3660e7567</a>">3660e7567</a><a href="https://github.com/jazzband/django-smart-selects/commit/fd97ceaf38d012455af4c4db98a46efa0af4f51e"> into 2ecfe8857">2ecfe8857</a>

Pull Request Pull Request #283: Fix render() error in widgets.py

Run Details

169 of 169 new or added lines in 5 files covered. (100.0%)

423 of 471 relevant lines covered (89.81%)

14.94 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

95.92

/smart_selects/db_fields.py

import django
from django.db.models.fields.related import (
    ForeignKey, ManyToManyField, RECURSIVE_RELATIONSHIP_CONSTANT
)
from django.db import models
from django.utils import six

from smart_selects import form_fields


class IntrospectiveFieldMixin(object):
    to_app_name = None
    to_model_name = None

    def __init__(self, to, *args, **kwargs):
        if isinstance(to, six.string_types):
            if to == RECURSIVE_RELATIONSHIP_CONSTANT:  # to == 'self'
                # This will be handled in contribute_to_class(), when we have
                # enough information to set these properly
                self.to_app_name, self.to_model_name = (None, to)
            elif '.' in to:  # 'app_label.ModelName'
                self.to_app_name, self.to_model_name = to.split('.')
            else:  # 'ModelName'
                self.to_app_name, self.to_model_name = (None, to)
        else:
            self.to_app_name = to._meta.app_label
            self.to_model_name = to._meta.object_name

        super(IntrospectiveFieldMixin, self).__init__(to, *args, **kwargs)

    def contribute_to_class(self, cls, *args, **kwargs):
        if self.to_model_name == RECURSIVE_RELATIONSHIP_CONSTANT:
            # Resolve the model name
            self.to_model_name = cls._meta.object_name
        if self.to_app_name is None:
            # Resolve the app name
            self.to_app_name = cls._meta.app_label
        super(IntrospectiveFieldMixin, self).contribute_to_class(cls, *args, **kwargs)


class ChainedManyToManyField(IntrospectiveFieldMixin, ManyToManyField):
    """
    chains the choices of a previous combo box with this ManyToMany
    """
    def __init__(self, to, chained_field=None, chained_model_field=None,
                 auto_choose=False, horizontal=False, **kwargs):
        """
        examples:

        class Publication(models.Model):
            name = models.CharField(max_length=255)

        class Writer(models.Model):
            name = models.CharField(max_length=255)
            publications = models.ManyToManyField('Publication', blank=True, null=True)

        class Book(models.Model):
            publication = models.ForeignKey(Publication)
            writer = ChainedManyToManyField(
                Writer,
                chained_field="publication",
                chained_model_field="publications",
                )
            name = models.CharField(max_length=255)

        ``chained_field`` is the name of the ForeignKey field referenced by ChainedManyToManyField of the same Model.
        in the examples, chained_field is the name of field publication in Model Book.

        ``chained_model_field`` is the name of the ManyToMany field referenced in the 'to' Model.
        in the examples, chained_model_field is the name of field publications in Model Writer.

        ``auto_choose`` controls whether auto select the choice when there is only one available choice.

        """
        self.chain_field = chained_field
        self.chained_model_field = chained_model_field
        self.auto_choose = auto_choose
        self.horizontal = horizontal
        self.verbose_name = kwargs.get('verbose_name', '')
        super(ChainedManyToManyField, self).__init__(to, **kwargs)

    def deconstruct(self):
        field_name, path, args, kwargs = super(
            ChainedManyToManyField, self).deconstruct()

        # Maps attribute names to their default kwarg values.
        defaults = {
            'chain_field': None,
            'chained_model_field': None,
            'auto_choose': False,
            'horizontal': False
        }

        # Maps attribute names to their __init__ kwarg names.
        attr_to_kwarg_names = {
            'chain_field': 'chained_field',
            'chained_model_field': 'chained_model_field',
            'auto_choose': 'auto_choose',
            'horizontal': 'horizontal',
            'verbose_name': 'verbose_name'
        }

        for name, default in defaults.items():
            value = getattr(self, name)
            kwarg_name = attr_to_kwarg_names[name]

            # None and Boolean defaults should use an 'is' comparison.
            if value is not default:
                kwargs[kwarg_name] = value
            else:
                # value is default, so don't include it in serialized kwargs.
                if kwarg_name in kwargs:
                    del kwargs[kwarg_name]

        return field_name, path, args, kwargs

    def formfield(self, **kwargs):
        foreign_key_app_name = self.model._meta.app_label
        foreign_key_model_name = self.model._meta.object_name
        foreign_key_field_name = self.name
        defaults = {
            'form_class': form_fields.ChainedManyToManyField,
            'queryset': (self.rel.to._default_manager.complex_filter(
                self.rel.limit_choices_to) if django.VERSION < (2, 0) else
                self.remote_field.model._default_manager.complex_filter(
                    self.remote_field.limit_choices_to)),
            'to_app_name': self.to_app_name,
            'to_model_name': self.to_model_name,
            'chain_field': self.chain_field,
            'chained_model_field': self.chained_model_field,
            'auto_choose': self.auto_choose,
            'horizontal': self.horizontal,
            'verbose_name': self.verbose_name,
            'foreign_key_app_name': foreign_key_app_name,
            'foreign_key_model_name': foreign_key_model_name,
            'foreign_key_field_name': foreign_key_field_name,
        }
        defaults.update(kwargs)
        return super(ChainedManyToManyField, self).formfield(**defaults)


class ChainedForeignKey(IntrospectiveFieldMixin, ForeignKey):
    """
    chains the choices of a previous combo box with this one
    """
    def __init__(self, to, chained_field=None, chained_model_field=None,
                 show_all=False, auto_choose=False, sort=True, view_name=None, **kwargs):
        """
        examples:

        class Continent(models.Model):
            name = models.CharField(max_length=255)

        class Country(models.Model):
            continent = models.ForeignKey(Continent)

        class Location(models.Model):
            continent = models.ForeignKey(Continent)
            country = ChainedForeignKey(
                Country,
                chained_field="continent",
                chained_model_field="continent",
                show_all=True,
                auto_choose=True,
                sort=True,
                # limit_choices_to={'name':'test'}
            )
        ``chained_field`` is the name of the ForeignKey field referenced by ChainedForeignKey of the same Model.
        in the examples, chained_field is the name of field continent in Model Location.

        ``chained_model_field`` is the name of the ForeignKey field referenced in the 'to' Model.
        in the examples, chained_model_field is the name of field continent in Model Country.

        ``show_all`` controls whether show other choices below the filtered choices, with separater '----------'.

        ``auto_choose`` controls whether auto select the choice when there is only one available choice.

        ``sort`` controls whether or not to sort results lexicographically or not.

        ``view_name`` controls which view to use, 'chained_filter' or 'chained_filter_all'.

        """
        self.chained_field = chained_field
        self.chained_model_field = chained_model_field
        self.show_all = show_all
        self.auto_choose = auto_choose
        self.sort = sort
        self.view_name = view_name
        if kwargs:
            kwargs['on_delete'] = kwargs.get('on_delete', models.CASCADE)
        else:
            kwargs = {'on_delete': models.CASCADE}
        super(ChainedForeignKey, self).__init__(to, **kwargs)

    def deconstruct(self):
        field_name, path, args, kwargs = super(
            ChainedForeignKey, self).deconstruct()

        # Maps attribute names to their default kwarg values.
        defaults = {
            'chained_field': None,
            'chained_model_field': None,
            'show_all': False,
            'auto_choose': False,
            'sort': True,
            'view_name': None,
        }

        # Maps attribute names to their __init__ kwarg names.
        attr_to_kwarg_names = {
            'chained_field': 'chained_field',
            'chained_model_field': 'chained_model_field',
            'show_all': 'show_all',
            'auto_choose': 'auto_choose',
            'sort': 'sort',
            'view_name': 'view_name',
        }

        for name, default in defaults.items():
            value = getattr(self, name)
            kwarg_name = attr_to_kwarg_names[name]

            # None and Boolean defaults should use an 'is' comparison.
            if value is not default:
                kwargs[kwarg_name] = value
            else:
                # value is default, so don't include it in serialized kwargs.
                if kwarg_name in kwargs:
                    del kwargs[kwarg_name]

        return field_name, path, args, kwargs

    def formfield(self, **kwargs):
        foreign_key_app_name = self.model._meta.app_label
        foreign_key_model_name = self.model._meta.object_name
        foreign_key_field_name = self.name
        defaults = {
            'form_class': form_fields.ChainedModelChoiceField,
            'queryset': (self.rel.to._default_manager.complex_filter(
                self.rel.limit_choices_to) if django.VERSION < (2, 0) else
                self.remote_field.model._default_manager.complex_filter(
                    self.remote_field.limit_choices_to)),
            'to_field_name': (self.rel.field_name if django.VERSION < (2, 0)
                              else self.remote_field.field_name),
            'to_app_name': self.to_app_name,
            'to_model_name': self.to_model_name,
            'chained_field': self.chained_field,
            'chained_model_field': self.chained_model_field,
            'show_all': self.show_all,
            'auto_choose': self.auto_choose,
            'sort': self.sort,
            'view_name': self.view_name,
            'foreign_key_app_name': foreign_key_app_name,
            'foreign_key_model_name': foreign_key_model_name,
            'foreign_key_field_name': foreign_key_field_name,
        }
        defaults.update(kwargs)
        return super(ChainedForeignKey, self).formfield(**defaults)


class GroupedForeignKey(ForeignKey):
    """
    Opt Grouped Field
    """
    def __init__(self, to, group_field, **kwargs):
        self.group_field = group_field
        self._choices = True
        if kwargs:
            kwargs['on_delete'] = kwargs.get('on_delete', models.CASCADE)
        else:
            kwargs = {'on_delete': models.CASCADE}
        super(GroupedForeignKey, self).__init__(to, **kwargs)

    def deconstruct(self):
        field_name, path, args, kwargs = super(
            GroupedForeignKey, self).deconstruct()

        # Add positional arg group_field as a kwarg, since the 'to' positional
        # arg is serialized as a keyword arg by the superclass deconstruct().
        kwargs.update(group_field=self.group_field)

        # Choices handling in Field.deconstruct() should suffice (if choices is
        # not default, serialize it as a kwarg). _choices is set in the
        # GroupedForeignKey constructor, but should be overwritten by the
        # Field constructor's handling of the 'choices' kwarg.

        return field_name, path, args, kwargs

    def formfield(self, **kwargs):
        defaults = {
            'form_class': form_fields.GroupedModelSelect,
            'queryset': (self.rel.to._default_manager.complex_filter(
                self.rel.limit_choices_to) if django.VERSION < (2, 0) else
                self.remote_field.model._default_manager.complex_filter(
                    self.remote_field.limit_choices_to)),
            'to_field_name': (self.rel.field_name if django.VERSION < (2, 0)
                              else self.remote_field.field_name),
            'order_field': self.group_field,
        }
        defaults.update(kwargs)
        return super(ForeignKey, self).formfield(**defaults)

1	import django	17✔
2	from django.db.models.fields.related import (	17✔
3	ForeignKey, ManyToManyField, RECURSIVE_RELATIONSHIP_CONSTANT
4	)
5	from django.db import models	17✔
6	from django.utils import six
7		17✔
8	from smart_selects import form_fields
9		17✔
10
11	class IntrospectiveFieldMixin(object):
12	to_app_name = None	17✔
13	to_model_name = None	17✔
14		17✔
15	def __init__(self, to, args, *kwargs):
16	if isinstance(to, six.string_types):	17✔
17	if to == RECURSIVE_RELATIONSHIP_CONSTANT: # to == 'self'	17✔
18	# This will be handled in contribute_to_class(), when we have	17✔
19	# enough information to set these properly
20	self.to_app_name, self.to_model_name = (None, to)
21	elif '.' in to: # 'app_label.ModelName'	×
22	self.to_app_name, self.to_model_name = to.split('.')	17✔
23	else: # 'ModelName'	17✔
24	self.to_app_name, self.to_model_name = (None, to)
25	else:	17✔
26	self.to_app_name = to._meta.app_label
27	self.to_model_name = to._meta.object_name	17✔
28		17✔
29	super(IntrospectiveFieldMixin, self).__init__(to, args, *kwargs)
30		17✔
31	def contribute_to_class(self, cls, args, *kwargs):
32	if self.to_model_name == RECURSIVE_RELATIONSHIP_CONSTANT:	17✔
33	# Resolve the model name	17✔
34	self.to_model_name = cls._meta.object_name
35	if self.to_app_name is None:	×
36	# Resolve the app name	17✔
37	self.to_app_name = cls._meta.app_label
38	super(IntrospectiveFieldMixin, self).contribute_to_class(cls, args, *kwargs)	17✔
39		17✔
40
41	class ChainedManyToManyField(IntrospectiveFieldMixin, ManyToManyField):
42	"""	17✔
43	chains the choices of a previous combo box with this ManyToMany
44	"""
45	def __init__(self, to, chained_field=None, chained_model_field=None,
46	auto_choose=False, horizontal=False, **kwargs):	17✔
47	"""
48	examples:
49
50	class Publication(models.Model):
51	name = models.CharField(max_length=255)
52
53	class Writer(models.Model):
54	name = models.CharField(max_length=255)
55	publications = models.ManyToManyField('Publication', blank=True, null=True)
56
57	class Book(models.Model):
58	publication = models.ForeignKey(Publication)
59	writer = ChainedManyToManyField(
60	Writer,
61	chained_field="publication",
62	chained_model_field="publications",
63	)
64	name = models.CharField(max_length=255)
65
66	``chained_field`` is the name of the ForeignKey field referenced by ChainedManyToManyField of the same Model.
67	in the examples, chained_field is the name of field publication in Model Book.
68
69	``chained_model_field`` is the name of the ManyToMany field referenced in the 'to' Model.
70	in the examples, chained_model_field is the name of field publications in Model Writer.
71
72	``auto_choose`` controls whether auto select the choice when there is only one available choice.
73
74	"""
75	self.chain_field = chained_field
76	self.chained_model_field = chained_model_field	17✔
77	self.auto_choose = auto_choose	17✔
78	self.horizontal = horizontal	17✔
79	self.verbose_name = kwargs.get('verbose_name', '')	17✔
80	super(ChainedManyToManyField, self).__init__(to, **kwargs)	17✔
81		17✔
82	def deconstruct(self):
83	field_name, path, args, kwargs = super(	17✔
84	ChainedManyToManyField, self).deconstruct()	17✔
85
86	# Maps attribute names to their default kwarg values.
87	defaults = {
88	'chain_field': None,	17✔
89	'chained_model_field': None,
90	'auto_choose': False,
91	'horizontal': False
92	}
93
94	# Maps attribute names to their __init__ kwarg names.
95	attr_to_kwarg_names = {
96	'chain_field': 'chained_field',	17✔
97	'chained_model_field': 'chained_model_field',
98	'auto_choose': 'auto_choose',
99	'horizontal': 'horizontal',
100	'verbose_name': 'verbose_name'
101	}
102
103	for name, default in defaults.items():
104	value = getattr(self, name)	17✔
105	kwarg_name = attr_to_kwarg_names[name]	17✔
106		17✔
107	# None and Boolean defaults should use an 'is' comparison.
108	if value is not default:
109	kwargs[kwarg_name] = value	17✔
110	else:	17✔
111	# value is default, so don't include it in serialized kwargs.
112	if kwarg_name in kwargs:
113	del kwargs[kwarg_name]	17✔
114		×
115	return field_name, path, args, kwargs
116		17✔
117	def formfield(self, **kwargs):
118	foreign_key_app_name = self.model._meta.app_label	17✔
119	foreign_key_model_name = self.model._meta.object_name	17✔
120	foreign_key_field_name = self.name	17✔
121	defaults = {	17✔
122	'form_class': form_fields.ChainedManyToManyField,	17✔
123	'queryset': (self.rel.to._default_manager.complex_filter(
124	self.rel.limit_choices_to) if django.VERSION < (2, 0) else
125	self.remote_field.model._default_manager.complex_filter(
126	self.remote_field.limit_choices_to)),
127	'to_app_name': self.to_app_name,
128	'to_model_name': self.to_model_name,
129	'chain_field': self.chain_field,
130	'chained_model_field': self.chained_model_field,
131	'auto_choose': self.auto_choose,
132	'horizontal': self.horizontal,
133	'verbose_name': self.verbose_name,
134	'foreign_key_app_name': foreign_key_app_name,
135	'foreign_key_model_name': foreign_key_model_name,
136	'foreign_key_field_name': foreign_key_field_name,
137	}
138	defaults.update(kwargs)
139	return super(ChainedManyToManyField, self).formfield(**defaults)	17✔
140		17✔
141
142	class ChainedForeignKey(IntrospectiveFieldMixin, ForeignKey):
143	"""	17✔
144	chains the choices of a previous combo box with this one
145	"""
146	def __init__(self, to, chained_field=None, chained_model_field=None,
147	show_all=False, auto_choose=False, sort=True, view_name=None, **kwargs):	17✔
148	"""
149	examples:
150
151	class Continent(models.Model):
152	name = models.CharField(max_length=255)
153
154	class Country(models.Model):
155	continent = models.ForeignKey(Continent)
156
157	class Location(models.Model):
158	continent = models.ForeignKey(Continent)
159	country = ChainedForeignKey(
160	Country,
161	chained_field="continent",
162	chained_model_field="continent",
163	show_all=True,
164	auto_choose=True,
165	sort=True,
166	# limit_choices_to={'name':'test'}
167	)
168	``chained_field`` is the name of the ForeignKey field referenced by ChainedForeignKey of the same Model.
169	in the examples, chained_field is the name of field continent in Model Location.
170
171	``chained_model_field`` is the name of the ForeignKey field referenced in the 'to' Model.
172	in the examples, chained_model_field is the name of field continent in Model Country.
173
174	``show_all`` controls whether show other choices below the filtered choices, with separater '----------'.
175
176	``auto_choose`` controls whether auto select the choice when there is only one available choice.
177
178	``sort`` controls whether or not to sort results lexicographically or not.
179
180	``view_name`` controls which view to use, 'chained_filter' or 'chained_filter_all'.
181
182	"""
183	self.chained_field = chained_field
184	self.chained_model_field = chained_model_field	17✔
185	self.show_all = show_all	17✔
186	self.auto_choose = auto_choose	17✔
187	self.sort = sort	17✔
188	self.view_name = view_name	17✔
189	if kwargs:	17✔
190	kwargs['on_delete'] = kwargs.get('on_delete', models.CASCADE)	17✔
191	else:	17✔
192	kwargs = {'on_delete': models.CASCADE}
193	super(ChainedForeignKey, self).__init__(to, **kwargs)	17✔
194		17✔
195	def deconstruct(self):
196	field_name, path, args, kwargs = super(	17✔
197	ChainedForeignKey, self).deconstruct()	17✔
198
199	# Maps attribute names to their default kwarg values.
200	defaults = {
201	'chained_field': None,	17✔
202	'chained_model_field': None,
203	'show_all': False,
204	'auto_choose': False,
205	'sort': True,
206	'view_name': None,
207	}
208
209	# Maps attribute names to their __init__ kwarg names.
210	attr_to_kwarg_names = {
211	'chained_field': 'chained_field',	17✔
212	'chained_model_field': 'chained_model_field',
213	'show_all': 'show_all',
214	'auto_choose': 'auto_choose',
215	'sort': 'sort',
216	'view_name': 'view_name',
217	}
218
219	for name, default in defaults.items():
220	value = getattr(self, name)	17✔
221	kwarg_name = attr_to_kwarg_names[name]	17✔
222		17✔
223	# None and Boolean defaults should use an 'is' comparison.
224	if value is not default:
225	kwargs[kwarg_name] = value	17✔
226	else:	17✔
227	# value is default, so don't include it in serialized kwargs.
228	if kwarg_name in kwargs:
229	del kwargs[kwarg_name]	17✔
230		×
231	return field_name, path, args, kwargs
232		17✔
233	def formfield(self, **kwargs):
234	foreign_key_app_name = self.model._meta.app_label	17✔
235	foreign_key_model_name = self.model._meta.object_name	17✔
236	foreign_key_field_name = self.name	17✔
237	defaults = {	17✔
238	'form_class': form_fields.ChainedModelChoiceField,	17✔
239	'queryset': (self.rel.to._default_manager.complex_filter(
240	self.rel.limit_choices_to) if django.VERSION < (2, 0) else
241	self.remote_field.model._default_manager.complex_filter(
242	self.remote_field.limit_choices_to)),
243	'to_field_name': (self.rel.field_name if django.VERSION < (2, 0)
244	else self.remote_field.field_name),
245	'to_app_name': self.to_app_name,
246	'to_model_name': self.to_model_name,
247	'chained_field': self.chained_field,
248	'chained_model_field': self.chained_model_field,
249	'show_all': self.show_all,
250	'auto_choose': self.auto_choose,
251	'sort': self.sort,
252	'view_name': self.view_name,
253	'foreign_key_app_name': foreign_key_app_name,
254	'foreign_key_model_name': foreign_key_model_name,
255	'foreign_key_field_name': foreign_key_field_name,
256	}
257	defaults.update(kwargs)
258	return super(ChainedForeignKey, self).formfield(**defaults)	17✔
259		17✔
260
261	class GroupedForeignKey(ForeignKey):
262	"""	17✔
263	Opt Grouped Field
264	"""
265	def __init__(self, to, group_field, **kwargs):
266	self.group_field = group_field	17✔
267	self._choices = True	17✔
268	if kwargs:	17✔
269	kwargs['on_delete'] = kwargs.get('on_delete', models.CASCADE)	17✔
270	else:	17✔
271	kwargs = {'on_delete': models.CASCADE}
272	super(GroupedForeignKey, self).__init__(to, **kwargs)	17✔
273		17✔
274	def deconstruct(self):
275	field_name, path, args, kwargs = super(	17✔
276	GroupedForeignKey, self).deconstruct()	17✔
277
278	# Add positional arg group_field as a kwarg, since the 'to' positional
279	# arg is serialized as a keyword arg by the superclass deconstruct().
280	kwargs.update(group_field=self.group_field)
281		17✔
282	# Choices handling in Field.deconstruct() should suffice (if choices is
283	# not default, serialize it as a kwarg). _choices is set in the
284	# GroupedForeignKey constructor, but should be overwritten by the
285	# Field constructor's handling of the 'choices' kwarg.
286
287	return field_name, path, args, kwargs
288		17✔
289	def formfield(self, **kwargs):
290	defaults = {	17✔
291	'form_class': form_fields.GroupedModelSelect,	17✔
292	'queryset': (self.rel.to._default_manager.complex_filter(
293	self.rel.limit_choices_to) if django.VERSION < (2, 0) else
294	self.remote_field.model._default_manager.complex_filter(
295	self.remote_field.limit_choices_to)),
296	'to_field_name': (self.rel.field_name if django.VERSION < (2, 0)
297	else self.remote_field.field_name),
298	'order_field': self.group_field,
299	}
300	defaults.update(kwargs)
301	return super(ForeignKey, self).formfield(**defaults)	17✔

jazzband / django-smart-selects / 253

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous