Update app.py

app.py

@@ -1,6 +1,6 @@
 # app.py
 # GOSHAWK ALBION MARKET AI
-# MAE iyileştirilmiş sürüm: sınıflandırma + overfit önleme + sadeleştirilmiş feature set
+# Kalite ayrımı + uzun vadeli trend (7/14 gün) + alış-satış spread feature'ları
 
 import os
 import time
@@ -15,7 +15,7 @@ import plotly.graph_objects as go
 import plotly.express as px
 
 import lightgbm as lgb
-from sklearn.metrics import mean_absolute_error, mean_squared_error, accuracy_score, confusion_matrix
+from sklearn.metrics import accuracy_score
 
 import gradio as gr
 
@@ -38,6 +38,12 @@ CITIES = [
     "Martlock", "Thetford", "Caerleon",
 ]
 
+# Kalite seviyeleri (1=Normal, 2=Good, 3=Outstanding, 4=Excellent, 5=Masterpiece)
+QUALITIES = ["1", "2", "3", "4", "5"]
+
+# Kalite kodları → insan-okunur
+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",
@@ -84,6 +90,13 @@ 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
@@ -104,12 +117,9 @@ RETRY_BACKOFF = 2
 
 HISTORY_TIME_SCALE = 1
 
-# Sınıflandırma sınırları (log getiri)
-CLASS_DOWN = -0.03       # -3% altı = AŞAĞI
-CLASS_UP = 0.03          # +3% üstü = YUKARI
-# Arada kalan = SABİT
+CLASS_DOWN = -0.03
+CLASS_UP = 0.03
 
-TARGET_SCALE = 10000.0
 TARGET_TOLERANCE_HOURS = 12
 
 # Dip alım
@@ -119,17 +129,19 @@ DIP_MIN_VOLUME_RATIO = 1.0
 DIP_MIN_PREDICTED_PCT = -1.0
 DIP_MAX_SPREAD_PCT = 0.15
 
-# Backtest
-MAX_POSITIONS = 5
+# Uzun vadeli lag/chg pencereleri
+LONG_TERM_WINDOWS = [24, 168, 336]  # 1g, 7g, 14g
 
-# SADELEŞTİRİLMİŞ feature set (13 güçlü özellik)
+# Feature kolonları (spread + uzun vadeli dahil)
 FEATURE_COLS = [
     "hour", "dayofweek",
-    "lag_24h_log", "chg_1h", "chg_6h", "chg_24h",
+    "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_24h_ratio", "ma_168h_ratio",
     "city_price_deviation",
+    "spread_pct", "buy_sell_ratio", "qual_code",
     "item_code", "city_code",
 ]
 
@@ -139,7 +151,7 @@ FEATURE_COLS = [
 
 
 def safe_request(url: str, params: Optional[dict] = None) -> Optional[list]:
-    headers = {"User-Agent": "GOSHAWK-ALBION-MARKET-AI/1.8", "Accept": "application/json"}
+    headers = {"User-Agent": "GOSHAWK-ALBION-MARKET-AI/2.0", "Accept": "application/json"}
     for attempt in range(MAX_RETRIES):
         try:
             resp = requests.get(url, params=params, headers=headers, timeout=REQUEST_TIMEOUT)
@@ -162,16 +174,17 @@ def safe_request(url: str, params: Optional[dict] = None) -> Optional[list]:
     return None
 
 
-def fetch_current_prices(item_ids: List[str], cities: List[str], qualities: str = "1") -> pd.DataFrame:
+def fetch_current_prices(item_ids: List[str], cities: List[str], qualities: str = "1,2,3,4,5") -> pd.DataFrame:
+    """Anlık fiyatlar — tüm kaliteler."""
     all_data = []
-    for i in range(0, len(item_ids), 50):
-        chunk = item_ids[i:i+50]
+    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.3)
+        time.sleep(0.4)
     if not all_data:
         return pd.DataFrame()
 
@@ -179,13 +192,16 @@ def fetch_current_prices(item_ids: List[str], cities: List[str], qualities: str
     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 = 1, qualities: str = "1") -> pd.DataFrame:
+def fetch_history(item_ids: List[str], cities: List[str], time_scale: int = 1, qualities: str = "1,2,3,4,5") -> pd.DataFrame:
+    """Tarihsel fiyatlar — tüm kaliteler."""
     all_records = []
-    for i in range(0, len(item_ids), 20):
-        chunk = item_ids[i:i+20]
+    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)
@@ -193,15 +209,17 @@ def fetch_history(item_ids: List[str], cities: List[str], time_scale: int = 1, q
             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.5)
+        time.sleep(0.6)
     if not all_records:
         return pd.DataFrame()
 
@@ -209,6 +227,8 @@ def fetch_history(item_ids: List[str], cities: List[str], time_scale: int = 1, q
     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
 
 
@@ -227,11 +247,16 @@ def clean_market_data(df: pd.DataFrame) -> pd.DataFrame:
     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 in df["item_id"].unique():
-        mask = df["item_id"] == item
+    # Kalite bazlı temizlik (item+city+quality bazında)
+    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)
@@ -239,7 +264,7 @@ def clean_market_data(df: pd.DataFrame) -> pd.DataFrame:
         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", "timestamp"]).reset_index(drop=True)
+    return df.sort_values(["item_id", "city", "quality", "timestamp"]).reset_index(drop=True)
 
 
 def save_to_csv(df: pd.DataFrame, name: str) -> str:
@@ -268,31 +293,50 @@ def compute_rsi(series: pd.Series, period: int = 14) -> pd.Series:
 
 
 def build_features(df: pd.DataFrame) -> pd.DataFrame:
+    """
+    Kalite ayrımı + uzun vadeli trend + spread feature'ları.
+    group_cols = [item_id, city, quality] → kalite farkı artık karışmıyor.
+    """
     if df.empty:
         return df
 
-    df = df.sort_values(["item_id", "city", "timestamp"]).copy()
+    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["is_weekend"] = (df["dayofweek"] >= 5).astype(int)
+    df["qual_code"] = df["quality"].astype(int)
 
-    group_cols = ["item_id", "city"]
+    # KRİTİK: kalite artık grup içinde
+    group_cols = ["item_id", "city", "quality"]
 
     df["log_price"] = np.log(df["avg_price"].replace(0, np.nan))
+
+    # Uzun vadeli 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)
 
-    for chg in [1, 6, 24]:
+    # Değişimler
+    for chg in [1, 6, 24, 168, 336]:
         df[f"chg_{chg}h"] = df.groupby(group_cols)["log_price"].shift(chg)
 
