Python ServerProxy.package_releases方法代码示例

# 需要导入模块: from xmlrpc.client import ServerProxy [as 别名]
# 或者: from xmlrpc.client.ServerProxy import package_releases [as 别名]
    def check_pypi(self):
        """
        If the requirement is frozen to pypi, check for a new version.
        """
        for dist in get_installed_distributions():
            name = dist.project_name
            if name in self.reqs.keys():
                self.reqs[name]["dist"] = dist

        pypi = ServerProxy("https://pypi.python.org/pypi")
        for name, req in list(self.reqs.items()):
            if req["url"]:
                continue  # skipping github packages.
            elif "dist" in req:
                dist = req["dist"]
                dist_version = LooseVersion(dist.version)
                available = pypi.package_releases(req["pip_req"].name, True) or pypi.package_releases(req["pip_req"].name.replace('-', '_'), True)
                available_version = self._available_version(dist_version, available)

                if not available_version:
                    msg = self.style.WARN("release is not on pypi (check capitalization and/or --extra-index-url)")
                elif self.options['show_newer'] and dist_version > available_version:
                    msg = self.style.INFO("{0} available (newer installed)".format(available_version))
                elif available_version > dist_version:
                    msg = self.style.INFO("{0} available".format(available_version))
                else:
                    msg = "up to date"
                    del self.reqs[name]
                    continue
                pkg_info = self.style.BOLD("{dist.project_name} {dist.version}".format(dist=dist))
            else:
                msg = "not installed"
                pkg_info = name
            print("{pkg_info:40} {msg}".format(pkg_info=pkg_info, msg=msg))
            del self.reqs[name]

# 需要导入模块: from xmlrpc.client import ServerProxy [as 别名]
# 或者: from xmlrpc.client.ServerProxy import package_releases [as 别名]
def show_pypi_status(ctx, severe=True):
    """Show project status on PyPI before doing a release.
    """
    info = atelier.current_project.SETUP_INFO
    version = info['version']
    name = info['name']

    assert name and version

    from xmlrpc.client import ServerProxy
    client = ServerProxy('https://pypi.python.org/pypi')
    released_versions = client.package_releases(name)
    if len(released_versions) == 0:
        print("No PyPI release of %(name)s has been done so far." % info)
    else:
        urls = client.release_urls(name, released_versions[-1])
        if len(urls) == 0:
            msg = "Last PyPI release was {0} (no files available)."
            msg = msg.format(released_versions[-1])
            print(msg)
        else:
            lastrel = urls[-1]
            # dt = lastrel['upload_time']
            # lastrel['upload_time'] = dt.ISO()
            print(LASTREL_INFO % lastrel)
        if severe and version in released_versions:
            raise Exit(
                "ABORT: %(name)s %(version)s has already been "
                "released." % info)

# 需要导入模块: from xmlrpc.client import ServerProxy [as 别名]
# 或者: from xmlrpc.client.ServerProxy import package_releases [as 别名]
 def pypi_release(self):
     """Get the latest pypi release
     """
     meta = self.distribution.metadata
     pypi = ServerProxy(self.pypi_index_url)
     releases = pypi.package_releases(meta.name)
     if releases:
         return next(iter(sorted(releases, reverse=True)))

# 需要导入模块: from xmlrpc.client import ServerProxy [as 别名]
# 或者: from xmlrpc.client.ServerProxy import package_releases [as 别名]
def _fetch_version(name):
    arch_name = fix_name(name)

    # First try to get the package by name
    r = requests.get("https://www.archlinux.org/packages/search/json",
                     params={"name": arch_name})
    if r.status_code == 200:
        results = r.json()["results"]
    else:
        results = []

    def build_url(r):
        return "https://www.archlinux.org/packages/%s/%s/%s" % (
            r["repo"], r["arch"], r["pkgname"])

    versions = {}
    for result in results:
        url = build_url(result)
        versions[arch_name] = (result["pkgver"], url)
        for vs in result["provides"]:
            if "=" in vs:
                prov_name, ver = vs.split("=", 1)
                ver = ver.rsplit("-", 1)[0]
                versions[prov_name] = (ver, url)
            else:
                versions[vs] = (result["pkgver"], url)
        return versions

    # If all fails, search the AUR
    r = requests.get("https://aur.archlinux.org/rpc.php", params={
        "v": "5", "type": "search", "by": "name", "arg": arch_name})
    if r.status_code == 200:
        results = r.json()["results"]
    else:
        results = []

    for result in results:
        if result["Name"] == arch_name:
            url = "https://aur.archlinux.org/packages/%s" % result["Name"]
            return {arch_name: (result["Version"].rsplit("-", 1)[0], url)}

    if arch_name.startswith(("python-", "python2-")):
        pypi_name = arch_name.split("-", 1)[-1]
    else:
        pypi_name = arch_name

    client = ServerProxy('https://pypi.python.org/pypi')
    releases = client.package_releases(pypi_name)
    if releases:
        return {arch_name: (
            releases[0], "https://pypi.python.org/pypi/%s" % pypi_name)}

    r = requests.get(
        "http://ftp.gnome.org/pub/GNOME/sources/%s/cache.json" % arch_name)
    if r.status_code == 200:
        return {arch_name: (list(r.json()[2].values())[0][-1], "")}

    return {}

