skilleter-thingy 0.0.40__py3-none-any.whl → 0.0.42__py3-none-any.whl

skilleter_thingy/tfparse.py

@@ -0,0 +1,101 @@
+#! /usr/bin/env python3
+
+"""
+Read JSON Terraform output and convert back to human-readable text
+This allows multiple errors and warnings to be reported as there's
+no way of doing this directly from Terraform
+"""
+
+import os
+import sys
+import json
+import argparse
+from collections import defaultdict
+
+import thingy.colour as colour
+
+################################################################################
+
+def error(msg, status=1):
+    """Report an error and quit"""
+
+    colour.write(f'[RED:ERROR]: {msg}')
+    sys.exit(status)
+
+################################################################################
+
+def main():
+    """Everything"""
+
+    # Command line is either empty or contains the input file
+
+    parser = argparse.ArgumentParser(description='Convert Terraform JSON output back into human-readable text')
+    parser.add_argument('--abspath', '-a', action='store_true', help='Output absolute file paths')
+    parser.add_argument('infile', nargs='*', help='The error file (defaults to standard input if not specified)')
+
+    args = parser.parse_args()
+
+    # Open the input file or use stdin and read the JSON
+
+    jsonfile = open(sys.argv[1], 'rt') if args.infile else sys.stdin
+
+    terraform = json.loads(jsonfile.read())
+
+    # Collect each of the error/warnings
+
+    report = defaultdict(list)
+
+    if 'diagnostics' in terraform:
+        for diagnostics in terraform['diagnostics']:
+            severity = diagnostics['severity'].title()
+
+            if 'range' in diagnostics:
+                file_path = os.path.abspath(diagnostics['range']['filename']) if args.abspath else diagnostics['range']['filename']
+
+            category = f'{severity}: {diagnostics["summary"]} - {diagnostics["detail"]}'
+
+            message = ''
+            if 'range' in diagnostics:
+                message += f'In [BLUE:{file_path}:{diagnostics["range"]["start"]["line"]}]'
+
+            if 'address' in diagnostics:
+                message += f' in [BLUE:{diagnostics["address"]}]'
+
+            report[category].append(message)
+
+    for category in report:
+        colour.write()
+
+        # Fudge emboldening multi-line warnings
+
+        formatted_category = '[BOLD:' + category.replace('\n', ']\n[BOLD:') + ']'
+        colour.write(formatted_category)
+
+        for entry in sorted(report[category]):
+            colour.write(f'    {entry}')
+
+    # Summarise the results
+
+    error_count = terraform.get('error_count', 0)
+    warning_count = terraform.get('warning_count', 0)
+
+    colour.write()
+    colour.write(f'[BOLD:Summary:] [BLUE:{error_count}] [BOLD:errors and] [BLUE:{warning_count}] [BOLD:warnings]')
+
+################################################################################
+
+def tfparse():
+    """Entry point"""
+
+    try:
+        main()
+
+    except KeyboardInterrupt:
+        sys.exit(1)
+    except BrokenPipeError:
+        sys.exit(2)
+
+################################################################################
+
+if __name__ == '__main__':
+    tfparse()

skilleter_thingy/thingy/__init__.py

@@ -0,0 +1,6 @@
+import os
+import sys
+
+thingy_path = os.path.dirname(os.path.realpath(__file__))
+
+sys.path.append(thingy_path)

skilleter_thingy/thingy/colour.py