-    # ma_24h / lag_24h oranı (trend göstergesi)
+    # MA oranları
     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["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()
@@ -302,21 +346,66 @@ def build_features(df: pd.DataFrame) -> pd.DataFrame:
     )
     df["volume_ratio"] = df["item_count"] / df["volume_ma_24h"].replace(0, np.nan)
 
-    city_avg = df.groupby(["item_id", "timestamp"])["avg_price"].transform("mean")
+    # Şehir fiyat farkı (aynı item+quality+timestamp içinde)
+    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)
 
+    # 7g yüzdelik konum
     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)
 
+    # SPREAD feature'ları — prices_df'ten merge edilecek
+    # Şimdilik NaN, sonra enrich_spread_features ile doldurulacak
+
     df = _compute_forward_target(df)
     return df
 
 
+def enrich_spread_features(featured_df: pd.DataFrame, prices_df: pd.DataFrame) -> pd.DataFrame:
+    """
+    Anlık alış-satış spread'i feature olarak ekle.
+    prices_df'te kalite ayrımı varsa ona göre merge.
+    """
+    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)
+
+    prices["sell_price_min"] = pd.to_numeric(prices["sell_price_min"], errors="coerce").astype("float64")
+    prices["buy_price_max"] = pd.to_numeric(prices["buy_price_max"], 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
+    )
+
+    price_features = prices[["item_id", "city", "quality", "spread_pct", "buy_sell_ratio"]].drop_duplicates(
+        subset=["item_id", "city", "quality"]
+    )
+
+    result = featured_df.merge(price_features, on=["item_id", "city", "quality"], how="left")
+    result["spread_pct"] = result["spread_pct"].fillna(0.0)
+    result["buy_sell_ratio"] = result["buy_sell_ratio"].fillna(1.0)
+    return result
+
+
 def _compute_forward_target(df: pd.DataFrame) -> pd.DataFrame:
     if df.empty or "log_price" not in df.columns:
         df["target_log_return_24h"] = np.nan
@@ -324,8 +413,9 @@ def _compute_forward_target(df: pd.DataFrame) -> pd.DataFrame:
         return df
 
     df["target_log_return_24h"] = np.nan
+    group_cols = ["item_id", "city", "quality"]
 
-    for (item_id, city), g in df.groupby(["item_id", "city"]):
+    for keys, g in df.groupby(group_cols):
         if len(g) < 5:
             continue
 
@@ -355,17 +445,14 @@ def _compute_forward_target(df: pd.DataFrame) -> pd.DataFrame:
         target_log = merged["log_price_future"].values - merged["log_price_now"].values
         df.loc[merged["idx"].values, "target_log_return_24h"] = target_log
 
-    # 3 sınıf: 0=AŞAĞI, 1=SABİT, 2=YUKARI
     t = df["target_log_return_24h"]
-    df["target_class"] = np.where(t < CLASS_DOWN, 0,
-                            np.where(t > CLASS_UP, 2, 1))
+    df["target_class"] = np.where(t < CLASS_DOWN, 0, np.where(t > CLASS_UP, 2, 1))
     df.loc[t.isna(), "target_class"] = np.nan
-
     return df
 
 
 # ---------------------------------------------------------------------------
-# MODEL EĞİTİMİ — SINIFLANDIRMA
+# MODEL
 # ---------------------------------------------------------------------------
 
 
