Delete modules

modules/dollar_cost_averaging.py

@@ -1,101 +0,0 @@
-from modules.utils import load_css
-
-def calculate_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 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 = calculate_dollar_cost_averaging(old_avg_price, old_quantity, new_price, new_quantity)
-
-    # 수익률에 따른 클래스 설정
-    emoji_return = ""
-    new_return_class = ""
-    old_return_class = ""
-    if new_return > old_return:
-        emoji_return = "💧"
-    elif new_return < old_return:
-        emoji_return = "🔥"
-    else: 
-        emoji_return = ""
-
-    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">
-        <div>
-            <div style="margin-bottom: 1.5rem;">
-                <!-- 새로운 수익률 표시 -->
-                <div style="font-size: 1.5rem; margin-top: 1.5rem; margin-bottom: 1.5rem;">{emoji_return}</div>
-                <div style="font-size: 1.5rem;">
-                    {old_return_class} ➜ {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;">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;">Transaction</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>
-    """
-    return result_html

modules/rebalancing.py

@@ -1,261 +0,0 @@
-import math
-import FinanceDataReader as fdr
-import yfinance as yf
-from concurrent.futures import ThreadPoolExecutor
-from modules.utils import load_css, get_currency_symbol, format_quantity, plot_treemap
-
-def parse_input(holdings, cash_amount):
-    try:
-        lines = holdings.strip().split(',')
-        stock_inputs = []
-        total_target_ratio = 0
-        
-        for line in lines:
-            parts = line.split()
-            if len(parts) == 4:
-                stock_code, currency_code, quantity_expr, target_ratio_expr = parts
-                # 수량과 비중을 숫자로 변환
-                quantity = float(quantity_expr.replace(' ', ''))
-                # 목표 비율이 빈 대괄호일 경우 0으로 처리
-                if target_ratio_expr.strip() == '[]':
-                    target_ratio = 0
-                else:
-                    target_ratio = float(eval(target_ratio_expr.strip('[]').replace(' ', '')))
-                
-                # 수량을 정수로 내림 처리
-                quantity = math.floor(quantity)
-                
-                stock_inputs.append((currency_code.upper(), stock_code, quantity, target_ratio))
-                total_target_ratio += target_ratio
-
-        return stock_inputs, cash_amount
-    except Exception as e:
-        raise ValueError(f"Input parsing error: {e}")
-
-def get_portfolio_exchange_rate(currency_code, main_currency):
-    try:
-        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)
-        if not data.empty:
-            return data['Close'].iloc[0]
-        else:
-            raise ValueError("<p style='color: red;'>Failed to retrieve exchange rate data.</p>")
-    except Exception as e:
-        raise ValueError(f"<p style='color: red;'>Exchange rate retrieval error: {e}</p>")
-
-def get_portfolio_exchange_reflected_stock_price(stock_code, currency_code, main_currency):
-    try:
-        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)
-    except Exception as e:
-        raise ValueError(f"<p style='color: red;'>Exchange reflected stock price error: {e}</p>")
-
-def get_portfolio_current_stock_price(stock_code):
-    try:
-        df = fdr.DataReader(stock_code)
-        return df['Close'].iloc[-1]
-    except Exception as e:
-        raise ValueError(f"<p style='color: red;'>Current stock price retrieval error: {e}</p>")
-
-def build_portfolio(stock_inputs, main_currency):
-    portfolio = {}
-    target_ratios = {}
-    
-    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[0]), stock_inputs)
-    
-    total_value = 0
-    for stock_code, new_price, quantity, target_ratio, currency_code in results:
-        portfolio[stock_code] = {'quantity': quantity, 'price': new_price, 'currency': currency_code}
-        target_ratios[stock_code] = target_ratio
-        total_value += new_price * quantity
-
-    # 목표 비율의 합이 0인 경우, 기본 비율 설정
-    total_target_ratio = sum(target_ratios.values())
-    if total_target_ratio == 0:
-        # 기본 비율을 설정하거나, 균등 분배
-        num_stocks = len(stock_inputs)
-        default_ratio = num_stocks / num_stocks
-        for stock_code in target_ratios:
-            target_ratios[stock_code] = default_ratio
-
-    return portfolio, target_ratios, total_value
-
-def generate_portfolio_info(portfolio, target_ratios, total_value, main_currency, cash_amount):
-    css = load_css()
-    currency_symbol = get_currency_symbol(main_currency)
-    
-    # 현재 상태 차트
-    current_weights = {stock_code: (stock['price'] * stock['quantity'] / total_value) * 100 for stock_code, stock in portfolio.items()}
-    current_chart = plot_treemap(current_weights)
-
-    portfolio_info = css + f"""
-    <div class="wrap-text">
-        <div>
-            <div style="margin-bottom: 1.5rem;">
-                <div style="font-size: 1.5rem; margin-top: 1.5rem; margin-bottom: 1.5rem;">Your Current Portfolio (Before Trades)</div>
-                    <span style='font-size: 1.5rem; font-weight: bold; color: #1678fb'>{currency_symbol}{format_quantity(total_value)}</span>
-                <hr style="margin: 1.5rem 0;">
-                {current_chart}
-            </div>
-        </div>
-    <br>
-    """
-
-    # 현재 비율 및 가치를 계산
-    current_values = {stock_code: stock['price'] * stock['quantity'] for stock_code, stock in portfolio.items()}
-    sorted_stocks = current_values.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, current_value in sorted_stocks:
-        weight = (current_value / total_value) * 100
-        current_info_html += (
-            f"<tr>"
-            f"<td>{stock_code.upper()}</td>"
-            f"<td>{weight:.1f}%</td>"
-            f"<td>{currency_symbol}{current_value:,.0f}</td>"
-            f"</tr>"
-        )
-    current_info_html += "</tbody></table></div><br>"
-
-    # 통화별 포트폴리오 요약 생성
-    currency_totals = {currency: {'amount': 0, 'weight': 0} for currency in set(stock_data['currency'] 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
-
-    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>"
-
-    return portfolio_info + current_info_html + currency_table
-
-def generate_rebalancing_analysis(portfolio, target_ratios, total_value, main_currency, cash_amount, allow_selling):
-    currency_symbol = get_currency_symbol(main_currency)
-    
-    total_trade_value = 0
-    adjustments = []
-    new_total_value = cash_amount + total_value
-
-    for stock_code, stock_data in portfolio.items():
-        current_value = stock_data['price'] * stock_data['quantity']
-        target_ratio = target_ratios.get(stock_code, 0)
-        target_weight = target_ratio / sum(target_ratios.values())
-        target_value = new_total_value * target_weight
-        difference = target_value - current_value
-
-        if not allow_selling and difference < 0:
-            # 매도를 허용하지 않는 경우, 매도는 생략
-            trade_quantity = 0
-        else:
-            trade_quantity = math.floor(difference / stock_data['price']) if difference > 0 else -math.ceil(-difference / stock_data['price'])
-        
-        # 거래가 가능한지 확인 (현금 잔고 확인 포함)
-        if trade_quantity > 0 and not allow_selling:
-            trade_quantity = min(trade_quantity, cash_amount // 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)
-        
-        current_value_pct = (current_value / total_value) * 100
-        adjustments.append((difference, current_value, target_ratio, current_value_pct, trade_quantity, stock_code, stock_data['price'], new_value, trade_value, stock_data['quantity'], new_quantity, target_weight, stock_data['currency']))
-
-    total_new_stock_value = sum(adj[7] for adj in adjustments)
-    new_weights = {stock_code: (new_value / total_new_stock_value) * 100 for _, _, _, _, _, stock_code, _, new_value, _, _, _, _, _ in adjustments}
-    new_chart = plot_treemap(new_weights)
-
-    for i in range(len(adjustments)):
-        (difference, current_value, target_ratio, current_value_pct, trade_quantity, stock_code, price, new_value, trade_value, old_quantity, new_quantity, target_weight, currency) = adjustments[i]
-        new_value_pct = (new_value / total_new_stock_value) * 100
-        adjustments[i] = (difference, current_value, target_ratio, current_value_pct, trade_quantity, stock_code, price, new_value, trade_value, old_quantity, new_quantity, target_weight, new_value_pct, currency)
-
-    cash_balance = new_total_value - total_new_stock_value
-
-    result_message = f"""
-    <div>
-        <div style="margin-bottom: 1.5rem;">
-            <div style="font-size: 1.5rem; margin-top: 1.5rem; margin-bottom: 1.5rem;">Your Adjusted Portfolio (After Trades)</div>
-            <span style='font-size: 1.5rem; font-weight: bold; color: #1678fb'>{currency_symbol}{format_quantity(total_new_stock_value)}</span>
-            Adjusted Portfolio
-            <div></div>
-            <span style='font-size: 1.5rem; font-weight: bold; color: #1678fb'>{currency_symbol}{format_quantity(cash_balance)}</span>
-            cash balance
-            <hr style="margin: 1.5rem 0;">
-            {new_chart}            
-        </div>
-    </div>
-    <br>
-    <h3>Trades to Re-Balance Your Portfolio</h3>
-    <div class='table-container wrap-text'><table>"""
-    result_message += "<thead><tr><th>Stock Code</th><th>Current Weight (%)</th><th>Target Ratio</th><th>Target Weight (%)</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 (difference, current_value, target_ratio, current_value_pct, trade_quantity, stock_code, price, new_value, trade_value, old_quantity, new_quantity, target_weight, new_value_pct, currency) in adjustments:
-        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_ratio_str = f"<span class='highlight-edit'>{target_ratio}</span>"
-        target_weight_str = f"{target_weight * 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}"         
-        trade_quantity_str = f"<span class='highlight-sky'>{format_quantity(trade_quantity)}</span>" if trade_value != 0 else ''
-        old_quantity_str = f"{old_quantity:,.0f} → {new_quantity:,.0f}" 
-        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_ratio_str}</td>"
-            f"<td>{target_weight_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><br></div></div>"
-
-    return result_message
-
-def rebalancing_tool(main_currency, holdings, cash_amount, allow_selling):
-    try:
-        stock_inputs, cash_amount = parse_input(holdings, cash_amount)
-        portfolio, target_ratios, total_value = build_portfolio(stock_inputs, main_currency)
-        portfolio_info = generate_portfolio_info(portfolio, target_ratios, total_value, main_currency, cash_amount)
-        rebalancing_analysis = generate_rebalancing_analysis(portfolio, target_ratios, total_value, main_currency, cash_amount, allow_selling)
-
-        return portfolio_info + rebalancing_analysis
-    except Exception as e:
-        return f"<p style='color: red;'>An error occurred: {e}</p>"

modules/retirement_planning.py

@@ -1,222 +0,0 @@
-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, 
-    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, 
-    post_retirement_roi=None, 
-    pre_retirement_dividend_yield=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
-
-    # 현재 투자액으로 초기 투자 설정
-    total_investment = current_investment
-
-    # 은퇴 전 월간 이자율 계산
-    monthly_return_pre = (1 + pre_retirement_roi / 100) ** (1 / 12) - 1
-
-    # 은퇴 시점의 투자 계산
-    for year in range(years_to_retirement):
-        for month in range(12):
-            # 월간 투자액과 이자율을 적용하여 총 투자액 갱신
-            total_investment = (total_investment + monthly_investment) * (1 + monthly_return_pre)
-            # 배당금을 재투자할 경우 배당금 추가
-            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
-    annual_dividend_at_retirement = investment_at_retirement * (pre_retirement_dividend_yield / 100)
-    monthly_dividend_at_retirement = annual_dividend_at_retirement / 12
-
-    # 은퇴 후 월간 이자율 계산
-    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_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):
-        # 은퇴 후 수익률을 적용하여 총 투자액 갱신
-        total_investment *= (1 + post_retirement_roi / 100)
-        # 연간 배당 수익 계산
-        annual_dividend_income = total_investment * (post_retirement_dividend_yield / 100)
-        # 월간 배당 수익 계산
-        monthly_dividend_income = annual_dividend_income / 12
-        # 연도별 물가상승률 반영한 월 생활비 갱신
-        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'{income_required:,.0f}', f'{annual_dividend_income:,.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')
-    
-    graph_html = f'<h3 style="margin-bottom: 0.5rem;">Retirement Planning: Income vs. Dividends</h3>'
-
-    # 은퇴 계획에 대한 HTML 결과 생성
-    result_html = css + f"""
-    <div class="wrap-text">
-        <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 After Retirement</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 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 style="margin-bottom: 1.5rem;">
-                <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
-                    <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;"></div>
-                {graph_html}
-                <img src="data:image/svg+xml;base64,{svg_base64}" alt="Retirement Plan Graph" style="width: 100%; height: auto;"/>
-            </div>  
-        </div>
-    </div>
-    <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 Income Required</th>
-                    <th>Monthly Income Required</th>
-                    <th>Annual Dividend Income</th>
-                    <th>Monthly Dividend Income</th>
-                    <th>Additional Cash Required</th>
-                </tr>
-            </thead>
-            <tbody>
-    """
-
-    # 각 연도별 투자와 배당 수익 및 월 생활비를 테이블에 추가
-    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>{income_required:,.0f}</td>
-                    <td>{annual_dividend_income:,.0f}</td>
-                    <td>{monthly_dividend_income:,.0f}</td>
-                    <td>{additional_cash_required}</td>
-                </tr>
-        """
-
-    result_html += """
-            </tbody>
-        </table>
-    </div>
-    <p style="padding: 10px; border: 1px solid; border-radius: 5px; text-align: center; max-width: 400px; margin: 20px auto;">
-        <strong>Note:</strong> No additional investments or reinvestment of dividends after retirement.
-    </p>
-    """
-
-    return result_html
-
-            

modules/share_price_trend.py

@@ -1,128 +0,0 @@
-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)]
-        if df.empty:
-            print(f"<p style='color: red;'>No data available for {stock_code}</p>")
-            return None
-        return df['Close']
-    except Exception as e:
-        print(f"<p style='color: red;'>Failed to fetch data for {stock_code}: {e}</p>")
-        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"<p style='color: red;'>Failed to fetch data for {stock_code}: {e}</p>")
-
-    if not stock_prices:
-        return "<p style='color: red;'>No data available for the provided stock codes.</p>"
-
-    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())
-
-    # Remove the axes and ticks
-    ax.spines['top'].set_visible(False)
-    ax.spines['right'].set_visible(False)
-    ax.spines['left'].set_visible(False)
-    ax.spines['bottom'].set_visible(False)
-    
-    ax.xaxis.set_visible(False)
-    ax.yaxis.set_visible(False)
-    
-    # Add grid for better readability
-    ax.grid(True, which='both', linestyle='--', linewidth=0.5)
-    
-    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>''')
-
-    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>"
-
-    # Create a date range with only business days
-    all_dates = pd.date_range(start=min(df.index.min() for df in stock_prices.values()), end=pd.to_datetime('today'), freq='B')
-    all_dates = all_dates[::-1]  # Reverse the order of dates
-
-    for date in all_dates:
-        html_table += f"<tr><td>{date.strftime('%Y-%m-%d')}</td>"
-        for stock_code in stock_prices.keys():
-            price = stock_prices[stock_code].get(date, None)
-            if price is not None:
-                html_table += f"<td>{price:,.2f}</td>"
-            else:
-                html_table += "<td>N/A</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
-
-# Example usage
-# stock_codes = "AAPL,MSFT,GOOGL"
-# days = 30
-# result = share_price_trend(stock_codes, days)
-# print(result)

modules/utils.py

@@ -1,164 +0,0 @@
-import ssl
-import logging
-import gradio as gr
-import matplotlib.pyplot as plt
-from io import BytesIO
-import base64
-from datetime import datetime
-
-# 로그 설정
-#logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
-
-# SSL 인증서 검증 비활성화
-ssl._create_default_https_context = ssl._create_unverified_context
-
-current_time = datetime.now().strftime("%b-%d-%Y")
-
-def load_css():
-    with open('style.css', 'r', encoding='utf-8') as file:
-        css = file.read()
-    return f"<style>{css}</style>"
-
-
-def format_quantity(quantity):
-    if quantity < 0:
-        return f"({-quantity:,})"
-    else:
-        return f"{quantity:,}"
-
-currency_symbols = {
-    "KRW": "₩",
-    "USD": "$",
-    "CAD": "$",
-    "EUR": "€",
-    "JPY": "¥",
-    "GBP": "£"
-}
-
-def get_currency_symbol(currency_code):
-    return currency_symbols.get(currency_code.upper(), "")
-
-def get_currency_codes():
-    return list(currency_symbols.keys())
-
-currency_codes = get_currency_codes()
-
-# Helper function to add buttons
-def clear_buttons(inputs):
-    clear_button = gr.ClearButton(value="Clear")
-    clear_button.click(
-        fn=lambda: [None] * len(inputs),
-        inputs=[],
-        outputs=inputs
-    )
-    return clear_button
-
-def submit_buttons(inputs, update_fn, output):    
-    submit_button = gr.Button(value="Run", variant="primary")
-    submit_button.click(
-        fn=update_fn,
-        inputs=inputs,
-        outputs=output
-    )
-    return submit_button
-
-def on_change(inputs, update_ouutput, outputs):
-    for input_component in inputs:
-        input_component.change(
-            fn=update_ouutput,
-            inputs=inputs,
-            outputs=outputs
-        )
-
-def render_components(component_rows):
-    for row in component_rows:
-        if isinstance(row, list):
-            with gr.Row():
-                for component in row:
-                    component.render()
-        else:
-            row.render()
-
-def create_tab(tab_name, inputs, outputs, update_fn, examples, component_rows):
-    with gr.TabItem(tab_name):
-        with gr.Row():
-            with gr.Column(elem_classes="input"):
-                render_components(component_rows)
-                clear_buttons(inputs)
-                submit_buttons(inputs, update_fn, outputs)
-                # gr.Examples(examples=examples, cache_examples=False, inputs=inputs)
-            with gr.Column():
-                outputs.render()
-        on_change(inputs, update_fn, outputs)
-
-import matplotlib.pyplot as plt
-import squarify
-from io import BytesIO
-import base64
-from matplotlib import font_manager
-
-# Global dictionary to store color mapping
-color_map_storage = {}
-
-def get_color_for_label(label, color_map, num_labels):
-    """Retrieve or generate color for the given label."""
-    if label not in color_map_storage:
-        cmap = plt.get_cmap(color_map)
-        # Generate a color based on label index
-        index = len(color_map_storage) % num_labels
-        color_map_storage[label] = cmap(index / (num_labels - 1))
-    return color_map_storage[label]
-
-def plot_treemap(data, color_map='Set3', font_path='Quicksand-Regular.ttf', legend_fontsize=30):
-    # 데이터 필터링: 비중이 0이 아닌 항목만 추출
-    filtered_data = {k: v for k, v in data.items() if v > 0}
-    
-    if not filtered_data:
-        return '<p>No data to display.</p>'  # 데이터가 없는 경우 처리
-
-    labels = [label.upper() for label in filtered_data.keys()]  # 라벨을 대문자로 변환
-    sizes = list(filtered_data.values())
-    
-    # 폰트 설정
-    font_properties = font_manager.FontProperties(fname=font_path, size=legend_fontsize)
-
-    # 색상 맵을 설정
-    num_labels = len(labels)
-
-    if len(labels) == 1:
-        # 항목이 하나일 때, 전체 사각형을 그립니다.
-        rectangles = [{'x': 0, 'y': 0, 'dx': 100, 'dy': 100}]
-        colors = [get_color_for_label(labels[0], color_map, num_labels)]  # 색상 하나로 채우기
-    else:
-        norm_sizes = squarify.normalize_sizes(sizes, 100, 100)
-        rectangles = squarify.squarify(norm_sizes, x=0, y=0, dx=100, dy=100)
-        colors = [get_color_for_label(label, color_map, num_labels) for label in labels]
-
-    # 트리맵 시각화
-    fig, ax = plt.subplots(figsize=(12, 8), dpi=300)  # figsize와 dpi를 설정하여 해상도 높이기
-    for rect, color in zip(rectangles, colors):
-        x, y, dx, dy = rect['x'], rect['y'], rect['dx'], rect['dy']
-        ax.add_patch(plt.Rectangle((x, y), dx, dy, color=color, alpha=0.7))
-
-    # 범례 생성
-    handles = [plt.Line2D([0], [0], marker='s', color='w', label=f'{label} {size:.1f}%',
-                         markersize=45, markerfacecolor=get_color_for_label(label, color_map, num_labels))
-               for label, size in zip(labels, sizes)]
-    
-    # 범례 추가, 제목 제거, 글자 크기를 키우고 범례 박스를 조정
-    ax.legend(handles=handles, loc='upper left', bbox_to_anchor=(1, 1), 
-              prop=font_properties, frameon=False)
-    
-    ax.set_xlim(0, 100)
-    ax.set_ylim(0, 100)
-    ax.axis('off')  # 축을 숨깁니다.
-    
-    # SVG로 저장
-    buf = BytesIO()
-    plt.savefig(buf, format='svg', bbox_inches='tight')  # bbox_inches='tight'를 추가하여 범례가 잘리는 문제를 방지
-    plt.close(fig)
-    buf.seek(0)
-    
-    # SVG 데이터를 base64로 인코딩
-    svg_str = buf.getvalue().decode('utf-8')
-    return f'<img src="data:image/svg+xml;base64,{base64.b64encode(svg_str.encode("utf-8")).decode("utf-8")}" />'