Upload 2 files

app.py

@@ -0,0 +1,594 @@
+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)}"]
+
+# ==================== কাস্টম CSS ====================
+
+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; 
+}
+"""
+
+# ==================== গ্র্যাডিও ইন্টারফেস ====================
+
+predictor_app = AviatorPredictorApp()
+predictor_app.reset()
+
+with gr.Blocks(css=CUSTOM_CSS, theme='dark', 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]
+    )
+
+# ==================== API এন্ডপয়েন্ট (ShareX-এর জন্য) ====================
+
+@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__":
+    demo.launch(server_name="0.0.0.0", server_port=7860)

requirements.txt

@@ -0,0 +1,6 @@
+gradio>=6.7.0
+numpy>=1.24.0
+pandas>=2.0.0
+openpyxl>=3.1.0
+fastapi>=0.104.0
+uvicorn>=0.24.0