version_recommend.py

#!-*- coding:utf-8 -*-

import re
import datetime
import time
from typing import List

__ALL__ = ["VersionRecommend"]

class VersionType(object):

    def __init__(self):
        self._version_type = None

    def version_match(self, pkg_version):
        pass

    def latest_version(self, version_entry):
        version_entry.sort(reverse=True)
        return version_entry[0]

    def maintain_version(self, version_entry, current_version, pkg_type):
        _ = version_entry, pkg_type
        return current_version

    def _max(self, z1, z2):
        d1 = tuple(self._split(z1))  # 第一个参数版本号拆分,获取里面的数字/字母,得到序列
        d2 = tuple(self._split(z2))  # 第二个参数版本号拆分,获取里面的数字/字母,得到序列
        len1 = len(d1)
        len2 = len(d2)
        length = min(len1, len2)
        for index in range(length):
            if d1[index].isdigit() and d1[index].isdigit():
                if int(d1[index]) > int(d2[index]):
                    return 1
                elif int(d1[index]) < int(d2[index]):
                    return -1
            else:
                if d1[index] > d2[index]:
                    return 1
                elif d1[index] < d2[index]:
                    return -1
        if len1 > len2:
            return 1
        else:
            return -1

    def get_version_mode(self):
        return self._version_type

    def _split(self, x):
        for f, s in re.findall(r'([\d.]+)|([^\d.]+)', x):
            if f:
                float(f)
                yield f
            else:
                yield s


class VersionTypeXYZW(VersionType):

    def version_match(self, pkg_version):
        version = pkg_version.strip()
        digital_list = re.split(r'[._-]', version)
        if len(digital_list) != 4:  # 通过 '.'分割后，应该剩下4位
            return False
        if len(digital_list[0]) > 2:  # 第一位版本号不应该大于2位
            return False
        if len(digital_list[1]) > 2:  # 第二位版本号不应该大于2位
            return False
        if len(digital_list[2]) > 3:  # 第三位版本号不应该大于3位
            return False
        if len(digital_list[3]) > 1:  # 第四位版本号不应该大于1位
            return False
        return True

    def maintain_version(self, version_entry, current_version, pkg_type):
        if len(version_entry) == 1:  # 仅一个版本,当前即为最新版本
            return version_entry[0]

        version_candidate = []
        version_digital = re.split(r'[._-]', current_version)  # 将版本号做拆分
        xyz = version_digital[0:3]
        for version in version_entry:
            version_temp = re.split(r'[._-]', version)
            if version_digital[0:3] == version_temp[0:3]:  # 如果版本号与当前版本前三位一致，说明是维护分支版本
                version_candidate.append(version_temp)  # 将同特性版本的子版本挑选出来

        if len(version_candidate) == 1:
            return '.'.join(version_candidate[0])

        w = '0'
        for version in version_candidate:
            if len(version) <= 3:
                continue

            if self._max(version[3], w) > 0:
                w = version[3]

        xyz.append(w)
        return '.'.join(xyz)

    def latest_version(self, version_entry):
        if len(version_entry) == 1:  # 仅一个版本,当前即为最新版本
            return version_entry[0]
        version_list = []
        for version in version_entry:
            version_list.append(re.split(r'[._-]', version))  # 将 version 拆分为列表,方便后续比较
        x = '0'
        for version in version_list:  # 第一轮比较取出最大的第一位
            if self._max(x, version[0]) < 0:
                x = version[0]

        version_candidate = []
        for version in version_list:  # 将第一位最大的列入候选列表,准备第二位比较
            if x == version[0]:
                version_candidate.append(version)

        if len(version_candidate) == 1:  # 仅一个版本,候选即为最新版本
            return '.'.join(version_candidate[0])

        version_list = version_candidate[:]
        y = '0'
        for version in version_list:  # 第二轮比较取出最大的第二位
            if len(version) <= 1:  # 过滤仅一位的版本号
                continue
            if self._max(y, version[1]) < 0:
                y = version[1]

        version_candidate.clear()
        for version in version_list:  # 将第二位最大的列入候选列表,准备第三位比较
            if y == version[1]:
                version_candidate.append(version)

        if len(version_candidate) == 1:  # 仅一个版本,候选即为最新版本
            return '.'.join(version_candidate[0])

        z = '0'
        version_list = version_candidate[:]
        for version in version_list:  # 第三轮比较取出最大的第三位
            if len(version) <= 2:  # 过滤仅二位的版本号
                continue
            if self._max(z, version[2]) < 0:
                z = version[2]

        version_candidate.clear()
        for version in version_list:  # 最后一位最大版本必须惟一,直接返回结果
            if len(version) <= 2:  # 过滤仅二位的版本号
                continue
            if z == version[2]:
                version_candidate.append(version)

        if len(version_candidate) == 1:  # 仅一个版本,候选即为最新版本
            return '.'.join(version_candidate[0])

        w = '0'
        version_list = version_candidate[:]
        for version in version_list:  # 最后一位最大版本必须惟一,直接返回结果
            if len(version) <= 3:  # 过滤仅三位的版本号
                continue
            if self._max(w, version[3]) < 0:
                w = version[3]

        for version in version_list:  # 最后一位最大版本必须惟一,直接返回结果
            if len(version) <= 3:  # 过滤仅三位的版本号
                continue
            if w == version[3]:
                return '.'.join(version)

        return ''

    def __init__(self):
        super().__init__()
        self._version_type = 'x.y.z.w'


