def _load_workflows(self, application: speedwagon.gui.MainWindow2) -> None:
tabs_file = os.path.join(
self.platform_settings.get_app_data_directory(),
TABS_YML_FILE_NAME
)
self.logger.debug("Loading Workflows")
loading_workflows_stream = io.StringIO()
with contextlib.redirect_stderr(loading_workflows_stream):
all_workflows = job.available_workflows()
for workflow_name, error in \
self._find_invalid(all_workflows):
error_message = \
f"Unable to load workflow '{workflow_name}'. Reason: {error}"
self.logger.error(error_message)
application.console.add_message(error_message)
del all_workflows[workflow_name]
# Load every user configured tab
self.load_custom_tabs(application, tabs_file, all_workflows)
# All Workflows tab
self.load_all_workflows_tab(application, all_workflows)
workflow_errors_msg = loading_workflows_stream.getvalue().strip()
if workflow_errors_msg:
for line in workflow_errors_msg.split("\n"):
self.logger.warning(line)
def _load_workflows(self, application: speedwagon.gui.MainWindow1) -> None:
self._logger.debug("Loading Workflows")
loading_workflows_stream = io.StringIO()
with contextlib.redirect_stderr(loading_workflows_stream):
all_workflows = job.available_workflows()
# Load every user configured tab
tabs_file_size = os.path.getsize(self.tabs_file)
if tabs_file_size > 0:
try:
for tab_name, extra_tab in \
get_custom_tabs(all_workflows, self.tabs_file):
application.add_tab(tab_name, collections.OrderedDict(
sorted(extra_tab.items())))
except FileFormatError as error:
self._logger.warning(
"Unable to load custom tabs from %s. Reason: %s",
self.tabs_file,
error
)
# All Workflows tab
self._logger.debug("Loading Tab All")
application.add_tab("All", collections.OrderedDict(
sorted(all_workflows.items())))
workflow_errors_msg = loading_workflows_stream.getvalue().strip()
if workflow_errors_msg:
for line in workflow_errors_msg.split("\n"):
self._logger.warning(line)
def test_workflow_list_model2_remove(self):
workflows_model = models.WorkflowListModel2()
workflows = job.available_workflows()
workflows_model.add_workflow(workflows["Hathi Prep"])
jp2_workflow = workflows['Make JP2']
workflows_model.add_workflow(jp2_workflow)
assert workflows_model.rowCount() == 2
workflows_model.remove_workflow(jp2_workflow)
assert workflows_model.rowCount() == 1
def test_workflow_list_model2_isub():
workflows_model = models.WorkflowListModel2()
workflows = job.available_workflows()
workflows_model.add_workflow(workflows["Hathi Prep"])
jp2_workflow = workflows['Make JP2']
workflows_model += jp2_workflow
assert workflows_model.rowCount() == 2
workflows_model -= jp2_workflow
assert workflows_model.rowCount() == 1
def submit_job(
self,
job_manager: runner_strategies.BackgroundJobManager,
workflow_name: str,
options: Dict[str, typing.Any],
main_app: typing.Optional[speedwagon.gui.MainWindow2] = None,
) -> None:
workflow_class = \
job.available_workflows().get(workflow_name)
try:
if workflow_class is None:
raise ValueError(f"Unknown workflow: '{workflow_name}'")
workflow_class.validate_user_options(**options)
except ValueError as user_option_error:
self.report_exception(
parent=main_app,
exc=user_option_error,
dialog_box_title="Invalid User Options"
)
return
dialog_box = WorkflowProgress(parent=self.windows)
if main_app is not None:
dialog_box.rejected.connect(main_app.close)
dialog_box.setWindowTitle(workflow_name)
dialog_box.show()
threaded_events = ThreadedEvents()
dialog_box.aborted.connect(
lambda: self.abort_job(dialog_box, threaded_events)
)
callbacks = WorkflowProgressCallbacks(dialog_box)
if main_app is not None:
callbacks.signals.finished.connect(
main_app.console.log_handler.flush
)
dialog_box.attach_logger(self.logger)
setattr(job_manager, "request_more_info", self.request_more_info)
job_manager.submit_job(
workflow_name=workflow_name,
options=options,
app=self,
liaison=runner_strategies.JobManagerLiaison(
callbacks=callbacks,
events=threaded_events
)
)
threaded_events.started.set()
def test_workflow_list_model2_add(self):
workflows_model = models.WorkflowListModel2()
workflows = job.available_workflows()
workflows_model.add_workflow(workflows["Hathi Prep"])
assert workflows_model.rowCount() == 1
def load(self) -> None:
"""Load configuration settings."""
print(f"loading {self.settings_location}")
self.editor.tabs_file = self.settings_location
workflows = job.available_workflows()
self.editor.set_all_workflows(workflows)
def load_all_workflows(self):
workflows = job.available_workflows()
self.editor.set_all_workflows(workflows)
def run(self):
# Display a splash screen until the app is loaded
with resources.open_binary(speedwagon.__name__, "logo.png") as logo:
splash = QtWidgets.QSplashScreen(
QtGui.QPixmap(logo.name).scaled(400, 400))
splash.setEnabled(False)
splash.setWindowFlags(QtCore.Qt.WindowStaysOnTopHint
| QtCore.Qt.FramelessWindowHint)
splash_message_handler = SplashScreenLogHandler(splash)
# If debug mode, print the log messages directly on the splash screen
if self._debug:
splash_message_handler.setLevel(logging.DEBUG)
else:
splash_message_handler.setLevel(logging.INFO)
splash.show()
self.app.processEvents()
self.set_app_display_metadata()
with worker.ToolJobManager() as work_manager:
work_manager.settings_path = \
self.platform_settings.get_app_data_directory()
windows = MainWindow(work_manager=work_manager,
debug=self.startup_settings['debug'])
windows.setWindowTitle("")
self._logger.addHandler(splash_message_handler)
self._logger.addHandler(windows.log_data_handler)
self._logger.addHandler(windows.console_log_handler)
app_title = speedwagon.__name__.title()
try:
app_version = metadata.version(__package__)
except metadata.PackageNotFoundError:
app_version = ""
self._logger.info(f"{app_title} {app_version}")
self.app.processEvents()
# ==================================================
# Load configurations
self._logger.debug("Applying settings to Speedwagon")
work_manager.user_settings = self.platform_settings
work_manager.configuration_file = self.config_file
# ==================================================
self._logger.debug("Loading Workflows")
loading_workflows_stream = io.StringIO()
with contextlib.redirect_stderr(loading_workflows_stream):
all_workflows = job.available_workflows()
# Load every user configured tab
tabs_file_size = os.path.getsize(self.tabs_file)
if tabs_file_size > 0:
try:
for tab_name, extra_tab in \
get_custom_tabs(all_workflows, self.tabs_file):
windows.add_tab(
tab_name,
collections.OrderedDict(sorted(extra_tab.items())))
except FileFormatError as e:
self._logger.warning("Unable to load custom tabs from {}. "
"Reason: {}".format(
self.tabs_file, e))
# All Workflows tab
self._logger.debug("Loading Tab All")
windows.add_tab(
"All", collections.OrderedDict(sorted(all_workflows.items())))
workflow_errors_msg = loading_workflows_stream.getvalue().strip()
if workflow_errors_msg:
for line in workflow_errors_msg.split("\n"):
self._logger.warning(line)
# ==================================================
self._logger.debug("Loading User Interface")
windows.show()
if "starting-tab" in self.startup_settings:
windows.set_current_tab(
tab_name=self.startup_settings['starting-tab'])
splash.finish(windows)
self._logger.info("Ready")
self._logger.removeHandler(windows.log_data_handler)
self._logger.removeHandler(windows.console_log_handler)
self._logger.removeHandler(splash_message_handler)
return self.app.exec_()
def load(self):
print(f"loading {self.settings_location}")
self.editor.tabs_file = self.settings_location
workflows = job.available_workflows()
self.editor.set_all_workflows(workflows)
def _set_workflow(self, workflow_name: str) -> None:
available_workflows = job.available_workflows()
self.workflow = available_workflows[workflow_name]()
def test_workflow_list_model2_iadd():
workflows_model = models.WorkflowListModel2()
workflows = job.available_workflows()
workflows_model += workflows["Hathi Prep"]
assert workflows_model.rowCount() == 1
