async def welcome2(
request: Request, name: fields.Str(missing="Friend",
location="querystring")
) -> Response:
"""A welcome page, using a field annotation."""
return JSONResponse({"message": f"Welcome, {name}!"})
async def test(request):
return JSONResponse("its lit")
async def analyze(request):
data = await request.form()
img_bytes = await (data['file'].read())
img = open_image(BytesIO(img_bytes))
prediction = learn.predict(img)[0]
return JSONResponse({'result': str(prediction)})
async def register(request: Request):
input: RegisterUserInput = await parse(RegisterUserInput.parse, request)
return JSONResponse(UserSchema().dump(input.user))
async def get_open_api_endpoint():
return JSONResponse(
get_openapi(title="FastAPI", routes=app.routes, version="2"))
def index():
return JSONResponse(content={"message": "Hello, World"}, status_code=200)
async def analyze(request):
data = await request.form()
return JSONResponse({'result': textResponse(data)})
async def swagger_config_handler(request):
host = '{}:{}'.format(request.url.hostname, request.url.port)
return JSONResponse(doc.get_config(host))
async def swagger_editor_handler(request):
return JSONResponse(content=doc.editor_html, media_type='text/html')
async def http_exception(request: Request,
exc: WebargsHTTPException) -> Response:
return JSONResponse(exc.messages,
status_code=exc.status_code,
headers=exc.headers)
async def register(form: Credentials) -> JSONResponse:
if User.find(username=form.username):
raise HTTPException(400, "User with this username already exists")
user = User.register(form.username, form.password)
user.write()
return JSONResponse({"success": True})
async def post(self, request: Request, x: float, y: float) -> Response:
return JSONResponse({"result": x + y})
async def add(request: Request, x: float, y: float) -> Response:
"""An addition endpoint."""
return JSONResponse({"result": x + y})
async def welcome_no_default(request: Request, name: str) -> Response:
"""A welcome page with no default name. If "name" isn't passed in the querystring,
an error response will be returned.
"""
return JSONResponse({"message": f"Welcome, {name}!"})
def default(req):
return JSONResponse([{"id": 1, "name": "foo"}, {"id": 2, "name": "bar"}])
async def get_open_api_endpoint(api_key: APIKey = Depends(get_api_key)):
response = JSONResponse(
get_openapi(title="FastAPI security test", version=1, routes=app.routes)
)
return response
async def stat(request: Request):
# current_version: 2020-03-12_1584028278
version_str = oss.key_to_version(current_version)
return JSONResponse({"version": version_str, "net_meta": session.hparams})
async def answers_to_hw(request):
return JSONResponse(
[answer_question_1, answer_question_2, answer_question_3])
async def get_workers():
return JSONResponse(status_code=status.HTTP_200_OK,
content=con.worker_online)
async def class_list(request):
return JSONResponse(['nes', 'supern', 'n64', 'gamecube'])
async def get(self, request, *args, **kwargs):
"""."""
return JSONResponse({'hello': 'World'})
async def root(request):
return JSONResponse({"ms": "Welcome to Notes app."})
async def on_disconnect(self, page_id):
logging.debug(f'In disconnect Homepage')
await WebPage.instances[page_id].on_disconnect(
) # Run the specific page disconnect function
return JSONResponse(False)
async def _http_error_handler(_: Request,
exc: Type[BaseException]) -> JSONResponse:
assert isinstance(exc, exception_cls) # nosec
return JSONResponse(content=jsonable_encoder({"errors": [str(exc)]}),
status_code=status_code)
async def http_error_handler(_: Request, exc: HTTPException) -> JSONResponse:
return JSONResponse({"errors": [exc.detail]}, status_code=exc.status_code)
async def http_error_handler(_: Request, exc: HTTPException) -> JSONResponse:
return JSONResponse(content=jsonable_encoder({"errors": [exc.detail]}),
status_code=exc.status_code)
async def gang(request):
img_data = await request.form('img')
prediction = learn.predict(img_data)[0]
return JSONResponse({'result': str(prediction)})
async def catch_exceptions_middleware(request: Request, call_next):
try:
return await call_next(request)
except Exception as err:
return JSONResponse(content={"error": f"Internal server error: {err}"}, status_code=500)
async def index(request: Request) -> Response:
return JSONResponse({"exists": context.exists()})
async def welcome(request: Request, name: str = "Friend") -> Response:
"""A welcome page."""
return JSONResponse({"message": f"Welcome, {name}!"})