Delete modules

modules/compare_stock_prices.py

@@ -1,109 +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)]
-        return df['Close']
-    except Exception as e:
-        print(f"Failed to fetch data for {stock_code}: {e}")
-        return None
-
-def compare_stock_prices(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)

modules/cost_averaging.py

@@ -1,122 +0,0 @@
-from modules.utils import load_css
-
-def 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_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 = 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/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/portfolio_rebalancing.py

@@ -1,241 +0,0 @@
-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 portfolio_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/rebalancing.py

@@ -1,297 +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_donut_chart, format_value, current_time
-from collections import defaultdict
-
-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(eval(quantity_expr.replace(' ', '')))
-                if target_ratio_expr.strip() == '[]':
-                    target_ratio = 0
-                else:
-                    target_ratio = float(eval(target_ratio_expr.strip('[]').replace(' ', '')))
-                
-                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 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 set_default_ratios_if_zero(target_ratios):
-    total_target_ratio = sum(target_ratios.values())
-    if total_target_ratio == 0:
-        num_stocks = len(target_ratios)
-        default_ratio = 1 / num_stocks
-        return {stock_code: default_ratio for stock_code in target_ratios}
-    return target_ratios
-
-def build_portfolio(stock_inputs, main_currency):
-    portfolio = {}
-    target_ratios = {}
-    
-    with ThreadPoolExecutor() as executor:
-        results = list(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
-    
-    target_ratios = set_default_ratios_if_zero(target_ratios)
-
-    return portfolio, target_ratios, total_value
-
-def generate_portfolio_info(portfolio, total_value, main_currency):
-    css = load_css()
-    currency_symbol = get_currency_symbol(main_currency)
-    
-    # 보유 종목별 총액을 계산합니다.
-    holdings_totals = {
-        stock_code: {
-            'value': stock['price'] * stock['quantity'],
-            'weight': (stock['price'] * stock['quantity'] / total_value)
-        }
-        for stock_code, stock in portfolio.items()
-    }
-    
-    # 통화별 총액을 계산합니다.
-    currency_totals = defaultdict(lambda: {'value': 0, 'weight': 0})
-    for stock in portfolio.values():
-        currency = stock['currency']
-        value = stock['price'] * stock['quantity']
-        currency_totals[currency]['value'] += value
-        currency_totals[currency]['weight'] += value / total_value
-
-    # 현재 비중을 사용하여 포트폴리오 트리맵 차트를 생성합니다.
-    currunt_weights = {stock_code: details['weight'] for stock_code, details in holdings_totals.items()}
-    currunt_weights_chart = plot_donut_chart(currunt_weights)
-    
-    currency_weights = {currency: details['weight'] for currency, details in currency_totals.items()}
-    currency_weights_chart = plot_donut_chart(currency_weights)
-
-    # HTML 생성
-    portfolio_info = css + f"""
-    <div class="wrap-text">
-        <h3>Your Portfolio Holdings</h3>
-        {currunt_weights_chart}    
-        <div class='table-container wrap-text'>
-            <table>
-                <thead>
-                    <tr><th>Stock Code</th><th>Current Weight (%)</th><th>Current Value</th></tr>
-                </thead>
-                <tbody>
-                    {''.join(
-                        f"<tr><td>{stock_code.upper()}</td><td>{details['weight'] * 100:.1f}%</td><td>{currency_symbol}{format_value(details['value'])}</td></tr>"
-                        for stock_code, details in holdings_totals.items()
-                    )}
-                </tbody>
-            </table>
-        </div>
-
-        <br>        
-    </div>
-    """
-        # <br>        
-        # <h3>Your Portfolio by Currency</h3>
-        # {currency_weights_chart}
-        # <br>
-        # <div class='table-container wrap-text'>
-        #     <table>
-        #         <thead>
-        #             <tr><th>Currency</th><th>Total Weight (%)</th><th>Total Value</th></tr>
-        #         </thead>
-        #         <tbody>
-        #             {''.join(
-        #                 f"<tr><td>{currency.upper()}</td><td>{details['weight']* 100:.1f}%</td><td>{currency_symbol}{format_value(details['value'])}</td></tr>"
-        #                 for currency, details in currency_totals.items()
-        #             )}
-        #         </tbody>
-        #     </table>
-        # </div>
-    return portfolio_info
-
-def generate_rebalancing_analysis(portfolio, target_ratios, total_value, main_currency, cash_amount, allow_selling):
-    css = load_css()
-    currency_symbol = get_currency_symbol(main_currency)
-    adjustments = []
-
-    new_total_value = cash_amount + total_value
-    total_target_ratio = sum(target_ratios.values())
-    
-    target_ratios = set_default_ratios_if_zero(target_ratios)
-
-    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 / total_target_ratio
-        target_value = new_total_value * target_weight
-        difference = target_value - current_value
-
-        # Allow selling이 false이고 현금이 음수인 경우 매도를 방지
-        if not allow_selling and (difference < 0 or cash_amount < 0):
-            trade_quantity = 0
-        else:
-            trade_quantity = difference / stock_data['price']
-
-        if trade_quantity > 0 and not allow_selling:
-            trade_quantity = min(trade_quantity, cash_amount / stock_data['price'])
-
-        trade_value = trade_quantity * stock_data['price']
-        new_quantity = trade_quantity + stock_data['quantity']
-        new_value = new_quantity * stock_data['price']
-        
-        if trade_value > 0:
-            cash_amount -= trade_value
-        else:
-            cash_amount += abs(trade_value)
-        
-        # 각 항목별 Buy_or_Sell 값을 루프 안에서 정의
-        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>"
-
-        adjustments.append({
-            'difference': difference,
-            'current_value': current_value,
-            'target_ratio': target_ratio,
-            'current_value_pct': current_value / total_value,
-            'trade_quantity': trade_quantity,
-            'stock_code': stock_code,
-            'price': stock_data['price'],
-            'new_value': new_value,
-            "Buy_or_Sell": Buy_or_Sell,
-            'trade_value': trade_value,
-            'old_quantity': stock_data['quantity'],
-            'new_quantity': new_quantity,
-            'target_weight': target_weight,
-            'currency': stock_data['currency'],
-            'new_value_pct': new_value / new_total_value
-        })
-
-    # HTML 생성
-    rebalancing_analysis = css + f"""
-    <div class="wrap-text">
-        <div style="margin-bottom: 1.5rem;">
-            <div style="font-size: 1.5rem; margin-top: 1.5rem; margin-bottom: 1.5rem;">Re-Balancing Analysis | Your Portfolio Holdings as of {current_time}</div>
-            <span style='font-size: 1.5rem; font-weight: bold; color: #1678fb'>{currency_symbol}{format_value(sum(adj['new_value'] for adj in adjustments))} </span>
-            (After Trades)
-        </div>
-        <div class='table-container wrap-text'>
-            <table>
-                <thead>
-                    <tr>
-                        <th colspan="1"></th>
-                        <th colspan="2" class="header-bg-before">Your Current Portfolio (Before Trades)</th>
-                        <th colspan="1"></th>                        
-                        <th colspan="5" style='text-align: center'>Trades to Re-Balance Your Portfolio</th>
-                        <th colspan="2" class="header-bg-after">Your Adjusted Portfolio (After Trades)</th>
-                    </tr>
-                    <tr>
-                        <th>Stock Code</th>
-                        <th class="header-bg-before">Total Value - {main_currency} {currency_symbol}</th>
-                        <th class="header-bg-before">% Asset Allocation</th>
-                        <th>Your Target Asset Allocation %</th>
-                        <th>Buy or Sell?</th>
-                        <th>Trade Amount - {main_currency} {currency_symbol}</th>
-                        <th>Current Price per Share - {main_currency} {currency_symbol}</th>
-                        <th>Estimated # of Shares to Buy or Sell</th>
-                        <th>Shares Before and After</th>
-                        <th class="header-bg-after">Total Value - {main_currency} {currency_symbol}</th>
-                        <th class="header-bg-after">% Asset Allocation</th>
-                    </tr>
-                    <tr style="font-weight: bold;">
-                        <td>Total</td>
-                        <td>{format_value(sum(adj['current_value'] for adj in adjustments))}</td>
-                        <td>{sum(adj['current_value'] for adj in adjustments) / total_value * 100:.1f}%</td>
-                        <td></td>
-                        <td></td>
-                        <td>{format_value(sum(adj['trade_value'] for adj in adjustments))}</td>
-                        <td></td>
-                        <td></td>
-                        <td></td>
-                        <td>{format_value(sum(adj['new_value'] for adj in adjustments))}</td>
-                        <td>{sum(adj['new_value'] for adj in adjustments) / new_total_value * 100:.1f}%</td>
-                    </tr>
-                </thead>
-                <tbody>
-                    {''.join(
-                        f"<tr>"
-                        f"<td>{adj['stock_code'].upper()}</td>"
-                        f"<td>{format_value(adj['current_value'])}</td>"
-                        f"<td>{adj['current_value_pct'] * 100:.1f}%</td>"
-                        f"<td><span class='highlight-edit'>{adj['target_weight'] * 100:.1f}%</span></td>"
-                        f"<td>{adj['Buy_or_Sell']}</td>"
-                        f"<td><span class='highlight-sky'>{format_value(adj['trade_value'])}</span></td>"
-                        f"<td>{adj['price']:,.2f}</td>"
-                        f"<td><span class='highlight-sky'>{format_quantity(adj['trade_quantity'])}</span></td>"
-                        f"<td>{format_quantity(adj['old_quantity'])} → {format_quantity(adj['new_quantity'])}</td>"
-                        f"<td>{format_value(adj['new_value'])}</td>"
-                        f"<td>{adj['new_value_pct'] * 100:.1f}%</td>"
-                        f"</tr>"
-                        for adj in adjustments
-                    )}
-                </tbody>
-            </table>
-        </div>
-        <br>
-        
-    </div>
-    """
-
-    return rebalancing_analysis
-
-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, total_value, main_currency)
-        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,175 +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):
-    # 아주 작은 값을 0으로 처리
-    if abs(quantity) < 1e-5:  # 임계값을 조정하여 더 적절한 값을 설정할 수 있습니다.
-        quantity = 0    
-    if quantity < 0:
-        return f"({-quantity:,.1f})"
-    else:
-        return f"{quantity:,.1f}"
-
-def format_value(value):
-    # 아주 작은 값을 0으로 처리
-    if abs(value) < 1e-5:  # 임계값을 조정하여 더 적절한 값을 설정할 수 있습니다.
-        value = 0
-    if value < 0:
-        return f"({-value:,.0f})"
-    else:
-        return f"{value:,.0f}"
-
-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 numpy as np
-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(index, color_map, num_labels):
-    """Retrieve or generate color for the given index."""
-    if index not in color_map_storage:
-        cmap = plt.get_cmap(color_map)
-        # Generate a color based on index (inverse of the index for color intensity)
-        color_map_storage[index] = cmap(1 - index / (num_labels - 1))
-    return color_map_storage[index]
-
-def plot_donut_chart(data, color_map='Blues', 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>'  # 데이터가 없는 경우 처리
-
-    # 비중에 따라 데이터를 정렬
-    sorted_data = sorted(filtered_data.items(), key=lambda item: item[1], reverse=True)
-    labels, sizes = zip(*sorted_data)
-    
-    # 색상 맵을 설정
-    num_labels = len(labels)
-    
-    # 원형 차트의 색상 리스트 생성
-    colors = [get_color_for_label(i, color_map, num_labels) for i in range(num_labels)]
-
-    # 도넛 차트 시각화
-    fig, ax = plt.subplots(figsize=(12, 8), dpi=300)  # figsize와 dpi를 설정하여 해상도 높이기
-    wedges, _ = ax.pie(
-        sizes,
-        colors=colors,
-        labels=[None]*num_labels,  # 라벨을 없애기
-        autopct=None,              # 값 표시를 없애기
-        startangle=-90,            # 12시 방향부터 시작
-        pctdistance=0.85,
-        wedgeprops=dict(width=0.4, edgecolor='w')  # 도넛 차트
-    )
-    
-    # y축 뒤집기
-    ax.invert_yaxis()
-    
-    # 범례 생성
-    handles = [plt.Line2D([0], [0], marker='o', color='w', label=f'{label} {size * 100:.1f}%',
-                         markersize=15, markerfacecolor=get_color_for_label(i, color_map, num_labels))
-               for i, (label, size) in enumerate(zip(labels, sizes))]
-    
-    # 범례 추가, 제목 제거, 글자 크기를 키우고 범례 박스를 조정
-    ax.legend(handles=handles, loc='upper left', bbox_to_anchor=(1, 1), 
-              prop=font_manager.FontProperties(fname=font_path, size=legend_fontsize), frameon=False)
-    
-    # 축을 숨깁니다.
-    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")}" />'