def repo_data(PACKAGES_TXT, repo, flag):
"""Grap data packages
"""
(name, location, size, unsize, rname, rlocation, rsize,
runsize) = ([] for i in range(8))
for line in PACKAGES_TXT.splitlines():
if _meta_.rsl_deps in ["on", "ON"] and "--resolve-off" not in flag:
status(0.000005)
if line.startswith("PACKAGE NAME:"):
name.append(line[15:].strip())
if line.startswith("PACKAGE LOCATION:"):
location.append(line[21:].strip())
if line.startswith("PACKAGE SIZE (compressed):"):
size.append(line[28:-2].strip())
if line.startswith("PACKAGE SIZE (uncompressed):"):
unsize.append(line[30:-2].strip())
if repo == "rlw":
(rname, rlocation, rsize,
runsize) = rlw_filter(name, location, size, unsize)
elif repo == "alien":
(rname, rlocation, rsize,
runsize) = alien_filter(name, location, size, unsize)
elif repo == "rested":
(rname, rlocation, rsize,
runsize) = rested_filter(name, location, size, unsize)
elif repo == "ktown":
(rname, rlocation, rsize,
runsize) = ktown_filter(name, location, size, unsize)
else:
rname, rlocation, rsize, runsize = name, location, size, unsize
return [rname, rlocation, rsize, runsize]
def pkg_upgrade(repo, skip, flag):
"""Checking packages for upgrade
"""
Msg().checking()
PACKAGES_TXT = RepoInit(repo).fetch()[0]
pkgs_for_upgrade = []
# name = data[0]
# location = data[1]
# size = data[2]
# unsize = data[3]
data = repo_data(PACKAGES_TXT, repo, flag="")
for pkg in installed():
status(0.0005)
inst_pkg = split_package(pkg)
for name in data[0]:
if name: # this tips because some pkg_name is empty
repo_pkg = split_package(name[:-4])
if (repo_pkg[0] == inst_pkg[0]
and LooseVersion(repo_pkg[1]) > LooseVersion(inst_pkg[1])
and repo_pkg[3] >= inst_pkg[3] and inst_pkg[0] not in skip
and repo_pkg[1] != "blacklist"):
pkgs_for_upgrade.append(repo_pkg[0])
Msg().done()
if "--checklist" in flag:
pkgs_for_upgrade = choose_upg(pkgs_for_upgrade)
return pkgs_for_upgrade
def sbo(self, name):
"""
Build all dependencies of a package
"""
if self.meta.rsl_deps in ["on", "ON"] and self.flag != "--resolve-off":
try:
sys.setrecursionlimit(10000)
dependencies = []
requires = SBoGrep(name).requires()
if requires:
for req in requires:
status(0.03)
# toolbar_width = status(index, toolbar_width, 1)
# avoid to add %README% as dependency and
# if require in blacklist
if "%README%" not in req and req not in self.blacklist:
dependencies.append(req)
if dependencies:
self.dep_results.append(dependencies)
for dep in dependencies:
self.sbo(dep)
return self.dep_results
except KeyboardInterrupt:
print("") # new line at exit
sys.exit(0)
else:
return []
def pkg_upgrade(repo, skip):
"""
Checking packages for upgrade
"""
try:
Msg().checking()
PACKAGES_TXT = RepoInit(repo).fetch()[0]
pkgs_for_upgrade = []
# name = data[0]
# location = data[1]
# size = data[2]
# unsize = data[3]
data = repo_data(PACKAGES_TXT, repo, flag="")
for pkg in installed():
status(0.0005)
inst_pkg = split_package(pkg)
for name in data[0]:
if name: # this tips because some pkg_name is empty
repo_pkg = split_package(name[:-4])
if (
repo_pkg[0] == inst_pkg[0]
and LooseVersion(repo_pkg[1]) > LooseVersion(inst_pkg[1])
and repo_pkg[3] >= inst_pkg[3]
and inst_pkg[0] not in skip
):
pkgs_for_upgrade.append(repo_pkg[0])
Msg().done()
return pkgs_for_upgrade
except KeyboardInterrupt:
print("") # new line at exit
sys.exit(0)
def pkg_upgrade(repo, skip, flag):
"""
Checking packages for upgrade
"""
Msg().checking()
PACKAGES_TXT = RepoInit(repo).fetch()[0]
pkgs_for_upgrade = []
# name = data[0]
# location = data[1]
# size = data[2]
# unsize = data[3]
data = repo_data(PACKAGES_TXT, repo, flag="")
for pkg in installed():
status(0.0005)
inst_pkg = split_package(pkg)
for name in data[0]:
if name: # this tips because some pkg_name is empty
repo_pkg = split_package(name[:-4])
if (repo_pkg[0] == inst_pkg[0] and
LooseVersion(repo_pkg[1]) > LooseVersion(inst_pkg[1]) and
repo_pkg[3] >= inst_pkg[3] and
inst_pkg[0] not in skip and
repo_pkg[1] != "blacklist"):
pkgs_for_upgrade.append(repo_pkg[0])
Msg().done()
if "--checklist" in flag:
pkgs_for_upgrade = choose_upg(pkgs_for_upgrade)
return pkgs_for_upgrade
def sbo_version_source(self, slackbuilds):
"""Create sbo name with version
"""
sbo_versions, sources = [], []
for sbo in slackbuilds:
status(0.02)
sbo_ver = "{0}-{1}".format(sbo, SBoGrep(sbo).version())
sbo_versions.append(sbo_ver)
sources.append(SBoGrep(sbo).source())
return [sbo_versions, sources]
def sbo_version_source(self, slackbuilds):
"""Create sbo name with version
"""
sbo_versions, sources = [], []
for sbo in slackbuilds:
status(0.02)
sbo_ver = "{0}-{1}".format(sbo, SBoGrep(sbo).version())
sbo_versions.append(sbo_ver)
sources.append(SBoGrep(sbo).source())
return [sbo_versions, sources]
def search_pkg(name, repo):
"""Search if package exists in PACKAGES.TXT file
and return the name.
"""
PACKAGES_TXT = Utils().read_file(_meta_.lib_path + "{0}_repo/"
"PACKAGES.TXT".format(repo))
names = Utils().package_name(PACKAGES_TXT)
blacklist = BlackList().packages(pkgs=names, repo=repo)
for line in PACKAGES_TXT.splitlines():
status(0)
if line.startswith("PACKAGE NAME: ") and len(line) > 16:
pkg_name = split_package(line[15:])[0].strip()
if name == pkg_name and name not in blacklist:
return pkg_name
def search_pkg(name, repo):
"""Search if package exists in PACKAGES.TXT file
and return the name.
"""
PACKAGES_TXT = Utils().read_file(_meta_.lib_path + "{0}_repo/"
"PACKAGES.TXT".format(repo))
names = Utils().package_name(PACKAGES_TXT)
blacklist = BlackList().packages(pkgs=names, repo=repo)
for line in PACKAGES_TXT.splitlines():
status(0)
if line.startswith("PACKAGE NAME: ") and len(line) > 16:
pkg_name = split_package(line[15:])[0].strip()
if name == pkg_name and name not in blacklist:
return pkg_name
def resolving_deps(self):
"""Return package dependencies
"""
requires = []
if (self.meta.rsl_deps in ["on", "ON"] and
self.flag != "--resolve-off"):
self.msg.resolving()
for dep in self.packages:
status(0.05)
dependencies = []
dependencies = Utils().dimensional_list(Dependencies(
self.repo, self.blacklist).binary(dep, self.flag))
requires += self._fix_deps_repos(dependencies)
self.deps_dict[dep] = Utils().remove_dbs(requires)
return Utils().remove_dbs(requires)
def resolving_deps(self):
"""Return package dependencies
"""
requires = []
if (self.meta.rsl_deps in ["on", "ON"] and
self.flag != "--resolve-off"):
self.msg.resolving()
for dep in self.packages:
status(0.05)
dependencies = []
dependencies = Utils().dimensional_list(Dependencies(
self.repo, self.blacklist).binary(dep, self.flag))
requires += self._fix_deps_repos(dependencies)
self.deps_dict[dep] = Utils().remove_dbs(requires)
return Utils().remove_dbs(requires)
def repo_data(PACKAGES_TXT, repo, flag):
"""
Grap data packages
"""
(name, location, size, unsize,
rname, rlocation, rsize, runsize) = ([] for i in range(8))
for line in PACKAGES_TXT.splitlines():
if _meta_.rsl_deps in ["on", "ON"] and "--resolve-off" not in flag:
status(0.000005)
if line.startswith("PACKAGE NAME:"):
name.append(line[15:].strip())
if line.startswith("PACKAGE LOCATION:"):
location.append(line[21:].strip())
if line.startswith("PACKAGE SIZE (compressed):"):
size.append(line[28:-2].strip())
if line.startswith("PACKAGE SIZE (uncompressed):"):
unsize.append(line[30:-2].strip())
if repo == "rlw":
(rname,
rlocation,
rsize,
runsize
) = rlw_filter(name, location, size, unsize)
elif repo == "alien":
(rname,
rlocation,
rsize,
runsize
) = alien_filter(name, location, size, unsize)
elif repo == "rested":
(rname,
rlocation,
rsize,
runsize
) = rested_filter(name, location, size, unsize)
elif repo == "ktown":
(rname,
rlocation,
rsize,
runsize
) = ktown_filter(name, location, size, unsize)
else:
rname, rlocation, rsize, runsize = name, location, size, unsize
return [rname, rlocation, rsize, runsize]
def binary(self, name, flag):
"""Build all dependencies of a package
"""
if self.meta.rsl_deps in ["on", "ON"] and "--resolve-off" not in flag:
sys.setrecursionlimit(10000)
dependencies = []
requires = Requires(name, self.repo).get_deps()
if requires:
for req in requires:
status(0)
if req and req not in self.black:
dependencies.append(req)
if dependencies:
self.dep_results.append(dependencies)
for dep in dependencies:
self.binary(dep, flag)
return self.dep_results
else:
return []
def binary(self, name, flag):
"""Build all dependencies of a package
"""
if self.meta.rsl_deps in ["on", "ON"] and "--resolve-off" not in flag:
sys.setrecursionlimit(10000)
dependencies = []
requires = Requires(name, self.repo).get_deps()
if requires:
for req in requires:
status(0)
if req and req not in self.black:
dependencies.append(req)
if dependencies:
self.dep_results.append(dependencies)
for dep in dependencies:
self.binary(dep, flag)
return self.dep_results
else:
return []
def sbo_upgrade(skip, flag):
"""Return packages for upgrade
"""
Msg().checking()
upgrade_names = []
data = SBoGrep(name="").names()
blacklist = BlackList().packages(pkgs=data, repo="sbo")
for pkg in sbo_list():
status(0.02)
name = split_package(pkg)[0]
ver = split_package(pkg)[1]
if (name in data and name not in skip and name not in blacklist):
sbo_package = ("{0}-{1}".format(name, SBoGrep(name).version()))
package = ("{0}-{1}".format(name, ver))
if LooseVersion(sbo_package) > LooseVersion(package):
upgrade_names.append(name)
Msg().done()
if "--checklist" in flag:
upgrade_names = choose_upg(upgrade_names)
return upgrade_names
def sbo_upgrade(skip, flag):
"""Return packages for upgrade
"""
Msg().checking()
upgrade_names = []
data = SBoGrep(name="").names()
blacklist = BlackList().packages(pkgs=data, repo="sbo")
for pkg in sbo_list():
status(0.02)
name = split_package(pkg)[0]
ver = split_package(pkg)[1]
if (name in data and name not in skip and name not in blacklist):
sbo_package = ("{0}-{1}".format(name, SBoGrep(name).version()))
package = ("{0}-{1}".format(name, ver))
if LooseVersion(sbo_package) > LooseVersion(package):
upgrade_names.append(name)
Msg().done()
if "--checklist" in flag:
upgrade_names = choose_upg(upgrade_names)
return upgrade_names
def store(self):
"""
Store and return packages for upgrading
"""
data = repo_data(self.PACKAGES_TXT, "slack", self.flag)
black = BlackList().packages(pkgs=data[0], repo="slack")
for name, loc, comp, uncomp in zip(data[0], data[1], data[2], data[3]):
status(0.0003)
repo_pkg_name = split_package(name)[0]
if (not os.path.isfile(self.meta.pkg_path + name[:-4]) and
repo_pkg_name not in black and
repo_pkg_name not in self.skip):
self.dwn_links.append("{0}{1}/{2}".format(mirrors("", ""),
loc, name))
self.comp_sum.append(comp)
self.uncomp_sum.append(uncomp)
self.upgrade_all.append(name)
self.count_upg += 1
if not find_package(repo_pkg_name, self.meta.pkg_path):
self.count_added += 1
self.count_upg -= 1
return self.count_upg
def sbo(self, name):
"""Build all dependencies of a package
"""
if (self.meta.rsl_deps in ["on", "ON"]
and "--resolve-off" not in self.flag):
sys.setrecursionlimit(10000)
dependencies = []
requires = SBoGrep(name).requires()
if requires:
for req in requires:
status(0.03)
# toolbar_width = status(index, toolbar_width, 1)
# avoid to add %README% as dependency and
# if require in blacklist
if "%README%" not in req and req not in self.blacklist:
dependencies.append(req)
if dependencies:
self.dep_results.append(dependencies)
for dep in dependencies:
self.sbo(dep)
return self.dep_results
else:
return []
def store(self):
"""
Store and return packages for upgrading
"""
data = repo_data(self.PACKAGES_TXT, "slack", self.flag)
black = BlackList().packages(pkgs=data[0], repo="slack")
for name, loc, comp, uncomp in zip(data[0], data[1], data[2], data[3]):
status(0.0003)
repo_pkg_name = split_package(name)[0]
if (not os.path.isfile(self.meta.pkg_path + name[:-4])
and repo_pkg_name not in black
and repo_pkg_name not in self.skip):
self.dwn_links.append("{0}{1}/{2}".format(
mirrors("", ""), loc, name))
self.comp_sum.append(comp)
self.uncomp_sum.append(uncomp)
self.upgrade_all.append(name)
self.count_upg += 1
if not find_package(repo_pkg_name + self.meta.sp,
self.meta.pkg_path):
self.count_added += 1
self.count_upg -= 1
return self.count_upg
def sbo_upgrade(skip):
"""
Return packages for upgrade
"""
try:
Msg().checking()
upgrade_names = []
data = SBoGrep(name="").names()
blacklist = BlackList().packages(pkgs=data, repo="sbo")
for pkg in sbo_list():
status(0.02)
name = split_package(pkg)[0]
ver = split_package(pkg)[1]
if (name in data and name not in skip and name not in blacklist):
sbo_package = ("{0}-{1}".format(name, SBoGrep(name).version()))
package = ("{0}-{1}".format(name, ver))
if LooseVersion(sbo_package) > LooseVersion(package):
upgrade_names.append(name)
Msg().done()
return upgrade_names
except KeyboardInterrupt:
print("") # new line at exit
sys.exit(0)
def binary(self, name, flag):
"""
Build all dependencies of a package
"""
if self.meta.rsl_deps in ["on", "ON"] and flag != "--resolve-off":
try:
sys.setrecursionlimit(10000)
dependencies = []
requires = Requires(name, self.repo).get_deps()
if requires:
for req in requires:
status(0)
if req and req not in self.black:
dependencies.append(req)
if dependencies:
self.dep_results.append(dependencies)
for dep in dependencies:
self.binary(dep, flag)
return self.dep_results
except KeyboardInterrupt:
print("") # new line at exit
sys.exit(0)
else:
return []
def exists(index, toolbar_width):
'''
search packages if exists in the repository
and it gets to avoidable modified packages
from the user with the tag _SBo
'''
upgrade_names = []
for pkg in sbo_list():
index += 1
toolbar_width = status(index, toolbar_width, 4)
name = split_package(pkg)[0]
if sbo_search_pkg(name):
sbo_package = ("{0}-{1}".format(name, SBoGrep(name).version()))
package = ("{0}-{1}".format(name, split_package(pkg)[1]))
if sbo_package > package:
upgrade_names.append(name)
return upgrade_names
def slack_data(PACKAGES_TXT, step):
'''
Grap data packages
'''
(name, location, size, unsize) = ([] for i in range(4))
index, toolbar_width = 0, 700
for line in PACKAGES_TXT.splitlines():
index += 1
toolbar_width = status(index, toolbar_width, step)
if line.startswith("PACKAGE NAME"):
name.append(line[15:].strip())
if line.startswith("PACKAGE LOCATION"):
location.append(line[21:].strip())
if line.startswith("PACKAGE SIZE (compressed): "):
size.append(line[28:-2].strip())
if line.startswith("PACKAGE SIZE (uncompressed): "):
unsize.append(line[30:-2].strip())
return [name, location, size, unsize]
def matching_data(name, support):
'''
Open and read SLACKBUILD.TXT file and store matching
packages
'''
sbo_matching, sbo_versions, packages_arch = [], [], []
toolbar_width, index = 3, 0
with open(lib_path + "sbo_repo/SLACKBUILDS.TXT", "r") as SLACKBUILDS_TXT:
for line in SLACKBUILDS_TXT:
if line.startswith("SLACKBUILD NAME: "):
sbo_name = line[17:].strip()
if name in sbo_name:
index += 1
toolbar_width = status(index, toolbar_width, 4)
sbo_matching.append(sbo_name)
sbo_versions.append(SBoGrep(sbo_name).version())
sources = SBoGrep(sbo_name).source()
packages_arch.append(select_arch(sources, support))
SLACKBUILDS_TXT.close()
return [sbo_matching, sbo_versions, packages_arch]
def matching_data(name, support):
'''
Open and read SLACKBUILD.TXT file and store matching
packages
'''
sbo_matching, sbo_versions, packages_arch = [], [], []
toolbar_width, index = 3, 0
with open(lib_path + "sbo_repo/SLACKBUILDS.TXT", "r") as SLACKBUILDS_TXT:
for line in SLACKBUILDS_TXT:
if line.startswith("SLACKBUILD NAME: "):
sbo_name = line[17:].strip()
if name in sbo_name:
index += 1
toolbar_width = status(index, toolbar_width, 4)
sbo_matching.append(sbo_name)
sbo_versions.append(SBoGrep(sbo_name).version())
sources = SBoGrep(sbo_name).source()
packages_arch.append(select_arch(sources, support))
SLACKBUILDS_TXT.close()
return [sbo_matching, sbo_versions, packages_arch]
def start(self, if_upgrade):
try:
tagc = ""
count_ins = count_upg = count_uni = 0
for _sbo in self.slackbuilds:
status(0.03)
if _sbo in self.data and _sbo not in self.blacklist:
sbo_deps = Requires(self.flag).sbo(_sbo)
self.deps += sbo_deps
self.deps_dict[_sbo] = self.one_for_all(sbo_deps)
self.package_found.append(_sbo)
else:
self.package_not_found.append(_sbo)
if not self.package_found:
self.match = True
self.matching()
self.master_packages, mas_src = self.sbo_version_source(
self.package_found)
Msg().done()
if (self.meta.rsl_deps in ["on", "ON"] and
self.flag != "--resolve-off"):
Msg().resolving()
self.dependencies, dep_src = self.sbo_version_source(
self.one_for_all(self.deps))
if (self.meta.rsl_deps in ["on", "ON"] and
self.flag != "--resolve-off"):
Msg().done()
self.clear_masters()
if self.package_found:
print("\nThe following packages will be automatically "
"installed or upgraded \nwith new version:\n")
self.top_view()
Msg().upg_inst(if_upgrade)
# view master packages
for sbo, ar in zip(self.master_packages, mas_src):
tagc, count_ins, count_upg, count_uni = self.tag(
sbo, count_ins, count_upg, count_uni)
name = "-".join(sbo.split("-")[:-1])
self.view_packages(tagc, name, sbo.split("-")[-1],
self.select_arch(ar))
self._view_installing_for_deps()
# view dependencies
for dep, ar in zip(self.dependencies, dep_src):
tagc, count_ins, count_upg, count_uni = self.tag(
dep, count_ins, count_upg, count_uni)
name = "-".join(dep.split("-")[:-1])
self.view_packages(tagc, name, dep.split("-")[-1],
self.select_arch(ar))
count_total = (count_ins + count_upg + count_uni)
print("\nInstalling summary")
print("=" * 79)
print("{0}Total {1} {2}.".format(
self.meta.color["GREY"], count_total,
Msg().pkg(count_total)))
print("{0} {1} will be installed, {2} allready installed and "
"{3} {4}".format(count_uni, Msg().pkg(count_uni),
count_ins, count_upg,
Msg().pkg(count_upg)))
print("will be upgraded.{0}\n".format(self.meta.color["ENDC"]))
self._continue_to_install()
else:
Msg().not_found(if_upgrade)
except KeyboardInterrupt:
print("") # new line at exit
sys.exit(0)
def start(self, is_upgrade):
"""Start view, build and install SBo packages
"""
tagc = ""
self.is_upgrade = is_upgrade
self.case_insensitive()
for _sbo in self.slackbuilds:
status(0.03)
if _sbo in self.data and _sbo not in self.blacklist:
sbo_deps = Requires(self.flag).sbo(_sbo)
self.deps += sbo_deps
self.deps_dict[_sbo] = self.one_for_all(sbo_deps)
self.package_found.append(_sbo)
else:
self.package_not_found.append(_sbo)
self.update_deps()
if not self.package_found:
self.match = True
self.matching()
self.master_packages, mas_src = self.sbo_version_source(
self.package_found)
self.msg.done()
if (self.meta.rsl_deps in ["on", "ON"] and self.flag != "--resolve-off"
and not self.match):
self.msg.resolving()
self.dependencies, dep_src = self.sbo_version_source(
self.one_for_all(self.deps))
if (self.meta.rsl_deps in ["on", "ON"] and self.flag != "--resolve-off"
and not self.match):
self.msg.done()
self.clear_masters()
if self.package_found:
print("\nThe following packages will be automatically "
"installed or upgraded \nwith new version:\n")
self.top_view()
self.msg.upg_inst(self.is_upgrade)
# view master packages
for sbo, arch in zip(self.master_packages, mas_src):
tagc = self.tag(sbo)
name = "-".join(sbo.split("-")[:-1])
self.view_packages(tagc, name,
sbo.split("-")[-1], self.select_arch(arch))
self.view_installing_for_deps()
# view dependencies
for dep, arch in zip(self.dependencies, dep_src):
tagc = self.tag(dep)
name = "-".join(dep.split("-")[:-1])
self.view_packages(tagc, name,
dep.split("-")[-1], self.select_arch(arch))
count_total = sum([self.count_ins, self.count_upg, self.count_uni])
print("\nInstalling summary")
print("=" * 79)
print("{0}Total {1} {2}.".format(self.meta.color["GREY"],
count_total,
self.msg.pkg(count_total)))
print("{0} {1} will be installed, {2} already installed and "
"{3} {4}".format(self.count_uni,
self.msg.pkg(self.count_uni),
self.count_ins, self.count_upg,
self.msg.pkg(self.count_upg)))
print("will be upgraded.{0}\n".format(self.meta.color["ENDC"]))
self.continue_to_install()
else:
self.msg.not_found(self.is_upgrade)
raise SystemExit(1)
def start(self, if_upgrade):
"""Start view, build and install SBo packages
"""
tagc = ""
self.if_upgrade = if_upgrade
self.case_insensitive()
for _sbo in self.slackbuilds:
status(0.03)
if _sbo in self.data and _sbo not in self.blacklist:
sbo_deps = Requires(self.flag).sbo(_sbo)
self.deps += sbo_deps
self.deps_dict[_sbo] = self.one_for_all(sbo_deps)
self.package_found.append(_sbo)
else:
self.package_not_found.append(_sbo)
self.update_deps()
if not self.package_found:
self.match = True
self.matching()
self.master_packages, mas_src = self.sbo_version_source(
self.package_found)
self.msg.done()
if (self.meta.rsl_deps in ["on", "ON"] and
self.flag != "--resolve-off" and not self.match):
self.msg.resolving()
self.dependencies, dep_src = self.sbo_version_source(
self.one_for_all(self.deps))
if (self.meta.rsl_deps in ["on", "ON"] and
self.flag != "--resolve-off" and not self.match):
self.msg.done()
self.clear_masters()
if self.package_found:
print("\nThe following packages will be automatically "
"installed or upgraded \nwith new version:\n")
self.top_view()
self.msg.upg_inst(self.if_upgrade)
# view master packages
for sbo, arch in zip(self.master_packages, mas_src):
tagc = self.tag(sbo)
name = "-".join(sbo.split("-")[:-1])
self.view_packages(tagc, name, sbo.split("-")[-1],
self.select_arch(arch))
self.view_installing_for_deps()
# view dependencies
for dep, arch in zip(self.dependencies, dep_src):
tagc = self.tag(dep)
name = "-".join(dep.split("-")[:-1])
self.view_packages(tagc, name, dep.split("-")[-1],
self.select_arch(arch))
count_total = sum([self.count_ins, self.count_upg,
self.count_uni])
print("\nInstalling summary")
print("=" * 79)
print("{0}Total {1} {2}.".format(
self.meta.color["GREY"], count_total,
self.msg.pkg(count_total)))
print("{0} {1} will be installed, {2} already installed and "
"{3} {4}".format(self.count_uni,
self.msg.pkg(self.count_uni),
self.count_ins, self.count_upg,
self.msg.pkg(self.count_upg)))
print("will be upgraded.{0}\n".format(self.meta.color["ENDC"]))
self.continue_to_install()
else:
self.msg.not_found(self.if_upgrade)
