바른 프로그래밍

Router 의존성 주입과 API Func 의존성 주입

r잡초처럼 — Mon, 16 Oct 2023 23:51:13 +0900

오늘 PR 리뷰를 하다가 현재 User에 대한 validate와 user 정보를 받아오는 함수를 정의해서 api args에서 annotate로 선언해서 썼다. 문제가 없는 코드였다.

API endpoint에 depends 주입한 코드

from typing import Annotated

from fastapi import Depends, FastAPI
from fastapi.security import OAuth2PasswordBearer
from pydantic import BaseModel

app = FastAPI()

oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")

def validate_token(token):
	# 토큰이 유효하지 않다면
    	raise HTTPException(status_code=401, detail="Invalid Token")
    # 토큰이 유효하다면
    	return token

def get_user_by_token(token):
    # 1. token 이 유효한지 검사한다.
    # 2. token 이 유효하다면 토큰에 심어져 있는 id 를 통해 db 에서 user 정보를 조회한다.
    # 3. 만약 user 정보가 없다면 raise 를 일으킨다.
    # 4. 해당 user의 active 가 true 인지 확인하고 아니라면 raise 를 일으킨다.
    # 5. 모든 게 통과된다면 user 를 return 한다.
    user = repository.get_user_by_token(token) # db 에서 user 를 가져온다.
    if user is None:
        raise HTTPException(status_code=404, detail="Invalid User")
    if not user.active
        raise HTTPException(status_code=404, detail="Invalid User")
    return user


async def get_current_user(token: Annotated[str, Depends(validate_token)]):
    user = get_user_by_token(token)
    return user


@app.get("/users/me")
async def read_users_me(current_user: Annotated[User, Depends(get_current_user)]):
    return current_user

위의 코드는 공식문서에 있는 코드를 변형해서 슈도 코드로 만들었다. read_users_me의 current_user 에 depends를 주입시켰다.
문제가 없는 코드이지만 나는 current_user는 인증이 요구되는 api endpoint 함수들에는 다 필요한 요소라고 생각했고, path router에다가 depends를 주입하면 코드 중복성을 제거할 수 있지 않을까 생각했다.

APIRouter에 depends를 주입해 보자

login_required_router = APIRouter(
	dependencies=[Depends(get_current_user)],
)


@login_required_router("/api")
def get_foo(user: User):
	do_something()

위와 같이 할 수 있지 않을까 생각했다. 결론적으로는 역할이 달랐고, return value를 endpoint에서 직접적으로 꺼내는 방법은 없었다.

하지만 내 생각에는 api endpoint 함수들마다 get_current_user를 annotate 인자로 받아서 쓰는 건 모든 api 마다 current user를 중복으로 쓰지 않을까란 생각이 들었다(결국 인증 - 유저가 유효한지- 에 관한 문제이기 때문에)결국엔 login_required 가 필요한 api endpoint에 공통적으로 들어가 있는 게 훨씬 낫다는 생각이었다. 따라서 request state에 담아서 쓰는 건 어떤가라는 생각이 들었다.
아래는 router에 depends를 주입하는 코드이다.

# router/user.py

async def get_current_user(request: Request, token: Annotated[str, Depends(validate_token)]):
    user = get_user_by_token(token)    	
    request.state.current_user = user
    return user
    

login_required_router = APIRouter(
    dependencies=[Depends(get_current_user)],
)


@login_required_router("/api")
def get_foo(request: Request):
    current_user = request.state.current_user    
    do_something()

물론 이 코드도 문제는 request.state 에 current_user 가 저장되어 있다는 것을 알아야 하지만 내 생각에는 이게 중복성을 제거할 수 있지 않을까란 생각이 들었다.

ps. 글을 쓰고 다시 생각해보니 middleware에다가 현재 로그인한 사용자를 넣는건 어떨까란 생각이 드는데 올바른지 고민해봐야겠다

상속 안티 패턴

r잡초처럼 — Tue, 5 Sep 2023 00:29:06 +0900

원하는 데이터 객체를 만들기 위해 많은 비용을 들이지 말자. 다음 예를 보자

class TransactionalPolicy(collections.UserDict):
    """잘못된 상속의 예"""
    
    def change_in_policy(self, customer_id, **new_policy_data):
    	self[customer_id].update(**new_policy_data)

