def get_time_series_for_point(ctx: ServiceContext,
ds_name: str,
var_name: str,
lon: float,
lat: float,
start_date: np.datetime64 = None,
end_date: np.datetime64 = None,
max_valids: int = None) -> Dict:
"""
Get the time-series for a given point.
:param ctx: Service context object
:param ds_name: The dataset identifier.
:param var_name: The variable name.
:param lon: The point's longitude in decimal degrees.
:param lat: The point's latitude in decimal degrees.
:param start_date: An optional start date.
:param end_date: An optional end date.
:param max_valids: Optional number of valid points.
If it is None (default), also missing values are returned as NaN;
if it is -1 only valid values are returned;
if it is a positive integer, the most recent valid values are returned.
:return: Time-series data structure.
"""
measure_time = measure_time_cm(disabled=not ctx.trace_perf)
with measure_time('get_time_series_for_point'):
dataset = _get_time_series_dataset(ctx, ds_name, var_name)
return _get_time_series_for_point(dataset,
var_name,
shapely.geometry.Point(lon, lat),
start_date=start_date,
end_date=end_date,
max_valids=max_valids)
def test_enabled(self):
measure_time = measure_time_cm(disabled=False)
with measure_time("hello") as cm:
time.sleep(0.06)
self.assertTrue(hasattr(cm, "duration"))
self.assertTrue(cm.duration > 0.05)
self.assertIsNotNone(cm.logger)
def __init__(self,
other: Union[Mapping, MutableMapping],
logger: Logger = LOG,
name: Optional[str] = None):
assert_instance(other, Mapping)
self._other = other
self._measure_time = measure_time_cm(logger=logger)
self._name = name or 'chunk_store'
if hasattr(other, 'listdir'):
setattr(self, 'listdir', self.__listdir)
if hasattr(other, 'getsize'):
setattr(self, 'getsize', self.__getsize)
def get_ml_dataset_tile(ml_dataset: MultiLevelDataset,
var_name: str,
x: int,
y: int,
z: int,
labels: Mapping[str, Any] = None,
labels_are_indices: bool = False,
cmap_name: Union[str, Tuple[Optional[str]]] = None,
cmap_range: Union[Tuple[float, float],
Tuple[Tuple[float, float],
Tuple[float, float],
Tuple[float, float]]] = None,
image_cache: MutableMapping[str, TiledImage] = None,
tile_cache: Cache = None,
trace_perf: bool = False,
exception_type: Type[Exception] = ValueError) -> Tile:
labels = labels or {}
ds_cache_id = hex(id(ml_dataset))
image_id = '-'.join(
map(str, [
ds_cache_id, z, ml_dataset.ds_id, var_name, cmap_name, cmap_range
] + [
f'{dim_name}={dim_value}'
for dim_name, dim_value in labels.items()
]))
measure_time = measure_time_cm(logger=LOG, disabled=not trace_perf)
if image_cache and image_id in image_cache:
image = image_cache[image_id]
else:
with measure_time() as measured_time:
if var_name == 'rgb':
image = new_rgb_image(ml_dataset, image_id, cmap_name,
cmap_range, z, labels,
labels_are_indices, tile_cache,
trace_perf, exception_type)
else:
image = new_color_mapped_image(ml_dataset, image_id, var_name,
cmap_name, cmap_range, z,
labels, labels_are_indices,
tile_cache, trace_perf,
exception_type)
if image_cache:
image_cache[image_id] = image
if trace_perf:
tile_grid = ml_dataset.tile_grid
LOG.info(
f'Created tiled image {image_id!r} of size {image.size}.\n'
f'Took {measured_time.duration:.2f} seconds. Tile grid:\n'
f' num_levels: {tile_grid.num_levels}\n'
f' num_level_zero_tiles: {tile_grid.get_num_tiles(0)}\n'
f' tile_size: {tile_grid.tile_size}\n'
f' extent: {tile_grid.extent}\n'
f' is_j_axis_up: {tile_grid.is_j_axis_up}')
if trace_perf:
LOG.info(f'>>> tile {image_id}/{z}/{y}/{x}')
with measure_time() as measured_time:
tile = image.get_tile(x, y)
if trace_perf:
LOG.info(f'<<< tile {image_id}/{z}/{y}/{x}:'
f' took ' + '%.2f seconds' % measured_time.duration)
return tile
def measure_time(self):
""" A context manager to measure execution time of code blocks. """
return measure_time_cm(disabled=not self._trace_perf)
def measure_time(self):
return measure_time_cm(disabled=not self.trace_perf, logger=LOG)
def get_ml_dataset_tile(ml_dataset: MultiLevelDataset,
var_name: str,
x: int,
y: int,
z: int,
labels: Mapping[str, Any] = None,
labels_are_indices: bool = False,
cmap_name: str = None,
cmap_vmin: float = None,
cmap_vmax: float = None,
image_cache: MutableMapping[str, TiledImage] = None,
tile_cache: Cache = None,
tile_comp_mode: int = 0,
trace_perf: bool = False,
exception_type: Type[Exception] = ValueError):
measure_time = measure_time_cm(logger=_LOG, disabled=not trace_perf)
dataset = ml_dataset.get_dataset(ml_dataset.num_levels - 1 - z)
var = dataset[var_name]
labels = labels or {}
ds_id = hex(id(ml_dataset))
image_id = '-'.join(
map(str, [ds_id, z, var_name, cmap_name, cmap_vmin, cmap_vmax] + [
f'{dim_name}={dim_value}'
for dim_name, dim_value in labels.items()
]))
if image_cache and image_id in image_cache:
image = image_cache[image_id]
else:
no_data_value = var.attrs.get('_FillValue')
valid_range = get_var_valid_range(var)
cmap_name, cmap_vmin, cmap_vmax = get_var_cmap_params(
var, cmap_name, cmap_vmin, cmap_vmax, valid_range)
array = get_var_2d_array(var, labels, labels_are_indices,
exception_type, ml_dataset.ds_id)
tile_grid = ml_dataset.tile_grid
if not tile_comp_mode:
image = NdarrayImage(array.values,
image_id=f'ndai-{image_id}',
tile_size=tile_grid.tile_size,
trace_perf=trace_perf)
image = TransformArrayImage(image,
image_id=f'tai-{image_id}',
flip_y=tile_grid.inv_y,
force_masked=True,
no_data_value=no_data_value,
valid_range=valid_range,
trace_perf=trace_perf)
image = ColorMappedRgbaImage(image,
image_id=f'rgb-{image_id}',
cmap_range=(cmap_vmin, cmap_vmax),
cmap_name=cmap_name,
encode=True,
format='PNG',
tile_cache=tile_cache,
trace_perf=trace_perf)
else:
image = ColorMappedRgbaImage2(array.values,
image_id=f'rgb-{image_id}',
tile_size=tile_grid.tile_size,
cmap_range=(cmap_vmin, cmap_vmax),
cmap_name=cmap_name,
encode=True,
format='PNG',
flip_y=tile_grid.inv_y,
no_data_value=no_data_value,
valid_range=valid_range,
tile_cache=tile_cache,
trace_perf=trace_perf)
if image_cache:
image_cache[image_id] = image
if trace_perf:
_LOG.info(
f'Created tiled image {image_id!r} of size {image.size} with tile grid:'
)
_LOG.info(f' num_levels: {tile_grid.num_levels}')
_LOG.info(f' num_level_zero_tiles: {tile_grid.num_tiles(0)}')
_LOG.info(f' tile_size: {tile_grid.tile_size}')
_LOG.info(f' geo_extent: {tile_grid.geo_extent}')
_LOG.info(f' inv_y: {tile_grid.inv_y}')
if trace_perf:
_LOG.info(f'>>> tile {image_id}/{z}/{y}/{x}')
with measure_time() as measured_time:
tile = image.get_tile(x, y)
if trace_perf:
_LOG.info(f'<<< tile {image_id}/{z}/{y}/{x}: took ' +
'%.2f seconds' % measured_time.duration)
return tile
def test_disabled(self):
measure_time = measure_time_cm(disabled=True)
with measure_time("hello") as cm:
time.sleep(0.05)
self.assertTrue(hasattr(cm, "duration"))
self.assertIsNone(cm.duration)
def get_dataset_tile(ctx: ServiceContext, ds_id: str, var_name: str, x: str,
y: str, z: str, params: RequestParams):
x = RequestParams.to_int('x', x)
y = RequestParams.to_int('y', y)
z = RequestParams.to_int('z', z)
tile_comp_mode = params.get_query_argument_int('mode', ctx.tile_comp_mode)
trace_perf = params.get_query_argument_int('debug', ctx.trace_perf) != 0
measure_time = measure_time_cm(logger=_LOG, disabled=not trace_perf)
var = ctx.get_variable_for_z(ds_id, var_name, z)
dim_names = list(var.dims)
if 'lon' not in dim_names or 'lat' not in dim_names:
raise ServiceBadRequestError(
f'Variable "{var_name}" of dataset "{ds_id}" is not geo-spatial')
dim_names.remove('lon')
dim_names.remove('lat')
var_indexers = ctx.get_var_indexers(ds_id, var_name, var, dim_names,
params)
cmap_cbar = params.get_query_argument('cbar', default=None)
cmap_vmin = params.get_query_argument_float('vmin', default=None)
cmap_vmax = params.get_query_argument_float('vmax', default=None)
if cmap_cbar is None or cmap_vmin is None or cmap_vmax is None:
default_cmap_cbar, default_cmap_vmin, default_cmap_vmax = ctx.get_color_mapping(
ds_id, var_name)
cmap_cbar = cmap_cbar or default_cmap_cbar
cmap_vmin = cmap_vmin or default_cmap_vmin
cmap_vmax = cmap_vmax or default_cmap_vmax
image_id = '-'.join(
map(str, [ds_id, z, var_name, cmap_cbar, cmap_vmin, cmap_vmax] + [
f'{dim_name}={dim_value}'
for dim_name, dim_value in var_indexers.items()
]))
if image_id in ctx.image_cache:
image = ctx.image_cache[image_id]
else:
no_data_value = var.attrs.get('_FillValue')
valid_range = var.attrs.get('valid_range')
if valid_range is None:
valid_min = var.attrs.get('valid_min')
valid_max = var.attrs.get('valid_max')
if valid_min is not None and valid_max is not None:
valid_range = [valid_min, valid_max]
# Make sure we work with 2D image arrays only
if var.ndim == 2:
assert len(var_indexers) == 0
array = var
elif var.ndim > 2:
assert len(var_indexers) == var.ndim - 2
array = var.sel(method='nearest', **var_indexers)
else:
raise ServiceBadRequestError(
f'Variable "{var_name}" of dataset "{var_name}" '
'must be an N-D Dataset with N >= 2, '
f'but "{var_name}" is only {var.ndim}-D')
cmap_vmin = np.nanmin(
array.values) if np.isnan(cmap_vmin) else cmap_vmin
cmap_vmax = np.nanmax(
array.values) if np.isnan(cmap_vmax) else cmap_vmax
tile_grid = ctx.get_tile_grid(ds_id)
if not tile_comp_mode:
image = NdarrayImage(
array,
image_id=f'ndai-{image_id}',
tile_size=tile_grid.tile_size,
# tile_cache=ctx.tile_cache,
trace_perf=trace_perf)
image = TransformArrayImage(
image,
image_id=f'tai-{image_id}',
flip_y=tile_grid.inv_y,
force_masked=True,
no_data_value=no_data_value,
valid_range=valid_range,
# tile_cache=ctx.tile_cache,
trace_perf=trace_perf)
image = ColorMappedRgbaImage(image,
image_id=f'rgb-{image_id}',
value_range=(cmap_vmin, cmap_vmax),
cmap_name=cmap_cbar,
encode=True,
format='PNG',
tile_cache=ctx.tile_cache,
trace_perf=trace_perf)
else:
image = ColorMappedRgbaImage2(array,
image_id=f'rgb-{image_id}',
tile_size=tile_grid.tile_size,
cmap_range=(cmap_vmin, cmap_vmax),
cmap_name=cmap_cbar,
encode=True,
format='PNG',
flip_y=tile_grid.inv_y,
no_data_value=no_data_value,
valid_range=valid_range,
tile_cache=ctx.tile_cache,
trace_perf=trace_perf)
ctx.image_cache[image_id] = image
if trace_perf:
_LOG.info(
f'Created tiled image {image_id!r} of size {image.size} with tile grid:'
)
_LOG.info(f' num_levels: {tile_grid.num_levels}')
_LOG.info(f' num_level_zero_tiles: {tile_grid.num_tiles(0)}')
_LOG.info(f' tile_size: {tile_grid.tile_size}')
_LOG.info(f' geo_extent: {tile_grid.geo_extent}')
_LOG.info(f' inv_y: {tile_grid.inv_y}')
if trace_perf:
_LOG.info(f'>>> tile {image_id}/{z}/{y}/{x}')
with measure_time() as measured_time:
tile = image.get_tile(x, y)
if trace_perf:
_LOG.info(f'<<< tile {image_id}/{z}/{y}/{x}: took ' +
'%.2f seconds' % measured_time.duration)
return tile