bugfixing in config & add quiet mode
[logparse.git] / logparse / formatting.py
index d7a9b4d4d99a31821bba41318691d9558344a9d7..ab6266efc5233840d3e1369b21c03ff3aa5adec9 100644 (file)
@@ -3,21 +3,24 @@
 #   
 #   This file contains global functions for formatting and printing data. This
 #   file should be imported into individual log-parsing scripts located in
-#   logs/*. Data is all formatted in HTML. Writing to disk and/or emailng data
-#   is left to __main__.py.
+#   logs/*. Data is formatted in HTML or plaintext. Writing to disk and/or
+#   emailng data is left to __main__.py.
 #
 
 import os
 import re
 import locale
 from string import Template
+from math import floor, ceil
+from tabulate import tabulate
 
 import logparse
-from . import interface, util, config
+from . import interface, util, config, mail
 
 import logging
 logger = logging.getLogger(__name__)
 
+
 locale.setlocale(locale.LC_ALL, '') # inherit system locale
 #DEG = "°".encode('unicode_escape')
 DEG = u'\N{DEGREE SIGN}'
@@ -28,17 +31,31 @@ CORNERCHARS_DOUBLE = ['╚', '╝', '╗', '╔']
 CORNERCHARS_SINGLE = ['└', '┘', '┐', '┌']
 LINECHARS_DOUBLE = ['║', '═']
 LINECHARS_SINGLE = ['│', '─']
+JXNCHARS_DOUBLE = ['╠', '╣', '╦', '╩', '╬']
+JXNCHARS_SINGLE = ['├', '┤', '┬', '┴', '┼']
+BULLET = "• "
+INDENT = "  "
+
 
 class Output:
+    """
+    Base class for a data processor. 
+    """
     
     def __init__(self):
         self.content = ""
         self.destination = ""
 
     def append(self, content):
+        """
+        Add a string
+        """
         self.content += content
 
     def write(self, destination=""):
+        """
+        Output contents into a file
+        """
         if destination == "":
             destination = self.destination
         if destination == "":
@@ -50,6 +67,9 @@ class Output:
 
 
 class PlaintextOutput(Output):
+    """
+    Processes & outputs data in a plaintext form which can be read with cat or plaintext email.
+    """
 
     def __init__(self, linewidth=80):
         self.content = ""
@@ -57,24 +77,41 @@ class PlaintextOutput(Output):
         self.linewidth = linewidth;
 
     def append_header(self, template=''):
+        """
+        Print details with some primitive formatting
+        """
         init_varfilter()
         box = PlaintextBox(content=Template("$title $version on $hostname\n\n$time $date").safe_substitute(varsubst), vpadding=2, hpadding="\t\t", linewidth=config.prefs['linewidth'])
         line = PlaintextLine(self.linewidth)
         self.append(box.draw() + line.draw())
 
     def append_footer(self):
+        """
+        Append a horizontal line and some details
+        """
         init_varfilter()
         self.append(PlaintextLine(self.linewidth, vpadding=1).draw())
         self.append(Template("$hostname $time $date").safe_substitute(varsubst))
 
     def append_section(self, section):
+        """
+        Call the appropriate methods to format a section (provided by a parser).
+        This should be run by interface.py after every instance of parse_log().
+        """
         self.append(PlaintextBox(content=section.title, double=False, fullwidth=False, vpadding=0, hpadding=" ").draw())
         self.append('\n'*2)
         for data in section.data:
             self.append(self._fmt_data(data.subtitle, data.items))
-        self.append('\n')
+            self.append('\n')
+        for table in section.tables:
+            self.append(table.draw_plain())
+        self.append("\n")
 
     def _fmt_data(self, subtitle, data = None):   # write title and data
+        """
+        Format the properties of a data object into usable plaintext form with a few fancy symbols/formatting tricks.
+        Subtitle is required, data is not. If only subtitle is supplied or subtitle + one data item, a single line will be printed.
+        """
         if (subtitle == ""):
             logger.warning("No subtitle provided.. skipping section")
             return
@@ -90,26 +127,30 @@ class PlaintextOutput(Output):
             else:
                 itemoutput = subtitle + '\n'
                 for datum in data:
-                    datum = '• ' + datum
-                    if len(datum) > config.prefs['linewidth']:
+                    datum = BULLET + datum
+                    if len(datum) > config.prefs['linewidth'] - 3:
                         words = datum.split()
-                        if max(map(len, words)) > config.prefs['linewidth']:
-                            raise ValueError("Content width is too small")
+                        if max(map(len, words)) > config.prefs['linewidth'] - len(INDENT):
+                            continue
                         res, part, others = [], words[0], words[1:]
                         for word in others:
-                            if len(' ') + len(word) > config.prefs['linewidth'] - len(part):
+                            if 1 + len(word) > config.prefs['linewidth'] - len(part):
                                 res.append(part)
                                 part = word
                             else:
                                 part += ' ' + word
                         if part:
                             res.append(part)
-                        datum = '\n'.join(res)
+                        datum = ('\n    ').join(res)
+                    datum = INDENT + datum
                     itemoutput += datum + '\n'
                 return itemoutput
 
-
 class HtmlOutput(Output):
+    """
+    Process and output data in HTML format.
+    All HTML formatting functions now reside in this class to differentiate them from plaintext.
+    """
 
     def __init__(self):
         self.content = ""
@@ -117,75 +158,336 @@ class HtmlOutput(Output):
         self.css = ""
 
     def embed_css(self, css):
+        """
+        Convert stylesheet to inline tags
+        """
         self.content = mail.mailprep(self.content, css)
+        return self.content
 
-    def append_header(self, template):   # insert variables into header template file
+    def append_header(self, template):
+        """
+        Insert variables into header template file and append HTML tags
+        """
         init_varfilter()
         headercontent = Template(open(template, 'r').read())
         self.append(headercontent.safe_substitute(varsubst))
         self.append(opentag('div', id='main'))
 
     def append_footer(self):
+        """
+        Close HTML tags that were opened in the template.
+        TODO: add footer template similar to header template.
+        """
         self.append(closetag('div') + closetag('body') + closetag('html'))
 
     def append_section(self, section):
+        """
+        Call the appropriate methods to generate HTML tags for a section (provided by a parser).
+        This should be run by interface.py after every instance of parse_log().
+        """
         self.append(opentag('div', 1, section.title, 'section'))
         self.append(self._gen_title(section.title))
         for data in section.data:
             self.append(self._fmt_data(data.subtitle, data.items))
+        for table in section.tables:
+            self.append(table.draw_html())
         self.append(closetag('div', 1))
 
-    def _gen_title(self, title):  # write title for a section
+    def _gen_title(self, title):
+        """
+        Format the title for a section
+        """
         if (title == '' or '\n' in title):
             logger.error("Invalid title")
             raise ValueError 
         logger.debug("Writing title for " + title)
-        return tag('h2', 0, title)
+        return tag('h2', False, title)
 
-    def _fmt_data(self, subtitle, data = None):   # write title and data
+    def _fmt_data(self, subtitle, data = None):
+        """
+        Format the properties of a data object into usable HTML tags.
+        Subtitle is required, data is not. If only subtitle is supplied or subtitle + one data item, a single line will be printed.
+        """
         if (subtitle == ""):
             logger.warning("No subtitle provided.. skipping section")
             return
 
         if (data == None or len(data) == 0):
             logger.debug("No data provided.. just printing subtitle")
-            return tag('p', 0, subtitle)
+            return tag('p', False, subtitle)
         else:
             logger.debug("Received data " + str(data))
             subtitle += ':'
             if (len(data) == 1):
-                return tag('p', 0, subtitle + ' ' + data[0])
+                return tag('p', False, subtitle + ' ' + data[0])
             else:
                 output = ""
-                output += tag('p', 0, subtitle)
+                output += tag('p', False, subtitle)
                 output += opentag('ul', 1)
                 coderegex = re.compile('`(.*)`')
                 for datum in data:
                     if datum == "" or datum == None:
                         continue
-                    datum = coderegex.sub(r'<code>{\1}</code>', str(datum))
-                    output += tag('li', 0, datum)
-                output += closetag('ul', 1)
+                    datum = coderegex.sub(r"<code>\1</code>", str(datum))
+                    output += tag('li', False, datum)
+                output += closetag('ul', True)
                 return output
 
 
 class Section:
+    """
+    Each parser should output a Section() which contains the title and returned data.
+    """
 
     def __init__(self, title):
         self.title = title
         self.data = []
+        self.tables = []
 
-    def add_data(self, data):
+    def append_data(self, data):
         self.data.append(data)
 
+    def append_table(self, table):
+        self.tables.append(table)
+
+
 class Data:
+    """
+    Each section (parser) can have one or more Data() objects which are essentially glorified lists.
+    """
     
-    def __init__(self, subtitle, items=None):
+    def __init__(self, subtitle="", items=[]):
         self.subtitle = subtitle
         self.items = items 
 
+    def truncl(self, limit):      # truncate list
+        """
+        Truncate self.items to a specified value and state how many items are hidden.
+        """
+        if (len(self.items) > limit):
+            more = len(self.items) - limit
+            if more == 1:
+                return 0
+            self.items = self.items[:limit]
+            self.items.append("+ {0} more".format(str(more)))
+
+    def orderbyfreq(self):
+        """
+        Order a list by frequency of each item, then remove duplicates and append frequency in parentheses.
+        """
+        unsorted = list(self.items)
+        self.items = ["{0} ({1})".format(y, unsorted.count(y)) for y in sorted(set(unsorted), key = lambda x: -unsorted.count(x))]
+
+class Table(object):
+    """
+    A wrapper for python-tabulate's Tabulate type.
+    """
+    
+    def __init__(self, double=False, borders=False, hpadding=" ", maxwidth=80, headers=[]):
+        self.rows =  []     # List of row objects
+        self.keymap = {}    # For fast lookup of row by value of first column 
+        self.double = double
+        self.borders = borders
+        self.align_cols = []
+        self.hpadding = hpadding
+        self.maxwidth = maxwidth
+        self.headers = headers
+        self._align_cols = []
+
+    def add_row(self, row):
+
+        self.rows.append(row)
+        if len(row.columns) > 0:
+            self.keymap[row.columns[0]] = row
+
+        logger.debug("Added row with {0} columns".format(str(len(row.columns))))
+
+    def align_column(self, i, align):
+        while len(self._align_cols) -1 < i:
+            self._align_cols.append("")
+        self._align_cols[i] = align
+        for row in self.rows:
+            row.columns[i].align = align
+        logger.debug("Column alignment is now {0}".format(str(self._align_cols)))
+
+    def _gen_list(self):
+        hierarchy = []
+        for row in self.rows:
+            row_data = []
+            for column in row.columns:
+                row_data.append(column.content)
+            hierarchy.append(row_data)
+        return hierarchy
+
+    def draw_html(self):
+        output = tabulate(self._gen_list(), self.headers, tablefmt="html", colalign=tuple(self._align_cols))
+        return output
+
+    def draw_plain(self):
+        output = tabulate(self._gen_list(), self.headers, tablefmt="fancy_grid" if self.borders else "plain", colalign=tuple(self._align_cols))
+        return output + "\n"*2
+
+
+class Table0(object):
+    """
+    A two-dimensional information display.
+    This is a hacky implementation - Table() now relies on the Tabulate package which is much more reliable.
+    """
+
+    def __init__(self, double=False, borders=True, hpadding="+", maxwidth=80):
+        self.rows =  []     # List of row objects
+        self.keymap = {}    # For fast lookup of row by value of first column 
+        self.double = double
+        self.borders = borders
+        self.align_cols = []
+        self.hpadding = hpadding
+        self.maxwidth = maxwidth
+        self._colwidths = []
+
+    def add_row(self, row):
+        self.rows.append(row)
+        for i, col in enumerate(row.columns):
+            if len(self._colwidths) >= i + 1:
+                self._colwidths[i] = max([self._colwidths[i], len(col.content)])
+            else:
+                self._colwidths.append(len(col.content))
+        logger.debug("Added row with {0} columns. Column widths are now {1}.".format(str(len(row.columns)), str(self._colwidths)))
+        if len(row.columns) > 0:
+            self.keymap[row.columns[0]] = row
+    
+    def align_column(self, i, align):
+        for row in self.rows:
+            row.columns[i].align = align
+        
+
+    def draw_html(self):
+        output = ""
+        output += opentag("table", True, cl="data_table") 
+        for row in self.rows:
+            if row.header:
+                output += opentag("th", block=True, cl="header")
+            else:
+                output += opentag("tr", block=True)
+            for column in row.columns:
+                output += tag("td", content=column.content, style={"text-align": column.align} if column.align else {})
+            if row.header:
+                output += closetag("th", True)
+            else:
+                output += closetag("tr", True)
+        output += closetag("table", True)
+        logger.debug("Built table with {0} rows and {1} columns".format(str(len(self.rows)), str(max([x.n for x in self.rows]))))
+        return output
+
+    def draw_plain(self):
+        output = ""
+        cols = [list(x) for x in zip(self.rows)]
+        logger.debug("Cols are " + str(cols))
+
+        if self.double == True:
+            cornerchars = CORNERCHARS_DOUBLE
+            linechars = LINECHARS_DOUBLE
+            jxnchars = JXNCHARS_DOUBLE
+        else:
+            cornerchars = CORNERCHARS_SINGLE
+            linechars = LINECHARS_SINGLE
+            jxnchars = JXNCHARS_SINGLE
+        
+        lengths = []
+        row_lengths = []
+        for row in self.rows:
+            for i, col in enumerate(row.columns):
+                if len(lengths) >= i + 1:
+                    lengths[i] = max([lengths[i], len(col.content)])
+                else:
+                    lengths.append(len(col.content))
+
+        logger.debug("Lengths are " + str(lengths))
+
+        for i, row in enumerate(self.rows):
+            l = (len(INDENT) + len(self.hpadding)*2*len(row.columns) + ((1+len(row.columns)) if self.borders else 0) + sum([len(col.content) for col in row.columns]))
+            if l > self.maxwidth:
+                logger.debug("Line overflow for cell in row {0} of table".format(str(i)))
+                words = row.columns[-1].content.split()
+                if max(map(len, words)) > self.maxwidth:
+                    continue
+                res, part, others = [], words[0], words[1:]
+                for word in others:
+                    if l - len(word) < self.maxwidth:
+                        res.append(part)
+                        part = word
+                    else:
+                        part += ' ' + word
+                if part:
+                    res.append(part)
+                self._colwidths[-1] = max([len(f) for f in res] + [len(r.columns[-1].content) for r in self.rows if r != row])
+                if self.borders:
+                    row.columns[-1].content = res[0][:-1] + self.hpadding + " "*(self._colwidths[-1]-len(res[0])+1) + linechars[0]
+                    for fragment in res[1:]:
+                        row.columns[-1].content += "\n" + INDENT + "".join([(linechars[0] + self.hpadding + " "*x + self.hpadding) for x in lengths]) + linechars[0] + self.hpadding + fragment + " " * (max(self._colwidths) - len(fragment))
+
+        if self.borders:
+            top = INDENT + cornerchars[3] + jxnchars[2].join(linechars[1] * (l+2) for l in self._colwidths) + cornerchars[2] + "\n"
+            bottom = INDENT + cornerchars[0] + jxnchars[3].join(linechars[1] * (l+2) for l in self._colwidths) + cornerchars[1] + "\n"
+            rowtext = INDENT + linechars[0] + linechars[0].join("{:>%d}" % l for l in self._colwidths) + linechars[0] + "\n"
+            line = INDENT + jxnchars[0] + jxnchars[4].join(linechars[1] * (l+2) for l in self._colwidths) + jxnchars[1] + "\n"
+        else:
+            top = bottom = line = ""
+            rowtext = " ".join("{:>%d}" % l for l in self._colwidths) + "\n"
+
+        for i, row in enumerate(self.rows):
+            logger.debug("Processing row {0} of {1}".format(str(i), str(len(self.rows)-1)))
+            row_output = ""
+            if i == 0:
+                row_output += top
+            row_output += (INDENT + linechars[0] if self.borders else "")
+            for j, column in enumerate(row.columns):
+                if column.align == "right":
+                    cell_output = self.hpadding + " "*(self._colwidths[j]-len(column.content)) + column.content + self.hpadding + (linechars[0] if self.borders else "")
+                elif column.align == "left":
+                    cell_output = self.hpadding + column.content + " "*(self._colwidths[j]-len(column.content)) + self.hpadding + (linechars[0] if self.borders else "")
+                elif column.align == "center":
+                    n_whitespace = (self._colwidths[j]-len(column.content))/2
+                    cell_output = self.hpadding + " "*(floor(n_whitespace) if len(column.content) % 2 == 0 else ceil(n_whitespace)) + column.content + " "*(ceil(n_whitespace) if len(column.content) % 2 == 0 else floor(n_whitespace)) + self.hpadding + (linechars[0] if self.borders else "")
+                else:
+                    logger.warning("Couldn't find alignment value for cell {0} of row {1} with content \"{2}\"".format(str(j), str(i), column.content()))
+                    continue
+                row_output += cell_output
+                if len(row_output) > self.maxwidth:
+                    logger.warning("Line overflow for row {0} of table".format(str(i)))
+
+            output += row_output + "\n"
+            if i == len(self.rows)-1:
+                output += (bottom if self.borders else "")
+            else:
+                output += (line if self.borders else "")
+
+        return output
+
+class Row(object):
+    
+    def __init__(self, columns=[], header=False):
+        self.columns = columns
+        self.header = header
+        self.n = len(self.columns)
+
+    def add_column(self, column):
+        self.columns.append(column)
+        self.n += 1
+
+    def rm_column(self, column):
+        self.remove(column)
+        self.n -= 1
+
+class Column(object):
+
+    def __init__(self, content="", align="right"):
+        self.content = content
+        self.align = align
 
 class PlaintextLine:
