async def post_parameters(body: dict = Body(...)):
for k, v in body.items():
if k in parameters["gui_params"]:
parameters["gui_params"][k][0] = v
return {"res": "ok"}
async def update_item(item_id: int, item: Item = Body(embed=True)):
results = {"item_id": item_id, "item": item}
return results
async def query_space_list(query_name: str,
pagination: Pagination = Body(...),
current_user: User = Depends(
deps.get_current_user)):
result = query_space_with_pagination(query_name, pagination)
return result
async def load_enum_list_by_name(query_name,
pagination: Pagination = Body(...),
current_user: User = Depends(
deps.get_current_user)):
return query_enum_list_with_pagination(query_name, pagination)
class MessageBase(BaseModel):
name: str = Body(..., min_length=2, max_length=8)
body: str = Body(..., min_length=1, max_length=200)
def create_language(language: schemas.LanguageBase = Body(...), db: Session = Depends(get_db)):
return lang_utils.create_language(db, language)
async def checkout_cart(payload: Dict = Body(...),
db: DataBase = Depends(get_database)):
pass
async def send_reset_password(request: Request,
bg: BackgroundTasks,
username: str = Body(..., embed=True),
email: str = Body(..., embed=True)):
return await user_routes.send_reset_password(
username, email, "https://gs-suite.herokuapp.com/password/reset", bg)
async def get_username_from_user_id(user_uid: str = Body(..., embed=True),
token: dict = Depends(token_validation)):
return await user_routes.get_username_from_user_id(user_uid=user_uid,
token=token)
def label(utterances: list = Body(...), metric: str = 'euclidean'):
embeddings = embedding_fn(utterances)
groups = generate_groups(utterances, embeddings, metric)
return groups
async def test_test(test: dict = Body(None, example={"test": "mytest"})) -> JSONResponse:
if test:
return JSONResponse({"result": test.get("test")})
return JSONResponse({"result": True})
async def update_student(id: str, req: UpdateStudentModel = Body(...)):
updated_student = await update_student_data(id, req.dict())
return ResponseModel("Student with ID: {} name update is successful".format(id),
"Student name updated successfully") \
if updated_student \
else ErrorResponseModel("An error occurred", 404, "There was an error updating the student.".format(id))
async def add_student_data(student: StudentModel = Body(...)):
student = jsonable_encoder(student)
new_student = await add_student(student)
return ResponseModel(new_student, "Student added successfully.")
async def create_superuser(model, database,
instance: UserSchema = Body(..., )):
"""创建超级管理员"""
instance.password = get_password_hash(instance.password)
query = model.__table__.insert().values(dict(instance))
return await database.execute(query)
async def endpoint(request: Request, collection: str, data: dict = Body({})):
if collection not in directus.collections.registry.REGISTRY:
return await get_upstream_response(request)
return {
'data': directus.collections.registry.REGISTRY[collection].create(data)
}
async def pydantic_exception_duplicate(
kind: Optional[Kind] = Body(default=Kind.a), temp: int = Body(default=1)
):
return {"kind": kind}
def _get_create(create: CREATE_MODEL = Body(
..., embed=embed, alias=alias)) -> DateTimeRWModel:
create.set_datetime()
return create
async def pydantic_exception(item: str = Body(...)):
return {"item": item}
def update_language(lang_id: int = Path(..., ge=1), language: schemas.LanguageBase = Body(...), db: Session = Depends(get_db)):
if upd_lang := lang_utils.update_language(db, lang_id, language):
return upd_lang
async def load_dataset(subject_id,
pagination: Pagination = Body(...),
current_user: User = Depends(deps.get_current_user)):
data, count = load_dataset_by_subject_id(subject_id, pagination)
return build_data_pages(pagination, data, count)
async def query_user_groups_list_by_name(query_name: str,
pagination: Pagination = Body(...),
current_user: User = Depends(
deps.get_current_user)):
return query_user_groups_by_name_with_paginate(query_name, pagination)
async def update_throttle(throttle: int = Body(...)):
results = {"throttle": throttle}
print("got throttle %s" % str(throttle))
return results
async def update_space(space_id,
space: Space = Body(...),
current_user: User = Depends(deps.get_current_user)):
sync_space_to_user_group(space)
return update_space_by_id(space_id, space)
def create_student(student: StudentSchema = Body(...)):
student = jsonable_encoder(student)
return ResponseModel(student, "Student added successfully.")
async def search_videos(video_ids: List[str] = Body(..., embed=True)):
video_ids = list(set(video_ids))[:10]
data = await collection.find({"_id": {"$in": video_ids}}).to_list(10)
for video in data:
video["vod_links"] = parse_vod_urls(video)
return SuccessResponseModel(data=data)
async def create_user(name: str = Body(...), age: int = Body(...)):
return {"name": name, "age": age}
async def verify_url(authorization: str = Header(None),
resources: List[str] = Body(...),
verify: str = Body(...),
detail: Optional[bool] = False):
if authorization is None:
raise HTTPException(
status_code=status.HTTP_403_FORBIDDEN,
detail="Authorization token required",
headers={"WWW-Authenticate": "Bearer"},
)
identity, token = authorization.split(' ')
if identity not in "Bearer":
raise HTTPException(
status_code=status.HTTP_403_FORBIDDEN,
detail="Bearer authorization required",
headers={"WWW-Authenticate": "Bearer"},
)
credentials_exception = HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="Could not validate credentials",
headers={"WWW-Authenticate": "Bearer"},
)
# Verify jwt token
try:
decoded = jwt.decode(token, JWT_PUBLIC, algorithms=JWT_ALGORITHM)
except:
raise credentials_exception
if decoded is None:
raise credentials_exception
if not checkers.is_url(verify) or not allowed_file(verify):
raise HTTPException(
status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
detail="Verify image not valid",
)
print("Incoming prosess")
# Download verify image
try:
print("Downloading images verify: {}".format(verify))
verify_dir = download(verify, dest_folder=TEMP_DIR)
except:
raise HTTPException(
status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
detail="Unable to download verify image",
)
verify_image = face_recognition.load_image_file(verify_dir)
try:
verify_image = face_recognition.face_encodings(verify_image)[0]
except IndexError as e:
os.remove(verify_dir)
return return_index_error(resources, detail)
# Download resources image
resources_image = []
resources_temp = []
for resource in resources:
if not checkers.is_url(resource) or not allowed_file(resource):
raise HTTPException(
status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
detail="Resource image not valid",
)
try:
print("Downloading images resource: {}".format(resource))
resource_dir = download(resource, dest_folder=TEMP_DIR)
except:
raise HTTPException(
status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
detail="Unable to download resource image",
)
image_resource = face_recognition.load_image_file(resource_dir)
try:
image_encode = face_recognition.face_encodings(image_resource)[0]
except IndexError as e:
for resourcex in resources_temp:
os.remove(resourcex)
return return_index_error(resources, detail)
resources_image.append(image_encode)
resources_temp.append(resource_dir)
ret = face_recognition.compare_faces(resources_image, verify_image,
TOLERANCE)
is_detail = False
ret_return = []
if detail in (True, 'true'):
is_detail = True
ret_pros = face_recognition.face_distance(resources_image,
verify_image)
for i, face_distance in enumerate(ret_pros):
ret_return.append({
"result": bool(ret[i]),
"distance": float(face_distance)
})
final_result = False
for result in ret:
if result:
final_result = result
# Clean up tmp downloads
print("Cleaning up images")
os.remove(verify_dir)
for resource in resources_temp:
os.remove(resource)
print("Prosess result: {}".format(final_result))
if is_detail is False:
return_json = {"result": bool(final_result)}
else:
return_json = {"result": bool(final_result), "detail": ret_return}
return return_json
async def declare_embed_request_body(data: Data = Body(..., embed=True)):
return {"text": f"hello, {data.string}, {data.default_none}, {data.lists}"}
async def query_topic_list_by_name(query_name: str,
pagination: Pagination = Body(...),
current_user: User = Depends(
deps.get_current_user)):
return query_report_list_with_pagination(query_name, pagination)
async def reset_password(user: Users = Depends(get_current_user), new_pwd: str = Body(..., min_length=6), old_pwd: str = Body(..., min_length=6)):
if verify_password(old_pwd, user.password):
await user.update(password=get_password_hash(new_pwd))
return {"code": 0, "msg": "密码修改成功"}
return {"code": 1, "msg": "原密码错误"}