class VersionTypeXYZ(VersionType):

    def version_match(self, pkg_version):
        version = pkg_version.strip()
        digital_list = re.split(r'[._-]', version)
        if len(digital_list) != 3:  # 通过 '.'分割后，应该剩下3位
            return False
        if len(digital_list[0]) > 2:  # 第一位版本号不应该大于2位
            return False
        if len(digital_list[1]) > 3:  # 第二位版本号不应该大于3位
            return False
        if len(digital_list[2]) > 3:  # 第三位版本号不应该大于3位
            return False
        return True

    def maintain_version(self, version_entry, current_version, pkg_type):
        if len(version_entry) == 1:  # 仅一个版本,当前即为最新版本
            return version_entry[0]

        version_candidate = []
        version_digital = re.split(r'[._-]', current_version)  # 将版本号做拆分
        xy = version_digital[0:2]
        for version in version_entry:
            version_temp = re.split(r'[._-]', version)
            if version_digital[0:2] == version_temp[0:2]:  # 如果版本号与当前版本前两位一致，说明是维护分支版本
                version_candidate.append(version_temp)  # 将同特性版本的子版本挑选出来

        if len(version_candidate) == 1:
            return '.'.join(version_candidate[0])

        z = '0'
        for version in version_candidate:
            if len(version) <= 2:
                continue

            if self._max(version[2], z) > 0:
                z = version[2]

        xy.append(z)
        return '.'.join(xy)

    def latest_version(self, version_entry):
        if len(version_entry) == 1:  # 仅一个版本,当前即为最新版本
            return version_entry[0]
        version_list = []
        for version in version_entry:
            version_list.append(re.split(r'[._-]', version))  # 将 version 拆分为列表,方便后续比较
        x = '0'
        for version in version_list:  # 第一轮比较取出最大的第一位
            if self._max(x, version[0]) < 0:
                x = version[0]

        version_candidate = []
        for version in version_list:  # 将第一位最大的列入候选列表,准备第二位比较
            if x == version[0]:
                version_candidate.append(version)

        if len(version_candidate) == 1:  # 仅一个版本,候选即为最新版本
            return '.'.join(version_candidate[0])

        version_list = version_candidate[:]
        y = '0'
        for version in version_list:  # 第二轮比较取出最大的第二位
            if len(version) <= 1:  # 过滤仅一位的版本号
                continue
            if self._max(y, version[1]) < 0:
                y = version[1]

        version_candidate.clear()
        for version in version_list:  # 将第二位最大的列入候选列表,准备第三位比较
            if y == version[1]:
                version_candidate.append(version)

        if len(version_candidate) == 1:  # 仅一个版本,候选即为最新版本
            return '.'.join(version_candidate[0])

        z = '0'
        version_list = version_candidate[:]
        for version in version_list:  # 第三轮比较取出最大的第三位
            if len(version) <= 2:  # 过滤仅二位的版本号
                continue
            if self._max(z, version[2]) < 0:
                z = version[2]

        for version in version_list:  # 最后一位最大版本必须惟一,直接返回结果
            if len(version) <= 2:  # 过滤仅二位的版本号
                continue
            if z == version[2]:
                return '.'.join(version)

        return ''

    def __init__(self):
        super().__init__()
        self._version_type = 'x.y.z'


