Merge lp:~logan/ubuntu/trusty/prettytable/0.7.2-2ubuntu1 into lp:ubuntu/trusty/prettytable

[Logan Rosen]

[Daniel Holbach (dholbach)]

Thanks. Uploaded.

review: Approve

=== modified file 'CHANGELOG'
--- CHANGELOG	2012-06-06 19:30:29 +0000
+++ CHANGELOG	2013-11-19 02:16:58 +0000
@@ -1,15 +1,31 @@
-########## PrettyTable 0.6.1 - June 03, 2012 ##########
-
-* Unicode encoding scheme can now be set by user
-* __str__ now uses user-specified encoding instead of ASCII.  This
- fixes a bug where tables with non-ASCII characters would print
- correctly with "print x.get_string()" but not "print x" in 2.x
- (thanks to Google Code user kevincobain2000 for reporting this
- bug!)
-* Fixed an incompatibility with 3.0 and 3.1 (html.escape was new
-  in 3.2)
-
-########## PrettyTable 0.6 - April 05, 2012 ##########
+########## PrettyTable 0.7 - Feb 17, 2013 ###########
+
+* Improved Python 2 and 3 compatibility (2.4-3.2).
+* Improved support for non-Latin characters.  Table widths should
+  now be calculated correctly for tables with e.g. Japanese text.
+* Table contents can now be read in from a .csv file
+* Table contents can now be read in from a DB-API compatible cursor
+* Table contents can now be read in from a string containing a
+  HTML table (thanks to Christoph Robbert for submitting this patch!)
+* new valign attribute controls vertical alignment of text when
+  some cells in a row have multiple lines of text and others don't.
+  (thanks to Google Code user maartendb for submitting this patch!)
+* hrules attribute can now be set to HEADER, which draws a rule only
+  under the header row
+* new vrules attribute controls drawing of vertical rules and can
+  be set to FRAME, ALL or NONE
+* new header_style attribute controls formatting of text in table
+  headers and can be set to "cap", "title", "upper", "lower" or None
+* Fixed a simple bug regarding validation of max_width (thanks to
+  Anthony Toole for pointing out this bug and providing a patch).
+* Fixed a simple bug regarding initialisation of int_format value
+  for new tables (thanks to Ingo Schmiegel for pointing out this
+  bug!)
+* Fixed a bug regarding some constructor keywords, such as "border",
+  being ignored (thanks to Google Code user antonio.s.messina for
+  reporting this bug).
+
+########## PrettyTable 0.6 - May 5, 2012 ##########
 
 * Code is now simultaneously compatible with Python 2 and 3
 * Replaced all setter methods with managed attributes

=== modified file 'COPYING'
--- COPYING	2012-06-06 19:30:29 +0000
+++ COPYING	2013-11-19 02:16:58 +0000
@@ -1,8 +1,10 @@
-# Copyright (c) 2009-2012 Luke Maurits <[e-mail]>
+# Copyright (c) 2009-2013 Luke Maurits <[e-mail]>
 # All rights reserved.
 # With contributions from:
 #  * Chris Clark
+#  * Christoph Robbert
 #  * Klein Stephane
+#  * "maartendb"
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are met:

=== modified file 'PKG-INFO'
--- PKG-INFO	2012-06-06 19:30:29 +0000
+++ PKG-INFO	2013-11-19 02:16:58 +0000
@@ -1,6 +1,6 @@
 Metadata-Version: 1.0
 Name: prettytable
-Version: 0.6.1
+Version: 0.7.2
 Summary: A simple Python library for easily displaying tabular data in a visually appealing ASCII table format
 Home-page: http://code.google.com/p/prettytable
 Author: Luke Maurits
@@ -9,6 +9,8 @@
 Description: UNKNOWN
 Platform: UNKNOWN
 Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 2.4
+Classifier: Programming Language :: Python :: 2.5
 Classifier: Programming Language :: Python :: 2.6
 Classifier: Programming Language :: Python :: 2.7
 Classifier: Programming Language :: Python :: 3

=== modified file 'README'
--- README	2012-05-06 11:06:13 +0000
+++ README	2013-11-19 02:16:58 +0000
@@ -1,4 +1,4 @@
-TUTORIAL ON HOW TO USE THE PRETTYTABLE 0.6 API
+TUTORIAL ON HOW TO USE THE PRETTYTABLE 0.6+ API
 
 *** This tutorial is distributed with PrettyTable and is meant to serve
 as a "quick start" guide for the lazy or impatient.  It is not an
@@ -13,15 +13,15 @@
 from prettytable import PrettyTable
 x = PrettyTable()
 
-and you want to put some data into it.  You have two (sane) options
+and you want to put some data into it.  You have a few options.
 
 == Row by row ==
 
-You can add data one row at a time.  To do this you need to set the field names 
-first using the `set_field_names` method, and then add the rows one at a time 
+You can add data one row at a time.  To do this you can set the field names 
+first using the `field_names` attribute, and then add the rows one at a time 
 using the `add_row` method:
 
-x.set_field_names(["City name", "Area", "Population", "Annual Rainfall"])
+x.field_names = ["City name", "Area", "Population", "Annual Rainfall"]
 x.add_row(["Adelaide",1295, 1158259, 600.5])
 x.add_row(["Brisbane",5905, 1857594, 1146.4])
 x.add_row(["Darwin", 112, 120900, 1714.7])
@@ -54,6 +54,39 @@
 this way are kind of confusing for other people to read, though, so don't do 
 this unless you have a good reason.
 
+== Importing data from a CSV file ==
+
+If you have your table data in a comma separated values file (.csv), you can
+read this data into a PrettyTable like this:
+
+from prettytable import from_csv
+fp = open("myfile.csv", "r")
+mytable = from_csv(fp)
+fp.close()
+
+== Importing data from a HTML string ==
+
+If you have a string containing a HTML <table>, you can read this data into a
+PrettyTable like this:
+
+from prettytable import from_html
+mytable = from_html(html_string)
+
+== Importing data from a database cursor ==
+
+If you have your table data in a database which you can access using a library
+which confirms to the Python DB-API (e.g. an SQLite database accessible using
+the sqlite module), then you can build a PrettyTable using a cursor object,
+like this:
+
+import sqlite3
+from prettytable import from_db_cursor
+
+connection = sqlite3.connect("mydb.db")
+cursor = connection.cursor()
+cursor.execute("SELECT field1, field2, field3 FROM my_table")
+mytable = from_db_cursor(cursor)
+
 == Getting data out ==
 
 There are three ways to get data out of a PrettyTable, in increasing order of 
@@ -99,8 +132,9 @@
 
 in Python 3.x.
 
-The old x.printt() method from versions 0.5 and earlier has been removed.  To
-pass options changing the look of the table, use the get_string() method
+The old x.printt() method from versions 0.5 and earlier has been removed.
+
+To pass options changing the look of the table, use the get_string() method
 documented below:
 
 print x.get_string()
@@ -314,9 +348,11 @@
     or not the first row of the table is a header showing the names of all the 
     fields.
   * `hrules` - Controls printing of horizontal rules after rows.  Allowed 
-    values: FRAME, ALL, NONE - note that these are variables defined inside the 
-    `prettytable` module so make sure you import them or use `prettytable.FRAME` 
-    etc.
+    values: FRAME, HEADER, ALL, NONE - note that these are variables defined
+    inside the `prettytable` module so make sure you import them or use
+    `prettytable.FRAME` etc.
+  * `vrules` - Controls printing of vertical rules between columns.  Allowed 
+    values: FRAME, ALL, NONE.
   * `int_format` - A string which controls the way integer data is printed.
     This works like: print "%<int_format>d" % data
   * `float_format` - A string which controls the way floating point data is
@@ -390,7 +426,7 @@
 By default, PrettyTable outputs HTML for "vanilla" tables.  The HTML code is 
 quite simple.  It looks like this:
 
-<table border="1">
+<table>
     <tr>
         <th>City name</th>
         <th>Area</th>
@@ -437,7 +473,7 @@
 
 will print:
 
-<table border="1" name="my_table" class="red_table">
+<table name="my_table" class="red_table">
     <tr>
         <th>City name</th>
         <th>Area</th>

=== modified file 'debian/changelog'
--- debian/changelog	2012-11-05 04:00:38 +0000
+++ debian/changelog	2013-11-19 02:16:58 +0000
@@ -1,3 +1,34 @@
+prettytable (0.7.2-2ubuntu1) trusty; urgency=low
+
+  * Merge from Debian unstable. Remaining changes:
+    - Convert to dh_python2:
+      + debian/control: Removed python-support from Build-Depends-Indep.
+      + debian/rules: Added --with python2 to complete transition.
+
+ -- Logan Rosen <[e-mail]>  Mon, 18 Nov 2013 21:11:55 -0500
+
+prettytable (0.7.2-2) unstable; urgency=low
+
+  [ Jakub Wilk ]
+  * Use canonical URIs for Vcs-* fields.
+
+  [ Sandro Tosi ]
+  * debian/control
+    - bump Standards-Version to 3.9.4 (no changes needed)
+
+ -- Sandro Tosi <[e-mail]>  Sun, 29 Sep 2013 15:31:36 +0200
+
+prettytable (0.7.2-1) experimental; urgency=low
+
+  * New upstream release
+  * debian/copyright
+    - update upstream copyright information
+    - extend packaging copyright years
+  * debian/{control, rules}
+    - install and use UTF-8 charset, needed by test suite
+
+ -- Sandro Tosi <[e-mail]>  Sun, 07 Apr 2013 23:23:17 +0200
+
 prettytable (0.6.1-1ubuntu1) raring; urgency=low
 
   * Merge from Debian unstable. Remaining changes:
