def __init__(self, *args, **kwargs):
    super(BooleanField, self).__init__(*args, **normalize_field(kwargs, False))

def bind(self, fieldmapping, original, bound_field_class):
    return bound_field_class(self, fieldmapping, original)

def clean(self, value, model_instance):
    """
    Convert the value's type and run validation. Validation errors
    from to_python and validate are propagated. The correct value is
    returned if no error is raised.
    """
    value = self.to_python(value)
    self.validate(value, model_instance)
    self.run_validators(value)
    return value

def contribute_to_class(self, cls, name, virtual_only=False):
    self.set_attributes_from_name(name)
    self.model = cls
    if virtual_only:
        cls._meta.add_virtual_field(self)
    else:
        cls._meta.add_field(self)
    if self.choices:
        setattr(cls, 'get_%s_display' % self.name,
                curry(cls._get_FIELD_display, field=self))

def db_type(self, connection):
    """
    Returns the database column data type for this field, for the provided
    connection.
    """
    # The default implementation of this method looks at the
    # backend-specific DATA_TYPES dictionary, looking up the field by its
    # "internal type".
    #
    # A Field class can implement the get_internal_type() method to specify
    # which *preexisting* Django Field class it's most similar to -- i.e.,
    # a custom field might be represented by a TEXT column type, which is
    # the same as the TextField Django field type, which means the custom
    # field's get_internal_type() returns 'TextField'.
    #
    # But the limitation of the get_internal_type() / data_types approach
    # is that it cannot handle database column types that aren't already
    # mapped to one of the built-in Django field types. In this case, you
    # can implement db_type() instead of get_internal_type() to specify
    # exactly which wacky database column type you want to use.
    data = DictWrapper(self.__dict__, connection.ops.quote_name, "qn_")
    try:
        return (connection.creation.data_types[self.get_internal_type()]
                % data)
    except KeyError:
        return None

def formfield(self, **kwargs):
    # Unlike most fields, BooleanField figures out include_blank from
    # self.null instead of self.blank.
    if self.choices:
        include_blank = (self.null or
                         not (self.has_default() or 'initial' in kwargs))
        defaults = {'choices': self.get_choices(
                                   include_blank=include_blank)}
    else:
        defaults = {'form_class': forms.BooleanField}
    defaults.update(kwargs)
    return super(BooleanField, self).formfield(**defaults)

def get_attname(self):
    return self.name

def get_attname_column(self):
    attname = self.get_attname()
    column = self.db_column or attname
    return attname, column

def get_cache_name(self):
    return '_%s_cache' % self.name

def get_choices(self, include_blank=True, blank_choice=BLANK_CHOICE_DASH):
    """Returns choices with a default blank choices included, for use
    as SelectField choices for this field."""
    first_choice = blank_choice if include_blank else []
    if self.choices:
        return first_choice + list(self.choices)
    rel_model = self.rel.to
    if hasattr(self.rel, 'get_related_field'):
        lst = [(getattr(x, self.rel.get_related_field().attname),
                    smart_text(x))
               for x in rel_model._default_manager.complex_filter(
                   self.rel.limit_choices_to)]
    else:
        lst = [(x._get_pk_val(), smart_text(x))
               for x in rel_model._default_manager.complex_filter(
                   self.rel.limit_choices_to)]
    return first_choice + lst

def get_choices_default(self):
    return self.get_choices()

