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

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

@@ -0,0 +1,107 @@
+#! /usr/bin/env python3
+
+################################################################################
+""" Thingy addpath command
+
+    Copyright (C) 2018 John Skilleter
+
+    Update a $PATH-type variable by adding or removing entries.
+
+    Intended to be used as in:
+
+        export PATH=$(addpath $PATH --add /opt/bin)
+"""
+################################################################################
+
+import sys
+import os
+import argparse
+
+################################################################################
+
+def pathmod(pathentries, separator, pathlist, prefix=False, suffix=False, delete=False, force=False):
+    """ Modify a path.
+    """
+
+    # Only do something if the list of paths to add exists
+
+    if pathlist:
+        # Join the list path entries together then split them into individual entries
+        # Allows for a list of entries in the form ['a:b:c', 'd', 'e']
+
+        paths = separator.join(pathlist).split(separator)
+
+        # Process each entry
+
+        for entry in paths:
+            # Do nothing (except delete) if the path does not exist and we aren't forcing
+
+            if not entry or (not os.path.isdir(entry) and not (force or delete)):
+                continue
+
+            # If we are removing or adding/moving an entry remove any existing entry
+
+            if (delete or prefix or suffix) and entry in pathentries:
+                pathentries.remove(entry)
+
+            # Prefix or suffix the entry
+
+            if not delete and entry not in pathentries:
+                if suffix:
+                    pathentries.append(entry)
+                else:
+                    pathentries.insert(0, entry)
+
+    return pathentries
+
+################################################################################
+
+def main():
+    """ Main function - handles command line, outputs result to stdout """
+
+    parser = argparse.ArgumentParser(description='Add or remove entries from a path list (e.g. as used by the PATH environment variable)')
+    parser.add_argument('--add', action='append', help='Add an entry to the front of the path (do nothing if it is already present in the path)')
+    parser.add_argument('--prefix', action='append', help='Add an entry to the front of the path (or move it there if it is already present)')
+    parser.add_argument('--suffix', action='append', help='Add an entry to the end of the path (or move it there if it is already present)')
+    parser.add_argument('--remove', action='append', help='Remove an entry from the path (do nothing if it is not present')
+    parser.add_argument('--force', default=False, help='Add entries even if a corresponding directory does not exist')
+    parser.add_argument('--separator', action='store', default=':', help='Override the default path separator')
+    parser.add_argument('path', nargs=1, help='The path to modify')
+
+    args = parser.parse_args()
+
+    # Split the given path into component parts
+
+    pathsplit = [pathentry for pathentry in args.path[0].split(args.separator) if pathentry]
+
+    # Process the additions, suffixations, prefixanisms and deletes.
+
+    pathmod(pathsplit, args.separator, args.add)
+    pathmod(pathsplit, args.separator, args.prefix, prefix=True)
+    pathmod(pathsplit, args.separator, args.suffix, suffix=True)
+    pathmod(pathsplit, args.separator, args.remove, delete=True)
+
+    # Glue the path back together
+
+    pathjoin = args.separator.join(pathsplit)
+
+    # Output the updated path to stdout
+
+    print(pathjoin)
+
+################################################################################
+
+def addpath():
+    """Entry point"""
+
+    try:
+        main()
+    except KeyboardInterrupt:
+        sys.exit(1)
+    except BrokenPipeError:
+        sys.exit(2)
+
+################################################################################
+
+if __name__ == '__main__':
+    addpath()

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/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
+
+import thingy.colour as 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()

skilleter_thingy/diskspacecheck.py

