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": "原密码错误"}