c33a9f9aa2
changed the behavior to import division and print to be consistent across all app and similar with python 3.x
147 lines
4.9 KiB
Python
147 lines
4.9 KiB
Python
# coding=utf-8
|
|
from __future__ import absolute_import, division, print_function
|
|
|
|
__author__ = "Gina Häußge <osd@foosel.net>"
|
|
__license__ = 'GNU Affero General Public License http://www.gnu.org/licenses/agpl.html'
|
|
__copyright__ = "Copyright (C) 2014 The OctoPrint Project - Released under terms of the AGPLv3 License"
|
|
|
|
import requests
|
|
import logging
|
|
|
|
from ..exceptions import ConfigurationInvalid
|
|
|
|
RELEASE_URL = "https://api.github.com/repos/{user}/{repo}/releases"
|
|
|
|
logger = logging.getLogger("octoprint.plugins.softwareupdate.version_checks.github_release")
|
|
|
|
def _get_latest_release(user, repo, include_prerelease=False):
|
|
nothing = None, None, None
|
|
r = requests.get(RELEASE_URL.format(user=user, repo=repo))
|
|
|
|
from . import log_github_ratelimit
|
|
log_github_ratelimit(logger, r)
|
|
|
|
if not r.status_code == requests.codes.ok:
|
|
return nothing
|
|
|
|
releases = r.json()
|
|
|
|
# sanitize
|
|
required_fields = {"name", "tag_name", "html_url", "draft", "prerelease", "published_at"}
|
|
releases = filter(lambda rel: set(rel.keys()) & required_fields == required_fields,
|
|
releases)
|
|
|
|
# filter out prereleases and drafts
|
|
if include_prerelease:
|
|
releases = filter(lambda rel: not rel["draft"], releases)
|
|
else:
|
|
releases = filter(lambda rel: not rel["prerelease"] and not rel["draft"],
|
|
releases)
|
|
|
|
if not releases:
|
|
return nothing
|
|
|
|
# sort by date
|
|
comp = lambda a, b: cmp(a.get("published_at", None), b["published_at"])
|
|
releases = sorted(releases, cmp=comp)
|
|
|
|
# latest release = last in list
|
|
latest = releases[-1]
|
|
|
|
return latest["name"], latest["tag_name"], latest.get("html_url", None)
|
|
|
|
|
|
def _get_sanitized_version(version_string):
|
|
if "-" in version_string:
|
|
version_string = version_string[:version_string.find("-")]
|
|
return version_string
|
|
|
|
|
|
def _get_comparable_version_pkg_resources(version_string, force_base=True):
|
|
import pkg_resources
|
|
|
|
version = pkg_resources.parse_version(version_string)
|
|
|
|
if force_base:
|
|
if isinstance(version, tuple):
|
|
# old setuptools
|
|
base_version = []
|
|
for part in version:
|
|
if part.startswith("*"):
|
|
break
|
|
base_version.append(part)
|
|
version = tuple(base_version)
|
|
else:
|
|
# new setuptools
|
|
version = pkg_resources.parse_version(version.base_version)
|
|
|
|
return version
|
|
|
|
|
|
def _get_comparable_version_semantic(version_string, force_base=True):
|
|
import semantic_version
|
|
|
|
version = semantic_version.Version.coerce(version_string, partial=False)
|
|
|
|
if force_base:
|
|
version_string = "{}.{}.{}".format(version.major, version.minor, version.patch)
|
|
version = semantic_version.Version.coerce(version_string, partial=False)
|
|
|
|
return version
|
|
|
|
|
|
def _is_current(release_information, compare_type, custom=None, force_base=True):
|
|
if release_information["remote"]["value"] is None:
|
|
return True
|
|
|
|
if not compare_type in ("python", "semantic", "unequal", "custom") or compare_type == "custom" and custom is None:
|
|
compare_type = "python"
|
|
|
|
sanitized_local = _get_sanitized_version(release_information["local"]["value"])
|
|
sanitized_remote = _get_sanitized_version(release_information["remote"]["value"])
|
|
|
|
try:
|
|
if compare_type == "python":
|
|
local_version = _get_comparable_version_pkg_resources(sanitized_local, force_base=force_base)
|
|
remote_version = _get_comparable_version_pkg_resources(sanitized_remote, force_base=force_base)
|
|
return local_version >= remote_version
|
|
|
|
elif compare_type == "semantic":
|
|
local_version = _get_comparable_version_semantic(sanitized_local, force_base=force_base)
|
|
remote_version = _get_comparable_version_semantic(sanitized_remote, force_base=force_base)
|
|
return local_version >= remote_version
|
|
|
|
elif compare_type == "custom":
|
|
return custom(sanitized_local, sanitized_remote)
|
|
|
|
else:
|
|
return sanitized_local == sanitized_remote
|
|
except:
|
|
logger.exception("Could not check if version is current due to an error, assuming it is")
|
|
return True
|
|
|
|
|
|
def get_latest(target, check, custom_compare=None):
|
|
if not "user" in check or not "repo" in check:
|
|
raise ConfigurationInvalid("github_release update configuration for %s needs user and repo set" % target)
|
|
|
|
current = check.get("current", None)
|
|
include_prerelease = check.get("prerelease", False)
|
|
force_base = check.get("force_base", True)
|
|
|
|
remote_name, remote_tag, release_notes = _get_latest_release(check["user"],
|
|
check["repo"],
|
|
include_prerelease=include_prerelease)
|
|
compare_type = check["release_compare"] if "release_compare" in check else "python"
|
|
|
|
information =dict(
|
|
local=dict(name=current, value=current),
|
|
remote=dict(name=remote_name, value=remote_tag, release_notes=release_notes)
|
|
)
|
|
|
|
logger.debug("Target: %s, local: %s, remote: %s" % (target, current, remote_tag))
|
|
|
|
return information, _is_current(information,
|
|
compare_type,
|
|
custom=custom_compare,
|
|
force_base=force_base)
|