login_enabled_only 3menu

app.py

@@ -1,968 +1,152 @@
 # -*- coding: utf-8 -*-
 """
-주식 디버거 (모바일 웹앱) - 5개 분석 통합
+주식 디버거 (모바일 웹앱) — 3개 분석 / Hugging Face Spaces 배포용
 
-  1) VCP 돌파 감지      (past_vcp_debug.py)   * 진단 날짜 선택 입력 가능
-  2) VCP 실패 부분매도  (vcp_sell_debug.py)
-  3) 볼린저 카운트      (bollinger_count_debug.py)  * 최근 1년 자동
-  4) 240선 추세사망 컷  (MA240_cut_debug.py)
-  5) 전량매도 (RS·이격) (sell_+10_debug.py)
+탭(분석):
+  1) VCP 돌파 감지   (vcp_debug.py)          ← 날짜 자동: 최근 1년
+  2) 볼린저 카운트   (bollinger_count_debug.py) ← 날짜 자동: 최근 1년
+  3) 전량매도 최후보루 (final_sell_monitor.py)   ← 최종 확정 버전
 
-각 분석은 데스크탑 스크립트의 로직/출력을 그대로 보존(print 출력을 캡처).
+원칙: 데스크탑 스크립트의 로직/출력을 그대로 재현.
+  - 함수형(analyze_one) 스크립트: import 후 함수 호출
+  - 최상위 실행형(VCP·볼린저): 소스를 읽어 TICKER만 바꿔 exec (sys.exit 가드)
+  모든 출력은 contextlib.redirect_stdout 로 그대로 캡처해 화면에 표시.
+
+HF Spaces(한국 외 IP)에서도 네이버 주가/지수 데이터는 정상 로드됨.
+KRX(StockListing)만 막히므로 시장(KOSPI/KOSDAQ)은 직접 선택.
 """
 
 import io
-import sys
-import ssl
+import os
+import re
 import contextlib
-import warnings
 from datetime import datetime, timedelta
 
-import pandas as pd
-import numpy as np
-import FinanceDataReader as fdr
 import gradio as gr
 
-ssl._create_default_https_context = ssl._create_unverified_context
-warnings.filterwarnings('ignore')
-
-
-# ============================================================
-# 1) 볼린저 카운트  (날짜만 최근 1년 자동, 나머지 동일)
-# ============================================================
-def run_bollinger(ticker):
-    buf = io.StringIO()
-    try:
-        with contextlib.redirect_stdout(buf):
-            TICKER       = ticker
-            BB_WINDOW    = 20
-            BB_STD       = 2
-            MA_240       = 240
-            MA_60        = 60
-            BB_THRESHOLD = 1.030
-
-            today      = datetime.today()
-            DEBUG_TO   = today.strftime('%Y-%m-%d')
-            DEBUG_FROM = (today - timedelta(days=365)).strftime('%Y-%m-%d')
-            DATA_START = (today - timedelta(days=1100)).strftime('%Y-%m-%d')
-
-            print(f"({TICKER}) 데이터 로드 중...")
-            df = fdr.DataReader(TICKER, DATA_START, DEBUG_TO)
-            print(f"데이터: {len(df)}일치\n")
-
-            df['ma20']     = df['Close'].rolling(BB_WINDOW).mean()
-            df['std20']    = df['Close'].rolling(BB_WINDOW).std()
-            df['bb_upper'] = df['ma20'] + BB_STD * df['std20']
-            df['bb_lower'] = df['ma20'] - BB_STD * df['std20']
-            df['ma60']     = df['Close'].rolling(MA_60).mean()
-            df['ma240']    = df['Close'].rolling(MA_240).mean()
-
-            count        = 0
-            peak_close   = 0
-            was_below_60 = False
-            counts       = []
-            peak_list    = []
-            flags        = []
-
-            for i in range(len(df)):
-                c    = df['Close'].iloc[i]
-                o    = df['Open'].iloc[i]
-                u    = df['bb_upper'].iloc[i]
-                m60  = df['ma60'].iloc[i]
-                m240 = df['ma240'].iloc[i]
-
-                if pd.isna(m240) or pd.isna(u) or pd.isna(m60):
-                    counts.append(count)
-                    peak_list.append(peak_close)
-                    flags.append('데이터부족')
-                    continue
-
-                if c < m240:
-                    count        = 0
-                    peak_close   = 0
-                    was_below_60 = False
-                    flag = '240선이탈→리셋'
-
-                elif c < m60:
-                    was_below_60 = True
-                    flag = f'60선이탈→유지(count={count})'
-
-                else:
-                    open_above_240 = (o > m240)
-                    clearly_above  = (c > u * BB_THRESHOLD)
-
-                    if not open_above_240:
-                        flag = f'시초가({o:,.0f})<240선({m240:,.0f})→무효'
-                    elif clearly_above:
-                        if was_below_60:
-                            if o > peak_close:
-                                count       += 1
-                                peak_close   = c
-                                was_below_60 = False
-                                flag = f'+{count} (60선복귀,시초가>{peak_close:,.0f})'
-                            else:
-                                flag = f'BB돌파but시초가({o:,.0f})≤피크({peak_close:,.0f})→스킵'
-                        else:
-                            count      += 1
-                            peak_close  = max(peak_close, c)
-                            flag = f'+{count}'
-                    else:
-                        pct = (c / u - 1) * 100
-                        flag = f'종가미달(BB대비{pct:+.1f}%)'
-
-                counts.append(count)
-                peak_list.append(peak_close)
-                flags.append(flag)
-
-            df['bb_count']   = counts
-            df['peak_close'] = peak_list
-            df['flag']       = flags
-
-            mask     = (df.index >= DEBUG_FROM) & (df.index <= DEBUG_TO)
-            debug_df = df[mask].copy()
-
-            print("=" * 115)
-            print(f"날짜별 카운팅 ({DEBUG_FROM} ~ {DEBUG_TO})")
-            print("=" * 115)
-            print(f"{'날짜':<12} {'종가':>7} {'시가':>7} {'BB상단':>8} {'BB×1.03':>9} "
-                  f"{'60MA':>7} {'240MA':>7} {'피크':>8} {'카운트':>6}  판정")
-            print("-" * 115)
-
-            prev_count = 0
-            for date, row in debug_df.iterrows():
-                cnt  = int(row['bb_count'])
-                flag = row['flag']
-                is_notable = (cnt != prev_count or
-                              '리셋' in flag or '이탈' in flag or
-                              '복귀' in flag or '스킵' in flag or
-                              '무효' in flag)
-                if is_notable:
-                    mark = ' ◀' if cnt > prev_count else ''
-                    print(f"{str(date)[:10]:<12} "
-                          f"{row['Close']:>7,.0f} "
-                          f"{row['Open']:>7,.0f} "
-                          f"{row['bb_upper']:>8,.0f} "
-                          f"{row['bb_upper']*BB_THRESHOLD:>9,.0f} "
-                          f"{row['ma60']:>7,.0f} "
-                          f"{row['ma240']:>7,.0f} "
-                          f"{row['peak_close']:>8,.0f} "
-                          f"{cnt:>6}  {flag}{mark}")
-                prev_count = cnt
-
-            print("\n" + "=" * 60)
-            print("카운트 증가한 날들 요약")
-            print("=" * 60)
-            prev = 0
-            for date, row in debug_df.iterrows():
-                cnt = int(row['bb_count'])
-                if cnt > prev:
-                    print(f"  {str(date)[:10]}: {row['flag']}"
-                          f"  (종가:{row['Close']:,.0f}, 시가:{row['Open']:,.0f}, "
-                          f"BB×1.03:{row['bb_upper']*BB_THRESHOLD:,.0f}, "
-                          f"240MA:{row['ma240']:,.0f})")
-                prev = cnt
-
-            print(f"\n최대 카운트: {debug_df['bb_count'].max()}")
-    except SystemExit:
-        pass
-    except Exception as e:
-        buf.write(f"\n[오류] {type(e).__name__}: {e}\n"
-                  f"티커 번호(6자리)를 확인해주세요. 예: 005930")
-    return buf.getvalue()
-
-
-# ============================================================
-# 2) 240선 추세사망 컷  (MA240_cut_debug.py 로직 그대로)
-# ============================================================
-def run_ma240(ticker):
-    buf = io.StringIO()
-
-    BREAK_PCT      = 0.05
-    CONFIRM_DAYS   = 3
-    USE_SLOPE      = False
-    SLOPE_LOOKBACK = 20
-    ARM_PCT        = 0.25
-    DATA_BACK      = 800
-    SHOW_FROM      = None
-
-    def compute_240ma_cut(df, break_pct=BREAK_PCT, confirm_days=CONFIRM_DAYS,
-                          use_slope=USE_SLOPE, slope_lookback=SLOPE_LOOKBACK,
-                          arm_pct=ARM_PCT):
-        df = df.copy()
-        df['ma240'] = df['Close'].rolling(240).mean()
-        closes = df['Close'].values.astype(float)
-        ma240  = df['ma240'].values.astype(float)
-        dates  = df.index
-
-        rows = []
-        consec    = 0
-        is_sold   = False
-        armed     = False
-        sell_info = None
+# 함수형 스크립트는 import 해서 호출 (최상위에서 분석이 실행되지 않음)
+import final_sell_monitor
 
-        for i in range(len(df)):
-            c = closes[i]
-            m = ma240[i]
+HERE = os.path.dirname(os.path.abspath(__file__))
+BOLL_PATH = os.path.join(HERE, "bollinger_count_debug.py")
+VCP_PATH  = os.path.join(HERE, "vcp_debug.py")
 
-            rec = {
-                'date': dates[i], 'close': c, 'ma240': m,
-                'cut_line': np.nan, 'gap_pct': np.nan, 'ma_dir': '-',
-                'consec': 0, 'below_cut': False, 'armed': armed,
-                'category': 'nodata', 'verdict': '데이터부족',
-                'sold_today': False, 'is_sold': is_sold,
-            }
+_TICKER_RE = re.compile(r"TICKER\s*=\s*['\"][0-9A-Za-z]+['\"]")
 