def get_db_prep_lookup(self, lookup_type, value, connection,
                       prepared=False):
    """
    Returns field's value prepared for database lookup.
    """
    if not prepared:
        value = self.get_prep_lookup(lookup_type, value)
        prepared = True
    if hasattr(value, 'get_compiler'):
        value = value.get_compiler(connection=connection)
    if hasattr(value, 'as_sql') or hasattr(value, '_as_sql'):
        # If the value has a relabeled_clone method it means the
        # value will be handled later on.
        if hasattr(value, 'relabeled_clone'):
            return value
        if hasattr(value, 'as_sql'):
            sql, params = value.as_sql()
        else:
            sql, params = value._as_sql(connection=connection)
        return QueryWrapper(('(%s)' % sql), params)
    if lookup_type in ('month', 'day', 'week_day', 'hour', 'minute',
                       'second', 'search', 'regex', 'iregex'):
        return [value]
    elif lookup_type in ('exact', 'gt', 'gte', 'lt', 'lte'):
        return [self.get_db_prep_value(value, connection=connection,
                                       prepared=prepared)]
    elif lookup_type in ('range', 'in'):
        return [self.get_db_prep_value(v, connection=connection,
                                       prepared=prepared) for v in value]
    elif lookup_type in ('contains', 'icontains'):
        return ["%%%s%%" % connection.ops.prep_for_like_query(value)]
    elif lookup_type == 'iexact':
        return [connection.ops.prep_for_iexact_query(value)]
    elif lookup_type in ('startswith', 'istartswith'):
        return ["%s%%" % connection.ops.prep_for_like_query(value)]
    elif lookup_type in ('endswith', 'iendswith'):
        return ["%%%s" % connection.ops.prep_for_like_query(value)]
    elif lookup_type == 'isnull':
        return []
    elif lookup_type == 'year':
        if isinstance(self, DateTimeField):
            return connection.ops.year_lookup_bounds_for_datetime_field(value)
        elif isinstance(self, DateField):
            return connection.ops.year_lookup_bounds_for_date_field(value)
        else:
            return [value]          # this isn't supposed to happen

def get_db_prep_save(self, value, connection):
    """
    Returns field's value prepared for saving into a database.
    """
    return self.get_db_prep_value(value, connection=connection,
                                  prepared=False)

def get_db_prep_value(self, value, connection, prepared=False):
    """Returns field's value prepared for interacting with the database
    backend.
    Used by the default implementations of ``get_db_prep_save``and
    `get_db_prep_lookup```
    """
    if not prepared:
        value = self.get_prep_value(value)
    return value

def get_default(self):
    """
    Returns the default value for this field.
    """
    if self.has_default():
        if callable(self.default):
            return self.default()
        return force_text(self.default, strings_only=True)
    if (not self.empty_strings_allowed or (self.null and
               not connection.features.interprets_empty_strings_as_nulls)):
        return None
    return ""

def get_flatchoices(self, include_blank=True,
                    blank_choice=BLANK_CHOICE_DASH):
    """
    Returns flattened choices with a default blank choice included.
    """
    first_choice = blank_choice if include_blank else []
    return first_choice + list(self.flatchoices)

def get_internal_type(self):
    return "BooleanField"

def get_prep_lookup(self, lookup_type, value):
    # Special-case handling for filters coming from a Web request (e.g. the
    # admin interface). Only works for scalar values (not lists). If you're
    # passing in a list, you might as well make things the right type when
    # constructing the list.
    if value in ('1', '0'):
        value = bool(int(value))
    return super(BooleanField, self).get_prep_lookup(lookup_type, value)

def get_prep_value(self, value):
    if value is None:
        return None
    return bool(value)

def get_validator_unique_lookup_type(self):
    return '%s__exact' % self.name

def has_default(self):
    """
    Returns a boolean of whether this field has a default value.
    """
    return self.default is not NOT_PROVIDED

def pre_save(self, model_instance, add):
    """
    Returns field's value just before saving.
    """
    return getattr(model_instance, self.attname)

def run_validators(self, value):
    if value in self.empty_values:
        return
    errors = []
    for v in self.validators:
        try:
            v(value)
        except exceptions.ValidationError as e:
            if hasattr(e, 'code') and e.code in self.error_messages:
                e.message = self.error_messages[e.code]
            errors.extend(e.error_list)
    if errors:
        raise exceptions.ValidationError(errors)

def save_form_data(self, instance, data):
    setattr(instance, self.name, data)

def set_attributes_from_name(self, name):
    if not self.name:
        self.name = name
    self.attname, self.column = self.get_attname_column()
    if self.verbose_name is None and self.name:
        self.verbose_name = self.name.replace('_', ' ')

