Upload 16 files

app.py

@@ -1,127 +1,157 @@
-
 import gradio as gr
-from interface.portfolio_rebalancing_interface import examples ,portfolio_inputs, output as portpolio_output, update_output as portpolio_update_output
-from interface.compare_stock_prices_interface import compare_inputs, output as compare_output, update_output as compare_update_output
-from interface.cost_averaging_interface import cost_averaging_inputs, output, update_output, markdown1, old_price, old_quantity, markdown2, new_price, new_quantity
-from interface.retirement_planning_interface import retirement_planning_inputs, output as retirement_output, update_output as retirement_update_output
+from interface.rebalancing_interface import examples, rebalancing_inputs, output as rebalancing_output, update_output as rebalancing_update_output
+from interface.share_price_trend_interface import share_price_trend_inputs, output as share_price_trend_output, update_output as share_price_trend_update_output
+from interface.dollar_cost_averaging_interface import dollar_cost_averaging_inputs, output as dollar_cost_averaging_output, update_output as dollar_cost_averaging_update_output, markdown1 as dollar_cost_averaging_markdown1, old_price, old_quantity, markdown2 as dollar_cost_averaging_markdown2, new_price, new_quantity
+from interface.retirement_planning_interface import (
+    current_age, retirement_age, life_expectancy, monthly_income_required, inflation_rate, current_investment, monthly_investment, annual_increase_in_monthly_investment, reinvest_dividends, pre_retirement_roi, pre_retirement_dividend_yield, post_retirement_roi, post_retirement_dividend_yield, output as retirement_output, update_output as retirement_update_output
+)
 from interface.about_interface import render as render_about_tab
 
 with gr.Blocks(css='style.css') as demo:
     with gr.Column(elem_id="col-container"):
         with gr.Tabs():
-            with gr.TabItem("🗺️🔍Portfolio"):
+            with gr.TabItem("RE-BALANCING"):
                 with gr.Row():  # Use Row to place inputs and output side by side
                     with gr.Column():  # Column for inputs
-                        for input_component in portfolio_inputs:
+                        for input_component in rebalancing_inputs:
                             input_component.render()
                         # Add the ClearButton below the inputs
                         clear_button = gr.ClearButton(value="Clear")
                         clear_button.click(
-                            fn=lambda: [None] * len(portfolio_inputs),
+                            fn=lambda: [None] * len(rebalancing_inputs),
                             inputs=[],
-                            outputs=portfolio_inputs
+                            outputs=rebalancing_inputs
                         )
                                 
                         # Add the Submit Button below the ClearButton
                         submit_button = gr.Button(value="Run", variant="primary")
                         submit_button.click(
-                            fn=portpolio_update_output,
-                            inputs=portfolio_inputs,
-                            outputs=portpolio_output
+                            fn=rebalancing_update_output,
+                            inputs=rebalancing_inputs,
+                            outputs=rebalancing_output
                         )
                     with gr.Column():  # Column for output
-                        portpolio_output.render()
+                        rebalancing_output.render()
                 
-                # Add change event handlers for Portfolio inputs
-                # for input_component in portfolio_inputs:
-                #     input_component.change(
-                #         fn=portpolio_update_output,
-                #         inputs=portfolio_inputs,
-                #         outputs=portpolio_output
-                #     )            
                 # Add examples
                 gr.Examples(
                     examples=examples,
                     cache_examples=False,
-                    inputs=portfolio_inputs
+                    inputs=rebalancing_inputs
                 )
-            with gr.TabItem("Compare"):
+            with gr.TabItem("SHARE PRICE TREND"):
                 with gr.Row():  # Use Row to place inputs and output side by side
                     with gr.Column():  # Column for inputs
-                        for input_component in compare_inputs:
+                        for input_component in share_price_trend_inputs:
                             input_component.render()
                         # Add the ClearButton below the inputs
                         clear_button = gr.ClearButton(value="Clear")
                         clear_button.click(
-                            fn=lambda: [None] * len(compare_inputs),
+                            fn=lambda: [None] * len(share_price_trend_inputs),
                             inputs=[],
-                            outputs=compare_inputs
+                            outputs=share_price_trend_inputs
                         )
                                 
                         # Add the Submit Button below the ClearButton
                         submit_button = gr.Button(value="Run", variant="primary")
                         submit_button.click(
-                            fn=compare_update_output,
-                            inputs=compare_inputs,
-                            outputs=compare_output
+                            fn=share_price_trend_update_output,
+                            inputs=share_price_trend_inputs,
+                            outputs=share_price_trend_output
                         )
                     with gr.Column():  # Column for output
-                        compare_output.render()
+                        share_price_trend_output.render()
                 
-                # Add change event handlers for Compare inputs
-                # for input_component in compare_inputs:
-                #     input_component.change(
-                #         fn=compare_update_output,
-                #         inputs=compare_inputs,
-                #         outputs=compare_output
-                #     )
-            with gr.TabItem("Cost Averaging"):
+            with gr.TabItem("DOLLAR-COST AVERAGING"):
                 with gr.Row():  # Use Row to place inputs and output side by side
                     with gr.Column():  # Column for inputs
-                        markdown1.render()
+                        dollar_cost_averaging_markdown1.render()
                         old_price.render()
                         old_quantity.render()
-                        markdown2.render()
+                        dollar_cost_averaging_markdown2.render()
                         new_price.render()
                         new_quantity.render()
                         # Add the ClearButton below the inputs
                         clear_button = gr.ClearButton(value="Clear")
                         clear_button.click(
-                            fn=lambda: [None] * len(cost_averaging_inputs),
+                            fn=lambda: [None] * len(dollar_cost_averaging_inputs),
                             inputs=[],
-                            outputs=cost_averaging_inputs
+                            outputs=dollar_cost_averaging_inputs
                         )
                     with gr.Column():  # Column for output
-                        output.render()
+                        dollar_cost_averaging_output.render()
 
                 # Add change event handlers for cost averaging inputs
-                cost_averaging_inputs[0].change(fn=update_output, inputs=cost_averaging_inputs, outputs=output)
-                cost_averaging_inputs[1].change(fn=update_output, inputs=cost_averaging_inputs, outputs=output)
-                cost_averaging_inputs[2].change(fn=update_output, inputs=cost_averaging_inputs, outputs=output)
-                cost_averaging_inputs[3].change(fn=update_output, inputs=cost_averaging_inputs, outputs=output)
+                for input_component in dollar_cost_averaging_inputs:
+                    input_component.change(
+                        fn=dollar_cost_averaging_update_output,
+                        inputs=dollar_cost_averaging_inputs,
+                        outputs=dollar_cost_averaging_output
+                    )
                 
-            with gr.TabItem("Retirement Planning"):
+            with gr.TabItem("RETIREMENT PLANNING"):
                 with gr.Row():  # Use Row to place inputs and output side by side
                     with gr.Column():  # Column for inputs
-                        for input_component in retirement_planning_inputs:
-                            input_component.render()
-                        # Add the ClearButton below the inputs
-                        clear_button = gr.ClearButton(value="Clear")
-                        clear_button.click(
-                            fn=lambda: [None] * len(retirement_planning_inputs),
-                            inputs=[],
-                            outputs=retirement_planning_inputs
-                        )
-                    with gr.Column():  # Column for output
+
+                        gr.Markdown("### Profile")
+                        with gr.Row():
+                            current_age.render()
+                            retirement_age.render()
+                            life_expectancy.render()
+                            monthly_income_required.render()
+                            inflation_rate.render()         
+
+                        gr.Markdown("### Savings")
+                        with gr.Row():
+                            current_investment.render()
+                            monthly_investment.render()
+                            annual_increase_in_monthly_investment.render()  # 추가된 입력
+                            reinvest_dividends.render()
+                        
+                        gr.Markdown("### Growth")
+                        with gr.Row():
+                            pre_retirement_roi.render()
+                            pre_retirement_dividend_yield.render()
+                            # retirement_markdown.render()
+                            post_retirement_roi.render()
+                            post_retirement_dividend_yield.render()
+
+                    
+                        # # Add the ClearButton below the inputs
+                        # clear_button = gr.ClearButton(value="Clear")
+                        # clear_button.click(
+                        #     fn=lambda: [None] * len([
+                        #         current_age, retirement_age, life_expectancy, monthly_income_required, inflation_rate, current_investment, monthly_investment, annual_increase_in_monthly_investment, reinvest_dividends, pre_retirement_roi, pre_retirement_dividend_yield, post_retirement_roi, post_retirement_dividend_yield
+                        #     ]),
+                        #     inputs=[],
+                        #     outputs=[
+                        #         current_age, retirement_age, life_expectancy, monthly_income_required, inflation_rate, current_investment, monthly_investment, annual_increase_in_monthly_investment, reinvest_dividends, pre_retirement_roi, pre_retirement_dividend_yield, post_retirement_roi, post_retirement_dividend_yield
+                        #     ]
+                        # )
+                        # # Add the Submit Button below the ClearButton
+                        # submit_button = gr.Button(value="Run", variant="primary")
+                        # submit_button.click(
+                        #     fn=retirement_update_output,
+                        #         inputs=[
+                        #         current_age, retirement_age, life_expectancy, monthly_income_required, inflation_rate, current_investment, monthly_investment, annual_increase_in_monthly_investment, reinvest_dividends, pre_retirement_roi, pre_retirement_dividend_yield, post_retirement_roi, post_retirement_dividend_yield
+                        #     ],
+                        #     outputs=retirement_output
+                        # )                            
+                    with gr.Column():
                         retirement_output.render()
-                
+
                 # Add change event handlers for retirement planning inputs
-                for input_component in retirement_planning_inputs:
+                for input_component in [
+                    current_age, retirement_age, life_expectancy, monthly_income_required, inflation_rate, current_investment, monthly_investment, annual_increase_in_monthly_investment, reinvest_dividends, pre_retirement_roi, pre_retirement_dividend_yield, post_retirement_roi, post_retirement_dividend_yield
+                ]:
                     input_component.change(
                         fn=retirement_update_output,
-                        inputs=retirement_planning_inputs,
+                        inputs=[
+                            current_age, retirement_age, life_expectancy, monthly_income_required, inflation_rate, current_investment, monthly_investment, annual_increase_in_monthly_investment, reinvest_dividends, pre_retirement_roi, pre_retirement_dividend_yield, post_retirement_roi, post_retirement_dividend_yield
+                        ],
                         outputs=retirement_output
                     )
+                    
             render_about_tab()
 
 demo.launch(share=True)

interface/about_interface.py

@@ -1,8 +1,7 @@
 import gradio as gr
 
 def render():    
-    with gr.TabItem("💡 How To Use"):
-        gr.Markdown("## How To Use:")
+    with gr.TabItem("💡 HINT"):
         
         def create_tool_section(tool_name, korean_description, english_description):
             with gr.Accordion(tool_name, open=False):
