renamed decorator to tagger

Author: anselor

examples/formatters.py

@@ -75,8 +75,9 @@ def int2word(num, separator="-"):
         print("num out of range")
 
 
-def decorate_row_obj(row_obj: MyRowObject) -> dict:
-    """Example row decorator function processing row objects"""
+def tag_row_obj(row_obj: MyRowObject) -> dict:
+    """Example row tagging function processing row objects and returning
+    optional properties"""
     opts = dict()
     if row_obj.field4 % 4 == 0:
         opts[tf.TableFormatter.ROW_OPT_TEXT_COLOR] = tf.TableColors.TEXT_COLOR_GREEN
@@ -99,12 +100,12 @@ def decorate_row_obj(row_obj: MyRowObject) -> dict:
            tf.Column('Multiplied', obj_formatter=multiply))
 
 print("Formatters on object-based row entries")
-print(tf.generate_table(rows, columns, row_decorator=decorate_row_obj))
+print(tf.generate_table(rows, columns, row_tagger=tag_row_obj))
 
 
-def decorate_row_tuples(row_tuple: Tuple) -> dict:
+def tag_row_tuples(row_tuple: Tuple) -> dict:
     """
-    Example decorator function processing row tuples/iterables
+    Example row tagging function processing row tuples/iterables
 
     Note that this is the tuple as provided to the TableFormatter prior
     to display formatting performed on each column
@@ -130,4 +131,4 @@ def decorate_row_tuples(row_tuple: Tuple) -> dict:
            tf.Column('Multiplied', obj_formatter=multiply_tuple))
 
 print("Formatters on tuple-based row entries")
-print(tf.generate_table(rows, columns, row_decorator=decorate_row_tuples))
+print(tf.generate_table(rows, columns, row_tagger=tag_row_tuples))

tableformatter.py

@@ -604,15 +604,15 @@ def generate_table(rows: Iterable[Union[Iterable, object]],
                    columns: Collection[Union[str, Tuple[str, dict]]]=None,
                    grid_style: Optional[Grid]=None,
                    transpose: bool=False,
-                   row_decorator: Callable=None) -> str:
+                   row_tagger: Callable=None) -> str:
     """
     Convenience function to easily generate a table from rows/columns
 
     :param rows: iterable of objects or iterable fields
     :param columns: Iterable of column definitions
     :param grid_style: The grid style to use
     :param transpose: Transpose the rows/columns for display
-    :param row_decorator: decorator function to apply per-row options
+    :param row_tagger: decorator function to apply per-row options
     :return: formatted string containing the table
     """
     show_headers = True
@@ -646,7 +646,7 @@ def generate_table(rows: Iterable[Union[Iterable, object]],
     if grid_style is None:
         grid_style = DEFAULT_GRID
     formatter = TableFormatter(columns, grid_style=grid_style, show_header=show_headers,
-                               use_attribs=use_attrib, transpose=transpose, row_decorator=row_decorator)
+                               use_attribs=use_attrib, transpose=transpose, row_tagger=row_tagger)
     return formatter.generate_table(rows)
 
 
@@ -763,7 +763,7 @@ def __init__(self,
                  use_attribs=False,
                  transpose=False,
                  row_show_header=False,
-                 row_decorator: Callable=None):
+                 row_tagger: Callable=None):
         """
         :param columns: list of either column names or tuples of (column name, dict of column options)
         :param cell_padding: number of spaces to pad to the left/right of each column
@@ -789,7 +789,7 @@ def __init__(self,
                              TableFormatter.TABLE_OPT_TRANSPOSE: transpose,
                              TableFormatter.TABLE_OPT_ROW_HEADER: row_show_header}
         self._show_header = show_header
-        self._row_decorator = row_decorator
+        self._row_tagger = row_tagger
 
         for col_index, column in enumerate(columns):
             if isinstance(column, tuple) and len(column) > 1 and isinstance(column[1], dict):
@@ -925,12 +925,12 @@ def generate_table(self, entries: Iterable[Union[Iterable, object]], force_trans
                 except TypeError:
                     # not iterable, so we just use the object directly
                     entry_obj = entry
-                    if self._row_decorator is not None:
-                        entry_opts = self._row_decorator(entry_obj)
+                    if self._row_tagger is not None:
+                        entry_opts = self._row_tagger(entry_obj)
                 else:
                     entry_obj = entry[0]
-                    if self._row_decorator is not None:
-                        entry_opts = self._row_decorator(entry_obj)
+                    if self._row_tagger is not None:
+                        entry_opts = self._row_tagger(entry_obj)
                     if len(entry) == 2 and isinstance(entry[1], dict):
                         entry_opts.update(entry[1])
 
@@ -966,8 +966,8 @@ def generate_table(self, entries: Iterable[Union[Iterable, object]], force_trans
                     row.append(field_lines)
 
             else:
-                if self._row_decorator is not None:
-                    entry_opts = self._row_decorator(entry)
+                if self._row_tagger is not None:
+                    entry_opts = self._row_tagger(entry)
                 if len(entry) == len(self._columns) + 1 and isinstance(entry[len(self._columns)], dict):
                     # if there is exactly 1 more entry than columns, the last one is metadata
                     entry_opts.update(entry[len(self._columns)])