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