def image(self, state):
if not self.valid(state):
return gridded_forecast.empty_image()
data = self._input_output(self.pattern, state.variable,
state.initial_time, state.valid_time,
state.pressure)
data.update(
gridded_forecast.coordinates(state.valid_time, state.initial_time,
state.pressures, state.pressure))
return data
def test_surface_and_times(self, to_datetime):
valid = datetime(2019, 10, 10, 9)
initial = datetime(2019, 10, 10, 3)
to_datetime.side_effect = [valid, initial]
result = gridded_forecast.coordinates(sentinel.valid, sentinel.initial,
[], None)
self.assertEqual(to_datetime.mock_calls, [call(sentinel.valid),
call(sentinel.initial)])
self.assertEqual(result, {'valid': [valid], 'initial': [initial],
'length': ['T+6'], 'level': ['Surface']})
def image(self, state):
"""
Main image loading function. This function will actually realise the
data,
"""
if self.variable_id != state.variable:
self.variable_id = state.variable
self._cube = None
valid_time = state.valid_time
pressure = state.pressure
selected_time = util.to_datetime(valid_time)
# the guts of creating the bokeh object has been put into a separate
# function so that it can be cached, so if image is called multiple
# time the calculations are only done once (hopefully).
cube = self.cube
coord_names = [c1.name() for c1 in cube.coords()]
if "air_pressure" in coord_names and pressure is None:
data = gridded_forecast.empty_image()
return data
data = _get_bokeh_image(
cube,
self.experiment_id,
self.variable_id,
self.institution_id,
state.initial_time,
self.member_id,
selected_time,
pressure,
)
data.update(
gridded_forecast.coordinates(
str(selected_time),
state.initial_time,
state.pressures,
pressure,
))
data.update({
"name": [self._label],
"units": [str(cube.units)],
"experiment": [self.experiment_id],
"institution": [self.institution_id],
"memberid": [self.member_id],
"variableid": [self.variable_id],
})
return data
def _image(self, long_name, initial_time, valid_time, pressures, pressure):
data = empty_image()
paths = self.locator.glob()
long_name_to_variable = self.locator.long_name_to_variable(paths)
frequency = dt.timedelta(minutes=15) # TODO: Support arbitrary frequencies
for path in self.locator.find_paths(paths, valid_time, frequency):
with xarray.open_dataset(path) as nc:
if long_name not in long_name_to_variable:
continue
x = np.ma.masked_invalid(nc['lon'])[:]
y = np.ma.masked_invalid(nc['lat'])[:]
var = nc[long_name_to_variable[long_name]]
z = np.ma.masked_invalid(var)[:]
data = geo.stretch_image(x, y, z)
data.update(coordinates(valid_time, initial_time, pressures, pressure))
data['name'] = [str(var.long_name)]
if 'units' in var.attrs:
data['units'] = [str(var.units)]
return data
def test_surface_and_times(self, to_datetime):
valid = datetime(2019, 10, 10, 9)
initial = datetime(2019, 10, 10, 3)
to_datetime.side_effect = [valid, initial]
result = gridded_forecast.coordinates(sentinel.valid, sentinel.initial,
[], None)
self.assertEqual(
to_datetime.mock_calls,
[call(sentinel.valid),
call(sentinel.initial)],
)
self.assertEqual(
result,
{
"valid": [valid],
"initial": [initial],
"length": ["T+6"],
"level": ["Surface"],
},
)
def test_pressure(self, to_datetime):
result = gridded_forecast.coordinates(None, None, [1000, 900], 900)
self.assertEqual(result["level"], ["900 hPa"])
def test_surface_no_pressure(self, to_datetime):
result = gridded_forecast.coordinates(None, None, [1000, 900], None)
self.assertEqual(result["level"], ["Surface"])
def test_surface_no_pressures(self, to_datetime):
result = gridded_forecast.coordinates(None, None, [], 950)
self.assertEqual(result['level'], ['Surface'])