class VersionTypeXY(VersionType):

    def version_match(self, pkg_version):
        version = pkg_version.strip()
        digital_list = re.split(r'[._-]', version)
        if len(digital_list) != 2:  # 通过 '.'分割后，应该剩下2位
            return False
        if len(digital_list[0]) > 2:  # 第一位版本号不应该大于2位
            return False
        if len(digital_list[1]) > 3:  # 第二位版本号不应该大于2位
            return False
        return True

    def __init__(self):
        super().__init__()
        self._version_type = 'x.y'

    def latest_version(self, version_entry):
        if len(version_entry) == 1:  # 仅一个版本,当前即为最新版本
            return version_entry[0]
        version_list = []
        for version in version_entry:
            version_list.append(re.split(r'[._-]', version))  # 将 version 拆分为列表,方便后续比较
        x = '0'
        for version in version_list:  # 第一轮比较取出最大的第一位
            if self._max(x, version[0]) < 0:
                x = version[0]

        version_candidate = []
        for version in version_list:  # 将第一位最大的列入候选列表,准备第二位比较
            if x == version[0]:
                version_candidate.append(version)

        if len(version_candidate) == 1:  # 仅一个版本,候选即为最新版本
            return '.'.join(version_candidate[0])

        version_list = version_candidate[:]
        y = '0'
        for version in version_list:  # 第二轮比较取出最大的第二位
            if len(version) <= 1:  # 过滤仅一位的版本号
                continue
            if self._max(y, version[1]) < 0:
                y = version[1]

        version_candidate.clear()
        for version in version_list:  # x.y 版本类型中会小概率出现三位版本号,需要将第二位最大的列入候选列表,准备第三位比较
            if len(version) <= 1:  # 过滤仅一位的版本号
                continue
            if y == version[1]:
                version_candidate.append(version)

        if len(version_candidate) == 1:  # 仅一个版本,候选即为最新版本
            return '.'.join(version_candidate[0])

        z = '0'
        version_list = version_candidate[:]
        for version in version_list:  # 第三轮比较取出最大的第三位
            if len(version) <= 2:  # 过滤仅二位的版本号
                continue
            if self._max(z, version[2]) < 0:
                z = version[2]

        for version in version_list:  # 最后一位最大版本必须惟一,直接返回结果
            if len(version) <= 2:  # 过滤仅二位的版本号
                continue
            if z == version[2]:
                return '.'.join(version)

        return ''

    def maintain_version(self, version_entry, current_version, pkg_type):
        version_candidate = []
        version_digital = re.split(r'[._-]', current_version)  # 将版本号做拆分
        x = [version_digital[0]]
        for version in version_entry:
            version_temp = re.split(r'[._-]', version)
            if version_digital[0] == version_temp[0]:  # 如果版本号与当前版本前两位一致，说明是维护分支版本
                version_candidate.append(version_temp)  # 将同特性版本的子版本挑选出来

        if len(version_candidate) == 1:
            return '.'.join(version_candidate[0])

        y = '0'
        for version in version_candidate[0:]:
            if len(version) <= 1:
                continue

            if self._max(version[1], y) > 0:
                y = version[1]
        x.append(y)
        return '.'.join(x)


