def _apply_variable_changes(self): ''' apply the changes the user made to the expression library ''' # Case XML (before) Editor (after) Change Action # ---------------------------------------------------------- # A <none> local created create # B local inherited reverted delete # C local <none> deleted delete # TODO: also check into the possibility that an inherited variable can have it's name # changed (in this case don't overwrite the orginal variable's name. Instead create a new # variable with the new name. dirty_variables = [var for var in self.model.variables if var['dirty']] # case A create_set = [var for var in dirty_variables if var['originalnode'] is None] delete_set = [] for xml_node in self.original_nodes: if xml_node.get('inherited') is not None: # only care about local or shadowing nodes continue for variable in self.model.variables: if variable['originalnode'] is xml_node: # original is represented in variable list if variable['inherited']: delete_set.append(xml_node) # Case B break # stop looking else: # did not find node delete_set.append(xml_node) # case C # the rest of the variables should just be updated update_set = [var for var in dirty_variables if not var['originalnode'] in delete_set and var not in create_set] # Apply the changes to each set of nodes expression_lib = self.project.find('general/expression_library') for variable in create_set: # print 'CREATE SET ', variable node = node_from_variable(variable) # print ' node', node self.project.insert_node(node, expression_lib) for variable in update_set: node = node_from_variable(variable) original_node = variable['originalnode'] # reference to the actual XML node # print 'UPDATE SET %s (original %s)' %(variable['name'], original_node) self.project.make_local(original_node) for key in node.attrib: if not key == 'inherited': original_node.set(key, node.get(key)) if 'dataset' in original_node.attrib: del original_node.attrib['dataset'] original_node.text = node.text for node in delete_set: # print 'DELETE SET %s' % (node) self.project.delete_node(node) self.initialize() something_changed = bool(update_set or create_set or delete_set) update_mainwindow_savestate(something_changed) get_mainwindow_instance().emit(SIGNAL('variables_updated')) return True
def copy_selected_to_parent(self): ''' Copy the selected item to the first parent configuration ''' if not self.has_selected_item(): return if not get_mainwindow_instance().okToCloseProject( 'copying the node to the parent configuration (reload required)' ): return self.model.copy_to_parent(self.selected_index()) get_mainwindow_instance().reloadProject()
def move_selected_to_parent(self): ''' Move the selected item to the first parent configuration ''' if not self.has_selected_item(): return if not get_mainwindow_instance().okToCloseProject( 'moving the node to the parent configuration (reload required)' ): return self.model.move_to_parent(self.selected_index()) self.project.save() get_mainwindow_instance().reloadProject()
def _apply_variable_changes(self): ''' apply the changes the user made to the expression library ''' # TODO: also check into the possibility that an inherited variable can have its name # changed (in this case don't overwrite the original variable's name. Instead create a new # variable with the new name.) dirty_variables = [var for var in self.model.all_variables if var['dirty']] # partition dirty variables into create, delete and update sets create_set = [var for var in dirty_variables if var['originalnode'] is None] delete_set = [var for var in dirty_variables if var['delete'] and var['originalnode'] is not None] # the rest of the variables should just be updated update_set = [var for var in dirty_variables if not var['originalnode'] in delete_set and var not in create_set] # verify if we have a partition assert(set([str(var) for var in create_set]) | set([str(var) for var in delete_set]) | set([str(var) for var in update_set]) == set([str(var) for var in dirty_variables])) assert(set([str(var) for var in create_set]) & set([str(var) for var in delete_set]) & set([str(var) for var in update_set]) == set()) # Apply the changes to each set of nodes expression_lib = self.project.find('general/expression_library') for variable in create_set: # print 'CREATE SET ', variable node = node_from_variable(variable) # print ' node', node self.project.insert_node(node, expression_lib) for variable in update_set: node = node_from_variable(variable) original_node = variable['originalnode'] # reference to the actual XML node # print 'UPDATE SET %s (original %s)' %(variable['name'], original_node) self.project.make_local(original_node) for key in node.attrib: if not key == 'inherited': original_node.set(key, node.get(key)) if 'dataset' in original_node.attrib: del original_node.attrib['dataset'] original_node.text = node.text for variable in delete_set: # print 'DELETE SET %s' % (node) self.project.delete_node(variable['originalnode']) self.initialize() something_changed = bool(update_set or create_set or delete_set) update_mainwindow_savestate(something_changed) get_mainwindow_instance().emit(SIGNAL('variables_updated')) return True
def _init_run(self, run_name): # Fire up a new thread and run the model self.pbnStartModel.setText(QString("Pause simulation run...")) # References to the GUI elements for status for this run... self.progressBarTotal = self.runProgressBarTotal self.progressBarYear = self.runProgressBarYear self.progressBarModel = self.runProgressBarModel # self.pbnRemoveModel.setEnabled(False) # self.pbnStartModel.setEnabled(False) # Initializing values self.progressBarTotal.setValue(0) self.progressBarYear.setValue(0) self.progressBarModel.setValue(0) self.progressBarTotal.setRange(0, 0) self.progressBarYear.setRange(0, 0) self.progressBarModel.setRange(0, 0) batch_name = str(self.cboOptionalIndicatorBatch.currentText()) if batch_name == "(None)": batch_name = None self.runThread = RunModelThread(get_mainwindow_instance(), self, batch_name, run_name) # Use this signal from the thread if it is capable of producing its own status signal QObject.connect(self.runThread, SIGNAL("runFinished(PyQt_PyObject)"), self.runFinishedFromThread) QObject.connect(self.runThread, SIGNAL("runError(PyQt_PyObject)"), self.runErrorFromThread) # Use this timer to call a function in the thread to check status if the thread is unable # to produce its own signal above self.timer = QTimer() QObject.connect(self.timer, SIGNAL("timeout()"), self.runStatusFromThread) self.timer.start(1000) self.running = True self.paused = False
def __init__(self, mainwindow, modelguielement, batch_name = None, run_name = None): QThread.__init__(self, mainwindow) self.modelguielement = modelguielement self.modelguielement.model.run_name = run_name self.batch_name = batch_name self.run_name = run_name self.project = get_mainwindow_instance().project
def __init__(self, project, parent_widget): QWidget.__init__(self, parent_widget) self.setupUi(self) self.project = project #TODO handle this as the variables are handled try: obj = get_manager_instance('results').xml_controller.model self.connect(obj, SIGNAL("layoutChanged()"), self._setup_simulation_data) except AttributeError: pass def test(): print 'Variables updated' self.connect(get_mainwindow_instance(), SIGNAL('variables_updated'), test) tool_tip = ('If checked, indicator results will automatically be\n' 'created for the currently selected simulation run,\n' 'indicator, and years. If unchecked, click\n' 'Generate results in order to make results available.') self.cb_auto_gen.setToolTip(tool_tip) self.inGui = False self.logFileKey = 0 self.available_years_for_simulation_runs = {} self.current_indicator = '' self.current_indicator_dataset = '' self.current_run = '' self.current_year = '' self._update_current_label() self.running_key = None self.queued_results = None self.setup = True self._setup_available_indicators() self._setup_simulation_data() self.setup = False self.already_browsed = {} self.generating_results = False if self.cb_auto_gen.isChecked(): self.on_pb_generate_results_clicked() # self.pb_export_results.setEnabled(False) self.tabwidget_visualizations.removeTab(0) self.tabIcon = IconLibrary.icon('table') self.tabLabel = "Result Browser"
def __init__(self, project, parent_widget): QWidget.__init__(self, parent_widget) self.setupUi(self) self.project = project # TODO handle this as the variables are handled try: obj = get_manager_instance("results").xml_controller.model self.connect(obj, SIGNAL("layoutChanged()"), self._setup_simulation_data) except AttributeError: pass def test(): print "Variables updated" self.connect(get_mainwindow_instance(), SIGNAL("variables_updated"), test) tool_tip = ( "If checked, indicator results will automatically be\n" "created for the currently selected simulation run,\n" "indicator, and years. If unchecked, click\n" "Generate results in order to make results available." ) self.cb_auto_gen.setToolTip(tool_tip) self.inGui = False self.logFileKey = 0 self.available_years_for_simulation_runs = {} self.current_indicator = "" self.current_indicator_dataset = "" self.current_run = "" self.current_year = "" self._update_current_label() self.running_key = None self.queued_results = None self.setup = True self._setup_available_indicators() self._setup_simulation_data() self.setup = False self.already_browsed = {} self.generating_results = False if self.cb_auto_gen.isChecked(): self.on_pb_generate_results_clicked() # self.pb_export_results.setEnabled(False) self.tabwidget_visualizations.removeTab(0) self.tabIcon = IconLibrary.icon("table") self.tabLabel = "Result Browser"
def __init__(self, mainwindow, modelguielement, batch_name=None, run_name=None): QThread.__init__(self, mainwindow) self.modelguielement = modelguielement self.modelguielement.model.run_name = run_name self.batch_name = batch_name self.run_name = run_name self.project = get_mainwindow_instance().project
def __init__(self, mainwindow, modelguielement, batch_name = None, run_name = None): QThread.__init__(self, mainwindow) self.modelguielement = modelguielement self.modelguielement.model.run_name = run_name self.batch_name = batch_name self.run_name = run_name self.project = get_mainwindow_instance().project self.restart = False self.run_id = None self.config = None self.restart_year = None
def __init__(self, mainwindow, modelguielement, batch_name = None, run_name = None): QThread.__init__(self, mainwindow) self.modelguielement = modelguielement self.modelguielement.model.run_name = run_name self.batch_name = batch_name self.run_name = run_name self.project = get_mainwindow_instance().project self.restart = False self.run_id = None self.config = None self.restart_year = None
def _action_before_continue(question, buttons, parent_widget): ''' base for dialogs that ask users to close with dirty data ''' if parent_widget is None: parent_widget = get_mainwindow_instance() ok_answers = [QMessageBox.Apply, QMessageBox.Save, QMessageBox.Yes] answer = QMessageBox.question(parent_widget, "Warning", question, *buttons) if answer in ok_answers: return YES elif answer == QMessageBox.Discard: return NO elif answer == QMessageBox.Cancel: return CANCEL return UNKNOWN_ANSWER
def _action_before_continue(question, buttons, parent_widget): ''' base for dialogs that ask users to close with dirty data ''' if parent_widget is None: parent_widget = get_mainwindow_instance() ok_answers = [QMessageBox.Apply, QMessageBox.Save, QMessageBox.Yes] answer = QMessageBox.question(parent_widget, "Warning", question, *buttons) if answer in ok_answers: return YES elif answer == QMessageBox.Discard: return NO elif answer == QMessageBox.Cancel: return CANCEL return UNKNOWN_ANSWER
def on_pbnStartModel_released(self): if self.running == True and self.paused == False: # Take care of pausing a run self.paused = True self.timer.stop() self.runThread.pause() self.pbnStartModel.setText(QString("Resume Estimation...")) elif self.running == True and self.paused == True: # Need to resume a paused run self.paused = False self.timer.start(1000) self.runThread.resume() self.pbnStartModel.setText(QString("Pause Estimation...")) elif self.running == False: self.logFileKey = 0 # Update the XMLConfig self.manager.project.update_xml_config() # Fire up a new thread and run the estimation # References to the GUI elements for status for this run... self.progressBar = self.runProgressBar self.statusLabel = self.runStatusLabel self.pbnStartModel.setText(QString("Pause Estimation...")) self.progressBar.setValue(0) self.statusLabel.setText(QString("Estimation initializing...")) self.runThread = RunEstimationThread(get_mainwindow_instance(), self) # Use this signal from the thread if it is capable of producing its own status signal QObject.connect(self.runThread, SIGNAL("estimationFinished(PyQt_PyObject)"), self.runFinishedFromThread) QObject.connect(self.runThread, SIGNAL("estimationError(PyQt_PyObject)"), self.runErrorFromThread) # Use this timer to call a function in the thread to check status if the thread is unable # to produce its own signal above self.timer = QTimer() QObject.connect(self.timer, SIGNAL("timeout()"), self.runStatusFromThread) self.timer.start(1000) self.running = True self.paused = False self.runThread.start() else: print "Unexpected state in the estimation run..."
def on_pbnStartModel_clicked(self): if self.running == True and self.paused == False: # Take care of pausing a run self.paused = True self.timer.stop() self.runThread.pause() self.pbnStartModel.setText(QString("Resume Estimation...")) elif self.running == True and self.paused == True: # Need to resume a paused run self.paused = False self.timer.start(1000) self.runThread.resume() self.pbnStartModel.setText(QString("Pause Estimation...")) elif self.running == False: self.logFileKey = 0 # Update the XMLConfig self.manager.project.update_xml_config() # Fire up a new thread and run the estimation # References to the GUI elements for status for this run... self.progressBar = self.runProgressBar self.statusLabel = self.runStatusLabel self.pbnStartModel.setText(QString("Pause Estimation...")) self.progressBar.setValue(0) self.statusLabel.setText(QString("Estimation initializing...")) self.runThread = RunEstimationThread(get_mainwindow_instance(), self) # Use this signal from the thread if it is capable of producing its own status signal QObject.connect(self.runThread, SIGNAL("estimationFinished(PyQt_PyObject)"), self.runFinishedFromThread) QObject.connect(self.runThread, SIGNAL("estimationError(PyQt_PyObject)"), self.runErrorFromThread) # Use this timer to call a function in the thread to check status if the thread is unable # to produce its own signal above self.timer = QTimer() QObject.connect(self.timer, SIGNAL("timeout()"), self.runStatusFromThread) self.timer.start(1000) self.running = True self.paused = False self.runThread.start() else: print "Unexpected state in the estimation run..."
def _init_run(self, run_name): # Fire up a new thread and run the model self.pbnStartModel.setText(QString("Pause simulation run...")) # References to the GUI elements for status for this run... self.progressBarTotal = self.runProgressBarTotal self.progressBarYear = self.runProgressBarYear self.progressBarModel = self.runProgressBarModel #self.pbnRemoveModel.setEnabled(False) #self.pbnStartModel.setEnabled(False) # Initializing values self.progressBarTotal.setValue(0) self.progressBarYear.setValue(0) self.progressBarModel.setValue(0) self.progressBarTotal.setRange(0, 0) self.progressBarYear.setRange(0, 0) self.progressBarModel.setRange(0, 0) batch_name = str(self.cboOptionalIndicatorBatch.currentText()) if batch_name == '(None)': batch_name = None self.runThread = RunModelThread(get_mainwindow_instance(), self, batch_name, run_name) # Use this signal from the thread if it is capable of producing its own status signal QObject.connect(self.runThread, SIGNAL("runFinished(PyQt_PyObject)"), self.runFinishedFromThread) QObject.connect(self.runThread, SIGNAL("runError(PyQt_PyObject)"), self.runErrorFromThread) # Use this timer to call a function in the thread to check status if the thread is unable # to produce its own signal above self.timer = QTimer() QObject.connect(self.timer, SIGNAL("timeout()"), self.runStatusFromThread) self.timer.start(1000) self.running = True self.paused = False
def _restart_selected_run(self): assert self.has_selected_item() run_node = self.selected_item().node # ask for start_year, end_year # start_year default to the last year of years run # need to avoid insert auto generate run directory again # original_start_year = int(run_node.find('start_year').text) # original_end_year = int(run_node.find('end_year').text) # restart_year = original_end_year + 1 # end_year = restart_year + 1 run_name = run_node.get('name') scenario_name = run_node.find('scenario_name').text run_id = run_node.get('run_id') try: run_id = int(run_id) except ValueError: raise ValueError, "run_id for run %s is invalid: %s; the run cannot be restarted." % \ (run_name, run_id) run_manager = get_run_manager() config = run_manager.get_resources_for_run_id_from_history(run_id) xml_config = self.project.xml_config opusgui = get_mainwindow_instance() scenario_manager = get_manager_instance('scenario_manager') opusmodel = OpusModel(scenario_manager, xml_config, scenario_name) tab_widget = SimulationGuiElementRestart(mainwindow=opusgui, runManager=scenario_manager, model=opusmodel, xml_config=xml_config, run_id=run_id, run_name=run_name) tab_widget.config = config # tab_widget.start_year = start_year # tab_widget.end_year = end_year scenario_manager._attach_tab(tab_widget) opusgui.update()
def _restart_selected_run(self): assert self.has_selected_item() run_node = self.selected_item().node # ask for start_year, end_year # start_year default to the last year of years run # need to avoid insert auto generate run directory again # original_start_year = int(run_node.find('start_year').text) # original_end_year = int(run_node.find('end_year').text) # restart_year = original_end_year + 1 # end_year = restart_year + 1 run_name = run_node.get('name') scenario_name = run_node.find('scenario_name').text run_id = run_node.get('run_id') try: run_id = int(run_id) except ValueError: raise ValueError, "run_id for run %s is invalid: %s; the run cannot be restarted." % \ (run_name, run_id) run_manager = get_run_manager() config = run_manager.get_resources_for_run_id_from_history(run_id) xml_config = self.project.xml_config opusgui = get_mainwindow_instance() scenario_manager = get_manager_instance('scenario_manager') opusmodel = OpusModel(scenario_manager, xml_config, scenario_name) tab_widget = SimulationGuiElementRestart(mainwindow=opusgui, runManager=scenario_manager, model=opusmodel, xml_config=xml_config, run_id=run_id, run_name=run_name) tab_widget.config = config # tab_widget.start_year = start_year # tab_widget.end_year = end_year scenario_manager._attach_tab(tab_widget) opusgui.update()
def on_pb_generate_results_released(self): run_name = self.current_run indicator_name = self.current_indicator indicator_dataset = self.current_indicator_dataset start_year = int(self.current_year) end_year = start_year if run_name is None or indicator_name is None or start_year is None: return key = (run_name, indicator_name, start_year) if key in self.already_browsed: if not self.generating_results: (tab_widget,map_widget) = self.already_browsed[key] # self.swap_visualizations(map_widget, tab_widget) self.pb_generate_results.setText('Results Generated') else: self.queued_results = ('swap', (map_widget, tab_widget)) return self.pb_generate_results.setEnabled(False) self.pb_generate_results.setText('Generating Results...') indicator_nodes = get_available_indicator_nodes(self.project) dataset = None for indicator_node in indicator_nodes: ind_dataset, name = get_variable_dataset_and_name(indicator_node) if name == indicator_name and ind_dataset == indicator_dataset: dataset = ind_dataset break if dataset is None: raise Exception('Could not find dataset for indicator %s' % indicator_name) table_params = { 'name': None, 'output_type' : 'tab', 'indicators' : [indicator_name], } map_params = {'name':None, 'indicators':[indicator_name]} visualizations = [ ('table_per_year', dataset, table_params), ('mapnik_map', dataset, map_params) ] batch_processor = BatchProcessor(self.project) batch_processor.guiElement = self batch_processor.set_data( visualizations = visualizations, source_data_name = run_name, years = range(start_year, end_year + 1)) if not self.generating_results: self.generating_results = True logger.log_note('Generating results for %s on run %s for year %indicator_node'%(run_name, indicator_name, start_year)) self.running_key = key self.batch_processor = batch_processor batch_processor_thread = OpusGuiThread( parentThread = get_mainwindow_instance(), parentGuiElement = self, thread_object = self.batch_processor) # Use this signal from the thread if it is capable of producing its own status signal self.connect(batch_processor_thread, SIGNAL("runFinished(PyQt_PyObject)"), self._run_finished) self.connect(batch_processor_thread, SIGNAL("runError(PyQt_PyObject)"), self._run_error) batch_processor_thread.start() else: self.queued_results = (key, batch_processor)
import_path = tool_path + "." + module_name importString = "from %s import opusRun" % (import_path) exec (importString) tool_config_to_tool_name[tool_config_node] = import_path except Exception, e: MessageBox.error( mainwindow=self.view, text="Invalid module name", detailed_text=( 'This tool points to a module named "%s" ' "but there is no module with that name, or module returned import error." % import_path ), ) return ExecuteToolSetGui(get_mainwindow_instance(), tool_config_nodes, tool_config_to_tool_name).show() def exportXMLToFile(self): """ NO DOCUMENTATION """ assert self.has_selected_item() # Ask the users where they want to save the file start_dir = "" opus_home = os.environ.get("OPUS_HOME") if opus_home: start_dir_test = os.path.join(opus_home, "project_configs") if start_dir_test: start_dir = start_dir_test configDialog = QFileDialog() filter_str = QString("*.xml") fd = configDialog.getSaveFileName(
def on_pbnStartModel_released(self): duplicate = False self.diagnostic_go_button.setEnabled(True) if self.running and not self.paused: # Take care of pausing a run success = self.runThread.pause() if success: self.paused = True self.timer.stop() self.pbnStartModel.setText(QString("Resume simulation run...")) elif self.running and self.paused: # Need to resume a paused run success = self.runThread.resume() if success: self.paused = False self.timer.start(1000) self.pbnStartModel.setText(QString("Pause simulation run...")) elif not self.running: run_name = str(self.leRunName.text()) if run_name == '': run_name = None else: run_id = None run_nodes = get_available_run_nodes(self.project) for run_node in run_nodes: existing_run_name = run_node.tag if run_name == existing_run_name: duplicate = True r = run_node.get('run_id') if r is not None: run_id = int(r) break if duplicate: dlg_dup = OverwriteRunDialog(self) if dlg_dup.exec_() == QDialog.Rejected: return delete_simulation_run( self.project, run_node.tag) # todo change to run_node.get('name') # Update the XML self.project.update_xml_config() self.updateConfigAndGuiForRun() # Fire up a new thread and run the model self.pbnStartModel.setText(QString("Pause simulation run...")) # References to the GUI elements for status for this run... self.progressBarTotal = self.runProgressBarTotal self.progressBarYear = self.runProgressBarYear self.progressBarModel = self.runProgressBarModel #self.pbnRemoveModel.setEnabled(False) #self.pbnStartModel.setEnabled(False) # Initializing values self.progressBarTotal.setValue(0) self.progressBarYear.setValue(0) self.progressBarModel.setValue(0) self.progressBarTotal.setRange(0, 0) self.progressBarYear.setRange(0, 0) self.progressBarModel.setRange(0, 0) batch_name = str(self.cboOptionalIndicatorBatch.currentText()) if batch_name == '(None)': batch_name = None self.runThread = RunModelThread(get_mainwindow_instance(), self, batch_name, run_name) if duplicate and run_id is not None: from opus_core.services.run_server.run_manager import RunManager as ServicesRunManager run_manager = ServicesRunManager( ServicesDatabaseConfiguration()) run_manager.delete_everything_for_this_run(run_id=run_id) run_manager.close() # Use this signal from the thread if it is capable of producing its own status signal QObject.connect(self.runThread, SIGNAL("runFinished(PyQt_PyObject)"), self.runFinishedFromThread) QObject.connect(self.runThread, SIGNAL("runError(PyQt_PyObject)"), self.runErrorFromThread) # Use this timer to call a function in the thread to check status if the thread is unable # to produce its own signal above self.timer = QTimer() QObject.connect(self.timer, SIGNAL("timeout()"), self.runStatusFromThread) self.timer.start(1000) self.running = True self.paused = False self.runThread.start() else: print "Unexpected state in the model run..."
def __init__(self,opusTool): QThread.__init__(self, get_mainwindow_instance()) self.opusTool = opusTool
def on_pbnStartModel_released(self): duplicate = False self.diagnostic_go_button.setEnabled(True) if self.running and not self.paused: # Take care of pausing a run success = self.runThread.pause() if success: self.paused = True self.timer.stop() self.pbnStartModel.setText(QString("Resume simulation run...")) elif self.running and self.paused: # Need to resume a paused run success = self.runThread.resume() if success: self.paused = False self.timer.start(1000) self.pbnStartModel.setText(QString("Pause simulation run...")) elif not self.running: run_name = str(self.leRunName.text()) if run_name == '': run_name = None else: run_id = None run_nodes = get_available_run_nodes(self.project) for run_node in run_nodes: existing_run_name = run_node.tag if run_name == existing_run_name: duplicate = True r = run_node.get('run_id') if r is not None: run_id = int(r) break if duplicate: dlg_dup = OverwriteRunDialog(self) if dlg_dup.exec_() == QDialog.Rejected: return delete_simulation_run(self.project, run_node.tag) # todo change to run_node.get('name') # Update the XML self.project.update_xml_config() self.updateConfigAndGuiForRun() # Fire up a new thread and run the model self.pbnStartModel.setText(QString("Pause simulation run...")) # References to the GUI elements for status for this run... self.progressBarTotal = self.runProgressBarTotal self.progressBarYear = self.runProgressBarYear self.progressBarModel = self.runProgressBarModel #self.pbnRemoveModel.setEnabled(False) #self.pbnStartModel.setEnabled(False) # Initializing values self.progressBarTotal.setValue(0) self.progressBarYear.setValue(0) self.progressBarModel.setValue(0) self.progressBarTotal.setRange(0,0) self.progressBarYear.setRange(0,0) self.progressBarModel.setRange(0,0) batch_name = str(self.cboOptionalIndicatorBatch.currentText()) if batch_name == '(None)': batch_name = None self.runThread = RunModelThread(get_mainwindow_instance(), self, batch_name, run_name) if duplicate and run_id is not None: from opus_core.services.run_server.run_manager import RunManager as ServicesRunManager run_manager = ServicesRunManager(ServicesDatabaseConfiguration()) run_manager.delete_everything_for_this_run(run_id = run_id) run_manager.close() # Use this signal from the thread if it is capable of producing its own status signal QObject.connect(self.runThread, SIGNAL("runFinished(PyQt_PyObject)"), self.runFinishedFromThread) QObject.connect(self.runThread, SIGNAL("runError(PyQt_PyObject)"), self.runErrorFromThread) # Use this timer to call a function in the thread to check status if the thread is unable # to produce its own signal above self.timer = QTimer() QObject.connect(self.timer, SIGNAL("timeout()"), self.runStatusFromThread) self.timer.start(1000) self.running = True self.paused = False self.runThread.start() else: print "Unexpected state in the model run..."
module_name = hooked_tool_node.find('class_module').text tool_path = get_path_to_tool_modules(self.project) import_path = tool_path + '.' + module_name importString = "from %s import opusRun" % (import_path) exec(importString) tool_config_to_tool_name[tool_config_node] = import_path except Exception, e: MessageBox.error(mainwindow = self.view, text = 'Invalid module name', detailed_text = ('This tool points to a module named "%s", ' % import_path + \ 'but there is no module with that name, or module returned import error: %s. ' \ % formatExceptionInfo() )) return ExecuteToolSetGui(get_mainwindow_instance(), tool_config_nodes, tool_config_to_tool_name).show() def add_custom_menu_items_for_node(self, node, menu): index = self.model.index_for_node(node) cnt = self.model.rowCount(index.parent()) istop = index.row() == 0 isbottom = index.row() == cnt-1 isonly = cnt == 1 # Tool files are the "actual" tools if node.tag == "tool": menu.addAction(self.actExecToolFile)
def addNewSimulationElement(self, model): ''' Initialize and add a simulation runner tab ''' tab_widget = SimulationGuiElement(get_mainwindow_instance(), self, model, self.project.xml_config) self._attach_tab(tab_widget)
def _run_finished(self, success): key = self.running_key self.running_key = None size = QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) self.tabwidget_visualizations.setSizePolicy(size) name = '%s/%s/%s' % key new_tab = QTabWidget(self.tabwidget_visualizations) self.tabwidget_visualizations.addTab(new_tab, name) map_widget = None tab_widget = None for (visualization_type, visualizations) in self.batch_processor.get_visualizations(): if len(visualizations) > 0: if visualization_type == 'mapnik_map': viz = visualizations[0] map_widget = ViewImageForm(viz, new_tab) map_widget.setSizePolicy(size) elif visualization_type == 'mapnik_animated_map': viz = visualizations[0] map_widget = ViewAnimationForm(viz, new_tab) map_widget.setSizePolicy(size) elif visualization_type == 'table_per_year': viz = visualizations[0] tab_widget = ViewTableForm(viz, new_tab) tab_widget.setSizePolicy(size) # else: # map_widget = self.tabMap # tab_widget = self.tabTable # if not map_widget or not tab_widget: return # self.tabMap = map_widget # self.tabTable = tab_widget if tab_widget: new_tab.addTab(tab_widget, "Table") if map_widget: new_tab.addTab(map_widget, "Map") self.already_browsed[key] = (tab_widget, map_widget) # self.lblViewIndicator.setText(QString(key[1])) # self.lblViewRun.setText(QString(key[0])) # self.lblViewYear.setText(QString(repr(key[2]))) swap = self.queued_results is not None and self.queued_results[ 0] == 'swap' if self.queued_results is not None and not swap: self.running_key = self.queued_results[0] logger.log_note( 'Generating queued results for %s on run %s for year %i' % self.running_key) self.batch_processor = self.queued_results[1] self.queued_results = None runThread = OpusGuiThread(parentThread=get_mainwindow_instance(), parentGuiElement=self, thread_object=self.batch_processor) # Use this signal from the thread if it is capable of producing its own status signal QObject.connect(runThread, SIGNAL("runFinished(PyQt_PyObject)"), self._run_finished) QObject.connect(runThread, SIGNAL("runError(PyQt_PyObject)"), self._run_error) runThread.start() else: # if swap: # (map_widget, tab_widget) = self.queued_results[1] # ## self.swap_visualizations(map_widget, tab_widget) # name = '%s/%s/%s'%key # # self.swap_visualizations(map_widget, tab_widget) # self.add_visualization(map_widget = map_widget, tab_widget = tab_widget, name = name) self.queued_results = None self.generating_results = False self.pb_generate_results.setText('Results Generated')
def on_pb_generate_results_clicked(self): run_name = self.current_run indicator_name = self.current_indicator indicator_dataset = self.current_indicator_dataset start_year = int(self.current_year) end_year = start_year if run_name is None or indicator_name is None or start_year is None: return key = (run_name, indicator_name, start_year) if key in self.already_browsed: if not self.generating_results: (tab_widget, map_widget) = self.already_browsed[key] # self.swap_visualizations(map_widget, tab_widget) self.pb_generate_results.setText('Results Generated') else: self.queued_results = ('swap', (map_widget, tab_widget)) return self.pb_generate_results.setEnabled(False) self.pb_generate_results.setText('Generating Results...') indicator_nodes = get_available_indicator_nodes(self.project) dataset = None for indicator_node in indicator_nodes: ind_dataset, name = get_variable_dataset_and_name(indicator_node) if name == indicator_name and ind_dataset == indicator_dataset: dataset = ind_dataset break if dataset is None: raise Exception('Could not find dataset for indicator %s' % indicator_name) table_params = { 'name': None, 'output_type': 'tab', 'indicators': [indicator_name], } map_params = {'name': None, 'indicators': [indicator_name]} visualizations = [('table_per_year', dataset, table_params), ('mapnik_map', dataset, map_params)] batch_processor = BatchProcessor(self.project) batch_processor.guiElement = self batch_processor.set_data(visualizations=visualizations, source_data_name=run_name, years=range(start_year, end_year + 1)) if not self.generating_results: self.generating_results = True logger.log_note( 'Generating results for %s on run %s for year %indicator_node' % (run_name, indicator_name, start_year)) self.running_key = key self.batch_processor = batch_processor batch_processor_thread = OpusGuiThread( parentThread=get_mainwindow_instance(), parentGuiElement=self, thread_object=self.batch_processor) # Use this signal from the thread if it is capable of producing its own status signal self.connect(batch_processor_thread, SIGNAL("runFinished(PyQt_PyObject)"), self._run_finished) self.connect(batch_processor_thread, SIGNAL("runError(PyQt_PyObject)"), self._run_error) batch_processor_thread.start() else: self.queued_results = (key, batch_processor)
tool_path = get_path_to_tool_modules(self.project) import_path = tool_path + '.' + module_name importString = "from %s import opusRun" % (import_path) exec(importString) tool_config_to_tool_name[tool_config_node] = import_path except Exception, e: MessageBox.error( mainwindow=self.view, text='Invalid module name', detailed_text= ('This tool points to a module named "%s" ' 'but there is no module with that name, or module returned import error.' % import_path)) return ExecuteToolSetGui(get_mainwindow_instance(), tool_config_nodes, tool_config_to_tool_name).show() def exportXMLToFile(self): ''' NO DOCUMENTATION ''' assert self.has_selected_item() # Ask the users where they want to save the file start_dir = '' opus_home = os.environ.get('OPUS_HOME') if opus_home: start_dir_test = os.path.join(opus_home, 'project_configs') if start_dir_test: start_dir = start_dir_test configDialog = QFileDialog() filter_str = QString("*.xml")
def _apply_variable_changes(self): ''' apply the changes the user made to the expression library ''' # TODO: also check into the possibility that an inherited variable can have its name # changed (in this case don't overwrite the original variable's name. Instead create a new # variable with the new name.) dirty_variables = [ var for var in self.model.all_variables if var['dirty'] ] # partition dirty variables into create, delete and update sets create_set = [ var for var in dirty_variables if var['originalnode'] is None ] delete_set = [ var for var in dirty_variables if var['delete'] and var['originalnode'] is not None ] # the rest of the variables should just be updated update_set = [ var for var in dirty_variables if not var['originalnode'] in delete_set and var not in create_set ] # verify if we have a partition assert (set([str(var) for var in create_set]) | set([str(var) for var in delete_set]) | set([str(var) for var in update_set]) == set( [str(var) for var in dirty_variables])) assert (set([str(var) for var in create_set]) & set([str(var) for var in delete_set]) & set([str(var) for var in update_set]) == set()) # Apply the changes to each set of nodes expression_lib = self.project.find('general/expression_library') for variable in create_set: # print 'CREATE SET ', variable node = node_from_variable(variable) # print ' node', node self.project.insert_node(node, expression_lib) for variable in update_set: node = node_from_variable(variable) original_node = variable[ 'originalnode'] # reference to the actual XML node # print 'UPDATE SET %s (original %s)' %(variable['name'], original_node) self.project.make_local(original_node) for key in node.attrib: if not key == 'inherited': original_node.set(key, node.get(key)) if 'dataset' in original_node.attrib: del original_node.attrib['dataset'] original_node.text = node.text for variable in delete_set: # print 'DELETE SET %s' % (node) self.project.delete_node(variable['originalnode']) self.initialize() something_changed = bool(update_set or create_set or delete_set) update_mainwindow_savestate(something_changed) get_mainwindow_instance().emit(SIGNAL('variables_updated')) return True
def _run_finished(self, success): key = self.running_key self.running_key = None size = QSizePolicy(QSizePolicy.Expanding,QSizePolicy.Expanding) self.tabwidget_visualizations.setSizePolicy(size) name = '%s/%s/%s'%key new_tab = QTabWidget(self.tabwidget_visualizations) self.tabwidget_visualizations.addTab(new_tab, name) map_widget = None tab_widget = None for (visualization_type, visualizations) in self.batch_processor.get_visualizations(): if len(visualizations) > 0: if visualization_type == 'mapnik_map': viz = visualizations[0] map_widget = ViewImageForm(viz, new_tab) map_widget.setSizePolicy(size) elif visualization_type == 'mapnik_animated_map': viz = visualizations[0] map_widget = ViewAnimationForm(viz, new_tab) map_widget.setSizePolicy(size) elif visualization_type == 'table_per_year': viz = visualizations[0] tab_widget = ViewTableForm(viz, new_tab) tab_widget.setSizePolicy(size) # else: # map_widget = self.tabMap # tab_widget = self.tabTable # if not map_widget or not tab_widget: return # self.tabMap = map_widget # self.tabTable = tab_widget if tab_widget: new_tab.addTab(tab_widget, "Table") if map_widget: new_tab.addTab(map_widget, "Map") self.already_browsed[key] = (tab_widget, map_widget) # self.lblViewIndicator.setText(QString(key[1])) # self.lblViewRun.setText(QString(key[0])) # self.lblViewYear.setText(QString(repr(key[2]))) swap = self.queued_results is not None and self.queued_results[0] == 'swap' if self.queued_results is not None and not swap: self.running_key = self.queued_results[0] logger.log_note('Generating queued results for %s on run %s for year %i'%self.running_key) self.batch_processor = self.queued_results[1] self.queued_results = None runThread = OpusGuiThread( parentThread = get_mainwindow_instance(), parentGuiElement = self, thread_object = self.batch_processor) # Use this signal from the thread if it is capable of producing its own status signal QObject.connect(runThread, SIGNAL("runFinished(PyQt_PyObject)"), self._run_finished) QObject.connect(runThread, SIGNAL("runError(PyQt_PyObject)"), self._run_error) runThread.start() else: # if swap: # (map_widget, tab_widget) = self.queued_results[1] # ## self.swap_visualizations(map_widget, tab_widget) # name = '%s/%s/%s'%key # # self.swap_visualizations(map_widget, tab_widget) # self.add_visualization(map_widget = map_widget, tab_widget = tab_widget, name = name) self.queued_results = None self.generating_results = False self.pb_generate_results.setText('Results Generated')
def __init__(self,opusTool): QThread.__init__(self, get_mainwindow_instance()) self.opusTool = opusTool
def addNewSimulationElement(self, model): ''' Initialize and add a simulation runner tab ''' tab_widget = SimulationGuiElement(get_mainwindow_instance(), self, model, self.project.xml_config) self._attach_tab(tab_widget)