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 deal_with_by_sno(pre_time, obs):
aver = obs.map(lambda item: item[5] / item[3]) \
.average(lambda num: num)
Observable.zip(obs, aver, lambda item, av: (pre_time, item[1], av)).subscribe(on_next = lambda entry: c.execute('insert into transformed_data values(?, ?, ?)', entry),
on_error = lambda error: print(error),
on_completed = lambda: conn.commit()
)
def class_twentyfive():
import requests
text_request = requests.get(
"http://www.gutenberg.org/cache/epub/55506/pg55506.txt")
if text_request.ok == False:
print("request failed: {}".format(text_request.reason))
print("{}".format(text_request.url))
return
from tempfile import NamedTemporaryFile
temp = NamedTemporaryFile()
temp.file.write(text_reqiest.content)
temp.file.seek(0)
# do something with the file
Observable.from_(["a", "b", "c", "d", "e", "f"])
numbers = Observable.range(1, 5)
Observable.zip(letters, numbers,
lambda l, n: "{} <===> {}".format(l, n)).subscribe(print)
def storeToDB(file_path):
maked_time = make_time_from_filename(file_path)
with open(file_path, mode='r', encoding='big5') as f:
read_data = f.read()
try:
raw_json = json.loads(read_data)
except:
return
f.closed
retVal = raw_json["retVal"]
item = Observable.from_(retVal)
send_time = Observable.repeat(maked_time)
send_item = Observable.zip(item, send_time, lambda i, t: (t, i['iid'], i['sv'], i['sd'], i['vtyp'], i['sno'], i['sna'], i['sip'], i['tot'], i['sbi'], i['sarea'], i['mday'], i['lat'], i['lng'], i['ar'], i['sareaen'], i['snaen'], i['aren'], i['nbcnt'], i['bemp'], i['act']))
insert_sql = 'insert into raw_data values(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)'
send_item.subscribe(lambda item: c.execute(insert_sql, item))
conn.commit()
print(file_path)
from rx import Observable o1 = Observable.interval(1000) o2 = Observable.from_(["A", "B", "C"]) Observable.zip(o1,o2,lambda x,y:(x,y)) \ .subscribe(lambda x: print(x))
Observable.from_(items) \
.map(lambda s: Observable.from_(s.split('/'))) \
.merge_all() \
.subscribe(lambda i: print(i))
Observable.from_(items) \
.flat_map(lambda s: Observable.from_(s.split('/'))) \
.subscribe(lambda i: print(i))
Observable.concat(obs1, obs2).subscribe(lambda x: print(x))
letters = Observable.from_(['A', 'B', 'C', 'D', 'E', 'F'])
numbers = Observable.range(1, 5)
Observable.zip(letters, numbers, lambda l,n: "{0}-({1})".format(l,n))\
.subscribe(lambda x: print(x))
letters.zip(numbers, lambda l,n: "{0}-({1})".format(l,n))\
.subscribe(lambda x: print(x))
letters = Observable.from_(['Alpha', 'Betta', 'Gamma', 'Delta', 'Epsilon'])
intervals = Observable.interval(1000)
Observable.zip(letters, intervals, lambda l,i: l)\
.subscribe(lambda s: print(s), on_completed=lambda: print('Completed!'))
list_ = ['Alpha', 'Beta', 'Gamma', 'Delta', 'Epsilon']
Observable.from_(list_)\
.group_by(lambda s: len(s))\
Observable.interval(2, test_scheduler).map(lambda x: 'b: {}'.format(x)),
lambda a, b: '{}; {}'.format(a, b)
).take_until(Observable.timer(5)).subscribe(print_value)
test_scheduler.start()
# You can see that as it progresses, the current value of the A or B
# stream will be passed along with the updated value of the other
# stream. So in some cases we see the same number for A while the B
# number has increased, and vice versa. This is great when you want to
# combine items no matter which stream is emitting those items.
# Zip will emit items only when all observables have an item to
# emit. This is also another good way to combine streams of data and
# it's great because it can effectively block until all observables
# have items.
# For example, we could be opening files in multiple threads or
# subprocesses but we only want to process the information when all
# files have been
# Here's a small example of using zip.
print('-- Zip')
test_scheduler = TestScheduler()
Observable.zip(
Observable.interval(1, test_scheduler).map(lambda x: 'a: {}'.format(x)),
Observable.interval(2, test_scheduler).map(lambda x: 'b: {}'.format(x)),
lambda a, b: '{}; {}'.format(a, b)
).take_until(Observable.timer(5)).subscribe(print_value)
test_scheduler.start()
# You can see that the numbers aren't printed until both items are
# emitted from the A and B stream.
subscriptionManagerStream = Subject()
entitlementStatusStream.subscribe(
lambda x: print(x),
lambda err: print(err),
lambda : print('end of the show')
)
subscriptionManagerStream.subscribe(
lambda x: print(x),
lambda err: print(err),
lambda : print('end of the show')
)
Observable.zip(entitlementStatusStream,subscriptionManagerStream, lambda x,y: [x,y])\
.subscribe(
lambda x: print("entitlement + subscription zip: ", str(x)),
lambda err: print("zip error: " + str(err)),
lambda x: print('end of the show')
)
aa = Observable.from_(['ent01','ent02','ent03'])
bb = Observable.from_(['subMan01','subMan02','subMan03'])
aa.zip(bb, lambda x,y: [x,y])\
.subscribe(
lambda x: print("zip(aa,bb) : " + str(x)),
lambda err: print("zip error: " + str(err)),
lambda : print('end of the show')
)
Observable.from_(['ent01','ent02','ent03'])\
.subscribe(
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 time import sleep
from rx import Observable
# Generate an interval sequece, firing once each second
interval = Observable.interval(1000)
# 5..10
numbers = Observable.from_(range(5, 11))
# Zip two streams together so it emits at the pace of the slowest stream
source = Observable.zip(
interval,
numbers,
# Because we only push the elements of the `numbers` stream,
# As soon as it runs out of events, it will keep sending empty
# events to the subscribers
lambda _, n: n
)
sub1 = source.subscribe(
lambda v : print("Value published to observer 1: {0}".format(v)),
lambda e : print("Error! {0}".format(e)),
lambda : print("Completed!")
)
sub2 = source.subscribe(
lambda v : print("Value published to observer 2: {0}".format(v)),
lambda e : print("Error! {0}".format(e)),
lambda : print("Completed!")
)
def vector_subtract(obs1, obs2):
return Observable.zip(obs1, obs2, lambda x, y: x - y)
def vector_add(obs1, obs2):
return Observable.zip(obs1, obs2, lambda x, y: x + y)
def dot_product(obs1, obs2):
return Observable.zip(obs1, obs2, lambda x, y: x * y).sum()
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)
'''
'''
将文章信息列表关联作者名称
'''
from rx import Observable, Observer
articles = [
{"post_id":1, "author_id":1, "title":"title1"},
{"post_id":2, "author_id":2, "title":"title2"},
{"post_id":3, "author_id":2, "title":"title2"}
]
authors = [
{"author_id":1, "name":"AA"},
{"author_id":2, "name":"BB"}
]
Observable.from_(articles)\
.flat_map(
lambda x: Observable.zip(Observable.just(x),
Observable.from_(authors).filter(lambda y: y["author_id"] == x["author_id"]),
lambda l, r: dict(list(l.items()) + list(r.items())) ))\
.subscribe(on_next= lambda s: print(s),
on_completed= lambda: print("group_by Done!\n")
)
from __future__ import print_function
from rx import Observable
list = ["Alpha","Beta","Gamma","Delta","Epsilon"]
letters = Observable.from_(list)
intervals = Observable.interval(1000)
Observable.zip(letters,intervals, lambda s,i: s) \
.subscribe(lambda s: print(s))
# intervals = Observable.interval(1000).take(len(list))
# intervals \
# .map(lambda i: list[i]) \
# .subscribe(lambda s: print(s))
input("Press any key to quit\n")
for k, v in zip(header, row):
# print(k, ' == ', v)
d[k] = v
print(d)
return d
def ff(row):
print('row', row)
return row.to_list()
# Observable.from_(row).merge().subscribe(lambda g: print('g', g))
Observable.merge(row[:]).subscribe(lambda g: print('g', g))
# return row.flat_map(lambda i: i.flat_map(lambda y:y.flat_map(lambda o:o)))
return Observable.merge(row[:])
return row.merge_all()
def subdictes_to_dict(row):
d = {}
for x in row:
d.update(x)
return d
source = Observable.from_iterable(reader)\
.map(lambda row: Observable.zip(Observable.from_(header), row, lambda k,v: {k:v}))\
.map(lambda x: x.to_list().map(subdictes_to_dict))#.subscribe(lambda r: print(r, end="\n\n\n"))
print(source.flat_map(lambda x: x).subscribe(lambda x: print(x)))
# Observable.merge(source[:]).merge_all()
from rx import Observable
letters = Observable.from_(["A", "B", "C", "D", "E", "F"])
numbers = Observable.range(1, 5)
Observable.zip(letters,numbers, lambda l,n: "{0}-{1}".format(l,n)) \
.subscribe(lambda i: print(i))
def class_twentyone():
letters = Observable.from_(["a", "b", "c", "d", "e", "f"])
numbers = Observable.range(1, 5)
Observable.zip(letters, numbers,
lambda l, n: "{} <===> {}".format(l, n)).subscribe(print)