이 클래스는 고객의 정책에 접근해 정책을 바꾼다는 목적에는 부합할 수 있으나, 상속의 안티패턴을 보여주고 있다.

계층 구조가 잘못됐다.

기본 클래스에서 새 클래스를 만드는 것은 개념적으로 확장되고 세부적인 것이다라는 것을 뜻한다. 하지만 해당 데이터 객체는 Dict를 상속하면서 Dict의 개념을 확장했다기 보단 필요한 몇몇 부분(고객 데이터를 접근하는 부분)만 사용했다는 느낌을 가지게 된다.
결합력이 강하다.

이 클래스에는 pop() 또는 items()와 같은 메서드가 필요하지 않지만 포함되어 있다. 덕타이핑으로 볼 때 해당 오리는 필요없는 부위가 있는 이상한 오리다.

이것이 구현 객체를 도메인 객체와 혼합할 때 발생하는 문제이다. dict는 특정 유형의 작업에 적합한 객체 또는 데이터 구조로서 다른 데이터 구조와 마찬가지로 트레이드오프가 있다. TransactionPolicy는 특정 도메인의 정보를 나타내는 것이므로 해결하려는 문제의 일부분에 사용되는 엔티티여야 한다.

올바른 해결책은 컴포지션을 사용하는 것이다.

컴포지션이란?
다른 클래스의 인스턴스를 자신의 인스턴스 변수로 가지고 있는 것이다.

class TransactionalPolicy:
    """컴포지션을 사용한 리팩토링 예제"""
    
    def __init__(self, policy_data, **extra_data):
        self._data = {**policy_data, **extra_data}
        
    def change_in_policy(self, customer_id, **new_policy_data):
        self._data[customer_id].update(**new_policy_data)
        
    def __getitem__(self, customer_id):
    	return self._data[customer_id]
        
    def __len__(self):
    	return len(self._data)

이 방법은 개념적으로 정확할 뿐만 아니라 확장성도 뛰어나다.

FastAPI - Query Parameter에 Custom Validate 적용하기

r잡초처럼 — Sat, 2 Sep 2023 14:51:05 +0900

문제상황

FastAPI에서 Query Parameter에 Validate를 적용하고 싶었다. 기본적인 건 min_length, max_length, pattern, regex 등은 기본적으로 지원해 주지만(공식문서), 조금 복잡한 validate를 적용할 때는 마땅한 게 없었다.

View에서 물론 처리해도 되겠지만, 같은 코드 블록이 다른 View에서 계속 쓰이는 것은 보기 불편했다.(validate 함수를 지정하고 view에서 계속 호출하는 그게 너무 싫었다)

해결 과정

처음 생각한 건 BaseModel을 적용해서 @field_validator 를 적용할까 생각했지만, 한 두 개의 query param을 위해 BaseModel을 적용하는 건 필요 이상으로 복잡하게 모델을 구현한다는 생각이 들었다.
생각해보다가 FastAPI에서 제공해 주는 Depends를 활용하면 어떨까란 생각이 들었다. 마침 Depends에 대한 공식문서의 설명에서 내가 생각한 게 아주 틀리진 않다는 확신을 가졌다.

"Dependency Injection" means, in programming, that there is a way for your code (in this case, your path operation functions) to declare things that it requires to work and use: "dependencies".
And then, that system (in this case FastAPI) will take care of doing whatever is needed to provide your code with those needed dependencies ("inject" the dependencies).
This is very useful when you need to:
- Have shared logic (the same code logic again and again).
- Share database connections.
- Enforce security, authentication, role requirements, etc.
- And many other things..

첫 번째 줄의 Have shared logic 이란 부분에서 같은 validate를 적용하면 되지 않을까 싶었다.

구현해 보기

우선 비교를 위해 처음 구현되었던 부분을 보자

@app.get("/duplicate/validate/query1")
async def duple_validate_query_1(
    q: Annotated[str, Query(description="이것은 query string 이다.")]
):
    if not do_validate_something(q):
        return {"message": "Cheer Up!!!!"}
    ...



@app.get("/duplicate/validate/query2")
async def duple_validate_query_1(
    q: Annotated[str, Query(description="이것은 query string 이다.")]
):
    if not do_validate_something(q):
        return {"message": "Cheer Up!!"}
    ...

