skilleter-modules 0.0.1__py3-none-any.whl

skilleter_modules/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_modules/path.py

@@ -0,0 +1,153 @@
+#! /usr/bin/env python3
+
+################################################################################
+""" Thingy file and directory functionality
+
+    Copyright (C) 2017-18 John Skilleter
+
+    Licence: GPL v3 or later
+"""
+################################################################################
+
+import os
+import logging
+
+################################################################################
+
+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)
+
+    logging.debug('root path: %s', abs_root_path)
+    logging.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). """
+
+    logging.debug('Path: "%s"', full_path)
+    logging.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 = '~'
+        logging.debug('Converted path to "~"')
+
+    elif is_subdirectory(home_dir, full_path):
+        full_path = "~/%s" % full_path[len(home_dir) + 1:]
+
+        logging.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)
+
+    logging.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('/')
+
+    logging.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
+
+        logging.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
+
+        logging.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
+
+        logging.debug('Removing entries %d..%d from the path', left, right)
+
+        directories = directories[0:left + 1] + ['...'] + directories[right:]
+
+    full_path = '/'.join(directories)
+
+    logging.debug('Calculated width is %d and actual width is %d', path_len, len(full_path))
+
+    return full_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_modules/popup.py

@@ -0,0 +1,88 @@
+################################################################################
+""" 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
+import curses.panel
+
+################################################################################
+
+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()