def get_stats(stats, metrics, from_datetime, to_datetime):
"""this function give stats (the samalest, bigger and average value)
of metrics (temperature, dewPoint, precipitation, ...) between a select begin and end
time period
"""
all_display_stats = []
query_measurement = query_measurements(from_datetime, to_datetime)
for m in metrics:
# create an array with metric values
metric_val = metric_value(m, query_measurement)
#if the array is empty return an empty array
if len(metric_val) == 0:
return jsonify(all_display_stats)
#calculate the stats for every stat (min,max average) and add it into our final array
for s in stats:
if s == 'min':
min_stats = min(metric_val)
my_stat = creat_stat('min', m, min_stats)
all_display_stats.append(my_stat)
elif s == 'max':
max_stats = max(metric_val)
my_stat = creat_stat('max', m, max_stats)
all_display_stats.append(my_stat)
elif s == 'average':
average_stats = float(sum(metric_val)) / float(len(metric_val))
average_stats = round(average_stats, 1)
my_stat = creat_stat('average', m, average_stats)
all_display_stats.append(my_stat)
else:
return abort(400)
return jsonify(all_display_stats)
def get_stats(stats, metrics, from_datetime, to_datetime):
# TODO:
#abort(501)
### ADDED ###
ret = []
measurements = query_measurements(from_datetime, to_datetime)
for stat in stats:
if stat == 'min':
for metric in metrics:
entry = {}
entry['metrics'] = metric
entry['stats'] = 'min'
entry['value'] = min(
[m.metrics.get(metric) for m in measurements])
ret.append(entry)
elif stat == 'max':
for metric in metrics:
entry = {}
entry['metrics'] = metric
entry['stats'] = 'max'
entry['value'] = max(
[m.metrics.get(metric) for m in measurements])
ret.append(entry)
elif stat == 'average':
for metric in metrics:
entry = {}
data = [float(m.metrics.get(metric)) for m in measurements]
entry['metrics'] = metric
entry['stats'] = 'average'
entry['value'] = sum(data) / len(data)
ret.append(entry)
return ret
def get_stats(stats, metrics, from_datetime, to_datetime):
statistics = []
query_measurement = query_measurements(from_datetime, to_datetime)
for metric in metrics:
for stat in stats:
result = calculateMetricStats(query_measurement, metric, stat)
statistics.add(result)
return statistics
def get_stats(stats, metrics, from_datetime, to_datetime):
result = []
all_stats = ["min", "max", "avg"]
measurements = query_measurements(from_datetime, to_datetime)
for metric in metrics:
numbers = aggregate_metric(metric, measurements)
if len(numbers) != 0:
if len(stats) == 1 and stats[0] == "all":
stats = all_stats
for stat in stats:
val = compute_stat(stat, numbers)
tmp = {
'metric': metric,
'stat' : stat,
'value': val
}
result.append(tmp)
return result
def get_stats(stats, metrics, from_datetime, to_datetime):
#initialize metric_dict to hold list of values for each metric
metric_dict = {}
for metric in metrics:
metric_dict[metric] = []
#swap to and from datetimes if from_datetime is greater than to_datetime
if from_datetime > to_datetime:
temp = from_datetime
from_datetime = to_datetime
to_datetime = temp
#create Statistics object or retrieve if already exsits
new_statistic = get_statistic(from_datetime, to_datetime)
#retrieve list of measurements and create list of values for each metric to add to metric_dict
queried_measurements = query_measurements(from_datetime, to_datetime)
for measurement in queried_measurements:
for metric in metrics:
if metric in measurement.metrics:
metric_dict[metric].append(measurement.get_metric(metric))
#calculate stat and add to statistics list if needed
for metric in metrics:
for stat in stats:
if metric_dict[metric] and not new_statistic.metric_stat_exists(
metric, stat):
value = stats_dict[stat](metric_dict[metric])
new_statistic.add_statistic({
'metric': metric,
'stat': stat,
'value': value
})
#add Statistics object to store if statistics list is not empty
if new_statistic.statistics:
stats_store.append(new_statistic)
return new_statistic.statistics
def get_stats(stats, metrics, from_datetime, to_datetime):
stats_lis = []
# stats_lis = {}
if from_datetime >= to_datetime:
return stats_lis
selected_measurement_lis = query_measurements(from_datetime, to_datetime)
for metric in metrics:
print("for metric {}".format(metric))
# initialize
response_stats_dic = {}
measurement = selected_measurement_lis[0]
all_values_for_avg = []
if metric in measurement.metrics:
initial_value = measurement.get_metric(metric)
all_values_for_avg.append(initial_value)
else:
initial_value = 0
# initialize metric_stats_dic with very first measurement
print("initializing stats for {}".format(metric))
for stat in stats:
print("setting stat {}".format(stat))
response_stats_dic[stat] = initial_value
index = 1
while index < len(selected_measurement_lis):
print("now finding stats using all {}".format(index))
measurement = selected_measurement_lis[index]
if metric in measurement.metrics:
value = measurement.get_metric(metric)
print("metric next value {}".format(value))
else:
value = 0
# Assuming that if metric value is zero, skip metric value for min, max, average calculation
if value == 0:
print("skipping, value is 0")
index += 1
continue
if 'min' in response_stats_dic and response_stats_dic[
'min'] > value:
response_stats_dic['min'] = value
if 'max' in response_stats_dic and response_stats_dic[
'max'] < value:
response_stats_dic['max'] = value
if 'average' in response_stats_dic:
print("adding in average {}".format(value))
all_values_for_avg.append(value)
index += 1
if 'average' in response_stats_dic:
print("total sum {} and count {}".format(sum(all_values_for_avg),
len(all_values_for_avg)))
response_stats_dic['average'] = round(
(sum(all_values_for_avg) / len(all_values_for_avg)), 1)
# response format:
stats_lis.append({metric:
response_stats_dic}) # declare stats_lis = [] at top
# stats_lis[metric] = response_stats_dic # declare stats_lis = {} at top
print("Stats list {}".format(stats_lis))
return stats_lis
def __init__(self, metrics, start_date, end_date):
self.measurements = query_measurements(start_date, end_date)
self._aggregate_metrics(metrics)