-            if np.isnan(m):
-                rows.append(rec)
-                continue
-
-            cut_line = m * (1 - break_pct)
-            gap_pct  = (c / m - 1) * 100
-
-            j = i - slope_lookback
-            if j >= 0 and not np.isnan(ma240[j]):
-                ma_dir = 'down' if m < ma240[j] else 'up'
-            else:
-                ma_dir = 'na'
-
-            just_armed = False
-            if not armed and gap_pct >= arm_pct * 100:
-                armed = True
-                just_armed = True
-
-            below_cut = c < cut_line
-            rec.update({'cut_line': cut_line, 'gap_pct': gap_pct,
-                        'ma_dir': ma_dir, 'below_cut': below_cut, 'armed': armed})
-
-            if is_sold:
-                consec = 0
-                rec['category'] = 'sold'
-                if sell_info and sell_info['price'] > 0:
-                    chg = (c / sell_info['price'] - 1) * 100
-                    rec['verdict'] = f"(이미 전량매도) 매도가 대비 {chg:+.1f}%"
-                else:
-                    rec['verdict'] = "(이미 전량매도)"
-                rec['consec']  = 0
-                rec['is_sold'] = True
-                rows.append(rec)
-                continue
-
-            if not below_cut:
-                consec = 0
-                if c >= m:
-                    rec['category'] = 'safe_above'
-                    rec['verdict']  = "240선 위 - 보유"
-                    if just_armed:
-                        rec['verdict'] += f"  ★컷 무장(240선 +{arm_pct*100:.0f}% 돌파)"
-                else:
-                    rec['category'] = 'buffer'
-                    rec['verdict']  = (f"240선 아래지만 {gap_pct:+.1f}% "
-                                       f"(컷라인 위, 살짝만 깸) - 보유")
-            else:
-                consec += 1
-                if not armed:
-                    rec['category'] = 'below_unarmed'
-                    rec['verdict'] = (f"컷라인 {gap_pct:+.1f}% 아래지만 240선 "
-                                      f"+{arm_pct*100:.0f}% 돌파 이력 없음(동산 구간) "
-                                      f"-> 컷 대상 아님 - 보유")
-                else:
-                    slope_ok = (not use_slope) or (ma_dir == 'down')
-                    rec['category'] = 'below_cut'
-                    if consec < confirm_days:
-                        rec['verdict'] = (f"컷라인 {gap_pct:+.1f}% 아래 - "
-                                          f"{consec}/{confirm_days}일째 (확정 전) - 보유")
-                    elif not slope_ok:
-                        rec['verdict'] = (f"컷라인 아래 {consec}일째 BUT 240MA 아직 상승중 "
-                                          f"-> 기울기조건 미충족 - 보유")
-                    else:
-                        tail = ", 240MA 하락 전환" if use_slope else ""
-                        rec['verdict']  = (f">>> 전량 매도! "
-                                           f"(무장+240선 {break_pct*100:.0f}% 아래로 "
-                                           f"{confirm_days}일 확정{tail})")
-                        rec['category']   = 'sell'
-                        rec['sold_today'] = True
-                        is_sold = True
-                        sell_info = {'date': dates[i], 'price': c, 'ma240': m,
-                                     'gap_pct': gap_pct, 'index_i': i}
-
-            rec['consec']  = consec
-            rec['is_sold'] = is_sold
-            rows.append(rec)
-
-        return rows, sell_info
-
-    def analyze(ticker):
-        print("=" * 96)
-        print(f"240일선 추세사망 컷 디버그 : {ticker}")
-        print(f"규칙 : 종가 < 240MA×{1-BREAK_PCT:.2f} ({BREAK_PCT*100:.0f}% 아래) "
-              f"가 {CONFIRM_DAYS}일 연속 -> 전량 매도"
-              + (f" | 240MA 하락전환 필수(USE_SLOPE)" if USE_SLOPE else " | 240MA방향은 정보로만"))
-        print("=" * 96)
-
-        name, market = ticker, '-'
-        try:
-            kospi  = fdr.StockListing('KOSPI')
-            kosdaq = fdr.StockListing('KOSDAQ')
-            if ticker in kospi['Code'].values:
-                market = 'KOSPI'; name = kospi[kospi['Code'] == ticker]['Name'].values[0]
-            elif ticker in kosdaq['Code'].values:
-                market = 'KOSDAQ'; name = kosdaq[kosdaq['Code'] == ticker]['Name'].values[0]
-        except Exception:
-            pass
-
-        data_start = (datetime.today() - timedelta(days=DATA_BACK)).strftime('%Y-%m-%d')
-        analyze_to = datetime.today().strftime('%Y-%m-%d')
-        df = fdr.DataReader(ticker, data_start, analyze_to)
-        if df is None or len(df) == 0:
-            print("데이터 없음"); return
-        print(f"종목 : {name} ({ticker}) / {market} | 데이터 {len(df)}일\n")
-
-        rows, sell_info = compute_240ma_cut(df)
-
-        if np.isnan(rows[-1]['ma240']):
-            print("!! 240일치 데이터가 부족해서 240MA를 못 구함 -> 분석 불가 "
-                  "(상장 1년 미만 종목)")
-            return
-
-        valid_rows = [r for r in rows if r['category'] != 'nodata']
-        if not valid_rows:
-            print("240MA 유효 구간 없음"); return
-
-        if SHOW_FROM:
-            win = [r for r in valid_rows if str(r['date'])[:10] >= SHOW_FROM]
-            if not win:
-                print(f"!! SHOW_FROM({SHOW_FROM}) 이후 데이터 없음. 240MA 유효 범위: "
-                      f"{str(valid_rows[0]['date'])[:10]} ~ {str(valid_rows[-1]['date'])[:10]}")
-                return
-        else:
-            win = valid_rows
-
-        print(f"240MA 유효 시작: {str(valid_rows[0]['date'])[:10]} | "
-              f"표 표시: {str(win[0]['date'])[:10]} ~ {str(win[-1]['date'])[:10]}")
-
-        print("-" * 96)
-        print(f"{'날짜':<11}{'종가':>9}{'240MA':>9}{'컷라인':>9}"
-              f"{'vs240':>8}{'방향':>5}{'연속':>5}  판정")
-        print("-" * 96)
-
-        dir_map = {'up': 'UP', 'down': 'DN', 'na': '-', '-': '-'}
-        prev_cat = None
-        for k, r in enumerate(win):
-            cat       = r['category']
-            is_last   = (k == len(win) - 1)
-            notable   = (cat != prev_cat) or (cat in ('below_cut', 'sell')) or is_last
-            prev_cat  = cat
-            if not notable:
-                continue
-            consec_s = str(r['consec']) if r['category'] == 'below_cut' else ''
-            mark     = '  <<<<<' if r['sold_today'] else ''
-            print(f"{str(r['date'])[:10]:<11}"
-                  f"{r['close']:>9,.0f}"
-                  f"{r['ma240']:>9,.0f}"
-                  f"{r['cut_line']:>9,.0f}"
-                  f"{r['gap_pct']:>+7.1f}%"
-                  f"{dir_map.get(r['ma_dir'],'-'):>5}"
-                  f"{consec_s:>5}  {r['verdict']}{mark}")
-
-        print("\n" + "=" * 96)
-        print("요약")
-        print("=" * 96)
-        print(f"종목     : {name} ({ticker}) / {market}")
-        print(f"컷 규칙  : 무장(240선 +{ARM_PCT*100:.0f}% 이력) + 240MA×{1-BREAK_PCT:.2f} "
-              f"아래 {CONFIRM_DAYS}일 연속" + (" + 240MA 하락전환" if USE_SLOPE else ""))
-
-        valid_gaps = [r['gap_pct'] for r in valid_rows if not np.isnan(r['gap_pct'])]
-        max_gap    = max(valid_gaps) if valid_gaps else float('nan')
-        ever_armed = any(r['armed'] for r in valid_rows)
-        print(f"무장 상태: {'무장됨' if ever_armed else '무장 안 됨(동산 구간 -> 240선 컷 대상 아님)'}"
-              f" | 240선 대비 최고 {max_gap:+.1f}%")
-
-        if sell_info is not None:
-            si = sell_info
-            in_win = "" if si['date'] >= win[0]['date'] else "  (표 시작 이전 구간)"
-            print(f"매도 신호: >>> {str(si['date'])[:10]}{in_win} | "
-                  f"매도가 {si['price']:,.0f} | 그때 240MA {si['ma240']:,.0f} "
-                  f"({si['gap_pct']:+.1f}%)")
-
-            after = [r for r in rows[si['index_i'] + 1:] if not np.isnan(r['close'])]
-            if after:
-                ac     = np.array([r['close'] for r in after])
-                mn_i   = int(np.argmin(ac)); mx_i = int(np.argmax(ac))
-                mn, mx, lp = ac[mn_i], ac[mx_i], ac[-1]
-                mn_chg = (mn / si['price'] - 1) * 100
-                mx_chg = (mx / si['price'] - 1) * 100
-                lp_chg = (lp / si['price'] - 1) * 100
-                print(f"\n[매도 후 검증]  매도가 {si['price']:,.0f} 기준")
-                print(f"  이후 최고 : {mx:,.0f} ({str(after[mx_i]['date'])[:10]}) -> {mx_chg:+.1f}%")
-                print(f"  이후 최저 : {mn:,.0f} ({str(after[mn_i]['date'])[:10]}) -> {mn_chg:+.1f}%")
-                print(f"  현재가    : {lp:,.0f} -> {lp_chg:+.1f}%")
-                if mx_chg >= 10 and mx_i < mn_i:
-                    print(f"  => 매도 후 {mx_chg:+.0f}%까지 반등했다가 빠짐 "
-                          f"-> 휩쏘(저점 근처에서 너무 일찍 컷) 가능성 큼.")
-                elif mn_chg <= -5:
-                    print(f"  => 매도 후 더 빠짐 -> 컷이 손실을 막아준 케이스.")
-                elif lp_chg > 8:
-                    print(f"  => 매도 후 반등 유지 -> 휩쏘(너무 일찍 컷) 가능성.")
-                else:
-                    print(f"  => 매도 후 큰 변동 없음.")
-        else:
-            last = win[-1]
-            cat  = last['category']
-            print(f"매도 신호: 없음 (240선 컷 미발생, 계속 보유)")
-            if cat == 'safe_above':
-                tail = "240선 위, 보유"
-            elif cat == 'buffer':
-                tail = "240선 아래지만 컷라인 위(살짝 깸), 보유"
-            elif cat == 'below_cut':
-                tail = (f"컷라인 아래 {last['consec']}일째 "
-                        f"(확정 전, {CONFIRM_DAYS}일 되면 매도), 보유")
-            elif cat == 'below_unarmed':
-                tail = (f"컷라인 아래지만 동산 구간(무장 안 됨) -> 컷 대상 아님, 보유")
-            else:
-                tail = "보유"
-            print(f"현재 상태: 종가 {last['close']:,.0f} / 240MA {last['ma240']:,.0f} "
-                  f"({last['gap_pct']:+.1f}%) -> {tail}")
 