def to_python(self, value):
    if value in (True, False):
        # if value is 1 or 0 than it's equal to True or False, but we want
        # to return a true bool for semantic reasons.
        return bool(value)
    if value in ('t', 'True', '1'):
        return True
    if value in ('f', 'False', '0'):
        return False
    raise exceptions.ValidationError(
        self.error_messages['invalid'],
        code='invalid',
        params={'value': value},
    )

def validate(self, value, model_instance):
    """
    Validates value and throws ValidationError. Subclasses should override
    this to provide validation logic.
    """
    if not self.editable:
        # Skip validation for non-editable fields.
        return
    if self._choices and value not in self.empty_values:
        for option_key, option_value in self.choices:
            if isinstance(option_value, (list, tuple)):
                # This is an optgroup, so look inside the group for
                # options.
                for optgroup_key, optgroup_value in option_value:
                    if value == optgroup_key:
                        return
            elif value == option_key:
                return
        raise exceptions.ValidationError(
            self.error_messages['invalid_choice'],
            code='invalid_choice',
            params={'value': value},
        )
    if value is None and not self.null:
        raise exceptions.ValidationError(self.error_messages['null'], code='null')
    if not self.blank and value in self.empty_values:
        raise exceptions.ValidationError(self.error_messages['blank'], code='blank')

def value_from_object(self, obj):
    """
    Returns the value of this field in the given model instance.
    """
    return getattr(obj, self.attname)

def value_to_string(self, obj):
    """
    Returns a string value of this field from the passed obj.
    This is used by the serialization framework.
    """
    return smart_text(self._get_val_from_obj(obj))

def __init__(self, *args, **kwargs):
    if not kwargs.has_key('max_length'):
        kwargs['max_length'] = 250
    super(CharField, self).__init__(*args, **normalize_field(kwargs, ''))

def bind(self, fieldmapping, original, bound_field_class):
    return bound_field_class(self, fieldmapping, original)

def clean(self, value, model_instance):
    """
    Convert the value's type and run validation. Validation errors
    from to_python and validate are propagated. The correct value is
    returned if no error is raised.
    """
    value = self.to_python(value)
    self.validate(value, model_instance)
    self.run_validators(value)
    return value

def contribute_to_class(self, cls, name, virtual_only=False):
    self.set_attributes_from_name(name)
    self.model = cls
    if virtual_only:
        cls._meta.add_virtual_field(self)
    else:
        cls._meta.add_field(self)
    if self.choices:
        setattr(cls, 'get_%s_display' % self.name,
                curry(cls._get_FIELD_display, field=self))

def db_type(self, connection):
    """
    Returns the database column data type for this field, for the provided
    connection.
    """
    # The default implementation of this method looks at the
    # backend-specific DATA_TYPES dictionary, looking up the field by its
    # "internal type".
    #
    # A Field class can implement the get_internal_type() method to specify
    # which *preexisting* Django Field class it's most similar to -- i.e.,
    # a custom field might be represented by a TEXT column type, which is
    # the same as the TextField Django field type, which means the custom
    # field's get_internal_type() returns 'TextField'.
    #
    # But the limitation of the get_internal_type() / data_types approach
    # is that it cannot handle database column types that aren't already
    # mapped to one of the built-in Django field types. In this case, you
    # can implement db_type() instead of get_internal_type() to specify
    # exactly which wacky database column type you want to use.
    data = DictWrapper(self.__dict__, connection.ops.quote_name, "qn_")
    try:
        return (connection.creation.data_types[self.get_internal_type()]
                % data)
    except KeyError:
        return None

def formfield(self, **kwargs):
    # Passing max_length to forms.CharField means that the value's length
    # will be validated twice. This is considered acceptable since we want
    # the value in the form field (to pass into widget for example).
    defaults = {'max_length': self.max_length}
    defaults.update(kwargs)
    return super(CharField, self).formfield(**defaults)

def get_attname(self):
    return self.name

def get_attname_column(self):
    attname = self.get_attname()
    column = self.db_column or attname
    return attname, column

def get_cache_name(self):
    return '_%s_cache' % self.name

