Revert "Revert "pylint: upgrade to 1.3.1""

third_party/logilab/common/table.py

-# copyright 2003-2011 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
+# copyright 2003-2012 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
 # contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
 #
 # This file is part of logilab-common.
 #
 # logilab-common is free software: you can redistribute it and/or modify it under
 # the terms of the GNU Lesser General Public License as published by the Free
 # Software Foundation, either version 2.1 of the License, or (at your option) any
 # later version.
 #
 # logilab-common is distributed in the hope that it will be useful, but WITHOUT
 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 # FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
 # details.
 #
 # You should have received a copy of the GNU Lesser General Public License along
 # with logilab-common.  If not, see <http://www.gnu.org/licenses/>.
 """Table management module."""
+
+from __future__ import print_function
+
 __docformat__ = "restructuredtext en"
 
+from six.moves import range
 
 class Table(object):
     """Table defines a data table with column and row names.
     inv:
         len(self.data) <= len(self.row_names)
         forall(self.data, lambda x: len(x) <= len(self.col_names))
     """
 
     def __init__(self, default_value=0, col_names=None, row_names=None):
         self.col_names = []
@@ skipping 10 matching lines @@
 
     def __iter__(self):
         return iter(self.data)
 
     def __eq__(self, other):
         if other is None:
             return False
         else:
             return list(self) == list(other)
 
+    __hash__ = object.__hash__
+
     def __ne__(self, other):
         return not self == other
 
     def __len__(self):
         return len(self.row_names)
 
     ## Rows / Columns creation #################################################
     def create_rows(self, row_names):
         """Appends row_names to the list of existing rows
         """
@@ skipping 372 matching lines @@
         for row_name in self.row_names:
             if len(row_name) > max_row_name:
                 max_row_name = len(row_name)
         col_start = max_row_name + 5
 
         lines = []
         # Build the 'first' line <=> the col_names one
         # The first cell <=> an empty one
         col_names_line = [' '*col_start]
         for col_name in self.col_names:
-            col_names_line.append(col_name.encode('iso-8859-1') + ' '*5)
+            col_names_line.append(col_name + ' '*5)
         lines.append('|' + '|'.join(col_names_line) + '|')
         max_line_length = len(lines[0])
 
         # Build the table
         for row_index, row in enumerate(self.data):
             line = []
             # First, build the row_name's cell
-            row_name = self.row_names[row_index].encode('iso-8859-1')
+            row_name = self.row_names[row_index]
             line.append(row_name + ' '*(col_start-len(row_name)))
 
             # Then, build all the table's cell for this line.
             for col_index, cell in enumerate(row):
                 col_name_length = len(self.col_names[col_index]) + 5
                 data = str(cell)
                 line.append(data + ' '*(col_name_length - len(data)))
             lines.append('|' + '|'.join(line) + '|')
             if len(lines[-1]) > max_line_length:
                 max_line_length = len(lines[-1])
@@ skipping 179 matching lines @@
     def add_rule(self, rule):
         """Adds a rule to the stylesheet rules
         """
         try:
             source_code = ['from math import *']
             source_code.append(CELL_PROG.sub(r'self.data[\1][\2]', rule))
             self.instructions.append(compile('\n'.join(source_code),
                 'table.py', 'exec'))
             self.rules.append(rule)
         except SyntaxError:
-            print "Bad Stylesheet Rule : %s [skipped]"%rule
+            print("Bad Stylesheet Rule : %s [skipped]" % rule)
 
 
     def add_rowsum_rule(self, dest_cell, row_index, start_col, end_col):
         """Creates and adds a rule to sum over the row at row_index from
         start_col to end_col.
         dest_cell is a tuple of two elements (x,y) of the destination cell
         No check is done for indexes ranges.
         pre:
             start_col >= 0
             end_col > start_col
@@ skipping 74 matching lines @@
         cell_value = table.data[row_index][col_index]
         final_content = self._make_cell_content(cell_value,
                                                 table_style, col_index  +1)
         return self._render_cell_content(final_content,
                                          table_style, col_index + 1)
 
 
     def render_row_cell(self, row_name, table, table_style):
         """Renders the cell for 'row_id' row
         """
-        cell_value = row_name.encode('iso-8859-1')
+        cell_value = row_name
         return self._render_cell_content(cell_value, table_style, 0)
 
 
     def render_col_cell(self, col_name, table, table_style):
         """Renders the cell for 'col_id' row
         """
-        cell_value = col_name.encode('iso-8859-1')
+        cell_value = col_name
         col_index = table.col_names.index(col_name)
         return self._render_cell_content(cell_value, table_style, col_index +1)
 
 
 
     def _render_cell_content(self, content, table_style, col_index):
         """Makes the appropriate rendering for this cell content.
         Rendering properties will be searched using the
         *table_style.get_xxx_by_index(col_index)' methods
 
@@ skipping 150 matching lines @@
         self._stream.write('<table>\n<title>%s></title>\n'%(title))
         self._stream.write(
             '<tgroup cols="%d" align="left" colsep="1" rowsep="1">\n'%
             (len(self._table.col_names)+1))
         self._write_headers()
         self._write_body()
 
         self._stream.write('</tgroup>\n</table>\n')