pip_review.py

# -*- coding: utf-8 -*-

import pip, os

from pip.commands.list import ListCommand
from pip.req import parse_requirements
import re
import argparse

class MyListCommand(ListCommand):
    my_options = None
    my_args = None

    def run(self, options, args):
        self.my_options = options
        self.my_args = args


class Requirement():
    comes_from_reg = re.compile(r"^-r (.*) \(line (\d+)\)$")

    def __init__(self, req):
        self.name = req.name
        self.non_frozen = None
        self.frozen_version = None

        for sign, version in req.req.specs:
            if sign == '==':
                self.frozen_version = version
            else:
                self.non_frozen = req.req.specs

        self.file, self.line_number = self.comes_from_reg.match(req.comes_from).groups()

        self.installed_version = None
        self.latest_version = None


    def __str__(self):
        return "{} {} {} line {}".format(self.name, self.frozen_version or "NonFrozen", self.file, self.line_number)

    def get_review(self):
        versions_info = [
            "{}: in {} line {}".format(self.name, self.file, self.line_number),
        ]

        if self.frozen_version == self.installed_version == self.latest_version:
            versions_info.append("  {} Requirements/Installed/Latest".format(self.frozen_version))
        elif self.frozen_version == self.installed_version:
            versions_info.append("  {} Requirements/Installed".format(self.frozen_version))
            versions_info.append("  {} Latest".format(self.latest_version))
        elif self.frozen_version == self.latest_version:
            versions_info.append("  {} Requirements/Latest".format(self.frozen_version))
            versions_info.append("  {} Installed".format(self.installed_version))
        elif self.installed_version == self.latest_version:
            versions_info.append("  {} Installed/Latest".format(self.installed_version))
            versions_info.append("  {} Requirements".format(self.frozen_version or "NotFrozen"))
        else:
            versions_info.append("  {} Requirements".format(self.frozen_version))
            versions_info.append("  {} Installed".format(self.installed_version))
            versions_info.append("  {} Latest".format(self.latest_version))

        return "\n".join(versions_info)


    def add_dist_infos(self, dist, new_version):
        self.latest_version = new_version
        self.installed_version = dist.version

class Summary:
    implicits_up_to_date = []
    implicits_to_upgrade = []
    requirements_up_to_date = []
    requirements_to_upgrade = []


if __name__ == '__main__':
    parser = argparse.ArgumentParser(description='Review your requirements')
    parser.add_argument('requirement_file', nargs='?', help='the file path')
    parser.set_defaults(requirement_file='requirements.txt')
    args = parser.parse_args()

    a = MyListCommand()
    a.main(["-o"])

    summary = Summary()
    req_list = {}

    for req in parse_requirements(args.requirement_file, session='abc'):
        require = Requirement(req)
        req_list[require.name] = require


    non_requirements = []
    for dist, new_version, parsed_version in a.find_packages_latest_versions(a.my_options):
        req = req_list.get(dist.project_name)
        if req:
            req.add_dist_infos(dist, new_version)
            print req.get_review()
            if new_version == dist._parsed_version:
                summary.requirements_up_to_date.append((dist.project_name, dist._parsed_version, new_version))
            else:
                summary.requirements_to_upgrade.append((dist.project_name, dist._parsed_version, new_version))

        else:
            non_requirements.append(dist.project_name)
            if new_version == dist._parsed_version:
                summary.implicits_up_to_date.append((dist.project_name, dist._parsed_version, new_version))
            else:
                summary.implicits_to_upgrade.append((dist.project_name, dist._parsed_version, new_version))
            print "{} got {} latest {}\n   implicit requirement".format(dist.project_name, dist._parsed_version, new_version)


    print "\n\n\n"
    print "\n--Implicits up to date--"
    for name, installed, latest in summary.implicits_up_to_date:
        print "{} {}".format(name, installed)
    print "\n--Implicits up to upgrade--"
    for name, installed, latest in summary.implicits_to_upgrade:
        print "{} {} -> {}".format(name, installed, latest)
    print "\n--Requirements up to date--"
    for name, installed, latest in summary.requirements_up_to_date:
        print "{} {}".format(name, installed)
    print "\n--Requirements up to upgrade--"
    for name, installed, latest in summary.requirements_to_upgrade:
        print "{} {} -> {}".format(name, installed, latest)