# 需要导入模块: from xmlrpc.client import ServerProxy [as 别名]
# 或者: from xmlrpc.client.ServerProxy import package_releases [as 别名]
def get_pkg_info(pkg_name, downloads=0):
    # multiple asyncio jobs can not share a client
    client = ServerProxy(PYPI_URL)
    try:
        release = client.package_releases(pkg_name)[0]
    except IndexError:  # marionette-transport, ll-orasql, and similar
        print(pkg_name, 'has no releases in PyPI!!')
        return pkg_info(pkg_name, downloads, False, False, 'PyPI error!!', '')
    troves = '\n'.join(client.release_data(pkg_name, release)['classifiers'])
    py2only = py2_only_classifier in troves
    py3 = py3_classifier in troves
    url = client.release_data(pkg_name, release)['package_url']
    return pkg_info(pkg_name, downloads, py2only, py3, release, url)

# 需要导入模块: from xmlrpc.client import ServerProxy [as 别名]
# 或者: from xmlrpc.client.ServerProxy import package_releases [as 别名]
def shortcut(package):
	from xmlrpc.client import ServerProxy
	server = ServerProxy('https://pypi.python.org/pypi')
	version = server.package_releases(package)
	data = server.package_data(package, version[0])
	print("#"*30)
	print('Package Metadata for \n\t\t'+data.get('name', ''))
	print("#" * 30)
	if data.get('summary',None):
		print(data.get('summary'))
		print("#" * 30)
	if data.get('docs_url', None):
		print(data.get('docs_url'))
	if data.get('description', None):
		print(data.get('description'))

# 需要导入模块: from xmlrpc.client import ServerProxy [as 别名]
# 或者: from xmlrpc.client.ServerProxy import package_releases [as 别名]
def check_for_updates():
    from xmlrpc.client import ServerProxy
    from distutils.version import StrictVersion
    pypi = ServerProxy("http://pypi.python.org/pypi")
    version = StrictVersion(__version__)
    pypiversion = StrictVersion(pypi.package_releases("tmc")[0])
    if pypiversion > version:
        infomsg("There is a new version available. ({})".format(pypiversion))
        print("You can upgrade tmc.py with either of these ways, depending",
              "on the way you installed tmc.py in the first place.",
              "\nIf you installed it with pip:",
              "\n    sudo pip install --upgrade tmc",
              "\nIf you installed it with the installation script:",
              "\n    Run the script again and select upgrade.")
    elif pypiversion < version:
        print("You are running a newer version than available.")
    else:
        print("You are running the most current version.")

# 需要导入模块: from xmlrpc.client import ServerProxy [as 别名]
# 或者: from xmlrpc.client.ServerProxy import package_releases [as 别名]
class PYPISource:
    PYPI_URL = 'http://pypi.python.org/pypi'
    def __init__(self):
        self.pypi = ServerProxy(self.PYPI_URL)
    def packages(self):
        return self.pypi.list_packages()
    def releases(self, package):
        return self.pypi.package_releases(package, True)
    def urls(self, package, version):
        return self.pypi.release_urls(package, version)
    def release_data(self, package, version):
        return self.pypi.release_data(package, version)
    def release_data_and_urls(self, package, version):
        return [self.release_data(package, version), self.urls(package, version)]
    def latest(self):
        return self.pypi.changelog_last_serial()
    def changes(self, serial):
        return self.pypi.changelog_since_serial(serial)

# 需要导入模块: from xmlrpc.client import ServerProxy [as 别名]
# 或者: from xmlrpc.client.ServerProxy import package_releases [as 别名]
def get_package_dist(name, version='latest', packagetype='bdist_wheel'):
    """
    Get a description of a package from a pypi server.
    """
    pypi = ServerProxy(HOST)

    if version == 'latest':
        version = pypi.package_releases(name)[0]

    urls = pypi.release_urls(name, version)
    if not urls:
        print('No package "{}" version "{}"'.format(name, version))
        return None

    dists = [d for d in urls if d['packagetype'] == packagetype]
    if not dists:
        print('No package "{}" type "{}"'.format(name, packagetype))
        return None

    return dists[0]

