def create_tasks(phones):
# d1 = datetime.now() + timedelta(minutes=10)
# d2 = datetime.now() + timedelta(hours=1)
task1 = Task(
phone=phones[0],
status=TaskStatus.PENDING,
text="First text",
interval=3,
time_unit="MINUTES",
)
task2 = Task(
phone=phones[0],
status=TaskStatus.REPEAT,
text="Second text",
interval=2,
time_unit="HOURS",
)
# task3 = Task(phone=phones[1], status=TaskStatus.PENDING, text="Some text")
tasks = [task1, task2]
for task in tasks:
db.session.add(task)
db.session.commit()
print(tasks)
return tasks
def test_create_task(self):
tasker = Tasker(self.db)
tasker.create_task('Fix bike', 'once', date(2016, 11, 2))
tasker.create_task('Make coffee', 'daily', date(2016, 11, 3))
tasker.create_task('Get gas', 'weekly', date(2016, 11, 5))
tasker.create_task('Pay bills', 'monthly', date(2016, 11, 4))
tasks = self.db.query(Task).order_by(Task.start).all()
self.assertEqual(tasks, [
Task(
id=1, name='Fix bike', cadence='once', start=date(2016, 11,
2)),
Task(id=2,
name='Make coffee',
cadence='daily',
start=date(2016, 11, 3)),
Task(id=4,
name='Pay bills',
cadence='monthly',
start=date(2016, 11, 4)),
Task(id=3,
name='Get gas',
cadence='weekly',
start=date(2016, 11, 5))
])
def test_create_task_duplicate_name(self):
input_str = 'Do some things\ndaily\n2017-11-06\n'
val = self._call_cli(['create'], stdin=input_str)
input_str = 'Do some things\nDo some other things\ndaily\n2017-11-07\n'
val = self._call_cli(['create'], stdin=input_str)
output_str = '{}{}{}{}'.format(CLI_ENTER_TASK_NAME_STRING,
CLI_ENTER_TASK_NAME_STRING,
CLI_ENTER_CADENCE_STRING,
CLI_ENTER_START_DATE_STRING)
self.assertEqual(val,
(0, output_str,
CLI_DUPLICATE_NAME_FORMAT.format('Do some things')))
# Verify that it was created.
tasks = self._connect_db().query(Task).all()
self.assertEqual(tasks, [
Task(id=1,
name='Do some things',
cadence='daily',
start=date(2017, 11, 6)),
Task(id=2,
name='Do some other things',
cadence='daily',
start=date(2017, 11, 7))
])
def test_run_error(_db, twilio_client, task_mock):
task_mock.query.filter_by().all.side_effect = [
[
Task(status=TaskStatus.ERROR), # Do not execute
Task( # Do not execute
status=TaskStatus.PENDING,
edited_at=datetime.now(),
interval=1,
time_unit=TimeUnit.DAYS,
),
Task( # Execute
id=5,
status=TaskStatus.PENDING,
edited_at=datetime.now() - timedelta(days=2),
interval=1,
time_unit=TimeUnit.DAYS,
phone=Phone(number="whatsapp:+569123456789"),
text="Execute1",
),
],
[],
]
def raise_function(*_args):
raise Exception("My error")
twilio_client().send_message.side_effect = raise_function
cron = CronJob()
initial_time = datetime.now()
cron.run()
final_time = datetime.now()
assert len(cron.tasks) == 1
assert cron.tasks[0].status == TaskStatus.ERROR
assert initial_time < cron.tasks[0].edited_at < final_time
def admin_main():
user = get_current_user()
if user is None:
return render("access-denied.html")
if not user.is_admin:
return render("access-denied.html")
subjects = Subject.find({"hidden": False})
texts_list = [{"id": "5e4066a91c9d440000785ec1", "low": "Нет текста"}]
texts = Text.find()
for text in texts:
if str(text.id) == "5e4066a91c9d440000785ec1":
continue
low = text.body
if len(low) > 30:
low = low[:30]
texts_list.append({"id": str(text.id), "low": low})
if request.method == "GET":
return render("add-task.html", subjects=subjects, texts_list=texts_list)
subject = Subject.find_one({"label": request.form["subject"]})
task_type = TaskType.find_one(
{"number": request.form["task_type"], "subject": subject.id}
)
task_type.count_of_tasks += 1
task_type.commit()
description = request.form["description"]
var1 = request.form["var1"]
var2 = request.form["var2"]
var3 = request.form["var3"]
var4 = request.form["var4"]
var5 = request.form["var5"]
options = []
if var1:
options.append(var1)
if var2:
options.append(var2)
if var3:
options.append(var3)
if var4:
options.append(var4)
if var5:
options.append(var5)
answers = request.form["answers"].replace(" ", "").split(",")
explanation = request.form["explanation"]
text = request.form["text"]
task = Task(
task_type=task_type,
description=description,
options=options,
answers=answers,
explanation=explanation,
text=ObjectId(str(text)),
)
task.commit()
return render("add-task.html", subjects=subjects, ok=True, texts_list=texts_list)
def test_update_after_message_sent():
task1 = Task(status=TaskStatus.PENDING)
task2 = Task(status=TaskStatus.REPEAT)
with patch("src.models.task.datetime") as datetime_mock:
datetime_mock.now = Mock(return_value=5)
task1.update_after_message_sent()
task2.update_after_message_sent()
assert task1.status == TaskStatus.READY
assert task1.edited_at == 5
assert task2.status == TaskStatus.REPEAT
task2.update_after_message_sent(error=True)
assert task2.status == TaskStatus.ERROR
def task_done():
user = get_current_user()
if user is None:
return "No user context"
task_id = request.form["task_id"]
task = Task.find_one({"id": ObjectId(task_id)})
tasklink = TaskLink.find_one({
"user": user.id,
"task": task.id,
"done": True
})
if tasklink is not None:
return "Task already done"
tasktype = task.task_type.fetch()
tasktypelink = TaskTypeLink.find_one({
"user": user.id,
"task_type": tasktype.id
})
if tasktypelink is not None:
tasktypelink.done_tasks += 1
else:
tasktypelink = TaskTypeLink(task_type=tasktype,
user=user,
done_tasks=1,
status=0)
tasktypelink.commit()
tasklink = TaskLink(user=user, task=task, done=True)
tasklink.commit()
return "Query ok"
def app_logged_in(subj_name):
user = get_current_user()
if user is None:
return redirect(url_for("index"))
subject_list = list(Subject.find({"hidden": False}))
if subj_name not in [sub["name"] for sub in subject_list]:
abort(404)
exclude = request.args.get("exclude", "").split()
subject = Subject.find_one({"name": subj_name})
task_types = TaskType.find({"subject": subject.id})
tasks = []
for tt in task_types:
if tt.number in exclude:
continue
rel_tasks = Task.find({"task_type": tt.id})
task = choice(list(rel_tasks))
session["task" + str(tt.number)] = str(task.id)
text = None
if task.text.pk is not None:
text = task.text.fetch().body
tasks.append({
"number": tt.number,
"description": eval('"' + task.description + '"'),
"text": text,
"options": task.options,
})
return render(
"practice.html",
title="Тест",
header_label="Тест в формате ЕГЭ",
current_subj=subj_name,
current_mode="practice",
subject_list=subject_list,
tasks=tasks,
)
def run(self):
phone = Phone.get_or_create_by_number(self.number)
task = Task(
status=self.task_status,
time_unit=self.time_unit,
interval=self.interval,
phone=phone,
text=self.text,
)
db.session.add(task)
db.session.commit()
return f'Message scheduled correctly.\nSend me "delete {task.id}" to remove it.'
def results(subj_name):
if flask.request.method == "GET":
abort(404)
user = get_current_user()
if user is None:
return redirect(url_for("index"))
tasks = []
right = 0
all = 0
test_time = int(request.form["time_counter"])
test_time = time.strftime("%H:%M:%S", time.gmtime(test_time))
subject_list = list(Subject.find({"hidden": False}))
first_points = 0
for q in request.form:
if q != "time_counter":
number = q[4:]
answer = request.form[q]
all += 1
task = Task.find_one({"id": ObjectId(session[q])})
tl = TaskLink.find_one({"task": task.id, "user": user.id})
text = None
if task.text.pk is not None:
text = task.text.fetch().body
tasks.append({
"user_answer": answer,
"number": number,
"description": eval('"' + task.description + '"'),
"text": text,
"options": task.options,
"done": tl.done if tl else False,
"answers": task.answers,
"explanation": task.explanation,
})
if answer in task.answers:
first_points += points[subj_name]["first"][int(number)]
right += 1
return render(
"practice-results.html",
title="Ответы на тест",
header_label="Тест в формате ЕГЭ",
current_subj=subj_name,
current_mode="practice",
subject_list=subject_list,
tasks=tasks,
right=right,
all=all,
time=test_time,
first_points=first_points,
second_points=points[subj_name]["second"][first_points],
)
def main(cfg: DictConfig):
_ = seed_everything(cfg.training.random_seed)
trainer = instantiate(cfg.trainer)
task = Task(cfg)
# Run learning rate finder
lr_finder = trainer.tuner.lr_find(task)
fig = lr_finder.plot(suggest=True)
# create directory if does not exists
os.makedirs(cfg.general.save_dir, exist_ok=True)
# save lr-finder plot to memory
_path = os.path.join(cfg.general.save_dir, f"lr-finder-plot.png")
fig.savefig(_path)
logger.info(f"\nSuggested LR's : {lr_finder.suggestion():.7f}")
logger.info(f"Results saved to {_path}")
def test_create_task_assume_today(self):
input_str = 'Do some things\ndaily\n\n'
output_str = '{}{}{}'.format(CLI_ENTER_TASK_NAME_STRING,
CLI_ENTER_CADENCE_STRING,
CLI_ENTER_START_DATE_STRING)
val = self._call_cli(['create'], stdin=input_str)
self.assertEqual(val, (0, output_str, ''))
# Verify that it was created.
tasks = self._connect_db().query(Task).all()
self.assertEqual(tasks, [
Task(id=1,
name='Do some things',
cadence='daily',
start=date.today())
])
def test_get_text_to_send():
task = Task(status=TaskStatus.PENDING, text="Hi!")
expected_text = "Hi!\n\n```Schedule another message if you want.\n"
expected_text += "Send 'help new' for more information```"
assert task.get_text_to_send() == expected_text
task = Task(
status=TaskStatus.REPEAT,
id=5,
interval=10,
time_unit=TimeUnit.MINUTES,
text="Hi!",
)
expected_text = "Hi!\n\n```This message will be sent again in 10 minute(s).\n"
expected_text += "Send 'delete 5' to stop this.```"
assert task.get_text_to_send() == expected_text
task.status = TaskStatus.READY
with raises(ValueError) as error:
task.get_text_to_send()
assert "READY not valid for sending messages." in str(error)
def test_dict():
phone = Phone(number="whatsapp:+56123456789")
phone.tasks = [
Task(
status=TaskStatus.PENDING,
time_unit=TimeUnit.DAYS,
interval=5,
text="Hola",
),
]
assert phone.to_dict() == {
"id":
None,
"number":
"whatsapp:+56123456789",
"tasks": [{
"id": None,
"phone": "whatsapp:+56123456789",
"phone_id": None,
"status": "PENDING",
"interval": 5,
"time_unit": "DAYS",
"edited_at": None,
"created_at": None,
"text": "Hola",
}],
}
if os.getenv("SKIP_DB_TESTS") != "false":
return
db.session.add(phone)
db.session.commit()
assert phone.id is not None
assert phone.tasks[0].id is not None
assert phone.tasks[0].phone_id == phone.id # pylint: disable=no-member
assert phone.tasks[0].edited_at is not None
assert phone.tasks[0].created_at is not None
db.session.delete(phone.tasks[0])
db.session.delete(phone)
db.session.commit()
def test_create_task_invalid_cadence(self):
input_str = 'Do some things\nlol testing\ndaily\n2017-11-06\n'
output_str = '{}{}{}{}'.format(CLI_ENTER_TASK_NAME_STRING,
CLI_ENTER_CADENCE_STRING,
CLI_ENTER_CADENCE_STRING,
CLI_ENTER_START_DATE_STRING)
val = self._call_cli(['create'], stdin=input_str)
self.assertEqual(
val, (0, output_str,
CLI_CADENCE_NOT_AVAILABLE_FORMAT.format('lol testing')))
# Verify that it was created.
tasks = self._connect_db().query(Task).all()
self.assertEqual(tasks, [
Task(id=1,
name='Do some things',
cadence='daily',
start=date(2017, 11, 6))
])
def test_create_task_invalid_interval(self):
input_str = 'Do some things\nmonthly\n2017-11-29\n2017-11-06'
output_str = '{}{}{}{}'.format(CLI_ENTER_TASK_NAME_STRING,
CLI_ENTER_CADENCE_STRING,
CLI_ENTER_START_DATE_STRING,
CLI_ENTER_START_DATE_STRING)
val = self._call_cli(['create'], stdin=input_str)
self.assertEqual(val, (0, output_str,
CLI_INAPPROPRATE_DATE_FORMAT.format(
'monthly', date(2017, 11, 29))))
# Verify that it was created.
tasks = self._connect_db().query(Task).all()
self.assertEqual(tasks, [
Task(id=1,
name='Do some things',
cadence='monthly',
start=date(2017, 11, 6))
])
def task_practice(subj_name, task_id):
if get_current_user() is None:
return redirect(url_for("index"))
if subj_name != "russian":
abort(404)
user = get_current_user()
subject = Subject.find_one({"name": subj_name})
subject_list = list(Subject.find({"hidden": False}))
task_type = TaskType.find_one({
"subject": subject.id,
"number": str(task_id)
})
tasks = []
raw_tasks = Task.find({"task_type": task_type.id})
for task in raw_tasks:
tl = TaskLink.find_one({"task": task.id, "user": user.id})
text = None
if task.text.pk is not None:
text = task.text.fetch().body
tasks.append({
"id": str(task.id),
"number": task_type.number,
"description": eval('"' + task.description + '"'),
"text": str(text),
"options": task.options,
"done": tl.done if tl else False,
"answers": task.answers,
"explanation": task.explanation,
})
return render(
"task-practice.html",
title="Задания",
header_label="Практика задания",
current_subj=subj_name,
subject_list=subject_list,
tasks=tasks,
)
async def delete(self):
Task.delete_object(self.uuid)
return Response()
async def get(self):
return json_response(Task.get_object(self.uuid))
def main(cfg: DictConfig):
# instantiate Wandb Logger
wandblogger = WandbLogger(project=cfg.general.project_name,
log_model=True,
name=cfg.training.job_name)
# Log Hyper-parameters to Wandb
wandblogger.log_hyperparams(cfg)
# set random seeds so that results are reproducible
seed_everything(cfg.training.random_seed)
# generate a random idx for the job
if cfg.training.unique_idx is None:
cfg.training.unique_idx = generate_random_id()
uq_id = cfg.training.unique_idx
model_name = f"{cfg.training.encoder}-fold={cfg.training.fold}-{uq_id}"
# Set up Callbacks to assist in Training
cbs = [
WandbTask(),
DisableValidationBar(),
LogInformationCallback(),
LearningRateMonitor(logging_interval="step"),
]
if cfg.training.patience is not None:
cbs.append(
EarlyStopping(monitor="valid/acc",
patience=cfg.training.patience,
mode="max"))
checkpointCallback = ModelCheckpoint(
monitor="valid/acc",
save_top_k=1,
mode="max",
)
# set up trainder kwargs
kwds = dict(checkpoint_callback=checkpointCallback,
callbacks=cbs,
logger=wandblogger)
trainer = instantiate(cfg.trainer, **kwds)
# set up cassava image classification Task
model = Task(cfg)
trainer.fit(model)
# Laod in the best checkpoint and save the model weights
checkpointPath = checkpointCallback.best_model_path
# Testing Stage
_ = trainer.test(verbose=True, ckpt_path=checkpointPath)
# load in the best model weights
model = Task.load_from_checkpoint(checkpointPath)
# create model save dir to save the weights of the
# vanilla torch-model
os.makedirs(cfg.general.save_dir, exist_ok=True)
path = os.path.join(cfg.general.save_dir, f"{model_name}.pt")
# save the weights of the model
torch.save(model.model.state_dict(), f=path)
# upload trained weights to wandb
wandb.save(path)
# save the original compiles config file to wandb
conf_path = os.path.join(cfg.general.save_dir, "cfg.yml")
OmegaConf.save(cfg, f=conf_path)
wandb.save(conf_path)
async def post(self):
content = await self.request.json()
return json_response(
Task.create_object(content, self.request.app.router['todo'].url_for)
)
from src.main import db
from src.models import Task
@app.route('/newtask', methods=['POST'])
def hand_new_task()
if request.method == 'POST':
data = request.get_json()
print(data)
new_task = Task(
title=data["title"]
category_id=data["category_id"]
creation=data["creation"]
start=data["start"]
final=data["final"]
region_id=data["region_id"]
comunne_id=data["comunne_id"]
description=data["description"]
price=data["price"]
)
db.session.add(new_task)
if db:
db.session.commit()
return jsonify({
"ok":"nueva tarea insertada"
}), 200
else:
return jsonify({
"error": "tarea no insertada"
}), 404
async def delete(self):
Task.delete_all_objects()
return Response()
async def patch(self):
content = await self.request.json()
return json_response(
Task.update_object(self.uuid, content))
def test_should_execute(status, time_unit, interval, time_lapse, execute):
edited_at = datetime.now() - timedelta(seconds=time_lapse)
task = Task(
status=status, time_unit=time_unit, interval=interval, edited_at=edited_at
)
assert task.should_execute() is execute
def test_run(_db, twilio_client, task_mock):
task_mock.query.filter_by().all.side_effect = [
[
Task(status=TaskStatus.ERROR), # Do not execute
Task( # Do not execute
status=TaskStatus.PENDING,
edited_at=datetime.now(),
interval=1,
time_unit=TimeUnit.DAYS,
),
Task( # Execute
id=5,
status=TaskStatus.PENDING,
edited_at=datetime.now() - timedelta(days=2),
interval=1,
time_unit=TimeUnit.DAYS,
phone=Phone(number="whatsapp:+569123456789"),
text="Execute1",
),
],
[
Task(status=TaskStatus.ERROR), # Do not execute
Task( # Do not execute
status=TaskStatus.REPEAT,
edited_at=datetime.now(),
interval=1,
time_unit=TimeUnit.DAYS,
),
Task( # Execute
id=6,
status=TaskStatus.REPEAT,
edited_at=datetime.now() - timedelta(days=2),
interval=1,
time_unit=TimeUnit.DAYS,
phone=Phone(number="whatsapp:+569987654321"),
text="Execute2",
),
],
]
cron = CronJob()
initial_time = datetime.now()
cron.run()
final_time = datetime.now()
assert task_mock.query.filter_by().all.call_count == 2
assert len(cron.tasks) == 2
assert twilio_client().send_message.call_count == 2
assert cron.tasks[0].status == TaskStatus.READY
assert cron.tasks[1].status == TaskStatus.REPEAT
assert initial_time < cron.tasks[0].edited_at < final_time
assert initial_time < cron.tasks[1].edited_at < final_time
calls = twilio_client().send_message.call_args_list
assert calls[0][0][1] == "whatsapp:+569123456789"
assert calls[1][0][1] == "whatsapp:+569987654321"
expected_text1 = "Execute1\n\n```Schedule another message if you want.\n"
expected_text1 += "Send 'help new' for more information```"
expected_text2 = "Execute2\n\n```This message will be sent again in 1 day(s).\n"
expected_text2 += "Send 'delete 6' to stop this.```"
assert calls[0][0][0] == expected_text1
assert calls[1][0][0] == expected_text2
def test_validate(kwargs, valid):
task = Task(**kwargs)
assert task.validate() is valid
async def get(self):
return json_response(Task.all_objects())
from src import db
from src.models import Task, User
from datetime import date, datetime
db.create_all()
db.session.add(User('Administrator', '*****@*****.**', '123456', 'admin'))
db.session.add(Task('Finish this website', date(2016, 6, 30), 10, datetime.utcnow(), 1, 1))
db.session.add(Task('Finish iOS application', date(2016, 8, 31), 10, datetime.utcnow(), 1, 1))
db.session.commit()