@@ -0,0 +1,213 @@
+#! /usr/bin/env python3
+
+################################################################################
+""" Colour colour output
+
+    Copyright (C) 2017-18 John Skilleter
+
+    Licence: GPL v3 or later
+
+    0-15 are the standard VGA colour codes
+    16-21 are a few extras
+    22-231 appear to be a sort of colour cube
+    232-255 are 24 shades of grey
+"""
+################################################################################
+
+import sys
+import re
+
+################################################################################
+# Constants
+
+_ANSI_NORMAL = '\x1b[0m'
+_ANSI_BOLD = '\x1b[1m'
+_ANSI_UNDERSCORE = '\x1b[4m'
+_ANSI_BLINK = '\x1b[5m'
+_ANSI_REVERSE = '\x1b[7m'
+_ANSI_BLACK = '\x1b[30m'
+_ANSI_RED = '\x1b[31m'
+_ANSI_GREEN = '\x1b[32m'
+_ANSI_YELLOW = '\x1b[33m'
+_ANSI_BLUE = '\x1b[34m'
+_ANSI_MAGENTA = '\x1b[35m'
+_ANSI_CYAN = '\x1b[36m'
+_ANSI_WHITE = '\x1b[37m'
+_ANSI_BBLACK = '\x1b[40m'
+_ANSI_BRED = '\x1b[41m'
+_ANSI_BGREEN = '\x1b[42m'
+_ANSI_BYELLOW = '\x1b[43m'
+_ANSI_BBLUE = '\x1b[44m'
+_ANSI_BMAGENTA = '\x1b[45m'
+_ANSI_BCYAN = '\x1b[46m'
+_ANSI_BWHITE = '\x1b[47m'
+
+# Looking up tables for converting textual colour codes to ANSI codes
+
+ANSI_REGEXES = \
+    (
+        (r'\[NORMAL:(.*?)\]', r'%s\1%s' % (_ANSI_NORMAL, _ANSI_NORMAL)),
+        (r'\[BOLD:(.*?)\]', r'%s\1%s' % (_ANSI_BOLD, _ANSI_NORMAL)),
+        (r'\[UNDERSCORE:(.*?)\]', r'%s\1%s' % (_ANSI_UNDERSCORE, _ANSI_NORMAL)),
+        (r'\[BLINK:(.*?)\]', r'%s\1%s' % (_ANSI_BLINK, _ANSI_NORMAL)),
+        (r'\[REVERSE:(.*?)\]', r'%s\1%s' % (_ANSI_REVERSE, _ANSI_NORMAL)),
+
+        (r'\[BLACK:(.*?)\]', r'%s\1%s' % (_ANSI_BLACK, _ANSI_NORMAL)),
+        (r'\[RED:(.*?)\]', r'%s\1%s' % (_ANSI_RED, _ANSI_NORMAL)),
+        (r'\[GREEN:(.*?)\]', r'%s\1%s' % (_ANSI_GREEN, _ANSI_NORMAL)),
+        (r'\[YELLOW:(.*?)\]', r'%s\1%s' % (_ANSI_YELLOW, _ANSI_NORMAL)),
+        (r'\[BLUE:(.*?)\]', r'%s\1%s' % (_ANSI_BLUE, _ANSI_NORMAL)),
+        (r'\[MAGENTA:(.*?)\]', r'%s\1%s' % (_ANSI_MAGENTA, _ANSI_NORMAL)),
+        (r'\[CYAN:(.*?)\]', r'%s\1%s' % (_ANSI_CYAN, _ANSI_NORMAL)),
+        (r'\[WHITE:(.*?)\]', r'%s\1%s' % (_ANSI_WHITE, _ANSI_NORMAL)),
+
+        (r'\[BBLACK:(.*?)\]', r'%s\1%s' % (_ANSI_BBLACK, _ANSI_NORMAL)),
+        (r'\[BRED:(.*?)\]', r'%s\1%s' % (_ANSI_BRED, _ANSI_NORMAL)),
+        (r'\[BGREEN:(.*?)\]', r'%s\1%s' % (_ANSI_BGREEN, _ANSI_NORMAL)),
+        (r'\[BYELLOW:(.*?)\]', r'%s\1%s' % (_ANSI_BYELLOW, _ANSI_NORMAL)),
+        (r'\[BBLUE:(.*?)\]', r'%s\1%s' % (_ANSI_BBLUE, _ANSI_NORMAL)),
+        (r'\[BMAGENTA:(.*?)\]', r'%s\1%s' % (_ANSI_BMAGENTA, _ANSI_NORMAL)),
+        (r'\[BCYAN:(.*?)\]', r'%s\1%s' % (_ANSI_BCYAN, _ANSI_NORMAL)),
+        (r'\[BWHITE:(.*?)\]', r'%s\1%s' % (_ANSI_BWHITE, _ANSI_NORMAL))
+    )
+
+ANSI_CODES = \
+    (
+        ('[NORMAL]', _ANSI_NORMAL),
+        ('[BOLD]', _ANSI_BOLD),
+        ('[UNDERSCORE]', _ANSI_UNDERSCORE),
+        ('[BLINK]', _ANSI_BLINK),
+        ('[REVERSE]', _ANSI_REVERSE),
+
+        ('[BLACK]', _ANSI_BLACK),
+        ('[RED]', _ANSI_RED),
+        ('[GREEN]', _ANSI_GREEN),
+        ('[YELLOW]', _ANSI_YELLOW),
+        ('[BLUE]', _ANSI_BLUE),
+        ('[MAGENTA]', _ANSI_MAGENTA),
+        ('[CYAN]', _ANSI_CYAN),
+        ('[WHITE]', _ANSI_WHITE),
+
+        ('[BBLACK]', _ANSI_BBLACK),
+        ('[BRED]', _ANSI_BRED),
+        ('[BGREEN]', _ANSI_BGREEN),
+        ('[BYELLOW]', _ANSI_BYELLOW),
+        ('[BBLUE]', _ANSI_BBLUE),
+        ('[BMAGENTA]', _ANSI_BMAGENTA),
+        ('[BCYAN]', _ANSI_BCYAN),
+        ('[BWHITE]', _ANSI_BWHITE),
+    )
+
+# Regex to match an ANSI control sequence
+
+RE_ANSI = re.compile(r'\x1b\[([0-9][0-9;]*)*m')
+
+################################################################################
+
+def format(txt):
+    """ Convert textual colour codes in a string to ANSI codes.
+        Codes can be specified as either [COLOUR], where all following text
+        is output in the specified colour or [COLOR:text] where only 'text' is
+        output in the colour, with subsequent text output in the default colours """
+
+    # Replace [COLOUR:text] with COLOURtextNORMAL using regexes
+
+    if re.search(r'\[.*:.*\]', txt):
+        for regex in ANSI_REGEXES:
+            txt = re.sub(regex[0], regex[1], txt)
+
+    # Replace [COLOUR] with COLOUR
+
+    if re.search(r'\[.*\]', txt):
+        for code in ANSI_CODES:
+            txt = txt.replace(code[0], code[1])
+
+    # Now replace [N(N)(N)] with 256 colour colour code.
+
+    while True:
+        p = re.match(r'.*\[([0-9]{1,3})\].*', txt)
+        if p is None:
+            break
+
+        value = int(p.group(1))
+        txt = txt.replace('[%s]' % p.group(1), '\x1b[38;5;%dm' % value)
+
+    while True:
+        p = re.match(r'.*\[B([0-9]{1,3})\].*', txt)
+        if p is None:
+            break
+
+        value = int(p.group(1))
+        txt = txt.replace('[B%s]' % p.group(1), '\x1b[48;5;%dm' % value)
+
+    return txt
+
+################################################################################
+
+def write(txt=None, newline=True, stream=sys.stdout, indent=0):
+    """ Write to the specified stream (defaulting to stdout), converting colour codes to ANSI
+        txt can be None, a string or a list of strings."""
+
+    if txt:
+        if isinstance(txt, str):
+            txt = txt.split('\n')
+
+        for n, line in enumerate(txt):
+            line = format(line)
+
+            if indent:
+                stream.write(' ' * indent)
+
+            stream.write(line)
+
+            if newline or n < len(txt) - 1:
+                stream.write('\n')
+    elif newline:
+        stream.write('\n')
+
+################################################################################
+
+def error(txt, newline=True, stream=sys.stderr, status=1):
+    """ Write an error message to the specified stream (defaulting to
+        stderr) and exit with the specified status code (defaulting to 1) """
+
+    write(txt, newline, stream)
+
+    sys.exit(status)
+
+################################################################################
+
+if __name__ == '__main__':
+    write('Foreground: [RED]red [GREEN]green [BLACK]black [NORMAL]normal')
+    write('Background: [BRED]red [BGREEN]green [BBLACK]black [NORMAL]normal')
+
+    write('Foreground: [BBLUE:blue] [RED:red] normal')
+
+    for combo in (0, 1, 2):
+        print()
+        if combo == 0:
+            print('Background colours')
+        elif combo == 1:
+            print('Foreground colours')
+        else:
+            print('Combinations')
+
+        print()
+        for y in range(0, 32):
+            for x in range(0, 8):
+                colour = x + y * 8
+
+                if combo == 0:
+                    write(format('[B%d] %04d ' % (colour, colour)), newline=False)
+                elif combo == 1:
+                    write(format('[%d] %04d ' % (colour, colour)), newline=False)
+                else:
+                    write(format('[B%d] %04d [%d] %04d ' % (colour, colour, 255 - colour, 255 - colour)), newline=False)
+
+            write('[NORMAL]')
+
+    print()
+
+    error('Error message (nothing should be output after this)', status=0)
+
+    write('This message should not appear')

