Update app.py

app.py

@@ -1,114 +1,324 @@
 import gradio as gr
 import random
 from statistics import mean
+from datetime import datetime
+
+# ---------- কনফিগারেশন ----------
+MAX_ROUNDS = 50
+DEFAULT_ROUNDS = 20
+UPDATE_INTERVAL = 1  # সেকেন্ড
+
+# পিঙ্ক জোন টাইম উইন্ডো (মিনিট)
+PINK_WINDOWS = [
+    {"start": 55, "end": 57, "name": "প্রাইম পিঙ্ক", "multiplier": 1.9},
+    {"start": 59, "end": 1, "name": "প্রাইম পিঙ্ক", "multiplier": 1.9},
+    {"start": 18, "end": 20, "name": "পিঙ্ক জোন", "multiplier": 1.4},
+    {"start": 27, "end": 29, "name": "পিঙ্ক জোন", "multiplier": 1.4},
+    {"start": 38, "end": 40, "name": "পিঙ্ক জোন", "multiplier": 1.4},
+    {"start": 43, "end": 45, "name": "পিঙ্ক জোন", "multiplier": 1.4},
+    {"start": 48, "end": 50, "name": "পিঙ্ক জোন", "multiplier": 1.4},
+]
+
+# ---------- হেল্পার ফাংশন ----------
+def get_current_time_window():
+    """বর্তমান মিনিট অনুযায়ী পিঙ্ক জোন চেক করে"""
+    now = datetime.now()
+    minutes = now.minute
+    
+    for window in PINK_WINDOWS:
+        if window["start"] <= window["end"]:
+            if minutes >= window["start"] and minutes <= window["end"]:
+                return window
+        else:
+            # ক্রস-আওয়ার বাউন্ডারি (যেমন 59-1)
+            if minutes >= window["start"] or minutes <= window["end"]:
+                return window
+    return None
+
+def get_next_time_window():
+    """পরবর্তী পিঙ্ক জোন কত মিনিট পরে তা বের করে"""
+    now = datetime.now()
+    current_minutes = now.minute
+    
+    nearest = None
+    min_distance = 60
+    
+    for window in PINK_WINDOWS:
+        if window["start"] <= window["end"]:
+            if current_minutes <= window["start"]:
+                distance = window["start"] - current_minutes
+            else:
+                distance = (60 - current_minutes) + window["start"]
+        else:
+            if current_minutes >= window["start"]:
+                distance = (60 - current_minutes) + window["end"]
+            elif current_minutes <= window["end"]:
+                distance = 0
+            else:
+                distance = window["start"] - current_minutes
+        
+        if distance < min_distance and distance > 0:
+            min_distance = distance
+            nearest = {"window": window, "minutes": distance}
+    
+    return nearest
 
-# ---------- Helper functions ----------
 def compute_outputs(rounds):
-    """Calculate expected multiplier, analysis, and decision based on recent rounds."""
+    """এক্সপেক্টেড মাল্টিপ্লায়ার, অ্যানালাইসিস এবং ডিসিশন ক্যালকুলেট করে"""
     if not rounds:
-        return "0.0", "No data", "N/A"
-
-    # Use last 10 rounds (or fewer if not enough data)
+        return "0.0x", "কোন ডাটা নেই", "N/A", 0, "medium", False
+    
+    # সর্বশেষ ১০টি রাউন্ড ব্যবহার করুন (অথবা কম)
     recent = rounds[-10:] if len(rounds) >= 10 else rounds
     avg = mean(recent)
-
-    # Expected multiplier = average ± small random fluctuation (simulate unpredictability)
-    expected = round(avg * random.uniform(0.95, 1.05), 2)
-
-    # Simple trend analysis
+    
+    # ছোট র‍্যান্ডম ফ্লাকচুয়েশন যোগ করুন (আসল গেমের টাইমার-ভিত্তিক র‍্যান্ডমনেস অনুকরণ)
+    expected = round(avg * random.uniform(0.92, 1.08), 2)
+    
+    # ট্রেন্ড অ্যানালাইসিস
     if len(recent) >= 2:
-        trend = recent[-1] - recent[-2]
-        if trend > 0.1:
-            analysis = "Increasing"
-        elif trend < -0.1:
-            analysis = "Decreasing"
+        trend_val = recent[-1] - recent[-2]
+        if trend_val > 0.15:
+            trend = "উর্ধ্বমুখী 📈"
+        elif trend_val < -0.15:
+            trend = "নিম্নমুখী 📉"
         else:
