def word_counter(file_name):
# count words using `group_by()`
# tuple the word with the count
return words_from_file(file_name).pipe(
ops.group_by(lambda word: word),
ops.flat_map(lambda grp: grp.pipe(ops.count(),
ops.map(lambda ct: (grp.key, ct)))))
def subscribe_group_observable(group_observable):
def print_count(count):
print(f'Group key={group_observable.key} contains {count} items')
group_observable.pipe(
ops.count()
).subscribe(print_count)
def _count(predicate: Predicate = None) -> Callable[[Observable], Observable]:
if predicate:
filtering = ops.filter(predicate)
return pipe(filtering, ops.count())
counter = ops.reduce(lambda n, _: n + 1, seed=0)
return pipe(counter)
def _count(predicate: Optional[Predicate] = None) -> Callable[[Observable], Observable]:
if predicate:
filtering = ops.filter(predicate)
return pipe(filtering, ops.count())
counter = ops.reduce(lambda n, _: n + 1, seed=0)
return pipe(counter)
def create():
def predicate(x):
if x == 3:
raise Exception(ex)
else:
return True
return xs.pipe(_.count(predicate))
def test_count_some(self):
scheduler = TestScheduler()
xs = scheduler.create_hot_observable(
on_next(150, 1),
on_next(210, 2),
on_next(220, 3),
on_next(230, 4),
on_completed(250))
res = scheduler.start(create=lambda: xs.pipe(_.count())).messages
assert res == [on_next(250, 3), on_completed(250)]
def test_groupby_count(self):
res = []
counts = rx.from_(range(10)).pipe(
ops.group_by(lambda i: 'even' if i % 2 == 0 else 'odd'),
ops.flat_map(lambda i: i.pipe(
ops.count(),
ops.map(lambda ii: (i.key, ii)),
)))
counts.subscribe(on_next=res.append)
assert res == [('even', 5), ('odd', 5)]
def run(onComplete=lambda: None):
limit = 10 ** 22
optimal_thread_count = multiprocessing.cpu_count()
pool_scheduler = ThreadPoolScheduler(optimal_thread_count)
count = rx.from_iterable(pandigital_step_numbers()) \
.pipe(
ops.take_while(lambda n: n < limit),
ops.count(),
) \
.run()
onComplete(count)
def test_completion():
data = [1, 2, 3]
actual_data = []
actual_completed = []
rx.from_(data).pipe(
rs.ops.tee_map(
ops.count(),
rs.math.sum(reduce=True),
)
).subscribe(
on_next=actual_data.append,
on_completed=lambda: actual_completed.append(True)
)
assert actual_completed == [True]
assert actual_data == [(3, 6)]
def _solve_rx(print=print):
"""Benchmark: 15/1_000_000 takes 30s """
print(f'\n\n\n***************')
turns = 15
game_count = 1_000_000
#scheduler=rx.scheduler.CurrentThreadScheduler()
scheduler = rx.scheduler.ThreadPoolScheduler(4)
wins = rx.range(0,game_count,scheduler=scheduler)\
.pipe(
ops.filter(lambda i: play_w(turns)),
ops.count()
).run()
print(f' Max prize: {math.floor(game_count/wins)}')
print(f"Not done")
return False
def create():
return xs.pipe(_.count(lambda _: True))
import rx
from rx import operators as ops
rx.from_(["Alpha", "Beta", "Gamma",
"Delta", "Epsilon"]).pipe(ops.filter(lambda s: len(s) != 5),
ops.count()).subscribe(lambda i: print(i))
print('-- window_with_count | FlatMap')
rx.from_(range(3)).pipe(ops.window_with_count(2),
ops.flat_map(lambda x: x)).subscribe(print_value)
# flatmap 은
# flat 하면 리스트를 푼다.
# [[1,2], [3]] -> [1,2,3]
# 그리고 나서 map 한다. x -> x
# [1, 2, 3] -> [1, 2, 3]
print('-- window_with_time')
test_scheduler = TestScheduler()
rx.interval(0.05, test_scheduler).pipe(ops.take_until(
rx.timer(0.1)), ops.window_with_time(0.01)).subscribe(
lambda observable: observable.pipe(ops.count()).subscribe(print_value))
test_scheduler.start()
time.sleep(0.5)
# 결과가 이게 맞나?? 단위가 뭐지?
print('-- combine_latest')
rx.combine_latest(
rx.interval(0.1).pipe(ops.map(lambda x: 'a- {}'.format(x))),
rx.interval(0.2).pipe(ops.map(lambda x: 'b- {}'.format(x)))).pipe(
ops.take_until(rx.timer(0.5))).subscribe(print_value)
time.sleep(1)
# 누가 먼저 결과를 배출할지 예상 불가
print('-- zip')
rx.zip(
rx.interval(0.1).pipe(ops.map(lambda x: 'a- {}'.format(x))),
rx.throw() rx.interval() rx.from_() rx.interval() rx.just() rx.range() rx.repeat_value() rx.start() rx.timer() """Mathematical""" op.average() op.concat() op.count() op.max() op.min() op.reduce() op.sum() """Transformation""" op.buffer() op.group_by() op.map() op.scan() # ... """Filtering""" op.debounce() op.distinct()
import rx
from rx import operators as ops
rx.from_(["Alpha", "Beta", "Gamma", "Delta", "Epsilon"]).pipe(
ops.group_by(lambda s: len(s)),
ops.flat_map(
lambda grp: grp.pipe(ops.count(), ops.map(lambda ct: (grp.key, ct)))),
ops.to_dict(lambda key_value: key_value[0],
lambda key_value: key_value[1])).subscribe(lambda i: print(i))
import rx
import rx.operators as ops
numbers = rx.from_([1, 2, 3, 4])
numbers.pipe(ops.count(lambda i: i > 2)).subscribe(
on_next=lambda i: print("on_next {}".format(i)),
on_error=lambda e: print("on_error: {}".format(e)),
on_completed=lambda: print("on_completed"))
def test_sample_file(self):
self.source.observable().pipe(count()).subscribe(
lambda aantal: assert_that(aantal, equal_to(34)),
lambda e: fail(e))
"""this operator takes in an observable with values, and converts it into observable
that will have single value. the count function takes in predicate function as an optional argument.
the function is of type boolean, and will add value to the output only, if it satisfies the condition
:parameter
the count function takes in predicate function as an optional argument.
the function is of type Boolean, and will add value to the output only, if it satisfies the condition.
:return
it will return an observable with a single value, i.e. the count from the source observable.
"""
from rx import of, operators as op
test = of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
sub1 = test.pipe(op.count(lambda x: x % 2)).subscribe(
lambda x: print("the count is {}".format(x)))
# result
# the count is 5
# remove lambda argument the count is 10
def test_count_never(self):
scheduler = TestScheduler()
xs = scheduler.create_hot_observable(on_next(150, 1))
res = scheduler.start(create=lambda: xs.pipe(_.count())).messages
assert res == []
def test_count_on_error(self):
ex = 'ex'
scheduler = TestScheduler()
xs = scheduler.create_hot_observable(on_next(150, 1), on_error(210, ex))
res = scheduler.start(create=lambda: xs.pipe(_.count())).messages
assert res == [on_error(210, ex)]
def create():
return xs.pipe(_.count(lambda x: x % 2 == 0))
def create():
return xs.pipe(_.count())
def create():
return xs.pipe(_.count(lambda _: False))
k3=random.randint(0, k3_range),
data=random.random() * 1000,
)
source = dataset(dataset_size)
rx.from_(source).pipe(
rs.state.with_memory_store(
rx.pipe(
rs.ops.group_by(
lambda i: i.k1,
rx.pipe(
rs.ops.group_by(
lambda i: i.k2,
rx.pipe(
rs.data.roll(5, 5,
rx.pipe(rs.ops.count(
reduce=True), )), )), )), )),
ops.count(),
).run()
'''
subscribe(
on_next=lambda i: print(i),
on_error=lambda e: print(e),
)
'''
print("done!")
time.sleep(5.0)
