ENH: Migrate print_config usage to use core.config, register options on pkg load

Author: y-p

pandas/__init__.py

@@ -22,6 +22,9 @@
 from pandas.version import version as __version__
 from pandas.info import __doc__
 
+# let init-time option registration happen
+import pandas.core.config_init
+
 from pandas.core.api import *
 from pandas.sparse.api import *
 from pandas.stats.api import *

pandas/core/common.py

@@ -19,6 +19,8 @@
 
 from pandas.util.py3compat import StringIO, BytesIO
 
+from pandas.core.config import get_option
+
 # XXX: HACK for NumPy 1.5.1 to suppress warnings
 try:
     np.seterr(all='ignore')
@@ -1113,7 +1115,7 @@ def in_interactive_session():
 # 2) If you need to send something to the console, use console_encode().
 #
 #    console_encode() should (hopefully) choose the right encoding for you
-#    based on the encoding set in fmt.print_config.encoding.
+#    based on the encoding set in option "print_config.encoding"
 #
 # 3) if you need to write something out to file, use
 #    pprint_thing_encoded(encoding).
@@ -1165,16 +1167,17 @@ def pprint_thing(thing, _nest_lvl=0):
     result - unicode object on py2, str on py3. Always Unicode.
 
     """
-    from pandas.core.format import print_config
+
     if thing is None:
         result = ''
     elif (py3compat.PY3 and hasattr(thing,'__next__')) or \
          hasattr(thing,'next'):
         return unicode(thing)
     elif (isinstance(thing, dict) and
-          _nest_lvl < print_config.pprint_nest_depth):
+          _nest_lvl < get_option("print_config.pprint_nest_depth")):
         result = _pprint_dict(thing, _nest_lvl)
-    elif _is_sequence(thing) and _nest_lvl < print_config.pprint_nest_depth:
+    elif _is_sequence(thing) and _nest_lvl < \
+		get_option("print_config.pprint_nest_depth"):
         result = _pprint_seq(thing, _nest_lvl)
     else:
         # when used internally in the package, everything
@@ -1202,12 +1205,12 @@ def pprint_thing_encoded(object, encoding='utf-8', errors='replace'):
 
 
 def console_encode(object):
-    from pandas.core.format import print_config
     """
     this is the sanctioned way to prepare something for
     sending *to the console*, it delegates to pprint_thing() to get
     a unicode representation of the object relies on the global encoding
     set in print_config.encoding. Use this everywhere
     where you output to the console.
     """
-    return pprint_thing_encoded(object, print_config.encoding)
+    return pprint_thing_encoded(object,
+             get_option("print_config.encoding"))

pandas/core/format.py

@@ -11,7 +11,8 @@
 from pandas.core.common import adjoin, isnull, notnull
 from pandas.core.index import MultiIndex, _ensure_index
 from pandas.util import py3compat
-
+from pandas.core.config import get_option, set_option, \
+                               reset_options
 import pandas.core.common as com
 import pandas.lib as lib
 
@@ -69,7 +70,7 @@ def __init__(self, series, buf=None, header=True, length=True,
         self.header = header
 
         if float_format is None:
-            float_format = print_config.float_format
+            float_format = get_option("print_config.float_format")
         self.float_format = float_format
 
     def _get_footer(self):
@@ -145,11 +146,11 @@ def to_string(self):
     _strlen = len
 else:
     def _encode_diff(x):
-        return len(x) - len(x.decode(print_config.encoding))
+        return len(x) - len(x.decode(get_option("print_config.encoding")))
 
     def _strlen(x):
         try:
-            return len(x.decode(print_config.encoding))
+            return len(x.decode(get_option("print_config.encoding")))
         except UnicodeError:
             return len(x)
 
@@ -176,7 +177,7 @@ def __init__(self, frame, buf=None, columns=None, col_space=None,
         self.show_index_names = index_names
 
         if sparsify is None:
-            sparsify = print_config.multi_sparse
+            sparsify = get_option("print_config.multi_sparse")
 
         self.sparsify = sparsify
 
@@ -188,7 +189,7 @@ def __init__(self, frame, buf=None, columns=None, col_space=None,
         self.index = index
 
         if justify is None:
-            self.justify = print_config.colheader_justify
+            self.justify = get_option("print_config.colheader_justify")
         else:
             self.justify = justify
 
@@ -697,13 +698,13 @@ def format_array(values, formatter, float_format=None, na_rep='NaN',
         fmt_klass = GenericArrayFormatter
 
     if space is None:
-        space = print_config.column_space
+        space = get_option("print_config.column_space")
 
     if float_format is None:
-        float_format = print_config.float_format
+        float_format = get_option("print_config.float_format")
 
     if digits is None:
-        digits = print_config.precision
+        digits = get_option("print_config.precision")
 
     fmt_obj = fmt_klass(values, digits, na_rep=na_rep,
                         float_format=float_format,
@@ -739,9 +740,9 @@ def _have_unicode(self):
 
     def _format_strings(self, use_unicode=False):
         if self.float_format is None:
-            float_format = print_config.float_format
+            float_format = get_option("print_config.float_format")
             if float_format is None:
-                fmt_str = '%% .%dg' % print_config.precision
+                fmt_str = '%% .%dg' % get_option("print_config.precision")
                 float_format = lambda x: fmt_str % x
         else:
             float_format = self.float_format
@@ -863,7 +864,7 @@ def _make_fixed_width(strings, justify='right', minimum=None):
     if minimum is not None:
         max_len = max(minimum, max_len)
 
-    conf_max = print_config.max_colwidth
+    conf_max = get_option("print_config.max_colwidth")
     if conf_max is not None and max_len > conf_max:
         max_len = conf_max
 
@@ -974,34 +975,56 @@ def set_printoptions(precision=None, column_space=None, max_rows=None,
         elements in outer levels within groups)
     """
     if precision is not None:
-        print_config.precision = precision
+        set_option("print_config.precision", precision)
     if column_space is not None:
-        print_config.column_space = column_space
+        set_option("print_config.column_space", column_space)
     if max_rows is not None:
-        print_config.max_rows = max_rows
+        set_option("print_config.max_rows", max_rows)
     if max_colwidth is not None:
-        print_config.max_colwidth = max_colwidth
+        set_option("print_config.max_colwidth", max_colwidth)
     if max_columns is not None:
-        print_config.max_columns = max_columns
+        set_option("print_config.max_columns", max_columns)
     if colheader_justify is not None:
-        print_config.colheader_justify = colheader_justify
+        set_option("print_config.colheader_justify", colheader_justify)
     if notebook_repr_html is not None:
-        print_config.notebook_repr_html = notebook_repr_html
+        set_option("print_config.notebook_repr_html", notebook_repr_html)
     if date_dayfirst is not None:
-        print_config.date_dayfirst = date_dayfirst
+        set_option("print_config.date_dayfirst", date_dayfirst)
     if date_yearfirst is not None:
-        print_config.date_yearfirst = date_yearfirst
+        set_option("print_config.date_yearfirst", date_yearfirst)
     if pprint_nest_depth is not None:
-        print_config.pprint_nest_depth = pprint_nest_depth
+        set_option("print_config.pprint_nest_depth", pprint_nest_depth)
     if multi_sparse is not None:
-        print_config.multi_sparse = multi_sparse
+        set_option("print_config.multi_sparse", multi_sparse)
     if encoding is not None:
-        print_config.encoding = encoding
-
+        set_option("print_config.encoding", encoding)
 
 def reset_printoptions():
-    print_config.reset()
+    reset_options("print_config.")
+
+def detect_console_encoding():
+    """
+    Try to find the most capable encoding supported by the console.
+    slighly modified from the way IPython handles the same issue.
+    """
+    import locale
+
+    encoding = None
+    try:
+        encoding=sys.stdin.encoding
+    except AttributeError:
+        pass
 
+    if not encoding or encoding =='ascii': # try again for something better
+        try:
+            encoding = locale.getpreferredencoding()
+        except Exception:
+            pass
+
+    if not encoding: # when all else fails. this will usually be "ascii"
+            encoding = sys.getdefaultencoding()
+
+    return encoding
 
 class EngFormatter(object):
     """
@@ -1109,59 +1132,8 @@ def set_eng_float_format(precision=None, accuracy=3, use_eng_prefix=False):
                       "being renamed to 'accuracy'", FutureWarning)
         accuracy = precision
 
-    print_config.float_format = EngFormatter(accuracy, use_eng_prefix)
-    print_config.column_space = max(12, accuracy + 9)
-
-
-class _GlobalPrintConfig(object):
-    """
-    Holds the console formatting settings for DataFrame and friends
-    """
-
-    def __init__(self):
-        self.precision = self.digits = 7
-        self.float_format = None
-        self.column_space = 12
-        self.max_rows = 200
-        self.max_colwidth = 50
-        self.max_columns = 0
-        self.colheader_justify = 'right'
-        self.notebook_repr_html = True
-        self.date_dayfirst = False
-        self.date_yearfirst = False
-        self.pprint_nest_depth = 3
-        self.multi_sparse = True
-        self.encoding = self.detect_encoding()
-
-    def detect_encoding(self):
-        """
-        Try to find the most capable encoding supported by the console.
-        slighly modified from the way IPython handles the same issue.
-        """
-        import locale
-
-        encoding = None
-        try:
-            encoding = sys.stdin.encoding
-        except AttributeError:
-            pass
-
-        if not encoding or encoding == 'ascii':  # try again for better
-            try:
-                encoding = locale.getpreferredencoding()
-            except Exception:
-                pass
-
-        if not encoding:  # when all else fails. this will usually be "ascii"
-            encoding = sys.getdefaultencoding()
-
-        return encoding
-
-    def reset(self):
-        self.__init__()
-
-print_config = _GlobalPrintConfig()
-
+    set_option("print_config.float_format", EngFormatter(accuracy, use_eng_prefix))
+    set_option("print_config.column_space", max(12, accuracy + 9))
 
 def _put_lines(buf, lines):
     if any(isinstance(x, unicode) for x in lines):

pandas/core/frame.py

@@ -44,6 +44,8 @@
 import pandas.core.nanops as nanops
 import pandas.lib as lib
 
+from pandas.core.config import get_option
+
 #----------------------------------------------------------------------
 # Docstring templates
 
@@ -579,12 +581,11 @@ def _need_info_repr_(self):
         Check if it is needed to use info/summary view to represent a
         particular DataFrame.
         """
