strings without u-prefix + tests on Python 3.2 (except doctests)

Author: astanin

HOWTOPUBLISH

@@ -1,6 +1,6 @@
 # bump version number in setup.py and tabulate.py
 python2 benchmark.py  # then update README
-tox -e py26,py27-extra,py33-extra
+tox -e py26,py27-extra,py32,py33-extra
 python2 setup.py register -n
 python2 setup.py register sdist upload
 # tag version release

tabulate.py

@@ -92,7 +92,7 @@ def _pipe_line_with_colons(colwidths, colaligns):
     """Return a horizontal line with optional colons to indicate column's
     alignment (as in `pipe` output format)."""
     segments = [_pipe_segment_with_colons(a, w) for a, w in zip(colaligns, colwidths)]
-    return u"|" + u"|".join(segments) + u"|"
+    return "|" + "|".join(segments) + "|"
 
 
 def _mediawiki_row_with_attrs(separator, cell_values, colwidths, colaligns):
@@ -198,7 +198,7 @@ def simple_separated_format(separator):
     """Construct a simple TableFormat with columns separated by a separator.
 
     >>> tsv = simple_separated_format("\\t") ; \
-        tabulate([["foo", 1], ["spam", 23]], tablefmt=tsv) == u'foo \\t 1\\nspam\\t23'
+        tabulate([["foo", 1], ["spam", 23]], tablefmt=tsv) == 'foo \\t 1\\nspam\\t23'
     True
 
     """
@@ -309,7 +309,7 @@ def _padleft(width, s, has_invisible=True):
 
     """
     iwidth = width + len(s) - len(_strip_invisible(s)) if has_invisible else width
-    fmt = u"{0:>%ds}" % iwidth
+    fmt = "{0:>%ds}" % iwidth
     return fmt.format(s)
 
 
@@ -321,7 +321,7 @@ def _padright(width, s, has_invisible=True):
 
     """
     iwidth = width + len(s) - len(_strip_invisible(s)) if has_invisible else width
-    fmt = u"{0:<%ds}" % iwidth
+    fmt = "{0:<%ds}" % iwidth
     return fmt.format(s)
 
 
@@ -333,7 +333,7 @@ def _padboth(width, s, has_invisible=True):
 
     """
     iwidth = width + len(s) - len(_strip_invisible(s)) if has_invisible else width
-    fmt = u"{0:^%ds}" % iwidth
+    fmt = "{0:^%ds}" % iwidth
     return fmt.format(s)
 
 
@@ -427,7 +427,7 @@ def _column_type(strings, has_invisible=True):
     return reduce(_more_generic, types, int)
 
 
-def _format(val, valtype, floatfmt, missingval=u""):
+def _format(val, valtype, floatfmt, missingval=""):
     """Format a value accoding to its type.
 
     Unicode is supported:
@@ -443,13 +443,13 @@ def _format(val, valtype, floatfmt, missingval=u""):
         return missingval
 
     if valtype in [int, _text_type]:
-        return u"{0}".format(val)
+        return "{0}".format(val)
     elif valtype is _binary_type:
         return _text_type(val, "ascii")
     elif valtype is float:
         return format(float(val), floatfmt)
     else:
-        return u"{0}".format(val)
+        return "{0}".format(val)
 
 
 def _align_header(header, alignment, width):
@@ -458,7 +458,7 @@ def _align_header(header, alignment, width):
     elif alignment == "center":
         return _padboth(width, header)
     elif not alignment:
-        return u"{0}".format(header)
+        return "{0}".format(header)
     else:
         return _padleft(width, header)
 
@@ -532,14 +532,14 @@ def _normalize_tabular_data(tabular_data, headers):
        nhs = len(headers)
        ncols = len(rows[0])
        if nhs < ncols:
