ENH: refactor formatting stuff. also close #755

Author: wesm

pandas/__init__.py

@@ -23,8 +23,8 @@
 from pandas.sparse.api import *
 from pandas.stats.api import *
 
-from pandas.core.common import set_printoptions, reset_printoptions
-from pandas.core.common import set_eng_float_format
+from pandas.core.format import (set_printoptions, reset_printoptions,
+                                set_eng_float_format)
 from pandas.io.parsers import read_csv, read_table, read_clipboard, ExcelFile
 from pandas.io.pytables import HDFStore
 from pandas.util.testing import debug

pandas/core/api.py

@@ -5,7 +5,8 @@
 from pandas.core.datetools import DateOffset
 import pandas.core.datetools as datetools
 
-from pandas.core.common import isnull, notnull, set_printoptions, save, load
+from pandas.core.common import isnull, notnull, save, load
+from pandas.core.format import set_printoptions
 from pandas.core.index import Index, Int64Index, Factor, MultiIndex
 from pandas.core.daterange import DateRange
 from pandas.core.series import Series, TimeSeries

pandas/core/common.py

@@ -16,9 +16,6 @@
 from numpy.lib.format import read_array, write_array
 import numpy as np
 
-import decimal
-import math
-
 import pandas._tseries as lib
 from pandas.util import py3compat
 import codecs
@@ -370,260 +367,6 @@ def _try_sort(iterable):
     except Exception:
         return listed
 
