python - पायथन और पीपी, उपलब्ध पैकेज के सभी संस्करणों की सूची है?




virtualenv pip (12)

एक पाइथन (2.X) पैकेज के नाम को देखते हुए जिसे pip और virtualenv साथ स्थापित किया जा सकता है, क्या इसके सभी संभावित संस्करणों की सूची जानने का कोई तरीका है कि पीआईपी स्थापित हो सकता है? अभी यह परीक्षण और त्रुटि है।

मैं एक थर्ड पार्टी लाइब्रेरी के लिए एक संस्करण स्थापित करने की कोशिश कर रहा हूं, लेकिन नवीनतम संस्करण बहुत नया है, पीछे असंगत परिवर्तन किए गए थे। तो मैं किसी भी तरह से उन सभी संस्करणों की एक सूची बनाना चाहता हूं जिनके बारे में पीआईपी जानता है, ताकि मैं उनका परीक्षण कर सकूं।


आप PyPI से पैकेज के लिए उपलब्ध संस्करणों की सूची को पकड़ने के लिए इस छोटे पायथन 3 स्निपेट का उपयोग कर सकते हैं। यहां पोस्ट किए गए कुछ अन्य पायथन समाधानों के विपरीत, यह django के 1.10rc1 या uwsgi 1.10rc1 जैसे ढीले संस्करणों पर नहीं 2.0.13.1 :

>>> import requests
>>> from pkg_resources import parse_version
>>> 
>>> def versions(name):
...     url = "https://pypi.python.org/pypi/{}/json".format(name)
...     return sorted(requests.get(url).json()["releases"], key=parse_version)
... 
>>> print(*reversed(versions("Django")), sep="\n")
1.10.3
1.10.2
1.10.1
1.10
1.10rc1
1.10b1
1.10a1
...

आप अपनी pip list के परिणाम grep कर सकते हैं

-> % pip list | grep 'beautifulsoup4'

beautifulsoup4 (4.4.1)

इस जानकारी को पाने के लिए आपको किसी तृतीय पक्ष पैकेज की आवश्यकता नहीं है। पीपीआई सभी संकुलों के लिए सरल JSON फ़ीड प्रदान करता है

https://pypi.python.org/pypi/{PKG_NAME}/json

यहां केवल कुछ मानक लाइब्रेरी का उपयोग करके कुछ पायथन कोड है जो सभी संस्करणों को प्राप्त करता है।

import json
import urllib2
from distutils.version import StrictVersion

def versions(package_name):
    url = "https://pypi.python.org/pypi/%s/json" % (package_name,)
    data = json.load(urllib2.urlopen(urllib2.Request(url)))
    versions = data["releases"].keys()
    versions.sort(key=StrictVersion)
    return versions

print "\n".join(versions("scikit-image"))

वह कोड प्रिंट करता है (23 फरवरी, 2015 तक):

0.7.2
0.8.0
0.8.1
0.8.2
0.9.0
0.9.1
0.9.2
0.9.3
0.10.0
0.10.1

थोड़ी देर के लिए पीपी के कोड को देखने के बाद, ऐसा लगता है कि पैकेज ढूंढने के लिए ज़िम्मेदार कोड PackageFinder में PackageFinder क्लास में पाया जा सकता है। इसकी विधि find_requirement के संस्करणों को देखता है, लेकिन दुर्भाग्यवश केवल सबसे हालिया संस्करण देता है।

नीचे दिया गया कोड मूल फ़ंक्शन की लगभग 1: 1 प्रति है, जिसमें लाइन 114 में वापसी सभी संस्करणों को वापस करने के लिए बदली गई है।

स्क्रिप्ट एक पैकेज नाम को पहले और केवल तर्क के रूप में उम्मीद करता है और सभी संस्करणों को लौटाता है।

http://pastebin.com/axzdUQhZ

मैं शुद्धता की गारंटी नहीं दे सकता, क्योंकि मैं पीआईपी कोड से परिचित नहीं हूं। लेकिन उम्मीद है कि यह मदद करता है।

नमूना उत्पादन

$ python test.py pip
Versions of pip
0.8.2
0.8.1
0.8
0.7.2
0.7.1
0.7
0.6.3
0.6.2
0.6.1
0.6
0.5.1
0.5
0.4
0.3.1
0.3
0.2.1
0.2 dev

कोड:

import posixpath
import pkg_resources
import sys
from pip.download import url_to_path
from pip.exceptions import DistributionNotFound
from pip.index import PackageFinder, Link
from pip.log import logger
from pip.req import InstallRequirement
from pip.util import Inf