-           headers = [u""]*(ncols - nhs) + headers
+           headers = [""]*(ncols - nhs) + headers
 
     return rows, headers
 
 
 def tabulate(tabular_data, headers=[], tablefmt="simple",
              floatfmt="g", numalign="decimal", stralign="left",
-             missingval=u""):
+             missingval=""):
     """Format a fixed width table for pretty printing.
 
     >>> print(tabulate([[1, 2.34], [-56, "8.999"], ["2", "10001"]]))
@@ -740,8 +740,8 @@ def tabulate(tabular_data, headers=[], tablefmt="simple",
 
     # optimization: look for ANSI control codes once,
     # enable smart width functions only if a control code is found
-    plain_text = u'\n'.join(['\t'.join(map(_text_type, headers))] + \
-                            [u'\t'.join(map(_text_type, row)) for row in list_of_lists])
+    plain_text = '\n'.join(['\t'.join(map(_text_type, headers))] + \
+                            ['\t'.join(map(_text_type, row)) for row in list_of_lists])
     has_invisible = re.search(_invisible_codes, plain_text)
     if has_invisible:
         width_fn = _visible_width
@@ -806,7 +806,7 @@ def _build_line(colwidths, colaligns, linefmt):
 
 def _pad_row(cells, padding):
     if cells:
-        pad = u" "*padding
+        pad = " "*padding
         padded_cells = [pad + cell + pad for cell in cells]
         return padded_cells
     else:

test/test_api.py

@@ -20,7 +20,7 @@ def test_tabulate_formats():
     print("tabulate_formats = %r" % supported)
     assert type(supported) is list
     for fmt in supported:
-        assert type(fmt) is type(u"")
+        assert type(fmt) is type("")
 
 
 def _check_signature(function, expected_sig):

test/test_input.py

@@ -11,10 +11,10 @@ def test_iterable_of_iterables():
     "Input: an interable of iterables."
     ii = iter(map(lambda x: iter(x), [range(5), range(5,0,-1)]))
     expected = "\n".join(
-        [u'-  -  -  -  -',
-         u'0  1  2  3  4',
-         u'5  4  3  2  1',
-         u'-  -  -  -  -'])
+        ['-  -  -  -  -',
+         '0  1  2  3  4',
+         '5  4  3  2  1',
+         '-  -  -  -  -'])
     result   = tabulate(ii)
     print("Expected:\n%s\n" % expected)
     print("Got:\n%s\n" % result)
@@ -25,10 +25,10 @@ def test_iterable_of_iterables_headers():
     "Input: an interable of iterables with headers."
     ii = iter(map(lambda x: iter(x), [range(5), range(5,0,-1)]))
     expected = "\n".join(
-        [u'  a    b    c    d    e',
-         u'---  ---  ---  ---  ---',
-         u'  0    1    2    3    4',
-         u'  5    4    3    2    1'])
+        ['  a    b    c    d    e',
+         '---  ---  ---  ---  ---',
+         '  0    1    2    3    4',
+         '  5    4    3    2    1'])
     result   = tabulate(ii, "abcde")
     print("Expected:\n%s\n" % expected)
     print("Got:\n%s\n" % result)
@@ -39,10 +39,10 @@ def test_iterable_of_iterables_firstrow():
     "Input: an interable of iterables with the first row as headers"
     ii = iter(map(lambda x: iter(x), ["abcde", range(5), range(5,0,-1)]))
     expected = "\n".join(
-        [u'  a    b    c    d    e',
-         u'---  ---  ---  ---  ---',
-         u'  0    1    2    3    4',
-         u'  5    4    3    2    1'])
+        ['  a    b    c    d    e',
+         '---  ---  ---  ---  ---',
+         '  0    1    2    3    4',
+         '  5    4    3    2    1'])
     result   = tabulate(ii, "firstrow")
     print("Expected:\n%s\n" % expected)
     print("Got:\n%s\n" % result)
@@ -53,10 +53,10 @@ def test_list_of_lists():
     "Input: a list of lists with headers."
     ll = [["a","one",1],["b","two",None]]
     expected = "\n".join([
-        u'    string      number',
-        u'--  --------  --------',
-        u'a   one              1',
-        u'b   two'])
+        '    string      number',
+        '--  --------  --------',
+        'a   one              1',
+        'b   two'])
     result   = tabulate(ll, headers=["string","number"])
     print("Expected:\n%s\n" % expected)
     print("Got:\n%s\n" % result)
@@ -67,10 +67,10 @@ def test_list_of_lists_firstrow():
     "Input: a list of lists with the first row as headers."
     ll = [["string","number"],["a","one",1],["b","two",None]]
     expected = "\n".join([
-        u'    string      number',
-        u'--  --------  --------',
-        u'a   one              1',
-        u'b   two'])
+        '    string      number',
+        '--  --------  --------',
+        'a   one              1',
+        'b   two'])
     result   = tabulate(ll, headers="firstrow")
     print("Expected:\n%s\n" % expected)
     print("Got:\n%s\n" % result)
@@ -81,10 +81,10 @@ def test_list_of_lists_keys():
     "Input: a list of lists with column indices as headers."
     ll = [["a","one",1],["b","two",None]]
     expected = "\n".join([
-        u'0    1      2',
-        u'---  ---  ---',
-        u'a    one    1',
-        u'b    two'])
+        '0    1      2',
+        '---  ---  ---',
+        'a    one    1',
+        'b    two'])
     result   = tabulate(ll, headers="keys")
     print("Expected:\n%s\n" % expected)
     print("Got:\n%s\n" % result)
@@ -98,19 +98,19 @@ def test_dict_like():
     # keys' order (hence columns' order) is not deterministic in Python 3
     # => we have to consider both possible results as valid
     expected1 = "\n".join([
-        u'  a    b',
-        u'---  ---',
-        u'  0  101',
-        u'  1  102',
-        u'  2  103',
-        u'     104'])
+        '  a    b',
+        '---  ---',
+        '  0  101',
+        '  1  102',
+        '  2  103',
+        '     104'])
     expected2 = "\n".join([
-        u'  b    a',
-        u'---  ---',
-        u'101    0',
-        u'102    1',
-        u'103    2',
-        u'104'])
+        '  b    a',
+        '---  ---',
+        '101    0',
+        '102    1',
+        '103    2',
+        '104'])
     result    = tabulate(dd, "keys")
     print("Keys' order: %s" % dd.keys())
     print("Expected 1:\n%s\n" % expected1)
@@ -125,11 +125,11 @@ def test_numpy_2d():
         import numpy
         na = (numpy.arange(1,10, dtype=numpy.float32).reshape((3,3))**3)*0.5
         expected = "\n".join([
-            u'    a      b      c',
-            u'-----  -----  -----',
-            u'  0.5    4     13.5',
-            u' 32     62.5  108',
-            u'171.5  256    364.5'])
+            '    a      b      c',
+            '-----  -----  -----',
+            '  0.5    4     13.5',
+            ' 32     62.5  108',
+            '171.5  256    364.5'])
         result   = tabulate(na, ["a", "b", "c"])
         print("Expected:\n%s\n" % expected)
         print("Got:\n%s\n" % result)
@@ -145,10 +145,10 @@ def test_numpy_2d_firstrow():
         import numpy
         na = (numpy.arange(1,10, dtype=numpy.int32).reshape((3,3))**3)
         expected = "\n".join([
-            u'  1    8    27',
-            u'---  ---  ----',
-            u' 64  125   216',
-            u'343  512   729'])
+            '  1    8    27',
+            '---  ---  ----',
+            ' 64  125   216',
+            '343  512   729'])
         result   = tabulate(na, headers="firstrow")
         print("Expected:\n%s\n" % expected)
         print("Got:\n%r\n" % result)
@@ -164,11 +164,11 @@ def test_numpy_2d_keys():
         import numpy
         na = (numpy.arange(1,10, dtype=numpy.float32).reshape((3,3))**3)*0.5
         expected = "\n".join([
-            u'    0      1      2',
-            u'-----  -----  -----',
-            u'  0.5    4     13.5',
-            u' 32     62.5  108',
-            u'171.5  256    364.5'])
+            '    0      1      2',
+            '-----  -----  -----',
+            '  0.5    4     13.5',
+            ' 32     62.5  108',
+            '171.5  256    364.5'])
         result   = tabulate(na, headers="keys")
         print("Expected:\n%s\n" % expected)
         print("Got:\n%s\n" % result)
@@ -250,10 +250,10 @@ def test_pandas():
         import pandas
         df = pandas.DataFrame([["one",1],["two",None]], index=["a","b"])
         expected = "\n".join([
-            u'    string      number',
-            u'--  --------  --------',
-            u'a   one              1',
-            u'b   two            nan'])
+            '    string      number',
+            '--  --------  --------',
+            'a   one              1',
+            'b   two            nan'])
         result   = tabulate(df, headers=["string", "number"])
         print("Expected:\n%s\n" % expected)
         print("Got:\n%s\n" % result)
@@ -271,9 +271,9 @@ def test_pandas_firstrow():
                               columns=["string","number"],
                               index=["a","b"])
         expected = "\n".join([
-            u'a    one      1.0',
-            u'---  -----  -----',
-            u'b    two      nan'])
+            'a    one      1.0',
+            '---  -----  -----',
+            'b    two      nan'])
         result   = tabulate(df, headers="firstrow")
         print("Expected:\n%s\n" % expected)
         print("Got:\n%s\n" % result)
@@ -291,10 +291,10 @@ def test_pandas_keys():
                               columns=["string","number"],
                               index=["a","b"])
         expected = "\n".join(
-            [u'    string      number',
-             u'--  --------  --------',
-             u'a   one              1',
-             u'b   two            nan'])
+            ['    string      number',
+             '--  --------  --------',
+             'a   one              1',
+             'b   two            nan'])
         result   = tabulate(df, headers="keys")
         print("Expected:\n%s\n" % expected)
         print("Got:\n%s\n" % result)
@@ -309,11 +309,11 @@ def test_list_of_namedtuples():
     from collections import namedtuple
     NT = namedtuple("NT", ['foo', 'bar'])
     lt = [NT(1,2), NT(3,4)]
-    expected = u"\n".join([
-        u'-  -',
-        u'1  2',
-        u'3  4',
-        u'-  -'])
+    expected = "\n".join([
+        '-  -',
+        '1  2',
+        '3  4',
+        '-  -'])
     result = tabulate(lt)
     print("Expected:\n%s\n" % expected)
     print("Got:\n%s\n" % result)
@@ -325,11 +325,11 @@ def test_list_of_namedtuples_keys():
     from collections import namedtuple
     NT = namedtuple("NT", ['foo', 'bar'])
     lt = [NT(1,2), NT(3,4)]
-    expected = u"\n".join([
-        u'  foo    bar',
-        u'-----  -----',
-        u'    1      2',
-        u'    3      4'])
+    expected = "\n".join([
+        '  foo    bar',
+        '-----  -----',
+        '    1      2',
+        '    3      4'])
     result = tabulate(lt, headers="keys")
     print("Expected:\n%s\n" % expected)
     print("Got:\n%s\n" % result)