skilleter-thingy 0.0.22__py3-none-any.whl

skilleter_thingy/borger.py

@@ -0,0 +1,269 @@
+#! /usr/bin/env python3
+
+"""
+Wrapper for the borg backup command
+
+Copyright (C) 2018 John Skilleter
+
+TODO: Major tidy-up as this is a translation of a Bash script.
+TODO: Merge with the usb-backup script since both do almost the same job
+TODO: Default configuration file should be named for the hostname
+TODO: Move all configuration data into the configuration file
+"""
+
+################################################################################
+# Imports
+
+import sys
+import os
+import time
+import argparse
+import configparser
+import subprocess
+from pathlib import Path
+
+################################################################################
+# Variables
+
+DEFAULT_CONFIG_FILE = Path('borger.ini')
+
+COMMANDS = ('backup', 'mount', 'umount', 'compact', 'info', 'prune', 'check', 'init')
+
+# TODO: NOT USED
+PRUNE_OPTIONS = [
+    '--keep-within', '7d',
+    '--keep-daily', '30',
+    '--keep-weekly', '26',
+    '--keep-monthly', '24',
+    '--keep-yearly', '10',
+]
+
+################################################################################
+
+def run(args, cmd):
+    """Run a subprocess."""
+
+    if args.debug:
+        cmd_str = ' '.join(cmd)
+        print(f'Running "{cmd_str}"')
+
+    return subprocess.run(cmd, check=True)
+
+################################################################################
+
+def borg_backup(args, exclude_list):
+    """Perform a backup."""
+
+    create_options = ['--compression', 'auto,lzma']
+
+    version = time.strftime('%Y-%m-%d-%H:%M:%S')
+
+    print(f'Creating backup version {version}')
+
+    if args.verbose:
+        create_options += ['--list', '--filter=AMC']
+
+    if args.dryrun:
+        create_options.append('--dry-run')
+    else:
+        create_options.append('--stats')
+
+    exclude_opts = []
+
+    if exclude_list:
+        for exclude in exclude_list:
+            exclude_opts += ['--exclude', exclude]
+
+    os.chdir(args.source)
+
+    run(args,
+        ['borg'] + args.options + ['create', f'{str(args.destination)}::{version}', str(args.source)] + create_options +
+        ['--show-rc', '--one-file-system', '--exclude-caches'] + exclude_opts)
+
+################################################################################
+
+def borg_prune(args):
+    """Prune the repo by limiting the number of backups stored."""
+
+    print('Pruning old backups')
+
+    # Keep all backups for at least 7 days, 1 per day for 30 days, 1 per week for 2 years
+    # 1 per month for 4 years and 1 per year for 10 years.
+
+    run(args, ['borg'] + args.options + ['prune', str(args.destination)] + PRUNE_OPTIONS)
+
+################################################################################
+
+def borg_compact(args):
+    """Compact the repo."""
+
+    print('Compacting the backup')
+
+    # Keep all backups for at least 7 days, 1 per day for 30 days, 1 per week for 2 years
+    # 1 per month for 4 years and 1 per year for 10 years.
+
+    run(args, ['borg'] + args.options + ['compact', str(args.destination)])
+
+################################################################################
+
+def borg_info(args):
+    """Info."""
+
+    run(args, ['borg'] + args.options + ['info', str(args.destination)])
+
+################################################################################
+
+def borg_mount(args):
+    """Mount."""
+
+    print(f'Mounting Borg backups at {args.mount_dir}')
+
+    mount = Path(args.mount_dir)
+
+    if not mount.is_dir():
+        mount.mkdir()
+
+    run(args, ['borg'] + args.options + ['mount', str(args.destination), str(mount)])
+
+################################################################################
+
+def borg_umount(args):
+    """Unmount."""
+
+    print('Unmounting {args.mount}')
+
+    run(args, ['borg'] + args.options + ['umount', str(args.mount)])
+
+################################################################################
+
+def borg_check(args):
+    """Check the status of a backup."""
+
+    run(args, ['borg'] + args.options + ['check', str(args.destination)])
+
+################################################################################
+
+def borg_init(args):
+    """Initialise a backup."""
+
+    run(args, ['borg'] + args.options + ['init', str(args.destination), '--encryption=none'])
+
+################################################################################
+
+def process_excludes(exclude_data):
+    """Process the include list from the configuration file."""
+
+    return exclude_data.replace('%', str(Path.cwd())).split('\n')
+
+################################################################################
+
+def main():
+    """Entry point."""
+
+    command_list = ', '.join(COMMANDS)
+
+    parser = argparse.ArgumentParser(description='Wrapper app for Borg backup to make it easier to use')
+    parser.add_argument('--dryrun', '--dry-run', '-D', action='store_true', help='Dry-run comands')
+    parser.add_argument('--debug', '-d', action='store_true', help='Debug')
+    parser.add_argument('--verbose', '-v', action='store_true', help='Verbosity to the maximum')
+    parser.add_argument('--config', '-c', default=None, help='Specify the configuration file')
+    parser.add_argument('commands', nargs='+', help=f'One or more commands ({command_list})')
+    args = parser.parse_args()
+
+    # If no config file specified then look in all the usual places
+
+    if args.config:
+        args.config = Path(args.config)
+    elif DEFAULT_CONFIG_FILE.is_file():
+        args.config = DEFAULT_CONFIG_FILE
+    else:
+        args.config = Path.home() / DEFAULT_CONFIG_FILE
+
+        if not args.config.is_file():
+            args.config = Path(sys.argv[0]).parent / DEFAULT_CONFIG_FILE
+
+    # Check that the configuration file exists
+
+    if not args.config.is_file():
+        print(f'Configuration file "{args.config}" not found')
+        sys.exit(1)
+
+    # Default options
+
+    args.options = []
+
+    # Read the configuration file
+
+    config = configparser.ConfigParser(interpolation=configparser.ExtendedInterpolation())
+    config.read(args.config)
+
+    if 'borger' not in config:
+        print('Invalid configuration file "args.config"')
+        sys.exit(1)
+
+    exclude = process_excludes(config['borger']['exclude']) if 'exclude' in config['borger'] else []
+
+    if 'prune' in config['borger']:
+        # TODO: Stuff
+        print('Parser for the prune option is not implemented yet')
+        sys.exit(1)
+
+    if 'destination' in config['borger']:
+        args.destination = config['borger']['destination']
+    else:
+        print('Destination directory not specified')
+        sys.exit(1)
+
+    if 'source' in config['borger']:
+        args.source = Path(config['borger']['source'])
+    else:
+        print('Source directory not specified')
+        sys.exit(1)
+
+    # Initialise if necessary
+
+    if args.debug:
+        args.options.append('--verbose')
+
+    if args.verbose:
+        args.options.append('--progress')
+
+    # Decide what to do
+
+    for command in args.commands:
+        if command == 'backup':
+            borg_backup(args, exclude)
+        elif command == 'mount':
+            borg_mount(args)
+        elif command == 'umount':
+            borg_umount(args)
+        elif command == 'info':
+            borg_info(args)
+        elif command == 'prune':
+            borg_prune(args)
+        elif command == 'check':
+            borg_check(args)
+        elif command == 'init':
+            borg_init(args)
+        elif command == 'compact':
+            borg_compact(args)
+        else:
+            print(f'Unrecognized command: {command}')
+            sys.exit(2)
+
+################################################################################
+
+def borger():
+    """Entry point"""
+
+    try:
+        main()
+    except KeyboardInterrupt:
+        sys.exit(1)
+    except BrokenPipeError:
+        sys.exit(2)
+
+################################################################################
+
+if __name__ == '__main__':
+    borger()

