def patch_project( project: dict, name: str, patch_mode: schemas.PatchMode = fastapi.Header( schemas.PatchMode.replace, alias=schemas.HeaderNames.patch_mode), projects_role: typing.Optional[schemas.ProjectsRole] = fastapi.Header( None, alias=schemas.HeaderNames.projects_role), # TODO: we're in a http request context here, therefore it doesn't make sense that by default it will hold the # request until the process will be completed - after UI supports waiting - change default to False wait_for_completion: bool = fastapi.Query(True, alias="wait-for-completion"), iguazio_session: typing.Optional[str] = fastapi.Cookie( None, alias="session"), db_session: Session = fastapi.Depends(deps.get_db_session), ): project, is_running_in_background = get_project_member().patch_project( db_session, name, project, patch_mode, projects_role, iguazio_session, wait_for_completion=wait_for_completion, ) if is_running_in_background: return fastapi.Response(status_code=HTTPStatus.ACCEPTED.value) return project
def delete_project( name: str, deletion_strategy: schemas.DeletionStrategy = fastapi.Header( schemas.DeletionStrategy.default(), alias=schemas.HeaderNames.deletion_strategy), projects_role: typing.Optional[schemas.ProjectsRole] = fastapi.Header( None, alias=schemas.HeaderNames.projects_role), # TODO: we're in a http request context here, therefore it doesn't make sense that by default it will hold the # request until the process will be completed - after UI supports waiting - change default to False wait_for_completion: bool = fastapi.Query(True, alias="wait-for-completion"), auth_verifier: deps.AuthVerifier = fastapi.Depends(deps.AuthVerifier), db_session: Session = fastapi.Depends(deps.get_db_session), ): is_running_in_background = get_project_member().delete_project( db_session, name, deletion_strategy, projects_role, auth_verifier.auth_info.session, wait_for_completion=wait_for_completion, ) if is_running_in_background: return fastapi.Response(status_code=HTTPStatus.ACCEPTED.value) return fastapi.Response(status_code=HTTPStatus.NO_CONTENT.value)
def patch_project( project: dict, name: str, patch_mode: mlrun.api.schemas.PatchMode = fastapi.Header( mlrun.api.schemas.PatchMode.replace, alias=mlrun.api.schemas.HeaderNames.patch_mode, ), # TODO: we're in a http request context here, therefore it doesn't make sense that by default it will hold the # request until the process will be completed - after UI supports waiting - change default to False wait_for_completion: bool = fastapi.Query(True, alias="wait-for-completion"), auth_verifier: mlrun.api.api.deps.AuthVerifierDep = fastapi.Depends( mlrun.api.api.deps.AuthVerifierDep), db_session: sqlalchemy.orm.Session = fastapi.Depends( mlrun.api.api.deps.get_db_session), ): project, is_running_in_background = get_project_member().patch_project( db_session, name, project, patch_mode, auth_verifier.auth_info.projects_role, auth_verifier.auth_info.session, wait_for_completion=wait_for_completion, ) if is_running_in_background: return fastapi.Response(status_code=http.HTTPStatus.ACCEPTED.value) return project
async def read_item(user_name: str, user_agent: str = fastapi.Header(None)): my_list = ["justin", "walter", "bryan"] print(my_list) print(user_name) if user_name in my_list: return {"user_name": user_name, "user_agent": user_agent} raise fastapi.HTTPException(status_code=404, detail="Invalid user name")
def verify_webhook_origin_twitter( config, request: fastapi.Request, x_twitter_webhooks_signature: typing.Optional[str] = fastapi.Header(None), ) -> None: """Verify the origin of a request is Twitter based. Twitter will send a header `x-twitter-webhooks-signature` which contains the HMAC SHA256 hash of the resource payload signed using our `CONSUMER_SECRET`. This dependency will raise a `400 BAD REQUEST` exception if it does not find that header.""" if "=" not in x_twitter_webhooks_signature: raise fastapi.HTTPException( status_code=fastapi.status.HTTP_400_BAD_REQUEST, message="Twitter signature did not match", ) # get the digests from the request expected_digest = hmac.new( config.twitter_auth.CONSUMER_KEY_SECRET.encode("utf8"), msg=request.body(), digestmod=hashlib.sha256, ).digest() actual_digest = base64.b64decode( x_twitter_webhooks_signature.split("=", 1)[-1].encode("utf8")) # compare the digests to check they match digests_match = hmac.compare_digest(expected_digest, actual_digest) if not digests_match: raise fastapi.HTTPException( status_code=fastapi.status.HTTP_400_BAD_REQUEST, detail="Twitter signature did not match", )
async def recorded_video(video_id: str, range: str = fastapi.Header(None)): log.info(f"Recorded video requested : '{video_id}'") video_path = pintu.config.recordings_dir / video_id if not video_path.is_file(): log.error(f"No such file: '{video_path}'") raise FileNotFoundError(video_id) if range: start_str, end_str = range.replace("bytes=", "").split("-") start = int(start_str) end = int(end_str) if end_str else start + CHUNK_SIZE else: start = 0 end = video_path.stat().st_size with video_path.open("rb") as video: video.seek(start) data = video.read(end - start) filesize = str(video_path.stat().st_size) headers = { "Content-Range": f"bytes {str(start)}-{str(end)}/{filesize}", "Accept-Ranges": "bytes", } return fastapi.Response( data, status_code=206, headers=headers, # media_type="video/mp4", media_type="video/webm", )
def delete_project( name: str, deletion_strategy: mlrun.api.schemas.DeletionStrategy = fastapi.Header( mlrun.api.schemas.DeletionStrategy.default(), alias=mlrun.api.schemas.HeaderNames.deletion_strategy, ), # TODO: we're in a http request context here, therefore it doesn't make sense that by default it will hold the # request until the process will be completed - after UI supports waiting - change default to False wait_for_completion: bool = fastapi.Query(True, alias="wait-for-completion"), auth_info: mlrun.api.schemas.AuthInfo = fastapi.Depends( mlrun.api.api.deps.authenticate_request), db_session: sqlalchemy.orm.Session = fastapi.Depends( mlrun.api.api.deps.get_db_session), ): is_running_in_background = get_project_member().delete_project( db_session, name, deletion_strategy, auth_info.projects_role, auth_info, wait_for_completion=wait_for_completion, ) if is_running_in_background: return fastapi.Response(status_code=http.HTTPStatus.ACCEPTED.value) return fastapi.Response(status_code=http.HTTPStatus.NO_CONTENT.value)
def from_authotization_header( authorization: str = fastapi.Header(None), ) -> Token: """ Validates an ``Authorization: Bearer`` header and returns a :class:`sni.uac.token.Token`. If the token string is invalid, raises a ``401``. Should be used as a FastAPI dependency. """ bearer = "Bearer " if not authorization or not authorization.startswith(bearer): raise fastapi.HTTPException( fastapi.status.HTTP_401_UNAUTHORIZED, headers={"WWW-Authenticate": "Bearer"}, ) try: token = get_token_from_jwt(authorization[len(bearer):]) logging.debug("Successfully validated token %s", token.uuid) return token except jwt_exceptions.InvalidSignatureError: error_msg = "Failed to validate token: invalid signature" except jwt_exceptions.ExpiredSignatureError: error_msg = "Failed to validate token: expired signature" except jwt_exceptions.InvalidAudienceError: error_msg = "Failed to validate token: invalid audience" except jwt_exceptions.InvalidIssuerError: error_msg = "Failed to validate token: invalid issuer" except jwt_exceptions.InvalidIssuedAtError: error_msg = "Failed to validate token: invalid issuance date" except jwt_exceptions.ImmatureSignatureError: error_msg = "Failed to validate token: immature signature" except jwt_exceptions.InvalidKeyError: error_msg = "Failed to validate token: invalid key" except jwt_exceptions.InvalidAlgorithmError: error_msg = "Failed to validate token: invalid algorithm" except jwt_exceptions.MissingRequiredClaimError: error_msg = "Failed to validate token: missing claim" except jwt_exceptions.DecodeError: error_msg = "Failed to validate token: token could not be decoded" except jwt_exceptions.InvalidTokenError: error_msg = "Failed to validate token: token is invalid" except KeyError: error_msg = "Failed to validate token: payload is invalid" logging.error(error_msg) raise fastapi.HTTPException( fastapi.status.HTTP_401_UNAUTHORIZED, detail=error_msg, headers={"WWW-Authenticate": "Bearer"}, )
def list_secret_keys( project: str, provider: schemas.SecretProviderName = schemas.SecretProviderName.vault, token: str = fastapi.Header(None, alias=schemas.HeaderNames.secret_store_token), auth_verifier: mlrun.api.api.deps.AuthVerifierDep = fastapi.Depends( mlrun.api.api.deps.AuthVerifierDep ), ): mlrun.api.utils.clients.opa.Client().query_project_resource_permissions( mlrun.api.schemas.AuthorizationResourceTypes.secret, project, provider, mlrun.api.schemas.AuthorizationAction.read, auth_verifier.auth_info, ) return mlrun.api.crud.Secrets().list_secret_keys(project, provider, token)
def list_secret_keys( project: str, provider: schemas.SecretProviderName = schemas.SecretProviderName. kubernetes, token: str = fastapi.Header(None, alias=schemas.HeaderNames.secret_store_token), auth_info: mlrun.api.schemas.AuthInfo = fastapi.Depends( mlrun.api.api.deps.authenticate_request), db_session: Session = fastapi.Depends(mlrun.api.api.deps.get_db_session), ): mlrun.api.utils.singletons.project_member.get_project_member().get_project( db_session, project, auth_info.session) mlrun.api.utils.auth.verifier.AuthVerifier( ).query_project_resource_permissions( mlrun.api.schemas.AuthorizationResourceTypes.secret, project, provider, mlrun.api.schemas.AuthorizationAction.read, auth_info, ) return mlrun.api.crud.Secrets().list_secret_keys(project, provider, token)
def invitebot(ref: str = "No Referrer", dnt: int = fastapi.Header(0), perms: int = 0): from urllib.parse import quote url = "https://discord.com/oauth2/authorize?client_id={}&permissions={}&scope=bot".format( 619328560141697036, perms) url += "&response_type=code&redirect_url=" + quote( "https://api.yourapps.cyou/callbacks/authorized") async def bg(): pass # prevent nameerror if dnt == 0: async def bg(): cursor = await app.state.db.execute( "SELECT referrals FROM referrers WHERE id=?;", (ref, )) count = await cursor.fetchone() if not count: # This is the first time this source has referred. # We need to create a row. await app.state.db.execute( """ INSERT INTO referrers (id, referrals) VALUES (?, 1); """, (ref, )) else: # Just need to increment await app.state.db.execute( """ UPDATE referrers SET referrals=`referrals`+1 WHERE id=?; """, (ref, )) await app.state.db.commit() return fastapi.responses.RedirectResponse( url, 308, {"Cache-Control": "max-age=806400"}, BackgroundTask(bg))
def get_current_user(auth_api_user: dict = fastapi.Depends(get_user_from_auth), account_id: str = fastapi.Header(None)): """Parse the provided dict into a User instance.""" return User(user_id=auth_api_user['keycloakGuid'], user_name=auth_api_user['username'], account_id=account_id)