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

skilleter_thingy/thingy/gitlab.py

@@ -0,0 +1,193 @@
+#! /usr/bin/env python3
+
+################################################################################
+""" GitLab module - implemented using the REST API as some features are not
+    available (or don't work) in the official Python module
+
+    Copyright (C) 2017-20 John Skilleter
+
+    Licence: GPL v3 or later
+
+    Note: There are two types of function for returning data from GitLab;
+    the paged functions and the non-paged ones - the paged ones return a page
+    (normally 20 items) of data and need to be called repeated until no data is
+    left whereas the non-paged ones query all the data and concatenate it
+    together.
+
+    The paged functions expect a full request string with the URL, as returned
+    by the request_string() member. The non-paged ones call request_string()
+    to add the URL & API prefix.
+"""
+################################################################################
+
+import sys
+import os
+
+try:
+    import requests
+except ModuleNotFoundError:
+    sys.stderr.write('This code requires the Python "requests" module which should be installed via your package manager\n')
+    sys.exit(1)
+
+################################################################################
+
+class GitLabError(Exception):
+    """ Gitlab exceptions """
+
+    def __init__(self, response):
+        """ Save the error code and text """
+
+        self.status = response.status_code
+        self.message = response.reason
+
+    def __str__(self):
+        """ Return a string version of the exception """
+
+        return '%s: %s' % (self.status, self.message)
+
+################################################################################
+
+class GitLab:
+    """ Class for GitLab access """
+
+    def __init__(self, gitlab, token=None):
+        """ Initialisation """
+
+        # Save the GitLab URL
+
+        self.gitlab = gitlab
+
+        # If we have a private token use it, otherwise try and get it from
+        # the environmnet
+
+        self.token = token if token else os.getenv('GITLAB_TOKEN', None)
+
+        # Create the default header for requests
+
+        self.header = {'Private-Token': self.token}
+
+    ################################################################################
+
+    @staticmethod
+    def encode_project(name):
+        """ Encode a project name in the form request by GitLab requests """
+
+        return name.replace('/', '%2F')
+
+    ################################################################################
+
+    def request_string(self, request):
+        """ Add the URL/API header onto a request string """
+
+        return '%s/api/v4/%s' % (self.gitlab, request)
+
+    ################################################################################
+
+    def request(self, request, parameters=None):
+        """ Send a request to GitLab - handles pagination and returns all the
+            results concatenated together """
+
+        if parameters:
+            request = '%s?%s' % (request, '&'.join(parameters))
+
+        gl_request = self.request_string(request)
+
+        # Keep requesting data until there's no 'next' link in the response
+
+        while True:
+            response = requests.get(gl_request, headers=self.header)
+
+            if not response:
+                raise GitLabError(response)
+
+            yield response.json()
+
+            if 'next' not in response.links:
+                break
+
+            gl_request = response.links['next']['url']
+
+    ################################################################################
+
+    def paged_request(self, request):
+        """ Send a request to GitLab - returns all the results concatenated together
+            and returns a page of results along with the request for the next page of
+            results (if any).
+
+            Note that the request parameter is the full request string as returned by
+            request_string(). """
+
+        response = requests.get(request, headers=self.header)
+
+        result = response.json()
+
+        if not response:
+            raise GitLabError(response)
+
+        request = response.links['next']['url'] if 'next' in response.links else None
+
+        return result, request
+
+    ################################################################################
+
+    def projects(self):
+        """ Return a list of projects """
+
+        return self.request('projects')
+
+    ################################################################################
+
+    def branches(self, repo):
+        """ Return the list of branches in a repo """
+
+        for batch in self.request('projects/%s/repository/branches' % self.encode_project(repo)):
+            for branch in batch:
+                yield branch
+
+    ################################################################################
+
+    def merge_requests(self, **kwargs):
+        """ Return a list of merge requests filtered according to the parameters """
+
+        request = 'merge_requests'
+
+        parameters = []
+
+        for data in kwargs:
+            parameters.append('%s=%s' % (data, kwargs[data]))
+
+        for result in self.request(request, parameters):
+            for r in result:
+                yield r
+
+    ################################################################################
+
+    def default_branch(self, repo):
+        """ Query gitlab to retreive the default branch for the repo """
+
+        # Look for the default branch
+
+        for branch in self.branches(repo):
+            if branch['default']:
+                return branch['name']
+
+        return None
+
+    ################################################################################
+
+    def isbranch(self, repo, branchname):
+        """ Return True if the branch exists in the repo """
+
+        request = self.request_string('projects/%s/repository/branches' % self.encode_project(repo))
+
+        while True:
+            branches, request = self.paged_request(request)
+
+            for branch in branches:
+                if branch['name'] == branchname:
+                    return True
+
+            if not request:
+                break
+
+        return False

