Comment vérifiez-vous si un package est à sa dernière version par programmation dans un script et retournez un vrai ou un faux?

Je peux vérifier avec un script comme celui-ci:

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'])

ou avec la ligne de commande:

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

Mais comment puis-je vérifier par programme et retourner vrai ou faux?

Version rapide (vérification de l'emballage uniquement)

Le code ci-dessous appelle le package avec une version non disponible comme pip install package_name==random. L'appel renvoie toutes les versions disponibles. Le programme lit la dernière version.

Le programme s'exécute ensuite pip show package_nameet obtient la version actuelle du package.

S'il trouve une correspondance, il renvoie True, sinon False.

Il s'agit d'une option fiable étant donné qu'elle repose sur pip

import subprocess
import sys
def check(name):
    latest_version = str(subprocess.run([sys.executable, '-m', 'pip', 'install', '{}==random'.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

Le code suivant appelle 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

Mon projet johnnydepa cette fonctionnalité.

En coquille:

pip install --upgrade pip johnnydep
pip install gekko==0.2.0

En Python:

>>> from johnnydep.lib import JohnnyDist
>>> dist = JohnnyDist("gekko")
>>> dist.version_installed  
'0.2.0'
>>> dist.version_latest 
'0.2.3'

Modifier: Supprimer la recherche pip

Merci pour les nombreuses suggestions. Voici une nouvelle version qui n'utilise pas pip searchmais tire à la place la dernière version directement pypicomme proposé par Daniel Hill . Cela résout également le problème avec les fausses correspondances de la sous-chaîne.

def check(name):
    import subprocess
    import sys
    import json
    import urllib.request

    # create dictionary of package versions
    pkgs = subprocess.check_output([sys.executable, '-m', 'pip', 'freeze'])
    keys = [p.decode().split('==')[0] for p in pkgs.split()]
    values = [p.decode().split('==')[1] for p in pkgs.split()]
    d = dict(zip(keys, values)) # dictionary of all package versions

    # retrieve info on latest version
    contents = urllib.request.urlopen('https://pypi.org/pypi/'+name+'/json').read()
    data = json.loads(contents)
    latest_version = data['info']['version']

    if d[name]==latest_version:
        print('Latest version (' + d[name] + ') of '+str(name)+' is installed')
        return True
    else:
        print('Version ' + d[name] + ' of '+str(name)+' not the latest '+latest_version)
        return False

print(check('gekko'))

Réponse originale

Voici une solution rapide qui récupère les informations de dernière version uniquement sur le gekkopackage qui vous intéresse.

def check(name):
    import subprocess
    import sys
    # create dictionary of package versions
    pkgs = subprocess.check_output([sys.executable, '-m', 'pip', 'freeze'])
    keys = [p.decode().split('==')[0] for p in pkgs.split()]
    values = [p.decode().split('==')[1] for p in pkgs.split()]
    d = dict(zip(keys, values)) # dictionary of all package versions

    # retrieve info on latest version
    s = subprocess.check_output([sys.executable, '-m', 'pip', 'search', name])

    if d[name] in s.decode():  # weakness
        print('Latest version (' + d[name] + ') of '+str(name)+' is installed')
        return True
    else:
        print(s.decode())
        return False

print(check('gekko'))

Cela produit le message Latest version (0.2.3) of gekko is installedet retourne Truepour indiquer la dernière version (ou Falsesinon la dernière version). Ce n'est peut-être pas la meilleure solution car il ne vérifie qu'une sous-chaîne de version if d[name] in s.decode():mais il est plus rapide que pip list --outdatedcela vérifie tous les packages. Ce n'est pas la méthode la plus fiable car elle retournera une erreur Truesi la version installée actuelle est 0.2.3mais la dernière version est 0.2.30ou 0.2.3a. Une amélioration serait d'obtenir par programmation la dernière version et de faire une comparaison directe.

Dernière version:

Mon projet ludditea cette fonctionnalité:

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

Version installée:

La manière canonique de vérifier la version installée consiste simplement à accéder à l' __version__attribut de l'espace de noms de niveau supérieur:

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

Malheureusement, tous les projets ne définissent pas cet attribut. Dans le cas contraire, vous pouvez les utiliser pkg_resourcespour les extraire des métadonnées:

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

Cela devrait faire l'affaire au moins à des fins de démonstration. Appelez simplement isLatestVersionavec le nom du colis que vous souhaitez vérifier. Si vous utilisez ceci dans un endroit important, vous voudrez essayer / intercepter la demande d'URL car l'accès Internet peut ne pas être disponible. Notez également que si le package n'est pas installé isLatestVersion, False sera renvoyé.

Ceci est testé pour Python 3.7.4 et 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

Il n'est pas difficile d'écrire un script simple vous-même en interrogeant l'API PyPI . Avec la dernière version de Python 3.8, il est possible d'utiliser uniquement la bibliothèque standard (lorsque vous utilisez Python 3.7 ou une version antérieure, vous devrez installer le importlib_metadatabackport):

# 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)

Exemple d'utilisation:

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

S'il vous arrive d'avoir packaginginstallé, c'est une meilleure alternative à l' distutils.versionanalyse de version:

from distutils.version import LooseVersion

...

LooseVersion(s)

devient

from packaging.version import parse

...

parse(s)