app.py

import gradio as gr
import pandas as pd
import numpy as np
from datetime import datetime
import plotly.graph_objects as go

class StartupValuationCalculator:
    def __init__(self):
        # 업종별 벤치마크 멀티플 (EV/ARR)
        self.industry_multiples = {
            "SaaS - B2B": {"low": 3, "mid": 6, "high": 10},
            "SaaS - B2C": {"low": 2, "mid": 4, "high": 7},
            "마켓플레이스": {"low": 2, "mid": 5, "high": 8},
            "이커머스": {"low": 1, "mid": 2.5, "high": 4},
            "핀테크": {"low": 3, "mid": 5, "high": 8},
            "헬스케어": {"low": 4, "mid": 7, "high": 12},
            "AI/딥테크": {"low": 5, "mid": 8, "high": 15},
            "기타": {"low": 2, "mid": 4, "high": 6}
        }
        
        # 성장률 조정 계수
        self.growth_adjustments = {
            "0-20%": 0.7,
            "20-50%": 0.9,
            "50-100%": 1.1,
            "100-200%": 1.3,
            "200%+": 1.5
        }
        
        # 단위경제 점수 가중치
        self.unit_economics_weights = {
            "ltv_cac_ratio": 0.3,
            "gross_margin": 0.3,
            "retention": 0.2,
            "payback": 0.2
        }
    
    def calculate_arr(self, monthly_revenue, revenue_type):
        """월 매출을 연간 반복 매출(ARR)로 변환"""
        if revenue_type == "구독형 (SaaS)":
            return monthly_revenue * 12
        elif revenue_type == "거래수수료형":
            return monthly_revenue * 12 * 0.8  # 거래수수료는 변동성 고려
        else:
            return monthly_revenue * 12 * 0.6  # 일회성 매출은 더 할인
    
    def calculate_ltv(self, arpu, gross_margin, monthly_churn):
        """LTV 계산"""
        if monthly_churn == 0:
            monthly_churn = 0.01  # 최소 이탈률
        return arpu * (gross_margin / 100) / monthly_churn
    
    def calculate_cac(self, monthly_marketing, monthly_sales, new_customers):
        """CAC 계산"""
        if new_customers == 0:
            return 0
        return (monthly_marketing + monthly_sales) / new_customers
    
    def calculate_payback(self, cac, arpu, gross_margin):
        """Payback Period 계산 (개월)"""
        if arpu * (gross_margin / 100) == 0:
            return 999
        return cac / (arpu * (gross_margin / 100))
    
    def get_unit_economics_score(self, ltv_cac_ratio, gross_margin, retention_rate, payback_months):
        """단위경제 점수 계산 (0-100)"""
        scores = {
            "ltv_cac_ratio": min(100, (ltv_cac_ratio / 3) * 100) if ltv_cac_ratio > 0 else 0,
            "gross_margin": min(100, gross_margin * 1.25),
            "retention": retention_rate,
            "payback": max(0, 100 - (payback_months / 24) * 100) if payback_months < 999 else 0
        }
        
        total_score = sum(scores[key] * self.unit_economics_weights[key] for key in scores)
        return total_score
    
    def get_growth_category(self, growth_rate):
        """성장률 카테고리 결정"""
        if growth_rate < 20:
            return "0-20%"
        elif growth_rate < 50:
            return "20-50%"
        elif growth_rate < 100:
            return "50-100%"
        elif growth_rate < 200:
            return "100-200%"
        else:
            return "200%+"
    
    def calculate_valuation(self, data):
        """종합 가치평가 계산"""
        # ARR 계산
        arr = self.calculate_arr(data["monthly_revenue"], data["revenue_type"])
        
        # 단위경제 계산
        ltv = self.calculate_ltv(data["arpu"], data["gross_margin"], data["monthly_churn"])
        cac = self.calculate_cac(data["monthly_marketing"], data["monthly_sales"], data["new_customers"])
        ltv_cac_ratio = ltv / cac if cac > 0 else 0
        payback = self.calculate_payback(cac, data["arpu"], data["gross_margin"])
        
        # 단위경제 점수
        ue_score = self.get_unit_economics_score(
            ltv_cac_ratio, data["gross_margin"], data["retention_rate"], payback
        )
        
        # 기본 멀티플 선택
        multiples = self.industry_multiples[data["industry"]]
        if ue_score >= 80:
            base_multiple = multiples["high"]
        elif ue_score >= 50:
            base_multiple = multiples["mid"]
        else:
            base_multiple = multiples["low"]
        
        # 성장률 조정
        growth_adj = self.growth_adjustments[self.get_growth_category(data["growth_rate"])]
        adjusted_multiple = base_multiple * growth_adj
        
        # 스테이지 조정
        stage_adj = {
            "MVP/베타": 0.7,
            "초기 매출": 0.85,
            "성장 단계": 1.0,
            "수익성 확보": 1.2
        }
        final_multiple = adjusted_multiple * stage_adj[data["stage"]]
        
        # 최종 가치평가
        valuation = arr * final_multiple
        
        # 런웨이 계산
        runway = data["cash_balance"] / data["burn_rate"] if data["burn_rate"] > 0 else 999
        
        return {
            "valuation": valuation,
            "arr": arr,
            "multiple": final_multiple,
            "ltv": ltv,
            "cac": cac,
            "ltv_cac_ratio": ltv_cac_ratio,
            "payback": payback,
            "ue_score": ue_score,
            "runway": runway
        }
    
    def create_comparison_chart(self, valuation, industry, arr):
        """동종업계 비교 차트 생성"""
        multiples = self.industry_multiples[industry]
        
        fig = go.Figure()
        
        # 업계 범위
        low_val = arr * multiples["low"]
        mid_val = arr * multiples["mid"]
        high_val = arr * multiples["high"]
        
        # 막대 그래프
        fig.add_trace(go.Bar(
            x=["하위 25%", "중간값", "상위 25%", "현재 기업"],
            y=[low_val, mid_val, high_val, valuation],
            text=[f"${low_val/1000000:.1f}M", f"${mid_val/1000000:.1f}M", 
                  f"${high_val/1000000:.1f}M", f"${valuation/1000000:.1f}M"],
            textposition="outside",
            marker_color=["lightgray", "gray", "darkgray", "blue"]
        ))
        
        fig.update_layout(
            title=f"{industry} 업계 가치평가 비교",
            yaxis_title="기업가치 (USD)",
            showlegend=False,
            height=400
        )
        
        return fig

