def post(self):
venue_id = self.request.get_range('venue_id')
venue = Venue.get_by_id(venue_id)
if not venue:
self.abort(400)
index = self.request.get_range('index')
days = []
for day in DaySchedule.DAYS:
confirmed = bool(self.request.get(str(day)))
if confirmed:
start = datetime.strptime(self.request.get('start_%s' % day),
STR_TIME_FORMAT)
end = datetime.strptime(self.request.get('end_%s' % day),
STR_TIME_FORMAT)
days.append(
DaySchedule(weekday=day,
start=start.time(),
end=end.time()))
schedule = Schedule(days=days)
if not venue.time_break:
venue.time_break = [schedule]
elif len(venue.time_break) > index:
venue.time_break[index] = schedule
else:
venue.time_break.append(schedule)
venue.put()
self.redirect('/company/venues')
def post(self):
venue_id = self.request.get_range('venue_id')
venue = Venue.get_by_id(venue_id)
if not venue:
self.abort(400)
delivery_type = int(self.request.get('delivery_type'))
delivery_type = venue.get_delivery_type(delivery_type)
logging.debug(delivery_type)
days = []
for day in DaySchedule.DAYS:
confirmed = bool(self.request.get(str(day)))
logging.debug(confirmed)
if confirmed:
start = datetime.strptime(self.request.get('start_%s' % day),
STR_TIME_FORMAT)
end = datetime.strptime(self.request.get('end_%s' % day),
STR_TIME_FORMAT)
days.append(
DaySchedule(weekday=day,
start=start.time(),
end=end.time()))
schedule = Schedule(days=days)
logging.debug("new scheldule: {}".format(schedule))
delivery_type.schedule_restriction = schedule
delivery_type.put()
venue.put()
self.redirect_to('delivery_types')
def add_schedule(self, **kwargs):
schedule = Schedule(day=kwargs["day"],
chet=kwargs["chet"],
group_id=kwargs["group_id"],
interval_id=kwargs["interval_id"],
subject_id=kwargs["subject_id"],
lecturer_id=kwargs["lecturer_id"])
self.db.session.add(schedule)
self.db.session.commit()
def _get_schedule(schedule_dicts):
schedule = Schedule()
for schedule_dict in schedule_dicts:
start_hour = int(schedule_dict['hours'].split('-')[0]) % 24
end_hour = int(schedule_dict['hours'].split('-')[1]) % 24
for day in schedule_dict['days']:
schedule.days.append(DaySchedule(weekday=int(day),
start=time(hour=start_hour),
end=time(hour=end_hour)))
return schedule
def parse_resto_schedule(resto_schedule):
schedule = Schedule()
for resto_schedule in resto_schedule:
resto_start_hour = int(resto_schedule['hours'].split('-')[0]) % 24
resto_end_hour = int(resto_schedule['hours'].split('-')[1]) % 24
for day in resto_schedule['days']:
schedule.days.append(DaySchedule(weekday=int(day),
start=time(hour=resto_start_hour),
end=time(hour=resto_end_hour)))
return schedule
def _create_restaurant_schedule_with_availabilities_for_dates(
self, restaurant_row, dates):
restaurant_name = restaurant_row.find(
id='schedule_place_data').find('a').string
rows_of_daily_opening_closing_times = restaurant_row.find_all(
id='schedule_time_data', )
availabilities = self._get_availabilities_from_rows_for_dates(
rows_of_daily_opening_closing_times,
dates,
)
return Schedule(restaurant_name, availabilities)
def select(id):
schedule = None
sql = "SELECT * FROM schedules WHERE id = %s"
values = [id]
result = run_sql(sql, values)[0]
if result is not None:
instructor = instructor_repository.select(result['instructor_id'])
gym_class = gym_class_repository.select(result['class_id'])
room = room_repository.select(result['room_id'])
schedule = Schedule(result['class_date'], result['start_time'], result['length_mins'], instructor,
gym_class, room, result['id'])
return schedule
def select_all():
schedules = []
sql = "SELECT * FROM schedules ORDER BY class_date"
results = run_sql(sql)
for row in results:
instructor = instructor_repository.select(row['instructor_id'])
gym_class = gym_class_repository.select(row['class_id'])
room = room_repository.select(row['room_id'])
schedule = Schedule(row['class_date'], row['start_time'], row['length_mins'], instructor,
gym_class, room, row['id'])
schedules.append(schedule)
return schedules
def add_schedule():
class_date = request.form['class_date']
start_time = request.form['start_time']
length_mins = request.form['length_mins']
instructor_id = request.form['instructor_id']
class_id = request.form['class_id']
room_id = request.form['room_id']
instructor = details_repository.select(instructor_id)
gym_class = gym_class_repository.select(class_id)
room = room_repository.select(room_id)
schedule = Schedule(class_date, start_time, length_mins, instructor,
gym_class, room, id)
schedule_repository.save(schedule)
return redirect('/schedule')
def create_schedule(df=None, d=None, h=None):
# jobs after d
early_dict = OrderedDict()
ba_diff_asc = False
# best for ba_diff_df descending, for h=0.2, results were better with
# ba_diff_df ascending
if h > 0.5:
ba_diff = 1 # best overall = 1
elif 0.25 < h <= 0.5:
ba_diff = 3 # best overall = 3
else:
ba_diff = 5 # best overall = 5
# # best for ba_diff_df ascending
# if h > 0.75:
# ba_diff = 1 # best overall = 1
# elif 0.5 < h <= 0.75:
# ba_diff = 2 # best overall = 2
# else:
# ba_diff = 3 # best overall = 3 for h=0.2 k < 50, else best = 5
# the idea here is to place the jobs with lower ba_diff in tardy group
tardy_dict = df[df['b'] - df['a'] <= ba_diff].to_dict('index')
# we then pick the reamining jobs, order them by highest p/a first and, if
# they fit, try to place them on early group
ba_diff_dict = df[df['b'] - df['a'] > ba_diff].sort_values(
['pa'], ascending=ba_diff_asc).to_dict(into=OrderedDict,
orient='index')
start_time = d
for idx, row in ba_diff_dict.items():
if idx not in early_dict and idx not in tardy_dict:
p = int(row['p'])
if start_time - p >= 0:
early_dict[idx] = row
start_time -= p
else:
tardy_dict[idx] = row
tardy_dict = OrderedDict(
sorted(tardy_dict.items(), key=lambda x: x[1]['pb']))
early_dict = OrderedDict(
sorted(early_dict.items(), key=lambda x: x[1]['pa']))
return Schedule(d, start_time, early_dict, tardy_dict)
def select_dates():
schedules_list = []
sql = "SELECT * FROM schedules WHERE class_date = %s ORDER BY start_time"
for index in range(7):
schedules = []
values = [date.today() + timedelta(days=index)]
results = run_sql(sql, values)
if results is not None:
for row in results:
instructor = instructor_repository.select(row['instructor_id'])
gym_class = gym_class_repository.select(row['class_id'])
room = room_repository.select(row['room_id'])
schedule = Schedule(row['class_date'], row['start_time'], row['length_mins'], instructor,
gym_class, room, row['id'])
schedules.append(schedule)
else:
schedule = None
schedules.append(schedule)
schedules_list.append(schedules)
return schedules_list
def _create_schedules(self, raw_events):
schedules_dict = {} # name to schedule object
for event_json in raw_events:
name = event_json.get('summary')
location = event_json.get('location')
opens_at = self._extract_datetime(event_json, 'start')
closes_at = self._extract_datetime(event_json, 'end')
date = opens_at.date() if opens_at is not None else None
availability = Availability(
date=date,
opens_at=opens_at,
closes_at=closes_at,
location=location,
)
if name in schedules_dict:
schedules_dict[name].add_availability(availability)
else:
schedules_dict[name] = Schedule(
name=name,
availabilities=[availability],
)
return schedules_dict.values()
def post(self):
promo_id = self.request.get_range('promo_id')
promo = Promo.get_by_id(promo_id)
if not promo:
self.abort(400)
days = []
for day in DaySchedule.DAYS:
confirmed = bool(self.request.get(str(day)))
if confirmed:
start = datetime.strptime(self.request.get('start_%s' % day),
STR_TIME_FORMAT)
end = datetime.strptime(self.request.get('end_%s' % day),
STR_TIME_FORMAT)
days.append(
DaySchedule(weekday=day,
start=start.time(),
end=end.time()))
schedule = Schedule(days=days)
condition = PromoCondition()
condition.method = self.request.get_range('method')
condition.schedule = schedule
promo.conditions.append(condition)
promo.put()
self.redirect('/company/promos/list')
datetime.date(1990, 8, 14))
instructor_dets_3 = InstructorDetails('John', 'Wilson',
datetime.date(1990, 8, 14))
# instructor_sch = InstructorSchedule('9-5', True, True, True,
# True, True, False, False, datetime.time(9, 0),
# datetime.time(17, 0))
# instructor_tim = InstructorTimetable(datetime.date(2021, 3, 21), instructor_dets, instructor_sch)
details_repository.save(instructor_dets_1)
details_repository.save(instructor_dets_2)
details_repository.save(instructor_dets_3)
# i_schedule_repository.save(instructor_sch)
# timetable_repository.save(instructor_tim)
schedule_1 = Schedule(datetime.date(2021, 5, 3), datetime.time(10, 0), 60,
instructor_dets_1, class_1, room_1)
schedule_2 = Schedule(datetime.date(2021, 5, 3), datetime.time(13, 0), 60,
instructor_dets_1, class_1, room_1)
schedule_3 = Schedule(datetime.date(2021, 5, 3), datetime.time(16, 0), 60,
instructor_dets_1, class_1, room_1)
schedule_4 = Schedule(datetime.date(2021, 5, 5), datetime.time(10, 0), 60,
instructor_dets_1, class_1, room_1)
schedule_5 = Schedule(datetime.date(2021, 5, 5), datetime.time(13, 0), 60,
instructor_dets_1, class_1, room_1)
schedule_6 = Schedule(datetime.date(2021, 5, 5), datetime.time(16, 0), 60,
instructor_dets_1, class_1, room_1)
schedule_7 = Schedule(datetime.date(2021, 5, 7), datetime.time(10, 0), 60,
instructor_dets_1, class_1, room_1)
schedule_8 = Schedule(datetime.date(2021, 5, 7), datetime.time(13, 0), 60,
instructor_dets_1, class_1, room_1)
schedule_9 = Schedule(datetime.date(2021, 5, 7), datetime.time(16, 0), 60,
def Schedule(self):
return Schedule(self)
def parse(response):
root = ET.fromstring(response)
movies = []
schedules = []
updates = []
for program in root \
.find('sapo:GetChannelByDateIntervalResult', ns) \
.find('sapo:Programs', ns) \
.findall('sapo:Program', ns):
sapo_id = program.find('sapo:Id', ns).text
sapo_title = program.find('sapo:Title', ns).text
sapo_title = sapo_title.replace('(V.O.)', '').replace('(V.P.)',
'').strip()
sapo_description = program.find('sapo:Description', ns).text
if _validate_movie(sapo_title):
# Check if movie is saved under other movie entry
movie = _resolve_movie(sapo_id, sapo_title, sapo_description)
# Movie was successfully resolved
if movie is not None:
sapo_id = movie.sapo_id
# Adding id alias
if movie.sapo_id != sapo_id and sapo_id not in movie.alias_ids:
movie.alias_ids.append(sapo_id)
updates.append(movie)
# Adding title alias
if movie.sapo_title != sapo_title and sapo_title not in movie.alias_titles:
movie.alias_titles.append(sapo_title)
updates.append(movie)
# Movie already in the list of movies to be added
elif any(m.sapo_id == sapo_id for m in movies):
pass
# Getting alias_ids for movies not yet in persisted
elif any(sapo_title.lower() == m.sapo_title.lower()
for m in movies):
movie = next(m for m in movies
if sapo_title.lower() == m.sapo_title.lower())
movie.alias_ids.append(sapo_id)
# Otherwise add new one
else:
movie = Movie()
movie.sapo_id = sapo_id
movie.sapo_title = sapo_title
movie.sapo_description = sapo_description
movies.append(movie)
schedule = Schedule()
schedule.sapo_id = sapo_id
schedule.sapo_channel = root \
.find('sapo:GetChannelByDateIntervalResult', ns) \
.find('sapo:Sigla', ns).text
schedule.sapo_start_datetime = datetime.datetime.strptime(
program.find('sapo:StartTime', ns).text, '%Y-%m-%d %H:%M:%S')
schedule.sapo_end_datetime = datetime.datetime.strptime(
program.find('sapo:EndTime', ns).text, '%Y-%m-%d %H:%M:%S')
schedule.sapo_duration = program.find('sapo:Duration', ns).text
schedules.append(schedule)
return movies, schedules, updates
def post(self):
data = json.loads(self.request.body)
name, phone, email = map(data['info'].get, ('name', 'phone', 'email'))
phone = '7' + ''.join(c for c in phone if '0' <= c <= '9')
namespace = self._find_namespace(name)
password = "******" % random.randint(0, 10000)
CompanyUser.create_user(namespace,
namespace=namespace,
password_raw=password,
login=namespace,
rights=CompanyUser.RIGHTS_MASK_ADMIN)
namespace_manager.set_namespace(namespace)
cfg = Config(id=1)
cfg.APP_NAME = name
cfg.DELIVERY_PHONES = [phone]
cfg.DELIVERY_EMAILS = ['*****@*****.**', email]
cfg.SUPPORT_EMAILS = [email]
cfg.ACTION_COLOR = "FF25B8CD"
cfg.put()
delivery_slot_keys = [
DeliverySlot(name=u'Сейчас', slot_type=0, value=0).put(),
DeliverySlot(name=u'Через 5 минут', slot_type=0, value=5).put(),
DeliverySlot(name=u'Через 10 минут', slot_type=0, value=10).put(),
DeliverySlot(name=u'Через 15 минут', slot_type=0, value=15).put(),
DeliverySlot(name=u'Через 20 минут', slot_type=0, value=20).put(),
DeliverySlot(name=u'Через 25 минут', slot_type=0, value=25).put(),
DeliverySlot(name=u'Через 30 минут', slot_type=0, value=30).put()
]
menu = data['menu']
init = MenuCategory(category=None, title="Init")
init.put()
for i, category_dict in enumerate(menu):
MenuCategory.generate_category_sequence_number(
) # only to increase counter
category = MenuCategory(title=category_dict["title"],
sequence_number=i,
category=init.key)
category.put()
for j, item in enumerate(category_dict["items"]):
MenuItem(category=category.key,
title=item["title"],
description=item["description"],
picture=item["imageUrl"],
price=int(round(float(item["price"]) * 100)),
sequence_number=j).put()
for _ in category.get_items():
category.generate_sequence_number() # only to increase counter
venue_dict = data['venue']
venue = Venue(title=venue_dict['title'],
description=venue_dict['address'],
coordinates=ndb.GeoPt(venue_dict['lat'],
venue_dict['lng']),
active=True)
venue.update_address()
venue.schedule = Schedule(days=[
DaySchedule(
weekday=i, start=datetime.time(0, 0), end=datetime.time(0, 0))
for i in xrange(1, 8)
])
for delivery_type in (SELF, IN_CAFE):
delivery = DeliveryType.create(delivery_type)
delivery.put()
delivery.status = STATUS_AVAILABLE
delivery.max_time = DAY_SECONDS + HOUR_SECONDS # need hour to order on tomorrow
delivery.delivery_slots = delivery_slot_keys
venue.delivery_types.append(delivery)
venue.put()
PaymentType(id=str(CASH_PAYMENT_TYPE),
title="cash",
status=STATUS_AVAILABLE).put()
deferred.defer(_notify_sms, phone, namespace, password)
deferred.defer(_notify_email, email, phone, name, namespace, password)
self.render_json({'login': namespace, 'password': password})
# if 'duration' in schedule_json:
# sapo_duration = schedule_json['duration']
#
# if not sapo_duration:
# raise Exception('Invalid option')
# else:
# if 'duration' in schedule_json:
# db.schedule.update({'_id': schedule._id}, {'$unset': {'duration': ""}})
# # print(sapo_start_datetime)
# # print(sapo_end_datetime)
# # print(sapo_duration)
# db.schedule.update({'_id': schedule._id}, {'$set': {'sapo_start_datetime': sapo_start_datetime}})
# db.schedule.update({'_id': schedule._id}, {'$set': {'sapo_end_datetime': sapo_end_datetime}})
# db.schedule.update({'_id': schedule._id}, {'$set': {'sapo_duration': sapo_duration}})
schedule = Schedule()
schedule.sapo_id = '123'
schedule.sapo_channel = 'ABC'
schedule.sapo_start_datetime = datetime.datetime.now()
schedule.sapo_end_datetime = datetime.datetime.now()
schedule.sapo_duration = '12345'
serialized = json_util.loads(json_util.dumps(schedule.__dict__))
print(serialized)
# db.schedule.insert(serialized)
s = Schedule(
json.loads(json_util.dumps(
db.schedule.find_one({'sapo_id': schedule.sapo_id})),
object_hook=json_util.object_hook))
print(
ms.exists_schedule_in_db(s.sapo_id, s.sapo_channel,
def setUp(self):
self.schedule = Schedule(datetime.date(2021, 3, 21), 45)
"""Printing image"""
file = io.BytesIO(urllib.request.urlopen(uri).read())
image = Image.open(file)
image.show()
im.detect_web_uri(uri)
if __name__ == '__main__':
unresolved_movies_json = json.loads(dumps(ms.get_all_unresolved_movies()))
# Solving each unresolved movie
for unresolved_movie_json in unresolved_movies_json:
unresolved_movie = Movie(
unresolved_movie_json) # Getting object from json
schedule = Schedule(
json.loads(dumps(ms.get_channel_movie(unresolved_movie.sapo_id))))
print('\n')
print('*** {} *** [{}]'.format(unresolved_movie.sapo_id,
schedule.sapo_channel))
print('Movie sapo title: {}'.format(unresolved_movie.sapo_title))
print('Movie sapo description: {}'.format(
unresolved_movie.sapo_description))
print('* Choose one of the following candidates *')
img_uri = CONFIG.SAPO_IMAGE.format(unresolved_movie.sapo_id)
_print_img(img_uri) # Printing movie image
success_google_vision, annotations = im.detect_web_uri(
img_uri) # Getting nnotation from Google Vision API
# Electing the right candidate
