def compute_schedule(self, organization_id):
celery_id = self.request.id
start = timezone.localtime(timezone.now())
count = Organization.objects \
.filter(pk=organization_id, celery_task_id=None) \
.update(celery_task_id=celery_id, celery_start=start,
message=_('Computation started at %(d)s, %(t)s') % {'d': date_format(start, use_l10n=True),
't': time_format(start, use_l10n=True)})
if count == 0:
return
organization = Organization.objects.get(pk=organization_id, celery_task_id=celery_id)
schedule_run = ScheduleRun(organization=organization, celery_task_id=celery_id, celery_start=start)
schedule_run.save()
scheduler = Scheduler(organization)
try:
result_list = scheduler.solve(verbose=False, max_compute_time=organization.max_compute_time,
schedule_run=schedule_run)
result_dict = scheduler.result_by_agent(result_list)
end = timezone.localtime(timezone.now())
selected = bool(result_dict)
if selected:
apply_schedule(organization_id, result_dict)
msg = _('Computation finished at %(d)s, %(t)s') % {'d': date_format(end, use_l10n=True),
't': time_format(end, use_l10n=True)}
balancing = scheduler.compute_balancing(result_list)
if balancing:
balances = _(', ').join(['%s: %s' % (x[0], x[2]) for x in balancing.values()])
schedule_msg = _('Balancing: %(b)s') % {'b': balances}
else:
schedule_msg = _('No balance required.')
ScheduleRun.objects.filter(organization__id=organization_id).update(is_selected=False)
else:
schedule_msg = _('Unable to find a solution')
msg = _('Unable to find a solution, maybe you should remove some constraints. '
'Computation finished at %(d)s, %(t)s') % {'d': date_format(end, use_l10n=True),
't': time_format(end, use_l10n=True)}
serialized_result_dict = json.dumps(result_dict, cls=SetJSONEncoder)
ScheduleRun.objects.filter(pk=schedule_run.pk).update(celery_end=end, process_id=None, status=bool(result_dict),
result_dict=serialized_result_dict, is_selected=selected,
message=schedule_msg)
except subprocess.TimeoutExpired:
end = timezone.localtime(timezone.now())
msg = _('%(d)s, %(t)s: Unable to find a schedule in the allowed time.') % \
{'d': date_format(end, use_l10n=True), 't': time_format(end, use_l10n=True)}
ScheduleRun.objects.filter(pk=schedule_run.pk).update(celery_end=end, process_id=None, status=False)
except Exception as e:
end = timezone.localtime(timezone.now())
msg = _('%(d)s, %(t)s: Unable to compute a schedule %(msg)s') % \
{'msg': e, 'd': date_format(end, use_l10n=True), 't': time_format(end, use_l10n=True)}
ScheduleRun.objects.filter(pk=schedule_run.pk).update(celery_end=end, process_id=None, status=False)
Organization.objects.filter(pk=organization_id, celery_task_id=celery_id) \
.update(celery_task_id=None, message=msg)
def test_simple_balance(self):
org = self.get_organization()
category_1 = org.category_set.get(name='C1')
assert isinstance(category_1, Category)
category_1.balancing_mode = Category.BALANCE_NUMBER
category_1.balancing_tolerance = 0
category_1.save()
task_1 = Task(organization=org, name='E1', start_time=self.get_time(0), end_time=self.get_time(1),
category=category_1)
task_1.save()
task_2 = Task(organization=org, name='E2', start_time=self.get_time(1), end_time=self.get_time(2),
category=category_1)
task_2.save()
task_3 = Task(organization=org, name='E3', start_time=self.get_time(2), end_time=self.get_time(3),
category=category_1)
task_3.save()
s = Scheduler(org)
result_list = s.solve(verbose=False)
result_dict = s.result_by_agent(result_list)
self.assertEqual({1: {3}, 2: {2}, 3: {1}}, result_dict)
def test_single(self):
org = self.get_organization()
category_1 = org.category_set.get(name='C1')
task_1 = Task(organization=org, name='E1', start_time=self.get_time(0), end_time=self.get_time(1),
category=category_1)
task_1.save()
# s = Scheduler(org)
# for c in s.constraints():
# print(c)
org = self.get_organization()
category_1 = org.category_set.get(name='C1')
category_1.balancing_mode = Category.BALANCE_NUMBER
category_1.save()
task_1 = Task(organization=org, name='E1', start_time=self.get_time(0), end_time=self.get_time(1),
category=category_1)
task_1.save()
s = Scheduler(org)
result_list = s.solve(verbose=False)
result_dict = s.result_by_agent(result_list)
self.assertEqual({4: {2}}, result_dict)
def test_empty(self):
org = self.get_organization()
s = Scheduler(org)
self.assertEqual(['min:'], [str(x) for x in s.constraints()])
def test_overlap(self):
org = self.get_organization()
category_1 = org.category_set.get(name='C1')
Agent.objects.filter(organization=org, name__in=['A2', 'A3']).delete()
task_1 = Task(organization=org, name='E1', start_time=self.get_time(10), end_time=self.get_time(20),
category=category_1)
task_1.save()
task_2 = Task(organization=org, name='E2', start_time=self.get_time(15), end_time=self.get_time(23),
category=category_1)
task_2.save()
s = Scheduler(org)
result_list = s.solve(verbose=False)
result_dict = s.result_by_agent(result_list)
self.assertEqual({}, result_dict)
task_2.start_time = self.get_time(21)
task_2.save()
s = Scheduler(org)
result_list = s.solve(verbose=False)
result_dict = s.result_by_agent(result_list)
self.assertEqual({1: {1, 2}}, result_dict)
task_2.start_time = self.get_time(20)
task_2.save()
s = Scheduler(org)
result_list = s.solve(verbose=False)
result_dict = s.result_by_agent(result_list)
self.assertEqual({1: {1, 2}}, result_dict)
task_2.start_time = self.get_time(5)
task_2.end_time = self.get_time(10)
task_2.save()
s = Scheduler(org)
result_list = s.solve(verbose=False)
result_dict = s.result_by_agent(result_list)
self.assertEqual({1: {1, 2}}, result_dict)
task_2.start_time = self.get_time(5)
task_2.end_time = self.get_time(11)
task_2.save()
s = Scheduler(org)
result_list = s.solve(verbose=False)
result_dict = s.result_by_agent(result_list)
self.assertEqual({}, result_dict)
task_2.start_time = self.get_time(5)
task_2.end_time = self.get_time(23)
task_2.save()
s = Scheduler(org)
result_list = s.solve(verbose=False)
result_dict = s.result_by_agent(result_list)
self.assertEqual({}, result_dict)
task_2.start_time = self.get_time(12)
task_2.end_time = self.get_time(17)
task_2.save()
s = Scheduler(org)
result_list = s.solve(verbose=False)
result_dict = s.result_by_agent(result_list)
self.assertEqual({}, result_dict)