skilleter_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/console_colours.py

@@ -0,0 +1,63 @@
+#! /usr/bin/env python3
+
+################################################################################
+""" Output all console colours
+
+    Copyright (C) 2017-18 John Skilleter
+
+    Licence: GPL v3 or later
+"""
+################################################################################
+
+import sys
+
+from skilleter_thingy import colour
+
+################################################################################
+
+def main():
+    """ Main function - draw the colour grid """
+
+    # Extended ANSI colour are slightly weird.
+    # Colours 0-15 are the standard basic colours
+    # Colours 16-231 form a 6x6x6 colour cube
+    # Colours 232-255 are greyscale range with colours 0 and 15 as black and white
+
+    for code in range(0, 256):
+        if code in (8, 16) or (code > 16 and (code - 16) % 6 == 0):
+            colour.write('')
+
+        if (code - 16) % 36 == 0:
+            colour.write('')
+
+        # Set the foreground code to be white for dark backgrounds
+
+        foreground = 15 if code in (0, 1, 4, 5, 8, 12) \
+            or (16 <= code <= 33) \
+            or (52 <= code <= 69) \
+            or (88 <= code <= 105) \
+            or (124 <= code <= 135) \
+            or (160 <= code <= 171) \
+            or (196 <= code <= 201) \
+            or (232 <= code <= 243) else 0
+
+        colour.write('[B%d][%d] %3d [NORMAL] ' % (code, foreground, code), newline=False)
+
+    print()
+
+################################################################################
+
+def console_colours():
+    """Entry point"""
+
+    try:
+        main()
+    except KeyboardInterrupt:
+        sys.exit(1)
+    except BrokenPipeError:
+        sys.exit(2)
+
+################################################################################
+
+if __name__ == '__main__':
+    console_colours()