def test_scheduler():
c = Counter()
s = Scheduler()
s.add(c.inc_every, every=200)
assert c.cnt_every == 0
assert s.next() == 0.0
s.add(c.inc_at, at=100)
s.reached(0.0)
assert c.cnt_every == 1
assert c.cnt_at == 0
assert s.next() == 100
s.reached(100)
assert c.cnt_every == 1
assert c.cnt_at == 1
assert s.next() == 200
s.reached(200)
assert c.cnt_every == 2
assert c.cnt_at == 1
# If a later timestep is passed to 's.reached()' then actions in
# between *won't* be triggered.
s.reached(500)
assert c.cnt_every == 2 # still the same as before
assert c.cnt_at == 1 # still the same as before
def test_reset_with_at():
c = Counter()
s = Scheduler()
s.add(c.inc_at, at=10)
assert c.cnt_at == 0
s.reached(0)
assert c.cnt_at == 0
s.reached(10)
assert c.cnt_at == 1
s.reached(20)
assert c.cnt_at == 1
s.reached(30)
assert c.cnt_at == 1
# Events that already happened are not triggered again ...
s.reached(10)
assert c.cnt_at == 1
# ... unless we reset the scheduler first
s.reset(2)
s.reached(10)
assert c.cnt_at == 2
# Resetting to a time *after* the scheduled time will result in
# the event not being triggered again, even if we tell the
# scheduler that the time step was reached.
s.reset(30)
s.reached(10)
assert c.cnt_at == 2
def run(self):
if self.config is False:
# May be error format
return
scheduler = CronSchedulerServer(10)
scheduler.add(f"{uuid4()}", self.config, self.push_task)
scheduler.start()
def test_illegal_arguments():
def dummy_func():
pass
s = Scheduler()
with pytest.raises(AssertionError):
s.add(dummy_func, at=0, after=1) # delays don't mix with 'at'
with pytest.raises(AssertionError):
s.add(dummy_func, at=1, every=2) # can't mix 'at' with 'every'
def run(self):
config.set_global_force(**self.global_config)
if self.config is False:
# May be error format
return
scheduler = CronSchedulerServer(10)
scheduler.add(f"{uuid4()}", self.config, self.push_task)
scheduler.start()
def start():
config = Config()
monitor = Monitor()
logger = get_logger(__name__)
pmonitor = PlexMonitor(monitor, config, logger)
if (len(argv) > 1) and argv[1] == "--debug":
pmonitor.full()
s = Scheduler()
s.add(Event("Error Log", 300, pmonitor))
s.run()
def test_returns_None_if_no_actions_or_done():
s = Scheduler()
with pytest.raises(StopIteration):
s.next()
def bogus():
pass
s.add(bogus, at=1)
assert s.next() == 1
s.reached(1)
with pytest.raises(StopIteration):
s.next()
def test_regression_not_more_than_once_per_time():
x = [0, 0, 0, 0]
def my_at_fun():
x[0] += 1
def my_at_fun_accident():
x[1] += 1
def my_every_fun():
x[2] += 1
def my_standalone_at_end_fun():
x[3] += 1
s = Scheduler()
s.add(my_at_fun, at=1, at_end=True) # can trigger twice
# 2 is also end, should trigger only once
s.add(my_at_fun_accident, at=2, at_end=True)
s.add(my_every_fun, every=1, after=1, at_end=True) # twice
s.add(my_standalone_at_end_fun, at_end=True) # once anyways
assert s.next() == 1
s.reached(1)
assert x == [1, 0, 1, 0]
s.reached(2)
assert x == [1, 1, 2, 0]
s.finalise(2)
assert x == [2, 1, 2, 1]
def test_scheduler_every():
c = Counter()
s = Scheduler()
s.add(c.inc_every, every=100, after=5)
assert c.cnt_every == 0
assert s.next() == 5
s.reached(5)
assert c.cnt_every == 1
s.reached(100) # shouldn't trigger any event
assert c.cnt_every == 1 # ... thus the counter shouldn't increase
s.reached(105)
assert c.cnt_every == 2
s.reached(205)
assert c.cnt_every == 3
def load_url(self, channel, method, properties, body):
body = json.loads(body)
url = body.get('url', '')
print(url)
if url:
details = Scraper(url,
BasicExtractor()).get_details([NameAttribute])
product = Product()
for attribute in details:
setattr(product, attribute.name, attribute.value)
print(product.name)
channel.basic_ack(delivery_tag=method.delivery_tag)
data = product.__dict__
Scheduler.add('extract_meta', data)
def test_reached():
c = Counter()
s = Scheduler()
s.add(c.inc_every, every=10)
s.add(c.inc_at, at=20)
assert c.cnt_every == 0
assert c.cnt_at == 0
assert s.next() == 0.0
# Trigger the first couple of events
s.reached(0)
assert c.cnt_every == 1
assert c.cnt_at == 0
s.reached(10)
assert c.cnt_every == 2
assert c.cnt_at == 0
# Call reached() with a time step that skips the next scheduled
# one; this should *not* trigger any events!
s.reached(30)
assert c.cnt_every == 2
assert c.cnt_at == 0
# Now call reached() with the next scheduled time step, assert
# that it triggered the event. Then do a couple more steps for
# sanity checks.
s.reached(20)
assert c.cnt_every == 3
assert c.cnt_at == 1
s.reached(25)
assert c.cnt_every == 3
assert c.cnt_at == 1
s.reached(30)
assert c.cnt_every == 4
assert c.cnt_at == 1
# It is not an error to call reached() with a time step in the
# past. However, this won't trigger any events here because the
# RepeatingTimeEvent knows about its next time step, and the
# SingleTimeEvent was already triggered above (and no event is
# triggered twice for the same time step, unless a reset()
# happens).
s.reached(10)
assert c.cnt_every == 4
assert c.cnt_at == 1
s.reached(20)
assert c.cnt_every == 4
assert c.cnt_at == 1
def test_scheduler_clear():
c = Counter()
s = Scheduler()
s.add(c.inc_every, every=5)
assert c.cnt_every == 0
assert s.next() == 0.0
s.reached(0)
assert c.cnt_every == 1
s.reached(5)
assert c.cnt_every == 2
# Clear the schedule and assert that nothing is supposed to happen any more
s.clear()
assert (s.items == [])
assert (s.realtime_items == {})
s.reached(10)
assert c.cnt_every == 2 # still the same as before
with pytest.raises(StopIteration):
s.next()
def test_reset_with_every():
c = Counter()
s = Scheduler()
s.add(c.inc_every, every=10)
assert c.cnt_every == 0
# Trigger a few events at their scheduled times
s.reached(0)
assert c.cnt_every == 1
s.reached(10)
assert c.cnt_every == 2
s.reached(20)
assert c.cnt_every == 3
s.reached(30)
assert c.cnt_every == 4
# Reset time from 30 to 15 (note: in between two scheduled time
# steps); check that no additional events were triggered and that
# the next time step is as expected
s.reset(15)
assert c.cnt_every == 4
assert s.next() == 20
# Trigger a few more events
s.reached(20)
assert c.cnt_every == 5
s.reached(30)
assert c.cnt_every == 6
# Reset time again, this time precisely to a scheduled time step
# (namely, 20); again, no additional events should have been
# triggered and the next scheduled time step should still be 20.
s.reset(20)
assert c.cnt_every == 6
assert s.next() == 20
# Trigger a few more events
s.reached(20)
assert c.cnt_every == 7
s.reached(30)
assert c.cnt_every == 8
class GameState:
def __init__(self):
self.scheduler = Scheduler()
self.entities: Dict[str, Entity] = {}
self.maps: Dict[str, GameMap] = {}
self.cur_map_id = "none"
@property
def cur_map(self) -> GameMap:
return self.maps[self.cur_map_id]
@property
def cur_things(self) -> List[Entity]:
return [
e for e in self.entities.values() if e.map_id == self.cur_map_id
]
@property
def player(self) -> Entity:
return next((e for e in self.entities.values() if e.is_player), None)
def things_at(self, x: int, y: int) -> List[Entity]:
[e for e in self.cur_things if e.x == x and e.y == y]
def pause(self):
self.scheduler.running = False
def resume(self):
self.scheduler.running = True
def add(self, entity: Entity):
self.entities.update({entity.id: entity})
if not entity.ai.empty:
self.scheduler.add(entity)
def remove(self, entity: Entity):
del self.entities[entity.id]
self.scheduler.remove(entity)
def add_map(self, m: GameMap):
self.maps[m.id] = m
def __init__(self, body):
self.name = body.__name__
def f(*args, **kargs):
try:
res = body(*args, **kargs)
if type(res) == GeneratorType:
res = yield from res
except Exception as e:
self.exception = e
#raise e
finally:
for i in self.waiters:
Scheduler.wake(i)
self.done = True
return res
self.body = f
self.exception = None
self.waiters = set()
self.done = False
self.initialized = False
self.cwd = None
Scheduler.add(self)
break
# 10) Refactoring using async_sleep()
def async_repetitive_message(message, interval_seconds):
"""Yields control until time interval expires"""
while True:
print(message)
yield from async_sleep(interval_seconds)
# 11) Try one more time to get cooperative execution of two functions
# now this non-blocking 'async_is_prime' that was an issue lat time.
if __name__ == '__main__':
scheduler = Scheduler()
scheduler.add(
async_repetitive_message("A Loud Automatic Repetitive Message", 2.5))
scheduler.add(async_print_matches(lucas(), async_is_prime))
# NB: prints inside "run_to_completion" should be disabled
scheduler.run_to_completion()
# >>> A Loud Automatic Repetitive Message
# >>> Found: 2
# >>> Found: 3
# >>> Found: 7
# >>> Found: 11
# >>> Found: 29
# >>> Found: 47
# >>> Found: 199
# >>> Found: 521
# >>> Found: 2207
# >>> Found: 3571
# >>> Found: 9349
def process_request(url):
Scheduler.add('load_url', {'url': url})
microphone = sr.Microphone(device_index = 0)
scheduler = Scheduler()
text = ''
fileName = 'speech.txt'
file = open(fileName,'w+')
def speechToText():
print('Grabando')
with microphone as source:
#recognize.adjust_for_ambient_noise(source)
audio = recognizer.listen(source)
try:
text = recognizer.recognize_google(audio)
file.write(text + '\n')
except:
text = 'Debe hablar claro'
print(text)
print('Fin grabación')
return text
if __name__ = '__main__':
scheduler.add(1,0,speechToText())
while text != 'see':
text = scheduler.run()
file.close()
