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

445

पायथन पैकेज के नाम को देखते हुए, जिसे पाइप के साथ स्थापित किया जा सकता है , क्या इसके बारे में सभी संभावित संस्करणों की सूची का पता लगाने का कोई तरीका है जो पाइप स्थापित कर सकता है? अभी यह ट्रायल और एरर है।

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

python  pip 
— रोरी
स्रोत
1
स्वीकृत उत्तर स्क्रिप्ट के साथ अन्य के बराबर नहीं है क्योंकि वे समान आउटपुट उत्पन्न नहीं करते हैं।
— ओलिगोफ़्रेन
17
कृपया चयनित उत्तर को अपडेट करें। जर्दी टूटी हुई और अनावश्यक है। के साथ जवाब pip install pylibmc==एकदम सही है।
— जोनाथन
कृपया स्वीकार किए गए उत्तर को अपडेट करें क्योंकि @ जोनाथन सुझाव देता है। मैं इसे सही नहीं कहूंगा क्योंकि यह पाइप (v7 या v8) के पुराने संस्करणों पर काम नहीं करेगा, लेकिन अन्यथा बहुत अच्छा है।
— एंटनी हैचकिंस
1
@ कृपया स्वीकृत उत्तर को अपडेट करें, जर्दी मृत है। क्रिस मोंट्रो का जवाब वर्तमान में आईएमओ का सबसे अच्छा तरीका है।
— रयान फिशर
1
@ रोरी कृपया भविष्य के आगंतुकों के लाभ के लिए स्वीकृत उत्तर को इस लोकप्रिय प्रश्न में बदलें। योक प्रोजेक्ट अब बनाए नहीं रखा गया है और यह बस उस जवाब के दावों के अनुसार काम नहीं करता है।
— विम

जवाबों:

167

(अपडेट: मार्च 2020 तक, कई लोगों ने बताया है कि जर्दी, के माध्यम से स्थापित है pip install yolk3k, केवल नवीनतम संस्करण लौटाता है। क्रिस का जवाब मेरे लिए सबसे अधिक उत्थान और काम किया गया लगता है)

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

एक बेहतर चौतरफा समाधान yolk3k का उपयोग करना होगा , जो कि पाइप के साथ स्थापित करने के लिए उपलब्ध है। उदाहरण के लिए Django के कौन से संस्करण उपलब्ध हैं:

$ pip install yolk3k
$ 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

yolk3k2012yolk में विकास को बंद करने वाले मूल का कांटा है । हालाँकि अब इसे बनाए नहीं रखा गया है (जैसा कि नीचे टिप्पणी में इंगित किया गया है), प्रतीत होता है और पायथन 3 का समर्थन करता है।yolkyolk3k

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

— m000
स्रोत
4
नीचे दिए गए उत्तर (पास्टिबिन से स्क्रिप्ट का उपयोग करके) अधिक बोझिल है, लेकिन कम से कम मेरे मामले में काम करता है (डरावना के संस्करणों की खोज)। जर्दी केवल अंतिम संस्करण उपलब्ध होने को दर्शाता है, दूसरी स्क्रिप्ट सभी संस्करणों को वापस 0.8.0 पर दिखाती है।
— ओलिगोफ़्रेन
30
अधिकांश समय यह केवल सबसे नया संस्करण
— लौटेगा
17
प्राथमिकी python3 बस पाइप स्थापित करें yolk3k का उपयोग करें। जर्दी कमांड उपलब्ध होगी।
— पियरे क्रियुलेससी
8
जर्दी की तरह, अधिकांश समय yolk3k केवल नवीनतम संस्करण लौटाते हैं।
— diabloneo
4
जर्दी टूट गई है / अब कायम नहीं है। इस उत्तर को हटा दें।
— wim
836

पाइप के लिए = = 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कोई भी स्ट्रिंग हो सकती है जो एक मान्य संस्करण संख्या नहीं है ।

