def test_curve_pprint_repr(self):
# Ensure it isn't a bytes object with the 'b' prefix
expected = "':Curve [x] (y)'"
r = PrettyPrinter.pprint(Curve([1, 2, 3]))
self.assertEqual(repr(r), expected)
def test_roll_ints(self):
rolled = rolling(self.int_curve, rolling_window=2)
rolled_vals = [np.NaN, 1.5, 2.5, 3.5, 4.5, 5.5, 6.5]
self.assertEqual(rolled, Curve(rolled_vals))
def test_resample_weekly(self):
resampled = resample(self.date_curve, rule='W')
dates = list(map(pd.Timestamp, ["2016-01-03", "2016-01-10"]))
vals = [2, 5.5]
self.assertEqual(resampled, Curve((dates, vals)))
def test_interpolate_curve_post(self):
interpolated = interpolate_curve(Curve([0, 0.5, 1]),
interpolation='steps-post')
curve = Curve([(0, 0), (1, 0), (1, 0.5), (2, 0.5), (2, 1)])
self.assertEqual(interpolated, curve)
def test_render_holomap_embedded(self):
hmap = HoloMap({i: Curve([1, 2, i]) for i in range(5)})
data, _ = self.renderer.components(hmap)
self.assertIn('State"', data['text/html'])
def test_resample_weekly_label_left(self):
resampled = resample(self.date_curve, rule='W', label='left')
dates = list(map(pd.Timestamp, ["2015-12-27", "2016-01-03"]))
vals = [2, 5.5]
self.assertEqual(resampled, Curve((dates, vals)))
def setUp(self):
"Variations on the constructors in the Elements notebook"
self.curve1 = Curve([(0.1*i, np.sin(0.1*i)) for i in range(100)])
self.curve2 = Curve([(0.1*i, np.sin(0.1*i)) for i in range(101)])
def test_hist_curve_int_edges_construct(self):
hist = Histogram(Curve(range(3)))
self.assertEqual(hist.data[0], np.arange(3))
self.assertEqual(hist.data[1], np.array([-.5, .5, 1.5, 2.5]))
def setUp(self):
self.xs = range(11)
self.ys = np.linspace(0, 1, 11)
self.chart = Chart(zip(self.xs, self.ys))
self.curve = Curve(zip(self.xs, self.ys))
def plot_ts(filename, time_range=[None, None]):
'''
Plot the time series in z3d file filename
return a holoviews dynspread object
time_range must be tz-aware
'''
# print('reading...')
z3d = read_z3d(filename)
sampling_rate = z3d['metadata']['A/D Rate']
if 'TX.SENSE' in z3d['metadata']:
# NOTE: this only ids channel 1 TX files
station_type = 'TX'
else:
station_type = 'RX'
# These items were in schedule_info for RX
try:
station = z3d['metadata']['CH.STN']
except KeyError:
try:
station = z3d['metadata']['RX.STN']
except KeyError:
station = ''
try:
station = str(int(station))
except ValueError:
station = str(station)
channel = z3d['metadata']['Channel']
component = z3d['metadata']['CH.CMP']
if z3d['metadata']['CH.CMP'][0] == 'H':
# mag field
# antenna_number = z3d['metadata']['CH.ANTSN']
pass
elif z3d['metadata']['CH.CMP'][0] == 'E':
# electric field
# antenna_number = None
pass
elif z3d['metadata']['CH.CMP'][0] == 'R':
# electric field, transmitter ref channel
# antenna_number = None
pass
else:
raise ValueError('CH.CMP not recognized as either E or H component')
if z3d['num_records'] == 0:
valid = False
else:
[dt_start, dt_end
] = timeio.get_start_and_end_times_mountain(z3d,
include_final_second=True,
astype='timestamp')
# print('getting times...')
# dt_start_naive = dt_start.replace(tzinfo=None)
# dt_end_naive = dt_end.replace(tzinfo=None)
# dt_start_naive = pd.Timestamp(dt_start.replace(tzinfo=None))
# dt_end_naive = pd.Timestamp(dt_end.replace(tzinfo=None))
# period = timedelta(seconds=1)/sampling_rate
# sampling_increment = timedelta(seconds=1./sampling_rate)
# dt_times = pd.date_range(start=dt_start_naive, periods=len(z3d['data']),
# freq=sampling_increment, tz=None,
# normalize=False, name=None, closed=None)
dt_times = pd.date_range(start=dt_start,
end=dt_end,
periods=len(z3d['data']),
tz=None,
normalize=False,
name=None,
closed=None) #.values
# print('windowing data...')
# print(type(dt_start))
# print(type(time_range[0]))
# window data to time_range
if time_range[0]:
dt_start = time_range[0]
if time_range[1]:
dt_end = time_range[1]
window_slice = timeio.slice_to_window_series(dt_times, dt_start, dt_end)
curve_data = z3d['data'][window_slice]
dt_times = dt_times[window_slice]
# ... or don't
# curve_data = z3d['data']
# print('windowed!')
# holoviews seems to want timezone-naive type datetime64[ns]. Throws warning otherwise
try:
dt_times = dt_times.tz_localize(None).astype('datetime64[ns]')
# time_range[0] = time_range[0].tz_localize(None)
# time_range[1] = time_range[1].tz_localize(None)
# hv_time_range = (time_range[0].tz_localize(None), time_range[1].tz_localize(None))
hv_time_range = (dt_start.tz_localize(None), dt_end.tz_localize(None))
# print(type(dt_times))
# print(type(dt_times[0]))
# print(dt_times[0])
# print(type(dt_start))
# print(dt_start)
dt_start = np.datetime64(dt_start.tz_localize(None))
# print(type(dt_start))
# print(dt_start)
dt_end = np.datetime64(dt_end.tz_localize(None))
except Exception as e:
print(e)
traceback.print_exc()
# print(len(curve_data))
# print(len(dt_times))
# print(hv_time_range)
# print('plotting...')
title_str = '{} Station: {}, '+\
'Channel {:.0f} ({}), {} to {} Mountain'
title_str = title_str.format(station_type, station, channel, component,
np.datetime_as_string(dt_start, unit='s'),
np.datetime_as_string(dt_end, unit='s'))
ts_tools = ['save', 'pan', 'xwheel_zoom', 'box_zoom', 'undo', 'reset']
signal = hv.Dimension('signal', label='Signal', unit='V')
time = hv.Dimension('time', label='Time', range=hv_time_range)
curve = Curve((dt_times, curve_data), time, signal,
label=title_str) #.redim.range(time=time_range)
# kdims=['Time'],vdims=['Signal, V']
# dscurve = datashade(curve, cmap=["blue"]).opts(width=800)
# dscurve = datashade(curve,name=title_str).opts(width=800)
dscurve = dynspread(
datashade(curve).opts( #framewise=True,
xformatter=verbose_formatter(),
default_tools=ts_tools))
dsfinal = dscurve.opts(plot=dict(hooks=[no_logo]))
# print('done!')
return dsfinal
def test_hist_curve_construct(self):
hist = Histogram(Curve(([0.1, 0.3, 0.5], [2.1, 2.2, 3.3])))
self.assertEqual(hist.data[0], np.array([2.1, 2.2, 3.3]))
self.assertEqual(hist.data[1], np.array([0, 0.2, 0.4, 0.6]))
def test_reduce_y_dimension(self):
xs = np.linspace(-9, 9, 10)
zs = [0., 4.5, 9., 13.5, 18., 22.5, 27., 31.5, 36., 40.5]
with DatatypeContext([self.datatype, 'dictionary' , 'dataframe'], Image):
self.assertEqual(self.image.reduce(y=np.mean),
Curve((xs, zs), kdims=['x'], vdims=['z']))
def test_sample_ycoord(self):
xs = np.linspace(-9, 9, 10)
zs = [0, 4, 8, 12, 16, 20, 24, 28, 32, 36]
with DatatypeContext([self.datatype, 'dictionary' , 'dataframe'], self.image):
self.assertEqual(self.image.sample(y=5),
Curve((xs, zs), kdims=['x'], vdims=['z']))
def test_sample_xcoord(self):
ys = np.linspace(0.5, 9.5, 10)
zs = [0, 7, 14, 21, 28, 35, 42, 49, 56, 63]
with DatatypeContext([self.datatype, 'dictionary' , 'dataframe'], self.image):
self.assertEqual(self.image.sample(x=5),
Curve((ys, zs), kdims=['y'], vdims=['z']))
def test_hist_curve_construct(self):
hist = Histogram(Curve(([0.1, 0.3, 0.5], [2.1, 2.2, 3.3])))
values = hist.dimension_values(1)
edges = hist.edges
self.assertEqual(values, np.array([2.1, 2.2, 3.3]))
self.assertEqual(edges, np.array([0, 0.2, 0.4, 0.6]))
def test_chart_slice(self):
chart_slice = Curve(zip(range(5, 9), np.linspace(0.5, 0.8, 4)))
self.assertEqual(self.curve[5:9], chart_slice)
def test_hist_curve_int_edges_construct(self):
hist = Histogram(Curve(range(3)))
values = hist.dimension_values(1)
edges = hist.edges
self.assertEqual(values, np.arange(3))
self.assertEqual(edges, np.array([-.5, .5, 1.5, 2.5]))
def test_render_to_png(self):
curve = Curve([])
renderer = BokehRenderer.instance(fig='png')
png, info = renderer(curve)
self.assertIsInstance(png, bytes)
self.assertEqual(info['file-ext'], 'png')
def test_interpolate_curve_pre_with_values(self):
interpolated = interpolate_curve(Curve([(0, 0, 'A'), (1, 0.5, 'B'), (2, 1, 'C')], vdims=['y', 'z']),
interpolation='steps-pre')
curve = Curve([(0, 0, 'A'), (0, 0.5, 'B'), (1, 0.5, 'B'), (1, 1, 'C'), (2, 1, 'C')], vdims=['y', 'z'])
self.assertEqual(interpolated, curve)
def test_hist_curve_construct(self):
hist = Histogram(Curve(([0.1, 0.3, 0.5], [2.1, 2.2, 3.3])))
values = hist.dimension_values(1)
edges = hist.interface.coords(hist, hist.kdims[0], edges=True)
self.assertEqual(values, np.array([2.1, 2.2, 3.3]))
self.assertEqual(edges, np.array([0, 0.2, 0.4, 0.6]))
def test_interpolate_curve_mid(self):
interpolated = interpolate_curve(Curve([0, 0.5, 1]),
interpolation='steps-mid')
curve = Curve([(0, 0), (0.5, 0), (0.5, 0.5), (1.5, 0.5), (1.5, 1),
(2, 1)])
self.assertEqual(interpolated, curve)
def test_hist_curve_int_edges_construct(self):
hist = Histogram(Curve(range(3)))
values = hist.dimension_values(1)
edges = hist.interface.coords(hist, hist.kdims[0], edges=True)
self.assertEqual(values, np.arange(3))
self.assertEqual(edges, np.array([-.5, .5, 1.5, 2.5]))
def test_render_static(self):
curve = Curve([])
obj, _ = self.renderer._validate(curve, None)
self.assertIsInstance(obj, CurvePlot)
def test_curve_string_signature(self):
curve = Curve([], 'a', 'b')
self.assertEqual(curve.kdims, [Dimension('a')])
self.assertEqual(curve.vdims, [Dimension('b')])
def test_render_holomap_not_embedded(self):
hmap = HoloMap({i: Curve([1, 2, i]) for i in range(5)})
data, _ = self.renderer.instance(widget_mode='live').components(hmap)
self.assertNotIn('State"', data['text/html'])
def test_chart_zipconstruct(self):
self.assertEqual(Curve(zip(self.xs, self.sin)), self.curve)
def test_roll_ints_with_window_type(self):
rolled = rolling(self.int_curve,
rolling_window=3,
window_type='triang')
rolled_vals = [np.NaN, 2, 3, 4, 5, 6, np.NaN]
self.assertEqual(rolled, Curve(rolled_vals))
def test_chart_tuple_construct(self):
self.assertEqual(Curve((self.xs, self.sin)), self.curve)
def test_resample_weekly_closed_left(self):
resampled = resample(self.date_curve, rule='W', closed='left')
dates = list(map(pd.Timestamp, ["2016-01-03", "2016-01-10"]))
vals = [1.5, 5]
self.assertEqual(resampled, Curve((dates, vals)))
def test_unique_keys_no_overlap_dynamicmap_uninitialized(self):
dmap1 = DynamicMap(lambda A: Curve(range(10)), kdims=['A'])
dmap2 = DynamicMap(lambda B: Curve(range(10)), kdims=['B'])
dims, keys = unique_dimkeys(dmap1 + dmap2)
self.assertEqual(dims, dmap1.kdims + dmap2.kdims)
self.assertEqual(keys, [])
