python_packageversion

#!/usr/bin/python3
import sys
import subprocess
import argparse
import os.path

def create_proc(cmd):
    proc = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
    out, err = proc.communicate()
    out, err = str(out.decode("utf-8")), str(err.decode("utf-8"))
    exit_code = proc.returncode
    return {"out": out, "err": err, "exit_code": exit_code}

class PkgManager:
    def __init__(self):
        self.manager = ""
        self.variants = {
            "dpkg": "dpkg --help",
            "rpm":  "rpm --help",
            "pacman": "pacman --help"
        }
        self._define()
    @staticmethod
    def print_package(package):
        spaces = 5
        print("Package:" + " "*(len(package["name"])+spaces-len("Package:")) + "Version:")
        print(package["name"]+" "*spaces+package["version"])

    @staticmethod
    def print_packages(packages):
        spaces = 5
        maxlen_name = max(len(x['name']) for x in packages)
        maxlen_formatted_name = 0
        end_strings = []
        for package in packages:
            st = package["name"]
            st += " "*(maxlen_name-len(package["name"])+spaces)
            if len(st) > maxlen_formatted_name:
                maxlen_formatted_name = len(st)
            st += package["version"]
            end_strings.append(st)
        print("Package:" + " "*(maxlen_formatted_name-len("Package:")) + "Version:")
        for st in end_strings:
            print(st)

    def _define(self):
        for manager, test_cmd in self.variants.items():
            proc = create_proc(test_cmd)
            exit_code = proc["exit_code"]
            if exit_code == 0:
                self.manager = manager

    def find(self, requested_pkg, find_all=False):
        package = ""
        packages = []
        if self.manager == "dpkg":
            package = self._find_dpkg(requested_pkg)
            packages = self._findall_dpkg(requested_pkg)
        elif self.manager == "rpm":
            package = self._find_rpm(requested_pkg)
            packages = self._findall_rpm(requested_pkg)
        elif self.manager == "pacman":
            package = self._find_pacman(requested_pkg)
            packages = self._findall_pacman(requested_pkg)
        if package and not find_all:
            self.print_package(package)
            return True
        if not package and not find_all:
            if packages:
                print("Package {} not found with {}, but "
                      "were found next packages:\n".format(requested_pkg, self.manager))
                self.print_packages(packages)
                return True
        if packages and find_all:
            self.print_packages(packages)
            return True
        print("Package( -s) not found with {}".format(self.manager))
        return False

    def _find_dpkg(self, package):
        package = {"name": package, "version":""}
        cmd = "dpkg-query --showformat='${{Version}}' --show {}".format(package["name"])
        proc = create_proc(cmd)
        if proc["exit_code"] != 0:
            #print("Package doesn't exists. dpkg return: {}".format(proc["err"]))
            return {}
        package["version"] = proc["out"]
        return package

    def _findall_dpkg(self, package):
        packages = []
        cmd = "dpkg -l | awk '{print $2" + ' " " ' + "$3}" + "' | grep '^{}'".format(package)
        proc = create_proc(cmd)
        if proc["exit_code"] != 0:
            #print("Packages doesn't exists. dpkg return: {}".format(proc["err"]))
            return {}
        packages_src = proc["out"].split("\n")
        packages_src = [x for x in packages_src if x]
        for package in packages_src:
            package = package.split(" ")
            packages.append({"name": package[0], "version": package[1]})
        return packages

    def _find_rpm(self, package):
        package = {"name": package, "version":""}
        cmd = "rpm -q --queryformat %{{VERSION}} {}".format(package["name"])
        proc = create_proc(cmd)
        if proc["exit_code"] != 0:
            #print("Package doesn't exists. rpm return: {}".format(proc["out"]))
            return {}
        package["version"] = proc["out"]
        return package

    def _findall_rpm(self, package):
        packages = []
        cmd = 'rpm -qa --qf "%{NAME} %{VERSION}\n" |' + "grep '^{}'".format(package)
        proc = create_proc(cmd)
        if proc["exit_code"] != 0:
            return {}
        packages_src = proc["out"].split("\n")
        packages_src = [x for x in packages_src if x]
        for package in packages_src:
            package = package.split(" ")
            packages.append({"name": package[0], "version": package[1]})
        return packages


    def _find_pacman(self, package):
        package = {"name": package, "version":""}
        pass

    def _findall_pacman(self, package):
        pass

class FileSearch:
    def __init__(self):
        self.search_paths = ["/bin/", "/usr/bin", "/sbin", "/usr/local/bin"]

    def _find_bins(self, package):
        bin_files = []
        for path in self.search_paths:
           files = os.listdir(path)
           for f in sorted(files):
               if f.startswith(package):
                   bin_files.append(os.path.join(path, f))
        return bin_files

    def try_get_version(self, path_to_bin):
        versions = ["--version", "-v"]
        for version in versions:
            cmd = path_to_bin + " " + version
            proc = create_proc(cmd)
            if proc["exit_code"] == 0:
                return proc["out"]
            else:
                return ""

    def find(self, package):
        bin_files = self._find_bins(package)
        for bin_file in bin_files:
            ver = self.try_get_version(bin_file)
            if ver:
                print(ver)
                return True
        print("Package not found with file search")
        return False

if __name__ == "__main__":
   pkg_manager = PkgManager()
   #pkg_manager.find(sys.argv[1])
   parser = argparse.ArgumentParser(description="Get version of software")
   parser.add_argument('-a','--all', action='store_true')
   parser.add_argument('package')
   args = parser.parse_args()
   if not args.package:
       print("No arguments")
       sys.exit(0)
   if args.all:
       status = pkg_manager.find(args.package, find_all=True)
   else:
       status = pkg_manager.find(args.package)

   if not status:
       fs = FileSearch()
       fs.find(args.package)