From 6c9d17603b6f2cba8bfcd4bd2e73c6196ad85a08 Mon Sep 17 00:00:00 2001
From: Leo Fang <leofang_94@163.com>
Date: Mon, 13 Jul 2020 16:16:26 +0800
Subject: [PATCH 1/5] Optimize code struct and bugfix for some: 1.functionalize
 items in simple-update 2.combine para of '-f' and '-c' 3.add some prompt
 4.fix compare() in version_recommend Signed-off-by: Leo Fang
 <leofang_94@163.com>

---
 advisors/simple-update-robot.py | 109 +++++++++++++++++++++-----------
 advisors/version_recommend.py   |   2 +-
 2 files changed, 73 insertions(+), 38 deletions(-)

diff --git a/advisors/simple-update-robot.py b/advisors/simple-update-robot.py
index 054ddd1f..f8c0b666 100755
--- a/advisors/simple-update-robot.py
+++ b/advisors/simple-update-robot.py
@@ -21,8 +21,10 @@ import subprocess
 import os.path
 import re
 import datetime
+
 import version_recommend
 
+
 def download_source_url(spec, o_ver, n_ver):
     """
     Download source file from Source or Source0 URL
@@ -59,6 +61,52 @@ def download_upstream_url(gt, repo, n_ver):
         return False
 
 
+def update_check(spec, o_ver, n_ver):
+    """
+    Requirements check for upgraded package
+    """
+    if len(spec.patches) >= 1:
+        print("I'm too naive to handle complicated package.")
+        print("This package has multiple in-house patches.")
+        return False
+
+    ver_type = version_recommend.VersionType()
+    if(ver_type.compare(n_ver, o_ver) == 1):
+        return True
+    else:
+        print("Please check version of {pkg} will upgrade to, it's current version is {version}.".format(
+            pkg=spec.name, version=o_ver))
+        return False
+
+
+def fork_clone_repo(gt, repo):
+    """
+    Fork repo from src-openEuler to private repository and clone it to local
+    """
+    if not gt.fork_repo(repo):
+        print("The repo of {pkg} seems to have been forked.".format(pkg=repo))
+    
+    name = gt.token["user"]
+    subprocess.call(["git", "clone", "git@gitee.com:{user}/{pkg}".format(user=name, pkg=repo)])
+    os.chdir(repo)
+
+
+def download_src(gt, spec, o_ver, n_ver):
+    """
+    Download source code for upgraded package
+    """
+    source_file = download_source_url(spec, o_ver, n_ver)
+    if source_file:
+        print(source_file)
+    else:
+        source_file = download_upstream_url(gt, spec.name, n_ver)
+        if source_file:
+            print(source_file)
+        else:
+            print("Failed to download the latest source code.")
+            return False
+
+
 def create_spec(repo, spec_str, o_ver, n_ver, src_fn=None):
     """
     Create new spec file for upgraded package
@@ -89,55 +137,42 @@ def create_spec(repo, spec_str, o_ver, n_ver, src_fn=None):
             fn.write("\n")
     fn.close()
 
+
 if __name__ == "__main__":
     pars = argparse.ArgumentParser()
     pars.add_argument("pkg", type=str, help="The package to be upgraded")
     pars.add_argument("-n", "--new_version", type=str, help="New upstream version of package will be upgrade to")
     pars.add_argument("-s", "--create_spec", help="Create spec file", action="store_true")
     pars.add_argument("-d", "--download", help="Download upstream source code", action="store_true")
-    pars.add_argument("-f", "--fork", help="fork src-openeuler repo into users", action="store_true")
-    pars.add_argument("-c", "--clone", help="clone privatge repo to local", action="store_true")
+    pars.add_argument("-fc", "--FC", help="fork src-openeuler repo into users and clone to local", action="store_true")
     pars.add_argument("-p", "--PR", help="Create upgrade PR", action="store_true")
     args = pars.parse_args()
 
-    my_gitee = gitee.Gitee()
-    my_version = version_recommend.VersionType()
-    spec_string= my_gitee.get_spec(args.pkg)
-
-    s_spec = Spec.from_string(spec_string)
-    cur_ver = replace_macros(s_spec.version, s_spec)
-
-    if args.fork:
-        if not my_gitee.fork_repo(args.pkg):
-            print("The repo of {pkg} seems to have been forked.".format(pkg=args.pkg))
-
-    if args.clone:
-        user=my_gitee.token["user"]
-        subprocess.call(["git", "clone", "git@gitee.com:{user}/{pkg}".format(user=user, pkg=args.pkg)])
-        os.chdir(args.pkg)
+    if not args.pkg:
+        print("Please specify the package will upgrade.")
+        sys.exit(1)
+    
+    user_gitee = gitee.Gitee()
+    spec_string = user_gitee.get_spec(args.pkg)
+    spec_file = Spec.from_string(spec_string)
+    cur_ver = replace_macros(spec_file.version, spec_file)
+
+    if args.FC:
+        fork_clone_repo(user_gitee, args.pkg)
+    
+    if args.download or args.create_spec:
+        if not args.new_version:
+            print("Please specify the upgraded version of the {repo}".format(repo=args.pkg))
+            sys.exit(1)
+        elif not update_check(spec_file, cur_ver, args.new_version):
+            sys.exit(1)
 
     if args.download:
-        source_file = download_source_url(s_spec, cur_ver, args.new_version)
-        if source_file:
-            print(source_file)
-        else:
-            source_file = download_upstream_url(my_gitee, args.pkg, args.new_version)
-            if source_file:
-                print(source_file)
-            else:
-                print("Failed to download the latest source code.")
-                sys.exit(1)
+        if not download_src(user_gitee, spec_file, cur_ver, args.new_version):
+            sys.exit(1)
 
     if args.create_spec:
-        if len(s_spec.patches) >= 1:
-            print("I'm too naive to handle complicated package.")
-            print("This package has multiple in-house patches.")
-            sys.exit(1)
-        if(my_version.compare(args.new_version, cur_ver) ==1):
-            create_spec(args.pkg, spec_string, cur_ver, args.new_version)
-        else:
-            print("Please check version of {pkg} will upgrade to, it's current version is {version}.".format(
-				pkg=args.pkg, version=cur_ver))
+        create_spec(args.pkg, spec_string, cur_ver, args.new_version)
 
     if args.PR:
-        my_gitee.create_pr(my_gitee.token["user"], args.pkg)
+        user_gitee.create_pr(user_gitee.token["user"], args.pkg)
diff --git a/advisors/version_recommend.py b/advisors/version_recommend.py
index d4b0d7c8..55f9fce6 100755
--- a/advisors/version_recommend.py
+++ b/advisors/version_recommend.py
@@ -72,7 +72,7 @@ class VersionType(object):
         :return 0: z1 equal then z2
         :raises: None
         """
-        return self._compare(self, z1, z2)
+        return self._compare(z1, z2)
 
     def _compare(self, z1, z2):
         """
-- 
Gitee


From 564205d495de1e4683bdfa6b6b0d0cb0122954ad Mon Sep 17 00:00:00 2001
From: Leo Fang <leofang_94@163.com>
Date: Wed, 15 Jul 2020 15:59:39 +0800
Subject: [PATCH 2/5] Add some functions and improvements: 1.Add auto_update
 for package and repository 2.Package interface of oa_upgradable 3.Imporve
 some code for user experience

Signed-off-by: Leo Fang <leofang_94@163.com>
---
 advisors/gitee.py               |  30 ++++---
 advisors/oa_upgradable.py       | 103 ++++++++++++----------
 advisors/simple-update-robot.py | 146 ++++++++++++++++++++++++++------
 3 files changed, 196 insertions(+), 83 deletions(-)

diff --git a/advisors/gitee.py b/advisors/gitee.py
index 6925c2ea..620c3913 100755
--- a/advisors/gitee.py
+++ b/advisors/gitee.py
@@ -26,12 +26,13 @@ class Gitee(object):
 
         self.headers = {'User-Agent':'Mozilla/5.0 (Windows NT 10.0; WOW 64; rv:50.0) Gecko/20100101 Firefox/50.0'}
         self.gitee_url = "https://gitee.com/"
-        self.src_openeuler_url = self.gitee_url + "src-openeuler/{package}/raw/master/"
+        self.src_openeuler_url = self.gitee_url + "src-openeuler/{package}/raw/{branch}/"
         self.advisor_url = self.gitee_url + "openeuler/openEuler-Advisor/raw/master/"
         self.specfile_url_template = self.src_openeuler_url + "{specfile}"
         self.yamlfile_url_template = self.src_openeuler_url + "{package}.yaml"
         #self.advisor_url_template = "https://gitee.com/openeuler/openEuler-Advisor/raw/master/upstream-info/{package}.yaml"
         self.advisor_url_template = self.advisor_url + "upstream-info/{package}.yaml"
+        self.community_url_template = self.gitee_url + "openeuler/community/raw/master/repository/{repository}.yaml"
         #self.specfile_exception_url = "https://gitee.com/openeuler/openEuler-Advisor/raw/master/helper/specfile_exceptions.yaml"
         self.specfile_exception_url = self.advisor_url + "advisors/helper/specfile_exceptions.yaml"
         self.time_format = "%Y-%m-%dT%H:%M:%S%z"
@@ -96,7 +97,7 @@ Yours openEuler-Advisor.
 
     def get_gitee_json(self, url):
         """
-        get and load gitee json response
+        Get and load gitee json response
         """
         headers = self.headers.copy()
         #headers = {}
@@ -106,31 +107,29 @@ Yours openEuler-Advisor.
 
     def get_spec_exception(self):
         """
-        get well known spec file exceptions
+        Get well known spec file exceptions
         """
         resp = self.get_gitee(self.specfile_exception_url)
         exps = yaml.load(resp, Loader=yaml.Loader)
         return exps
 
