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)
class Bot:
def __init__(self):
self.commands = Commands().initialize()
self.scheduler = Scheduler().initialize()
def start(self):
self.scheduler.start()
self.commands.start()
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 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 main():
"""
调度器入口
:return:
"""
s = Scheduler()
s.run()
print('------------------------------------>')
print('欢迎使用nj_cookies_pool, 调度器开始运行……')
print('------------------------------------>')
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 main():
if options.num_hours:
try:
hours = int(options.num_hours)
except:
print("Must enter a valid number of hours")
return
else:
hours = 4
scheduler = Scheduler(hours)
scheduler.print_schedule()
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 add_event():
"""Adds event to scheduler."""
for atr in ['name', 'when', 'how']:
if atr not in request.get_json():
abort(400)
if not verify_signature(request):
abort(400)
json = request.get_json()
event = Scheduler.create_event(name=json.get('name'), when=json.get('when'), how=json.get('how'), receiver=json.get('receiver'), message=json.get('message'), subject=json.get('subject'))
sch.process_event(event)
return '', 200
def run_scheduler():
"""Loads calendar and stars scheduler"""
sch = Scheduler()
try:
sch.load_calendar(os.environ['CALENDAR'])
except:
pass
sch.run()
return sch
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_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 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_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 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_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 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 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 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]
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
def open_ui():
eel.init('web')
eel.start('index.html', port=8686)
def run_systray_icon():
icon = pystray.Icon('test name')
icon.title = APP_NAME
icon.icon = Image.open(resource_path('src/icon.png'))
icon.menu = pystray.Menu(
pystray.MenuItem(text='Options', action=open_ui, default=True),
pystray.MenuItem(text='Next photo', action=Options.set_wallpaper_next),
pystray.MenuItem(text='Previous photo',
action=Options.set_wallpaper_prev),
pystray.MenuItem(text='Random photo',
action=Options.set_wallpaper_random))
icon.run()
if __name__ == '__main__':
print('running')
time.sleep(1)
Scheduler.start()
# # ui = threading.Thread(target = open_ui)
# # ui.start()
run_systray_icon()
def __init__(self):
self.commands = Commands().initialize()
self.scheduler = Scheduler().initialize()
def test_create_event_with_wrong_date(capsys):
with pytest.raises(Exception) as excinfo:
Scheduler.create_event('test', 'test')
cp = capsys.readouterr()
assert not cp.out
assert 'Could not match input to any of' in str(excinfo.value)
def main(args):
scheduler = Scheduler(simulation_speed=args.simulation_speed)
scheduler.run(run_time=args.simulation_time)
def simulate(scheduling_algorithm, accounting_file, verbose=False):
## Create Nodes
if verbose:
sys.stderr.write("Creating nodes ...\n")
slow1 = ComputeNode(name='slow1', running_watts=SLOW_NODE_1_RUNNING_WATTS,
idle_watts=SLOW_NODE_1_IDLE_WATTS,
cpus=SLOW_NODE_1_CPUS, cost_per_kwh=DOLLARS_PER_KILOWATT_HOUR,
verbose=verbose)
slow2 = ComputeNode(name='slow2', running_watts=SLOW_NODE_2_RUNNING_WATTS,
idle_watts=SLOW_NODE_2_IDLE_WATTS,
cpus=SLOW_NODE_2_CPUS, cost_per_kwh=DOLLARS_PER_KILOWATT_HOUR,
verbose=verbose)
fast = ComputeNode(name='fast', running_watts=FAST_NODE_RUNNING_WATTS,
idle_watts=FAST_NODE_IDLE_WATTS,
cpus=FAST_NODE_CPUS, cost_per_kwh=DOLLARS_PER_KILOWATT_HOUR,
verbose=verbose)
nodes = [slow1, slow2, fast]
## Read submission data into a list
if verbose:
sys.stderr.write("Reading job submission data into memory ...\n")
jobs = jobs_from_accounting_file(accounting_file)
if not jobs:
sys.stderr.write("Failed to read accounting file " + accounting_file +\
"; exiting.\n")
sys.exit()
sys.stderr.write("Got " + str(len(jobs)) + " jobs.\n")
period_of_study_begin = jobs[0].arrival_time
## Create Scheduler
if verbose:
sys.stderr.write("Creating scheduler ...\n")
scheduler = Scheduler(scheduling_algorithm, nodes, jobs, verbose)
## Run simulation
if verbose:
sys.stderr.write("Initializing scheduler ...\n")
scheduler.initialize(period_of_study_begin)
if verbose:
sys.stderr.write("Beginning simulation ...\n")
current_second = period_of_study_begin
while scheduler.jobs_remaining():
if verbose and current_second % 3600 == 0:
hours_elapsed = int((current_second - period_of_study_begin) / 3600)
sys.stderr.write(str(hours_elapsed) + " sim hours elapsed ...\n")
sys.stderr.write("scheduler has " + str(scheduler.jobs_remaining()) +
" jobs remaining\n")
scheduler.update(current_second)
current_second += 1
period_of_study_end = current_second
period_of_study_duration = period_of_study_end - period_of_study_begin
## Report results
# print simulation info
sim_start = date_string_from_epoch_timestamp(period_of_study_begin)
sim_end = date_string_from_epoch_timestamp(period_of_study_end)
sim_length = date_string_from_duration_in_seconds(period_of_study_duration)
print("\n## SIMULATION INFORMATION ##\n")
print("simulation start: " + sim_start)
print("simulation end: " + sim_end)
print("simulation duration (dd:hh:mm:ss): " + sim_length + "\n")
# print job info
print("\n## JOB INFORMATION ##\n")
print("arrival_time\tstart_time\tcompletion_time\twait_time (dd:hh:mm:ss)\t" +
"run_time (dd:hh:mm:ss)\tnode")
print("------------\t----------\t---------------\t------------------\t----")
print(scheduler.generate_job_report())
# print header for node data
print("\n## NODE INFORMATION ##\n")
print("name\ttotal_compute_time (dd:hh:mm:ss)\ttotal_idle_time (dd:hh:mm:ss)\t" +
"total_energy_consumption (kWh)\ttotal_energy_cost")
print("----\t------------------------\t---------------------\t" +
"------------------------------")
print(scheduler.generate_node_report())
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)
def test_create_event(capsys):
Scheduler.create_event('test', '2021-01-30 19:25:00')
cp = capsys.readouterr()
assert not cp.err
def set_schedule(interval, unit):
Scheduler.start(interval, unit)
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()