blinkster: comparison web/lib/django/forms/widgets.py

equal deleted inserted replaced

-:8d941af65caf
+:77b6da96e6f1
+"""
+HTML Widget classes
+"""
+import django.utils.copycompat as copy
+from itertools import chain
+from django.conf import settings
+from django.utils.datastructures import MultiValueDict, MergeDict
+from django.utils.html import escape, conditional_escape
+from django.utils.translation import ugettext
+from django.utils.encoding import StrAndUnicode, force_unicode
+from django.utils.safestring import mark_safe
+from django.utils import datetime_safe, formats
+import time
+import datetime
+from util import flatatt
+from urlparse import urljoin
+__all__ = (
+'Media', 'MediaDefiningClass', 'Widget', 'TextInput', 'PasswordInput',
+'HiddenInput', 'MultipleHiddenInput',
+'FileInput', 'DateInput', 'DateTimeInput', 'TimeInput', 'Textarea', 'CheckboxInput',
+'Select', 'NullBooleanSelect', 'SelectMultiple', 'RadioSelect',
+'CheckboxSelectMultiple', 'MultiWidget',
+'SplitDateTimeWidget',
+)
+MEDIA_TYPES = ('css','js')
+class Media(StrAndUnicode):
+def __init__(self, media=None, **kwargs):
+if media:
+media_attrs = media.__dict__
+else:
+media_attrs = kwargs
+self._css = {}
+self._js = []
+for name in MEDIA_TYPES:
+getattr(self, 'add_' + name)(media_attrs.get(name, None))
+# Any leftover attributes must be invalid.
+# if media_attrs != {}:
+#     raise TypeError("'class Media' has invalid attribute(s): %s" % ','.join(media_attrs.keys()))
+def __unicode__(self):
+return self.render()
+def render(self):
+return mark_safe(u'\n'.join(chain(*[getattr(self, 'render_' + name)() for name in MEDIA_TYPES])))
+def render_js(self):
+return [u'<script type="text/javascript" src="%s"></script>' % self.absolute_path(path) for path in self._js]
+def render_css(self):
+# To keep rendering order consistent, we can't just iterate over items().
+# We need to sort the keys, and iterate over the sorted list.
+media = self._css.keys()
+media.sort()
+return chain(*[
+[u'<link href="%s" type="text/css" media="%s" rel="stylesheet" />' % (self.absolute_path(path), medium)
+for path in self._css[medium]]
+for medium in media])
+def absolute_path(self, path):
+if path.startswith(u'http://') or path.startswith(u'https://') or path.startswith(u'/'):
+return path
+return urljoin(settings.MEDIA_URL,path)
+def __getitem__(self, name):
+"Returns a Media object that only contains media of the given type"
+if name in MEDIA_TYPES:
+return Media(**{str(name): getattr(self, '_' + name)})
+raise KeyError('Unknown media type "%s"' % name)
+def add_js(self, data):
+if data:
+for path in data:
+if path not in self._js:
+self._js.append(path)
+def add_css(self, data):
+if data:
+for medium, paths in data.items():
+for path in paths:
+if not self._css.get(medium) or path not in self._css[medium]:
+self._css.setdefault(medium, []).append(path)
+def __add__(self, other):
+combined = Media()
+for name in MEDIA_TYPES:
+getattr(combined, 'add_' + name)(getattr(self, '_' + name, None))
+getattr(combined, 'add_' + name)(getattr(other, '_' + name, None))
+return combined
+def media_property(cls):
+def _media(self):
+# Get the media property of the superclass, if it exists
+if hasattr(super(cls, self), 'media'):
+base = super(cls, self).media
+else:
+base = Media()
+# Get the media definition for this class
+definition = getattr(cls, 'Media', None)
+if definition:
+extend = getattr(definition, 'extend', True)
+if extend:
+if extend == True:
+m = base
+else:
+m = Media()
+for medium in extend:
+m = m + base[medium]
+return m + Media(definition)
+else:
+return Media(definition)
+else:
+return base
+return property(_media)
+class MediaDefiningClass(type):
+"Metaclass for classes that can have media definitions"
+def __new__(cls, name, bases, attrs):
+new_class = super(MediaDefiningClass, cls).__new__(cls, name, bases,
+attrs)
+if 'media' not in attrs:
+new_class.media = media_property(new_class)
+return new_class
+class Widget(object):
+__metaclass__ = MediaDefiningClass
+is_hidden = False          # Determines whether this corresponds to an <input type="hidden">.
+needs_multipart_form = False # Determines does this widget need multipart-encrypted form
+is_localized = False
+def __init__(self, attrs=None):
+if attrs is not None:
+self.attrs = attrs.copy()
+else:
+self.attrs = {}
+def __deepcopy__(self, memo):
+obj = copy.copy(self)
+obj.attrs = self.attrs.copy()
+memo[id(self)] = obj
+return obj
+def render(self, name, value, attrs=None):
+"""
+Returns this Widget rendered as HTML, as a Unicode string.
+The 'value' given is not guaranteed to be valid input, so subclass
+implementations should program defensively.
+"""
+raise NotImplementedError
+def build_attrs(self, extra_attrs=None, **kwargs):
+"Helper function for building an attribute dictionary."
+attrs = dict(self.attrs, **kwargs)
+if extra_attrs:
+attrs.update(extra_attrs)
+return attrs
+def value_from_datadict(self, data, files, name):
+"""
+Given a dictionary of data and this widget's name, returns the value
+of this widget. Returns None if it's not provided.
+"""
+return data.get(name, None)
+def _has_changed(self, initial, data):
+"""
+Return True if data differs from initial.
+"""
+# For purposes of seeing whether something has changed, None is
+# the same as an empty string, if the data or inital value we get
+# is None, replace it w/ u''.
+if data is None:
+data_value = u''
+else:
+data_value = data
+if initial is None:
+initial_value = u''
+else:
+initial_value = initial
+if force_unicode(initial_value) != force_unicode(data_value):
+return True
+return False
+def id_for_label(self, id_):
+"""
+Returns the HTML ID attribute of this Widget for use by a <label>,
+given the ID of the field. Returns None if no ID is available.
+This hook is necessary because some widgets have multiple HTML
+elements and, thus, multiple IDs. In that case, this method should
+return an ID value that corresponds to the first ID in the widget's
+tags.
+"""
+return id_
+id_for_label = classmethod(id_for_label)
+class Input(Widget):
+"""
+Base class for all <input> widgets (except type='checkbox' and
+type='radio', which are special).
+"""
+input_type = None # Subclasses must define this.
+def _format_value(self, value):
+if self.is_localized:
+return formats.localize_input(value)
+return value
+def render(self, name, value, attrs=None):
+if value is None:
+value = ''
+final_attrs = self.build_attrs(attrs, type=self.input_type, name=name)
+if value != '':
+# Only add the 'value' attribute if a value is non-empty.
+final_attrs['value'] = force_unicode(self._format_value(value))
+return mark_safe(u'<input%s />' % flatatt(final_attrs))
+class TextInput(Input):
+input_type = 'text'
+class PasswordInput(Input):
+input_type = 'password'
+def __init__(self, attrs=None, render_value=True):
+super(PasswordInput, self).__init__(attrs)
+self.render_value = render_value
+def render(self, name, value, attrs=None):
+if not self.render_value: value=None
+return super(PasswordInput, self).render(name, value, attrs)
+class HiddenInput(Input):
+input_type = 'hidden'
+is_hidden = True
+class MultipleHiddenInput(HiddenInput):
+"""
+A widget that handles <input type="hidden"> for fields that have a list
+of values.
+"""
+def __init__(self, attrs=None, choices=()):
+super(MultipleHiddenInput, self).__init__(attrs)
+# choices can be any iterable
+self.choices = choices
+def render(self, name, value, attrs=None, choices=()):
+if value is None: value = []
+final_attrs = self.build_attrs(attrs, type=self.input_type, name=name)
+id_ = final_attrs.get('id', None)
+inputs = []
+for i, v in enumerate(value):
+input_attrs = dict(value=force_unicode(v), **final_attrs)
+if id_:
+# An ID attribute was given. Add a numeric index as a suffix
+# so that the inputs don't all have the same ID attribute.
+input_attrs['id'] = '%s_%s' % (id_, i)
+inputs.append(u'<input%s />' % flatatt(input_attrs))
+return mark_safe(u'\n'.join(inputs))
+def value_from_datadict(self, data, files, name):
+if isinstance(data, (MultiValueDict, MergeDict)):
+return data.getlist(name)
+return data.get(name, None)
+class FileInput(Input):
+input_type = 'file'
+needs_multipart_form = True
+def render(self, name, value, attrs=None):
+return super(FileInput, self).render(name, None, attrs=attrs)
+def value_from_datadict(self, data, files, name):
+"File widgets take data from FILES, not POST"
+return files.get(name, None)
+def _has_changed(self, initial, data):
+if data is None:
+return False
+return True
+class Textarea(Widget):
+def __init__(self, attrs=None):
+# The 'rows' and 'cols' attributes are required for HTML correctness.
+default_attrs = {'cols': '40', 'rows': '10'}
+if attrs:
+default_attrs.update(attrs)
+super(Textarea, self).__init__(default_attrs)
+def render(self, name, value, attrs=None):
+if value is None: value = ''
+final_attrs = self.build_attrs(attrs, name=name)
+return mark_safe(u'<textarea%s>%s</textarea>' % (flatatt(final_attrs),
+conditional_escape(force_unicode(value))))
+class DateInput(Input):
+input_type = 'text'
+format = '%Y-%m-%d'     # '2006-10-25'
+def __init__(self, attrs=None, format=None):
+super(DateInput, self).__init__(attrs)
+if format:
+self.format = format
+def _format_value(self, value):
+if self.is_localized:
+return formats.localize_input(value)
+elif hasattr(value, 'strftime'):
+value = datetime_safe.new_date(value)
+return value.strftime(self.format)
+return value
+def _has_changed(self, initial, data):
+# If our field has show_hidden_initial=True, initial will be a string
+# formatted by HiddenInput using formats.localize_input, which is not
+# necessarily the format used for this widget. Attempt to convert it.
+try:
+input_format = formats.get_format('DATE_INPUT_FORMATS')[0]
+initial = datetime.date(*time.strptime(initial, input_format)[:3])
+except (TypeError, ValueError):
+pass
+return super(DateInput, self)._has_changed(self._format_value(initial), data)
+class DateTimeInput(Input):
+input_type = 'text'
+format = '%Y-%m-%d %H:%M:%S'     # '2006-10-25 14:30:59'
+def __init__(self, attrs=None, format=None):
+super(DateTimeInput, self).__init__(attrs)
+if format:
+self.format = format
+def _format_value(self, value):
+if self.is_localized:
+return formats.localize_input(value)
+elif hasattr(value, 'strftime'):
+value = datetime_safe.new_datetime(value)
+return value.strftime(self.format)
+return value
+def _has_changed(self, initial, data):
+# If our field has show_hidden_initial=True, initial will be a string
+# formatted by HiddenInput using formats.localize_input, which is not
+# necessarily the format used for this widget. Attempt to convert it.
+try:
+input_format = formats.get_format('DATETIME_INPUT_FORMATS')[0]
+initial = datetime.datetime(*time.strptime(initial, input_format)[:6])
+except (TypeError, ValueError):
+pass
+return super(DateTimeInput, self)._has_changed(self._format_value(initial), data)
+class TimeInput(Input):
+input_type = 'text'
+format = '%H:%M:%S'     # '14:30:59'
+def __init__(self, attrs=None, format=None):
+super(TimeInput, self).__init__(attrs)
+if format:
+self.format = format
+def _format_value(self, value):
+if self.is_localized:
+return formats.localize_input(value)
+elif hasattr(value, 'strftime'):
+return value.strftime(self.format)
+return value
+def _has_changed(self, initial, data):
+# If our field has show_hidden_initial=True, initial will be a string
+# formatted by HiddenInput using formats.localize_input, which is not
+# necessarily the format used for this  widget. Attempt to convert it.
+try:
+input_format = formats.get_format('TIME_INPUT_FORMATS')[0]
+initial = datetime.time(*time.strptime(initial, input_format)[3:6])
+except (TypeError, ValueError):
+pass
+return super(TimeInput, self)._has_changed(self._format_value(initial), data)
+class CheckboxInput(Widget):
+def __init__(self, attrs=None, check_test=bool):
+super(CheckboxInput, self).__init__(attrs)
+# check_test is a callable that takes a value and returns True
+# if the checkbox should be checked for that value.
+self.check_test = check_test
+def render(self, name, value, attrs=None):
+final_attrs = self.build_attrs(attrs, type='checkbox', name=name)
+try:
+result = self.check_test(value)
+except: # Silently catch exceptions
+result = False
+if result:
+final_attrs['checked'] = 'checked'
+if value not in ('', True, False, None):
+# Only add the 'value' attribute if a value is non-empty.
+final_attrs['value'] = force_unicode(value)
+return mark_safe(u'<input%s />' % flatatt(final_attrs))
+def value_from_datadict(self, data, files, name):
+if name not in data:
+# A missing value means False because HTML form submission does not
+# send results for unselected checkboxes.
+return False
+value = data.get(name)
+# Translate true and false strings to boolean values.
+values =  {'true': True, 'false': False}
+if isinstance(value, basestring):
+value = values.get(value.lower(), value)
+return value
+def _has_changed(self, initial, data):
+# Sometimes data or initial could be None or u'' which should be the
+# same thing as False.
+return bool(initial) != bool(data)
+class Select(Widget):
+def __init__(self, attrs=None, choices=()):
+super(Select, self).__init__(attrs)
+# choices can be any iterable, but we may need to render this widget
+# multiple times. Thus, collapse it into a list so it can be consumed
+# more than once.
+self.choices = list(choices)
+def render(self, name, value, attrs=None, choices=()):
+if value is None: value = ''
+final_attrs = self.build_attrs(attrs, name=name)
+output = [u'<select%s>' % flatatt(final_attrs)]
+options = self.render_options(choices, [value])
+if options:
+output.append(options)
+output.append(u'</select>')
+return mark_safe(u'\n'.join(output))
+def render_options(self, choices, selected_choices):
+def render_option(option_value, option_label):
+option_value = force_unicode(option_value)
+selected_html = (option_value in selected_choices) and u' selected="selected"' or ''
+return u'<option value="%s"%s>%s</option>' % (
+escape(option_value), selected_html,
+conditional_escape(force_unicode(option_label)))
+# Normalize to strings.
+selected_choices = set([force_unicode(v) for v in selected_choices])
+output = []
+for option_value, option_label in chain(self.choices, choices):
+if isinstance(option_label, (list, tuple)):
+output.append(u'<optgroup label="%s">' % escape(force_unicode(option_value)))
+for option in option_label:
+output.append(render_option(*option))
+output.append(u'</optgroup>')
+else:
+output.append(render_option(option_value, option_label))
+return u'\n'.join(output)
+class NullBooleanSelect(Select):
+"""
+A Select Widget intended to be used with NullBooleanField.
+"""
+def __init__(self, attrs=None):
+choices = ((u'1', ugettext('Unknown')), (u'2', ugettext('Yes')), (u'3', ugettext('No')))
+super(NullBooleanSelect, self).__init__(attrs, choices)
+def render(self, name, value, attrs=None, choices=()):
+try:
+value = {True: u'2', False: u'3', u'2': u'2', u'3': u'3'}[value]
+except KeyError:
+value = u'1'
+return super(NullBooleanSelect, self).render(name, value, attrs, choices)
+def value_from_datadict(self, data, files, name):
+value = data.get(name, None)
+return {u'2': True,
+True: True,
+'True': True,
+u'3': False,
+'False': False,
+False: False}.get(value, None)
+def _has_changed(self, initial, data):
+# For a NullBooleanSelect, None (unknown) and False (No)
+# are not the same
+if initial is not None:
+initial = bool(initial)
+if data is not None:
+data = bool(data)
+return initial != data
+class SelectMultiple(Select):
+def render(self, name, value, attrs=None, choices=()):
+if value is None: value = []
+final_attrs = self.build_attrs(attrs, name=name)
+output = [u'<select multiple="multiple"%s>' % flatatt(final_attrs)]
+options = self.render_options(choices, value)
+if options:
+output.append(options)
+output.append('</select>')
+return mark_safe(u'\n'.join(output))
+def value_from_datadict(self, data, files, name):
+if isinstance(data, (MultiValueDict, MergeDict)):
+return data.getlist(name)
+return data.get(name, None)
+def _has_changed(self, initial, data):
+if initial is None:
+initial = []
+if data is None:
+data = []
+if len(initial) != len(data):
+return True
+for value1, value2 in zip(initial, data):
+if force_unicode(value1) != force_unicode(value2):
+return True
+return False
+class RadioInput(StrAndUnicode):
+"""
+An object used by RadioFieldRenderer that represents a single
+<input type='radio'>.
+"""
+def __init__(self, name, value, attrs, choice, index):
+self.name, self.value = name, value
+self.attrs = attrs
+self.choice_value = force_unicode(choice[0])
+self.choice_label = force_unicode(choice[1])
+self.index = index
+def __unicode__(self):
+if 'id' in self.attrs:
+label_for = ' for="%s_%s"' % (self.attrs['id'], self.index)
+else:
+label_for = ''
+choice_label = conditional_escape(force_unicode(self.choice_label))
+return mark_safe(u'<label%s>%s %s</label>' % (label_for, self.tag(), choice_label))
+def is_checked(self):
+return self.value == self.choice_value
+def tag(self):
+if 'id' in self.attrs:
+self.attrs['id'] = '%s_%s' % (self.attrs['id'], self.index)
+final_attrs = dict(self.attrs, type='radio', name=self.name, value=self.choice_value)
+if self.is_checked():
+final_attrs['checked'] = 'checked'
+return mark_safe(u'<input%s />' % flatatt(final_attrs))
+class RadioFieldRenderer(StrAndUnicode):
+"""
+An object used by RadioSelect to enable customization of radio widgets.
+"""
+def __init__(self, name, value, attrs, choices):
+self.name, self.value, self.attrs = name, value, attrs
+self.choices = choices
+def __iter__(self):
+for i, choice in enumerate(self.choices):
+yield RadioInput(self.name, self.value, self.attrs.copy(), choice, i)
+def __getitem__(self, idx):
+choice = self.choices[idx] # Let the IndexError propogate
+return RadioInput(self.name, self.value, self.attrs.copy(), choice, idx)
+def __unicode__(self):
+return self.render()
+def render(self):
+"""Outputs a <ul> for this set of radio fields."""
+return mark_safe(u'<ul>\n%s\n</ul>' % u'\n'.join([u'<li>%s</li>'
+% force_unicode(w) for w in self]))
+class RadioSelect(Select):
+renderer = RadioFieldRenderer
+def __init__(self, *args, **kwargs):
+# Override the default renderer if we were passed one.
+renderer = kwargs.pop('renderer', None)
+if renderer:
+self.renderer = renderer
+super(RadioSelect, self).__init__(*args, **kwargs)
+def get_renderer(self, name, value, attrs=None, choices=()):
+"""Returns an instance of the renderer."""
+if value is None: value = ''
+str_value = force_unicode(value) # Normalize to string.
+final_attrs = self.build_attrs(attrs)
+choices = list(chain(self.choices, choices))
+return self.renderer(name, str_value, final_attrs, choices)
+def render(self, name, value, attrs=None, choices=()):
+return self.get_renderer(name, value, attrs, choices).render()
+def id_for_label(self, id_):
+# RadioSelect is represented by multiple <input type="radio"> fields,
+# each of which has a distinct ID. The IDs are made distinct by a "_X"
+# suffix, where X is the zero-based index of the radio field. Thus,
+# the label for a RadioSelect should reference the first one ('_0').
+if id_:
+id_ += '_0'
+return id_
+id_for_label = classmethod(id_for_label)
+class CheckboxSelectMultiple(SelectMultiple):
+def render(self, name, value, attrs=None, choices=()):
+if value is None: value = []
+has_id = attrs and 'id' in attrs
+final_attrs = self.build_attrs(attrs, name=name)
+output = [u'<ul>']
+# Normalize to strings
+str_values = set([force_unicode(v) for v in value])
+for i, (option_value, option_label) in enumerate(chain(self.choices, choices)):
+# If an ID attribute was given, add a numeric index as a suffix,
+# so that the checkboxes don't all have the same ID attribute.
+if has_id:
+final_attrs = dict(final_attrs, id='%s_%s' % (attrs['id'], i))
+label_for = u' for="%s"' % final_attrs['id']
+else:
+label_for = ''
+cb = CheckboxInput(final_attrs, check_test=lambda value: value in str_values)
+option_value = force_unicode(option_value)
+rendered_cb = cb.render(name, option_value)
+option_label = conditional_escape(force_unicode(option_label))
+output.append(u'<li><label%s>%s %s</label></li>' % (label_for, rendered_cb, option_label))
+output.append(u'</ul>')
+return mark_safe(u'\n'.join(output))
+def id_for_label(self, id_):
+# See the comment for RadioSelect.id_for_label()
+if id_:
+id_ += '_0'
+return id_
+id_for_label = classmethod(id_for_label)
+class MultiWidget(Widget):
+"""
+A widget that is composed of multiple widgets.
+Its render() method is different than other widgets', because it has to
+figure out how to split a single value for display in multiple widgets.
+The ``value`` argument can be one of two things:
+* A list.
+* A normal value (e.g., a string) that has been "compressed" from
+a list of values.
+In the second case -- i.e., if the value is NOT a list -- render() will
+first "decompress" the value into a list before rendering it. It does so by
+calling the decompress() method, which MultiWidget subclasses must
+implement. This method takes a single "compressed" value and returns a
+list.
+When render() does its HTML rendering, each value in the list is rendered
+with the corresponding widget -- the first value is rendered in the first
+widget, the second value is rendered in the second widget, etc.
+Subclasses may implement format_output(), which takes the list of rendered
+widgets and returns a string of HTML that formats them any way you'd like.
+You'll probably want to use this class with MultiValueField.
+"""
+def __init__(self, widgets, attrs=None):
+self.widgets = [isinstance(w, type) and w() or w for w in widgets]
+super(MultiWidget, self).__init__(attrs)
+def render(self, name, value, attrs=None):
+if self.is_localized:
+for widget in self.widgets:
+widget.is_localized = self.is_localized
+# value is a list of values, each corresponding to a widget
+# in self.widgets.
+if not isinstance(value, list):
+value = self.decompress(value)
+output = []
+final_attrs = self.build_attrs(attrs)
+id_ = final_attrs.get('id', None)
+for i, widget in enumerate(self.widgets):
+try:
+widget_value = value[i]
+except IndexError:
+widget_value = None
+if id_:
+final_attrs = dict(final_attrs, id='%s_%s' % (id_, i))
+output.append(widget.render(name + '_%s' % i, widget_value, final_attrs))
+return mark_safe(self.format_output(output))
+def id_for_label(self, id_):
+# See the comment for RadioSelect.id_for_label()
+if id_:
+id_ += '_0'
+return id_
+id_for_label = classmethod(id_for_label)
+def value_from_datadict(self, data, files, name):
+return [widget.value_from_datadict(data, files, name + '_%s' % i) for i, widget in enumerate(self.widgets)]
+def _has_changed(self, initial, data):
+if initial is None:
+initial = [u'' for x in range(0, len(data))]
+else:
+if not isinstance(initial, list):
+initial = self.decompress(initial)
+for widget, initial, data in zip(self.widgets, initial, data):
+if widget._has_changed(initial, data):
+return True
+return False
+def format_output(self, rendered_widgets):
+"""
+Given a list of rendered widgets (as strings), returns a Unicode string
+representing the HTML for the whole lot.
+This hook allows you to format the HTML design of the widgets, if
+needed.
+"""
+return u''.join(rendered_widgets)
+def decompress(self, value):
+"""
+Returns a list of decompressed values for the given compressed value.
+The given value can be assumed to be valid, but not necessarily
+non-empty.
+"""
+raise NotImplementedError('Subclasses must implement this method.')
+def _get_media(self):
+"Media for a multiwidget is the combination of all media of the subwidgets"
+media = Media()
+for w in self.widgets:
+media = media + w.media
+return media
+media = property(_get_media)
+def __deepcopy__(self, memo):
+obj = super(MultiWidget, self).__deepcopy__(memo)
+obj.widgets = copy.deepcopy(self.widgets)
+return obj
+class SplitDateTimeWidget(MultiWidget):
+"""
+A Widget that splits datetime input into two <input type="text"> boxes.
+"""
+date_format = DateInput.format
+time_format = TimeInput.format
+def __init__(self, attrs=None, date_format=None, time_format=None):
+if date_format:
+self.date_format = date_format
+if time_format:
+self.time_format = time_format
+widgets = (DateInput(attrs=attrs, format=self.date_format),
+TimeInput(attrs=attrs, format=self.time_format))
+super(SplitDateTimeWidget, self).__init__(widgets, attrs)
+def decompress(self, value):
+if value:
+return [value.date(), value.time().replace(microsecond=0)]
+return [None, None]
+class SplitHiddenDateTimeWidget(SplitDateTimeWidget):
+"""
+A Widget that splits datetime input into two <input type="hidden"> inputs.
+"""
+is_hidden = True
+def __init__(self, attrs=None, date_format=None, time_format=None):
+super(SplitHiddenDateTimeWidget, self).__init__(attrs, date_format, time_format)
+for widget in self.widgets:
+widget.input_type = 'hidden'
+widget.is_hidden = True