+    """
+    Draw a horizontal line for plain text format, with optional padding/styling.
+    """
 
     def __init__(self, linewidth=80, double=True, vpadding=1, hpadding=""):
         self.linewidth = linewidth
@@ -197,7 +499,11 @@ class PlaintextLine:
         line = (LINECHARS_DOUBLE[1] if self.double else LINECHARS_SINGLE[1])
         return "\n" * self.vpadding + self.hpadding +  line * (self.linewidth - 2 * len(self.hpadding)) + self.hpadding + "\n" * self.vpadding
 
+
 class PlaintextBox:
+    """
+    Draw a rectangular box around text, with customisable padding/size/style
+    """
 
     def __init__(self, content="", double=True, fullwidth=True, linewidth=80, hpadding="\t", vpadding=1):
         self.content = content
@@ -235,7 +541,7 @@ class PlaintextBox:
             if len(line) > contentwidth:
                 words = line.split()
                 if max(map(len, words)) > contentwidth:
-                    raise ValueError("Content width is too small")
+                    continue
                 res, part, others = [], words[0], words[1:]
                 for word in others:
                     if len(' ') + len(word) > contentwidth - len(part):
@@ -269,6 +575,7 @@ class PlaintextBox:
         contentlines.append(cornerchars[0] + linechars[1] * (contentwidth + len(self.hpadding)*2) + cornerchars[1])
         return ('\n').join(contentlines)
 