def create_ui():
    calculator = StartupValuationCalculator()
    
    def process_valuation(
        company_name, founded_year, industry, stage, revenue_type,
        monthly_revenue, growth_rate, arpu, gross_margin, monthly_churn,
        retention_rate, new_customers, monthly_marketing, monthly_sales,
        cash_balance, burn_rate
    ):
        # 입력값 검증
        if monthly_revenue <= 0:
            return "월 매출을 입력해주세요.", None, None
        
        # 데이터 준비
        data = {
            "company_name": company_name,
            "founded_year": founded_year,
            "industry": industry,
            "stage": stage,
            "revenue_type": revenue_type,
            "monthly_revenue": monthly_revenue * 1000,  # 천 달러 단위로 입력받음
            "growth_rate": growth_rate,
            "arpu": arpu,
            "gross_margin": gross_margin,
            "monthly_churn": monthly_churn / 100,
            "retention_rate": retention_rate,
            "new_customers": new_customers,
            "monthly_marketing": monthly_marketing * 1000,
            "monthly_sales": monthly_sales * 1000,
            "cash_balance": cash_balance * 1000,
            "burn_rate": burn_rate * 1000
        }
        
        # 가치평가 계산
        results = calculator.calculate_valuation(data)
        
        # 결과 포맷팅
        valuation_text = f"""
# 🚀 {company_name} 가치평가 결과

## 📊 주요 지표
- **기업가치**: ${results['valuation']/1000000:.1f}M (₩{results['valuation']/1000000*1300:.0f}억)
- **ARR**: ${results['arr']/1000000:.1f}M
- **적용 멀티플**: {results['multiple']:.1f}x

## 💰 단위경제
- **LTV**: ${results['ltv']:.0f}
- **CAC**: ${results['cac']:.0f}
- **LTV/CAC**: {results['ltv_cac_ratio']:.1f}x
- **Payback Period**: {results['payback']:.1f}개월
- **단위경제 점수**: {results['ue_score']:.0f}/100

## 🏃 재무 건전성
- **현금 런웨이**: {results['runway']:.1f}개월
- **월간 번레이트**: ${burn_rate}K

## 💡 평가 인사이트
"""
        # 인사이트 추가
        if results['ltv_cac_ratio'] < 1:
            valuation_text += "- ⚠️ LTV/CAC 비율이 1 미만입니다. 마케팅 효율성 개선이 필요합니다.\n"
        elif results['ltv_cac_ratio'] > 3:
            valuation_text += "- ✅ 우수한 LTV/CAC 비율을 보이고 있습니다.\n"
        
        if results['runway'] < 12:
            valuation_text += "- ⚠️ 런웨이가 12개월 미만입니다. 추가 자금조달을 고려하세요.\n"
        
        if gross_margin < 60:
            valuation_text += "- 📈 매출총이익률 개선 여지가 있습니다. (업계 평균: 70-80%)\n"
        
        # 비교 차트 생성
        comparison_chart = calculator.create_comparison_chart(
            results['valuation'], industry, results['arr']
        )
        
        # 상세 분석 테이블
        metrics_df = pd.DataFrame({
            "지표": ["월 매출", "연 성장률", "매출총이익률", "월 이탈률", "고객 유지율"],
            "현재 값": [f"${monthly_revenue}K", f"{growth_rate}%", f"{gross_margin}%", 
                      f"{monthly_churn}%", f"{retention_rate}%"],
            "업계 평균": ["N/A", "50-100%", "70-80%", "2-5%", "80-90%"]
        })
        
        return valuation_text, comparison_chart, metrics_df
    
    # Gradio UI
    with gr.Blocks(title="스타트업 가치평가 계산기", theme=gr.themes.Soft()) as demo:
        gr.Markdown("""
        # 🦄 스타트업 가치평가 자동화 시스템
        
        간단한 정보 입력만으로 귀사의 예상 기업가치를 산출하고 동종업계와 비교해드립니다.
        """)
        
        with gr.Tab("기본 정보"):
            with gr.Row():
                company_name = gr.Textbox(label="회사명", value="우리 스타트업")
                founded_year = gr.Slider(2015, 2024, value=2022, step=1, label="설립연도")
            
            with gr.Row():
                industry = gr.Dropdown(
                    choices=list(calculator.industry_multiples.keys()),
                    value="SaaS - B2B",
                    label="산업 분류"
                )
                stage = gr.Radio(
                    choices=["MVP/베타", "초기 매출", "성장 단계", "수익성 확보"],
                    value="초기 매출",
                    label="사업 단계"
                )
            
            revenue_type = gr.Radio(
                choices=["구독형 (SaaS)", "거래수수료형", "일회성 판매"],
                value="구독형 (SaaS)",
                label="수익 모델"
            )
        
        with gr.Tab("매출 및 성장"):
            gr.Markdown("### 💰 매출 정보 (단위: 천 달러)")
            with gr.Row():
                monthly_revenue = gr.Number(label="월 매출 ($K)", value=50)
                growth_rate = gr.Slider(0, 300, value=100, step=10, 
                                       label="연간 성장률 (%)")
            
            with gr.Row():
                arpu = gr.Number(label="고객당 평균 매출 (ARPU) ($)", value=100)
                gross_margin = gr.Slider(0, 100, value=70, step=5,
                                        label="매출총이익률 (%)")
        
        with gr.Tab("고객 및 마케팅"):
            gr.Markdown("### 👥 고객 지표")
            with gr.Row():
                retention_rate = gr.Slider(0, 100, value=85, step=5,
                                          label="월간 고객 유지율 (%)")
                monthly_churn = gr.Slider(0, 20, value=3, step=0.5,
                                         label="월 이탈률 (%)")
            
            gr.Markdown("### 📢 마케팅 효율성")
            with gr.Row():
                new_customers = gr.Number(label="월 신규 고객 수", value=50)
                monthly_marketing = gr.Number(label="월 마케팅 비용 ($K)", value=20)
                monthly_sales = gr.Number(label="월 영업 비용 ($K)", value=15)
        
        with gr.Tab("재무 현황"):
            gr.Markdown("### 💸 현금 상황 (단위: 천 달러)")
            with gr.Row():
                cash_balance = gr.Number(label="현금 잔고 ($K)", value=1000)
                burn_rate = gr.Number(label="월 번레이트 ($K)", value=80)
        
        # 평가 실행 버튼
        evaluate_btn = gr.Button("🔍 가치평가 실행", variant="primary", size="lg")
        
        # 결과 출력
        with gr.Row():
            with gr.Column(scale=2):
                valuation_output = gr.Markdown(label="평가 결과")
            with gr.Column(scale=1):
                metrics_table = gr.DataFrame(label="주요 지표 비교")
        
        comparison_chart = gr.Plot(label="동종업계 비교")
        
        # 이벤트 연결
        evaluate_btn.click(
            process_valuation,
            inputs=[
                company_name, founded_year, industry, stage, revenue_type,
                monthly_revenue, growth_rate, arpu, gross_margin, monthly_churn,
                retention_rate, new_customers, monthly_marketing, monthly_sales,
                cash_balance, burn_rate
            ],
            outputs=[valuation_output, comparison_chart, metrics_table]
        )
        
        # 예시 데이터 버튼들
        gr.Markdown("### 📝 예시 데이터로 테스트하기")
        with gr.Row():
            gr.Button("SaaS 스타트업 예시").click(
                lambda: [
                    "테크 스타트업", 2021, "SaaS - B2B", "성장 단계", "구독형 (SaaS)",
                    100, 150, 200, 75, 2,
                    90, 40, 30, 20,
                    2000, 120
                ],
                outputs=[
                    company_name, founded_year, industry, stage, revenue_type,
                    monthly_revenue, growth_rate, arpu, gross_margin, monthly_churn,
                    retention_rate, new_customers, monthly_marketing, monthly_sales,
                    cash_balance, burn_rate
                ]
            )
            
            gr.Button("이커머스 예시").click(
                lambda: [
                    "온라인 쇼핑몰", 2022, "이커머스", "초기 매출", "일회성 판매",
                    80, 80, 50, 40, 5,
                    70, 100, 25, 10,
                    500, 70
                ],
                outputs=[
                    company_name, founded_year, industry, stage, revenue_type,
                    monthly_revenue, growth_rate, arpu, gross_margin, monthly_churn,
                    retention_rate, new_customers, monthly_marketing, monthly_sales,
                    cash_balance, burn_rate
                ]
            )
    
    return demo

# 실행
if __name__ == "__main__":
    demo = create_ui()
    demo.launch(share=True)