Tabulators break formatting about prettytable

[hugovk]

How are you actually using PrettyTable? Please provide some example Python code.

[dremerb]

        startindex = page * num_elems
        showarr = inputarr[startindex:startindex+num_elems]
        headers = ["Index", "Date", "Type", "Command", "Internal Hash", "Project Commit Hash", "Diff from last commit", "Tag"]
        table = PrettyTable()
        table.field_names = headers
        # this line is currently used to remove "\t" chars from problematic column, breaks without
        table.add_rows(map(lambda x: (x[0], x[1], x[2], x[3], x[4], x[5], x[6].replace("\t", ""), x[7]), showarr))
        table.align = "l"
        print(table)

[hugovk]

Thanks, please could you create a "Minimal, Reproducible Example"?

https://stackoverflow.com/help/minimal-reproducible-example

[dremerb]

from prettytable import PrettyTable

data = [[   "first",
            "second",
            """diff --git partdiff.c partdiff.c
index 05ced0c..804cd7d 100644
--- partdiff.c
+++ partdiff.c
@@ -377,6 +377,7 @@ main (int argc, char** argv)
 \tstruct calculation_arguments arguments;
 \tstruct calculation_results results;

+\tprintf("Some random text!");
 \taskParams(&options, argc, argv);

 \tinitVariables(&arguments, &results, &options);""",
            "fourth"],
        ]

headers = ["col1", "col2", "col3", "col4"]

table = PrettyTable()
table.field_names = headers
table.add_rows(data)
print(table)

produces

+-------+--------+--------------------------------------------------+--------+
|  col1 |  col2  |                       col3                       |  col4  |
+-------+--------+--------------------------------------------------+--------+
| first | second |         diff --git partdiff.c partdiff.c         | fourth |
|       |        |          index 05ced0c..804cd7d 100644           |        |
|       |        |                  --- partdiff.c                  |        |
|       |        |                  +++ partdiff.c                  |        |
|       |        | @@ -377,6 +377,7 @@ main (int argc, char** argv) |        |
|       |        |                              struct calculation_arguments arguments;                          |        |
|       |        |                              struct calculation_results results;                          |        |
|       |        |                                                  |        |
|       |        |                         +    printf("Some random text!");                          |        |
|       |        |                              askParams(&options, argc, argv);                          |        |
|       |        |                                                  |        |
|       |        |                              initVariables(&arguments, &results, &options);                          |        |
+-------+--------+--------------------------------------------------+--------+

You could also try adding a table.align = "l", shifts content correctly inside the column, but delimiters are broken in exactly the same way.

[hugovk]

Thanks for that!

So it looks like this is the Python's print reading the \t as a tab character.

For example:

>>> print("a\tb")
a	b
>>> print(" \tstruct calculation_arguments arguments;")
 	struct calculation_arguments arguments;

---

If I preprocess the data and replace \t with \\t, to escape the backslash:

from prettytable import PrettyTable

data = [[   "first",
            "second",
            """diff --git partdiff.c partdiff.c
index 05ced0c..804cd7d 100644
--- partdiff.c
+++ partdiff.c
@@ -377,6 +377,7 @@ main (int argc, char** argv)
 \\tstruct calculation_arguments arguments;
 \\tstruct calculation_results results;

+\\tprintf("Some random text!");
 \\taskParams(&options, argc, argv);

 \\tinitVariables(&arguments, &results, &options);""",
            "fourth"],
        ]

headers = ["col1", "col2", "col3", "col4"]

table = PrettyTable()
table.field_names = headers
table.add_rows(data)
print(table)

It prints nicely as:

+-------+--------+---------------------------------------------------+--------+
|  col1 |  col2  |                        col3                       |  col4  |
+-------+--------+---------------------------------------------------+--------+
| first | second |          diff --git partdiff.c partdiff.c         | fourth |
|       |        |           index 05ced0c..804cd7d 100644           |        |
|       |        |                   --- partdiff.c                  |        |
|       |        |                   +++ partdiff.c                  |        |
|       |        |  @@ -377,6 +377,7 @@ main (int argc, char** argv) |        |
|       |        |      \tstruct calculation_arguments arguments;    |        |
|       |        |        \tstruct calculation_results results;      |        |
|       |        |                                                   |        |
|       |        |          +\tprintf("Some random text!");          |        |
|       |        |         \taskParams(&options, argc, argv);        |        |
|       |        |                                                   |        |
|       |        |  \tinitVariables(&arguments, &results, &options); |        |
+-------+--------+---------------------------------------------------+--------+

But I guess it doesn't make much sense to show \t in the output.

---

Another idea is to pre-process the \t as four spaces, or two spaces, whatever you prefer:

from prettytable import PrettyTable

data = [[   "first",
            "second",
            """diff --git partdiff.c partdiff.c
index 05ced0c..804cd7d 100644
--- partdiff.c
+++ partdiff.c
@@ -377,6 +377,7 @@ main (int argc, char** argv)
     struct calculation_arguments arguments;
     struct calculation_results results;

+    printf("Some random text!");
     askParams(&options, argc, argv);

     initVariables(&arguments, &results, &options);""",
            "fourth"],
        ]

headers = ["col1", "col2", "col3", "col4"]

table = PrettyTable()
table.field_names = headers
table.add_rows(data)
print(table)

Produces:

+-------+--------+-----------------------------------------------------+--------+
|  col1 |  col2  |                         col3                        |  col4  |
+-------+--------+-----------------------------------------------------+--------+
| first | second |           diff --git partdiff.c partdiff.c          | fourth |
|       |        |            index 05ced0c..804cd7d 100644            |        |
|       |        |                    --- partdiff.c                   |        |
|       |        |                    +++ partdiff.c                   |        |
|       |        |   @@ -377,6 +377,7 @@ main (int argc, char** argv)  |        |
|       |        |          struct calculation_arguments arguments;    |        |
|       |        |            struct calculation_results results;      |        |
|       |        |                                                     |        |
|       |        |          +    printf("Some random text!");          |        |
|       |        |             askParams(&options, argc, argv);        |        |
|       |        |                                                     |        |
|       |        |      initVariables(&arguments, &results, &options); |        |
+-------+--------+-----------------------------------------------------+--------+

---

How does that sound? Can you preprocess \t into 2 or 4 (or whatever) spaces?

I'm not sure if this should be handled by PrettyTable itself, whether it should make assumptions whether \t should be 2 or 4 spaces. Or if the centering algorithm can be adapted to somehow take into account a tab, or how it should do that.

[dremerb]

Printing \t as a character does not make sense in my case, as it's simply for formatting, no information.
Imo PrettyTable could handle the replacing, makes for a better user experience - just throw in some data and it'll work. While I found the workaround pretty quickly, might not be the case for a Python beginner. For me \t is 4 spaces, but you could introduce an optional parameter to set it to whatever value.
But you could also argue that the user has to sanitize their data. In that case maybe document the behavior somewhere, so that the fix can be found easily?