fix: client 요청 사항 반영 (#17)

* fix: user birth_date, birth_time 분리

* fix: lotto recommendation 지난 회차 1등 당첨금 필드 제거

* feat: 유저 사주명식 description hcx call 추가

* fix: 불필요 import 제거

* fix: 오행 enum에서 한글 제거

* fix: 추천 결과 없을 때에도 round 정보 보내도록 수정

* fix: 로또 추천 번호 조회 기간 설정

---------

Co-authored-by: Gukhee Jo <[email protected]>

Author: 9keyyyy

src/four_pillars/common/calculator.py

@@ -1,10 +1,15 @@
+import asyncio
+import traceback
 from datetime import datetime, date
 from pathlib import Path
 from typing import List, Tuple, Dict
 from collections import Counter
 
 from src.four_pillars.entities.schemas import FourPillar, FourPillarDetail, PillarInfo
 from src.four_pillars.entities.enums import FiveElements, TenGods
+from src.hcx_client.client import HCXClient
+from src.hcx_client.common.utils import HCXUtils
+from src.hcx_client.common.parser import Parser
 
 
 class FourPillarsCalculator:
@@ -19,7 +24,6 @@ def __init__(self):
         self._init_five_elements_mapping()
         self._init_ten_gods_mapping()
 
-
     def _init_five_elements_mapping(self):
         """천간과 지지의 오행 매핑 초기화"""
         # 천간 오행 매핑
@@ -344,26 +348,18 @@ def _get_pillar_detail(self, pillar: str, day_stem: str) -> PillarInfo:
         heavenly_stem = pillar[0]  # 천간
         earthly_branch = pillar[1]  # 지지
 
-        # 천간의 십신과 오행
+        # 천간의 십신
         heavenly_stem_ten_god = self._get_ten_god(day_stem, heavenly_stem)
-        heavenly_stem_element = self.jikkan_five_elements.get(
-            heavenly_stem, FiveElements.EARTH
-        )
 
         # 지지의 십신 (지지의 숨겨진 천간을 기준으로 계산)
         hidden_stem = self._get_hidden_stem(earthly_branch)
         earthly_branch_ten_god = self._get_ten_god(day_stem, hidden_stem)
-        earthly_branch_element = self.jyunishi_five_elements.get(
-            earthly_branch, FiveElements.EARTH
-        )
 
         return PillarInfo(
             stem=heavenly_stem,
             branch=earthly_branch,
             stem_ten_god=heavenly_stem_ten_god,
             branch_ten_god=earthly_branch_ten_god,
-            stem_element=heavenly_stem_element,
-            branch_element=earthly_branch_element,
         )
 
     def _get_hidden_stem(self, earthly_branch: str) -> str:
@@ -385,6 +381,24 @@ def _get_hidden_stem(self, earthly_branch: str) -> str:
         }
         return hidden_stems.get(earthly_branch, "甲")
 
+    def _normalize_element(self, element: str) -> FiveElements:
+        """오행 문자열을 FiveElements enum으로 정규화"""
+        # 기존 형식: "화(火)", "목(木)" 등을 처리
+        element_mapping = {
+            "화(火)": FiveElements.FIRE,
+            "목(木)": FiveElements.WOOD,
+            "토(土)": FiveElements.EARTH,
+            "금(金)": FiveElements.METAL,
+            "수(水)": FiveElements.WATER,
+        }
+        
+        normalized = element_mapping.get(element)
+        if normalized is None:
+            # 기본값으로 EARTH 반환
+            return FiveElements.EARTH
+        
+        return normalized
+
     def calculate_four_pillars(self, birth_date: datetime) -> FourPillar:
         """사주 계산 메인 함수"""
         year = birth_date.year
@@ -413,7 +427,9 @@ def calculate_four_pillars(self, birth_date: datetime) -> FourPillar:
 
         return result
 
-    def calculate_four_pillars_detailed(self, birth_date: datetime) -> FourPillarDetail:
+    async def calculate_four_pillars_detailed(
+        self, birth_date: datetime
+    ) -> FourPillarDetail:
         """십신 정보를 포함한 상세한 사주 계산"""
         # 기본 사주 계산
         basic_result = self.calculate_four_pillars(birth_date)
