Delete app.py

app.py

@@ -1,1236 +0,0 @@
-# app.py
-# GOSHAWK ALBION MARKET AI v3.1
-# 24h model + 90d hibrit (model varsa model, yoksa trend projeksiyonu)
-
-import os
-import time
-import warnings
-import datetime as dt
-from typing import List, Dict, Tuple, Optional
-
-import numpy as np
-import pandas as pd
-import requests
-import plotly.graph_objects as go
-import plotly.express as px
-
-import lightgbm as lgb
-from sklearn.metrics import accuracy_score
-
-import gradio as gr
-
-try:
-    import joblib
-    _HAS_JOBLIB = True
-except ImportError:
-    _HAS_JOBLIB = False
-
-warnings.filterwarnings("ignore")
-
-# ---------------------------------------------------------------------------
-# SABİTLER
-# ---------------------------------------------------------------------------
-
-API_BASE = "https://europe.albion-online-data.com/api/v2"
-
-CITIES = [
-    "Bridgewatch", "Fort Sterling", "Lymhurst",
-    "Martlock", "Thetford", "Caerleon",
-]
-
-QUALITY_NAMES = {1: "Normal", 2: "Good", 3: "Outstanding", 4: "Excellent", 5: "Masterpiece"}
-
-_ITEM_POOL = [
-    "T4_BAG", "T5_BAG", "T6_BAG", "T7_BAG", "T8_BAG",
-    "T4_CAPE", "T5_CAPE", "T6_CAPE", "T7_CAPE", "T8_CAPE",
-    "T4_ARMOR_PLATE_SET1", "T5_ARMOR_PLATE_SET1", "T6_ARMOR_PLATE_SET1",
-    "T4_ARMOR_LEATHER_SET1", "T5_ARMOR_LEATHER_SET1", "T6_ARMOR_LEATHER_SET1",
-    "T4_ARMOR_CLOTH_SET1", "T5_ARMOR_CLOTH_SET1", "T6_ARMOR_CLOTH_SET1",
-    "T4_HEAD_PLATE_SET1", "T5_HEAD_PLATE_SET1", "T6_HEAD_PLATE_SET1",
-    "T4_HEAD_LEATHER_SET1", "T5_HEAD_LEATHER_SET1", "T6_HEAD_LEATHER_SET1",
-    "T4_HEAD_CLOTH_SET1", "T5_HEAD_CLOTH_SET1", "T6_HEAD_CLOTH_SET1",
-    "T4_SHOES_PLATE_SET1", "T5_SHOES_PLATE_SET1", "T6_SHOES_PLATE_SET1",
-    "T4_SHOES_LEATHER_SET1", "T5_SHOES_LEATHER_SET1", "T6_SHOES_LEATHER_SET1",
-    "T4_SHOES_CLOTH_SET1", "T5_SHOES_CLOTH_SET1", "T6_SHOES_CLOTH_SET1",
-    "T4_MAIN_SWORD", "T5_MAIN_SWORD", "T6_MAIN_SWORD",
-    "T4_MAIN_AXE", "T5_MAIN_AXE", "T6_MAIN_AXE",
-    "T4_MAIN_BOW", "T5_MAIN_BOW", "T6_MAIN_BOW",
-    "T4_MAIN_CROSSBOW", "T5_MAIN_CROSSBOW", "T6_MAIN_CROSSBOW",
-    "T4_MAIN_FIRE", "T5_MAIN_FIRE", "T6_MAIN_FIRE",
-    "T4_MAIN_FROST", "T5_MAIN_FROST", "T6_MAIN_FROST",
-    "T4_MAIN_HOLY", "T5_MAIN_HOLY", "T6_MAIN_HOLY",
-    "T4_MAIN_NATURE", "T5_MAIN_NATURE", "T6_MAIN_NATURE",
-    "T4_MAIN_CURSED", "T5_MAIN_CURSED", "T6_MAIN_CURSED",
-    "T4_MAIN_HAMMER", "T5_MAIN_HAMMER", "T6_MAIN_HAMMER",
-    "T4_MAIN_SPEAR", "T5_MAIN_SPEAR", "T6_MAIN_SPEAR",
-    "T4_MAIN_MACE", "T5_MAIN_MACE", "T6_MAIN_MACE",
-    "T4_OFF_SHIELD", "T5_OFF_SHIELD", "T6_OFF_SHIELD",
-    "T4_OFF_TORCH", "T5_OFF_TORCH", "T6_OFF_TORCH",
-    "T4_OFF_BOOK", "T5_OFF_BOOK", "T6_OFF_BOOK",
-    "T4_2H_STAFF", "T5_2H_STAFF", "T6_2H_STAFF",
-    "T4_2H_BOW", "T5_2H_BOW", "T6_2H_BOW",
-    "T4_2H_CROSSBOW", "T5_2H_CROSSBOW", "T6_2H_CROSSBOW",
-    "T4_2H_FIRE", "T5_2H_FIRE", "T6_2H_FIRE",
-    "T4_2H_FROST", "T5_2H_FROST", "T6_2H_FROST",
-    "T4_2H_HOLY", "T5_2H_HOLY", "T6_2H_HOLY",
-    "T4_2H_NATURE", "T5_2H_NATURE", "T6_2H_NATURE",
-    "T4_2H_CURSED", "T5_2H_CURSED", "T6_2H_CURSED",
-    "T4_2H_HAMMER", "T5_2H_HAMMER", "T6_2H_HAMMER",
-    "T4_2H_SPEAR", "T5_2H_SPEAR", "T6_2H_SPEAR",
-    "T4_2H_MACE", "T5_2H_MACE", "T6_2H_MACE",
-]
-ITEM_IDS = list(dict.fromkeys(_ITEM_POOL))[:100]
-
-
-def item_display_name(item_id: str) -> str:
-    return item_id.replace("_", " ").title()
-
-
-def quality_name(q) -> str:
-    try:
-        return QUALITY_NAMES.get(int(q), f"Q{q}")
-    except Exception:
-        return f"Q{q}"
-
-
-SETUP_FEE_RATE = 0.025
-TRANSACTION_TAX_RATE = 0.08
-TOTAL_TRADE_COST = SETUP_FEE_RATE + TRANSACTION_TAX_RATE
-
-MIN_PROFIT_MARGIN = 0.02
-LOW_CONFIDENCE_THRESHOLD = TOTAL_TRADE_COST + MIN_PROFIT_MARGIN
-
-DATA_DIR = "gos_hawk_data"
-os.makedirs(DATA_DIR, exist_ok=True)
-MODEL_DIR = os.path.join(DATA_DIR, "models")
-os.makedirs(MODEL_DIR, exist_ok=True)
-MODEL_PATH_24H = os.path.join(MODEL_DIR, "gos_hawk_24h.pkl")
-MODEL_PATH_30D = os.path.join(MODEL_DIR, "gos_hawk_30d.pkl")
-
-MIN_TRAIN_SAMPLES = 150
-REQUEST_TIMEOUT = 60
-MAX_RETRIES = 3
-RETRY_BACKOFF = 2
-
-HISTORY_TIME_SCALE = 6
-
-# 24h model
-CLASS_DOWN_24H = -0.03
-CLASS_UP_24H = 0.03
-TARGET_TOLERANCE_HOURS_24H = 12
-
-# 30 GÜN model (3 ay yerine 30 gün — veri bulunabilirliği için)
-HORIZON_DAYS_30D = 30
-CLASS_DOWN_30D = -0.10
-CLASS_UP_30D = 0.10
-TARGET_TOLERANCE_HOURS_30D = 48
-
-# Trend projeksiyon (30d veri yoksa fallback)
-TREND_PROJECTION_DAYS = 90
-
-# Dip sinyali
-DIP_RSI_MAX = 40.0
-DIP_PERCENTILE_MAX = 0.25
-DIP_MIN_VOLUME_RATIO = 1.0
-DIP_MIN_PREDICTED_PCT = -1.0
-DIP_MAX_SPREAD_PCT = 0.15
-
-FEATURE_COLS_24H = [
-    "hour", "dayofweek",
-    "lag_24h_log", "lag_168h_log", "lag_336h_log",
-    "chg_1h", "chg_6h", "chg_24h", "chg_168h", "chg_336h",
-    "rsi_14", "volatility_24h",
-    "volume_ratio",
-    "ma_24h_ratio", "ma_168h_ratio",
-    "city_price_deviation",
-    "spread_pct", "buy_sell_ratio", "qual_code",
-    "item_code", "city_code",
-]
-
-FEATURE_COLS_30D = [
-    "month", "dayofweek",
-    "lag_168h_log", "lag_336h_log", "lag_720h_log",
-    "chg_168h", "chg_336h", "chg_720h",
-    "rsi_14", "volatility_24h", "volatility_168h",
-    "volume_ratio",
-    "ma_168h_ratio", "ma_720h_ratio",
-    "trend_slope_30d",
-    "city_price_deviation",
-    "spread_pct", "buy_sell_ratio", "qual_code",
-    "item_code", "city_code",
-]
-
-# ---------------------------------------------------------------------------
-# PUBLIC API
-# ---------------------------------------------------------------------------
-
-
-def safe_request(url: str, params: Optional[dict] = None) -> Optional[list]:
-    headers = {"User-Agent": "GOSHAWK-ALBION-MARKET-AI/3.1", "Accept": "application/json"}
-    for attempt in range(MAX_RETRIES):
-        try:
-            resp = requests.get(url, params=params, headers=headers, timeout=REQUEST_TIMEOUT)
-            if resp.status_code == 200:
-                return resp.json()
-            elif resp.status_code == 429:
-                time.sleep(RETRY_BACKOFF * (attempt + 1) * 2)
-                continue
-            elif resp.status_code >= 500:
-                time.sleep(RETRY_BACKOFF * (attempt + 1))
-                continue
-            else:
-                print(f"API: {resp.status_code} - {url}")
-                return None
-        except requests.exceptions.Timeout:
-            print(f"Timeout: {url}")
-        except requests.exceptions.RequestException as e:
-            print(f"Hata: {e}")
-        time.sleep(RETRY_BACKOFF * (attempt + 1))
-    return None
-
-
-def fetch_current_prices(item_ids: List[str], cities: List[str], qualities: str = "1,2,3") -> pd.DataFrame:
-    all_data = []
-    for i in range(0, len(item_ids), 40):
-        chunk = item_ids[i:i+40]
-        url = f"{API_BASE}/stats/prices/{','.join(chunk)}.json"
-        params = {"locations": ",".join(cities), "qualities": qualities}
-        data = safe_request(url, params)
-        if data:
-            all_data.extend(data)
-        time.sleep(0.4)
-    if not all_data:
-        return pd.DataFrame()
-
-    df = pd.DataFrame(all_data)
-    for col in ["sell_price_min", "sell_price_max", "buy_price_min", "buy_price_max"]:
-        if col in df.columns:
-            df[col] = pd.to_numeric(df[col], errors="coerce").astype("float64")
-    if "quality" in df.columns:
-        df["quality"] = pd.to_numeric(df["quality"], errors="coerce").fillna(1).astype(int)
-    return df
-
-
-def fetch_history(item_ids: List[str], cities: List[str], time_scale: int = 6,
-                  qualities: str = "1,2,3") -> pd.DataFrame:
-    all_records = []
-    for i in range(0, len(item_ids), 15):
-        chunk = item_ids[i:i+15]
-        url = f"{API_BASE}/stats/history/{','.join(chunk)}.json"
-        params = {"locations": ",".join(cities), "qualities": qualities,
-                  "time-scale": time_scale}
-        data = safe_request(url, params)
-        if data:
-            for entry in data:
-                item_id = entry.get("item_id")
-                loc = entry.get("location")
-                quality = entry.get("quality", 1)
-                for point in entry.get("data", []):
-                    all_records.append({
-                        "item_id": item_id,
-                        "city": loc,
-                        "quality": quality,
-                        "timestamp": point.get("timestamp"),
-                        "avg_price": point.get("avg_price"),
-                        "item_count": point.get("item_count", 0),
-                    })
-        time.sleep(0.6)
-    if not all_records:
-        return pd.DataFrame()
-
-    df = pd.DataFrame(all_records)
-    df["timestamp"] = pd.to_datetime(df["timestamp"], errors="coerce")
-    df["avg_price"] = pd.to_numeric(df["avg_price"], errors="coerce").astype("float64")
-    df["item_count"] = pd.to_numeric(df["item_count"], errors="coerce").fillna(0).astype("float64")
-    if "quality" in df.columns:
-        df["quality"] = pd.to_numeric(df["quality"], errors="coerce").fillna(1).astype(int)
-    return df
-
-
-def check_api_health() -> Tuple[bool, str]:
-    try:
-        url = f"{API_BASE}/stats/prices/T4_BAG.json"
-        data = safe_request(url, {"locations": "Bridgewatch", "qualities": "1"})
-        return (True, "OK") if data is not None else (False, "Yanıt yok")
-    except Exception as e:
-        return False, str(e)
-
-
-def clean_market_data(df: pd.DataFrame) -> pd.DataFrame:
-    if df.empty:
-        return df
-    df = df.copy()
-    df["avg_price"] = pd.to_numeric(df["avg_price"], errors="coerce").astype("float64")
-    df["item_count"] = pd.to_numeric(df["item_count"], errors="coerce").fillna(0).astype("float64")
-    if "quality" in df.columns:
-        df["quality"] = pd.to_numeric(df["quality"], errors="coerce").fillna(1).astype(int)
-    else:
-        df["quality"] = 1
-    df = df[df["avg_price"] > 0].copy()
-    df = df.dropna(subset=["timestamp"]).copy()
-
-    for (item, qual) in df[["item_id", "quality"]].drop_duplicates().itertuples(index=False):
-        mask = (df["item_id"] == item) & (df["quality"] == qual)
-        if mask.sum() < 10:
-            continue
-        lower = df.loc[mask, "avg_price"].quantile(0.005)
-        upper = df.loc[mask, "avg_price"].quantile(0.995)
-        if pd.notna(lower) and pd.notna(upper) and upper > lower:
-            df.loc[mask, "avg_price"] = df.loc[mask, "avg_price"].clip(lower, upper)
-
-    return df.sort_values(["item_id", "city", "quality", "timestamp"]).reset_index(drop=True)
-
-
-def save_to_csv(df: pd.DataFrame, name: str) -> str:
-    if df.empty:
-        return ""
-    path = os.path.join(DATA_DIR, f"{name}_{dt.datetime.now().strftime('%Y%m%d_%H%M%S')}.csv")
-    try:
-        df.to_csv(path, index=False)
-    except Exception as e:
-        print(f"CSV hatası: {e}")
-        return ""
-    return path
-
-
-# ---------------------------------------------------------------------------
-# FEATURES
-# ---------------------------------------------------------------------------
-
-
-def compute_rsi(series: pd.Series, period: int = 14) -> pd.Series:
-    delta = series.diff()
-    gain = delta.clip(lower=0).rolling(period).mean()
-    loss = (-delta.clip(upper=0)).rolling(period).mean()
-    rs = gain / loss.replace(0, np.nan)
-    return (100 - (100 / (1 + rs))).fillna(50)
-
-
-def _linear_trend_slope(y: np.ndarray) -> float:
-    if len(y) < 5:
-        return 0.0
-    x = np.arange(len(y), dtype=float)
-    try:
-        return float(np.polyfit(x, y, 1)[0])
-    except Exception:
-        return 0.0
-
-
-def build_features(df: pd.DataFrame) -> pd.DataFrame:
-    if df.empty:
-        return df
-    if "quality" not in df.columns:
-        df["quality"] = 1
-
-    df = df.sort_values(["item_id", "city", "quality", "timestamp"]).copy()
-    df["avg_price"] = pd.to_numeric(df["avg_price"], errors="coerce").astype("float64")
-    df["item_count"] = pd.to_numeric(df["item_count"], errors="coerce").fillna(0).astype("float64")
-
-    df["hour"] = df["timestamp"].dt.hour
-    df["dayofweek"] = df["timestamp"].dt.dayofweek
-    df["month"] = df["timestamp"].dt.month
-    df["is_weekend"] = (df["dayofweek"] >= 5).astype(int)
-    df["qual_code"] = df["quality"].astype(int)
-
-    group_cols = ["item_id", "city", "quality"]
-    df["log_price"] = np.log(df["avg_price"].replace(0, np.nan))
-
-    # 24h lag'ler
-    df["lag_24h_log"] = df.groupby(group_cols)["log_price"].shift(24)
-    df["lag_168h_log"] = df.groupby(group_cols)["log_price"].shift(168)
-    df["lag_336h_log"] = df.groupby(group_cols)["log_price"].shift(336)
-
-    # 30d lag'ler
-    df["lag_720h_log"] = df.groupby(group_cols)["log_price"].shift(720)
-    df["lag_1440h_log"] = df.groupby(group_cols)["log_price"].shift(1440)
-
-    for chg in [1, 6, 24, 168, 336, 720, 1440]:
-        df[f"chg_{chg}h"] = df.groupby(group_cols)["log_price"].shift(chg)
-
-    df["ma_24h_raw"] = df.groupby(group_cols)["avg_price"].transform(
-        lambda x: x.rolling(24, min_periods=6).mean()
-    )
-    df["ma_24h_ratio"] = df["ma_24h_raw"] / df["avg_price"].replace(0, np.nan) - 1.0
-
-    df["ma_168h_raw"] = df.groupby(group_cols)["avg_price"].transform(
-        lambda x: x.rolling(168, min_periods=24).mean()
-    )
-    df["ma_168h_ratio"] = df["ma_168h_raw"] / df["avg_price"].replace(0, np.nan) - 1.0
-
-    df["ma_720h_raw"] = df.groupby(group_cols)["avg_price"].transform(
-        lambda x: x.rolling(720, min_periods=72).mean()
-    )
-    df["ma_720h_ratio"] = df["ma_720h_raw"] / df["avg_price"].replace(0, np.nan) - 1.0
-
-    df["rsi_14"] = df.groupby(group_cols)["avg_price"].transform(lambda x: compute_rsi(x, 14))
-    df["volatility_24h"] = df.groupby(group_cols)["log_price"].transform(
-        lambda x: x.rolling(24, min_periods=6).std()
-    )
-    df["volatility_168h"] = df.groupby(group_cols)["log_price"].transform(
-        lambda x: x.rolling(168, min_periods=24).std()
-    )
-    df["volume_ma_24h"] = df.groupby(group_cols)["item_count"].transform(
-        lambda x: x.rolling(24, min_periods=6).mean()
-    )
-    df["volume_ratio"] = df["item_count"] / df["volume_ma_24h"].replace(0, np.nan)
-
-    df["trend_slope_30d"] = df.groupby(group_cols)["log_price"].transform(
-        lambda x: x.rolling(720, min_periods=72).apply(_linear_trend_slope, raw=True)
-    )
-
-    city_avg = df.groupby(["item_id", "quality", "timestamp"])["avg_price"].transform("mean")
-    df["city_price_deviation"] = (df["avg_price"] - city_avg) / city_avg.replace(0, np.nan)
-
-    df["price_pct_7d"] = df.groupby(group_cols)["avg_price"].transform(
-        lambda x: x.rolling(168, min_periods=24).apply(
-            lambda arr: (arr[-1] - np.min(arr)) / (np.max(arr) - np.min(arr) + 1e-9),
-            raw=True
-        )
-    )
-    df["is_downtrend"] = ((df["chg_6h"] < 0) & (df["chg_24h"] < 0)).astype(int)
-
-    df = _compute_targets(df)
-    return df
-
-
-def _compute_targets(df: pd.DataFrame) -> pd.DataFrame:
-    if df.empty or "log_price" not in df.columns:
-        for c in ["target_log_return_24h", "target_class_24h",
-                  "target_log_return_30d", "target_class_30d"]:
-            df[c] = np.nan
-        return df
-
-    df["target_log_return_24h"] = np.nan
-    df["target_log_return_30d"] = np.nan
-
-    group_cols = ["item_id", "city", "quality"]
-
-    for _, g in df.groupby(group_cols):
-        if len(g) < 5:
-            continue
-        g = g.sort_values("timestamp")
-        left = pd.DataFrame({
-            "timestamp": g["timestamp"].values,
-            "log_price_now": g["log_price"].values,
-            "idx": g.index.values,
-        })
-        right = pd.DataFrame({
-            "timestamp": g["timestamp"].values,
-            "log_price_future": g["log_price"].values,
-        }).sort_values("timestamp")
-
-        # 24h
-        left["target_t_24h"] = left["timestamp"] + pd.Timedelta(hours=24)
-        m24 = pd.merge_asof(
-            left.sort_values("target_t_24h"),
-            right.sort_values("timestamp"),
-            left_on="target_t_24h", right_on="timestamp",
-            direction="nearest", tolerance=pd.Timedelta(hours=TARGET_TOLERANCE_HOURS_24H),
-            suffixes=("", "_f"),
-        )
-        df.loc[m24["idx"].values, "target_log_return_24h"] = (
-            m24["log_price_future"].values - m24["log_price_now"].values
-        )
-
-        # 30g
-        left["target_t_30d"] = left["timestamp"] + pd.Timedelta(days=HORIZON_DAYS_30D)
-        m30 = pd.merge_asof(
-            left.sort_values("target_t_30d"),
-            right.sort_values("timestamp"),
-            left_on="target_t_30d", right_on="timestamp",
-            direction="nearest", tolerance=pd.Timedelta(hours=TARGET_TOLERANCE_HOURS_30D),
-            suffixes=("", "_f"),
-        )
-        df.loc[m30["idx"].values, "target_log_return_30d"] = (
-            m30["log_price_future"].values - m30["log_price_now"].values
-        )
-
-    t24 = df["target_log_return_24h"]
-    df["target_class_24h"] = np.where(t24 < CLASS_DOWN_24H, 0, np.where(t24 > CLASS_UP_24H, 2, 1))
-    df.loc[t24.isna(), "target_class_24h"] = np.nan
-
-    t30 = df["target_log_return_30d"]
-    df["target_class_30d"] = np.where(t30 < CLASS_DOWN_30D, 0, np.where(t30 > CLASS_UP_30D, 2, 1))
-    df.loc[t30.isna(), "target_class_30d"] = np.nan
-
-    return df
-
-
-def enrich_spread_features(featured_df: pd.DataFrame, prices_df: pd.DataFrame) -> pd.DataFrame:
-    if featured_df.empty or prices_df.empty:
-        featured_df["spread_pct"] = 0.0
-        featured_df["buy_sell_ratio"] = 1.0
-        return featured_df
-
-    prices = prices_df.copy()
-    if "quality" not in prices.columns:
-        prices["quality"] = 1
-    prices["quality"] = pd.to_numeric(prices["quality"], errors="coerce").fillna(1).astype(int)
-    for c in ["sell_price_min", "buy_price_max"]:
-        prices[c] = pd.to_numeric(prices[c], errors="coerce").astype("float64")
-
-    prices["spread_pct"] = np.where(
-        prices["buy_price_max"] > 0,
-        (prices["sell_price_min"] - prices["buy_price_max"]) / prices["buy_price_max"], np.nan
-    )
-    prices["buy_sell_ratio"] = np.where(
-        prices["sell_price_min"] > 0,
-        prices["buy_price_max"] / prices["sell_price_min"], np.nan
-    )
-
-    pf = prices[["item_id", "city", "quality", "spread_pct", "buy_sell_ratio"]].drop_duplicates(
-        subset=["item_id", "city", "quality"]
-    )
-    out = featured_df.merge(pf, on=["item_id", "city", "quality"], how="left")
-    out["spread_pct"] = out["spread_pct"].fillna(0.0)
-    out["buy_sell_ratio"] = out["buy_sell_ratio"].fillna(1.0)
-    return out
-
-
-# ---------------------------------------------------------------------------
-# MODEL EĞİTİMİ
-# ---------------------------------------------------------------------------
-
-
-def _prepare_model_df(featured_df: pd.DataFrame, horizon: str) -> Tuple[pd.DataFrame, pd.Series, pd.DataFrame]:
-    if featured_df.empty:
-        return pd.DataFrame(), pd.Series(dtype=int), pd.DataFrame()
-
-    target_col = f"target_class_{horizon}"
-    if target_col not in featured_df.columns:
-        return pd.DataFrame(), pd.Series(dtype=int), pd.DataFrame()
-
-    df = featured_df.copy()
-    df["item_code"] = df["item_id"].astype("category").cat.codes
-    df["city_code"] = df["city"].astype("category").cat.codes
-    if "qual_code" not in df.columns:
-        df["qual_code"] = df.get("quality", 1)
-
-    df = df.dropna(subset=[target_col]).copy()
-    df[target_col] = df[target_col].astype(int)
-
-    fill_chg = ["chg_1h", "chg_6h", "chg_24h", "chg_168h", "chg_336h", "chg_720h", "chg_1440h"]
-    for c in fill_chg:
-        if c in df.columns:
-            df[c] = df[c].fillna(0.0)
-
-    for c in ["lag_24h_log", "lag_168h_log", "lag_336h_log", "lag_720h_log", "lag_1440h_log"]:
-        if c in df.columns:
-            df[c] = df[c].fillna(df["log_price"])
-
-    df["rsi_14"] = df["rsi_14"].fillna(50.0)
-    for c in ["volatility_24h", "volatility_168h", "volume_ratio", "ma_24h_ratio",
-              "ma_168h_ratio", "ma_720h_ratio", "trend_slope_30d", "city_price_deviation",
-              "spread_pct", "buy_sell_ratio"]:
-        if c in df.columns:
-            df[c] = df[c].fillna(0.0)
-
-    fcols = FEATURE_COLS_24H if horizon == "24h" else FEATURE_COLS_30D
-    fcols = [c for c in fcols if c in df.columns]
-    model_df = df.dropna(subset=fcols + [target_col]).copy()
-    if model_df.empty:
-        return pd.DataFrame(), pd.Series(dtype=int), pd.DataFrame()
-
-    X = model_df[fcols].astype("float64")
-    y = model_df[target_col]
-    meta = model_df[["item_id", "city", "quality", "timestamp", "avg_price"]].copy()
-    return X, y, meta
-
-
-def train_model(X: pd.DataFrame, y: pd.Series, horizon: str) -> Optional[lgb.LGBMClassifier]:
-    if len(X) < MIN_TRAIN_SAMPLES:
-        return None
-    cc = y.value_counts().to_dict()
-    print(f"[{horizon}] sınıf: {cc}")
-    if len(cc) < 2:
-        return None
-    if len(cc) < 3:
-        print(f"[{horizon}] UYARI: sadece {len(cc)} sınıf var")
-
-    split = int(len(X) * 0.8)
-    X_tr, X_val = X.iloc[:split], X.iloc[split:]
-    y_tr, y_val = y.iloc[:split], y.iloc[split:]
-
-    n_est = 300 if horizon == "24h" else 250
-    model = lgb.LGBMClassifier(
-        objective="multiclass", num_class=3, metric="multi_logloss",
-        boosting_type="gbdt",
-        num_leaves=15, max_depth=5, min_child_samples=50,
-        learning_rate=0.03, n_estimators=n_est,
-        feature_fraction=0.8, bagging_fraction=0.8, bagging_freq=5,
-        reg_alpha=0.5, reg_lambda=1.0,
-        verbose=-1, random_state=42, n_jobs=-1,
-    )
-    try:
-        model.fit(
-            X_tr, y_tr, eval_set=[(X_val, y_val)],
-            callbacks=[lgb.early_stopping(30, verbose=False), lgb.log_evaluation(0)],
-        )
-        acc = accuracy_score(y_val, model.predict(X_val))
-        print(f"[{horizon}] val_accuracy={acc:.4f}")
-    except Exception as e:
-        print(f"[{horizon}] eğitim hatası: {e}")
-        return None
-    return model
-
-
-def predict(model, latest_features: pd.DataFrame, horizon: str) -> pd.DataFrame:
-    if latest_features.empty or model is None:
-        return pd.DataFrame()
-
-    df = latest_features.copy()
-    df["item_code"] = df["item_id"].astype("category").cat.codes
-    df["city_code"] = df["city"].astype("category").cat.codes
-    if "qual_code" not in df.columns:
-        df["qual_code"] = df.get("quality", 1)
-
-    for c in ["chg_1h", "chg_6h", "chg_24h", "chg_168h", "chg_336h", "chg_720h", "chg_1440h"]:
-        if c in df.columns:
-            df[c] = df[c].fillna(0.0)
-    for c in ["lag_24h_log", "lag_168h_log", "lag_336h_log", "lag_720h_log", "lag_1440h_log"]:
-        if c in df.columns:
-            df[c] = df[c].fillna(df["log_price"])
-    df["rsi_14"] = df["rsi_14"].fillna(50.0)
-    for c in ["volatility_24h", "volatility_168h", "volume_ratio", "ma_24h_ratio",
-              "ma_168h_ratio", "ma_720h_ratio", "trend_slope_30d", "city_price_deviation",
-              "spread_pct", "buy_sell_ratio"]:
-        if c in df.columns:
-            df[c] = df[c].fillna(0.0)
-
-    fcols = FEATURE_COLS_24H if horizon == "24h" else FEATURE_COLS_30D
-    fcols = [c for c in fcols if c in df.columns]
-    X_ready = df[fcols].astype("float64").dropna()
-    if X_ready.empty:
-        return pd.DataFrame()
-
-    probs = model.predict_proba(X_ready)
-    pred_class = np.argmax(probs, axis=1)
-
-    if horizon == "24h":
-        exp_log = probs[:, 0] * CLASS_DOWN_24H + probs[:, 2] * CLASS_UP_24H
-        clipped = np.clip(exp_log, CLASS_DOWN_24H, CLASS_UP_24H)
-    else:
-        exp_log = probs[:, 0] * CLASS_DOWN_30D + probs[:, 2] * CLASS_UP_30D
-        clipped = np.clip(exp_log, CLASS_DOWN_30D, CLASS_UP_30D)
-
-    keep = ["item_id", "city", "quality", "avg_price", "item_count",
-            "volatility_24h", "rsi_14", "volume_ratio", "price_pct_7d",
-            "is_downtrend", "chg_6h", "chg_24h", "chg_168h", "trend_slope_30d",
-            "spread_pct", "buy_sell_ratio"]
-    keep = [c for c in keep if c in df.columns]
-    out = df.loc[X_ready.index, keep].copy()
-    out["pred_class"] = pred_class
-    out["prob_down"] = probs[:, 0]
-    out["prob_flat"] = probs[:, 1] if probs.shape[1] > 1 else 0.0
-    out["prob_up"] = probs[:, 2] if probs.shape[1] > 2 else 0.0
-    out["predicted_log_return"] = clipped
-    out["predicted_return_pct"] = (np.exp(clipped) - 1) * 100
-    out["predicted_price"] = out["avg_price"] * np.exp(clipped)
-    out["confidence"] = probs.max(axis=1)
-    return out
-
-
-# ---------------------------------------------------------------------------
-# TREND PROJEKSİYONU (30d model yoksa fallback)
-# ---------------------------------------------------------------------------
-
-
-def trend_projection_90d(latest: pd.DataFrame) -> pd.DataFrame:
-    """
-    30d model yoksa, trend_slope_30d kullanarak 90 günlük basit projeksiyon.
-    Formül: fiyat × exp(slope × gün_sayısı)
-    slope günlük log değişim → 90 günde slope × 90
-    """
-    if latest.empty:
-        return pd.DataFrame()
-
-    df = latest.copy()
-    df["trend_slope_30d"] = df.get("trend_slope_30d", pd.Series(0.0, index=df.index)).fillna(0.0)
-
-    # slope * 90 gün = 90 günlük log getiri
-    log_return_90d = df["trend_slope_30d"] * TREND_PROJECTION_DAYS
-
-    # Aşırı projeksiyonu clip'le (90 günde ±%100)
-    log_return_90d = np.clip(log_return_90d, -1.0, 1.0)
-
-    df["predicted_log_return"] = log_return_90d
-    df["predicted_return_pct"] = (np.exp(log_return_90d) - 1) * 100
-    df["predicted_price"] = df["avg_price"] * np.exp(log_return_90d)
-
-    # Güven: trend gücüne göre
-    df["confidence"] = np.abs(df["trend_slope_30d"]).clip(0, 0.005) / 0.005 * 0.6 + 0.3
-
-    df["pred_class"] = np.where(log_return_90d < -0.05, 0,
-                          np.where(log_return_90d > 0.05, 2, 1))
-    df["prob_up"] = np.where(log_return_90d > 0.05, 0.6, 0.2)
-    df["prob_down"] = np.where(log_return_90d < -0.05, 0.6, 0.2)
-    df["prob_flat"] = 1.0 - df["prob_up"] - df["prob_down"]
-
-    return df
-
-
-# ---------------------------------------------------------------------------
-# DİP SİNYALİ
-# ---------------------------------------------------------------------------
-
-
-def compute_dip_signal(row: pd.Series) -> Tuple[str, str]:
-    reasons, passed = [], 0
-    rsi = row.get("rsi_14", 50)
-    if pd.notna(rsi) and rsi < DIP_RSI_MAX:
-        passed += 1; reasons.append(f"RSI={rsi:.0f}")
-    pct = row.get("price_pct_7d", 0.5)
-    if pd.notna(pct) and pct < DIP_PERCENTILE_MAX:
-        passed += 1; reasons.append(f"7g%={pct*100:.0f}")
-    vr = row.get("volume_ratio", 1.0)
-    if pd.notna(vr) and vr >= DIP_MIN_VOLUME_RATIO:
-        passed += 1; reasons.append(f"H×{vr:.1f}")
-    pp = row.get("predicted_return_pct", 0)
-    if pd.notna(pp) and pp >= DIP_MIN_PREDICTED_PCT:
-        passed += 1; reasons.append(f"M={pp:+.1f}%")
-    sp = row.get("spread_pct", np.nan)
-    if pd.notna(sp) and abs(sp) < DIP_MAX_SPREAD_PCT:
-        passed += 1; reasons.append(f"Sp={sp*100:.1f}%")
-    down = row.get("is_downtrend", 0)
-    if not down or (pd.notna(pp) and pp > 2):
-        passed += 1; reasons.append("Trend✓")
-
-    if passed >= 5: sig = "🟢 GÜÇLÜ AL"
-    elif passed == 4: sig = "🟡 ZAYIF AL"
-    elif passed == 3 and pd.notna(rsi) and rsi < 45: sig = "🔵 İZLE"
-    elif down and pd.notna(pp) and pp < -2: sig = "🔴 ALMA"
-    else: sig = "⚪ BEKLE"
-    return sig, " · ".join(reasons) if reasons else "—"
-
-
-# ---------------------------------------------------------------------------
-# PIPELINE
-# ---------------------------------------------------------------------------
-
-
-class DataPipeline:
-    def __init__(self):
-        self.history_df = pd.DataFrame()
-        self.prices_df = pd.DataFrame()
-        self.featured_df = pd.DataFrame()
-        self.model_24h = None
-        self.model_30d = None
-        self.last_update = None
-        self.status_message = "Veri yüklenmedi."
-        self._diagnostics = {}
-        self._projection_mode = "MODEL"  # veya "TREND"
-
-        if _HAS_JOBLIB:
-            try:
-                if os.path.exists(MODEL_PATH_24H):
-                    self.model_24h = joblib.load(MODEL_PATH_24H)
-                if os.path.exists(MODEL_PATH_30D):
-                    self.model_30d = joblib.load(MODEL_PATH_30D)
-                if self.model_24h or self.model_30d:
-                    self.status_message = "Kayıtlı model(ler) yüklendi."
-            except Exception:
-                pass
-
-    def fetch_data(self, item_ids=None, cities=None):
-        item_ids = item_ids or ITEM_IDS
-        cities = cities or CITIES
-
-        self.status_message = "Public API'den veri çekiliyor..."
-        ok, msg = check_api_health()
-        if not ok:
-            self.status_message = f"API erişilemiyor: {msg}"
-            return
-
-        try:
-            hist = fetch_history(item_ids, cities, time_scale=HISTORY_TIME_SCALE)
-            prices = fetch_current_prices(item_ids, cities)
-        except Exception as e:
-            self.status_message = f"API hatası: {e}"
-            return
-
-        if hist.empty:
-            self.status_message = "Tarihsel veri alınamadı."
-            return
-
-        self.history_df = clean_market_data(hist)
-        self.prices_df = prices
-        n_q = self.history_df["quality"].nunique()
-        self.status_message = f"✓ {len(self.history_df)} satır ({n_q} kalite), {len(self.prices_df)} anlık."
-
-        save_to_csv(self.history_df, "history")
-        save_to_csv(self.prices_df, "prices")
-
-        self.featured_df = build_features(self.history_df)
-        self.featured_df = enrich_spread_features(self.featured_df, self.prices_df)
-        self._update_diagnostics()
-
-    def _update_diagnostics(self):
-        df = self.featured_df
-        if df.empty:
-            self._diagnostics = {}
-            return
-        n24 = int(df["target_class_24h"].notna().sum())
-        n30 = int(df["target_class_30d"].notna().sum())
-        cd24 = df["target_class_24h"].value_counts().to_dict() if n24 > 0 else {}
-        cd30 = df["target_class_30d"].value_counts().to_dict() if n30 > 0 else {}
-        date_range_days = (df["timestamp"].max() - df["timestamp"].min()).days if len(df) > 0 else 0
-
-        self._diagnostics = {
-            "n_total": len(df),
-            "n_24h": n24,
-            "n_30d": n30,
-            "class_24h": cd24,
-            "class_30d": cd30,
-            "date_range_days": date_range_days,
-        }
-        print(f"[TANI] total={len(df)}, 24h={n24}, 30d={n30}, gün={date_range_days}")
-
-    def train_all(self):
-        if self.featured_df.empty:
-            self.status_message = "Önce veri çekin."
-            return False
-
-        # 24h
-        X24, y24, _ = _prepare_model_df(self.featured_df, "24h")
-        if len(X24) >= MIN_TRAIN_SAMPLES:
-            self.model_24h = train_model(X24, y24, "24h")
-            if _HAS_JOBLIB and self.model_24h:
-                try:
-                    joblib.dump(self.model_24h, MODEL_PATH_24H)
-                except Exception:
-                    pass
-
-        # 30d
-        X30, y30, _ = _prepare_model_df(self.featured_df, "30d")
-        n30 = len(X30)
-        if n30 >= MIN_TRAIN_SAMPLES:
-            self.model_30d = train_model(X30, y30, "30d")
-            if _HAS_JOBLIB and self.model_30d:
-                try:
-                    joblib.dump(self.model_30d, MODEL_PATH_30D)
-                except Exception:
-                    pass
-
-        # Projeksiyon modu belirle
-        if self.model_30d is not None:
-            self._projection_mode = "MODEL"
-        else:
-            self._projection_mode = "TREND"
-
-        msgs = []
-        msgs.append("24h ✓" if self.model_24h else "24h ✗")
-        if self.model_30d:
-            msgs.append(f"30d ✓ ({n30})")
-        else:
-            msgs.append(f"30d ✗ ({n30}) → trend projeksiyonu")
-        self.status_message = " · ".join(msgs)
-        self.last_update = dt.datetime.now()
-        return True
-
-    def get_latest(self) -> pd.DataFrame:
-        if self.featured_df.empty:
-            return pd.DataFrame()
-        return self.featured_df.sort_values("timestamp").groupby(
-            ["item_id", "city", "quality"]
-        ).tail(1).copy()
-
-    def predict_24h(self) -> pd.DataFrame:
-        latest = self.get_latest()
-        if latest.empty or self.model_24h is None:
-            return pd.DataFrame()
-        preds = predict(self.model_24h, latest, "24h")
-        if preds.empty:
-            return preds
-
-        if not self.prices_df.empty:
-            pi = self.prices_df[["item_id", "city", "quality",
-                                  "sell_price_min", "buy_price_max"]].copy()
-            for c in ["sell_price_min", "buy_price_max"]:
-                pi[c] = pd.to_numeric(pi[c], errors="coerce").astype("float64")
-            preds = preds.merge(pi, on=["item_id", "city", "quality"], how="left")
-            preds["spread"] = preds["sell_price_min"] - preds["buy_price_max"]
-        else:
-            preds["spread"] = np.nan
-
-        preds["net_return_pct"] = preds["predicted_return_pct"] - (TOTAL_TRADE_COST * 100)
-        dip = preds.apply(compute_dip_signal, axis=1, result_type="expand")
-        preds["Dip Sinyali"] = dip[0]
-        preds["Sinyal Detayı"] = dip[1]
-        return preds
-
-    def predict_long_horizon(self) -> Tuple[pd.DataFrame, str]:
-        """30d model varsa model, yoksa trend projeksiyonu."""
-        latest = self.get_latest()
-        if latest.empty:
-            return pd.DataFrame(), "veri_yok"
-
-        if self.model_30d is not None:
-            preds = predict(self.model_30d, latest, "30d")
-            return preds, "model_30d"
-        else:
-            preds = trend_projection_90d(latest)
-            return preds, "trend_projection"
-
-
-pipeline = DataPipeline()
-
-
-# ---------------------------------------------------------------------------
-# GRADIO YARDIMCILARI
-# ---------------------------------------------------------------------------
-
-
-def get_dashboard_metrics():
-    diag = pipeline._diagnostics
-    if pipeline.featured_df.empty:
-        return pd.DataFrame({"Metrik": ["Durum"], "Değer": ["Veri yok."]})
-
-    df = pipeline.featured_df
-    m = {
-        "Veri Kaynağı": "Public AODP API",
-        "Veri Süresi": f"{diag.get('date_range_days', 0)} gün",
-        "Toplam Gözlem": len(df),
-        "Hedefli 24h": diag.get("n_24h", 0),
-        "Hedefli 30d": diag.get("n_30d", 0),
-        "Sınıf 24h": str(diag.get("class_24h", {})),
-        "Sınıf 30d": str(diag.get("class_30d", {})),
-        "24h Model": "Eğitildi" if pipeline.model_24h else "Yok",
-        "30d Model": "Eğitildi" if pipeline.model_30d else "Yok",
-        "Uzun Vadeli Mod": pipeline._projection_mode,
-        "Son Güncelleme": pipeline.last_update.strftime("%Y-%m-%d %H:%M") if pipeline.last_update else "—",
-    }
-    return pd.DataFrame(list(m.items()), columns=["Metrik", "Değer"])
-
-
-def get_prediction_24h_table():
-    preds = pipeline.predict_24h()
-    if preds.empty:
-        return pd.DataFrame({"Bilgi": ["24h tahmini yok."]})
-    preds = preds.copy()
-    preds["Ürün"] = preds["item_id"].apply(item_display_name)
-    preds["Kalite"] = preds["quality"].apply(quality_name)
-    preds["Şehir"] = preds["city"]
-    preds["Mevcut"] = preds["avg_price"].round(0)
-    preds["24s"] = preds["predicted_price"].round(0)
-    preds["Değişim %"] = preds["predicted_return_pct"].round(2)
-    preds["Sınıf"] = preds["pred_class"].map({0: "↓", 1: "→", 2: "↑"})
-    preds["P(↑)"] = (preds["prob_up"] * 100).round(0).astype(int).astype(str) + "%"
-    preds["Güven"] = (preds["confidence"] * 100).round(0).astype(int).astype(str) + "%"
-    preds["Net %"] = preds["net_return_pct"].round(2)
-    cols = ["Ürün", "Kalite", "Şehir", "Mevcut", "24s", "Değişim %",
-            "Sınıf", "P(↑)", "Güven", "Net %", "Dip Sinyali"]
-    return preds[cols].sort_values("Güven", ascending=False)
-
-
-def get_prediction_long_table():
-    preds, mode = pipeline.predict_long_horizon()
-    if preds.empty:
-        return pd.DataFrame({"Bilgi": ["Uzun vadeli tahmin yok."]}), mode
-
-    preds = preds.copy()
-    preds["Ürün"] = preds["item_id"].apply(item_display_name)
-    preds["Kalite"] = preds["quality"].apply(quality_name)
-    preds["Şehir"] = preds["city"]
-    preds["Mevcut"] = preds["avg_price"].round(0)
-
-    if mode == "model_30d":
-        preds["30 Gün Tahmini"] = preds["predicted_price"].round(0)
-        preds["Değişim %"] = preds["predicted_return_pct"].round(2)
-        preds["Trend"] = preds["pred_class"].map({0: "↓ AŞAĞI", 1: "→ SABİT", 2: "↑ YUKARI"})
-        preds["P(↑)"] = (preds["prob_up"] * 100).round(0).astype(int).astype(str) + "%"
-        preds["Güven"] = (preds["confidence"] * 100).round(0).astype(int).astype(str) + "%"
-        cols = ["Ürün", "Kalite", "Şehir", "Mevcut", "30 Gün Tahmini",
-                "Değişim %", "Trend", "P(↑)", "Güven"]
-    else:
-        # Trend projeksiyon
-        preds["90 Gün Tahmini"] = preds["predicted_price"].round(0)
-        preds["Değişim %"] = preds["predicted_return_pct"].round(2)
-        preds["Trend"] = preds["pred_class"].map({0: "↓ AŞAĞI", 1: "→ SABİT", 2: "↑ YUKARI"})
-        preds["Güven"] = (preds["confidence"] * 100).round(0).astype(int).astype(str) + "%"
-        cols = ["Ürün", "Kalite", "Şehir", "Mevcut", "90 Gün Tahmini",
-                "Değişim %", "Trend", "Güven"]
-
-    return preds[cols].sort_values("Güven", ascending=False), mode
-
-
-def get_analysis_table():
-    if pipeline.featured_df.empty:
-        return pd.DataFrame()
-
-    latest = pipeline.get_latest()
-    if not pipeline.prices_df.empty:
-        pi = pipeline.prices_df[["item_id", "city", "quality",
-                                  "sell_price_min", "buy_price_max"]].copy()
-        for c in ["sell_price_min", "buy_price_max"]:
-            pi[c] = pd.to_numeric(pi[c], errors="coerce").astype("float64")
-        latest = latest.merge(pi, on=["item_id", "city", "quality"], how="left")
-    else:
-        latest["sell_price_min"] = np.nan
-        latest["buy_price_max"] = np.nan
-
-    latest["Ürün"] = latest["item_id"].apply(item_display_name)
-    latest["Kalite"] = latest["quality"].apply(quality_name)
-    latest["Şehir"] = latest["city"]
-    latest["Fiyat"] = latest["avg_price"].round(0)
-    latest["Hacim"] = latest["item_count"].fillna(0).astype(int)
-    latest["Spread"] = (latest["sell_price_min"] - latest["buy_price_max"]).round(0)
-    latest["RSI"] = latest["rsi_14"].round(0)
-    latest["7g%"] = (latest["price_pct_7d"] * 100).round(0)
-    latest["30g Trend"] = latest["trend_slope_30d"].round(4)
-    cols = ["Ürün", "Kalite", "Şehir", "Fiyat", "Hacim", "Spread",
-            "RSI", "7g%", "30g Trend"]
-    return latest[cols].sort_values("Hacim", ascending=False).head(100)
-
-
-def get_dip_table():
-    preds = pipeline.predict_24h()
-    if preds.empty:
-        return pd.DataFrame({"Bilgi": ["Tahmin yok."]})
-    dip = preds[preds["Dip Sinyali"].isin(["🟢 GÜÇLÜ AL", "🟡 ZAYIF AL", "🔵 İZLE"])].copy()
-    if dip.empty:
-        return pd.DataFrame({"Bilgi": ["Dip sinyali yok."]})
-
-    order = {"🟢 GÜÇLÜ AL": 0, "🟡 ZAYIF AL": 1, "🔵 İZLE": 2}
-    dip["_r"] = dip["Dip Sinyali"].map(order)
-    dip["Ürün"] = dip["item_id"].apply(item_display_name)
-    dip["Kalite"] = dip["quality"].apply(quality_name)
-    dip["Şehir"] = dip["city"]
-    dip["Mevcut"] = dip["avg_price"].round(0)
-    dip["RSI"] = dip["rsi_14"].round(0)
-    dip["7g%"] = (dip["price_pct_7d"] * 100).round(0)
-    dip["P(↑)"] = (dip["prob_up"] * 100).round(0).astype(int).astype(str) + "%"
-    dip["Net %"] = dip["net_return_pct"].round(2)
-    dip = dip.sort_values(["_r", "confidence"], ascending=[True, False])
-    cols = ["Dip Sinyali", "Ürün", "Kalite", "Şehir", "Mevcut",
-            "RSI", "7g%", "P(↑)", "Net %", "Sinyal Detayı"]
-    return dip[cols].head(50)
-
-
-def get_arbitrage_table():
-    if pipeline.prices_df.empty:
-        return pd.DataFrame({"Bilgi": ["Fiyat yok."]})
-
-    prices = pipeline.prices_df.copy()
-    if "quality" not in prices.columns:
-        prices["quality"] = 1
-    prices["quality"] = pd.to_numeric(prices["quality"], errors="coerce").fillna(1).astype(int)
-    for c in ["sell_price_min", "buy_price_max"]:
-        prices[c] = pd.to_numeric(prices[c], errors="coerce").astype("float64")
-    prices = prices[prices["sell_price_min"] > 0]
-    if prices.empty:
-        return pd.DataFrame({"Bilgi": ["Fiyat yok."]})
-
-    buy = prices.loc[prices.groupby(["item_id", "quality"])["sell_price_min"].idxmin()][
-        ["item_id", "quality", "city", "sell_price_min"]
-    ].rename(columns={"city": "buy_city", "sell_price_min": "buy_price"})
-
-    sell = prices.loc[prices.groupby(["item_id", "quality"])["buy_price_max"].idxmax()][
-        ["item_id", "quality", "city", "buy_price_max"]
-    ].rename(columns={"city": "sell_city", "buy_price_max": "sell_price"})
-
-    arb = buy.merge(sell, on=["item_id", "quality"])
-    arb = arb[arb["sell_price"] > arb["buy_price"]].copy()
-    if arb.empty:
-        return pd.DataFrame({"Bilgi": ["Arbitraj yok."]})
-
-    arb["brüt"] = arb["sell_price"] - arb["buy_price"]
-    arb["maliyet"] = arb["buy_price"] * SETUP_FEE_RATE + arb["sell_price"] * (SETUP_FEE_RATE + TRANSACTION_TAX_RATE)
-    arb["net"] = arb["brüt"] - arb["maliyet"]
-    arb["marj"] = (arb["net"] / arb["buy_price"]) * 100
-    arb = arb[arb["net"] > 0].sort_values("marj", ascending=False)
-
-    if arb.empty:
-        return pd.DataFrame({"Bilgi": ["Kârlı arbitraj yok."]})
-
-    arb["Ürün"] = arb["item_id"].apply(item_display_name)
-    arb["Kalite"] = arb["quality"].apply(quality_name)
-    arb["Alış"] = arb["buy_city"]
-    arb["Satış"] = arb["sell_city"]
-    arb["Alış Fiyatı"] = arb["buy_price"].round(0)
-    arb["Satış Fiyatı"] = arb["sell_price"].round(0)
-    arb["Net Kâr"] = arb["net"].round(0)
-    arb["Marj %"] = arb["marj"].round(1)
-    cols = ["Ürün", "Kalite", "Alış", "Satış", "Alış Fiyatı", "Satış Fiyatı", "Net Kâr", "Marj %"]
-    return arb[cols].head(50)
-
-
-def get_importance_plot(horizon: str = "24h"):
-    model = pipeline.model_24h if horizon == "24h" else pipeline.model_30d
-    if model is None:
-        return go.Figure().update_layout(title=f"{horizon} model yok", template="plotly_dark")
-    try:
-        df = pd.DataFrame({
-            "Özellik": model.feature_name_,
-            "Önem": model.feature_importances_,
-        }).sort_values("Önem", ascending=True).tail(20)
-        fig = px.bar(df, x="Önem", y="Özellik", orientation="h",
-                     title=f"{horizon} Feature Importance", template="plotly_dark")
-        fig.update_layout(height=600)
-        return fig
-    except Exception as e:
-        return go.Figure().update_layout(title=f"Hata: {e}", template="plotly_dark")
-
-
-def list_csv_files() -> pd.DataFrame:
-    rows = []
-    if os.path.isdir(DATA_DIR):
-        for f in sorted(os.listdir(DATA_DIR)):
-            if f.endswith(".csv"):
-                fp = os.path.join(DATA_DIR, f)
-                try:
-                    rows.append({
-                        "Dosya": f,
-                        "Boyut (KB)": round(os.path.getsize(fp) / 1024, 2),
-                        "Son Değişiklik": dt.datetime.fromtimestamp(os.path.getmtime(fp)).strftime("%Y-%m-%d %H:%M:%S"),
-                    })
-                except OSError:
-                    continue
-    return pd.DataFrame(rows) if rows else pd.DataFrame(columns=["Dosya", "Boyut (KB)", "Son Değişiklik"])
-
-
-def refresh_all():
-    try:
-        pipeline.fetch_data()
-        if not pipeline.featured_df.empty:
-            pipeline.train_all()
-    except Exception as e:
-        pipeline.status_message = f"Hata: {e}"
-        import traceback
-        traceback.print_exc()
-
-    try:
-        long_table, long_mode = get_prediction_long_table()
-    except Exception:
-        long_table, long_mode = pd.DataFrame(), "error"
-
-    def _safe(fn, default):
-        try:
-            return fn()
-        except Exception:
-            return default
-
-    mode_msg = f"Uzun vade: {'MODEL (30d)' if long_mode == 'model_30d' else 'TREND PROJEKSİYONU (90d)'}"
-
-    return (
-        f"{pipeline.status_message} | {mode_msg}",
-        _safe(get_dashboard_metrics, pd.DataFrame()),
-        _safe(get_analysis_table, pd.DataFrame()),
-        _safe(get_prediction_24h_table, pd.DataFrame()),
-        long_table,
-        _safe(get_dip_table, pd.DataFrame()),
-        _safe(get_arbitrage_table, pd.DataFrame()),
-        _safe(get_importance_plot, go.Figure().update_layout(title="—", template="plotly_dark")),
-        _safe(lambda: get_importance_plot("30d"), go.Figure().update_layout(title="—", template="plotly_dark")),
-        _safe(list_csv_files, pd.DataFrame()),
-    )
-
-
-def initial_load():
-    def _safe(fn, default):
-        try:
-            return fn()
-        except Exception:
-            return default
-    return (
-        _safe(get_dashboard_metrics, pd.DataFrame({"Metrik": ["Durum"], "Değer": ["Hazır"]})),
-        pd.DataFrame(), pd.DataFrame(), pd.DataFrame(),
-        pd.DataFrame({"Bilgi": ["Yenile'ye basın"]}),
-        pd.DataFrame(), pd.DataFrame(),
-        go.Figure().update_layout(title="Yenile", template="plotly_dark"),
-        go.Figure().update_layout(title="Yenile", template="plotly_dark"),
-        _safe(list_csv_files, pd.DataFrame()),
-    )
-
-
-# ---------------------------------------------------------------------------
-# GRADIO
-# ---------------------------------------------------------------------------
-
-
-with gr.Blocks(title="GOSHAWK ALBION MARKET AI", theme=gr.themes.Soft(primary_hue="cyan", secondary_hue="slate")) as demo:
-
-    gr.Markdown(
-        """
-        # 🦅 GOSHAWK ALBION MARKET AI v3.1
-        **Hibrit yaklaşım:** 24h model + 30d model (yoksa 90d trend projeksiyonu)
-
-        **⚠️ Uyarı:** Uzun vadeli tahmin **düşük güvenilirlikte**. Trend yönü için kullanın.
-        """
-    )
-
-    with gr.Row():
-        refresh_btn = gr.Button("🔄 Verileri Yenile", variant="primary", scale=1)
-        status_text = gr.Textbox(label="Durum", interactive=False, scale=2, value=pipeline.status_message)
-
-    with gr.Tabs():
-        with gr.TabItem("📊 Dashboard"):
-            dashboard_table = gr.Dataframe(label="Özet & Teşhis", interactive=False, wrap=True)
-            gr.Markdown(
-                "### Hibrit Yaklaşım\n"
-                "**24h Model:** Her zaman denenir\n"
-                "**30d Model:** Yeterli veri varsa (min 150 örnek) eğitilir\n"
-                "**Trend Projeksiyonu:** 30d model yoksa, 30 günlük lineer trend eğiminden 90 günlük tahmin\n\n"
-                "### Neden 30d, 90d değil?\n"
-                "- 90d model için **6 ay geçmiş veri** gerekir\n"
-                "- API'de genelde 2-4 ay var → 90d model eğitilemez\n"
-                "- 30d model için **2 ay geçmiş** yeterli → çoğu üründe çalışır\n\n"
-                "### Trend Projeksiyonu Formülü\n"
-                "`fiyat × exp(trend_slope_30d × 90 gün)`\n"
-                "- Basit ama az veriyle çalışır\n"
-                "- Patch/sezon değişimini **görmez**"
-            )
-
-        with gr.TabItem("🔮 24 Saat"):
-            pred_24h_table = gr.Dataframe(label="24s Tahminler", interactive=False)
-
-        with gr.TabItem("📅 Uzun Vade"):
-            pred_long_table = gr.Dataframe(label="30 Gün Modeli veya 90 Gün Trend Projeksiyonu", interactive=False)
-            gr.Markdown(
-                "*30d model eğitildiyse 30 günlük tahmin, aksi halde 30 günlük trendden 90 günlük projeksiyon. "
-                "**Güven %50 altındaysa işlem yapmayın.** Patch değişimleri modeli tamamen bozar.*"
-            )
-
-        with gr.TabItem("🎯 DİP ALIM"):
-            dip_table = gr.Dataframe(label="Dip Alım", interactive=False)
-
-        with gr.TabItem("📦 Ürün Analizi"):
-            analysis_table = gr.Dataframe(label="Ürün Analizi", interactive=False)
-
-        with gr.TabItem("🚚 Arbitraj"):
-            arbitrage_table = gr.Dataframe(label="Arbitraj", interactive=False)
-
-        with gr.TabItem("📈 24h Model"):
-            importance_24h = gr.Plot(label="24h Önem")
-
-        with gr.TabItem("📈 30d Model"):
-            importance_30d = gr.Plot(label="30d Önem")
-
-        with gr.TabItem("🗄️ Veri"):
-            gr.Markdown(
-                "**API:** europe.albion-online-data.com\n"
-                "**Kalite:** 1-3\n"
-                f"**24h sınır:** ±%{CLASS_UP_24H*100:.0f}\n"
-                f"**30d sınır:** ±%{CLASS_UP_30D*100:.0f}\n"
-                f"**Trend projeksiyon:** {TREND_PROJECTION_DAYS} gün"
-            )
-            csv_files = gr.Dataframe(label="CSV", interactive=False,
-                                     headers=["Dosya", "Boyut (KB)", "Son Değişiklik"])
-
-    refresh_btn.click(
-        fn=refresh_all,
-        inputs=[],
-        outputs=[status_text, dashboard_table, analysis_table, pred_24h_table,
-                 pred_long_table, dip_table, arbitrage_table, importance_24h,
-                 importance_30d, csv_files],
-    )
-
-    demo.load(
-        fn=initial_load,
-        inputs=[],
-        outputs=[dashboard_table, analysis_table, pred_24h_table, pred_long_table,
-                 dip_table, arbitrage_table, importance_24h, importance_30d, csv_files],
-    )
-
-
-if __name__ == "__main__":
-    demo.launch(server_name="0.0.0.0", server_port=7860, share=False)