def get_choices(self, include_blank=True, blank_choice=BLANK_CHOICE_DASH):
    """Returns choices with a default blank choices included, for use
    as SelectField choices for this field."""
    first_choice = blank_choice if include_blank else []
    if self.choices:
        return first_choice + list(self.choices)
    rel_model = self.rel.to
    if hasattr(self.rel, 'get_related_field'):
        lst = [(getattr(x, self.rel.get_related_field().attname),
                    smart_text(x))
               for x in rel_model._default_manager.complex_filter(
                   self.rel.limit_choices_to)]
    else:
        lst = [(x._get_pk_val(), smart_text(x))
               for x in rel_model._default_manager.complex_filter(
                   self.rel.limit_choices_to)]
    return first_choice + lst

def get_choices_default(self):
    return self.get_choices()

def get_db_prep_lookup(self, lookup_type, value, connection,
                       prepared=False):
    """
    Returns field's value prepared for database lookup.
    """
    if not prepared:
        value = self.get_prep_lookup(lookup_type, value)
        prepared = True
    if hasattr(value, 'get_compiler'):
        value = value.get_compiler(connection=connection)
    if hasattr(value, 'as_sql') or hasattr(value, '_as_sql'):
        # If the value has a relabeled_clone method it means the
        # value will be handled later on.
        if hasattr(value, 'relabeled_clone'):
            return value
        if hasattr(value, 'as_sql'):
            sql, params = value.as_sql()
        else:
            sql, params = value._as_sql(connection=connection)
        return QueryWrapper(('(%s)' % sql), params)
    if lookup_type in ('month', 'day', 'week_day', 'hour', 'minute',
                       'second', 'search', 'regex', 'iregex'):
        return [value]
    elif lookup_type in ('exact', 'gt', 'gte', 'lt', 'lte'):
        return [self.get_db_prep_value(value, connection=connection,
                                       prepared=prepared)]
    elif lookup_type in ('range', 'in'):
        return [self.get_db_prep_value(v, connection=connection,
                                       prepared=prepared) for v in value]
    elif lookup_type in ('contains', 'icontains'):
        return ["%%%s%%" % connection.ops.prep_for_like_query(value)]
    elif lookup_type == 'iexact':
        return [connection.ops.prep_for_iexact_query(value)]
    elif lookup_type in ('startswith', 'istartswith'):
        return ["%s%%" % connection.ops.prep_for_like_query(value)]
    elif lookup_type in ('endswith', 'iendswith'):
        return ["%%%s" % connection.ops.prep_for_like_query(value)]
    elif lookup_type == 'isnull':
        return []
    elif lookup_type == 'year':
        if isinstance(self, DateTimeField):
            return connection.ops.year_lookup_bounds_for_datetime_field(value)
        elif isinstance(self, DateField):
            return connection.ops.year_lookup_bounds_for_date_field(value)
        else:
            return [value]          # this isn't supposed to happen

def get_db_prep_save(self, value, connection):
    """
    Returns field's value prepared for saving into a database.
    """
    return self.get_db_prep_value(value, connection=connection,
                                  prepared=False)

def get_db_prep_value(self, value, connection, prepared=False):
    """Returns field's value prepared for interacting with the database
    backend.
    Used by the default implementations of ``get_db_prep_save``and
    `get_db_prep_lookup```
    """
    if not prepared:
        value = self.get_prep_value(value)
    return value

def get_default(self):
    """
    Returns the default value for this field.
    """
    if self.has_default():
        if callable(self.default):
            return self.default()
        return force_text(self.default, strings_only=True)
    if (not self.empty_strings_allowed or (self.null and
               not connection.features.interprets_empty_strings_as_nulls)):
        return None
    return ""

def get_flatchoices(self, include_blank=True,
                    blank_choice=BLANK_CHOICE_DASH):
    """
    Returns flattened choices with a default blank choice included.
    """
    first_choice = blank_choice if include_blank else []
    return first_choice + list(self.flatchoices)

def get_internal_type(self):
    return "CharField"

