BUG: Validate float_format setting as callable or None

The `float_format` setting takes either None or a callable object
that returns a formatted string given a float value. Currently, the
setting isn't validated, so cryptic error messages are returned
if, for example, a format non-callable format string is given (see
\pandas-dev#12704). Add a standard validation method and use it to validate
the `float_format` setting.

closes pandas-dev#12706
closes pandas-dev#12711

Author: tdhopper

doc/source/whatsnew/v0.18.1.txt

@@ -124,6 +124,7 @@ Bug Fixes
 - Bug in numpy compatibility of ``np.round()`` on a ``Series`` (:issue:`12600`)
 - Bug in ``Series`` construction with ``Categorical`` and ``dtype='category'`` is specified (:issue:`12574`)
 - Bugs in concatenation with a coercable dtype was too aggressive. (:issue:`12411`, :issue:`12045`, :issue:`11594`, :issue:`10571`)
+- Bug in ``float_format`` option with option not being validated as a callable. (:issue:`12706`)
 
 
 
@@ -167,4 +168,4 @@ Bug Fixes
 
 
 - Bug in ``pivot_table`` when ``margins=True`` and ``dropna=True`` where nulls still contributed to margin count (:issue:`12577`)
-- Bug in ``Series.name`` when ``name`` attribute can be a hashable type (:issue:`12610`)
+- Bug in ``Series.name`` when ``name`` attribute can be a hashable type (:issue:`12610`)

pandas/core/config.py

@@ -786,12 +786,20 @@ def inner(x):
 
 
 def is_one_of_factory(legal_values):
+
+    callables = [c for c in legal_values if callable(c)]
+    legal_values = [c for c in legal_values if not callable(c)]
+
     def inner(x):
         from pandas.core.common import pprint_thing as pp
         if x not in legal_values:
-            pp_values = lmap(pp, legal_values)
-            raise ValueError("Value must be one of %s" %
-                             pp("|".join(pp_values)))
+
+            if not any([c(x) for c in callables]):
+                pp_values = pp("|".join(lmap(pp, legal_values)))
+                msg = "Value must be one of {0}".format(pp_values)
+                if len(callables):
+                    msg += " or a callable"
+                raise ValueError(msg)
 
     return inner
 
@@ -803,3 +811,21 @@ def inner(x):
 is_str = is_type_factory(str)
 is_unicode = is_type_factory(compat.text_type)
 is_text = is_instance_factory((str, bytes))
+
+
+def is_callable(obj):
+    """
+
+    Parameters
+    ----------
+    `obj` - the object to be checked
+
+    Returns
+    -------
+    validator - returns True if object is callable
+        raises ValueError otherwise.
+
+    """
+    if not callable(obj):
+        raise ValueError("Value must be a callable")
+    return True

pandas/core/config_init.py

@@ -13,7 +13,8 @@
 
 import pandas.core.config as cf
 from pandas.core.config import (is_int, is_bool, is_text, is_instance_factory,
-                                is_one_of_factory, get_default_val)
+                                is_one_of_factory, get_default_val,
+                                is_callable)
 from pandas.core.format import detect_console_encoding
 
 #
@@ -279,7 +280,8 @@ def mpl_style_cb(key):
 
 with cf.config_prefix('display'):
     cf.register_option('precision', 6, pc_precision_doc, validator=is_int)
-    cf.register_option('float_format', None, float_format_doc)
+    cf.register_option('float_format', None, float_format_doc,
+                       validator=is_one_of_factory([None, is_callable]))
     cf.register_option('column_space', 12, validator=is_int)
     cf.register_option('max_info_rows', 1690785, pc_max_info_rows_doc,
                        validator=is_instance_factory((int, type(None))))

pandas/tests/test_config.py

@@ -206,6 +206,13 @@ def test_validation(self):
         self.assertRaises(ValueError, self.cf.set_option, 'a', 'ab')
         self.assertRaises(ValueError, self.cf.set_option, 'b.c', 1)
 
+        validator = self.cf.is_one_of_factory([None, self.cf.is_callable])
+        self.cf.register_option('b', lambda: None, 'doc',
+                                validator=validator)
+        self.cf.set_option('b', '%.1f'.format)  # Formatter is callable
+        self.cf.set_option('b', None)  # Formatter is none (default)
+        self.assertRaises(ValueError, self.cf.set_option, 'b', '%.1f')
+
     def test_reset_option(self):
         self.cf.register_option('a', 1, 'doc', validator=self.cf.is_int)
         self.cf.register_option('b.c', 'hullo', 'doc2',