-    def get_spec(self, pkg):
+    def get_spec(self, pkg, br="master"):
         """
-        get openeuler spec file for specific package
+        Get openeuler spec file for specific package
         """
-        specurl = self.specfile_url_template.format(package=pkg, specfile=pkg + ".spec")
+        specurl = self.specfile_url_template.format(branch=br, package=pkg, specfile=pkg + ".spec")
         exp = self.get_spec_exception()
         if pkg in exp:
             dir_name = exp[pkg]["dir"]
             file_name = exp[pkg]["file"]
             specurl = urllib.parse.urljoin(specurl, os.path.join(dir_name, file_name))
-
         try:
             resp = self.get_gitee(specurl)
         except urllib.error.HTTPError:
             resp = ""
-
         return resp
 
-    def get_yaml(self, pkg):
+    def get_yaml(self, pkg, br="master"):
         """
         get upstream yaml metadata for specific package
         """
@@ -140,7 +139,7 @@ Yours openEuler-Advisor.
         except urllib.error.HTTPError:
             resp = "Not found"
         if re.match("Not found", resp):
-            yamlurl = self.yamlfile_url_template.format(package=pkg)
+            yamlurl = self.yamlfile_url_template.format(branch=br, package=pkg)
             try:
                 resp = self.get_gitee(yamlurl)
             except urllib.error.HTTPError:
@@ -153,6 +152,17 @@ Yours openEuler-Advisor.
         else:
             return resp
 
+    def get_community(self, repo):
+        """
+        Get yaml data from community repo
+        """
+        yamlurl = self.community_url_template.format(repository=repo)
+        try:
+            resp = self.get_gitee(yamlurl)
+        except urllib.error.HTTPError:
+            resp = ""
+        return resp
+
     def get_issues(self, pkg, prj="src-openeuler"):
         """
         List all open issues of pkg
diff --git a/advisors/oa_upgradable.py b/advisors/oa_upgradable.py
index 949f55b1..f05ff597 100755
--- a/advisors/oa_upgradable.py
+++ b/advisors/oa_upgradable.py
@@ -12,10 +12,54 @@ import os
 import argparse
 
 import urllib.error
+
 import gitee
 import check_upstream
 import version_recommend
 
+
+def get_ver_tags(gt, repo, d_path=None):
+    """
+    Get version tags of given package
+    """
+    repo_yaml = ""
+    if d_path:
+        try:
+            repo_yaml = open(os.path.join(d_path, repo + ".yaml")).read()
+        except FileNotFoundError:
+            print("Failed to get YAML info from default path.")
+
+    if not repo_yaml:
+        try:
+            repo_yaml = gt.get_yaml(repo)
+        except urllib.error.HTTPError:
+            print("Failed to get YAML info for {pkg}".format(pkg=repo))
+            return None
+
+    pkg_info = yaml.load(repo_yaml, Loader=yaml.Loader)
+
+    vc_type = pkg_info["version_control"]
+    if vc_type == "hg":
+        tags = check_upstream.check_hg(pkg_info)
+    elif vc_type == "github":
+        tags = check_upstream.check_github(pkg_info)
+    elif vc_type == "git":
+        tags = check_upstream.check_git(pkg_info)
+    elif vc_type == "gitlab.gnome":
+        tags = check_upstream.check_gnome(pkg_info)
+    elif vc_type == "svn":
+        tags = check_upstream.check_svn(pkg_info)
+    elif vc_type == "metacpan":
+        tags = check_upstream.check_metacpan(pkg_info)
+    elif vc_type == "pypi":
+        tags = check_upstream.check_pypi(pkg_info)
+    else:
+        print("Unsupport version control method {vc}".format(vc=vc_type))
+        return None
+    
+    return tags
+
+
 if __name__ == "__main__":
     parameters = argparse.ArgumentParser()
     parameters.add_argument("-p", "--push", action="store_true",
@@ -27,56 +71,23 @@ if __name__ == "__main__":
 
     args = parameters.parse_args()
 
-    gitee = gitee.Gitee()
-    prj_name = args.repo
-    spec_string = gitee.get_spec(prj_name)
+    user_gitee = gitee.Gitee()
+    spec_string = user_gitee.get_spec(args.repo)
     if not spec_string:
-        print("{repo} seems to be an empty repository".format(repo=args.repo))
+        print("{pkg}.spec can't be found on the master branch".format(pkg=args.repo))
         sys.exit(1)
 
-    s_spec = Spec.from_string(spec_string)
-
-    current_version = replace_macros(s_spec.version, s_spec)
-
-    print("Checking ", prj_name)
-    print("current version is ", current_version)
+    spec_file = Spec.from_string(spec_string)
+    cur_version = replace_macros(spec_file.version, spec_file)
 
-    try:
-        prj_info_string = open(os.path.join(args.default, prj_name + ".yaml")).read()
-    except FileNotFoundError:
-        prj_info_string = ""
+    print("Checking ", args.repo)
+    print("current version is ", cur_version)
 
-    if not prj_info_string:
-        print("Get YAML info from gitee")
-        try:
-            prj_info_string = gitee.get_yaml(prj_name)
-        except urllib.error.HTTPError:
-            print("Failed to get YAML info for {pkg}".format(pkg=prj_name))
-            sys.exit(1)
-
-
-    prj_info = yaml.load(prj_info_string, Loader=yaml.Loader)
-
-    vc_type = prj_info["version_control"]
-    if vc_type == "hg":
-        tags = check_upstream.check_hg(prj_info)
-    elif vc_type == "github":
-        tags = check_upstream.check_github(prj_info)
-    elif vc_type == "git":
-        tags = check_upstream.check_git(prj_info)
-    elif vc_type == "gitlab.gnome":
-        tags = check_upstream.check_gnome(prj_info)
-    elif vc_type == "svn":
-        tags = check_upstream.check_svn(prj_info)
-    elif vc_type == "metacpan":
-        tags = check_upstream.check_metacpan(prj_info)
-    elif vc_type == "pypi":
-        tags = check_upstream.check_pypi(prj_info)
-    else:
-        print("Unsupport version control method {vc}".format(vc=vc_type))
+    pkg_tags = get_ver_tags(user_gitee, args.repo, args.default)
+    if pkg_tags is None:
         sys.exit(1)
+    ver_rec = version_recommend.VersionRecommend(pkg_tags, cur_version, 0)
 
-    print("known release tags :", tags)
-    v = version_recommend.VersionRecommend(tags, current_version, 0)
-    print("Latest version is ", v.latest_version)
-    print("Maintain version is", v.maintain_version)
+    print("known release tags :", pkg_tags)
+    print("Latest version is ", ver_rec.latest_version)
+    print("Maintain version is", ver_rec.maintain_version)
diff --git a/advisors/simple-update-robot.py b/advisors/simple-update-robot.py
index f8c0b666..90b11685 100755
--- a/advisors/simple-update-robot.py
+++ b/advisors/simple-update-robot.py
@@ -22,6 +22,7 @@ import os.path
 import re
 import datetime
 
+import oa_upgradable
 import version_recommend
 
 
@@ -74,14 +75,14 @@ def update_check(spec, o_ver, n_ver):
     if(ver_type.compare(n_ver, o_ver) == 1):
         return True
     else:
-        print("Please check version of {pkg} will upgrade to, it's current version is {version}.".format(
-            pkg=spec.name, version=o_ver))
+        print("Update failed >> [{pkg}: current_ver:{cur_ver}, upgraded_ver:{upd_ver}]".format(
+            pkg=spec.name, cur_ver=o_ver, upd_ver=n_ver))
         return False
 
 
 def fork_clone_repo(gt, repo):
     """