def get_prep_lookup(self, lookup_type, value):
    """
    Perform preliminary non-db specific lookup checks and conversions
    """
    if hasattr(value, 'prepare'):
        return value.prepare()
    if hasattr(value, '_prepare'):
        return value._prepare()
    if lookup_type in (
            'iexact', 'contains', 'icontains',
            'startswith', 'istartswith', 'endswith', 'iendswith',
            'month', 'day', 'week_day', 'hour', 'minute', 'second',
            'isnull', 'search', 'regex', 'iregex',
        ):
        return value
    elif lookup_type in ('exact', 'gt', 'gte', 'lt', 'lte'):
        return self.get_prep_value(value)
    elif lookup_type in ('range', 'in'):
        return [self.get_prep_value(v) for v in value]
    elif lookup_type == 'year':
        try:
            return int(value)
        except ValueError:
            raise ValueError("The __year lookup type requires an integer "
                             "argument")
    raise TypeError("Field has invalid lookup: %s" % lookup_type)

def get_prep_value(self, value):
    return self.to_python(value)

def get_validator_unique_lookup_type(self):
    return '%s__exact' % self.name

def has_default(self):
    """
    Returns a boolean of whether this field has a default value.
    """
    return self.default is not NOT_PROVIDED

def pre_save(self, model_instance, add):
    """
    Returns field's value just before saving.
    """
    return getattr(model_instance, self.attname)

def run_validators(self, value):
    if value in self.empty_values:
        return
    errors = []
    for v in self.validators:
        try:
            v(value)
        except exceptions.ValidationError as e:
            if hasattr(e, 'code') and e.code in self.error_messages:
                e.message = self.error_messages[e.code]
            errors.extend(e.error_list)
    if errors:
        raise exceptions.ValidationError(errors)

def save_form_data(self, instance, data):
    setattr(instance, self.name, data)

def set_attributes_from_name(self, name):
    if not self.name:
        self.name = name
    self.attname, self.column = self.get_attname_column()
    if self.verbose_name is None and self.name:
        self.verbose_name = self.name.replace('_', ' ')

def to_python(self, value):
    if isinstance(value, six.string_types) or value is None:
        return value
    return smart_text(value)

def validate(self, value, model_instance):
    """
    Validates value and throws ValidationError. Subclasses should override
    this to provide validation logic.
    """
    if not self.editable:
        # Skip validation for non-editable fields.
        return
    if self._choices and value not in self.empty_values:
        for option_key, option_value in self.choices:
            if isinstance(option_value, (list, tuple)):
                # This is an optgroup, so look inside the group for
                # options.
                for optgroup_key, optgroup_value in option_value:
                    if value == optgroup_key:
                        return
            elif value == option_key:
                return
        raise exceptions.ValidationError(
            self.error_messages['invalid_choice'],
            code='invalid_choice',
            params={'value': value},
        )
    if value is None and not self.null:
        raise exceptions.ValidationError(self.error_messages['null'], code='null')
    if not self.blank and value in self.empty_values:
        raise exceptions.ValidationError(self.error_messages['blank'], code='blank')

def value_from_object(self, obj):
    """
    Returns the value of this field in the given model instance.
    """
    return getattr(obj, self.attname)

def value_to_string(self, obj):
    """
    Returns a string value of this field from the passed obj.
    This is used by the serialization framework.
    """
    return smart_text(self._get_val_from_obj(obj))

def __init__(self, *args, **kwargs):
    if not kwargs.has_key('null'):
        kwargs['null'] = True
    super(DateField, self).__init__(*args, **normalize_field(kwargs))

def bind(self, fieldmapping, original, bound_field_class):
    return bound_field_class(self, fieldmapping, original)

def clean(self, value, model_instance):
    """
    Convert the value's type and run validation. Validation errors
    from to_python and validate are propagated. The correct value is
    returned if no error is raised.
    """
    value = self.to_python(value)
    self.validate(value, model_instance)
    self.run_validators(value)
    return value