+def _safe(fn, *args):
+    """어떤 분석이든 예외가 나도 빨간 '오류' 대신 이유를 글로 반환."""
     try:
-        with contextlib.redirect_stdout(buf):
-            analyze(ticker)
-    except SystemExit:
-        pass
+        return fn(*args)
     except Exception as e:
-        buf.write(f"\n[오류] {type(e).__name__}: {e}\n"
-                  f"티커 번호(6자리)를 확인해주세요. 예: 005930")
-    return buf.getvalue()
+        msg = str(e).strip().splitlines()[0] if str(e).strip() else type(e).__name__
+        return (f"[오류] {msg[:200]}\n"
+                f"종목코드가 맞는지, 잠시 후 다시 시도해 보세요.\n"
+                f"(데이터 제공처(네이버) 일시 오류이거나, 신규/정지/폐지 종목일 수 있습니다.)")
 
 
-
-# ============================================================
-# 3) 전량매도 (최후보루)  (final_sell_monitor.py 로직 이식 · 단일 티커)
-#    주 신호 : 자기고점 이격 -10% -> 22일내 lower-low 재확인 (240올 구간)
-#    백업    : 종가가 240선 BREAK_CONFIRM일 연속 이탈
-# ============================================================
-def run_sell(ticker, market_override="자동"):
+def _exec_script(path, ticker, extra_subs=None):
+    """최상위 실행형 스크립트: TICKER(및 추가 치환)만 바꿔 exec, 출력 캡처."""
     buf = io.StringIO()
-
-    DIV_THRESHOLD   = -0.10   # 이격 기준
-    CONFIRM_WINDOW  = 22      # lower-low 재확인 윈도우(거래일)
-    TREND_MIN_DAYS  = 60      # '240올': 최근 N거래일 연속 240선 위
-    TREND_MIN_GAP   = 0.05    # '240올': 240선 +5% 이상
-    BREAK_PCT       = 0.00    # 백업 240선 이탈 기준
-    BREAK_CONFIRM   = 2       # 백업: 연속 N일 이탈
-    DATA_BACK_DAYS  = 900     # 240MA 워밍업 포함 로드(≈2.5년)
-
-    def in_240_run(stock, ma240, i):
-        if i - TREND_MIN_DAYS + 1 < 0:
-            return False
-        m = ma240[i]
-        if np.isnan(m) or stock[i] <= m * (1 + TREND_MIN_GAP):
-            return False
-        for k in range(i - TREND_MIN_DAYS + 1, i + 1):
-            if np.isnan(ma240[k]) or stock[k] <= ma240[k]:
-                return False
-        return True
-
-    def load(tk, market):
-        end   = datetime.today().strftime('%Y-%m-%d')
-        start = (datetime.today() - timedelta(days=DATA_BACK_DAYS)).strftime('%Y-%m-%d')
-        sdf = fdr.DataReader(tk, start, end)
-        if sdf is None or len(sdf) == 0:
-            return None
-        idx_code = 'KS11' if market == 'KOSPI' else 'KQ11'
-        idf = None
-        for c in (idx_code, '^' + idx_code):
-            try:
-                t = fdr.DataReader(c, start, end)
-                if t is not None and len(t) > 0:
-                    idf = t; break
-            except Exception:
-                continue
-        if idf is None:
-            return None
-        merged = pd.concat([sdf['Close'].rename('stock'), idf['Close'].rename('index')],
-                           axis=1, sort=True)
-        merged['index'] = merged['index'].ffill()
-        merged = merged.dropna()
-        merged['ma240'] = merged['stock'].rolling(240).mean()
-        return merged
-
-    try:
-        with contextlib.redirect_stdout(buf):
-            TICKER = ticker
-            name = TICKER
-
-            print("=" * 72)
-            print(f"전량매도 최후보루 모니터 | {datetime.today().strftime('%Y-%m-%d %H:%M')}")
-            print(f"주 신호: 240올 + 이격 {DIV_THRESHOLD*100:.0f}% lower-low 재확인({CONFIRM_WINDOW}일)"
-                  f" | 백업: 240선 {BREAK_CONFIRM}일 연속 이탈")
-            print("=" * 72)
-
-            # --- 시장 결정 (수동 우선, 자동은 KRX 가능할 때만) ---
-            print("\n[시장 판별]")
-            mo = (market_override or "자동").strip()
-            market = None
-            if mo in ('KOSPI', 'KOSDAQ'):
-                market = mo
-                print(f"    (수동 지정) {market}")
-            else:
-                try:
-                    for mk in ('KOSPI', 'KOSDAQ'):
-                        lst = fdr.StockListing(mk)
-                        code_col = next((c for c in lst.columns
-                                         if str(c).lower() in ('code', 'symbol', '종목코드')), None)
-                        name_col = next((c for c in lst.columns
-                                         if str(c).lower() in ('name', '종목명', 'korname')), None)
-                        codes = (lst[code_col] if code_col is not None else lst.index).astype(str)
-                        hit = (codes == TICKER)
-                        if bool(hit.any()):
-                            market = mk
-                            if name_col is not None:
-                                name = str(lst.loc[hit, name_col].values[0])
-                            break
-                    if market is None:
-                        market = 'KOSDAQ'
-                        print(f"    목록에서 못 찾음 -> KOSDAQ 가정 (위 '시장' 메뉴에서 직접 선택)")
-                    else:
-                        print(f"    {name} ({TICKER}) / {market}")
-                except Exception as e:
-                    market = 'KOSDAQ'
-                    print(f"    자동판별 실패({type(e).__name__}) -> KOSDAQ 가정. "
-                          f"위 '시장' 메뉴에서 KOSPI/KOSDAQ 직접 선택 권장.")
-
-            # --- 데이터 로드 ---
-            df = load(TICKER, market)
-            if df is None:
-                print(f"\n[{TICKER} {name}] 데이터 로드 실패 (티커/시장 확인)"); sys.exit()
-
-            dates = [str(d)[:10] for d in df.index]
-            stock = df['stock'].values.astype(float)
-            index = df['index'].values.astype(float)
-            ma240 = df['ma240'].values.astype(float)
-            n = len(stock)
-
-            # --- 워크포워드: 자기고점 + 이격 이벤트 + lower-low 재확인 (가장 최근 것 추적) ---
-            running_peak = -1.0; index_at_peak = None; peak_date = None
-            div_flag = False; div_flag_value = None; div_sold = False
-            last_event = None
-            confirmed = None
-
-            for t in range(n):
-                st = stock[t]; it = index[t]
-                if running_peak < 0 or st >= running_peak:
-                    running_peak = st; index_at_peak = it; peak_date = dates[t]
-                    div_flag = False; div_flag_value = None; div_sold = False
-                    last_event = None
-                    confirmed = None
-                else:
-                    sr = st / running_peak - 1
-                    ir = (it / index_at_peak - 1) if index_at_peak else 0.0
-                    div = sr - ir
-                    if div <= DIV_THRESHOLD:
-                        if not div_flag:
-                            div_flag = True; div_flag_value = div; div_sold = False
-                        elif div < div_flag_value:
-                            if not div_sold:
-                                if (last_event is not None
-                                        and t - last_event['i'] <= CONFIRM_WINDOW
-                                        and st < last_event['price']):
-                                    confirmed = {'i': t, 'date': dates[t], 'price': st,
-                                                 'prev_date': last_event['date'],
-                                                 'run': in_240_run(stock, ma240, t)}
-                                last_event = {'i': t, 'price': st, 'date': dates[t]}
-                                div_sold = True
-                            div_flag_value = div
-                        else:
-                            div_flag_value = div
-                    else:
-                        div_flag = False; div_flag_value = None; div_sold = False
-
-            # --- 백업: 240선 이탈 (연속 BREAK_CONFIRM일) ---
-            break_240 = None
-            streak = 0
-            for t in range(n):
-                if np.isnan(ma240[t]):
-                    continue
-                if stock[t] < ma240[t] * (1 - BREAK_PCT):
-                    streak += 1
-                    if streak >= BREAK_CONFIRM and break_240 is None:
-                        break_240 = dates[t]
-                else:
-                    streak = 0
-                    break_240 = None
-
-            # --- 오늘 상태 ---
-            t = n - 1
-            today = dates[t]
-            m = ma240[t]
-            run_now = in_240_run(stock, ma240, t)
-            sr_now = stock[t] / running_peak - 1 if running_peak > 0 else 0.0
-            ir_now = (index[t] / index_at_peak - 1) if index_at_peak else 0.0
-            div_now = sr_now - ir_now
-
-            print("\n" + "=" * 72)
-            print(f"[{TICKER} {name}] {market} | {today} 종가 {stock[t]:,.0f}"
-                  + (f" | 240선 {m:,.0f} ({(stock[t]/m-1)*100:+.1f}%)" if not np.isnan(m) else " | 240선 데이터부족"))
-            print(f"  240올 여부 : {'예 (60일 연속 240위 + 5%↑)' if run_now else '아니오'}")
-            print(f"  종목 고점  : {running_peak:,.0f} ({peak_date}) | 현재 이격 {div_now*100:+.1f}%"
-                  f" (기준 {DIV_THRESHOLD*100:.0f}%) | flag {'ON' if div_flag else 'off'}")
-            if last_event and not confirmed:
-                remain = CONFIRM_WINDOW - (t - last_event['i'])
-                if remain > 0:
-                    print(f"  1차 이벤트 : {last_event['date']} @ {last_event['price']:,.0f}"
-                          f" -> 재확인 대기 {remain}거래일 남음 (이보다 낮은 2차 이벤트면 전량매도)")
-
-            # --- 판정 ---
-            if confirmed:
-                tag = '240올' if confirmed['run'] else '비240올(참고)'
-                ago = (n - 1) - confirmed['i']
-                print(f"\n  >>> [주 신호] 전량매도: {confirmed['date']} @ {confirmed['price']:,.0f}"
-                      f"  (1차 {confirmed['prev_date']} -> lower-low 재확인, {tag}) | {ago}거래일 전")
-                if not confirmed['run']:
-                    print("      (240올 구간이 아니어서 신뢰도는 한 단계 낮음 — 차트로 확인)")
-            if break_240:
-                print(f"\n  >>> [백업] 240선 이탈 매도: {break_240} (연속 {BREAK_CONFIRM}일 이탈, 현재도 이탈 중)")
-            if not confirmed and not break_240:
-                print(f"\n  ==> 매도 신호 없음. 보유 유지.")
-    except SystemExit:
-        pass
-    except Exception as e:
-        buf.write(f"\n[오류] {type(e).__name__}: {e}\n"
-                  f"티커 번호(6자리)를 확인해주세요. 예: 005930")
-    return buf.getvalue()
-
-
-# ============================================================
-# 4) VCP 실패 부분매도  (vcp_sell_debug.py 로직 그대로)
-# ============================================================
-def run_vcp_sell(ticker):
+    ns = {"__name__": "__sandbox__"}   # __main__ 가드 비활성
+    with contextlib.redirect_stdout(buf):
+        try:
+            with open(path, encoding="utf-8") as f:
+                src = f.read()
+            src = _TICKER_RE.sub(f"TICKER = '{ticker}'", src, count=1)
+            if extra_subs:
+                for pat, repl in extra_subs:
+                    src = re.sub(pat, repl, src, count=1)
+            exec(compile(src, path, "exec"), ns)
+        except SystemExit:
+            pass                       # 스크립트의 sys.exit() 가 앱을 죽이지 않게
+        except Exception as e:
+            msg = str(e).strip().splitlines()[0] if str(e).strip() else type(e).__name__
+            print(f"\n[오류] {msg[:200]}")
+    return buf.getvalue() or "출력 없음"
+
+
+def _call_func(fn, *args):
+    """함수형 스크립트: 함수 호출하며 출력 캡처."""
     buf = io.StringIO()
