Come verificare se il pacchetto python è l'ultima versione a livello di codice?




pip gekko (4)

Versione veloce (controllo solo del pacchetto)

Questo fa il trucco di chiamare il pacchetto con una versione non disponibile come pip install package_name==random e la risposta fornisce tutta la versione disponibile, quindi il programma legge l'ultima.

Quindi esegue pip show package_name e ottiene la versione corrente del pacchetto.

Se trova una corrispondenza, restituisce True, altrimenti False

Questa è un'opzione affidabile dato che si trova su pip

import subprocess
import sys
def check(name):
    latest_version = str(subprocess.run([sys.executable, '-m', 'pip', 'install', '{}==0'.format(name)], capture_output=True, text=True))
    latest_version = latest_version[latest_version.find('(from versions:')+15:]
    latest_version = latest_version[:latest_version.find(')')]
    latest_version = latest_version.replace(' ','').split(',')[-1]

    current_version = str(subprocess.run([sys.executable, '-m', 'pip', 'show', '{}'.format(name)], capture_output=True, text=True))
    current_version = current_version[current_version.find('Version:')+8:]
    current_version = current_version[:current_version.find('\\n')].replace(' ','') 

    if latest_version == current_version:
        return True
    else:
        return False

Questo richiede l' pip list --outdated

import subprocess
import sys

def check(name):
    reqs = subprocess.check_output([sys.executable, '-m', 'pip', 'list','--outdated'])
    outdated_packages = [r.decode().split('==')[0] for r in reqs.split()]
    return name in outdated_packages

Come si fa a verificare se un pacchetto è programmaticamente alla sua ultima versione in uno script e restituisce un vero o falso?

Posso verificare con uno script come questo:

package='gekko'
import pip
if hasattr(pip, 'main'):
    from pip import main as pipmain
else:
    from pip._internal import main as pipmain
pipmain(['search','gekko'])

o con riga di comando:

(base) C:\User>pip search gekko
gekko (0.2.3)  - Machine learning and optimization for dynamic systems
  INSTALLED: 0.2.3 (latest)

Ma come posso controllare a livello di codice e restituire vero o falso?


Ultima versione:

Il mio progetto luddite ha questa funzione:

>>> import luddite
>>> luddite.get_version_pypi("gekko")
'0.2.3'

Versione installata:

Il modo canonico per controllare la versione installata è solo per accedere all'attributo __version__ dello spazio dei nomi di livello superiore:

>>> import gekko
>>> gekko.__version__
'0.2.0'

Purtroppo non tutti i progetti impostano questo attributo. pkg_resources , puoi usare pkg_resources per estrarlo dai metadati:

>>> import pkg_resources
>>> pkg_resources.get_distribution("gekko").version
'0.2.0'

Non è difficile scrivere un semplice script eseguendo una query sull'API PyPI . Con l'ultimo Python 3.8, è possibile utilizzare solo la libreria standard (quando si utilizza Python 3.7 o precedente, è necessario installare il backport importlib_metadata ):

# check_version.py

import json
import urllib.request
import sys

try:
    from importlib.metadata import version
except ImportError:
    from importlib_metadata import version

from distutils.version import LooseVersion


if __name__ == '__main__':
    name = sys.argv[1]
    installed_version = LooseVersion(version(name))

    # fetch package metadata from PyPI
    pypi_url = f'https://pypi.org/pypi/{name}/json'
    response = urllib.request.urlopen(pypi_url).read().decode()
    latest_version = max(LooseVersion(s) for s in json.loads(response)['releases'].keys())

    print('package:', name, 'installed:', installed_version, 'latest:', latest_version)

Esempio di utilizzo:

$ python check_version.py setuptools
package: setuptools installed: 41.2.0 latest: 41.6.0

Se ti capita di avere un packaging installato, è un'alternativa migliore a distutils.version per l'analisi della versione:

from distutils.version import LooseVersion

...

LooseVersion(s)

diventa

from packaging.version import parse

...

parse(s)

Questo dovrebbe fare il trucco almeno per scopi dimostrativi. Basta chiamare isLatestVersion con il nome del pacchetto che si desidera controllare. Se lo stai usando in un posto importante, dovresti provare a catturare la richiesta url poiché l'accesso a Internet potrebbe non essere disponibile. Si noti inoltre che se il pacchetto non è installato isLatestVersion restituirà False.

Questo è testato per Python 3.7.4 e Pip 19.0.3.

import pip
import subprocess
import json
import urllib.request
from pip._internal.operations.freeze import freeze

def isLatestVersion(pkgName):
    # Get the currently installed version
    current_version = ''
    for requirement in freeze(local_only=False):
        pkg = requirement.split('==')
        if pkg[0] == pkgName:
            current_version = pkg[1]

    # Check pypi for the latest version number
    contents = urllib.request.urlopen('https://pypi.org/pypi/'+pkgName+'/json').read()
    data = json.loads(contents)
    latest_version = data['info']['version']

    return latest_version == current_version






gekko