def create_user(
data: UserCreate,
background_tasks: BackgroundTasks,
db: Session = Depends(deps.get_db),
rdc: RedisCache = Depends(deps.get_redis)
) -> Any:
"""
Endpoint for create user
"""
user = crud_user.get_user_by_email(db, data.email)
if user:
raise HTTPException(status_code=400,
detail='Endereço de email já registrador!')
user = crud_user.create(db, data)
rdc.invalidate_cache_prefix("providers-list")
token = security.generate_token(str(user.id), "activate",
datetime.utcnow() + timedelta(days=31))
background_tasks.add_task(mail.send_account_activation_email, user.name,
user.email, token)
return {
'detail':
'Enviamos um e-mail para você confirma seu cadastro, por favor verifique sua caixa de entrada.'
}
def predict(
request: Any = Body(..., media_type="application/json"), debug=False):
api = local_cache["api"]
predictor_impl = local_cache["predictor_impl"]
debug_obj("payload", request, debug)
prediction = predictor_impl.predict(request)
try:
json_string = json.dumps(prediction)
except Exception as e:
raise UserRuntimeException(
f"the return value of predict() or one of its nested values is not JSON serializable",
str(e),
) from e
debug_obj("prediction", json_string, debug)
response = Response(content=json_string, media_type="application/json")
if api.tracker is not None:
try:
predicted_value = api.tracker.extract_predicted_value(prediction)
api.post_tracker_metrics(predicted_value)
if (api.tracker.model_type == "classification"
and predicted_value not in local_cache["class_set"]):
tasks = BackgroundTasks()
tasks.add_task(api.upload_class, class_name=predicted_value)
local_cache["class_set"].add(predicted_value)
response.background = tasks
except:
cx_logger().warn("unable to record prediction metric",
exc_info=True)
return response
def _tasks_from_event(self, event: Hashable, *args: Any,
**kwargs: Any) -> BackgroundTasks:
tasks = BackgroundTasks()
for f in list(self._handlers[event].values()):
tasks.add_task(f, *args, **kwargs)
return tasks
def predict(
request: Any = Body(..., media_type="application/json"), debug=False):
api = local_cache["api"]
predictor_impl = local_cache["predictor_impl"]
debug_obj("payload", request, debug)
prediction = predictor_impl.predict(request)
debug_obj("prediction", prediction, debug)
try:
json_string = json.dumps(prediction)
except:
json_string = util.json_tricks_encoder().encode(prediction)
response = Response(content=json_string, media_type="application/json")
if api.tracker is not None:
try:
predicted_value = api.tracker.extract_predicted_value(prediction)
api.post_tracker_metrics(predicted_value)
if (api.tracker.model_type == "classification"
and predicted_value not in local_cache["class_set"]):
tasks = BackgroundTasks()
tasks.add_task(api.upload_class, class_name=predicted_value)
local_cache["class_set"].add(predicted_value)
response.background = tasks
except:
cx_logger().warn("unable to record prediction metric",
exc_info=True)
return response
def handle_decline_mission(db: Session, mission_uuid: str, volunteer_id: int,
error_state: models.MissionErrorState,
background_tasks: BackgroundTasks):
# fetch models instances
mission = db.query(
models.Mission).filter(models.Mission.uuid == mission_uuid).first()
volunteer_mission = db.query(models.VolunteerMission).filter(
and_(models.VolunteerMission.mission_id == mission.id,
models.VolunteerMission.volunteer_id == volunteer_id)).first()
volunteer_mission.state = VolunteerMissionState.declined
if error_state == MissionErrorState.no_one_answered_call:
if mission.error_state == MissionErrorState.no_one_answered_call:
# mission had already no answer, just set the state as error
mission.state = MissionState.error
db.commit()
else:
# schedule retry in 60 minutes, have in mind the the other volunteers will still have the chance to call the elder.
mission.error_state = MissionErrorState.no_one_answered_call
set_mission_state(db, mission, MissionState.approved)
elif error_state == MissionErrorState.not_relevant_anymore:
# mission will be handled by call center
set_mission_error(db, mission, MissionErrorState.not_relevant_anymore)
elif error_state == MissionErrorState.refuse_mission:
# mission was refused by volunteer, rerun search now
set_mission_state(db, mission, MissionState.approved)
background_tasks.add_task(search_task_caller, mission.uuid)
async def sso_callback(request: Request,
background_tasks: BackgroundTasks,
sso_type: str = Path(default=None,
description="social media type",
example="google")):
"""
Generate login token after successful social media login.
"""
existing_user, user_details, access_token = await Authentication.verify_and_process(
request, sso_type)
if not existing_user and Utility.email_conf["email"]["enable"]:
background_tasks.add_task(
Utility.format_and_send_mail,
mail_type='password_generated',
email=user_details['email'],
first_name=user_details['first_name'],
password=user_details['password'].get_secret_value())
return {
"data": {
"access_token": access_token,
"token_type": "bearer"
},
"message":
"""It is your responsibility to keep the token secret.
If leaked then other may have access to your system.""",
}
def create_test_run(cls, background_tasks: BackgroundTasks):
"""Creates a new test run in the DB ensuring that no other tests are
still running and starts up a background task to run it.
:returns dict:
"""
output = {
'created': False,
'id': None
}
running = cls.get_currently_running()
if running.count():
print('test already running')
output['id'] = running[0].id
return output
# No tests are still running.
new_run = cls().save()
background_tasks.add_task(new_run.execute_pytest)
output['id'] = new_run.id
output['created'] = True
return output
def register(
*,
db: Session = Depends(get_db),
password: str = Body(...),
email: EmailStr = Body(...),
full_name: str = Body(None),
background_tasks: BackgroundTasks,
):
"""register a new user"""
# why not use UserCreate schema? if used, user can control self become a superuser
# only USERS_OPEN_REGISTRATION is True can register
if not settings.USERS_OPEN_REGISTRATION:
raise HTTPException(status_code=403, detail="forbidden for register")
user = crud.user.get_by_email(db, email=email)
if user:
raise HTTPException(status_code=400, detail="User already exists")
user_in = schemas.UserCreate(password=password,
email=email,
full_name=full_name)
user = crud.user.create(db, obj=user_in)
# send confirm email
if settings.EMAILS_ENABLED and user.email:
confirm_token = create_access_token(
subject=email,
expires_delta=timedelta(settings.EMAIL_CONFIRM_TOKEN_EXPIRE))
background_tasks.add_task(send_confirm_email,
email_to=user.email,
token=confirm_token)
return user
def image_response(background_tasks: BackgroundTasks, image_id: str):
"""Serves the encoded img and deletes it shortly after"""
path = os.sep.join((TMP, image_id)) + ".png"
if os.path.isfile(path):
background_tasks.add_task(remove_file, path)
return FileResponse(path)
return "Encoded pictures are avaible only once"
async def encode_img(background_tasks: BackgroundTasks,
key: str = Form(...),
secret: str = Form(...)):
pxl = Rothko(key).encode_to_img(secret, scale=True)
save_path = pxl.save(TMP)
background_tasks.add_task(remove_file, save_path)
return FileResponse(save_path)
async def put_stack_instance(
background_tasks: BackgroundTasks,
stack_instance_update: StackInstanceUpdate,
document_manager: DocumentManager = Depends(get_document_manager),
stack_manager: StackManager = Depends(get_stack_manager),
redis=Depends(get_redis)):
"""
Updates a stack instance by using a StackInstanceUpdate object
"""
logger.info("[StackInstances PUT] Received PUT request")
to_be_deleted = stack_manager.check_delete_services(stack_instance_update)
(stack_instance, return_result) = stack_manager.process_stack_request(
stack_instance_update, "update")
if stack_instance is None:
return HTTPException(422, return_result)
# Perform invocations
if not stack_instance_update.disable_invocation:
for service in to_be_deleted:
background_tasks.add_task(create_job_per_service, service,
document_manager, "delete", redis,
stack_instance, to_be_deleted)
copy_stack_instance = stack_instance.copy(deep=True)
delete_services(to_be_deleted, copy_stack_instance)
background_tasks.add_task(create_job_for_agent, copy_stack_instance,
"update", redis)
document_manager.write_stack_instance(stack_instance)
return return_result
async def app(scope, receive, send):
tasks = BackgroundTasks()
tasks.add_task(increment)
tasks.add_task(increment)
response = Response("tasks initiated",
media_type="text/plain",
background=tasks)
await response(scope, receive, send)
async def clear_cache(name: str, background_tasks: BackgroundTasks) -> None:
cache = Cache(Cache.REDIS,
endpoint=app_settings.CACHE_HOST,
port=app_settings.CACHE_PORT)
if name == "all":
background_tasks.add_task(cache.delete, "/*")
else:
background_tasks.add_task(cache.delete, f"/{name}*")
async def xls2html(request: Request, back_ground_tasks: BackgroundTasks):
form_data = await request.form()
file = form_data.get("file").file._file
if not file.getvalue():
return templates.TemplateResponse("web/failure.html",
{"request": request, "message": "没有文件上传！"})
back_ground_tasks.add_task(send_html, file)
return templates.TemplateResponse("web/success.html",
{"request": request, "email_address": "*****@*****.**"})
async def create_summary(
payload: SummaryPayloadSchema,
background_tasks: BackgroundTasks) -> SummaryResponseSchema:
summary_id = await crud.post(payload)
background_tasks.add_task(generate_summary, summary_id, payload.url)
response_object = {"id": summary_id, "url": payload.url}
return response_object
async def email_by_gmail2(request: Request, mailing_list: SendEmail, background_tasks: BackgroundTasks):
t = time()
background_tasks.add_task(
send_email, mailing_list=mailing_list.email_to
)
print("+*+*" * 30)
print(str(round((time() - t) * 1000, 5)) + "ms")
print("+*+*" * 30)
return MessageOk()
def predict(self, request, tasks: BackgroundTasks):
payload = request['payload']
# use np.round to squeeze to binary {0,1}
results = list(np.round(self.model.predict(payload)))
tasks.add_task(log_to_arize, results, self.arize_client, self.model_id,
self.model_version)
response = {'result': results}
return response
async def add_up(
background_tasks: BackgroundTasks,
url: HttpUrl = Query(...),
up_repo: UpRepository = Depends(get_repository(UpRepository))
) -> UpInDB:
up_info = await get_up_info(url=url)
create = get_create_from_dict(CREATE_MODEL=UpInCreate)(up_info)
up_in_db = await up_repo.create(CREATE_MODEL=UpInCreate,
RETURN_MODEL=UpInDB)(create)
background_tasks.add_task(update_up_info, url=url, up_repo=up_repo)
return up_in_db
async def register_dicom(request):
"""Endpoint for registering newly received DICOM files. Called by the getdcmtags module."""
payload = dict(await request.form())
filename = payload.get("filename","")
file_uid = payload.get("file_uid","")
series_uid = payload.get("series_uid","")
query = dicom_files.insert().values(
filename=filename, file_uid=file_uid, series_uid=series_uid, time=datetime.datetime.now()
)
tasks = BackgroundTasks()
tasks.add_task(execute_db_operation, operation=query)
return JSONResponse({'ok': ''}, background=tasks)
async def post_mercure_event(request):
"""Endpoint for receiving mercure system events."""
payload = dict(await request.form())
sender = payload.get("sender","Unknown")
event = payload.get("event",monitor.h_events.UNKNOWN)
severity = int(payload.get("severity",monitor.severity.INFO))
description = payload.get("description","")
query = mercure_events.insert().values(
sender=sender, event=event, severity=severity, description=description, time=datetime.datetime.now()
)
tasks = BackgroundTasks()
tasks.add_task(execute_db_operation, operation=query)
return JSONResponse({'ok': ''}, background=tasks)
async def post_webgui_event(request):
"""Endpoint for logging relevant events of the webgui."""
payload = dict(await request.form())
sender = payload.get("sender","Unknown")
event = payload.get("event",monitor.w_events.UNKNOWN)
user = payload.get("user","UNKNOWN")
description = payload.get("description","")
query = webgui_events.insert().values(
sender=sender, event=event, user=user, description=description, time=datetime.datetime.now()
)
tasks = BackgroundTasks()
tasks.add_task(execute_db_operation, operation=query)
return JSONResponse({'ok': ''}, background=tasks)
async def create_propagation_task(
token: str,
request: Request,
background_tasks: BackgroundTasks,
jessigod_config=fastapi.Depends(get_jessigod_config),
):
if not compare_digest(jessigod_config.bots.telegram_bot.token, token):
return 'not ok'
body = await request.body()
background_tasks.add_task(core.handle_telegram_update, jessigod_config,
json.loads(body))
return 'ok'
def predict(request: Request):
tasks = BackgroundTasks()
api = local_cache["api"]
predictor_impl = local_cache["predictor_impl"]
dynamic_batcher = local_cache["dynamic_batcher"]
kwargs = build_predict_kwargs(request)
if dynamic_batcher:
prediction = dynamic_batcher.predict(**kwargs)
else:
prediction = predictor_impl.predict(**kwargs)
if isinstance(prediction, bytes):
response = Response(content=prediction,
media_type="application/octet-stream")
elif isinstance(prediction, str):
response = Response(content=prediction, media_type="text/plain")
elif isinstance(prediction, Response):
response = prediction
else:
try:
json_string = json.dumps(prediction)
except Exception as e:
raise UserRuntimeException(
str(e),
"please return an object that is JSON serializable (including its nested fields), a bytes object, "
"a string, or a starlette.response.Response object",
) from e
response = Response(content=json_string, media_type="application/json")
if local_cache["provider"] != "local" and api.monitoring is not None:
try:
predicted_value = api.monitoring.extract_predicted_value(
prediction)
api.post_monitoring_metrics(predicted_value)
if (api.monitoring.model_type == "classification"
and predicted_value not in local_cache["class_set"]):
tasks.add_task(api.upload_class, class_name=predicted_value)
local_cache["class_set"].add(predicted_value)
except:
logger().warn("unable to record prediction metric", exc_info=True)
if util.has_method(predictor_impl, "post_predict"):
kwargs = build_post_predict_kwargs(prediction, request)
request_thread_pool.submit(predictor_impl.post_predict, **kwargs)
if len(tasks.tasks) > 0:
response.background = tasks
return response
def create_appointments(
data: AppointmentCreate,
background_tasks: BackgroundTasks,
user: User = Depends(deps.get_user),
db: Session = Depends(deps.get_db),
rdc: RedisCache = Depends(deps.get_redis)
) -> Any:
"""
Endpoint for create appointment
"""
db_provider = crud_user.get_user_by_id(db, str(data.provider_id))
if not db_provider:
raise HTTPException(status_code=404,
detail="Cabeleireiro não encontrado")
current_date = datetime.now()
compare_date = data.date.replace(tzinfo=None)
if compare_date < current_date:
raise HTTPException(
status_code=400,
detail="Você não pode marcar agendamento em datas passadas")
if data.date.hour < 8 or data.date.hour > 17:
raise HTTPException(
status_code=400,
detail="Você só pode cria agendamentos entre 8:00 e 17:00")
if data.provider_id == user.id:
raise HTTPException(
status_code=400,
detail="Você não pode marca agendamento consigo mesmo")
validate_date = crud_appointment.get_appointment_by_date(
db, data.provider_id, data.date)
if validate_date:
raise HTTPException(status_code=400,
detail="Este horario já esta agendado")
appointment = crud_appointment.create(db, data, user)
msg = f"Novo agendamento de {user.name} {user.surname} para o {date.format_date(data.date)}"
background_tasks.add_task(crud_notification.create, str(data.provider_id),
msg)
date_time = data.date
rdc.invalidate_cache(
f"providers-appointments:{data.provider_id}:{date_time.year}:{date_time.month}:{date_time.day}"
)
rdc.invalidate_cache(f"user-appointments:{user.id}")
return appointment
def post_pong(
digits_input: DigitsInput,
background_tasks: BackgroundTasks,
aiohttp_client: aiohttp.ClientSession = Depends(aiohttp_client_dep),
history: ResponseHistory = Depends(response_history_dep),
) -> DigitsOutput:
digits_list = digits_input.digits or []
avg, min_digit, max_digit = get_avg_min_max(digits_list)
background_tasks.add_task(
ping, digits_list=digits_list, aiohttp_client=aiohttp_client, history=history
)
return DigitsOutput(digits=digits_list, min=min_digit, max=max_digit, avg=avg)
async def get_revisions(page_id: int, bg_tasks: BackgroundTasks) -> WikiPage:
"""Return revisions data for a given page ID."""
page = await _try_cached_page(page_id)
if page:
return page
page = await _perform_revisions_request(page_id)
bg_tasks.add_task(
ctx.redis.set,
page_id,
pickle.dumps(page),
expire=config.CACHE_TTL_IN_SECONDS,
)
return page
async def solve_dependencies(
*,
request: Request,
dependant: Dependant,
body: Dict[str, Any] = None,
background_tasks: BackgroundTasks = None,
) -> Tuple[Dict[str, Any], List[ErrorWrapper], Optional[BackgroundTasks]]:
values: Dict[str, Any] = {}
errors: List[ErrorWrapper] = []
for sub_dependant in dependant.dependencies:
sub_values, sub_errors, background_tasks = await solve_dependencies(
request=request,
dependant=sub_dependant,
body=body,
background_tasks=background_tasks,
)
if sub_errors:
errors.extend(sub_errors)
continue
assert sub_dependant.call is not None, "sub_dependant.call must be a function"
if is_coroutine_callable(sub_dependant.call):
solved = await sub_dependant.call(**sub_values)
else:
solved = await run_in_threadpool(sub_dependant.call, **sub_values)
assert sub_dependant.name is not None, "Subdependants always have a name"
values[sub_dependant.name] = solved
path_values, path_errors = request_params_to_args(
dependant.path_params, request.path_params
)
query_values, query_errors = request_params_to_args(
dependant.query_params, request.query_params
)
header_values, header_errors = request_params_to_args(
dependant.header_params, request.headers
)
cookie_values, cookie_errors = request_params_to_args(
dependant.cookie_params, request.cookies
)
values.update(path_values)
values.update(query_values)
values.update(header_values)
values.update(cookie_values)
errors += path_errors + query_errors + header_errors + cookie_errors
if dependant.body_params:
body_values, body_errors = await request_body_to_args( # type: ignore # body_params checked above
dependant.body_params, body
)
values.update(body_values)
errors.extend(body_errors)
if dependant.request_param_name:
values[dependant.request_param_name] = request
if dependant.background_tasks_param_name:
if background_tasks is None:
background_tasks = BackgroundTasks()
values[dependant.background_tasks_param_name] = background_tasks
if dependant.security_scopes_param_name:
values[dependant.security_scopes_param_name] = SecurityScopes(
scopes=dependant.security_scopes
)
return values, errors, background_tasks
async def handle_graphql(self, request: Request) -> Response:
if request.method in ("GET", "HEAD"):
if "text/html" in request.headers.get("Accept", ""):
if not self.graphiql:
return PlainTextResponse(
"Not Found", status_code=status.HTTP_404_NOT_FOUND)
return await self.handle_graphiql(request)
data = request.query_params # type: typing.Mapping[str, typing.Any]
elif request.method == "POST":
content_type = request.headers.get("Content-Type", "")
if "application/json" in content_type:
data = await request.json()
elif "application/graphql" in content_type:
body = await request.body()
text = body.decode()
data = {"query": text}
elif "query" in request.query_params:
data = request.query_params
else:
return PlainTextResponse(
"Unsupported Media Type",
status_code=status.HTTP_415_UNSUPPORTED_MEDIA_TYPE,
)
else:
return PlainTextResponse(
"Method Not Allowed",
status_code=status.HTTP_405_METHOD_NOT_ALLOWED)
try:
query = data["query"]
variables = data.get("variables")
operation_name = data.get("operationName")
except KeyError:
return PlainTextResponse(
"No GraphQL query found in the request",
status_code=status.HTTP_400_BAD_REQUEST,
)
background = BackgroundTasks()
context = {"request": request, "background": background}
result = await self.execute(query,
variables=variables,
context=context,
operation_name=operation_name)
error_data = ([format_error(err)
for err in result.errors] if result.errors else None)
response_data = {"data": result.data}
if error_data:
response_data["errors"] = error_data
status_code = (status.HTTP_400_BAD_REQUEST
if result.errors else status.HTTP_200_OK)
print(status_code, response_data)
return JSONResponse(response_data,
status_code=status_code,
background=background)
async def _get_response(self, request: Request, data: QueryParams,
variables: typing.Optional[dict]) -> Response:
try:
query = data["query"]
except KeyError:
return PlainTextResponse("No GraphQL query found in the request",
400)
config = get_graphql_config(request)
background = BackgroundTasks()
context = {"req": request, "background": background, **config.context}
engine: Engine = config.engine
result: dict = await engine.execute(
query,
context=context,
variables=variables,
operation_name=data.get("operationName"),
)
content = {"data": result["data"]}
has_errors = "errors" in result
if has_errors:
content["errors"] = format_errors(result["errors"])
status = 400 if has_errors else 200
return JSONResponse(content=content,
status_code=status,
background=background)
async def handle_http_request(self, http_request: Request):
background_tasks = BackgroundTasks()
# noinspection PyTypeChecker
sub_response = Response(
content=None,
status_code=None,
headers=None,
media_type=None,
background=None,
)
try:
body = await self.parse_body(http_request)
except Exception as exc:
resp, _ = await self.entrypoint.handle_exception_to_resp(exc)
response = self.response_class(content=resp, background=background_tasks)
else:
try:
resp = await self.handle_body(http_request, background_tasks, sub_response, body)
except NoContent:
# no content for successful notifications
response = Response(media_type='application/json', background=background_tasks)
else:
response = self.response_class(content=resp, background=background_tasks)
response.headers.raw.extend(sub_response.headers.raw)
if sub_response.status_code:
response.status_code = sub_response.status_code
return response