class VersionTypeX(VersionType):

    def version_match(self, pkg_version):
        version = pkg_version.strip()
        digital_list = re.split(r'[._-]', version)
        if len(digital_list) != 1:  # 通过 '.'分割后，应该剩下1位
            return False
        if len(digital_list[0]) > 3:  # 第一位版本号不应该大于3位
            return False
        return True

    def latest_version(self, version_entry):
        if 1 == len(version_entry):  # 仅一个版本,当前即为最新版本
            return version_entry[0]
        version_list: List[List[str]] = []
        for version in version_entry:
            version_list.append(re.split(r'[._-]', version))  # 将 version 拆分为列表,方便后续比较
        x = '0'
        for version in version_list:  # 第一轮比较取出最大的第一位
            if self._max(x, version[0]) < 0:
                x = version[0]

        version_candidate = []
        for version in version_list:  # 将第一位最大的列入候选列表,准备第二位比较
            if x == version[0]:
                version_candidate.append(version)

        if len(version_candidate) == 1:  # 仅一个版本,候选即为最新版本
            return '.'.join(version_candidate[0])

        version_list = version_candidate[:]
        y = '0'
        for version in version_list:  # 第二轮比较取出最大的第二位
            if len(version) <= 1:  # 过滤仅一位的版本号
                continue
            if self._max(y, version[1]) < 0:
                y = version[1]

        x.append(y)
        return '.'.join(x)

    def maintain_version(self, version_entry, current_version, pkg_type):
        version_candidate = []
        version_digital = re.split(r'[._-]', current_version)  # 将版本号做拆分
        x = [version_digital[0]]
        for version in version_entry:
            version_temp = re.split(r'[._-]', version)
            if version_digital[0] == version_temp[0]:  # 如果版本号与当前版本前两位一致，说明是维护分支版本
                version_candidate.append(version_temp)  # 将同特性版本的子版本挑选出来

        if len(version_candidate) == 1:
            return '.'.join(version_candidate[0])

        y = '0'
        for version in version_candidate[0:]:
            if len(version) <= 1:
                continue

            if self._max(version[1], y) > 0:
                y = version[1]
        x.append(y)
        return '.'.join(x)

    def __init__(self):
        super().__init__()
        self._version_type = 'x'


class VersionTypeYyyyXY(VersionType):

    def version_match(self, pkg_version):
        version = pkg_version.strip()
        digital_list = re.split(r'[._-]', version)
        if len(digital_list) != 3:  # 通过 '.'分割后，应该剩下3位
            return False

        if len(digital_list[0]) != 4:  # 第一位为发布年份，位数为4位
            return False

        year = int(digital_list[0])
        if year < 2000 or year > datetime.datetime.now().year:  # 软件发布时间应该大于2000 年，小于当前时间
            return False

        if len(digital_list[1]) > 2:  # 第二位版本号不应该大于2位
            return False

        if str(int(digital_list[1])) != digital_list[1]:  # 版本类型为数字,且非0 开头
            return False

        if len(digital_list[2]) > 2:  # 第三位版本号不应该大于2位
            return False

        if str(int(digital_list[2])) != digital_list[2]:  # 版本类型为数字,且非0 开头
            return False

        return True

    def __init__(self):
        super().__init__()
        self._version_type = 'yyyy.x.y'


class VersionTypeYyyyX(VersionType):

    def version_match(self, pkg_version):
        version = pkg_version.strip()
        digital_list = re.split(r'[._-]', version)
        if len(digital_list) != 2:  # 通过 '.'分割后，应该剩下2位
            return False

        if len(digital_list[0]) != 4:  # 第一位为发布年份，位数为4位
            return False
        year = int(digital_list[0])
        if year < 2000 or year > datetime.datetime.now().year:  # 软件发布时间应该大于2000 年，小于当前时间
            return False

        if len(digital_list[1]) > 2:  # 第二位版本号不应该大于2位
            return False
        return True

    def __init__(self):
        super().__init__()
        self._version_type = 'yyyy.x'


class VersionTypeYyyyW(VersionType):

    def version_match(self, pkg_version):
        version = pkg_version.strip()
        if len(version) != 5:  # 共5 位
            return False
        if not str(version[0:4]).isdigit():  # 前四位为年份数字
            return False

        year = int(version[0:4])
        if year < 2000 or year > datetime.datetime.now().year:  # 软件发布时间应该大于2000 年，小于当前时间
            return False

        return True

    def __init__(self):
        super().__init__()
        self._version_type = 'yyyyw'


