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!")