class MyPackageFinder(PackageFinder):

    def find_requirement(self, req, upgrade):
        url_name = req.url_name
        # Only check main index if index URL is given:
        main_index_url = None
        if self.index_urls:
            # Check that we have the url_name correctly spelled:
            main_index_url = Link(posixpath.join(self.index_urls[0], url_name))
            # This will also cache the page, so it's okay that we get it again later:
            page = self._get_page(main_index_url, req)
            if page is None:
                url_name = self._find_url_name(Link(self.index_urls[0]), url_name, req) or req.url_name

        # Combine index URLs with mirror URLs here to allow
        # adding more index URLs from requirements files
        all_index_urls = self.index_urls + self.mirror_urls

        def mkurl_pypi_url(url):
            loc = posixpath.join(url, url_name)
            # For maximum compatibility with easy_install, ensure the path
            # ends in a trailing slash.  Although this isn't in the spec
            # (and PyPI can handle it without the slash) some other index
            # implementations might break if they relied on easy_install's behavior.
            if not loc.endswith('/'):
                loc = loc + '/'
            return loc
        if url_name is not None:
            locations = [
                mkurl_pypi_url(url)
                for url in all_index_urls] + self.find_links
        else:
            locations = list(self.find_links)
        locations.extend(self.dependency_links)
        for version in req.absolute_versions:
            if url_name is not None and main_index_url is not None:
                locations = [
                    posixpath.join(main_index_url.url, version)] + locations

        file_locations, url_locations = self._sort_locations(locations)

        locations = [Link(url) for url in url_locations]
        logger.debug('URLs to search for versions for %s:' % req)
        for location in locations:
            logger.debug('* %s' % location)
        found_versions = []
        found_versions.extend(
            self._package_versions(
                [Link(url, '-f') for url in self.find_links], req.name.lower()))
        page_versions = []
        for page in self._get_pages(locations, req):
            logger.debug('Analyzing links from page %s' % page.url)
            logger.indent += 2
            try:
                page_versions.extend(self._package_versions(page.links, req.name.lower()))
            finally:
                logger.indent -= 2
        dependency_versions = list(self._package_versions(
            [Link(url) for url in self.dependency_links], req.name.lower()))
        if dependency_versions:
            logger.info('dependency_links found: %s' % ', '.join([link.url for parsed, link, version in dependency_versions]))
        file_versions = list(self._package_versions(
                [Link(url) for url in file_locations], req.name.lower()))
        if not found_versions and not page_versions and not dependency_versions and not file_versions:
            logger.fatal('Could not find any downloads that satisfy the requirement %s' % req)
            raise DistributionNotFound('No distributions at all found for %s' % req)
        if req.satisfied_by is not None:
            found_versions.append((req.satisfied_by.parsed_version, Inf, req.satisfied_by.version))
        if file_versions:
            file_versions.sort(reverse=True)
            logger.info('Local files found: %s' % ', '.join([url_to_path(link.url) for parsed, link, version in file_versions]))
            found_versions = file_versions + found_versions
        all_versions = found_versions + page_versions + dependency_versions
        applicable_versions = []
        for (parsed_version, link, version) in all_versions:
            if version not in req.req:
                logger.info("Ignoring link %s, version %s doesn't match %s"
                            % (link, version, ','.join([''.join(s) for s in req.req.specs])))
                continue
            applicable_versions.append((link, version))
        applicable_versions = sorted(applicable_versions, key=lambda v: pkg_resources.parse_version(v[1]), reverse=True)
        existing_applicable = bool([link for link, version in applicable_versions if link is Inf])
        if not upgrade and existing_applicable:
            if applicable_versions[0][1] is Inf:
                logger.info('Existing installed version (%s) is most up-to-date and satisfies requirement'
                            % req.satisfied_by.version)
            else:
                logger.info('Existing installed version (%s) satisfies requirement (most up-to-date version is %s)'
                            % (req.satisfied_by.version, applicable_versions[0][1]))
            return None
        if not applicable_versions:
            logger.fatal('Could not find a version that satisfies the requirement %s (from versions: %s)'
                         % (req, ', '.join([version for parsed_version, link, version in found_versions])))
            raise DistributionNotFound('No distributions matching the version for %s' % req)
        if applicable_versions[0][0] is Inf:
            # We have an existing version, and its the best version
            logger.info('Installed version (%s) is most up-to-date (past versions: %s)'
                        % (req.satisfied_by.version, ', '.join([version for link, version in applicable_versions[1:]]) or 'none'))
            return None
        if len(applicable_versions) > 1:
            logger.info('Using version %s (newest of versions: %s)' %
                        (applicable_versions[0][1], ', '.join([version for link, version in applicable_versions])))
        return applicable_versions