-    Fork repo from src-openEuler to private repository and clone it to local
+    Fork repo from src-openEuler to private repository, then clone it to local
     """
     if not gt.fork_repo(repo):
         print("The repo of {pkg} seems to have been forked.".format(pkg=repo))
@@ -138,41 +139,132 @@ def create_spec(repo, spec_str, o_ver, n_ver, src_fn=None):
     fn.close()
 
 
+def auto_update_pkg(gt, u_branch, u_pkg):
+    """
+    Auto upgrade based on given branch for single package
+    """
+    spec_str = gt.get_spec(u_pkg, u_branch)
+    if not spec_str:
+        print("{pkg}.spec can't be found on the {br} branch. ".format(
+            pkg=u_pkg, br=u_branch))
+        sys.exit(1)
+    pkg_spec = Spec.from_string(spec_str)
+    pkg_ver = replace_macros(pkg_spec.version, pkg_spec)
+
+    pkg_tags = oa_upgradable.get_ver_tags(gt, u_pkg)
+    if pkg_tags is None:
+        sys.exit(1)
+    ver_rec = version_recommend.VersionRecommend(pkg_tags, pkg_ver, 0)
+    rec_up_ver = pkg_ver
+    if re.search("master", u_branch):
+        rec_up_ver = ver_rec.latest_version
+    elif re.search("LTS", u_branch):
+        rec_up_ver = ver_rec.maintain_version
+    else:
+        print("Only support master and LTS version upgrade.")
+        sys.exit(1)
+
+    fork_clone_repo(gt, u_pkg)
+
+    if not update_check(pkg_spec, pkg_ver, rec_up_ver):
+        sys.exit(1)
+
+    if not download_src(gt, pkg_spec, pkg_ver, rec_up_ver):
+        sys.exit(1)
+
+    create_spec(u_pkg, spec_str, pkg_ver, rec_up_ver)
+
+
+def auto_update_repo(gt, u_branch, u_repo):
+    """
+    Auto upgrade based on given branch for packages in given repository
+    """
+    repo_yaml = gt.get_community(u_repo)
+    if not repo_yaml:
+        print("{repo}.yaml in community is empty.".format(repo=u_repo))
+        sys.exit(1)
+
+    pkg_info = yaml.load(repo_yaml, Loader=yaml.loader)
+    pkg_list = pkg_info.get("repositories")
+    for pkg in pkg_list:
+        pkg_name = pkg.get("name")
+        spec_str = gt.get_spec(pkg_name, u_branch)
+        if not spec_str:
+            print("{pkg}.spec can't be found on the {br} branch. ".format(
+                pkg=pkg_name, br=u_branch))
+            continue
+        pkg_spec = Spec.from_string(spec_str)
+        pkg_ver = replace_macros(pkg_spec.version, pkg_spec)
+
+        pkg_tags = oa_upgradable.get_ver_tags(gt, pkg_name)
+        if pkg_tags is None:
+            continue
+        ver_rec = version_recommend.VersionRecommend(pkg_tags, pkg_ver, 0)
+        rec_up_ver = pkg_ver
+        if re.search("master", u_branch):
+            rec_up_ver = ver_rec.latest_version
+        elif re.search("LTS", u_branch):
+            rec_up_ver = ver_rec.maintain_version
+        else:
+            print("Only support master and LTS version upgrade.")
+            sys.exit(1)
+
+        fork_clone_repo(gt, pkg_name)
+
+        if not update_check(pkg_spec, pkg_ver, rec_up_ver):
+            continue
+
+        if not download_src(gt, pkg_spec, pkg_ver, rec_up_ver):
+            continue
+
+        create_spec(pkg_name, spec_str, pkg_ver, rec_up_ver)
+
+
 if __name__ == "__main__":
     pars = argparse.ArgumentParser()
-    pars.add_argument("pkg", type=str, help="The package to be upgraded")
+    pars.add_argument("repo_pkg", type=str, help="The repository or package to be upgraded")
+    pars.add_argument("branch", type=str, help="The branch that upgrade based")
+    pars.add_argument("-u", "--update", type=str, help="Auto upgrade for packages in repository or single package",
+            choices=["repo", "pkg"])
     pars.add_argument("-n", "--new_version", type=str, help="New upstream version of package will be upgrade to")
     pars.add_argument("-s", "--create_spec", help="Create spec file", action="store_true")
     pars.add_argument("-d", "--download", help="Download upstream source code", action="store_true")
-    pars.add_argument("-fc", "--FC", help="fork src-openeuler repo into users and clone to local", action="store_true")
+    pars.add_argument("-fc", "--fork_then_clone", help="Fork src-openeuler repo into users, then clone to local",
+            action="store_true")
     pars.add_argument("-p", "--PR", help="Create upgrade PR", action="store_true")
     args = pars.parse_args()
-
-    if not args.pkg:
-        print("Please specify the package will upgrade.")
-        sys.exit(1)
     
     user_gitee = gitee.Gitee()
-    spec_string = user_gitee.get_spec(args.pkg)
-    spec_file = Spec.from_string(spec_string)
-    cur_ver = replace_macros(spec_file.version, spec_file)
 
-    if args.FC:
-        fork_clone_repo(user_gitee, args.pkg)
-    
-    if args.download or args.create_spec:
-        if not args.new_version:
-            print("Please specify the upgraded version of the {repo}".format(repo=args.pkg))
-            sys.exit(1)
-        elif not update_check(spec_file, cur_ver, args.new_version):
+    if args.update:
+        if args.update == "repo":
+            auto_update_repo(user_gitee, args.branch, args.repo_pkg)
+        else:
+            auto_update_pkg(user_gitee, args.branch, args.repo_pkg)
+    else:
+        spec_string = user_gitee.get_spec(args.repo_pkg, args.branch)
+        if not spec_string:
+            print("{pkg}.spec can't be found on the {br} branch. ".format(pkg=args.repo_pkg, br=args.branch))
             sys.exit(1)
+        spec_file = Spec.from_string(spec_string)
+        cur_version = replace_macros(spec_file.version, spec_file)
 
-    if args.download:
-        if not download_src(user_gitee, spec_file, cur_ver, args.new_version):
-            sys.exit(1)
+        if args.fork_then_clone:
+            fork_clone_repo(user_gitee, args.repo_pkg)
+
+        if args.download or args.create_spec:
+            if not args.new_version:
+                print("Please specify the upgraded version of the {repo}".format(repo=args.repo_pkg))
+                sys.exit(1)
+            elif not update_check(spec_file, cur_version, args.new_version):
+                sys.exit(1)
+
+        if args.download:
+            if not download_src(user_gitee, spec_file, cur_version, args.new_version):
+                sys.exit(1)
 
-    if args.create_spec:
-        create_spec(args.pkg, spec_string, cur_ver, args.new_version)
+        if args.create_spec:
+            create_spec(args.repo_pkg, spec_string, cur_version, args.new_version)
 
-    if args.PR:
-        user_gitee.create_pr(user_gitee.token["user"], args.pkg)
+        if args.PR:
+            user_gitee.create_pr(user_gitee.token["user"], args.repo_pkg)
-- 
Gitee


From e9bd3cdbf18ad256e8a51bdf7dc1fe1bf75ce76e Mon Sep 17 00:00:00 2001
From: Leo Fang <leofang_94@163.com>
Date: Tue, 21 Jul 2020 21:19:13 +0800
Subject: [PATCH 3/5] bugfix of compare() and solve the except case in version
 recommend: gegl04 gimp python-pymongo nss mutt openssh glibc

Signed-off-by: Leo Fang <leofang_94@163.com>
---
 advisors/helper/ver_rec_excpt.yaml | 10 ++++++++++
 advisors/oa_upgradable.py          | 19 +++++++++++++++++--
 advisors/version_recommend.py      | 12 ++++++++++--
 3 files changed, 37 insertions(+), 4 deletions(-)
 create mode 100644 advisors/helper/ver_rec_excpt.yaml

diff --git a/advisors/helper/ver_rec_excpt.yaml b/advisors/helper/ver_rec_excpt.yaml
new file mode 100644
index 00000000..0e0a0d96
--- /dev/null
+++ b/advisors/helper/ver_rec_excpt.yaml
@@ -0,0 +1,10 @@
+---
+# version recommend exception list
+gegl04:
+    - '20001120.v002'
+gimp:
+    - '19990910'
+nss:
+    - '334.20030307'
+glibc:
+    - '9000'
diff --git a/advisors/oa_upgradable.py b/advisors/oa_upgradable.py
index f05ff597..49d66f0e 100755
--- a/advisors/oa_upgradable.py
+++ b/advisors/oa_upgradable.py
@@ -18,6 +18,15 @@ import check_upstream
 import version_recommend
 
 
+def _get_rec_excpt():
+    """
+    Get except case of version recommend
+    """
+    y_file = open(os.getcwd() + "/helper/ver_rec_excpt.yaml")
+    excpt = yaml.load(y_file, Loader=yaml.Loader)
+    return excpt
+
+
 def get_ver_tags(gt, repo, d_path=None):
     """
     Get version tags of given package