— क्रिस मोंट्रो
स्रोत
25
मुझे यह अजीब लगता है कि पाइप की त्रुटि सभी संस्करणों से बाहर निकलती है लेकिन उनके पास स्पष्ट रूप से उक्त डेटा प्राप्त करने के लिए कोई तर्क नहीं है
— क्रिस मोंट्रो
2
इस समाधान की एक और अच्छी संपत्ति यह है कि यह अधिष्ठापन स्रोतों को सीमित करने के लिए सभी सामान्य झंडे के साथ काम करता है। उदाहरण के लिए pip install --only-binary :all: pylibmcबाइनरी पैकेज के रूप में उपलब्ध pylibmc के सभी संस्करणों को सूचीबद्ध करेगा।
— पावन
3
pip install pylibmc==9999999 | tr ', ' "\n" | sort -n
— विकास
18
इसे सही उत्तर के रूप में चिह्नित किया जाना चाहिए क्योंकि इसे स्थापित करने के लिए किसी अन्य पैकेज की आवश्यकता नहीं है।
— यवेस डोरफ्समैन
5
यह थोड़ा हास्यास्पद है कि यह पाइप में ऐसा करने का एकमात्र तरीका है। मुझे उम्मीद है कि उनके बग ट्रैकर पर इस बारे में कम से कम एक खुला मुद्दा है?
— PMOS
69

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

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

root@node7:~# 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

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

root@node7:~# 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

या 

root@node7:~# cd $(mktemp -d)
root@node7:/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 के साथ परीक्षण किया गया

root@node7:~# pip --version
pip 1.0 from /usr/lib/python2.7/dist-packages (python 2.7)
— HVNSweeting
स्रोत
9
pip 1.5.4DEPRECATION: --no-install, --no-download, --build, and --no-clean are deprecated. See https://github.com/pypa/pip/issues/906.पहले से इंस्टॉल किए गए पैकेज के लिए उपलब्ध संस्करण नहीं देता और दिखाता है।
— int_ua
2
सभी संस्करणों को दिखाने के लिए, बस जरूरत है -v। मेरा बाकी जवाब इसके अतिरिक्त प्रभाव (इंस्टॉल / डाउनलोड) से बचने के लिए है। स्थापित pkg के लिए, बस --upgrad जोड़ें। Anw, आप सब कुछ सरल बनाने के लिए एक अलग virtualenv बना सकते हैं।
— एचवीएनएस ट्विट
2
पाइप 9.0.1 छाल:no such option: --no-install
— थका हुआ_फिट_परिटर्स
"संस्करणों के नवीनतम:" -v कुछ संस्करणों को शामिल नहीं करता है।
— mmacvicar
55

यह जानकारी प्राप्त करने के लिए आपको तीसरे पक्ष के पैकेज की आवश्यकता नहीं है। pypi सभी पैकेजों के लिए सरल 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
— एरिक चियांग
स्रोत
2
JSON के पास उचित मात्रा में नेस्टिंग है। मैं versions = [x for x in data["releases"] if any([y["python_version"] in ['cp26', '2.6'] for y in data["releases"][x]])]पायथन 2.6 के साथ संगत संस्करणों का उपयोग करता था। (मैंने cp26कहीं भी नहीं देखा , लेकिन कुछ पैकेजों में cp27ऐसा था कि मैं अनुमान लगाता हूं कि यह अन्य पैकेजों में मौजूद हो सकता है।)
— ट्रिपल
2
यहाँ कर्ल, jq, और सॉर्ट (एक "एक लाइनर"!) के साथ करने का एक तरीका है: curl -s https://pypi.python.org/pypi/{PKG_NAME}/json | jq -r '.releases | keys[]' | sort -t. -k 1,1n -k 2,2n -k 3,3n
— एलन Ivey
1
यह ValueErrorकुछ पैकेजों के लिए एक अपवाद फेंकता है जो इतनी सख्त संस्करण योजनाओं का पालन नहीं करते हैं। इन पैकेजों के लिए इसे ठीक करने के लिए, यह देखें ।
— ट्रिनिट्रॉनएक्स
पुराना आपके लिए ऐसा करेगा।
— shadi
18

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

#!/bin/bash
set -e

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

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

अद्यतन: संस्करण संख्या के अनुसार छँटाई जोड़ें।

— टिमोफी स्टोलबोव
स्रोत
मैं curlकाम करने में असमर्थ था , संभवतः प्रमाणपत्र त्रुटियों के कारण। wget --no-check-certificateकाम करता है, लेकिन यहां तक ​​कि curl -k --insecureकुछ भी नहीं पैदा करता है। मुझे जो चेतावनी मिलती है वह wgetकहती हैERROR: certificate common name `www.python.org´ doesn´t match requested host name `pypi.python.org´.
— त्रिपली
sort -Vकी homebrew के संस्करण के साथ पर OSX काम नहीं करता हैjq
— deepelement
16