@@ -5,7 +36,7 @@
       + debian/control: Removed python-support from Build-Depends-Indep.
       + debian/rules: Added --with python2 to complete transition.
 
- -- Logan Rosen <[e-mail]>  Sun, 04 Nov 2012 22:59:44 -0500
+ -- Logan Rosen <[e-mail]>  Sun, 04 Nov 2012 22:59:44 -0500
 
 prettytable (0.6.1-1) unstable; urgency=low
 

=== modified file 'debian/control'
--- debian/control	2012-05-20 10:42:04 +0000
+++ debian/control	2013-11-19 02:16:58 +0000
@@ -4,11 +4,11 @@
 Maintainer: Ubuntu Developers <[e-mail]>
 XSBC-Original-Maintainer: Debian Python Modules Team <[e-mail]>
 Uploaders: Sandro Tosi <[e-mail]>
-Build-Depends: debhelper (>= 7.0.50~), python-all (>= 2.6.6-3~), python3-all (>= 3.1.3-3), python-setuptools, python3-setuptools
-Standards-Version: 3.9.3
+Build-Depends: debhelper (>= 7.0.50~), python-all (>= 2.6.6-3~), python3-all (>= 3.1.3-3), python-setuptools, python3-setuptools, locales
+Standards-Version: 3.9.4
 Homepage: http://code.google.com/p/prettytable/
-Vcs-Svn: svn://svn.debian.org/python-modules/packages/prettytable/trunk/
-Vcs-Browser: http://svn.debian.org/viewsvn/python-modules/packages/prettytable/trunk/
+Vcs-Svn: svn://anonscm.debian.org/python-modules/packages/prettytable/trunk/
+Vcs-Browser: http://anonscm.debian.org/viewvc/python-modules/packages/prettytable/trunk/
 
 Package: python-prettytable
 Architecture: all

=== modified file 'debian/copyright'
--- debian/copyright	2012-05-06 11:06:13 +0000
+++ debian/copyright	2013-11-19 02:16:58 +0000
@@ -2,12 +2,12 @@
 Upstream-Name: prettytable
 Source: http://code.google.com/p/prettytable/
 