-            analysis = "Stable"
+            trend = "স্থিতিশীল ➡️"
     else:
-        analysis = "Insufficient data"
-
-    # Decision based on expected multiplier
-    if expected > 2.5:
-        decision = "High"
-    elif expected > 1.5:
-        decision = "Medium"
+        trend = "পর্যাপ্ত ডাটা নেই"
+    
+    # পিঙ্ক প্রোবাবিলিটি
+    pink_count = sum(1 for r in recent if r >= 3.0)
+    pink_prob = min(0.9, pink_count / len(recent) + 0.1)
+    is_pink_expected = pink_prob > 0.4 or expected > 2.8
+    
+    # টাইম উইন্ডো চেক
+    current_window = get_current_time_window()
+    if current_window:
+        expected *= current_window["multiplier"]
+        expected = round(min(15.0, expected), 2)
+        pink_boost = "টাইম উইন্ডো একটিভ!"
     else:
-        decision = "Low"
-
-    return str(expected), analysis, decision
+        pink_boost = ""
+    
+    # কনফিডেন্স লেভেল
+    confidence = min(0.9, 0.5 + (len(rounds) / 100) + (pink_prob * 0.2))
+    
+    # রিস্ক লেভেল
+    if expected > 5.0:
+        risk = "উচ্চ ⚠️"
+    elif expected > 2.5:
+        risk = "মাঝারি ⚖️"
+    else:
+        risk = "নিম্ন ✅"
+    
+    # ডিসিশন
+    if is_pink_expected:
+        decision = "পিঙ্ক আশান্বিত 🌸"
+    elif expected > 3.0:
+        decision = "বড় মাল্টিপ্লায়ার 🚀"
+    elif expected > 1.8:
+        decision = "মাঝারি 💪"
+    else:
+        decision = "ছোট 🎯"
+    
+    # অ্যানালাইসিস টেক্সট
+    analysis_parts = [trend]
+    if pink_boost:
+        analysis_parts.append(pink_boost)
+    if is_pink_expected:
+        analysis_parts.append("🌸 পিঙ্ক সম্ভাবনা")
+    analysis = " | ".join(analysis_parts)
+    
+    return f"{expected}x", analysis, decision, confidence, risk, is_pink_expected
 
 def update_ui(rounds):
-    """Prepare the dataframe and the three output values from the current rounds list."""
-    # Build table: [Round number, Multiplier]
-    table = [[i+1, val] for i, val in enumerate(rounds)]
-    exp, ana, dec = compute_outputs(rounds)
-    return table, exp, ana, dec
+    """UI আপডেট করার জন্য ডাটা প্রস্তুত করে"""
+    table = [[i+1, f"{val}x"] for i, val in enumerate(rounds)]
+    exp, ana, dec, conf, risk, pink = compute_outputs(rounds)
+    return table, exp, ana, dec, conf, risk, pink
 
 def add_round(state, new_val):
-    """Append a new multiplier, keep only last 50, and refresh UI."""
+    """নতুন মাল্টিপ্লায়ার যোগ করে"""
     if new_val <= 0:
-        # ignore invalid inputs (but you could show a warning – here we just return unchanged)
-        return state + update_ui(state)[:3]   # need to return state and outputs
+        return state + update_ui(state)[:6]
+    
     rounds = state.copy()
     rounds.append(new_val)
-    if len(rounds) > 50:
-        rounds = rounds[-50:]
-    table, exp, ana, dec = update_ui(rounds)
-    return rounds, table, exp, ana, dec
+    if len(rounds) > MAX_ROUNDS:
+        rounds = rounds[-MAX_ROUNDS:]
+    
+    table, exp, ana, dec, conf, risk, pink = update_ui(rounds)
+    return rounds, table, exp, ana, dec, conf, risk, pink
 
 def reset_rounds():
-    """Reset to a fresh set of 20 random multipliers."""
-    initial = [round(random.uniform(1.0, 3.0), 2) for _ in range(20)]
-    table, exp, ana, dec = update_ui(initial)
-    return initial, table, exp, ana, dec
+    """ডাটা রিসেট করে"""
+    initial = [round(random.uniform(1.0, 3.5), 2) for _ in range(DEFAULT_ROUNDS)]
+    table, exp, ana, dec, conf, risk, pink = update_ui(initial)
+    return initial, table, exp, ana, dec, conf, risk, pink
 