물론 '이게 뭐가 거슬리냐?'라고 말할 수 있다. 하지만 이러한 validate 가 조금씩 늘어난다면 어떻게 될까?

@app.get("/duplicate/validate/query1")
async def duple_validate_query_1(
    q: Annotated[str, Query(description="이것은 query string 이다.")],
    qq: Annotated[str, Query(description="이것은 query string 이다.")],
):
    if not do_validate_something(q):
        return {"message": "Cheer Up!!!!"}
    if not do_validate_something(qq):
        return {"message": "More Cheer Up!!!"}
    ...


@app.get("/duplicate/validate/query2")
async def duple_validate_query_1(
    q: Annotated[str, Query(description="이것은 query string 이다.")],
    qq: Annotated[str, Query(description="이것은 query string 이다.")],
):
    if not do_validate_something(q):
        return {"message": "Cheer Up!!!!"}
    if not do_validate_something(qq):
        return {"message": "More Cheer Up!!!"}
    ...

조금씩 코드뭉치가 늘어나는 느낌이다.

query param이 많다면 다음과 같은 방법도 괜찮을 것이다.(참고자료)


class QueryParam(BaseModel):
    q: str = Query(description="이것은 query string 이다.")
    qq: str = Query(description="이것은 query string 이다.")
    qqq: int = Query(description="이것은 query string 이다.")

    @field_validator("q", "qq")
    @classmethod
    def q_must_is_goal(cls, v: str):
        if do_validate_something(v):
            return v
        raise HTTPException(
            status_code=HTTP_400_BAD_REQUEST, detail={"message": "Cheer Up"}
        )

    @field_validator("qqq")
    @classmethod
    def qqq_must_match(cls, v: int):
        expected_value = [10000, 10200, 30000]
        if v in expected_value:
            return v
        raise HTTPException(
            status_code=HTTP_400_BAD_REQUEST,
            detail={"message": f"qqq is {','.join(map(str, expected_value))}"},
        )


@app.get("/duplicate/validate/query2")
async def duple_validate_query_base_model(query_param: QueryParam = Depends()):
    return query_param.model_dump()

다만 이 방법은 너무 적은 수의 Query를 class로 적용하면, 복잡도를 높인다고 생각든다.

Depends 사용해 보기

그럼 이제 Depends를 사용해 보자.

async def depends_query_validate(
    q: Annotated[str, Query(description="이것은 Depends 로 검사하는 query string")]
):
    if do_validate_something(q):
        return q
    return "sorry invalid q"


@app.get("/duplicate/validate/query/depends")
async def duple_validate_query_depends(
    q: Annotated[str, Depends(depends_query_validate)]
):
    result = q
    return {"message": result}

성공!!!

실패

마치며

사실 Validator를 사용하는 방법이 있긴 한데 어째서인지 router로 serving하면 validate가 세 번이 돌고 있어서 사용하지 않았다. 이 글을 쓰면서 계속 이유를 찾고 있어서 만약 해결이 된다면 따로 포스팅할 예정이다.(app으로 serving 한 경우에는 이런 문제가 발생하지 않는다.)

def result_validate(value):
    return value + "1"
    
    
@test_router.get(
    "/TEST",
    name="test",
)
async def test(
    foo: Annotated[
        str | None,
        Query(description="foo"),
        AfterValidator(result_validate),
    ],
):
    return {"serving_router": foo}
    
    
@app.get(
    "/TEST",
    name="test",
)
async def test(
    foo: Annotated[
        str | None,
        Query(description="foo"),
        AfterValidator(result_validate),
    ],
):
    return {"serving_app": foo}

router로 서빙한 결과

app 으로 서빙한 결과

FastApi 사용하면서 기록할 것들

r잡초처럼 — Wed, 30 Aug 2023 19:36:43 +0900

Embed

만약 Body 에서 Request Body 내부에 Key 로 구분지어서 받고 싶다면 Embed=True 로 설정하면 된다. 다음과 같이 나온다

from typing import Annotated

from fastapi import Body, FastAPI
from pydantic import BaseModel

app = FastAPI()


class Item(BaseModel):
    name: str
    description: str | None = None
    price: float
    tax: float | None = None


@app.put("/items/{item_id}")
async def update_item(item_id: int, item: Annotated[Item, Body(embed=True)]):
    results = {"item_id": item_id, "item": item}
    return results