def contribute_to_class(self, cls, name):
    super(DateField,self).contribute_to_class(cls, name)
    if not self.null:
        setattr(cls, 'get_next_by_%s' % self.name,
            curry(cls._get_next_or_previous_by_FIELD, field=self,
                  is_next=True))
        setattr(cls, 'get_previous_by_%s' % self.name,
            curry(cls._get_next_or_previous_by_FIELD, field=self,
                  is_next=False))

def db_type(self, connection):
    """
    Returns the database column data type for this field, for the provided
    connection.
    """
    # The default implementation of this method looks at the
    # backend-specific DATA_TYPES dictionary, looking up the field by its
    # "internal type".
    #
    # A Field class can implement the get_internal_type() method to specify
    # which *preexisting* Django Field class it's most similar to -- i.e.,
    # a custom field might be represented by a TEXT column type, which is
    # the same as the TextField Django field type, which means the custom
    # field's get_internal_type() returns 'TextField'.
    #
    # But the limitation of the get_internal_type() / data_types approach
    # is that it cannot handle database column types that aren't already
    # mapped to one of the built-in Django field types. In this case, you
    # can implement db_type() instead of get_internal_type() to specify
    # exactly which wacky database column type you want to use.
    data = DictWrapper(self.__dict__, connection.ops.quote_name, "qn_")
    try:
        return (connection.creation.data_types[self.get_internal_type()]
                % data)
    except KeyError:
        return None

def formfield(self, **kwargs):
    defaults = {'form_class': forms.DateField}
    defaults.update(kwargs)
    return super(DateField, self).formfield(**defaults)

def get_attname(self):
    return self.name

def get_attname_column(self):
    attname = self.get_attname()
    column = self.db_column or attname
    return attname, column

def get_cache_name(self):
    return '_%s_cache' % self.name

def get_choices(self, include_blank=True, blank_choice=BLANK_CHOICE_DASH):
    """Returns choices with a default blank choices included, for use
    as SelectField choices for this field."""
    first_choice = blank_choice if include_blank else []
    if self.choices:
        return first_choice + list(self.choices)
    rel_model = self.rel.to
    if hasattr(self.rel, 'get_related_field'):
        lst = [(getattr(x, self.rel.get_related_field().attname),
                    smart_text(x))
               for x in rel_model._default_manager.complex_filter(
                   self.rel.limit_choices_to)]
    else:
        lst = [(x._get_pk_val(), smart_text(x))
               for x in rel_model._default_manager.complex_filter(
                   self.rel.limit_choices_to)]
    return first_choice + lst

def get_choices_default(self):
    return self.get_choices()

def get_db_prep_lookup(self, lookup_type, value, connection,
                       prepared=False):
    """
    Returns field's value prepared for database lookup.
    """
    if not prepared:
        value = self.get_prep_lookup(lookup_type, value)
        prepared = True
    if hasattr(value, 'get_compiler'):
        value = value.get_compiler(connection=connection)
    if hasattr(value, 'as_sql') or hasattr(value, '_as_sql'):
        # If the value has a relabeled_clone method it means the
        # value will be handled later on.
        if hasattr(value, 'relabeled_clone'):
            return value
        if hasattr(value, 'as_sql'):
            sql, params = value.as_sql()
        else:
            sql, params = value._as_sql(connection=connection)
        return QueryWrapper(('(%s)' % sql), params)
    if lookup_type in ('month', 'day', 'week_day', 'hour', 'minute',
                       'second', 'search', 'regex', 'iregex'):
        return [value]
    elif lookup_type in ('exact', 'gt', 'gte', 'lt', 'lte'):
        return [self.get_db_prep_value(value, connection=connection,
                                       prepared=prepared)]
    elif lookup_type in ('range', 'in'):
        return [self.get_db_prep_value(v, connection=connection,
                                       prepared=prepared) for v in value]
    elif lookup_type in ('contains', 'icontains'):
        return ["%%%s%%" % connection.ops.prep_for_like_query(value)]
    elif lookup_type == 'iexact':
        return [connection.ops.prep_for_iexact_query(value)]
    elif lookup_type in ('startswith', 'istartswith'):
        return ["%s%%" % connection.ops.prep_for_like_query(value)]
    elif lookup_type in ('endswith', 'iendswith'):
        return ["%%%s" % connection.ops.prep_for_like_query(value)]
    elif lookup_type == 'isnull':
        return []
    elif lookup_type == 'year':
        if isinstance(self, DateTimeField):
            return connection.ops.year_lookup_bounds_for_datetime_field(value)
        elif isinstance(self, DateField):
            return connection.ops.year_lookup_bounds_for_date_field(value)
        else:
            return [value]          # this isn't supposed to happen