@@ -57,6 +66,12 @@ def get_ver_tags(gt, repo, d_path=None):
         print("Unsupport version control method {vc}".format(vc=vc_type))
         return None
     
+    excpt_list = _get_rec_excpt()
+    if repo in excpt_list:
+        for excpt in excpt_list[repo]:
+            for tag in tags:
+                if excpt in tag:
+                    tags.remove(tag)
     return tags
 
 
@@ -88,6 +103,6 @@ if __name__ == "__main__":
         sys.exit(1)
     ver_rec = version_recommend.VersionRecommend(pkg_tags, cur_version, 0)
 
-    print("known release tags :", pkg_tags)
-    print("Latest version is ", ver_rec.latest_version)
+    print("known release tags:", pkg_tags)
+    print("Latest version is", ver_rec.latest_version)
     print("Maintain version is", ver_rec.maintain_version)
diff --git a/advisors/version_recommend.py b/advisors/version_recommend.py
index 55f9fce6..d8f21122 100755
--- a/advisors/version_recommend.py
+++ b/advisors/version_recommend.py
@@ -91,11 +91,15 @@ class VersionType(object):
         len2 = len(d2)
         length = min(len1, len2)
         for index in range(length):
-            if d1[index].isdigit() and d1[index].isdigit():
+            if d1[index].isdigit() and d2[index].isdigit():
                 if int(d1[index]) > int(d2[index]):
                     return 1
                 elif int(d1[index]) < int(d2[index]):
                     return -1
