def post_single \ ( brewery_name:str=Query(..., title="Query string", description="Name of the Brewery (field: `brewery_name`).", ) , review_aroma:float=Query(..., description="Score given for Aroma (field: `review_aroma`).") , review_appearance:float=Query(..., description="Score given for Appearance (field: `review_appearance`).") , review_palate:float=Query(..., description="Score given for Palate (field: `review_palate`).") , review_taste:float=Query(..., description="Score given for Taste (field: `review_taste`).") ): # Imports from joblib import load # Validate params error = "" if not brewery_name in load("./data/processed/valid_breweries.joblib"): error += f"The brewery '{brewery_name}' is not valid." for param in ["review_aroma", "review_appearance", "review_palate", "review_taste"]: if not 0 <= eval(param) < 5: error += f"\nThe value '{eval(param)}' for param '{param}' is invalid. Must be between '0' and '5'." if len(error)>0: return PlainTextResponse(error, status_code=498) # Get prediction pred = p.predict_single \ ( brewery_name=[brewery_name] , review_aroma=[review_aroma] , review_appearance=[review_appearance] , review_palate=[review_palate] , review_taste=[review_taste] ) # Return return PlainTextResponse(str(pred[0]))
async def optimize_post_image(post_update: PostUpdate) -> PlainTextResponse: """ Generate retina version of a post's feature image if one doesn't exist. :param PostUpdate post_update: Incoming payload for an updated Ghost post. :returns: PlainTextResponse """ new_images = [] post = post_update.post.current feature_image = post.feature_image title = post.title if feature_image: new_images.append(images.create_retina_image(feature_image)) new_images.append(images.create_mobile_image(feature_image)) new_images = [image for image in new_images if image is not None] if bool(new_images): LOGGER.info( f"Generated {len(new_images)} images for post `{title}`: {new_images}" ) return PlainTextResponse(f"{post.title}: {new_images}") return PlainTextResponse( content=f"Retina & mobile images already exist for {post.title}.") return PlainTextResponse( content=f"Post `{post.slug}` ignored; no image exists for optimization." )
async def proxy(user: User = Depends(get_current_user)): payload = { "iat": datetime.utcnow(), "jti": secrets.token_hex(32), "payload": { "user": user.username, "date": datetime.today().strftime("%Y-%m-%d"), }, } token = jwt.encode(payload, SECRET_KEY, algorithm=HASHING_ALGORITHM) async with aiohttp.ClientSession() as session: try: response = await session.post( ENDPOINT_URL, headers={"x-my-jwt": token.decode("utf-8")}, ) except aiohttp.ClientConnectionError: return PlainTextResponse( "Failed when trying to connect to the remote service.", status_code=502) if response.status != 200: return PlainTextResponse( "The remote service returned status: {}".format(response.status), status_code=404, ) add_processed_request() return "Your request was succesfully processed"
def liveness() -> PlainTextResponse: work_time = time.time() - START_TIME if work_time < DEATH_DELAY_TIME: response = PlainTextResponse("Live", status_code=200) else: response = PlainTextResponse("Dead", status_code=400) return response
async def notifierserver_get( profile_id: str, notifier: NotifierService = Depends( Provide[AppContainer.notifier.service]), ) -> PlainTextResponse: for _ in range(90): if notifier.has_notifications(profile_id): notifications = notifier.get_notifications_view(profile_id) logger.debug(f"New notifications for profile {profile_id}") logger.debug(notifications) response = "\n".join([ orjson.dumps(notification).decode("utf8") for notification in notifications ]) logger.debug(f"NotifierService response: {response}") return PlainTextResponse( content=response, media_type="application/json", ) await asyncio.sleep(1) return PlainTextResponse( content=orjson.dumps({ "type": "ping", "eventId": "ping" }), media_type="application/json", )
def welcome_token(response: Response, token: str = "", format: str = ""): if token not in app.login_token_tokens: response.status_code = status.HTTP_401_UNAUTHORIZED return response else: response.status_code = status.HTTP_200_OK if format == "": result = "Welcome!" return PlainTextResponse(content=result, status_code=200) elif format == "json": result = {"message": "Welcome!"} return JSONResponse(content=result, status_code=200) elif format == "html": html= f""" <html> <head> <title>have no idea whether it works</title> </head> <body> <h1>Welcome!</h1> </body> </html> """ return HTMLResponse(content=html, status_code=200) else: result = "Welcome!" return PlainTextResponse(content=result, status_code=200)
def post(payload: Payload): try: if REDIS.get(f"{payload.name}"): raise Exception(f"Fruit {payload.name} already exists!") REDIS.set(f"{payload.name}", f"{payload.count}") return PlainTextResponse("OK", 200) except Exception as error: logger.warning(error) return PlainTextResponse("Bad Request", 400)
def post(payload: Payload): try: if payload.name in FRUIT: raise Exception(f"Fruit {payload.name} already exists!") FRUIT[payload.name] = payload.count return PlainTextResponse("OK", 200) except Exception as error: logger.warning(error) return PlainTextResponse("Bad Request", 400)
async def wrapper(**kwargs: Any) -> Any: if 'secret' not in kwargs: return PlainTextResponse('Secret required', status_code=400) if kwargs['secret'].secret != super_secret: logger.warning(f'Secret is {super_secret}') return PlainTextResponse('Secret wrong', status_code=403) if iscoroutinefunction(func): return await func(**kwargs) else: return func(**kwargs)
async def _handle_request(self, request: Request) -> Response: # route GET requests to the IDE if request.method == "GET" and "text/html" in request.headers.get("Accept", ""): # read the GraphiQL playground html and serve it as content graphiql = pathlib.Path(__file__).parent / "graphiql.html" raw_html = None with open(graphiql.absolute(), "r") as f: raw_html = f.read() return HTMLResponse(raw_html) # route POST requests to the graphql executor elif request.method == "POST": content_type = request.headers.get("Content-Type", "") # parse graphql according to content type if "application/json" in content_type: data = await request.json() 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 ) # attempt to pull final query and vars try: query = data["query"] variables = data.get("variables") except KeyError: return PlainTextResponse( "No GraphQL query found in the request", status_code=status.HTTP_400_BAD_REQUEST, ) # construct foundation fastapi context background = BackgroundTasks() context = {"request": request, "background": background} result = await self._execute_graphql(query, variables, context) # parse graphql result response = {} if not result.invalid: response["data"] = result.data if result.errors: response["errors"] = [format_error(e) for e in result.errors] status_code = ( status.HTTP_400_BAD_REQUEST if result.errors else status.HTTP_200_OK ) return ORJSONResponse(response, status_code=status_code, background=background)
def put(payload: Payload): try: fruit: Fruit = SESSION.query(Fruit).filter( Fruit.name == payload.name).one() fruit.count = payload.count SESSION.commit() return PlainTextResponse("OK", 200) except Exception as error: SESSION.rollback() logger.error(error) return PlainTextResponse("Bad Request", 400)
def login( email: str = Body(..., embed=True), password: str = Body(..., embed=True), account_service: AccountService = Depends( Provide[AppContainer.launcher.account_service]), ) -> PlainTextResponse: try: account_service.find(email=email, password=password) return PlainTextResponse(content=zlib.compress("OK".encode("utf8"))) except NotFoundError: return PlainTextResponse( content=zlib.compress("FAILED".encode("utf8")))
class EnumResponse(Enum): OK = DefaultResponse( { "description": "OK", "content": { "text/plain": { "example": "OK" } } }, PlainTextResponse("OK", 200)) BAD_REQUEST = DefaultResponse( { "description": "Bad Request", "content": { "text/plain": { "example": "Bad Request" } }, }, PlainTextResponse("Bad Request", 400)) UNAUTHORIZED = DefaultResponse( { "description": "Unauthorized", "content": { "text/plain": { "example": "Unauthorized" } }, }, PlainTextResponse("Unauthorized", 401)) NOT_FOUND = DefaultResponse( { "description": "Not Found", "content": { "text/plain": { "example": "Not Found" } }, }, PlainTextResponse("Not Found", 404)) INTERNAL_SERVER_ERROR = DefaultResponse( { "description": "Internal Server Error", "content": { "text/plain": { "example": "Internal Server Error" } }, }, PlainTextResponse("Internal Server Error", 500))
def log_out(format: Optional[str] = None): if format == "json": return JSONResponse(content={"message": "Logged out!"}) elif format == "html": return HTMLResponse(content="<h1>Logged out!</h1>") else: return PlainTextResponse(content="Logged out!")
async def post_key(key: schemas.Key, db: Session = Depends(get_db)): key_id = crud.create_key(db, key.name, key.value) if not key_id: return PlainTextResponse(f"Key with name='{key.name}' already exists!", status_code=400) else: return key_id
def text_error(code: int, error: Exception, url: str) -> Response: """Format error message as plain text Returns ------- error message formatted as plain text. """ return PlainTextResponse( content=f"""Error {code}: {ERROR_CODE_MESSAGES[code]} {error} Usage details are available from Request: {url} Request Submitted: {UTCDateTime().isoformat()}Z Service Version: {VERSION} """, status_code=code, )
async def get_cache_or_request_with_model( key: str, model: Type[models.BaseModel], cache: RedisCacheBackend, path: str, ) -> Union[models.BaseModel, PlainTextResponse]: cached_result = None cache_down = None try: cached_result = await cache.get(key) logger.debug(messages.CACHE_AVAILABLE) except Exception as ex: cache_down = True logger.debug(f"{messages.CACHE_UNAVAILABLE}\nErr: {repr(ex)}") try: if cached_result: logger.debug(messages.CACHE_HIT) return model.parse_raw(cached_result) else: response = await request_data(path) result = model.parse_raw(response.content) if not cache_down: await cache.set(key, result.json(), expire=config["CACHE_TTL"]) return result except ValidationError as exc: return PlainTextResponse( messages.VALIDATION_FAIL, status_code=404, )
async def logged_out(format: Optional[str] = None): if format == "json": return JSONResponse(content={"message": "Logged out!"}, status_code=status.HTTP_200_OK) elif format == "html": return HTMLResponse(content="<h1>Logged out!</h1>", status_code=status.HTTP_200_OK) else: return PlainTextResponse(content="Logged out!", status_code=status.HTTP_200_OK)
def welcome_token(*, response: Response, token: str = Query(None), format: str = Query(None)): if token not in app.token_value: raise HTTPException( status_code=status.HTTP_401_UNAUTHORIZED, detail="Incorrect email or password", headers={"WWW-Authenticate": "Basic"}, ) if format == "json": return {"message": "Welcome!"} elif format == "html": return HTMLResponse(""" <html> <head> <title>Some HTML in here</title> </head> <body> <h1>Welcome!</h1> </body> </html> """) else: return PlainTextResponse("Welcome!")
def return_message(text: str, message_format: Optional[str]): if message_format == "json": return JSONResponse(content={"message": text}, status_code=200) if message_format == "html": return HTMLResponse(content=f"<html><h1>{text}</h1></html>", status_code=200) return PlainTextResponse(content=text, status_code=200)
def get_response_by_format(format: str = '', message: str = 'Welcome!'): if format == 'json': return {"message": f"{message}"} elif format == 'html': return HTMLResponse(content=f"<h1>{message}</h1>") else: return PlainTextResponse(content=f"{message}")
def logged_out(format: str = ""): if format == 'json': return {"message": "Logged out!"} elif format == 'html': return HTMLResponse(content='<h1>Logged out!</h1>') else: return PlainTextResponse(content='Logged out!')
def api_register_device( user: user_auth.UserInDB = Depends(user_auth.get_current_user), device_name: str = Form(...), ) -> PlainTextResponse | HTTPException: if not user: # User authorization raise HTTPException( status_code=status.HTTP_401_UNAUTHORIZED, detail="Incorrect username or password", headers={"WWW-Authenticate": "Bearer"}, ) if len(device_name) < 3: raise HTTPException( status_code=status.HTTP_400_BAD_REQUEST, detail="Device name must be more than 3 characters.", ) try: db.register_device(device_name, None, None) except ValueError: raise HTTPException( status_code=status.HTTP_400_BAD_REQUEST, detail="This device is already registered.", ) return PlainTextResponse('successfully registered\n', status_code=200)
def detect(file: UploadFile = File(...)): raw = file.file.read() landmarks = detect_cat(raw) if landmarks: return {"success": True, "landmarks": landmarks} else: return PlainTextResponse("No cats detected", status_code=400)
def message_response(format: str, func_value: str): if format == "json": return JSONResponse(content={"message": func_value}) if format == "html": return HTMLResponse(content=f"<h1>{func_value}</h1>") return PlainTextResponse(content=func_value)
def returnResponse(response): if type(response) is dict: return Response(json.dumps(response, indent=4), media_type="application/json") if type(response) is str: return PlainTextResponse(response) return response
async def metrics(): service = get_service() labels = {"service": service.name, "node": config.node} if service.pooled: labels["pool"] = config.pool if hasattr(service, "slot_number"): labels["slot"] = service.slot_number out = [] mdata = service.get_mon_data() for key in mdata: if key == "pid": continue metric_name = key local_labels = {} if isinstance(mdata[key], (bool, str)): continue if isinstance(key, tuple): metric_name = key[0] for k in key[1:]: local_labels.update({k[0]: k[1]}) local_labels.update(labels) cleared_name = str(metric_name).translate(TR).lower() value = mdata[key] if value is None: continue if hasattr(value, "iter_prom_metrics"): out += list(value.iter_prom_metrics(cleared_name, local_labels)) else: out_labels = ",".join(['%s="%s"' % (i.lower(), local_labels[i]) for i in local_labels]) out += ["# TYPE %s untyped" % cleared_name] out += ["%s{%s} %s" % (cleared_name, out_labels, value)] return PlainTextResponse( content="\n".join(out) + "\n", headers={"Content-Type": "text/plain; version=0.0.4"} )
async def index(request: Request, sid: Optional[str] = Cookie(None), chapter: Optional[str] = None) -> bytes: ses = Session().get(where=f'id="{sid}"') if ses.userId: isAdmin = False if User().get(where=f"id={ses.userId}").tags.lower( ).find("admin") == -1 else True if chapter == "admin": if isAdmin: return templates.TemplateResponse( "index.html", { "request": request, "title": "Administration", "icon": "favicon.ico", "styles": ["white_blue.css"], "scripts": ["system.js", "admin.js"] }) return PlainTextResponse(content="Access denied", status_code=403) return templates.TemplateResponse( "index.html", { "request": request, "title": "MonitoringIT", "icon": "favicon.ico", "styles": ["white_blue.css"], "scripts": ["system.js", "monitorit.js"], "isAdmin": isAdmin }) return templates.TemplateResponse( "index.html", { "request": request, "title": "Authorization", "icon": "favicon.ico", "styles": ["auth.css"], "scripts": ["auth.js"] })
def logged_out(format: str = ""): if format == 'json': return {"message": "Logged out!"} elif format == 'html': return HTMLResponse(content="<h1>Logged out!</h1>", status_code=200) else: return PlainTextResponse(content="Logged out!", status_code=200)
def logged_out(format: str = ''): if format == "json": return {"message": "Logged out!"} elif format == "html": return HTMLResponse(content="<h1>Logged out!</h1>") else: return PlainTextResponse("Logged out!")