Update app.py

app.py

@@ -1,8 +1,6 @@
 import gradio as gr
 import datetime
-from datetime import datetime, timedelta
-import requests
-import json
+import re
 
 class SajuCalculator:
     def __init__(self):
@@ -29,35 +27,92 @@ class SajuCalculator:
             '금': {'목': '편재/정재', '화': '편관/정관', '토': '편인/정인', '금': '비견/겁재', '수': '식신/상관'},
             '수': {'목': '식신/상관', '화': '편재/정재', '토': '편관/정관', '금': '편인/정인', '수': '비견/겁재'}
         }
+
+    def parse_date(self, date_str):
+        """날짜 파싱"""
+        # 숫자만 추출
+        numbers = re.findall(r'\d+', str(date_str))
         
-        # 색상 매핑
-        self.element_colors = {
-            '목': '#28a745',  # 녹색
-            '화': '#dc3545',  # 빨강
-            '토': '#ffc107',  # 노랑
-            '금': '#6c757d',  # 회색
-            '수': '#007bff'   # 파랑
-        }
+        if not numbers:
+            raise ValueError("날짜에서 숫자를 찾을 수 없습니다")
+        
+        # 하나의 긴 숫자인 경우
+        if len(numbers) == 1:
+            num_str = numbers[0]
+            if len(num_str) == 8:  # YYYYMMDD
+                year = int(num_str[:4])
+                month = int(num_str[4:6])
+                day = int(num_str[6:8])
+            elif len(num_str) == 6:  # YYMMDD
+                year_part = int(num_str[:2])
+                year = 1900 + year_part if year_part > 30 else 2000 + year_part
+                month = int(num_str[2:4])
+                day = int(num_str[4:6])
+            else:
+                raise ValueError(f"날짜 형식을 인식할 수 없습니다: {num_str}")
+        
+        # 여러 숫자로 분리된 경우
+        elif len(numbers) >= 3:
+            year = int(numbers[0])
+            month = int(numbers[1])
+            day = int(numbers[2])
+            
+            if year < 100:
+                year = 1900 + year if year > 30 else 2000 + year
+        else:
+            raise ValueError("날짜 정보가 부족합니다")
+        
+        return year, month, day
+
+    def parse_time(self, time_str):
+        """시간 파싱"""
+        if not time_str:
+            return 12, 0
+        
+        numbers = re.findall(r'\d+', str(time_str))
+        
+        if not numbers:
+            return 12, 0
+        
+        if len(numbers) == 1:
+            time_num = numbers[0]
+            if len(time_num) == 4:  # HHMM
+                hour = int(time_num[:2])
+                minute = int(time_num[2:4])
+            elif len(time_num) == 3:  # HMM
+                hour = int(time_num[0])
+                minute = int(time_num[1:3])
+            else:  # H or HH
+                hour = int(time_num)
+                minute = 0
+        else:
+            hour = int(numbers[0])
+            minute = int(numbers[1]) if len(numbers) > 1 else 0
+        
+        # 24시간 형식 조정
+        hour = hour % 24
+        
+        return hour, minute
 
     def get_ganzhi(self, year, month, day, hour):
         """간지 계산"""
-        # 기준일: 1900년 1월 1일 (경자년 정축월 갑인일)
-        base_date = datetime(1900, 1, 1)
-        target_date = datetime(year, month, day)
+        # 기준일: 1900년 1월 1일
+        base_date = datetime.datetime(1900, 1, 1)
+        target_date = datetime.datetime(year, month, day)
         
         days_diff = (target_date - base_date).days
         
         # 연주 계산
-        year_stem_index = (year - 1900 + 6) % 10  # 1900년이 경년(6)
-        year_branch_index = (year - 1900 + 0) % 12  # 1900년이 자년(0)
+        year_stem_index = (year - 1900 + 6) % 10
+        year_branch_index = (year - 1900 + 0) % 12
         
-        # 월주 계산 (절기 고려해야 하지만 간단히 처리)
+        # 월주 계산
         month_stem_index = (year_stem_index * 2 + month + 1) % 10
         month_branch_index = (month + 1) % 12
         
         # 일주 계산