@@ -376,120 +463,109 @@ def prepare_model_data(featured_df: pd.DataFrame) -> Tuple[pd.DataFrame, pd.Seri
     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_class", "lag_24h_log"]).copy()
     df["target_class"] = df["target_class"].astype(int)
 
-    for col in ["chg_1h", "chg_6h", "chg_24h"]:
-        df[col] = df[col].fillna(0.0)
+    # Uzun pencereli feature'ları doldur (kısa pencereden)
+    for col in ["chg_1h", "chg_6h", "chg_24h", "chg_168h", "chg_336h"]:
+        if col in df.columns:
+            df[col] = df[col].fillna(0.0)
+
+    df["lag_168h_log"] = df["lag_168h_log"].fillna(df["lag_24h_log"])
+    df["lag_336h_log"] = df["lag_336h_log"].fillna(df["lag_168h_log"]).fillna(df["lag_24h_log"])
 
     df["rsi_14"] = df["rsi_14"].fillna(50.0)
     df["volatility_24h"] = df["volatility_24h"].fillna(0.0)
     df["volume_ratio"] = df["volume_ratio"].fillna(1.0)
     df["ma_24h_ratio"] = df["ma_24h_ratio"].fillna(0.0)
+    df["ma_168h_ratio"] = df["ma_168h_ratio"].fillna(df["ma_24h_ratio"]).fillna(0.0)
     df["city_price_deviation"] = df["city_price_deviation"].fillna(0.0)
+    df["spread_pct"] = df.get("spread_pct", pd.Series(0.0, index=df.index)).fillna(0.0)
+    df["buy_sell_ratio"] = df.get("buy_sell_ratio", pd.Series(1.0, index=df.index)).fillna(1.0)
 
     model_df = df.dropna(subset=FEATURE_COLS + ["target_class"]).copy()
 
     X = model_df[FEATURE_COLS].astype("float64")
     y = model_df["target_class"]
-    meta = model_df[["item_id", "city", "timestamp", "avg_price", "target_log_return_24h"]].copy()
-
+    meta = model_df[["item_id", "city", "quality", "timestamp", "avg_price", "target_log_return_24h"]].copy()
     return X, y, meta
 
 
 def train_global_model(X: pd.DataFrame, y: pd.Series) -> Optional[lgb.LGBMClassifier]:
     if len(X) < MIN_TRAIN_SAMPLES:
-        print(f"Yetersiz veri: {len(X)} < {MIN_TRAIN_SAMPLES}")
         return None
 
     class_counts = y.value_counts().to_dict()
-    print(f"[TANI] Sınıf dağılımı: {class_counts}")
-
-    if len(class_counts) < 3:
-        print(f"⚠️ Bazı sınıflar eksik. Daha fazla veri gerekli.")
+    print(f"[TANI] Sınıf: {class_counts}")
+    if len(class_counts) < 3 or min(class_counts.values()) < 10:
         return None
 
     split_idx = int(len(X) * 0.8)
     X_train, X_val = X.iloc[:split_idx], X.iloc[split_idx:]
     y_train, y_val = y.iloc[:split_idx], y.iloc[split_idx:]
 
-    # Overfit önleyici parametreler
     model = lgb.LGBMClassifier(
-        objective="multiclass",
-        num_class=3,
-        metric="multi_logloss",
+        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=200,
-        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,
+        num_leaves=15, max_depth=5, min_child_samples=50,
+        learning_rate=0.03, n_estimators=300,
+        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,
     )
 
-    callbacks = [
-        lgb.early_stopping(stopping_rounds=30, verbose=False),
-        lgb.log_evaluation(period=0),
-    ]
-
     model.fit(
         X_train, y_train,
         eval_set=[(X_val, y_val)],
-        eval_metric="multi_logloss",
-        callbacks=callbacks,
+        callbacks=[lgb.early_stopping(30, verbose=False), lgb.log_evaluation(0)],
     )
 
     val_preds = model.predict(X_val)
     val_acc = accuracy_score(y_val, val_preds)
     print(f"[TANI] val_accuracy={val_acc:.4f}")
-
     return model
 
 
-def predict_24h_returns(model: lgb.LGBMClassifier, latest_features: pd.DataFrame) -> pd.DataFrame:
+def predict_24h_returns(model, latest_features: pd.DataFrame) -> pd.DataFrame:
     if latest_features.empty or model is None:
         return pd.DataFrame()
 
     missing = [c for c in FEATURE_COLS if c not in latest_features.columns]
     if missing:
-        print(f"Eksik özellikler: {missing}")
         return pd.DataFrame()
 
     X_pred = latest_features.copy()
-
-    for col in ["chg_1h", "chg_6h", "chg_24h"]:
+    for col in ["chg_1h", "chg_6h", "chg_24h", "chg_168h", "chg_336h"]:
         if col in X_pred.columns:
             X_pred[col] = X_pred[col].fillna(0.0)
-
+    X_pred["lag_168h_log"] = X_pred["lag_168h_log"].fillna(X_pred["lag_24h_log"])
+    X_pred["lag_336h_log"] = X_pred["lag_336h_log"].fillna(X_pred["lag_168h_log"]).fillna(X_pred["lag_24h_log"])
     X_pred["rsi_14"] = X_pred["rsi_14"].fillna(50.0)
     X_pred["volatility_24h"] = X_pred["volatility_24h"].fillna(0.0)
     X_pred["volume_ratio"] = X_pred["volume_ratio"].fillna(1.0)
     X_pred["ma_24h_ratio"] = X_pred["ma_24h_ratio"].fillna(0.0)
+    X_pred["ma_168h_ratio"] = X_pred["ma_168h_ratio"].fillna(X_pred["ma_24h_ratio"]).fillna(0.0)
     X_pred["city_price_deviation"] = X_pred["city_price_deviation"].fillna(0.0)
+    X_pred["spread_pct"] = X_pred.get("spread_pct", pd.Series(0.0, index=X_pred.index)).fillna(0.0)
+    X_pred["buy_sell_ratio"] = X_pred.get("buy_sell_ratio", pd.Series(1.0, index=X_pred.index)).fillna(1.0)
 
     X_ready = X_pred[FEATURE_COLS].astype("float64").dropna()
     if X_ready.empty:
         return pd.DataFrame()
 
-    probs = model.predict_proba(X_ready)  # shape (n, 3)
+    probs = model.predict_proba(X_ready)
     pred_class = np.argmax(probs, axis=1)
-
-    # Beklenen log getiri (olasılık ağırlıklı)
     expected_log = probs[:, 0] * CLASS_DOWN + probs[:, 1] * 0.0 + probs[:, 2] * CLASS_UP
     clipped_log = np.clip(expected_log, CLASS_DOWN, CLASS_UP)
     pred_return_pct = (np.exp(clipped_log) - 1) * 100
 
-    keep_cols = ["item_id", "city", "avg_price", "item_count",
-                 "volatility_24h", "rsi_14", "volume_ratio",
-                 "price_pct_7d", "is_downtrend", "chg_6h", "chg_24h"]
+    keep_cols = ["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",
+                 "spread_pct", "buy_sell_ratio"]
     keep_cols = [c for c in keep_cols if c in X_pred.columns]
     result = X_pred.loc[X_ready.index, keep_cols].copy()
     result["pred_class"] = pred_class
@@ -500,18 +576,16 @@ def predict_24h_returns(model: lgb.LGBMClassifier, latest_features: pd.DataFrame
     result["predicted_return_pct"] = pred_return_pct
     result["predicted_price_24h"] = result["avg_price"] * np.exp(clipped_log)
     result["confidence"] = probs.max(axis=1)
-
     return result
 
 
 # ---------------------------------------------------------------------------
-# DİP ALIM SİNYALİ
+# DİP SİNYALİ
 # ---------------------------------------------------------------------------
 
 
 def compute_dip_signal(row: pd.Series) -> Tuple[str, str]:
-    reasons = []
-    passed = 0
+    reasons, passed = [], 0
 
     rsi = row.get("rsi_14", 50)
     if pd.notna(rsi) and rsi < DIP_RSI_MAX:
@@ -526,40 +600,39 @@ def compute_dip_signal(row: pd.Series) -> Tuple[str, str]:
     vr = row.get("volume_ratio", 1.0)
     if pd.notna(vr) and vr >= DIP_MIN_VOLUME_RATIO:
         passed += 1
-        reasons.append(f"Hacim×{vr:.1f}")
+        reasons.append(f"H×{vr:.1f}")
 
     pred_pct = row.get("predicted_return_pct", 0)
     if pd.notna(pred_pct) and pred_pct >= DIP_MIN_PREDICTED_PCT:
         passed += 1
-        reasons.append(f"Model={pred_pct:+.1f}%")
+        reasons.append(f"M={pred_pct:+.1f}%")
 
-    spread = row.get("spread", np.nan)
-    price = row.get("avg_price", 1)
-    if pd.notna(spread) and price > 0 and abs(spread) / price < DIP_MAX_SPREAD_PCT:
+    spread_pct = row.get("spread_pct", np.nan)
+    if pd.notna(spread_pct) and abs(spread_pct) < DIP_MAX_SPREAD_PCT:
         passed += 1
-        reasons.append(f"Spread={abs(spread)/price*100:.1f}%")
+        reasons.append(f"Sp={spread_pct*100:.1f}%")
 
     is_down = row.get("is_downtrend", 0)
     if not is_down or (pd.notna(pred_pct) and pred_pct > 2):
         passed += 1
-        reasons.append("Trend OK")
+        reasons.append("Trend✓")
 
     if passed >= 5:
-        signal = "🟢 GÜÇLÜ AL"
+        sig = "🟢 GÜÇLÜ AL"
     elif passed == 4:
-        signal = "🟡 ZAYIF AL"
+        sig = "🟡 ZAYIF AL"
     elif passed == 3 and pd.notna(rsi) and rsi < 45:
-        signal = "🔵 İZLE"
+        sig = "🔵 İZLE"
     elif is_down and pd.notna(pred_pct) and pred_pct < -2:
-        signal = "🔴 ALMA"
+        sig = "🔴 ALMA"
     else:
-        signal = "⚪ BEKLE"
+        sig = "⚪ BEKLE"
 
-    return signal, " · ".join(reasons) if reasons else "—"
+    return sig, " · ".join(reasons) if reasons else "—"
 
 
 # ---------------------------------------------------------------------------
-# WALK-FORWARD BACKTEST
+# BACKTEST
 # ---------------------------------------------------------------------------
 
 
@@ -575,10 +648,9 @@ def walk_forward_backtest(featured_df: pd.DataFrame, n_splits: int = 3) -> Dict:
 
     test_size = len(unique_times) // (n_splits + 1)
     if test_size < 5:
-        return {"error": f"Test boyutu çok küçük ({test_size} < 5)."}
+        return {"error": "Test boyutu çok küçük."}
 
-    results = []
-    all_predictions = []
+    results, all_predictions = [], []
 
     for i in range(n_splits):
         test_start_idx = test_size * (i + 1) + 24
@@ -601,10 +673,7 @@ def walk_forward_backtest(featured_df: pd.DataFrame, n_splits: int = 3) -> Dict:
         X_train, y_train, _ = prepare_model_data(train_df)
         X_test, y_test, meta_test = prepare_model_data(test_df)
 
-        if len(X_train) < 30 or len(X_test) < 3:
-            continue
-
-        if y_train.nunique() < 3:
+        if len(X_train) < 30 or len(X_test) < 3 or y_train.nunique() < 3:
             continue
 
         model = lgb.LGBMClassifier(
@@ -618,17 +687,14 @@ def walk_forward_backtest(featured_df: pd.DataFrame, n_splits: int = 3) -> Dict:
 
         preds_class = model.predict(X_test)
         probs = model.predict_proba(X_test)
-        expected_log = probs[:, 0] * CLASS_DOWN + probs[:, 1] * 0.0 + probs[:, 2] * CLASS_UP
 
         accuracy = accuracy_score(y_test, preds_class)
 
-        # Direction accuracy: sadece UP vs DOWN (flat hariç)
         y_dir = np.where(y_test == 2, 1, np.where(y_test == 0, 0, -1))
         p_dir = np.where(preds_class == 2, 1, np.where(preds_class == 0, 0, -1))
         mask = (y_dir >= 0) & (p_dir >= 0)
         direction_acc = float(np.mean(y_dir[mask] == p_dir[mask])) if mask.sum() > 0 else 0.5
 
-        # Baseline: hep "flat" tahmin
         baseline_acc = float((y_test == 1).mean())
 
         results.append({
@@ -643,32 +709,33 @@ def walk_forward_backtest(featured_df: pd.DataFrame, n_splits: int = 3) -> Dict:
 
         test_meta = meta_test.copy()
         test_meta["predicted_class"] = preds_class
-        test_meta["expected_log_return"] = expected_log
+        test_meta["prob_up"] = probs[:, 2]
         all_predictions.append(test_meta)
 
     if not results:
         return {"error": "Backtest tamamlanamadı."}
 
-    # Simülasyon: sadece UP tahmini + güçlü sinyalleri al
-    simulation = {"total_trades": 0, "win_rate_pct": 0.0, "avg_net_return_pct": 0.0, "profitable_trades": 0}
+    simulation = {"total_trades": 0, "win_rate_pct": 0.0, "avg_net_return_pct": 0.0,
+                  "profitable_trades": 0, "avg_confidence_pct": 0.0}
     if all_predictions:
         sim_df = pd.concat(all_predictions).dropna(subset=["target_log_return_24h"])
-        buy_signals = sim_df[sim_df["predicted_class"] == 2].copy()
-        if len(buy_signals) > 0:
-            buy_signals["net_return"] = buy_signals["target_log_return_24h"] - TOTAL_TRADE_COST
-            win_rate = float((buy_signals["net_return"] > 0).mean() * 100)
+        # Sadece YUKARI tahmini + yüksek güven
+        buys = sim_df[(sim_df["predicted_class"] == 2) & (sim_df["prob_up"] > 0.6)].copy()
+        if len(buys) > 0:
+            buys["net_return"] = buys["target_log_return_24h"] - TOTAL_TRADE_COST
             simulation = {
-                "total_trades": int(len(buy_signals)),
-                "win_rate_pct": round(win_rate, 2),
-                "avg_net_return_pct": round(float(buy_signals["net_return"].mean() * 100), 4),
-                "profitable_trades": int((buy_signals["net_return"] > 0).sum()),
+                "total_trades": int(len(buys)),
+                "win_rate_pct": round(float((buys["net_return"] > 0).mean() * 100), 2),
+                "avg_net_return_pct": round(float(buys["net_return"].mean() * 100), 4),
+                "profitable_trades": int((buys["net_return"] > 0).sum()),
+                "avg_confidence_pct": round(float(buys["prob_up"].mean() * 100), 1),
             }
 
     return {"results": results, "simulation": simulation, "n_splits_completed": len(results)}
 
 
 # ---------------------------------------------------------------------------
-# VERİ HATTI
+# PIPELINE
 # ---------------------------------------------------------------------------
 
 
@@ -679,7 +746,7 @@ class DataPipeline:
         self.featured_df = pd.DataFrame()
         self.model = None
         self.last_update = None
-        self.status_message = "Veri yüklenmedi. 'Verileri Yenile' butonuna basın."
+        self.status_message = "Veri yüklenmedi."
         self._backtest_cache = None
         self._diagnostics = {}
 
@@ -687,14 +754,14 @@ class DataPipeline:
             try:
                 self.model = joblib.load(MODEL_PATH)
                 self.status_message = "Kayıtlı model yüklendi."
-            except Exception as e:
-                print(f"Model yükleme hatası: {e}")
+            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..."
+        self.status_message = "Public API'den veri çekiliyor (5 kalite)..."
         ok, msg = check_api_health()
         if not ok:
             self.status_message = f"API erişilemiyor: {msg}"
@@ -704,7 +771,7 @@ class DataPipeline:
             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 bağlantı hatası: {e}"
+            self.status_message = f"API hatası: {e}"
             return
 
         if hist.empty:
@@ -713,12 +780,14 @@ class DataPipeline:
 
         self.history_df = clean_market_data(hist)
         self.prices_df = prices
-        self.status_message = f"✓ {len(self.history_df)} satır tarihsel, {len(self.prices_df)} anlık."
+        n_qualities = self.history_df["quality"].nunique() if "quality" in self.history_df.columns else 1
+        self.status_message = f"✓ {len(self.history_df)} satır tarihsel ({n_qualities} 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._backtest_cache = None
         self._update_diagnostics()
 
@@ -727,33 +796,29 @@ class DataPipeline:
         if df.empty:
             self._diagnostics = {}
             return
-        n_total = len(df)
         n_with_target = int(df["target_class"].notna().sum()) if "target_class" in df.columns else 0
-        class_dist = {}
-        if n_with_target > 0:
-            class_dist = df["target_class"].value_counts().to_dict()
+        class_dist = df["target_class"].value_counts().to_dict() if n_with_target > 0 else {}
         self._diagnostics = {
-            "n_total": n_total,
+            "n_total": len(df),
             "n_with_target": n_with_target,
             "class_dist": class_dist,
+            "n_qualities": int(df["quality"].nunique()) if "quality" in df.columns else 1,
         }
-        print(f"[TANI] total={n_total}, hedefli={n_with_target}, sınıf={class_dist}")
+        print(f"[TANI] total={len(df)}, hedefli={n_with_target}, sınıf={class_dist}")
 
     def train_model(self):
         if self.featured_df.empty:
-            self.status_message = "Önce veri çekmelisiniz."
+            self.status_message = "Önce veri çekin."
             return False
 
         diag = self._diagnostics or {}
-        n_with_target = diag.get("n_with_target", 0)
-
-        if n_with_target < MIN_TRAIN_SAMPLES:
-            self.status_message = f"Yetersiz örnek: {n_with_target} < {MIN_TRAIN_SAMPLES}"
+        if diag.get("n_with_target", 0) < MIN_TRAIN_SAMPLES:
+            self.status_message = f"Yetersiz örnek: {diag.get('n_with_target', 0)}"
             return False
 
         class_dist = diag.get("class_dist", {})
         if len(class_dist) < 3 or min(class_dist.values()) < 10:
-            self.status_message = f"Sınıf dağılımı dengesiz: {class_dist}. Daha fazla veri gerekli."
+            self.status_message = f"Sınıf dengesiz: {class_dist}"
             return False
 
         X, y, _ = prepare_model_data(self.featured_df)
@@ -766,7 +831,7 @@ class DataPipeline:
             self.status_message = "Model eğitimi başarısız."
             return False
 
-        self.status_message = f"✓ Model eğitildi (sınıflandırma, {len(X)} örnek)."
+        self.status_message = f"✓ Model eğitildi ({len(X)} örnek)."
 
         if _HAS_JOBLIB:
             try:
@@ -781,32 +846,38 @@ class DataPipeline:
         if self.featured_df.empty or self.model is None:
             return pd.DataFrame()
 
-        latest = self.featured_df.sort_values("timestamp").groupby(["item_id", "city"]).tail(1).copy()
+        latest = self.featured_df.sort_values("timestamp").groupby(
+            ["item_id", "city", "quality"]
+        ).tail(1).copy()
+
         latest["item_code"] = latest["item_id"].astype("category").cat.codes
         latest["city_code"] = latest["city"].astype("category").cat.codes
+        if "qual_code" not in latest.columns:
+            latest["qual_code"] = latest.get("quality", 1)
 
         for col in FEATURE_COLS:
             if col not in latest.columns:
                 latest[col] = 0.0
 
         preds = predict_24h_returns(self.model, latest)
-
-        if not preds.empty and not self.prices_df.empty:
-            price_info = self.prices_df[["item_id", "city", "sell_price_min", "buy_price_max"]].copy()
-            price_info["sell_price_min"] = pd.to_numeric(price_info["sell_price_min"], errors="coerce").astype("float64")
-            price_info["buy_price_max"] = pd.to_numeric(price_info["buy_price_max"], errors="coerce").astype("float64")
-            preds = preds.merge(price_info, on=["item_id", "city"], how="left")
+        if preds.empty:
+            return preds
+
+        if not self.prices_df.empty:
+            price_info = self.prices_df[["item_id", "city", "quality",
+                                          "sell_price_min", "buy_price_max"]].copy()
+            for col in ["sell_price_min", "buy_price_max"]:
+                price_info[col] = pd.to_numeric(price_info[col], errors="coerce").astype("float64")
+            preds = preds.merge(price_info, on=["item_id", "city", "quality"], how="left")
             preds["spread"] = preds["sell_price_min"] - preds["buy_price_max"]
         else:
             preds["spread"] = np.nan
 
-        total_cost = SETUP_FEE_RATE + TRANSACTION_TAX_RATE
-        preds["net_return_pct"] = preds["predicted_return_pct"] - (total_cost * 100)
+        preds["net_return_pct"] = preds["predicted_return_pct"] - (TOTAL_TRADE_COST * 100)
 
         dip_signals = preds.apply(compute_dip_signal, axis=1, result_type="expand")
         preds["Dip Sinyali"] = dip_signals[0]
         preds["Sinyal Detayı"] = dip_signals[1]
-
         return preds
 
     def get_backtest(self):
@@ -832,18 +903,18 @@ def get_dashboard_metrics():
         })
 
     df = pipeline.featured_df
-    class_dist = diag.get("class_dist", {})
+    cd = diag.get("class_dist", {})
     metrics = {
         "Veri Kaynağı": "Public AODP API (europe)",
-        "Görev Tipi": "3-sınıf sınıflandırma (AŞAĞI/SABİT/YUKARI)",
+        "Görev": "3-sınıf sınıflandırma",
+        "Kalite Sayısı": diag.get("n_qualities", 1),
         "Toplam Gözlem": len(df),
         "Hedefli Satır": diag.get("n_with_target", 0),
-        "Sınıf AŞAĞI": class_dist.get(0, 0),
-        "Sınıf SABİT": class_dist.get(1, 0),
-        "Sınıf YUKARI": class_dist.get(2, 0),
+        "Sınıf AŞAĞI": cd.get(0, 0),
+        "Sınıf SABİT": cd.get(1, 0),
+        "Sınıf YUKARI": cd.get(2, 0),
         "Tarih Aralığı": f"{df['timestamp'].min().date()} - {df['timestamp'].max().date()}",
-        "Model Durumu": "Eğitildi" if pipeline.model else "Eğitilmedi",
-        "Sınıf Sınırları": f"±%{CLASS_UP*100:.0f}",
+        "Model": "Eğitildi" if pipeline.model else "Eğitilmedi",
         "Son Güncelleme": pipeline.last_update.strftime("%Y-%m-%d %H:%M") if pipeline.last_update else "—",
     }
     return pd.DataFrame(list(metrics.items()), columns=["Metrik", "Değer"])
@@ -853,29 +924,35 @@ def get_analysis_table():
     if pipeline.featured_df.empty:
         return pd.DataFrame()
 
-    latest = pipeline.featured_df.sort_values("timestamp").groupby(["item_id", "city"]).tail(1).copy()
+    latest = pipeline.featured_df.sort_values("timestamp").groupby(
+        ["item_id", "city", "quality"]
+    ).tail(1).copy()
 
     if not pipeline.prices_df.empty:
-        price_info = pipeline.prices_df[["item_id", "city", "sell_price_min", "buy_price_max"]].copy()
-        price_info["sell_price_min"] = pd.to_numeric(price_info["sell_price_min"], errors="coerce").astype("float64")
-        price_info["buy_price_max"] = pd.to_numeric(price_info["buy_price_max"], errors="coerce").astype("float64")
-        latest = latest.merge(price_info, on=["item_id", "city"], how="left")
+        price_info = pipeline.prices_df[["item_id", "city", "quality",
+                                          "sell_price_min", "buy_price_max"]].copy()
+        for col in ["sell_price_min", "buy_price_max"]:
+            price_info[col] = pd.to_numeric(price_info[col], errors="coerce").astype("float64")
+        latest = latest.merge(price_info, 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["Mevcut 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 Konum %"] = (latest["price_pct_7d"] * 100).round(0)
-    latest["Trend"] = np.where(latest["is_downtrend"] == 1, "↓ Düşüş", "→ Yatay/Yukarı")
+    latest["7g%"] = (latest["price_pct_7d"] * 100).round(0)
+    latest["Trend"] = np.where(latest["is_downtrend"] == 1, "↓", "→")
     latest["Likidite"] = pd.cut(latest["item_count"], bins=[-1, 10, 50, 200, np.inf],
                                  labels=["Düşük", "Orta", "İyi", "Yüksek"]).astype(str)
 
-    return latest[["Ürün", "Şehir", "Mevcut Fiyat", "Hacim", "Spread", "RSI", "7g Konum %", "Trend", "Likidite"]].sort_values("Hacim", ascending=False).head(100)
+    cols = ["Ürün", "Kalite", "Şehir", "Mevcut Fiyat", "Hacim", "Spread",
+            "RSI", "7g%", "Trend", "Likidite"]
+    return latest[cols].sort_values("Hacim", ascending=False).head(100)
 
 
 def get_prediction_table():
@@ -885,91 +962,96 @@ def get_prediction_table():
 
     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 Fiyat"] = preds["avg_price"].round(0)
-    preds["Tahmin Sınıfı"] = preds["pred_class"].map({0: "AŞAĞI", 1: "SABİT", 2: "YUKARI"})
-    preds["P(Aşağı)"] = (preds["prob_down"] * 100).round(0).astype(int).astype(str) + "%"
-    preds["P(Sabit)"] = (preds["prob_flat"] * 100).round(0).astype(int).astype(str) + "%"
-    preds["P(Yukarı)"] = (preds["prob_up"] * 100).round(0).astype(int).astype(str) + "%"
+    preds["Tahmin"] = 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üvenilirlik"] = (preds["confidence"] * 100).round(0).astype(int).astype(str) + "%"
     preds["Tahmini Değişim %"] = preds["predicted_return_pct"].round(2)
     preds["Net Getiri %"] = preds["net_return_pct"].round(2)
 
-    cols = ["Ürün", "Şehir", "Mevcut Fiyat", "Tahmin Sınıfı", "P(Aşağı)", "P(Sabit)",
-            "P(Yukarı)", "Güvenilirlik", "Tahmini Değişim %", "Net Getiri %", "Dip Sinyali"]
+    cols = ["Ürün", "Kalite", "Şehir", "Mevcut Fiyat", "Tahmin",
+            "P(↑)", "Güvenilirlik", "Tahmini Değişim %", "Net Getiri %", "Dip Sinyali"]
     return preds[cols].sort_values("Güvenilirlik", ascending=False)
 
 
 def get_dip_alim_table():
     preds = pipeline.get_latest_predictions()
     if preds.empty:
-        return pd.DataFrame({"Bilgi": ["Tahmin üretilemedi."]})
-
-    dip_only = preds[preds["Dip Sinyali"].isin(["🟢 GÜÇLÜ AL", "🟡 ZAYIF AL", "🔵 İZLE"])].copy()
+        return pd.DataFrame({"Bilgi": ["Tahmin yok."]})
 
-    if dip_only.empty:
+    dip = preds[preds["Dip Sinyali"].isin(["🟢 GÜÇLÜ AL", "🟡 ZAYIF AL", "🔵 İZLE"])].copy()
+    if dip.empty:
         return pd.DataFrame({"Bilgi": ["Şu anda dip alım sinyali yok."]})
 
-    signal_order = {"🟢 GÜÇLÜ AL": 0, "🟡 ZAYIF AL": 1, "🔵 İZLE": 2}
-    dip_only["_sig_rank"] = dip_only["Dip Sinyali"].map(signal_order)
+    order = {"🟢 GÜÇLÜ AL": 0, "🟡 ZAYIF AL": 1, "🔵 İZLE": 2}
+    dip["_r"] = dip["Dip Sinyali"].map(order)
 
-    dip_only["Ürün"] = dip_only["item_id"].apply(item_display_name)
-    dip_only["Şehir"] = dip_only["city"]
-    dip_only["Mevcut Fiyat"] = dip_only["avg_price"].round(0)
-    dip_only["RSI"] = dip_only["rsi_14"].round(0)
-    dip_only["7g Konum %"] = (dip_only["price_pct_7d"] * 100).round(0)
-    dip_only["Trend"] = np.where(dip_only["is_downtrend"] == 1, "↓", "→")
-    dip_only["Hacim×Ort"] = dip_only["volume_ratio"].round(1)
-    dip_only["Tahmin Sınıfı"] = dip_only["pred_class"].map({0: "AŞAĞI", 1: "SABİT", 2: "YUKARI"})
-    dip_only["P(Yukarı)"] = (dip_only["prob_up"] * 100).round(0).astype(int).astype(str) + "%"
-    dip_only["Net Getiri %"] = dip_only["net_return_pct"].round(2)
+    dip["Ürün"] = dip["item_id"].apply(item_display_name)
+    dip["Kalite"] = dip["quality"].apply(quality_name)
+    dip["Şehir"] = dip["city"]
+    dip["Mevcut Fiyat"] = 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 Getiri %"] = dip["net_return_pct"].round(2)
 
-    dip_only = dip_only.sort_values(["_sig_rank", "confidence"], ascending=[True, False])
-
-    cols = ["Dip Sinyali", "Ürün", "Şehir", "Mevcut Fiyat", "RSI", "7g Konum %",
-            "Trend", "Hacim×Ort", "Tahmin Sınıfı", "P(Yukarı)", "Net Getiri %", "Sinyal Detayı"]
-    return dip_only[cols].head(50)
+    dip = dip.sort_values(["_r", "confidence"], ascending=[True, False])
+    cols = ["Dip Sinyali", "Ürün", "Kalite", "Şehir", "Mevcut Fiyat",
+            "RSI", "7g%", "P(↑)", "Net Getiri %", "Sinyal Detayı"]
+    return dip[cols].head(50)
 
 
 def get_arbitrage_table():
     if pipeline.prices_df.empty:
-        return pd.DataFrame({"Bilgi": ["Anlık fiyat yok."]})
+        return pd.DataFrame({"Bilgi": ["Fiyat yok."]})
 
     prices = pipeline.prices_df.copy()
-    prices["sell_price_min"] = pd.to_numeric(prices["sell_price_min"], errors="coerce").astype("float64")
-    prices["buy_price_max"] = pd.to_numeric(prices["buy_price_max"], errors="coerce").astype("float64")
+    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": ["Geçerli fiyat yok."]})
 
-    buy = prices.loc[prices.groupby("item_id")["sell_price_min"].idxmin()][["item_id", "city", "sell_price_min"]]
-    buy.columns = ["item_id", "buy_city", "buy_price"]
-    sell = prices.loc[prices.groupby("item_id")["buy_price_max"].idxmax()][["item_id", "city", "buy_price_max"]]
-    sell.columns = ["item_id", "sell_city", "sell_price"]
+    # Kalite bazlı arbitraj — T4.0 ile T4.2 karıştırılmıyor
+    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")
+    arb = buy.merge(sell, on=["item_id", "quality"])
     arb = arb[arb["sell_price"] > arb["buy_price"]].copy()
     if arb.empty:
-        return pd.DataFrame({"Bilgi": ["Kârlı arbitraj yok."]})
+        return pd.DataFrame({"Bilgi": ["Arbitraj yok."]})
 
-    arb["brüt_kâr"] = arb["sell_price"] - arb["buy_price"]
-    arb["toplam_maliyet"] = arb["buy_price"] * SETUP_FEE_RATE + arb["sell_price"] * (SETUP_FEE_RATE + TRANSACTION_TAX_RATE)
-    arb["net_kâr"] = arb["brüt_kâr"] - arb["toplam_maliyet"]
-    arb["kâr_marjı_%"] = (arb["net_kâr"] / arb["buy_price"]) * 100
-    arb = arb[arb["net_kâr"] > 0].sort_values("kâr_marjı_%", ascending=False)
+    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_kâr"] = arb["brüt"] - arb["maliyet"]
+    arb["marj_%"] = (arb["net_kâr"] / arb["buy_price"]) * 100
+    arb = arb[arb["net_kâr"] > 0].sort_values("marj_%", ascending=False)
 
     if arb.empty:
-        return pd.DataFrame({"Bilgi": ["Maliyetler sonrası kârlı arbitraj yok."]})
+        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ış Şehri"] = arb["buy_city"]
     arb["Satış Şehri"] = arb["sell_city"]
-    arb["Alış Fiyatı"] = arb["buy_price"].round(0)
-    arb["Satış Fiyatı"] = arb["sell_price"].round(0)
+    arb["Alış"] = arb["buy_price"].round(0)
+    arb["Satış"] = arb["sell_price"].round(0)
     arb["Net Kâr"] = arb["net_kâr"].round(0)
-    arb["Kâr Marjı %"] = arb["kâr_marjı_%"].round(1)
+    arb["Marj %"] = arb["marj_%"].round(1)
 
-    return arb[["Ürün", "Alış Şehri", "Satış Şehri", "Alış Fiyatı", "Satış Fiyatı", "Net Kâr", "Kâr Marjı %"]].head(50)
+    cols = ["Ürün", "Kalite", "Alış Şehri", "Satış Şehri", "Alış", "Satış", "Net Kâr", "Marj %"]
+    return arb[cols].head(50)
 
 
 def get_model_performance_plot():
@@ -981,7 +1063,7 @@ def get_model_performance_plot():
             "Önem": pipeline.model.feature_importances_,
         }).sort_values("Önem", ascending=True).tail(20)
         fig = px.bar(df_imp, x="Önem", y="Özellik", orientation="h",
-                     title="Feature Importance (Top 20)", template="plotly_dark")
+                     title="Feature Importance", template="plotly_dark")
         fig.update_layout(height=600)
         return fig
     except Exception as e:
@@ -992,19 +1074,18 @@ def get_backtest_outputs():
     bt = pipeline.get_backtest()
     if "error" in bt:
         return (pd.DataFrame({"Bilgi": [bt["error"]]}),
-                go.Figure().update_layout(title="Backtest hatası", template="plotly_dark"),
+                go.Figure().update_layout(title="Hata", template="plotly_dark"),
                 pd.DataFrame())
 
-    results_df = pd.DataFrame(bt["results"])
-
+    rdf = pd.DataFrame(bt["results"])
     fig = go.Figure()
-    fig.add_trace(go.Bar(name="Model Accuracy", x=results_df["split"], y=results_df["accuracy"], marker_color="cyan"))
-    fig.add_trace(go.Bar(name="Baseline (Flat)", x=results_df["split"], y=results_df["baseline_accuracy"], marker_color="gray"))
-    fig.update_layout(title="Walk-Forward: Accuracy vs Baseline", xaxis_title="Split",
+    fig.add_trace(go.Bar(name="Model Acc", x=rdf["split"], y=rdf["accuracy"], marker_color="cyan"))
+    fig.add_trace(go.Bar(name="Baseline", x=rdf["split"], y=rdf["baseline_accuracy"], marker_color="gray"))
+    fig.update_layout(title="Accuracy vs Baseline", xaxis_title="Split",
                       yaxis_title="Accuracy", barmode="group", template="plotly_dark")
 
-    sim_df = pd.DataFrame([bt["simulation"]]) if bt.get("simulation") else pd.DataFrame()
-    return results_df, fig, sim_df
+    sim = pd.DataFrame([bt["simulation"]]) if bt.get("simulation") else pd.DataFrame()
+    return rdf, fig, sim
 
 
 def list_csv_files() -> pd.DataFrame:
@@ -1038,7 +1119,7 @@ def refresh_data_ui():
         bt_table, bt_fig, sim_table = get_backtest_outputs()
     except Exception:
         bt_table, sim_table = pd.DataFrame(), pd.DataFrame()
-        bt_fig = go.Figure().update_layout(title="Backtest hatası", template="plotly_dark")
+        bt_fig = go.Figure().update_layout(title="Hata", template="plotly_dark")
 
     def _safe(fn, default):
         try:
@@ -1069,7 +1150,7 @@ def initial_load():
     return (
         _safe(get_dashboard_metrics, pd.DataFrame({"Metrik": ["Durum"], "Değer": ["Hazır"]})),
         pd.DataFrame(), pd.DataFrame(), pd.DataFrame(), pd.DataFrame(),
-        go.Figure().update_layout(title="Yenile butonuna basın", template="plotly_dark"),
+        go.Figure().update_layout(title="Yenile", template="plotly_dark"),
         pd.DataFrame(),
         go.Figure().update_layout(title="Veri gerekli", template="plotly_dark"),
         pd.DataFrame(),
@@ -1078,7 +1159,7 @@ def initial_load():
 
 
 # ---------------------------------------------------------------------------
-# GRADIO ARAYÜZÜ
+# GRADIO
 # ---------------------------------------------------------------------------
 
 
@@ -1086,11 +1167,11 @@ with gr.Blocks(title="GOSHAWK ALBION MARKET AI", theme=gr.themes.Soft(primary_hu
 
     gr.Markdown(
         """
-        # 🦅 GOSHAWK ALBION MARKET AI
-        **Sınıflandırma tabanlı sürüm** | Avrupa Sunucusu
+        # 🦅 GOSHAWK ALBION MARKET AI — v2.0
+        **Kalite ayrımı + uzun vadeli trend + spread feature'ları** | Avrupa Sunucusu
         *LightGBM 3-sınıf sınıflandırma: AŞAĞI / SABİT / YUKARI*
 
-        **⚠️ Risk Uyarısı:** Bu uygulama yatırım tavsiyesi değildir. Model tahminleri belirsizlik içerir.
+        **⚠️ Risk Uyarısı:** Yatırım tavsiyesi değildir.
         """
     )
 
@@ -1100,21 +1181,21 @@ with gr.Blocks(title="GOSHAWK ALBION MARKET AI", theme=gr.themes.Soft(primary_hu
 
     with gr.Tabs():
         with gr.TabItem("📊 Dashboard"):
-            dashboard_table = gr.Dataframe(label="Özet & Teşhis", interactive=False, wrap=True)
+            dashboard_table = gr.Dataframe(label="Özet", interactive=False, wrap=True)
             gr.Markdown(
-                "### Sınıflandırma Görevi\n"
-                "MAE yerine **accuracy** kullanılır. Model 3 sınıf tahmin eder:\n"
-                f"- **AŞAĞI** (log < {CLASS_DOWN:.2f}, ≈ %{np.exp(CLASS_DOWN)*100-100:.0f}'den fazla düşüş)\n"
-                "- **SABİT** (arada)\n"
-                f"- **YUKARI** (log > {CLASS_UP:.2f}, ≈ %{np.exp(CLASS_UP)*100-100:.0f}'den fazla artış)\n\n"
-                "### Backtest Metrikleri\n"
-                "- **Accuracy:** Genel doğruluk (3 sınıf)\n"
-                "- **Direction Accuracy:** Sadece AŞAĞI vs YUKARI (SABİT hariç)\n"
-                "- **Baseline Accuracy:** Hep SABİT tahmin etmenin doğruluğu\n"
-                "- **Accuracy Lift:** Modelin baseline'dan farkı (%)\n\n"
+                "### v2.0 Yenilikleri\n"
+                "- **Kalite ayrımı:** T4.0, T4.1, T4.2 ayrı ürün olarak işlenir\n"
+                "- **7/14 günlük trend:** `lag_168h`, `lag_336h`, `chg_168h`, `chg_336h`\n"
+                "- **Spread feature:** Alış-satış farkı modele girdi\n"
+                "- **Arbitraj:** Kalite bazlı, T4.0 ile T4.2 karışmaz\n"
+                "- **7g yüzdelik konum:** Dip noktası daha net\n\n"
+                "### Sınıflar\n"
+                f"- AŞAĞI: log < {CLASS_DOWN:.2f}\n"
+                f"- SABİT: arada\n"
+                f"- YUKARI: log > {CLASS_UP:.2f}\n\n"
                 "### Riskler\n"
-                "- Sınıf dağılımı dengesizse accuracy yanıltıcı olabilir\n"
-                "- Direction accuracy'ye bakmak daha güvenilir"
+                "- Kalite/enchant hâlâ sınırlı\n"
+                "- Overfit kontrolü yapın"
             )
 
         with gr.TabItem("🎯 DİP ALIM"):
@@ -1127,22 +1208,26 @@ with gr.Blocks(title="GOSHAWK ALBION MARKET AI", theme=gr.themes.Soft(primary_hu
             analysis_table = gr.Dataframe(label="Ürün Analizi", interactive=False)
 
         with gr.TabItem("🚚 Arbitraj"):
-            arbitrage_table = gr.Dataframe(label="Arbitraj", interactive=False)
+            arbitrage_table = gr.Dataframe(label="Arbitraj (Kalite Bazlı)", interactive=False)
+            gr.Markdown(
+                "*T4.0 Normal ile T4.2 Outstanding ayrı hesaplanır. "
+                "Thetford'daki ucuz T4.0 Cape, başka şehirde pahalıysa burada görünür.*"
+            )
 
         with gr.TabItem("📈 Model"):
             performance_plot = gr.Plot(label="Feature Importance")
 
         with gr.TabItem("🧪 Backtest"):
             backtest_table = gr.Dataframe(label="Split Sonuçları", interactive=False)
-            backtest_plot = gr.Plot(label="Accuracy Karşılaştırması")
+            backtest_plot = gr.Plot(label="Accuracy vs Baseline")
             simulation_table = gr.Dataframe(label="Simülasyon", interactive=False)
 
         with gr.TabItem("🗄️ Veri"):
             gr.Markdown(
-                "**API:** `europe.albion-online-data.com/api/v2`\n"
-                "**Görev:** 3-sınıf sınıflandırma\n"
-                f"**Sınıf Sınırları:** ±%{CLASS_UP*100:.0f}\n"
-                f"**Maliyet:** %{(SETUP_FEE_RATE+TRANSACTION_TAX_RATE)*100:.1f}"
+                "**API:** europe.albion-online-data.com\n"
+                "**Kaliteler:** 1-5 (Normal→Masterpiece)\n"
+                f"**Maliyet:** %{TOTAL_TRADE_COST*100:.1f}\n"
+                f"**Sınıf sınırı:** ±%{CLASS_UP*100:.0f}"
             )
             csv_files = gr.Dataframe(label="CSV Dosyaları", interactive=False,
                                      headers=["Dosya", "Boyut (KB)", "Son Değişiklik"])