app.py

import gradio as gr
import pandas as pd
import numpy as np
from datetime import datetime
import plotly.graph_objects as go
import re
from urllib.parse import urlparse

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
        }
        
        # IP 자산 가치 가중치
        self.ip_asset_weights = {
            "patents": 0.25,
            "papers": 0.15,
            "domains": 0.15,
            "trademarks": 0.10,
            "github": 0.10,
            "awards": 0.10,
            "team": 0.15
        }
    
    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 evaluate_domain(self, domains):
        """도메인 가치 평가"""
        if not domains:
            return 0
        
        domain_list = [d.strip() for d in domains.split(',') if d.strip()]
        score = 0
        
        for domain in domain_list:
            parsed = urlparse(domain if domain.startswith('http') else f'http://{domain}')
            domain_name = parsed.netloc or parsed.path
            
            # .com 도메인 가산점
            if domain_name.endswith('.com'):
                score += 30
            elif domain_name.endswith(('.io', '.ai', '.tech')):
                score += 20
            else:
                score += 10
            
            # 짧은 도메인 가산점
            name_length = len(domain_name.split('.')[0])
            if name_length <= 5:
                score += 20
            elif name_length <= 8:
                score += 10
        
        return min(100, score / len(domain_list))
    
    def evaluate_patents(self, patent_filed, patent_granted):
        """특허 가치 평가"""
        score = 0
        score += patent_filed * 15  # 출원 특허당 15점
        score += patent_granted * 30  # 등록 특허당 30점
        return min(100, score)
    
    def evaluate_papers(self, papers):
        """논문 가치 평가"""
        if not papers:
            return 0
        
        paper_count = len([p.strip() for p in papers.split('\n') if p.strip()])
        score = paper_count * 20  # 논문당 20점
        
        # 주요 학회/저널 키워드 체크
        prestigious_keywords = ['Nature', 'Science', 'IEEE', 'ACM', 'CVPR', 'NeurIPS', 'ICML']
        for keyword in prestigious_keywords:
            if keyword.lower() in papers.lower():
                score += 10
        
        return min(100, score)
    
    def evaluate_github(self, github_url, github_stars):
        """GitHub 저장소 평가"""
        if not github_url:
            return 0
        
        score = 0
        if github_stars >= 1000:
            score = 80
        elif github_stars >= 500:
            score = 60
        elif github_stars >= 100:
            score = 40
        elif github_stars >= 50:
            score = 20
        else:
            score = 10
        
        return score
    
    def evaluate_team(self, team_size, phd_count, serial_entrepreneurs, big_tech_experience):
        """팀 역량 평가"""
        score = 0
        
        # 팀 규모
        if team_size >= 20:
            score += 20
        elif team_size >= 10:
            score += 15
        elif team_size >= 5:
            score += 10
        
        # 박사 학위
        score += min(30, phd_count * 10)
        
        # 연쇄창업가
        score += min(30, serial_entrepreneurs * 15)
        
        # 빅테크 경험
        score += min(20, big_tech_experience * 5)
        
        return min(100, score)
    
    def calculate_ip_score(self, ip_data):
        """지적재산 종합 점수 계산"""
        scores = {
            "patents": self.evaluate_patents(ip_data["patent_filed"], ip_data["patent_granted"]),
            "papers": self.evaluate_papers(ip_data["papers"]),
            "domains": self.evaluate_domain(ip_data["domains"]),
            "trademarks": min(100, ip_data["trademarks"] * 20),
            "github": self.evaluate_github(ip_data["github_url"], ip_data["github_stars"]),
            "awards": min(100, ip_data["awards"] * 25),
            "team": self.evaluate_team(
                ip_data["team_size"], ip_data["phd_count"],
                ip_data["serial_entrepreneurs"], ip_data["big_tech_experience"]
            )
        }
        
        total_score = sum(scores[key] * self.ip_asset_weights[key] for key in scores)
        return total_score, scores
    
    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, ip_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
        )
        
        # IP 자산 점수
        ip_score, ip_breakdown = self.calculate_ip_score(ip_data)
        
        # 종합 점수 (단위경제 60%, IP 40%)
        combined_score = ue_score * 0.6 + ip_score * 0.4
        
        # 기본 멀티플 선택
        multiples = self.industry_multiples[data["industry"]]
        if combined_score >= 80:
            base_multiple = multiples["high"]
        elif combined_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
        }
        
        # IP 자산 프리미엄 (최대 20%)
        ip_premium = 1 + (ip_score / 100 * 0.2)
        
        final_multiple = adjusted_multiple * stage_adj[data["stage"]] * ip_premium
        
        # 최종 가치평가
        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,
            "ip_score": ip_score,
            "ip_breakdown": ip_breakdown,
            "combined_score": combined_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_ip_breakdown_chart(self, ip_breakdown):
        """IP 자산 분석 차트"""
        categories = list(ip_breakdown.keys())
        values = list(ip_breakdown.values())
        
        fig = go.Figure(data=[
            go.Radar(
                r=values,
                theta=categories,
                fill='toself',
                name='IP 자산 점수'
            )
        ])
        
        fig.update_layout(
            polar=dict(
                radialaxis=dict(
                    visible=True,
                    range=[0, 100]
                )
            ),
            showlegend=False,
            title="지적재산 자산 분석"
        )
        
        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,
        # IP 관련 입력
        domains, patent_filed, patent_granted, papers, trademarks,
        github_url, github_stars, awards, partnerships,
        team_size, phd_count, serial_entrepreneurs, big_tech_experience,
        media_coverage, app_downloads, social_followers
    ):
        # 입력값 검증
        if monthly_revenue <= 0:
            return "월 매출을 입력해주세요.", None, 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
        }
        
        ip_data = {
            "domains": domains,
            "patent_filed": patent_filed,
            "patent_granted": patent_granted,
            "papers": papers,
            "trademarks": trademarks,
            "github_url": github_url,
            "github_stars": github_stars,
            "awards": awards,
            "partnerships": partnerships,
            "team_size": team_size,
            "phd_count": phd_count,
            "serial_entrepreneurs": serial_entrepreneurs,
            "big_tech_experience": big_tech_experience,
            "media_coverage": media_coverage,
            "app_downloads": app_downloads,
            "social_followers": social_followers
        }
        
        # 가치평가 계산
        results = calculator.calculate_valuation(data, ip_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

## 🎯 지적재산 및 무형자산
- **IP 자산 점수**: {results['ip_score']:.0f}/100
- **종합 점수**: {results['combined_score']:.0f}/100

### IP 자산 세부 평가:
- 특허: {results['ip_breakdown']['patents']:.0f}/100
- 논문: {results['ip_breakdown']['papers']:.0f}/100
- 도메인: {results['ip_breakdown']['domains']:.0f}/100
- 상표권: {results['ip_breakdown']['trademarks']:.0f}/100
- 오픈소스: {results['ip_breakdown']['github']:.0f}/100
- 수상실적: {results['ip_breakdown']['awards']:.0f}/100
- 팀 역량: {results['ip_breakdown']['team']:.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"
        
        if results['ip_score'] > 70:
            valuation_text += "- 🏆 강력한 IP 포트폴리오를 보유하고 있어 가치평가에 프리미엄이 적용되었습니다.\n"
        
        # 비교 차트 생성
        comparison_chart = calculator.create_comparison_chart(
            results['valuation'], industry, results['arr']
        )
        
        # IP 분석 차트
        ip_chart = calculator.create_ip_breakdown_chart(results['ip_breakdown'])
        
        # 상세 분석 테이블
        metrics_df = pd.DataFrame({
            "지표": ["월 매출", "연 성장률", "매출총이익률", "월 이탈률", "고객 유지율", "IP 자산 점수"],
            "현재 값": [f"${monthly_revenue}K", f"{growth_rate}%", f"{gross_margin}%", 
                      f"{monthly_churn}%", f"{retention_rate}%", f"{results['ip_score']:.0f}/100"],
            "업계 평균": ["N/A", "50-100%", "70-80%", "2-5%", "80-90%", "50/100"]
        })
        
        return valuation_text, comparison_chart, ip_chart, metrics_df
    
    # Gradio UI
    with gr.Blocks(title="스타트업 가치평가 계산기", theme=gr.themes.Soft()) as demo:
        gr.Markdown("""
        # 🦄 스타트업 가치평가 자동화 시스템 v2.0
        
        간단한 정보 입력만으로 귀사의 예상 기업가치를 산출하고 동종업계와 비교해드립니다.
        이제 지적재산과 무형자산까지 종합적으로 평가합니다.
        """)
        
        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():
                patent_filed = gr.Number(label="출원 특허 수", value=2)
                patent_granted = gr.Number(label="등록 특허 수", value=1)
                trademarks = gr.Number(label="상표권 수", value=1)
            
            papers = gr.Textbox(
                label="발표 논문 (한 줄에 하나씩, URL 포함 가능)",
                lines=3,
                placeholder="예: https://arxiv.org/abs/2301.12345 - AI Model Optimization\nICML 2023 - Novel Approach to Machine Learning"
            )
            
            gr.Markdown("### 🌐 디지털 자산")
            domains = gr.Textbox(
                label="보유 도메인 (쉼표로 구분)",
                placeholder="예: mycompany.com, mycompany.ai, myproduct.io"
            )
            
            with gr.Row():
                github_url = gr.Textbox(
                    label="GitHub 저장소 URL",
                    placeholder="https://github.com/yourcompany/yourrepo"
                )
                github_stars = gr.Number(label="GitHub 스타 수", value=100)
            
            gr.Markdown("### 🏆 인증 및 수상")
            with gr.Row():
                awards = gr.Number(label="주요 수상 실적 수", value=1)
                partnerships = gr.Number(label="전략적 파트너십 수", value=2)
        
        with gr.Tab("팀 및 브랜드"):
            gr.Markdown("### 👥 팀 구성")
            with gr.Row():
                team_size = gr.Number(label="전체 팀 규모", value=10)
                phd_count = gr.Number(label="박사 학위 보유자 수", value=1)
            
            with gr.Row():
                serial_entrepreneurs = gr.Number(label="연쇄창업가 수", value=1)
                big_tech_experience = gr.Number(label="빅테크 출신 인원", value=2)
            
            gr.Markdown("### 📱 브랜드 및 사용자 기반")
            with gr.Row():
                media_coverage = gr.Number(label="주요 언론 보도 수", value=5)
                app_downloads = gr.Number(label="앱 다운로드 수 (만)", value=10)
                social_followers = gr.Number(label="소셜미디어 팔로워 (천)", value=50)
        
        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="주요 지표 비교")
        
        with gr.Row():
            comparison_chart = gr.Plot(label="동종업계 비교")
            ip_chart = gr.Plot(label="IP 자산 분석")
        
        # 이벤트 연결
        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,
                domains, patent_filed, patent_granted, papers, trademarks,
                github_url, github_stars, awards, partnerships,
                team_size, phd_count, serial_entrepreneurs, big_tech_experience,
                media_coverage, app_downloads, social_followers
            ],
            outputs=[valuation_output, comparison_chart, ip_chart, metrics_table]
        )
        
        # 예시 데이터 버튼들
        gr.Markdown("### 📝 예시 데이터로 테스트하기")
        with gr.Row():
            gr.Button("AI 스타트업 예시").click(
                lambda: [
                    "AI Tech Corp", 2021, "AI/딥테크", "성장 단계", "구독형 (SaaS)",
                    100, 150, 200, 75, 2,
                    90, 40, 30, 20,
                    2000, 120,
                    "aitech.com, aitech.ai", 5, 2, 
                    "NeurIPS 2023 - Novel AI Architecture\nhttps://arxiv.org/abs/2023.12345", 3,
                    "https://github.com/aitech/core", 500, 3, 5,
                    15, 3, 2, 4,
                    10, 50, 100
                ],
                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,
                    domains, patent_filed, patent_granted, papers, trademarks,
                    github_url, github_stars, awards, partnerships,
                    team_size, phd_count, serial_entrepreneurs, big_tech_experience,
                    media_coverage, app_downloads, social_followers
                ]
            )
            
            gr.Button("바이오테크 예시").click(
                lambda: [
                    "BioHealth Inc", 2020, "헬스케어", "초기 매출", "구독형 (SaaS)",
                    80, 200, 500, 85, 1,
                    95, 20, 40, 30,
                    3000, 150,
                    "biohealth.com, biohealth.health", 8, 4,
                    "Nature Medicine 2023 - Breakthrough in Drug Discovery\nScience 2023 - Novel Biomarker", 5,
                    "https://github.com/biohealth/research", 200, 5, 3,
                    25, 8, 1, 3,
                    15, 5, 30
                ],
                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,
                    domains, patent_filed, patent_granted, papers, trademarks,
                    github_url, github_stars, awards, partnerships,
                    team_size, phd_count, serial_entrepreneurs, big_tech_experience,
                    media_coverage, app_downloads, social_followers
                ]
            )
    
    return demo

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