def test_from_proto_list(self):
"""
Assert from_proto_list creates valid objects
"""
protos = [
StatPointProto(time=1, min=2, mean=3, max=4, count=5, stddev=6),
StatPointProto(time=11,
min=12,
mean=13,
max=14,
count=15,
stddev=16)
]
points = StatPoint.from_proto_list(protos)
assert points[0].time == protos[0].time
assert points[0].min == protos[0].min
assert points[0].mean == protos[0].mean
assert points[0].max == protos[0].max
assert points[0].count == protos[0].count
assert points[0].stddev == protos[0].stddev
assert points[1].time == protos[1].time
assert points[1].min == protos[1].min
assert points[1].mean == protos[1].mean
assert points[1].max == protos[1].max
assert points[1].count == protos[1].count
assert points[1].stddev == protos[1].stddev
def windows(self, start, end, width, depth=0, version=0):
"""
Read arbitrarily-sized windows of data from BTrDB. StatPoint objects
will be returned representing the data for each window.
Parameters
----------
start : int or datetime like object
The start time in nanoseconds for the range to be queried. (see
:func:`btrdb.utils.timez.to_nanoseconds` for valid input types)
end : int or datetime like object
The end time in nanoseconds for the range to be queried. (see
:func:`btrdb.utils.timez.to_nanoseconds` for valid input types)
width : int
The number of nanoseconds in each window, subject to the depth
parameter.
depth : int
The precision of the window duration as a power of 2 in nanoseconds.
E.g 30 would make the window duration accurate to roughly 1 second
version : int
The version of the stream to query.
Returns
-------
tuple
Returns a tuple containing windows of data. Each window is a tuple
containing data tuples. Each data tuple contains a StatPoint and
the stream version (tuple(tuple(StatPoint, int), ...)).
Notes
-----
Windows returns arbitrary precision windows from BTrDB. It is slower
than AlignedWindows, but still significantly faster than RawValues. Each
returned window will be `width` nanoseconds long. `start` is inclusive,
but `end` is exclusive (e.g if end < start+width you will get no
results). That is, results will be returned for all windows that start
at a time less than the end timestamp. If (`end` - `start`) is not a
multiple of width, then end will be decreased to the greatest value less
than end such that (end - start) is a multiple of `width` (i.e., we set
end = start + width * floordiv(end - start, width). The `depth`
parameter is an optimization that can be used to speed up queries on
fast queries. Each window will be accurate to 2^depth nanoseconds. If
depth is zero, the results are accurate to the nanosecond. On a dense
stream for large windows, this accuracy may not be required. For example
for a window of a day, +- one second may be appropriate, so a depth of
30 can be specified. This is much faster to execute on the database
side.
"""
materialized = []
start = to_nanoseconds(start)
end = to_nanoseconds(end)
windows = self._btrdb.ep.windows(self._uuid, start, end, width, depth,
version)
for stat_points, version in windows:
for point in stat_points:
materialized.append((StatPoint.from_proto(point), version))
return tuple(materialized)
def test_from_proto_creates_rawpoint(self):
"""
Assert from_proto creates a new instance of StatPoint
"""
proto = StatPointProto(time=1, min=2, mean=3, max=4, count=5, stddev=6)
point = StatPoint.from_proto(proto)
assert isinstance(point, StatPoint)
def test_get_raises_indexerror(self):
"""
Assert the __get__ raises IndexError
"""
point = StatPoint(1, 2, 3, 4, 5, 6)
with pytest.raises(IndexError):
point[6]
with pytest.raises(IndexError):
point[-1]
def aligned_windows(self, start, end, pointwidth, version=0):
"""
Read statistical aggregates of windows of data from BTrDB.
Query BTrDB for aggregates (or roll ups or windows) of the time series
with `version` between time `start` (inclusive) and `end` (exclusive) in
nanoseconds. Each point returned is a statistical aggregate of all the
raw data within a window of width 2**`pointwidth` nanoseconds. These
statistical aggregates currently include the mean, minimum, and maximum
of the data and the count of data points composing the window.
Note that `start` is inclusive, but `end` is exclusive. That is, results
will be returned for all windows that start in the interval [start, end).
If end < start+2^pointwidth you will not get any results. If start and
end are not powers of two, the bottom pointwidth bits will be cleared.
Each window will contain statistical summaries of the window.
Statistical points with count == 0 will be omitted.
Parameters
----------
start : int or datetime like object
The start time in nanoseconds for the range to be queried. (see
:func:`btrdb.utils.timez.to_nanoseconds` for valid input types)
end : int or datetime like object
The end time in nanoseconds for the range to be queried. (see
:func:`btrdb.utils.timez.to_nanoseconds` for valid input types)
pointwidth : int
Specify the number of ns between data points (2**pointwidth)
version : int
Version of the stream to query
Returns
-------
tuple
Returns a tuple containing windows of data. Each window is a tuple
containing data tuples. Each data tuple contains a StatPoint and
the stream version.
Notes
-----
As the window-width is a power-of-two, it aligns with BTrDB internal
tree data structure and is faster to execute than `windows()`.
"""
materialized = []
start = to_nanoseconds(start)
end = to_nanoseconds(end)
windows = self._btrdb.ep.alignedWindows(self._uuid, start, end,
pointwidth, version)
for stat_points, version in windows:
for point in stat_points:
materialized.append((StatPoint.from_proto(point), version))
return tuple(materialized)
def test_get_returns_correct_values(self):
"""
Assert the __get__ returns correct values
"""
point = StatPoint(1, 2, 3, 4, 5, 6)
assert point[0] == 1
assert point[1] == 2
assert point[2] == 3
assert point[3] == 4
assert point[4] == 5
assert point[5] == 6
def test_from_proto(self):
"""
Assert from_proto creates a correct object
"""
proto = StatPointProto(time=1, min=2, mean=3, max=4, count=5, stddev=6)
point = StatPoint.from_proto(proto)
assert point.time == proto.time
assert point.min == proto.min
assert point.mean == proto.mean
assert point.max == proto.max
assert point.count == proto.count
assert point.stddev == proto.stddev
def windows(self, start, end, width, depth=0, version=0):
"""
Read arbitrarily-sized windows of data from BTrDB. StatPoint objects
will be returned representing the data for each window.
Parameters
----------
start : int or datetime like object
The start time in nanoseconds for the range to be queried. (see
:func:`btrdb.utils.timez.to_nanoseconds` for valid input types)
end : int or datetime like object
The end time in nanoseconds for the range to be queried. (see
:func:`btrdb.utils.timez.to_nanoseconds` for valid input types)
width : int
The number of nanoseconds in each window.
version : int
The version of the stream to query.
Returns
-------
tuple
Returns a tuple containing windows of data. Each window is a tuple
containing data tuples. Each data tuple contains a StatPoint and
the stream version (tuple(tuple(StatPoint, int), ...)).
Notes
-----
Windows returns arbitrary precision windows from BTrDB. It is slower
than AlignedWindows, but still significantly faster than RawValues. Each
returned window will be `width` nanoseconds long. `start` is inclusive,
but `end` is exclusive (e.g if end < start+width you will get no
results). That is, results will be returned for all windows that start
at a time less than the end timestamp. If (`end` - `start`) is not a
multiple of width, then end will be decreased to the greatest value less
than end such that (end - start) is a multiple of `width` (i.e., we set
end = start + width * floordiv(end - start, width). The `depth`
parameter previously available has been deprecated. The only valid value
for depth is now 0.
"""
materialized = []
start = to_nanoseconds(start)
end = to_nanoseconds(end)
windows = self._btrdb.ep.windows(self._uuid, start, end, width, depth,
version)
for stat_points, version in windows:
for point in stat_points:
materialized.append((StatPoint.from_proto(point), version))
return tuple(materialized)
def test_from_proto_list_returns_list_of_statpoint(self):
"""
Assert from_proto_list returns list of StatPoint
"""
protos = [
StatPointProto(time=1, min=2, mean=3, max=4, count=5, stddev=6),
StatPointProto(time=11,
min=12,
mean=13,
max=14,
count=15,
stddev=16)
]
points = StatPoint.from_proto_list(protos)
assert len(points) == 2
for point in points:
assert isinstance(point, StatPoint)
def statpoint_streamset():
rows = [
[
StatPoint(1500000000100000000, 0, 2.0, 2.5, 10, 1),
StatPoint(1500000000100000000, 0, 4.0, 4.5, 11, 1),
StatPoint(1500000000100000000, 0, 6.0, 6.5, 10, 1),
StatPoint(1500000000100000000, 0, 8.0, 8.5, 11, 2)
],
[
StatPoint(1500000000300000000, 0, 3.0, 3.5, 11, 1),
StatPoint(1500000000300000000, 0, 5.0, 5.5, 10, 1),
StatPoint(1500000000300000000, 0, 7.0, 7.5, 10, 1),
StatPoint(1500000000300000000, 0, 9.0, 9.5, 11, 2)
],
[
StatPoint(1500000000500000000, 0, 4.0, 4.5, 10, 1),
StatPoint(1500000000500000000, 0, 6.0, 6.5, 11, 1),
StatPoint(1500000000500000000, 0, 8.0, 8.5, 10, 1),
StatPoint(1500000000500000000, 0, 10.0, 10.5, 11, 2)
],
[
StatPoint(1500000000700000000, 0, 5.0, 5.5, 11, 1),
StatPoint(1500000000700000000, 0, 7.0, 7.5, 10, 1),
StatPoint(1500000000700000000, 0, 9.0, 9.5, 10, 1),
StatPoint(1500000000700000000, 0, 11.0, 11.5, 11, 2)
],
]
values = [
[
StatPoint(1500000000100000000, 0, 2.0, 2.5, 10, 1),
StatPoint(1500000000300000000, 0, 4.0, 4.5, 11, 1),
StatPoint(1500000000500000000, 0, 6.0, 6.5, 10, 1),
StatPoint(1500000000700000000, 0, 8.0, 8.5, 11, 2)
],
[
StatPoint(1500000000100000000, 1, 3.0, 3.5, 11, 1),
StatPoint(1500000000300000000, 1, 5.0, 5.5, 10, 1),
StatPoint(1500000000500000000, 1, 7.0, 7.5, 10, 1),
StatPoint(1500000000700000000, 1, 9.0, 9.5, 11, 2)
],
[
StatPoint(1500000000100000000, 2, 4.0, 4.5, 10, 1),
StatPoint(1500000000300000000, 2, 6.0, 6.5, 11, 1),
StatPoint(1500000000500000000, 2, 8.0, 8.5, 10, 1),
StatPoint(1500000000700000000, 2, 10.0, 10.5, 11, 2)
],
[
StatPoint(1500000000100000000, 3, 5.0, 5.5, 11, 1),
StatPoint(1500000000300000000, 3, 7.0, 7.5, 10, 1),
StatPoint(1500000000500000000, 3, 9.0, 9.5, 10, 1),
StatPoint(1500000000700000000, 3, 11.0, 11.5, 11, 2)
],
]
streams = []
for idx in range(4):
stream = Mock(Stream)
type(stream).collection = PropertyMock(return_value="test")
type(stream).name = PropertyMock(return_value="stream{}".format(idx))
streams.append(stream)
obj = StreamSet(streams)
obj.rows = Mock(return_value=rows)
obj.values = Mock(return_value=values)
obj.pointwidth = 20
return obj
def test_create(self):
"""
Ensure we can create the object
"""
StatPoint(1, 1, 1, 1, 1, 1)