-
-    VCP_BUFFER  = 0.05
-    VCP_BUY_KRW = None
-    STOP_REF    = 'breakout_low'
-
-    CONTRACT_DAYS    = 2
-    VOL_DRYUP_SURGE  = 2.0
-    MIN_PRICE_GAIN   = 0.10
-    BASE_LOOKBACK    = 10
-
-    ANALYZE_DAYS = 365
-    WARMUP_DAYS  = 40
-    DATA_START   = (datetime.today() - timedelta(days=ANALYZE_DAYS + WARMUP_DAYS)).strftime('%Y-%m-%d')
-    ANALYZE_FROM = (datetime.today() - timedelta(days=ANALYZE_DAYS)).strftime('%Y-%m-%d')
-
-    def find_vcp_breakouts(df):
-        O = df['Open'].values.astype(float);  H = df['High'].values.astype(float)
-        L = df['Low'].values.astype(float);   C = df['Close'].values.astype(float)
-        V = df['Volume'].values.astype(float)
-        out = []
-        for t in range(BASE_LOOKBACK, len(df)):
-            quiet_max = V[t - CONTRACT_DAYS:t].max()
-            if quiet_max <= 0 or C[t - 1] <= 0:
-                continue
-            surge     = V[t] / quiet_max
-            base_high = H[t - BASE_LOOKBACK:t].max()
-            gain      = C[t] / C[t - 1] - 1
-            if (surge >= VOL_DRYUP_SURGE and C[t] > base_high
-                    and gain >= MIN_PRICE_GAIN and C[t] > O[t]):
-                out.append({
-                    'i': t, 'date': str(df.index[t])[:10],
-                    'close': C[t], 'open': O[t], 'low': L[t],
-                    'gain': round(gain * 100, 1), 'surge': round(surge, 2),
-                    'base_high': base_high, 'base_low': float(L[t - BASE_LOOKBACK:t].min()),
-                })
-        return [b for b in out if b['date'] >= ANALYZE_FROM]
-
-    def track_vcp_stop(closes, dates, breakout_i, ref_low, entry_price, buffer=VCP_BUFFER):
-        stop = ref_low * (1 - buffer)
-        daily, failed, fail = [], False, None
-        for k in range(breakout_i + 1, len(closes)):
-            ck = float(closes[k])
-            if ck < stop:
-                failed = True
-                fail = {'date': dates[k], 'price': ck, 'k': k,
-                        'loss_pct': (ck / entry_price - 1) * 100}
-                daily.append((dates[k], ck, 'fail')); break
-            elif ck < stop * 1.05:
-                daily.append((dates[k], ck, 'warn'))
-            else:
-                daily.append((dates[k], ck, 'hold'))
-        return stop, failed, fail, daily
-
-    def analyze(ticker):
-        ref_name = "돌파일 저점" if STOP_REF == 'breakout_low' else "베이스 저점"
-        print("=" * 80)
-        print(f"VCP 실패 부분매도 디버그 : {ticker}")
-        print(f"규칙 : 돌파 매수 후 종가 < {ref_name}×{1-VCP_BUFFER:.2f} ({VCP_BUFFER*100:.0f}% 버퍼) "
-              f"-> VCP 실패 -> VCP로 산 만큼만 부분 매도")
-        print(f"       (VCP 실패 ≠ 종목 악화. 나머지 포지션은 그대로 유지)")
-        print("=" * 80)
-
-        name, market = ticker, '-'
+    with contextlib.redirect_stdout(buf):
         try:
-            kospi  = fdr.StockListing('KOSPI')
-            kosdaq = fdr.StockListing('KOSDAQ')
-            if ticker in kospi['Code'].values:
-                market = 'KOSPI'; name = kospi[kospi['Code'] == ticker]['Name'].values[0]
-            elif ticker in kosdaq['Code'].values:
-                market = 'KOSDAQ'; name = kosdaq[kosdaq['Code'] == ticker]['Name'].values[0]
-        except Exception:
+            fn(*args)
+        except SystemExit:
             pass