-        day_stem_index = (days_diff + 10) % 10  # 1900.1.1이 갑일
-        day_branch_index = (days_diff + 2) % 12  # 1900.1.1이 인일
+        day_stem_index = (days_diff + 10) % 10
+        day_branch_index = (days_diff + 2) % 12
         
         # 시주 계산
         hour_branch_index = ((hour + 1) // 2) % 12
@@ -104,189 +159,60 @@ class SajuCalculator:
         
         return analysis
 
-    def calculate_daeun(self, birth_year, gender):
-        """대운 계산 (간단한 버전)"""
-        daeun_list = []
-        start_age = 8 if gender == '남' else 7  # 간단히 설정
-        
-        for i in range(8):  # 8개 대운
-            age_start = start_age + i * 10
-            age_end = age_start + 9
-            year_start = birth_year + age_start
-            year_end = birth_year + age_end
-            
-            # 대운 간지는 월주를 기준으로 순행/역행
-            daeun_list.append({
-                'period': f"{age_start}-{age_end}세",
-                'years': f"{year_start}-{year_end}년",
-                'ganzhi': f"대운{i+1}"  # 실제로는 복잡한 계산 필요
-            })
-        
-        return daeun_list
-
-def parse_flexible_date(date_str):
-    """유연한 날짜 파싱"""
-    import re
-    
-    # 모든 공백 제거
-    date_str = date_str.replace(' ', '')
-    
-    # 숫자만 추출
-    numbers = re.findall(r'\d+', date_str)
-    
-    if len(numbers) == 0:
-        raise ValueError("숫자를 찾을 수 없습니다.")
-    
-    # 하나의 긴 숫자 문자열인 경우 (예: 19900515, 900515)
-    if len(numbers) == 1:
-        num_str = numbers[0]
-        
-        if len(num_str) == 8:  # YYYYMMDD
-            year = int(num_str[:4])
-            month = int(num_str[4:6])
-            day = int(num_str[6:8])
-        elif len(num_str) == 6:  # YYMMDD 또는 YYYYMM
-            if int(num_str[:2]) > 30:  # 년도가 30보다 크면 19XX
-                year = 1900 + int(num_str[:2])
-                month = int(num_str[2:4])
-                day = int(num_str[4:6])
-            else:  # YYYYMM 형태로 해석
-                year = int(num_str[:4])
-                month = int(num_str[4:6])
-                day = 1  # 기본값
-        elif len(num_str) == 5:  # YMMDD
-            year = 1900 + int(num_str[0])
-            month = int(num_str[1:3])
-            day = int(num_str[3:5])
-        else:
-            raise ValueError(f"날짜 형식을 인식할 수 없습니다: {num_str}")
-    
-    # 여러 숫자로 분리된 경우 (예: 1990-5-15)
-    elif len(numbers) >= 3:
-        year = int(numbers[0])
-        month = int(numbers[1])
-        day = int(numbers[2])
-        
-        # 연도가 2자리인 경우 처리
-        if year < 100:
-            if year > 30:
-                year += 1900
-            else:
-                year += 2000
-    
-    elif len(numbers) == 2:
-        # 년월만 있는 경우
-        year = int(numbers[0])
-        month = int(numbers[1])
-        day = 1
-        
-        if year < 100:
-            if year > 30:
-                year += 1900
-            else:
-                year += 2000
-    
-    else:
-        raise ValueError("날짜 정보가 부족합니다.")
-    
-    return year, month, day
+def get_element_personality(element):
+    """오행별 성격 특성"""
+    personalities = {
+        '목': "창의적이고 성장 지향적이며, 유연하고 협력적인 성격을 가지고 있습니다.",
+        '화': "열정적이고 활동적이며, 밝고 사교적인 성격을 가지고 있습니다.",
+        '토': "안정적이고 신중하며, 포용력이 있고 책임감이 강한 성격을 가지고 있습니다.",
+        '금': "원칙적이고 정의로우며, 결단력이 있고 리더십이 강한 성격을 가지고 있습니다.",
+        '수': "지혜롭고 적응력이 있으며, 깊이 있고 신중한 성격을 가지고 있습니다."
+    }
+    return personalities.get(element, "균형 잡힌 성격을 가지고 있습니다.")
 
-def parse_flexible_time(time_str):
-    """유연한 시간 파싱"""
-    import re
-    
-    if not time_str:
-        return 12, 0
-    
-    # 모든 공백 제거
-    time_str = time_str.replace(' ', '')
-    
-    # 숫자만 추출
-    numbers = re.findall(r'\d+', time_str)
-    
-    if len(numbers) == 0:
-        return 12, 0
-    
-    # 하나의 숫자인 경우
-    if len(numbers) == 1:
-        time_num = numbers[0]
-        
-        if len(time_num) == 4:  # HHMM
-            hour = int(time_num[:2])
-            minute = int(time_num[2:4])
-        elif len(time_num) == 3:  # HMM
-            hour = int(time_num[0])
-            minute = int(time_num[1:3])
-        elif len(time_num) <= 2:  # HH
-            hour = int(time_num)
-            minute = 0
-        else:
-            hour = 12
-            minute = 0
+def get_element_balance_advice(elements):
+    """오행 균형에 따른 조언"""
+    max_element = max(elements, key=elements.get)
+    min_element = min(elements, key=elements.get)
     
-    # 여러 숫자인 경우
-    elif len(numbers) >= 2:
-        hour = int(numbers[0])
-        minute = int(numbers[1])
+    advice = f"현재 {max_element}가 가장 강하고 {min_element}가 가장 약합니다. "
     
+    if elements[max_element] - elements[min_element] > 2:
+        advice += f"{min_element}를 보강하고 {max_element}의 기운을 조절하는 것이 좋겠습니다."
     else:
-        hour = int(numbers[0])
-        minute = 0
-    
-    # 24시간 형식으로 조정
-    if hour > 24:
-        hour = hour % 24
+        advice += "전체적으로 균형이 잘 잡혀 있는 편입니다."
     
-    return hour, minute
+    return advice
 
 def calculate_saju(birth_date, birth_time, gender, birth_place):
     """사주 계산 메인 함수"""
+    # SajuCalculator 인스턴스 생성
+    calculator = SajuCalculator()
+    
     try:
         # 입력 검증
         if not birth_date:
             return "❌ 생년월일을 입력해주세요."
         
-        # SajuCalculator 인스턴스 생성 (�� 앞에서 생성)
-        calculator = SajuCalculator()
+        # 날짜 파싱
+        year, month, day = calculator.parse_date(birth_date)
         
-        # 유연한 날짜 파싱
-        try:
-            year, month, day = parse_flexible_date(birth_date)
-            print(f"파싱된 날짜: {year}년 {month}월 {day}일")  # 디버깅용
-            
-            # 날짜 유효성 검사
-            if year < 1900 or year > 2100:
-                return f"❌ 연도는 1900~2100 사이여야 합니다. 입력된 연도: {year}"
-            if month < 1 or month > 12:
-                return f"❌ 월은 1~12 사이여야 합니다. 입력된 월: {month}"
-            if day < 1 or day > 31:
-                return f"❌ 일은 1~31 사이여야 합니다. 입력된 일: {day}"
-            
-        except Exception as e:
-            return f"❌ 날짜 파싱 오류: {str(e)}\n입력값: '{birth_date}'\n💡 다음과 같이 입력해보세요:\n- 19900515 (8자리 숫자)\n- 1990-5-15 (하이픈 구분)\n- 1990/5/15 (슬래시 구분)"
-        
-        # 유연한 시간 파싱
-        if birth_time:
-            try:
-                hour, minute = parse_flexible_time(birth_time)
-            except:
-                hour, minute = 12, 0  # 기본값
-        else:
-            hour, minute = 12, 0  # 시간 입력이 없으면 정오로 설정
+        # 시간 파싱
+        hour, minute = calculator.parse_time(birth_time)
+        
+        # 날짜 유효성 검사
+        if year < 1900 or year > 2100:
+            return f"❌ 연도는 1900~2100 사이여야 합니다. 입력된 연도: {year}"
+        if month < 1 or month > 12:
+            return f"❌ 월은 1~12 사이여야 합니다. 입력된 월: {month}"
+        if day < 1 or day > 31:
+            return f"❌ 일은 1~31 사이여야 합니다. 입력된 일: {day}"
         
         # datetime 객체 생성
-        try:
-            birth_datetime = datetime(year, month, day, hour, minute)
-        except ValueError as e:
-            return f"❌ 유효하지 않은 날짜입니다: {year}년 {month}월 {day}일\n{str(e)}"
+        birth_datetime = datetime.datetime(year, month, day, hour, minute)
         
         # 간지 계산
-        ganzhi = calculator.get_ganzhi(
-            birth_datetime.year,
-            birth_datetime.month,
-            birth_datetime.day,
-            birth_datetime.hour
-        )
+        ganzhi = calculator.get_ganzhi(year, month, day, hour)
         
         # 오행 분석
         elements = calculator.analyze_elements(ganzhi)
@@ -294,18 +220,18 @@ def calculate_saju(birth_date, birth_time, gender, birth_place):
         # 십신 분석
         ten_gods = calculator.get_ten_gods_analysis(ganzhi)
         
-        # 대운 계산
-        daeun = calculator.calculate_daeun(birth_datetime.year, gender)
-        
         # 결과 포맷팅
-        result = format_saju_result(ganzhi, elements, ten_gods, daeun, birth_datetime, gender, birth_place)
+        result = format_saju_result(ganzhi, elements, ten_gods, birth_datetime, gender, birth_place, calculator)
         
         return result
         
+    except ValueError as ve:
+        return f"❌ 입력 오류: {str(ve)}\n\n💡 입력 예시:\n- 생년월일: 19900207, 1990-2-7\n- 시간: 0815, 8:15"
+    
     except Exception as e:
-        return f"❌ 계산 중 오류가 발생했습니다: {str(e)}\n\n💡 입력 예시:\n- 생년월일: 19900515, 1990-5-15, 90515\n- 시간: 1430, 14:30, 오후2시30분"
+        return f"❌ 계산 중 오류가 발생했습니다: {str(e)}"
 
-def format_saju_result(ganzhi, elements, ten_gods, daeun, birth_datetime, gender, birth_place):
+def format_saju_result(ganzhi, elements, ten_gods, birth_datetime, gender, birth_place, calculator):
     """사주 결과 포맷팅"""
     
     result = f"""
@@ -343,8 +269,6 @@ def format_saju_result(ganzhi, elements, ten_gods, daeun, birth_datetime, gender
 
 """
     
-    calculator = SajuCalculator()
-    
     # 오행 분석 추가
     total_elements = sum(elements.values())
     for element, count in elements.items():
@@ -359,10 +283,7 @@ def format_saju_result(ganzhi, elements, ten_gods, daeun, birth_datetime, gender
 ### 오행 균형 분석
 - **가장 강한 오행**: {max_element} ({elements[max_element]}개)
 - **가장 약한 오행**: {min_element} ({elements[min_element]}개)
-"""
 
-    # 십신 분석 추가
-    result += """
 ## 🎭 십신(十神) 분석
 
 """
@@ -373,18 +294,8 @@ def format_saju_result(ganzhi, elements, ten_gods, daeun, birth_datetime, gender
         result += f"- 천간: {ten_gods[pillar_name]['stem_relation']}\n"
         result += f"- 지지: {ten_gods[pillar_name]['branch_relation']}\n\n"
 
-    # 대운 정보 추가
-    result += """
-## 🔄 대운(大運) 정보
-
-"""
-    
-    for i, du in enumerate(daeun[:4]):  # 처음 4개 대운만 표시
-        result += f"**{du['period']}** ({du['years']})\n"
-
     # 기본 해석 추가
     result += f"""
-
 ## 💡 기본 해석
 
 ### 성격 특���
@@ -400,38 +311,13 @@ def format_saju_result(ganzhi, elements, ten_gods, daeun, birth_datetime, gender
 - 절기, 시간대, 지역별 차이 등이 고려되지 않았을 수 있습니다.
 
 ---
-*생성일시: {datetime.now().strftime('%Y년 %m월 %d일 %H시 %M분')}*
+*생성일시: {datetime.datetime.now().strftime('%Y년 %m월 %d일 %H시 %M분')}*
 """
     
     return result
 
-def get_element_personality(element):
-    """오행별 성격 특성"""
-    personalities = {
-        '목': "창의적이고 성장 지향적이며, 유연하고 협력적인 성격을 가지고 있습니다.",
-        '화': "열정적이고 활동적이며, 밝고 사교적인 성격을 가지고 있습니다.",
-        '토': "안정적이고 신중하며, 포용력이 있고 책임감이 강한 성격을 가지고 있습니다.",
-        '금': "원칙적이고 정의로우며, 결단력이 있고 리더십이 강한 성격을 가지고 있습니다.",
-        '수': "지혜롭고 적응력이 있으며, 깊이 있고 신중한 성격을 가지고 있습니다."
-    }
-    return personalities.get(element, "균형 잡힌 성격을 가지고 있습니다.")
-
-def get_element_balance_advice(elements):
-    """오행 균형에 따른 조언"""
-    max_element = max(elements, key=elements.get)
-    min_element = min(elements, key=elements.get)
-    
-    advice = f"현재 {max_element}가 가장 강하고 {min_element}가 가장 약합니다. "
-    
-    if elements[max_element] - elements[min_element] > 2:
-        advice += f"{min_element}를 보강하고 {max_element}의 기운을 조절하는 것이 좋겠습니다."
-    else:
-        advice += "전체적으로 균형이 잘 잡혀 있는 편입니다."
-    
-    return advice
-
-# Gradio 인터페이스 생성
 def create_interface():
+    """Gradio 인터페이스 생성"""
     with gr.Blocks(title="🔮 사주명리 만세력 시스템") as demo:
         gr.HTML("""
         <div style="text-align: center; padding: 20px;">
@@ -446,14 +332,14 @@ def create_interface():
                 
                 birth_date = gr.Textbox(
                     label="생년월일",
-                    placeholder="19900515 또는 1990-5-15 또는 1990/5/15",
-                    info="숫자만 입력해도 됩니다 (예: 19900515, 1990515, 90515)"
+                    placeholder="19900207 또는 1990-2-7",
+                    info="8자리 숫자 또는 구분자 포함하여 입력"
                 )
                 
                 birth_time = gr.Textbox(
                     label="태어난 시간 (선택사항)",
-                    placeholder="1430 또는 14:30 또는 오후2시30분",
-                    info="숫자만 입력해도 됩니다 (예: 1430, 14시30분, 230). 비우면 정오(12시)로 설정"
+                    placeholder="0815 또는 8:15",
+                    info="4자리 숫자 또는 구분자 포함하여 입력. 비우면 정오로 설정"
                 )
                 
                 gender = gr.Radio(
@@ -464,7 +350,7 @@ def create_interface():
                 
                 birth_place = gr.Textbox(
                     label="출생지",
-                    placeholder="서울특별시",
+                    placeholder="대구",
                     info="시/도 단위로 입력해주세요"
                 )
                 
@@ -488,7 +374,7 @@ def create_interface():
         
         # 예시 데이터로 자동 실행
         demo.load(
-            fn=lambda: calculate_saju("19900515", "1430", "남", "서울특별시"),
+            fn=lambda: calculate_saju("19900207", "0815", "여", "대구"),
             outputs=result_output
         )
         
@@ -501,9 +387,6 @@ def create_interface():
     
     return demo
 
-# 전역 변수로 계산기 인스턴스 생성
-calculator = SajuCalculator()
-
 if __name__ == "__main__":
     demo = create_interface()
     demo.launch(