Made all type filters case-insensitive for all backends

flask_admin/contrib/mongoengine/filters.py

@@ -92,10 +92,10 @@ class FilterEmpty(BaseMongoEngineFilter, filters.BaseBooleanFilter):
         else:
             flt = {'%s__ne' % self.column.name: None}
         return query.filter(**flt)
-        
+
     def operation(self):
         return lazy_gettext('empty')
-        
+
 
 class FilterInList(BaseMongoEngineFilter):
     def __init__(self, column, name, options=None, data_type=None):
@@ -103,23 +103,23 @@ class FilterInList(BaseMongoEngineFilter):
 
     def clean(self, value):
         return [v.strip() for v in value.split(',') if v.strip()]
-        
+
     def apply(self, query, value):
         flt = {'%s__in' % self.column.name: value}
         return query.filter(**flt)
-        
+
     def operation(self):
         return lazy_gettext('in list')
-        
+
 
 class FilterNotInList(FilterInList):
     def apply(self, query, value):
         flt = {'%s__nin' % self.column.name: value}
         return query.filter(**flt)
-    
+
     def operation(self):
         return lazy_gettext('not in list')
-        
+
 
 # Customized type filters
 class BooleanEqualFilter(FilterEqual, filters.BaseBooleanFilter):
@@ -132,95 +132,95 @@ class BooleanNotEqualFilter(FilterNotEqual, filters.BaseBooleanFilter):
     def apply(self, query, value):
         flt = {'%s' % self.column.name: value != '1'}
         return query.filter(**flt)
-        
+
 
 class IntEqualFilter(FilterEqual, filters.BaseIntFilter):
     pass
-    
+
 
 class IntNotEqualFilter(FilterNotEqual, filters.BaseIntFilter):
     pass
-    
+
 
 class IntGreaterFilter(FilterGreater, filters.BaseIntFilter):
     pass
-    
+
 
 class IntSmallerFilter(FilterSmaller, filters.BaseIntFilter):
     pass
-    
+
 
 class IntInListFilter(filters.BaseIntListFilter, FilterInList):
     pass
-    
+
 
 class IntNotInListFilter(filters.BaseIntListFilter, FilterNotInList):
     pass
-    
+
 
 class FloatEqualFilter(FilterEqual, filters.BaseFloatFilter):
     pass
-    
+
 
 class FloatNotEqualFilter(FilterNotEqual, filters.BaseFloatFilter):
     pass
-    
+
 
 class FloatGreaterFilter(FilterGreater, filters.BaseFloatFilter):
     pass
-    
+
 
 class FloatSmallerFilter(FilterSmaller, filters.BaseFloatFilter):
     pass
-    
+
 
 class FloatInListFilter(filters.BaseFloatListFilter, FilterInList):
     pass
-    
+
 
 class FloatNotInListFilter(filters.BaseFloatListFilter, FilterNotInList):
     pass
-    
+
 
 class DateTimeEqualFilter(FilterEqual, filters.BaseDateTimeFilter):
     pass
-    
+
 
 class DateTimeNotEqualFilter(FilterNotEqual, filters.BaseDateTimeFilter):
     pass
-    
+
 
 class DateTimeGreaterFilter(FilterGreater, filters.BaseDateTimeFilter):
     pass
-        
+
 
 class DateTimeSmallerFilter(FilterSmaller, filters.BaseDateTimeFilter):
     pass
-    
+
 
 class DateTimeBetweenFilter(BaseMongoEngineFilter, filters.BaseDateTimeBetweenFilter):
     def __init__(self, column, name, options=None, data_type=None):
         super(DateTimeBetweenFilter, self).__init__(column,
-                                                    name, 
+                                                    name,
                                                     options,
                                                     data_type='datetimerangepicker')
-                                                    
+
     def apply(self, query, value):
         start, end = value
         flt = {'%s__gte' % self.column.name: start, '%s__lte' % self.column.name: end}
         return query.filter(**flt)
