Source code for version_tool

# labtools, Copyright (C) 2017 Jerry Fowler and Paul Scheet.
# This program comes with ABSOLUTELY NO WARRANTY. It is licensed under
# GNU GPL Version 3. License and warranty may be viewed in the manual.
'''
version_tool
'''

import os
import sys

import re

from labtools import const
from labtools import misc
from labtools import reflection

def make_version_list(vlist):
    '''
    Strip off and ignore -SNAP or any other trailing string
    '''
    if isinstance(vlist, str):
        vlist = vlist.split(const.DOT)
    vlist = [int(n) if str(n).isdigit() else n for n in vlist]
    if not str(vlist[-1]).isdigit():
        m = re.match(r'(\d*)(\D*)$', vlist[-1])
        vlist[-1] = 0 if m.group(1) == const.EMPTY else int(m.group(1))
    return vlist

class version_tool():
    
    def __init__(self, my_version, lowest_acceptable=[0]):
        '''
        '''
        if not isinstance(my_version, list):
            raise UserWarning('Programmer: version should be a numeric list (got %r)' % (my_version))
        if not isinstance(lowest_acceptable, list):
            raise UserWarning('Programmer: lowest_acceptable should be a numeric list (got %r)' % (my_version))
        self.my_version = my_version 
        self.lowest_acceptable = lowest_acceptable
        for element in my_version[:-1]:
            if not isinstance(element, int):
                raise UserWarning('Programmer: all but the last element of __version__ should be a numeric list (got %s)' % (my_version))


    def version(self, version_list=None, lowest_acceptable=False):
        '''
        Return the version as a dotted string
        '''
        if version_list is None:
            version_list = self.lowest_acceptable if lowest_acceptable else self.my_version
        return const.DOT.join([str(v) for v in version_list])


    def version_acceptable(self, x, lowerbound, upperbound=None):
        w = DeprecationWarning('%s is obsolete, is_package_version_acceptable(lowerbound[, upperbound]) instead' %
                               (reflection.my_methodname()))
        if False:
            raise w
        else:
            print(w.message, file=sys.stderr)
        return self.is_package_version_acceptable(lowerbound, upperbound)


    def is_package_version_acceptable(self, lowerbound, upperbound=None):
        '''
        Test whether the package version meets the boundaries.
        Be satisfied with any numerically or lexically higher revision 
        less than or equal to *upperbound* if given
        
        Elements of the version can have trailing strings.
        '''
        #print('Testing %r' % (test_version))
        my_version = make_version_list(self.my_version)
        lowerbound = make_version_list(lowerbound)
        if len(lowerbound) < len(my_version):
            lowerbound.extend(my_version[len(lowerbound):])
        elif len(lowerbound) > len(my_version):
            my_version.extend([0]*(len(lowerbound)-len(my_version)))
        lowerstrict = [(lowerbound[i] < my_version[i]) for i in range(len(my_version))]
        lowerequal = [(lowerbound[i] == my_version[i]) for i in range(len(my_version))]
        for i in range(len(lowerstrict)):
            if lowerstrict[i]:
                break
            elif not lowerequal[i]:
                return False
        if upperbound is None:
            return True
        upperbound = make_version_list(upperbound)
        if len(upperbound) < len(my_version):
            upperbound.extend(my_version[len(upperbound):])
        elif len(upperbound) > len(my_version):
            my_version.extend([0]*(len(upperbound)-len(my_version)))
        upperstrict = [(upperbound[i] > my_version[i]) for i in range(len(my_version))]
        upperequal = [(upperbound[i] == my_version[i]) for i in range(len(my_version))]
        for i in range(len(upperstrict)):
            if upperstrict[i]:
                break
            elif not upperequal[i]:
                return False
        return True


    def is_retrieved_version_acceptable_to_package(self, retrieved, lowerbound=None):
        '''
        Test whether the retrieved version can be used by the package.
        Be satisfied with any retrieved version between a lowerbound (if given) and my_version.
        
        Elements of the version can have trailing strings.
        '''
        #print('Testing %r' % (test_version))
        my_version = make_version_list(self.my_version)
        retrieved = make_version_list(retrieved)
        if len(retrieved) < len(my_version):
            retrieved.extend(my_version[len(retrieved):])
        elif len(retrieved) > len(my_version):
            my_version.extend([0]*(len(retrieved)-len(my_version)))
        lowerbound = make_version_list(lowerbound if lowerbound else self.lowest_acceptable)
        if len(lowerbound) < len(my_version):
            lowerbound.extend(retrieved[len(lowerbound):])
        upperstrict = [(retrieved[i] < my_version[i]) for i in range(len(retrieved))]
        upperequal = [(retrieved[i] == my_version[i]) for i in range(len(retrieved))]
        for i in range(len(upperstrict)):
            if upperstrict[i]:
                break
            elif not upperequal[i]:
                return False
        lowerstrict = [(lowerbound[i] < retrieved[i]) for i in range(len(retrieved))]
        lowerequal = [(lowerbound[i] == retrieved[i]) for i in range(len(retrieved))]
        for i in range(len(lowerstrict)):
            if lowerstrict[i]:
                break
            elif not lowerequal[i]:
                return False
        return True