class VersionTypeYyyyMmDd(VersionType):

    def version_match(self, pkg_version):
        version = pkg_version.strip()
        digital_list = re.split(r'[._-]', version)
        if len(digital_list) != 3:  # 通过 '.'分割后，应该剩下3位
            return False

        if len(digital_list[0]) != 4:  # 第一位为发布年份，位数为4位
            return False

        if int(digital_list[1]) > 12 or int(digital_list[1]) == 0:  # 第二位为发布月份，小于12
            return False

        if int(digital_list[2]) > 31 or int(digital_list[2]) == 0:  # 第三位为发布日期，小于31
            return False

        # 判断日期是否为合法日期
        try:
            if '_' in version:
                d_time = time.mktime(time.strptime(version, "%Y_%m_%d"))
            elif '-' in version:
                d_time = time.mktime(time.strptime(version, "%Y-%m-%d"))
            elif '.' in version:
                d_time = time.mktime(time.strptime(version, "%Y.%m.%d"))
            else:
                return False

            now_str = datetime.datetime.now().strftime('%Y-%m-%d')
            end_time = time.mktime(time.strptime(now_str, '%Y-%m-%d'))
            if d_time > end_time:  # 判断日期是否大于当前日期
                return False
            else:
                return True
        except ValueError as e:  # 时间格式非法
            print('Time foramt failed %s.', version)
            return False

    def __init__(self):
        super().__init__()
        self._version_type = 'yyyy.mm.dd'


class VersionTypeYyyyMm(VersionType):

    def version_match(self, pkg_version):
        version = pkg_version.strip()
        digital_list = re.split(r'[._-]', version)
        if len(digital_list) != 2:  # 通过 '.'分割后，应该剩下2位
            return False

        if len(digital_list[0]) != 4:  # 第一位为发布年份，位数为4位
            return False
        year = int(digital_list[0])
        if year < 2000 or year > datetime.datetime.now().year:  # 软件发布时间应该大于2000 年，小于当前时间
            return False

        if int(digital_list[1]) > 12 or int(digital_list[1]) == 0:  # 第二位为发布月份，小于12
            return False

        if year == datetime.datetime.now().year and \
                int(digital_list[1]) > datetime.datetime.now().month:
            return False

        return True

    def __init__(self):
        super().__init__()
        self._version_type = 'yyyy.mm'


class VersionTypeYyyyMm(VersionType):

    def version_match(self, pkg_version):
        version = pkg_version.strip()
        if len(version) != 6:  # 长度为6
            return False

        if not version.isdigit():  # 时间格式为数字
            return False

        digital_list = [version[0:4], version[4:]]

        if len(digital_list[0]) != 4:  # 第一位为发布年份，位数为4位
            return False
        year = int(digital_list[0])
        if year < 2000 or year > datetime.datetime.now().year:  # 软件发布时间应该大于2000 年，小于当前时间
            return False

        if int(digital_list[1]) > 12 or int(digital_list[1]) == 0:  # 第二位为发布月份，小于12
            return False

        if year == datetime.datetime.now().year and \
                int(digital_list[1]) > datetime.datetime.now().month:
            return False

        return True

    def __init__(self):
        super().__init__()
        self._version_type = 'yyyymm'


class VersionTypeXYymmZ(VersionType):

    def version_match(self, pkg_version):
        version = pkg_version.strip()
        digital_list = re.split(r'[._-]', version)
        if len(digital_list) != 3:  # 通过 '.'分割后，应该剩下3位
            return False

        if len(digital_list[0]) > 2:  # 第一位为主版本号，小于2位
            return False
        # 将年月拆分后分别判断
        if len(digital_list[1]) != 4:  # 年月等于4位
            return False
        year = str(digital_list[1][:2])
        month = str(digital_list[1][-2:])
        if year > datetime.datetime.now().year[-2:]:  # 年份不能大于当前年份，不用考虑20000 年前的情况
            return False
        if month > '12' or month == '0':
            return False
        if len(digital_list[2]) > 2:  # 迭代号不大于2位
            return False
        return True

    def __init__(self):
        super().__init__()
        self._version_type = 'x.yymm.z'