-# ---------- Build the Gradio interface ----------
-with gr.Blocks(theme='dark', css="footer {visibility: hidden}") as demo:
-    gr.Markdown("# AVOLD")
-
-    # State: stores the list of multipliers
-    rounds_state = gr.State([round(random.uniform(1.0, 3.0), 2) for _ in range(20)])
+def get_time_status():
+    """সময়-ভিত্তিক স্ট্যাটাস আপডেট করে"""
+    now = datetime.now()
+    time_str = now.strftime("%H:%M:%S")
+    
+    current = get_current_time_window()
+    next_window = get_next_time_window()
+    
+    if current:
+        status = f"🌸 {current['name']} একটিভ! 🌸"
+        detail = f"বুস্ট: +{int((current['multiplier']-1)*100)}%"
+        css_class = "active-window"
+    elif next_window and next_window["minutes"] <= 2:
+        status = f"⚠️ {next_window['window']['name']} আসছে {next_window['minutes']} মিনিটে"
+        detail = "প্রস্তুত হোন!"
+        css_class = "approaching-window"
+    else:
+        status = "পিঙ্ক জোনের অপেক্ষায়..."
+        detail = next_window and f"পরবর্তী: {next_window['window']['name']} {next_window['minutes']} মিনিটে" or ""
+        css_class = "waiting-window"
+    
+    return time_str, status, detail, css_class
 
-    # Input row
+# ---------- গ্র্যাডিও ইন্টারফেস ----------
+with gr.Blocks(theme='dark', css="""
+    footer {visibility: hidden}
+    .active-window { background: linear-gradient(135deg, #ff1493, #ff69b4) !important; }
+    .approaching-window { background: linear-gradient(135deg, #ffa726, #ff9800) !important; }
+    .waiting-window { background: linear-gradient(135deg, #1a1a2e, #16213e) !important; }
+    .pink-text { color: #ff1493 !important; }
+    .confidence-bar { height: 8px; background: #333; border-radius: 4px; overflow: hidden; }
+    .confidence-fill { height: 100%; background: linear-gradient(90deg, #00d4ff, #ff1493); transition: width 0.3s; }
+    .risk-badge { padding: 2px 8px; border-radius: 12px; font-size: 12px; font-weight: 600; }
+    .risk-high { background: #ff4757; color: white; }
+    .risk-medium { background: #ffa726; color: black; }
+    .risk-low { background: #66bb6a; color: white; }
+    .time-box { text-align: center; padding: 12px; border-radius: 8px; margin-bottom: 16px; transition: all 0.3s; }
+""") as demo:
+    
+    gr.Markdown("""
+    <div style="text-align: center; margin-bottom: 20px;">
+        <h1 style="color: #00d4ff; font-size: 48px; margin: 0;">✈️ AVOLD</h1>
+        <p style="color: #888; font-size: 14px;">এভিয়েটর রাউন্ড অ্যানালাইজার</p>
+    </div>
+    """)
+    
+    # স্টেট
+    rounds_state = gr.State([round(random.uniform(1.0, 3.5), 2) for _ in range(DEFAULT_ROUNDS)])
+    
+    # টাইম সেকশন (ডায়নামিক)
     with gr.Row():
-        new_multiplier = gr.Number(label="New Multiplier", value=1.0, step=0.1)
-        add_btn = gr.Button("Add Round")
-
-    # Reset button
-    reset_btn = gr.Button("Reset Data")
-
-    # Three outputs in one row
+        time_box = gr.HTML(label="টাইম স্ট্যাটাস")
+    
+    # ইনপুট রো
     with gr.Row():
