def create_doc_from_edu_file(edu_file, annotate_func): with open(edu_file, 'r') as fin: doc_tokens = [] paragraphs = [p.strip() for p in fin.read().split('<P>') if p.strip()] previous_edu_num = 0 for pidx, para in enumerate(paragraphs): sentences = [s.strip() for s in para.split('<S>') if s.strip()] for sidx, sent in enumerate(sentences): edus = [e.strip() + ' ' for e in sent.split('\n') if e.strip()] sent_text = ''.join(edus) annot_re = annotate_func(sent_text)['sentences'][0] sent_tokens = [] for t in annot_re['tokens']: token = Token() token.tidx, token.word, token.lemma, token.pos = t[ 'index'], t['word'], t['lemma'], t['pos'] token.pidx, token.sidx = pidx + 1, sidx edu_text_length = 0 for eidx, edu_text in enumerate(edus): edu_text_length += len(edu_text) if edu_text_length > t['characterOffsetEnd']: token.eduidx = previous_edu_num + eidx + 1 break sent_tokens.append(token) for dep in annot_re['basicDependencies']: dependent_token = sent_tokens[dep['dependent'] - 1] dependent_token.hidx = dep['governor'] dependent_token.dep_label = dep['dep'] doc_tokens += sent_tokens previous_edu_num += len(edus) doc = Doc() doc.init_from_tokens(doc_tokens) return doc
def post(self, request): forget_pwd_form = ForgetPwdForm(request.POST) if forget_pwd_form.is_valid(): email = forget_pwd_form.cleaned_data.get("email") user = UserProfile.objects.get(email=email) token_generator = Token(expires_in=1800) token = token_generator.generate_token({ "email": email, "token_type": "forget_pwd" }) message = EmailMessage(user=user, token=token, send_type="forget_pwd") message.send() return_msg = "已向{}用户发送验证邮件,邮件有效时间为0.5小时,请注意查收。".format(email) return HttpResponse(json.dumps({ 'status': "success", "message": return_msg }), content_type="application/json") else: return HttpResponse(json.dumps({'status': "error_email"}), content_type="application/json")
def token_score(self, token): """ Compute a matching score of a token. :param str token: query word. :rtype: float :returns: Score of the token, higher means better matches dictionary """ if token.word.endswith('-') and token.split == '\n': token = Token(token.word[:-1], '') if ((len(token.get_word()) <= 4 and len(token.get_word()) >= 3 and token.get_word() == token.get_word().upper()) or all(c in SPECIAL for c in token.get_word())): return self.zeta, token score, typo = self.exists(self.trim(token.get_word()), edit_dist=1) if not typo: typo = token.get_word() w = len(token.get_word()) # if score < 1.0: # score *= score # self.density(len(typo)) * score # return (score * ((len(token.get_word()) / 15.0) ** 2 + 0.05), # Token(typo, token.get_split())) return (score * (w * w * self.alpha + w * self.beta + self.gamma), token)
async def mutate(self, info, user_password_input: UserPasswordInput): repository = UserRepository(info.context.get("client_motor")) user = await repository.check_user(login=user_password_input.login, password=user_password_input.password) if not user: raise Exception("Ошибка при авторизации пользователя.") token = Token(repository_user=repository, login=user.meta_info.login) return SignIn(token=token.encode())
def get_id(self, request): "解密获取用户id" token = request.query_params.get("token") obj = Token() result = obj.decryt(token) if result: return result
def get(self): # first check the auth token auth_header = request.headers.get('Authorization') if not auth_header: return "No authorization token", 403 T = Token() identity = T.check(auth_header) if not identity: return "Wrong token", 403 if identity['role'] != 1: return "Not customer", 403 # select all purchased items left outer join ratings sql_1 = """ SELECT purchases.item_id, customer_rating.rating FROM (SELECT item_id FROM order_item, orders WHERE order_item.ord_id = orders.ord_id and user_id = ?) AS purchases LEFT OUTER JOIN customer_rating ON purchases.item_id = customer_rating.item_id AND customer_rating.user_id = ? """ param_1 = (identity['user_id'], identity['user_id']) try: with sqlite3.connect(os.environ.get("DB_FILE")) as conn: conn.row_factory = lambda C, R: { c[0]: R[i] for i, c in enumerate(C.description) } cur = conn.cursor() cur.execute(sql_1, param_1) result = cur.fetchall() if len(result) == 0: return "No purchase records yet", 204 else: # add the item name and photo into it for d in result: sql_2 = "SELECT name FROM item WHERE item_id = {}".format( d['item_id']) sql_3 = "SELECT photo FROM photo WHERE item_id = {} LIMIT 1".format( d['item_id']) cur.execute(sql_2) d['name'] = cur.fetchone()['name'] cur.execute(sql_3) d['photo'] = cur.fetchone()['photo'] return result, 200 except Exception as e: print(e) return "Internal server error", 500
def post(self): # first check the auth token auth_header = request.headers.get('Authorization') if not auth_header: return "No authorization token", 403 T = Token() identity = T.check(auth_header) if not identity: return "Wrong token", 403 # unpack the address data = request.json if not data: return "Malformed request", 400 success, result = unpack( data, "unit_number", "street_number", "street_name", "suburb", "postcode", "state", required=True ) if not success: return "Missing parameter in address", 400 unitnumber, streetnumber, streetname, suburb, postcode, state = result # check all validity success, msg = check_address( unitnumber, streetnumber, streetname, suburb, postcode, state ) if not success: return msg, 400 sql = """INSERT INTO customer_address(user_id, unit_number, street_number, street_name, suburb, state, postcode) VALUES(?, ?, ?, ?, ?, ?, ?) """ values = (identity['user_id'], unitnumber, streetnumber, streetname, suburb, state, postcode) try: with sqlite3.connect(os.environ.get("DB_FILE")) as conn: conn.row_factory = lambda C, R: {c[0]: R[i] for i, c in enumerate(C.description)} cur = conn.cursor() cur.execute(sql, values) new_address_id = cur.lastrowid return {"address_id": new_address_id}, 200 except Exception as e: print(e) return "Internal server error", 500
def perform_create(self, serializer): "保存数据前,额外需要传递的参数" obj = serializer.save(is_staff=0, is_active=0) # 生成激活码 tk_obj = Token() token = tk_obj.encryt(obj.id).decode("utf-8") reciver = obj.email content = settings.CONTENT.format(obj.username, token, token) # celery发送邮件 send_QQmail.delay(settings.SUBJECT, '', settings.SENDER, reciver, content)
def get(self): auth_header = request.headers.get("Authorization") if not auth_header: return "No authorization token", 403 T = Token() identity = T.check(auth_header) if not identity: return "Wrong token", 403 result = get_user_profile(identity['user_id']) return result
def check_admin_token(header): if not header: abort(400, "No authorization token") T = Token() identity = T.check(header) if not identity: abort(403, "Wrong token") if identity['role'] != 0: abort(403, "Only admin can access") return identity
def post(self): if not request.json: return "Malformed request", 400 data = request.json if (not "password" in data) or (not "email" in data): return "Missing email / password", 400 email, password = data['email'], data['password'] # check the database try: with sqlite3.connect(os.environ.get("DB_FILE")) as conn: conn.row_factory = lambda C, R: { c[0]: R[i] for i, c in enumerate(C.description) } cur = conn.cursor() sql = """ SELECT user_id, role, password FROM user WHERE email = ? """ param = (email, ) cur.execute(sql, param) result = cur.fetchone( ) # fetch one: return either a dict or None if not result: return "Invalid email/password", 403 if result['password'] != password: return "Invalid email/password", 403 # generate token T = Token() token = T.generate(user_id=result["user_id"], role=result["role"]) return_value = {'token': token, 'role': result['role']} return return_value, 200 except Exception as e: print(e) return "Internal server error", 500
def create_new_token(self, fingerprint): token = generate_unique_token(self.valid_tokens) date = dt.datetime.now() expire_date = date + dt.timedelta(0, config.access_token_expire_sec) token_data = Token(token, expire_date) self.valid_tokens[fingerprint] = token_data return token_data
def check_admin_identity(): # check token auth = request.headers.get("Authorization") if not auth: return None, "No authorization token", 403 T = Token() identity = T.check(auth) if not identity: return None, "Wrong token", 403 if identity['role'] != 0: return None, "Only admin can edit", 403 return identity, None, None
def _parse_fmerge_line(line): """ Parse one line from *.merge file """ items = line.split("\t") tok = Token() tok.pidx, tok.sidx, tok.tidx = int(items[-1]), int(items[0]), int( items[1]) # Without changing the case tok.word = items[2] try: tok.eduidx = int(items[9]) except ValueError: print("EDU index for {} is missing in fmerge file".format( tok.word)) pass return tok
def get_current_user_db_with_token(token: str): token_dict: dict = Token().decode(token) current_user = crud.get_user_by_id(token_dict['user_id']) if not current_user: raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail=strings.USER_NOT_FOUND) return current_user
def get(self): # check the token first # first check the auth token auth_header = request.headers.get('Authorization') if not auth_header: return "No authorization token", 403 T = Token() identity = T.check(auth_header) if not identity: return "Wrong token", 403 try: with sqlite3.connect(os.environ.get("DB_FILE")) as conn: conn.row_factory = lambda C, R: { c[0]: R[i] for i, c in enumerate(C.description) } cur = conn.cursor() sql_1 = """ SELECT orders.ord_id FROM user, orders WHERE user.user_id = orders.user_id AND user.user_id = ? ORDER BY unix_time DESC """ sql_1_param = (identity["user_id"], ) cur.execute(sql_1, sql_1_param) sql_1_result = cur.fetchall() order_id_list = [e['ord_id'] for e in sql_1_result] if not order_id_list: return "The customer has not made any orders yet", 204 result = [] for ord_id in order_id_list: result.append(get_this_order_history(ord_id)) return result, 200 except Exception as e: print(e) return "Internal server error", 500
def notify(): data = request.get_json(force=True) user = User.find_by_token(Token.encode(data['token'])) if user: line_bot_api.push_message(user.user_id, TextSendMessage(data['message'])) return 'OK'
def verify_token(token): token_dict = Token.auth(token) if token_dict: g.user_id = token_dict.get('user_id') g.car_ip = token_dict.get('car_ip') g.car_port = token_dict.get('car_port') g.token = token return True else: return False
def post(self): # check the token first # first check the auth token auth_header = request.headers.get('Authorization') if not auth_header: return "No authorization token", 403 T = Token() identity = T.check(auth_header) if not identity: return "Wrong token", 403 # check the payload data = request.json if not data: return "Malformed request", 400 # submit cart code, response = submit_order(data, identity) return response, code
def login(med: shemas.MedicLogin): medico:models.Medico = models.Medico.get_or_none( models.Medico.correo == med.correo, models.Medico.clave == med.clave) if not medico: raise HTTPException( status_code=status.HTTP_400_BAD_REQUEST, detail=strings.USER_OR_EMAIL_NOT_FOUND) else: token =Token().encode(user_id=medico.id, user_email=medico.correo) return ServerResponse(msg=strings.LOGGED, token=token)
def get_welcome_message(user_id): user = User.find(user_id) if not user: while True: # 產生 token token = Token.generate() # 沒有重複就使用 if not User.find_by_token(Token.encode(token)): break user = User(user_id=user_id, token=Token.encode(token)) db.session.add(user) db.session.commit() return [ TextSendMessage('Hi, I am Missue Tracker\'s LINE bot.'), TextSendMessage( f'To make you able to receive notifications, please fill the following token into your profile page: {Token.decode(user.token)}' ), ]
def login(): car = g.user.car token = None car_ip_port = '' user_id = g.user.id car_id = '' is_connected = False if car: car_id = car.id car_ip_port = redis_cli.get('car:' + car_id) if not car_ip_port: token = Token(user_id) else: car_ip, car_port = car_ip_port.split(":") token = Token(user_id, car_id, car_ip, car_port) is_connected = True return jsonify({ 'status': 'success', 'data': token.get(), 'ísConnected': is_connected })
def retokenise(self, token): """ Attempt to split a given token into good tokens. :param Token token: The query token :rtype: pair(int, list(Token)) :returns: A pair of the matching score and splitted portions """ # token = self.dictionary.join_tokens(self.tokens[st: st + window]) big_word = token.get_word() # logger.log_full_debug(big_word) F = [NEG_INFINITY for _ in range(len(big_word) + 1)] nx = [idx + 1 for idx in range(len(big_word) + 1)] F[len(big_word)] = 0 for i in reversed(range(len(big_word))): F[i], nx[i] = \ findmax(( ((self.dictionary.token_score(Token(big_word[i:j]))[0] * (j - i) + (len(big_word) - j) * F[j]) / (len(big_word) - i)) for j in range(i + 1, min(len(big_word), i + 25) + 1)), NEG_INFINITY) nx[i] += i + 1 res = [] idx = 0 while idx < len(big_word): _, tok = self.dictionary.token_score( Token(big_word[idx:nx[idx]], ' ')) if nx[idx] >= len(big_word): res.append(Token(tok.get_word(), token.get_split())) # logger.log_full_debug(token) else: res.append(Token(tok.get_word(), ' ')) idx = nx[idx] logger.log_full_debug('retokenized', token, 'into', res) logger.log_full_debug('retokenization score:', F) logger.log_full_debug('retokenization nexts:', nx) # logger.log_full_debug([self.dictionary.token_score(x) for x in res]) return F[0], res
def try_to_fix(self, st, window): """ A dynamic programming algorithm using memoization, that tries to find the best merging of tokens that maximizes the number of correct tokens within a given range. :param int st: Start index of tokens' range without offset :param int en: End index of tokens' range without offset :param int[][] table: The memoization table of the recursion :param int[][] split: The memoization table of the split indices :param int offset: The offset of the range of tokens :rtype: int :returns: The number of maximum correct tokens """ assert window > 0 # if table[st][window] is not None: # return table[st][window][0] joined = self.dictionary.join_tokens(self.tokens[st:st + window]) # return self.retokenise(joined)[0], SPLIT_ENUM score, _ = self.dictionary.token_score(joined) split_whole = False if score < EPS: score, _ = self.retokenise(joined) if score > EPS: split_whole = True if split_whole: split_whole = SPLIT_ENUM else: split_whole = USE_WHOLE_ENUM if logger.is_full_debug(): if Token('-', '\n') in self.tokens[st:st + window]: logger.log_full_debug('from', st + 1, 'to', window, self.tokens[st:st + window], score, split_whole, joined, highlight=2) else: logger.log_full_debug('from', st + 1, 'to', window, self.tokens[st:st + window], score, split_whole, joined, highlight=2) return score, split_whole
def get(self): header = request.headers.get("Authorization") if not header: return "No authorization token", 403 T = Token() identity = T.check(header) if not identity: return "Wrong Token", 403 sql = """ SELECT DISTINCT view_history.item_id FROM view_history LEFT OUTER JOIN item ON view_history.item_id = item.item_id WHERE user_id= ? AND item.status = 1 ORDER BY time DESC LIMIT 8 """ parameter = (identity["user_id"],) try: with sqlite3.connect(os.environ.get("DB_FILE")) as conn: conn.row_factory = lambda C, R: {c[0]: R[i] for i, c in enumerate(C.description)} cur = conn.cursor() r = cur.execute(sql, parameter) result = r.fetchall() if len(result) == 0: return "No content", 204 else: final = get_all_profiles(list(result)) return final, 200 except Exception as e: print(e) return "Internal server error", 500
def update_session(self, refresh_token): db_sess = db_session.create_session() q = db_sess.query(SessionModel) q = q.filter(SessionModel.refresh_token == refresh_token) if not q.all(): return session = q.first() if Token(session.refresh_token, session.expires_at).is_expired(): return db_sess.delete(session) db_sess.commit() new_session = self.create_new(session.user_id, session.fingerprint) db_sess.object_session(new_session).add(new_session) db_sess.object_session(new_session).commit() return new_session
def update_email_name(doctor:shemas.MedicNombreCorreo,token:str): current_user: models.Medico = get_current_user_db_with_token(token) if check_if_email_is_taken(doctor.correo): raise HTTPException( status_code=status.HTTP_400_BAD_REQUEST, detail= strings.USER_ALRRADY_REGISTERED) doctor_updated = crud.update_email_name_doctor(current_user.id, doctor) if doctor_updated ==1: newToken = Token().encode(current_user.id, doctor.correo) return ServerResponse(msg=strings.DOCTOR_UPDATED, token=newToken) else: raise HTTPException( status_code=status.HTTP_304_NOT_MODIFIED, detail=strings.DOCTOR_NOT_UPDATED)
def create_medico(med: shemas.MedicRegister): if check_if_email_is_taken(med.correo): raise HTTPException( status_code=status.HTTP_400_BAD_REQUEST, detail= strings.USER_ALRRADY_REGISTERED) try: medico:models.Medico = models.Medico(**med.dict()) medico.save() token = Token().encode(medico.id,medico.correo) return ServerResponse( msg=strings.DOCTOR_ADED,token = token) except: raise HTTPException( status_code = status.HTTP_400_BAD_REQUEST, detail=strings.ERROR)
def _parse_fmerge_line(line): """ Parse one line from *.merge file """ items = line.split("\t") tok = Token() tok.pidx, tok.sidx, tok.tidx = int(items[-1]), int(items[0]), int(items[1]) # Without changing the case tok.word, tok.lemma = items[2], items[3] tok.pos = items[4] tok.dep_label = items[5] try: tok.hidx = int(items[6]) except ValueError: pass tok.ner, tok.partial_parse = items[7], items[8] try: tok.eduidx = int(items[9]) except ValueError: print("EDU index for {} is missing in fmerge file".format(tok.word)) # sys.exit() pass return tok
def join_tokens(self, tokens): """ Join a list of tokens. :param list(str) tokens: The list of tokens. :rtype: str :returns: A string of the combined token. """ last_good_split = list(filter( lambda tk: not (tk.get_word().endswith('-') and tk.get_split() == '\n'), tokens)) if not last_good_split: last_good_split = ' ' else: last_good_split = last_good_split[-1].get_split() ret = Token(''.join(self.trim(token.get_word()) for token in tokens if token.get_word() != '-'), last_good_split) return ret
async def prepare(self): """Метод вернет объект пользователя исходя из информации токена, что был передан в заголовке с имененем 'token', в объекте request. Срабатывает перед методами get/post/... """ from modules.user.repositories import UserRepository repository_user = UserRepository(client_motor=self.settings.get("client_motor")) current_user = None try: token = Token.decode_from_str(repository_user, self.request.headers.get(JWT_NAME_HEADER, "")) is_valid = await token.is_valid() if is_valid: current_user = await token.get_user() except JWTError as _: pass if not current_user: raise Response(ExecutionResult(errors=("Пользователь не авторизован",))) self.current_user = current_user