-
-        df = fdr.DataReader(ticker, DATA_START, datetime.today().strftime('%Y-%m-%d'))
-        if df is None or len(df) == 0:
-            print("데이터 없음"); return
-        print(f"종목 : {name} ({ticker}) / {market} | 데이터 {len(df)}일\n")
-
-        bos    = find_vcp_breakouts(df)
-        closes = df['Close'].values.astype(float)
-        dates  = [str(d)[:10] for d in df.index]
-        print(f"VCP 돌파(매수): {len(bos)}개\n")
-        if not bos:
-            print("VCP 돌파 없음 -> 추적 대상 없음"); return
-
-        results = []
-        for n, b in enumerate(bos, 1):
-            entry   = b['close']
-            ref_low = b['low'] if STOP_REF == 'breakout_low' else b['base_low']
-            stop, failed, fail, daily = track_vcp_stop(closes, dates, b['i'], ref_low, entry, VCP_BUFFER)
-
-            print("-" * 80)
-            print(f"VCP #{n}  돌파 {b['date']} @ {entry:,.0f}원 "
-                  f"(상승 +{b['gain']}%, 거래량 {b['surge']}배)")
-            print(f"  {ref_name}: {ref_low:,.0f} | 손절선 = {ref_low:,.0f}×{1-VCP_BUFFER:.2f} = {stop:,.0f}원 "
-                  f"(진입가 대비 {(stop/entry-1)*100:+.1f}%)")
-            print(f"  ---- 돌파 후 추적 ----")
-            prev = None
-            for j, (d, c, st) in enumerate(daily):
-                is_last = (j == len(daily) - 1)
-                if not ((st != prev) or st in ('warn', 'fail') or is_last):
-                    prev = st; continue
-                prev = st
-                if st == 'fail':
-                    msg = (f">>> VCP 실패! 종가 {c:,.0f} < 손절선 {stop:,.0f} "
-                           f"-> VCP분만 매도 (진입가 대비 {fail['loss_pct']:+.1f}%)  <<<<<")
-                elif st == 'warn':
-                    msg = f"경고 (종가 {c:,.0f}, 손절선 {stop:,.0f} 근접) - 보유"
-                else:
-                    msg = f"보유 (종가 {c:,.0f} > 손절선 {stop:,.0f})"
-                print(f"  {d:<11} {msg}")
-            if not failed:
-                cur = closes[-1]
-                print(f"  => VCP 유지 중 (현재 {cur:,.0f}, 진입가 대비 {(cur/entry-1)*100:+.1f}%)")
-            results.append({'n': n, 'entry': entry, 'failed': failed, 'fail': fail})
-            print()
-
-        fails = [r for r in results if r['failed']]
-        holds = [r for r in results if not r['failed']]
-        print("=" * 80)
-        print("요약")
-        print("=" * 80)
-        print(f"종목     : {name} ({ticker}) / {market}")
-        print(f"VCP 돌파 : {len(bos)}개 | 실패(부분매도): {len(fails)}개 | 유지: {len(holds)}개")
-        if fails:
-            avg = np.mean([r['fail']['loss_pct'] for r in fails])
-            print(f"실패분 손실: 평균 {avg:+.1f}% (VCP 트랜치 기준, 나머지 포지션은 유지)")
-            for r in fails:
-                line = f"  VCP #{r['n']}: 진입 {r['entry']:,.0f} -> {r['fail']['date']} 매도 ({r['fail']['loss_pct']:+.1f}%)"
-                if VCP_BUY_KRW:
-                    loss = VCP_BUY_KRW * r['fail']['loss_pct'] / 100
-                    line += f" | 매도금액 ~{VCP_BUY_KRW+loss:,.0f}원 (손익 {loss:+,.0f}원)"
-                print(line)
-
-    try:
-        with contextlib.redirect_stdout(buf):
-            analyze(ticker)
-    except SystemExit:
-        pass
-    except Exception as e:
-        buf.write(f"\n[오류] {type(e).__name__}: {e}\n"
-                  f"티커 번호(6자리)를 확인해주세요. 예: 005930")
-    return buf.getvalue()
+        except Exception as e:
+            msg = str(e).strip().splitlines()[0] if str(e).strip() else type(e).__name__
+            print(f"\n[오류] {msg[:200]}")
+            print("종목코드와 시장(KOSDAQ/KOSPI)이 맞는지 확인하세요.")
+    return buf.getvalue() or "출력 없음"
 
 
-# ============================================================
-# 5) VCP 돌파 감지  (past_vcp_debug.py 로직 그대로 + 진단 날짜 선택)
-# ============================================================
-def run_vcp_detect(ticker, diagnose_date=None):
-    buf = io.StringIO()
-
-    CONTRACT_DAYS    = 2
-    VOL_DRYUP_SURGE  = 6.0
-    MIN_PRICE_GAIN   = 0.13
-    BASE_LOOKBACK    = 10
-
-    DIAGNOSE_DATE    = diagnose_date  # 비우면 진단 생략
-
-    ANALYZE_DAYS = 365
-    WARMUP_DAYS  = 40
-    DATA_START   = (datetime.today() - timedelta(days=ANALYZE_DAYS + WARMUP_DAYS)).strftime('%Y-%m-%d')
-    ANALYZE_FROM = (datetime.today() - timedelta(days=ANALYZE_DAYS)).strftime('%Y-%m-%d')
-    ANALYZE_TO   = datetime.today().strftime('%Y-%m-%d')
-
-    def find_vcp_breakouts(df):
-        O = df['Open'].values.astype(float);  H = df['High'].values.astype(float)
-        L = df['Low'].values.astype(float);   C = df['Close'].values.astype(float)
-        V = df['Volume'].values.astype(float)
-        out = []
-        for t in range(BASE_LOOKBACK, len(df)):
-            quiet_max = V[t - CONTRACT_DAYS:t].max()
-            if quiet_max <= 0 or C[t - 1] <= 0:
-                continue
-            surge     = V[t] / quiet_max
-            base_high = H[t - BASE_LOOKBACK:t].max()
-            gain      = C[t] / C[t - 1] - 1
-            if (surge >= VOL_DRYUP_SURGE and C[t] > base_high
-                    and gain >= MIN_PRICE_GAIN and C[t] > O[t]):
-                out.append({
-                    'i': t, 'date': str(df.index[t])[:10],
-                    'close': C[t], 'open': O[t], 'low': L[t],
-                    'gain': round(gain * 100, 1), 'surge': round(surge, 2),
-                    'base_high': base_high, 'base_low': float(L[t - BASE_LOOKBACK:t].min()),
-                })
-        return [b for b in out if b['date'] >= ANALYZE_FROM]
-
-    def run_diagnose(df, date_str):
-        O = df['Open'].values.astype(float);  H = df['High'].values.astype(float)
-        C = df['Close'].values.astype(float); V = df['Volume'].values.astype(float)
-        idx = [str(d)[:10] for d in df.index]
-        pos = next((k for k, d in enumerate(idx) if d >= date_str), len(df) - 1)
-        lo  = max(BASE_LOOKBACK, pos - 12); hi = min(len(df), pos + 4)
-        bh_label = f"{BASE_LOOKBACK}일고가"
-
-        print("\n" + "=" * 92)
-        print(f"[진단] {date_str} 주변 일별  (배수 = 그날 거래량 / 직전 {CONTRACT_DAYS}일 '최대' 거래량)")
-        print("=" * 92)
-        print(f"{'날짜':<11}{'종가':>8}{'시가':>8}{'거래량':>12}{'직전최대':>12}{'배수':>7}"
-              f"{'대비%':>7}{'양봉':>5}{bh_label:>9}{'고가돌파':>7}")
-        print("-" * 92)
-        for k in range(lo, hi):
-            qa  = V[k - CONTRACT_DAYS:k].max()
-            sg  = (V[k] / qa) if qa > 0 else 0
-            bh  = H[k - BASE_LOOKBACK:k].max()
-            gn  = (C[k] / C[k - 1] - 1) * 100 if C[k - 1] > 0 else 0
-            bull = 'O' if C[k] > O[k] else ''
-            pbk  = 'O' if C[k] > bh else ''
-            mark = '  <==' if idx[k] == date_str else ''
-            print(f"{idx[k]:<11}{C[k]:>8,.0f}{O[k]:>8,.0f}{V[k]:>12,.0f}{qa:>12,.0f}{sg:>6.1f}x"
-                  f"{gn:>+6.1f}%{bull:>5}{bh:>9,.0f}{pbk:>7}{mark}")
-
-        print("\n  [판정]")
-        target = idx[pos]
-        if target != date_str:
-            print(f"  (참고: {date_str}은 거래일 아님 -> 가장 가까운 {target} 기준)")
-        qa = V[pos - CONTRACT_DAYS:pos].max()
-        sg = (V[pos] / qa) if qa > 0 else 0
-        bh = H[pos - BASE_LOOKBACK:pos].max()
-        gn = (C[pos] / C[pos - 1] - 1) * 100 if C[pos - 1] > 0 else 0
-        c1 = sg >= VOL_DRYUP_SURGE; c2 = C[pos] > bh
-        c3 = gn >= MIN_PRICE_GAIN * 100; c4 = C[pos] > O[pos]
-        print(f"    거래량 배수 {sg:.1f}x >= {VOL_DRYUP_SURGE}?        {'O' if c1 else 'X'}")
-        print(f"    종가 {C[pos]:,.0f} > {BASE_LOOKBACK}일고가 {bh:,.0f}?   {'O' if c2 else 'X'}")
-        print(f"    상승률 {gn:+.1f}% >= {MIN_PRICE_GAIN*100:.0f}%?         {'O' if c3 else 'X'}")
-        print(f"    양봉 (종가 {C[pos]:,.0f} > 시가 {O[pos]:,.0f})?    {'O' if c4 else 'X'}")
-        if c1 and c2 and c3 and c4:
-            print(f"  => 4조건 통과 -> 잡혀야 함.")
-        else:
-            fails = [n for n, ok in [(f'거래량 배수 부족({sg:.1f}x)', c1), ('가격이 고가 못 넘음', c2),
-                                     (f'상승률 부족({gn:+.1f}%)', c3), ('음봉', c4)] if not ok]
-            print(f"  => 안 잡힘. 이유: {', '.join(fails)}")
-            if not c1:
-                print(f"     (VOL_DRYUP_SURGE를 {sg:.1f} 밑으로 낮추면 잡혀)")
-
-    try:
-        with contextlib.redirect_stdout(buf):
-            TICKER = ticker
-            print("=" * 70)
-            print(f"VCP 돌파 감지: {TICKER} | 기간: {ANALYZE_FROM} ~ {ANALYZE_TO}")
-            print(f"조건: 직전{CONTRACT_DAYS}일 대비 거래량 {VOL_DRYUP_SURGE}배+ & {BASE_LOOKBACK}일고가 돌파 "
-                  f"& 상승 +{MIN_PRICE_GAIN*100:.0f}%+ & 양봉")
-            print("=" * 70)
-
-            df = fdr.DataReader(TICKER, DATA_START, ANALYZE_TO)
-            if df is None or len(df) == 0:
-                print("데이터 없음"); sys.exit()
-            print(f"데이터: {len(df)}일 로드 완료\n")
-
-            bos = find_vcp_breakouts(df)
-            print(f"감지된 VCP 돌파: {len(bos)}개\n")
-
-            for n, b in enumerate(bos, 1):
-                print("=" * 70)
-                print(f"VCP #{n}  돌파 {b['date']} @ {b['close']:,.0f}원")
-                print(f"  상승률 +{b['gain']}% | 거래량 {b['surge']}배(직전{CONTRACT_DAYS}일의 최대 기준) | "
-                      f"{BASE_LOOKBACK}일고가({b['base_high']:,.0f}) 돌파 | 양봉")
-                print()
-
-            print("=" * 70)
-            print(f"요약: 총 {len(bos)}개 돌파")
-            for b in bos:
-                print(f"  {b['date']} | {b['close']:,.0f}원 | +{b['gain']}% | 거래량 {b['surge']}배")
-
-            if DIAGNOSE_DATE:
-                run_diagnose(df, DIAGNOSE_DATE)
-    except SystemExit:
-        pass
-    except Exception as e:
-        buf.write(f"\n[오류] {type(e).__name__}: {e}\n"
-                  f"티커 번호(6자리)를 확인해주세요. 예: 005930")
-    return buf.getvalue()
-
-
-# ============================================================
-# Gradio UI
-# ============================================================
-VCP_DETECT = "VCP 돌파 감지"
-VCP_SELL   = "VCP 실패 부분매도"
-BOLL       = "볼린저 카운트"
-MA240      = "240선 추세사망 컷"
-SELL       = "전���매도 (최후보루)"
-
-CHOICES = [VCP_DETECT, VCP_SELL, BOLL, MA240, SELL]
+# ---------- 분석별 실행 ----------
+def run_bollinger(ticker):
+    ticker = (ticker or "").strip()
+    if not ticker:
+        return "종목코드를 입력하세요 (예: 420770)"
+    today = datetime.today()
+    frm = (today - timedelta(days=365)).strftime("%Y-%m-%d")
+    to  = today.strftime("%Y-%m-%d")
+    subs = [
+        (r"DEBUG_FROM\s*=\s*['\"][0-9-]+['\"]", f"DEBUG_FROM = '{frm}'"),
+        (r"DEBUG_TO\s*=\s*['\"][0-9-]+['\"]",   f"DEBUG_TO = '{to}'"),
+    ]
+    return _exec_script(BOLL_PATH, ticker, subs)
+
+
+def run_vcp(ticker):
+    ticker = (ticker or "").strip()
+    if not ticker:
+        return "종목코드를 입력하세요 (예: 007340)"
+    return _exec_script(VCP_PATH, ticker)
 
 
-def analyze(choice, ticker, diag_date, market_sel):
+def run_final(ticker, market, name):
     ticker = (ticker or "").strip()
     if not ticker:
-        return "티커 번호(6자리)를 입력하세요.\n예: 005930(삼성전자), 009150(삼성전기)"
-    diag = (diag_date or "").strip() or None
+        return "종목코드를 입력하세요 (예: 195940)"
+    h = {"ticker": ticker, "market": market, "name": (name or "").strip() or None}
+    return _call_func(final_sell_monitor.analyze_one, h)
 
-    if choice == VCP_DETECT:
-        return run_vcp_detect(ticker, diag)
-    if choice == VCP_SELL:
-        return run_vcp_sell(ticker)
-    if choice == BOLL:
-        return run_bollinger(ticker)
-    if choice == MA240:
-        return run_ma240(ticker)
-    if choice == SELL:
-        return run_sell(ticker, market_sel)
-    return "분석 종류를 선택하세요."
 
+# ---------- UI ----------
+with gr.Blocks(title="주식 디버거") as demo:
+    gr.Markdown("## 주식 디버거 (모바일)\n분석을 고르고 종목코드만 넣으면 데스크탑과 동일한 출력이 나옵니다.")
 
-with gr.Blocks(title="주식 디버거", theme=gr.themes.Soft()) as demo:
-    gr.Markdown(
-        "## 📈 주식 디버거\n"
-        "분석 종류를 고르고 티커(6자리)를 입력한 뒤 **분석 실행**을 누르세요.\n"
-        "표가 넓으면 좌우로 스크롤하거나 가로화면으로 보세요."
-    )
-    with gr.Row():
-        choice = gr.Dropdown(choices=CHOICES, value=VCP_DETECT, label="분석 종류")
-        ticker = gr.Textbox(label="티커 (6자리)", placeholder="예: 005930")
-    diag_date = gr.Textbox(
-        label="VCP 진단 날짜 (선택 · 'VCP 돌파 감지'에서만 사용)",
-        placeholder="예: 2025-12-16  (비워두면 진단 생략)",
-    )
-    market_sel = gr.Dropdown(
-        choices=["자동", "KOSPI", "KOSDAQ"], value="자동",
-        label="시장 (전량매도용 · 자동 판별 실패 시 직접 선택)",
-    )
-    btn = gr.Button("분석 실행", variant="primary")
-    out = gr.Code(label="결과", lines=30)
+    with gr.Tab("볼린저 카운트"):
+        b_tk = gr.Textbox(label="종목코드", placeholder="예: 420770")
+        b_btn = gr.Button("실행", variant="primary")
+        b_out = gr.Textbox(label="결과 (최근 1년 자동)", lines=20)
+        b_btn.click(lambda tk: _safe(run_bollinger, tk), inputs=b_tk, outputs=b_out)
+
+    with gr.Tab("VCP 돌파"):
+        v_tk = gr.Textbox(label="종목코드", placeholder="예: 007340")
+        v_btn = gr.Button("실행", variant="primary")
+        v_out = gr.Textbox(label="결과 (최근 1년 자동)", lines=20)
+        v_btn.click(lambda tk: _safe(run_vcp, tk), inputs=v_tk, outputs=v_out)
 
-    btn.click(analyze, inputs=[choice, ticker, diag_date, market_sel], outputs=out)
-    ticker.submit(analyze, inputs=[choice, ticker, diag_date, market_sel], outputs=out)
+    with gr.Tab("전량매도 최후보루"):
+        with gr.Row():
+            f_tk = gr.Textbox(label="종목코드", placeholder="예: 195940", scale=2)
+            f_mkt = gr.Radio(["KOSDAQ", "KOSPI"], value="KOSDAQ", label="시장", scale=2)
+        f_nm = gr.Textbox(label="종목명(선택)", placeholder="예: HK이노엔")
+        f_btn = gr.Button("실행", variant="primary")
+        f_out = gr.Textbox(label="결과", lines=16)
+        f_btn.click(lambda a,b,c: _safe(run_final, a, b, c), inputs=[f_tk, f_mkt, f_nm], outputs=f_out)
 
 
 if __name__ == "__main__":
-    demo.launch()
+    # ---- 로그인 벽: 아이디/비밀번호를 아는 사람만 ----
+    # 아래 두 값을 본인이 원하는 걸로 바꿔서 쓰세요. (공유할 사람에게만 알려줌)
+    APP_USER = "johnflower"
+    APP_PASS = "johnflower"
+
+    # HF Spaces 표준 실행 (포트 7860 고정) + 로그인
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        auth=(APP_USER, APP_PASS),
+        auth_message="공유받은 아이디/비밀번호를 입력하세요.",
+    )

bollinger_count_debug.py

@@ -0,0 +1,145 @@
+"""
+실리콘투 볼린저밴드 카운팅 디버깅 v5
+
+확정 규칙:
+1. 시초가 > 240일선  ← 신규 추가
+2. 종가 > BB 상단 × 1.03
+3. 60일선 아래 다녀온 후: 시초가 > 이전 피크 종가 (추가 조건)
+4. 240일선 아래 → 완전 리셋
+5. 60일선 아래 → 카운트 유지
+"""
+
+import pandas as pd
+import numpy as np
+import FinanceDataReader as fdr
+import warnings
+warnings.filterwarnings('ignore')
+
+TICKER       = '000660'
+DEBUG_FROM   = '2025-05-02'
+DEBUG_TO     = '2026-06-19'
+BB_WINDOW    = 20
+BB_STD       = 2
+MA_240       = 240
+MA_60        = 60
+BB_THRESHOLD = 1.030
+
+print(f"({TICKER}) 데이터 로드 중...")
+df = fdr.DataReader(TICKER, '2022-01-01', DEBUG_TO)
+print(f"데이터: {len(df)}일치\n")
+
+df['ma20']     = df['Close'].rolling(BB_WINDOW).mean()
+df['std20']    = df['Close'].rolling(BB_WINDOW).std()
+df['bb_upper'] = df['ma20'] + BB_STD * df['std20']
+df['bb_lower'] = df['ma20'] - BB_STD * df['std20']
+df['ma60']     = df['Close'].rolling(MA_60).mean()
+df['ma240']    = df['Close'].rolling(MA_240).mean()
+
+count        = 0
+peak_close   = 0
+was_below_60 = False
+counts       = []
+peak_list    = []
+flags        = []
+
+for i in range(len(df)):
+    c    = df['Close'].iloc[i]
+    o    = df['Open'].iloc[i]
+    u    = df['bb_upper'].iloc[i]
+    m60  = df['ma60'].iloc[i]
+    m240 = df['ma240'].iloc[i]
+
+    if pd.isna(m240) or pd.isna(u) or pd.isna(m60):
+        counts.append(count)
+        peak_list.append(peak_close)
+        flags.append('데이터부족')
+        continue
+
+    if c < m240:
+        count        = 0
+        peak_close   = 0
+        was_below_60 = False
+        flag = '240선이탈→리셋'
+
+    elif c < m60:
+        was_below_60 = True
+        flag = f'60선이탈→유지(count={count})'
+
+    else:
+        # 핵심 조건들
+        open_above_240 = (o > m240)          # ← 신규: 시초가 > 240일선
+        clearly_above  = (c > u * BB_THRESHOLD)  # 종가 > BB상단 × 1.020
+
+        if not open_above_240:
+            flag = f'시초가({o:,.0f})<240선({m240:,.0f})→무효'
+        elif clearly_above:
+            if was_below_60:
+                if o > peak_close:
+                    count       += 1
+                    peak_close   = c
+                    was_below_60 = False
+                    flag = f'+{count} (60선복귀,시초가>{peak_close:,.0f})'
+                else:
+                    flag = f'BB돌파but시초가({o:,.0f})≤피크({peak_close:,.0f})→스킵'
+            else:
+                count      += 1
+                peak_close  = max(peak_close, c)
+                flag = f'+{count}'
+        else:
+            pct = (c / u - 1) * 100
+            flag = f'종가미달(BB대비{pct:+.1f}%)'
+
+    counts.append(count)
+    peak_list.append(peak_close)
+    flags.append(flag)
+
+df['bb_count']   = counts
+df['peak_close'] = peak_list
+df['flag']       = flags
+
+mask     = (df.index >= DEBUG_FROM) & (df.index <= DEBUG_TO)
+debug_df = df[mask].copy()
+
+print("=" * 115)
+print(f"날짜별 카운팅 ({DEBUG_FROM} ~ {DEBUG_TO})")
+print("=" * 115)
+print(f"{'날짜':<12} {'종가':>7} {'시가':>7} {'BB상단':>8} {'BB×1.03':>9} "
+      f"{'60MA':>7} {'240MA':>7} {'피크':>8} {'카운트':>6}  판정")
+print("-" * 115)
+
+prev_count = 0
+for date, row in debug_df.iterrows():
+    cnt  = int(row['bb_count'])
+    flag = row['flag']
+    is_notable = (cnt != prev_count or
+                  '리셋' in flag or '이탈' in flag or
+                  '복귀' in flag or '스킵' in flag or
+                  '무효' in flag)
+    if is_notable:
+        mark = ' ◀' if cnt > prev_count else ''
+        print(f"{str(date)[:10]:<12} "
+              f"{row['Close']:>7,.0f} "
+              f"{row['Open']:>7,.0f} "
+              f"{row['bb_upper']:>8,.0f} "
+              f"{row['bb_upper']*BB_THRESHOLD:>9,.0f} "
+              f"{row['ma60']:>7,.0f} "
+              f"{row['ma240']:>7,.0f} "
+              f"{row['peak_close']:>8,.0f} "
+              f"{cnt:>6}  {flag}{mark}")
+    prev_count = cnt
+
+print("\n" + "=" * 60)
+print("카운트 증가한 날들 요약")
+print("=" * 60)
+prev = 0
+for date, row in debug_df.iterrows():
+    cnt = int(row['bb_count'])
+    if cnt > prev:
+        print(f"  {str(date)[:10]}: {row['flag']}"
+              f"  (종가:{row['Close']:,.0f}, 시가:{row['Open']:,.0f}, "
+              f"BB×1.03:{row['bb_upper']*BB_THRESHOLD:,.0f}, "
+              f"240MA:{row['ma240']:,.0f})")
+    prev = cnt
+
+print(f"\n최대 카운트: {debug_df['bb_count'].max()}")
+

