def main():
commands = ['update', 'install', 'list', 'remove']
# Parse args
parser = argparse.ArgumentParser()
parser.add_argument('command', help=', '.join(commands))
parser.add_argument('argument', nargs='?', help='Argument for command')
args = parser.parse_args()
# Parse command
command = args.command
if command not in commands:
print(f'Unrecognized command {args.command}')
print(f'Valid commands {commands}')
exit(1)
if command == 'update':
package.update_package_index()
elif command == 'install':
available_packages = package.get_available_packages()
package_name = args.argument
package_found = False
for available_package in available_packages:
name = name_of_package(available_package)
if name == package_name:
download_path = available_package.download()
package.install_from_path(download_path)
print(f'Installed package to path {download_path}')
package_found = True
break
if not package_found:
print('Package not found')
elif command == 'list':
installed_packages = package.get_installed_packages()
for installed_package in installed_packages:
print(name_of_package(installed_package))
elif command == 'remove':
installed_packages = package.get_installed_packages()
package_name = args.argument
package_found = False
for installed_package in installed_packages:
name = name_of_package(installed_package)
if name == package_name:
installed_package.remove()
print(f'Removed package {name}')
package_found = True
break
if not package_found:
print('Package not found')
def __init__(self, table_content, available_actions):
super().__init__()
self.table_content = table_content
self.available_actions = available_actions
self.setSizeAdjustPolicy(QAbstractScrollArea.AdjustToContents)
self.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Minimum)
headers = [
"Readme",
"Name",
"Package name",
"From code",
"To code",
"Version",
]
if self.AvailableActions.UNINSTALL in self.available_actions:
headers.append("Uninstall")
if self.AvailableActions.INSTALL in self.available_actions:
headers.append("Install")
self.setColumnCount(len(headers))
self.setHorizontalHeaderLabels(headers)
self.verticalHeader().setVisible(False)
self.horizontalHeader().setSectionResizeMode(QHeaderView.ResizeToContents)
self.horizontalHeader().setSectionResizeMode(1, QHeaderView.Stretch)
self.horizontalHeader().setSectionResizeMode(2, QHeaderView.Stretch)
# Padding in header sections used as workaround for inaccurate results of resizeColumnsToContents()
self.STRETCH_COLUMN_MIN_PADDING = 50
self.horizontalHeader().setDefaultAlignment(Qt.AlignLeft)
self.installed_packages = package.get_installed_packages()
def get_packages(self):
if self.table_content == self.TableContent.AVAILABLE:
return package.get_available_packages()
elif self.table_content == self.TableContent.INSTALLED:
return package.get_installed_packages()
else:
raise Exception("Invalid table content")
def load_installed_languages():
"""Returns a list of Languages installed from packages"""
packages = package.get_installed_packages()
# Load languages and translations from packages
language_of_code = dict()
for pkg in packages:
if pkg.from_code not in language_of_code:
language_of_code[pkg.from_code] = Language(
pkg.from_code, pkg.from_name)
if pkg.to_code not in language_of_code:
language_of_code[pkg.to_code] = Language(
pkg.to_code, pkg.to_name)
from_lang = language_of_code[pkg.from_code]
to_lang = language_of_code[pkg.to_code]
translation_to_add = CachedTranslation(PackageTranslation(
from_lang, to_lang, pkg))
from_lang.translations_from.append(translation_to_add)
to_lang.translations_to.append(translation_to_add)
languages = list(language_of_code.values())
# Add translations so everything can translate to itself
for language in languages:
identity_translation = IdentityTranslation(language)
language.translations_from.append(identity_translation)
language.translations_to.append(identity_translation)
# Pivot through intermediate languages to add translations
# that don't already exist
for language in languages:
keep_adding_translations = True
while keep_adding_translations:
keep_adding_translations = False
for translation in language.translations_from:
for translation_2 in translation.to_lang.translations_from:
if language.get_translation(translation_2.to_lang) == None:
# The language currently doesn't have a way to translate
# to this language
keep_adding_translations = True
composite_translation = CompositeTranslation(translation, translation_2)
language.translations_from.append(composite_translation)
translation_2.to_lang.translations_to.append(composite_translation)
# Put English first if available so it shows up as the from language in the gui
en_index = None
for i, language in enumerate(languages):
if language.code == 'en':
en_index = i
break
english = None
if en_index != None:
english = languages.pop(en_index)
languages.sort(key=lambda x: x.name)
if english != None:
languages = [english] + languages
return languages
def remove_package(args):
"""Remove installed package."""
installed_packages = package.get_installed_packages()
package_name = args.name
for installed_package in installed_packages:
name = package.argospm_package_name(installed_package)
if name == package_name:
installed_package.remove()
print(f"Removed package {name}")
break
else:
print("Package not found")
def remove_package(args):
"""Remove installed package."""
installed_packages = package.get_installed_packages()
package_name = args.name
for installed_package in installed_packages:
name = name_of_package(installed_package)
if name == package_name:
installed_package.remove()
print(f'Removed package {name}')
break
else:
print('Package not found')
def populate_packages_table(self):
packages = package.get_installed_packages()
self.packages_table.setRowCount(len(packages))
self.packages_table.setColumnCount(8)
self.packages_table.setHorizontalHeaderLabels([
'Readme',
'From name',
'To name',
'Package version',
'Argos version',
'From code',
'To code',
'Uninstall'
])
self.packages_table.verticalHeader().setVisible(False)
for i, pkg in enumerate(packages):
from_name = pkg.from_name
to_name = pkg.to_name
package_version = pkg.package_version
argos_version = pkg.argos_version
from_code = pkg.from_code
to_code = pkg.to_code
pkg = packages[i]
readme_button = QPushButton('view')
bound_view_package_readme_function = functools.partial(
self.view_package_readme, pkg)
readme_button.clicked.connect(bound_view_package_readme_function)
self.packages_table.setCellWidget(i, 0, readme_button)
self.packages_table.setItem(i, 1, QTableWidgetItem(from_name))
self.packages_table.setItem(i, 2, QTableWidgetItem(to_name))
self.packages_table.setItem(i, 3, QTableWidgetItem(package_version))
self.packages_table.setItem(i, 4, QTableWidgetItem(argos_version))
self.packages_table.setItem(i, 5, QTableWidgetItem(from_code))
self.packages_table.setItem(i, 6, QTableWidgetItem(to_code))
delete_button = QPushButton('x')
bound_delete_function = functools.partial(self.uninstall_package, pkg)
delete_button.clicked.connect(bound_delete_function)
self.packages_table.setCellWidget(i, 7, delete_button)
self.packages_table.resizeColumnsToContents()
self.packages_table.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.packages_table.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.packages_table.setFixedSize(
self.packages_table.horizontalHeader().length() +
self.packages_table.verticalHeader().width(),
self.packages_table.verticalHeader().length() +
self.packages_table.horizontalHeader().height() +
4
)
def check_and_install_models(force=False):
if len(package.get_installed_packages()) < 2 or force:
# Update package definitions from remote
print("Updating language models")
package.update_package_index()
# Load available packages from local package index
available_packages = package.load_available_packages()
print("Found %s models" % len(available_packages))
# Download and install all available packages
for available_package in available_packages:
print("Downloading %s (%s) ..." %
(available_package, available_package.package_version))
download_path = available_package.download()
package.install_from_path(download_path)
print("Loaded support for %s languages (%s models total)!" % (len(
translate.load_installed_languages()), len(available_packages)))
def check_and_install_models(force=False, load_only_lang_codes=None):
if len(package.get_installed_packages()) < 2 or force:
# Update package definitions from remote
print("Updating language models")
package.update_package_index()
# Load available packages from local package index
available_packages = package.load_available_packages()
print("Found %s models" % len(available_packages))
if load_only_lang_codes is not None:
# load_only_lang_codes: List[str] (codes)
# Ensure the user does not use any unavailable language code.
unavailable_lang_codes = set(load_only_lang_codes)
for pack in available_packages:
unavailable_lang_codes -= {pack.from_code, pack.to_code}
if unavailable_lang_codes:
raise ValueError("Unavailable language codes: %s." %
",".join(sorted(unavailable_lang_codes)))
# Keep only the packages that have both from_code and to_code in our list.
available_packages = [
pack for pack in available_packages
if pack.from_code in load_only_lang_codes
and pack.to_code in load_only_lang_codes
]
if not available_packages:
raise ValueError("no available package")
print("Keep %s models" % len(available_packages))
# Download and install all available packages
for available_package in available_packages:
print("Downloading %s (%s) ..." %
(available_package, available_package.package_version))
download_path = available_package.download()
package.install_from_path(download_path)
# reload installed languages
app.language.languages = translate.load_installed_languages()
print("Loaded support for %s languages (%s models total)!" % (len(
translate.load_installed_languages()), len(available_packages)))
def populate_packages_table(self):
packages = package.get_installed_packages()
self.packages_table.setRowCount(len(packages))
for i, pkg in enumerate(packages):
from_name = pkg.from_name
to_name = pkg.to_name
package_version = pkg.package_version
argos_version = pkg.argos_version
from_code = pkg.from_code
to_code = pkg.to_code
pkg = packages[i]
readme_button = QPushButton('view')
bound_view_package_readme_function = functools.partial(
self.view_package_readme, pkg)
readme_button.clicked.connect(bound_view_package_readme_function)
self.packages_table.setCellWidget(i, 0, readme_button)
self.packages_table.setItem(i, 1, QTableWidgetItem(from_name))
self.packages_table.setItem(i, 2, QTableWidgetItem(to_name))
self.packages_table.setItem(i, 3,
QTableWidgetItem(package_version))
self.packages_table.setItem(i, 4, QTableWidgetItem(argos_version))
self.packages_table.setItem(i, 5, QTableWidgetItem(from_code))
self.packages_table.setItem(i, 6, QTableWidgetItem(to_code))
delete_button = QPushButton('x')
bound_delete_function = functools.partial(self.uninstall_package,
pkg)
delete_button.clicked.connect(bound_delete_function)
self.packages_table.setCellWidget(i, 7, delete_button)
# Resize table widget
self.packages_table.setMinimumSize(QSize(0, 0))
self.packages_table.resizeColumnsToContents()
self.packages_table.adjustSize()
# Set minimum width of packages_table that also limits size of packages window
header_width = self.packages_table.horizontalHeader().length()
self.packages_table.setMinimumSize(
QSize(
header_width +
self.packages_table.STRETCH_COLUMN_MIN_PADDING * 2, 0))
def list_packages(args):
"""List packages."""
installed_packages = package.get_installed_packages()
for installed_package in installed_packages:
print(package.argospm_package_name(installed_package))
def get_sbd_package():
packages = package.get_installed_packages()
for pkg in packages:
if pkg.type == "sbd":
return pkg
return None
def get_installed_languages():
"""Returns a list of Languages installed from packages"""
info("get_installed_languages")
if settings.model_provider == settings.ModelProvider.OPENNMT:
packages = package.get_installed_packages()
# If stanza not available filter for sbd available
if not settings.stanza_available:
sbd_packages = list(filter(lambda x: x.type == "sbd", packages))
sbd_available_codes = set()
for sbd_package in sbd_packages:
sbd_available_codes = sbd_available_codes.union(
sbd_package.from_codes)
packages = list(
filter(lambda x: x.from_code in sbd_available_codes, packages))
# Filter for translate packages
packages = list(filter(lambda x: x.type == "translate", packages))
# Load languages and translations from packages
language_of_code = dict()
for pkg in packages:
if pkg.from_code not in language_of_code:
language_of_code[pkg.from_code] = Language(
pkg.from_code, pkg.from_name)
if pkg.to_code not in language_of_code:
language_of_code[pkg.to_code] = Language(
pkg.to_code, pkg.to_name)
from_lang = language_of_code[pkg.from_code]
to_lang = language_of_code[pkg.to_code]
translation_to_add = CachedTranslation(
PackageTranslation(from_lang, to_lang, pkg))
from_lang.translations_from.append(translation_to_add)
to_lang.translations_to.append(translation_to_add)
languages = list(language_of_code.values())
# Add translations so everything can translate to itself
for language in languages:
identity_translation = IdentityTranslation(language)
language.translations_from.append(identity_translation)
language.translations_to.append(identity_translation)
# Pivot through intermediate languages to add translations
# that don't already exist
for language in languages:
keep_adding_translations = True
while keep_adding_translations:
keep_adding_translations = False
for translation in language.translations_from:
for translation_2 in translation.to_lang.translations_from:
if language.get_translation(
translation_2.to_lang) is None:
# The language currently doesn't have a way to translate
# to this language
keep_adding_translations = True
composite_translation = CompositeTranslation(
translation, translation_2)
language.translations_from.append(
composite_translation)
translation_2.to_lang.translations_to.append(
composite_translation)
elif settings.model_provider == settings.ModelProvider.LIBRETRANSLATE:
# TODO: Add API key and custom URL support
libretranslate_api = apis.LibreTranslateAPI()
supported_languages = (libretranslate_api.languages()
) # [{"code":"en", "name":"English"}]
languages = [
Language(l["code"], l["name"]) for l in supported_languages
]
for from_lang in languages:
for to_lang in languages:
translation = LibreTranslateTranslation(
from_lang, to_lang, libretranslate_api)
from_lang.translations_from.append(translation)
to_lang.translations_to.append(translation)
elif settings.model_provider == settings.ModelProvider.OPENAI:
language_model = apis.OpenAIAPI(settings.openai_api_key)
# TODO
languages = [Language("en", "English"), Language("es", "Spanish")]
for from_lang in languages:
for to_lang in languages:
translation = FewShotTranslation(from_lang, to_lang,
language_model)
from_lang.translations_from.append(translation)
to_lang.translations_to.append(translation)
# Put English first if available so it shows up as the from language in the gui
en_index = None
for i, language in enumerate(languages):
if language.code == "en":
en_index = i
break
english = None
if en_index is not None:
english = languages.pop(en_index)
languages.sort(key=lambda x: x.name)
if english is not None:
languages = [english] + languages
return languages
def list_packages(args):
"""List packages."""
installed_packages = package.get_installed_packages()
for installed_package in installed_packages:
print(name_of_package(installed_package))
def get_sbd_translation():
packages = package.get_installed_packages()
for pkg in packages:
if pkg.type == "sbd":
return PackageTranslation(None, None, pkg)
return None
def get_sbd_translation():
packages = package.get_installed_packages()
for pkg in packages:
if pkg.from_code == SBD_FROM_CODE and pkg.to_code == SBD_TO_CODE:
return PackageTranslation(SBD_FROM_CODE, SBD_TO_CODE, pkg)
return None
def test_boot_argos():
"""Test Argos translate models initialization"""
boot(["en", "es"])
assert len(package.get_installed_packages()) >= 2