आप जर्दी के बजाय yolk3k पैकेज दे सकते हैं। yolk3k मूल जर्दी से एक कांटा है और यह python2 और 3 दोनों का समर्थन करता है।

https://github.com/myint/yolk

pip install yolk3k
— ykyuen
स्रोत
यह जानना आसान था, क्योंकि जर्दी अजगर 3.x के तहत काम नहीं करता है
— टूटा हुआ मैन
1
yolk3k मेरे लिए केवल स्थापित संस्करण लौटाता है:yolk -V attest Attest 0.5.3
— एंटनी हैचकिंस
2
yolk3k केवल नवीनतम संस्करण वापस करने के लिए लगता है?
— mvherweg
16

कुछ समय के लिए पाइप के कोड को देखने के बाद, ऐसा लगता है कि कोड खोजने के लिए जिम्मेदार कोड PackageFinderकक्षा में पाया जा सकता है pip.index। इसकी विधि find_requirementएक के संस्करणों को देखती है InstallRequirement, लेकिन दुर्भाग्य से केवल सबसे हाल के संस्करण को ही लौटाती है।

नीचे दिया गया कोड मूल फ़ंक्शन की लगभग 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]
— रीनर गेरेके
स्रोत
इसने ऊपर दिए गए उत्तर की तुलना में पूरी तरह से बेहतर काम किया। स्किनी $ योक -वी स्कैपी स्किपी 0.12.0 स्किनी $ पीथॉन टेस्टोस्टेरोन स्किपी स्केपी के संस्करण 0.12.0 0.12.0 0.11.0 0.11.0 0.10.1 0.10.1 0.10.0 0.10.0 0.9.0 0.9.0 0.8.0
— ओलिगोफ़्रेन
1
यह उपयोग डॉक्स में स्पष्ट रूप से हतोत्साहित करता है : " आपको इस तरह से पाइप के आंतरिक एपीआई का उपयोग नहीं करना चाहिए "
— wim
9

आप JSON एपीआई का उपयोग करके PyPI से पैकेज के लिए उपलब्ध संस्करणों की सूची को हथियाने और उन्हें रिवर्स कालानुक्रमिक क्रम में प्रिंट करने के लिए इस छोटे पायथन 3 स्क्रिप्ट (केवल मानक पुस्तकालय मॉड्यूल का उपयोग करके) का उपयोग कर सकते हैं । यहां पोस्ट किए गए कुछ अन्य पायथन समाधानों के विपरीत, यह django's ' 2.2rc1या uwsgi's जैसे ढीले संस्करणों पर नहीं टूटता है 2.0.17.1:

#!/usr/bin/env python3

import json
import sys
from urllib import request    
from pkg_resources import parse_version    

def versions(pkg_name):
    url = f'https://pypi.python.org/pypi/{pkg_name}/json'
    releases = json.loads(request.urlopen(url).read())['releases']
    return sorted(releases, key=parse_version, reverse=True)    

if __name__ == '__main__':
    print(*versions(sys.argv[1]), sep='\n')

स्क्रिप्ट को सहेजें और तर्क के रूप में पैकेज नाम के साथ चलाएं, जैसे:

python versions.py django
3.0a1
2.2.5
2.2.4
2.2.3
2.2.2
2.2.1
2.2
2.2rc1
...
— यूजीन यमश
स्रोत
7

यह मेरे लिए OSX पर काम करता है:

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कि संस्करणों को पार्स करने के लिए (OSX पर) इंस्टॉल करना होगा। आप इसे स्थापित कर सकते हैंbrew install coreutils

— दादी
स्रोत
जीजा आपने भी यह जवाब क्यों पोस्ट किया। @ क्रिस मॉन्टारो का जवाब काम करता है और सुरुचिपूर्ण है। यह सिर्फ अनावश्यक रूप से जटिलता का परिचय देता है
— ब्रायन लीच
@BrianLeach smh ... एक ही दृष्टिकोण एक स्क्रिप्ट में उपयोग के लिए फ़िल्टर्ड ...
— दादी
1
मेरे लिए cygwin / bash में काम करता है, दूसरे solution use के लिए, cygwin में gsort नहीं।
— वेबकॉम
यहाँ अजगर यकीनन बैश की तुलना में अधिक पठनीय कोड देता है ... देखें @eric चियांग का जवाब (उम्मीद से ऊपर :) :)
— mirekphd
4