if __name__ == '__main__':
    req = InstallRequirement.from_line(sys.argv[1], None)
    finder = MyPackageFinder([], ['http://pypi.python.org/simple/'])
    versions = finder.find_requirement(req, False)
    print 'Versions of %s' % sys.argv[1]
    for v in versions:
        print v[1]

पेस्टबिन पर लिपि काम करता है। हालांकि यदि आप कई वातावरण / होस्ट के साथ काम कर रहे हैं तो यह बहुत सुविधाजनक नहीं है क्योंकि आपको हर बार इसकी प्रतिलिपि बनाना / बनाना होगा।

एक बेहतर आसपास के समाधान yolk का उपयोग करना होगा, जो पीआईपी के साथ स्थापित करने के लिए उपलब्ध है। यह देखने के लिए कि Django के कौन से संस्करण उपलब्ध हैं:

$ pip install yolk
$ yolk -V django
Django 1.3
Django 1.2.5
Django 1.2.4
Django 1.2.3
Django 1.2.2
Django 1.2.1
Django 1.2
Django 1.1.4
Django 1.1.3
Django 1.1.2
Django 1.0.4

एक मामूली चेतावनी: जर्दी वितरित पर निर्भर करता है। यह एक बुरी चीज नहीं है, लेकिन अगर आपको किसी भी कारण से छुटकारा पाने के लिए किसी भी कारण की आवश्यकता है तो यह एक समस्या हो सकती है (बहिष्कृत) पायथन सेटअपटोल।

नोट: मैं जर्दी के विकास में शामिल नहीं हूं। अगर ऐसा कुछ नहीं लगता है जैसा कि इसे करना चाहिए, तो यहां एक टिप्पणी छोड़ना बहुत अंतर नहीं लेना चाहिए। इसके बजाय जर्नल इश्यू ट्रैकर का प्रयोग करें और यदि संभव हो, तो एक फिक्स सबमिट करने पर विचार करें।


मुझे पता है कि यह मूर्खतापूर्ण है लेकिन आप इस तरह कुछ कोशिश कर सकते हैं:

pip install django == x

यह त्रुटि होगी लेकिन इस पैकेज के लिए उपलब्ध सभी संस्करणों को सूचीबद्ध करेगा।

बस अपने इच्छित पैकेज के साथ django को प्रतिस्थापित करें और मुझे विश्वास है, उम्मीद है कि एक्स नामक ऐसा कोई संस्करण नहीं है।


मेरे पास yolk , yolk3k या pip install -v साथ कोई भाग्य नहीं था, लेकिन इसलिए मैंने इसका उपयोग समाप्त कर दिया (एरिक चियांग के उत्तर से पायथन 3 में अनुकूलित):

import json
import requests
from distutils.version import StrictVersion

def versions(package_name):
    url = "https://pypi.python.org/pypi/{}/json".format(package_name)
    data = requests.get(url).json()
    return sorted(list(data["releases"].keys()), key=StrictVersion, reverse=True)

>>> print("\n".join(versions("gunicorn")))
19.1.1
19.1.0
19.0.0
18.0
17.5
0.17.4
0.17.3
...

मैं मृत-सरल बैश लिपि के साथ आया था। jq के लेखक के लिए धन्यवाद।

#!/bin/bash
set -e

PACKAGE_JSON_URL="https://pypi.python.org/pypi/${1}/json"

curl -s "$PACKAGE_JSON_URL" | jq  -r '.releases | keys | .[]' | sort -V

अद्यतन: संस्करण संख्या द्वारा सॉर्टिंग जोड़ें।


यह ओएसएक्स पर मेरे लिए काम करता है:

pip install docker-compose== 2>&1 | grep -oE '(\(.*\))' | awk -F:\ '{print$NF}' | sed -E 's/( |\))//g' | tr ',' '\n'

यह प्रति पंक्ति एक सूची देता है:

1.1.0rc1
1.1.0rc2
1.1.0
1.2.0rc1
1.2.0rc2
1.2.0rc3
1.2.0rc4
1.2.0
1.3.0rc1
1.3.0rc2
1.3.0rc3
1.3.0
1.3.1
1.3.2
1.3.3
1.4.0rc1
1.4.0rc2
1.4.0rc3
1.4.0
1.4.1
1.4.2
1.5.0rc1
1.5.0rc2
1.5.0rc3
1.5.0
1.5.1
1.5.2
1.6.0rc1
1.6.0
1.6.1
1.6.2
1.7.0rc1
1.7.0rc2
1.7.0
1.7.1
1.8.0rc1
1.8.0rc2
1.8.0
1.8.1
1.9.0rc1
1.9.0rc2
1.9.0rc3
1.9.0rc4
1.9.0
1.10.0rc1
1.10.0rc2
1.10.0