class VersionTypeYyyymmdd(VersionType):

    def version_match(self, pkg_version):
        version = pkg_version.strip()
        if len(version) != 8:  # 日期长度满足 8 位要求
            return False
        if not version.isdigit():  # 连续数字，没有其他分别符号
            return False
        digital_list = [version[:4], version[4:6], version[6:]]

        if int(digital_list[1]) > 12 or int(digital_list[1]) == 0:  # 第二位为发布月份，小于12
            return False

        if int(digital_list[2]) > 31 or int(digital_list[2]) == 0:  # 第三位为发布日期，小于31
            return False

        # 判断日期是否为合法日期
        try:
            d_time = time.mktime(time.strptime(version, "%Y%m%d"))
            now_str = datetime.datetime.now().strftime('%Y-%m-%d')
            end_time = time.mktime(time.strptime(now_str, '%Y-%m-%d'))
            if d_time > end_time:  # 判断日期是否大于当前日期
                return False
            else:
                return True
        except ValueError as e:  # 时间格式非法
            print('Time format failed %s,', version)
            return False

    def __init__(self):
        super().__init__()
        self._version_type = 'yyyymmdd'


class VersionRecommend(object):

    def __init__(self, version_entry, current_version, pkg_type):
        self.latest_version = current_version  # 提供初值,避免 current_version 为空导致后面出现异常
        self.maintain_version = current_version
        self.version_type = self._version_match(version_entry)
        if self.version_type is None:
            print('version type is None:', current_version)
            return

        print('version type = ', self.version_type.get_version_mode())
        self.latest_version = self._get_latest_version(version_entry)
        self.maintain_version = self._get_maintain_version(version_entry, current_version, pkg_type)

    def _version_match(self, version_entry):

        version_method = {VersionTypeXYZW(): 0,
                          VersionTypeXYZ(): 0,
                          VersionTypeXY(): 0,
                          VersionTypeX(): 0,
                          VersionTypeYyyyXY(): 0,
                          VersionTypeYyyyX(): 0,
                          VersionTypeYyyyW(): 0,
                          VersionTypeYyyyMmDd(): 0,
                          VersionTypeYyyyMm(): 0,
                          VersionTypeYyyyMm(): 0,
                          VersionTypeXYymmZ(): 0,
                          VersionTypeYyyymmdd(): 0}
        if not version_entry:
            return None
        for version in version_entry[:]:
            if not self._version_valid(version):
                version_entry.remove(version)  # 删除非法版本号
                continue
            for method, count in version_method.items():
                if method.version_match(version):
                    version_method[method] = count + 1

        # 解决多版本类型问题,选取类型最多的作为匹配,这个处理不是最优方案,需要改进
        method = max(version_method, key=lambda x: version_method[x])

        if version_method[method] == 0:
            return None
        else:
            return method

    def _version_valid(self, version):
        m = re.match("^[0-9a-zA-Z._-]*$", version)
        if m is None:  # 版本号应该是 数字/小写字母/下划线/. 组成
            return False

        m = re.match('^[0-9].*', version)
        if m is None:  # 版本号应该是数字开头
            return False

        if 'rc' in version \
                or 'RC' in version \
                or 'dev' in version \
                or 'beta' in version \
                or 'Beta' in version \
                or 'BETA' in version \
                or 'alpha' in version \
                or 'pl' in version \
                or 'pre' in version \
                or 'PRE' in version \
                or 'bp' in version:  # 仅获取正式版本
            return False

        if 'ubuntu' in version or 'fedora' in version:  # 去掉厂家专用版本号
            return False

        return True

    def _get_latest_version(self, version_entry):
        if self.version_type is None:
            return ''
        else:
            return self.version_type.latest_version(version_entry)

    def _get_maintain_version(self, version_entry, current_version, pkg_type):
        if self.version_type is None:
            return ''
        else:
            return self.version_type.maintain_version(version_entry, current_version, pkg_type)


if __name__ == '__main__':
    version_recommend = VersionRecommend(
        ['0.1', '0.2', '1.2.3', '1.2.4', '1.2.6', '1.3.0', '1.5-rc', '2.0-rc'], '1.2.3', 0)
    print('latest_version', version_recommend.latest_version)
    print('maintain_version', version_recommend.maintain_version)