def test_run_chain_read_filter_kelvin_summarize(self):
        processor_list = [{
            'name': 'GridReadingProcessor',
            'config': {
                'latitude': 'lat',
                'longitude': 'lon',
                'time': 'time',
                'variable_to_read': 'analysed_sst'
            }
        }, {
            'name': 'EmptyTileFilter',
            'config': {}
        }, {
            'name': 'KelvinToCelsius',
            'config': {}
        }, {
            'name': 'TileSummarizingProcessor',
            'config': {}
        }]
        processorchain = ProcessorChain(processor_list)

        test_file = path.join(path.dirname(__file__), 'datafiles',
                              'not_empty_mur.nc4')

        input_tile = nexusproto.NexusTile()
        tile_summary = nexusproto.TileSummary()
        tile_summary.granule = "file:%s" % test_file
        tile_summary.section_spec = "time:0:1,lat:0:10,lon:0:10"
        input_tile.summary.CopyFrom(tile_summary)

        results = list(processorchain.process(input_tile))

        self.assertEqual(1, len(results))
    def test_run_chain_read_filter_all(self):
        processor_list = [{
            'name': 'GridReadingProcessor',
            'config': {
                'latitude': 'lat',
                'longitude': 'lon',
                'time': 'time',
                'variable_to_read': 'analysed_sst'
            }
        }, {
            'name': 'EmptyTileFilter',
            'config': {}
        }]
        processorchain = ProcessorChain(processor_list)

        test_file = path.join(path.dirname(__file__), 'datafiles',
                              'empty_mur.nc4')

        input_tile = nexusproto.NexusTile()
        tile_summary = nexusproto.TileSummary()
        tile_summary.granule = "file:%s" % test_file
        tile_summary.section_spec = "time:0:1,lat:0:10,lon:0:10"
        input_tile.summary.CopyFrom(tile_summary)

        gen = processorchain.process(input_tile)
        for message in gen:
            self.fail("Should not produce any messages. Message: %s" % message)
def run_processor_chain():
    try:
        parameters = request.get_json()
    except Exception as e:
        raise BadRequest("Invalid JSON data") from e

    try:
        processor_list = parameters['processor_list']
    except (KeyError, TypeError):
        raise BadRequest(description="processor_list is required.")

    try:
        chain = ProcessorChain(processor_list)
    except ProcessorNotFound as e:
        raise BadRequest("Unknown processor requested: %s" %
                         e.missing_processor) from e
    except MissingProcessorArguments as e:
        raise BadRequest("%s missing required configuration options: %s" %
                         (e.processor, e.missing_processor_args)) from e

    try:
        input_data = json_format.Parse(parameters['input_data'],
                                       nexusproto.NexusTile())
    except ParseError as e:
        raise BadRequest(
            "input_data must be a NexusTile protobuf serialized as a string"
        ) from e

    result = next(chain.process(input_data), None)

    if isinstance(result, nexusproto.NexusTile):
        result = result.SerializeToString()

    return Response(result, mimetype='application/octet-stream')
    def test_construct_chain_with_list_config(self):
        processor_list = [{
            'name': 'TimeSeriesReadingProcessor',
            'config': {
                'latitude': 'lat',
                'longitude': 'lon',
                'time': 'time',
                'variable_to_read': 'Qout'
            }
        }, {
            'name': 'EmptyTileFilter',
            'config': {}
        }, {
            'name': 'PromoteVariableToGlobalAttribute',
            'config': {
                'attribute_name': 'rivid_i',
                'variable_name': 'rivid',
                'dimensioned_by.0': 'rivid',
                'dimensioned_by.1': 'other'
            }
        }, {
            'name': 'TileSummarizingProcessor',
            'config': {}
        }]

        processorchain = ProcessorChain(processor_list)

        self.assertIsNotNone(processorchain)
    def test_run_chain_promote_var(self):
        processor_list = [{
            'name': 'GridReadingProcessor',
            'config': {
                'latitude': 'lat',
                'longitude': 'lon',
                'time': 'time',
                'variable_to_read': 'analysed_sst'
            }
        }, {
            'name': 'EmptyTileFilter',
            'config': {}
        }, {
            'name': 'KelvinToCelsius',
            'config': {}
        }, {
            'name': 'PromoteVariableToGlobalAttribute',
            'config': {
                'attribute_name': 'time_i',
                'variable_name': 'time',
                'dimensioned_by.0': 'time'
            }
        }, {
            'name': 'TileSummarizingProcessor',
            'config': {}
        }]
        processorchain = ProcessorChain(processor_list)

        test_file = path.join(path.dirname(__file__), 'datafiles',
                              'partial_empty_mur.nc4')

        input_tile = nexusproto.NexusTile()
        tile_summary = nexusproto.TileSummary()
        tile_summary.granule = "file:%s" % test_file
        tile_summary.section_spec = "time:0:1,lat:489:499,lon:0:10"
        input_tile.summary.CopyFrom(tile_summary)

        results = list(processorchain.process(input_tile))

        self.assertEqual(1, len(results))
        tile = results[0]
        self.assertEqual("1104483600",
                         tile.summary.global_attributes[0].values[0])
    def test_construct_chain_with_list_config_bad_index(self):
        processor_list = [{
            'name': 'PromoteVariableToGlobalAttribute',
            'config': {
                'attribute_name': 'rivid_i',
                'variable_name': 'rivid',
                'dimensioned_by.0': 'rivid',
                'dimensioned_by.10': 'other'
            }
        }]

        processorchain = ProcessorChain(processor_list)

        self.assertIsNotNone(processorchain)
    def test_construct_chain_with_multiple_list_config(self):
        processor_list = [{
            'name': 'PromoteVariableToGlobalAttribute',
            'config': {
                'attribute_name': 'rivid_i',
                'variable_name': 'rivid',
                'dimensioned_by.0': 'rivid',
                'dimensioned_by.1': 'other',
                'unused.0': 'list',
                'unused.1': 'second'
            }
        }]

        processorchain = ProcessorChain(processor_list)

        self.assertIsNotNone(processorchain)