+            elif d1[index].isdigit():
+                return 1
+            elif d2[index].isdigit():
+                return -1
             else:
                 if d1[index] > d2[index]:
                     return 1
@@ -126,7 +130,7 @@ class VersionType(object):
         :returns: The split result
         :raises: None
         """
-        for f, s in re.findall(r'([\d]+)|([^\d.]+)', x):
+        for f, s in re.findall(r'([\d]+)|([^\d.-]+)', x):
             if f:
                 float(f)
                 yield f
@@ -1085,6 +1089,10 @@ class VersionRecommend(object):
         if m is None:  # 版本号应该是数字开头
             return False
 
+        m = re.search(r'b\d', version)
+        if not m is None:
+            return False
+
         if 'rc' in version \
                 or 'RC' in version \
                 or 'dev' in version \
-- 
Gitee


From 4ee24ba51a68b34bd55434cb57fafdab472f3384 Mon Sep 17 00:00:00 2001
From: Leo Fang <leofang_94@163.com>
Date: Sat, 25 Jul 2020 16:07:51 +0800
Subject: [PATCH 4/5] improve get_yaml() in gitee.py and bugfix for
 oa_upgradable.py

Signed-off-by: Leo Fang <leofang_94@163.com>
---
 advisors/gitee.py         |  4 ++--
 advisors/oa_upgradable.py | 24 ++++++++++--------------
 2 files changed, 12 insertions(+), 16 deletions(-)

diff --git a/advisors/gitee.py b/advisors/gitee.py
index 620c3913..557f72bc 100755
--- a/advisors/gitee.py
+++ b/advisors/gitee.py
@@ -131,7 +131,7 @@ Yours openEuler-Advisor.
 
     def get_yaml(self, pkg, br="master"):
         """