이렇게 하면 아래와 같이 나온다.

{
  "item": {
    "name": "string",
    "description": "string",
    "price": 0,
    "tax": 0
  }
}

BaseModel로 QueryParam 사용하기

참고 자료
1. https://github.com/tiangolo/fastapi/discussions/6495

2. https://stackoverflow.com/questions/62468402/query-parameters-from-pydantic-model

Query parameters from pydantic model

Is there a way to convert a pydantic model to query parameters in fastapi? Some of my endpoints pass parameters via the body, but some others pass them directly in the query. All this endpoints s...

stackoverflow.com

만약 query param의 개수가 많다면 BaseModel로 선언하고, 아래와 같이 사용하면 된다.

class Foo(BaseModel):
	num: int
    char: str


@app.put("/items/{item_id}")
async def get_item(
    query_parm: Foo = Depends(),
):
	...

여기에 Field와 Query를 추가하면 metadata도 추가할 수 있다.

class Foo(BaseModel):
	num: int = Field(
        Query(
            ...,
            description="숫자"          
            example=1,
        ),
    )
    char: str = Field(
        Query(
            ...,
            description="문자"          
            example="hello, world.",
            min_length=1,
        ),
    )

response_model_exclude_unset=True

값이 할당 되지 않은 예를 들면 Key가 없는 건 response 모델에서 뺀다.

class Item(BaseModel):
    name: str
    description: str | None = None
    price: float
    tax: float = 10.5
    tags: list[str] = []


items = {
    "foo": {"name": "Foo", "price": 50.2},
    "bar": {"name": "Bar", "description": "The bartenders", "price": 62, "tax": 20.2},
    "baz": {"name": "Baz", "description": None, "price": 50.2, "tax": 10.5, "tags": []},
}


@app.get("/items/{item_id}", response_model=Item, response_model_exclude_unset=True)
async def read_item(item_id: str):
    return items[item_id]

response 모델은 Item으로 정의되어 있지만, response를 보면 key 가 없는 foo의 경우엔 보이지 않는다.

{
  "name": "Foo",
  "price": 50.2
}

Response Model Union

class BaseItem(BaseModel):
    description: str
    type: str


class CarItem(BaseItem):
    type: str = "car"


class PlaneItem(BaseItem):
    type: str = "plane"
    size: int


items = {
    "item1": {"description": "All my friends drive a low rider", "type": "car"},
    "item2": {
        "description": "Music is my aeroplane, it's my aeroplane",
        "type": "plane",
        "size": 5,
    },
}


@app.get("/items/{item_id}", response_model=Union[PlaneItem, CarItem])
async def read_item(item_id: str):
    return items[item_id]

이런식으로 response_model을 선언하면 schema에선 다음과 같이 보인다.

[ERROR] Pycharm Interpreter package install 시 'cp949' Encode error

r잡초처럼 — Mon, 14 Aug 2023 16:22:10 +0900

pycharm에서 poetry로 가상환경을 세팅했다. 하지만 패키지를 설치하려고 할 때마다 `cp949` 에러가 났다.
사실 큰 문제는 아니었다. terminal에서 poetry 직접 add를 하면 됐다.
하지만 mypy를 plugin 으로 설치하고, 작동을 하려니까 계속 install mypy라는 noti가 뜨고(global 하게 mypy를 설치한 python을 써도 같은 오류를 뱉었다... virtualenv로 가상환경을 구성했을 땐 잘만되던 게... 왜 poetry에서만...ㅠ) 설치하려니 해당 오류를 뱉으니, 더 이상 무시할 수 없게 되었다.

Pycharm file encoding 문제인가 싶어 UTF-8로 설정했지만, 에러 로그에는 stream_out.py 에서 `\u2022`를 encode 하다가 에러가 발생했다는 메시지만 보여줬다.

아무 생각 없이 stream_out.py 파일을 건드려서 해당 문자열을 오류 핸들링 했다

# stream_out.py

def _write(self, message: str, new_line: bool = False) -> None:
    if new_line:
        message += "\n"
        
    # custom 코드
    # 하지만 깨름칙하다. python release 버전 소스코드를 내맘대로 커스텀 하는게..
    if "\u2022" in message:
        message = message.replace("\u2022", '*')
        
    self._stream.write(message)
    self._stream.flush()