skilleter_thingy/thingy/logger.py

@@ -0,0 +1,112 @@
+#! /usr/bin/env python3
+
+################################################################################
+""" Thingy logging functionality - wraps the Pythong logging module
+
+    Copyright (c) 2017 John Skilleter
+
+    Licence: GPL v3 or later
+"""
+################################################################################
+
+import os
+
+import logging
+
+################################################################################
+
+CRITICAL = logging.CRITICAL
+ERROR = logging.ERROR
+WARNING = logging.WARNING
+INFO = logging.INFO
+DEBUG = logging.DEBUG
+NOTSET = logging.NOTSET
+
+LOG_LEVELS = {
+    'CRITICAL': CRITICAL, 'ERROR': ERROR, 'WARNING': WARNING, 'INFO': INFO,
+    'DEBUG': DEBUG, 'NOTSET': NOTSET
+}
+
+__config_done__ = False
+
+################################################################################
+
+def set_logging(log, name):
+    """ If an environment variable called NAME_DEBUG is set and defines a
+        log level that is more verbose than the current level then set
+        that level (you can only increase verbosity via the variable, not
+        decrease it). """
+
+    # Check whether there is an environment variable setting the debug level
+
+    env_name = '%s_DEBUG' % name.upper()
+
+    value = os.getenv(env_name, None)
+
+    if value is not None:
+        value = value.upper()
+
+        current = log.getEffectiveLevel()
+
+        # Check for a textual level in the value and if no match, try
+        # for an integer level ignoring invalid values.
+
+        if value in LOG_LEVELS:
+            if current > LOG_LEVELS[value]:
+                log.setLevel(LOG_LEVELS[value])
+        else:
+            try:
+                intlevel = int(value)
+
+                if current > intlevel:
+                    log.setLevel(intlevel)
+
+            except ValueError:
+                pass
+
+    return log
+
+################################################################################
+
+def init(name):
+    """ Initilise logging and create a logger.
+        If the environment variable NAME_DEBUG is set to a value in LOG_LEVELS
+        then the log level is set to that level. If NAME_DEBUG is an integer
+        then the same applies, otherwise, by default, the log level is CRITICAL """
+
+    # Create the new logger
+
+    log = logging.getLogger(name)
+
+    # Default log level is CRITICAL
+
+    log.setLevel(CRITICAL)
+
+    # Set logging according to the value of THINGY_DEBUG (if set) then
+    # override with the logger-specific variable (again, if set)
+
+    set_logging(log, 'THINGY')
+    set_logging(log, name)
+
+    return log
+
+################################################################################
+# Entry point
+
+# Ensure that the logging module is initialise
+
+if not __config_done__:
+    logging.basicConfig()
+    __config_done__ = True
+
+if __name__ == '__main__':
+    demo = init('wombat')
+
+    demo.critical('Critical error')
+
+    # These messages should only appear if the WOMBAT_DEBUG environment variable
+    # is set to an appropriate value (ERROR, WARNING or INFO)
+
+    demo.error('Error message')
+    demo.warning('Warning message')
+    demo.info('Info message')

skilleter_thingy/thingy/path.py

