Python使用pip工具实现包自动更新的多种方法

# 更新单个包
pip install --upgrade package_name

# 更新所有已安装包
pip freeze | grep -v '^\-e' | cut -d = -f 1 | xargs -n1 pip install -U

import pkg_resources
from subprocess import call
import requests

def get_latest_version(package_name):
    response = requests.get(f'https://pypi.org/pypi/{package_name}/json')
    return response.json()['info']['version']

def auto_update():
    installed_packages = {pkg.key: pkg.version
                         for pkg in pkg_resources.working_set}

    for package, version in installed_packages.items():
        latest_version = get_latest_version(package)
        if latest_version != version:
            call(f'pip install --upgrade {package}', shell=True)
            print(f'Updated {package} from {version} to {latest_version}')

def safe_update():
    # 获取当前requirements
    with open('requirements.txt', 'r') as f:
        requirements = f.readlines()

    updated_requirements = []
    for req in requirements:
        if '==' in req:
            package, version = req.strip().split('==')
            latest = get_latest_version(package)
            if latest.split('.')[0] == version.split('.')[0]:  # 只更新次要和补丁版本
                updated_requirements.append(f'{package}=={latest}\n')
            else:
                updated_requirements.append(req)
        else:
            updated_requirements.append(req)

    with open('requirements.txt', 'w') as f:
        f.writelines(updated_requirements)

# 创建虚拟环境
python -m venv .venv
source .venv/bin/activate  # Linux/Mac
.venv\Scripts\activate     # Windows

# 安装必要工具
pip install pip-tools safety

import subprocess
import pkg_resources
from packaging import version
import requests
import json
from datetime import datetime

class PackageUpdater:
    def __init__(self, requirements_file='requirements.txt'):
        self.requirements_file = requirements_file
        self.log_file = 'update_log.json'
        self.backup_file = f'requirements_backup_{datetime.now().strftime("%Y%m%d")}.txt'

    def get_installed_packages(self):
        return {pkg.key: pkg.version for pkg in pkg_resources.working_set}

    def get_latest_version(self, package_name):
        try:
            response = requests.get(f'https://pypi.org/pypi/{package_name}/json', timeout=5)
            response.raise_for_status()
            return response.json()['info']['version']
        except (requests.RequestException, json.JSONDecodeError):
            return None

    def backup_requirements(self):
        with open(self.requirements_file, 'r') as f:
            content = f.read()
        with open(self.backup_file, 'w') as f:
            f.write(content)

    def log_update(self, package, old_version, new_version, status):
        log_entry = {
            'timestamp': datetime.now().isoformat(),
            'package': package,
            'old_version': old_version,
            'new_version': new_version,
            'status': status
        }

        try:
            with open(self.log_file, 'a') as f:
                json.dump(log_entry, f)
                f.write('\n')
        except IOError:
            pass

    def safe_update_package(self, package, current_version):
        latest_version = self.get_latest_version(package)
        if not latest_version:
            return False

        current = version.parse(current_version)
        latest = version.parse(latest_version)

        # 只更新次要版本和补丁版本
        if current.major == latest.major:
            try:
                subprocess.check_call(
                    ['pip', 'install', '--upgrade', f'{package}=={latest_version}'],
                    stdout=subprocess.DEVNULL,
                    stderr=subprocess.DEVNULL
                )
                self.log_update(package, current_version, latest_version, 'success')
                return True
            except subprocess.CalledProcessError:
                self.log_update(package, current_version, latest_version, 'failed')
                return False
        return False

    def run(self):
        self.backup_requirements()
        installed = self.get_installed_packages()
        results = {
            'updated': [],
            'skipped': [],
            'failed': []
        }

        for package, current_version in installed.items():
            if self.safe_update_package(package, current_version):
                results['updated'].append(package)
            else:
                results['skipped'].append(package)

        return results

if __name__ == '__main__':
    updater = PackageUpdater()
    print("Starting package update process...")
    results = updater.run()
    print(f"Update completed: {len(results['updated'])} updated, "
          f"{len(results['skipped'])} skipped")

# .github/workflows/update-deps.yml
name: Update Dependencies

on:
  schedule:
    - cron: '0 0 * * 1'  # 每周一午夜运行

jobs:
  update:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v2
    - name: Set up Python
      uses: actions/setup-python@v2
    - name: Install dependencies
      run: |
        python -m pip install --upgrade pip
        pip install -r requirements.txt
    - name: Run auto-updater
      run: |
        python scripts/auto_updater.py
    - name: Create Pull Request
      uses: peter-evans/create-pull-request@v3
      with:
        commit-message: "chore: automated dependency updates"
        title: "Weekly Dependency Updates"
        body: "Automated updates of Python dependencies"

def rollback_update(package, version):
    subprocess.check_call(['pip', 'install', f'{package}=={version}'])

pip install safety
safety check --full-report