#1639 adding support for fancy tables

Author: allmightyspiff

SoftLayer/CLI/environment.py

@@ -9,6 +9,7 @@
 
 import click
 import pkg_resources
+from rich.console import Console
 
 import SoftLayer
 from SoftLayer.CLI import formatting
@@ -38,9 +39,18 @@ def __init__(self):
 
         self._modules_loaded = False
 
-    def out(self, output, newline=True):
+    def out(self, output):
         """Outputs a string to the console (stdout)."""
-        click.echo(output, nl=newline)
+        console = Console()
+        if self.format in ('json', 'jsonraw'):
+            console.print_json(output)
+        else:
+            # If we want to print a list of tables, Rich doens't handle that well.
+            if isinstance(output, list):
+                for line in output:
+                    console.print(line)
+            else:
+                console.print(output)
 
     def err(self, output, newline=True):
         """Outputs an error string to the console (stderr)."""
@@ -56,14 +66,14 @@ def format_output_is_json(self):
         """Return True if format output is json or jsonraw"""
         return 'json' in self.format
 
-    def fout(self, output, newline=True):
+    def fout(self, output):
         """Format the input and output to the console (stdout)."""
         if output is not None:
             try:
-                self.out(self.fmt(output), newline=newline)
+                self.out(self.fmt(output))
             except UnicodeEncodeError:
                 # If we hit an undecodeable entry, just try outputting as json.
-                self.out(self.fmt(output, 'json'), newline=newline)
+                self.out(self.fmt(output, 'json'))
 
     def input(self, prompt, default=None, show_default=True):
         """Provide a command prompt."""

SoftLayer/CLI/formatting.py

@@ -10,8 +10,8 @@
 import os
 
 import click
-
-import prettytable
+from rich import box
+from rich.table import Table as rTable
 
 from SoftLayer.CLI import exceptions
 from SoftLayer import utils
@@ -22,42 +22,38 @@
 def format_output(data, fmt='table'):  # pylint: disable=R0911,R0912
     """Given some data, will format it for console output.
 
-    :param data: One of: String, Table, FormattedItem, List, Tuple,
-                 SequentialOutput
+    :param data: One of: String, Table, FormattedItem, List, Tuple, SequentialOutput
     :param string fmt (optional): One of: table, raw, json, python
     """
-    if isinstance(data, str):
-        if fmt in ('json', 'jsonraw'):
-            return json.dumps(data)
+    if fmt in ('json', 'jsonraw'):
+        return json.dumps(data, indent=4, cls=CLIJSONEncoder)
+
+    if isinstance(data, str) or isinstance(data, rTable):    
         return data
 
     # responds to .prettytable()
-    if hasattr(data, 'prettytable'):
-        if fmt == 'table':
-            return str(format_prettytable(data))
-        elif fmt == 'raw':
-            return str(format_no_tty(data))
+    if hasattr(data, 'prettytable') and fmt in ('table', 'raw'):
+        return format_prettytable(data)
 
     # responds to .to_python()
     if hasattr(data, 'to_python'):
+        print("to_python()")
         if fmt == 'json':
-            return json.dumps(
-                format_output(data, fmt='python'),
-                indent=4,
-                cls=CLIJSONEncoder)
+            return json.dumps(format_output(data, fmt='python'), indent=4, cls=CLIJSONEncoder)
         elif fmt == 'jsonraw':
-            return json.dumps(format_output(data, fmt='python'),
-                              cls=CLIJSONEncoder)
+            return json.dumps(format_output(data, fmt='python'), cls=CLIJSONEncoder)
         elif fmt == 'python':
             return data.to_python()
 
     # responds to .formatted
     if hasattr(data, 'formatted'):
+        print("formatted()")
         if fmt == 'table':
             return data.formatted
 
     # responds to .separator
     if hasattr(data, 'separator'):
+        print("FUCKING THISNGS UP HERE")
         output = [format_output(d, fmt=fmt) for d in data if d]
         return str(SequentialOutput(data.separator, output))
 
@@ -66,42 +62,19 @@ def format_output(data, fmt='table'):  # pylint: disable=R0911,R0912
         output = [format_output(d, fmt=fmt) for d in data]
         if fmt == 'python':
             return output
-        return format_output(listing(output, separator=os.linesep))
+        return output
 
     # fallback, convert this odd object to a string
-    return data
+    print(f"Casting this to string {data}")
+    return str(data)
 
 
 def format_prettytable(table):
     """Converts SoftLayer.CLI.formatting.Table instance to a prettytable."""
     for i, row in enumerate(table.rows):
         for j, item in enumerate(row):
             table.rows[i][j] = format_output(item)