@@ -451,15 +467,75 @@ def calculate_four_pillars_detailed(self, birth_date: datetime) -> FourPillarDet
         strong_element = strong_elements[0] if strong_elements else FiveElements.EARTH
         weak_element = weak_elements[0] if weak_elements else FiveElements.WOOD
 
-        # 종합 설명 생성
-        description = "근심과 즐거움이 상반하니 세월의 흐름을 잘 읽어보시게"
-
-        return FourPillarDetail(
+        # FourPillarDetail 객체 생성 (임시 description으로)
+        four_pillar_detail = FourPillarDetail(
             strong_element=strong_element,
             weak_element=weak_element,
-            description=description,
+            description="",  # 임시값
             year_pillar_detail=year_pillar_detail,
             month_pillar_detail=month_pillar_detail,
             day_pillar_detail=day_pillar_detail,
             time_pillar_detail=time_pillar_detail,
         )
+
+        # HCX API 호출하여 사주 설명 생성
+        description = await self._generate_four_pillar_description(
+            four_pillar_detail, strong_element
+        )
+
+        # description 업데이트
+        four_pillar_detail.description = description
+
+        return four_pillar_detail
+
+    async def _generate_four_pillar_description(
+        self, four_pillar_detail: FourPillarDetail, strong_element: FiveElements
+    ) -> str:
+        """HCX API를 호출하여 사주 설명을 생성합니다."""
+        try:
+            hcx_client = HCXClient()
+
+            # FourPillarDetail에서 사주 정보 추출
+            year_pillar = ""
+            month_pillar = ""
+            day_pillar = ""
+            time_pillar = ""
+
+            if four_pillar_detail.year_pillar_detail:
+                year_pillar = f"{four_pillar_detail.year_pillar_detail.stem}{four_pillar_detail.year_pillar_detail.branch}"
+
+            if four_pillar_detail.month_pillar_detail:
+                month_pillar = f"{four_pillar_detail.month_pillar_detail.stem}{four_pillar_detail.month_pillar_detail.branch}"
+
+            if four_pillar_detail.day_pillar_detail:
+                day_pillar = f"{four_pillar_detail.day_pillar_detail.stem}{four_pillar_detail.day_pillar_detail.branch}"
+
+            if four_pillar_detail.time_pillar_detail:
+                time_pillar = f"{four_pillar_detail.time_pillar_detail.stem}{four_pillar_detail.time_pillar_detail.branch}"
+
+            # 사주 정보 준비
+            four_pillar_data = {
+                "year_pillar": year_pillar,
+                "month_pillar": month_pillar,
+                "day_pillar": day_pillar,
+                "time_pillar": time_pillar,
+                "strong_element": strong_element.value,
+            }
+
+            # HCXUtils를 사용하여 프롬프트 가져오기
+            system_prompt, user_prompt_template = HCXUtils.get_prompt_pair(
+                "fortune.yaml", "four_pillar"
+            )
+
+            user_prompt = user_prompt_template.format(**four_pillar_data)
+
+            # HCX API 호출
+            response = await hcx_client.call_completion(
+                system_prompt=system_prompt, user_prompt=user_prompt
+            )
+
+            return response.strip()
+
+        except Exception as e:
+            # API 호출 실패 시 기본 설명 반환
+            return "근심과 즐거움이 상반하니 세월의 흐름을 잘 읽어보시게"

src/four_pillars/entities/enums.py

@@ -4,11 +4,11 @@
 class FiveElements(str, Enum):
     """오행 (五行)"""
 
-    WOOD = "목(木)"
-    FIRE = "화(火)"
-    EARTH = "토(土)"
-    METAL = "금(金)"
-    WATER = "수(水)"
+    WOOD = "木"
+    FIRE = "火"
+    EARTH = "土"
+    METAL = "金"
+    WATER = "水"
 
 
 class TenGods(str, Enum):

src/four_pillars/entities/schemas.py

@@ -1,6 +1,6 @@
 from typing import Optional, List
 
-from pydantic import BaseModel
+from pydantic import BaseModel, field_validator
 from typing_extensions import TypedDict
 
 from src.config.schemas import CommonBase
@@ -12,8 +12,7 @@ class PillarInfo(BaseModel):
     branch: str  # 지지 (두 번째 글자)
     stem_ten_god: TenGods  # 천간의 십신
     branch_ten_god: TenGods  # 지지의 십신
-    stem_element: FiveElements  # 천간의 오행
-    branch_element: FiveElements  # 지지의 오행
+
 
 class FourPillar(TypedDict, total=False):
     year_pillar: str  # 년주
@@ -23,6 +22,7 @@ class FourPillar(TypedDict, total=False):
     strong_elements: Optional[List[str]]  # 가장 많은 오행
     weak_elements: Optional[List[str]]  # 가장 적은 오행
 
+
 class FourPillarDetail(CommonBase):
     strong_element: FiveElements  # 가장 많은 오행
     weak_element: FiveElements  # 가장 적은 오행
@@ -32,3 +32,23 @@ class FourPillarDetail(CommonBase):
     month_pillar_detail: Optional[PillarInfo]  # 월주 상세
     day_pillar_detail: Optional[PillarInfo]  # 일주 상세
     time_pillar_detail: Optional[PillarInfo]  # 시주 상세
+
+    @field_validator("strong_element", "weak_element", mode="before")
+    @classmethod
+    def normalize_element(cls, v):
+        """오행 문자열을 FiveElements enum으로 정규화"""
+        if isinstance(v, str):
+            # 기존 형식: "화(火)", "목(木)" 등을 처리
+            element_mapping = {
+                "화(火)": FiveElements.FIRE,
+                "목(木)": FiveElements.WOOD,
+                "토(土)": FiveElements.EARTH,
+                "금(金)": FiveElements.METAL,
+                "수(水)": FiveElements.WATER,
+            }
+
+            normalized = element_mapping.get(v)
+            if normalized is not None:
+                return normalized
+
+        return v

src/hcx_client/prompts/fortune.yaml

@@ -1,37 +1,19 @@
 four_pillar:
   system_prompt: |
     - 당신은 전통 사주명리학 전문가입니다. 
-    - 사용자가 이름, 성별, 생년월일시, 생년월일 기준을 제공하면, 정확한 사주명식 8글자(년주, 월주, 일주, 시주)를 계산하여 제공해야 합니다.
-    - 사용자의 생년월일 기준은 양력, 음/평달, 음/윤달 중 하나로 주어집니다.
-    - 한국 시간을 기준으로, 만세력 기준을 정확히 적용하여 사주를 계산합니다.
-    - 출생 시간이 주어지지 않은 경우, 시주는 'XX'으로 응답합니다.
-    - 사주명식 계산 후 사주의 종합 해석을 3줄 이내로 작성합니다.
-
-    ## 사주 계산 규칙
-    1. year_pillar: 출생년도의 천간지지 2글자
-    2. month_pillar: 출생월의 천간지지 2글자  
-    3. day_pillar: 출생일의 천간지지 2글자
-    4. time_pillar: 출생시간의 천간지지 2글자
-    5. interpretation: 사주에 대한 종합 해석 (3줄 이내)
-    
-    **천간 (10개):** 甲乙丙丁戊己庚辛壬癸
-    **지지 (12개):** 子丑寅卯辰巳午未申酉戌亥
+    - 사용자의 사주명식(년주, 월주, 일주, 시주)과 강한 오행 기운이 주어지면 이에 대한 간단한 설명을 제공합니다.
+    - 설명은 40자 이내로 작성하며, 불필요한 문장이나 단어는 사용하지 않습니다.
+    - 문장의 끝은 ~하오, ~하게 형식으로 작성합니다.
 
     ## 응답 형식
-    ### JSON으로 응답하되, 마크다운 코드 블록(```)을 절대 사용하지 않습니다.
-    {
-      "year_pillar": "甲子",
-      "month_pillar": "丙寅",
-      "day_pillar": "丁卯",
-      "time_pillar": "戊辰",
-      "interpretation": "강한 목(木) 기운을 가지고 있으며, 창의적이고 활동적인 성향이 두드러집니다."
-    }
+    매해 열매를 맺는 나무와 같이 창의적이며 항상 높은 이상을 향해 매진하고 있소
 
   user_prompt: |
-    이름: {name}
-    성별: {gender}
-    생년월일시: {birth_date}
-    생년월일 기준: {birth_date_type}
+    년주: {year_pillar}
+    월주: {month_pillar}
+    일주: {day_pillar}
+    시주: {time_pillar}
+    오행 중 가장 강한 기운: {strong_element}
 
 lotto:
   system_prompt: |

src/lotto/entities/schemas.py

@@ -1,7 +1,7 @@
 from datetime import date, datetime
 from typing import List, Optional
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, field_validator
 
 from src.config.schemas import CommonBase
 from src.four_pillars.entities.enums import FiveElements
@@ -69,16 +69,32 @@ class LottoRecommendationContent(BaseModel):
     )
     strong_element: FiveElements = Field(description="강한 기운", examples=["화(火)"])
     weak_element: FiveElements = Field(description="상충되는 기운", examples=["목(木)"])
