def predict(sentences,
word_index,
index_chunk,
model: Model,
model_config: BiLSTMCRFModelConfigure,
parallel=False) -> Observable:
x = sentence_to_vec(sentences, word_index, model_config)
start = time.clock()
preds = model.predict(x, batch_size=1024)
print("Predict cost time {} s".format(time.clock() - start))
tags_encode = np.argmax(preds, axis=2)
tags_decode = Observable.of(*tags_encode)
if parallel:
return Observable.zip(Observable.of(*sentences), tags_decode, lambda s, i: (s, i)) \
.flat_map(lambda v: Observable.just(v)
.subscribe_on(pool_scheduler)
.map(lambda v: (v[0], v[1][-len(v[0]):]))
.map(lambda v: (v[0], list(map(lambda i: index_chunk[i], v[1]))))
.map(lambda v: cut_sentence_str(*v)))
else:
return Observable.zip(Observable.of(*sentences), tags_decode, lambda s, i: (s, i)) \
.map(lambda v: (v[0], v[1][-len(v[0]):])) \
.map(lambda v: (v[0], list(map(lambda i: index_chunk[i], v[1])))) \
.map(lambda v: cut_sentence_str(*v))
def test_sliding_window():
from collections import deque
window_size = 3
def adder(agg, val):
agg.append(val)
return agg
Observable.of(1, 2, 3, 4, 5, 6, 7, ) \
.scan(adder, seed=deque(maxlen=window_size)) \
.filter(lambda x: len(x) == window_size) \
.map(tuple) \
.subscribe(print)
def on_start(self, connection_context, op_id, params):
try:
execution_result = self.execute(connection_context.request_context,
params)
if not isinstance(execution_result, Observable):
# pylint cannot find of method
observable = Observable.of(execution_result, GQL_COMPLETE) # pylint: disable=E1101
# Register the operation using None even though we are not implementing async
# iterators. This is useful for bookkeeping purpose, allowing us to ignore generated
# events for closed operations and avoid sending an unnecessary web socket messages.
# Requires that `unsubscribe` is overridden to handle the None case.
connection_context.register_operation(op_id, None)
else:
observable = execution_result
connection_context.register_operation(op_id, observable)
def on_complete(conn_context):
# unsubscribe from the completed operation
self.on_stop(conn_context, op_id)
observable.subscribe(
SubscriptionObserver(
connection_context,
op_id,
self.send_execution_result,
self.send_error,
on_complete,
))
# appropriate to catch all errors here
except Exception as e: # pylint: disable=W0703
self.send_error(connection_context, op_id, str(e))
def filter(self, event, size, msgs=2):
# min size of the event data
source = Observable.of(event)
source\
.map(lambda s: len(s))\
.filter(lambda i : i>=size)\
.subscribe(lambda value : print(value)) # an observer is setup here with subscribe function
# map associet une fonction/transforme fait une action
# filter garde ce qu'on veut
# subscribe c'est l'output en fonction d'un type d'events next, error, terminé
# emits integer each 1000 ms
# Observables can be created for button events, requests, timers, and even live Twitter feeds.
Observable.interval(1000)\
.map(lambda i : "{0} Mississipi".format(i))\
.subscribe(lambda s : print(s))
input("press any key to quit\n")
from random import randint
''' use the rx events for the connection with the agent bidder class ?? '''
three_emissions = Observable.range(1,msgs) # msg are separately sent to different subscribers
three_random_ints = three_emissions.map(lambda i: randint(1,1000))
three_random_ints.subscribe(lambda i: print("subscriber 1 received".format(i)))
three_random_ints.subscribe(lambda i: print("subscriber 2 received".format(i)))
# send the same message to different subscribers
three_random_ints = three_emissions.mpa(lambda i: randint(1,1000)).publish()
three_random_ints.subscribe(lambda i: print("subscriber 1 received".format(i)))
three_random_ints.subscribe(lambda i: print("subscriber 1 received".format(i)))
three_random_ints.connect()
# .auto_connect(2) hold off until the number of subscriber reach 2
# then emissions is firing at this moment
# Observable.zip(letters, intervals, lambda s, i: (s, i)) \ .subscribe(lambda t: print(t))
'''
save event SQL alchemy DB
from sqlalchemy import create_engine, text
from rx import Observable
engine = create_engine('sqlite:///rexon_metals.db')
conn = engine.connect()
def customer_for_id(customer_id):
stmt = text("SELECT * FROM CUSTOMER WHERE CUSTOMER_ID = :id")
return Observable.from_(conn.execute(stmt, id=customer_id))
# Query customers with IDs 1, 3, and 5
Observable.of(1, 3, 5) \
.flat_map(lambda id: customer_for_id(id)) \
.subscribe(lambda r: print(r))
'''
return
def _build_local_discover_observable(self, thing_filter):
"""Builds an Observable to discover Things using the local method."""
found_tds = [
ThingDescription.from_thing(exposed_thing.thing).to_str()
for exposed_thing in self._servient.exposed_things
if self._is_fragment_match(exposed_thing, thing_filter)
]
# noinspection PyUnresolvedReferences
return Observable.of(*found_tds)
def on_start(self, connection_context, op_id, params):
try:
execution_result = self.execute(
# Even though this object is referred to as the "request_context", it is
# actually a IWorkspaceProcessContext. This is a naming restriction from the underlying
# GeventSubscriptionServer. Here, we create a new request context for every
# incoming GraphQL request
connection_context.request_context.create_request_context(),
params,
)
if not isinstance(execution_result, Observable):
# pylint cannot find of method
observable = Observable.of(execution_result, GQL_COMPLETE) # pylint: disable=E1101
# Register the operation using None even though we are not implementing async
# iterators. This is useful for bookkeeping purpose, allowing us to ignore generated
# events for closed operations and avoid sending an unnecessary web socket messages.
# Requires that `unsubscribe` is overridden to handle the None case.
connection_context.register_operation(op_id, None)
else:
observable = execution_result
# This registered operation will get overwritten below, but is necessary to handle
# the messages that get emitted as soon as the subscription is made (e.g. handling
# subscription events that are already queued up)
connection_context.register_operation(op_id, observable)
def on_complete(conn_context):
# unsubscribe from the completed operation
self.on_stop(conn_context, op_id)
disposable = observable.subscribe(
SubscriptionObserver(
connection_context,
op_id,
self.send_execution_result,
self.send_error,
on_complete,
))
# replace the registered operation with the subscribed observer, to ensure that it gets
# cleaned up upon connection close
connection_context.register_operation(op_id, disposable)
# appropriate to catch all errors here
except Exception as e: # pylint: disable=W0703
self.send_error(connection_context, op_id, str(e))
def on_start(self, connection_context, op_id, params):
try:
execution_result = self.execute(connection_context.request_context,
params)
if not isinstance(execution_result, Observable):
# pylint cannot find of method
observable = Observable.of(execution_result, GQL_COMPLETE) # pylint: disable=E1101
else:
observable = execution_result
observable.subscribe(
SubscriptionObserver(
connection_context,
op_id,
self.send_execution_result,
self.send_error,
self.on_close,
))
# appropriate to catch all errors here
except Exception as e: # pylint: disable=W0703
self.send_error(connection_context, op_id, str(e))
def test_of_empty(self):
results = []
Observable.of().subscribe_(results.append)
assert (len(results) == 0)
from sqlalchemy import create_engine, text
from rx import Observable
engine = create_engine('sqlite:///rexon_metals.db')
conn = engine.connect()
def customer_for_id(customer_id):
stmt = text("SELECT * FROM CUSTOMER WHERE CUSTOMER_ID = :id")
return Observable.from_(conn.execute(stmt, id=customer_id))
# Query customers with IDs 1, 3, and 5
Observable.of(1, 3, 5) \
.flat_map(lambda id: customer_for_id(id)) \
.subscribe(lambda r: print(r))
def intense_calculation(value):
# sleep for a random short duration between 0.5 to 2.0 seconds to simulate a long-running calculation
time.sleep(random.randint(5, 20) * .1)
return value
# calculate number of CPU's, then create a ThreadPoolScheduler with that number of threads
optimal_thread_count = multiprocessing.cpu_count()
pool_scheduler = ThreadPoolScheduler(optimal_thread_count)
# Create Process 1
Observable.of("Alpha", "Beta", "Gamma", "Delta", "Epsilon") \
.map(lambda s: intense_calculation(s)) \
.subscribe_on(pool_scheduler) \
.subscribe(on_next=lambda s: print("PROCESS 1: {0} {1}".format(current_thread().name, s)),
on_error=lambda e: print(e),
on_completed=lambda: print("PROCESS 1 done!"))
# Create Process 2
Observable.range(1, 10) \
.map(lambda s: intense_calculation(s)) \
.subscribe_on(pool_scheduler) \
.subscribe(on_next=lambda i: print("PROCESS 2: {0} {1}".format(current_thread().name, i)),
on_error=lambda e: print(e), on_completed=lambda: print("PROCESS 2 done!"))
# Create Process 3, which is infinite
Observable.interval(1000) \
.map(lambda i: i * 100) \
.observe_on(pool_scheduler) \
.map(lambda s: intense_calculation(s)) \
from sqlalchemy import create_engine, text
from rx import Observable
engine = create_engine('sqlite:///rexon_metals.db')
conn = engine.connect()
def customer_for_id(customer_id):
stmt = text("SELECT * FROM CUSTOMER WHERE CUSTOMER_ID = :id")
return Observable.from_(conn.execute(stmt, id=customer_id))
# Query customers with IDs 1, 3, and 5
Observable.of(1, 3, 5) \
.flat_map(lambda id: customer_for_id(id)) \
.subscribe(lambda r: print(r))
from rx import Observable, Observer
# Using Observable.range()
letters = Observable.range(1, 10)
letters.subscribe(lambda value: print(value))
# Using Observable.just()
greeting = Observable.of("Hello World!")
greeting.subscribe(lambda value: print(value))
from __future__ import print_function
from rx import Observable, Observer
# Using Observable.range()
# create an Observable that emits a particular range of sequential integers
# http://reactivex.io/documentation/operators/range.html
letters = Observable.range(1, 10)
letters.subscribe(lambda value: print(value))
# Using Observable.just()
# create an Observable that emits a particular item
# http://reactivex.io/documentation/operators/just.html
greeting = Observable.just("Hello World!")
greeting.subscribe(lambda value: print(value))
books = Observable.of('ABC', 'EFG', 'HIJ') \
.subscribe(lambda s: print(s))
def test_split_list():
# flat_map does not preserve order
Observable.of(
[1, 2, 3],
[4, 5, 6]).flat_map(lambda l: Observable.from_list(l)).subscribe(print)
def say_hello(name, callback):
callback('hello {}!'.format(name))
# You can use from_callback to produce more observables using a
# function as a factory.
hello = Observable.from_callback(say_hello)
hello('Rudolf').subscribe(print_value)
hello('observable').subscribe(print_value)
# You can turn a list into an observable.
Observable.from_list([1, 2, 3]).subscribe(print_value)
# You can turn a list of arguments into an observable.
Observable.of(1, 2, 3, 'A', 'B', 'C').subscribe(print_value)
# And for testing, you can use "marbles". Marbles are a visual
# representation of when items are emitted through an observable.
# We have to import the marbles module to activate this function and
# we have to import the TestScheduler.
from rx.testing import marbles, TestScheduler
from rx.concurrency import timeout_scheduler, new_thread_scheduler
test_scheduler = TestScheduler()
# When you create an observable, you have the option of passing in a
# scheduler. The scheduler can be the Python Async IO scheduler, the
# scheduler from Tornado or the scheduler from Q. The scheduler
from rx import Observable
source = Observable.of("Alpha", "Beta", "Gamma", "Delta", "Epsilon")
lengths = source.map(lambda s: len(s))
filtered = lengths.filter(lambda i: i >= 5)
filtered.subscribe(lambda value: print("Received {0}".format(value)))
'''
Received 5
Received 5
Received 5
Received 7
'''
from rx import Observable
letters = Observable.of("Alpha", "Beta", "Gamma", "Delta", "Epsilon")
intervals = Observable.interval(1000)
Observable.zip(letters, intervals, lambda s, i: (s, i)) \
.subscribe(lambda t: print(t))
input("Press any key to quit\n")
# O/P
#
# ('Alpha', 0)
# ('Beta', 1)
# ('Gamma', 2)
# ('Delta', 3)
# ('Epsilon', 4)
from __future__ import print_function
from rx import Observable
foo = Observable.interval(500).take(5) \
.zip(Observable.from_('hello'), lambda x, y: y)
bar = Observable.interval(300).take(7) \
.zip(Observable.of(0, 1, 0, 1, 0, 1, 0), lambda x, y: y)
# -----H-----e-----l-----l-----o
#---0---1---0---1---0---1---0
#------h-----e-----L-----l-----o
# .subscribe(lambda x: print(x), lambda err: print(x), lambda : print("complete"))
foo.with_latest_from(bar, lambda x, y: x.upper() if y == 1 else x.lower()) \
.subscribe(lambda x: print(x), lambda err: print(err), lambda : print("complete"))
input("Press some keys\n")
#
# Let's try using it in practice here, and we hit that function to combine the values. Let's run this, and we see there a lower case "H," lower case "E-L-L-O," just like we had outlined here. We use withLatestFrom to map an observable, foo, to another observable, but using the latest value from some other observables.
# That is why there is no static version of the withLatestFrom operator. That's because foo here is somehow special. It's different. It's assuming a different responsibility than bar is because essentially it's not like CombineLatest. If we would use CombineLatest, then when one is emitted on bar, it would be combined with latest value from "H" and that would make upper case "H," but that's not what we want.
# We want basically this to be a mapping of that observable, just using some secondary information from other observables. The main observable is foo, that's what we want to map. That's why foo here is special because it's the main observable and we just want to use secondary information from other observables.
def create_numbers_observable(*args):
return Observable.of(*args)
def create():
return Observable.of(1, 2, 3, 4, 5)
def create():
return Observable.of(scheduler=scheduler)
class Query(graphene.ObjectType):
base = graphene.String()
class RandomType(graphene.ObjectType):
booler = graphene.String()
seconds = graphene.Int()
random_int = graphene.Int()
# data = Observable.subscribe(observer=)
flag = True
ret = Observable.of(RandomType(seconds=1, booler=0))
source = Observable
class Subscription(graphene.ObjectType):
count_seconds = graphene.Int(up_to=graphene.Int())
random_int = graphene.Field(RandomType)
print("random_int")
print(count_seconds.args)
def resolve_count_seconds(root, info, up_to=5):
print("callled")
print(up_to)
from rx import Observable
numbers = Observable.of(1, 2, 3, 4)
numbers.subscribe(on_next=lambda i: print("item: {}".format(i)),
on_error=lambda e: print("error: {}".format(e)),
on_completed=lambda: print("completed"))
def test_of_empty(self):
results = []
Observable.of().subscribe(results.append)
assert(len(results) == 0)
from rx import Observable
source = Observable.of("Alpha", "Beta", "Gamma", "Delta", "Epsilon")
lengths = source.map(lambda s: len(s))
filtered = lengths.filter(lambda i: i >= 5)
filtered.subscribe(lambda value: print("Received {0}".format(value)))
# Chaining
from rx import Observable
Observable.of("Alpha", "Beta", "Gamma", "Delta", "Epsilon") \
.map(lambda s: len(s)) \
.filter(lambda i: i >= 5) \
.subscribe(lambda value: print("Received {0}".format(value)))
def create():
return Observable.of(scheduler=scheduler)
def test_of(self):
results = []
Observable.of(1,2,3,4,5).subscribe(results.append)
assert(str([1,2,3,4,5]) == str(results))
from rx import Observable, Observer
xs = Observable.of(1,2,3)
ys = Observable.of(4,5,6)
zs = xs + ys # Concatenate observables
zs.to_list().subscribe(lambda value: print(value))
xs = Observable.of(1,2,3)
ys = xs * 4
ys.to_list().subscribe(lambda value: print(value))
xs = Observable.of(1,2,3)
ys = xs[1:-1]
ys.to_list().subscribe(lambda value: print(value))
xs = Observable.of(1,2,3,4,5,6)
ys = xs.to_blocking()
zs = (x*x for x in ys if x > 3)
for x in zs:
print(x)
'''
[1, 2, 3, 4, 5, 6]
[1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]
[2]
16
25
36
'''
def create():
return Observable.of(1,2,3,4,5, scheduler=scheduler)
from __future__ import print_function
from rx import Observable, Observer
foo = Observable.of('h', 'e', 'l', 'l', 'o') \
.zip(Observable.interval(600).take(5), lambda x, y: x)
# -----h-----e-----l-----l-----o|
#
# buffer_with_count(2)
#
# ----------[h,e]-------[l,l]--[o]|
# -----h-----e-----l-----l-----o|
# --------x--------x--------x
# buffer_with_time(9000)
#
# --------h--------e--------ll-0|
# -----h-----e-----l-----l-----o| (foo)
# buffer(closing observable)
# --------0--------1--------2| (bar)
#
# -------h-------e---------ll|
bar = Observable.interval(800).take(3)
# foo.buffer_with_count(2).subscribe(lambda x: print(x))
# foo.buffer_with_time(900).subscribe(lambda x: print(x))
foo.buffer(bar).subscribe(lambda x: print(x), lambda err: print(err),
lambda: print("DONE"))
from rx import Observable
letters = Observable.of("Alpha", "Beta", "Gamma", "Delta", "Epsilon")
intervals = Observable.interval(1000)
Observable.zip(letters, intervals, lambda s, i: (s, i)) \
.subscribe(lambda t: print(t))
input("Press any key to quit\n")
'''
Press any key to quit
('Alpha', 0)
('Beta', 1)
('Gamma', 2)
('Delta', 3)
('Epsilon', 4)
'''
def create():
return Observable.of(1, 2, 3, 4, 5, scheduler=scheduler)
def resolve_hello(root, info):
return Observable.of("hello world!")
from rx import Observable
source = Observable.of("Alpha", "Beta", "Gamma", "Delta", "Epsilon")
lengths = source.map(lambda s: len(s))
filtered = lengths.filter(lambda i: i >= 5)
filtered.subscribe(lambda value: print("Received {0}".format(value)))
from rx import Observable
source = Observable.of("Alpha", "Beta", "Gamma", "Delta", "Epsilon")
lengths = source.map(lambda s: len(s))
filtered = lengths.filter(lambda i: i >= 5)
filtered.subscribe(lambda value: print("Received {0}".format(value)))
# using chaining
Observable.of("Alpha", "Beta", "Gamma", "Delta", "Epsilon") \
.map(lambda s: len(s)) \
.filter(lambda i: i >= 5) \
.subscribe(lambda value: print("Received {0}".format(value)))
def test_of(self):
results = []
Observable.of(1, 2, 3, 4, 5).subscribe_(results.append)
assert (str([1, 2, 3, 4, 5]) == str(results))
