def callback_c(n, durationValue, amountValue, rvValue, scheduleRows, modeValue,
rateValue, **kwargs):
user = kwargs['user']
if n is None:
user = kwargs['user']
return [
html.Div('Lease quote', className='h3 mb-0'),
dbc.Button("Save quote",
id="save_quote_button",
className="d-none d-md-block btn btn-sm btn-primary"),
]
return dash.no_update
else:
if n > 1:
return [
html.Div('Lease quote', className='h3 mb-0'),
]
customer = get_object_or_404(Customer, pk=1)
contract = Contract()
contract.customer = customer
contract.user = user
contract.status = 'Created'
contract.creation_date = datetime.date.today()
contract.status_date = datetime.date.today()
contract.save()
schedule = Schedule()
schedule.contract = contract
schedule.mode = modeValue
schedule.rv = rvValue
schedule.amount = amountValue
schedule.start_date = startdate
schedule.rate = rateValue / 120000
schedule.save()
i = 0
for scheduleRow in scheduleRows:
if (modeValue == '01'):
date = startdate + relativedelta(months=i)
else:
date = startdate + relativedelta(months=i + 1)
i = i + 1
step = Step()
step.schedule = schedule
step.rent = scheduleRow['rent']
step.balance = scheduleRow['balance']
step.date = date
step.save()
return [
html.Div('Lease quote', className='h3 mb-0 text-gray-800'),
html.Div('Quote saved !', className='h3 mb-0 text-gray-800'),
]
def _save_schedule(self, schedule: Schedule):
t = datetime.datetime.now().strftime('%Y-%m-%dT%H-%M-%S')
fname = os.path.join(
os.getcwd(), "data/schedules", f"sch-str-{t}.csv")
with open(fname, "w") as f:
f.write(schedule.to_csv())
self._logger.write(
f"\nHuman Readable Schedule successfully saved to: {fname}")
fname = os.path.join(
os.getcwd(), "data/schedules", f"sch-num-{t}.csv")
with open(fname, "w") as f:
f.write(schedule.to_num_csv())
self._logger.write(
f"Numeric Schedule successfully saved to: {fname}")
def is_name_unique(self, name):
schedules = Schedule.all()
schedules.filter('owner =', users.get_current_user());
schedules.filter('name =', name)
if (schedules.count() > 0):
return False
return True
def create_schedule(self, name): profile = profiles.get_user_profile_from_ds() schedule = Schedule(parent=profile) schedule.name = name schedule.owner = users.get_current_user() schedule.term = 1 schedule.year = 2011 schedule.put() return schedule
def save(self):
schedule_code = self.cleaned_data['file'].read()
parser = ScheduleParser()
schedule = parser.parse(schedule_code)
with transaction.commit_on_success():
t = Trigger.objects.get(method__name=schedule['trigger_method'], method__interface__name=schedule['trigger_interface'])
s = Schedule(trigger=t, name=schedule['schedule_name'], schedule_file=self.cleaned_data['file'])
s.save()
for action in schedule['actions']:
a = Action.objects.get(name=action['action_name'])
sa = ScheduleAction(schedule=s, action=a)
if action['trigger_from'] != None:
ad = ActionDevice.objects.get(action=a, parameter_position=action['trigger_from'])
sa.trigger_device = ad
sa.save()
def get_schedule_by_name(self, scheduleName):
schedules = Schedule.all()
schedules.filter('owner =', users.get_current_user());
schedules.filter('name =', scheduleName)
if schedules.count() == 0:
return None
# Schedules should have unique names, so...
for schedule in schedules:
return schedule
def test_saving_and_retrieving_schedule(self):
schedule1 = Schedule(event="New",
start_time=datetime.time(11, 23, 44),
end_time=datetime.time(11, 25, 44))
schedule1.save()
schedule2 = Schedule(event="Next",
start_time=datetime.time(8, 11, 10),
end_time=datetime.time(8, 25, 12))
schedule2.save()
saved_schedule = Schedule.objects.all()
self.assertEqual(saved_schedule.count(), 2)
self.assertEqual(saved_schedule[0], schedule1)
self.assertEqual(saved_schedule[1], schedule2)
def generate(self) -> Schedule:
classes = []
for C in self.schedule_param.courses:
assigned_instructors = self._get_assigned_Instructors_for(
C, )
for sec_i in range(C.num_of_sections):
instructor, timeslot, room = self._get_unique_Instr_Timeslot_Room(
assigned_instructors, C, classes, )
section = Section(C, sec_i+1)
classes.append(Class(section, instructor, room, timeslot))
return Schedule(classes)
def get_user_schedules(self):
schedules = Schedule.all()
schedules.filter('owner =', users.get_current_user())
schedules.order('creationDate')
schedList = []
for schedule in schedules:
toSend = {}
toSend['name'] = cgi.escape(schedule.name)
toSend['nameB64'] = base64.b64encode(schedule.name)
toSend['courseCount'] = schedule.course_set.count()
toSend['year'] = schedule.year
toSend['term'] = schedule.term
toSend['key'] = str(schedule.key())
schedList.append(toSend)
return schedList
def run(self, *args, **kwargs):
# initial population
population = [
self.schedule_generator.generate()
for _ in range(self.population_size)
]
new_population = [None for _ in range(self.population_size)]
total_classes = len(self.schedule_param.sections)
self.logger.write(self.logger.record_start_marker)
for epoch in range(self.epochs):
try:
population = sorted(
population,
key=lambda sch: self.fitness_provider.fitness(sch),
reverse=not self.fitness_provider.is_reverse())
best_fitness = self.fitness_provider.fitness(population[0])
self.logger.write(f"{epoch}\t\t{best_fitness}")
if self.fitness_provider.compare(best_fitness,
self.min_acceptable_fitness):
return population[0]
""" Dominance by elites """
elite_count = (self.elite_pct * self.population_size) // 100
for i in range(elite_count):
new_population[i] = population[i]
""" Crossover """
mateable_count = (self.mateable_pct *
self.population_size) // 100
siblig_index = 1 \
if (self.population_size - elite_count) % 2 == 0 \
else -1
for i in range(elite_count, self.population_size, 2):
parent1_idx = np.random.randint(mateable_count)
parent2_idx = np.random.randint(mateable_count)
# single point crossover
crossover_point = np.random.randint(total_classes)
# 2 children produced
new_population[i + siblig_index] = Schedule(
(population[parent1_idx].classes[:crossover_point] +
population[parent2_idx].classes[crossover_point:]))
new_population[i] = Schedule(
(population[parent2_idx].classes[:crossover_point] +
population[parent1_idx].classes[crossover_point:]))
""" Mutation """
# self.mutable_pct
mutable_count = (self.mutable_pct *
self.population_size) // 100
for i in range(mutable_count):
# NOTE: research on optimal choice of `schedule_idx` range
schedule_idx = np.random.randint(self.population_size)
# schedule_idx = np.random.randint(elite_count, population_size)
class_idx = np.random.randint(total_classes)
param_idx = np.random.randint(3)
tmp_sch = deepcopy(new_population[schedule_idx])
if param_idx == 0:
""" mutate room """
tmp_sch.classes[class_idx].room = random.choice(
self.schedule_param.rooms)
elif param_idx == 1:
""" mutate instructor """
tmp_sch.classes[class_idx].instructor = \
random.choice(self.schedule_param.instructors)
else: # param_idx == 2
""" mutate timeslot """
tmp_sch.classes[class_idx].timeslot = \
random.choice(self.schedule_param.timeslots)
new_population[schedule_idx] = tmp_sch
""" Local Search using Smart Mutation """
lcl_search_count = (self.lcl_search_pct *
self.population_size) // 100
for i in range(lcl_search_count):
schedule_idx = np.random.randint(self.population_size)
class_idx = np.random.randint(total_classes)
tmp_sch = deepcopy(new_population[schedule_idx])
for j in range(self.lcl_search_iters):
param_idx = np.random.randint(3)
if param_idx == 0:
""" mutate room """
tmp_sch.classes[class_idx].room = random.choice(
self.schedule_param.rooms)
elif param_idx == 1:
""" mutate instructor """
tmp_sch.classes[class_idx].instructor = \
random.choice(self.schedule_param.instructors)
else: # param_idx == 2
""" mutate timeslot """
tmp_sch.classes[class_idx].timeslot = \
random.choice(self.schedule_param.timeslots)
tmp_fitness = self.fitness_provider.fitness(tmp_sch)
current_fitness = self.fitness_provider.fitness(
new_population[schedule_idx])
if self.fitness_provider.compare(
tmp_fitness, current_fitness):
new_population[schedule_idx] = tmp_sch
break
population = new_population
except KeyboardInterrupt:
print("Solver stopped by user")
break
self.logger.write(self.logger.record_end_marker)
best_fitness = self.fitness_provider.fitness(population[0])
best_fit_idx = 0
for i in range(1, len(population)):
f = self.fitness_provider.fitness(population[i])
if self.fitness_provider.compare(f, best_fitness):
best_fitness = f
best_fit_idx = i
return population[best_fit_idx]
def setUp(self):
import datetime
schedule1 = Schedule(event="New",
start_time=datetime.time(11, 23),
end_time=datetime.time(11, 25))
schedule1.save()