+
 def init_varfilter():
     global varfilter
     global varpattern
@@ -278,97 +585,80 @@ def init_varfilter():
     varpattern = re.compile("|".join(varfilter.keys()))
     varsubst = dict(title=config.prefs['title'], date=interface.start.strftime(DATEFMT), time=interface.start.strftime(TIMEFMT), hostname=util.hostname(config.prefs['hostname-path']), version=logparse.__version__, css=os.path.relpath(config.prefs['css'], os.path.dirname(config.prefs['output'])))
 
-def writetitle(title):  # write title for a section
-    if (title == '' or '\n' in title):
-        logger.error("Invalid title")
-        raise ValueError 
-    logger.debug("Writing title for " + title)
-    return tag('h2', 0, title)
+def backticks(l):
+    return ["`" + x + "`" for x in l]
 
-def opentag(tag, block = 0, id = None, cl = None):   # write html opening tag
-    output = ""
-    if (block):
-        output += '\n'
-    output += '<' + tag
-    if (id != None):
-        output += " id='" + id + "'"
-    if (cl != None):
-        output += " class='" + cl + "'"
-    output += '>'
-    if (block):
-        output += '\n'
-    return output
-
-def closetag(tag, block = 0):  # write html closing tag
-    if (block == 0):
-        return "</" + tag + ">"
-    else:
-        return "\n</" + tag + ">\n"
-
-def tag(tag, block = 0, content = ""):  # write html opening tag, content, and html closing tag
-    o = opentag(tag, block)
-    c = closetag(tag, block)
-    return o + content + c
 