@@ -13,311 +12,503 @@ def render():
 
         # Portfolio Rebalancing Tool Section
         create_tool_section(
-            "Portfolio",
+            "RE-BALANCING CALCULATOR",
             """
-            # 포트폴리오 리밸런싱 도구
+            ## 📊 리밸런싱 계산기
 
-            이 도구는 투자자들이 현재 보유 자산을 분석하고 목표 배분을 달성하기 위해 매수/매도 조치를 제안하여 포트폴리오를 재조정하는 데 도움을 줍니다. 다양한 주식 코드, 통화 및 원하는 목표 비율을 고려하여 포트폴리오를 조정하는 방법에 대한 자세한 정보를 제공합니다.
+            이 도구는 주어진 주식 보유량, 현금 금액 및 현금 비율을 바탕으로 포트폴리오를 분석하고 재조정합니다. 
 
-            ## 주요 기능
-            - **다중 통화 지원**: 모든 금액은 메인 통화로 변환됩니다.
-            - **상세 분석**: 현재 포트폴리오, 통화 배분 및 리밸런싱 권장 사항을 표시합니다. 리밸런싱 계산시 1주단위로 계산됩니다.
+            ### 입력값
 
-            ## 사용 방법
-            1. **포트폴리오 세부 정보 입력**: 지정된 형식으로 `주식코드 통화 보유수량 목표비중`을 입력합니다. 종목안의 항목들은 띄어쓰기로 구분합니다. 여러 주식종목을 (,)로 구분합니다.
-            2. **현금 금액 및 비율 설정**: 유지하려는 현금 금액 및 비율(%)을 지정합니다.
+            - **주식 보유량 (holdings)**: 각 주식의 코드, 통화 코드, 수량, 목표 비율을 입력합니다. 여러 주식 종목은 쉼표로 구분하여 입력합니다. 예: `AAPL USD 10 0.30,TSLA USD 5 0.20` 
+            - **현금 금액 (cash_amount)**: 포트폴리오에 포함된 현금의 금액입니다. 예: `1000`
+            - **현금 비율 (cash_ratio)**: 포트폴리오에서 현금이 차지하는 비율입니다. 예: `10` (10%)
 
-            ## 예제 입력
-            ```
-            AAPL USD 100 2,
-            TSLA USD 50 1,
-            005930 KRW 200 3
-            ```
-            - `AAPL USD 100 2`: USD로 된 Apple (AAPL) 주식 100주, 목표 비중 2.
-            - `TSLA USD 50 1`: USD로 된 Tesla (TSLA) 주식 50주, 목표 비중 1.
-            - `005930 KRW 200 3`: KRW로 된 삼성전자 (005930) 주식 200주, 목표 비중 3.
+            ### 기능
 
-            ## 중요 사항
+            1. **입력 파싱**: 주식 보유량, 현금 금액 및 비율을 분석하여 각 주식의 목표 비율을 계산합니다.
+            2. **환율 조회**: 각 주식의 통화 코드와 메인 통화 간의 환율을 조회하여 주식 가격을 변환합니다.
+            3. **포트폴리오 구축**: 주식과 현금 정보를 바탕으로 포트폴리오를 구축합니다.
+            4. **포트폴리오 재조정 정보 제공**: 현재 포트폴리오의 가치와 목표 비율을 비교하여 재조정 필요성을 분석합니다.
+            - **현재 보유량 및 가치**: 각 주식 및 현금의 현재 보유량과 가치를 계산합니다.
+            - **재조정 항목**: 목표 비율에 맞추기 위해 매수 또는 매도해야 할 주식 수량과 금액을 계산합니다.
+            - **통화별 요약**: 포트폴리오의 통화별 분포를 요약합니다.
+
+            ### 결과
+
+            - **포트폴리오 정보**: 현재 포트폴리오의 총 가치 및 현금 정보를 포함한 HTML 코드입니다.
+            - **현재 보유량 및 가치**: 각 주식의 현재 비율 및 가치에 대한 정보입니다.
+            - **재조정 분석**: 주식의 매수/매도 조정이 필요한 항목 및 금액에 대한 상세 분석입니다.
+            - **통화별 요약**: 포트폴리오의 통화별 비율 및 총 가치를 요약한 정보입니다.
+
+            이 도구를 통해 포트폴리오를 효율적으로 재조정하고, 주식 및 현금의 비율을 최적화할 수 있습니다! 📈💼
+
+            ### 중요 사항
             - 주식 코드와 통화 코드가 유효한지 확인하세요.
             - 이 도구는 주가와 환율의 실시간 데이터를 사용하므로 인터넷 연결이 필요합니다.
             - Yahoo Finance 및 FinanceDataReader의 데이터를 사용합니다.
 
-            ## 면책 조항
+            ### 면책 조항
             이 도구에서 제공하는 정보는 일반적인 정보 제공 목적만을 위해 제공됩니다. 사이트의 모든 정보는 선의로 제공되지만, 사이트의 정보의 정확성, 적절성, 유효성, 신뢰성, 가용성 또는 완전성에 대해 ���시적이든 묵시적이든 어떠한 종류의 진술이나 보증을 하지 않습니다. 사이트의 사용과 사이트의 정보를 신뢰하는 것은 전적으로 사용자의 책임입니다.
             """,
             """
-            # Portfolio Rebalancing Tool
+            ## 📊 RE-BALANCING CALCULATOR
+
+            This tool analyzes and rebalances a portfolio based on given stock holdings, cash amount, and cash ratio.
 
-            This tool helps investors rebalance their portfolios by analyzing their current holdings and suggesting buy/sell actions to achieve target allocations. It provides detailed information on how to adjust the portfolio, considering various stock codes, currencies, and desired target ratios.
+            ### Input Values
 
-            ## Key Features
-            - **Multi-currency Support**: All amounts are converted to the main currency.
-            - **Detailed Analysis**: Displays current portfolio, currency allocation, and rebalancing recommendations. Rebalancing is calculated on a per-share basis.
+            - **Stock Holdings (holdings)**: Enter the stock code, currency code, quantity, and target weight for each stock. Separate multiple stocks with commas. Example: `AAPL USD 10 0.30,TSLA USD 5 0.20`
+            - **Cash Amount (cash_amount)**: The amount of cash in the portfolio. Example: `1000`
+            - **Cash Ratio (cash_ratio)**: The proportion of cash in the portfolio. Example: `10` (10%)
 
-            ## How to Use
-            1. **Enter Portfolio Details**: Enter `stock code currency quantity target ratio` in the specified format. Separate items within a stock with spaces. Separate multiple stock items with commas.
-            2. **Set Cash Amount and Ratio**: Specify the cash amount and ratio (%) you want to maintain.
+            ### Functionality
 
-            ## Example Input
-            ```
-            AAPL USD 100 2,
-            TSLA USD 50 1,
-            005930 KRW 200 3
-            ```
-            - `AAPL USD 100 2`: 100 shares of Apple (AAPL) in USD, target ratio 2.
-            - `TSLA USD 50 1`: 50 shares of Tesla (TSLA) in USD, target ratio 1.
-            - `005930 KRW 200 3`: 200 shares of Samsung Electronics (005930) in KRW, target ratio 3.
+            1. **Parse Input**: Analyzes stock holdings, cash amount, and ratio to calculate the target weights for each stock.
+            2. **Exchange Rate Lookup**: Retrieves exchange rates between each stock's currency code and the main currency to convert stock prices.
+            3. **Build Portfolio**: Constructs the portfolio based on stock and cash information.
+            4. **Get Portfolio Rebalancing Information**: Compares the current portfolio value and target weights to analyze rebalancing needs.
+            - **Current Holdings and Value**: Calculates the current holdings and value of each stock and cash.
+            - **Rebalancing Items**: Calculates the quantities and amounts of stocks to buy or sell to meet target weights.
+            - **Currency Summary**: Summarizes the portfolio's distribution by currency.
 
-            ## Important Notes
+            ### Results
+
+            - **Portfolio Information**: HTML code containing the total value of the current portfolio and cash information.
+            - **Current Holdings and Value**: Information on the current weights and values of each stock.
+            - **Rebalancing Analysis**: Detailed analysis of the adjustments needed to buy/sell stocks to meet target weights.
+            - **Currency Summary**: Summary of portfolio distribution by currency, including total value.
+
+            Use this tool to efficiently rebalance your portfolio and optimize the ratio of stocks and cash! 📈💼
+
+            ### Important Notes
             - Ensure stock codes and currency codes are valid.
             - This tool requires an internet connection as it uses real-time stock prices and exchange rates.
             - Data is sourced from Yahoo Finance and FinanceDataReader.
 
-            ## Disclaimer
+            ### Disclaimer
             The information provided by this tool is for general informational purposes only. All information on the site is provided in good faith, but we make no representation or warranty of any kind, express or implied, regarding the accuracy, adequacy, validity, reliability, availability, or completeness of any information on the site. Your use of the site and reliance on any information on the site is solely at your own risk.
             """
         )
 
         # Stock Comparison Tool Section
         create_tool_section(
-            "Compare",
+            "STOCK PRICE TREND VISUALIZATION",
             """
-            # 주식 그래프 비교 도구
-
-            이 도구는 사용자가 지정한 기간 동안 여러 회사의 상대 주가를 비교할 수 있도록 합니다. 역사적인 주가를 가져와 상대 성능을 보여주도록 정상화하고 비교 그래프를 생성합니다.
-
-            ## 주요 기능
-            - **주식 비교**: 사용��가 정의한 기간 동안 여러 주식의 성능을 비교합니다.
-            - **상대적 가격비교**: 가격을 동일한 기준선에서 시작하는 상대적인 변화를 보여주도록 합니다.
-
-            ## 사용 방법
-            1. **주식 코드 입력**: 쉼표로 구분된 주식 코드 목록을 제공합니다 (예: `AAPL, GOOGL, TSLA`).
-            2. **날짜 수 지정**: 주가를 비교할 기간의 날짜 수를 입력합니다.
-            3. **출력**: 주가를 가져와 비교 그래프를 표시합니다.
-
-            ## 예제 입력
-            - `주식 코드`: AAPL, GOOGL, TSLA
-            - `날짜 수`: 30
-
-            ## 예제 출력
-            - Apple (AAPL), Google (GOOGL), Tesla (TSLA)의 최근 30일간의 상대 주가를 비교하는 그래프.
-
-            ## 중요 사항
-            - 모든 주식 코드가 유효하고 데이터 소스에서 지원하는지 확인하세요.
-            - 도구는 영업일 기준으로 데이터를 가져오므로 주말 및 공휴일은 제외됩니다.
-            - 이 도구는 주가 데이터를 사용하므로 인터넷 연결이 필요합니다.                
-            - FinanceDataReader를 사용하여 주가 데이터를 가져옵니다.
-            - 그래픽 시각화를 위해 matplotlib을 사용하여 개발되었습니다.
-                
-            ## 면책 조항
+            ## 📈 주식 가격 추세 시각화
+
+            이 코드는 주어진 주식 코드들의 가격 추세를 시각화합니다. 여러 주식의 가격을 추적하고 비교하기 위해 사용됩니다. 📊
+
+            ### 입력값
+
+            - **주식 코드 (stock_codes)**: 가격을 추적할 주식의 코드들입니다. 쉼표로 구분된 문자열 형식으로 입력합니다. 예: `AAPL,GOOGL,MSFT`
+            - **일수 (days)**: 가격을 조회할 기간입니다. 예: `30` (최근 30일)
+
+            ### 기능
+
+            1. **주식 가격 데이터 가져오기**: 주어진 주식 코드와 기간에 대해 주식 가격 데이터를 가져옵니다.
+            2. **가격 변동 시각화**: 각 주식의 가격 변동을 시각화하여 비교할 수 있는 그래프를 생성합니다.
+            - **상대 가격**: 각 주식의 가격을 처음 가격에 대해 상대적으로 변동을 보여줍니다.
+            - **스타일**: 그래프에는 색상 그라디언트와 그림자 효과가 적용됩니다.
+            - **애니메이션**: 선의 애니메이션 효과가 추가되어 시각적으로 더욱 매력적입니다.
+            3. **데이터 테이블 생성**: 각 날짜와 주식의 가격을 포함한 HTML 테이블을 생성합니다.
+
+            ### 결과
+
+            - **그래프**: 최근 `days` 일 동안의 상대 주식 가격 추세를 보여주는 그래프입니다.
+            - **데이터 테이블**: 날짜별로 각 주식의 가격을 포함하는 HTML 테이블입니다.
+
+            ### 사용 예제
+
+            주식 코드와 기간을 입력하면, 다음과 같은 결과를 얻을 수 있습니다:
+
+            - **주식 코드**: `AAPL,GOOGL,MSFT`
+            - **일수**: `30`
+
+            결과는 최근 30일 동안의 주식 가격 변동을 보여주는 그래프와 데이터 테이블이 포함됩니다.
+
+            이 도구를 통해 주식 가격의 변동 추세를 한눈에 확인하고 분석할 수 있습니다! 📈💡
+
+            ### 중요 사항
+            - 주식 코드가 유효한지 확인하세요.
+            - 이 도구는 주가의 실시간 데이터를 사용하므로 인터넷 연결이 필요합니다.
+            - Yahoo Finance 및 FinanceDataReader의 데이터를 사용합니다.
+
+            ### 면책 조항
             이 도구에서 제공하는 정보는 일반적인 정보 제공 목적만을 위해 제공됩니다. 사이트의 모든 정보는 선의로 제공되지만, 사이트의 정보의 정확성, 적절성, 유효성, 신뢰성, 가용성 또는 완전성에 대해 명시적이든 묵시적이든 어떠한 종류의 진술이나 보증을 하지 않습니다. 사이트의 사용과 사이트의 정보를 신뢰하는 것은 전적으로 사용자의 책임입니다.
             """,
             """
-            # Stock Comparison Tool
+            ## 📈 Stock Price Trend Visualization
+
+            This script visualizes the price trends of given stock codes over a specified period. It allows you to track and compare the price movements of multiple stocks. 📊
+
+            ### Input Values
+
+            - **Stock Codes (stock_codes)**: The codes of the stocks you want to track. Enter them as a comma-separated string. Example: `AAPL,GOOGL,MSFT`
+            - **Days (days)**: The period for which you want to fetch the price data. Example: `30` (last 30 days)
 
-            This tool allows users to compare the relative prices of multiple companies over a specified period. It fetches historical stock prices, normalizes them to show relative performance, and generates a comparison graph.
+            ### Functionality
 
-            ## Key Features
-            - **Stock Comparison**: Compare the performance of multiple stocks over a user-defined period.
-            - **Relative Price Comparison**: Shows relative changes starting from the same baseline.
+            1. **Fetch Stock Price Data**: Retrieves stock price data for the given stock codes and period.
+            2. **Visualize Price Trends**: Creates a graph to visualize and compare the price trends of each stock.
+            - **Relative Price**: Shows each stock's price relative to its initial price.
+            - **Style**: The graph includes color gradients and shadow effects.
+            - **Animation**: Line animation effects are added for visual appeal.
+            3. **Generate Data Table**: Creates an HTML table with the price data for each stock and date.
 
-            ## How to Use
-            1. **Enter Stock Codes**: Provide a comma-separated list of stock codes (e.g., `AAPL, GOOGL, TSLA`).
-            2. **Specify Number of Days**: Enter the number of days for the comparison period.
-            3. **Output**: Fetches stock prices and displays a comparison graph.
+            ### Results
 
-            ## Example Input
-            - `Stock Codes`: AAPL, GOOGL, TSLA
-            - `Number of Days`: 30
+            - **Graph**: A graph showing the relative stock price trends over the last `days` days.
+            - **Data Table**: An HTML table displaying the prices of each stock by date.
 
-            ## Example Output
-            - A graph comparing the relative stock prices of Apple (AAPL), Google (GOOGL), and Tesla (TSLA) over the last 30 days.
+            ### Example Usage
 
-            ## Important Notes
-            - Ensure all stock codes are valid and supported by the data source.
-            - The tool fetches data based on trading days, excluding weekends and holidays.
-            - An internet connection is required as the tool uses stock price data.
-            - Data is sourced from FinanceDataReader.
-            - Developed using matplotlib for graphical visualization.
+            Given stock codes and days, you can obtain results such as:
 
-            ## Disclaimer
+            - **Stock Codes**: `AAPL,GOOGL,MSFT`
+            - **Days**: `30`
+
+            The result will include a graph showing the price trends over the last 30 days and an HTML table with the price data.
+
+            Use this tool to easily analyze and visualize stock price movements! 📈💡
+
+            ### Important Notes
+            - Ensure stock codes are valid.
+            - This tool requires an internet connection as it uses real-time stock prices.
+            - Data is sourced from Yahoo Finance and FinanceDataReader.
+
+            ### Disclaimer
             The information provided by this tool is for general informational purposes only. All information on the site is provided in good faith, but we make no representation or warranty of any kind, express or implied, regarding the accuracy, adequacy, validity, reliability, availability, or completeness of any information on the site. Your use of the site and reliance on any information on the site is solely at your own risk.
             """
         )
 
         # Cost Averaging Tool Section
         create_tool_section(
-            "Cost Averaging",
+            "DOLLAR-COST AVERAGING CALCULATOR",
             """
-            # 물타기 계산 도구
-
-            이 도구는 투자자가 다른 가격으로 추가 주식을 매수한 후 새로운 평균 매수 단가와 수익률을 계산하는 데 도움을 줍니다. 새로운 투자가 전체 비용 기반과 잠재적 수익에 미치는 영향을 이해하는 데 유용합니다.
-
-            ## 사용 방법
-            1. **현재 투자 세부 정보 입력**: 보유한 주식의 평균 가격과 수량을 제공합니다.
-            2. **새로운 매수 세부 정보 입력**: 매수하려는 주식의 가격과 수량을 제공합니다.
-            3. **출력**: 도구는 새로운 평균 가격, 총 수량, 추가 투자액, 총 투자액 및 새로운 수익률을 계산하고 표시합니다.
-
-            ## 예제 입력
-            - `이전 평균 가격`: 100
-            - `이전 수량`: 50
-            - `새로운 가격`: 120
-            - `새로운 수량`: 30
-
-            ## 예제 출력
-            - `수익률`: 11.1%                        
-            - `새로운 평균 가격`: 108
-            - `총 수량`: 80
-            - `추가 투자금`: 3600
-            - `총 투자금`: 8640
-
-            ## 중요 사항
-            - 모든 입력이 유효한 숫자인지 확인하세요.
-            - 도구는 이전 및 새로운 투자의 가중 평균을 기반으로 새로운 평균 가격을 계산합니다.
-            - 사용하기 쉬운 사용자 인터페이스 생성을 위해 Gradio를 사용하여 개발되었습니다.
-            - 실시간 계산 및 즉각���인 피드백을 지원합니다.
-                
-            ## 면책 조항
+            ## 💸 물타기 계산기
+
+            물타기(Dollar-Cost Averaging, DCA) 계산기를 이용해 보세요! 이 계산기는 특정 주식에 대한 추가 투자를 할 때 평균 구매 가격을 계산해줍니다. 📈
+
+            ### 입력값 설정 📊
+
+            다음의 값을 입력해 주세요:
+
+            - **이전 평균 가격 (old_avg_price)**: 기존 주식의 평균 가격 💵
+            - **이전 수량 (old_quantity)**: 기존 주식의 수량 📦
+            - **새 가격 (new_price)**: 새로 구매한 주식의 가격 💲
+            - **새 수량 (new_quantity)**: 새로 구매한 주식의 수량 📈
+
+            ### 계산 방법 🔢
+
+            1. **현재 투자 금액 계산**: 이전 평균 가격과 이전 수량을 곱하여 현재 투자 금액을 계산합니다.
+            2. **추가 투자 금액 계산**: 새 가격과 새 수량을 곱하여 추가 투자 금액을 계산합니다.
+            3. **총 투자 금액 및 총 주식 수 계산**: 현재 투자 금액과 추가 투자 금액을 합쳐서 총 투자 금액을 계산하고, 이전 수량과 새 수량을 더하여 총 주식 수를 계산합니다.
+            4. **새 평균 가격 계산**: 총 투자 금액을 총 주식 수로 나누어 새로운 평균 가격을 계산합니다.
+            5. **수익률 계산**: 이전과 새로운 수익률을 계산하여 투자 결과를 분석합니다.
+
+            ### 결과 🎯
+
+            **1) 이전 수익률 (Old Return)**
+
+            이전 평균 가격을 기준으로 한 수익률을 표시합니다.
+
+            **2) 새로운 수익률 (New Return)**
+
+            새로운 평균 가격을 기준으로 한 수익률을 표시합니다.
+
+            **3) 추가 투자 금액 (Additional Investment)**
+
+            추가로 투자한 금액을 표시합니다.
+
+            **4) 새로운 평균 가격 (Average Price)**
+
+            새롭게 계산된 평균 가격을 표시합니다.
+
+            **5) 총 수량 (Total Quantity)**
+
+            총 주식 수량을 표시합니다.
+
+            **6) 총 투자 금액 (Total Investment)**
+
+            총 투자 금액을 표시합니다.
+
+            ### 예제 📉
+
+            - **이전 평균 가격**: 100
+            - **이전 수량**: 10
+            - **새 가격**: 120
+            - **새 수량**: 5
+
+            결과:
+            - 새로운 평균 가격: 105
+            - 총 수량: 15
+            - 총 투자 금액: 1,575
+            - 이전 수익률: 20.00%
+            - 새로운 수익률: 14.29%
+            - 추가 투자 금액: 600
+
+            물타기 계산기를 통해 투자의 평균 구매 가격을 쉽게 계산해 보세요! 📊💰
+
+            ### 면책 조항
             이 도구에서 제공하는 정보는 일반적인 정보 제공 목적만을 위해 제공됩니다. 사이트의 모든 정보는 선의로 제공되지만, 사이트의 정보의 정확성, 적절성, 유효성, 신뢰성, 가용성 또는 완전성에 대해 명시적이든 묵시적이든 어떠한 종류의 진술이나 보증을 하지 않습니다. 사이트의 사용과 사이트의 정보를 신뢰하는 것은 전적으로 사용자의 책임입니다.                
             """,
             """
-            # Cost Averaging Calculator
-
-            This tool helps investors calculate the new average purchase price and yield after purchasing additional shares at different prices. It is useful for understanding the impact of new investments on the overall cost basis and potential returns.
-
-            ## How to Use
-            1. **Enter Current Investment Details**: Provide the average price and quantity of the shares you hold.
-            2. **Enter New Purchase Details**: Provide the price and quantity of the shares you want to purchase.
-            3. **Output**: The tool calculates and displays the new average price, total quantity, additional investment amount, total investment amount, and new yield.
-
-            ## Example Input
-            - `Previous Average Price`: 100
-            - `Previous Quantity`: 50
-            - `New Price`: 120
-            - `New Quantity`: 30
-
-            ## Example Output
-            - `Return`: 11.1%
-            - `New Average Price`: 108
-            - `Total Quantity`: 80
-            - `Additional Investment Amount`: 3600
-            - `Total Investment Amount`: 8640
-
-            ## Important Notes
-            - Ensure all inputs are valid numbers.
-            - The tool calculates the new average price based on the weighted average of previous and new investments.
-            - Developed using Gradio for an easy-to-use user interface.
-            - Supports real-time calculations and instant feedback.
-
-            ## Disclaimer
+            ## 💸 Dollar-Cost Averaging Calculator
+
+            Try out the Dollar-Cost Averaging (DCA) calculator! This tool helps you calculate the average purchase price of stocks when making additional investments. 📈
+
+            ### Input Values 📊
+
+            Please enter the following details:
+
+            - **Old Average Price (old_avg_price)**: The average price of the existing stocks 💵
+            - **Old Quantity (old_quantity)**: The quantity of the existing stocks 📦
+            - **New Price (new_price)**: The price of the newly purchased stocks 💲
+            - **New Quantity (new_quantity)**: The quantity of the newly purchased stocks 📈
+
+            ### Calculation Process 🔢
+
+            1. **Current Investment**: Calculate the current investment amount by multiplying the old average price by the old quantity.
+            2. **Additional Investment**: Calculate the additional investment amount by multiplying the new price by the new quantity.
+            3. **Total Investment and Total Quantity**: Add the current investment amount and additional investment amount to get the total investment. Sum the old quantity and new quantity to get the total quantity of stocks.
+            4. **New Average Price**: Calculate the new average price by dividing the total investment by the total quantity of stocks.
+            5. **Return Calculation**: Calculate the old and new returns to analyze the investment results.
+
+            ### Results 🎯
+
+            **1) Old Return**
+
+            Displays the return based on the old average price.
+
+            **2) New Return**
+
+            Displays the return based on the new average price.
+
+            **3) Additional Investment**
+
+            Shows the amount of additional investment made.
+
+            **4) Average Price**
+
+            Displays the newly calculated average price.
+
+            **5) Total Quantity**
+
+            Shows the total quantity of stocks.
+
+            **6) Total Investment**
+
+            Displays the total investment amount.
+
+            ### Example 📉
+
+            - **Old Average Price**: 100
+            - **Old Quantity**: 10
+            - **New Price**: 120
+            - **New Quantity**: 5
+
+            Results:
+            - New Average Price: 105
+            - Total Quantity: 15
+            - Total Investment: 1,575
+            - Old Return: 20.00%
+            - New Return: 14.29%
+            - Additional Investment: 600
+
+            Use the Dollar-Cost Averaging Calculator to easily compute the average purchase price of your investments! 📊💰
+
+            ### Disclaimer
             The information provided by this tool is for general informational purposes only. All information on the site is provided in good faith, but we make no representation or warranty of any kind, express or implied, regarding the accuracy, adequacy, validity, reliability, availability, or completeness of any information on the site. Your use of the site and reliance on any information on the site is solely at your own risk.
             """
         )
 
         # Retirement Planning Tool Section
         create_tool_section(
-            "Retirement Planning",
+            "RETIREMENT PLANNING CALCULATOR",
             """
-            # 은퇴 계획 도구
-
-            이 도구는 개인이 은퇴 시점까지 투자 성장과 은퇴 후 배당 소득을 예측하여 은퇴 계획을 세우는 데 도움을 줍니다. 초기 투자금, 월간 투자금, 은퇴 전후의 투자 수익률 (ROI) 및 배당 수익률과 같은 다양한 요인을 고려합니다.
-
-            ## 주요 기능
-            - **유연한 입력**: 사용자는 현재 나이, 은퇴 나이, 현재 투자액, 월간 투자액, ROI, 배당 수익률 및 기대 수명을 입력할 수 있습니다.
-            - **상세 예측**: 도구는 은퇴 시 총 투자 가치, 예상 연간 및 월간 배당 소득, 은퇴 후 투자 성장 및 배당 소득을 계산합니다.
-            - **재투자 옵션**: 사용자는 은퇴 전 배당금을 재투자하여 복리 성장을 선택할 수 있습니다.
-
-            ## 사용 방법
-            1. **현재 세부 사항 입력**: 현재 나이, 은퇴 나이, 현재 투자액 및 월간 투자액을 제공합니다.
-            2. **투자 수익률 지정**: 은퇴 전후의 예상 ROI 및 배당 수익률을 입력합니다.
-            3. **재투자 옵션 선택**: 은퇴 전 배당금을 재투자할지 선택합니다.
-            4. **기대 수명 설정**: 기대 수명을 입력합니다.
-            5. **출력**: 도구는 은퇴 시 총 투자 가치, 연간 및 월간 배당 소득, 은퇴 후 투자 성장 및 배당 소득을 계산하고 표시합니다.
-
-            ## 예제 입력
-            - `현재 나이`: 30
-            - `은퇴 나이`: 65
-            - `초기 투자금`: 50000
-            - `월간 투자금`: 500
-            - `은퇴 전 ROI`: 7%
-            - `은퇴 후 ROI`: 5%
-            - `은퇴 전 배당 수익률`: 2%
-            - `은퇴 후 배당 수익률`: 3%
-            - `배당금 재투자`: 예
-            - `기대 수명`: 85
-
-            ## 예제 출력
-            - `은퇴 시 총 금액`: 500,000
-            - `은퇴 시 연간 배당 소득`: 10,000
-            - `은퇴 시 월간 배당 소득`: 833
-            - `은퇴 후 투자 성장 및 배당 소득`: 은퇴 후 매년 상세 표 형식으로 제공.
-
-            ## 중요 사항
-            - 모든 입력이 유효한 숫자인지 확인하세요.
-            - 도구는 은퇴 후 추가 투자나 배당금 재투자를 가정하지 않습니다.
-            - 사용하기 쉬운 사용자 인터페이스 생성을 위해 Gradio를 사용하여 개발되었습니다.
-            - 상세한 은퇴 계획 예측과 즉각적인 피드백을 지원합니다.
-                
-            ## 면책 조항
-            이 도구에서 제공하는 정보는 일반적인 정보 제공 목적만을 위해 제공됩니다. 사이트의 모든 정보는 선의로 제공되지만, 사이트의 정보의 정확성, 적절성, 유효성, 신뢰성, 가용성 또는 완전성에 대해 명시적이든 묵시적이든 어떠한 종류의 진술이나 보증을 하지 않습니다. 사이트의 사용과 사이트의 정보를 신뢰하는 것은 전적으로 사용자의 책임입니다.                
+            ## 🏖️ 은퇴 계획 계산기 사용법
+
+            안녕하세요! 😊 은퇴 계획 계산기에 오신 것을 환영합니다. 이 도구는 여러분의 은퇴 후 재정 상황을 예측하고 준비하는 데 도움을 줄 거예요. 아래는 이 계산기의 작동 방식과 필요한 정보입니다. 
+
+            ### 1. 입력 값 📊
+
+            계산기에서 다음 정보를 입력해 주세요:
+
+            - **현재 나이 (current_age)**: 현재 나이 🎂
+            - **은퇴 나이 (retirement_age)**: 은퇴하고 싶은 나이 🎉
+            - **평생 기대 수명 (life_expectancy)**: 예상되는 평생 수명 🌟
+            - **월별 필요한 생활비 (monthly_income_required)**: 매월 필요한 생활비 💵
+            - **인플레이션율 (inflation_rate)**: 물가 상승률 📈
+            - **현재 투자액 (current_investment)**: 현재 보유한 투자액 💰
+            - **월별 추가 투자액 (monthly_investment)**: 매월 추가로 투자할 금액 💸
+            - **월 투자액의 연간 증가액 (annual_increase_in_monthly_investment)**: 매월 증가할 투자액(매년 월 적립식 투자금에서 늘려나갈 금액. (ex: 매년 10만원씩 늘릴 예정이라면, 100,000 입력)) 📈
+            - **배당금 재투자 여부 (reinvest_dividends)**: 배당금을 재투자할지 여부 🔄
+            - **은퇴 전 수익률 (pre_retirement_roi)**: 은퇴 전 예상 연 수익률 📊
+            - **은퇴 전 배당 수익률 (pre_retirement_dividend_yield)**: 은퇴 전 배당금 수익률 📈
+            - **은퇴 후 수익률 (post_retirement_roi)**: 은퇴 후 예상 연 수익률 🌿
+            - **은퇴 후 배당 수익률 (post_retirement_dividend_yield)**: 은퇴 후 배당금 수익률 💵
+
+            ### 2. 계산 과정 🔢
+
+            **1) 은퇴 전 자산 계산**
+
+            현재 자산과 매월 추가 투자액을 고려해 은퇴 전 자산을 계산해요. 월별 수익률을 적용하여 자산이 어떻게 성장할지 예측합니다.
+
+            **공식:**
+            \[ \text{월간 수익률} = \left(1 + \frac{\text{연 수익률}}{100}\right)^{\frac{1}{12}} - 1 \]
+
+            **2) 은퇴 후 자산 및 배당 수익 계산**
+
+            은퇴 시점의 자산과 배당 수익을 기록하고, 은퇴 후 매년 자산과 배당 수익을 업데이트합니다. 매년 필요한 생활비도 물가 상승률에 맞춰 조정합니다.
+
+            **3) 추가 현금 필요량 계산**
+
+            배당 수익과 필요한 생활비를 비교하여 추가로 필요한 현금을 계산해요.
+
+            **공식:**
+            \[ \text{연간 필요한 생활비} = \text{월별 필요한 생활비} \times 12 \]
+            \[ \text{추가 현금 필요량} = \text{연간 필요한 생활비} - \text{연간 배당 수익} \]
+
+            ### 3. 결과 출력 📈
+
+            계산된 결과는 다음과 같은 형식으로 제공됩니다:
+
+            - **은퇴 직후 필요한 생활비**와 **배당 수익**을 한눈에 볼 수 있어요.
+            - 은퇴 후 매년 자산, 필요한 생활비, 배당 수익 등을 표로 확인할 수 있습니다.
+            - 추가로 필요한 현금을 계산하여 총 필요 현금을 보여줍니다.
+
+            ### 예제 🎁
+
+            **입력 값 예시:**
+
+            - 현재 나이: 40세
+            - 은퇴 나이: 65세
+            - 평생 기대 수명: 85세
+            - 월별 필요한 생활비: 2,000,000 원
+            - 인플레이션율: 2%
+            - 현재 투자액: 50,000,000 원
+            - 월별 추가 투자액: 500,000 원
+            - 월별 투자 증가액: 50,000 원
+            - 배당금 재투자 여부: 예
+            - 은퇴 전 수익률: 5%
+            - 은퇴 전 배당 수익률: 2%
+            - 은퇴 후 수익률: 4%
+            - 은퇴 후 배당 수익률: 2%
+
+            **출력 결과:**
+
+            - 은퇴 직후 월별 필요한 생활비: 2,000,000 원
+            - 은퇴 직후 월별 배당 수익: 500,000 원
+            - 총 추가 현금 필요량: 매년 추가로 필요한 금액
+
+            **그래프와 CSV 파일 📉:**
+
+            - 은퇴 계획을 시각적으로 보여주는 그래프와 계산 결과를 포함한 CSV 파일 다운로드 링크도 제공됩니다.
+
+            은퇴 계획 계산기를 통해 여러분의 재정 계획을 미리 준비하고, 안정적인 미래를 계획해보세요! 🌟💼
+
+
+            ### 면책 조항
+            이 도구에서 제공하는 정보는 일반적인 정보 제공 목적만을 위해 제공됩니다. 사이트의 모든 정보는 선의로 제공되지만, 사이트의 정보의 정확성, 적절성, 유효성, 신뢰성, 가용성 또는 완전성에 대해 명시적이든 묵시적이든 어떠한 종류의 진술이나 보증을 하지 않습니다. 사이트의 사용과 사이트의 정보를 신뢰하는 것은 전적으로 사용자의 책임입니다.
             """,
             """
-            # Retirement Planning Tool
-
-            This tool helps individuals plan for retirement by predicting investment growth and dividend income up to the retirement date and beyond. It considers various factors such as initial investment, monthly contributions, ROI before and after retirement, and dividend yield.
-
-            ## Key Features
-            - **Flexible Input**: Users can enter their current age, retirement age, current investment amount, monthly contribution, ROI, dividend yield, and life expectancy.
-            - **Detailed Projections**: The tool calculates and displays total investment value at retirement, expected annual and monthly dividend income, investment growth, and dividend income after retirement.
-            - **Reinvestment Option**: Users can choose to reinvest dividends before retirement for compounded growth.
-
-            ## How to Use
-            1. **Enter Current Details**: Provide current age, retirement age, current investment amount, and monthly contribution.
-            2. **Specify ROI**: Enter the expected ROI and dividend yield before and after retirement.
-            3. **Select Reinvestment Option**: Choose whether to reinvest dividends before retirement.
-            4. **Set Life Expectancy**: Enter your expected life expectancy.
-            5. **Output**: The tool calculates and displays total investment value at retirement, annual and monthly dividend income, and investment growth and dividend income after retirement.
-
-            ## Example Input
-            - `Current Age`: 30
-            - `Retirement Age`: 65
-            - `Initial Investment`: 50000
-            - `Monthly Contribution`: 500
-            - `Pre-Retirement ROI`: 7%
-            - `Post-Retirement ROI`: 5%
-            - `Pre-Retirement Dividend Yield`: 2%
-            - `Post-Retirement Dividend Yield`: 3%
-            - `Dividend Reinvestment`: Yes
-            - `Life Expectancy`: 85
-
-            ## Example Output
-            - `Total Amount at Retirement`: 500,000
-            - `Annual Dividend Income at Retirement`: 10,000
-            - `Monthly Dividend Income at Retirement`: 833
-            - `Post-Retirement Investment Growth and Dividend Income`: Detailed annually in tabular format.
-
-            ## Important Notes
-            - Ensure all inputs are valid numbers.
-            - The tool assumes no additional investments or dividend reinvestments after retirement.
-            - Developed using Gradio for an easy-to-use user interface.
-            - Supports detailed retirement planning projections and instant feedback.
-
-            ## Disclaimer
+            ## 🏖️ Retirement Planning Calculator Guide
+
+            Welcome to the Retirement Planning Calculator! 😊 This tool helps you forecast and prepare for your financial situation after retirement. Here’s how it works and what information you need to provide:
+
+            ### 1. Input Values 📊
+
+            Please provide the following details:
+
+            - **Current Age (current_age)**: Your current age 🎂
+            - **Retirement Age (retirement_age)**: Age at which you plan to retire 🎉
+            - **Life Expectancy (life_expectancy)**: Expected lifespan 🌟
+            - **Monthly Income Required (monthly_income_required)**: Monthly expenses needed 💵
+            - **Inflation Rate (inflation_rate)**: Rate of inflation 📈
+            - **Current Investment (current_investment)**: Amount currently invested 💰
+            - **Monthly Investment (monthly_investment)**: Additional monthly investment 💸
+            - **Annual Increase in Monthly Investment (annual_increase_in_monthly_investment)**: Increase in monthly investment (For example, if you plan to increase your monthly investment by $100,000 each year, enter 100,000.) 📈
+            - **Reinvest Dividends (reinvest_dividends)**: Whether to reinvest dividends 🔄
+            - **Pre-Retirement ROI (pre_retirement_roi)**: Expected annual return before retirement 📊
+            - **Pre-Retirement Dividend Yield (pre_retirement_dividend_yield)**: Dividend yield before retirement 📈
+            - **Post-Retirement ROI (post_retirement_roi)**: Expected annual return after retirement 🌿
+            - **Post-Retirement Dividend Yield (post_retirement_dividend_yield)**: Dividend yield after retirement 💵
+
+            ### 2. Calculation Process 🔢
+
+            **1) Pre-Retirement Asset Calculation**
+
+            The calculator uses your current assets and monthly contributions to forecast your asset growth before retirement. Monthly returns are applied to estimate how your assets will grow.
+
+            **Formula:**
+            \[ \text{Monthly Return} = \left(1 + \frac{\text{Annual ROI}}{100}\right)^{\frac{1}{12}} - 1 \]
+
+            **2) Post-Retirement Asset and Dividend Income Calculation**
+
+            The calculator tracks your assets and dividend income at retirement, then updates these figures annually. It also adjusts monthly income needs for inflation.
+
+            **3) Additional Cash Needed Calculation**
+
+            It compares dividend income with required income to determine if additional cash is needed.
+
+            **Formula:**
+            \[ \text{Annual Income Required} = \text{Monthly Income Required} \times 12 \]
+            \[ \text{Additional Cash Required} = \text{Annual Income Required} - \text{Annual Dividend Income} \]
+
+            ### 3. Results 📈
+
+            The results are displayed as follows:
+
+            - **Immediate Post-Retirement Income Needs** and **Dividend Income** for easy comparison.
+            - Annual asset, required income, and dividend income details in a table.
+            - Total additional cash required to cover any shortfall.
+
+            ### Example 🎁
+
+            **Example Input Values:**
+
+            - Current Age: 40 years
+            - Retirement Age: 65 years
+            - Life Expectancy: 85 years
+            - Monthly Income Required: $2,000
+            - Inflation Rate: 2%
+            - Current Investment: $50,000
+            - Monthly Investment: $500
+            - Monthly Increase in Investment: $50
+            - Reinvest Dividends: Yes
+            - Pre-Retirement ROI: 5%
+            - Pre-Retirement Dividend Yield: 2%
+            - Post-Retirement ROI: 4%
+            - Post-Retirement Dividend Yield: 2%
+
+            **Output Results:**
+
+            - Monthly Income Required Immediately After Retirement: $2,000
+            - Monthly Dividend Income Immediately After Retirement: $500
+            - Total Additional Cash Required: Amount needed annually
+
+            **Graph and CSV File 📉:**
+
+            - Visual graphs of the retirement plan and a CSV file with detailed calculations are available for download.
+
+            Use the Retirement Planning Calculator to prepare for your future and ensure a secure retirement! 🌟💼
+
+            ### Disclaimer
             The information provided by this tool is for general informational purposes only. All information on the site is provided in good faith, but we make no representation or warranty of any kind, express or implied, regarding the accuracy, adequacy, validity, reliability, availability, or completeness of any information on the site. Your use of the site and reliance on any information on the site is solely at your own risk.
             """
         )