-        config = fmt.print_config
 
         terminal_width, terminal_height = get_terminal_size()
-        max_rows = (terminal_height if config.max_rows == 0
-                    else config.max_rows)
-        max_columns = config.max_columns
+        max_rows = (terminal_height if get_option("print_config.max_rows") == 0
+                    else get_option("print_config.max_rows"))
+        max_columns = get_option("print_config.max_columns")
 
         if max_columns > 0:
             if len(self.index) <= max_rows and \
@@ -628,7 +629,7 @@ def _repr_html_(self):
         Return a html representation for a particular DataFrame.
         Mainly for IPython notebook.
         """
-        if fmt.print_config.notebook_repr_html:
+        if get_option("print_config.notebook_repr_html"):
             if self._need_info_repr_():
                 return None
             else:

pandas/core/index.py

@@ -13,6 +13,7 @@
 import pandas._algos as _algos
 from pandas.lib import Timestamp
 from pandas.util import py3compat
+from pandas.core.config import get_option
 
 __all__ = ['Index']
 
@@ -1514,8 +1515,7 @@ def format(self, space=2, sparsify=None, adjoin=True, names=False,
             result_levels.append(level)
 
         if sparsify is None:
-            import pandas.core.format as fmt
-            sparsify = fmt.print_config.multi_sparse
+            sparsify = get_option("print_config.multi_sparse")
 
         if sparsify:
             # little bit of a kludge job for #1217

pandas/core/series.py

@@ -33,6 +33,7 @@
 from pandas.util.decorators import Appender, Substitution, cache_readonly
 
 from pandas.compat.scipy import scoreatpercentile as _quantile
+from pandas.core.config import get_option
 
 __all__ = ['Series', 'TimeSeries']
 
@@ -914,8 +915,8 @@ def reset_index(self, level=None, drop=False, name=None, inplace=False):
     def __repr__(self):
         """Clean string representation of a Series"""
         width, height = get_terminal_size()
-        max_rows = (height if fmt.print_config.max_rows == 0
-                    else fmt.print_config.max_rows)
+        max_rows = (height if get_option("print_config.max_rows") == 0
+                    else get_option("print_config.max_rows"))
         if len(self.index) > (max_rows or 1000):
             result = self._tidy_repr(min(30, max_rows - 4))
         elif len(self.index) > 0:

pandas/tests/test_format.py

@@ -19,6 +19,7 @@
 import pandas.util.testing as tm
 import pandas
 import pandas as pd
+from pandas.core.config import set_option,get_option
 
 _frame = DataFrame(tm.getSeriesData())
 
@@ -64,7 +65,7 @@ def test_repr_tuples(self):
 
     def test_repr_truncation(self):
         max_len = 20
-        fmt.print_config.max_colwidth = max_len
+        set_option("print_config.max_colwidth", max_len)
         df = DataFrame({'A': np.random.randn(10),
                  'B': [tm.rands(np.random.randint(max_len - 1,
                      max_len + 1)) for i in range(10)]})
@@ -76,10 +77,10 @@ def test_repr_truncation(self):
             else:
                 self.assert_('...' not in line)
 
-        fmt.print_config.max_colwidth = None
+        set_option("print_config.max_colwidth", 999999)
         self.assert_('...' not in repr(df))
 
-        fmt.print_config.max_colwidth = max_len + 2
+        set_option("print_config.max_colwidth", max_len + 2)
         self.assert_('...' not in repr(df))
 
     def test_repr_should_return_str (self):
@@ -425,7 +426,7 @@ def test_to_string_float_formatting(self):
         assert(df_s == expected)
 
         fmt.reset_printoptions()
-        self.assertEqual(fmt.print_config.precision, 7)
+        self.assertEqual(get_option("print_config.precision"), 7)
 
         df = DataFrame({'x': [1e9, 0.2512]})
         df_s = df.to_string()