या उपलब्ध नवीनतम संस्करण प्राप्त करने के लिए:

pip install docker-compose== 2>&1 | grep -oE '(\(.*\))' | awk -F:\ '{print$NF}' | sed -E 's/( |\))//g' | tr ',' '\n' | gsort -r -V | head -1

1.10.0rc2

ध्यान रखें कि संस्करणों को पार्स करने के लिए gsort को स्थापित करना होगा (ओएसएक्स पर)। आप इसे brew install coreutils साथ स्थापित कर सकते हैं


लीगेसी पीईपीआई पैकेज एपीआई खोजते हुए वर्तमान पायथन पाइप-आधारित विधि यहां दी गई है:

from pip import index
import requests
finder = index.PackageFinder(
    [],
    ['https://pypi.python.org/simple'],
    session=requests.Session()
)
results = finder.find_all_candidates("package_name")
versions = [p.version for p in results]

अद्यतन करें:
सितंबर 2017 तक यह विधि अब काम नहीं करती है: - --no-install 7 में नो --no-install हटा दिया गया था

pip install -v प्रयोग करें, आप उपलब्ध सभी संस्करण देख सकते हैं

[email protected]:~# pip install web.py -v
Downloading/unpacking web.py
  Using version 0.37 (newest of versions: 0.37, 0.36, 0.35, 0.34, 0.33, 0.33, 0.32, 0.31, 0.22, 0.2)
  Downloading web.py-0.37.tar.gz (90Kb): 90Kb downloaded
  Running setup.py egg_info for package web.py
    running egg_info
    creating pip-egg-info/web.py.egg-info

किसी भी पैकेज को स्थापित करने के लिए, निम्न समाधान में से एक का उपयोग करें:

[email protected]:~# pip install --no-deps --no-install flask -v                                                                                                      
Downloading/unpacking flask
  Using version 0.10.1 (newest of versions: 0.10.1, 0.10, 0.9, 0.8.1, 0.8, 0.7.2, 0.7.1, 0.7, 0.6.1, 0.6, 0.5.2, 0.5.1, 0.5, 0.4, 0.3.1, 0.3, 0.2, 0.1)
  Downloading Flask-0.10.1.tar.gz (544Kb): 544Kb downloaded

या

[email protected]:~# cd $(mktemp -d)
[email protected]:/tmp/tmp.c6H99cWD0g# pip install flask -d . -v
Downloading/unpacking flask
  Using version 0.10.1 (newest of versions: 0.10.1, 0.10, 0.9, 0.8.1, 0.8, 0.7.2, 0.7.1, 0.7, 0.6.1, 0.6, 0.5.2, 0.5.1, 0.5, 0.4, 0.3.1, 0.3, 0.2, 0.1)
  Downloading Flask-0.10.1.tar.gz (544Kb): 4.1Kb downloaded

पीआईपी 1.0 के साथ परीक्षण किया

[email protected]:~# pip --version
pip 1.0 from /usr/lib/python2.7/dist-packages (python 2.7)

पाइप> = 9.0 उपयोग के लिए

$ pip install pylibmc==
Collecting pylibmc==
  Could not find a version that satisfies the requirement pylibmc== (from 
  versions: 0.2, 0.3, 0.4, 0.5.1, 0.5.2, 0.5.3, 0.5.4, 0.5.5, 0.5, 0.6.1, 0.6, 
  0.7.1, 0.7.2, 0.7.3, 0.7.4, 0.7, 0.8.1, 0.8.2, 0.8, 0.9.1, 0.9.2, 0.9, 
  1.0-alpha, 1.0-beta, 1.0, 1.1.1, 1.1, 1.2.0, 1.2.1, 1.2.2, 1.2.3, 1.3.0)
No matching distribution found for pylibmc==

- सभी उपलब्ध संस्करणों को वास्तव में किसी भी अतिरिक्त पैकेज को डाउनलोड या इंस्टॉल किए बिना मुद्रित किया जाएगा।

पाइप <9.0 उपयोग के लिए

pip install pylibmc==blork

जहां blork कोई स्ट्रिंग हो सकती है जो इंस्टॉल उम्मीदवार होने की संभावना नहीं है।





pip