+        with gr.Accordion("🤝 Support Us", open=False):
+            # Support Us Section
+            gr.Markdown("""
+            If you find this tool useful and would like to support the development of such projects, please consider making a donation. Your support is greatly appreciated.
 
-        # Support Us Section
-        gr.Markdown("""
-        ## Support Us
-        If you find this tool useful and would like to support the development of such projects, please consider making a donation. Your support is greatly appreciated.
-
-        [![Donate with PayPal](https://www.paypalobjects.com/en_US/i/btn/btn_donateCC_LG.gif)](https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=M8SBRC396DPBW)
+            [![Donate with PayPal](https://www.paypalobjects.com/en_US/i/btn/btn_donateCC_LG.gif)](https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=M8SBRC396DPBW)
 
-        Or, if you prefer, you can also support us through Toss at:
+            Or, if you prefer, you can also support us through Toss at:
 
-        <a href="https://toss.me/eichijei" target="_blank">
-            <img src="https://static.toss.im/logos/png/1x/logo-toss.png" alt="Donate with Toss" style="width: 150px;">
-        </a>
-        """)
+            <a href="https://toss.me/eichijei" target="_blank">
+                <img src="https://static.toss.im/logos/png/1x/logo-toss.png" alt="Donate with Toss" style="width: 150px;">
+            </a>
+            """)
 

interface/dollar_cost_averaging_interface.py

@@ -0,0 +1,22 @@
+import gradio as gr
+from modules.dollar_cost_averaging import gradio_dollar_cost_averaging, load_css
+
+def dollar_cost_averaging_interface_fn(old_avg_price, old_quantity, new_price, new_quantity):
+    result = gradio_dollar_cost_averaging(old_avg_price, old_quantity, new_price, new_quantity)
+    css = load_css()
+    return css + result
+
+# Define the inputs
+markdown1 = gr.Markdown("### First Purchase")
+old_price = gr.Textbox(label="Old Price", value="")
+old_quantity = gr.Textbox(label="Quantity", value="")
+markdown2 = gr.Markdown("### Second Purchase")
+new_price = gr.Textbox(label="New Price", value="")
+new_quantity = gr.Textbox(label="Quantity", value="")
+
+dollar_cost_averaging_inputs = [old_price, old_quantity, new_price, new_quantity]
+output = gr.HTML()
+
+# Define the update function
+def update_output(old_avg_price, old_quantity, new_price, new_quantity):
+    return dollar_cost_averaging_interface_fn(old_avg_price, old_quantity, new_price, new_quantity)

interface/rebalancing_interface.py

@@ -0,0 +1,37 @@
+import gradio as gr
+from modules.rebalancing import rebalancing_tool, load_css
+from modules.utils import get_currency_codes
+
+def rebalancing_interface_fn(main_currency, holdings, cash_amount, cash_ratio):
+    result = rebalancing_tool(main_currency, holdings, cash_amount, cash_ratio)
+    css = load_css()
+    return css + result
+
+currency_codes = get_currency_codes()
+examples = [
+    ["KRW", "458730 KRW 580 8,\n368590 KRW 80 2", 507977, 0],
+    ["KRW", "SCHD USD 500 8,\nQQQ USD 200 2", 0, 15]
+    ]
+
+rebalancing_inputs = [
+    gr.Dropdown(label="Main Currency", choices=currency_codes, value="KRW", info="Assets converted to main currency."),    
+    gr.Textbox(label="Holdings", lines=2, info="Format: [ ticker currency quantity weight, ... ]", placeholder="e.g., SCHD USD 500 8, QQQ USD 200 2"),
+    gr.Number(label="Cash", value="", info="MAIN CURRENCY CASH"),
+    gr.Slider(label="Cash Ratio (%)", minimum=0, maximum=100, step=1)
+]
+
+output = gr.HTML()
+
+# Define the update function
+def update_output(main_currency, holdings, cash_amount, cash_ratio):
+    return rebalancing_interface_fn(main_currency, holdings, cash_amount, cash_ratio)
+
+# portfolio_rebalancing_interface = gr.Interface(
+#     fn=portfolio_rebalancing_interface_fn,
+#     inputs=portfolio_inputs,
+#     outputs=gr.HTML(),
+#     examples=examples,
+#     cache_examples=False,
+#     live=False
+# )
+

interface/retirement_planning_interface.py

@@ -2,26 +2,36 @@ import gradio as gr
 from modules.utils import load_css
 from modules.retirement_planning import retirement_planning
 
-def retirement_planning_interface_fn(current_age, retirement_age, current_investment, monthly_investment, pre_retirement_roi, post_retirement_roi, pre_retirement_dividend_yield, post_retirement_dividend_yield, reinvest_dividends, life_expectancy):
-    result = retirement_planning(current_age, retirement_age, current_investment, monthly_investment, pre_retirement_roi, post_retirement_roi, pre_retirement_dividend_yield, post_retirement_dividend_yield, reinvest_dividends, life_expectancy)
+def retirement_planning_interface_fn(
+    current_age, retirement_age, life_expectancy, monthly_income_required, inflation_rate, current_investment, monthly_investment, annual_increase_in_monthly_investment, reinvest_dividends, pre_retirement_roi, pre_retirement_dividend_yield, post_retirement_roi, post_retirement_dividend_yield
+):
+    result = retirement_planning(
+        current_age, retirement_age, life_expectancy, monthly_income_required, inflation_rate, current_investment, monthly_investment, annual_increase_in_monthly_investment, reinvest_dividends, pre_retirement_roi, pre_retirement_dividend_yield, post_retirement_roi, post_retirement_dividend_yield
+    )
     css = load_css()
     return css + result
 
-retirement_planning_inputs = [
-    gr.Slider(label="Current Age (15-60 Years)", value=15, minimum=15, maximum=60, step=1),
-    gr.Slider(label="Retirement Age (Upto 70 Years)", value=55, minimum=15, maximum=70, step=1),
-    gr.Number(label="Current Investment", value=10000000),
-    gr.Number(label="Monthly Investment", value=500000),
-    gr.Number(label="Expected Return On Investment (Pre-retirement) (%)", value=8),
-    gr.Number(label="Expected Return On Investment (Post-retirement) (%)", value=8),
-    gr.Number(label="Expected Dividend Yield (Pre-retirement) (%)", value=3.3),
-    gr.Number(label="Expected Dividend Yield (Post-retirement) (%)", value=3.3),
-    gr.Checkbox(label="Reinvest Dividends", value=True),
-    gr.Slider(label="Life Expectancy (Upto 100 Years)", value=80, minimum=30, maximum=100, step=1)
-]
+# Define the input components
+current_age = gr.Slider(label="Current Age (15-60 Years)", value=15, minimum=15, maximum=60, step=1)
+retirement_age = gr.Slider(label="Retirement Age (Upto 70 Years)", value=55, minimum=15, maximum=70, step=1)
+life_expectancy = gr.Slider(label="Life Expectancy (Upto 100 Years)", value=80, minimum=30, maximum=100, step=1)
+monthly_income_required = gr.Number(label="Monthly Income Required In Retirement Years (CPP)", value=2000000)
+inflation_rate = gr.Number(label="Expected Inflation Rate (%)", value=3)
+current_investment = gr.Number(label="Current Investment", value=10000000)
+monthly_investment = gr.Number(label="Monthly Investment", value=500000)
+annual_increase_in_monthly_investment = gr.Number(label="Annual Increase in Monthly Investment", value=0)  # 추가된 입력
+reinvest_dividends = gr.Checkbox(label="Reinvest Dividends", value=True)
+pre_retirement_roi = gr.Number(label="Expected Return On Investment (Pre-retirement) (%)", value=8)
+pre_retirement_dividend_yield = gr.Number(label="Expected Dividend Yield (Pre-retirement) (%)", value=3.3)
+post_retirement_roi = gr.Number(label="Expected Return On Investment (Post-retirement) (%)", value=8)
+post_retirement_dividend_yield = gr.Number(label="Expected Dividend Yield (Post-retirement) (%)", value=3.3)
 
 output = gr.HTML()
 
 # Define the update function
-def update_output(current_age, retirement_age, current_investment, monthly_investment, pre_retirement_roi, post_retirement_roi, pre_retirement_dividend_yield, post_retirement_dividend_yield, reinvest_dividends, life_expectancy):
-    return retirement_planning_interface_fn(current_age, retirement_age, current_investment, monthly_investment, pre_retirement_roi, post_retirement_roi, pre_retirement_dividend_yield, post_retirement_dividend_yield, reinvest_dividends, life_expectancy)
+def update_output(
+    current_age, retirement_age, life_expectancy, monthly_income_required, inflation_rate, current_investment, monthly_investment, annual_increase_in_monthly_investment, reinvest_dividends, pre_retirement_roi, pre_retirement_dividend_yield, post_retirement_roi, post_retirement_dividend_yield
+):
+    return retirement_planning_interface_fn(
+        current_age, retirement_age, life_expectancy, monthly_income_required, inflation_rate, current_investment, monthly_investment, annual_increase_in_monthly_investment, reinvest_dividends, pre_retirement_roi, pre_retirement_dividend_yield, post_retirement_roi, post_retirement_dividend_yield
+    )

interface/share_price_trend_interface.py

@@ -0,0 +1,27 @@
+import gradio as gr
+from modules.utils import load_css
+from modules.share_price_trend import share_price_trend
+
+# Define the interface for the Compare tab
+def share_price_trend_interface_fn(stock_codes, period):
+    result = share_price_trend(stock_codes, period)
+    css = load_css()
+    return css + result
+
+share_price_trend_inputs = [
+    gr.Textbox(label="Stock Codes", info="Enter stock codes separated by comma.", placeholder="e.g., AAPL,GOOGL,MSFT", value="SCHD,QQQ"),
+    gr.Number(label="input # of days below", value="90")
+]
+
+output=gr.HTML()
+
+# Define the update function
+def update_output(stock_codes, period):
+    return share_price_trend_interface_fn(stock_codes, period)
+
+# compare_stock_prices_interface = gr.Interface(
+#     fn=compare_stock_prices_interface_fn,
+#     inputs=compare_inputs,
+#     outputs=gr.HTML(),
+#     live=False
+# )

modules/dollar_cost_averaging.py

@@ -0,0 +1,122 @@
+from modules.utils import load_css
+
+def dollar_cost_averaging(old_avg_price, old_quantity, new_price, new_quantity):
+    # 입력값을 숫자로 변환 (각 입력값이 None일 경우 0.0으로 설정)
+    old_avg_price = float(old_avg_price) if old_avg_price else 0.0
+    old_quantity = float(old_quantity) if old_quantity else 0.0
+    new_price = float(new_price) if new_price else 0.0
+    new_quantity = float(new_quantity) if new_quantity else 0.0
+
+    # 현재 투자 금액 계산 (이전 평균 가격 * 이전 수량)
+    current_investment = old_avg_price * old_quantity
+    # 추가 투자 금액 계산 (새 가격 * 새 수량)
+    additional_investment = new_price * new_quantity
+    # 총 투자 금액 계산 (현재 투자 금액 + 추가 투자 금액)
+    total_investment = current_investment + additional_investment
+    # 총 주식 수 계산 (이전 수량 + 새 수량)
+    total_quantity = old_quantity + new_quantity
+    # 새 평균 가격 계산 (총 투자 금액 / 총 주식 수)
+    new_avg_price = total_investment / total_quantity if total_quantity != 0 else 0.0
+    # 이전 수익률 계산 (이전 평균 가격을 기준으로)
+    old_return = (new_price / old_avg_price - 1) * 100 if old_avg_price != 0 else 0.0
+    # 새로운 수익률 계산 (새 가격 / 새 평균 가격 - 1) * 100
+    new_return = (new_price / new_avg_price - 1) * 100 if new_avg_price != 0 else 0.0
+    
+    # 새 평균 가격, 총 수량, 총 투자 금액, 새로운 수익률, 추가 투자 금액, 이전 수익률 반환
+    return new_avg_price, total_quantity, total_investment, new_return, additional_investment, old_return
+
+def gradio_dollar_cost_averaging(old_avg_price, old_quantity, new_price, new_quantity):
+    css = load_css()
+
+    # 입력값을 숫자로 변환
+    old_avg_price = float(old_avg_price) if old_avg_price else 0.0
+    old_quantity = float(old_quantity) if old_quantity else 0.0
+    new_price = float(new_price) if new_price else 0.0
+    new_quantity = float(new_quantity) if new_quantity else 0.0
+
+    # 평균 가격, 총 수량, 총 투자 금액, 수익률 및 추가 투자 금액 계산
+    new_avg_price, total_quantity, total_investment, new_return, additional_investment, old_return = dollar_cost_averaging(old_avg_price, old_quantity, new_price, new_quantity)
+
+    # 수익률에 따른 클래스 설정
+    new_return_class = ""
+    old_return_class = ""
+    if new_return > 0:
+        new_return_class = f"<span style='color: #4caf50; font-weight: bold;'>{new_return:+,.2f}%</span>"
+    elif new_return < 0:
+        new_return_class = f"<span style='color: #f44336; font-weight: bold;'>{new_return:,.2f}%</span>"
+    else:
+        new_return_class = f"<span><strong>0</strong></span>"
+
+    if old_return > 0:
+        old_return_class = f"<span style='color: #4caf50; font-weight: bold;'>{old_return:+,.2f}%</span>"
+    elif old_return < 0:
+        old_return_class = f"<span style='color: #f44336; font-weight: bold;'>{old_return:,.2f}%</span>"
+    else:
+        old_return_class = f"<span><strong>0</strong></span>"
+
+    # HTML 결과 생성
+    result_html = css + f"""
+    <div class="wrap-text" style="box-shadow: 0 0.25rem 0.5rem rgba(0, 0, 0, 0.1); border-radius: 0.5rem; padding: 3rem; position: relative; width: 100%; padding: 1.5rem;">
+        <div>
+            <div style="margin-bottom: 1.5rem;">
+                <!-- 이전 수익률 표시 -->
+                <div style="font-size: 1.5rem; margin-top: 1.5rem; margin-bottom: 1.5rem;">Old Return</div>
+                <div style="font-size: 1.5rem;">
+                    {old_return_class}
+                </div>
+                <hr style="margin: 1.5rem 0;">
+            </div>
+        </div>
+        <div>
+            <div style="margin-bottom: 1.5rem;">
+                <!-- 새로운 수익률 표시 -->
+                <div style="font-size: 1.5rem; margin-top: 1.5rem; margin-bottom: 1.5rem;">New Return</div>
+                <div style="font-size: 1.5rem;">
+                    {new_return_class}
+                </div>
+                <hr style="margin: 1.5rem 0;">
+            </div>
+        </div>
+        <div>
+            <div style="margin-bottom: 1.5rem;">
+                <!-- 추가 투자 금액 표시 -->
+                <div style="font-size: 1.5rem; margin-top: 1.5rem; margin-bottom: 1.5rem;">Additional Investment</div>
+                <div style="font-size: 1.5rem; font-weight: bold; color: #1c75bc;">
+                    <span style='color: #1678fb'>{additional_investment:,.0f}</span>
+                </div>
+                <hr style="margin: 1.5rem 0;">
+            </div>
+        </div>
+        <div>
+            <div style="margin-bottom: 1.5rem;">
+                <!-- 평균 가격 표시 -->
+                <div style="font-size: 1.5rem; margin-top: 1.5rem; margin-bottom: 1.5rem;">Average Price</div>
+                <div style="font-size: 1.5rem; font-weight: bold; color: #1c75bc;">
+                    <span style='color: #1678fb'>{new_avg_price:,.0f}</span>
+                </div>
+                <hr style="margin: 1.5rem 0;">
+            </div>
+        </div>
+        <div>
+            <div style="margin-bottom: 1.5rem;">
+                <!-- 총 수량 표시 -->
+                <div style="font-size: 1.5rem; margin-top: 1.5rem; margin-bottom: 1.5rem;">Total Quantity</div>
+                <div style="font-size: 1.5rem; font-weight: bold; color: #1c75bc;">
+                    <span style='color: #1678fb'>{total_quantity:,.0f}</span>
+                </div>
+                <hr style="margin: 1.5rem 0;">
+            </div>
+        </div>
+        <div>
+            <div style="margin-bottom: 1.5rem;">
+                <!-- 총 투자 금액 표시 -->
+                <div style="font-size: 1.5rem; margin-top: 1.5rem; margin-bottom: 1.5rem;">Total Investment</div>
+                <div style="font-size: 1.5rem; font-weight: bold; color: #1c75bc;">
+                    <span style='color: #1678fb'>{total_investment:,.0f}</span>
+                </div>
+                <hr style="margin: 1.5rem 0;">
+            </div>
+        </div>
+    </div>
+    """
+    return result_html

modules/rebalancing.py

@@ -0,0 +1,241 @@
+import requests
+import pytz
+import math
+import pandas as pd
+import FinanceDataReader as fdr
+import yfinance as yf
+from datetime import datetime
+from concurrent.futures import ThreadPoolExecutor
+from modules.utils import load_css, get_currency_symbol, format_quantity
+
+# 주어진 입력을 구문 분석하여 주식 보유량, 현금 금액 및 현금 비율을 계산하는 함수
+def parse_input(holdings, cash_amount, cash_ratio):
+    lines = holdings.strip().split(',')
+    stock_inputs = []
+    total_target_weight = 0
+    
+    for line in lines:
+        parts = line.split()
+        if len(parts) == 4:
+            stock_code, currency_code, quantity_expr, target_weight_expr = parts
+            quantity = math.floor(eval(quantity_expr.replace(' ', '')))
+            target_weight = eval(target_weight_expr.replace(' ', ''))
+            target_ratio = (1 - cash_ratio / 100) * target_weight
+            stock_inputs.append((currency_code, stock_code, quantity, target_weight, target_ratio))
+            total_target_weight += target_weight
+
+    cash_amount = math.floor(cash_amount) if cash_amount else 0
+    main_currency_cash_inputs = {'amount': cash_amount, 'target_weight': cash_ratio / 100.0}
+
+    stock_total_weight = total_target_weight
+
+    for i in range(len(stock_inputs)):
+        stock_inputs[i] = (stock_inputs[i][0], stock_inputs[i][1], stock_inputs[i][2], stock_inputs[i][3], (1 - main_currency_cash_inputs['target_weight']) * stock_inputs[i][3] / stock_total_weight)
+
+    return stock_inputs, main_currency_cash_inputs
+
+# 주어진 통화 코드와 메인 통화 간의 환율을 가져오는 함수
+def get_portfolio_exchange_rate(currency_code, main_currency):
+    if currency_code.lower() == main_currency.lower():
+        return 1.0
+    
+    ticker = f"{currency_code.upper()}{main_currency.upper()}=X"
+    data = yf.download(ticker, period='1d', progress=False)  # progress=False 추가
+    if not data.empty:
+        return data['Close'].iloc[0]
+    else:
+        raise ValueError("Failed to retrieve exchange rate data.")
+
+# 주어진 주식 코드와 통화 코드에 대해 환율을 반영한 주식 가격을 가져오는 함수
+def get_portfolio_exchange_reflected_stock_price(stock_code, currency_code, main_currency):
+    new_price = get_portfolio_current_stock_price(stock_code)
+    exchange_rate = get_portfolio_exchange_rate(currency_code, main_currency)
+    return math.floor(new_price * exchange_rate)
+
+# 주어진 주식 코드의 현재 주식 가격을 가져오는 함수
+def get_portfolio_current_stock_price(stock_code):
+    df = fdr.DataReader(stock_code)
+    return df['Close'].iloc[-1]
+
+# 주어진 주식 입력 및 현금 입력을 바탕으로 포트폴리오를 구축하는 함수
+def build_portfolio(stock_inputs, main_currency_cash_inputs, main_currency):
+    portfolio = {}
+    target_weights = {}
+    
+    with ThreadPoolExecutor() as executor:
+        results = executor.map(lambda x: (x[1], get_portfolio_exchange_reflected_stock_price(x[1], x[0], main_currency), x[2], x[3], x[4], x[0]), stock_inputs)
+    
+    for stock_code, new_price, quantity, target_weight, target_ratio, currency_code in results:
+        portfolio[stock_code] = {'quantity': quantity, 'price': new_price, 'target_weight': target_weight, 'currency': currency_code}
+        target_weights[stock_code] = target_ratio
+
+    return portfolio, target_weights, main_currency_cash_inputs
+
+# 포트폴리오 재조정 정보를 가져오는 함수
+def get_portfolio_rebalancing_info(portfolio, target_weights, main_currency_cash_inputs, main_currency):
+    css = load_css()
+
+    current_time = datetime.now().strftime("%b-%d-%Y")
+
+    total_value = sum(stock['price'] * stock['quantity'] for stock in portfolio.values()) + main_currency_cash_inputs['amount']
+    total_new_stock_value = 0
+    total_trade_value = 0
+    adjustments = []
+
+    currency_symbol = get_currency_symbol(main_currency)
+
+    # 포트폴리오 정보 생성
+    portfolio_info = css + f"""
+        <div class="wrap-text" style="box-shadow: 0 0.25rem 0.5rem rgba(0, 0, 0, 0.1); border-radius: 0.5rem; padding: 3rem; position: relative; width: 100%; padding: 1.5rem;">
+            <div>
+                <div style="margin-bottom: 1.5rem;">
+                    <!-- 전체 평가금액 표시 -->
+                    <div style="font-size: 1.5rem; margin-top: 1.5rem; margin-bottom: 1.5rem;">Market Value</div>
+                        <span style='font-size: 1.5rem; font-weight: bold; color: #1678fb'>{currency_symbol}{total_value:,.0f}</span>
+                        As of {current_time} 
+                    <hr style="margin: 1.5rem 0;">
+                </div>
+            </div>
+        </div>
+        """
+
+    # 현재 비율 및 가치를 계산
+    current_weights = {stock_code: (stock['price'] * stock['quantity'] / total_value) * 100 for stock_code, stock in portfolio.items()}
+    current_values = {stock_code: stock['price'] * stock['quantity'] for stock_code, stock in portfolio.items()}
+    
+    # 현금을 현재 비율 및 가치에 포함
+    current_weights['CASH'] = (main_currency_cash_inputs['amount'] / total_value) * 100
+    current_values['CASH'] = main_currency_cash_inputs['amount']
+
+    # 현재 비율을 기준으로 주식을 내림차순으로 정렬
+    # sorted_stocks = sorted(current_weights.items(), key=lambda x: x[1], reverse=True)
+    sorted_stocks = current_weights.items()
+
+    # 현재 보유량 및 가치 섹션 표시
+    current_info_html = "<h3>Your Portfolio Holdings</h3><div class='table-container'><table>"
+    current_info_html += "<thead><tr><th>Stock Code</th><th>Current Weight (%)</th><th>Current Value</th></tr></thead><tbody>"
+    for stock_code, weight in sorted_stocks:
+        current_info_html += (
+            f"<tr>"
+            f"<td>{stock_code.upper()}</td>"
+            f"<td>{weight:.1f}%</td>"
+            f"<td>{currency_symbol}{current_values[stock_code]:,.0f}</td>"
+            f"</tr>"
+        )
+    current_info_html += "</tbody></table></div><br>"
+
+    # 조정 항목 생성
+    for stock_code, stock_data in portfolio.items():
+        current_value = stock_data['price'] * stock_data['quantity']
+        target_value = total_value * target_weights.get(stock_code, 0)
+        difference = target_value - current_value
+        trade_quantity = math.floor(difference / stock_data['price']) if difference > 0 else -math.ceil(-difference / stock_data['price'])
+        new_quantity = trade_quantity + stock_data['quantity']
+        new_value = new_quantity * stock_data['price']
+        trade_value = trade_quantity * stock_data['price']
+        total_trade_value += abs(trade_value)
+        total_new_stock_value += new_value
+        current_value_pct = (current_value / total_value) * 100
+        new_value_pct = (new_value / total_value) * 100
+
+        adjustments.append((difference, current_value, target_value, current_value_pct, trade_quantity, stock_code, stock_data['price'], new_value, trade_value, stock_data['quantity'], new_quantity, target_weights[stock_code], new_value_pct, stock_data['target_weight'], stock_data['currency']))
+
+    # 현금에 대한 조정 항목 생성
+    main_currency_new_amount = total_value - total_new_stock_value
+    main_currency_target_value = total_value * main_currency_cash_inputs['target_weight']
+    main_currency_difference = main_currency_new_amount - main_currency_cash_inputs['amount']
+    trade_quantity = main_currency_difference
+    new_quantity = main_currency_cash_inputs['amount'] + trade_quantity
+    new_value = new_quantity
+    trade_value = trade_quantity
+    current_value = main_currency_cash_inputs['amount']
+    current_value_pct = (current_value / total_value) * 100
+    new_value_pct = (new_value / total_value) * 100
+
+    adjustments.append((main_currency_difference, current_value, main_currency_target_value, current_value_pct, trade_quantity, 'CASH', 1, new_value, trade_value, main_currency_cash_inputs['amount'], new_quantity, main_currency_cash_inputs['target_weight'], new_value_pct, '', 'main_currency'))
+
+    # 통화별 포트폴리오 요약 생성
+    currency_totals = {stock_data['currency']: {'amount': 0, 'weight': 0} for stock_data in portfolio.values()}
+
+    for stock_code, stock_data in portfolio.items():
+        currency = stock_data['currency']
+        current_value = stock_data['price'] * stock_data['quantity']
+        currency_totals[currency]['amount'] += current_value
+        currency_totals[currency]['weight'] += current_value / total_value
+
+    currency_totals['CASH'] = {'amount': main_currency_cash_inputs['amount'], 'weight': main_currency_cash_inputs['amount'] / total_value}
+    # sorted_currencies = sorted(currency_totals.items(), key=lambda x: x[1]['weight'], reverse=True)
+    sorted_currencies = currency_totals.items()
+
+
+    # 통화별 요약 테이블 생성
+    currency_table = "<h3>Your Portfolio by Currency</h3><div class='table-container wrap-text'><table>"
+    currency_table += "<thead><tr><th>Currency</th><th>Total Weight (%)</th><th>Total Value</th></tr></thead><tbody>"
+
+    for currency, data in sorted_currencies:
+        currency_table += (
+            f"<tr>"
+            f"<td>{currency.upper()}</td>"
+            f"<td>{data['weight'] * 100:.1f}%</td>"
+            f"<td>{currency_symbol}{data['amount']:,}</td>"            
+            f"</tr>"
+        )
+
+    currency_table += "</tbody></table></div><br>"
+
+    # 재조정 분석 테이블 생성
+    result_message = portfolio_info + current_info_html + currency_table + "<h3>Re-Balancing Analysis</h3><div class='table-container wrap-text'><table>"
+    result_message += "<thead><tr><th>Stock Code</th><th>Current Weight (%)</th><th>Target Weight</th><th>Target Ratio (%)</th><th>Buy or Sell?</th><th>Trade Amount</th><th>Current Price per Share</th><th>Estimated # of<br> Shares to Buy or Sell</th><th>Quantity of Units</th><th>Market Value</th><th>% Asset Allocation</th></tr></thead><tbody>"
+
+    for adj in adjustments:
+        difference, current_value, target_value, current_value_pct, trade_quantity, stock_code, price, new_value, trade_value, old_quantity, new_quantity, target_ratio, new_value_pct, target_weight, currency = adj
+        Buy_or_Sell = ""
+        if trade_quantity > 0:
+            Buy_or_Sell = f"<span class='buy-sell buy'>Buy</span>"
+        elif trade_quantity < 0:
+            Buy_or_Sell = f"<span class='buy-sell sell'>Sell</span>"
+        else:
+            Buy_or_Sell = f"<span></span>"
+
+        current_value_pct_str = f"{current_value_pct:.1f}%"
+        target_weight_str = f"<span class='highlight-edit'>{target_weight}</span>" if stock_code != 'CASH' else ''
+        target_ratio_str = f"<span class='highlight-edit'>{target_ratio * 100:.1f}%</span>" if stock_code == 'CASH' else f"{target_ratio * 100:.1f}%"
+        trade_value_str = f"<span class='highlight-sky'>{format_quantity(trade_value)}</span>" if trade_value != 0 else ''
+        price_str = f"{currency_symbol}{price:,.0f}" if stock_code != 'CASH' else ''        
+        trade_quantity_str = (
+            f"<span class='highlight-sky'>{format_quantity(trade_quantity)}</span>"
+            if stock_code != 'CASH' and trade_value != 0 else ''
+        )
+        old_quantity_str = f"{old_quantity:,.0f} → {new_quantity:,.0f}" if stock_code != 'CASH' else ''
+        new_value_str = f"{currency_symbol}{new_value:,.0f}"
+        new_value_pct_str = f"{new_value_pct:.1f}%"
+
+        result_message += (
+            f"<tr>"
+            f"<td>{stock_code.upper()}</td>"
+            f"<td>{current_value_pct_str}</td>"
+            f"<td>{target_weight_str}</td>"
+            f"<td>{target_ratio_str}</td>"
+            f"<td>{Buy_or_Sell}</td>"
+            f"<td>{trade_value_str}</td>"
+            f"<td>{price_str}</td>"
+            f"<td>{trade_quantity_str}</td>"
+            f"<td>{old_quantity_str}</td>"
+            f"<td>{new_value_str}</td>"
+            f"<td>{new_value_pct_str}</td>"
+            f"</tr>"
+        )
+
+    result_message += "</tbody></table></div>"
+    
+    return result_message
+
+# 포트폴리오 재조정 도구의 주요 함수
+def rebalancing_tool(main_currency, holdings, cash_amount, cash_ratio):
+    try:
+        stock_inputs, main_currency_cash_inputs = parse_input(holdings, cash_amount, cash_ratio)
+        portfolio, target_weights, main_currency_cash_inputs = build_portfolio(stock_inputs, main_currency_cash_inputs, main_currency)
+        result = get_portfolio_rebalancing_info(portfolio, target_weights, main_currency_cash_inputs, main_currency)
+        return result
+    except Exception as e:
+        return str(e)

modules/retirement_planning.py

@@ -1,18 +1,47 @@
+import base64
+import csv
+from io import StringIO
+import matplotlib.pyplot as plt
+import io
+
 from modules.utils import load_css
 
-def retirement_planning(current_age=None, retirement_age=None, current_investment=None, monthly_investment=None, pre_retirement_roi=None, post_retirement_roi=None, pre_retirement_dividend_yield=None, post_retirement_dividend_yield=None, reinvest_dividends=False, life_expectancy=None):
+def retirement_planning(
+    current_age=None, 
+    retirement_age=None, 
+    life_expectancy=None, 
+    monthly_income_required=None, 
+    inflation_rate=None, 
+    current_investment=None, 
+    monthly_investment=None, 
+    annual_increase_in_monthly_investment=None,  # 추가된 입력
+    reinvest_dividends=None, 
+    pre_retirement_roi=None, 
+    pre_retirement_dividend_yield=None, 
+    post_retirement_roi=None, 
+    post_retirement_dividend_yield=None
+):
     # NoneType일 때 0으로 처리
     current_age = current_age if current_age is not None else 0
     retirement_age = retirement_age if retirement_age is not None else 0
     current_investment = current_investment if current_investment is not None else 0
     monthly_investment = monthly_investment if monthly_investment is not None else 0
+    annual_increase_in_monthly_investment = annual_increase_in_monthly_investment if annual_increase_in_monthly_investment is not None else 0
     pre_retirement_roi = pre_retirement_roi if pre_retirement_roi is not None else 0
     post_retirement_roi = post_retirement_roi if post_retirement_roi is not None else 0
     pre_retirement_dividend_yield = pre_retirement_dividend_yield if pre_retirement_dividend_yield is not None else 0
     post_retirement_dividend_yield = post_retirement_dividend_yield if post_retirement_dividend_yield is not None else 0
     life_expectancy = life_expectancy if life_expectancy is not None else 0
+    monthly_income_required = monthly_income_required if monthly_income_required is not None else 0
+    inflation_rate = inflation_rate if inflation_rate is not None else 0
 
     # 은퇴 전후의 년 수 계산
+    if retirement_age > life_expectancy:
+        return "<p style='color: red;'>Error: Retirement age cannot be greater than life expectancy.</p>"
+    
+    if retirement_age < current_age:
+        return "<p style='color: red;'>Error: Retirement age cannot be less than current age.</p>"
+    
     years_to_retirement = retirement_age - current_age
     post_retirement_years = life_expectancy - retirement_age
 
@@ -30,6 +59,8 @@ def retirement_planning(current_age=None, retirement_age=None, current_investmen
             # 배당금을 재투자할 경우 배당금 추가
             if reinvest_dividends:
                 total_investment += total_investment * (pre_retirement_dividend_yield / 100 / 12)
+        # 연간 증가액을 월 투자액에 추가
+        monthly_investment += annual_increase_in_monthly_investment
 
     # 은퇴 시작 시점의 총 투자액과 연간 배당 수익 저장
     investment_at_retirement = total_investment
@@ -39,8 +70,19 @@ def retirement_planning(current_age=None, retirement_age=None, current_investmen
     # 은퇴 후 월간 이자율 계산
     monthly_return_post = (1 + post_retirement_roi / 100) ** (1 / 12) - 1
 
+    # 연간 물가상승률을 반영한 월 생활비 계산
+    monthly_income_required_inflated = monthly_income_required
+    monthly_income_required_over_time = []
+    for age in range(current_age, life_expectancy + 1):
+        if age >= retirement_age:
+            monthly_income_required_over_time.append((age, monthly_income_required_inflated))
+        monthly_income_required_inflated *= (1 + inflation_rate / 100 / 12) ** 12
+
+    annual_income_required_at_retirement = monthly_income_required_over_time[0][1] * 12
+    monthly_income_required_at_retirement = monthly_income_required_over_time[0][1]
+
     # 은퇴 후 투자 목록 초기화
-    post_retirement_investments = [(retirement_age, investment_at_retirement, annual_dividend_at_retirement, monthly_dividend_at_retirement)]
+    post_retirement_investments = [(retirement_age, investment_at_retirement, annual_income_required_at_retirement, annual_dividend_at_retirement, monthly_dividend_at_retirement, monthly_income_required_at_retirement, annual_dividend_at_retirement - annual_income_required_at_retirement)]
 
     # 은퇴 후 각 년도의 투자 및 배당 수익 계산
     for year in range(1, post_retirement_years + 1):
@@ -50,60 +92,117 @@ def retirement_planning(current_age=None, retirement_age=None, current_investmen
         annual_dividend_income = total_investment * (post_retirement_dividend_yield / 100)
         # 월간 배당 수익 계산
         monthly_dividend_income = annual_dividend_income / 12
-        # 각 연도별 투자와 배당 수익을 리스트에 추가
-        post_retirement_investments.append((retirement_age + year, total_investment, annual_dividend_income, monthly_dividend_income))
+        # 연도별 물가상승률 반영한 월 생활비 갱신
+        inflated_income_required = monthly_income_required_over_time[year][1] if year < len(monthly_income_required_over_time) else monthly_income_required_over_time[-1][1]
+        # 각 연도별 투자와 배당 수익 및 월 생활비를 리스트에 추가
+        difference = annual_dividend_income - inflated_income_required * 12
+        post_retirement_investments.append((retirement_age + year, total_investment, inflated_income_required * 12, annual_dividend_income, monthly_dividend_income, inflated_income_required, difference))
+
+    # 마이너스 값의 difference 합계 계산
+    negative_differences_sum = sum(diff for _, _, _, _, _, _, diff in post_retirement_investments if diff < 0)
+
+    # CSV 파일 생성
+    csv_output = StringIO()
+    csv_writer = csv.writer(csv_output)
+    csv_writer.writerow(['Age', 'SAVINGS', 'Annual Income Required', 'Annual Dividend Income', 'Monthly Income Required', 'Monthly Dividend Income', 'Additional Cash Required'])
+    for age, investment, annual_income_required, annual_dividend_income, monthly_dividend_income, income_required, difference in post_retirement_investments:
+        additional_cash_required = f'{abs(difference):,.0f}' if difference < 0 else ''
+        csv_writer.writerow([age, f'{investment:,.0f}', f'{annual_income_required:,.0f}', f'{annual_dividend_income:,.0f}', f'{income_required:,.0f}', f'{monthly_dividend_income:,.0f}', additional_cash_required])
+
+    csv_string = csv_output.getvalue().encode('utf-8')
+    csv_base64 = base64.b64encode(csv_string).decode('utf-8')
 
     # style.css에서 CSS 읽기
     css = load_css()
 
+    # SVG 그래프 생성
+    fig, ax = plt.subplots()
+    ages = [investment[0] for investment in post_retirement_investments]
+    income_required = [investment[2] for investment in post_retirement_investments]
+    dividend_income = [investment[3] for investment in post_retirement_investments]
+
+    ax.plot(ages, income_required, label='Income Required', color='red')
+    ax.plot(ages, dividend_income, label='Dividend Income', color='green')
+    ax.set_xlabel('Age')
+    ax.set_ylabel('Amount')
+    # ax.set_title('Retirement Plan Overview')
+    ax.legend()
+    ax.grid(True)
+
+    # 그래프를 SVG 형식으로 저장
+    svg_output = io.StringIO()
+    plt.savefig(svg_output, format='svg')
+    plt.close(fig)
+    svg_data = svg_output.getvalue()
+    svg_base64 = base64.b64encode(svg_data.encode('utf-8')).decode('utf-8')
+
     # 은퇴 계획에 대한 HTML 결과 생성
     result_html = css + f"""
     <div class="wrap-text" style="box-shadow: 0 0.25rem 0.5rem rgba(0, 0, 0, 0.1); border-radius: 0.5rem; padding: 3rem; position: relative; width: 100%; padding: 1.5rem;">
         <div>
             <div style="margin-bottom: 1.5rem;">
-                <!-- 은퇴 시점의 총 투자액 표시 -->
-                <div style="font-size: 1.5rem; margin-top: 1.5rem; margin-bottom: 1.5rem;">SAVINGS at retirement</div>
-                <div style="font-size: 1.5rem; font-weight: bold; color: #1c75bc;">
-                    <span style='color: #1678fb'>{investment_at_retirement:,.0f}</span>
-                </div>
+                <div style="font-size: 1.5rem; margin-top: 1.5rem; margin-bottom: 1.5rem;"></div>
+                <img src="data:image/svg+xml;base64,{svg_base64}" alt="Retirement Plan Graph" style="width: 100%; height: auto;"/>
+            </div>  
+            <div style="margin-bottom: 1.5rem;">
+                <div style="font-size: 1.5rem; margin-top: 1.5rem; margin-bottom: 1.5rem;">Income Required Immediately After Retirement</div>
+                    <span style='font-size: 1.5rem; font-weight: bold; color: #1678fb'>{annual_income_required_at_retirement:,.0f}</span>
+                    Annual
+                    <div></div>
+                    <span style='font-size: 1.5rem; font-weight: bold; color: #1678fb'>{monthly_income_required_at_retirement:,.0f}</span>
+                    MONTHLY
                 <hr style="margin: 1.5rem 0;">
             </div>
-        </div>
-        <div>
             <div style="margin-bottom: 1.5rem;">
-                <!-- 은퇴 시점의 연간 및 월간 배당 수익 표시 -->
-                <div style="font-size: 1.5rem; margin-top: 1.5rem; margin-bottom: 1.5rem;">DIVIDEND INCOME at retirement</div>
-                    <span style='font-size: 1.5rem; font-weight: bold; color: #1678fb'>{annual_dividend_at_retirement:,.0f}</span> 
+                <div style="font-size: 1.5rem; margin-top: 1.5rem; margin-bottom: 1.5rem;">Dividend Income Immediately After Retirement</div>
+                    <span style='font-size: 1.5rem; font-weight: bold; color: #1678fb'>{annual_dividend_at_retirement:,.0f}</span>
                     Annual
-                    <p></p>
-                    <span style='font-size: 1.5rem; font-weight: bold; color: #1678fb'>{monthly_dividend_at_retirement:,.0f}</span> 
-                    Monthly 
+                    <div></div>                    
+                    <span style='font-size: 1.5rem; font-weight: bold; color: #1678fb'>{monthly_dividend_at_retirement:,.0f}</span>
+                    MONTHLY
+                <hr style="margin: 1.5rem 0;">
+            </div>
+            <div style="margin-bottom: 1.5rem;">
+                <div style="font-size: 1.5rem; margin-top: 1.5rem; margin-bottom: 1.5rem;">Total Additional Cash Required</div>
+                    <span style='font-size: 1.5rem; font-weight: bold; color: #1678fb'>{abs(negative_differences_sum):,.0f}</span>
                 <hr style="margin: 1.5rem 0;">
             </div>
+            
         </div>
     </div>
-    <h3>Dividend Income After Retirement</h3>
+    <div style="margin-bottom: 2rem;"></div>
+    <div style="display: flex; align-items: center; justify-content: space-between;">
+        <h3>Retirement Plan Overview</h3>
+        <a href="data:text/csv;base64,{csv_base64}" download="retirement_planning.csv" style="padding: 10px 20px; border: 1px solid; border-radius: 5px; background-color: #1678fb; color: white; text-decoration: none;">Download CSV</a>
+    </div>
     <div class='table-container'>
         <table>
             <thead>
                 <tr>
                     <th>Age</th>
                     <th>SAVINGS</th>
-                    <th>Annual</th>
-                    <th>Monthly</th>
+                    <th>Annual Income Required</th>
+                    <th>Annual Dividend Income</th>
+                    <th>Monthly Income Required</th>
+                    <th>Monthly Dividend Income</th>
+                    <th>Additional Cash Required</th>
                 </tr>
             </thead>
             <tbody>
     """
-    
-    # 각 연도별 투자와 배당 수익을 테이블에 추가
-    for age, investment, annual_dividend_income, monthly_dividend_income in post_retirement_investments:
+
+    # 각 연도별 투자와 배당 수익 및 월 생활비를 테이블에 추가
+    for age, investment, annual_income_required, annual_dividend_income, monthly_dividend_income, income_required, difference in post_retirement_investments:
+        additional_cash_required = f'{abs(difference):,.0f}' if difference < 0 else ''
         result_html += f"""
                 <tr>
                     <td>{age}</td>
                     <td>{investment:,.0f}</td>
+                    <td>{annual_income_required:,.0f}</td>
                     <td>{annual_dividend_income:,.0f}</td>
+                    <td>{income_required:,.0f}</td>
                     <td>{monthly_dividend_income:,.0f}</td>
+                    <td>{additional_cash_required}</td>
                 </tr>
         """
 

modules/share_price_trend.py

@@ -0,0 +1,109 @@
+import io
+import matplotlib.pyplot as plt
+import FinanceDataReader as fdr
+import pandas as pd
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+def get_stock_prices(stock_code, days):
+    try:
+        df = fdr.DataReader(stock_code)
+        end_date = pd.to_datetime('today')
+        start_date = pd.date_range(end=end_date, periods=days, freq='B')[0]
+        df = df[(df.index >= start_date) & (df.index <= end_date)]
+        return df['Close']
+    except Exception as e:
+        print(f"Failed to fetch data for {stock_code}: {e}")
+        return None
+
+def share_price_trend(stock_codes, days):
+    stock_prices = {}
+    with ThreadPoolExecutor(max_workers=10) as executor:
+        futures = {executor.submit(get_stock_prices, stock_code.strip(), int(days)): stock_code.strip() for stock_code in stock_codes.split(',')}
+        for future in as_completed(futures):
+            stock_code = futures[future]
+            try:
+                prices = future.result()
+                if prices is not None:
+                    stock_prices[stock_code] = prices
+            except Exception as e:
+                print(f"Failed to fetch data for {stock_code}: {e}")
+
+    plt.switch_backend('agg')
+    plt.style.use('tableau-colorblind10')  # 테마 변경
+
+    fig, ax = plt.subplots(figsize=(8, 4.5))
+    for stock_code, prices in stock_prices.items():
+        relative_prices = prices / prices.iloc[0]
+        ax.plot(prices.index, relative_prices, label=stock_code.upper())
+    
+    ax.spines['top'].set_visible(False)
+    ax.spines['right'].set_visible(False)
+    
+    ax.set_xlabel('Date')
+    ax.set_ylabel('Relative Price (Normalized to 1)')
+    ax.legend()
+    plt.tight_layout()
+
+    svg_graph = io.StringIO()
+    plt.savefig(svg_graph, format='svg')
+    svg_graph.seek(0)
+    svg_data = svg_graph.getvalue()
+    plt.close()
+
+    svg_data = svg_data.replace('<svg ', '<svg width="100%" height="100%" ')
+    svg_data = svg_data.replace('</svg>', '''
+    <defs>
+        <linearGradient id="grad1" x1="0%" y1="0%" x2="100%" y2="0%">
+            <stop offset="0%" style="stop-color:rgb(173,216,230);stop-opacity:1" />
+            <stop offset="100%" style="stop-color:rgb(0,191,255);stop-opacity:1" />
+        </linearGradient>
+        <filter id="dropshadow" height="130%">
+            <feGaussianBlur in="SourceAlpha" stdDeviation="3"/>
+            <feOffset dx="2" dy="2" result="offsetblur"/>
+            <feMerge> 
+                <feMergeNode/>
+                <feMergeNode in="SourceGraphic"/> 
+            </feMerge>
+        </filter>
+    </defs>
+    <style>
+        @keyframes lineAnimation {
+            from {
+                stroke-dasharray: 0, 1000;
+            }
+            to {
+                stroke-dasharray: 1000, 0;
+            }
+        }
+        path {
+            animation: lineAnimation 1s linear forwards;
+        }
+    </style>
+    </svg>''')
+
+    # Replace line color with gradient, add shadow filter, and apply animation
+    svg_data = svg_data.replace('stroke="#1f77b4"', 'stroke="url(#grad1)" filter="url(#dropshadow)"')
+
+    html_table = "<h3>Stock Prices Data</h3><div class='table-container'><table>"
+    html_table += "<thead><tr><th>Date</th>"
+    for stock_code in stock_prices.keys():
+        html_table += f"<th>{stock_code.upper()}</th>"
+    html_table += "</tr></thead><tbody>"
+
+    dates = stock_prices[list(stock_prices.keys())[0]].index[::-1]
+    for date in dates:
+        html_table += f"<tr><td>{date.strftime('%Y-%m-%d')}</td>"
+        for stock_code in stock_prices.keys():
+            html_table += f"<td>{stock_prices[stock_code][date]:,.2f}</td>"
+        html_table += "</tr>"
+
+    html_table += "</tbody></table></div>"
+
+    graph_html = f'<h3>Relative Stock Prices Over the Last {days} Days</h3>{svg_data}'
+    return graph_html + html_table
+
+# 예시 사용 방법
+# stock_codes = "AAPL,MSFT,GOOGL"
+# days = 30
+# result = compare_stock_prices(stock_codes, days)
+# print(result)

style.css

@@ -13,8 +13,8 @@
 #col-container {
     margin: 0 auto;
     max-width: 100%;
-    font-family: 'Patrick Hand', 'ui-sans-serif', 'system-ui', 'sans-serif';
-    text-transform: uppercase; /* 모든 텍스트를 대문자로 변환합니다 */
+    font-family: 'Montserrat', 'ui-sans-serif', 'system-ui', 'sans-serif';
+    /* text-transform: uppercase; 모든 텍스트를 대문자로 변환합니다 */
 
 }
 
@@ -142,6 +142,7 @@
     }
 }
 
+/* 기본 테이블 스타일 */
 .table-container {
     width: 100%;
     overflow: auto;
@@ -163,12 +164,9 @@
     background-color: var(--background-color-light);
 }
 
-.table-container tr:hover td {
-    background: #e7f9ef;
-}
-
 .table-container th {
     background-color: var(--highlight-color-light);
+    color: var(--header-color-light); /* 라이트 모드에서 타이틀 색상을 설정 */
     position: sticky;
     top: 0;
     z-index: 2;
@@ -185,6 +183,16 @@
     z-index: 3;
 }
 
+/* 마우스오버 효과 */
+.table-container tr:hover td {
+    background: #e7f9ef;
+    color: #000;
+    /* border: 1px solid #4caf50;
+    transform: scale(1.02);
+    transition: all 0.3s ease; */
+}
+
+/* 어두운 테마 적용 */
 @media (prefers-color-scheme: dark) {
     .table-container {
         border: 1px hidden #444;
@@ -209,5 +217,15 @@
     .table-container tr:hover td {
         background: #e7f9ef;
         color: #000;
+        /* border: 1px solid #4caf50;
+        transform: scale(1.02);
+        transition: all 0.3s ease; */
     }
 }
+
+/* 추가적인 마우스오버 효과 */
+/* .table-container tr:hover td {
+    text-shadow: 1px 1px 2px rgba(0, 0, 0, 0.2);
+    cursor: pointer;
+} */
+