def train_model(background_tasks: BackgroundTasks, bot: Text, user: Text, email: Text, process_type: Text): """ train model common code when uploading files or training a model :param background_tasks: fast api background task :param bot: bot id :param user: user id :param email: user email for generating token for reload :param process_type: either upload or train """ from ...shared.data.model_processor import ModelProcessor from ...shared.auth import Authentication from ...shared.data.constant import MODEL_TRAINING_STATUS from ...train import start_training exception = process_type != 'upload' ModelProcessor.is_training_inprogress(bot, raise_exception=exception) ModelProcessor.is_daily_training_limit_exceeded( bot, raise_exception=exception) ModelProcessor.set_training_status( bot=bot, user=user, status=MODEL_TRAINING_STATUS.INPROGRESS.value, ) token = Authentication.generate_integration_token( bot, email, ACCESS_ROLES.TESTER.value, expiry=180, token_type=TOKEN_TYPE.DYNAMIC.value) background_tasks.add_task(start_training, bot, user, token)
def save_label( background_tasks: BackgroundTasks, image: str, params: str = Form("{}"), tag: str = DefaultLabelTag.FINAL.value, label: UploadFile = File(...), ): file_ext = "".join(pathlib.Path( label.filename).suffixes) if label.filename else ".nii.gz" label_file = tempfile.NamedTemporaryFile(suffix=file_ext).name tag = tag if tag else DefaultLabelTag.FINAL.value with open(label_file, "wb") as buffer: shutil.copyfileobj(label.file, buffer) background_tasks.add_task(remove_file, label_file) instance: MONAILabelApp = app_instance() save_params: Dict[str, Any] = json.loads(params) if params else {} logger.info(f"Save Label params: {params}") label_id = instance.datastore().save_label(image, label_file, tag, save_params) res = instance.on_save_label(image, label_id) res = res if res else {} res.update({ "image": image, "label": label_id, }) return res
async def register(user: UserInput, background: BackgroundTasks): if User.find_user_with_email(email=user.email): return Fortauto.response({"message": "Account already exist"}, status_code=status.HTTP_400_BAD_REQUEST) if user.password.strip() == user.confirm_password.strip(): try: password = UserMixin.hash_password( user.password) if UserMixin.hash_password( user.password) else None newUser = User(email=user.email.lower(), first_name=user.first_name.lower(), last_name=user.last_name.lower(), phone_number=user.phone_number, city=user.city.lower(), state=user.state.lower(), address=user.address, password=password) newUser.save(clean=True) if newUser: background.add_task( Fortauto.mailUsr, email_title=f"Account activation", user_email=user.email, email_message=f"Welcome to {WEBSITE_NAME}, " f"kindly click on the link below to activate your " f"account\n\n {user.website_url}/{newUser.id}/activate") return Fortauto.response( { "message": "Account created successfully," " an verification link has been sent to your email" }, status_code=status.HTTP_201_CREATED) return Fortauto.response({ "message": "Error Creating account, please check your details or try" }) except errors.NotUniqueError: return Fortauto.response( {"message": "User with email already exist"}, status_code=status.HTTP_400_BAD_REQUEST) except errors.ValidationError: return Fortauto.response( { "message": "Error validating details, please check your details and try again" }, status_code=status.HTTP_400_BAD_REQUEST) except Exception.__base__: return Fortauto.response( { "message": "Error Creating account, please check your details or try" }, status_code=status.HTTP_400_BAD_REQUEST) return Fortauto.response({"message": "Password is does not match"}, status_code=status.HTTP_400_BAD_REQUEST)
def run_inference( background_tasks: BackgroundTasks, model: str, image: str = "", session_id: str = "", params: str = Form("{}"), file: UploadFile = File(None), label: UploadFile = File(None), output: Optional[ResultType] = None, ): request = {"model": model, "image": image} if not file and not image and not session_id: raise HTTPException(status_code=500, detail="Neither Image nor File not Session ID input is provided") instance: MONAILabelApp = app_instance() if file: file_ext = "".join(pathlib.Path(file.filename).suffixes) if file.filename else ".nii.gz" image_file = tempfile.NamedTemporaryFile(suffix=file_ext).name with open(image_file, "wb") as buffer: shutil.copyfileobj(file.file, buffer) request["image"] = image_file background_tasks.add_task(remove_file, image_file) if label: file_ext = "".join(pathlib.Path(label.filename).suffixes) if label.filename else ".nii.gz" label_file = tempfile.NamedTemporaryFile(suffix=file_ext).name with open(label_file, "wb") as buffer: shutil.copyfileobj(label.file, buffer) background_tasks.add_task(remove_file, label_file) # if binary file received, e.g. scribbles from OHIF - then convert using reference image if file_ext == ".bin": image_uri = instance.datastore().get_image_uri(image) label_file = binary_to_image(image_uri, label_file) request["label"] = label_file config = instance.info().get("config", {}).get("infer", {}) request.update(config) p = json.loads(params) if params else {} request.update(p) if session_id: session = instance.sessions().get_session(session_id) if session: request["image"] = session.image request["session"] = session.to_json() logger.info(f"Infer Request: {request}") result = instance.infer(request) if result is None: raise HTTPException(status_code=500, detail="Failed to execute infer") return send_response(instance.datastore(), result, output, background_tasks)
def registerUserAccount(user:UserRegisterationInput, background:BackgroundTasks): if accountModel.UserAccount.get_singleUserByEmail(email=user.email): ErrorResponse = {"message": "Account does not exist"} return KhairoFullMixin.Response(userMessage=ErrorResponse, success=False, status_code=status.HTTP_400_BAD_REQUEST) if user.password.strip() == user.confirmPassword.strip(): try: password = AccountManager.hash_password(password=user.password) newUserDetails = { "firstname": user.firstname, "lastname":user.lastname, "email": user.email, "password": password } newUser = accountModel.UserAccount(**newUserDetails).save(clean=True) if newUser: mailData = { "title":"Khairo diet Account verification", "message":f" Welcome to {WEBSITE_NAME}, {newUser.firstname} { newUser.lastname}\n " f"Your account was created successfully please " f"verify your email to continue\n {WEBSITE_URL}{API_BASE_URI}/user/{newUser.id}" } background.add_task(KhairoFullMixin.mailUser, userEmail=newUser.email, emailTitle=mailData.get("title"), emailMessage=mailData.get("message")) SuccessResponseData = { "user": {"firstname":newUser.firstname, "lastname":newUser.lastname}, "message": "Account was created successfully", "confirm email": "A mail was sent to your to confirm your email address" } return KhairoFullMixin.Response(userMessage=SuccessResponseData, success=True, status_code=status.HTTP_201_CREATED) ErrorResponse = {"message": "Error creating account, check your detail and try again"} return KhairoFullMixin.Response(userMessage=ErrorResponse, success=False, status_code=status.HTTP_400_BAD_REQUEST) except errors.ValidationError: ErrorResponse = {"message": "Error creating account, check your detail and try again"} return KhairoFullMixin.Response(userMessage=ErrorResponse, success=False, status_code=status.HTTP_400_BAD_REQUEST) except errors.NotUniqueError: ErrorResponse = {"message": "Account with this email already exist, try again"} return KhairoFullMixin.Response(userMessage=ErrorResponse, success=False, status_code=status.HTTP_400_BAD_REQUEST) ErrorResponse = {"message": "Password do not match, try again"} return KhairoFullMixin.Response(userMessage=ErrorResponse, success=False, status_code=status.HTTP_400_BAD_REQUEST)
def getPasswordLink(userOldData: GetPasswordResetLink, background: BackgroundTasks): user = accountModel.UserAccount.get_singleUserByEmail(email=userOldData.email) if user: mailData = { "title": "Password reset", "message": f"password reset pass code\n Password reset link: {userOldData.passwordReset_url}/{user.id}" } background.add_task(KhairoFullMixin.mailUser, userEmail=user.email, emailTitle=mailData.get("title"), emailMessage=mailData.get("message")) ResponseData = {"message": "Check your email for password reset link"} return KhairoFullMixin.Response(userMessage=ResponseData, status_code=status.HTTP_200_OK) ErrorResponseData = {"message": "Account does not exist"} return KhairoFullMixin.Response(userMessage=ErrorResponseData, status_code=status.HTTP_401_UNAUTHORIZED)
async def get_user_account_activation_link(background: BackgroundTasks, user: GetPasswordResetLink): current_user = User.find_user_with_email(email=user.email) if current_user: background.add_task( Fortauto.mailUsr, email_title=f"Account activation", user_email=user.email, email_message=f"Welcome to {WEBSITE_NAME}, " f"kindly click on the link below to activate your " f"account\n\n {user.website_url}/{current_user.id}/activate") return Fortauto.response( { "message": "Account created successfully," "an verification link has been sent to your email" }, status_code=status.HTTP_201_CREATED) return Fortauto.response({"message": "Account does not exist"}, status_code=status.HTTP_400_BAD_REQUEST)
async def get_password_reset_link(background: BackgroundTasks, user: GetPasswordResetLink): current_user = User.find_user_with_email(email=user.email) if current_user: background.add_task( Fortauto.mailUsr, user_email=user.email, email_message= f" Good day {current_user.first_name} {current_user.last_name}, You requested for password reset, " f"please click\n\n " f"on to link below to continue \n\n {user.website_url}/{current_user.id}/password/reset", email_title="Password reset link") return Fortauto.response( { "message": "password reset link has been sent your email address, click it to continue." }, status_code=status.HTTP_200_OK) return Fortauto.response({"message": "Account does not exist"}, status_code=status.HTTP_400_BAD_REQUEST)
def create_session( background_tasks: BackgroundTasks, uncompress: bool = False, expiry: int = 0, files: List[UploadFile] = File(...), ): instance: MONAILabelApp = app_instance() sessions: Sessions = instance.sessions() if sessions is None: logger.error("Session Feature is Not Enabled") raise HTTPException(status_code=406, detail="Session Feature is Not Enabled") logger.info(f"Uncompress: {uncompress}; Expiry: {expiry}") logger.info(f"Request Files: {files}") received_dir = tempfile.NamedTemporaryFile().name os.makedirs(received_dir, exist_ok=True) input_image = "" total_files = 0 for f in files: basename = get_basename(f.filename) if f.filename else tempfile.NamedTemporaryFile().name input_image = os.path.join(received_dir, basename) with open(input_image, "wb") as fb: shutil.copyfileobj(f.file, fb) total_files += 1 logger.info(f"{total_files} => {f} => {input_image}") if total_files > 1: logger.info(f"Input has multiple files; Saving ALL into: {received_dir}") input_image = received_dir session_id, session_info = sessions.add_session(input_image, expiry, uncompress) background_tasks.add_task(remove_file, received_dir) if total_files == 0: raise HTTPException(status_code=404, detail="Image(s) Not Found") logger.info(f"Session ID: {session_id}; Info: {session_info.to_str()}") return {"session_id": session_id, "session_info": session_info.to_json()}
def add_image( background_tasks: BackgroundTasks, image: Optional[str] = None, params: str = Form("{}"), file: UploadFile = File(...), ): logger.info(f"Image: {image}; File: {file}; params: {params}") file_ext = "".join(pathlib.Path( file.filename).suffixes) if file.filename else ".nii.gz" image_id = image if image else os.path.basename(file.filename).replace( file_ext, "") image_file = tempfile.NamedTemporaryFile(suffix=file_ext).name with open(image_file, "wb") as buffer: shutil.copyfileobj(file.file, buffer) background_tasks.add_task(remove_file, image_file) instance: MONAILabelApp = app_instance() save_params: Dict[str, Any] = json.loads(params) if params else {} image_id = instance.datastore().add_image(image_id, image_file, save_params) return {"image": image_id}
def train_model(background_tasks: BackgroundTasks, bot: Text, user: Text, email: Text, process_type: Text): """ train model common code when uploading files or training a model :param background_tasks: fast api background task :param bot: bot id :param user: user id :param email: user email for generating token for reload :param process_type: either upload or train """ from .data_processor.model_processor import ModelProcessor from .api.auth import Authentication from .data_processor.constant import MODEL_TRAINING_STATUS from .train import start_training exception = process_type != 'upload' ModelProcessor.is_training_inprogress(bot, raise_exception=exception) ModelProcessor.is_daily_training_limit_exceeded(bot, raise_exception=exception) ModelProcessor.set_training_status( bot=bot, user=user, status=MODEL_TRAINING_STATUS.INPROGRESS.value, ) token = Authentication.create_access_token(data={"sub": email}, token_expire=180) background_tasks.add_task( start_training, bot, user, token.decode('utf8') )