# 需要导入模块: from xmlrpc.client import ServerProxy [as 别名]
# 或者: from xmlrpc.client.ServerProxy import package_releases [as 别名]
def should_update():
    from xmlrpc.client import ServerProxy
    from distutils.version import StrictVersion
    from datetime import datetime
    import calendar

    current_version = StrictVersion(__version__)
    last_value = (Config.has_name("needs_update")
                  and Config.get_value("needs_update") == "1")
    last_version = (0, 0, 0)
    if Config.has_name("last_version"):
        last_version = StrictVersion(Config.get_value("last_version"))

    # Return false if an upgrade has happened
    if last_value and (last_version < current_version):
        return False

    Config.set("last_version", __version__)

    # Next lets check the time
    last_time = None
    if Config.has_name("last_update_check"):
        last_time = datetime.utcfromtimestamp(int(
            Config.get_value("last_update_check")))
    else:
        last_time = datetime.now()

    if (last_time - datetime.now()).days < 7:
        return False

    Config.set("last_update_check",
               calendar.timegm(datetime.now().timetuple()))

    # Lastly lets check pypi for versions
    pypi = ServerProxy("http://pypi.python.org/pypi")
    pypiversion = StrictVersion(pypi.package_releases("tmc")[0])

    if pypiversion > current_version:
        return True
    return False

# 需要导入模块: from xmlrpc.client import ServerProxy [as 别名]
# 或者: from xmlrpc.client.ServerProxy import package_releases [as 别名]
from xmlrpc.client import ServerProxy
from collections import defaultdict
from progressbar import ProgressBar, Bar, ETA, AdaptiveETA, Percentage

pypi = ServerProxy("http://pypi.python.org/pypi")

start = pypi.changelog_last_serial()

packages = pypi.list_packages()

releases = defaultdict(list)

pb = ProgressBar(widgets=[Percentage(), ' ', Bar(), ' ', ETA(), ' ', AdaptiveETA()])

for pkg in pb(packages):
    rel = pypi.package_releases(pkg)
    all = pypi.package_releases(pkg, True)
    releases[pkg] = (set(rel), set(all)-set(rel))
    for r in all:
        urls = release_urls(pkg, r)
        data = release_data(pkg, r)
        dl = release_downloads(pkg, r)

end = pypi.changelog_last_serial()

if end > start:
    print("{} changes while this code ran".format(end-start))

# 需要导入模块: from xmlrpc.client import ServerProxy [as 别名]
# 或者: from xmlrpc.client.ServerProxy import package_releases [as 别名]
class PyPiPackage(object):
	def __init__(self, name, json_link=None):
		self.name = self.package =name
		if not json_link:
			self.json_link = "http://pypi.python.org/pypi/{}/json".format(self.package)
		else:
			self.json_link = json_link
		self.proxy = ServerProxy('https://pypi.python.org/pypi')
		roles = [role[1] for role in self.proxy.package_roles(self.name)]
		if len(roles)==1:
			self.roles = roles[0]
		else:
			self.roles = roles
		self.data = self._data
		self.keywords = self.info.get('keywords')
		self.author = self.info.get('author')
		self.classifiers = self.info.get('classifiers')
		self.maintainer_email = self.info.get('maintainer_email')
		self.home_page = self.info.get('home_page')
		self.platform = self.info.get('platform')
		self._pypi_ordering = self.info.get('_pypi_ordering')
		self.downloads_url = self.info.get('download_url')
		self.docs_url = self.info.get('docs_url')
		self.author_email = self.info.get('author_email')
		self.summary = self.info.get('summary', ".")
		self.maintainer = self.info.get('maintainer')
		self.description = self.info.get('description')
		self.package_url = self.info.get('package_url')
		self.bugtrack_url = self.info.get('bugtrack_url')
		self.packagetype = self.urls.get('packagetype')
		self.size = self.urls.get('size')
		self.size_fmt = "{:,}".format(self.size)
		self.max_downloads = self._max_downloads

		self._compacted = self.compact_info
		for key, value in self.compact_info.items():
			if value:
				self.__setattr__(key, value)

	def from_dict(self, d):
		from copy import copy
		alias = self.copy()
		for k,v in d.items():
			alias.__setattr__(k,v)
		return alias

	def clean_Nones(self):
		alias = copy(self)
		for k,v in alias.__dict__.items():
			if v is None:
				del alias[k]
		return alias


	def __repr__(self):
		name =self.name
		if self.max_downloads:
			dls = "{:,} downloads, ".format(self.max_downloads)
		else:
			dls = ''
		if self.size_fmt:
			size = "size: {}, ".format(self.size_fmt)
		else:
			size = ''
		if self.summary:
			if len(self.summary) > 40:
				summary = " ".join(w for w in self.summary.lower().split() if w not in STOPWORDS)
			elif len(self.summary) <= 40:
				summary = self.summary
		else:
			summary = ''
		return "<Package {}: {}{};{}>".format(name, dls, size, summary)

	@property
	def _data(self):
		try:
			data = requests.get(self.json_link).json()
		except JSONDecodeError:
			version = max(self.proxy.package_releases(self.name))
			data = self.proxy.release_data(self.name, version)
		return data

	@property
	def _max_downloads(self):
		counts = []
		releases = self.data.get('releases')
		for key in releases.keys():
			if len(releases[key]) > 0:
				counts.append(releases[key][0].get('downloads', 0))
		return sum(counts)

	@property
	def info(self):
		return self.data.get('info')

	@property
	def compact_info(self):
		compacter = itemgetter('downloads', 'release_url', 'keywords', 'author', 'classifiers', 'maintainer_email','home_page', 'license', 'name', 'platform', '_pypi_ordering', 'download_url', 'docs_url', 'author_email', 'summary', 'maintainer', 'description', 'version', 'package_url', 'bugtrack_url')

		compacted_info = compacter(self.info)
