def __init__(self, gap_size):
if gap_size <= 0:
raise ValueError('The size parameter must be strictly positive.')
self.gap_size = Duration.of(gap_size)
def __init__(self, size, period, offset=0):
if size <= 0:
raise ValueError('The size parameter must be strictly positive.')
self.size = Duration.of(size)
self.period = Duration.of(period)
self.offset = Timestamp.of(offset) % period
def from_runner_api_parameter(fn_parameter, unused_context):
return SlidingWindows(
size=Duration(micros=fn_parameter.size.ToMicroseconds()),
offset=Timestamp(micros=fn_parameter.offset.ToMicroseconds()),
period=Duration(micros=fn_parameter.period.ToMicroseconds()))
def advance_processing_time(self, processing_time_delta):
record = TestStreamFileRecord(recorded_event=TestStreamPayload.Event(
processing_time_event=TestStreamPayload.Event.
AdvanceProcessingTime(
advance_duration=Duration.of(processing_time_delta).micros)))
self._records.append(record)
def from_runner_api_parameter(fn_parameter, unused_context):
# type: (...) -> FixedWindows
return FixedWindows(
size=Duration(micros=fn_parameter.size.ToMicroseconds()),
offset=Timestamp(micros=fn_parameter.offset.ToMicroseconds()))
def __init__(self, size, period, offset=0):
if size <= 0:
raise ValueError('The size parameter must be strictly positive.')
self.size = Duration.of(size)
self.period = Duration.of(period)
self.offset = Timestamp.of(offset) % period
def test_precision(self):
self.assertEqual(Duration(10000000) % 0.1, 0)
self.assertEqual(Duration(10000000) % 0.05, 0)
self.assertEqual(Duration(10000000) % 0.000005, 0)
def __init__(self, advance_by): self.advance_by = Duration.of(advance_by)
def run_trigger(
self,
window_fn,
trigger_fn,
accumulation_mode,
bundles,
late_bundles,
expected_panes):
actual_panes = collections.defaultdict(list)
allowed_lateness = Duration(
micros=int(common_urns.constants.MAX_TIMESTAMP_MILLIS.constant) * 1000)
driver = GeneralTriggerDriver(
Windowing(
window_fn,
trigger_fn,
accumulation_mode,
allowed_lateness=allowed_lateness),
TestClock())
state = InMemoryUnmergedState()
for bundle in bundles:
for wvalue in driver.process_elements(state,
bundle,
MIN_TIMESTAMP,
MIN_TIMESTAMP):
window, = wvalue.windows
self.assertEqual(window.max_timestamp(), wvalue.timestamp)
actual_panes[window].append(set(wvalue.value))
while state.timers:
for timer_window, (name, time_domain,
timestamp) in state.get_and_clear_timers():
for wvalue in driver.process_timer(timer_window,
name,
time_domain,
timestamp,
state,
MIN_TIMESTAMP):
window, = wvalue.windows
self.assertEqual(window.max_timestamp(), wvalue.timestamp)
actual_panes[window].append(set(wvalue.value))
for bundle in late_bundles:
for wvalue in driver.process_elements(state,
bundle,
MAX_TIMESTAMP,
MAX_TIMESTAMP):
window, = wvalue.windows
self.assertEqual(window.max_timestamp(), wvalue.timestamp)
actual_panes[window].append(set(wvalue.value))
while state.timers:
for timer_window, (name, time_domain,
timestamp) in state.get_and_clear_timers():
for wvalue in driver.process_timer(timer_window,
name,
time_domain,
timestamp,
state,
MAX_TIMESTAMP):
window, = wvalue.windows
self.assertEqual(window.max_timestamp(), wvalue.timestamp)
actual_panes[window].append(set(wvalue.value))
self.assertEqual(expected_panes, actual_panes)
def test_arithmetic(self):
# Supported operations.
self.assertEqual(Timestamp(123) + 456, 579)
self.assertEqual(Timestamp(123) + Duration(456), 579)
self.assertEqual(456 + Timestamp(123), 579)
self.assertEqual(Duration(456) + Timestamp(123), 579)
self.assertEqual(Timestamp(123) - 456, -333)
self.assertEqual(Timestamp(123) - Duration(456), -333)
self.assertEqual(Timestamp(1230) % 456, 318)
self.assertEqual(Timestamp(1230) % Duration(456), 318)
self.assertEqual(Timestamp(123) - Timestamp(100), 23)
# Check that direct comparison of Timestamp and Duration is allowed.
self.assertTrue(Duration(123) == Timestamp(123))
self.assertTrue(Timestamp(123) == Duration(123))
self.assertFalse(Duration(123) == Timestamp(1230))
self.assertFalse(Timestamp(123) == Duration(1230))
# Check return types.
self.assertEqual((Timestamp(123) + 456).__class__, Timestamp)
self.assertEqual((Timestamp(123) + Duration(456)).__class__, Timestamp)
self.assertEqual((456 + Timestamp(123)).__class__, Timestamp)
self.assertEqual((Duration(456) + Timestamp(123)).__class__, Timestamp)
self.assertEqual((Timestamp(123) - 456).__class__, Timestamp)
self.assertEqual((Timestamp(123) - Duration(456)).__class__, Timestamp)
self.assertEqual((Timestamp(1230) % 456).__class__, Duration)
self.assertEqual((Timestamp(1230) % Duration(456)).__class__, Duration)
self.assertEqual((Timestamp(123) - Timestamp(100)).__class__, Duration)
# Unsupported operations.
with self.assertRaises(TypeError):
self.assertEqual(Timestamp(123) * 456, 56088)
with self.assertRaises(TypeError):
self.assertEqual(Timestamp(123) * Duration(456), 56088)
with self.assertRaises(TypeError):
self.assertEqual(456 * Timestamp(123), 56088)
with self.assertRaises(TypeError):
self.assertEqual(Duration(456) * Timestamp(123), 56088)
with self.assertRaises(TypeError):
self.assertEqual(456 - Timestamp(123), 333)
with self.assertRaises(TypeError):
self.assertEqual(Duration(456) - Timestamp(123), 333)
with self.assertRaises(TypeError):
self.assertEqual(-Timestamp(123), -123) # pylint: disable=invalid-unary-operand-type
with self.assertRaises(TypeError):
self.assertEqual(-Timestamp(123), -Duration(123)) # pylint: disable=invalid-unary-operand-type
with self.assertRaises(TypeError):
self.assertEqual(1230 % Timestamp(456), 318)
with self.assertRaises(TypeError):
self.assertEqual(Duration(1230) % Timestamp(456), 318)
def for_bid(expected_duration_micro, timestamp, bid):
return AuctionOrBidWindow(
timestamp,
timestamp + Duration(micros=expected_duration_micro * 2),
bid.auction, False)
def test_of(self):
interval = Timestamp(123)
self.assertEqual(id(interval), id(Timestamp.of(interval)))
self.assertEqual(interval, Timestamp.of(123.0))
with self.assertRaises(TypeError):
Timestamp.of(Duration(10))
def test_to_proto(self):
dur = Duration(seconds=1234, micros=56)
actual_dur_proto = Duration.to_proto(dur)
expected_dur_proto = duration_pb2.Duration(seconds=1234, nanos=56000)
self.assertEqual(actual_dur_proto, expected_dur_proto)
def test_from_proto_fails_with_truncation(self):
# TODO(https://github.com/apache/beam/issues/19922): Better define
# durations.
with self.assertRaises(ValueError):
Duration.from_proto(
duration_pb2.Duration(seconds=1234, nanos=56789))
def from_runner_api_parameter(fn_parameter, unused_context):
return Sessions(gap_size=Duration(
micros=fn_parameter.gap_size.ToMicroseconds()))
def from_runner_api_parameter(fn_parameter, unused_context):
return SlidingWindows(size=Duration(micros=fn_parameter['size']),
offset=Timestamp(micros=fn_parameter['offset']),
period=Duration(micros=fn_parameter['period']))
def test_of(self):
interval = Duration(123)
self.assertEqual(id(interval), id(Duration.of(interval)))
self.assertEqual(interval, Duration.of(123.0))
with self.assertRaises(TypeError):
Duration.of(Timestamp(10))
def from_runner_api_parameter(fn_parameter, unused_context):
return Sessions(gap_size=Duration(micros=fn_parameter['gap_size']))
def __init__(self, gap_size):
if gap_size <= 0:
raise ValueError('The size parameter must be strictly positive.')
self.gap_size = Duration.of(gap_size)
def test_from_proto_fails_with_truncation(self):
# TODO(BEAM-8738): Better define durations.
with self.assertRaises(ValueError):
Duration.from_proto(
duration_pb2.Duration(seconds=1234, nanos=56789))
