def run(self):
""" Run command """
pr.p('Checking upgradable packages...')
installed_packages = Pkg.installed_list()['list']
upgradable_packages = []
for pkg in installed_packages:
installed_version = pkg.installed()
latest_version = pkg.data['version']
if Pkg.compare_version(latest_version, installed_version) == 1:
upgradable_packages.append(pkg)
if not upgradable_packages:
pr.p(ansi.green + 'all of packages are up to date' + ansi.reset)
return 0
packages_names = [pkg.data['name'] for pkg in upgradable_packages]
install_cmd = InstallCommand()
return install_cmd.handle(ArgParser.parse(['cati', 'install', *self.args['options'], *packages_names]))
def run(self):
""" Run command """
if not self.has_option('-q') and not self.has_option('--quiet'):
pr.p('Loading packages list...')
pr.p('========================')
# load list of packages
if self.has_option('--installed'):
# just list installed packages
packages = Pkg.installed_list()
elif self.has_option('--installed-manual'):
packages = Pkg.installed_list()
packages_list = [
tmp_pkg for tmp_pkg in packages['list']
if Pkg.is_installed_manual(tmp_pkg.data['name'])
]
packages['list'] = packages_list
else:
packages = Pkg.all_list()
for error in packages['errors']:
self.message(error + ansi.reset, True, before=ansi.red)
# load filter options
wanted_authors = []
if self.has_option('--author'):
wanted_authors = self.option_value('--author').strip().split('|')
wanted_authors = [author.strip() for author in wanted_authors]
wanted_maintainers = []
if self.has_option('--maintainer'):
wanted_maintainers = self.option_value(
'--maintainer').strip().split('|')
wanted_maintainers = [
maintainer.strip() for maintainer in wanted_maintainers
]
wanted_categories = []
if self.has_option('--category'):
wanted_categories = self.option_value('--category').strip().split(
'|')
wanted_categories = [
category.strip() for category in wanted_categories
]
search_query = self.option_value('--search')
if search_query:
search_query_words = search_query.strip().split(' ')
search_query_words = [word.strip() for word in search_query_words]
else:
search_query_words = []
for package in packages['list']:
# check filters
if wanted_authors:
try:
if not package.data['author'].strip() in wanted_authors:
continue
except:
continue
if wanted_maintainers:
try:
if not package.data['maintainer'].strip(
) in wanted_maintainers:
continue
except:
continue
if wanted_categories:
try:
if not package.data['category'].strip(
) in wanted_categories:
continue
except:
continue
if search_query:
is_math_with_query = False
for word in search_query_words:
if word in package.data['name']:
is_math_with_query = True
try:
if search_query in package.data['description']:
is_math_with_query = True
except:
pass
if not is_math_with_query:
continue
if self.has_option('--upgradable'):
if package.installed():
if Pkg.compare_version(package.data['version'],
package.installed()) != 1:
continue
else:
continue
# show item
self.show_once(package)
def handle_install_depends(self):
""" Adds installable packages depends to install list """
new_to_install = []
i = 0
while i < len(self.to_install):
depends = self.to_install[i].get_depends()
if self.with_recommends:
depends = [*depends, *self.to_install[i].get_recommends()]
for depend in depends:
if not Pkg.check_state(depend) and depend.strip()[0] != '@':
# find package depend
try:
self.to_install[i].depend_get_next[depend]
except:
try:
self.to_install[i].depend_get_next[depend] = 0
except:
self.to_install[i].depend_get_next = {}
self.to_install[i].depend_get_next[depend] = 0
pkg = Pkg.check_state(depend, get_false_pkg=True, get_false_pkg_next=self.to_install[i].depend_get_next[depend])
self.to_install[i].depend_get_next[depend] += 1
if len(pkg) == 1:
a = 0
added = False
while a < len(self.to_install):
if self.to_install[a].data['name'] == pkg[0]:
added = True
a += 1
if not added:
new_to_install.append(Pkg.load_last(pkg[0]))
elif len(pkg) == 3:
a = 0
added = False
while a < len(self.to_install):
if self.to_install[a].data['name'] == pkg[0]:
wanted_version = pkg[2]
installed_version = self.to_install[a].wanted_version
if pkg[1] == '=':
if Pkg.compare_version(installed_version, wanted_version) == 0:
added = True
elif pkg[1] == '>=':
if Pkg.compare_version(installed_version, wanted_version) >= 0:
added = True
elif pkg[1] == '<=':
if Pkg.compare_version(installed_version, wanted_version) <= 0:
added = True
elif pkg[1] == '>':
if Pkg.compare_version(installed_version, wanted_version) == 1:
added = True
elif pkg[1] == '<':
if Pkg.compare_version(installed_version, wanted_version) == -1:
added = True
a += 1
if not added:
pkg_obj = None
if pkg[1] == '=':
pkg_obj = Pkg.load_version(pkg[0], pkg[2])
elif pkg[1] == '>=' or pkg[1] == '>':
pkg_obj = Pkg.load_last(pkg[0])
elif pkg[1] == '<=':
pkg_obj = Pkg.load_version(pkg[0], pkg[2])
elif pkg[1] == '<':
pkg_obj = Pkg.load_last(pkg[0])
versions = pkg_obj.get_versions_list()
x = 0
while x < len(versions):
if Pkg.compare_version(versions[x][0], pkg[0]) >= 0:
versions.pop(x)
x += 1
versions = [v[0] for v in versions]
wanted_ver = pkg.get_last_version(versions)
pkg_obj = Pkg.load_version(pkg[0], wanted_ver)
new_to_install.append(pkg_obj)
i += 1
if new_to_install:
self.install(new_to_install)
self.handle_install_reverse_depends()