-    last_prize_amount: int = Field(description="지난 회차 1등 당첨금")
+
+    @field_validator("strong_element", "weak_element", mode="before")
+    @classmethod
+    def normalize_element(cls, v):
+        """오행 문자열을 FiveElements enum으로 정규화"""
+        if isinstance(v, str):
+            # 기존 형식: "화(火)", "목(木)" 등을 처리
+            element_mapping = {
+                "화(火)": FiveElements.FIRE,
+                "목(木)": FiveElements.WOOD,
+                "토(土)": FiveElements.EARTH,
+                "금(金)": FiveElements.METAL,
+                "수(水)": FiveElements.WATER,
+            }
+            
+            normalized = element_mapping.get(v)
+            if normalized is not None:
+                return normalized
+        
+        return v
 
 
 class LottoRecommendation(CommonBase):
-    id: int
     user_id: str
     round: int
-    content: LottoRecommendationContent
-    created_at: datetime
-    updated_at: datetime
+    content: Optional[LottoRecommendationContent] = None
 
 
 class LottoRecommendationCreate(CommonBase):

src/lotto/repository.py

@@ -1,3 +1,4 @@
+from datetime import datetime
 from typing import List, Optional, Tuple
 
 from fastapi import Depends
@@ -71,15 +72,20 @@ async def create_lotto_recommendation(
         return recommendation
 
     async def get_lotto_recommendation_by_user_id(
-        self, user_id: str
+        self, user_id: str, start_time: datetime = None, end_time: datetime = None
     ) -> Optional[LottoRecommendations]:
         """사용자의 최신 로또 추천을 조회합니다."""
-        query = (
-            select(LottoRecommendations)
-            .where(LottoRecommendations.user_id == user_id)
-            .order_by(desc(LottoRecommendations.created_at))
-            .limit(1)
+        query = select(LottoRecommendations).where(
+            LottoRecommendations.user_id == user_id
         )
+
+        if start_time and end_time:
+            query = query.where(
+                LottoRecommendations.created_at >= start_time,
+                LottoRecommendations.created_at < end_time,
+            )
+
+        query = query.order_by(desc(LottoRecommendations.created_at)).limit(1)
         result = await self.session.execute(query)
         return result.scalar_one_or_none()
 
@@ -102,13 +108,3 @@ async def get_excluded_numbers(self, limit: int = 2) -> List[int]:
         )
         result = await self.session.execute(query)
         return [row[0] for row in result.fetchall()]
-
-    async def get_latest_prize_amount(self) -> Optional[int]:
-        """가장 최신 회차의 1등 당첨금을 조회합니다."""
-        query = (
-            select(LottoDraws.first_prize_amount)
-            .order_by(desc(LottoDraws.round))
-            .limit(1)
-        )
-        result = await self.session.execute(query)
-        return result.scalar_one_or_none()