final_sell_monitor.py

@@ -0,0 +1,206 @@
+# -*- coding: utf-8 -*-
+"""
+전량매도 '최후 보루' 모니터 - 보유 종목 일괄 점검 (매일 돌리는 용) [최소 버전]
+
+[ 규칙 ]
+  주 신호 : 종목 자기고점 기준 이격 -10% '1차 이벤트' 후,
+            22거래일 내에 '2차 이벤트'(1차보다 낮은 종가)가 나오면 -> 전량매도.
+            * 1·2차는 '현재 고점' 이후로만 카운트(신고가 나면 리셋).
+            * 2차가 1차보다 안 낮거나 22일 밖이면 -> 이 고점에선 신호 없음.
+  백업    : 주 신호가 안 떴어도 종가가 240선을 연속 2일 이탈하면 -> 전량매도.
+
+[ 쓰는 법 ]
+  HOLDINGS 에 보유 종목(ticker/market/name)을 넣고 매일 실행.
+"""
+
+import sys, ssl
+import pandas as pd
+import numpy as np
+import FinanceDataReader as fdr
+from datetime import datetime, timedelta
+
+ssl._create_default_https_context = ssl._create_unverified_context
+if sys.platform == 'win32':
+    sys.stdout.reconfigure(encoding='utf-8')
+
+# =============================================
+# [보유 종목 — 여기만 바꾸면 됨]
+# =============================================
+HOLDINGS = [
+    {'ticker': '195940', 'market': 'KOSDAQ', 'name': 'HK이노엔'},
+    {'ticker': '005250', 'market': 'KOSPI',  'name': '녹십자홀딩스'},
+]
+
+# =============================================
+# 설정
+# =============================================
+DIV_THRESHOLD  = -0.10   # 이격 기준
+CONFIRM_WINDOW = 22      # 2차 재확인 윈도우 (거래일)
+BREAK_PCT      = 0.00    # 백업 240선 이탈 기준 (0.00=종가<240선)
+BREAK_CONFIRM  = 2       # 백업: 연속 N일 이탈
+DATA_BACK_DAYS = 900     # 240MA 워밍업 포함 로드
+
+
+def load(ticker, market):
+    end   = datetime.today().strftime('%Y-%m-%d')
+    start = (datetime.today() - timedelta(days=DATA_BACK_DAYS)).strftime('%Y-%m-%d')
+    try:
+        sdf = fdr.DataReader(ticker, start, end)
+    except Exception:
+        return None
+    if not isinstance(sdf, pd.DataFrame) or 'Close' not in sdf.columns or len(sdf) == 0:
+        return None
+    idx_code = 'KS11' if market == 'KOSPI' else 'KQ11'
+    idf = None
+    for c in (idx_code, '^' + idx_code):
+        try:
+            t = fdr.DataReader(c, start, end)
+            if isinstance(t, pd.DataFrame) and 'Close' in t.columns and len(t) > 0:
+                idf = t; break
+        except Exception:
+            continue
+    if idf is None:
+        return None
+    merged = pd.concat([sdf['Close'].rename('stock'), idf['Close'].rename('index')],
+                       axis=1, sort=True)
+    merged['index'] = merged['index'].ffill()
+    merged = merged.dropna()
+    if len(merged) == 0:
+        return None
+    merged['ma240'] = merged['stock'].rolling(240).mean()
+    return merged
+
+
+def resolve_name(ticker, market, given):
+    if given:
+        return given
+    try:
+        lst = fdr.StockListing(market)
+        for cc in ('Code', 'Symbol', 'code'):
+            if cc in lst.columns and ticker in lst[cc].values:
+                for nc in ('Name', 'name'):
+                    if nc in lst.columns:
+                        return str(lst[lst[cc] == ticker][nc].values[0])
+    except Exception:
+        pass
+    return ticker
+
+
+def current_peak_events(stock, index, dates):
+    """현재 고점(=신고가 이후) 구간의 이격 이벤트를 1차,2차... 순서로 반환.
+       이벤트 = flag ON(이격<=-10%) 후 '더 깊어진 첫 날'(에피소드당 1개)."""
+    n = len(stock)
+    running_peak = -1.0; index_at_peak = None; peak_date = None; peak_i = 0
+    div_flag = False; div_flag_value = None; div_sold = False
+    events = []
+    for t in range(n):
+        st = float(stock[t]); it = float(index[t])
+        if running_peak < 0 or st >= running_peak:
+            running_peak = st; index_at_peak = it; peak_date = dates[t]; peak_i = t
+            div_flag = False; div_flag_value = None; div_sold = False
+            events = []                         # 신고가 -> 리셋
+        else:
+            sr = st / running_peak - 1
+            ir = (it / index_at_peak - 1) if index_at_peak else 0.0
+            div = sr - ir
+            if div <= DIV_THRESHOLD:
+                if not div_flag:
+                    div_flag = True; div_flag_value = div; div_sold = False
+                elif div < div_flag_value:
+                    if not div_sold:
+                        events.append({'i': t, 'date': dates[t], 'price': st, 'div': div})
+                        div_sold = True
+                    div_flag_value = div
+                else:
+                    div_flag_value = div
+            else:
+                div_flag = False; div_flag_value = None; div_sold = False
+    return running_peak, peak_date, peak_i, index_at_peak, events
+
+
+def confirm(events):
+    """주 신호: 1차 뒤 '2차'가 1차로부터 22일 내 + 1차보다 낮으면 확정."""
+    if len(events) < 2:
+        return None
+    e1, e2 = events[0], events[1]
+    if (e2['i'] - e1['i'] <= CONFIRM_WINDOW) and (e2['price'] < e1['price']):
+        return {'date': e2['date'], 'price': e2['price'], 'i': e2['i'],
+                'first_date': e1['date'], 'first_price': e1['price']}
+    return None
+
+
+def backup_240(stock, ma240, dates):
+    """현재까지 연속 BREAK_CONFIRM일 240선 이탈 중이면 그 시작일 반환."""
+    n = len(stock); streak = 0; start = None
+    for t in range(n):
+        if np.isnan(ma240[t]):
+            continue
+        if stock[t] < ma240[t] * (1 - BREAK_PCT):
+            streak += 1
+            if streak >= BREAK_CONFIRM and start is None:
+                start = dates[t]
+        else:
+            streak = 0; start = None
+    return start
+
+
+def analyze_one(h):
+    tk = h['ticker']; market = h.get('market', 'KOSDAQ')
+    name = resolve_name(tk, market, h.get('name'))
+    df = load(tk, market)
+    if df is None:
+        print(f"\n[{tk} {name}] 데이터를 불러오지 못했습니다.")
+        print(f"  - 종목코드({tk})가 맞는지, 시장(KOSDAQ/KOSPI)이 맞는지 확인하세요.")
+        print(f"  - 신규상장/거래정지/상장폐지 종목은 데이터가 없을 수 있습니다.")
+        return
+
+    dates = [str(d)[:10] for d in df.index]
+    stock = df['stock'].values.astype(float)
+    index = df['index'].values.astype(float)
+    ma240 = df['ma240'].values.astype(float)
+    n = len(stock); t = n - 1
+
+    peak, peak_date, peak_i, iap, events = current_peak_events(stock, index, dates)
+    confirmed = confirm(events)
+    break_day = backup_240(stock, ma240, dates)
+
+    m = ma240[t]
+    div_now = (stock[t] / peak - 1) - ((index[t] / iap - 1) if iap else 0.0)
+
+    print("\n" + "=" * 64)
+    print(f"[{tk} {name}] {market} | {dates[t]} 종가 {stock[t]:,.0f}"
+          + (f" | 240선 {m:,.0f} ({(stock[t]/m-1)*100:+.1f}%)" if not np.isnan(m) else ""))
+    print(f"  고점 {peak:,.0f}({peak_date}) | 이격 {div_now*100:+.1f}% | 이벤트 {len(events)}개")
+    for e in events:
+        if confirmed and e['date'] == confirmed['date']:
+            mk = ' <<< 전량매도(2차<1차)'
+        elif e is events[0]:
+            mk = ' (1차)'
+        else:
+            mk = ' (참고)'
+        print(f"    {e['date']} @ {e['price']:,.0f} (이격 {e['div']*100:+.1f}%){mk}")
+
+    if confirmed:
+        ago = t - confirmed['i']
+        print(f"  >>> [주 신호] 전량매도: {confirmed['date']} @ {confirmed['price']:,.0f} "
+              f"(1차 {confirmed['first_date']} @ {confirmed['first_price']:,.0f} 대비 낮음) | {ago}일 전")
+    if break_day:
+        print(f"  >>> [백업] 240선 이탈: {break_day} (연속 {BREAK_CONFIRM}일, 현재도 이탈 중)")
+    if not confirmed and not break_day:
+        print(f"  ==> 매도 신호 없음. 보유 유지.")
+
+
+def main():
+    print("=" * 64)
+    print(f"전량매도 최후보루 모니터 | {datetime.today().strftime('%Y-%m-%d %H:%M')}")
+    print(f"주신호: 이격 {DIV_THRESHOLD*100:.0f}% 1차->2차(22일내,더낮음) | 백업: 240선 {BREAK_CONFIRM}일 이탈")
+    print("=" * 64)
+    for h in HOLDINGS:
+        try:
+            analyze_one(h)
+        except Exception as e:
+            print(f"\n[{h.get('ticker')}] 오류: {e}")
+
+
+if __name__ == '__main__':
+    main()

requirements.txt

@@ -1,5 +1,4 @@
-finance-datareader
+gradio
 pandas
 numpy
-lxml
-requests
+finance-datareader

vcp_debug.py

