def create_request(): """ Create new request for logged in user """ auth_header = request.headers["Authorization"] # get authorization header token = auth_header.split(" ")[1] # split header to obtain token if token: user = User.decode_token(token) # check if user is a string if not isinstance(user, str): if request.json and request.json.get('title') and \ request.json.get('description') and request.json.get('location'): title = request.json.get('title') description = request.json.get('description') location = request.json.get('location') req = Request( title=title, description=description, location=location, created_by=user["id"] ) req.save() return make_response(jsonify({ "title": req.title, "description": req.description, "location": req.location, "created_by": req.created_by })), 201 return make_response(jsonify({ "message": "Please provide the title, description, and location of your request." })), 400 return make_response(jsonify({"message": str(user)})), 401 return make_response(jsonify({"message": "Invalid request"})), 500
def decline_request(update: Update, context: CallbackContext): tel_to = update.callback_query.message.chat.id tel_id = active_requests.get(tel_to, None) if tel_id: tel_id = tel_id[0] del active_requests[tel_to] del active_requests[tel_id] delete_msg(tel_id, context) delete_msg(tel_to, context) active_commands[tel_id] = context.bot.send_message( text=f'``` Request Cancelled ```', parse_mode=ParseMode.MARKDOWN, chat_id=tel_id).message_id active_commands[tel_to] = context.bot.send_message( text=f'``` Request Cancelled ```', parse_mode=ParseMode.MARKDOWN, chat_id=tel_to).message_id Db.get_instance().update_user_disconnected(tel_id) Db.get_instance().update_user_disconnected(tel_to) req = Request() req.make(tel_id, tel_to, 2) Db.get_instance().update_request(req) else: delete_msg(tel_to, context) active_commands[tel_to] = context.bot.send_message( text=f'``` Expired Request ```', parse_mode=ParseMode.MARKDOWN, chat_id=tel_to).message_id
def accept_request(update: Update, context: CallbackContext): tel_to = update.callback_query.message.chat.id tel_id = active_requests.get(tel_to, None) if tel_id: tel_id = tel_id[0] active_chats[tel_id] = active_requests[tel_id][0] active_chats[active_chats[tel_id]] = tel_id del active_requests[tel_id] del active_requests[active_chats[tel_id]] delete_msg(tel_id, context) delete_msg(tel_to, context) active_commands[tel_id] = context.bot.send_message( text=f'``` Request Accepted ```', parse_mode=ParseMode.MARKDOWN, chat_id=tel_id).message_id context.bot.send_message( text= f'``` The Messages Now on (except Commands will be visible to the Anonymous ' f'person) ```', parse_mode=ParseMode.MARKDOWN, chat_id=tel_id) context.bot.send_message( text= f'``` The Messages Now on (except Commands will be visible to the Anonymous ' f'person) ```', parse_mode=ParseMode.MARKDOWN, chat_id=tel_to) res = Db.get_instance().get_common_interests(tel_id, tel_to) data = [INTEREST_LIST[x] for x in res[0].intersection(res[1])] if len(data) != 0: context.bot.send_message( text=f'``` Common Interest {" ".join(data)}```', parse_mode=ParseMode.MARKDOWN, chat_id=tel_id) context.bot.send_message( text=f'``` Common Interest {" ".join(data)} ```', parse_mode=ParseMode.MARKDOWN, chat_id=tel_to) else: context.bot.send_message( text= f'``` Interests the Anonymous User have:- {" ".join([INTEREST_LIST[i] for i in res[1]])}```', parse_mode=ParseMode.MARKDOWN, chat_id=tel_id) context.bot.send_message( text= f'``` Interests the Anonymous User have:- {" ".join([INTEREST_LIST[i] for i in res[0]])} ```', parse_mode=ParseMode.MARKDOWN, chat_id=tel_to) req = Request() req.make(tel_id, tel_to, 3) Db.get_instance().update_request(req) else: delete_msg(tel_to, context) active_commands[tel_to] = context.bot.send_message( text=f'``` Expired Request ```', parse_mode=ParseMode.MARKDOWN, chat_id=tel_to).message_id
def read_request_id(self, tel_id: int) -> Request: self.c.execute("""SELECT * FROM requests WHERE id=? OR to_id=?""", (tel_id, tel_id)) data = self.c.fetchone() if data: request = Request() request.make(data[0], data[1], data[2]) return request return data
def read_requests(self): self.c.execute("""SELECT * FROM requests""") requests = [] for request in self.c.fetchall(): new_request = Request() new_request.make(request[0], request[1], request[2]) requests.append(new_request) for request in requests: print(request.tel_to)
def teacher_request(): form = forms.RequestForm() form.goals.choices = [(i.key, i.name) for i in Goal.query.all()] if request.method == 'POST': if form.validate_on_submit(): form.goals.data = Goal.query.filter( Goal.key == form.data['goals']).first() Request.add(**form.data).commit() return render_template('request_done.html', form=form) return render_template('request.html', form=form)
def get_values(self, data): try: arr = data.split("\r\n") method, query, protocol = self.method_query_protocol(arr[0]) url = self.url(query) connection = self.get_connection() except BaseException as e: self._log.debug('parsing exc: {}'.format(e)) return Request("unknown", "unknown", "unknown", "unknown") return Request(method, protocol, url, connection)
def complete_ride(request_id): """ Marks a ride request as completed. :param request_id: :return: """ print "Going to mark the ride with request id {request_id} as COMPLETED".format(request_id=request_id) updated_args = { "req_status": ReqStatus.COMPLETED, "completed_at": datetime.utcnow() } Request.filter_and_update(filter_args={"id": request_id}, updated_args=updated_args)
def get_values(data): arr = data.split(b'\n') values = arr[0].split() method = values[0] query = values[1].split(b'?')[0] protocol = values[2] return Request(method, protocol, query, get_connection())
def main(): try: url = sys.argv[1] except IndexError: url = 'http://ogp.me/' page_html = Request(url).get_page_html() if page_html[:9] == 'HTTPError': res = json.dumps({ 'STATUS': 'ERROR', 'MSG': "bad url request error, page not found", "CATEGORIES": page_html, 'CODE': "404" }) print(res) return res page_bsoup = BSoup(page_html).return_bSoup_object_from_page_html() res = ResponseBuilder(OpenGraph(page_bsoup)).get_response_object_in_json() if res == '{}': res = json.dumps({ 'STATUS': 'ERROR', 'MSG': "No open graph meta was found for the given url", "CATEGORIES": "no open graph meta tags", 'CODE': "404" }) print(res) return res
def get_requests(): """ :return: All ```request(s)``` in json format. """ from models.request import Request requests = Request.all() return map(lambda r: r.as_dict(), requests)
def serve_request(driver_id, request_id): """ Responsible for serving a request(If not served in past, i.e. waiting request) from driver app. And schedule a completion job for this request, at ```now + RIDE_COMPLETION_DURATION_IN_SEC``` :param driver_id: :param request_id: :return: status & message """ from services.taxi_scheduler import schedule from taxi import app try: updated_args = { "req_status": ReqStatus.ONGOING, "driver_id": driver_id, "picked_up": datetime.utcnow() } request = Request.filter_and_update(filter_args={"id": request_id, "req_status": ReqStatus.WAITING}, updated_args=updated_args) if request: schedule(app.config['RIDE_COMPLETION_DURATION_IN_SEC'], complete_ride, (request_id,)) else: res = {"status": "warning", "message": "No such request found or request may already be selected/served."} return res except Exception as e: print e res = {"status": "error", "message": "Couldn't serve request."} return res res = { "status": "success", "message": "Accepted request successfully." } return res
def post(self): args = CreateRequest.parser.parse_args() request = Request(user_email=args.get('user_email'), quantity=args.get('quantity'), urgency=args.get('urgency'), item=args.get('item'), is_surplus=args.get('is_surplus')) session.add(request) session.commit() return {'response': 'success'}
def parse(self, data: str) -> Optional[Request]: method = self._parse_method(data) protocol = self._parse_protocol(data) url = self._parse_url(data) params = self._parse_params(data) headers = self._parse_headers(data) return Request(method=method, protocol=protocol, url=url, params=params, headers=headers)
def cancel_chat(update: Update, context: CallbackContext): tel_id = active_chats.get(update.callback_query.message.chat.id, None) if tel_id: Db.get_instance().update_user_disconnected(tel_id) Db.get_instance().update_user_disconnected(active_chats[tel_id]) req = Request() req.make(tel_id, active_chats[tel_id], 1) Db.get_instance().update_request(req) req.make(active_chats[tel_id], tel_id, 1) Db.get_instance().update_request(req) delete_msg(tel_id, context) delete_msg(active_chats[tel_id], context) active_commands[tel_id] = context.bot.send_message( text=f'``` Chat Cancelled ```', parse_mode=ParseMode.MARKDOWN, chat_id=tel_id).message_id active_commands[active_chats[tel_id]] = context.bot.send_message( text=f'``` Chat Cancelled ```', parse_mode=ParseMode.MARKDOWN, chat_id=active_chats[tel_id]).message_id context.bot.send_message(text="/chat for chat settings", parse_mode=ParseMode.MARKDOWN, chat_id=active_chats[tel_id]) context.bot.send_message(text="/chat for chat settings", parse_mode=ParseMode.MARKDOWN, chat_id=tel_id) del active_chats[active_chats[tel_id]] del active_chats[tel_id]
def open_connection(socket, client_conn, data, router): request = None try: payload = json.loads(data) request = Request(**payload) request.connection = client_conn try: response = router.resolve(request) if response != None: socket.sendto(response.encode(), client_conn) except Exception as e: print(e) socket.sendto( Response(code=codes.INTERNAL_ERROR, body="Internal error").encode(), client_conn) except Exception as e: print(e) socket.sendto( Response(code=codes.BAD_REQUEST, body="Invalid request").encode(), client_conn)
def get_requests_by_status(status=ReqStatus.WAITING,driver_id=None): """ Filters request(s) on the basis of ```req_status``` & ```driver_id``` :param status: :param driver_id: :return: Filtered request(s) """ filter_criteria = { "req_status": status } if driver_id is not None: filter_criteria['driver_id'] = driver_id requests = Request.filter(filter_criteria) return map(lambda r: r.as_dict(), requests)
def catch_all(path): path = "/" + path c = db_session.query(Client).filter( Client.ip == request.remote_addr).first() if c is None: c = Client(ip=request.remote_addr) db_session.add(c) r = Request(route=path, time=datetime.datetime.now(), post_data=request.get_data(), headers=request.headers, client=c, method=request.method) db_session.add(r) db_session.commit() return "", 200
def ride(customer_id): """ Responsible for creating a new ride request from customer app. :param customer_id: :return: """ try: Request(customer_id).create() except Exception as e: print e res = {"status": "error", "message": "Couldn't submit request for this ride."} return res res = { "status": "success", "message": "Request for the ride has been submitted successfully." } return res
async def handle(self, reader, writer): data = b'' while True: chunk = await reader.read(CHUNK_SIZE) data += chunk if not data or reader.at_eof() or data[-4:] == b'\r\n\r\n': break if len(data) > 0: request = Request(data) response_data = await self.executor.execute(request) response = await self.serializer.dump(response_data) writer.write(response) await writer.drain() writer.close()
def load_empresa(self): selected_emp = str(self.select_empresa.currentText()) if selected_emp not in '': self.empresa = self.empresas.get(selected_emp) reqs = Request.get_by_empresa_id(self.empresa.id) self.tbl_request.setRowCount(len(reqs)) for i, r in enumerate(reqs): self.tbl_request.setItem(i, 0, QTableWidgetItem(str(r.name))) self.tbl_request.setItem(i, 1, QTableWidgetItem(str(r.init_date))) self.tbl_request.setItem(i, 2, QTableWidgetItem(str(r.end_date))) self.tbl_request.setItem(i, 3, QTableWidgetItem(str(r.state))) self.tbl_request.setItem( i, 4, QTableWidgetItem(str(r.numero_cfdis or '-'))) self.tbl_request.setItem( i, 5, QTableWidgetItem(str(r.estado_solicitud or '-'))) self.tbl_request.setItem( i, 6, QTableWidgetItem(str(r.mensaje or '-'))) self.tbl_request.setItem(i, 7, QTableWidgetItem(str(r.id))) if len(Fiel.get_by_empresa_id(self.empresa.id)) > 0: self.btn_add_request.setEnabled(True) self.tbl_request.itemClicked.connect(self.activate_request_buttons)
def post(self, eventId, guardianId): '''The visitor is not an authenticated guardian''' if not SubscriptionLoginHandler.isAuthenticatedGuardian(): self.redirect('/inschrijven/') return '''The guardian is not authorized to the given''' if not self.isAuthorized(eventId, guardianId): SubscriptionLoginHandler.redirectToSubscriptionPage(self) return event = Event.get_by_id(int(eventId)) days = Day.gql("WHERE event = :1", event).fetch(999) guardian = Guardian.get_by_key_name(guardianId) students = Student.gql("WHERE guardian = :1", guardian).fetch(999, 0) students_subjects = self.getStudentsSubjects(students) notifications = [] templVal = { 'event': event, 'days': days, 'guardian': guardian, 'students': students_subjects, 'notifications': notifications } if not (event and days and guardian and students): notifications.append('U probeert een onmogelijke bewerking uit te voeren.') self.showError(templVal) return subscriptionDetailsList = SubscriptionDetails.gql("WHERE event = :1 AND guardian = :2", event, guardian).fetch(1, 0) if not subscriptionDetailsList: notifications.append('Pagina niet gevonden.') self.showError(templVal) return subscriptionDetails = subscriptionDetailsList[0] if subscriptionDetails and subscriptionDetails.requested: notifications.append('U kunt geen verzoeken meer indienen.') self.showError(templVal) return studentKeys = [str(k.replace('subject_', '')) for k in self.request.arguments() if re.match("subject_.+", k)] requests = [] dayPrefs = [] for s in students[:]: if str(s.key().name()) not in studentKeys: students.remove(s) if not students: notifications.append('U kunt geen verzoek indienen als u geen enkel vak geselecteerd heeft. ') for student in students[:]: subjectCodes = [c for c in self.request.get_all("subject_" + str(student.key().name()))] subjects = Subject.get_by_key_name(subjectCodes) if len(subjectCodes) > 3: notifications.append('U kunt maximaal 3 vakken per leerling bespreken.') if len(subjectCodes) != len(subjects): notifications.append('U probeert een onmogelijke bewerking uit te voeren.') for subject in subjects: combination = Combination.gql("WHERE class_id = :1 AND subject = :2", student.class_id, subject).fetch(1,0)[0] if not combination: notifications.append('U probeert een onmogelijke bewerking uit te voeren.') self.showError(templVal) return request = Request() request.event = event request.guardian = guardian request.student = student request.combination = combination requests.append(request) '''Process timepreference''' timePref = TimePreference() timePref.event = event timePref.guardian = guardian timePref.preference = 0 if not (self.request.get('time_pref') and (int(self.request.get('time_pref')) in [0,1,2])): notifications.append('U moet een voorkeur voor tijd aangeven.') else: timePref.preference = int(self.request.get('time_pref')) '''Check if dates from the form match the dates from the event ''' dayKeys = [long(k.replace('date_', '')) for k in self.request.arguments() if re.match("date_.+", k)] dayKeysFromStore= [day.key().id() for day in days] daysOk = True for dayKey in dayKeys: if dayKey not in dayKeysFromStore: daysOk = False notifications.append('U probeert een onmogelijke bewerking uit te voeren.') self.showError(templVal) return '''Check if the daypreference are correct filled in''' dayPrefsList = [int(self.request.get(k)) for k in self.request.arguments() if re.match("date_.+", k)] dayPrefsList.sort() dayPrefsOk = True if dayPrefsList != [1,2,3]: dayPrefsOk = False notifications.append('U moet een eerste, een tweede en een derde voorkeur aangeven') '''Process daypreferences''' if daysOk and dayPrefsOk: for day in days: dayPref = DayPreference() dayPref.day = day dayPref.guardian = guardian dayPref.rank = int(self.request.get("date_" + str(day.key().id()))) dayPrefs.append(dayPref) if notifications: path = os.path.join(os.path.dirname(__file__), '../templates/subscription/subscription.html') self.response.out.write(template.render(path, templVal)) return '''Store the requests''' for request in requests: request.put() for dayPref in dayPrefs: dayPref.put() timePref.put() subscriptionDetails.requested = True subscriptionDetails.put() SubscriptionLogoutHandler.logoutGuardian() path = os.path.join(os.path.dirname(__file__), '../templates/subscription/subscription-success.html') self.response.out.write(template.render(path, templVal)) return
def get(self, arg): event = Event.get_by_id(int(arg)) notifications = [] if not event: notifications.append("De bewerking kon niet worden voltooid omdat het event niet bestaat.") events = Event.all() path = os.path.join(os.path.dirname(__file__), '../templates/administration/event-list.html') template_values = {'events': events, 'logoutlink': users.create_logout_url("/") , 'notifications': notifications } self.response.out.write(template.render(path, template_values)) return requests = event.requests.fetch(9999) guardians_keys = [] for request in requests: if request.guardian.key().name() not in guardians_keys: guardians_keys.append(request.guardian.key().name()) if not guardians_keys: notifications.append("Er zijn geen voogden met verzoeken") events = Event.all() path = os.path.join(os.path.dirname(__file__), '../templates/administration/event-list.html') template_values = {'events': events, 'logoutlink': users.create_logout_url("/") , 'notifications': notifications } self.response.out.write(template.render(path, template_values)) return for guardian_num, guardian_key in enumerate(guardians_keys): guardian = Guardian.get_by_key_name(guardian_key) guardian_requests = Request.gql("WHERE guardian = :1 AND event = :2", guardian, event).fetch(999) guardian_appointments = [guardian_request.appointment.get() for guardian_request in guardian_requests if guardian_request.appointment.get()] day_ids = [appointment.day.key().id() for appointment in guardian_appointments if appointment] day_ids = list(set(day_ids)) if not guardian_appointments: continue mail = Email() message = 'Beste ' + guardian.title if not guardian.preposition == '': message += ' ' + guardian.preposition message += ' ' + guardian.lastname + ',\n\n' message += 'Er zijn afspraken ingepland voor de ouderavond(en) van het ' + event.event_name + ". " message += 'Hieronder vind u de afspraken die voor u zijn gemaakt:\n\n' for day_id in day_ids: day = Day.get_by_id(day_id) message += 'Op ' + str(day.date.day) + ' ' + AdministrationInviteGuardiansHandler.getMonthText(self, day.date.month) + ' ' + str(day.date.year) + ':\n' for appointment in guardian_appointments: if appointment.day.key().id() == day_id: student = appointment.request.student m = event.talk_time * appointment.slot d = timedelta(minutes=m) time = day.date + d message += 'Tijd: ' + str(time.hour) + ':' + str(time.minute) + '\n' message += 'Tafel: ' + str(appointment.table) + '\n' message += 'Leerling: ' + student.firstname + ' ' + student.preposition + ' ' + student.lastname + '\n' message += 'Vak: ' + appointment.request.combination.subject.name + '\n' message += 'Docent: ' + appointment.request.combination.teacher.name + '\n' message += 'Docentcode: ' + appointment.request.combination.teacher.key().name() + '\n\n' # mail.sendMail(guardian.email, 'Afspraken ouderavond(en) ' + event.event_name, message) if guardian_num == 0: print message return
def set_up_random_chat(update: Update, context: CallbackContext) -> None: data = status_code(update.callback_query.message.chat_id) if data == 1: context.bot.send_message( text=f'``` Close the current chat portal to start a new one ```', parse_mode=ParseMode.MARKDOWN, chat_id=update.callback_query.message.chat.id, ) return if data == 0: data = active_requests.get(update.callback_query.message.chat.id, None) delete_msg(update.callback_query.message.chat_id, context) print(data) if data[1] == 1: keyboard = [[ InlineKeyboardButton( "CANCEL REQUEST", callback_data=CANCEL_REQUEST_CALLBACK_DATA) ]] msg_id = context.bot.send_message( update.callback_query.message.chat.id, """``` You are in request phase Waiting for Accepting```""", parse_mode=ParseMode.MARKDOWN, reply_markup=InlineKeyboardMarkup(keyboard)).message_id active_commands[update.callback_query.message.chat.id] = msg_id elif data[1] == -1: keyboard = [ [ InlineKeyboardButton("ACCEPT", callback_data=ACCEPT_CALLBACK_DATA), InlineKeyboardButton("DECLINE", callback_data=DECLINE_CALLBACK_DATA), ], ] msg_id = context.bot.send_message( update.callback_query.message.chat.id, """``` You are in request phase```""", parse_mode=ParseMode.MARKDOWN, reply_markup=InlineKeyboardMarkup(keyboard)).message_id active_commands[update.callback_query.message.chat.id] = msg_id return data = Db.get_instance().read_available_users( update.callback_query.message.chat.id) if len(data) == 0: context.bot.send_message( text=f'``` Oops! No Users Available try after some time ```', parse_mode=ParseMode.MARKDOWN, chat_id=update.callback_query.message.chat.id, ) else: user = sample(data, 1)[0] request = Request() request.make(update.callback_query.message.chat.id, user.tel_id, 0) Db.get_instance().write_request(request) active_requests[request.tel_id] = (request.tel_to, 1) active_requests[request.tel_to] = (request.tel_id, -1) delete_msg(request.tel_id, context) keyboard = [[ InlineKeyboardButton("CANCEL REQUEST", callback_data=CANCEL_REQUEST_CALLBACK_DATA) ]] active_commands[request.tel_id] = context.bot.send_message( text=f'``` Waiting for Confirmation ```', parse_mode=ParseMode.MARKDOWN, chat_id=request.tel_id, reply_markup=InlineKeyboardMarkup(keyboard)).message_id keyboard = [ [ InlineKeyboardButton("ACCEPT", callback_data=ACCEPT_CALLBACK_DATA), InlineKeyboardButton("DECLINE", callback_data=DECLINE_CALLBACK_DATA), ], ] delete_msg(request.tel_to, context) active_commands[request.tel_to] = context.bot.send_message( text=f'``` Anonymous Chat Request ```', parse_mode=ParseMode.MARKDOWN, chat_id=request.tel_to, reply_markup=InlineKeyboardMarkup(keyboard)).message_id Db.get_instance().update_user_connected(request.tel_id) Db.get_instance().update_user_connected(request.tel_to)
def _row_to_request(self, row): request = Request() request.id = row[0] request.kind_premises = row[1] request.post_code = row[2] request.region = row[3] request.city_type = row[4] request.city = row[5] request.street_type = row[6] request.street = row[7] request.house = row[8] request.block = row[9] request.flat = row[10] request.adress = row[11] request.try_num = row[12] return request
def get_selected_request(self): id_req = self.tbl_request.item(self.tbl_request.currentRow(), 7).text() return Request.find_by_id(id_req)
time.guardian = guardian time.preference = random.randint(0, 2) time.save() days = event.days.fetch(999) random.shuffle(days) for i, day in enumerate(days): day_pref = DayPreference() day_pref.guardian = guardian day_pref.day = day day_pref.rank = i day_pref.save() for child in guardian.children: subjects = Combination.all().filter('class_id', child.class_id).fetch(999) selection = random.sample(subjects, int(random.triangular(0, 4, 0))) for choice in selection: request = Request() request.event = event request.guardian = guardian request.student = child request.combination = choice request.save() class DisplayRequestsHandler(webapp.RequestHandler): def get(self): path = os.path.join(os.path.dirname(__file__), 'templates/requests.html') template_values = { 'event': Event.all().filter('event_name', 'paasrapport').fetch(1), 'guardians': Guardian.all().fetch(9999) }
def get(self): print "" print "<html><body style='font-family: Helvetica; font-size: 0.9em;'>" print time.strftime("%H:%M:%S", time.localtime()) + ": Start<br>" logging.info("Fetching all info") # if arg != None: # event = Event.get_by_id(int(arg)) # else: event = Event.all().filter("event_name", "paasrapport").get() days = Day.all().filter("event", event).fetch(999) days.sort(key=lambda day: day.date) max_requests = 0 max_timepref = 0 max_rank = 0 allguardians = Guardian.all().fetch(9999) guardians = [] requests = [] for guardian in allguardians: requests = Request.all().filter("guardian", guardian).filter("event", event).fetch(999) if len(requests) > 0: max_requests = max([max_requests, len(requests)]) guardian.requests = requests guardian.day_prefs = [] for day in days: guardian.day_prefs.append(DayPreference.all().filter("guardian", guardian).filter("day", day).get()) guardian.day_prefs.sort(key=lambda day: day.rank) max_rank = max([max_rank, max([day.rank for day in guardian.day_prefs])]) guardian.time_pref = TimePreference.all().filter("guardian", guardian).filter("event", event).get() max_timepref = max([max_timepref, guardian.time_pref.preference]) if len(requests) > 5: guardianCopy = copy.deepcopy(guardian) guardian.requests = guardian.requests[: int(len(requests) / 2)] guardianCopy.requests = guardianCopy.requests[int(len(requests) / 2) :] guardianCopy.day_prefs[0].rank = 999 guardians.append(guardianCopy) guardians.append(guardian) timepref_options = range(max_timepref + 1) timepref_options = [1, 2, 0] planning = Planning(event, days) logging.info("All guardians/requests collected") for length in range(max_requests, 0, -1): for timepref in timepref_options: for rank in range(0, max_rank + 1): for day_num, day in enumerate(days): for guardian in filter( lambda guardian: (len(guardian.requests) == length) and (guardian.time_pref.preference == timepref) and ( filter(lambda day_pref: day_pref.day.date == day.date, guardian.day_prefs)[0].rank == rank ), guardians, ): # try to place these requests placed = planning.place(guardian, day_num) # on succes, remove guardian from guardian # on fail, the guardian will return on a less preferable round if placed: guardians.remove(guardian) logging.info("Placed") for dayIndex, day in enumerate(planning.days): start = time.clock() lowestValue = 0 for i, slot in enumerate(day[0]): lowestValue += len(planning.conflictedTeachers(day, i)) logging.info("conflicts: " + str(lowestValue)) # <--- Build a list of all regions logging.info("Building regions") regions = [] for tableIndex, table in enumerate(day): region = [tableIndex, 0, -1] previousGuardian = "" for slotIndex, slot in enumerate(table): guardianId = planning.getGuardianIdFromRequest(slot) block = table[region[1] : region[2] + 1] if guardianId == "": if len(block) == 0: region = [tableIndex, slotIndex, slotIndex] elif block.count(None) == 0: if previousGuardian != "": region[2] = slotIndex regions.append(region) region = [tableIndex, 0, -1] elif block.count(None) > 0: if len(block) > block.count(None): regions.append(region) region = [tableIndex, slotIndex, slotIndex] previousGuardian = "" else: if guardianId != previousGuardian and previousGuardian != "": regions.append(region) region = [tableIndex, slotIndex, slotIndex] region[2] = slotIndex previousGuardian = guardianId block = table[region[1] : region[2] + 1] if len(block) > block.count(None) > 0: regions.append(region) logging.info("Regions built") permutationSets = {} preconflicts = 0 pre_max_conflicts = 0 for i, slot in enumerate(day[0]): slotConflicts = len(planning.conflictedTeachers(day, i)) pre_max_conflicts = max([pre_max_conflicts, slotConflicts]) preconflicts += slotConflicts logging.info("Starting conflicts: " + str(preconflicts)) logging.info("Starting max slotconflicts: " + str(pre_max_conflicts)) for set in regions: block = day[set[0]][set[1] : set[2] + 1] block.sort(key=lambda x: planning.getTeacherStringFromRequest(x)) day[set[0]][set[1] : (set[2] + 1)] = block sortedconflicts = 0 sorted_max_conflicts = 0 for i, slot in enumerate(day[0]): slotConflicts = len(planning.conflictedTeachers(day, i)) sorted_max_conflicts = max([sorted_max_conflicts, slotConflicts]) sortedconflicts += slotConflicts logging.info("Conflicts after sorting: " + str(sortedconflicts)) logging.info("Max slotconflicts after sorting: " + str(sorted_max_conflicts)) conflicts = 9999 max_conflicts = 9999 while ( conflicts >= preconflicts and conflicts >= sortedconflicts and max_conflicts >= pre_max_conflicts and max_conflicts >= sorted_max_conflicts ): for set in regions: block = day[set[0]][set[1] : set[2] + 1] random.shuffle(block) day[set[0]][set[1] : (set[2] + 1)] = block conflicts = 0 max_conflicts = 0 for i, slot in enumerate(day[0]): slotConflicts = len(planning.conflictedTeachers(day, i)) max_conflicts = max([max_conflicts, slotConflicts]) conflicts += slotConflicts logging.info("Conflicts after shuffling: " + str(conflicts)) logging.info("Max slotconflicts after shuffling: " + str(max_conflicts)) # <--- Cycle through conflicted regions loop = 0 while lowestValue > 0: logging.info("Dropping non-conflicted regions") conflictedRegions = [ region for region in regions if planning.numberOfConflictsPerRegion(day, region) > 0 and (region[2] - region[1]) < 7 ] logging.info("Sorting regions to start with smallest region with highest number of conflicts") conflictedRegions.sort( key=lambda set: (set[2] - set[1], -planning.numberOfConflictsPerRegion(day, set)) ) logging.info(str(conflictedRegions)) loop += 2 if loop > len(conflictedRegions): loop = len(conflictedRegions) for set in conflictedRegions[:loop]: logging.info("Working on set: " + str(set)) logging.info("Set size: " + str(set[2] - set[1] + 1)) # logging.info("Number of conflicts in region: "+str(planning.numberOfConflictsPerRegion(day, set))) if planning.numberOfConflictsPerRegion(day, set) <= 0: logging.info("Already fixed; moving on...") continue if not tuple(set) in permutationSets: # logging.info("This set is new to the dictionary") block = day[set[0]][set[1] : set[2] + 1] permutations = itertools.permutations(block) permutations = list(permutations) permutationSets[tuple(set)] = permutations else: # logging.info("This set was already in the dictionary") permutations = permutationSets[tuple(set)] conflictCounter = [] for permIndex, perm in enumerate(permutations): block = day[set[0]][set[1] : (set[2] + 1)] day[set[0]][set[1] : (set[2] + 1)] = perm conflicts = 0 for i, slot in enumerate(day[0]): conflicts += len(planning.conflictedTeachers(day, i)) conflictCounter.append(conflicts) lowestValue = min(conflictCounter) bestOptions = [enum for enum, x in enumerate(conflictCounter) if x == lowestValue] bestOption = random.choice(bestOptions) newList = permutations[bestOption] day[set[0]][set[1] : set[2] + 1] = newList logging.info("Total conflicts: " + str(lowestValue)) if lowestValue == 0: break if lowestValue == 0: break if time.clock() - start > 600: break planning.outputHTML() for dayIndex, day in enumerate(planning.days): for tableIndex, table in enumerate(day): for slotIndex, slot in enumerate(table): if slot != None: new_appointment = Appointment( request=slot, day=days[dayIndex], table=tableIndex, slot=slotIndex ) new_appointment.put()
def __call__(self, inputs): # prepare analyses analyses = [WebGL()] group_analyses = [Mean(), WebGLGroup()] # render render = Render() # parse request Logger.info("Parsing request arguments ... [@performance]") begin_time = time.time() req = Request(**inputs) Logger.info("Parsing request arguments finished, time cost: " + str(time.time() - begin_time) + "s [@performance]") # get the corresponding subjects subjects = getattr(Subjects, req.semantic_model) # do computation and analyses for each contrast output = [] for contrast in req.contrasts: # create tasks tasks = [ Task(req.name, sub, contrast, analyses) for sub in subjects ] # parallely compute individuals ret = parallelize_tasks(tasks) # run in sequence # import time # ret = [] # t_begin = time.time() # for t in tasks: # begin = time.time() # ret.append(t.run()) # log_info = 'In sequence each task finishes in {0} seconds'.format(time.time() - begin) # Logger.debug(log_info) # log_info = 'In sequence all the tasks finished in {0} seconds'.format(time.time() - t_begin) # collect results sub_res, data = zip(*ret) sub_res = { sub.name: {k: v for i in res for k, v in i.serialize().items()} for res, sub in zip(sub_res, subjects) } # execute group evaluation next_data = {'contrast_results': data} grp_res = {} for ga in group_analyses: begin_time = time.time() res = ga(req.name, subjects, contrast, **next_data) Logger.info( "Executing group analysis {0} costs {1} s [@performance]". format(clsname(ga), str(time.time() - begin_time))) if isinstance(res, Serializable): grp_res.update(res.serialize()) elif isinstance(res, dict): next_data.update(res) output.append(render.render(contrast, grp_res, sub_res)) ret = json.dumps(output) Logger.debug(ret) update_contrast_result(ret) return ret
async def mentors(message): user = await message.get_author() Request.create(user.name, datetime.utcnow(), message.text)
def add_request(self): data = self.get_request_data() req = Request(**data) req.save_to_db()
def xslx_to_db(): wb = load_workbook(filename=cfg.request_xls_file_path) sheet_ranges = wb.get_active_sheet() i = 2 next_str = sheet_ranges[i] while next_str[0].value: r = Request() r.kind_premises = next_str[0].value r.post_code = next_str[1].value r.region = next_str[2].value r.city_type = next_str[3].value r.city = next_str[4].value r.street_type = next_str[5].value r.street = next_str[6].value r.house = next_str[7].value r.block = next_str[8].value r.flat = next_str[9].value r.adress = next_str[10].value db = DB() db.insert(r, 'request') i += 1 next_str = sheet_ranges[i]