skilleter_thingy/thingy/dc_curses.py

@@ -0,0 +1,278 @@
+#! /usr/bin/env python3
+
+""" Convert colour highlighting codes from the LS_COLORS environment variable
+    used by ls to curses
+"""
+
+################################################################################
+
+import sys
+import os
+import glob
+import fnmatch
+import curses
+import stat
+
+################################################################################
+
+class CursesDircolors:
+    """ Convert dircolors codes to curses colours """
+
+    # Convert standard foreground and background codes to curses equivalents
+
+    ANSI_CONVERT_FORE = {
+        30: curses.COLOR_BLACK,
+        31: curses.COLOR_RED,
+        32: curses.COLOR_GREEN,
+        33: curses.COLOR_YELLOW,
+        34: curses.COLOR_BLUE,
+        35: curses.COLOR_MAGENTA,
+        36: curses.COLOR_CYAN,
+        37: curses.COLOR_WHITE,
+    }
+
+    ANSI_CONVERT_BACK = {
+        40: curses.COLOR_BLACK,
+        41: curses.COLOR_RED,
+        42: curses.COLOR_GREEN,
+        43: curses.COLOR_YELLOW,
+        44: curses.COLOR_BLUE,
+        45: curses.COLOR_MAGENTA,
+        46: curses.COLOR_CYAN,
+        47: curses.COLOR_WHITE,
+    }
+
+    # Convert attribute codes to their meanings
+    # TODO: Attributes not handled yet
+
+    ANSI_CONVERT_ATTR = {
+        0: 0,
+        1: curses.A_BOLD,
+        4: curses.A_UNDERLINE,
+        5: curses.A_BLINK,
+        7: curses.A_BLINK,
+        8: curses.A_INVIS,
+    }
+
+    # Default colour
+
+    DEFAULT_ATTR = {'attr': [], 'fore': -1, 'back': -1}
+
+    ################################################################################
+
+    def __init__(self, reserved=0):
+        # Create the lookup tables associating special type codes or wildcards
+        # with colour pairs.
+
+        self.colour_pairs = [[-1, -1]]
+
+        self.wildcard_highlight = {}
+        self.special_highlight = {}
+
+        self.reserved = reserved
+
+        self.init_ls_colours()
+
+    ################################################################################
+
+    def curses_alloc_pair(self, attr):
+        """ Given a set of attributes return the equivalent curses colour pair,
+            creating a new one if a matching one doesn't already exsit """
+
+        # TODO: Take account of attributes as well as colours
+
+        colours = [attr['fore'], attr['back']]
+
+        # Get an existing colour pair that uses the same colours or create
+        # a new one if one doesn't exist
+
+        if colours in self.colour_pairs:
+            pair_index = self.colour_pairs.index(colours) + self.reserved
+        else:
+            pair_index = len(self.colour_pairs) + self.reserved
+            self.colour_pairs.append(colours)
+            curses.init_pair(pair_index, attr['fore'], attr['back'])
+
+        return pair_index
+
+    ################################################################################
+
+    def curses_colour(self, code):
+        """ Return a cursors colour pair index for the specified dircolor colour
+            code string. """
+
+        # Default attribute
+
+        attr = {'attr': [], 'fore': -1, 'back': -1}
+
+        # Non-zero if processing multi-value colour code
+
+        special = 0
+        special_item = None
+
+        # We trigger a ValueError and fail on anything that's wrong in the code
+
+        try:
+            # Split into fields and convert to integer values
+
+            codes = [int(c) for c in code.split(';')]
+
+            for entry in codes:
+                # Process 2nd entry in a special colour sequence - must have value of 5
+
+                if special == 1:
+                    if entry != 5:
+                        raise ValueError
+                    special = 2
+
+                # Process 3rd entry in a special colour sequence - must be the colour
+                # code between 0 and 255
+
+                elif special == 2:
+                    if entry < 0 or entry > 255:
+                        raise ValueError
+
+                    attr[special_item] = entry
+                    special = 0
+
+                # Normal foreground colour
+
+                elif entry in self.ANSI_CONVERT_FORE:
+                    attr['fore'] = self.ANSI_CONVERT_FORE[entry]
+
+                # Normal background colour
+
+                elif entry in self.ANSI_CONVERT_BACK:
+                    attr['back'] = self.ANSI_CONVERT_BACK[entry]
+
+                # Special foreground colour in the form 38;5;VALUE
+
+                elif entry == 38:
+                    special = 1
+                    special_item = 'fore'
+
+                # Special background colour in the form 48;5;VALUE
+
+                elif entry == 48:
+                    special = 1
+                    special_item = 'back'
+
+                # Attribute (underline, bold, etc.)
+
+                elif entry in self.ANSI_CONVERT_ATTR:
+                    attr['attr'].append(self.ANSI_CONVERT_ATTR[entry])
+
+                # Anything else is an error
+
+                else:
+                    raise ValueError
+
+        except ValueError:
+            print(f'Invalid colour specification: "{code}"')
+            sys.exit(1)
+
+        # Allocate a colour pair for the colour combination and return it
+
+        return self.curses_alloc_pair(attr)
+
+    ################################################################################
+
+    def init_ls_colours(self):
+        """ Generate tables matching special file types (fifos, sockets, etc.) and
+            wildcards to curses colour pairs """
+
+        colour_data = os.environ.get('LS_COLORS', '').split(':')
+
+        # Iterate through the highlighters, create/get a colour pair corresponding
+        # to the colour codes and save one of the tables.
+
+        for item in colour_data:
+            item = item.strip()
+            if '=' in item:
+                code, colour = item.split('=')
+
+                colour_pair = self.curses_colour(colour)
+
+                if len(code) == 2 and '*' not in code and '.' not in code:
+                    self.special_highlight[code] = colour_pair
+                else:
+                    self.wildcard_highlight[code] = colour_pair
+
+    ################################################################################
+
+    def get_colour(self, filename, filemode=None):
+        """ Get the curses colour for a filename, returns 0 if no highlighting
+            is needed """
+
+        if filemode:
+            if stat.S_ISDIR(filemode):
+                if 'di' in self.special_highlight:
+                    return self.special_highlight['di']
+            elif stat.S_ISLNK(filemode):
+                destfile = os.readlink(filename)
+
+                if os.path.exists(destfile):
+                    if 'ln' in self.special_highlight:
+                        return self.special_highlight['ln']
+                elif 'or' in self.special_highlight:
+                    return self.special_highlight['or']
+
+            elif stat.S_ISBLK(filemode):
+                if 'bd' in self.special_highlight:
+                    return self.special_highlight['bd']
+            elif stat.S_ISCHR(filemode):
+                if 'cd' in self.special_highlight:
+                    return self.special_highlight['cd']
+
+            if filemode & stat.S_IXUSR:
+                if 'ex' in self.special_highlight:
+                    return self.special_highlight['ex']
+
+        for entry in self.wildcard_highlight:
+            if fnmatch.fnmatch(filename, entry):
+                colour = self.wildcard_highlight[entry]
+                break
+        else:
+            colour = 0
+
+        return colour
+
+    ################################################################################
+
+    def get_colour_pair(self, filename, filemode=None):
+        """ Get the curses colour pair for a filename, optionally specifying the
+            file mode (as per os.stat()) """
+
+        return curses.color_pair(self.get_colour(filename, filemode))
+
+################################################################################
+
+def _test_code(stdscr):
+    """ Entry point """
+
+    curses.start_color()
+    curses.use_default_colors()
+
+    # Initialise colours
+
+    dc = CursesDircolors()
+
+    # Demo code to list files specified by the first command line argument
+    # highlighted appropriately
+
+    y = 0
+    for filename in glob.glob(sys.argv[1]):
+        colour = dc.get_colour(filename)
+
+        stdscr.addstr(y, 0, filename, curses.color_pair(colour))
+
+        y += 1
+        if y > 30:
+            break
+
+    stdscr.getch()
+
+################################################################################
+
+if __name__ == "__main__":
+    curses.wrapper(_test_code)