def get_data(self, query):
# Observable создается из списка url
return Observable.from_list(
self.urls
).flat_map(
# Для каждого url создается observable, который загружает данные
lambda url: Observable.from_future(self.get_rss(url))
).flat_map(
# Полученные данные парсятся, из них создается observable
lambda x: Observable.from_list(
feedparser.parse(x.body)['entries']
).filter(
# Фильтрует по вхождению запроса в заголовок или текст новости
lambda val, i: query in val.title or query in val.summary
).take(5) # Берем только по 5 новостей по каждому url
).map(lambda x: {'title': x.title, 'link': x.link,
'published': x.published, 'summary': x.summary})
def get_data(self, query):
""" query the data to the API and return the contet filtered"""
return Observable.from_list(self.orgs).flat_map(
lambda name: Observable.from_future(self.get_org_repos(name))
).flat_map(lambda x: Observable.from_list(
self.get_info(x) #transform the response to a json list
).filter(lambda val: (val.get("description") is not None and (val.get(
"description").lower()).find(query.lower()) != -1) or
(val.get("language") is not None and
(val.get("language").lower()).find(query.lower()) != -1)).
take(10) #just take 10 repos from each org
).map(
lambda x: {
'name': x.get("name"),
'stars': str(x.get("stargazers_count")),
'link': x.get("svn_url"),
'description': x.get("description"),
'language': x.get("language")
})
def fetch_project_teams_and_remind(smtp_config,
bamboo_api,
tempo_api,
recipients=None):
try:
employee_directory = bamboo_api.get_list_of_employees()
Observable.from_list(tempo_api.get_all_teams()) \
.filter(filter_teams) \
.flat_map(lambda team: Observable.create(lambda obs: obs.on_next(ProjectTeam(team["name"],
get_email(team["lead"]),
team["id"])))) \
.flat_map(lambda team: append_team_members(team, tempo_api)) \
.map(lambda team: append_team_member_details(team, employee_directory)) \
.map(lambda team: append_team_time_offs(team, bamboo_api)) \
.subscribe(lambda team: send_reminder(team, smtp_config, recipients.get(team.name)))
except smtplib.SMTPException:
log.exception('SMTP error occurred!')
pass
except Exception:
log.exception("Something went wrong!")
def get_data(self,query):
""" query the data to the API and return the contet filtered"""
return Observable.from_list(
self.orgs
).flat_map(
lambda name: Observable.from_future(self.get_org_repos(name))
).flat_map(
lambda x: Observable.from_list(
self.get_info(x) #transform the response to a json list
).filter(
lambda val: (val.get("description") is not None
and (val.get("description").lower()).find(query.lower())!= -1)
or (val.get("language") is not None
and (val.get("language").lower()).find(query.lower())!= -1)
).take(10) #just take 10 repos from each org
).map(lambda x: {'name': x.get("name"),
'stars': str(x.get("stargazers_count")),
'link': x.get("svn_url"),'description': x.get("description"),
'language': x.get("language")})
def resolve_author(root, info):
import json
authors = [Author(id=1, name="a"), Author(id=2, name="b")]
class PrintObserver(Observer):
def on_next(self, value):
pass
def on_completed(self):
pass
def on_error(self, error):
pass
source = Observable.from_list(authors)
source.subscribe(PrintObserver())
return source
def get_data(self, query):
# Observable создается из списка url
return Observable.from_list(self.urls).flat_map(
# Для каждого url создается observable, который загружает данные
lambda url: Observable.from_future(self.get_rss(url))
).flat_map(
# Полученные данные парсятся, из них создается observable
lambda x: Observable.
from_list(feedparser.parse(x.body)['entries']).filter(
# Фильтрует по вхождению запроса в заголовок или текст новости
lambda val, i: query in val.title or query in val.summary
).take(5) # Берем только по 5 новостей по каждому url
).map(
lambda x: {
'title': x.title,
'link': x.link,
'published': x.published,
'summary': x.summary
})
def get_data(self, query):
""" query the data to the API and return the content filtered"""
print(f"test {query}")
return rx.of(self.orgs).pipe(
flat_map(lambda name: print(name) or rx.from_future(
self.get_org_repos(name))),
flat_map(lambda rsp: Observable.from_list(
self.get_info(rsp) # transform the response to a json list
).filter(lambda val: (val.get("description") is not None and (
val.get("description").lower()).find(query.lower()) != -1) or
(val.get("language") is not None and
(val.get("language").lower()).find(query.lower()) != -1))
.take(10) # just take 10 repos from each org
),
map(
lambda rsp: {
"name": rsp.get("name"),
"stars": str(rsp.get("stargazers_count")),
"link": rsp.get("svn_url"),
"description": rsp.get("description"),
"language": rsp.get("language"),
}),
)
print("===================")
xs = Observable.from_([1, 2, 2, 2, 3, 3, 4, 5, 6])
xs.to_blocking().subscribe(print)
xs.to_iterable().subscribe(print)
print("===================")
def myprint(*args):
print(*args)
return None
drive = Observable.from_list(list(range(10))).publish()
s = Subject()
xs = s.buffer_with_count(3).do_action(myprint)
xs.subscribe()
drive.subscribe(s)
drive.connect()
print("===================")
xs = Observable.from_([1, 2, 3, 4, 5, 6])
ys = xs.to_blocking()
print(type(ys))
zs = (x * x for x in ys if x > 3)
print(zs)
from rx.subjects import Subject
#tornado
# class PrintObserver(Observer):
class PrintObserver(Subject):
"""https://auth0.com/blog/reactive-programming-in-python/"""
def on_next(self, value):
print("Received {0}".format(value))
def on_completed(self):
print("Done!")
def on_error(self, error):
print("Error Occurred: {0}".format(error))
def on_close(self):
self.combine_latest_sbs.dispose()
print("WebSocket closed")
if __name__ == '__main__':
source = Observable.from_list([1, 2, 3, 4, 5, 6])
s = source.subscribe(PrintObserver())
s.dispose()
# source = Observable.from_list([1,2,3,4,5,6])
#
# source.subscribe(lambda value: print("Received {0}".format(value)))
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)
# From
Observable.from_(['abc', 'def', 'ghi']).subscribe(print_value)
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()
def simple():
from rx import Observable, Observer
source = Observable.from_list([1, 2, 3, 4, 5, 6])
source.subscribe(lambda v: print("receive {}".format(v)))
import rx
import signal
from rx.subjects import Subject
from rx import Observable, Observer
def myprint(*args):
print(*args)
return None
# drive = Observable.from_list(list(range(33))).publish()
# reg = Subject().buffer_with_count(8).do_action(myprint)
# drive.subscribe(reg)
# drive.connect()
#publish:普通のObservableを接続可能なObservableに変換する
drive = Observable.from_list(list(range(33))).publish()
s = Subject()
#buffer_with_count
#観測可能なシーケンスの各要素を要素数情報に基づいて生成された0個以上のバッファに投影する
#→ 8個ずつ次のストリームに渡す
s.buffer_with_count(8).do_action(myprint).subscribe()
drive.subscribe(s)
#connectでストリーム同士を繋ぐ？
#これがないと結果が表示されない
drive.connect()
def on_next(self, coin):
self.pushButton()
def on_error(self, error):
print("error")
def on_completed(self):
print("completed")
def pushButton(self):
pass
if __name__ == "__main__":
coinEvents = Observable.from_list([5, 10, 5, 5, 10, 5]).publish()
Observable.from_iterable(range(4)) \
.zip(Observable.interval(250)) \
.subscribe(WaterLevelController())
totalCoinEvent = Observable.from_iterable(range(6)) \
.flat_map(lambda r: coinEvents.take(r) \
.reduce(lambda a, b: a + b, 0)
)
totalCoinEvent.subscribe(CoinLCDOutputObserver())
totalCoinEvent \