-
-    ptable = table.prettytable()
-    ptable.hrules = prettytable.FRAME
-    ptable.horizontal_char = '.'
-    ptable.vertical_char = ':'
-    ptable.junction_char = ':'
-    return ptable
-
-
-def format_no_tty(table):
-    """Converts SoftLayer.CLI.formatting.Table instance to a prettytable."""
-
-    for i, row in enumerate(table.rows):
-        for j, item in enumerate(row):
-            table.rows[i][j] = format_output(item, fmt='raw')
     ptable = table.prettytable()
-
-    for col in table.columns:
-        ptable.align[col] = 'l'
-
-    ptable.hrules = prettytable.NONE
-    ptable.border = False
-    ptable.header = False
-    ptable.left_padding_width = 0
-    ptable.right_padding_width = 2
     return ptable
 
 
@@ -238,6 +211,7 @@ def to_python(self):
         return self
 
     def __str__(self):
+        print("CASTSDFSDFSDFSDFSDF")
         return self.separator.join(str(x) for x in self)
 
 
@@ -271,6 +245,9 @@ def __init__(self, columns, title=None):
         self.sortby = None
         self.title = title
 
+    def __str__(self):
+        print("OK")
+
     def add_row(self, row):
         """Add a row to the table.
 
@@ -288,28 +265,30 @@ def to_python(self):
         return items
 
     def prettytable(self):
-        """Returns a new prettytable instance."""
-        table = prettytable.PrettyTable(self.columns)
-
-        if self.sortby:
-            if self.sortby in self.columns:
-                table.sortby = self.sortby
-            else:
-                msg = "Column (%s) doesn't exist to sort by" % self.sortby
-                raise exceptions.CLIAbort(msg)
-
-        if isinstance(self.align, str):
-            table.align = self.align
-        else:
-            # Required because PrettyTable has a strict setter function for alignment
-            for a_col, alignment in self.align.items():
-                table.align[a_col] = alignment
+        """Returns a RICH table instance."""
+        table = rTable(title=self.title, box=box.SQUARE, header_style="bright_cyan")
+
+        for col in self.columns:
+            justify = "center"
+            style = None
+            # This case aligns all columns in a table
+            if isinstance(self.align, str):
+                justify = self.align
+            # This case alings a specific column
+            elif isinstance(self.align, dict) and self.align.get(col, False):
+                justify = self.align.get(col)
+            # Backwards compatibility with PrettyTable style alignments
+            if justify == 'r':
+                justify = 'right'
+            if justify == 'l':
+                justify = 'left'
+            # Special coloring for some columns
+            if col in ('id', 'Id', 'ID'):
+                style = "pale_violet_red1"
+            table.add_column(col, justify=justify, style=style)
 
-        if self.title:
-            table.title = self.title
-        # Adding rows
         for row in self.rows:
-            table.add_row(row)
+            table.add_row(*row)
         return table
 
 
@@ -346,7 +325,7 @@ def __str__(self):
         """returns the formatted value."""
         # If the original value is None, represent this as 'NULL'
         if self.original is None:
-            return 'NULL'
+            return self.formatted or "NULL"
 
         try:
             return str(self.original)

tests/CLI/environment_tests.py

@@ -6,9 +6,11 @@
 """
 
 import click
+from rich.console import Console
 from unittest import mock as mock
 
 from SoftLayer.CLI import environment
+from SoftLayer.CLI import formatting
 from SoftLayer import testing
 
 
@@ -44,9 +46,7 @@ def test_get_command(self):
     @mock.patch('click.prompt')
     def test_input(self, prompt_mock):
         r = self.env.input('input')
-        prompt_mock.assert_called_with('input',
-                                       default=None,
-                                       show_default=True)
+        prompt_mock.assert_called_with('input', default=None, show_default=True)
         self.assertEqual(prompt_mock(), r)
 
     @mock.patch('click.prompt')
@@ -71,17 +71,18 @@ def test_resolve_alias(self):
         r = self.env.resolve_alias('realname')
         self.assertEqual(r, 'realname')
 
-    @mock.patch('click.echo')
-    def test_print_unicode(self, echo):
-        output = "\u3010TEST\u3011 image"
-        # https://docs.python.org/3.6/library/exceptions.html#UnicodeError
-        echo.side_effect = [
-            UnicodeEncodeError('utf8', output, 0, 1, "Test Exception"),
-            output
-        ]
-        self.env.fout(output)
-        self.assertEqual(2, echo.call_count)
-
     def test_format_output_is_json(self):
         self.env.format = 'jsonraw'
         self.assertTrue(self.env.format_output_is_json())
+
+    @mock.patch('rich.console.Console.print')
+    def test_multiple_tables(self, console):
+        tables = []
+        table1 = formatting.Table(["First", "Second"])
+        table1.add_row(["1", 2])
+        table2 = formatting.Table(["T2-1", "T2-2"])
+        table2.add_row(["zzzzzzz", "123123123"])
+        tables.append(table1)
+        tables.append(table2)
+        self.env.out(tables)
+        self.assertEqual(2, len(console.call_args_list))