मेरे प्रोजेक्ट ludditeमें यह सुविधा है।

उदाहरण उपयोग:

>>> import luddite
>>> luddite.get_versions_pypi("python-dateutil")
('0.1', '0.3', '0.4', '0.5', '1.0', '1.1', '1.2', '1.4', '1.4.1', '1.5', '2.0', '2.1', '2.2', '2.3', '2.4.0', '2.4.1', '2.4.2', '2.5.0', '2.5.1', '2.5.2', '2.5.3', '2.6.0', '2.6.1', '2.7.0', '2.7.1', '2.7.2', '2.7.3', '2.7.4', '2.7.5', '2.8.0')

यह उपलब्ध पैकेज के सभी संस्करणों को सूचीबद्ध करता है, https://pypi.org/ के json API को क्वेरी करके।

— विम
स्रोत
यह अधिक शिक्षाप्रद होगा यदि आप हमें बताएंगे कि आपका पैकेज क्या कर रहा है, अन्यथा आप सिर्फ अपने सॉफ़्टवेयर का प्रचार कर रहे हैं :)
— user228395
@ user228395 मुझे लगा कि यह स्पष्ट रूप से पर्याप्त है, लेकिन यह उपलब्ध होने वाले पैकेज के सभी संस्करणों को सूचीबद्ध करता है, जो कि वास्तव में सवाल के शीर्षक के बारे में क्या पूछता है। संपादित - बेहतर?
— विम
इसका कामकाज बेशक। तो यह अनिवार्य रूप से @Timofey Stolbov द्वारा प्रस्तुत समाधान लपेट रहा है?
— 2222 बजे user228395
1
@ user228395 मैं इसे "रैपिंग" नहीं कहूंगा, क्योंकि यह उत्तर बैश, कर्ल और जॉक का उपयोग करता है - जबकि लुडाइट सिर्फ पायथन मानक पुस्तकालय (यूरीलिब) का उपयोग करता है। लेकिन Stolbov से समाधान pypi.org पर उसी समापन बिंदु का उपयोग करता है । क्या मैं पूछ सकता हूं कि आपके पतन का कारण क्या है?
— विम
1
यदि आपने प्रोजेक्ट डिटेल पेज के लिंक का अनुसरण किया है, तो आप देख सकते हैं कि प्रोजेक्ट की मुख्य विशेषता requirements.txtआउट-ऑफ-डेट पैकेजों के लिए फ़ाइलों की जाँच करने के बारे में है । यह कोड की कुछ पंक्तियों से अधिक है। किसी requirements.txtफ़ाइल की जांच करने के लिए , आपको सभी पैकेज संस्करणों को सूचीबद्ध करने के लिए कार्यक्षमता की आवश्यकता होती है। यह हिस्सा जानबूझकर डिकोड किया गया है, और लुडाइट के सार्वजनिक एपीआई का हिस्सा है। और यह स्रोत अपाचे लाइसेंस 2.0 है, मुझे लगता है कि "ब्लैक-बॉक्स" सॉफ़्टवेयर पैकेज को कॉल करना वास्तव में उचित नहीं है।
— wim
2

मेरे पास कोई भाग्य नहीं था 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
...
— एंड्रयू मैगी
स्रोत
1
StrictVersionकई पैकेज के लिए काम नहीं करेगा ( django, uwsgi, psycopg2कुछ नाम हैं)। आप ( उदाहरण के लिए मेरा उत्तर देखें) parse_version()से उपयोग कर सकते हैं । setuptools
— यूजीन यर्मश
1

वैकल्पिक समाधान वेयरहाउस APIs का उपयोग करना है:

https://warehouse.readthedocs.io/api-reference/json/#release

उदाहरण के लिए फ्लास्क:

import requests
r = requests.get("https://pypi.org/pypi/Flask/json")
print(r.json()['releases'].keys())

प्रिंट होगा:

dict_keys(['0.1', '0.10', '0.10.1', '0.11', '0.11.1', '0.12', '0.12.1', '0.12.2', '0.12.3', '0.12.4', '0.2', '0.3', '0.3.1', '0.4', '0.5', '0.5.1', '0.5.2', '0.6', '0.6.1', '0.7', '0.7.1', '0.7.2', '0.8', '0.8.1', '0.9', '1.0', '1.0.1', '1.0.2'])
— चार्ली
स्रोत
0