@@ -0,0 +1,67 @@
+#! /usr/bin/env python3
+
+################################################################################
+""" Check how much free space is available on all filesystems, ignoring
+    read-only filesystems, /dev and tmpfs.
+
+    Issue a warning if any are above 90% used.
+"""
+################################################################################
+
+import sys
+import argparse
+import psutil
+
+################################################################################
+
+WARNING_LEVEL = 15
+
+################################################################################
+
+def main():
+    """ Do everything """
+
+    parser = argparse.ArgumentParser(description='Check for filesystems that are running low on space')
+    parser.add_argument('--level', action='store', type=int, default=WARNING_LEVEL,
+                        help='Warning if less than this amount of space is available on any writeable, mounted filesystem (default=%d)' % WARNING_LEVEL)
+    args = parser.parse_args()
+
+    if args.level < 0 or args.level > 100:
+        print('Invalid value: %d' % args.level)
+        sys.exit(3)
+
+    disks = psutil.disk_partitions()
+    devices = []
+    warning = []
+
+    for disk in disks:
+        if 'ro' not in disk.opts.split(',') and disk.device not in devices:
+            devices.append(disk.device)
+            usage = psutil.disk_usage(disk.mountpoint)
+
+            disk_space = 100 - usage.percent
+
+            if disk_space < args.level:
+                warning.append('%s has only %2.1f%% space available' % (disk.mountpoint, disk_space))
+
+    if warning:
+        print('Filesystems with less than %d%% available space:' % args.level)
+        print('\n'.join(warning))
+
+################################################################################
+
+def diskspacecheck():
+    """Entry point"""
+
+    try:
+        main()
+
+    except KeyboardInterrupt:
+        sys.exit(1)
+    except BrokenPipeError:
+        sys.exit(2)
+
+################################################################################
+
+if __name__ == '__main__':
+    diskspacecheck()

skilleter_thingy/docker_purge.py

@@ -0,0 +1,113 @@
+#! /usr/bin/env python3
+
+################################################################################
+""" Thingy docker-purge command
+
+    Copyright (C) 2017 John Skilleter
+
+    Initial version - contains only basic error checking and limited debug output.
+"""
+################################################################################
+
+import sys
+import re
+import argparse
+
+import thingy.logger as logger
+import thingy.docker as docker
+
+################################################################################
+
+def initialise():
+    """ Parse the command line """
+
+    parser = argparse.ArgumentParser(description='Purge docker instances and images')
+
+    parser.add_argument('-s', '--stop', action='store_true', help='Stop Docker instances')
+    parser.add_argument('-k', '--kill', action='store_true', help='Kill Docker instances')
+    parser.add_argument('-r', '--remove', action='store_true', help='Remove Docker images')
+    parser.add_argument('-l', '--list', action='store_true', help='List what would be done without doing it')
+    parser.add_argument('-f', '--force', action='store_true', help='Forcibly kill/remove instances')
+    parser.add_argument('--debug', action='store_true', help='Enable debug output')
+    parser.add_argument('images', nargs='*', help='List of Docker containers (regular expression)')
+
+    args = parser.parse_args()
+
+    # Configure logging
+
+    log = logger.init('git-prompt')
+
+    if args.debug:
+        log.setLevel(logger.DEBUG)
+        log.info('Debug logging enabled')
+
+    # Default is to stop matching images
+
+    if not args.stop and not args.kill and not args.remove:
+        args.stop = True
+
+    # Default is to match all containers
+
+    if not args.images:
+        args.images = '.*'
+    else:
+        args.images = '|'.join(args.images)
+
+    log.info('Arguments: %s', args)
+    return args
+
+################################################################################
+
+def main(args):
+    """ Main code """
+
+    try:
+        if args.stop or args.kill:
+            for instance in docker.instances():
+                if re.match(args.images, instance):
+
+                    print('Stopping instance: %s' % instance)
+
+                    if not args.list:
+                        docker.stop(instance, force=args.force)
+
+        if args.kill:
+            for instance in docker.instances(all=True):
+                if re.match(args.images, instance):
+
+                    print('Removing instance: %s' % instance)
+
+                    if not args.list:
+                        docker.rm(instance)
+
+        if args.remove:
+            for image in docker.images():
+                if re.match(args.images, image):
+
+                    print('Removing image: %s' % image)
+
+                    if not args.list:
+                        docker.rmi(image, force=args.force)
+
+    except docker.DockerError as exc:
+        sys.stderr.write(str(exc))
+        sys.exit(1)
+
+################################################################################
+
+def docker_purge():
+    """Entry point"""
+
+    try:
+        config = initialise()
+        main(config)
+
+    except KeyboardInterrupt:
+        sys.exit(1)
+    except BrokenPipeError:
+        sys.exit(2)
+
+################################################################################
+
+if __name__ == '__main__':
+    docker_purge()