def run_task(self, task_item, status_item, count=0, index=''):
"""Run a single task.
:param task_item: Table task_item containing task name / details.
:type task_item: QTableWidgetItem
:param status_item: Table task_item that holds the task status.
:type status_item: QTableWidgetItem
:param count: Count of scenarios that have been run already.
:type count:
:param index: The index for the table item that will be run.
:type index: int
:returns: Flag indicating if the task succeeded or not.
:rtype: bool
"""
self.enable_busy_cursor()
for layer_group in self.layer_group_container:
layer_group.setVisible(False)
# set status to 'running'
status_item.setText(self.tr('Running'))
# .. see also:: :func:`appendRow` to understand the next 2 lines
variant = task_item.data(QtCore.Qt.UserRole)
value = variant[0]
result = True
if isinstance(value, str):
filename = value
# run script
try:
self.run_script(filename)
# set status to 'OK'
status_item.setText(self.tr('Script OK'))
except Exception as e: # pylint: disable=W0703
# set status to 'fail'
status_item.setText(self.tr('Script Fail'))
LOGGER.exception('Running macro failed. The exception: ' +
str(e))
result = False
elif isinstance(value, dict):
# start in new project if toggle is active
if self.start_in_new_project:
self.iface.newProject()
# create layer group
group_name = value['scenario_name']
self.layer_group = self.root.addGroup(group_name)
self.layer_group_container.append(self.layer_group)
# Its a dict containing files for a scenario
success, parameters = self.prepare_task(value)
if not success:
# set status to 'running'
status_item.setText(self.tr('Please update scenario'))
self.disable_busy_cursor()
return False
# If impact function parameters loaded successfully, initiate IF.
impact_function = ImpactFunction()
impact_function.hazard = parameters[layer_purpose_hazard['key']]
impact_function.exposure = (
parameters[layer_purpose_exposure['key']])
if parameters[layer_purpose_aggregation['key']]:
impact_function.aggregation = (
parameters[layer_purpose_aggregation['key']])
elif parameters['extent']:
impact_function.requested_extent = parameters['extent']
impact_function.requested_extent_crs = parameters['crs']
prepare_status, prepare_message = impact_function.prepare()
if prepare_status == PREPARE_SUCCESS:
LOGGER.info('Impact function ready')
status, message = impact_function.run()
if status == ANALYSIS_SUCCESS:
status_item.setText(self.tr('Analysis Success'))
impact_layer = impact_function.impact
if impact_layer.isValid():
layer_list = [
impact_layer,
parameters[layer_purpose_hazard['key']],
parameters[layer_purpose_exposure['key']],
parameters[layer_purpose_aggregation['key']]]
QgsMapLayerRegistry.instance().addMapLayers(
layer_list, False)
for layer in layer_list:
self.layer_group.addLayer(layer)
map_canvas = QgsMapLayerRegistry.instance().mapLayers()
for layer in map_canvas:
# turn of layer visibility if not impact layer
if map_canvas[layer].id() == impact_layer.id():
self.legend.setLayerVisible(
map_canvas[layer], True)
else:
self.legend.setLayerVisible(
map_canvas[layer], False)
# generate map report and impact report
try:
# this line is to save the impact report in default
# InaSAFE directory.
generate_impact_report(impact_function, self.iface)
generate_impact_map_report(
impact_function,
self.iface)
# this line is to save the report in user specified
# directory.
self.generate_pdf_report(
impact_function,
self.iface,
group_name)
except:
status_item.setText(
self.tr('Report failed to generate.'))
else:
LOGGER.info('Impact layer is invalid')
elif status == ANALYSIS_FAILED_BAD_INPUT:
LOGGER.info('Bad input detected')
elif status == ANALYSIS_FAILED_BAD_CODE:
LOGGER.info('Impact function encountered a bug')
else:
LOGGER.warning('Impact function not ready')
send_error_message(self, prepare_message)
else:
LOGGER.exception('Data type not supported: "%s"' % value)
result = False
self.disable_busy_cursor()
return result
def setup_and_run_analysis(self):
"""Execute analysis after the tab is displayed.
Please check the code in dock.py accept(). It should follow
approximately the same code.
"""
self.show_busy()
# Read user's settings
self.read_settings()
# Prepare impact function from wizard dialog user input
self.impact_function = self.prepare_impact_function()
# Prepare impact function
status, message = self.impact_function.prepare()
# Check status
if status == PREPARE_FAILED_BAD_INPUT:
self.hide_busy()
LOGGER.info(tr(
'The impact function will not be able to run because of the '
'inputs.'))
LOGGER.info(message.to_text())
send_error_message(self, message)
return status, message
if status == PREPARE_FAILED_BAD_CODE:
self.hide_busy()
LOGGER.exception(tr(
'The impact function was not able to be prepared because of a '
'bug.'))
LOGGER.info(message.to_text())
send_error_message(self, message)
return status, message
# Start the analysis
status, message = self.impact_function.run()
# Check status
if status == ANALYSIS_FAILED_BAD_INPUT:
self.hide_busy()
LOGGER.info(tr(
'The impact function could not run because of the inputs.'))
LOGGER.info(message.to_text())
send_error_message(self, message)
return status, message
elif status == ANALYSIS_FAILED_BAD_CODE:
self.hide_busy()
LOGGER.exception(tr(
'The impact function could not run because of a bug.'))
LOGGER.exception(message.to_text())
send_error_message(self, message)
return status, message
LOGGER.info(tr('The impact function could run without errors.'))
# Add result layer to QGIS
add_impact_layers_to_canvas(self.impact_function, self.parent.iface)
# Some if-s i.e. zoom, debug, hide exposure
if self.zoom_to_impact_flag:
self.iface.zoomToActiveLayer()
qgis_exposure = (
QgsMapLayerRegistry.instance().mapLayer(
self.parent.exposure_layer.id()))
if self.hide_exposure_flag:
legend = self.iface.legendInterface()
legend.setLayerVisible(qgis_exposure, False)
# Generate impact report
error_code, message = generate_impact_report(
self.impact_function, self.parent.iface)
if error_code == ImpactReport.REPORT_GENERATION_FAILED:
self.hide_busy()
LOGGER.info(tr(
'The impact report could not be generated.'))
send_error_message(self, message)
LOGGER.info(message.to_text())
return ANALYSIS_FAILED_BAD_CODE, message
# Generate Impact Map Report
error_code, message = generate_impact_map_report(
self.impact_function, self.iface)
if error_code == ImpactReport.REPORT_GENERATION_FAILED:
self.hide_busy()
LOGGER.info(tr(
'The impact report could not be generated.'))
send_error_message(self, message)
LOGGER.info(message.to_text())
return ANALYSIS_FAILED_BAD_CODE, message
self.extent.set_last_analysis_extent(
self.impact_function.analysis_extent,
qgis_exposure.crs())
# Hide busy
self.hide_busy()
# Setup gui if analysis is done
self.setup_gui_analysis_done()
return ANALYSIS_SUCCESS, None
def run_task(self, task_item, status_item, count=0, index=''):
"""Run a single task.
:param task_item: Table task_item containing task name / details.
:type task_item: QTableWidgetItem
:param status_item: Table task_item that holds the task status.
:type status_item: QTableWidgetItem
:param count: Count of scenarios that have been run already.
:type count:
:param index: The index for the table item that will be run.
:type index: int
:returns: Flag indicating if the task succeeded or not.
:rtype: bool
"""
self.enable_busy_cursor()
for layer_group in self.layer_group_container:
layer_group.setVisible(False)
# set status to 'running'
status_item.setText(self.tr('Running'))
# .. see also:: :func:`appendRow` to understand the next 2 lines
variant = task_item.data(QtCore.Qt.UserRole)
value = variant[0]
result = True
if isinstance(value, str):
filename = value
# run script
try:
self.run_script(filename)
# set status to 'OK'
status_item.setText(self.tr('Script OK'))
except Exception as e: # pylint: disable=W0703
# set status to 'fail'
status_item.setText(self.tr('Script Fail'))
LOGGER.exception('Running macro failed. The exception: ' +
str(e))
result = False
elif isinstance(value, dict):
# start in new project if toggle is active
if self.start_in_new_project:
self.iface.newProject()
# create layer group
group_name = value['scenario_name']
self.layer_group = self.root.addGroup(group_name)
self.layer_group_container.append(self.layer_group)
# Its a dict containing files for a scenario
success, parameters = self.prepare_task(value)
if not success:
# set status to 'running'
status_item.setText(self.tr('Please update scenario'))
self.disable_busy_cursor()
return False
# If impact function parameters loaded successfully, initiate IF.
impact_function = ImpactFunction()
impact_function.hazard = parameters[layer_purpose_hazard['key']]
impact_function.exposure = (
parameters[layer_purpose_exposure['key']])
if parameters[layer_purpose_aggregation['key']]:
impact_function.aggregation = (
parameters[layer_purpose_aggregation['key']])
elif parameters['extent']:
impact_function.requested_extent = parameters['extent']
impact_function.requested_extent_crs = parameters['crs']
prepare_status, prepare_message = impact_function.prepare()
if prepare_status == PREPARE_SUCCESS:
LOGGER.info('Impact function ready')
status, message = impact_function.run()
if status == ANALYSIS_SUCCESS:
status_item.setText(self.tr('Analysis Success'))
impact_layer = impact_function.impact
if impact_layer.isValid():
layer_list = [
impact_layer,
parameters[layer_purpose_hazard['key']],
parameters[layer_purpose_exposure['key']],
parameters[layer_purpose_aggregation['key']]]
QgsMapLayerRegistry.instance().addMapLayers(
layer_list, False)
for layer in layer_list:
self.layer_group.addLayer(layer)
map_canvas = QgsMapLayerRegistry.instance().mapLayers()
for layer in map_canvas:
# turn of layer visibility if not impact layer
if map_canvas[layer].id() == impact_layer.id():
self.legend.setLayerVisible(
map_canvas[layer], True)
else:
self.legend.setLayerVisible(
map_canvas[layer], False)
# generate map report and impact report
try:
# this line is to save the impact report in default
# InaSAFE directory.
generate_impact_report(impact_function, self.iface)
generate_impact_map_report(
impact_function,
self.iface)
# this line is to save the report in user specified
# directory.
self.generate_pdf_report(
impact_function,
self.iface,
group_name)
except:
status_item.setText(
self.tr('Report failed to generate.'))
else:
LOGGER.info('Impact layer is invalid')
elif status == ANALYSIS_FAILED_BAD_INPUT:
LOGGER.info('Bad input detected')
elif status == ANALYSIS_FAILED_BAD_CODE:
LOGGER.info('Impact function encountered a bug')
else:
LOGGER.warning('Impact function not ready')
send_error_message(self, prepare_message)
else:
LOGGER.exception('Data type not supported: "%s"' % value)
result = False
self.disable_busy_cursor()
return result
def setup_and_run_analysis(self):
"""Execute analysis after the tab is displayed.
Please check the code in dock.py accept(). It should follow
approximately the same code.
"""
self.show_busy()
# Read user's settings
self.read_settings()
# Prepare impact function from wizard dialog user input
self.impact_function = self.prepare_impact_function()
# Prepare impact function
status, message = self.impact_function.prepare()
# Check status
if status == PREPARE_FAILED_BAD_INPUT:
self.hide_busy()
LOGGER.info(
tr('The impact function will not be able to run because of the '
'inputs.'))
LOGGER.info(message.to_text())
send_error_message(self, message)
return status, message
if status == PREPARE_FAILED_BAD_CODE:
self.hide_busy()
LOGGER.exception(
tr('The impact function was not able to be prepared because of a '
'bug.'))
LOGGER.info(message.to_text())
send_error_message(self, message)
return status, message
# Start the analysis
status, message = self.impact_function.run()
# Check status
if status == ANALYSIS_FAILED_BAD_INPUT:
self.hide_busy()
LOGGER.info(
tr('The impact function could not run because of the inputs.'))
LOGGER.info(message.to_text())
send_error_message(self, message)
return status, message
elif status == ANALYSIS_FAILED_BAD_CODE:
self.hide_busy()
LOGGER.exception(
tr('The impact function could not run because of a bug.'))
LOGGER.exception(message.to_text())
send_error_message(self, message)
return status, message
LOGGER.info(tr('The impact function could run without errors.'))
# Add result layer to QGIS
add_impact_layers_to_canvas(self.impact_function, self.parent.iface)
# Some if-s i.e. zoom, debug, hide exposure
if self.zoom_to_impact_flag:
self.iface.zoomToActiveLayer()
qgis_exposure = (QgsMapLayerRegistry.instance().mapLayer(
self.parent.exposure_layer.id()))
if self.hide_exposure_flag:
legend = self.iface.legendInterface()
legend.setLayerVisible(qgis_exposure, False)
# Generate impact report
error_code, message = generate_impact_report(self.impact_function,
self.parent.iface)
if error_code == ImpactReport.REPORT_GENERATION_FAILED:
self.hide_busy()
LOGGER.info(tr('The impact report could not be generated.'))
send_error_message(self, message)
LOGGER.info(message.to_text())
return ANALYSIS_FAILED_BAD_CODE, message
# Generate Impact Map Report
error_code, message = generate_impact_map_report(
self.impact_function, self.iface)
if error_code == ImpactReport.REPORT_GENERATION_FAILED:
self.hide_busy()
LOGGER.info(tr('The impact report could not be generated.'))
send_error_message(self, message)
LOGGER.info(message.to_text())
return ANALYSIS_FAILED_BAD_CODE, message
self.extent.set_last_analysis_extent(
self.impact_function.analysis_extent, qgis_exposure.crs())
# Hide busy
self.hide_busy()
# Setup gui if analysis is done
self.setup_gui_analysis_done()
return ANALYSIS_SUCCESS, None