-def orderbyfreq(l):     # order a list by the frequency of its elements and remove duplicates
-    temp_l = l[:]
-    l = list(set(l))
-    l = [[i, temp_l.count(i)] for i in l]   # add count of each element
-    l.sort(key=lambda x:temp_l.count(x[0])) # sort by count
-    l = [i[0] + ' (' + str(i[1]) + ')' for i in l]  # put element and count into string
-    l = l[::-1]     # reverse
-    return l
-
-def addtag(l, tag):  # add prefix and suffix tags to each item in a list
-    l2 = ['<' + tag + '>' + i + '</' + tag + '>' for i in l]
-    return l2
-
-def truncl(input, limit):      # truncate list
-    if (len(input) > limit):
-        more = str(len(input) - limit)
-        output = input[:limit]
-        output.append("+ " + more + " more")
-        return(output)
+def plural(noun, quantity, print_quantity=True):
+    """
+    Return "1 noun" or "n nouns"
+    """
+    if print_quantity:
+        if (quantity == 1):
+            return(str(quantity) + " " + noun)
+        else:
+            return(str(quantity) + " " + noun + "s")
     else:
-        return(input)
+        if (quantity == 1):
+            return noun
+        else:
+            return noun + "s"
 
-def plural(noun, quantity): # return "1 noun" or "n nouns"
-    if (quantity == 1):
-        return(str(quantity) + " " + noun)
-    else:
-        return(str(quantity) + " " + noun + "s")
 
-def parsesize(num, suffix='B'):     # return human-readable size from number of bytes
+def parsesize(num, suffix='B'):
+    """
+    Return human-readable size from number of bytes
+    """
     for unit in ['','Ki','Mi','Gi','Ti','Pi','Ei','Zi']:
         if abs(num) < 1024.0:
             return "%3.1f %s%s" % (num, unit, suffix)
         num /= 1024.0
     return "%.1f%s%s" % (num, 'Yi', suffix)
 
-def fsubject(template): # Replace variables in the title template provided in config
+
+def fsubject(template):
+    """
+    Replace variables in the title template provided in config
+    """
     r = varpattern.sub(lambda m: varfilter[re.escape(m.group(0))], template)
     logger.debug("Returning subject line " + r)
     return r
 
-def writedata(subtitle, data = None):   # write title and data
-    if (subtitle == ""):
-        logger.warning("No subtitle provided.. skipping section")
-        return
+def opentag(tag, block=False, id=None, cl=None, style=None):
+    """
+    Write HTML opening tag
+    """
+    output = ""
+    if block:
+        output += '\n'
+    output += '<' + tag
+    if id:
+        output += " id='" + id + "'"
+    if cl:
+        output += " class='" + cl + "'"
+    if style:
+        output += " style='"
+        output += " ".join("{0}: {1};".format(attr, value) for attr, value in style.items())
+        output += "'"
+    output += '>'
+    if block:
+        output += '\n'
+    return output
 
-    if (data == None or len(data) == 0):
-        logger.debug("No data provided.. just printing subtitle")
-        return tag('p', 0, subtitle)
+def closetag(tag, block=False):
+    """
+    Write HTML closing tag
+    """
+    if block:
+        return "\n</" + tag + ">\n"
     else:
-        logger.debug("Received data " + str(data))
-        subtitle += ':'
-        if (len(data) == 1):
-            return tag('p', 0, subtitle + ' ' + data[0])
-        else:
-            output = ""
-            output += tag('p', 0, subtitle)
-            output += opentag('ul', 1)
-            for datum in data:
-                output += tag('li', 0, datum)
-            output += closetag('ul', 1)
-            return output
+        return "</" + tag + ">"
+
+def tag(tag, block=False, content="", id=None, cl=None, style=None):
+    """
+    Write HTML opening tag, content, and closing tag
+    """
+    o = opentag(tag, block, id, cl, style)
+    c = closetag(tag, block)
+    return o + content + c