code
stringlengths 52
7.75k
| docs
stringlengths 1
5.85k
|
|---|---|
def _rmv_deps(self, dependencies, package):
removes = []
dependencies.append(package)
self._check_if_used(dependencies)
for dep in dependencies:
if dep not in self.skip and GetFromInstalled(dep).name():
ver = GetFromInstalled(dep).version()
removes.append(dep + ver)
self._removepkg(dep)
return removes | Remove dependencies |
def _rmv_pkg(self, package):
removes = []
if GetFromInstalled(package).name() and package not in self.skip:
ver = GetFromInstalled(package).version()
removes.append(package + ver)
self._removepkg(package)
return removes | Remove one signle package |
def _skip_remove(self):
if "--checklist" not in self.extra:
self.msg.template(78)
print("| Insert packages to exception remove:")
self.msg.template(78)
try:
self.skip = raw_input(" > ").split()
except EOFError:
print("")
raise SystemExit()
for s in self.skip:
if s in self.removed:
self.removed.remove(s) | Skip packages from remove |
def _check_if_used(self, removes):
if "--check-deps" in self.extra:
package, dependency, pkg_dep = [], [], []
for pkg in find_package("", self.dep_path):
deps = Utils().read_file(self.dep_path + pkg)
for rmv in removes:
if GetFromInstalled(rmv).name() and rmv in deps.split():
pkg_dep.append(
"{0} is dependency of the package --> {1}".format(
rmv, pkg))
package.append(pkg)
dependency.append(rmv)
if package:
if "--checklist" in self.extra:
text = ("Press 'spacebar' to choose packages for the remove"
" exception")
backtitle = "{0} {1}".format(self.meta.__all__,
self.meta.__version__)
status = False
choose = DialogUtil(pkg_dep, text, " !!! WARNING !!! ",
backtitle, status).checklist()
for pkg in choose:
self.skip.append(pkg.split()[0])
else:
self.msg.template(78)
print("| {0}{1}{2}".format(
self.meta.color["RED"], " " * 30 + "!!! WARNING !!!",
self.meta.color["ENDC"]))
self.msg.template(78)
for p, d in zip(package, dependency):
print("| {0}{1}{2} is dependency of the package --> "
"{3}{4}{5}".format(self.meta.color["YELLOW"], d,
self.meta.color["ENDC"],
self.meta.color["GREEN"], p,
self.meta.color["ENDC"]))
self.msg.template(78)
self._skip_remove() | Check package if dependencies for another package
before removed |
def _reference_rmvs(self, removes):
print("")
self.msg.template(78)
msg_pkg = "package"
if len(removes) > 1:
msg_pkg = "packages"
print("| Total {0} {1} removed".format(len(removes), msg_pkg))
self.msg.template(78)
for pkg in removes:
if not GetFromInstalled(pkg).name():
print("| Package {0} removed".format(pkg))
else:
print("| Package {0} not found".format(pkg))
self.msg.template(78)
print("") | Prints all removed packages |
def find(self, flag):
matching, pkg_cache, match_cache = 0, "", ""
print("\nPackages with matching name [ {0}{1}{2} ]\n".format(
self.meta.color["CYAN"], ", ".join(self.binary),
self.meta.color["ENDC"]))
for pkg in self.binary:
for match in find_package("", self.meta.pkg_path):
if "--case-ins" in flag:
pkg_cache = pkg.lower()
match_cache = match.lower()
else:
pkg_cache = pkg
match_cache = match
if pkg_cache in match_cache:
matching += 1
self._sizes(match)
print("[ {0}installed{1} ] [ {2} ] - {3}".format(
self.meta.color["GREEN"], self.meta.color["ENDC"],
self.file_size, match))
if matching == 0:
message = "Can't find"
self.msg.pkg_not_found("", ", ".join(self.binary), message, "\n")
raise SystemExit(1)
else:
self._calc_sizes()
print("\nFound summary")
print("=" * 79)
print("{0}Total found {1} matching packages.{2}".format(
self.meta.color["GREY"], matching, self.meta.color["ENDC"]))
print("{0}Size of installed packages {1} {2}.{3}\n".format(
self.meta.color["GREY"], round(self.size, 2), self.unit,
self.meta.color["ENDC"])) | Find installed Slackware packages |
def _sizes(self, package):
data = Utils().read_file(self.meta.pkg_path + package)
for line in data.splitlines():
if line.startswith("UNCOMPRESSED PACKAGE SIZE:"):
digit = float((''.join(re.findall(
"[-+]?\d+[\.]?\d*[eE]?[-+]?\d*", line[26:]))))
self.file_size = line[26:].strip()
if "M" in line[26:]:
self.size += digit * 1024
else:
self.size += digit
break | Package size summary |
def display(self):
for pkg in self.binary:
name = GetFromInstalled(pkg).name()
ver = GetFromInstalled(pkg).version()
find = find_package("{0}{1}{2}".format(name, ver, self.meta.sp),
self.meta.pkg_path)
if find:
package = Utils().read_file(
self.meta.pkg_path + "".join(find))
print(package)
else:
message = "Can't dislpay"
if len(self.binary) > 1:
bol = eol = ""
else:
bol = eol = "\n"
self.msg.pkg_not_found(bol, pkg, message, eol)
raise SystemExit(1) | Print the Slackware packages contents |
def package_list(self, repo, name, INDEX, installed):
tty_size = os.popen("stty size", "r").read().split()
row = int(tty_size[0]) - 2
try:
all_installed_names = []
index, page, pkg_list = 0, row, []
r = self.list_lib(repo)
pkg_list = self.list_greps(repo, r)[0]
all_installed_names = self.list_of_installed(repo, name)
print("")
for pkg in sorted(pkg_list):
pkg = self._splitting_packages(pkg, repo, name)
if installed:
if repo == "sbo":
if pkg in all_installed_names:
pkg = ("{0}{1}{2}".format(self.meta.color["GREEN"],
pkg,
self.meta.color["ENDC"]))
else:
if pkg in all_installed_names:
pkg = ("{0}{1}{2}".format(self.meta.color["GREEN"],
pkg,
self.meta.color["ENDC"]))
if INDEX:
index += 1
pkg = self.list_color_tag(pkg)
print("{0}{1}:{2} {3}".format(
self.meta.color["GREY"], index,
self.meta.color["ENDC"], pkg))
if index == page:
read = raw_input("\nPress {0}Enter{1} to "
"continue... ".format(
self.meta.color["CYAN"],
self.meta.color["ENDC"]))
if read in ["Q", "q"]:
break
print("") # new line after page
page += row
else:
print(pkg)
print("") # new line at end
except EOFError:
print("") # new line at exit
raise SystemExit() | List with the installed packages |
def _splitting_packages(self, pkg, repo, name):
if name and repo != "sbo":
pkg = split_package(pkg)[0]
elif not name and repo != "sbo":
pkg = pkg[:-4]
return pkg | Return package name from repositories |
def list_greps(self, repo, packages):
pkg_list, pkg_size = [], []
for line in packages.splitlines():
if repo == "sbo":
if line.startswith("SLACKBUILD NAME: "):
pkg_list.append(line[17:].strip())
pkg_size.append("0 K")
else:
if line.startswith("PACKAGE NAME: "):
pkg_list.append(line[15:].strip())
if line.startswith("PACKAGE SIZE (compressed): "):
pkg_size.append(line[26:].strip())
if repo == "alien" or repo == "ktown":
return alien_filter(pkg_list, pkg_size)
return pkg_list, pkg_size | Grep packages |
def list_lib(self, repo):
packages = ""
if repo == "sbo":
if (os.path.isfile(
self.meta.lib_path + "{0}_repo/SLACKBUILDS.TXT".format(
repo))):
packages = Utils().read_file(self.meta.lib_path + "{0}_repo/"
"SLACKBUILDS.TXT".format(repo))
else:
if (os.path.isfile(
self.meta.lib_path + "{0}_repo/PACKAGES.TXT".format(repo))):
packages = Utils().read_file(self.meta.lib_path + "{0}_repo/"
"PACKAGES.TXT".format(repo))
return packages | Return package lists |
def list_color_tag(self, pkg):
name = GetFromInstalled(pkg).name()
find = name + self.meta.sp
if pkg.endswith(".txz") or pkg.endswith(".tgz"):
find = pkg[:-4]
if find_package(find, self.meta.pkg_path):
pkg = "{0}{1}{2}".format(self.meta.color["GREEN"], pkg,
self.meta.color["ENDC"])
return pkg | Tag with color installed packages |
def list_of_installed(self, repo, name):
all_installed_names = []
all_installed_packages = find_package("", self.meta.pkg_path)
for inst in all_installed_packages:
if repo == "sbo" and inst.endswith("_SBo"):
name = split_package(inst)[0]
all_installed_names.append(name)
else:
if name:
all_installed_names.append(split_package(inst)[0])
else:
all_installed_names.append(inst)
return all_installed_names | Return installed packages |
def repo_data(PACKAGES_TXT, repo, flag):
(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] | Grap data packages |
def rlw_filter(name, location, size, unsize):
arch = _meta_.arch
if arch.startswith("i") and arch.endswith("86"):
arch = "i486"
(fname, flocation, fsize, funsize) = ([] for i in range(4))
for n, l, s, u in zip(name, location, size, unsize):
loc = l.split("/")
if arch == loc[-1]:
fname.append(n)
flocation.append(l)
fsize.append(s)
funsize.append(u)
return [fname, flocation, fsize, funsize] | Filter rlw repository data |
def alien_filter(name, location, size, unsize):
(fname, flocation, fsize, funsize) = ([] for i in range(4))
for n, l, s, u in zip(name, location, size, unsize):
if "slackbuilds" != l:
fname.append(n)
flocation.append(l)
fsize.append(s)
funsize.append(u)
return [fname, flocation, fsize, funsize] | Fix to avoid packages include in slackbuilds folder |
def rested_filter(name, location, size, unsize):
ver = slack_ver()
if _meta_.slack_rel == "current":
ver = "current"
path_pkg = "pkg"
if _meta_.arch == "x86_64":
path_pkg = "pkg64"
(fname, flocation, fsize, funsize) = ([] for i in range(4))
for n, l, s, u in zip(name, location, size, unsize):
if path_pkg == l.split("/")[-2] and ver == l.split("/")[-1]:
fname.append(n)
flocation.append(l)
fsize.append(s)
funsize.append(u)
return [fname, flocation, fsize, funsize] | Filter Alien"s repository data |
def get_deps(self):
if self.repo == "rlw":
dependencies = {}
rlw_deps = Utils().read_file(_meta_.conf_path + "rlworkman.deps")
for line in rlw_deps.splitlines():
if line and not line.startswith("#"):
pkgs = line.split(":")
dependencies[pkgs[0]] = pkgs[1]
if self.name in dependencies.keys():
return dependencies[self.name].split()
else:
return ""
else:
PACKAGES_TXT = Utils().read_file("{0}{1}_repo/PACKAGES.TXT".format(
_meta_.lib_path, self.repo))
for line in PACKAGES_TXT.splitlines():
if line.startswith("PACKAGE NAME:"):
pkg_name = split_package(line[14:].strip())[0]
if line.startswith("PACKAGE REQUIRED:"):
if pkg_name == self.name:
if line[18:].strip():
return self._req_fix(line) | Grap package requirements from repositories |
def _req_fix(self, line):
deps = []
for dep in line[18:].strip().split(","):
dep = dep.split("|")
if self.repo == "slacky":
if len(dep) > 1:
for d in dep:
deps.append(d.split()[0])
dep = "".join(dep)
deps.append(dep.split()[0])
else:
if len(dep) > 1:
for d in dep:
deps.append(d)
deps.append(dep[0])
return deps | Fix slacky and salix requirements because many dependencies splitting
with "," and others with "|" |
def run(self):
self.find_new()
for n in self.news:
print("{0}".format(n))
print("")
self.msg.template(78)
print("| Installed {0} new configuration files:".format(
len(self.news)))
self.msg.template(78)
self.choices() | print .new configuration files |
def find_new(self):
print("\nSearch for .new configuration files:\n")
for path, dirs, files in os.walk(self.etc):
del dirs # delete unsed
for f in files:
if f.endswith(".new"):
self.news.append(os.path.join(path, f))
if not self.news:
print(" No new configuration files\n")
raise SystemExit() | Find all '.new' files from /etc/ folder
and subfolders |
def choices(self):
print("| {0}K{1}{2}eep the old and .new files, no changes".format(
self.red, self.endc, self.br))
print("| {0}O{1}{2}verwrite all old configuration files with new "
"ones".format(self.red, self.endc, self.br))
print("| The old files will be saved with suffix .old")
print("| {0}R{1}{2}emove all .new files".format(
self.red, self.endc, self.br))
print("| {0}P{1}{2}rompt K, O, R, D, M option for each single "
"file".format(self.red, self.endc, self.br))
print("| {0}Q{1}{2}uit from menu".format(self.red, self.endc, self.br))
self.msg.template(78)
try:
choose = raw_input("\nWhat would you like to do [K/O/R/P/Q]? ")
except EOFError:
print("")
raise SystemExit()
print("")
if choose in ("K", "k"):
self.keep()
elif choose in ("O", "o"):
self.overwrite_all()
elif choose in ("R", "r"):
self.remove_all()
elif choose in ("P", "p"):
self.prompt() | Menu options for new configuration files |
def prompt(self):
self.msg.template(78)
print("| Choose what to do file by file:")
print("| {0}K{1}{2}eep, {3}O{4}{5}verwrite, {6}R{7}{8}emove, "
"{9}D{10}{11}iff, {12}M{13}{14}erge, {15}Q{16}{17}uit".format(
self.red, self.endc, self.br, self.red, self.endc, self.br,
self.red, self.endc, self.br, self.red, self.endc, self.br,
self.red, self.endc, self.br, self.red, self.endc, self.br))
self.msg.template(78)
print("")
self.i = 0
try:
while self.i < len(self.news):
self.question(self.news[self.i])
self.i += 1
except EOFError:
print("")
raise SystemExit() | Select file |
def question(self, n):
print("")
prompt_ask = raw_input("{0} [K/O/R/D/M/Q]? ".format(n))
print("")
if prompt_ask in ("K", "k"):
self.keep()
elif prompt_ask in ("O", "o"):
self._overwrite(n)
elif prompt_ask in ("R", "r"):
self._remove(n)
elif prompt_ask in ("D", "d"):
self.diff(n)
self.i -= 1
elif prompt_ask in ("M", "m"):
self.merge(n)
elif prompt_ask in ("Q", "q", "quit"):
self.quit() | Choose what do to file by file |
def _remove(self, n):
if os.path.isfile(n):
os.remove(n)
if not os.path.isfile(n):
print("File '{0}' removed".format(n)) | Remove one single file |
def _overwrite(self, n):
if os.path.isfile(n[:-4]):
shutil.copy2(n[:-4], n[:-4] + ".old")
print("Old file {0} saved as {1}.old".format(
n[:-4].split("/")[-1], n[:-4].split("/")[-1]))
if os.path.isfile(n):
shutil.move(n, n[:-4])
print("New file {0} overwrite as {1}".format(
n.split("/")[-1], n[:-4].split("/")[-1])) | Overwrite old file with new and keep file with suffix .old |
def diff(self, n):
if os.path.isfile(n[:-4]):
diff1 = Utils().read_file(n[:-4]).splitlines()
if os.path.isfile(n):
diff2 = Utils().read_file(n).splitlines()
lines, l, c = [], 0, 0
for a, b in itertools.izip_longest(diff1, diff2):
l += 1
if a != b:
for s1, s2 in itertools.izip_longest(str(a), str(b)):
c += 1
if s1 != s2:
break
print("@@ -{0},{1} +{2},{3} @@\n".format(l, c, l, c))
for line in lines[-3:]:
print("{0}".format(line))
if a is None:
a = ""
print("{0}{1}{2}{3}".format(self.red, "-", self.endc, a))
if b is None:
b = ""
print("{0}{1}{2}{3}".format(self.green, "+", self.endc, b))
lines = []
c = 0
else:
lines.append(a) | Print the differences between the two files |
def merge(self, n):
if os.path.isfile(n[:-4]):
old = Utils().read_file(n[:-4]).splitlines()
if os.path.isfile(n):
new = Utils().read_file(n).splitlines()
with open(n[:-4], "w") as out:
for l1, l2 in itertools.izip_longest(old, new):
if l1 is None:
l1 = ""
if l2 is None:
l2 = ""
if l1 != l2:
out.write(l2 + "\n")
else:
out.write(l1 + "\n")
print("The file {0} merged in file {1}".format(
n.split("/")[-1], n[:-4].split("/")[-1])) | Merge new file into old |
def status_bar(self):
print("")
self.msg.template(78)
print("| Repository Status")
self.msg.template(78) | Top view bar status |
def run(self):
if (self.repo in self.meta.default_repositories and
self.repo in self.meta.repositories):
try:
self.check = self.all_repos[self.repo]()
except OSError:
usage(self.repo)
raise SystemExit()
elif self.repo in self.meta.repositories:
self.check = self._init.custom(self.repo)
else:
usage(self.repo)
raise SystemExit()
self.status_bar()
self.status()
self.print_status(self.repo)
self.summary() | Run and check if new in ChangeLog.txt |
def status(self):
self.count_repo += 1
if self.check == 1:
self.count_news += 1
self.st = "{0}News in ChangeLog.txt{1}".format(
self.meta.color["GREEN"], self.meta.color["ENDC"])
elif self.check == 0:
self.st = "No changes in ChangeLog.txt" | Set messages |
def print_status(self, repo):
print(" {0}{1}{2}".format(repo, " " * (19 - len(repo)), self.st)) | Print status |
def summary(self):
print("\nSummary")
print("=" * 79)
cmd = "All repositories are updated."
if self.count_repo == 1:
cmd = "Repository is updated."
if self.count_news > 0:
cmd = "Run the command 'slpkg update'."
print("{0}From {1} repositories need {2} updating. {3}{4}\n".format(
self.meta.color["GREY"], self.count_repo, self.count_news, cmd,
self.meta.color["ENDC"])) | Print summary |
def md5(source):
# fix passing char '+' from source
source = source.replace("%2B", "+")
with open(source) as file_to_check:
data = file_to_check.read()
return hashlib.md5(data).hexdigest() | Return MD5 Checksum |
def repositories(self):
if self.repo == "sbo":
self.sbo_case_insensitive()
self.find_pkg = sbo_search_pkg(self.name)
if self.find_pkg:
self.dependencies_list = Requires(self.flag).sbo(self.name)
else:
PACKAGES_TXT = Utils().read_file(
self.meta.lib_path + "{0}_repo/PACKAGES.TXT".format(self.repo))
self.names = Utils().package_name(PACKAGES_TXT)
self.bin_case_insensitive()
self.find_pkg = search_pkg(self.name, self.repo)
if self.find_pkg:
self.black = BlackList().packages(self.names, self.repo)
self.dependencies_list = Dependencies(
self.repo, self.black).binary(self.name, self.flag) | Get dependencies by repositories |
def sbo_case_insensitive(self):
if "--case-ins" in self.flag:
data = SBoGrep(name="").names()
data_dict = Utils().case_sensitive(data)
for key, value in data_dict.iteritems():
if key == self.name.lower():
self.name = value | Matching packages distinguish between uppercase and
lowercase for sbo repository |
def bin_case_insensitive(self):
if "--case-ins" in self.flag:
data_dict = Utils().case_sensitive(self.names)
for key, value in data_dict.iteritems():
if key == self.name.lower():
self.name = value | Matching packages distinguish between uppercase and
lowercase |
def check_used(self, pkg):
used = []
dep_path = self.meta.log_path + "dep/"
logs = find_package("", dep_path)
for log in logs:
deps = Utils().read_file(dep_path + log)
for dep in deps.splitlines():
if pkg == dep:
used.append(log)
return used | Check if dependencies used |
def deps_tree(self):
dependencies = self.dependencies + [self.name]
if self.repo == "sbo":
for dep in dependencies:
deps = Requires(flag="").sbo(dep)
if dep not in self.deps_dict.values():
self.deps_dict[dep] = Utils().dimensional_list(deps)
else:
for dep in dependencies:
deps = Dependencies(self.repo, self.black).binary(dep, flag="")
if dep not in self.deps_dict.values():
self.deps_dict[dep] = Utils().dimensional_list(deps) | Package dependencies image map file |
def deps_used(self, pkg, used):
if find_package(pkg + self.meta.sp, self.meta.pkg_path):
if pkg not in self.deps_dict.values():
self.deps_dict[pkg] = used
else:
self.deps_dict[pkg] += used | Create dependencies dictionary |
def version(self):
if self.find:
return self.meta.sp + split_package(self.find)[1]
return "" | Return version from installed packages |
def if_all_installed(self):
count_inst = 0
for inst in (self.dep_install + self.install):
if (os.path.isfile(self.meta.pkg_path + inst[:-4]) and
"--download-only" not in self.flag):
count_inst += 1
if (count_inst == len(self.dep_install + self.install) and
"--reinstall" not in self.flag):
raise SystemExit() | Check if all packages is already installed |
def case_insensitive(self):
if "--case-ins" in self.flag:
data = []
data = Utils().package_name(self.PACKAGES_TXT)
data_dict = Utils().case_sensitive(data)
for pkg in self.packages:
index = self.packages.index(pkg)
for key, value in data_dict.iteritems():
if key == pkg.lower():
self.packages[index] = value | Matching packages distinguish between uppercase and
lowercase |
def update_deps(self):
for dep in self.dependencies:
deps = Utils().dimensional_list(Dependencies(
self.repo, self.blacklist).binary(
dep, self.flag))
self.deps_dict[dep] = deps | Update dependencies dictionary with all package |
def clear_masters(self):
packages = []
for mas in Utils().remove_dbs(self.packages):
if mas not in self.dependencies:
packages.append(mas)
self.packages = packages | Clear master packages if already exist in dependencies
or if added to install two or more times |
def install_packages(self):
installs, upgraded = [], []
for inst in (self.dep_install + self.install):
package = (self.tmp_path + inst).split()
pkg_ver = "{0}-{1}".format(split_package(inst)[0],
split_package(inst)[1])
self.checksums(inst)
if GetFromInstalled(split_package(inst)[0]).name():
print("[ {0}upgrading{1} ] --> {2}".format(
self.meta.color["YELLOW"], self.meta.color["ENDC"], inst))
upgraded.append(pkg_ver)
if "--reinstall" in self.flag:
PackageManager(package).upgrade("--reinstall")
else:
PackageManager(package).upgrade("--install-new")
else:
print("[ {0}installing{1} ] --> {2}".format(
self.meta.color["GREEN"], self.meta.color["ENDC"], inst))
installs.append(pkg_ver)
PackageManager(package).upgrade("--install-new")
return [installs, upgraded] | Install or upgrade packages |
def not_downgrade(self, package):
name = split_package(package)[0]
rep_ver = split_package(package)[1]
ins_ver = GetFromInstalled(name).version()[1:]
if not ins_ver:
ins_ver = "0"
if LooseVersion(rep_ver) < LooseVersion(ins_ver):
self.msg.template(78)
print("| Package {0} don't downgrade, "
"setting by user".format(name))
self.msg.template(78)
return True | Don't downgrade packages if repository version is lower than
installed |
def checksums(self, install):
check_md5(pkg_checksum(install, self.repo), self.tmp_path + install) | Checksums before install |
def resolving_deps(self):
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) | Return package dependencies |
def _fix_deps_repos(self, dependencies):
requires = []
for dep in dependencies:
if dep in self.repo_pkg_names:
requires.append(dep)
return requires | Fix store deps include in repository |
def views(self, install, comp_sum):
pkg_sum = uni_sum = upg_sum = 0
# fix repositories align
repo = self.repo + (" " * (6 - (len(self.repo))))
for pkg, comp in zip(install, comp_sum):
pkg_repo = split_package(pkg[:-4])
if find_package(pkg[:-4], self.meta.pkg_path):
pkg_sum += 1
COLOR = self.meta.color["GREEN"]
elif pkg_repo[0] == GetFromInstalled(pkg_repo[0]).name():
COLOR = self.meta.color["YELLOW"]
upg_sum += 1
else:
COLOR = self.meta.color["RED"]
uni_sum += 1
ver = GetFromInstalled(pkg_repo[0]).version()
print(" {0}{1}{2}{3} {4}{5} {6}{7}{8}{9}{10}{11:>11}{12}".format(
COLOR, pkg_repo[0] + ver, self.meta.color["ENDC"],
" " * (23-len(pkg_repo[0] + ver)), pkg_repo[1],
" " * (18-len(pkg_repo[1])), pkg_repo[2],
" " * (8-len(pkg_repo[2])), pkg_repo[3],
" " * (7-len(pkg_repo[3])), repo,
comp, " K")).rstrip()
return [pkg_sum, upg_sum, uni_sum] | Views packages |
def top_view(self):
self.msg.template(78)
print("{0}{1}{2}{3}{4}{5}{6}{7}{8}{9}{10}".format(
"| Package", " " * 17,
"New Version", " " * 8,
"Arch", " " * 4,
"Build", " " * 2,
"Repos", " " * 10,
"Size"))
self.msg.template(78) | Print packages status bar |
def store(self, packages):
dwn, install, comp_sum, uncomp_sum = ([] for i in range(4))
# name = data[0]
# location = data[1]
# size = data[2]
# unsize = data[3]
for pkg in packages:
for pk, loc, comp, uncomp in zip(self.data[0], self.data[1],
self.data[2], self.data[3]):
if (pk and pkg == split_package(pk)[0] and
pk not in install and
split_package(pk)[0] not in self.blacklist):
dwn.append("{0}{1}/{2}".format(self.mirror, loc, pk))
install.append(pk)
comp_sum.append(comp)
uncomp_sum.append(uncomp)
if not install:
for pkg in packages:
for pk, loc, comp, uncomp in zip(self.data[0], self.data[1],
self.data[2], self.data[3]):
name = split_package(pk)[0]
if (pk and pkg in name and name not in self.blacklist):
self.matching = True
dwn.append("{0}{1}/{2}".format(self.mirror, loc, pk))
install.append(pk)
comp_sum.append(comp)
uncomp_sum.append(uncomp)
dwn.reverse()
install.reverse()
comp_sum.reverse()
uncomp_sum.reverse()
if self.repo == "slack":
dwn, install, comp_sum, uncomp_sum = self.patches(dwn, install,
comp_sum,
uncomp_sum)
return [dwn, install, comp_sum, uncomp_sum] | Store and return packages for install |
def patches(self, dwn, install, comp_sum, uncomp_sum):
dwnp, installp, comp_sump, uncomp_sump = ([] for i in range(4))
for d, i, c, u in zip(dwn, install, comp_sum, uncomp_sum):
if "_slack" + slack_ver() in i:
dwnp.append(d)
dwn.remove(d)
installp.append(i)
install.remove(i)
comp_sump.append(c)
comp_sum.remove(c)
uncomp_sump.append(u)
uncomp_sum.remove(u)
if "--patches" in self.flag:
return dwnp, installp, comp_sump, uncomp_sump
return dwn, install, comp_sum, uncomp_sum | Seperates packages from patches/ directory |
def pkg_checksum(binary, repo):
md5 = "None"
if repo == "slack_patches" and _meta_.slack_rel == "stable":
CHECKSUMS_md5 = URL(mirrors("CHECKSUMS.md5", "patches/")).reading()
elif repo == "slack_patches" and _meta_.slack_rel == "current":
CHECKSUMS_md5 = URL(mirrors("CHECKSUMS.md5", "")).reading()
elif repo == "slpkg":
CHECKSUMS_md5 = URL(_meta_.CHECKSUMS_link).reading()
else:
lib = "{0}{1}_repo/CHECKSUMS.md5".format(_meta_.lib_path, repo)
f = open(lib, "r")
CHECKSUMS_md5 = f.read()
f.close()
for line in CHECKSUMS_md5.splitlines():
if line.endswith("/{0}".format(binary)):
md5 = line.split()[0]
return md5 | Return checksum from CHECKSUMS.md5 file by repository |
def library(repo):
pkg_list, packages = [], ""
if repo == "sbo":
if (os.path.isfile(
_meta_.lib_path + "{0}_repo/SLACKBUILDS.TXT".format(repo))):
packages = Utils().read_file(_meta_.lib_path + "{0}_repo/"
"SLACKBUILDS.TXT".format(repo))
else:
if (os.path.isfile(
_meta_.lib_path + "{0}_repo/PACKAGES.TXT".format(repo))):
packages = Utils().read_file(_meta_.lib_path + "{0}_repo/"
"PACKAGES.TXT".format(repo))
for line in packages.splitlines():
if repo == "sbo":
if line.startswith("SLACKBUILD NAME: "):
pkg_list.append(line[17:].strip())
elif "local" not in repo:
if line.startswith("PACKAGE NAME: "):
pkg_list.append(line[15:].strip())
if repo == "local":
pkg_list = find_package("", _meta_.pkg_path)
return pkg_list | Load packages from slpkg library and from local |
def info(self, name, sbo_file):
return URL(self.sbo_url + name + sbo_file).reading() | Read info file |
def slackbuild(self, name, sbo_file):
return URL(self.sbo_url + name + sbo_file).reading() | Read SlackBuild file |
def run(self):
self.files_exist()
self.info_file()
sources = self.sources
if len(sources) > 1 and self.sbo_sources != sources:
sources = self.sbo_sources
# If the list does not have the same order use from .info
# order.
BuildPackage(self.script, sources, self.path, auto=True).build()
raise SystemExit() | Build package and fix ordelist per checksum |
def info_file(self):
sources = SBoGrep(self.prgnam).source().split()
for source in sources:
self.sbo_sources.append(source.split("/")[-1]) | Grab sources from .info file and store filename |
def files_exist(self):
if not os.path.isfile(self.path + self.script):
print("\nslpkg: Error: SlackBuild archive.tar.gz not found\n")
raise SystemExit()
for src in self.sources:
if not os.path.isfile(self.path + src):
print("\nslpkg: Error: Source file '{0}' not found\n".format(
src))
raise SystemExit() | Check if SlackBuild archive.tar.gz and sources exist |
def help_version(self):
if (len(self.args) == 1 and self.args[0] in ["-h", "--help"] and
self.args[1:] == []):
options()
elif (len(self.args) == 1 and self.args[0] in ["-v", "--version"] and
self.args[1:] == []):
prog_version()
else:
usage("") | Help and version info |
def command_update(self):
if len(self.args) == 1 and self.args[0] == "update":
Update().repository(only="")
elif (len(self.args) == 2 and self.args[0] == "update" and
self.args[1].startswith("--only=")):
repos = self.args[1].split("=")[-1].split(",")
for rp in repos:
if rp not in self.meta.repositories:
repos.remove(rp)
Update().repository(repos)
else:
usage("") | Update package lists repositories |
def command_repo_enable(self):
if len(self.args) == 1 and self.args[0] == "repo-enable":
RepoEnable().choose()
else:
usage("") | Repositories enable/disable |
def command_repo_list(self):
if len(self.args) == 1 and self.args[0] == "repo-list":
RepoList().repos()
else:
usage("") | Repositories list |
def command_repo_add(self):
if len(self.args) == 3 and self.args[0] == "repo-add":
Repo().add(self.args[1], self.args[2])
else:
usage("") | Add custom repositories |
def command_repo_remove(self):
if len(self.args) == 2 and self.args[0] == "repo-remove":
Repo().remove(self.args[1])
else:
usage("") | Remove custom repositories |
def command_upgrade(self):
if len(self.args) == 1 and self.args[0] == "upgrade":
Initialization(False).upgrade(only="")
elif (len(self.args) == 2 and self.args[0] == "upgrade" and
self.args[1].startswith("--only=")):
repos = self.args[1].split("=")[-1].split(",")
for rp in repos:
if rp not in self.meta.repositories:
repos.remove(rp)
Initialization(False).upgrade(repos)
else:
usage("") | Recreate repositories package lists |
def command_repo_info(self):
if (len(self.args) == 2 and self.args[0] == "repo-info" and
self.args[1] in RepoList().all_repos):
del RepoList().all_repos
RepoInfo().view(self.args[1])
elif (len(self.args) > 1 and self.args[0] == "repo-info" and
self.args[1] not in RepoList().all_repos):
usage(self.args[1])
else:
usage("") | Repositories informations |
def command_health(self):
if len(self.args) == 1 and self.args[0] == "health":
PackageHealth(mode="").test()
elif (len(self.args) == 2 and self.args[0] == "health" and
self.args[1] == "--silent"):
PackageHealth(mode=self.args[1]).test()
else:
usage("") | Check package health |
def command_deps_status(self):
image = ""
for arg in self.args:
if arg.startswith("--graph="):
image = arg.split("=")[1]
if len(self.args) == 1 and self.args[0] == "deps-status":
DependenciesStatus(image).show()
elif len(self.args) == 2 and self.args[0] == "deps-status" and image:
DependenciesStatus(image).show()
elif (len(self.args) == 2 and self.args[0] == "deps-status" and
"--tree" in self.args):
DependenciesStatus(image).tree()
elif (len(self.args) == 3 and self.args[0] == "deps-status" and
"--tree" in self.args and image):
DependenciesStatus(image).tree()
else:
usage("") | Print dependencies status |
def command_new_config(self):
if len(self.args) == 1 and self.args[0] == "new-config":
NewConfig().run()
else:
usage("") | Manage .new configuration files |
def auto_build(self):
options = [
"-a",
"--autobuild"
]
if len(self.args) >= 3 and self.args[0] in options:
AutoBuild(self.args[1], self.args[2:], self.meta.path).run()
else:
usage("") | Auto built tool |
def pkg_list(self):
options = [
"-l",
"--list"
]
flag = ["--index", "--installed", "--name"]
name = INDEX = installed = False
for arg in self.args[2:]:
if flag[0] == arg:
INDEX = True
if flag[1] in arg:
installed = True
if flag[2] == arg:
name = True
if arg not in flag:
usage("")
raise SystemExit()
if (len(self.args) > 1 and len(self.args) <= 5 and
self.args[0] in options):
if self.args[1] in self.meta.repositories:
PackageManager(binary=None).package_list(self.args[1],
name,
INDEX,
installed)
else:
usage(self.args[1])
else:
usage("") | List of packages by repository |
def pkg_upgrade(self):
options = [
"-c",
"--check"
]
flags = [
"--upgrade",
"--skip=",
"--resolve-off",
"--checklist",
"--rebuild"
]
flag, skip = self.__pkg_upgrade_flags(flags)
if (len(self.args) == 3 and self.args[0] in options and
self.args[2] == flags[0] and
self.args[1] in self.meta.repositories):
if self.args[1] not in ["slack", "sbo"]:
BinaryInstall(pkg_upgrade(self.args[1], skip, flag),
self.args[1], flag).start(is_upgrade=True)
elif self.args[1] == "slack":
if self.meta.only_installed in ["on", "ON"]:
BinaryInstall(pkg_upgrade("slack", skip, flag),
"slack", flag).start(is_upgrade=True)
else:
Patches(skip, flag).start()
elif self.args[1] == "sbo":
SBoInstall(sbo_upgrade(skip, flag), flag).start(is_upgrade=True)
else:
usage(self.args[1])
elif len(self.args) == 2 and self.args[0] in options:
if self.args[1] == "ALL":
Updates(repo="").ALL()
else:
Updates(self.args[1]).run()
elif (len(self.args) >= 2 and self.args[0] in options and
self.args[1] not in self.meta.repositories):
usage(self.args[1])
else:
usage("") | Check and upgrade packages by repository |
def __pkg_upgrade_flags(self, flags):
flag, skip = [], ""
if flags[0] in self.args:
for arg in self.args[3:]:
if arg.startswith(flags[1]):
skip = Regex(arg.split("=")[1]).get()
self.args.remove(arg)
if arg in flags:
flag.append(arg)
if arg in self.args:
self.args.remove(arg)
return flag, skip | Manage flags for package upgrade option |
def pkg_install(self):
flag = []
options = [
"-s",
"--sync"
]
additional_options = [
"--resolve-off",
"--download-only",
"--directory-prefix=",
"--case-ins",
"--rebuild",
"--reinstall",
"--patches"
]
for arg in self.args:
if arg.startswith(additional_options[2]):
flag.append(arg)
arg = ""
if arg in additional_options:
flag.append(arg)
# clean from flags
for ar in flag:
if ar in self.args:
self.args.remove(ar)
if len(self.args) >= 3 and self.args[0] in options:
if (self.args[1] in self.meta.repositories and
self.args[1] not in ["sbo"]):
BinaryInstall(self.args[2:], self.args[1], flag).start(
is_upgrade=False)
elif (self.args[1] == "sbo" and
self.args[1] in self.meta.repositories):
SBoInstall(self.args[2:], flag).start(is_upgrade=False)
else:
usage(self.args[1])
else:
usage("") | Install packages by repository |
def pkg_tracking(self):
flag = []
options = [
"-t",
"--tracking"
]
additional_options = [
"--check-deps",
"--graph=",
"--case-ins"
]
for arg in self.args[2:]:
if arg.startswith(additional_options[1]):
flag.append(arg)
self.args.remove(arg)
if arg in additional_options:
flag.append(arg)
# clean additional options from args
for f in flag:
if f in self.args:
self.args.remove(f)
# print usage message if wrong additional option
for arg in self.args:
if arg.startswith("--"):
if arg not in additional_options:
usage("")
raise SystemExit()
if (len(self.args) >= 3 and len(self.args) <= 3 and
self.args[0] in options and
self.args[1] in self.meta.repositories):
TrackingDeps(self.args[2], self.args[1], flag).run()
elif (len(self.args) >= 2 and
self.args[1] not in self.meta.repositories):
usage(self.args[1])
else:
usage("") | Tracking package dependencies |
def sbo_network(self):
flag = []
options = [
"-n",
"--network"
]
additional_options = [
"--checklist",
"--case-ins"
]
for add in additional_options:
if add in self.args:
flag.append(add)
self.args.remove(add)
if (len(self.args) == 2 and self.args[0] in options and
"sbo" in self.meta.repositories):
SBoNetwork(self.args[1], flag).view()
else:
usage("sbo") | View slackbuilds packages |
def pkg_blacklist(self):
blacklist = BlackList()
options = [
"-b",
"--blacklist"
]
flag = [
"--add",
"--remove"
]
command = ["list"]
if (len(self.args) == 2 and self.args[0] in options and
self.args[1] == command[0]):
blacklist.listed()
elif (len(self.args) > 2 and self.args[0] in options and
flag[0] in self.args):
self.args.remove(flag[0])
blacklist.add(self.args[1:])
elif (len(self.args) == 3 and self.args[0] in options and
"ALL" in self.args and flag[1] in self.args):
self.args.remove(flag[1])
blacklist.remove(blacklist.get_black())
elif (len(self.args) > 2 and self.args[0] in options and
flag[1] in self.args):
self.args.remove(flag[1])
blacklist.remove(self.args[1:])
else:
usage("") | Manage blacklist packages |
def pkg_queue(self):
queue = QueuePkgs()
options = [
"-q",
"--queue"
]
flag = [
"--add",
"--remove"
]
command = [
"list",
"build",
"install",
"build-install"
]
if (len(self.args) > 2 and self.args[0] in options and
flag[0] in self.args):
self.args.remove(flag[0])
queue.add(self.args[1:])
elif (len(self.args) == 3 and self.args[0] in options and
"ALL" in self.args and flag[1] in self.args):
self.args.remove(flag[1])
queue.remove(queue.packages())
elif (len(self.args) > 2 and self.args[0] in options and
flag[1] in self.args):
self.args.remove(flag[1])
queue.remove(self.args[1:])
elif (len(self.args) == 2 and self.args[0] in options and
self.args[1] == command[0]):
queue.listed()
elif (len(self.args) == 2 and self.args[0] in options and
self.args[1] == command[1]):
queue.build()
elif (len(self.args) == 2 and self.args[0] in options and
self.args[1] == command[2]):
queue.install()
elif (len(self.args) == 2 and self.args[0] in options and
self.args[1] == command[3]):
queue.build()
queue.install()
else:
usage("") | Manage packages in queue |
def bin_install(self):
packages = self.args[1:]
options = [
"-i",
"--installpkg"
]
flag = ""
flags = [
"--warn",
"--md5sum",
"--root",
"--infobox",
"--menu",
"--terse",
"--ask",
"--priority",
"--tagfile"
]
if len(self.args) > 1 and self.args[0] in options:
if self.args[1] in flags:
flag = self.args[1]
packages = self.args[2:]
PackageManager(packages).install(flag)
else:
usage("") | Install Slackware binary packages |
def bin_upgrade(self):
packages = self.args[1:]
options = [
"-u",
"--upgradepkg"
]
flag = ""
flags = [
"--dry-run",
"--install-new",
"--reinstall",
"--verbose"
]
if len(self.args) > 1 and self.args[0] in options:
if self.args[1] in flags:
flag = self.args[1]
packages = self.args[2:]
PackageManager(packages).upgrade(flag)
else:
usage("") | Install-upgrade Slackware binary packages |
def bin_remove(self):
packages = self.args[1:]
options = [
"-r",
"--removepkg"
]
additional_options = [
"--deps",
"--check-deps",
"--tag",
"--checklist"
]
flag, extra = "", []
flags = [
"-warn",
"-preserve",
"-copy",
"-keep"
]
# merge --check-deps and --deps options
if (additional_options[1] in self.args and
additional_options[0] not in self.args):
self.args.append(additional_options[0])
if len(self.args) > 1 and self.args[0] in options:
for additional in additional_options:
if additional in self.args:
extra.append(additional)
self.args.remove(additional)
packages = self.args[1:]
for fl in flags:
if fl in self.args:
flag = self.args[1]
packages = self.args[2:]
PackageManager(packages).remove(flag, extra)
else:
usage("") | Remove Slackware packages |
def bin_find(self):
flag = []
options = [
"-f",
"--find"
]
additional_options = ["--case-ins"]
for arg in self.args:
if arg in additional_options:
flag.append(arg)
self.args.remove(arg)
packages = self.args[1:]
if len(self.args) > 1 and self.args[0] in options:
PackageManager(packages).find(flag)
else:
usage("") | Find installed packages |
def pkg_desc(self):
options = [
"-p",
"--desc"
]
flag = ["--color="]
colors = [
"red",
"green",
"yellow",
"cyan",
"grey"
]
tag = ""
for arg in self.args:
if arg.startswith(flag[0]):
tag = arg[len(flag[0]):]
self.args.remove(arg)
break
if tag and tag not in colors:
print("\nslpkg: Error: Available colors {0}\n".format(
colors))
raise SystemExit()
if (len(self.args) == 3 and self.args[0] in options and
self.args[1] in self.meta.repositories and tag in colors):
PkgDesc(self.args[2], self.args[1], tag).view()
elif (len(self.args) == 3 and self.args[0] in options and
self.args[1] in self.meta.repositories):
PkgDesc(self.args[2], self.args[1], paint="").view()
elif (len(self.args) > 1 and self.args[0] in options and
self.args[1] not in self.meta.repositories):
usage(self.args[1])
else:
usage("") | Print slack-desc by repository |
def pkg_find(self):
flag = []
options = [
"-F",
"--FIND"
]
additional_options = ["--case-ins"]
for arg in self.args:
if arg in additional_options:
flag.append(arg)
self.args.remove(arg)
packages = self.args[1:]
if len(self.args) > 1 and self.args[0] in options:
FindFromRepos().find(packages, flag)
else:
usage("") | Find packages from all enabled repositories |
def pkg_contents(self):
packages = self.args[1:]
options = [
"-d",
"--display"
]
if len(self.args) > 1 and self.args[0] in options:
PackageManager(packages).display()
else:
usage("") | Print packages contents |
def congiguration(self):
options = [
"-g",
"--config"
]
command = [
"print",
"edit",
"reset"
]
conf = Config()
if (len(self.args) == 2 and self.args[0] in options and
self.args[1] == command[1]):
conf.edit()
elif (len(self.args) == 2 and self.args[0] in options and
self.args[1] == (command[0])):
conf.view()
elif (len(self.args) == 2 and self.args[0] in options and
self.args[1] == (command[2])):
conf.reset()
else:
usage("") | Manage slpkg configuration file |
def auto_detect(self, args):
suffixes = [
".tgz",
".txz",
".tbz",
".tlz"
]
if (not args[0].startswith("-") and args[0] not in self.commands and
args[0].endswith(tuple(suffixes))):
packages, not_found = [], []
for pkg in args:
if pkg.endswith(tuple(suffixes)):
if os.path.isfile(pkg):
packages.append(pkg)
else:
not_found.append(pkg)
if packages:
Auto(packages).select()
if not_found:
for ntf in not_found:
self.msg.pkg_not_found("", ntf, "Not installed", "")
raise SystemExit() | Check for already Slackware binary packages exist |
def search_pkg(name, repo):
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 | Search if package exists in PACKAGES.TXT file
and return the name. |
def data(self):
for pkg in self.installed:
if os.path.isfile(self.meta.pkg_path + pkg):
name = split_package(pkg)[0]
for log in self.logs:
deps = Utils().read_file(self.dep_path + log)
for dep in deps.splitlines():
if name == dep:
if name not in self.dmap.keys():
self.dmap[name] = [log]
if not self.count_pkg:
self.count_pkg = 1
else:
self.dmap[name] += [log]
self.count_packages() | Check all installed packages and create
dictionary database |
def count_packages(self):
packages = []
for pkg in self.dmap.values():
packages += pkg
self.count_dep += 1
self.count_pkg = len(set(packages)) | Count dependencies and packages |
def show(self):
self.data()
print("")
self.msg.template(78)
print("| {0}{1}{2}".format("Dependencies", " " * 20, "Packages"))
self.msg.template(78)
for key, value in self.dmap.iteritems():
print(" {0}{1}{2}{3}{4}".format(
self.green, key, self.endc, " " * (32-len(key)),
", ".join(value)))
self.summary()
if self.image:
Graph(self.image).dependencies(self.dmap) | Show dependencies status |
def tree(self):
self.msg.template(78)
print("| Dependencies\n"
"| -- Packages")
self.msg.template(78)
self.data()
for pkg, dep in self.dmap.iteritems():
print("+ {0}{1}{2}".format(self.green, pkg, self.endc))
print("|")
for d in dep:
print("+-- {0}".format(d))
print("|")
sys.stdout.write("\x1b[1A{0}\n".format(" "))
sys.stdout.flush()
self.summary()
if self.image:
Graph(self.image).dependencies(self.dmap) | Like tree view mode |
def summary(self):
print("\nStatus summary")
print("=" * 79)
print("{0}found {1} dependencies in {2} packages.{3}\n".format(
self.grey, self.count_dep, self.count_pkg, self.endc)) | Summary by packages and dependencies |
def find(self, pkg, flag):
print("\nPackages with name matching [ {0}{1}{2} ]\n".format(
self.cyan, ", ".join(pkg), self.endc))
Msg().template(78)
print("| {0} {1}{2}{3}".format("Repository", "Package", " " * 54,
"Size"))
Msg().template(78)
for repo in _meta_.repositories:
PACKAGES_TXT = PackageManager(pkg).list_lib(repo)
packages, sizes = PackageManager(pkg).list_greps(repo, PACKAGES_TXT)
for find, size in zip(packages, sizes):
for p in pkg:
if "--case-ins" in flag:
self.p_cache = p.lower()
self.find_cache = find.lower()
else:
self.p_cache = p
self.find_cache = find
if self.p_cache in self.find_cache:
if self.cache != repo:
self.count_repo += 1
self.cache = repo
self.count_pkg += 1
ver = self.sbo_version(repo, find)
print(" {0}{1}{2}{3}{4} {5}{6:>11}".format(
self.cyan, repo, self.endc,
" " * (12 - len(repo)),
find + ver, " " * (53 - len(find + ver)),
size))
print("\nFound summary")
print("=" * 79)
print("{0}Total found {1} packages in {2} repositories."
"{3}\n".format(self.grey, self.count_pkg,
self.count_repo, self.endc)) | Start to find packages and print |
def sbo_version(self, repo, find):
ver = ""
if repo == "sbo":
ver = "-" + SBoGrep(find).version()
return ver | Add version to SBo packages |
def slack_ver():
if _meta_.slackware_version in ["off", "OFF"]:
sv = Utils().read_file("/etc/slackware-version")
version = re.findall(r"\d+", sv)
if len(sv) > 2:
return (".".join(version[:2]))
else:
return (".".join(version))
else:
return _meta_.slackware_version | Open file and read Slackware version |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.