def test_read_nonexistring_calendar(capsys):
sch = Scheduler()
with pytest.raises(Exception) as excinfo:
sch.read_calendar(file='non_existring_file.extension')
cp = capsys.readouterr()
assert not cp.out
assert 'No such file or directory:' in str(excinfo.value)
def test_read_empty_calendar(capsys):
sch = Scheduler()
with pytest.raises(Exception) as excinfo:
sch.read_calendar(file='tests/empty.ics')
cp = capsys.readouterr()
assert not cp.out
assert 'Multiple calendars in one file are not supported by this method.' in str(
excinfo.value)
def test_load_some_events_calendar(capsys):
sch = Scheduler()
sch.load_calendar(calendar_file='tests/some_events.ics')
events = sch.get_events()
p = capsys.readouterr()
cp = capsys.readouterr()
assert not cp.out
assert not cp.err
assert events
def main():
"""
调度器入口
:return:
"""
s = Scheduler()
s.run()
print('------------------------------------>')
print('欢迎使用nj_cookies_pool, 调度器开始运行……')
print('------------------------------------>')
def start_scheduling(self, chosen_scheduler):
"""
Start the scheduling thread so the window doesnt freeze
param - {int} - chosen_scheduler- short variable for the scheduler, look in consts
"""
# Start Scheduliung progress; is a class even necessary? dont know
self.thread_handler = QThreadPool()
scheduler = Scheduler(self, chosen_scheduler)
self.thread_handler.start(scheduler)
def run_scheduler():
"""Loads calendar and stars scheduler"""
sch = Scheduler()
try:
sch.load_calendar(os.environ['CALENDAR'])
except:
pass
sch.run()
return sch
def init(bot: Bot, u: Updater):
global updater
updater = u
global scheduler
scheduler = Scheduler(database, updater)
for user in database.users:
for name in database.reqs[user]:
if database.reqs[user][name]['enabled']:
scheduler.start(user, name)
def schedule(n: str, kilo_playouts: str):
try:
n = int(n)
except ValueError:
n = None
try:
kilo_playouts = int(kilo_playouts)
except ValueError:
kilo_playouts = None
scheduler = Scheduler()
scheduler.schedule(n, kilo_playouts)
def test_process_mail(capsys):
sch = Scheduler()
event = Scheduler.create_event('test', '2221-01-30 19:25:00', how='mail')
sch.process_event(event)
events = sch.get_events()
p = capsys.readouterr()
cp = capsys.readouterr()
assert not cp.out
assert not cp.err
assert events
def test_process_sms(capsys):
sch = Scheduler()
event = Scheduler.create_event('test', '2221-01-30 19:25:00', how='SMS')
with pytest.raises(Exception) as excinfo:
sch.process_event(event)
events = sch.get_events()
p = capsys.readouterr()
cp = capsys.readouterr()
assert not cp.out
assert not cp.err
assert not events
def hello(name, time, rest, mode, conf, color):
"""The Pomodoro Technique is a time management method developed by Francesco Cirillo in the late 1980s. The technique uses a timer to break down work into intervals, traditionally 25 minutes in length, separated by short breaks."""
tasks = get_tasks_conf(conf)
# default
if not name and not time and not rest and not mode:
tomatos = farm(tasks)
manager = Scheduler(tomatos, color=color, isRandom=True)
# single task
if name is not None:
if name in tasks:
task = tasks[name]
tom = Tomato(task["time"], task["rest"], name, task["content"])
else:
print("The task name is not in configuration file. Please input description and create temporary tasks for you.")
description = input("task description:")
tom = Tomato(time, rest, name, description)
manager = Scheduler([tom], color=color, isRandom=False)
# mode choice
if name is None:
tomatos = farm(tasks)
isRandom = True if mode == "random" else False
manager = Scheduler(tomatos, color=color, isRandom=isRandom)
manager.next()
def process_msg(q):
"""
从消息队列中取出消息进行处理，检查消息队列时间为0.5s
"""
s = Scheduler()
while True:
if q.empty():
time.sleep(0.5)
else:
msg = q.get()
try:
t = Thread(target=s.execute_cmd, args=(msg, ))
t.start()
except Exception as e:
logger.error(e.args)
s.c.send_text('({}) 执行失败，失败原因：{}'.format(msg, e.args))
def test_new_task():
"""Validate NewTask system call create new task in scheduler"""
bucket = []
def child():
for i in range(5):
bucket.append(i)
yield i
def parent():
_ = yield NewTask(child())
scheduler = Scheduler()
scheduler.new(parent())
scheduler.mainloop()
assert bucket == [0, 1, 2, 3, 4]
def test_get_tid():
"""Validate GetTid system call returns task id"""
tids = []
def _foo():
mytid = yield GetTid()
tids.append(mytid)
for i in range(5):
yield i
scheduler = Scheduler()
scheduler.new(_foo())
scheduler.new(_foo())
scheduler.mainloop()
# can we do better than hard code?
assert tids == [4, 5]
def test_simple_multitask():
"""Validate multitask scheduling by Scheduler"""
bucket = []
def _foo():
for i in range(10):
bucket.append(i)
yield
scheduler = Scheduler()
scheduler.new(_foo())
scheduler.new(_foo())
scheduler.mainloop()
expect_bucket = []
for i in range(10):
expect_bucket.append(i)
expect_bucket.append(i)
assert bucket == expect_bucket
def create_scheduler_with_jobs():
scheduler = Scheduler()
datetime_now = datetime.datetime.now()
job_a_time = datetime_now + datetime.timedelta(minutes=10)
job_b_time = datetime_now + datetime.timedelta(minutes=15)
job_c_time = datetime_now + datetime.timedelta(minutes=7)
job_d_time = datetime_now + datetime.timedelta(minutes=19)
job_e_time = datetime_now + datetime.timedelta(minutes=4)
job_a_hours, job_a_minutes = job_a_time.hour, job_a_time.minute
job_b_hours, job_b_minutes = job_b_time.hour, job_b_time.minute
job_c_hours, job_c_minutes = job_c_time.hour, job_c_time.minute
job_d_hours, job_d_minutes = job_d_time.hour, job_d_time.minute
job_e_hours, job_e_minutes = job_e_time.hour, job_e_time.minute
scheduler.register_job(job_a, str(job_a_hours) + ":" + str(job_a_minutes))
scheduler.register_job(job_b, str(job_b_hours) + ":" + str(job_b_minutes))
scheduler.register_job(job_c, str(job_c_hours) + ":" + str(job_c_minutes))
scheduler.register_job(job_d, str(job_d_hours) + ":" + str(job_d_minutes))
scheduler.register_job(job_e, str(job_e_hours) + ":" + str(job_e_minutes))
return scheduler
def test_wait_for_io():
"""Validate ReadWait/WriteWait wait for file descriptor to be available"""
bucket = []
file_obj = None
def read():
bucket.append(0)
yield ReadWait(file_obj)
bucket.append(1)
def write():
bucket.append(2)
yield WriteWait(file_obj)
bucket.append(3)
with open('README.md', 'a+') as handler:
file_obj = handler
scheduler = Scheduler()
scheduler.new(read())
scheduler.new(write())
scheduler.mainloop()
assert bucket == [0, 2, 1, 3]
def test_wait_for_task():
"""Validate WaitFor system call wait for child task to finish"""
end_flag = int(uuid1())
bucket = []
def child():
for i in range(5):
bucket.append(i)
yield i
def parent():
new_tid = yield NewTask(child())
yield WaitTask(new_tid)
bucket.append(end_flag)
scheduler = Scheduler()
scheduler.new(parent())
scheduler.mainloop()
# child task should finish and end flag should be
# added to the end of the list
expect_bucket = [0, 1, 2, 3, 4]
expect_bucket.append(end_flag)
assert bucket == expect_bucket
def test_kill_task():
"""Validate KillTask system call kill right task"""
bucket = []
def child():
for i in range(5):
bucket.append(i)
yield i
def parent():
new_tid = yield NewTask(child())
# kill non existed task
success = yield KillTask(100000)
assert success is False
# kill existed task
success = yield KillTask(new_tid)
assert success is True
scheduler = Scheduler()
scheduler.new(parent())
scheduler.mainloop()
# child coroutine stops at first iteration
assert bucket == [0, 1]
for i in data['tasks'].keys():
task_resources = list()
for j in data['tasks'][i]['resources']:
task_resources = [
resource for resource in resources if resource.name == j
]
tasks.append(
Task(i, int(data['tasks'][i]['period']), task_resources))
for i in range(0, len(tasks)):
tasks[i].set_prio(i)
get_wcet(data['file'], tasks)
scheduler = Scheduler(tasks, hyperperiod)
if not scheduler.rm_necessary_cond():
print("Necessary condition for RM not verified.")
exit(-1)
else:
print("Necessary condition verified.")
if data['preempt'] == True:
scheduler.schedule_prempt(data['algo'])
else:
scheduler.schedule_non_prempt(data['algo'])
# Draw result in svg file
draw = Drawer(scheduler.output, tasks, hyperperiod)
draw.draw_schedule(f"RateMonotonic")
def __init__(self):
self.commands = Commands().initialize()
self.scheduler = Scheduler().initialize()
def main(args):
scheduler = Scheduler(simulation_speed=args.simulation_speed)
scheduler.run(run_time=args.simulation_time)
from src.dep_controller import DepController
from src.req_handler import ReqHandler
from src.node_controller import NodeController
from src.scheduler import Scheduler
import unittest
import time
_nodeCtlLoop = 2
_depCtlLoop = 2
_scheduleCtlLoop = 2
apiServer = APIServer()
depController = DepController(apiServer, _depCtlLoop)
nodeController = NodeController(apiServer, _nodeCtlLoop)
reqHandler = ReqHandler(apiServer)
scheduler = Scheduler(apiServer, _scheduleCtlLoop)
depControllerThread = threading.Thread(target=depController)
nodeControllerThread = threading.Thread(target=nodeController)
reqHandlerThread = threading.Thread(target=reqHandler)
schedulerThread = threading.Thread(target=scheduler)
print("Threads Starting")
reqHandlerThread.start()
nodeControllerThread.start()
depControllerThread.start()
schedulerThread.start()
print("ReadingFile")
instructions = open("tracefiles/delete_deployment.txt", "r")
commands = instructions.readlines()
for command in commands:
cmdAttributes = command.split()
from src.scheduler import Scheduler
from lib import lib
import pandas as pd
import datetime
base_config = lib.load_yaml('base_config')
if __name__ == '__main__':
medic_directory = pd.read_csv(base_config['medic_directory_file_path'])
scheduler = Scheduler(medic_directory=medic_directory, timezone='US/Central')
output_file_name = 'schedule'
scheduler.run(output_file_path='{}/{}'.format(base_config['output_directory'], output_file_name))
# test_time = datetime.datetime(2017, 8, 22, 8, 17)
# now_time = datetime.datetime.utcnow()
# print(test_time.time(), datetime.time(now_time.month, now_time.hour, now_time.minute))
# scheduler.alert_medic(medic=None, signup_time=test_time)
import RPi.GPIO as GPIO
import time, threading, requests, json, sys
from env_setup import ENV_API_URL, ENV_LOCATION_ID
from src.pin_setup import PinSetup
from src.config import Config, initConfig
from src.scheduler import Scheduler, initSchedule
from src.temperature import Temperature, initTemp
from src.furnace import Furnace
GPIO.setmode(GPIO.BCM)
# ~~~~~~~~ INIT THERMOSTAT DEPENDENCIES ~~~~~~~~
pins = PinSetup()
config = Config(initConfig)
furnace = Furnace(pins)
scheduler = Scheduler(initSchedule, config.chipId)
temperature = Temperature(initTemp, pins)
class Thermostat:
def __init__(self):
self.running = True
self.prevTime = int(time.time())
GPIO.add_event_detect(pins.runTestPin,
GPIO.RISING,
callback=self.ioRunToggle,
bouncetime=500)
def ioRunToggle(self):
self.running = False