그러다 문득 든 생각이 '이럴 거면 그냥 window default encoding 옵션을 utf-8로 하면 되는 게 아닐까?'란 생각이 들었다.
(참고: https://bangtal.bosornd.com/posts/windows-utf-8/)

다행히 생각은 주효했고 다른 오류를 만났다

error: Microsoft Visual C++ 14.0 or greater is required. Get it with "Microsoft C++ Build Tools": https://visualstudio.microsoft.com/visual-cpp-build-tools/

이건 C++ 를 설치하면서 해결했다

Annotated

r잡초처럼 — Thu, 3 Aug 2023 11:10:27 +0900

Annotated를 활용해 Type hint에 대한 Metadata를 설정해 보자

정의

typing.Annotated란 해당 타입에 대한 메타데이터를 제공해 준다.

사용법

예를 들어 다음과 같이 사용할 수 있다

T1 = Annotated[int, ValueRange(-10, 5)]
T2 = Annotated[T1, ValueRange(-20, 3)]

Annotated는 첫 번째 인자는 유효한 자료형이어야 한다. T2와 같이 가변인자도 지원한다.
또한 위와 같이 여러 개의 형 주석이 지원된다.

Annotated[int, ValueRange(3, 10), ctype("char")]

Annotated는 최소한 두 개의 인자로 호출해야 한다.

# error
num: Annotated[int]

# Good
num: Annotated[int, "숫자"]

FastAPI에선 Query와 같이 사용하여 다음과 같이 validate도 할 수 있다.

from typing import Annotated

from fastapi import FastAPI, Query

app = FastAPI()


@app.get("/items/")
async def read_items(q: Annotated[str | None, Query(max_length=50)] = None):
	...

참고

1. https://docs.python.org/ko/3.9/library/typing.html#typing.Annotated

typing — 형 힌트 지원 — Python 3.9.17 문서

typing — 형 힌트 지원 소스 코드: Lib/typing.py 참고 파이썬 런타임은 함수와 변수 형 어노테이션을 강제하지 않습니다. 형 어노테이션은 형 검사기, IDE, 린터(linter) 등과 같은 제삼자 도구에서 사용

docs.python.org

2. https://fastapi.tiangolo.com/tutorial/query-params-str-validations/#__tabbed_2_1

Slack reminder 조회 및 삭제

r잡초처럼 — Thu, 3 Aug 2023 10:08:28 +0900

slack 에서 채널에 계속 공지하다가 삭제할 일이 생겼다.

1. remind 를 조회하자

/remind list

2. 목록에서 삭제를 누르면 된다

QueryParameter

r잡초처럼 — Wed, 2 Aug 2023 14:09:30 +0900

1. kwargs 와 type 힌트를 통해 queryparameter 를 사용할 수 있다.

fake_items_db = [{"item_name": "Foo"}, {"item_name": "Bar"}, {"item_name": "Baz"}]


@app.get("/items/")
async def read_item(skip: int = 0, limit: int = 10):
    return fake_items_db[skip : skip + limit]

2. Optional의 경우엔 어떻게?

@app.get("/items/{item_id}")
async def read_item(item_id: str, q: str | None = None):
    if q:
        return {"item_id": item_id, "q": q}
    return {"item_id": item_id}

3. multiple path and query parameter 는 특정 순서로 선언할 필요는 없다.

@app.get("/users/{user_id}/items/{item_id}")
async def read_user_item(
    user_id: int, item_id: str, q: str | None = None, short: bool = False
):
    item = {"item_id": item_id, "owner_id": user_id}
    if q:
        item.update({"q": q})
    if not short:
        item.update(
            {"description": "This is an amazing item that has a long description"}
        )
    return item

4. required query parameter는 default value 를 설정하지 않으면 된다.

@app.get("/items/{item_id}")
async def read_user_item(item_id: str, needy: str):
    item = {"item_id": item_id, "needy": needy}
    return item

물론 어떤 param 은 필수값이고 어떤 건 옵셔널하다면 다음과 같이 선언해도 된다.

@app.get("/items/{item_id}")
async def read_user_item(
    item_id: str, needy: str, skip: int = 0, limit: int | None = None
):
    item = {"item_id": item_id, "needy": needy, "skip": skip, "limit": limit}
    return item

FastAPI - PathParameter

r잡초처럼 — Wed, 2 Aug 2023 12:02:43 +0900

PathParameter

1. '{}' 를 쓰고 인자로 받으면 된다.

@app.get("/items/{item_id}")
async def read_item(item_id: int):
    return {"item_id": item_id}

2. 만약 sub path 가 같고 뒤에 오는게 다르다면?

@app.get("/users/me")
async def read_user_me():
    return {"user_id": "the current user"}


@app.get("/users/{user_id}")
async def read_user(user_id: str):
    return {"user_id": user_id}

이럴 경우엔 path param이 me가 오는 경우 read_user_me()가 호출 되고, 다른 경우엔 read_user가 호출된다.

3. 만약 path param 에서 받아오는 값에 "/" 가 붙어있는 경우에는 어떻게 해야할까? 이때는 :path 를 붙여준다.

@app.get("/files/{file_path:path}")  # :path 예를 들어 1/1.txt 로 요청해도 404 가 안뜬다
async def read_file(file_path: str):
    return {"file_path": file_path}

4. 만약 path param 으로 받아오는 값을 choice하게 해야된다면? Enum을 이용하자

class ModelName(str, Enum):
    alexnet = "alexnet"
    resnet = "resnet"
    lenet = "lenet"


@app.get("/models/{model_name}")
async def get_model(model_name: ModelName):
    if model_name is ModelName.alexnet:
        return {"model_name": model_name, "message": "Deep Learning FTW!"}

    if model_name.value == "lenet":
        return {"model_name": model_name, "message": "LeCNN all the images"}

    return {"model_name": model_name, "message": "Have some residuals"}

FastAPI 시작하기 - 개발환경 세팅

r잡초처럼 — Tue, 1 Aug 2023 17:03:51 +0900

FastAPI로 개발하게 될 거 같아서 공부를 해보자. 일단 개발환경부터 세팅하자

개발환경은 pyenv와 poetry로 가상환경을 설정했다.

pyenv

특징

pyenv 는 Python의 버전을 관리할 수 있다.
여러 개의 프로젝트에서 다양한 python 버전으로 개발환경을 세팅할 수 있다.
시스템 전체에 영향을 주지 않고 버전을 바꿀 수 있다.

주요 기능

여러 버전의 Python 설치
가상 환경 관리
- pyenv를 사용하여 가상 환경을 생성하고 관리할 수 있다.
- 각각의 프로젝트에 맞게 가상 환경을 생성하여 의존성을 격리할 수 있다.

사용 예시

python 설치하기

# Python 3.9.6 버전 설치
pyenv install 3.9.6

# Python 3.8.12 버전 설치
pyenv install 3.8.12

설치한 버전 확인하기

pyenv versions

프로젝트에서만 해당 python 버전 사용하기

cd my_project

pyenv local 3.8.12

전역으로 python 버전 설정하기

pyenv global 3.10.10

Poetry

특징

Poetry는 Python 패키지 관리 도구
Group 옵션을 통해 다양한 환경에서 의존성을 관리할 수 있다.

주요 기능

가상 환경 생성과 관리
패키지 의존성 관리
프로젝트 정보 관리
- pyproject.toml 파일을 사용하여 프로젝트의 정보를 정의한다.
- 프로젝트의 이름, 버전, 저자 등의 정보를 설정할 수 있다

사용 예시

프로젝트 생성과 의존성 추가

# 새 프로젝트 생성
poetry new my_project

# pyproject.toml 생성
cd my_project
poetry init

# 의존성 추가
poetry add requests
poetry add numpy --dev  # dev group에 numpy 설치

라이브러리 및 파일 실행하기(black, pytest 또는 소스 코드)

# 소스 코드 실행
poetry run python your_script.py

# pytest 실행
poetry run pytest

의존성 패키지 설치하기

poetry install

FastAPI

특징

ASGI 서버와 호환되어 비동기 방식으로 동작한다
안정적이고 빠른 개발환경을 제공한다

주요 기능

빠른 성능
강력한 타입 힌팅
API 문서 자동화

사용 예시

fastapi 및 서버 설치

poetry add fastapi

poetry add "uvicorn[standard]"

간단한 api 예시

from fastapi import FastAPI

app = FastAPI()


@app.get("/")
async def root():
    return {"message": "Hello World"}