@@ -0,0 +1,156 @@
+#! /usr/bin/env python3
+
+################################################################################
+""" Thingy file and directory functionality
+
+    Copyright (C) 2017-18 John Skilleter
+
+    Licence: GPL v3 or later
+"""
+################################################################################
+
+import os
+
+import thingy.logger as logger
+
+################################################################################
+
+class PathError(Exception):
+    """ Exception raised by the module """
+
+    def __init__(self, msg):
+        super(PathError, self).__init__(msg)
+        self.msg = msg
+
+################################################################################
+
+def is_subdirectory(root_path, sub_path):
+    """ Return True if sub_path is a sub-directory of root_path """
+
+    abs_sub_path = os.path.abspath(sub_path)
+    abs_root_path = os.path.abspath(root_path)
+
+    log.debug('root path: %s', abs_root_path)
+    log.debug('sub path : %s', abs_sub_path)
+
+    return abs_sub_path.startswith('%s/' % abs_root_path)
+
+################################################################################
+
+def trimpath(full_path, trim_width):
+    """ Trim a path to a specified maximum width, but always leaving the
+        lowest-level directory (even if it exceeds the trim width). """
+
+    log.debug('Path: "%s"', full_path)
+    log.debug('Required width: %d', trim_width)
+
+    full_path = os.path.abspath(full_path)
+
+    # Remove any trailing '/' from the path
+
+    if full_path != '/' and full_path[-1] == '/':
+        full_path = full_path[:-1]
+
+    # If the path starts with the user's home directory then convert the prefix
+    # into a '~'
+
+    home_dir = os.path.expanduser('~')
+
+    if full_path == home_dir:
+        full_path = '~'
+        log.debug('Converted path to "~"')
+
+    elif is_subdirectory(home_dir, full_path):
+        full_path = "~/%s" % full_path[len(home_dir) + 1:]
+
+        log.debug('Converted path to "%s"', full_path)
+
+    # If the path is too long then slice it into directories and cut sub-directories
+    # out of the middle until it is short enough. Always leave the last element
+    # in place, even if this means total length exceeds the requirement.
+
+    path_len = len(full_path)
+
+    log.debug('Path length: %d', path_len)
+
+    # Already within maximum width, so just return it
+
+    if path_len <= trim_width:
+        return full_path
+
+    # Split into an array of directories and trim out middle ones
+
+    directories = full_path.split('/')
+
+    log.debug('Path has %d elements: "%s"', len(directories), directories)
+
+    if len(directories) == 1:
+        # If there's only one element in the path, just give up
+
+        log.debug('Only 1 directory in the path, leaving it as-is')
+
+    elif len(directories) == 2:
+        # If there's only two elements in the path then replace the first
+        # element with '...' and give up
+
+        log.debug('Only 2 directories in the path, so setting the first to "..."')
+
+        directories[0] = '...'
+
+    else:
+        # Start in the middle and remove entries to the left and right until the total
+        # path length is shortened to a sufficient extent
+
+        right = len(directories) // 2
+        left = right - 1
+        first = True
+
+        while path_len > trim_width:
+
+            path_len -= len(directories[right]) + 1
+
+            if first:
+                path_len += 4
+                first = False
+
+            if right == len(directories) - 1:
+                break
+
+            right += 1
+
+            if path_len > trim_width:
+                path_len -= len(directories[left]) + 1
+
+                if left == 0:
+                    break
+
+                left -= 1
+
+        log.debug('Removing entries %d..%d from the path', left, right)
+
+        directories = directories[0:left + 1] + ['...'] + directories[right:]
+
+    full_path = '/'.join(directories)
+
+    log.debug('Calculated width is %d and actual width is %d', path_len, len(full_path))
+
+    return full_path
+
+################################################################################
+
+log = logger.init('tgy_path')
+
+if __name__ == '__main__':
+    PARENT = '/1/2/3/5'
+    CHILD = '/1/2/3/5/6'
+
+    print('Is %s a subdirectory of %s: %s (expecting True)' % (CHILD, PARENT, is_subdirectory(PARENT, CHILD)))
+    print('Is %s a subdirectory of %s: %s (expecting False)' % (PARENT, CHILD, is_subdirectory(CHILD, PARENT)))
+
+    LONG_PATH = '/home/jms/source/womble-biscuit-token-generation-service/subdirectory'
+
+    for pathname in (LONG_PATH, os.path.realpath('.')):
+        print('Full path: %s' % pathname)
+
+        for length in (80, 60, 40, 20, 16, 10):
+            print('Trimmed to %d characters: %s' % (length, trimpath(pathname, length)))

skilleter_thingy/thingy/popup.py