सरल bashस्क्रिप्ट जो केवल pythonखुद पर निर्भर करती है (मैं मानती हूं कि प्रश्न के संदर्भ में इसे स्थापित किया जाना चाहिए) curlया एक wget। यह एक धारणा है कि आपके पास setuptoolsसंस्करणों को सॉर्ट करने के लिए स्थापित है (लगभग हमेशा स्थापित)। यह बाहरी निर्भरता पर निर्भर नहीं करता है जैसे:

  • jq जो मौजूद नहीं हो सकता है;
  • grepऔर awkयह लिनक्स और macOS पर अलग तरह से व्यवहार कर सकता है।
curl --silent --location https://pypi.org/pypi/requests/json | python -c "import sys, json, pkg_resources; releases = json.load(sys.stdin)['releases']; print(' '.join(sorted(releases, key=pkg_resources.parse_version)))"

टिप्पणियों के साथ थोड़ा लंबा संस्करण।

एक चर में पैकेज का नाम रखें:

PACKAGE=requests

संस्करण प्राप्त करें (उपयोग करते हुए curl):

VERSIONS=$(curl --silent --location https://pypi.org/pypi/$PACKAGE/json | python -c "import sys, json, pkg_resources; releases = json.load(sys.stdin)['releases']; print(' '.join(sorted(releases, key=pkg_resources.parse_version)))")

संस्करण प्राप्त करें (उपयोग करते हुए wget):

VERSIONS=$(wget -qO- https://pypi.org/pypi/$PACKAGE/json | python -c "import sys, json, pkg_resources; releases = json.load(sys.stdin)['releases']; print(' '.join(sorted(releases, key=pkg_resources.parse_version)))")

प्रिंट किए गए संस्करण:

echo $VERSIONS
— एंड्री सेमकिन
स्रोत
-1

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

यह विचार एक पूरी तरह से नई कमांड प्रदान करने के लिए है (इंस्टॉल कमांड के बाद मॉडलिंग) जो आपको उपयोग करने के लिए पैकेज खोजक का एक उदाहरण देता है। उल्टा यह है कि यह किसी भी इंडेक्स के साथ काम करता है और उपयोग करता है, जो पाइप आपके स्थानीय पाइप कॉन्फ़िगरेशन फ़ाइलों का समर्थन करता है और पढ़ता है, इसलिए आपको सामान्य पाइप इंस्टॉल के साथ ही सही परिणाम मिलते हैं।

मैंने इसे पाइप वी 9.x और 10.x दोनों के साथ संगत बनाने का प्रयास किया है .. लेकिन इसे केवल 9.x पर आज़माया है

https://gist.github.com/kaos/68511bd013fcdebe766c981f50b473d4

#!/usr/bin/env python
# When you want a easy way to get at all (or the latest) version of a certain python package from a PyPi index.

import sys
import logging

try:
    from pip._internal import cmdoptions, main
    from pip._internal.commands import commands_dict
    from pip._internal.basecommand import RequirementCommand
except ImportError:
    from pip import cmdoptions, main
    from pip.commands import commands_dict
    from pip.basecommand import RequirementCommand

from pip._vendor.packaging.version import parse as parse_version

logger = logging.getLogger('pip')

class ListPkgVersionsCommand(RequirementCommand):
    """
    List all available versions for a given package from:

    - PyPI (and other indexes) using requirement specifiers.
    - VCS project urls.
    - Local project directories.
    - Local or remote source archives.

    """
    name = "list-pkg-versions"
    usage = """
      %prog [options] <requirement specifier> [package-index-options] ...
      %prog [options] [-e] <vcs project url> ...
      %prog [options] [-e] <local project path> ...
      %prog [options] <archive url/path> ..."""

    summary = 'List package versions.'

    def __init__(self, *args, **kw):
        super(ListPkgVersionsCommand, self).__init__(*args, **kw)

        cmd_opts = self.cmd_opts

        cmd_opts.add_option(cmdoptions.install_options())
        cmd_opts.add_option(cmdoptions.global_options())
        cmd_opts.add_option(cmdoptions.use_wheel())
        cmd_opts.add_option(cmdoptions.no_use_wheel())
        cmd_opts.add_option(cmdoptions.no_binary())
        cmd_opts.add_option(cmdoptions.only_binary())
        cmd_opts.add_option(cmdoptions.pre())
        cmd_opts.add_option(cmdoptions.require_hashes())

        index_opts = cmdoptions.make_option_group(
            cmdoptions.index_group,
            self.parser,
        )

        self.parser.insert_option_group(0, index_opts)
        self.parser.insert_option_group(0, cmd_opts)

    def run(self, options, args):
        cmdoptions.resolve_wheel_no_use_binary(options)
        cmdoptions.check_install_build_global(options)

        with self._build_session(options) as session:
            finder = self._build_package_finder(options, session)

            # do what you please with the finder object here... ;)
            for pkg in args:
                logger.info(
                    '%s: %s', pkg,
                    ', '.join(
                        sorted(
                            set(str(c.version) for c in finder.find_all_candidates(pkg)),
                            key=parse_version,
                        )
                    )
                )


commands_dict[ListPkgVersionsCommand.name] = ListPkgVersionsCommand

if __name__ == '__main__':
    sys.exit(main())

उदाहरण आउटपुट

./list-pkg-versions.py list-pkg-versions pika django
pika: 0.5, 0.5.1, 0.5.2, 0.9.1a0, 0.9.2a0, 0.9.3, 0.9.4, 0.9.5, 0.9.6, 0.9.7, 0.9.8, 0.9.9, 0.9.10, 0.9.11, 0.9.12, 0.9.13, 0.9.14, 0.10.0b1, 0.10.0b2, 0.10.0, 0.11.0b1, 0.11.0, 0.11.1, 0.11.2, 0.12.0b2
django: 1.1.3, 1.1.4, 1.2, 1.2.1, 1.2.2, 1.2.3, 1.2.4, 1.2.5, 1.2.6, 1.2.7, 1.3, 1.3.1, 1.3.2, 1.3.3, 1.3.4, 1.3.5, 1.3.6, 1.3.7, 1.4, 1.4.1, 1.4.2, 1.4.3, 1.4.4, 1.4.5, 1.4.6, 1.4.7, 1.4.8, 1.4.9, 1.4.10, 1.4.11, 1.4.12, 1.4.13, 1.4.14, 1.4.15, 1.4.16, 1.4.17, 1.4.18, 1.4.19, 1.4.20, 1.4.21, 1.4.22, 1.5, 1.5.1, 1.5.2, 1.5.3, 1.5.4, 1.5.5, 1.5.6, 1.5.7, 1.5.8, 1.5.9, 1.5.10, 1.5.11, 1.5.12, 1.6, 1.6.1, 1.6.2, 1.6.3, 1.6.4, 1.6.5, 1.6.6, 1.6.7, 1.6.8, 1.6.9, 1.6.10, 1.6.11, 1.7, 1.7.1, 1.7.2, 1.7.3, 1.7.4, 1.7.5, 1.7.6, 1.7.7, 1.7.8, 1.7.9, 1.7.10, 1.7.11, 1.8a1, 1.8b1, 1.8b2, 1.8rc1, 1.8, 1.8.1, 1.8.2, 1.8.3, 1.8.4, 1.8.5, 1.8.6, 1.8.7, 1.8.8, 1.8.9, 1.8.10, 1.8.11, 1.8.12, 1.8.13, 1.8.14, 1.8.15, 1.8.16, 1.8.17, 1.8.18, 1.8.19, 1.9a1, 1.9b1, 1.9rc1, 1.9rc2, 1.9, 1.9.1, 1.9.2, 1.9.3, 1.9.4, 1.9.5, 1.9.6, 1.9.7, 1.9.8, 1.9.9, 1.9.10, 1.9.11, 1.9.12, 1.9.13, 1.10a1, 1.10b1, 1.10rc1, 1.10, 1.10.1, 1.10.2, 1.10.3, 1.10.4, 1.10.5, 1.10.6, 1.10.7, 1.10.8, 1.11a1, 1.11b1, 1.11rc1, 1.11, 1.11.1, 1.11.2, 1.11.3, 1.11.4, 1.11.5, 1.11.6, 1.11.7, 1.11.8, 1.11.9, 1.11.10, 1.11.11, 1.11.12, 2.0, 2.0.1, 2.0.2, 2.0.3, 2.0.4
— इंग्लैंड Repack
स्रोत
इस प्रयोग को स्पष्ट रूप में हतोत्साहित किया जाता है डॉक्स : " आप इस तरह से पिप के आंतरिक API का उपयोग नहीं करना चाहिए "
— विम
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.