def generate_indicators(self):
self.filepaths = {}
for name, (projconfig, batchname, visname, datasourcename,
year) in self.indicators.items():
op = OpusProject()
op.open(os.path.join(PROJECTCONFIGBASE, projconfig))
bp = BatchProcessor(op)
visualizationsconf = get_batch_configuration(project=op,
batch_name=batchname,
vis_name=visname)
bp.set_data(visualizations=visualizationsconf,
source_data_name=datasourcename,
years=[year, year])
bp.run()
visualizations = bp.get_visualizations()
# visualizations in batch
assert len(visualizations) == 1
vistype, visualizations = visualizations[0]
# indicators in visualization
assert len(visualizations) == 1
self.filepaths[name] = visualizations[0].get_file_path()
def on_indicatorBox(self):
indicator_name = str(self.diagnostic_indicator_name.currentText())
dataset_name = self.diagnostic_dataset_name.currentText()
indicator_type = str(self.diagnostic_indicator_type.currentText())
year = str(self.diagnostic_year.currentText())
if year == '': return
year = int(year)
if dataset_name not in self.spatial_datasets and indicator_type == 'map':
MessageBox.warning(
mainwindow=self.mainwindow,
text="That indicator cannot be visualized as a map.",
detailed_text=(
'The dataset %s is either not spatial or cannot be '
'rendered as a grid. If the latter, please try '
'exporting to an external GIS tool.' % dataset_name))
return
cache_directory = self.model.config['cache_directory']
params = {'indicators': [indicator_name]}
if indicator_type == 'table':
indicator_type = 'tab'
params['output_type'] = 'tab'
# JLM > commented this out for when implemented animations
# else:
# indicator_type = 'mapnik_map'
visualizations = [(indicator_type, str(dataset_name), params)]
self.batch_processor = BatchProcessor(self.project)
self.batch_processor.guiElement = self
self.batch_processor.set_data(visualizations=visualizations,
source_data_name=self.model.run_name,
years=[year, year],
cache_directory=cache_directory)
self.diagnosticThread = OpusGuiThread(
parentThread=self.mainwindow,
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(self.diagnosticThread,
SIGNAL("runFinished(PyQt_PyObject)"),
self.visualizationsCreated)
QObject.connect(self.diagnosticThread,
SIGNAL("runError(PyQt_PyObject)"),
self.runErrorFromThread)
self.diagnosticThread.start()
def runIndicatorBatch(self):
visualizations = get_batch_configuration(project=self.project,
batch_name=self.batch_name)
start, end = self.get_years()
self.batch_processor = BatchProcessor(project=self.project)
self.batch_processor.errorCallback = self.errorCallback
self.batch_processor.finishedCallback = self.indicatorBatchFinishedCallback
self.batch_processor.set_data(visualizations=visualizations,
source_data_name=self.get_run_name(),
years=range(start, end + 1))
self.batch_processor.run()
def __init__(self, mainwindow, resultsManagerBase, batch_name = None,
run_name = None):
QDialog.__init__(self, mainwindow)
self.setupUi(self)
#mainwindow is an OpusGui
self.mainwindow = mainwindow
self.resultsManagerBase = resultsManagerBase
self.project = resultsManagerBase.project
self.available_years_for_simulation_runs = {}
self.batch_processor = BatchProcessor(project = self.project)
self.batch_processor.guiElement = self
self.run_name = run_name
self.batch_name = batch_name
self._setup_co__years()
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)
try: import wingdbstub
except: pass
option_group = MakeIndicatorsOptionGroup()
parser = option_group.parser
(options, args) = parser.parse_args()
if not (options.xml_configuration and
options.indicator_batch and
( options.cache_directory or
options.run_name) and
options.years
):
parser.print_help()
sys.exit(0)
from opus_gui.results_manager.run.batch_processor import BatchProcessor
project = OpusProject()
project.open(options.xml_configuration)
bp = BatchProcessor(project)
visualizations = get_batch_configuration(project = project,
batch_name = options.indicator_batch)
bp.set_data(visualizations=visualizations,
source_data_name = options.run_name,
cache_directory = options.cache_directory,
years = eval(options.years),
)
bp.errorCallback = lambda x: x ##
bp.finishedCallback = lambda x: x ## hack to work around BatchProcessor
bp.run()
