def param_rdb_download(request):
form = DataParamForm(request.GET)
if form.is_valid():
_logger.info(
"requested data download for %s with params %s"
% (form.cleaned_data["site_list"], form.cleaned_data["params"])
)
beginDate = form.cleaned_data["timeseries_start"]
endDate = form.cleaned_data["timeseries_end"]
gage = form.cleaned_data["site_list"]
p = form.cleaned_data["params"][0]
station_list = stage_queries.station_list([gage])
pt = Plottable(station_list[0], p, beginDate, endDate)
data_seq = pt.sequence()
# fifth parameter to create_metadata_header is list of Station objects
station_list = stage_queries.station_list([gage])
query_metadata_list = create_metadata_header(
GENERAL_MESSAGE, EDEN_CONTACT, END_OF_HEADER, form.cleaned_data, station_list, water_level=False
)
response = HttpResponse(content_type="text/csv")
stage_data.write_rdb(data_seq, response, metadata=query_metadata_list)
return response
else:
return HttpResponseBadRequest(",".join(form.errors))
def test_ambiguous_station_name(self):
"Test for the one station name that produces two separate station records"
names = ["S150_T"]
ss = stage_queries.station_list(names)
self.assertEqual(len(names), len(ss))
self.assertEquals(names, [s.station_name_web for s in ss])
def test_peculiar_station_names(self):
"Test for peculiar station names"
names = ['C111_wetland_east_of_FIU_LTER_TSPH5', 'S343A_H']
ss = stage_queries.station_list(names)
self.assertEqual(len(names), len(ss))
self.assertEquals(names, [s.station_name_web for s in ss])
def test_peculiar_station_names(self):
"Test for peculiar station names"
names = ['C111_wetland_east_of_FIU_LTER_TSPH5', 'S343A_H']
ss = stage_queries.station_list(names)
self.assertEqual(len(names), len(ss))
self.assertEquals(names, [s.station_name_web for s in ss])
def test_ambiguous_station_name(self):
"Test for the one station name that produces two separate station records"
names = ["S150_T"]
ss = stage_queries.station_list(names)
self.assertEqual(len(names), len(ss))
self.assertEquals(names, [s.station_name_web for s in ss])
def test_duplicate_station_names(self):
"Test that duplicate station names are collapsed, but otherwise order is preserved"
names = ["G-3567", "CH1", "RG3", "ANGEL", "BARW4", "TSH", "W2", "W15", "W2", "Upstream_Taylor_River", "TSH", "CH1"]
ss = stage_queries.station_list(names)
names_dedup = ["G-3567", "CH1", "RG3", "ANGEL", "BARW4", "TSH", "W2", "W15", "Upstream_Taylor_River"]
# self.assertEqual(len(names) - 3, len(ss))
self.assertEquals(names_dedup, [s.station_name_web for s in ss])
def param_page(request):
template_name = 'eve_params.html'
param_form = DataParamForm()
if "clear_form" in request.REQUEST:
return redirect(param_page)
has_data = False
# be careful about initial get with no parameters,
# so we don't clobber the initial values
if request.method == 'GET' and request.GET:
param_form = DataParamForm(request.GET)
has_data = True
elif request.method == 'POST':
param_form = DataParamForm(request.POST)
has_data = True
if has_data:
if param_form.is_valid():
# Avoid the troublesome Nones.
plot_params = {}
for k, v in param_form.cleaned_data.items():
if v:
plot_params[k] = v
kwargs = {
'beginDate': param_form.cleaned_data['timeseries_start'],
'endDate': param_form.cleaned_data['timeseries_end']
}
plottables = []
station_list = stage_queries.station_list(
[param_form.cleaned_data['site_list']])
for s in station_list:
for p in param_form.cleaned_data['params']:
pt = Plottable(s, p, **kwargs)
plottables.append(pt)
render_params = {
'param_form': param_form,
'plottables': plottables,
'EDEN_URL': settings.EDEN_URL,
}
return render(request, template_name, render_params)
else:
# error in input
return render(request,
template_name, {
'param_form': param_form,
'EDEN_URL': settings.EDEN_URL
},
status=400)
return render(request, template_name, {
'param_form': param_form,
'EDEN_URL': settings.EDEN_URL
})
def test_duplicate_station_names(self):
"Test that duplicate station names are collapsed, but otherwise order is preserved"
names = [
"G-3567", "CH1", "RG3", "ANGEL", "BARW4", "TSH", "W2", "W15", "W2",
"Upstream_Taylor_River", "TSH", "CH1"
]
ss = stage_queries.station_list(names)
names_dedup = [
"G-3567", "CH1", "RG3", "ANGEL", "BARW4", "TSH", "W2", "W15",
"Upstream_Taylor_River"
]
# self.assertEqual(len(names) - 3, len(ss))
self.assertEquals(names_dedup, [s.station_name_web for s in ss])
def param_rdb_download(request):
form = DataParamForm(request.GET)
if form.is_valid():
_logger.info("requested data download for %s with params %s" % (form.cleaned_data['site_list'], form.cleaned_data['params']))
beginDate = form.cleaned_data["timeseries_start"]
endDate = form.cleaned_data["timeseries_end"]
gage = form.cleaned_data['site_list']
p = form.cleaned_data['params'][0]
station_list = stage_queries.station_list([gage])
pt = Plottable(station_list[0], p, beginDate, endDate)
data_seq = pt.sequence()
# fifth parameter to create_metadata_header is list of Station objects
station_list = stage_queries.station_list([gage])
query_metadata_list = create_metadata_header(GENERAL_MESSAGE, EDEN_CONTACT, END_OF_HEADER, form.cleaned_data, station_list, water_level=False)
response = HttpResponse(content_type='text/csv')
stage_data.write_rdb(data_seq, response, metadata=query_metadata_list)
return response
else:
return HttpResponseBadRequest(",".join(form.errors))
def param_page(request):
template_name = 'eve_params.html'
param_form = DataParamForm()
if "clear_form" in request.REQUEST:
return redirect(param_page)
has_data = False
# be careful about initial get with no parameters,
# so we don't clobber the initial values
if request.method == 'GET' and request.GET :
param_form = DataParamForm(request.GET)
has_data = True
elif request.method == 'POST':
param_form = DataParamForm(request.POST)
has_data = True
if has_data:
if param_form.is_valid():
# Avoid the troublesome Nones.
plot_params = {}
for k, v in param_form.cleaned_data.items():
if v:
plot_params[k] = v
kwargs = {
'beginDate' : param_form.cleaned_data['timeseries_start'],
'endDate' : param_form.cleaned_data['timeseries_end']
}
plottables = []
station_list = stage_queries.station_list([param_form.cleaned_data['site_list']])
for s in station_list:
for p in param_form.cleaned_data['params']:
pt = Plottable(s, p, **kwargs)
plottables.append(pt)
render_params = {'param_form': param_form,
'plottables': plottables,
'EDEN_URL': settings.EDEN_URL,
}
return render (request, template_name, render_params)
else:
# error in input
return render(request, template_name, {'param_form': param_form, 'EDEN_URL': settings.EDEN_URL }, status=400)
return render (request, template_name, {'param_form': param_form, 'EDEN_URL': settings.EDEN_URL })
def _plot_simple(gage, p, beginDate=None, endDate=None, format='png', show_logo=True):
station_list = stage_queries.station_list([gage])
pt = Plottable(station_list[0], p, beginDate, endDate)
data_seq = pt.sequence()
if show_logo:
title = pt.title()
else:
title = None
if not format in _mime_types:
return HttpResponseBadRequest("Unknown image format: " + format)
response = HttpResponse(content_type=_mime_types[format])
hydrograph.png_simple(data_seq, response, beginDate=beginDate, endDate=endDate,
format=format, show_logo=show_logo, title=title, y_label=pt.label_y())
return response
def test_station_data(self):
# Marker_52 has no station datum, BARW4 does
names = ['Marker_52' # no station datum
, 'BARW4' # full data
, 'New_River_at_Sunday_Bay' # station_datum but no vertical_conversion
# convert_to_navd_88 is non-null
]
ss = stage_queries.station_list(names)
marker_52 = ss[0]
barw4 = ss[1]
new_river = ss[2]
self.assertIsNone(marker_52.vertical_conversion)
self.assertIsNotNone(barw4.vertical_conversion)
self.assertIsNone(new_river.vertical_conversion)
self.assertIsNone(marker_52.convert_to_navd88_feet)
self.assertIsNotNone(barw4.convert_to_navd88_feet)
self.assertIsNotNone(new_river.convert_to_navd88_feet)
def param_data_download(request):
form = DataParamForm(request.GET)
if form.is_valid():
_logger.info("requested plot data for %s with params %s" % (form.cleaned_data['site_list'], form.cleaned_data['params']))
beginDate = form.cleaned_data["timeseries_start"]
endDate = form.cleaned_data["timeseries_end"]
gage = form.cleaned_data['site_list']
p = form.cleaned_data['params'][0]
station_list = stage_queries.station_list([gage])
pt = Plottable(station_list[0], p, beginDate, endDate)
data_seq = pt.sequence()
response = HttpResponse(content_type='text/csv')
stage_data.write_csv(data_seq, response)
return response
else:
return HttpResponseBadRequest(",".join(form.errors))
def test_station_data(self):
# Marker_52 has no station datum, BARW4 does
names = [
'Marker_52' # no station datum
,
'BARW4' # full data
,
'New_River_at_Sunday_Bay' # station_datum but no vertical_conversion
# convert_to_navd_88 is non-null
]
ss = stage_queries.station_list(names)
marker_52 = ss[0]
barw4 = ss[1]
new_river = ss[2]
self.assertIsNone(marker_52.vertical_conversion)
self.assertIsNotNone(barw4.vertical_conversion)
self.assertIsNone(new_river.vertical_conversion)
self.assertIsNone(marker_52.convert_to_navd88_feet)
self.assertIsNotNone(barw4.convert_to_navd88_feet)
self.assertIsNotNone(new_river.convert_to_navd88_feet)
def _plot_simple(gage, p, beginDate=None, endDate=None, format="png", show_logo=True):
station_list = stage_queries.station_list([gage])
pt = Plottable(station_list[0], p, beginDate, endDate)
data_seq = pt.sequence()
if show_logo:
title = pt.title()
if not format in _mime_types:
return HttpResponseBadRequest("Unknown image format: " + format)
response = HttpResponse(content_type=_mime_types[format])
hydrograph.png_simple(
data_seq,
response,
beginDate=beginDate,
endDate=endDate,
format=format,
show_logo=show_logo,
title=title,
y_label=pt.label_y(),
)
return response
def param_data_download(request):
form = DataParamForm(request.GET)
if form.is_valid():
_logger.info(
"requested plot data for %s with params %s" % (form.cleaned_data["site_list"], form.cleaned_data["params"])
)
beginDate = form.cleaned_data["timeseries_start"]
endDate = form.cleaned_data["timeseries_end"]
gage = form.cleaned_data["site_list"]
p = form.cleaned_data["params"][0]
station_list = stage_queries.station_list([gage])
pt = Plottable(station_list[0], p, beginDate, endDate)
data_seq = pt.sequence()
response = HttpResponse(content_type="text/csv")
stage_data.write_csv(data_seq, response)
return response
else:
return HttpResponseBadRequest(",".join(form.errors))
def eden_page(request):
"""
Allows a user to select a site,
date in order to view a dygraph
plot of results.
"""
# TODO If URL does not end with /, redirect there for ease of form generation
template_name = 'eve.html'
query_form = TimeSeriesFilterForm()
eden_url = settings.EDEN_URL
has_data = False
# be careful about initial get with no parameters,
# so we don't clobber the initial values
if request.method == 'GET' and request.GET:
query_form = TimeSeriesFilterForm(request.GET)
has_data = True
elif request.method == 'POST':
query_form = TimeSeriesFilterForm(request.POST)
has_data = True
if has_data:
"""
if not query_form.has_changed():
return render(request, template_name, {'query_form': query_form, })
"""
if query_form.is_valid():
# Avoid the troublesome Nones.
plot_params = {}
for k, v in query_form.cleaned_data.items():
if v:
plot_params[k] = v
plot_query_str = urllib.urlencode(plot_params, doseq=True)
isIE = 'MSIE' in request.META['HTTP_USER_AGENT']
gages = query_form.cleaned_data['site_list']
colors = ColorRange(count=len(gages))
if query_form.cleaned_data['timeseries_start']:
str_tstart = '%s' % query_form.cleaned_data['timeseries_start']
# elif isIE:
# str_tstart = min_date(gages)
else:
str_tstart = None
if query_form.cleaned_data['timeseries_end']:
str_tend = '%s' % query_form.cleaned_data['timeseries_end']
# elif isIE:
# str_tstart = max_date(gages)
else:
str_tend = None
_logger.debug("In page generation, colors = %s", list(colors))
render_params = {
'query_form': query_form,
'plot_params': mark_safe(plot_query_str),
'series_options': mark_safe(dygraph_series_options(gages)),
'str_tstart': str_tstart,
'gages': gages,
'str_tend': str_tend,
'colors': mark_safe(json.dumps(list(colors))),
'color_list': list(colors),
'DYGRAPH_RANGE_SELECTOR': settings.DYGRAPH_RANGE_SELECTOR,
'EDEN_URL': eden_url,
}
if len(gages) == 1:
station = stage_queries.station_list(gages)[0]
render_params['ngvd29_series'] = '%s%s' % (
station.station_name_web, '_NGVD29')
render_params['dry_elevation'] = station.dry_elevation or None
render_params[
'ground_elevation'] = station.duration_elevation or None
render_params[
'ngvd29_correction'] = station.vertical_conversion or 0.0
else:
render_params['dry_elevation'] = None
render_params['ground_elevation'] = None
render_params['ngvd29_correction'] = "null"
return render(request, template_name, render_params)
else:
return render(request,
template_name, {
'query_form': query_form,
'EDEN_URL': eden_url
},
status=400)
return render(request, template_name, {
'query_form': query_form,
'EDEN_URL': eden_url
})
beginDate="2006-10-15",
endDate="2006-11-12")
station = ss[0]
ct = png_single_station(data,
"/tmp/hg6b.png",
station,
beginDate=dateutil.parser.parse("2006-10-15"),
endDate=dateutil.parser.parse("2006-11-12"),
show_logo=False)
print "hg6b.png", ct
gage = "EDEN_3"
p = "rainfall"
beginDate = datetime.date(2013, 01, 01)
endDate = datetime.date(2013, 3, 1)
station_list = stage_queries.station_list([gage])
pt = Plottable(station_list[0], p, beginDate, endDate)
data_seq = pt.sequence()
show_logo = True
# Let logo also drive title display
if show_logo:
title = pt.title()
png_simple(data_seq,
"/tmp/hg7.png",
beginDate=beginDate,
endDate=endDate,
show_logo=show_logo,
import dj_eden_app.stage_queries as station_data
import dj_eden_app.views.data_views as data_views
try:
from dj_eden_app.models import station_list
except ImportError:
pass
import dj_eden_app.stage_queries as stage_queries
from decimal import Decimal
import unittest
gages = ['G-3567', '2A300']
stations = stage_queries.station_list(gages)
class TestStationData(unittest.TestCase):
def check(self, q, data_cols, flag_cols):
"Exercise a query and check the results"
valid_flags = ['M', 'D', 'E', 'O']
rs = q.execute()
for r in rs:
self.assertGreater(len(r), len(data_cols), len(flag_cols))
for d in data_cols:
if r[d] is not None:
self.assertIsInstance(r[d], Decimal)
for f in flag_cols:
self.assertIn(r[f], valid_flags)
def test_hourly(self):
import dj_eden_app.stage_queries as station_data
import dj_eden_app.views.data_views as data_views
try:
from dj_eden_app.models import station_list
except ImportError:
pass
import dj_eden_app.stage_queries as stage_queries
from decimal import Decimal
import unittest
gages = ['G-3567', '2A300']
stations = stage_queries.station_list(gages)
class TestStationData(unittest.TestCase):
def check(self, q, data_cols, flag_cols):
"Exercise a query and check the results"
valid_flags = ['M', 'D', 'E', 'O']
rs = q.execute()
for r in rs:
self.assertGreater(len(r), len(data_cols), len(flag_cols))
for d in data_cols:
if r[d] is not None:
self.assertIsInstance(r[d], Decimal)
for f in flag_cols:
self.assertIn(r[f], valid_flags)
def test_hourly(self):
q, dt = station_data.hourly_query(*stations)
show_logo=default_show_logo)
print "hg6a.png", ct
data, ss = stage_queries.data_for_plot_hourly(['CV5NR'], beginDate="2006-10-15", endDate="2006-11-12")
station = ss[0]
ct = png_single_station(data, "/tmp/hg6b.png", station,
beginDate=dateutil.parser.parse("2006-10-15"),
endDate=dateutil.parser.parse("2006-11-12"),
show_logo=False)
print "hg6b.png", ct
gage = "EDEN_3"
p = "rainfall"
beginDate = datetime.date(2013, 01, 01)
endDate = datetime.date(2013, 3, 1)
station_list = stage_queries.station_list([gage])
pt = Plottable(station_list[0], p, beginDate, endDate)
data_seq = pt.sequence()
show_logo = True
# Let logo also drive title display
if show_logo:
title = pt.title()
png_simple(data_seq, "/tmp/hg7.png", beginDate=beginDate, endDate=endDate,
show_logo=show_logo, title=title, y_label=pt.label_y())
print "hg7.png"
data_seq = pt.sequence()
def eden_page(request):
"""
Allows a user to select a site,
date in order to view a dygraph
plot of results.
"""
# TODO If URL does not end with /, redirect there for ease of form generation
template_name = 'eve.html'
query_form = TimeSeriesFilterForm()
eden_url = settings.EDEN_URL
has_data = False
# be careful about initial get with no parameters,
# so we don't clobber the initial values
if request.method == 'GET' and request.GET :
query_form = TimeSeriesFilterForm(request.GET)
has_data = True
elif request.method == 'POST':
query_form = TimeSeriesFilterForm(request.POST)
has_data = True
if has_data:
"""
if not query_form.has_changed():
return render(request, template_name, {'query_form': query_form, })
"""
if query_form.is_valid():
# Avoid the troublesome Nones.
plot_params = {}
for k, v in query_form.cleaned_data.items():
if v:
plot_params[k] = v
plot_query_str = urllib.urlencode(plot_params, doseq=True);
if query_form.cleaned_data['timeseries_start']:
str_tstart = '%s' % query_form.cleaned_data['timeseries_start']
else:
str_tstart = None
if query_form.cleaned_data['timeseries_end']:
str_tend = '%s' % query_form.cleaned_data['timeseries_end']
else:
str_tend = None
gages = query_form.cleaned_data['site_list']
colors = ColorRange(count=len(gages))
_logger.debug("In page generation, colors = %s", list(colors))
render_params = {'query_form': query_form,
'plot_params': mark_safe(plot_query_str),
'series_options': mark_safe(dygraph_series_options(gages)),
'str_tstart': str_tstart,
'gages':gages,
'str_tend': str_tend,
'colors': mark_safe(json.dumps(list(colors))),
'color_list': list(colors),
'DYGRAPH_RANGE_SELECTOR':settings.DYGRAPH_RANGE_SELECTOR,
'EDEN_URL': eden_url,
}
if len(gages) == 1:
station = stage_queries.station_list(gages)[0]
render_params['ngvd29_series'] = '%s%s' % (station.station_name_web, '_NGVD29')
render_params['dry_elevation'] = station.dry_elevation or "null"
render_params['ground_elevation'] = station.duration_elevation or "null"
render_params['ngvd29_correction'] = station.vertical_conversion or 0.0
else:
render_params['dry_elevation'] = "null"
render_params['ground_elevation'] = "null"
render_params['ngvd29_correction'] = "null"
return render(request, template_name, render_params)
else:
return render(request, template_name, {'query_form': query_form, 'EDEN_URL': eden_url}, status=400)
return render(request, template_name, {'query_form': query_form, 'EDEN_URL': eden_url})