#.........这里部分代码省略.........

# 需要导入模块: from xmlrpc.client import ServerProxy [as 别名]
# 或者: from xmlrpc.client.ServerProxy import package_releases [as 别名]
class JSON_PYPI(object):
	def __init__(self, name=None, json_link=None):
		self.name = name
		self.package = name
		if not json_link:
			self.json_link = "http://pypi.python.org/pypi/{}/json".format(self.package)
		else:
			self.json_link = json_link
		self.proxy = ServerProxy('https://pypi.python.org/pypi')
		self.keywords = self.info.get('keywords')
		self.author = self.info.get('author')
		self.classifiers = self.info.get('classifiers')
		self.maintainer_email = self.info.get('maintainer_email')
		self.home_page = self.info.get('home_page')
		self.platform = self.info.get('platform')
		self._pypi_ordering = self.info.get('_pypi_ordering')
		self.downloads_url = self.info.get('download_url')
		self.docs_url = self.info.get('docs_url')
		self.author_email = self.info.get('author_email')
		self.summary = self.info.get('summary', ".")
		self.maintainer = self.info.get('maintainer')
		self.description = self.info.get('description')
		self.package_url = self.info.get('package_url')
		self.bugtrack_url = self.info.get('bugtrack_url')
		self.packagetype = self.urls.get('packagetype')
		self.size = self.urls.get('size')
		self.size_fmt=  "{:,}".format(self.size)


	@property
	def data(self):
		try:
			data =get_json(self.json_link)
		except simplejson.scanner.JSONDecodeError:
			version = max(self.proxy.package_releases(self.name))
			data = self.proxy.release_data(self.name, version)
		return data

	@property
	def info(self):
		return self.data.get('info')

	@property
	def releases(self):
		return self.data.get('releases')

	@property
	def urls(self):
		urls = self.data.get('urls')
		if len(urls) > 0 and isinstance(urls, list):
			result = urls[0]
		else:
			result = urls

		return result

	@property
	def upload_time(self):
		try:
			up_time = ' '.join(self.urls.get('upload_time').split('T'))
			upload_time = datetime.strptime(up_time, "%Y-%m-%d %H:%M:%S")
		except ValueError:
			date,time = self.urls.get('upload_time').split('T')
			year, month, day = date.split('-')
			hour, min, sec = time.split(':')
			upload_time = datetime(int(year), int(month), int(day), int(hour), int(min), int(sec))

		return upload_time

	@property
	def get_max_downloads(self):
		counts = []
		if isinstance(self.releases, str):
			json = requests.get(self.releases).json()['releases']
		elif isinstance(self.releases, dict):
			if 'releases' in self.releases:
				json = url['self.releases']
			else:
				json = self.releases

		for key in json.keys():
			if len(json[key]) > 0:
				counts.append(json[key][0].get('downloads', 0))
		return sum(counts)

	def roles(self):
		return self.proxy.package_roles(self.name)

	def __repr__(self):
		name = self.name
		if self.summary is not None or len(self.summary) > 2:
			summary = self.summary
		else:
			summary = " "
		size = self.fmt_size
		dls = "{:,}".format(self.get_max_downloads)
		if isinstance(summary, str) and len(summary) > 30:
			summary = " ".join(w for w in summary.split() if w not in STOPWORDS)

		return "<Package {}: {}, {}, {}>".format(name, dls, size, summary)

