def createScaleBar(self, barlen):
pb = QProgressBar(self)
pb.setAlignment(Qt.AlignCenter)
pb.setStyleSheet("QProgressBar {border: solid grey; border-radius: 0px; color: black; } \
QProgressBar::chunk {background-color: #00AAFF; border-radius:0px;}")
pb.setValue(100)
pb.setFixedSize(barlen, 6)
pb.setTextVisible(False)
return pb
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.home_url = None
self.webview = WebView(self)
self.webview.loadFinished.connect(self.load_finished)
self.webview.titleChanged.connect(self.setWindowTitle)
self.webview.urlChanged.connect(self.url_changed)
home_button = create_toolbutton(self, icon=ima.icon('home'),
tip=_("Home"),
triggered=self.go_home)
zoom_out_button = action2button(self.webview.zoom_out_action)
zoom_in_button = action2button(self.webview.zoom_in_action)
pageact2btn = lambda prop: action2button(self.webview.pageAction(prop),
parent=self.webview)
refresh_button = pageact2btn(QWebEnginePage.Reload)
stop_button = pageact2btn(QWebEnginePage.Stop)
previous_button = pageact2btn(QWebEnginePage.Back)
next_button = pageact2btn(QWebEnginePage.Forward)
stop_button.setEnabled(False)
self.webview.loadStarted.connect(lambda: stop_button.setEnabled(True))
self.webview.loadFinished.connect(lambda: stop_button.setEnabled(False))
progressbar = QProgressBar(self)
progressbar.setTextVisible(False)
progressbar.hide()
self.webview.loadStarted.connect(progressbar.show)
self.webview.loadProgress.connect(progressbar.setValue)
self.webview.loadFinished.connect(lambda _state: progressbar.hide())
label = QLabel(self.get_label())
self.url_combo = UrlComboBox(self)
self.url_combo.valid.connect(self.url_combo_activated)
if not WEBENGINE:
self.webview.iconChanged.connect(self.icon_changed)
self.find_widget = FindReplace(self)
self.find_widget.set_editor(self.webview)
self.find_widget.hide()
find_button = create_toolbutton(self, icon=ima.icon('find'),
tip=_("Find text"),
toggled=self.toggle_find_widget)
self.find_widget.visibility_changed.connect(find_button.setChecked)
hlayout = QHBoxLayout()
for widget in (previous_button, next_button, home_button, find_button,
label, self.url_combo, zoom_out_button, zoom_in_button,
refresh_button, progressbar, stop_button):
hlayout.addWidget(widget)
layout = QVBoxLayout()
layout.addLayout(hlayout)
layout.addWidget(self.webview)
layout.addWidget(self.find_widget)
self.setLayout(layout)
def __init__(self, parent=None, options_button=None, handle_links=True):
QWidget.__init__(self, parent)
self.home_url = None
self.webview = WebView(self, handle_links=handle_links)
self.webview.setup()
self.webview.loadFinished.connect(self.load_finished)
self.webview.titleChanged.connect(self.setWindowTitle)
self.webview.urlChanged.connect(self.url_changed)
home_button = create_toolbutton(self,
icon=ima.icon('home'),
tip=_("Home"),
triggered=self.go_home)
zoom_out_button = action2button(self.webview.zoom_out_action)
zoom_in_button = action2button(self.webview.zoom_in_action)
def pageact2btn(prop, icon=None):
return action2button(self.webview.pageAction(prop),
parent=self.webview,
icon=icon)
refresh_button = pageact2btn(QWebEnginePage.Reload,
icon=ima.icon('refresh'))
stop_button = pageact2btn(QWebEnginePage.Stop, icon=ima.icon('stop'))
previous_button = pageact2btn(QWebEnginePage.Back,
icon=ima.icon('previous'))
next_button = pageact2btn(QWebEnginePage.Forward,
icon=ima.icon('next'))
stop_button.setEnabled(False)
self.webview.loadStarted.connect(lambda: stop_button.setEnabled(True))
self.webview.loadFinished.connect(
lambda: stop_button.setEnabled(False))
progressbar = QProgressBar(self)
progressbar.setTextVisible(False)
progressbar.hide()
self.webview.loadStarted.connect(progressbar.show)
self.webview.loadProgress.connect(progressbar.setValue)
self.webview.loadFinished.connect(lambda _state: progressbar.hide())
label = QLabel(self.get_label())
self.url_combo = UrlComboBox(self)
self.url_combo.valid.connect(self.url_combo_activated)
if not WEBENGINE:
self.webview.iconChanged.connect(self.icon_changed)
self.find_widget = FindReplace(self)
self.find_widget.set_editor(self.webview)
self.find_widget.hide()
find_button = create_toolbutton(self,
icon=ima.icon('find'),
tip=_("Find text"),
toggled=self.toggle_find_widget)
self.find_widget.visibility_changed.connect(find_button.setChecked)
hlayout = QHBoxLayout()
for widget in (previous_button, next_button, home_button, find_button,
label, self.url_combo, zoom_out_button, zoom_in_button,
refresh_button, progressbar, stop_button):
hlayout.addWidget(widget)
if options_button:
hlayout.addWidget(options_button)
layout = create_plugin_layout(hlayout)
layout.addWidget(self.webview)
layout.addWidget(self.find_widget)
self.setLayout(layout)
class HomeTab(WidgetBase):
"""Home applications tab."""
# name, prefix, sender
sig_item_selected = Signal(object, object, object)
# button_widget, sender
sig_channels_requested = Signal(object, object)
# application_name, command, prefix, leave_path_alone, sender
sig_launch_action_requested = Signal(object, object, bool, object, object)
# action, application_name, version, sender
sig_conda_action_requested = Signal(object, object, object, object)
# url
sig_url_clicked = Signal(object)
# TODO: Connect these signals to have more granularity
# [{'name': package_name, 'version': version}...], sender
sig_install_action_requested = Signal(object, object)
sig_remove_action_requested = Signal(object, object)
def __init__(self, parent=None):
"""Home applications tab."""
super(HomeTab, self).__init__(parent)
# Variables
self._parent = parent
self.api = AnacondaAPI()
self.applications = None
self.style_sheet = None
self.app_timers = None
self.current_prefix = None
# Widgets
self.list = ListWidgetApplication()
self.button_channels = ButtonHomeChannels('Channels')
self.button_refresh = ButtonHomeRefresh('Refresh')
self.combo = ComboHomeEnvironment()
self.frame_top = FrameTabHeader(self)
self.frame_body = FrameTabContent(self)
self.frame_bottom = FrameTabFooter(self)
self.label_home = LabelHome('Applications on')
self.label_status_action = QLabel('')
self.label_status = QLabel('')
self.progress_bar = QProgressBar()
self.first_widget = self.combo
# Widget setup
self.setObjectName('Tab')
self.progress_bar.setTextVisible(False)
self.list.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
# Layout
layout_top = QHBoxLayout()
layout_top.addWidget(self.label_home)
layout_top.addWidget(SpacerHorizontal())
layout_top.addWidget(self.combo)
layout_top.addWidget(SpacerHorizontal())
layout_top.addWidget(self.button_channels)
layout_top.addWidget(SpacerHorizontal())
layout_top.addStretch()
layout_top.addWidget(self.button_refresh)
self.frame_top.setLayout(layout_top)
layout_body = QVBoxLayout()
layout_body.addWidget(self.list)
self.frame_body.setLayout(layout_body)
layout_bottom = QHBoxLayout()
layout_bottom.addWidget(self.label_status_action)
layout_bottom.addWidget(SpacerHorizontal())
layout_bottom.addWidget(self.label_status)
layout_bottom.addStretch()
layout_bottom.addWidget(self.progress_bar)
self.frame_bottom.setLayout(layout_bottom)
layout = QVBoxLayout()
layout.addWidget(self.frame_top)
layout.addWidget(self.frame_body)
layout.addWidget(self.frame_bottom)
self.setLayout(layout)
# Signals
self.list.sig_conda_action_requested.connect(
self.sig_conda_action_requested)
self.list.sig_url_clicked.connect(self.sig_url_clicked)
self.list.sig_launch_action_requested.connect(
self.sig_launch_action_requested)
self.button_channels.clicked.connect(self.show_channels)
self.button_refresh.clicked.connect(self.refresh_cards)
self.progress_bar.setVisible(False)
# --- Setup methods
# -------------------------------------------------------------------------
def setup(self, conda_data):
"""Setup the tab content."""
conda_processed_info = conda_data.get('processed_info')
environments = conda_processed_info.get('__environments')
applications = conda_data.get('applications')
self.current_prefix = conda_processed_info.get('default_prefix')
self.set_environments(environments)
self.set_applications(applications)
def set_environments(self, environments):
"""Setup the environments list."""
# Disconnect to avoid triggering the signal when updating the content
try:
self.combo.currentIndexChanged.disconnect()
except TypeError:
pass
self.combo.clear()
for i, (env_prefix, env_name) in enumerate(environments.items()):
self.combo.addItem(env_name, env_prefix)
self.combo.setItemData(i, env_prefix, Qt.ToolTipRole)
index = 0
for i, (env_prefix, env_name) in enumerate(environments.items()):
if self.current_prefix == env_prefix:
index = i
break
self.combo.setCurrentIndex(index)
self.combo.currentIndexChanged.connect(self._item_selected)
def set_applications(self, applications):
"""Build the list of applications present in the current conda env."""
apps = self.api.process_apps(applications, prefix=self.current_prefix)
all_applications = []
installed_applications = []
not_installed_applications = []
# Check if some installed applications are not on the apps dict
# for example when the channel was removed.
linked_apps = self.api.conda_linked_apps_info(self.current_prefix)
missing_apps = [app for app in linked_apps if app not in apps]
for app in missing_apps:
apps[app] = linked_apps[app]
for app_name in sorted(list(apps.keys())):
app = apps[app_name]
item = ListItemApplication(name=app['name'],
description=app['description'],
versions=app['versions'],
command=app['command'],
image_path=app['image_path'],
prefix=self.current_prefix,
needs_license=app.get(
'needs_license', False))
if item.installed:
installed_applications.append(item)
else:
not_installed_applications.append(item)
all_applications = installed_applications + not_installed_applications
self.list.clear()
for i in all_applications:
self.list.addItem(i)
self.list.update_style_sheet(self.style_sheet)
self.set_widgets_enabled(True)
self.update_status()
# --- Other methods
# -------------------------------------------------------------------------
def current_environment(self):
"""Return the current selected environment."""
env_name = self.combo.currentText()
return self.api.conda_get_prefix_envname(env_name)
def refresh_cards(self):
"""Refresh application widgets.
List widget items sometimes are hidden on resize. This method tries
to compensate for that refreshing and repainting on user demand.
"""
self.list.update_style_sheet(self.style_sheet)
self.list.repaint()
for item in self.list.items():
if not item.widget.isVisible():
item.widget.repaint()
def show_channels(self):
"""Emit signal requesting the channels dialog editor."""
self.sig_channels_requested.emit(self.button_channels, C.TAB_HOME)
def update_list(self, name=None, version=None):
"""Update applications list."""
self.set_applications()
self.label_status.setVisible(False)
self.label_status_action.setVisible(False)
self.progress_bar.setVisible(False)
def update_versions(self, apps=None):
"""Update applications versions."""
self.items = []
for i in range(self.list.count()):
item = self.list.item(i)
self.items.append(item)
if isinstance(item, ListItemApplication):
name = item.name
meta = apps.get(name)
if meta:
versions = meta['versions']
version = self.api.get_dev_tool_version(item.path)
item.update_versions(version, versions)
# --- Common Helpers (# FIXME: factor out to common base widget)
# -------------------------------------------------------------------------
def _item_selected(self, index):
"""Notify that the item in combo (environment) changed."""
name = self.combo.itemText(index)
prefix = self.combo.itemData(index)
self.sig_item_selected.emit(name, prefix, C.TAB_HOME)
@property
def last_widget(self):
"""Return the last element of the list to be used in tab ordering."""
if self.list.items():
return self.list.items()[-1].widget
def ordered_widgets(self, next_widget=None):
"""Return a list of the ordered widgets."""
ordered_widgets = [
self.combo,
self.button_channels,
self.button_refresh,
]
ordered_widgets += self.list.ordered_widgets()
return ordered_widgets
def set_widgets_enabled(self, value):
"""Enable or disable widgets."""
self.combo.setEnabled(value)
self.button_channels.setEnabled(value)
self.button_refresh.setEnabled(value)
for item in self.list.items():
item.button_install.setEnabled(value)
item.button_options.setEnabled(value)
if value:
item.set_loading(not value)
def update_items(self):
"""Update status of items in list."""
if self.list:
for item in self.list.items():
item.update_status()
def update_status(self, action='', message='', value=None, max_value=None):
"""Update the application action status."""
# Elide if too big
width = QApplication.desktop().availableGeometry().width()
max_status_length = round(width * (2.0 / 3.0), 0)
msg_percent = 0.70
fm = self.label_status_action.fontMetrics()
action = fm.elidedText(action, Qt.ElideRight,
round(max_status_length * msg_percent, 0))
message = fm.elidedText(
message, Qt.ElideRight,
round(max_status_length * (1 - msg_percent), 0))
self.label_status_action.setText(action)
self.label_status.setText(message)
if max_value is None and value is None:
self.progress_bar.setVisible(False)
else:
self.progress_bar.setVisible(True)
self.progress_bar.setMaximum(max_value)
self.progress_bar.setValue(value)
def update_style_sheet(self, style_sheet=None):
"""Update custom CSS style sheet."""
if style_sheet is None:
self.style_sheet = load_style_sheet()
else:
self.style_sheet = style_sheet
self.list.update_style_sheet(style_sheet=self.style_sheet)
self.setStyleSheet(self.style_sheet)
class ProgressView(QWidget):
"""
:type batch_manager: CalculationManager
"""
def __init__(self, parent, batch_manager):
QWidget.__init__(self, parent)
self.calculation_manager = batch_manager
self.whole_progress = QProgressBar(self)
self.whole_progress.setMinimum(0)
self.whole_progress.setMaximum(1)
self.whole_progress.setFormat("%v of %m")
self.whole_progress.setTextVisible(True)
self.part_progress = QProgressBar(self)
self.part_progress.setMinimum(0)
self.part_progress.setMaximum(1)
self.part_progress.setFormat("%v of %m")
self.whole_label = QLabel("All batch progress:", self)
self.part_label = QLabel("Single batch progress:", self)
self.logs = ExceptionList(self)
self.logs.setToolTip("Logs")
self.task_que = QListWidget()
self.process_num_timer = QTimer()
self.process_num_timer.setInterval(1000)
self.process_num_timer.setSingleShot(True)
self.process_num_timer.timeout.connect(self.change_number_of_workers)
self.number_of_process = QSpinBox(self)
self.number_of_process.setRange(1, multiprocessing.cpu_count())
self.number_of_process.setValue(1)
self.number_of_process.setToolTip(
"Number of process used in batch calculation")
self.number_of_process.valueChanged.connect(
self.process_num_timer_start)
layout = QGridLayout()
layout.addWidget(self.whole_label, 0, 0, Qt.AlignRight)
layout.addWidget(self.whole_progress, 0, 1, 1, 2)
layout.addWidget(self.part_label, 1, 0, Qt.AlignRight)
layout.addWidget(self.part_progress, 1, 1, 1, 2)
lab = QLabel("Number of process:")
lab.setToolTip("Number of process used in batch calculation")
layout.addWidget(lab, 2, 0)
layout.addWidget(self.number_of_process, 2, 1)
layout.addWidget(self.logs, 3, 0, 1, 3)
layout.addWidget(self.task_que, 0, 4, 0, 1)
layout.setColumnMinimumWidth(2, 10)
layout.setColumnStretch(2, 1)
self.setLayout(layout)
self.preview_timer = QTimer()
self.preview_timer.setInterval(1000)
self.preview_timer.timeout.connect(self.update_info)
def new_task(self):
self.whole_progress.setMaximum(
self.calculation_manager.calculation_size)
if not self.preview_timer.isActive():
self.update_info()
self.preview_timer.start()
def update_info(self):
res = self.calculation_manager.get_results()
for el in res.errors:
if el[0]:
QListWidgetItem(el[0], self.logs)
ExceptionListItem(el[1], self.logs)
if (state_store.report_errors and parsed_version.is_devrelease
and not isinstance(el[1][0], SegmentationLimitException)
and isinstance(el[1][1], tuple)):
with sentry_sdk.push_scope() as scope:
scope.set_tag("auto_report", "true")
sentry_sdk.capture_event(el[1][1][0])
self.whole_progress.setValue(res.global_counter)
working_search = True
for i, (progress, total) in enumerate(res.jobs_status):
if working_search and progress != total:
self.part_progress.setMaximum(total)
self.part_progress.setValue(progress)
working_search = False
if i < self.task_que.count():
item = self.task_que.item(i)
item.setText("Task {} ({}/{})".format(i, progress, total))
else:
self.task_que.addItem("Task {} ({}/{})".format(
i, progress, total))
if not self.calculation_manager.has_work:
print(
"[ProgressView.update_info]",
self.calculation_manager.has_work,
self.calculation_manager.batch_manager.has_work,
self.calculation_manager.writer.writing_finished(),
)
self.part_progress.setValue(self.part_progress.maximum())
self.preview_timer.stop()
logging.info("Progress stop")
def process_num_timer_start(self):
self.process_num_timer.start()
def update_progress(self, total_progress, part_progress):
self.whole_progress.setValue(total_progress)
self.part_progress.setValue(part_progress)
def set_total_size(self, size):
self.whole_progress.setMaximum(size)
def set_part_size(self, size):
self.part_progress.setMaximum(size)
def change_number_of_workers(self):
self.calculation_manager.set_number_of_workers(
self.number_of_process.value())
class MainDialog(DialogBase):
"""Main dialog for the anaconda navgator updater."""
# Signals
sig_application_updated = Signal()
sig_ready = Signal()
# Class variables
PACKAGE = 'anaconda-navigator'
WIDTH = 450
HEIGHT = 200
def __init__(self, latest_version=None, prefix=None):
"""Main dialog for the anaconda navgator updater."""
super(MainDialog, self).__init__()
# Variables
self.api = CondaAPI()
self.prefix = prefix or os.environ.get('CONDA_PREFIX',
self.api.ROOT_PREFIX)
self.info = {}
self.first_run = True
self.setup_ready = False
self.busy = False
self.up_to_date = False
self.error = False
self.success = False
self.status = ''
self.current_version = None
self.latest_version = latest_version
self.style_sheet = load_style_sheet()
self.timer = QTimer()
self.timer_2 = QTimer()
self._windows_appusermodelid = None
# Widgets
self.message_box = None # For testing
self.label_icon = QSvgWidget()
self.label_message = LabelBase(
"There's a new version of Anaconda Navigator available. "
"We strongly recommend you to update.")
self.label_status = LabelBase('')
self.progress_bar = QProgressBar()
self.button_cancel = ButtonNormal('Dismiss')
self.button_update = ButtonPrimary('Update now')
self.button_launch = ButtonPrimary('Launch Navigator')
# Widgets setup
if WIN:
self._windows_appusermodelid = set_windows_appusermodelid()
self.setMinimumSize(self.WIDTH, self.HEIGHT)
self.label_message.setAlignment(Qt.AlignLeft | Qt.AlignTop)
self.label_message.setWordWrap(True)
self.label_status.setWordWrap(True)
self.button_update.setAutoDefault(True)
self.button_launch.setAutoDefault(True)
self.button_cancel.setFocusPolicy(Qt.NoFocus)
self.timer.setInterval(1000)
self.timer_2.setInterval(5000)
self.progress_bar.setTextVisible(False)
self.progress_bar.setStyleSheet(self.style_sheet)
self.label_icon.load(images.ANACONDA_LOGO)
self.label_icon.setMaximumSize(QSize(64, 64))
self.label_icon.setMinimumSize(QSize(64, 64))
self.setWindowTitle('Anaconda Navigator Updater')
self.progress_bar.setMaximumWidth(self.WIDTH / 3)
self.setMinimumWidth(self.WIDTH)
self.setMaximumWidth(self.WIDTH)
self.setMinimumHeight(self.HEIGHT)
# Layouts
layout_status = QHBoxLayout()
layout_status.addWidget(self.label_status)
layout_status.addWidget(SpacerHorizontal())
layout_status.addWidget(self.progress_bar)
layout_text = QVBoxLayout()
layout_text.addWidget(self.label_message)
layout_text.addStretch()
layout_text.addWidget(SpacerVertical())
layout_text.addLayout(layout_status)
layout_icon = QVBoxLayout()
layout_icon.addWidget(self.label_icon)
layout_icon.addStretch()
layout_top = QHBoxLayout()
layout_top.addLayout(layout_icon)
layout_top.addWidget(SpacerHorizontal())
layout_top.addLayout(layout_text)
layout_buttons = QHBoxLayout()
layout_buttons.addStretch()
layout_buttons.addWidget(self.button_cancel)
layout_buttons.addWidget(SpacerHorizontal())
layout_buttons.addWidget(self.button_update)
layout_buttons.addWidget(self.button_launch)
layout = QVBoxLayout()
layout.addLayout(layout_top)
layout.addWidget(SpacerVertical())
layout.addWidget(SpacerVertical())
layout.addStretch()
layout.addLayout(layout_buttons)
self.setLayout(layout)
# Signals
self.button_update.clicked.connect(self.install_update)
self.button_cancel.clicked.connect(self.reject)
self.button_launch.clicked.connect(self.launch)
self.timer.timeout.connect(self.refresh)
self.timer_2.timeout.connect(self.check_conditions)
# Setup
self.timer.start()
self.timer_2.start()
self.check_conditions()
self.refresh()
def check_conditions(self):
"""Check every 5 seconds installed packages in case codna was used."""
packages = self.api.linked(prefix=self.prefix)
package = [p for p in packages if self.PACKAGE in p]
if package:
n, v, b = self.api.split_canonical_name(package[0])
self.current_version = v
else:
self.current_version = None
if self.latest_version is None:
worker_search = self.api.search(self.PACKAGE,
platform=self.api.get_platform())
worker_search.sig_finished.connect(self._search_callback)
else:
worker = self.api.info()
worker.sig_finished.connect(self.setup)
self.check_versions()
def check_versions(self):
"""Check if navigator is up to date."""
if self.latest_version and self.current_version:
from distutils.version import LooseVersion
cur_ver = LooseVersion(self.current_version)
lat_ver = LooseVersion(self.latest_version)
self.up_to_date = cur_ver >= lat_ver
else:
self.up_to_date = False
def _search_callback(self, worker, output, error):
"""Setup the widget."""
if isinstance(output, dict):
packages = output.get(self.PACKAGE, [])
versions = [package.get('version') for package in packages]
unique_versions = []
for version in versions:
if version not in unique_versions:
unique_versions.append(version)
if unique_versions:
self.latest_version = unique_versions[-1]
self.check_versions()
worker = self.api.info()
worker.sig_finished.connect(self.setup)
self.refresh()
def setup(self, worker, info, error):
"""Setup the widget."""
self.info = info
self.setup_ready = True
self.sig_ready.emit()
self.refresh()
if self.button_update.isVisible():
self.button_update.setFocus()
if self.button_launch.isVisible():
self.button_launch.setFocus()
def update_style_sheet(self):
"""Update custom CSS style sheet."""
self.style_sheet = load_style_sheet()
self.setStyleSheet(self.style_sheet)
def refresh(self):
"""Refresh enabled/disabled status of widgets."""
current_version = 'Not installed'
if self.current_version:
current_version = self.current_version
latest_version = '-'
if self.latest_version:
latest_version = self.latest_version
main_message = (
"Current version: <i>{0}</i><br>"
"Available version: <b>{1}</b><br>").format(
current_version, latest_version)
message = self.status
running = self.check_running()
self.button_launch.setVisible(False)
if not self.setup_ready:
self.button_update.setDisabled(True)
self.progress_bar.setVisible(True)
message = 'Updating index...'
self.update_status(message)
elif self.busy:
self.button_update.setDisabled(True)
self.progress_bar.setVisible(True)
else:
self.progress_bar.setVisible(False)
if running:
message = 'Please close Anaconda Navigator before updating.'
self.button_update.setDisabled(running)
elif not running:
self.button_update.setDisabled(False)
if self.success and self.current_version:
message = 'Anaconda Navigator was updated successfully.'
self.button_update.setVisible(False)
self.button_launch.setVisible(True)
elif self.up_to_date:
message = 'Anaconda Navigator is already up to date.'
self.button_update.setVisible(False)
self.button_launch.setVisible(True)
elif not self.error:
self.button_update.setVisible(True)
if self.current_version:
message = ('An update for Anaconda Navigator is now '
'available.')
self.button_update.setText('Update now')
else:
message = (
'Anaconda Navigator is available for install.')
self.button_update.setText('Install now')
if self.error:
self.button_update.setDisabled(False)
message = 'Cannot update Anaconda Navigator, <b>{0}</b>'
message = message.format(self.error)
self.label_status.setText(message)
self.label_message.setText(main_message)
def update_status(self, status='', value=-1, max_val=-1):
"""Update progress bar and message status."""
if status:
self.status = status
self.label_status.setText(status)
if value < 0 and max_val < 0:
self.progress_bar.setRange(0, 0)
else:
self.progress_bar.setMinimum(0)
self.progress_bar.setMaximum(max_val)
self.progress_bar.setValue(value)
def check_running(self):
"""Check if Anaconda Navigator is running."""
# Create file lock
lock = filelock.FileLock(NAVIGATOR_LOCKFILE)
try:
running = False
with lock.acquire(timeout=0.01):
pass
except filelock.Timeout:
running = True
return running
# --- Conda actions and helpers
# -------------------------------------------------------------------------
def partial_output_ready(self, worker, output, error):
"""Handle conda partial output ready."""
self.busy = True
# print(type(output))
# print(output)
# Get errors and data from ouput if it exists
fetch = None
if output and isinstance(output, dict):
fetch = output.get('fetch')
max_val = output.get('maxval', -1)
value = output.get('progress', -1)
if fetch:
status = 'Fetching <b>{0}</b>...'.format(fetch)
self.update_status(status=status, max_val=max_val, value=value)
def output_ready(self, worker, output, error):
"""Handle conda output ready."""
self.check_conditions()
# Get errors and data from ouput if it exists
error_text = output.get('error', '')
exception_type = output.get('exception_type', '')
exception_name = output.get('exception_name', '')
success = output.get('success')
actions = output.get('actions', {})
# op_order = output.get('op_order', [])
# action_check_fetch = actions.get('CHECK_FETCH', [])
# action_rm_fetch = actions.get('RM_FETCHED', [])
# action_fetch = actions.get('FETCH', [])
# action_check_extract = actions.get('CHECK_EXTRACT', [])
# action_rm_extract = actions.get('RM_EXTRACTED', [])
# action_extract = actions.get('EXTRACT', [])
# action_unlink = actions.get('UNLINK', [])
action_link = actions.get('LINK', [])
# action_symlink_conda = actions.get('SYMLINK_CONDA', [])
self.busy = False
# Get errors from json output
if error_text or exception_type or exception_name or not success:
self.error = exception_name
self.success = False
self.up_to_date = False
elif success and action_link:
self.sig_application_updated.emit()
self.error = None
self.success = True
self.up_to_date = False
elif success:
self.success = False
self.error = None
self.up_to_date = True
worker.lock.release()
self.refresh()
def install_update(self):
"""Install the specified version or latest version of navigator."""
self.busy = True
self.refresh()
# conda_prefix = self.info.et('conda_prefix')
# root_prefix = self.info.et('root_prefix')
navigator_prefixes = [
# os.path.join(self.api.ROOT_PREFIX, 'envs', '_navigator_'),
# os.path.join(self.api.ROOT_PREFIX, 'envs', '_conda_'),
self.prefix,
]
for prefix in navigator_prefixes:
if self.api.environment_exists(prefix=prefix):
break
if self.latest_version:
pkgs = ['{0}=={1}'.format(self.PACKAGE, self.latest_version)]
else:
pkgs = [self.PACKAGE.format(self.latest_version)]
# Lock Navigator
lock = filelock.FileLock(NAVIGATOR_LOCKFILE)
lock.acquire()
worker = self.api.install(prefix=prefix, pkgs=pkgs)
worker.lock = lock
worker.sig_partial.connect(self.partial_output_ready)
worker.sig_finished.connect(self.output_ready)
self.refresh()
if self.prefix == self.api.ROOT_PREFIX:
name = 'root'
else:
name = os.path.basename(self.prefix)
self.button_launch.setFocus()
if self.current_version:
msg = 'Updating package on <b>{0}</b>...'.format(name)
else:
msg = 'Installing package on <b>{0}</b>...'.format(name)
self.update_status(msg)
def launch(self):
"""Launch Anaconda Navigator."""
leave_path_alone = True
root_prefix = self.api.ROOT_PREFIX
prefix = self.prefix
command = ['anaconda-navigator']
# Use the app bundle on OSX
if MAC:
command = ['open', os.path.join(prefix, 'Anaconda-Navigator.app')]
launch_cmd(
prefix,
command,
leave_path_alone,
package_name='anaconda-navigator-app',
root_prefix=root_prefix,
)
self.close()
# --- Qt Overrides
# -------------------------------------------------------------------------
def reject(self):
"""Override Qt method."""
if self.busy:
msg_box = MessageBoxQuestion(title='Quit Navigator Updater?',
text='Anaconda Navigator is being '
'updated. <br><br>'
'Are you sure you want to quit?')
if msg_box.exec_():
super(MainDialog, self).reject()
else:
super(MainDialog, self).reject()
class RunDialog(QDialog):
simulation_done = Signal(bool, str)
simulation_termination_request = Signal()
def __init__(self,
config_file,
run_model,
simulation_arguments,
parent=None):
QDialog.__init__(self, parent)
self.setWindowFlags(Qt.Window)
self.setWindowFlags(self.windowFlags()
& ~Qt.WindowContextHelpButtonHint)
self.setModal(True)
self.setWindowModality(Qt.WindowModal)
self.setWindowTitle("Simulations - {}".format(config_file))
self._snapshot_model = SnapshotModel(self)
self._run_model = run_model
self._isDetailedDialog = False
self._minimum_width = 1200
ert = None
if isinstance(run_model, BaseRunModel):
ert = run_model.ert()
self._simulations_argments = simulation_arguments
self._ticker = QTimer(self)
self._ticker.timeout.connect(self._on_ticker)
progress_proxy_model = ProgressProxyModel(self._snapshot_model,
parent=self)
self._total_progress_label = QLabel(_TOTAL_PROGRESS_TEMPLATE.format(0),
self)
self._total_progress_bar = QProgressBar(self)
self._total_progress_bar.setRange(0, 100)
self._total_progress_bar.setTextVisible(False)
self._iteration_progress_label = QLabel(self)
self._progress_view = ProgressView(self)
self._progress_view.setModel(progress_proxy_model)
self._progress_view.setIndeterminate(True)
legend_view = LegendView(self)
legend_view.setModel(progress_proxy_model)
self._tab_widget = QTabWidget(self)
self._snapshot_model.rowsInserted.connect(self.on_new_iteration)
self._job_label = QLabel(self)
self._job_model = JobListProxyModel(self, 0, 0, 0, 0)
self._job_model.setSourceModel(self._snapshot_model)
self._job_view = QTableView(self)
self._job_view.clicked.connect(self._job_clicked)
self._open_files = {}
self._job_view.setModel(self._job_model)
self.running_time = QLabel("")
self.plot_tool = PlotTool(config_file)
self.plot_tool.setParent(self)
self.plot_button = QPushButton(self.plot_tool.getName())
self.plot_button.clicked.connect(self.plot_tool.trigger)
self.plot_button.setEnabled(ert is not None)
self.kill_button = QPushButton("Kill Simulations")
self.done_button = QPushButton("Done")
self.done_button.setHidden(True)
self.restart_button = QPushButton("Restart")
self.restart_button.setHidden(True)
self.show_details_button = QPushButton("Show Details")
self.show_details_button.setCheckable(True)
size = 20
spin_movie = resourceMovie("ide/loading.gif")
spin_movie.setSpeed(60)
spin_movie.setScaledSize(QSize(size, size))
spin_movie.start()
self.processing_animation = QLabel()
self.processing_animation.setMaximumSize(QSize(size, size))
self.processing_animation.setMinimumSize(QSize(size, size))
self.processing_animation.setMovie(spin_movie)
button_layout = QHBoxLayout()
button_layout.addWidget(self.processing_animation)
button_layout.addWidget(self.running_time)
button_layout.addStretch()
button_layout.addWidget(self.show_details_button)
button_layout.addWidget(self.plot_button)
button_layout.addWidget(self.kill_button)
button_layout.addWidget(self.done_button)
button_layout.addWidget(self.restart_button)
button_widget_container = QWidget()
button_widget_container.setLayout(button_layout)
layout = QVBoxLayout()
layout.addWidget(self._total_progress_label)
layout.addWidget(self._total_progress_bar)
layout.addWidget(self._iteration_progress_label)
layout.addWidget(self._progress_view)
layout.addWidget(legend_view)
layout.addWidget(self._tab_widget)
layout.addWidget(self._job_label)
layout.addWidget(self._job_view)
layout.addWidget(button_widget_container)
self.setLayout(layout)
self.kill_button.clicked.connect(self.killJobs)
self.done_button.clicked.connect(self.accept)
self.restart_button.clicked.connect(self.restart_failed_realizations)
self.show_details_button.clicked.connect(self.toggle_detailed_progress)
self.simulation_done.connect(self._on_simulation_done)
self.setMinimumWidth(self._minimum_width)
self._setSimpleDialog()
def _setSimpleDialog(self) -> None:
self._isDetailedDialog = False
self._tab_widget.setVisible(False)
self._job_label.setVisible(False)
self._job_view.setVisible(False)
self.show_details_button.setText("Show Details")
def _setDetailedDialog(self) -> None:
self._isDetailedDialog = True
self._tab_widget.setVisible(True)
self._job_label.setVisible(True)
self._job_view.setVisible(True)
self.show_details_button.setText("Hide Details")
@Slot(QModelIndex, int, int)
def on_new_iteration(self, parent: QModelIndex, start: int,
end: int) -> None:
if not parent.isValid():
iter = start
self._iteration_progress_label.setText(
f"Progress for iteration {iter}")
widget = RealizationWidget(iter)
widget.setSnapshotModel(self._snapshot_model)
widget.currentChanged.connect(self._select_real)
self._tab_widget.addTab(widget,
f"Realizations for iteration {iter}")
@Slot(QModelIndex)
def _job_clicked(self, index):
if not index.isValid():
return
selected_file = index.data(FileRole)
if selected_file and selected_file not in self._open_files:
job_name = index.siblingAtColumn(0).data()
viewer = FileDialog(
selected_file,
job_name,
index.row(),
index.model().get_real(),
index.model().get_iter(),
self,
)
self._open_files[selected_file] = viewer
viewer.finished.connect(
lambda _, f=selected_file: self._open_files.pop(f))
elif selected_file in self._open_files:
self._open_files[selected_file].raise_()
@Slot(QModelIndex)
def _select_real(self, index):
step = 0
stage = 0
real = index.row()
iter_ = index.model().get_iter()
self._job_model.set_step(iter_, real, stage, step)
self._job_label.setText(
f"Realization id {index.data(RealIens)} in iteration {iter_}")
self._job_view.horizontalHeader().setSectionResizeMode(
QHeaderView.Stretch)
# Clear the selection in the other tabs
for i in range(0, self._tab_widget.count()):
if i != self._tab_widget.currentIndex():
self._tab_widget.widget(i).clearSelection()
def reject(self):
return
def closeEvent(self, QCloseEvent):
if self._run_model.isFinished():
self.simulation_done.emit(self._run_model.hasRunFailed(),
self._run_model.getFailMessage())
else:
# Kill jobs if dialog is closed
if self.killJobs() != QMessageBox.Yes:
QCloseEvent.ignore()
def startSimulation(self):
self._run_model.reset()
self._snapshot_model.reset()
self._tab_widget.clear()
def run():
asyncio.set_event_loop(asyncio.new_event_loop())
self._run_model.startSimulations(self._simulations_argments)
simulation_thread = Thread(name="ert_gui_simulation_thread")
simulation_thread.setDaemon(True)
simulation_thread.run = run
simulation_thread.start()
self._ticker.start(1000)
tracker = create_tracker(
self._run_model,
num_realizations=self._simulations_argments["active_realizations"].
count(),
ee_config=self._simulations_argments.get("ee_config", None),
)
worker = TrackerWorker(tracker)
worker_thread = QThread()
worker.done.connect(worker_thread.quit)
worker.consumed_event.connect(self._on_tracker_event)
worker.moveToThread(worker_thread)
self.simulation_done.connect(worker.stop)
self._worker = worker
self._worker_thread = worker_thread
worker_thread.started.connect(worker.consume_and_emit)
self._worker_thread.start()
def killJobs(self):
msg = "Are you sure you want to kill the currently running simulations?"
if self._run_model.getQueueStatus().get(
JobStatusType.JOB_QUEUE_UNKNOWN, 0) > 0:
msg += "\n\nKilling a simulation with unknown status will not kill the realizations already submitted!"
kill_job = QMessageBox.question(self, "Kill simulations?", msg,
QMessageBox.Yes | QMessageBox.No)
if kill_job == QMessageBox.Yes:
# Normally this slot would be invoked by the signal/slot system,
# but the worker is busy tracking the evaluation.
self._worker.request_termination()
self.reject()
return kill_job
@Slot(bool, str)
def _on_simulation_done(self, failed, failed_msg):
self.processing_animation.hide()
self.kill_button.setHidden(True)
self.done_button.setHidden(False)
self.restart_button.setVisible(self.has_failed_realizations())
self.restart_button.setEnabled(self._run_model.support_restart)
self._total_progress_bar.setValue(100)
self._total_progress_label.setText(
_TOTAL_PROGRESS_TEMPLATE.format(100))
if failed:
QMessageBox.critical(
self,
"Simulations failed!",
f"The simulation failed with the following error:\n\n{failed_msg}",
)
@Slot()
def _on_ticker(self):
runtime = self._run_model.get_runtime()
self.running_time.setText(format_running_time(runtime))
@Slot(object)
def _on_tracker_event(self, event):
if isinstance(event, EndEvent):
self.simulation_done.emit(event.failed, event.failed_msg)
self._worker.stop()
self._ticker.stop()
elif isinstance(event, FullSnapshotEvent):
if event.snapshot is not None:
self._snapshot_model._add_snapshot(event.snapshot,
event.iteration)
self._progress_view.setIndeterminate(event.indeterminate)
progress = int(event.progress * 100)
self._total_progress_bar.setValue(progress)
self._total_progress_label.setText(
_TOTAL_PROGRESS_TEMPLATE.format(progress))
elif isinstance(event, SnapshotUpdateEvent):
if event.partial_snapshot is not None:
self._snapshot_model._add_partial_snapshot(
event.partial_snapshot, event.iteration)
self._progress_view.setIndeterminate(event.indeterminate)
progress = int(event.progress * 100)
self._total_progress_bar.setValue(progress)
self._total_progress_label.setText(
_TOTAL_PROGRESS_TEMPLATE.format(progress))
def has_failed_realizations(self):
completed = self._run_model.completed_realizations_mask
initial = self._run_model.initial_realizations_mask
for (index, successful) in enumerate(completed):
if initial[index] and not successful:
return True
return False
def count_successful_realizations(self):
"""
Counts the realizations completed in the prevoius ensemble run
:return:
"""
completed = self._run_model.completed_realizations_mask
return completed.count(True)
def create_mask_from_failed_realizations(self):
"""
Creates a BoolVector mask representing the failed realizations
:return: Type BoolVector
"""
completed = self._run_model.completed_realizations_mask
initial = self._run_model.initial_realizations_mask
inverted_mask = BoolVector(default_value=False)
for (index, successful) in enumerate(completed):
inverted_mask[index] = initial[index] and not successful
return inverted_mask
def restart_failed_realizations(self):
msg = QMessageBox(self)
msg.setIcon(QMessageBox.Information)
msg.setText(
"Note that workflows will only be executed on the restarted realizations and that this might have unexpected consequences."
)
msg.setWindowTitle("Restart Failed Realizations")
msg.setStandardButtons(QMessageBox.Ok | QMessageBox.Cancel)
result = msg.exec_()
if result == QMessageBox.Ok:
self.restart_button.setVisible(False)
self.kill_button.setVisible(True)
self.done_button.setVisible(False)
active_realizations = self.create_mask_from_failed_realizations()
self._simulations_argments[
"active_realizations"] = active_realizations
self._simulations_argments[
"prev_successful_realizations"] = self._simulations_argments.get(
"prev_successful_realizations", 0)
self._simulations_argments[
"prev_successful_realizations"] += self.count_successful_realizations(
)
self.startSimulation()
@Slot()
def toggle_detailed_progress(self):
if self._isDetailedDialog:
self._setSimpleDialog()
else:
self._setDetailedDialog()
self.adjustSize()
class BatchProcessingView(View):
btn_run_batch: QPushButton
progress_bar: QProgressBar
field_channel: QLineEdit
field_workflow_config: FileInput
field_input_dir: FileInput
field_output_dir: FileInput
def __init__(self, controller: IBatchProcessingController):
super().__init__(template_class=MainTemplate)
if controller is None:
raise ValueError("controller")
self._controller = controller
self.setObjectName("batchProcessingView")
def load(self, model=None):
self._setup_ui()
def _setup_ui(self):
"""
Set up the UI for the BatchProcessingView
"""
layout = QVBoxLayout()
self.setLayout(layout)
# Workflow config
self.field_workflow_config = FileInput(
mode=FileInputMode.FILE, filter="Json file (*.json)", placeholder_text="Load a JSON workflow file..."
)
self.field_workflow_config.file_selected.connect(self._form_field_changed)
row1 = FormRow("1. Load workflow:", self.field_workflow_config)
# Channel index
self.field_channel = QLineEdit("0")
self.field_channel.setValidator(QIntValidator(bottom=0))
self.field_channel.textChanged.connect(self._form_field_changed)
row2 = FormRow("2. Structure channel index:", self.field_channel)
# Input dir
self.field_input_dir = FileInput(mode=FileInputMode.DIRECTORY, placeholder_text="Select a directory...")
self.field_input_dir.file_selected.connect(self._form_field_changed)
row3 = FormRow("3. Input directory:", self.field_input_dir)
# Output dir
self.field_output_dir = FileInput(mode=FileInputMode.DIRECTORY, placeholder_text="Select a directory...")
self.field_output_dir.file_selected.connect(self._form_field_changed)
row4 = FormRow("4. Output directory:", self.field_output_dir)
# Help
label = QLabel()
label.setText("Supported file formats: .tif, .tiff, .czi, .ome.tif, .ome.tiff")
form = QWidget()
form.setLayout(Form([row1, row2, row3, row4]))
layout.addWidget(form)
layout.addWidget(label)
# Submit
self.btn_run_batch = QPushButton("Run Batch")
self.btn_run_batch.clicked.connect(self._btn_run_batch_clicked)
self.update_button(enabled=False)
layout.addWidget(self.btn_run_batch)
# Progress bar
self.progress_bar = QProgressBar()
self.progress_bar.setRange(0, 100)
self.progress_bar.setValue(0)
self.progress_bar.setTextVisible(True)
self.progress_bar.setVisible(False)
layout.addWidget(self.progress_bar)
def update_button(self, enabled: bool):
"""
Update state of process button
Inputs:
enabled: True to enable the button, false to disable it
"""
self.btn_run_batch.setEnabled(enabled)
def set_run_batch_in_progress(self):
"""
Update page to reflect that a batch run is in progress
"""
# TODO make a CancelButton widget to avoid repeating this connect / disconnect pattern
self.btn_run_batch.setText("Cancel")
self.btn_run_batch.clicked.disconnect()
self.btn_run_batch.clicked.connect(self._btn_run_batch_cancel_clicked)
self.progress_bar.setVisible(True)
def reset_run_batch(self):
"""
Reset page state to reflect that there is no batch run in progress
"""
self.progress_bar.setValue(0)
self.btn_run_batch.setText("Run Batch")
self.btn_run_batch.clicked.disconnect()
self.btn_run_batch.clicked.connect(self._btn_run_batch_clicked)
self.progress_bar.setVisible(False)
def set_progress(self, progress: int):
"""
Update progress bar
Inputs:
progress (int): numerical value to set the progress bar to
"""
self.progress_bar.setValue(progress)
#####################################################################
# Event handlers
#####################################################################
def _btn_run_batch_clicked(self):
self._controller.run_batch()
def _btn_run_batch_cancel_clicked(self):
self.btn_run_batch.setText("Canceling...")
self._controller.cancel_run_batch()
def _form_field_changed(self, value):
workflow_config = self.field_workflow_config.selected_file
channel_index = int(self.field_channel.text()) if self.field_channel.text() else None
input_dir = self.field_input_dir.selected_file
output_dir = self.field_output_dir.selected_file
self._controller.update_batch_parameters(workflow_config, channel_index, input_dir, output_dir)
class EmailReport(QWidget):
emailSentSignal = Signal()
def __init__(self, info='', report='', toemail=None, fromemail=None, password=None, server=None, port=25,
subject='Report', parent=None):
super().__init__(parent=parent)
self._info = str(info) # infomation reported
self._report = str(report) # report
self._toemail = str(toemail)
self._subject = str(subject)
mainLayout = QVBoxLayout(self)
mainLayout.setContentsMargins(0, 0, 0, 0)
mainLayout.setSpacing(0)
self.setStyleSheet("background-color: white;")
# information
self.infoText = QLabel(self._info)
self.infoText.setWordWrap(True)
self.infoText.setAlignment(Qt.AlignLeft | Qt.AlignTop)
self.infoText.setFont(QFont('Mcorsoft YaHei', 11, 50))
self.infoText.setStyleSheet("color:rgb(130,130,130); padding:10px;")
self.infoText.setFrameStyle(QFrame.Box|QFrame.Raised)
# report
self.reportText = QLabel(self._report)
self.reportText.setWordWrap(True)
self.reportText.setAlignment(Qt.AlignLeft | Qt.AlignTop)
self.reportText.setFont(QFont('Mcorsoft YaHei', 11, 50))
self.reportText.setStyleSheet("color:rgb(130,130,130); padding:10px;")
self.reportText.setFrameStyle(QFrame.Box|QFrame.Raised)
self.reportText.hide()
# 邮件地址
self.emailWidget = Email(email=fromemail, password=password, server=server, port=port, parent=self)
# 邮件发送按钮
buttonLayout = QHBoxLayout()
buttonLayout.setContentsMargins(10, 10, 10, 10)
buttonLayout.setSpacing(0)
buttonLayout.setAlignment(Qt.AlignHCenter)
emailSendButton = QPushButton()
emailSendButton.setText("发送邮件")
# 绑定点击事件处理函数
emailSendButton.clicked.connect(self.sendEmail)
emailSendButton.setStyleSheet(
"QPushButton{font:63 11pt 微软雅黑;border:0px; border-radius:3px; color:#FFFFFF; background-color:#2278C6}"
"QPushButton:hover{font:63 11pt 微软雅黑;border:0px; border-radius:3px;background-color:#1891FF;}"
)
buttonLayout.addWidget(emailSendButton)
# 进度条
self.progressBar = QProgressBar(self)
self.progressBar.setRange(0, 10)
self.progressBar.setTextVisible(False)
self.progressBar.setMaximumHeight(5)
# 将控件放入布局中
mainLayout.addWidget(self.infoText)
mainLayout.addWidget(self.reportText)
mainLayout.addWidget(self.emailWidget)
mainLayout.addLayout(buttonLayout)
mainLayout.addWidget(self.progressBar)
def sendEmail(self):
successFlag = True
subject = self.subject()
report = self.report()
toemail = self.toemail()
server = self.server()
port = self.port()
fromemail = self.fromemail()
password = self.password()
self.progressBar.setValue(2)
if successFlag:
try:
message = MIMEText(report, 'plain', 'utf-8')
message['From'] = Header(formataddr(('Reporter', fromemail)), 'utf-8') # 发送者
message['To'] = Header(formataddr(('Handler', toemail)), 'utf-8') # 接收者
message['Subject'] = Header(subject, 'utf-8')
self.progressBar.setValue(4)
except:
showQuickMessage(title='error', text='请输入合法的邮箱', icon=QMessageBox.Critical, parent=self)
successFlag = False
if successFlag:
try:
with smtplib.SMTP() as smtpObj:
smtpObj.connect(server, port)
smtpObj.login(fromemail, password)
self.progressBar.setValue(6)
smtpObj.sendmail(fromemail, [toemail], message.as_string())
self.progressBar.setValue(10)
showQuickMessage(title='info', text="邮件发送完成", icon=QMessageBox.Information, parent=self)
except:
showQuickMessage(title='error',
text=textwrap.dedent("""
邮件发送失败，请检查
1)网络是否连接。
2)邮箱账号密码是否输入正确
3)邮箱是否与服务器对应"""),
icon=QMessageBox.Critical,
parent=self)
successFlag = False
if successFlag:
self.emailSentSignal.emit()
self.progressBar.reset()
def subject(self):
return self._subject
def setSubject(self, subject):
self._subject = str(subject)
def info(self):
return self._info
def setInfo(self, info):
self._info = str(info)
self.infoText.setText(self._info)
def report(self):
return self._report
def setReport(self, report):
self._report = str(report)
self.reportText.setText(self._report)
def setReportVisible(self, visible=True):
if visible:
self.reportText.show()
else:
self.reportText.hide()
def showReport(self):
self.setReportVisible(True)
def hideReport(self):
self.setReportVisible(False)
def server(self):
return self.emailWidget.server()
def setServer(self, server):
self.emailWidget.setServer(server)
def port(self):
return self.emailWidget.port()
def setPort(self, port):
self.emailWidget.setPort(port)
def fromemail(self):
return self.emailWidget.email()
def setFromemail(self, email):
self.emailWidget.setEmail(email)
def toemail(self):
return self._toemail
def setToemail(self, email):
self._toemail = email
def password(self):
return self.emailWidget.password()
def setPassword(self, password):
self.emailWidget.setPassword(password)
class ProgressView(QWidget):
"""
:type batch_manager: CalculationManager
"""
def __init__(self, parent, batch_manager):
super().__init__(parent)
self.task_count = 0
self.calculation_manager = batch_manager
self.whole_progress = QProgressBar(self)
self.whole_progress.setMinimum(0)
self.whole_progress.setMaximum(1)
self.whole_progress.setFormat("%v of %m")
self.whole_progress.setTextVisible(True)
self.part_progress = QProgressBar(self)
self.part_progress.setMinimum(0)
self.part_progress.setMaximum(1)
self.part_progress.setFormat("%v of %m")
self.whole_label = QLabel("All batch progress:", self)
self.part_label = QLabel("Single batch progress:", self)
self.cancel_remove_btn = QPushButton("Remove task")
self.cancel_remove_btn.setDisabled(True)
self.logs = ExceptionList(self)
self.logs.setToolTip("Logs")
self.task_view = QListView()
self.task_que = QStandardItemModel(self)
self.task_view.setModel(self.task_que)
self.process_num_timer = QTimer()
self.process_num_timer.setInterval(1000)
self.process_num_timer.setSingleShot(True)
self.process_num_timer.timeout.connect(self.change_number_of_workers)
self.number_of_process = QSpinBox(self)
self.number_of_process.setRange(1, multiprocessing.cpu_count())
self.number_of_process.setValue(1)
self.number_of_process.setToolTip(
"Number of process used in batch calculation")
self.number_of_process.valueChanged.connect(
self.process_num_timer_start)
self.progress_item_dict = {}
layout = QGridLayout()
layout.addWidget(self.whole_label, 0, 0, Qt.AlignRight)
layout.addWidget(self.whole_progress, 0, 1, 1, 2)
layout.addWidget(self.part_label, 1, 0, Qt.AlignRight)
layout.addWidget(self.part_progress, 1, 1, 1, 2)
lab = QLabel("Number of process:")
lab.setToolTip("Number of process used in batch calculation")
layout.addWidget(lab, 2, 0)
layout.addWidget(self.number_of_process, 2, 1)
layout.addWidget(self.logs, 3, 0, 2, 3)
layout.addWidget(self.task_view, 0, 4, 4, 1)
layout.addWidget(self.cancel_remove_btn, 4, 4, 1, 1)
layout.setColumnMinimumWidth(2, 10)
layout.setColumnStretch(2, 1)
self.setLayout(layout)
self.preview_timer = QTimer()
self.preview_timer.setInterval(1000)
self.preview_timer.timeout.connect(self.update_info)
self.task_view.selectionModel().currentChanged.connect(
self.task_selection_change)
self.cancel_remove_btn.clicked.connect(self.task_cancel_remove)
def task_selection_change(self, new, old):
task: CalculationProcessItem = self.task_que.item(
new.row(), new.column())
if task is None:
self.cancel_remove_btn.setDisabled(True)
return
self.cancel_remove_btn.setEnabled(True)
if task.is_finished():
self.cancel_remove_btn.setText(f"Remove task {task.num}")
else:
self.cancel_remove_btn.setText(f"Cancel task {task.num}")
def task_cancel_remove(self):
index = self.task_view.selectionModel().currentIndex()
task: CalculationProcessItem = self.task_que.item(
index.row(), index.column())
if task.is_finished():
self.calculation_manager.remove_calculation(task.calculation)
self.task_que.takeRow(index.row())
else:
self.calculation_manager.cancel_calculation(task.calculation)
print(task)
def new_task(self):
self.whole_progress.setMaximum(
self.calculation_manager.calculation_size)
if not self.preview_timer.isActive():
self.update_info()
self.preview_timer.start()
def update_info(self):
res = self.calculation_manager.get_results()
for el in res.errors:
if el[0]:
QListWidgetItem(el[0], self.logs)
ExceptionListItem(el[1], self.logs)
if (state_store.report_errors and parsed_version.is_devrelease
and not isinstance(el[1][0], SegmentationLimitException)
and isinstance(el[1][1], tuple)):
with sentry_sdk.push_scope() as scope:
scope.set_tag("auto_report", "true")
sentry_sdk.capture_event(el[1][1][0])
self.whole_progress.setValue(res.global_counter)
working_search = True
for uuid, progress in res.jobs_status.items():
calculation = self.calculation_manager.calculation_dict[uuid]
total = len(calculation.file_list)
if uuid in self.progress_item_dict:
item = self.progress_item_dict[uuid]
item.update_count(progress)
else:
item = CalculationProcessItem(calculation, self.task_count,
progress)
self.task_count += 1
self.task_que.appendRow(item)
self.progress_item_dict[uuid] = item
if working_search and progress != total:
self.part_progress.setMaximum(total)
self.part_progress.setValue(progress)
working_search = False
if not self.calculation_manager.has_work:
self.part_progress.setValue(self.part_progress.maximum())
self.preview_timer.stop()
logging.info("Progress stop")
def process_num_timer_start(self):
self.process_num_timer.start()
def update_progress(self, total_progress, part_progress):
self.whole_progress.setValue(total_progress)
self.part_progress.setValue(part_progress)
def set_total_size(self, size):
self.whole_progress.setMaximum(size)
def set_part_size(self, size):
self.part_progress.setMaximum(size)
def change_number_of_workers(self):
self.calculation_manager.set_number_of_workers(
self.number_of_process.value())
class RunDialog(QDialog):
simulation_done = Signal(bool, str)
simulation_termination_request = Signal()
def __init__(self, config_file, run_model, parent=None):
QDialog.__init__(self, parent)
self.setWindowFlags(Qt.Window)
self.setWindowFlags(self.windowFlags()
& ~Qt.WindowContextHelpButtonHint)
self.setModal(True)
self.setWindowModality(Qt.WindowModal)
self.setWindowTitle(f"Simulations - {config_file}")
self._snapshot_model = SnapshotModel(self)
self._run_model = run_model
self._isDetailedDialog = False
self._minimum_width = 1200
ert = None
if isinstance(run_model, BaseRunModel):
ert = run_model.ert()
self._ticker = QTimer(self)
self._ticker.timeout.connect(self._on_ticker)
progress_proxy_model = ProgressProxyModel(self._snapshot_model,
parent=self)
self._total_progress_label = QLabel(
_TOTAL_PROGRESS_TEMPLATE.format(
total_progress=0, phase_name=run_model.getPhaseName()),
self,
)
self._total_progress_bar = QProgressBar(self)
self._total_progress_bar.setRange(0, 100)
self._total_progress_bar.setTextVisible(False)
self._iteration_progress_label = QLabel(self)
self._progress_view = ProgressView(self)
self._progress_view.setModel(progress_proxy_model)
self._progress_view.setIndeterminate(True)
legend_view = LegendView(self)
legend_view.setModel(progress_proxy_model)
self._tab_widget = QTabWidget(self)
self._tab_widget.currentChanged.connect(self._current_tab_changed)
self._snapshot_model.rowsInserted.connect(self.on_new_iteration)
self._job_label = QLabel(self)
self._job_model = JobListProxyModel(self, 0, 0, 0, 0)
self._job_model.setSourceModel(self._snapshot_model)
self._job_view = QTableView(self)
self._job_view.setVerticalScrollMode(QAbstractItemView.ScrollPerItem)
self._job_view.setSelectionBehavior(QAbstractItemView.SelectRows)
self._job_view.setSelectionMode(QAbstractItemView.SingleSelection)
self._job_view.clicked.connect(self._job_clicked)
self._open_files = {}
self._job_view.setModel(self._job_model)
self.running_time = QLabel("")
self.plot_tool = PlotTool(ert, config_file)
self.plot_tool.setParent(self)
self.plot_button = QPushButton(self.plot_tool.getName())
self.plot_button.clicked.connect(self.plot_tool.trigger)
self.plot_button.setEnabled(ert is not None)
self.kill_button = QPushButton("Kill simulations")
self.done_button = QPushButton("Done")
self.done_button.setHidden(True)
self.restart_button = QPushButton("Restart")
self.restart_button.setHidden(True)
self.show_details_button = QPushButton("Show details")
self.show_details_button.setCheckable(True)
size = 20
spin_movie = resourceMovie("loading.gif")
spin_movie.setSpeed(60)
spin_movie.setScaledSize(QSize(size, size))
spin_movie.start()
self.processing_animation = QLabel()
self.processing_animation.setMaximumSize(QSize(size, size))
self.processing_animation.setMinimumSize(QSize(size, size))
self.processing_animation.setMovie(spin_movie)
button_layout = QHBoxLayout()
button_layout.addWidget(self.processing_animation)
button_layout.addWidget(self.running_time)
button_layout.addStretch()
button_layout.addWidget(self.show_details_button)
button_layout.addWidget(self.plot_button)
button_layout.addWidget(self.kill_button)
button_layout.addWidget(self.done_button)
button_layout.addWidget(self.restart_button)
button_widget_container = QWidget()
button_widget_container.setLayout(button_layout)
layout = QVBoxLayout()
layout.addWidget(self._total_progress_label)
layout.addWidget(self._total_progress_bar)
layout.addWidget(self._iteration_progress_label)
layout.addWidget(self._progress_view)
layout.addWidget(legend_view)
layout.addWidget(self._tab_widget)
layout.addWidget(self._job_label)
layout.addWidget(self._job_view)
layout.addWidget(button_widget_container)
self.setLayout(layout)
self.kill_button.clicked.connect(self.killJobs)
self.done_button.clicked.connect(self.accept)
self.restart_button.clicked.connect(self.restart_failed_realizations)
self.show_details_button.clicked.connect(self.toggle_detailed_progress)
self.simulation_done.connect(self._on_simulation_done)
self.setMinimumWidth(self._minimum_width)
self._setSimpleDialog()
def _current_tab_changed(self, index: int):
# Clear the selection in the other tabs
for i in range(0, self._tab_widget.count()):
if i != index:
self._tab_widget.widget(i).clearSelection()
def _setSimpleDialog(self) -> None:
self._isDetailedDialog = False
self._tab_widget.setVisible(False)
self._job_label.setVisible(False)
self._job_view.setVisible(False)
self.show_details_button.setText("Show details")
def _setDetailedDialog(self) -> None:
self._isDetailedDialog = True
self._tab_widget.setVisible(True)
self._job_label.setVisible(True)
self._job_view.setVisible(True)
self.show_details_button.setText("Hide details")
@Slot(QModelIndex, int, int)
def on_new_iteration(self, parent: QModelIndex, start: int,
end: int) -> None:
if not parent.isValid():
index = self._snapshot_model.index(start, 0, parent)
iter_row = start
self._iteration_progress_label.setText(
f"Progress for iteration {index.internalPointer().id}")
widget = RealizationWidget(iter_row)
widget.setSnapshotModel(self._snapshot_model)
widget.currentChanged.connect(self._select_real)
self._tab_widget.addTab(
widget,
f"Realizations for iteration {index.internalPointer().id}")
@Slot(QModelIndex)
def _job_clicked(self, index):
if not index.isValid():
return
selected_file = index.data(FileRole)
if selected_file and selected_file not in self._open_files:
job_name = index.siblingAtColumn(0).data()
viewer = FileDialog(
selected_file,
job_name,
index.row(),
index.model().get_real(),
index.model().get_iter(),
self,
)
self._open_files[selected_file] = viewer
def remove_file():
"""
We have sometimes seen this fail because the selected file is not
in open file, without being able to reproduce the exception.
"""
try:
self._open_files.pop(selected_file)
except KeyError:
logger = logging.getLogger(__name__)
logger.exception(
f"Failed to pop: {selected_file} from {self._open_files}"
)
viewer.finished.connect(remove_file)
elif selected_file in self._open_files:
self._open_files[selected_file].raise_()
@Slot(QModelIndex)
def _select_real(self, index):
step = 0
stage = 0
real = index.row()
iter_ = index.model().get_iter()
self._job_model.set_step(iter_, real, stage, step)
self._job_label.setText(
f"Realization id {index.data(RealIens)} in iteration {iter_}")
self._job_view.horizontalHeader().setSectionResizeMode(
QHeaderView.Stretch)
def reject(self):
return
def closeEvent(self, QCloseEvent):
if self._run_model.isFinished():
self.simulation_done.emit(self._run_model.hasRunFailed(),
self._run_model.getFailMessage())
else:
# Kill jobs if dialog is closed
if self.killJobs() != QMessageBox.Yes:
QCloseEvent.ignore()
def startSimulation(self):
self._run_model.reset()
self._snapshot_model.reset()
self._tab_widget.clear()
evaluator_server_config = EvaluatorServerConfig()
def run():
asyncio.set_event_loop(asyncio.new_event_loop())
self._run_model.startSimulations(
evaluator_server_config=evaluator_server_config, )
simulation_thread = Thread(name="ert_gui_simulation_thread")
simulation_thread.setDaemon(True)
simulation_thread.run = run
simulation_thread.start()
self._ticker.start(1000)
tracker = EvaluatorTracker(
self._run_model,
ee_con_info=evaluator_server_config.get_connection_info(),
)
worker = TrackerWorker(tracker)
worker_thread = QThread()
worker.done.connect(worker_thread.quit)
worker.consumed_event.connect(self._on_tracker_event)
worker.moveToThread(worker_thread)
self.simulation_done.connect(worker.stop)
self._worker = worker
self._worker_thread = worker_thread
worker_thread.started.connect(worker.consume_and_emit)
self._worker_thread.start()
def killJobs(self):
msg = "Are you sure you want to kill the currently running simulations?"
kill_job = QMessageBox.question(self, "Kill simulations?", msg,
QMessageBox.Yes | QMessageBox.No)
if kill_job == QMessageBox.Yes:
# Normally this slot would be invoked by the signal/slot system,
# but the worker is busy tracking the evaluation.
self._worker.request_termination()
self.reject()
return kill_job
@Slot(bool, str)
def _on_simulation_done(self, failed, failed_msg):
self.processing_animation.hide()
self.kill_button.setHidden(True)
self.done_button.setHidden(False)
self.restart_button.setVisible(
self._run_model.has_failed_realizations())
self.restart_button.setEnabled(self._run_model.support_restart)
self._total_progress_bar.setValue(100)
self._total_progress_label.setText(
_TOTAL_PROGRESS_TEMPLATE.format(
total_progress=100, phase_name=self._run_model.getPhaseName()))
if failed:
msg = QMessageBox()
msg.setIcon(QMessageBox.Critical)
msg.setText("Simulations failed!".center(100))
msg.setDetailedText(failed_msg)
msg.exec_()
@Slot()
def _on_ticker(self):
runtime = self._run_model.get_runtime()
self.running_time.setText(format_running_time(runtime))
@Slot(object)
def _on_tracker_event(self, event):
if isinstance(event, EndEvent):
self.simulation_done.emit(event.failed, event.failed_msg)
self._worker.stop()
self._ticker.stop()
elif isinstance(event, FullSnapshotEvent):
if event.snapshot is not None:
self._snapshot_model._add_snapshot(event.snapshot,
event.iteration)
self._progress_view.setIndeterminate(event.indeterminate)
progress = int(event.progress * 100)
self._total_progress_bar.setValue(progress)
self._total_progress_label.setText(
_TOTAL_PROGRESS_TEMPLATE.format(total_progress=progress,
phase_name=event.phase_name))
elif isinstance(event, SnapshotUpdateEvent):
if event.partial_snapshot is not None:
self._snapshot_model._add_partial_snapshot(
event.partial_snapshot, event.iteration)
self._progress_view.setIndeterminate(event.indeterminate)
progress = int(event.progress * 100)
self._total_progress_bar.setValue(progress)
self._total_progress_label.setText(
_TOTAL_PROGRESS_TEMPLATE.format(total_progress=progress,
phase_name=event.phase_name))
def restart_failed_realizations(self):
msg = QMessageBox(self)
msg.setIcon(QMessageBox.Information)
msg.setText(
"Note that workflows will only be executed on the restarted "
"realizations and that this might have unexpected consequences.")
msg.setWindowTitle("Restart failed realizations")
msg.setStandardButtons(QMessageBox.Ok | QMessageBox.Cancel)
result = msg.exec_()
if result == QMessageBox.Ok:
self.restart_button.setVisible(False)
self.kill_button.setVisible(True)
self.done_button.setVisible(False)
self._run_model.restart()
self.startSimulation()
@Slot()
def toggle_detailed_progress(self):
if self._isDetailedDialog:
self._setSimpleDialog()
else:
self._setDetailedDialog()
self.adjustSize()
