View difference between Paste ID: FejNsTF6 and cqtH3Bmg

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