Python responses.PlainTextResponse方法代码示例

# 需要导入模块: from starlette import responses [as 别名]
# 或者: from starlette.responses import PlainTextResponse [as 别名]
def app(self):
        app_ = Starlette()
        app_.add_middleware(PrometheusMiddleware)
        app_.add_route("/metrics/", metrics)

        @app_.route("/foo/")
        def foo(request):
            return PlainTextResponse("Foo")

        @app_.route("/bar/")
        def bar(request):
            raise ValueError("bar")

        @app_.route("/foo/{bar}/")
        def foobar(request):
            return PlainTextResponse(f"Foo: {request.path_params['bar']}")

        return app_ 

# 需要导入模块: from starlette import responses [as 别名]
# 或者: from starlette.responses import PlainTextResponse [as 别名]
def app():
    app = Starlette()

    @app.route("/sync-message")
    def hi(request):
        capture_message("hi", level="error")
        return PlainTextResponse("ok")

    @app.route("/async-message")
    async def hi2(request):
        capture_message("hi", level="error")
        return PlainTextResponse("ok")

    app.add_middleware(SentryAsgiMiddleware)

    return app 

# 需要导入模块: from starlette import responses [as 别名]
# 或者: from starlette.responses import PlainTextResponse [as 别名]
def graphql_http_server(self, request: Request) -> Response:
        try:
            data = await self.extract_data_from_request(request)
        except HttpError as error:
            return PlainTextResponse(error.message or error.status, status_code=400)

        context_value = await self.get_context_for_request(request)
        extensions = await self.get_extensions_for_request(request, context_value)
        middleware = await self.get_middleware_for_request(request, context_value)

        success, response = await graphql(
            self.schema,
            data,
            context_value=context_value,
            root_value=self.root_value,
            validation_rules=self.validation_rules,
            debug=self.debug,
            introspection=self.introspection,
            logger=self.logger,
            error_formatter=self.error_formatter,
            extensions=extensions,
            middleware=middleware,
        )
        status_code = 200 if success else 400
        return JSONResponse(response, status_code=status_code) 

# 需要导入模块: from starlette import responses [as 别名]
# 或者: from starlette.responses import PlainTextResponse [as 别名]
def get(self, request: Request) -> Response:

        # validate state
        state = request.query_params["state"]
        _state = request.session.pop("state", "unknown")
        if state != _state:
            return PlainTextResponse("Invalid state", status_code=403)

        # retrieve tokens
        code = request.query_params["code"]
        tokens = self.kc.callback(code)
        # request.session["tokens"] = json.dumps(tokens)

        # retrieve user info
        access_token = tokens["access_token"]
        user = self.kc.fetch_userinfo(access_token)
        request.session["user"] = json.dumps(user)

        return RedirectResponse(self.redirect_uri) 

# 需要导入模块: from starlette import responses [as 别名]
# 或者: from starlette.responses import PlainTextResponse [as 别名]
def app(elasticapm_client):
    app = Starlette()

    @app.route("/", methods=["GET", "POST"])
    async def hi(request):
        with async_capture_span("test"):
            pass
        return PlainTextResponse("ok")

    @app.route("/raise-exception", methods=["GET", "POST"])
    async def raise_exception(request):
        raise ValueError()

    app.add_middleware(ElasticAPM, client=elasticapm_client)

    return app 

# 需要导入模块: from starlette import responses [as 别名]
# 或者: from starlette.responses import PlainTextResponse [as 别名]
def post(self, request: Request) -> Response:
        content_type = request.headers.get("Content-Type", "")

        if "application/json" in content_type:
            try:
                data = await request.json()
            except json.JSONDecodeError:
                return JSONResponse({"error": "Invalid JSON."}, 400)
        elif "application/graphql" in content_type:
            body = await request.body()
            data = {"query": body.decode()}
        elif "query" in request.query_params:
            data = request.query_params
        else:
            return PlainTextResponse("Unsupported Media Type", 415)

        return await self._get_response(request, data=data) 

# 需要导入模块: from starlette import responses [as 别名]
# 或者: from starlette.responses import PlainTextResponse [as 别名]
def _get_response(self, request: Request, data: QueryParams) -> 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=data.get("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) 

# 需要导入模块: from starlette import responses [as 别名]
# 或者: from starlette.responses import PlainTextResponse [as 别名]
def test_tartiflette_app_as_sub_starlette_app(engine: Engine) -> None:
    async def home(_request: Request) -> PlainTextResponse:
        return PlainTextResponse("Hello, world!")

    graphql = TartifletteApp(engine=engine)
    routes = [
        Route("/", endpoint=home),
        Mount("/graphql", app=graphql, name="tartiflette-asgi"),
    ]
    app = Starlette(routes=routes, on_startup=[graphql.startup])

    async with get_client(app) as client:
        response = await client.get("/")
        assert response.status_code == 200
        assert response.text == "Hello, world!"
        response = await client.get("/graphql?query={ hello }")
        assert response.status_code == 200
        assert response.json() == {"data": {"hello": "Hello stranger"}} 

# 需要导入模块: from starlette import responses [as 别名]
# 或者: from starlette.responses import PlainTextResponse [as 别名]
def hello_webpage(request):
    """
    returns PlainTextResponse callback for hello world webpage
    """
    return PlainTextResponse("Hello, world!") 

# 需要导入模块: from starlette import responses [as 别名]
# 或者: from starlette.responses import PlainTextResponse [as 别名]
def homepage(request) -> Response:
    return PlainTextResponse("Homepage") 

# 需要导入模块: from starlette import responses [as 别名]
# 或者: from starlette.responses import PlainTextResponse [as 别名]
def about(request) -> Response:
    return PlainTextResponse("About") 

# 需要导入模块: from starlette import responses [as 别名]
# 或者: from starlette.responses import PlainTextResponse [as 别名]
def config_validator(
    data: fastapi.UploadFile = fastapi.File(...),
):  # pragma: no cover
    try:
        rules.UserConfigurationSchema(await data.read())
    except Exception as e:
        status = 400
        message = str(e)
    else:
        status = 200
        message = "The configuration is valid"

    return responses.PlainTextResponse(message, status_code=status) 

# 需要导入模块: from starlette import responses [as 别名]
# 或者: from starlette.responses import PlainTextResponse [as 别名]
def howdy(request):
    user = request.session["user"]
    return PlainTextResponse(f"Howdy {user}!") 

# 需要导入模块: from starlette import responses [as 别名]
# 或者: from starlette.responses import PlainTextResponse [as 别名]
def logout(request):
    return PlainTextResponse("User logged out successfully") 

# 需要导入模块: from starlette import responses [as 别名]
# 或者: from starlette.responses import PlainTextResponse [as 别名]
def howdy(request):
    return PlainTextResponse("Howdy!")