-#-------------------------------------------------------------------------------
-# Global formatting options
-
-def set_printoptions(precision=None, column_space=None, max_rows=None,
-                     max_columns=None, colheader_justify='right'):
-    """
-    Alter default behavior of DataFrame.toString
-
-    precision : int
-        Floating point output precision (number of significant digits)
-    column_space : int
-        Default space for DataFrame columns, defaults to 12
-    max_rows : int
-    max_columns : int
-        max_rows and max_columns are used in __repr__() methods to decide if
-        to_string() or info() is used to render an object to a string.
-        Either one, or both can be set to 0 (experimental). Pandas will figure
-        out how big the terminal is and will not display more rows or/and
-        columns that can fit on it.
-    """
-    if precision is not None:
-        print_config.precision = precision
-    if column_space is not None:
-        print_config.column_space = column_space
-    if max_rows is not None:
-        print_config.max_rows = max_rows
-    if max_columns is not None:
-        print_config.max_columns = max_columns
-    if colheader_justify is not None:
-        print_config.colheader_justify = colheader_justify
-
-def reset_printoptions():
-    print_config.reset()
-
-class EngFormatter(object):
-    """
-    Formats float values according to engineering format.
-
-    Based on matplotlib.ticker.EngFormatter
-    """
-
-    # The SI engineering prefixes
-    ENG_PREFIXES = {
-        -24: "y",
-        -21: "z",
-        -18: "a",
-        -15: "f",
-        -12: "p",
-         -9: "n",
-         -6: "u",
-         -3: "m",
-          0: "",
-          3: "k",
-          6: "M",
-          9: "G",
-         12: "T",
-         15: "P",
-         18: "E",
-         21: "Z",
-         24: "Y"
-      }
-
-    def __init__(self, accuracy=None, use_eng_prefix=False):
-        self.accuracy = accuracy
-        self.use_eng_prefix = use_eng_prefix
-
-    def __call__(self, num):
-        """ Formats a number in engineering notation, appending a letter
-        representing the power of 1000 of the original number. Some examples:
-
-        >>> format_eng(0)       # for self.accuracy = 0
-        ' 0'
-
-        >>> format_eng(1000000) # for self.accuracy = 1,
-                                #     self.use_eng_prefix = True
-        ' 1.0M'
-
-        >>> format_eng("-1e-6") # for self.accuracy = 2
-                                #     self.use_eng_prefix = False
-        '-1.00E-06'
-
-        @param num: the value to represent
-        @type num: either a numeric value or a string that can be converted to
-                   a numeric value (as per decimal.Decimal constructor)
-
-        @return: engineering formatted string
-        """
-
-        dnum = decimal.Decimal(str(num))
-
-        sign = 1
-
-        if dnum < 0:  # pragma: no cover
-            sign = -1
-            dnum = -dnum
-
-        if dnum != 0:
-            pow10 = decimal.Decimal(int(math.floor(dnum.log10()/3)*3))
-        else:
-            pow10 = decimal.Decimal(0)
-
-        pow10 = pow10.min(max(self.ENG_PREFIXES.keys()))
-        pow10 = pow10.max(min(self.ENG_PREFIXES.keys()))
-        int_pow10 = int(pow10)
-
-        if self.use_eng_prefix:
-            prefix = self.ENG_PREFIXES[int_pow10]
-        else:
-            if int_pow10 < 0:
-                prefix = 'E-%02d' % (-int_pow10)
-            else:
-                prefix = 'E+%02d' % int_pow10
-
-        mant = sign*dnum/(10**pow10)
-
-        if self.accuracy is None:  # pragma: no cover
-            format_str = u"% g%s"
-        else:
-            format_str = (u"%% .%if%%s" % self.accuracy )
-
-        formatted = format_str % (mant, prefix)
-
-        return formatted #.strip()
-
-def set_eng_float_format(precision=None, accuracy=3, use_eng_prefix=False):
-    """
-    Alter default behavior on how float is formatted in DataFrame.
-    Format float in engineering format. By accuracy, we mean the number of
-    decimal digits after the floating point.
-
-    See also EngFormatter.
-    """
-    if precision is not None: # pragma: no cover
-        import warnings
-        warnings.warn("'precision' parameter in set_eng_float_format is "
-                      "being renamed to 'accuracy'" , FutureWarning)
-        accuracy = precision
-
-    print_config.float_format = EngFormatter(accuracy, use_eng_prefix)
-    print_config.column_space = max(12, accuracy + 9)
-
-def _stringify(col):
-    # unicode workaround
-    return unicode(col)
-    #if isinstance(col, tuple):
-    #    return str(col)
-    #else:
-    #    return '%s' % console_encode(col)
-
-def _float_format_default(v, width=None):
-    """
-    Take a float and its formatted representation and if it needs extra space
-    to fit the width, reformat it to that width.
-    """
-
-    fmt_str   = '%% .%dg' % print_config.precision
-    formatted = fmt_str % v
-
-    if width is None:
-        return formatted
-
-    extra_spc = width - len(formatted)
-
-    if extra_spc <= 0:
-        return formatted
-
-    if 'e' in formatted:
-        # we have something like 1e13 or 1.23e13
-        base, exp = formatted.split('e')
-
-        if '.' in base:
-            # expand fraction by extra space
-            whole, frac = base.split('.')
-            fmt_str = '%%.%df' % (len(frac) + extra_spc)
-            frac = fmt_str % float("0.%s" % frac)
-            base = whole + frac[1:]
-        else:
-            if extra_spc > 1:
-                # enough room for fraction
-                fmt_str = '%% .%df' % (extra_spc - 1)
-                base = fmt_str % float(base)
-            else:
-                # enough room for decimal point only
-                base += '.'
-
-        return base + 'e' + exp
-    else:
-        # we have something like 123 or 123.456
-        if '.' in formatted:
-            # expand fraction by extra space
-            wholel, fracl = map(len, formatted.split("."))
-            fmt_str = '%% .%df' % (fracl + extra_spc)
-        else:
-            if extra_spc > 1:
-                # enough room for fraction
-                fmt_str = '%% .%df' % (extra_spc - 1)
-            else:
-                # enough room for decimal point only
-                fmt_str = '% d.'
-
-        return fmt_str % v
-
-def _format(s, dtype, space=None, na_rep=None, float_format=None,
-            col_width=None):
-    def _just_help(x):
-        if space is None:
-            return x
-        return x[:space].ljust(space)
-
-    def _make_float_format(x):
-        if na_rep is not None and isnull(x):
-            if np.isnan(x):
-                x = ' ' + na_rep
-            return _just_help('%s' % x)
-
-        if float_format:
-            formatted = float_format(x)
-        elif print_config.float_format:
-            formatted = print_config.float_format(x)
-        else:
-            formatted = _float_format_default(x, col_width)
-
-        return _just_help(formatted)
-
-    def _make_int_format(x):
-        return _just_help('% d' % x)
-
-    if is_float_dtype(dtype):
-        return _make_float_format(s)
-    elif is_integer_dtype(dtype):
-        return _make_int_format(s)
-    else:
-        if na_rep is not None and lib.checknull(s):
-            if s is None:
-                return 'None'
-            return na_rep
-        else:
-            # object dtype
-            return _just_help('%s' % _stringify(s))
-
-class _GlobalPrintConfig(object):
-    def __init__(self):
-        self.precision = 4
-        self.float_format = None
-        self.column_space = 12
-        self.max_rows = 200
-        self.max_columns = 0
-        self.colheader_justify = 'right'
-
-    def reset(self):
-        self.__init__()
-
-print_config = _GlobalPrintConfig()
-
 #------------------------------------------------------------------------------
 # miscellaneous python tools
 
@@ -755,6 +498,10 @@ def _asarray_tuplesafe(values, dtype=None):
 
     return result
 
+def _stringify(col):
+    # unicode workaround
+    return unicode(col)
+
 def _maybe_make_list(obj):
     if obj is not None and not isinstance(obj, (tuple, list)):
         return [obj]