-        get upstream yaml metadata for specific package
+        Get upstream yaml metadata for specific package
         """
         yamlurl = self.advisor_url_template.format(package=pkg)
         try:
@@ -145,7 +145,7 @@ Yours openEuler-Advisor.
             except urllib.error.HTTPError:
                 resp = "Not found"
             if re.match("Not found", resp):
-                print("Cannot find upstream metadata")
+                print("Cann't find yaml metadata for {package} from upstream-info.".format(package=pkg))
                 return False
             else:
                 return resp
diff --git a/advisors/oa_upgradable.py b/advisors/oa_upgradable.py
index 49d66f0e..f256da1d 100755
--- a/advisors/oa_upgradable.py
+++ b/advisors/oa_upgradable.py
@@ -22,30 +22,26 @@ def _get_rec_excpt():
     """
     Get except case of version recommend
     """
-    y_file = open(os.getcwd() + "/helper/ver_rec_excpt.yaml")
+    y_file = open(os.path.join(os.path.dirname(os.path.abspath(__file__)), "helper/ver_rec_excpt.yaml"))
     excpt = yaml.load(y_file, Loader=yaml.Loader)
     return excpt
 
-
-def get_ver_tags(gt, repo, d_path=None):
+def get_ver_tags(gt, repo, cwd_path=None):
     """
     Get version tags of given package
     """
     repo_yaml = ""
-    if d_path:
+    if cwd_path:
         try:
-            repo_yaml = open(os.path.join(d_path, repo + ".yaml")).read()
+            repo_yaml = open(os.path.join(cwd_path, repo + ".yaml")).read()
         except FileNotFoundError:
-            print("Failed to get YAML info from default path.")
-
-    if not repo_yaml:
-        try:
+            print("Cann't find yaml metadata for {pkg} from current working directory.".format(pkg=repo))
             repo_yaml = gt.get_yaml(repo)
-        except urllib.error.HTTPError:
-            print("Failed to get YAML info for {pkg}".format(pkg=repo))
-            return None
 
-    pkg_info = yaml.load(repo_yaml, Loader=yaml.Loader)
+    if repo_yaml:
+        pkg_info = yaml.load(repo_yaml, Loader=yaml.Loader)
+    else:
+        return None
 
     vc_type = pkg_info["version_control"]
     if vc_type == "hg":
@@ -65,7 +61,7 @@ def get_ver_tags(gt, repo, d_path=None):
     else:
         print("Unsupport version control method {vc}".format(vc=vc_type))
         return None
-    
+
     excpt_list = _get_rec_excpt()
     if repo in excpt_list:
         for excpt in excpt_list[repo]:
-- 
Gitee


From 630c5568cf9b13d6f8699fc9efc190646757c42d Mon Sep 17 00:00:00 2001
From: Leo Fang <leofang_94@163.com>
Date: Mon, 27 Jul 2020 10:50:02 +0800
Subject: [PATCH 5/5] bugfix and improve for need 1.save origin spec file in
 create_spec for need 2.bugfix for download_src() 3.bugfix for get_ver_tags()
 4.add python2/3.yaml to upstream 5.dispaly all origin tags 6.ignore
 'a[1-9...]' of alpha version

Signed-off-by: Leo Fang <leofang_94@163.com>
---
 advisors/check_upstream.py      |  6 +++---
 advisors/oa_upgradable.py       | 22 +++++++++++++++-------
 advisors/simple-update-robot.py |  5 +++++
 advisors/version_recommend.py   |  2 +-
 upstream-info/python2.yaml      |  6 ++++++
 upstream-info/python3.yaml      |  6 ++++++
 6 files changed, 36 insertions(+), 11 deletions(-)
 create mode 100644 upstream-info/python2.yaml
 create mode 100644 upstream-info/python3.yaml

diff --git a/advisors/check_upstream.py b/advisors/check_upstream.py
index 954099bc..7b91b8db 100755
--- a/advisors/check_upstream.py
+++ b/advisors/check_upstream.py
@@ -36,8 +36,8 @@ def load_last_query_result(info, force_reload=False):
         else:
             return ""
 
-def clean_tags(tags, info):
 
+def clean_tags(tags, info):
     if info.get("tag_pattern", "") != "" and info.get("tag_pattern", "") is not None:
         pattern_regex = re.compile(info["tag_pattern"])
         result_list = [pattern_regex.sub("\\1", x) for x in tags]
@@ -50,7 +50,7 @@ def clean_tags(tags, info):
     if info.get("separator", ".") != "." and info.get("separator", ".") is not None:
         separator_regex = re.compile(info["separator"])
         result_list = [separator_regex.sub(".", x) for x in result_list]
-
+    
     # Xinwei used to mis-spell 'separator'. 
     # Followings are kept for compatability until all yaml files are fixed.
     if info.get("seperator", ".") != "." and info.get("seperator", ".") is not None:
@@ -58,7 +58,7 @@ def clean_tags(tags, info):
         result_list = [separator_regex.sub(".", x) for x in result_list]
 
     result_list = [x for x in result_list if x[0].isdigit()]
-
+    
     return result_list
 
 
diff --git a/advisors/oa_upgradable.py b/advisors/oa_upgradable.py
index f256da1d..df9c8afe 100755
--- a/advisors/oa_upgradable.py
+++ b/advisors/oa_upgradable.py
@@ -26,17 +26,28 @@ def _get_rec_excpt():
     excpt = yaml.load(y_file, Loader=yaml.Loader)
     return excpt
 
+
+def _filter_except(excpts, sources):
+    """
+    Filter except case in sources
+    """
+    for e in excpts:
+        sources = [s for s in sources if e not in s]
+    return sources
+    
+
 def get_ver_tags(gt, repo, cwd_path=None):
     """
     Get version tags of given package
     """
-    repo_yaml = ""
     if cwd_path:
         try:
             repo_yaml = open(os.path.join(cwd_path, repo + ".yaml")).read()
         except FileNotFoundError:
             print("Cann't find yaml metadata for {pkg} from current working directory.".format(pkg=repo))
             repo_yaml = gt.get_yaml(repo)
+    else:
+        repo_yaml = gt.get_yaml(repo)
 
     if repo_yaml:
         pkg_info = yaml.load(repo_yaml, Loader=yaml.Loader)
@@ -60,14 +71,10 @@ def get_ver_tags(gt, repo, cwd_path=None):
         tags = check_upstream.check_pypi(pkg_info)
     else:
         print("Unsupport version control method {vc}".format(vc=vc_type))
-        return None
 
     excpt_list = _get_rec_excpt()
     if repo in excpt_list:
-        for excpt in excpt_list[repo]:
-            for tag in tags:
-                if excpt in tag:
-                    tags.remove(tag)
+        tags = _filter_except(excpt_list[repo], tags) 
     return tags
 
 
@@ -95,10 +102,11 @@ if __name__ == "__main__":
     print("current version is ", cur_version)
 
     pkg_tags = get_ver_tags(user_gitee, args.repo, args.default)
+    print("known release tags:", pkg_tags)
+
     if pkg_tags is None:
         sys.exit(1)
     ver_rec = version_recommend.VersionRecommend(pkg_tags, cur_version, 0)
 
-    print("known release tags:", pkg_tags)
     print("Latest version is", ver_rec.latest_version)
     print("Maintain version is", ver_rec.maintain_version)
diff --git a/advisors/simple-update-robot.py b/advisors/simple-update-robot.py
index 90b11685..1ee8b1f4 100755
--- a/advisors/simple-update-robot.py
+++ b/advisors/simple-update-robot.py
@@ -99,10 +99,12 @@ def download_src(gt, spec, o_ver, n_ver):
     source_file = download_source_url(spec, o_ver, n_ver)
     if source_file:
         print(source_file)
+        return True
     else:
         source_file = download_upstream_url(gt, spec.name, n_ver)
         if source_file:
             print(source_file)
+            return True
         else:
             print("Failed to download the latest source code.")
             return False
@@ -112,6 +114,9 @@ def create_spec(repo, spec_str, o_ver, n_ver, src_fn=None):
     """
     Create new spec file for upgraded package
     """
+    fn = open(repo + "_old.spec", "w")
+    fn.write(spec_str)
+    fn.close()
     fn = open(repo + ".spec", "w")
     in_changelog = False
     for l in spec_str.splitlines():
diff --git a/advisors/version_recommend.py b/advisors/version_recommend.py
index d8f21122..47468630 100755
--- a/advisors/version_recommend.py
+++ b/advisors/version_recommend.py
@@ -1089,7 +1089,7 @@ class VersionRecommend(object):
         if m is None:  # 版本号应该是数字开头
             return False
 
-        m = re.search(r'b\d', version)
+        m = re.search(r'[ab]\d', version)
         if not m is None:
             return False
 
diff --git a/upstream-info/python2.yaml b/upstream-info/python2.yaml
new file mode 100644
index 00000000..97065dcc
--- /dev/null
+++ b/upstream-info/python2.yaml
@@ -0,0 +1,6 @@
+---
+version_control: github
+src_repo: python/cpython
+tag_prefix: "^v?3*|^v"
+seperator: "."
+url: https://github.com/python/cpython.git
diff --git a/upstream-info/python3.yaml b/upstream-info/python3.yaml
new file mode 100644
index 00000000..a1ad3009
--- /dev/null
+++ b/upstream-info/python3.yaml
@@ -0,0 +1,6 @@
+---
+version_control: github
+src_repo: python/cpython
+tag_prefix: "^v"
+seperator: "."
+url: https://github.com/python/cpython.git
-- 
Gitee