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