@@ -0,0 +1,87 @@
+################################################################################
+""" Curses-based pop-up message
+
+Usage:
+    with PopUp(curses_screen, message, colour):
+        do_stuff
+
+Popup message is displayed for the duration of the with statement, and
+has optional parameters to wait for a keypress, and/or pause before removing
+the popup again.
+
+"""
+################################################################################
+
+import time
+import curses
+
+################################################################################
+
+class PopUp():
+    """ Class to enable popup windows to be used via with statements """
+
+    def __init__(self, screen, msg, colour, waitkey=False, sleep=True, centre=True, refresh=True):
+        """ Initialisation - just save the popup parameters """
+
+        self.panel = None
+        self.screen = screen
+        self.msg = msg
+        self.centre = centre
+        self.colour = curses.color_pair(colour)
+        self.refresh = refresh
+        self.sleep = sleep and not waitkey
+        self.waitkey = waitkey
+        self.start_time = 0
+
+    def __enter__(self):
+        """ Display the popup """
+
+        lines = self.msg.split('\n')
+        height = len(lines)
+
+        width = 0
+        for line in lines:
+            width = max(width, len(line))
+
+        width += 2
+        height += 2
+
+        size_y, size_x = self.screen.getmaxyx()
+
+        window = curses.newwin(height, width, (size_y - height) // 2, (size_x - width) // 2)
+        self.panel = curses.panel.new_panel(window)
+
+        window.bkgd(' ', self.colour)
+        for y_pos, line in enumerate(lines):
+            x_pos = (width - len(line)) // 2 if self.centre else 1
+            window.addstr(y_pos + 1, x_pos, line, self.colour)
+
+        self.panel.top()
+        curses.panel.update_panels()
+        self.screen.refresh()
+
+        self.start_time = time.monotonic()
+
+        if self.waitkey:
+            while True:
+                keypress = self.screen.getch()
+                if keypress != curses.KEY_RESIZE:
+                    break
+
+                curses.panel.update_panels()
+                self.screen.refresh()
+
+    def __exit__(self, exc_type, exc_value, exc_traceback):
+        """ Remove the popup """
+
+        if self.panel:
+            if self.sleep:
+                elapsed = time.monotonic() - self.start_time
+
+                if elapsed < 1:
+                    time.sleep(1 - elapsed)
+
+            del self.panel
+            
+        if self.refresh:
+            self.screen.refresh()

skilleter_thingy/thingy/process.py

@@ -0,0 +1,112 @@
+#! /usr/bin/env python3
+
+################################################################################
+""" Basic subprocess handling - simplified API to the Python subprocess module
+
+    Copyright (C) 2017-18 John Skilleter
+
+    Licence: GPL v3 or later
+"""
+################################################################################
+
+import subprocess
+import sys
+
+import thingy.logger as logger
+
+################################################################################
+
+class RunError(Exception):
+    """ Run exception """
+
+    def __init__(self, msg, status=1):
+        super(RunError, self).__init__(msg)
+        self.msg = msg
+        self.status = status
+
+################################################################################
+
+def run(command, foreground=False, shell=False):
+    """ Run the specified command and return the output.
+        command - the command to run as an array of command+arguments
+        foreground - set to True to run the command in the foreground, using stdin/err/out
+        shell - set to True to run the command inside a shell (allows the command to be specified
+                as a string, but needs spaces to bew quoted
+        Returns an empty array if foreground is True or an array of the output otherwise. """
+
+    # TODO: for background use subprocess.Popen but use devnull = open('/dev/null', 'w') for stdio and return proc instead of communicating with it?
+
+    log.info('Running "%s"', ' '.join(command))
+
+    # If running in the foreground, run the command and either return an empty value
+    # on success (output is to the console) or raise a RunError
+
+    if foreground:
+        try:
+            if shell:
+                # TODO: Handle command lines with parameters containing spaces
+                command = ' '.join(command)
+
+            status = subprocess.run(command, shell=shell).returncode
+            if status:
+                raise RunError('Error %d' % status, status)
+            else:
+                return []
+        except OSError as exc:
+            raise RunError(exc)
+    else:
+        # Run the command and capture stdout and stderr
+
+        try:
+            proc = subprocess.run(command, stderr=subprocess.PIPE, stdout=subprocess.PIPE, universal_newlines=True)
+        except OSError as exc:
+            raise RunError(exc)
+
+        log.info('Stdout: %s', proc.stdout)
+        log.info('Stderr: %s', proc.stderr)
+
+        # If it returned an error raise a RunError exception with the stdout text as the
+        # exception message
+
+        if proc.returncode:
+            raise RunError(proc.stderr)
+
+        # Otherwise return the stdout data or nothing
+
+        if proc.stdout:
+            output = proc.stdout.split('\n')
+        else:
+            output = []
+
+        # Remove trailing blank lines from the output
+
+        while output and output[-1] == '':
+            output = output[:-1]
+
+        log.info('Output: %s', output)
+        return output
+
+################################################################################
+
+log = logger.init('tgy_process')
+
+if __name__ == '__main__':
+    print('Run ls -l:')
+
+    cmd_output = run(['ls', '-l'])
+
+    for o in cmd_output:
+        print(o)
+
+    print('Run wombat (should fail):')
+    try:
+        run(['wombat'])
+    except RunError as exc:
+        print('Failed with error: %s' % exc.msg)
+
+    if sys.stdout.isatty():
+        print('Run vi in the foreground')
+
+        run(['vi'], foreground=True)
+    else:
+        print('Not testing call to run() with foreground=True as stdout is not a TTY')