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 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 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))