def get_db_prep_save(self, value, connection):
    """
    Returns field's value prepared for saving into a database.
    """
    return self.get_db_prep_value(value, connection=connection,
                                  prepared=False)

def get_db_prep_value(self, value, connection, prepared=False):
    # Casts dates into the format expected by the backend
    if not prepared:
        value = self.get_prep_value(value)
    return connection.ops.value_to_db_date(value)

def get_default(self):
    """
    Returns the default value for this field.
    """
    if self.has_default():
        if callable(self.default):
            return self.default()
        return force_text(self.default, strings_only=True)
    if (not self.empty_strings_allowed or (self.null and
               not connection.features.interprets_empty_strings_as_nulls)):
        return None
    return ""

def get_flatchoices(self, include_blank=True,
                    blank_choice=BLANK_CHOICE_DASH):
    """
    Returns flattened choices with a default blank choice included.
    """
    first_choice = blank_choice if include_blank else []
    return first_choice + list(self.flatchoices)

def get_internal_type(self):
    return "DateField"

def get_prep_lookup(self, lookup_type, value):
    # For dates lookups, convert the value to an int
    # so the database backend always sees a consistent type.
    if lookup_type in ('month', 'day', 'week_day', 'hour', 'minute', 'second'):
        return int(value)
    return super(DateField, self).get_prep_lookup(lookup_type, value)

def get_prep_value(self, value):
    return self.to_python(value)

def get_validator_unique_lookup_type(self):
    return '%s__exact' % self.name

def has_default(self):
    """
    Returns a boolean of whether this field has a default value.
    """
    return self.default is not NOT_PROVIDED

def pre_save(self, model_instance, add):
    if self.auto_now or (self.auto_now_add and add):
        value = datetime.date.today()
        setattr(model_instance, self.attname, value)
        return value
    else:
        return super(DateField, self).pre_save(model_instance, add)

def run_validators(self, value):
    if value in self.empty_values:
        return
    errors = []
    for v in self.validators:
        try:
            v(value)
        except exceptions.ValidationError as e:
            if hasattr(e, 'code') and e.code in self.error_messages:
                e.message = self.error_messages[e.code]
            errors.extend(e.error_list)
    if errors:
        raise exceptions.ValidationError(errors)

def save_form_data(self, instance, data):
    setattr(instance, self.name, data)

def set_attributes_from_name(self, name):
    if not self.name:
        self.name = name
    self.attname, self.column = self.get_attname_column()
    if self.verbose_name is None and self.name:
        self.verbose_name = self.name.replace('_', ' ')

def to_python(self, value):
    if value is None:
        return value
    if isinstance(value, datetime.datetime):
        if settings.USE_TZ and timezone.is_aware(value):
            # Convert aware datetimes to the default time zone
            # before casting them to dates (#17742).
            default_timezone = timezone.get_default_timezone()
            value = timezone.make_naive(value, default_timezone)
        return value.date()
    if isinstance(value, datetime.date):
        return value
    try:
        parsed = parse_date(value)
        if parsed is not None:
            return parsed
    except ValueError:
        raise exceptions.ValidationError(
            self.error_messages['invalid_date'],
            code='invalid_date',
            params={'value': value},
        )
    raise exceptions.ValidationError(
        self.error_messages['invalid'],
        code='invalid',
        params={'value': value},
    )