-Files: * debian/prettytable_test.py
-Copyright: Copyright (c) 2009, Luke Maurits <[e-mail]>
+Files: *
+Copyright: Copyright (c) 2009-2013, Luke Maurits <[e-mail]>
 License: BSD
 
 Files: debian/*
-Copyright: Copyright (C) 2009-2012 Sandro Tosi <[e-mail]>
+Copyright: Copyright (C) 2009-2013 Sandro Tosi <[e-mail]>
 License: BSD
 
 License: BSD

=== modified file 'debian/rules'
--- debian/rules	2012-11-05 04:00:38 +0000
+++ debian/rules	2013-11-19 02:16:58 +0000
@@ -5,6 +5,12 @@
 PY2VERS := $(shell pyversions -s)
 PY3VERS := $(shell py3versions -s)
 
+# For running tests, we need UTF-8 charset
+# See #604706 for references about this method
+LOCALE_PATH	:= debian/tmpdir/usr/lib/locale
+LOCALE_NAME	:= en_US
+LOCALE_CHARSET	:= UTF-8
+
 %:
 	dh $@ --with python2,python3
 
@@ -31,13 +37,19 @@
 	    $$python setup.py clean -a; \
 	done
 	find . -name \*.pyc -exec rm {} \;
+	rm -rf $(LOCALE_PATH)
 	dh_clean
 
 override_dh_auto_test:
 ifeq ($(filter nocheck,$(DEB_BUILD_OPTIONS)),)
+	# configure a local charset dir, for testing purposes
+	mkdir -p $(LOCALE_PATH)
+	localedef -i $(LOCALE_NAME) -c -f $(LOCALE_CHARSET) \
+		-A /usr/share/locale/locale.alias --quiet \
+		$(LOCALE_PATH)/$(LOCALE_NAME).$(LOCALE_CHARSET)
 	set -e ; \
 	for python in $(PY2VERS) $(PY3VERS); do \
-		PYTHONPATH=. $$python setup.py test ; \
+		PYTHONPATH=. LOCPATH=$(LOCALE_PATH) LC_ALL=$(LOCALE_NAME).$(LOCALE_CHARSET) $$python setup.py test ; \
 	done
 endif
 

=== modified file 'prettytable.egg-info/PKG-INFO'
--- prettytable.egg-info/PKG-INFO	2012-06-06 19:30:29 +0000
+++ prettytable.egg-info/PKG-INFO	2013-11-19 02:16:58 +0000
@@ -1,6 +1,6 @@
 Metadata-Version: 1.0
 Name: prettytable
-Version: 0.6.1
+Version: 0.7.2
 Summary: A simple Python library for easily displaying tabular data in a visually appealing ASCII table format
 Home-page: http://code.google.com/p/prettytable
 Author: Luke Maurits
@@ -9,6 +9,8 @@
 Description: UNKNOWN
 Platform: UNKNOWN
 Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 2.4
+Classifier: Programming Language :: Python :: 2.5
 Classifier: Programming Language :: Python :: 2.6
 Classifier: Programming Language :: Python :: 2.7
 Classifier: Programming Language :: Python :: 3

=== modified file 'prettytable.py'
--- prettytable.py	2012-06-06 19:30:29 +0000
+++ prettytable.py	2013-11-19 02:16:58 +0000
@@ -1,6 +1,6 @@
 #!/usr/bin/env python
 #
-# Copyright (c) 2009, Luke Maurits <[e-mail]>
+# Copyright (c) 2009-2013, Luke Maurits <[e-mail]>
 # All rights reserved.
 # With contributions from:
 #  * Chris Clark
@@ -29,17 +29,31 @@
 # ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 # POSSIBILITY OF SUCH DAMAGE.
 
-__version__ = "0.6.1"
+__version__ = "0.7.2"
 
-import sys
 import copy
+import csv
 import random
+import re
+import sys
 import textwrap
+import itertools
+import unicodedata
 
 py3k = sys.version_info[0] >= 3
 if py3k:
     unicode = str
     basestring = str
+    itermap = map
+    iterzip = zip
+    uni_chr = chr
+    from html.parser import HTMLParser
+else: 
+    itermap = itertools.imap
+    iterzip = itertools.izip
+    uni_chr = unichr
+    from HTMLParser import HTMLParser
+
 if py3k and sys.version_info[1] >= 2:
     from html import escape
 else:
@@ -49,6 +63,7 @@
 FRAME = 0
 ALL   = 1
 NONE  = 2
+HEADER = 3
 
 # Table styles
 DEFAULT = 10
@@ -56,43 +71,34 @@
 PLAIN_COLUMNS = 12
 RANDOM = 20
 
+_re = re.compile("\033\[[0-9;]*m")
+
 def _get_size(text):
-    max_width = 0
-    max_height = 0
-    text = _unicode(text)
-    for line in text.split("\n"):
-        max_height += 1
-        if len(line) > max_width:
-            max_width = len(line)
-
-    return (max_width, max_height)
+    lines = text.split("\n")
+    height = len(lines)
+    width = max([_str_block_width(line) for line in lines])
+    return (width, height)
         
-def _unicode(value, encoding="UTF-8"):
-    if not isinstance(value, basestring):
-        value = str(value)
-    if not isinstance(value, unicode):
-        value = unicode(value, encoding, "replace")
-    return value
-
 class PrettyTable(object):
 
-    def __init__(self, field_names=None, encoding="UTF-8", **kwargs):
+    def __init__(self, field_names=None, **kwargs):
 
         """Return a new PrettyTable instance
 
         Arguments:
 
+        encoding - Unicode encoding scheme used to decode any encoded input
         field_names - list or tuple of field names
-        encoding - Unicode encoding scheme to use
         fields - list or tuple of field names to include in displays
         start - index of first data row to include in output
         end - index of last data row to include in output PLUS ONE (list slice style)
-        fields - names of fields (columns) to include
         header - print a header showing field names (True or False)
+        header_style - stylisation to apply to field names in header ("cap", "title", "upper", "lower" or None)
         border - print a border around the table (True or False)
-        hrules - controls printing of horizontal rules after rows.  Allowed values: FRAME, ALL, NONE
-	int_format - controls formatting of integer data
-	float_format - controls formatting of floating point data
+        hrules - controls printing of horizontal rules after rows.  Allowed values: FRAME, HEADER, ALL, NONE
+        vrules - controls printing of vertical rules between columns.  Allowed values: FRAME, ALL, NONE
+        int_format - controls formatting of integer data
+        float_format - controls formatting of floating point data
         padding_width - number of spaces on either side of column data (only used if left and right paddings are None)
         left_padding_width - number of spaces on left hand side of column data
         right_padding_width - number of spaces on right hand side of column data
@@ -101,57 +107,101 @@
         junction_char - single character string used to draw line junctions
         sortby - name of field to sort rows by
         sort_key - sorting key function, applied to data points before sorting
+        valign - default valign for each row (None, "t", "m" or "b")
         reversesort - True or False to sort in descending or ascending order"""
 
-        self.encoding = encoding
+        self.encoding = kwargs.get("encoding", "UTF-8")
 
         # Data
         self._field_names = []
         self._align = {}
+        self._valign = {}
         self._max_width = {}
         self._rows = []
         if field_names:
             self.field_names = field_names
         else:
             self._widths = []
-        self._rows = []
 
         # Options
-        self._options = "start end fields header border sortby reversesort sort_key attributes format hrules".split()
+        self._options = "start end fields header border sortby reversesort sort_key attributes format hrules vrules".split()
         self._options.extend("int_format float_format padding_width left_padding_width right_padding_width".split())
-        self._options.extend("vertical_char horizontal_char junction_char".split())
+        self._options.extend("vertical_char horizontal_char junction_char header_style valign xhtml print_empty".split())
         for option in self._options:
             if option in kwargs:
                 self._validate_option(option, kwargs[option])
             else:
                 kwargs[option] = None
 
-
         self._start = kwargs["start"] or 0
         self._end = kwargs["end"] or None
         self._fields = kwargs["fields"] or None
 
-        self._header = kwargs["header"] or True
-        self._border = kwargs["border"] or True
+        if kwargs["header"] in (True, False):
+            self._header = kwargs["header"]
+        else:
+            self._header = True
+        self._header_style = kwargs["header_style"] or None
+        if kwargs["border"] in (True, False):
+            self._border = kwargs["border"]
+        else:
+            self._border = True
         self._hrules = kwargs["hrules"] or FRAME
+        self._vrules = kwargs["vrules"] or ALL
 
         self._sortby = kwargs["sortby"] or None
-        self._reversesort = kwargs["reversesort"] or False
+        if kwargs["reversesort"] in (True, False):
+            self._reversesort = kwargs["reversesort"]
+        else:
+            self._reversesort = False
         self._sort_key = kwargs["sort_key"] or (lambda x: x)
 
-        self._int_format = kwargs["float_format"] or {}
+        self._int_format = kwargs["int_format"] or {}
         self._float_format = kwargs["float_format"] or {}
         self._padding_width = kwargs["padding_width"] or 1
         self._left_padding_width = kwargs["left_padding_width"] or None
         self._right_padding_width = kwargs["right_padding_width"] or None
 
-        self._vertical_char = kwargs["vertical_char"] or "|"
-        self._horizontal_char = kwargs["horizontal_char"] or "-"
-        self._junction_char = kwargs["junction_char"] or "+"
+        self._vertical_char = kwargs["vertical_char"] or self._unicode("|")
+        self._horizontal_char = kwargs["horizontal_char"] or self._unicode("-")
+        self._junction_char = kwargs["junction_char"] or self._unicode("+")
         
+        if kwargs["print_empty"] in (True, False):
+            self._print_empty = kwargs["print_empty"]
+        else:
+            self._print_empty = True
         self._format = kwargs["format"] or False
+        self._xhtml = kwargs["xhtml"] or False
         self._attributes = kwargs["attributes"] or {}
    
+    def _unicode(self, value):
+        if not isinstance(value, basestring):
+            value = str(value)
+        if not isinstance(value, unicode):
+            value = unicode(value, self.encoding, "strict")
+        return value
+
+    def _justify(self, text, width, align):
+        excess = width - _str_block_width(text)
+        if align == "l":
+            return text + excess * " "
+        elif align == "r":
+            return excess * " " + text
+        else:
+            if excess % 2:
+                # Uneven padding
+                # Put more space on right if text is of odd length...
+                if _str_block_width(text) % 2:
+                    return (excess//2)*" " + text + (excess//2 + 1)*" "
+                # and more space on left if text is of even length
+                else:
+                    return (excess//2 + 1)*" " + text + (excess//2)*" "
+                # Why distribute extra space this way?  To match the behaviour of
+                # the inbuilt str.center() method.
+            else:
+                # Equal padding on either side
+                return (excess//2)*" " + text + (excess//2)*" "
+
     def __getattr__(self, name):
 
         if name == "rowcount":
@@ -168,20 +218,26 @@
  
     def __getitem__(self, index):
 
-        newtable = copy.deepcopy(self)
+        new = PrettyTable()
+        new.field_names = self.field_names
+        for attr in self._options:
+            setattr(new, "_"+attr, getattr(self, "_"+attr))
+        setattr(new, "_align", getattr(self, "_align"))
         if isinstance(index, slice):
-            newtable._rows = self._rows[index]
+            for row in self._rows[index]:
+                new.add_row(row)
         elif isinstance(index, int):
-            newtable._rows = [self._rows[index],]
+            new.add_row(self._rows[index])
         else:
             raise Exception("Index %s is invalid, must be an integer or slice" % str(index))
-        return newtable
+        return new
 
-    def __str__(self):
-        if py3k:
-            return self.get_string()
-        else:
-            return self.get_string().encode(self.encoding)
+    if py3k:
+        def __str__(self):
+           return self.__unicode__()
+    else:
+        def __str__(self):
+           return self.__unicode__().encode(self.encoding)
 
     def __unicode__(self):
         return self.get_string()
@@ -198,7 +254,9 @@
     # Secondly, in the _get_options method, where keyword arguments are mixed with persistent settings
 
     def _validate_option(self, option, val):
-        if option in ("start", "end", "padding_width", "left_padding_width", "right_padding_width", "format"):
+        if option in ("field_names"):
+            self._validate_field_names(val)
+        elif option in ("start", "end", "max_width", "padding_width", "left_padding_width", "right_padding_width", "format"):
             self._validate_nonnegative_int(option, val)
         elif option in ("sortby"):
             self._validate_field_name(option, val)
@@ -206,10 +264,14 @@
             self._validate_function(option, val)
         elif option in ("hrules"):
             self._validate_hrules(option, val)
+        elif option in ("vrules"):
+            self._validate_vrules(option, val)
         elif option in ("fields"):
             self._validate_all_field_names(option, val)
-        elif option in ("header", "border", "reversesort"):
+        elif option in ("header", "border", "reversesort", "xhtml", "print_empty"):
             self._validate_true_or_false(option, val)
+        elif option in ("header_style"):
+            self._validate_header_style(val)
         elif option in ("int_format"):
             self._validate_int_format(option, val)
         elif option in ("float_format"):
@@ -221,17 +283,47 @@
         else:
             raise Exception("Unrecognised option: %s!" % option)
 
+    def _validate_field_names(self, val):
+        # Check for appropriate length
+        if self._field_names:
+            try:
+               assert len(val) == len(self._field_names)
+            except AssertionError:
+               raise Exception("Field name list has incorrect number of values, (actual) %d!=%d (expected)" % (len(val), len(self._field_names)))
+        if self._rows:
+            try:
+               assert len(val) == len(self._rows[0])
+            except AssertionError:
+               raise Exception("Field name list has incorrect number of values, (actual) %d!=%d (expected)" % (len(val), len(self._rows[0])))
+        # Check for uniqueness
+        try:
+            assert len(val) == len(set(val))
+        except AssertionError:
+            raise Exception("Field names must be unique!")
+
+    def _validate_header_style(self, val):
+        try:
+            assert val in ("cap", "title", "upper", "lower", None)
+        except AssertionError:
+            raise Exception("Invalid header style, use cap, title, upper, lower or None!")
+
     def _validate_align(self, val):
         try:
             assert val in ["l","c","r"]
         except AssertionError:
             raise Exception("Alignment %s is invalid, use l, c or r!" % val)
 
+    def _validate_valign(self, val):
+        try:
+            assert val in ["t","m","b",None]
+        except AssertionError:
+            raise Exception("Alignment %s is invalid, use t, m, b or None!" % val)
+
     def _validate_nonnegative_int(self, name, val):
         try:
             assert int(val) >= 0
         except AssertionError:
-            raise Exception("Invalid value for %s: %s!" % (name, _unicode(val)))
+            raise Exception("Invalid value for %s: %s!" % (name, self._unicode(val)))
 
     def _validate_true_or_false(self, name, val):
         try:
@@ -269,13 +361,19 @@
 
     def _validate_hrules(self, name, val):
         try:
+            assert val in (ALL, FRAME, HEADER, NONE)
+        except AssertionError:
+            raise Exception("Invalid value for %s!  Must be ALL, FRAME, HEADER or NONE." % name)
+
+    def _validate_vrules(self, name, val):
+        try:
             assert val in (ALL, FRAME, NONE)
         except AssertionError:
-            raise Exception("Invalid value for %s!  Must be ALL, FRAME or NONE." % name)
+            raise Exception("Invalid value for %s!  Must be ALL, FRAME, or NONE." % name)
 
     def _validate_field_name(self, name, val):
         try:
-            assert val in self._field_names
+            assert (val in self._field_names) or (val is None)
         except AssertionError:
             raise Exception("Invalid field name: %s!" % val)
 
@@ -288,7 +386,7 @@
 
     def _validate_single_char(self, name, val):
         try:
-            assert len(_unicode(val)) == 1
+            assert _str_block_width(val) == 1
         except AssertionError:
             raise Exception("Invalid value for %s!  Must be a string of length 1." % name)
 
@@ -310,6 +408,8 @@
 
         fields - list or tuple of field names"""
     def _set_field_names(self, val):
+        val = [self._unicode(x) for x in val]
+        self._validate_option("field_names", val)
         if self._field_names:
             old_names = self._field_names[:]
         self._field_names = val
@@ -317,10 +417,20 @@
             for old_name, new_name in zip(old_names, val):
                 self._align[new_name] = self._align[old_name]
             for old_name in old_names:
-                self._align.pop(old_name)
+                if old_name not in self._align:
+                    self._align.pop(old_name)
         else:
             for field in self._field_names:
                 self._align[field] = "c"
+        if self._valign and old_names:
+            for old_name, new_name in zip(old_names, val):
+                self._valign[new_name] = self._valign[old_name]
+            for old_name in old_names:
+                if old_name not in self._valign:
+                    self._valign.pop(old_name)
+        else:
+            for field in self._field_names:
+                self._valign[field] = "t"
     field_names = property(_get_field_names, _set_field_names)
 
     def _get_align(self):
@@ -331,14 +441,34 @@
             self._align[field] = val
     align = property(_get_align, _set_align)
 
+    def _get_valign(self):
+        return self._valign
+    def _set_valign(self, val):
+        self._validate_valign(val)
+        for field in self._field_names:
+            self._valign[field] = val
+    valign = property(_get_valign, _set_valign)
+
     def _get_max_width(self):
         return self._max_width
     def _set_max_width(self, val):
-        self._validate_nonnegativeint(val)
+        self._validate_option("max_width", val)
         for field in self._field_names:
             self._max_width[field] = val
     max_width = property(_get_max_width, _set_max_width)
     
+    def _get_fields(self):
+        """List or tuple of field names to include in displays
+
+        Arguments:
+
+        fields - list or tuple of field names to include in displays"""
+        return self._fields
+    def _set_fields(self, val):
+        self._validate_option("fields", val)
+        self._fields = val
+    fields = property(_get_fields, _set_fields)
+
     def _get_start(self):
         """Start index of the range of rows to print
 
@@ -412,6 +542,18 @@
         self._header = val
     header = property(_get_header, _set_header)
 
+    def _get_header_style(self):
+        """Controls stylisation applied to field names in header
+
+        Arguments:
+
+        header_style - stylisation to apply to field names in header ("cap", "title", "upper", "lower" or None)"""
+        return self._header_style
+    def _set_header_style(self, val):
+        self._validate_header_style(val)
+        self._header_style = val
+    header_style = property(_get_header_style, _set_header_style)
+
     def _get_border(self):
         """Controls printing of border around table
 
@@ -429,13 +571,25 @@
 
         Arguments:
 
-        hrules - horizontal rules style.  Allowed values: FRAME, ALL, NONE"""
+        hrules - horizontal rules style.  Allowed values: FRAME, ALL, HEADER, NONE"""
         return self._hrules
     def _set_hrules(self, val):
         self._validate_option("hrules", val)
         self._hrules = val
     hrules = property(_get_hrules, _set_hrules)
 
+    def _get_vrules(self):
+        """Controls printing of vertical rules between columns
+
+        Arguments:
+
+        vrules - vertical rules style.  Allowed values: FRAME, ALL, NONE"""
+        return self._vrules
+    def _set_vrules(self, val):
+        self._validate_option("vrules", val)
+        self._vrules = val
+    vrules = property(_get_vrules, _set_vrules)
+
     def _get_int_format(self):
         """Controls formatting of integer data
         Arguments:
@@ -443,7 +597,7 @@
         int_format - integer format string"""
         return self._int_format
     def _set_int_format(self, val):
-        self._validate_option("int_format", val)
+#        self._validate_option("int_format", val)
         for field in self._field_names:
             self._int_format[field] = val
     int_format = property(_get_int_format, _set_int_format)
@@ -455,7 +609,7 @@
         float_format - floating point format string"""
         return self._float_format
     def _set_float_format(self, val):
-        self._validate_option("float_format", val)
+#        self._validate_option("float_format", val)
         for field in self._field_names:
             self._float_format[field] = val
     float_format = property(_get_float_format, _set_float_format)
@@ -504,6 +658,7 @@
         vertical_char - single character string used to draw vertical lines"""
         return self._vertical_char
     def _set_vertical_char(self, val):
+        val = self._unicode(val)
         self._validate_option("vertical_char", val)
         self._vertical_char = val
     vertical_char = property(_get_vertical_char, _set_vertical_char)
@@ -516,6 +671,7 @@
         horizontal_char - single character string used to draw horizontal lines"""
         return self._horizontal_char
     def _set_horizontal_char(self, val):
+        val = self._unicode(val)
         self._validate_option("horizontal_char", val)
         self._horizontal_char = val
     horizontal_char = property(_get_horizontal_char, _set_horizontal_char)
@@ -528,6 +684,7 @@
         junction_char - single character string used to draw line junctions"""
         return self._junction_char
     def _set_junction_char(self, val):
+        val = self._unicode(val)
         self._validate_option("vertical_char", val)
         self._junction_char = val
     junction_char = property(_get_junction_char, _set_junction_char)
@@ -544,6 +701,18 @@
         self._format = val
     format = property(_get_format, _set_format)
 
+    def _get_print_empty(self):
+        """Controls whether or not empty tables produce a header and frame or just an empty string
+
+        Arguments:
+
+        print_empty - True or False"""
+        return self._print_empty
+    def _set_print_empty(self, val):
+        self._validate_option("print_empty", val)
+        self._print_empty = val
+    print_empty = property(_get_print_empty, _set_print_empty)
+
     def _get_attributes(self):
         """A dictionary of HTML attribute name/value pairs to be included in the <table> tag when printing HTML
 
@@ -552,7 +721,7 @@
         attributes - dictionary of attributes"""
         return self._attributes
     def _set_attributes(self, val):
-        self.validate_option("attributes", val)
+        self._validate_option("attributes", val)
         self._attributes = val
     attributes = property(_get_attributes, _set_attributes)
 
@@ -593,6 +762,7 @@
         self.header = True
         self.border = True
         self._hrules = FRAME
+        self._vrules = ALL
         self.padding_width = 1
         self.left_padding_width = 1
         self.right_padding_width = 1
@@ -623,7 +793,8 @@
         # Just for fun!
         self.header = random.choice((True, False))
         self.border = random.choice((True, False))
-        self._hrules = random.choice((ALL, FRAME, NONE))
+        self._hrules = random.choice((ALL, FRAME, HEADER, NONE))
+        self._vrules = random.choice((ALL, FRAME, NONE))
         self.left_padding_width = random.randint(0,5)
         self.right_padding_width = random.randint(0,5)
         self.vertical_char = random.choice("~!@#$%^&*()_+|-=\{}[];':\",./;<>?")
@@ -645,6 +816,8 @@
 
         if self._field_names and len(row) != len(self._field_names):
             raise Exception("Row has incorrect number of values, (actual) %d!=%d (expected)" %(len(row),len(self._field_names)))
+        if not self._field_names:
+            self.field_names = [("Field %d" % (n+1)) for n in range(0,len(row))]
         self._rows.append(list(row))
 
     def del_row(self, row_index):
@@ -659,7 +832,7 @@
             raise Exception("Cant delete row at index %d, table only has %d rows!" % (row_index, len(self._rows)))
         del self._rows[row_index]
 
-    def add_column(self, fieldname, column, align="c"):
+    def add_column(self, fieldname, column, align="c", valign="t"):
 
         """Add a column to the table.
 
@@ -668,12 +841,15 @@
         fieldname - name of the field to contain the new column of data
         column - column of data, should be a list with as many elements as the
         table has rows
-        align - desired alignment for this column - "l" for left, "c" for centre and "r" for right"""
+        align - desired alignment for this column - "l" for left, "c" for centre and "r" for right
+        valign - desired vertical alignment for new columns - "t" for top, "m" for middle and "b" for bottom"""
 
         if len(self._rows) in (0, len(column)):
             self._validate_align(align)
+            self._validate_valign(valign)
             self._field_names.append(fieldname)
             self._align[fieldname] = align
+            self._valign[fieldname] = valign
             for i in range(0, len(column)):
                 if len(self._rows) < i+1:
                     self._rows.append([])
@@ -708,10 +884,10 @@
 
     def _format_value(self, field, value):
         if isinstance(value, int) and field in self._int_format:
-            value = ("%%%sd" % self._int_format[field]) % value 
+            value = self._unicode(("%%%sd" % self._int_format[field]) % value)
         elif isinstance(value, float) and field in self._float_format:
-            value = ("%%%sf" % self._float_format[field]) % value 
-        return value
+            value = self._unicode(("%%%sf" % self._float_format[field]) % value)
+        return self._unicode(value)
 
     def _compute_widths(self, rows, options):
         if options["header"]:
@@ -720,8 +896,11 @@
             widths = len(self.field_names) * [0]
         for row in rows:
             for index, value in enumerate(row):
-                value = self._format_value(self.field_names[index], value)
-                widths[index] = max(widths[index], _get_size(_unicode(value))[0])
+                fieldname = self.field_names[index]
+                if fieldname in self.max_width:
+                    widths[index] = max(widths[index], min(_get_size(value)[0], self.max_width[fieldname]))
+                else:
+                    widths[index] = max(widths[index], _get_size(value)[0])
         self._widths = widths
 
     def _get_padding_widths(self, options):
@@ -743,7 +922,7 @@
 
         options - dictionary of option settings."""
        
-	# Make a copy of only those rows in the slice range 
+        # Make a copy of only those rows in the slice range 
         rows = copy.deepcopy(self._rows[options["start"]:options["end"]])
         # Sort if necessary
         if options["sortby"]:
@@ -755,7 +934,13 @@
             # Undecorate
             rows = [row[1:] for row in rows]
         return rows
-         
+        
+    def _format_row(self, row, options):
+        return [self._format_value(field, value) for (field, value) in zip(self._field_names, row)]
+
+    def _format_rows(self, rows, options):
+        return [self._format_row(row, options) for row in rows]
+ 
     ##############################
     # PLAIN TEXT STRING METHODS  #
     ##############################
@@ -771,9 +956,10 @@
         fields - names of fields (columns) to include
         header - print a header showing field names (True or False)
         border - print a border around the table (True or False)
-        hrules - controls printing of horizontal rules after rows.  Allowed values: FRAME, ALL, NONE
-	int_format - controls formatting of integer data
-	float_format - controls formatting of floating point data
+        hrules - controls printing of horizontal rules after rows.  Allowed values: ALL, FRAME, HEADER, NONE
+        vrules - controls printing of vertical rules between columns.  Allowed values: FRAME, ALL, NONE
+        int_format - controls formatting of integer data
+        float_format - controls formatting of floating point data
         padding_width - number of spaces on either side of column data (only used if left and right paddings are None)
         left_padding_width - number of spaces on left hand side of column data
         right_padding_width - number of spaces on right hand side of column data
@@ -782,55 +968,67 @@
         junction_char - single character string used to draw line junctions
         sortby - name of field to sort rows by
         sort_key - sorting key function, applied to data points before sorting
-        reversesort - True or False to sort in descending or ascending order"""
+        reversesort - True or False to sort in descending or ascending order
+        print empty - if True, stringify just the header for an empty table, if False return an empty string """
 
         options = self._get_options(kwargs)
 
-        bits = []
+        lines = []
 
         # Don't think too hard about an empty table
-        if self.rowcount == 0:
+        # Is this the desired behaviour?  Maybe we should still print the header?
+        if self.rowcount == 0 and (not options["print_empty"] or not options["border"]):
             return ""
 
+        # Get the rows we need to print, taking into account slicing, sorting, etc.
         rows = self._get_rows(options)
-        self._compute_widths(rows, options)
-
-        # Build rows
-        # (for now, this is done before building headers etc. because rowbits.append
-        # contains width-adjusting voodoo which has to be done first.  This is ugly
-        # and Wrong and will change soon)
-        rowbits = []
-        for row in rows:
-            rowbits.append(self._stringify_row(row, options))
-
+
+        # Turn all data in all rows into Unicode, formatted as desired
+        formatted_rows = self._format_rows(rows, options)
+
+        # Compute column widths
+        self._compute_widths(formatted_rows, options)
 
         # Add header or top of border
+        self._hrule = self._stringify_hrule(options)
         if options["header"]:
-            bits.append(self._stringify_header(options))
-        elif options["border"] and options["hrules"] != NONE:
-            bits.append(self._hrule)
+            lines.append(self._stringify_header(options))
+        elif options["border"] and options["hrules"] in (ALL, FRAME):
+            lines.append(self._hrule)
 
         # Add rows
-        bits.extend(rowbits)
+        for row in formatted_rows:
+            lines.append(self._stringify_row(row, options))
 
         # Add bottom of border
-        if options["border"] and not options["hrules"]:
-            bits.append(self._hrule)
+        if options["border"] and options["hrules"] == FRAME:
+            lines.append(self._hrule)
         
-        string = "\n".join(bits)
-        self._nonunicode = string
-        return _unicode(string)
+        return self._unicode("\n").join(lines)
 
     def _stringify_hrule(self, options):
 
         if not options["border"]:
             return ""
         lpad, rpad = self._get_padding_widths(options)
-        bits = [options["junction_char"]]
+        if options['vrules'] in (ALL, FRAME):
+            bits = [options["junction_char"]]
+        else:
+            bits = [options["horizontal_char"]]
+        # For tables with no data or fieldnames
+        if not self._field_names:
+                bits.append(options["junction_char"])
+                return "".join(bits)
         for field, width in zip(self._field_names, self._widths):
             if options["fields"] and field not in options["fields"]:
                 continue
             bits.append((width+lpad+rpad)*options["horizontal_char"])
+            if options['vrules'] == ALL:
+                bits.append(options["junction_char"])
+            else:
+                bits.append(options["horizontal_char"])
+        if options["vrules"] == FRAME:
+            bits.pop()
             bits.append(options["junction_char"])
         return "".join(bits)
 
@@ -839,54 +1037,62 @@
         bits = []
         lpad, rpad = self._get_padding_widths(options)
         if options["border"]:
-            if options["hrules"] != NONE:
+            if options["hrules"] in (ALL, FRAME):
                 bits.append(self._hrule)
                 bits.append("\n")
+            if options["vrules"] in (ALL, FRAME):
+                bits.append(options["vertical_char"])
+            else:
+                bits.append(" ")
+        # For tables with no data or field names
+        if not self._field_names:
+            if options["vrules"] in (ALL, FRAME):
+                bits.append(options["vertical_char"])
+            else:
+                bits.append(" ")
+        for field, width, in zip(self._field_names, self._widths):
+            if options["fields"] and field not in options["fields"]:
+                continue
+            if self._header_style == "cap":
+                fieldname = field.capitalize()
+            elif self._header_style == "title":
+                fieldname = field.title()
+            elif self._header_style == "upper":
+                fieldname = field.upper()
+            elif self._header_style == "lower":
+                fieldname = field.lower()
+            else:
+                fieldname = field
+            bits.append(" " * lpad + self._justify(fieldname, width, self._align[field]) + " " * rpad)
+            if options["border"]:
+                if options["vrules"] == ALL:
+                    bits.append(options["vertical_char"])
+                else:
+                    bits.append(" ")
+        # If vrules is FRAME, then we just appended a space at the end
+        # of the last field, when we really want a vertical character
+        if options["border"] and options["vrules"] == FRAME:
+            bits.pop()
             bits.append(options["vertical_char"])
-        for field, width, in zip(self._field_names, self._widths):
-            if options["fields"] and field not in options["fields"]:
-                continue
-            if self._align[field] == "l":
-                bits.append(" " * lpad + _unicode(field).ljust(width) + " " * rpad)
-            elif self._align[field] == "r":
-                bits.append(" " * lpad + _unicode(field).rjust(width) + " " * rpad)
-            else:
-                bits.append(" " * lpad + _unicode(field).center(width) + " " * rpad)
-            if options["border"]:
-                bits.append(options["vertical_char"])
         if options["border"] and options["hrules"] != NONE:
             bits.append("\n")
             bits.append(self._hrule)
         return "".join(bits)
 
     def _stringify_row(self, row, options):
-        
-        for index, value in enumerate(row):
-            row[index] = self._format_value(self.field_names[index], value)
-
+       
         for index, field, value, width, in zip(range(0,len(row)), self._field_names, row, self._widths):
             # Enforce max widths
-            max_width = self._max_width.get(field, 0)
-            lines = _unicode(value).split("\n")
+            lines = value.split("\n")
             new_lines = []
             for line in lines: 
-                if max_width and len(line) > max_width:
-                    line = textwrap.fill(line, max_width)
+                if _str_block_width(line) > width:
+                    line = textwrap.fill(line, width)
                 new_lines.append(line)
             lines = new_lines
             value = "\n".join(lines)
             row[index] = value
 
-        #old_widths = self._widths[:]
-
-        for index, field in enumerate(self._field_names):
-            namewidth = len(field)
-            datawidth = min(self._widths[index], self._max_width.get(field, self._widths[index]))
-            if options["header"]:
-               self._widths[index] = max(namewidth, datawidth)
-            else:
-               self._widths[index] = datawidth
-        
         row_height = 0
         for c in row:
             h = _get_size(c)[1]
@@ -898,31 +1104,43 @@
         for y in range(0, row_height):
             bits.append([])
             if options["border"]:
-                bits[y].append(self.vertical_char)
+                if options["vrules"] in (ALL, FRAME):
+                    bits[y].append(self.vertical_char)
+                else:
+                    bits[y].append(" ")
 
         for field, value, width, in zip(self._field_names, row, self._widths):
 
-            lines = _unicode(value).split("\n")
-            if len(lines) < row_height:
-                lines = lines + ([""] * (row_height-len(lines)))
+            valign = self._valign[field]
+            lines = value.split("\n")
+            dHeight = row_height - len(lines)
+            if dHeight:
+                if valign == "m":
+                  lines = [""] * int(dHeight / 2) + lines + [""] * (dHeight - int(dHeight / 2))
+                elif valign == "b":
+                  lines = [""] * dHeight + lines
+                else:
+                  lines = lines + [""] * dHeight
 
             y = 0
             for l in lines:
                 if options["fields"] and field not in options["fields"]:
                     continue
 
-                if self._align[field] == "l":
-                    bits[y].append(" " * lpad + _unicode(l).ljust(width) + " " * rpad)
-                elif self._align[field] == "r":
-                    bits[y].append(" " * lpad + _unicode(l).rjust(width) + " " * rpad)
-                else:
-                    bits[y].append(" " * lpad + _unicode(l).center(width) + " " * rpad)
+                bits[y].append(" " * lpad + self._justify(l, width, self._align[field]) + " " * rpad)
                 if options["border"]:
-                    bits[y].append(self.vertical_char)
-
+                    if options["vrules"] == ALL:
+                        bits[y].append(self.vertical_char)
+                    else:
+                        bits[y].append(" ")
                 y += 1
 
-        self._hrule = self._stringify_hrule(options)
+        # If vrules is FRAME, then we just appended a space at the end
+        # of the last field, when we really want a vertical character
+        for y in range(0, row_height):
+            if options["border"] and options["vrules"] == FRAME:
+                bits[y].pop()
+                bits[y].append(options["vertical_char"])
         
         if options["border"] and options["hrules"]== ALL:
             bits[row_height-1].append("\n")
@@ -931,8 +1149,6 @@
         for y in range(0, row_height):
             bits[y] = "".join(bits[y])
 
-        #self._widths = old_widths
-
         return "\n".join(bits)
 
     ##############################
@@ -950,15 +1166,17 @@
         fields - names of fields (columns) to include
         header - print a header showing field names (True or False)
         border - print a border around the table (True or False)
-        hrules - controls printing of horizontal rules after rows.  Allowed values: FRAME, ALL, NONE
-	int_format - controls formatting of integer data
-	float_format - controls formatting of floating point data
+        hrules - controls printing of horizontal rules after rows.  Allowed values: ALL, FRAME, HEADER, NONE
+        vrules - controls printing of vertical rules between columns.  Allowed values: FRAME, ALL, NONE
+        int_format - controls formatting of integer data
+        float_format - controls formatting of floating point data
         padding_width - number of spaces on either side of column data (only used if left and right paddings are None)
         left_padding_width - number of spaces on left hand side of column data
         right_padding_width - number of spaces on right hand side of column data
         sortby - name of field to sort rows by
         sort_key - sorting key function, applied to data points before sorting
-        attributes - dictionary of name/value pairs to include as HTML attributes in the <table> tag"""
+        attributes - dictionary of name/value pairs to include as HTML attributes in the <table> tag
+        xhtml - print <br/> tags if True, <br> tags if false"""
 
         options = self._get_options(kwargs)
 
@@ -967,97 +1185,282 @@
         else:
             string = self._get_simple_html_string(options)
 
-        self._nonunicode = string
-        return _unicode(string)
+        return string
 
     def _get_simple_html_string(self, options):
 
-        bits = []
-        # Slow but works
-        table_tag = '<table'
-        if options["border"]:
-            table_tag += ' border="1"'
+        lines = []
+        if options["xhtml"]:
+            linebreak = "<br/>"
+        else:
+            linebreak = "<br>"
+
+        open_tag = []
+        open_tag.append("<table")
         if options["attributes"]:
             for attr_name in options["attributes"]:
-                table_tag += ' %s="%s"' % (attr_name, options["attributes"][attr_name])
-        table_tag += '>'
-        bits.append(table_tag)
+                open_tag.append(" %s=\"%s\"" % (attr_name, options["attributes"][attr_name]))
+        open_tag.append(">")
+        lines.append("".join(open_tag))
 
         # Headers
         if options["header"]:
-            bits.append("    <tr>")
+            lines.append("    <tr>")
             for field in self._field_names:
                 if options["fields"] and field not in options["fields"]:
                     continue
-                bits.append("        <th>%s</th>" % escape(_unicode(field)).replace("\n", "<br />"))
-            bits.append("    </tr>")
+                lines.append("        <th>%s</th>" % escape(field).replace("\n", linebreak))
+            lines.append("    </tr>")
 
         # Data
         rows = self._get_rows(options)
-        for row in rows:
-            bits.append("    <tr>")
+        formatted_rows = self._format_rows(rows, options)
+        for row in formatted_rows:
+            lines.append("    <tr>")
             for field, datum in zip(self._field_names, row):
                 if options["fields"] and field not in options["fields"]:
                     continue
-                bits.append("        <td>%s</td>" % escape(_unicode(datum)).replace("\n", "<br />"))
-            bits.append("    </tr>")
-
-        bits.append("</table>")
-        string = "\n".join(bits)
-
-        self._nonunicode = string
-        return _unicode(string)
+                lines.append("        <td>%s</td>" % escape(datum).replace("\n", linebreak))
+            lines.append("    </tr>")
+
+        lines.append("</table>")
+
+        return self._unicode("\n").join(lines)
 
     def _get_formatted_html_string(self, options):
 
-        bits = []
+        lines = []
         lpad, rpad = self._get_padding_widths(options)
-        # Slow but works
-        table_tag = '<table'
+        if options["xhtml"]:
+            linebreak = "<br/>"
+        else:
+            linebreak = "<br>"
+
+        open_tag = []
+        open_tag.append("<table")
         if options["border"]:
-            table_tag += ' border="1"'
-        if options["hrules"] == NONE:
-            table_tag += ' frame="vsides" rules="cols"'
+            if options["hrules"] == ALL and options["vrules"] == ALL:
+                open_tag.append(" frame=\"box\" rules=\"all\"")
+            elif options["hrules"] == FRAME and options["vrules"] == FRAME:
+                open_tag.append(" frame=\"box\"")
+            elif options["hrules"] == FRAME and options["vrules"] == ALL:
+                open_tag.append(" frame=\"box\" rules=\"cols\"")
+            elif options["hrules"] == FRAME:
+                open_tag.append(" frame=\"hsides\"")
+            elif options["hrules"] == ALL:
+                open_tag.append(" frame=\"hsides\" rules=\"rows\"")
+            elif options["vrules"] == FRAME:
+                open_tag.append(" frame=\"vsides\"")
+            elif options["vrules"] == ALL:
+                open_tag.append(" frame=\"vsides\" rules=\"cols\"")
         if options["attributes"]:
             for attr_name in options["attributes"]:
-                table_tag += ' %s="%s"' % (attr_name, options["attributes"][attr_name])
-        table_tag += '>'
-        bits.append(table_tag)
+                open_tag.append(" %s=\"%s\"" % (attr_name, options["attributes"][attr_name]))
+        open_tag.append(">")
+        lines.append("".join(open_tag))
+
         # Headers
         if options["header"]:
-            bits.append("    <tr>")
+            lines.append("    <tr>")
             for field in self._field_names:
                 if options["fields"] and field not in options["fields"]:
                     continue
-                bits.append("        <th style=\"padding-left: %dem; padding-right: %dem; text-align: center\">%s</th>" % (lpad, rpad, escape(_unicode(field)).replace("\n", "<br />")))
-            bits.append("    </tr>")
+                lines.append("        <th style=\"padding-left: %dem; padding-right: %dem; text-align: center\">%s</th>" % (lpad, rpad, escape(field).replace("\n", linebreak)))
+            lines.append("    </tr>")
+
         # Data
         rows = self._get_rows(options)
-        for row in self._rows:
-            bits.append("    <tr>")
-            for field, datum in zip(self._field_names, row):
+        formatted_rows = self._format_rows(rows, options)
+        aligns = []
+        valigns = []
+        for field in self._field_names:
+            aligns.append({ "l" : "left", "r" : "right", "c" : "center" }[self._align[field]])
+            valigns.append({"t" : "top", "m" : "middle", "b" : "bottom"}[self._valign[field]])
+        for row in formatted_rows:
+            lines.append("    <tr>")
+            for field, datum, align, valign in zip(self._field_names, row, aligns, valigns):
                 if options["fields"] and field not in options["fields"]:
                     continue
-                if self._align[field] == "l":
-                    bits.append("        <td style=\"padding-left: %dem; padding-right: %dem; text-align: left\">%s</td>" % (lpad, rpad, escape(_unicode(datum)).replace("\n", "<br />")))
-                elif self._align[field] == "r":
-                    bits.append("        <td style=\"padding-left: %dem; padding-right: %dem; text-align: right\">%s</td>" % (lpad, rpad, escape(_unicode(datum)).replace("\n", "<br />")))
-                else:
-                    bits.append("        <td style=\"padding-left: %dem; padding-right: %dem; text-align: center\">%s</td>" % (lpad, rpad, escape(_unicode(datum)).replace("\n", "<br />")))
-            bits.append("    </tr>")
-        bits.append("</table>")
-        string = "\n".join(bits)
-
-        self._nonunicode = string
-        return _unicode(string)
+                lines.append("        <td style=\"padding-left: %dem; padding-right: %dem; text-align: %s; vertical-align: %s\">%s</td>" % (lpad, rpad, align, valign, escape(datum).replace("\n", linebreak)))
+            lines.append("    </tr>")
+        lines.append("</table>")
+
+        return self._unicode("\n").join(lines)
+
+##############################
+# UNICODE WIDTH FUNCTIONS    #
+##############################
+
+def _char_block_width(char):
+    # Basic Latin, which is probably the most common case
+    #if char in xrange(0x0021, 0x007e):
+    #if char >= 0x0021 and char <= 0x007e:
+    if 0x0021 <= char <= 0x007e:
+        return 1
+    # Chinese, Japanese, Korean (common)
+    if 0x4e00 <= char <= 0x9fff:
+        return 2
+    # Hangul
+    if 0xac00 <= char <= 0xd7af:
+        return 2
+    # Combining?
+    if unicodedata.combining(uni_chr(char)):
+        return 0
+    # Hiragana and Katakana
+    if 0x3040 <= char <= 0x309f or 0x30a0 <= char <= 0x30ff:
+        return 2
+    # Full-width Latin characters
+    if 0xff01 <= char <= 0xff60:
+        return 2
+    # CJK punctuation
+    if 0x3000 <= char <= 0x303e:
+        return 2
+    # Backspace and delete
+    if char in (0x0008, 0x007f):
+        return -1
+    # Other control characters
+    elif char in (0x0000, 0x001f):
+        return 0
+    # Take a guess
+    return 1
+
+def _str_block_width(val):
+
+    return sum(itermap(_char_block_width, itermap(ord, _re.sub("", val))))
+
+##############################
+# TABLE FACTORIES            #
+##############################
+
+def from_csv(fp, field_names = None, **kwargs):
+
+    dialect = csv.Sniffer().sniff(fp.read(1024))
+    fp.seek(0)
+    reader = csv.reader(fp, dialect)
+
+    table = PrettyTable(**kwargs)
+    if field_names:
+        table.field_names = field_names
+    else:
+        if py3k:
+            table.field_names = [x.strip() for x in next(reader)]
+        else:
+            table.field_names = [x.strip() for x in reader.next()]
+
+    for row in reader:
+        table.add_row([x.strip() for x in row])
+
+    return table
+
+def from_db_cursor(cursor, **kwargs):
+
+    if cursor.description:
+        table = PrettyTable(**kwargs)
+        table.field_names = [col[0] for col in cursor.description]
+        for row in cursor.fetchall():
+            table.add_row(row)
+        return table
+
+class TableHandler(HTMLParser):
+
+    def __init__(self, **kwargs):
+        HTMLParser.__init__(self)
+        self.kwargs = kwargs
+        self.tables = []
+        self.last_row = []
+        self.rows = []
+        self.max_row_width = 0
+        self.active = None
+        self.last_content = ""
+        self.is_last_row_header = False
+
+    def handle_starttag(self,tag, attrs):
+        self.active = tag
+        if tag == "th":
+            self.is_last_row_header = True
+
+    def handle_endtag(self,tag):
+        if tag in ["th", "td"]:
+            stripped_content = self.last_content.strip()
+            self.last_row.append(stripped_content)
+        if tag == "tr":
+            self.rows.append(
+                (self.last_row, self.is_last_row_header))
+            self.max_row_width = max(self.max_row_width, len(self.last_row))
+            self.last_row = []
+            self.is_last_row_header = False
+        if tag == "table":
+            table = self.generate_table(self.rows)
+            self.tables.append(table)
+            self.rows = []
+        self.last_content = " "
+        self.active = None
+
+
+    def handle_data(self, data):
+        self.last_content += data
+
+    def generate_table(self, rows):
+        """
+        Generates from a list of rows a PrettyTable object.
+        """
+        table = PrettyTable(**self.kwargs)
+        for row in self.rows:
+            if len(row[0]) < self.max_row_width:
+                appends = self.max_row_width - len(row[0])
+                for i in range(1,appends):
+                    row[0].append("-")
+
+            if row[1] == True:
+                self.make_fields_unique(row[0])
+                table.field_names = row[0]
+            else:
+                table.add_row(row[0])
+        return table
+
+    def make_fields_unique(self, fields):
+        """
+        iterates over the row and make each field unique
+        """
+        for i in range(0, len(fields)):
+            for j in range(i+1, len(fields)):
+                if fields[i] == fields[j]:
+                    fields[j] += "'"
+
+def from_html(html_code, **kwargs):
+    """
+    Generates a list of PrettyTables from a string of HTML code. Each <table> in
+    the HTML becomes one PrettyTable object.
+    """
+
+    parser = TableHandler(**kwargs)
+    parser.feed(html_code)
+    return parser.tables
+
+def from_html_one(html_code, **kwargs):
+    """
+    Generates a PrettyTables from a string of HTML code which contains only a
+    single <table>
+    """
+
+    tables = from_html(html_code, **kwargs)
+    try:
+        assert len(tables) == 1
+    except AssertionError:
+        raise Exception("More than one <table> in provided HTML code!  Use from_html instead.")
+    return tables[0]
+
+##############################
+# MAIN (TEST FUNCTION)       #
+##############################
 
 def main():
 
     x = PrettyTable(["City name", "Area", "Population", "Annual Rainfall"])
     x.sortby = "Population"
     x.reversesort = True
-    x.int_format["Area"] = "04"
-    x.float_format = "6.1"
+    x.int_format["Area"] = "04d"
+    x.float_format = "6.1f"
     x.align["City name"] = "l" # Left align city names
     x.add_row(["Adelaide", 1295, 1158259, 600.5])
     x.add_row(["Brisbane", 5905, 1857594, 1146.4])

=== modified file 'prettytable_test.py'
--- prettytable_test.py	2012-06-06 19:30:29 +0000
+++ prettytable_test.py	2013-11-19 02:16:58 +0000
@@ -1,8 +1,20 @@
-import unittest
+# coding=UTF-8
+
+from prettytable import *
+
 import sys
-sys.path.append("../src/")
+py3k = sys.version_info[0] >= 3
+try:
+    import sqlite3
+    _have_sqlite = True
+except ImportError:
+    _have_sqlite = False
+if py3k:
+    import io as StringIO
+else:
+    import StringIO
 from math import pi, e, sqrt
-from prettytable import *
+import unittest
 
 class BuildEquivelanceTest(unittest.TestCase):
 
@@ -98,7 +110,7 @@
 
 class OptionOverrideTests(CityDataTest):
 
-    """Make sure all options are properly overwritten by printt."""
+    """Make sure all options are properly overwritten by get_string."""
 
     def testBorder(self):
         default = self.x.get_string()
@@ -121,6 +133,42 @@
         override = self.x.get_string(hrules=NONE)
         self.assertTrue(default != override)
 
+class OptionAttributeTests(CityDataTest):
+
+    """Make sure all options which have an attribute interface work as they should.
+    Also make sure option settings are copied correctly when a table is cloned by
+    slicing."""
+
+    def testSetForAllColumns(self):
+        self.x.field_names = sorted(self.x.field_names)
+        self.x.align = "l"
+        self.x.max_width = 10
+        self.x.start = 2
+        self.x.end = 4
+        self.x.sortby = "Area"
+        self.x.reversesort = True
+        self.x.header = True
+        self.x.border = False
+        self.x.hrule = True
+        self.x.int_format = "4"
+        self.x.float_format = "2.2"
+        self.x.padding_width = 2
+        self.x.left_padding_width = 2
+        self.x.right_padding_width = 2
+        self.x.vertical_char = "!"
+        self.x.horizontal_char = "~"
+        self.x.junction_char = "*"
+        self.x.format = True
+        self.x.attributes = {"class" : "prettytable"}
+        assert self.x.get_string() == self.x[:].get_string()
+
+    def testSetForOneColumn(self):
+        self.x.align["Rainfall"] = "l"
+        self.x.max_width["Name"] = 10
+        self.x.int_format["Population"] = "4"
+        self.x.float_format["Area"] = "2.2"
+        assert self.x.get_string() == self.x[:].get_string()
+
 class BasicTests(CityDataTest):
 
     """Some very basic tests."""
@@ -175,6 +223,25 @@
         BasicTests.setUp(self)
         self.x.hrules = ALL
 
+class EmptyTableTests(CityDataTest):
+
+    """Make sure the print_empty option works"""
+
+    def setUp(self):
+        CityDataTest.setUp(self)
+        self.y = PrettyTable()
+        self.y.field_names = ["City name", "Area", "Population", "Annual Rainfall"]
+
+    def testPrintEmptyTrue(self):
+        assert self.y.get_string(print_empty=True) != ""
+        assert self.x.get_string(print_empty=True) != self.y.get_string(print_empty=True)
+
+    def testPrintEmptyFalse(self):
+        assert self.y.get_string(print_empty=False) == ""
+        assert self.y.get_string(print_empty=False) != self.x.get_string(print_empty=False)
+
+    def testInteractionWithBorder(self):
+        assert self.y.get_string(border=False, print_empty=True) == ""
 class PresetBasicTests(BasicTests):
 
     """Run the basic tests after using set_style"""
@@ -188,6 +255,10 @@
     def setUp(self):
         CityDataTest.setUp(self)
 
+    def testSliceAll(self):
+        y = self.x[:]
+        assert self.x.get_string() == y.get_string()
+
     def testSliceFirstTwoRows(self):
         y = self.x[0:2]
         string = y.get_string()
@@ -265,7 +336,7 @@
 
     def setUp(self):
         BasicTests.setUp(self)
-        self.x.float_format = "6.2"
+        self.x.float_format = "6.2f"
 
 class FloatFormatTests(unittest.TestCase):
 
@@ -276,12 +347,12 @@
         self.x.add_row(["sqrt(2)", sqrt(2)]) 
 
     def testNoDecimals(self):
-        self.x.float_format = ".0"
+        self.x.float_format = ".0f"
         self.x.caching = False
         assert "." not in self.x.get_string()
 
     def testRoundTo5DP(self):
-        self.x.float_format = ".5"
+        self.x.float_format = ".5f"
         string = self.x.get_string()
         assert "3.14159" in string
         assert "3.141592" not in string
@@ -292,7 +363,7 @@
         assert "1.414213" not in string
 
     def testPadWith2Zeroes(self):
-        self.x.float_format = "06.2"
+        self.x.float_format = "06.2f"
         string = self.x.get_string()
         assert "003.14" in string
         assert "002.72" in string
@@ -303,7 +374,7 @@
         t = PrettyTable(['Field 1', 'Field 2'])
         t.add_row(['value 1', 'value2\nsecond line'])
         t.add_row(['value 3', 'value4'])
-        result = t.get_string(hrules=True)
+        result = t.get_string(hrules=ALL)
         assert result.strip() == """
 +---------+-------------+
 | Field 1 |   Field 2   |
@@ -318,7 +389,7 @@
         t = PrettyTable(['Field 1', 'Field 2'])
         t.add_row(['value 1', 'value2\nsecond line'])
         t.add_row(['value 3\n\nother line', 'value4\n\n\nvalue5'])
-        result = t.get_string(hrules=True)
+        result = t.get_string(hrules=ALL)
         assert result.strip() == """
 +------------+-------------+
 |  Field 1   |   Field 2   |
@@ -354,16 +425,16 @@
         t = PrettyTable(['Field 1', 'Field 2'])
         t.add_row(['value 1', 'value2\nsecond line'])
         t.add_row(['value 3', 'value4'])
-        result = t.get_html_string(hrules=True)
+        result = t.get_html_string(hrules=ALL)
         assert result.strip() == """
-<table border="1">
+<table>
     <tr>
         <th>Field 1</th>
         <th>Field 2</th>
     </tr>
     <tr>
         <td>value 1</td>
-        <td>value2<br />second line</td>
+        <td>value2<br>second line</td>
     </tr>
     <tr>
         <td>value 3</td>
@@ -373,6 +444,7 @@
 """.strip()
 
 class HtmlOutputTests(unittest.TestCase):
+
     def testHtmlOutput(self):
         t = PrettyTable(['Field 1', 'Field 2', 'Field 3'])
         t.add_row(['value 1', 'value2', 'value3'])
@@ -380,7 +452,7 @@
         t.add_row(['value 7', 'value8', 'value9'])
         result = t.get_html_string()
         assert result.strip() == """
-<table border="1">
+<table>
     <tr>
         <th>Field 1</th>
         <th>Field 2</th>
@@ -411,29 +483,106 @@
         t.add_row(['value 7', 'value8', 'value9'])
         result = t.get_html_string(format=True)
         assert result.strip() == """
-<table border="1">
+<table frame="box" rules="cols">
     <tr>
         <th style="padding-left: 1em; padding-right: 1em; text-align: center">Field 1</th>
         <th style="padding-left: 1em; padding-right: 1em; text-align: center">Field 2</th>
         <th style="padding-left: 1em; padding-right: 1em; text-align: center">Field 3</th>
     </tr>
     <tr>
-        <td style="padding-left: 1em; padding-right: 1em; text-align: center">value 1</td>
-        <td style="padding-left: 1em; padding-right: 1em; text-align: center">value2</td>
-        <td style="padding-left: 1em; padding-right: 1em; text-align: center">value3</td>
-    </tr>
-    <tr>
-        <td style="padding-left: 1em; padding-right: 1em; text-align: center">value 4</td>
-        <td style="padding-left: 1em; padding-right: 1em; text-align: center">value5</td>
-        <td style="padding-left: 1em; padding-right: 1em; text-align: center">value6</td>
-    </tr>
-    <tr>
-        <td style="padding-left: 1em; padding-right: 1em; text-align: center">value 7</td>
-        <td style="padding-left: 1em; padding-right: 1em; text-align: center">value8</td>
-        <td style="padding-left: 1em; padding-right: 1em; text-align: center">value9</td>
+        <td style="padding-left: 1em; padding-right: 1em; text-align: center; vertical-align: top">value 1</td>
+        <td style="padding-left: 1em; padding-right: 1em; text-align: center; vertical-align: top">value2</td>
+        <td style="padding-left: 1em; padding-right: 1em; text-align: center; vertical-align: top">value3</td>
+    </tr>
+    <tr>
+        <td style="padding-left: 1em; padding-right: 1em; text-align: center; vertical-align: top">value 4</td>
+        <td style="padding-left: 1em; padding-right: 1em; text-align: center; vertical-align: top">value5</td>
+        <td style="padding-left: 1em; padding-right: 1em; text-align: center; vertical-align: top">value6</td>
+    </tr>
+    <tr>
+        <td style="padding-left: 1em; padding-right: 1em; text-align: center; vertical-align: top">value 7</td>
+        <td style="padding-left: 1em; padding-right: 1em; text-align: center; vertical-align: top">value8</td>
+        <td style="padding-left: 1em; padding-right: 1em; text-align: center; vertical-align: top">value9</td>
     </tr>
 </table>
 """.strip()
 
+class CsvConstructorTest(BasicTests):
+
+    def setUp(self):
+
+        csv_string = """City name, Area , Population , Annual Rainfall
+        Sydney, 2058 ,  4336374   ,      1214.8
+        Melbourne, 1566 ,  3806092   ,       646.9
+        Brisbane, 5905 ,  1857594   ,      1146.4
+        Perth, 5386 ,  1554769   ,       869.4
+        Adelaide, 1295 ,  1158259   ,       600.5
+        Hobart, 1357 ,   205556   ,       619.5
+        Darwin, 0112 ,   120900   ,      1714.7"""
+        csv_fp = StringIO.StringIO(csv_string)
+        self.x = from_csv(csv_fp)
+
+if _have_sqlite:
+    class DatabaseConstructorTest(BasicTests):
+
+        def setUp(self):
+            self.conn = sqlite3.connect(":memory:")
+            self.cur = self.conn.cursor()
+            self.cur.execute("CREATE TABLE cities (name TEXT, area INTEGER, population INTEGER, rainfall REAL)")
+            self.cur.execute("INSERT INTO cities VALUES (\"Adelaide\", 1295, 1158259, 600.5)")
+            self.cur.execute("INSERT INTO cities VALUES (\"Brisbane\", 5905, 1857594, 1146.4)")
+            self.cur.execute("INSERT INTO cities VALUES (\"Darwin\", 112, 120900, 1714.7)")
+            self.cur.execute("INSERT INTO cities VALUES (\"Hobart\", 1357, 205556, 619.5)")
+            self.cur.execute("INSERT INTO cities VALUES (\"Sydney\", 2058, 4336374, 1214.8)")
+            self.cur.execute("INSERT INTO cities VALUES (\"Melbourne\", 1566, 3806092, 646.9)")
+            self.cur.execute("INSERT INTO cities VALUES (\"Perth\", 5386, 1554769, 869.4)")
+            self.cur.execute("SELECT * FROM cities")
+            self.x = from_db_cursor(self.cur)
+
+        def testNonSelectCurosr(self):
+            self.cur.execute("INSERT INTO cities VALUES (\"Adelaide\", 1295, 1158259, 600.5)")
+            assert from_db_cursor(self.cur) is None
+
+class HtmlConstructorTest(CityDataTest):
+
+    def testHtmlAndBack(self):
+        html_string = self.x.get_html_string()
+        new_table = from_html(html_string)[0]
+        assert new_table.get_string() == self.x.get_string()
+
+    def testHtmlOneAndBack(self):
+        html_string = self.x.get_html_string()
+        new_table = from_html_one(html_string)
+        assert new_table.get_string() == self.x.get_string()
+
+    def testHtmlOneFailOnMany(self):
+        html_string = self.x.get_html_string()
+        html_string += self.x.get_html_string()
+        self.assertRaises(Exception, from_html_one, html_string)
+
+class PrintEnglishTest(CityDataTest):
+
+    def testPrint(self):
+        print()
+        print(self.x)
+
+class PrintJapanestTest(unittest.TestCase):
+
+    def setUp(self):
+
+        self.x = PrettyTable(["Kanji", "Hiragana", "English"])
+        self.x.add_row(["神戸", "こうべ", "Kobe"])
+        self.x.add_row(["京都", "きょうと", "Kyoto"])
+        self.x.add_row(["長崎", "ながさき", "Nagasaki"])
+        self.x.add_row(["名古屋", "なごや", "Nagoya"])
+        self.x.add_row(["大阪", "おおさか", "Osaka"])
+        self.x.add_row(["札幌", "さっぽろ", "Sapporo"])
+        self.x.add_row(["東京", "とうきょう", "Tokyo"])
+        self.x.add_row(["横浜", "よこはま", "Yokohama"])
+
+    def testPrint(self):
+        print()
+        print(self.x)
+
 if __name__ == "__main__":
     unittest.main()

=== modified file 'setup.py'
--- setup.py	2012-06-06 19:30:29 +0000
+++ setup.py	2013-11-19 02:16:58 +0000
@@ -7,6 +7,8 @@
     version=version,
     classifiers=[
         'Programming Language :: Python',
+        'Programming Language :: Python :: 2.4',
+        'Programming Language :: Python :: 2.5',
         'Programming Language :: Python :: 2.6',
         'Programming Language :: Python :: 2.7',
         'Programming Language :: Python :: 3',