-        
+
 
 class DateTimeNotBetweenFilter(DateTimeBetweenFilter):
     def apply(self, query, value):
         start, end = value
-        return query.filter(Q(**{'%s__not__gte' % self.column.name: start}) | 
+        return query.filter(Q(**{'%s__not__gte' % self.column.name: start}) |
                             Q(**{'%s__not__lte' % self.column.name: end}))
 
     def operation(self):
         return lazy_gettext('not between')
-        
-        
+
+
 # Base peewee filter field converter
 class FilterConverter(filters.BaseFilterConverter):
     strings = (FilterEqual, FilterNotEqual, FilterLike, FilterNotLike,
@@ -229,17 +229,19 @@ class FilterConverter(filters.BaseFilterConverter):
                    IntSmallerFilter, FilterEmpty, IntInListFilter,
                    IntNotInListFilter)
     float_filters = (FloatEqualFilter, FloatNotEqualFilter, FloatGreaterFilter,
-                     FloatSmallerFilter, FilterEmpty, FloatInListFilter, 
+                     FloatSmallerFilter, FilterEmpty, FloatInListFilter,
                      FloatNotInListFilter)
     bool_filters = (BooleanEqualFilter, BooleanNotEqualFilter)
-    datetime_filters = (DateTimeEqualFilter, DateTimeNotEqualFilter, 
+    datetime_filters = (DateTimeEqualFilter, DateTimeNotEqualFilter,
                         DateTimeGreaterFilter, DateTimeSmallerFilter,
-                        DateTimeBetweenFilter, DateTimeNotBetweenFilter, 
+                        DateTimeBetweenFilter, DateTimeNotBetweenFilter,
                         FilterEmpty)
 
     def convert(self, type_name, column, name):
-        if type_name in self.converters:
-            return self.converters[type_name](column, name)
+        filter_name = type_name.lower()
+
+        if filter_name in self.converters:
+            return self.converters[filter_name](column, name)
 
         return None
 
@@ -254,11 +256,11 @@ class FilterConverter(filters.BaseFilterConverter):
     @filters.convert('IntField', 'LongField')
     def conv_int(self, column, name):
         return [f(column, name) for f in self.int_filters]
-        
+
     @filters.convert('DecimalField', 'FloatField')
     def conv_float(self, column, name):
         return [f(column, name) for f in self.float_filters]
-        
+
     @filters.convert('DateTimeField', 'ComplexDateTimeField')
     def conv_datetime(self, column, name):
         return [f(column, name) for f in self.datetime_filters]

flask_admin/contrib/peewee/filters.py

@@ -89,7 +89,7 @@ class FilterEmpty(BasePeeweeFilter, filters.BaseBooleanFilter):
 
     def operation(self):
         return lazy_gettext('empty')
-        
+
 
 class FilterInList(BasePeeweeFilter):
     def __init__(self, column, name, options=None, data_type=None):
@@ -97,144 +97,144 @@ class FilterInList(BasePeeweeFilter):
 
     def clean(self, value):
         return [v.strip() for v in value.split(',') if v.strip()]
-        
+
     def apply(self, query, value):
         return query.filter(self.column << value)
-    
+
     def operation(self):
         return lazy_gettext('in list')
-        
+
 
 class FilterNotInList(FilterInList):
     def apply(self, query, value):
         # NOT IN can exclude NULL values, so "or_ == None" needed to be added
         return query.filter(~(self.column << value) | (self.column >> None))
-    
+
     def operation(self):
         return lazy_gettext('not in list')
-        
-        
+
+
 # Customized type filters
 class BooleanEqualFilter(FilterEqual, filters.BaseBooleanFilter):
     pass
-    
+
 
 class BooleanNotEqualFilter(FilterNotEqual, filters.BaseBooleanFilter):
     pass
-    
+
 
 class IntEqualFilter(FilterEqual, filters.BaseIntFilter):
     pass
-    
+
 
 class IntNotEqualFilter(FilterNotEqual, filters.BaseIntFilter):
     pass
-    
+
 
 class IntGreaterFilter(FilterGreater, filters.BaseIntFilter):
     pass
-    
+
 
 class IntSmallerFilter(FilterSmaller, filters.BaseIntFilter):
     pass
-    
+
 
 class IntInListFilter(filters.BaseIntListFilter, FilterInList):
     pass
-    
+
 
 class IntNotInListFilter(filters.BaseIntListFilter, FilterNotInList):
     pass
-    
+
 
 class FloatEqualFilter(FilterEqual, filters.BaseFloatFilter):
     pass
-    
+
 
 class FloatNotEqualFilter(FilterNotEqual, filters.BaseFloatFilter):
     pass
-    
+
 
 class FloatGreaterFilter(FilterGreater, filters.BaseFloatFilter):
     pass
-    
+
 
 class FloatSmallerFilter(FilterSmaller, filters.BaseFloatFilter):
     pass
-    
+
 
 class FloatInListFilter(filters.BaseFloatListFilter, FilterInList):
     pass
-    
+
 
 class FloatNotInListFilter(filters.BaseFloatListFilter, FilterNotInList):
     pass
-    
+
 
 class DateEqualFilter(FilterEqual, filters.BaseDateFilter):
     pass
-    
-    
+
+
 class DateNotEqualFilter(FilterNotEqual, filters.BaseDateFilter):
     pass
-    
+
 
 class DateGreaterFilter(FilterGreater, filters.BaseDateFilter):
     pass
-    
+
 
 class DateSmallerFilter(FilterSmaller, filters.BaseDateFilter):
     pass
-    
+
 
 class DateBetweenFilter(BasePeeweeFilter, filters.BaseDateBetweenFilter):
     def __init__(self, column, name, options=None, data_type=None):
         super(DateBetweenFilter, self).__init__(column,
-                                                name, 
+                                                name,
                                                 options,
                                                 data_type='daterangepicker')
-                                                
+
     def apply(self, query, value):
         start, end = value
-        return query.filter(self.column.between(start, end))   
-        
+        return query.filter(self.column.between(start, end))
+
 
 class DateNotBetweenFilter(DateBetweenFilter):
     def apply(self, query, value):
         start, end = value
         return query.filter(~(self.column.between(start, end)))
-        
+
     def operation(self):
         return lazy_gettext('not between')
-        
-            
+
+
 class DateTimeEqualFilter(FilterEqual, filters.BaseDateTimeFilter):
     pass
-        
+
 
 class DateTimeNotEqualFilter(FilterNotEqual, filters.BaseDateTimeFilter):
     pass
-        
+
 
 class DateTimeGreaterFilter(FilterGreater, filters.BaseDateTimeFilter):
     pass
-        
+
 
 class DateTimeSmallerFilter(FilterSmaller, filters.BaseDateTimeFilter):
     pass
-        
+
 
 class DateTimeBetweenFilter(BasePeeweeFilter, filters.BaseDateTimeBetweenFilter):
     def __init__(self, column, name, options=None, data_type=None):
         super(DateTimeBetweenFilter, self).__init__(column,
-                                                    name, 
+                                                    name,
                                                     options,
                                                     data_type='datetimerangepicker')
-                                                    
+
     def apply(self, query, value):
         start, end = value
         return query.filter(self.column.between(start, end))
-            
+
 
 class DateTimeNotBetweenFilter(DateTimeBetweenFilter):
     def apply(self, query, value):
@@ -243,45 +243,45 @@ class DateTimeNotBetweenFilter(DateTimeBetweenFilter):
 
     def operation(self):
         return lazy_gettext('not between')
-        
+
 
 class TimeEqualFilter(FilterEqual, filters.BaseTimeFilter):
     pass
-    
+
 
 class TimeNotEqualFilter(FilterNotEqual, filters.BaseTimeFilter):
     pass
-    
+
 
 class TimeGreaterFilter(FilterGreater, filters.BaseTimeFilter):
     pass
-    
+
 
 class TimeSmallerFilter(FilterSmaller, filters.BaseTimeFilter):
     pass
-    
+
 
 class TimeBetweenFilter(BasePeeweeFilter, filters.BaseTimeBetweenFilter):
     def __init__(self, column, name, options=None, data_type=None):
         super(TimeBetweenFilter, self).__init__(column,
-                                                name, 
+                                                name,
                                                 options,
                                                 data_type='timerangepicker')
-                                                
+
     def apply(self, query, value):
         start, end = value
         return query.filter(self.column.between(start, end))
-        
+
 
 class TimeNotBetweenFilter(TimeBetweenFilter):
     def apply(self, query, value):
         start, end = value
         return query.filter(~(self.column.between(start, end)))
-        
+
     def operation(self):
         return lazy_gettext('not between')
-        
-        
+
+
 # Base peewee filter field converter
 class FilterConverter(filters.BaseFilterConverter):
     strings = (FilterEqual, FilterNotEqual, FilterLike, FilterNotLike,
@@ -290,23 +290,25 @@ class FilterConverter(filters.BaseFilterConverter):
                    IntSmallerFilter, FilterEmpty, IntInListFilter,
                    IntNotInListFilter)
     float_filters = (FloatEqualFilter, FloatNotEqualFilter, FloatGreaterFilter,
-                     FloatSmallerFilter, FilterEmpty, FloatInListFilter, 
+                     FloatSmallerFilter, FilterEmpty, FloatInListFilter,
                      FloatNotInListFilter)
     bool_filters = (BooleanEqualFilter, BooleanNotEqualFilter)
     date_filters = (DateEqualFilter, DateNotEqualFilter, DateGreaterFilter,
                     DateSmallerFilter, DateBetweenFilter, DateNotBetweenFilter,
                     FilterEmpty)
     datetime_filters = (DateTimeEqualFilter, DateTimeNotEqualFilter,
-                        DateTimeGreaterFilter, DateTimeSmallerFilter, 
-                        DateTimeBetweenFilter, DateTimeNotBetweenFilter, 
+                        DateTimeGreaterFilter, DateTimeSmallerFilter,
+                        DateTimeBetweenFilter, DateTimeNotBetweenFilter,
                         FilterEmpty)
     time_filters = (TimeEqualFilter, TimeNotEqualFilter, TimeGreaterFilter,
                     TimeSmallerFilter, TimeBetweenFilter, TimeNotBetweenFilter,
                     FilterEmpty)
 
     def convert(self, type_name, column, name):
-        if type_name in self.converters:
-            return self.converters[type_name](column, name)
+        filter_name = type_name.lower()
+
+        if filter_name in self.converters:
+            return self.converters[filter_name](column, name)
 
         return None
 
@@ -321,11 +323,11 @@ class FilterConverter(filters.BaseFilterConverter):
     @filters.convert('IntegerField', 'BigIntegerField')
     def conv_int(self, column, name):
         return [f(column, name) for f in self.int_filters]
-        
+
     @filters.convert('DecimalField', 'FloatField', 'DoubleField')
     def conv_float(self, column, name):
         return [f(column, name) for f in self.float_filters]
-        
+
     @filters.convert('DateField')
     def conv_date(self, column, name):
         return [f(column, name) for f in self.date_filters]
@@ -333,7 +335,7 @@ class FilterConverter(filters.BaseFilterConverter):
     @filters.convert('DateTimeField')
     def conv_datetime(self, column, name):
         return [f(column, name) for f in self.datetime_filters]
-    
+
     @filters.convert('TimeField')
     def conv_time(self, column, name):
-        return [f(column, name) for f in self.time_filters]
+        return [f(column, name) for f in self.time_filters]
\ No newline at end of file

flask_admin/contrib/sqla/filters.py

@@ -89,7 +89,7 @@ class FilterEmpty(BaseSQLAFilter, filters.BaseBooleanFilter):
 
     def operation(self):
         return lazy_gettext('empty')
-        
+
 
 class FilterInList(BaseSQLAFilter):
     def __init__(self, column, name, options=None, data_type=None):
@@ -97,145 +97,145 @@ class FilterInList(BaseSQLAFilter):
 
     def clean(self, value):
         return [v.strip() for v in value.split(',') if v.strip()]
-        
+
     def apply(self, query, value):
         return query.filter(self.column.in_(value))
-    
+
     def operation(self):
         return lazy_gettext('in list')
-        
+
 
 class FilterNotInList(FilterInList):
     def apply(self, query, value):
         # NOT IN can exclude NULL values, so "or_ == None" needed to be added
         return query.filter(or_(~self.column.in_(value), self.column == None))
-    
+
     def operation(self):
         return lazy_gettext('not in list')
-        
+
 
 # Customized type filters
 class BooleanEqualFilter(FilterEqual, filters.BaseBooleanFilter):
     pass
-    
+
 
 class BooleanNotEqualFilter(FilterNotEqual, filters.BaseBooleanFilter):
     pass
-    
+
 
 class IntEqualFilter(FilterEqual, filters.BaseIntFilter):
     pass
-    
+
 
 class IntNotEqualFilter(FilterNotEqual, filters.BaseIntFilter):
     pass
-    
+
 
 class IntGreaterFilter(FilterGreater, filters.BaseIntFilter):
     pass
-    
+
 
 class IntSmallerFilter(FilterSmaller, filters.BaseIntFilter):
     pass
-    
+
 
 class IntInListFilter(filters.BaseIntListFilter, FilterInList):
     pass
-    
+
 
 class IntNotInListFilter(filters.BaseIntListFilter, FilterNotInList):
     pass
-    
+
 
 class FloatEqualFilter(FilterEqual, filters.BaseFloatFilter):
     pass
-    
+
 
 class FloatNotEqualFilter(FilterNotEqual, filters.BaseFloatFilter):
     pass
-    
+
 
 class FloatGreaterFilter(FilterGreater, filters.BaseFloatFilter):
     pass
-    
+
 
 class FloatSmallerFilter(FilterSmaller, filters.BaseFloatFilter):
     pass
-    
+
 
 class FloatInListFilter(filters.BaseFloatListFilter, FilterInList):
     pass
-    
+
 
 class FloatNotInListFilter(filters.BaseFloatListFilter, FilterNotInList):
     pass
-    
+
 
 class DateEqualFilter(FilterEqual, filters.BaseDateFilter):
     pass
 
-    
+
 class DateNotEqualFilter(FilterNotEqual, filters.BaseDateFilter):
     pass
-        
+
 
 class DateGreaterFilter(FilterGreater, filters.BaseDateFilter):
     pass
-        
+
 
 class DateSmallerFilter(FilterSmaller, filters.BaseDateFilter):
     pass
-        
+
 
 class DateBetweenFilter(BaseSQLAFilter, filters.BaseDateBetweenFilter):
     def __init__(self, column, name, options=None, data_type=None):
         super(DateBetweenFilter, self).__init__(column,
-                                                name, 
+                                                name,
                                                 options,
                                                 data_type='daterangepicker')
-                                                
+
     def apply(self, query, value):
         start, end = value
         return query.filter(self.column.between(start, end))
-        
+
 
 class DateNotBetweenFilter(DateBetweenFilter):
     def apply(self, query, value):
         start, end = value
         # ~between() isn't possible until sqlalchemy 1.0.0
         return query.filter(not_(self.column.between(start, end)))
-        
+
     def operation(self):
         return lazy_gettext('not between')
-        
-            
+
+
 class DateTimeEqualFilter(FilterEqual, filters.BaseDateTimeFilter):
     pass
-        
+
 
 class DateTimeNotEqualFilter(FilterNotEqual, filters.BaseDateTimeFilter):
     pass
-        
+
 
 class DateTimeGreaterFilter(FilterGreater, filters.BaseDateTimeFilter):
     pass
-        
+
 
 class DateTimeSmallerFilter(FilterSmaller, filters.BaseDateTimeFilter):
     pass
-        
+
 
 class DateTimeBetweenFilter(BaseSQLAFilter, filters.BaseDateTimeBetweenFilter):
     def __init__(self, column, name, options=None, data_type=None):
         super(DateTimeBetweenFilter, self).__init__(column,
-                                                    name, 
+                                                    name,
                                                     options,
                                                     data_type='datetimerangepicker')
-                                                    
+
     def apply(self, query, value):
         start, end = value
         return query.filter(self.column.between(start, end))
-            
+
 
 class DateTimeNotBetweenFilter(DateTimeBetweenFilter):
     def apply(self, query, value):
@@ -244,45 +244,45 @@ class DateTimeNotBetweenFilter(DateTimeBetweenFilter):
 
     def operation(self):
         return lazy_gettext('not between')
-        
+
 
 class TimeEqualFilter(FilterEqual, filters.BaseTimeFilter):
     pass
-    
+
 
 class TimeNotEqualFilter(FilterNotEqual, filters.BaseTimeFilter):
     pass
-    
+
 
 class TimeGreaterFilter(FilterGreater, filters.BaseTimeFilter):
     pass
-    
+
 
 class TimeSmallerFilter(FilterSmaller, filters.BaseTimeFilter):
     pass
-    
+
 
 class TimeBetweenFilter(BaseSQLAFilter, filters.BaseTimeBetweenFilter):
     def __init__(self, column, name, options=None, data_type=None):
         super(TimeBetweenFilter, self).__init__(column,
-                                                name, 
+                                                name,
                                                 options,
                                                 data_type='timerangepicker')
-                                                
+
     def apply(self, query, value):
         start, end = value
         return query.filter(self.column.between(start, end))
-        
+
 
 class TimeNotBetweenFilter(TimeBetweenFilter):
     def apply(self, query, value):
         start, end = value
         return query.filter(not_(self.column.between(start, end)))
-        
+
     def operation(self):
         return lazy_gettext('not between')
-        
-            
+
+
 # Base SQLA filter field converter
 class FilterConverter(filters.BaseFilterConverter):
     strings = (FilterEqual, FilterNotEqual, FilterLike, FilterNotLike,
@@ -291,7 +291,7 @@ class FilterConverter(filters.BaseFilterConverter):
                    IntSmallerFilter, FilterEmpty, IntInListFilter,
                    IntNotInListFilter)
     float_filters = (FloatEqualFilter, FloatNotEqualFilter, FloatGreaterFilter,
-                     FloatSmallerFilter, FilterEmpty, FloatInListFilter, 
+                     FloatSmallerFilter, FilterEmpty, FloatInListFilter,
                      FloatNotInListFilter)
     bool_filters = (BooleanEqualFilter, BooleanNotEqualFilter)
     enum = (FilterEqual, FilterNotEqual, FilterEmpty, FilterInList,
@@ -306,43 +306,46 @@ class FilterConverter(filters.BaseFilterConverter):
     time_filters = (TimeEqualFilter, TimeNotEqualFilter, TimeGreaterFilter,
                     TimeSmallerFilter, TimeBetweenFilter, TimeNotBetweenFilter,
                     FilterEmpty)
-            
+
     def convert(self, type_name, column, name, **kwargs):
-        if type_name.lower() in self.converters:
-            return self.converters[type_name.lower()](column, name, **kwargs)
+        filter_name = type_name.lower()
+
+        if filter_name in self.converters:
+            return self.converters[filter_name](column, name, **kwargs)
+
         return None
-        
+
     @filters.convert('string', 'char', 'unicode', 'varchar', 'tinytext',
                      'text', 'mediumtext', 'longtext', 'unicodetext',
                      'nchar', 'nvarchar', 'ntext')
     def conv_string(self, column, name, **kwargs):
         return [f(column, name, **kwargs) for f in self.strings]
-        
+
     @filters.convert('boolean', 'tinyint')
     def conv_bool(self, column, name, **kwargs):
         return [f(column, name, **kwargs) for f in self.bool_filters]
-        
+
     @filters.convert('int', 'integer', 'smallinteger', 'smallint', 'numeric',
                      'biginteger', 'bigint', 'mediumint')
     def conv_int(self, column, name, **kwargs):
         return [f(column, name, **kwargs) for f in self.int_filters]
-        
+
     @filters.convert('float', 'real', 'decimal', 'double_precision', 'double')
     def conv_float(self, column, name, **kwargs):
         return [f(column, name, **kwargs) for f in self.float_filters]
-        
+
     @filters.convert('date')
     def conv_date(self, column, name, **kwargs):
         return [f(column, name, **kwargs) for f in self.date_filters]
-        
+
     @filters.convert('datetime', 'datetime2', 'timestamp', 'smalldatetime')
     def conv_datetime(self, column, name, **kwargs):
         return [f(column, name, **kwargs) for f in self.datetime_filters]
-        
+
     @filters.convert('time')
     def conv_time(self, column, name, **kwargs):
         return [f(column, name, **kwargs) for f in self.time_filters]
-        
+
     @filters.convert('enum')
     def conv_enum(self, column, name, options=None, **kwargs):
         if not options:

flask_admin/model/filters.py

@@ -48,7 +48,7 @@ class BaseFilter(object):
             Validate value.
 
             If value is valid, returns `True` and `False` otherwise.
-            
+
             :param value:
                 Value to validate
         """
@@ -102,7 +102,7 @@ class BaseBooleanFilter(BaseFilter):
 
     def validate(self, value):
         return value in ('0', '1')
-        
+
 
 class BaseIntFilter(BaseFilter):
     """
@@ -110,7 +110,7 @@ class BaseIntFilter(BaseFilter):
     """
     def clean(self, value):
         return int(float(value))
-            
+
 
 class BaseFloatFilter(BaseFilter):
     """
@@ -118,7 +118,7 @@ class BaseFloatFilter(BaseFilter):
     """
     def clean(self, value):
         return float(value)
-            
+
 
 class BaseIntListFilter(BaseFilter):
     """
@@ -126,7 +126,7 @@ class BaseIntListFilter(BaseFilter):
     """
     def clean(self, value):
         return [int(float(v.strip())) for v in value.split(',') if v.strip()]
-        
+
 
 class BaseFloatListFilter(BaseFilter):
     """
@@ -134,7 +134,7 @@ class BaseFloatListFilter(BaseFilter):
     """
     def clean(self, value):
         return [float(v.strip()) for v in value.split(',') if v.strip()]
-        
+
 
 class BaseDateFilter(BaseFilter):
     """
@@ -144,10 +144,10 @@ class BaseDateFilter(BaseFilter):
         super(BaseDateFilter, self).__init__(name,
                                              options,
                                              data_type='datepicker')
-                                             
+
     def clean(self, value):
         return datetime.datetime.strptime(value, '%Y-%m-%d').date()
-        
+
 
 class BaseDateBetweenFilter(BaseFilter):
     """
@@ -163,16 +163,16 @@ class BaseDateBetweenFilter(BaseFilter):
 
     def validate(self, value):
         try:
-            value = [datetime.datetime.strptime(range, '%Y-%m-%d') 
+            value = [datetime.datetime.strptime(range, '%Y-%m-%d')
                      for range in value.split(' to ')]
             # if " to " is missing, fail validation
             # sqlalchemy's .between() will not work if end date is before start date
             if (len(value) == 2) and (value[0] <= value[1]):
                 return True
             else:
-                return False        
+                return False
         except ValueError:
-            return False   
+            return False
 
 
 class BaseDateTimeFilter(BaseFilter):
@@ -183,27 +183,27 @@ class BaseDateTimeFilter(BaseFilter):
         super(BaseDateTimeFilter, self).__init__(name,
                                                  options,
                                                  data_type='datetimepicker')
-                                                 
+
     def clean(self, value):
         # datetime filters will not work in SQLite + SQLAlchemy if value not converted to datetime
         return datetime.datetime.strptime(value, '%Y-%m-%d %H:%M:%S')
-        
+
 
 class BaseDateTimeBetweenFilter(BaseFilter):
     """
         Base DateTime Between filter. Consolidates logic for validation and clean.
         Apply method is different for each back-end.
-    """        
+    """
     def clean(self, value):
-        return [datetime.datetime.strptime(range, '%Y-%m-%d %H:%M:%S') 
+        return [datetime.datetime.strptime(range, '%Y-%m-%d %H:%M:%S')
                 for range in value.split(' to ')]
-    
+
     def operation(self):
         return lazy_gettext('between')
-        
+
     def validate(self, value):
         try:
-            value = [datetime.datetime.strptime(range, '%Y-%m-%d %H:%M:%S') 
+            value = [datetime.datetime.strptime(range, '%Y-%m-%d %H:%M:%S')
                      for range in value.split(' to ')]
             if (len(value) == 2) and (value[0] <= value[1]):
                 return True
@@ -211,7 +211,7 @@ class BaseDateTimeBetweenFilter(BaseFilter):
                 return False
         except ValueError:
             return False
-        
+
 
 class BaseTimeFilter(BaseFilter):
     """
@@ -221,14 +221,14 @@ class BaseTimeFilter(BaseFilter):
         super(BaseTimeFilter, self).__init__(name,
                                              options,
                                              data_type='timepicker')
-                                             
+
     def clean(self, value):
         # time filters will not work in SQLite + SQLAlchemy if value not converted to time
         timetuple = time.strptime(value, '%H:%M:%S')
         return datetime.time(timetuple.tm_hour,
                              timetuple.tm_min,
                              timetuple.tm_sec)
-                             
+
 
 class BaseTimeBetweenFilter(BaseFilter):
     """
@@ -236,7 +236,7 @@ class BaseTimeBetweenFilter(BaseFilter):
         Apply method is different for each back-end.
     """
     def clean(self, value):
-        timetuples = [time.strptime(range, '%H:%M:%S') 
+        timetuples = [time.strptime(range, '%H:%M:%S')
                       for range in value.split(' to ')]
         return [datetime.time(timetuple.tm_hour,
                               timetuple.tm_min,
@@ -248,7 +248,7 @@ class BaseTimeBetweenFilter(BaseFilter):
 
     def validate(self, value):
         try:
-            timetuples = [time.strptime(range, '%H:%M:%S') 
+            timetuples = [time.strptime(range, '%H:%M:%S')
                           for range in value.split(' to ')]
             if (len(timetuples) == 2) and (timetuples[0] <= timetuples[1]):
                 return True
@@ -257,7 +257,7 @@ class BaseTimeBetweenFilter(BaseFilter):
         except ValueError:
             raise
             return False
-            
+
 
 def convert(*args):
     """
@@ -266,7 +266,7 @@ def convert(*args):
         See :mod:`flask.ext.admin.contrib.sqla.filters` for usage example.
     """
     def _inner(func):
-        func._converter_for = args
+        func._converter_for = map(str.lower, args)
         return func
     return _inner