def validate(self, value, model_instance):
    """
    Validates value and throws ValidationError. Subclasses should override
    this to provide validation logic.
    """
    if not self.editable:
        # Skip validation for non-editable fields.
        return
    if self._choices and value not in self.empty_values:
        for option_key, option_value in self.choices:
            if isinstance(option_value, (list, tuple)):
                # This is an optgroup, so look inside the group for
                # options.
                for optgroup_key, optgroup_value in option_value:
                    if value == optgroup_key:
                        return
            elif value == option_key:
                return
        raise exceptions.ValidationError(
            self.error_messages['invalid_choice'],
            code='invalid_choice',
            params={'value': value},
        )
    if value is None and not self.null:
        raise exceptions.ValidationError(self.error_messages['null'], code='null')
    if not self.blank and value in self.empty_values:
        raise exceptions.ValidationError(self.error_messages['blank'], code='blank')

def value_from_object(self, obj):
    """
    Returns the value of this field in the given model instance.
    """
    return getattr(obj, self.attname)

def value_to_string(self, obj):
    val = self._get_val_from_obj(obj)
    return '' if val is None else val.isoformat()

def __init__(self, *args, **kwargs):
    if not kwargs.has_key('null'):
        kwargs['null'] = True
    super(DateTimeField, self).__init__(*args, **normalize_field(kwargs))

def bind(self, fieldmapping, original, bound_field_class):
    return bound_field_class(self, fieldmapping, original)

def clean(self, value, model_instance):
    """
    Convert the value's type and run validation. Validation errors
    from to_python and validate are propagated. The correct value is
    returned if no error is raised.
    """
    value = self.to_python(value)
    self.validate(value, model_instance)
    self.run_validators(value)
    return value

def contribute_to_class(self, cls, name):
    super(DateField,self).contribute_to_class(cls, name)
    if not self.null:
        setattr(cls, 'get_next_by_%s' % self.name,
            curry(cls._get_next_or_previous_by_FIELD, field=self,
                  is_next=True))
        setattr(cls, 'get_previous_by_%s' % self.name,
            curry(cls._get_next_or_previous_by_FIELD, field=self,
                  is_next=False))

def db_type(self, connection):
    """
    Returns the database column data type for this field, for the provided
    connection.
    """
    # The default implementation of this method looks at the
    # backend-specific DATA_TYPES dictionary, looking up the field by its
    # "internal type".
    #
    # A Field class can implement the get_internal_type() method to specify
    # which *preexisting* Django Field class it's most similar to -- i.e.,
    # a custom field might be represented by a TEXT column type, which is
    # the same as the TextField Django field type, which means the custom
    # field's get_internal_type() returns 'TextField'.
    #
    # But the limitation of the get_internal_type() / data_types approach
    # is that it cannot handle database column types that aren't already
    # mapped to one of the built-in Django field types. In this case, you
    # can implement db_type() instead of get_internal_type() to specify
    # exactly which wacky database column type you want to use.
    data = DictWrapper(self.__dict__, connection.ops.quote_name, "qn_")
    try:
        return (connection.creation.data_types[self.get_internal_type()]
                % data)
    except KeyError:
        return None

def formfield(self, **kwargs):
    defaults = {'form_class': forms.DateTimeField}
    defaults.update(kwargs)
    return super(DateTimeField, self).formfield(**defaults)

def get_attname(self):
    return self.name

def get_attname_column(self):
    attname = self.get_attname()
    column = self.db_column or attname
    return attname, column

def get_cache_name(self):
    return '_%s_cache' % self.name

def get_choices(self, include_blank=True, blank_choice=BLANK_CHOICE_DASH):
    """Returns choices with a default blank choices included, for use
    as SelectField choices for this field."""
    first_choice = blank_choice if include_blank else []
    if self.choices:
        return first_choice + list(self.choices)
    rel_model = self.rel.to
    if hasattr(self.rel, 'get_related_field'):
        lst = [(getattr(x, self.rel.get_related_field().attname),
                    smart_text(x))
               for x in rel_model._default_manager.complex_filter(
                   self.rel.limit_choices_to)]
    else:
        lst = [(x._get_pk_val(), smart_text(x))
               for x in rel_model._default_manager.complex_filter(
                   self.rel.limit_choices_to)]
    return first_choice + lst