@@ -0,0 +1,163 @@
+# -*- coding: utf-8 -*-
+"""
+VCP 돌파 감지 - 네 정의 버전 ('조용한 N일 -> 거래량+가격 폭발')
+TICKER 하나만 바꾸면 됨!
+
+[ 돌파 조건 (모두 충족) ]
+1. 폭발일 거래량 >= 직전 CONTRACT_DAYS 일 거래량 중 최대 × VOL_DRYUP_SURGE
+   (= 조용했다가 거래량이 확 터짐. '거래량 20일선'이 아니라 '직전 조용한 날 대비'라서
+      평소 거래량이 적은 종목/구간에서도 잡히고, 폭발 후 평균이 튀는 문제도 없음.)
+2. 폭발일 종가 > 직전 BASE_LOOKBACK일 고가  (가격 돌파)
+3. 폭발일 상승률(전일 종가 대비) >= MIN_PRICE_GAIN
+4. 폭발일 양봉 (종가 > 시가)
+
+★ 이 파일의 '감지 설정' 블록은 vcp_sell_debug.py 와 똑같이 유지할 것!
+"""
+
+import sys, ssl
+import pandas as pd
+import numpy as np
+import FinanceDataReader as fdr
+from datetime import datetime, timedelta
+
+ssl._create_default_https_context = ssl._create_unverified_context
+if sys.platform == 'win32':
+    sys.stdout.reconfigure(encoding='utf-8')
+
+# =============================================
+# [여기만 바꾸면 됨]
+# =============================================
+TICKER = '007340'
+
+# =============================================
+# 감지 설정  (★ vcp_sell_debug.py 와 똑같이!)
+# =============================================
+CONTRACT_DAYS    = 2      # 폭발 직전 '조용한 날' 수
+# VOL_DRYUP_SURGE  = 6.0    # 폭발일 거래량 ÷ 직전 조용한 날 평균 (조용했다가 몇 배로 터졌나)
+VOL_DRYUP_SURGE  = 5.0    # 폭발일 거래량 ÷ 직전 조용한 날 평균 (조용했다가 몇 배로 터졌나)
+MIN_PRICE_GAIN   = 0.13   # 폭발일 상승률 (전일 종가 대비)
+BASE_LOOKBACK    = 10     # 폭발일 종가가 '직전 N일 고가'를 넘어야 (가격 돌파 기준)
+
+# DIAGNOSE_DATE    = '2025-12-16'   # 예: '2025-07-08' -> 그 날이 왜 잡혔나/안 잡혔나 직접 판정
+DIAGNOSE_DATE    = None
+
+# =============================================
+# 분석 기간 (더 과거까지 보려면 ANALYZE_DAYS만)
+# =============================================
+ANALYZE_DAYS = 365        # 며칠 전까지의 돌파를 볼지 (730=2년, 1095=3년)
+WARMUP_DAYS  = 40         # 고가 lookback 워밍업용 추가 로드 (보통 그대로)
+DATA_START   = (datetime.today() - timedelta(days=ANALYZE_DAYS + WARMUP_DAYS)).strftime('%Y-%m-%d')
+ANALYZE_FROM = (datetime.today() - timedelta(days=ANALYZE_DAYS)).strftime('%Y-%m-%d')
+ANALYZE_TO   = datetime.today().strftime('%Y-%m-%d')
+
+
+# =============================================
+# 돌파 감지 (★ vcp_sell_debug.py 와 동일 로직)
+# =============================================
+def find_vcp_breakouts(df):
+    O = df['Open'].values.astype(float);  H = df['High'].values.astype(float)
+    L = df['Low'].values.astype(float);   C = df['Close'].values.astype(float)
+    V = df['Volume'].values.astype(float)
+    out = []
+    for t in range(BASE_LOOKBACK, len(df)):
+        quiet_max = V[t - CONTRACT_DAYS:t].max()   # 직전 조용한 날들 중 '최대' 거래량
+        if quiet_max <= 0 or C[t - 1] <= 0:
+            continue
+        surge     = V[t] / quiet_max   # 직전 며칠 '각각'의 N배 (하나라도 크면 탈락 = 폭발 다음날 방지)
+        base_high = H[t - BASE_LOOKBACK:t].max()
+        gain      = C[t] / C[t - 1] - 1
+        if (surge >= VOL_DRYUP_SURGE and C[t] > base_high
+                and gain >= MIN_PRICE_GAIN and C[t] > O[t]):
+            out.append({
+                'i': t, 'date': str(df.index[t])[:10],
+                'close': C[t], 'open': O[t], 'low': L[t],
+                'gain': round(gain * 100, 1), 'surge': round(surge, 2),
+                'base_high': base_high, 'base_low': float(L[t - BASE_LOOKBACK:t].min()),
+            })
+    return [b for b in out if b['date'] >= ANALYZE_FROM]
+
+
+# =============================================
+# 진단: 특정 날짜가 왜 잡혔나/안 잡혔나
+# =============================================
+def run_diagnose(df, date_str):
+    O = df['Open'].values.astype(float);  H = df['High'].values.astype(float)
+    C = df['Close'].values.astype(float); V = df['Volume'].values.astype(float)
+    idx = [str(d)[:10] for d in df.index]
+    pos = next((k for k, d in enumerate(idx) if d >= date_str), len(df) - 1)
+    lo  = max(BASE_LOOKBACK, pos - 12); hi = min(len(df), pos + 4)
+    bh_label = f"{BASE_LOOKBACK}일고가"
+
+    print("\n" + "=" * 92)
+    print(f"[진단] {date_str} 주변 일별  (배수 = 그날 거래량 / 직전 {CONTRACT_DAYS}일 '최대' 거래량)")
+    print("=" * 92)
+    print(f"{'날짜':<11}{'종가':>8}{'시가':>8}{'거래량':>12}{'직전최대':>12}{'배수':>7}"
+          f"{'대비%':>7}{'양봉':>5}{bh_label:>9}{'고가돌파':>7}")
+    print("-" * 92)
+    for k in range(lo, hi):
+        qa  = V[k - CONTRACT_DAYS:k].max()
+        sg  = (V[k] / qa) if qa > 0 else 0
+        bh  = H[k - BASE_LOOKBACK:k].max()
+        gn  = (C[k] / C[k - 1] - 1) * 100 if C[k - 1] > 0 else 0
+        bull = 'O' if C[k] > O[k] else ''
+        pbk  = 'O' if C[k] > bh else ''
+        mark = '  <==' if idx[k] == date_str else ''
+        print(f"{idx[k]:<11}{C[k]:>8,.0f}{O[k]:>8,.0f}{V[k]:>12,.0f}{qa:>12,.0f}{sg:>6.1f}x"
+              f"{gn:>+6.1f}%{bull:>5}{bh:>9,.0f}{pbk:>7}{mark}")
+
+    # 판정
+    print("\n  [판정]")
+    target = idx[pos]
+    if target != date_str:
+        print(f"  (참고: {date_str}은 거래일 아님 -> 가장 가까운 {target} 기준)")
+    qa = V[pos - CONTRACT_DAYS:pos].max()
+    sg = (V[pos] / qa) if qa > 0 else 0
+    bh = H[pos - BASE_LOOKBACK:pos].max()
+    gn = (C[pos] / C[pos - 1] - 1) * 100 if C[pos - 1] > 0 else 0
+    c1 = sg >= VOL_DRYUP_SURGE; c2 = C[pos] > bh
+    c3 = gn >= MIN_PRICE_GAIN * 100; c4 = C[pos] > O[pos]
+    print(f"    거래량 배수 {sg:.1f}x >= {VOL_DRYUP_SURGE}?        {'O' if c1 else 'X'}")
+    print(f"    종가 {C[pos]:,.0f} > {BASE_LOOKBACK}일고가 {bh:,.0f}?   {'O' if c2 else 'X'}")
+    print(f"    상승률 {gn:+.1f}% >= {MIN_PRICE_GAIN*100:.0f}%?         {'O' if c3 else 'X'}")
+    print(f"    양봉 (종가 {C[pos]:,.0f} > 시가 {O[pos]:,.0f})?    {'O' if c4 else 'X'}")
+    if c1 and c2 and c3 and c4:
+        print(f"  => 4조건 통과 -> 잡혀야 함.")
+    else:
+        fails = [n for n, ok in [(f'거래량 배수 부족({sg:.1f}x)', c1), ('가격이 고가 못 넘음', c2),
+                                 (f'상승률 부족({gn:+.1f}%)', c3), ('음봉', c4)] if not ok]
+        print(f"  => 안 잡힘. 이유: {', '.join(fails)}")
+        if not c1:
+            print(f"     (VOL_DRYUP_SURGE를 {sg:.1f} 밑으로 낮추면 잡혀)")
+
+
+# =============================================
+# 데이터 로드 + 출력
+# =============================================
+print("=" * 70)
+print(f"VCP 돌파 감지: {TICKER} | 기간: {ANALYZE_FROM} ~ {ANALYZE_TO}")
+print(f"조건: 직전{CONTRACT_DAYS}일 대비 거래량 {VOL_DRYUP_SURGE}배+ & {BASE_LOOKBACK}일고가 돌파 "
+      f"& 상승 +{MIN_PRICE_GAIN*100:.0f}%+ & 양봉")
+print("=" * 70)
+
+df = fdr.DataReader(TICKER, DATA_START, ANALYZE_TO)
+if df is None or len(df) == 0:
+    print("데이터 없음"); sys.exit()
+print(f"데이터: {len(df)}일 로드 완료\n")
+
+bos = find_vcp_breakouts(df)
+print(f"감지된 VCP 돌파: {len(bos)}개\n")
+
+for n, b in enumerate(bos, 1):
+    print("=" * 70)
+    print(f"VCP #{n}  돌파 {b['date']} @ {b['close']:,.0f}원")
+    print(f"  상승률 +{b['gain']}% | 거래량 {b['surge']}배(직전{CONTRACT_DAYS}일의 최대 기준) | "
+          f"{BASE_LOOKBACK}일고가({b['base_high']:,.0f}) 돌파 | 양봉")
+    print()
+
+print("=" * 70)
+print(f"요약: 총 {len(bos)}개 돌파")
+for b in bos:
+    print(f"  {b['date']} | {b['close']:,.0f}원 | +{b['gain']}% | 거래량 {b['surge']}배")
+
+if DIAGNOSE_DATE:
+    run_diagnose(df, DIAGNOSE_DATE)