# 需要导入模块: from xmlrpc.client import ServerProxy [as 别名]
# 或者: from xmlrpc.client.ServerProxy import package_releases [as 别名]
class Client(object):
	def __init__(self):
		self.uri = 'https://pypi.python.org/pypi'
		self.proxy = ServerProxy(self.uri)
		self.cache = set()


	def all_distributions(self):
		return self.proxy.list_packages()

	def roles(self, package):
		return [cl[1] for cl in self.proxy.package_roles(package)]

	def user_packages(self, user):
		return [cl[1] for cl in self.proxy.user_packages(user)]

	def release_downloads(self, package, version=None):
		if version is None:
			version = max(self.proxy.package_releases(package))
			if isinstance(version, list):
				version = version[0]
		return self.proxy.release_downloads(package, version)

	def package_releases(self, package):
		return self.proxy.package_releases(package)

	def release_data(self, package, version=None):
		version = max(self.proxy.package_releases(package))
		if isinstance(version, list):
			version = version[0]
		data = self.proxy.release_data(package, version)
		return data


	def simple_search(self, spec, operator='or', getter = None, omit = ('django')):
		"""Can search by name, version, author, author_email, maintainer,
		maintainer_email, home_page, license, summary,
		description, keywords, platform,download_url"""
		from pip.commands.search import transform_hits, highest_version
		from
		results = set()
		packages = {}
		from operator import itemgetter
		filter = itemgetter('name', 'version')
		info_getter = itemgetter('name', 'summary')
		name_getter = itemgetter('name')

		hits = self.proxy.search({'name': spec},{'summary':spec}, operator)
		results = transform_hits(hits)
		for result in results:
			result['version'] = highest_version(result['versions'])
			del result['score']
		return results


	def deep_search(self, spec, operator='and', cache = None, limit=20):
		results =list()
		temp_cache = set()
		initial_results = self.simple_search(spec, operator='and', getter=None, omit=['django'])
		for result in initial_results:
			new = PyPiPackage(result)
			results.append(new)
			temp_cache.add(new)
		if cache is not None:
			self.cache = cache|temp_cache
		else:
			pass
		filtered = sorted(results, key = lambda x: x.max_downloads, reversed=True)
		return filtered[limit:]


	def browse(self, classifiers):
		return self.proxy.browse(classifiers)


	def get_json_url(self, package):
		return "http://pypi.python.org/pypi/{}/json".format(package)

# 需要导入模块: from xmlrpc.client import ServerProxy [as 别名]
# 或者: from xmlrpc.client.ServerProxy import package_releases [as 别名]

#.........这里部分代码省略.........
        for k, v in d.items():
            alias.__setattr__(k, v)
        return alias

    def __repr__(self):
        name = self.name
        if self.max_downloads:
            dls = "{:,} downloads, ".format(self.max_downloads)
        else:
            dls = ""
        if self.size_fmt:
            size = "size: {}, ".format(self.size_fmt)
        else:
            size = ""
        if self.summary:
            if len(self.summary) > 40:
                summary = " ".join(w for w in self.summary.lower().split() if w not in STOPWORDS)
            elif len(self.summary) <= 40:
                summary = self.summary
        else:
            summary = ""
        return "<Package {}: {}{};{}>".format(name, dls, size, summary)

    def highest_version(self, versions):
        return next(iter(sorted(versions, key=pkg_resources.parse_version, reverse=True)))

    @property
    def _data(self):
        try:
            data = requests.get(self.json_link).json()
            print(bool(data))  ##
        except simplejson.JSONDecodeError:

            version = self.proxy.package_releases(self.name)
            if len(version) == 1:
                version = version[0]
                print(version)  ###
            data = self.proxy.release_data(self.name, version)
        else:
            data = dict(info="", releases="", urls="")
        return data

    @property
    def _max_downloads(self):
        counts = []
        releases = self.data.get("releases")
        for key in releases.keys():
            if len(releases[key]) > 0:
                counts.append(releases[key][0].get("downloads", 0))
        return sum(counts)

    @property
    def _keywords(self):
        if self.info is not None:
            kws = self.info.get("keywords", None)
            if kws:
                if "," in kws:
                    keywords = [kw.strip().lower() for kw in kws.split(",")]
                else:
                    keywords = [kw.strip().lower() for kw in kws.split()]
                return keywords
            else:
                return kws
        else:
            return None