-        expected_out = gr.Textbox(label="Expected Multiplier", interactive=False)
-        analysis_out = gr.Textbox(label="Analysis", interactive=False)
-        decision_out = gr.Textbox(label="Decision", interactive=False)
-
-    # Table at the bottom
+        new_multiplier = gr.Number(
+            label="নতুন মাল্টিপ্লায়ার",
+            value=1.0,
+            step=0.1,
+            minimum=1.0,
+            maximum=100.0
+        )
+        add_btn = gr.Button("➕ যোগ করুন", variant="primary")
+    
+    # রিসেট বাটন
+    reset_btn = gr.Button("🔄 রিসেট ডাটা", variant="secondary")
+    
+    # তিনটি আউটপুট এক লাইনে
+    with gr.Row():
+        expected_out = gr.Textbox(label="📊 এক্সপেক্টেড", interactive=False, elem_classes="pink-text")
+        analysis_out = gr.Textbox(label="📈 অ্যানালাইসিস", interactive=False)
+        decision_out = gr.Textbox(label="🎯 ডিসিশন", interactive=False)
+    
+    # কনফিডেন্স এবং রিস্ক
+    with gr.Row():
+        with gr.Column(scale=3):
+            confidence_bar = gr.HTML(label="কনফিডেন্স")
+        with gr.Column(scale=1):
+            risk_out = gr.Textbox(label="রিস্ক লেভেল", interactive=False)
+    
+    # টেবিল
     rounds_table = gr.Dataframe(
-        label="Last 50 Rounds",
-        headers=["Round", "Multiplier"],
-        row_count=10,          # show 10 rows at a time (scrollable)
+        label="📜 শেষ ৫০ রাউন্ড",
+        headers=["রাউন্ড", "মাল্টিপ্লায়ার"],
+        row_count=10,
+        interactive=False
     )
-
-    # Wire up the buttons
+    
+    # হিডেন স্টেট
+    pink_state = gr.State(False)
+    conf_state = gr.State(0.5)
+    
+    # ---------- ইভেন্ট হ্যান্ডলার ----------
+    def update_time_display():
+        time_str, status, detail, css_class = get_time_status()
+        return f"""
+        <div class="time-box {css_class}">
+            <div style="font-size: 24px; font-weight: 700;">{time_str}</div>
+            <div style="font-size: 16px; font-weight: 600;">{status}</div>
+            <div style="font-size: 12px; opacity: 0.9;">{detail}</div>
+        </div>
+        """
+    
+    def update_confidence_display(conf, is_pink):
+        color = "pink-text" if is_pink else ""
+        return f"""
+        <div>
+            <div style="display: flex; justify-content: space-between; margin-bottom: 4px;">
+                <span class="{color}">এমএল কনফিডেন্স: {int(conf*100)}%</span>
+                <span class="{color}">{'🌸 পিঙ্ক মোড' if is_pink else ''}</span>
+            </div>
+            <div class="confidence-bar">
+                <div class="confidence-fill" style="width: {int(conf*100)}%;"></div>
+            </div>
+        </div>
+        """
+    
+    # টাইম আপডেট (প্রতি সেকেন্ড)
+    demo.load(
+        fn=lambda: (update_time_display(),),
+        outputs=[time_box],
+        every=UPDATE_INTERVAL
+    )
+    
+    # অ্যাড বাটন
     add_btn.click(
         add_round,
         inputs=[rounds_state, new_multiplier],
-        outputs=[rounds_state, rounds_table, expected_out, analysis_out, decision_out]
+        outputs=[rounds_state, rounds_table, expected_out, analysis_out, decision_out, conf_state, risk_out, pink_state]
+    ).then(
+        lambda conf, pink: update_confidence_display(conf, pink),
+        inputs=[conf_state, pink_state],
+        outputs=[confidence_bar]
+    ).then(
+        lambda: (update_time_display(),),
+        outputs=[time_box]
     )
-
+    
+    # রিসেট বাটন
     reset_btn.click(
         reset_rounds,
-        outputs=[rounds_state, rounds_table, expected_out, analysis_out, decision_out]
+        outputs=[rounds_state, rounds_table, expected_out, analysis_out, decision_out, conf_state, risk_out, pink_state]
+    ).then(
+        lambda conf, pink: update_confidence_display(conf, pink),
+        inputs=[conf_state, pink_state],
+        outputs=[confidence_bar]
+    ).then(
+        lambda: (update_time_display(),),
+        outputs=[time_box]
     )
-
-    # Initial load
+    
+    # ইনিশিয়াল লোড
     demo.load(
-        lambda s: update_ui(s),
+        lambda s: update_ui(s) + (0.5, False, ""),
         inputs=[rounds_state],
-        outputs=[rounds_table, expected_out, analysis_out, decision_out]
+        outputs=[rounds_table, expected_out, analysis_out, decision_out, conf_state, risk_out, pink_state, confidence_bar]
+    ).then(
+        lambda conf, pink: update_confidence_display(conf, pink),
+        inputs=[conf_state, pink_state],
+        outputs=[confidence_bar]
     )
 
-# Launch the app
+# ---------- অ্যাপ রান ----------
 if __name__ == "__main__":
     demo.launch()