Delete app.py

app.py

@@ -1,600 +0,0 @@
-import gradio as gr
-import numpy as np
-import pandas as pd
-from datetime import datetime
-import random
-from collections import defaultdict
-import math
-import os
-import traceback
-import json
-from fastapi import FastAPI, Request
-from gradio.routes import App
-
-# ==================== কনফিগারেশন ====================
-CONFIG = {
-    "HISTORY_LIMIT": 1000,
-    "PINK_THRESHOLD": 3.0,
-    "BIG_PINK_THRESHOLD": 5.0,
-    "MAX_PREDICTION": 10000.0,  # সর্বোচ্চ প্রেডিকশন সীমা (খুব বড় করা হয়েছে)
-}
-
-# ==================== ডেটা লোড ও টাইম-ভিত্তিক পরিসংখ্যান ====================
-TIME_STATS = None
-
-def load_time_statistics():
-    global TIME_STATS
-    try:
-        # ডেটা ফাইলের পাথ
-        data_path = 'data/aviator_Rounds_history_scrp.xlsx'
-        if os.path.exists(data_path):
-            df = pd.read_excel(data_path, sheet_name='scraping rounds crash')
-            df = df[['ROUNDS', 'TIME ROUND']].dropna()
-            df['multiplier'] = pd.to_numeric(df['ROUNDS'], errors='coerce')
-            df = df.dropna()
-            df['hour'] = pd.to_datetime(df['TIME ROUND'], format='%H:%M').dt.hour
-            
-            stats = df.groupby('hour')['multiplier'].agg(['mean', 'std', 'count']).to_dict('index')
-            for h in range(24):
-                if h not in stats:
-                    stats[h] = {'mean': 1.8, 'std': 1.0, 'count': 0}
-            TIME_STATS = stats
-            print(f"✅ সময় পরিসংখ্যান লোড হয়েছে। মোট রেকর্ড: {len(df)}")
-        else:
-            print("⚠️ এক্সেল ফাইল পাওয়া যায়নি। ডিফল্ট পরিসংখ্যান ব্যবহার করা হবে।")
-            TIME_STATS = {h: {'mean': 1.8, 'std': 1.0, 'count': 100} for h in range(24)}
-    except Exception as e:
-        print(f"ডেটা লোড করতে সমস্যা: {e}")
-        TIME_STATS = {h: {'mean': 1.8, 'std': 1.0, 'count': 100} for h in range(24)}
-
-load_time_statistics()
-
-# ==================== স্ট্যাটিস্টিক্যাল মডেল V1-V5 ====================
-
-class StatisticalModelV1:
-    """V1: বেসিক স্ট্যাটিস্টিক্যাল + আউটলায়ার রিমুভাল"""
-    def predict(self, history):
-        recent = history[:15]
-        if len(recent) < 3:
-            return {'prediction': 1.5, 'confidence': 0.3}
-        
-        # আউটলায়ার রিমুভাল (IQR)
-        q1, q3 = np.percentile(recent, [25, 75])
-        iqr = q3 - q1
-        filtered = [x for x in recent if (q1 - 1.5*iqr) <= x <= (q3 + 1.5*iqr)]
-        if len(filtered) < 3:
-            filtered = recent
-        
-        # ওয়েটেড ট্রেন্ড
-        x = np.arange(len(filtered))
-        weights = np.linspace(1.5, 0.5, len(filtered))
-        weights /= weights.sum()
-        
-        weighted_mean_x = np.average(x, weights=weights)
-        weighted_mean_y = np.average(filtered, weights=weights)
-        
-        numerator = np.sum(weights * (x - weighted_mean_x) * (filtered - weighted_mean_y))
-        denominator = np.sum(weights * (x - weighted_mean_x)**2)
-        trend = numerator / denominator if denominator != 0 else 0
-        
-        prediction = np.median(filtered) + trend * 1.5
-        
-        # কনফিডেন্স
-        cv = np.std(filtered) / (np.mean(filtered) + 0.1)
-        confidence = min(0.85, 0.5 + len(filtered)/len(recent)*0.3 - cv*0.2)
-        
-        return {'prediction': float(prediction), 'confidence': float(confidence)}
-
-class StatisticalModelV2:
-    """V2: মাল্টি-টাইমফ্রেম"""
-    def predict(self, history):
-        timeframes = {'short': history[:5], 'medium': history[:10], 'long': history[:20]}
-        preds, confs = [], []
-        
-        for name, data in timeframes.items():
-            if len(data) < 3:
-                continue
-            
-            ma_3 = np.mean(data[:3]) if len(data)>=3 else np.mean(data)
-            ma_5 = np.mean(data[:5]) if len(data)>=5 else ma_3
-            
-            ema = data[0]
-            alpha = 0.3
-            for v in data[1:]:
-                ema = alpha*v + (1-alpha)*ema
-            
-            x = np.arange(len(data))
-            trend = np.polyfit(x, data, 1)[0]
-            
-            base = np.mean([ma_3, ma_5, ema])
-            preds.append(base + trend * len(data) / 10)
-            confs.append(min(0.9, 0.5 + len(data)/40))
-        
-        if not preds:
-            return {'prediction': 1.5, 'confidence': 0.3}
-        
-        weights = {'short':0.5, 'medium':0.3, 'long':0.2}
-        final_pred = 0
-        total_weight = 0
-        
-        for i, name in enumerate(timeframes.keys()):
-            if i < len(preds):
-                w = weights.get(name, 0.2) * confs[i]
-                final_pred += preds[i] * w
-                total_weight += w
-        
-        final_pred /= total_weight if total_weight else 1
-        confidence = np.mean(confs) * 0.9
-        
-        return {'prediction': float(final_pred), 'confidence': float(confidence)}
-
-class StatisticalModelV3:
-    """V3: সাইকেল ডিটেকশন"""
-    def detect_cycles(self, history):
-        if len(history) < 10:
-            return None
-        
-        cycles = []
-        for period in range(3, 7):
-            corrs = []
-            for i in range(len(history) - period*2):
-                seg1 = history[i:i+period]
-                seg2 = history[i+period:i+period*2]
-                if len(seg1) == len(seg2):
-                    corr = np.corrcoef(seg1, seg2)[0,1]
-                    if not np.isnan(corr):
-                        corrs.append(abs(corr))
-            if corrs and np.mean(corrs) > 0.6:
-                cycles.append({'period': period, 'strength': float(np.mean(corrs))})
-        
-        return cycles if cycles else None
-    
-    def predict(self, history):
-        recent = history[:20]
-        cycles = self.detect_cycles(recent)
-        cycle_pred = None
-        
-        if cycles:
-            best = max(cycles, key=lambda x: x['strength'])
-            period = best['period']
-            if len(recent) > period:
-                next_val = recent[period:period+1]
-                if next_val:
-                    cycle_pred = next_val[0] * (1 + best['strength'] * 0.1)
-        
-        base_pred = np.median(recent)
-        if cycle_pred:
-            base_pred = (base_pred + cycle_pred) / 2
-        
-        # ক্যাপ সরিয়ে দেওয়া হয়েছে - এখন যেকোনো মান হতে পারে
-        prediction = max(1.05, base_pred)
-        
-        confidence = min(0.9, 0.5 + len(recent)/40 + (0.15 if cycles else 0))
-        
-        return {'prediction': float(prediction), 'confidence': float(confidence)}
-
-class StatisticalModelV4:
-    """V4: এডাপটিভ লার্নিং"""
-    def __init__(self):
-        self.performance = []
-        self.bias = 0
-        self.volatility_regime = 'normal'
-    
-    def detect_volatility(self, history):
-        if len(history) < 10:
-            return 'normal'
-        recent_vol = np.std(history[:5])
-        long_vol = np.std(history[:20]) if len(history)>=20 else recent_vol
-        
-        if recent_vol > long_vol * 1.5:
-            return 'high'
-        elif recent_vol < long_vol * 0.5:
-            return 'low'
-        else:
-            return 'normal'
-    
-    def predict(self, history):
-        recent = history[:15]
-        self.volatility_regime = self.detect_volatility(history)
-        
-        mean_val, median_val = np.mean(recent), np.median(recent)
-        
-        x = np.arange(len(recent))
-        weights = np.exp(-0.2 * x)
-        weights /= weights.sum()
-        
-        weighted_mean_x = np.average(x, weights=weights)
-        weighted_mean_y = np.average(recent, weights=weights)
-        
-        numerator = np.sum(weights * (x - weighted_mean_x) * (recent - weighted_mean_y))
-        denominator = np.sum(weights * (x - weighted_mean_x)**2)
-        trend = numerator / denominator if denominator != 0 else 0
-        
-        preds = {'mean': mean_val, 'median': median_val, 'trend': median_val + trend * len(recent) * 0.5}
-        w = {'mean': 0.3, 'median': 0.4, 'trend': 0.3}
-        
-        if self.volatility_regime == 'high':
-            w['median'] *= 1.5
-        elif self.volatility_regime == 'low':
-            w['trend'] *= 1.3
-        
-        total = sum(w.values())
-        for k in w:
-            w[k] /= total
-        
-        prediction = sum(preds[k] * w[k] for k in preds) + self.bias
-        
-        confidence = 0.5 + len(recent)/30
-        if self.volatility_regime == 'high':
-            confidence *= 0.8
-        elif self.volatility_regime == 'low':
-            confidence *= 1.2
-        
-        if self.performance:
-            recent_perf = np.mean(self.performance[-10:]) if len(self.performance)>=10 else np.mean(self.performance)
-            confidence *= (1 + recent_perf * 0.1)
-        
-        confidence = min(0.9, confidence)
-        
-        # ক্যাপ সরিয়ে দেওয়া হয়েছে - এখন যেকোনো মান হতে পারে
-        return {'prediction': float(max(1.05, prediction)), 'confidence': float(confidence)}
-    
-    def update(self, actual, predicted):
-        error = abs(actual - predicted) / actual
-        acc = max(0, 1 - error)
-        self.performance.append(acc)
-        if len(self.performance) > 100:
-            self.performance = self.performance[-100:]
-        self.bias += (actual - predicted) * 0.01
-
-class StatisticalModelV5:
-    """V5: র‍্যান্ডম ফরেস্ট সিমুলেশন"""
-    def __init__(self):
-        self.n_estimators = 10
-    
-    def predict(self, history):
-        if len(history) < 10:
-            return {'prediction': 1.5, 'confidence': 0.5}
-        
-        recent = history[:10]
-        trees = []
-        
-        for _ in range(self.n_estimators):
-            idx = np.random.choice(len(recent), size=len(recent), replace=True)
-            sample = [recent[i] for i in idx]
-            if np.random.random() > 0.5:
-                trees.append(np.mean(sample))
-            else:
-                trees.append(np.median(sample))
-        
-        pred = float(np.mean(trees))
-        return {'prediction': pred, 'confidence': 0.7}
-
-# ==================== V6 মডেল (টাইম-ভিত্তিক) ====================
-
-class StatisticalModelV6:
-    """V6: টাইম-অফ-ডে অ্যাডজাস্টমেন্ট"""
-    def __init__(self, time_stats):
-        self.time_stats = time_stats
-    
-    def predict(self, history, current_hour=None):
-        if current_hour is None:
-            current_hour = datetime.now().hour
-        
-        stats = self.time_stats.get(current_hour, {'mean': 1.8, 'std': 1.0})
-        base_pred = np.median(history[:5]) if len(history)>=5 else 1.5
-        
-        alpha = 0.3
-        prediction = base_pred * (1 - alpha) + stats['mean'] * alpha
-        confidence = min(0.85, 0.5 + stats.get('count', 100) / 500)
-        
-        return {'prediction': float(prediction), 'confidence': float(confidence), 'hour': current_hour}
-
-# ==================== এনসেম্বল প্রেডিক্টর ====================
-
-class EnsemblePredictorV6:
-    def __init__(self, time_stats):
-        self.models = {
-            'v1': StatisticalModelV1(),
-            'v2': StatisticalModelV2(),
-            'v3': StatisticalModelV3(),
-            'v4': StatisticalModelV4(),
-            'v5': StatisticalModelV5(),
-            'v6': StatisticalModelV6(time_stats)
-        }
-        self.ensemble_weights = {'v1':0.2, 'v2':0.2, 'v3':0.15, 'v4':0.15, 'v5':0.15, 'v6':0.15}
-        self.performance = defaultdict(list)
-    
-    def predict(self, history):
-        if len(history) < 5:
-            return self._default_prediction(f"মাত্র {len(history)}টি রাউন্ড, ৫টি প্রয়োজন")
-        
-        current_hour = datetime.now().hour
-        preds = {}
-        confs = {}
-        
-        for name, model in self.models.items():
-            try:
-                if name == 'v6':
-                    res = model.predict(history, current_hour)
-                else:
-                    res = model.predict(history)
-                preds[name] = res['prediction']
-                confs[name] = res.get('confidence', 0.5)
-            except Exception as e:
-                print(f"মডেল {name} এ সমস্যা: {e}")
-                preds[name] = 1.5
-                confs[name] = 0.3
-        
-        # ওয়েট আপডেট
-        for name in self.ensemble_weights:
-            if name in self.performance and self.performance[name]:
-                recent_acc = np.mean(self.performance[name][-20:]) if len(self.performance[name])>=20 else np.mean(self.performance[name])
-                self.ensemble_weights[name] = 0.1 + recent_acc * 0.8
-        
-        total = sum(self.ensemble_weights.values())
-        for name in self.ensemble_weights:
-            self.ensemble_weights[name] /= total
-        
-        final_pred = 0
-        total_weight = 0
-        for name, pred in preds.items():
-            weight = self.ensemble_weights.get(name, 0.2) * confs[name]
-            final_pred += pred * weight
-            total_weight += weight
-        
-        final_pred /= total_weight if total_weight else 1
-        
-        # মার্কেট স্টেট
-        recent = history[:10]
-        vol = np.std(recent) / (np.mean(recent)+0.1)
-        if vol > 0.5:
-            state = "অস্থির 🌪️"
-        elif vol < 0.2:
-            state = "স্থিতিশীল ✨"
-        else:
-            state = "সাধারণ ➡️"
-        
-        confidence = np.mean(list(confs.values())) * 0.9
-        if vol < 0.2:
-            confidence *= 1.1
-        elif vol > 0.5:
-            confidence *= 0.9
-        confidence = min(0.95, confidence)
-        
-        # প্রেডিকশন ইন্টারভ্যাল
-        all_preds = list(preds.values())
-        std = np.std(all_preds) if len(all_preds)>1 else 0.2
-        spread = std * (2 - confidence)
-        spread = max(0.1, min(1.5, spread))
-        interval = (max(1.01, final_pred - spread/2), final_pred + spread/2)
-        
-        # ডিসিশন
-        if final_pred > 3.0:
-            decision = "বড় 🚀"
-        elif final_pred > 1.8:
-            decision = "মাঝারি 💪"
-        else:
-            decision = "ছোট 🎯"
-        
-        hour_stats = TIME_STATS.get(current_hour, {'mean':1.8, 'count':0})
-        time_info = f"বর্তমান ঘণ্টা: {current_hour}:00 – ঐতিহাসিক গড়: {hour_stats['mean']:.2f}x (ডাটা: {hour_stats['count']}টি)"
-        
-        summary = (
-            f"🎯 **প্রেডিকশন ইন্টারভ্যাল**: {interval[0]:.2f}x – {interval[1]:.2f}x\n"
-            f"📊 **এক্সপেক্টেড মাল্টিপ্লায়ার**: {final_pred:.2f}x\n"
-            f"📈 **কনফিডেন্স**: {confidence*100:.1f}%\n"
-            f"⚡ **মার্কেট স্টেট**: {state}\n"
-            f"🎲 **ডিসিশন**: {decision}\n"
-            f"⏰ **টাইম ফিচার**: {time_info}\n"
-            f"📌 **ডাটা পয়েন্ট**: {len(history)}টি রাউন্ড"
-        )
-        
-        return {
-            'summary': summary,
-            'prediction': final_pred,
-            'interval': interval,
-            'confidence': confidence,
-            'decision': decision,
-            'analysis': state,
-            'hour': current_hour
-        }
-    
-    def _default_prediction(self, msg):
-        return {
-            'summary': f"⚠️ {msg}\n\n📊 ডিফল্ট প্রেডিকশন: 1.50x (কনফিডেন্স 30%)",
-            'prediction': 1.5,
-            'interval': (1.3, 1.7),
-            'confidence': 0.3,
-            'decision': 'ছোট 🎯',
-            'analysis': 'অপ্রতুল ডাটা'
-        }
-
-# ==================== অ্যাপ্লিকেশন ক্লাস ====================
-
-class AviatorPredictorApp:
-    def __init__(self):
-        self.history = []
-        self.model = EnsemblePredictorV6(TIME_STATS)
-    
-    def add_round(self, multiplier):
-        try:
-            # ইনপুট ভ্যালিডেশন
-            if multiplier is None:
-                return self.get_all_outputs(error="মাল্টিপ্লায়ার দেওয়া হয়নি")
-            
-            # সংখ্যায় রূপান্তর
-            val = float(multiplier)
-            
-            if val <= 0:
-                return self.get_all_outputs(error="ইনভ্যালিড মাল্টিপ্লায়ার (১.০ এর বেশি দিন)")
-            
-            # ইতিহাসে যোগ করুন
-            self.history.insert(0, val)
-            if len(self.history) > CONFIG["HISTORY_LIMIT"]:
-                self.history = self.history[:CONFIG["HISTORY_LIMIT"]]
-            
-            return self.get_all_outputs()
-            
-        except ValueError:
-            return self.get_all_outputs(error=f"ইনভ্যালিড সংখ্যা: {multiplier}")
-        except Exception as e:
-            traceback.print_exc()  # Hugging Face লগে প্রিন্ট হবে
-            return self.get_all_outputs(error=f"⚠️ ত্রুটি: {str(e)}")
-    
-    def reset(self):
-        self.history = []
-        for _ in range(20):
-            self.history.append(round(random.uniform(1.0, 3.5), 2))
-        self.history.sort(reverse=True)
-        return self.get_all_outputs()
-    
-    def get_all_outputs(self, error=None):
-        if error:
-            table = [[i+1, "?.??x"] for i in range(min(20, len(self.history)))] or [[1, "1.00x"]]
-            return [table, f"⚠️ {error}"]
-        
-        try:
-            pred_result = self.model.predict(self.history)
-            table = [[i+1, f"{val:.2f}x"] for i, val in enumerate(self.history[:50])]
-            return [table, pred_result['summary']]
-        except Exception as e:
-            traceback.print_exc()
-            table = [[i+1, f"{val:.2f}x"] for i, val in enumerate(self.history[:50])]
-            return [table, f"⚠️ প্রেডিকশনে সমস্যা: {str(e)}"]
-
-# ==================== অ্যাপ ইনিশিয়ালাইজ ====================
-
-predictor_app = AviatorPredictorApp()
-predictor_app.reset()
-
-# ==================== গ্র্যাডিও ইন্টারফেস ====================
-
-with gr.Blocks(title="AVOLD V6 Predictor") as demo:
-    gr.HTML("""
-    <div style="text-align: center; margin-bottom: 20px;">
-        <h1 style="color: #00d4ff; font-size: 48px; margin: 0;">✈️ AVOLD V6</h1>
-        <p style="color: #888; font-size: 14px;">সময়-ভিত্তিক এভিয়েটর প্রেডিক্টর – ৬টি মডেলের এনসেম্বল</p>
-    </div>
-    """)
-    
-    with gr.Row():
-        inp = gr.Number(label="নতুন মাল্টিপ্লায়ার", value=1.0, step=0.1, minimum=1.0, maximum=None)
-        add_btn = gr.Button("➕ যোগ করুন", variant="primary")
-    
-    prediction_box = gr.Textbox(label="🧠 প্রেডিকশন রিপোর্ট", lines=10, interactive=False)
-    rounds_table = gr.Dataframe(label="📜 শেষ ৫০ রাউন���ড", headers=["রাউন্ড", "মাল্টিপ্লায়ার"], row_count=10)
-    reset_btn = gr.Button("🔄 রিসেট ডাটা", variant="secondary")
-    
-    add_btn.click(
-        fn=predictor_app.add_round,
-        inputs=inp,
-        outputs=[rounds_table, prediction_box]
-    )
-    
-    reset_btn.click(
-        fn=predictor_app.reset,
-        outputs=[rounds_table, prediction_box]
-    )
-    
-    demo.load(
-        fn=predictor_app.get_all_outputs,
-        outputs=[rounds_table, prediction_box]
-    )
-
-# ==================== কাস্টম CSS (launch() এ দেওয়া হবে) ====================
-
-CUSTOM_CSS = """
-.gradio-container {
-    background: #0a0a0f !important;
-    color: #ffffff !important;
-    font-family: 'Inter', sans-serif !important;
-}
-footer {visibility: hidden}
-h1 { 
-    color: #00d4ff !important; 
-    text-align: center; 
-    margin-bottom: 20px; 
-    text-shadow: 0 0 10px #00d4ff; 
-}
-.gr-box { 
-    border: 1px solid #333 !important; 
-    background: rgba(255,255,255,0.05) !important; 
-}
-.gr-button-primary { 
-    background: linear-gradient(135deg, #00d4ff, #0088ff) !important; 
-    border: none !important; 
-}
-.gr-button-secondary { 
-    background: rgba(255,255,255,0.1) !important; 
-    border: 1px solid #00d4ff !important; 
-    margin-top: 20px !important; 
-}
-.gr-dataframe { 
-    background: rgba(255,255,255,0.05) !important; 
-}
-"""
-
-# ==================== API এন্ডপয়েন্ট (ShareX-এর জন্য) ====================
-
-# FastAPI অ্যাপ তৈরি
-app = demo.app  # demo.gr_app নয়, demo.app ব্যবহার করতে হবে
-
-@app.post("/api/add_crash")
-async def add_crash_api(request: Request):
-    """
-    ShareX থেকে JSON ডাটা গ্রহণ করে ইতিহাসে যোগ করে
-    """
-    try:
-        data = await request.json()
-        crash_value = data.get("crash_value")
-        
-        if crash_value is None:
-            # বিকল্প হিসেবে "value" বা "multiplier" চেক করা
-            crash_value = data.get("value") or data.get("multiplier")
-        
-        if crash_value is None:
-            return {"status": "error", "message": "crash_value, value, অথবা multiplier প্রদান করুন"}
-        
-        # OCR থেকে আনা টেক্সট ক্লিন করা (যেমন "2.45x" থেকে "2.45")
-        if isinstance(crash_value, str):
-            # শুধু সংখ্যা ও ডট রাখা
-            import re
-            crash_value = re.sub(r'[^\d.]', '', crash_value)
-        
-        # সংখ্যায় রূপান্তর
-        val = float(crash_value)
-        
-        if val <= 1.0:
-            return {"status": "error", "message": f"মাল্টিপ্লায়ার ১.০ এর বেশি হতে হবে (পাওয়া গেছে: {val})"}
-        
-        # ইতিহাসে যোগ করা
-        result = predictor_app.add_round(val)
-        
-        # API রেসপন্স
-        return {
-            "status": "success", 
-            "message": f"ক্র্যাশ ভ্যালু {val:.2f}x যোগ করা হয়েছে",
-            "total_rounds": len(predictor_app.history)
-        }
-        
-    except ValueError as e:
-        return {"status": "error", "message": f"ইনভ্যালিড সংখ্যা: {crash_value}"}
-    except Exception as e:
-        traceback.print_exc()
-        return {"status": "error", "message": f"সার্ভার ত্রুটি: {str(e)}"}
-
-@app.get("/api/status")
-async def api_status():
-    """
-    API স্ট্যাটাস চেক করার জন্য
-    """
-    return {
-        "status": "active",
-        "total_rounds": len(predictor_app.history),
-        "last_10_rounds": [f"{x:.2f}" for x in predictor_app.history[:10]]
-    }
-
-if __name__ == "__main__":
-    # CSS এবং theme এখন launch() এ দেওয়া হয়েছে
-    demo.launch(server_name="0.0.0.0", server_port=7860, css=CUSTOM_CSS, theme='dark')