Add files via upload

Author: heisbuba

src/services/ai_modal_engine.py

@@ -0,0 +1,111 @@
+from google import genai
+from google.genai import types
+import traceback
+from ..config import db, get_user_keys
+
+class AiModalEngine:
+    @staticmethod
+    def _get_client(api_key):
+        return genai.Client(api_key=api_key)
+
+    @staticmethod
+    def initialize_firebase_session(uid, context):
+        try:
+            keys = get_user_keys(uid)
+            api_key = keys.get('gemini_key')
+            if not api_key: 
+                return "Error: No API Key found in Settings."
+
+            client = AiModalEngine._get_client(api_key)
+            
+            # Parsona
+            instruction = f"""
+            PARSONA:
+            You are the QuantVAT AI Trading Journal Auditor, a senior Risk Manager and Trading Psychologist with 50 years trading experience like a Market Wizard. 
+            Speak with veteran authority. Tone is blunt but constructive.
+
+            MANDATE:
+            1. Analyze the 'WHY' behind execution based on the provided logs.
+            2. STRUCTURE: 
+               - ## 📊 OVERVIEW: 2-sentence performance reality check.
+               - ## 🚩 RED FLAGS: Top 2 execution errors (FOMO, sizing, fear, etc).
+               - ## 💡 THE REMEDY: One specific, actionable rule for the next session.
+            3. FORMAT: Use bold text for emphasis. 
+            4. NO TABLES: Use bullet points only.
+            5. INTERACTION: End with a provocative question about a specific trade.
+
+            TRADING LEDGER (CSV FORMAT):
+            {context}
+            """
+
+            prompt = "Analyze my execution performance based on the CSV data above. End with: 'I have analyzed your data. Ready for audit.'"
+            
+            response = client.models.generate_content(
+                model='gemini-3-flash-preview', 
+                contents=prompt,
+                config=types.GenerateContentConfig(
+                    system_instruction=instruction
+                )
+            )
+            
+            history = [
+                {"role": "user", "parts": [{"text": prompt}]}, 
+                {"role": "model", "parts": [{"text": response.text}]}
+            ]
+            
+            db.collection('users').document(uid).set({
+                "ai_history": history,
+                "ai_context": context
+            }, merge=True)
+            
+            return response.text
+        except Exception as e:
+            print(f"AI Init Error: {traceback.format_exc()}")
+            return f"System Error: {str(e)}"
+
+    @staticmethod
+    def continue_firebase_chat(uid, prompt):
+        try:
+            user_doc = db.collection('users').document(uid).get()
+            data = user_doc.to_dict() if user_doc.exists else {}
+            history = data.get("ai_history", [])
+            context = data.get("ai_context", "") 
+            
+            api_key = get_user_keys(uid).get('gemini_key')
+            if not api_key: 
+                return "Error: API Key missing."
+
+            client = AiModalEngine._get_client(api_key)
+            
+            # Robust mapping
+            contents = []
+            for h in history:
+                p = h['parts'][0]
+                text_content = p['text'] if isinstance(p, dict) else str(p)
+                contents.append(types.Content(
+                    role=h['role'], 
+                    parts=[types.Part.from_text(text=text_content)]
+                ))
+            
+            contents.append(types.Content(role="user", parts=[types.Part.from_text(text=prompt)]))
+
+            # Re-injects Persona
+            instruction = f"PARSONA: QuantVAT AI Trading Journal Auditor. Senior Risk Manager.\nDATA:\n{context}"
+
+            response = client.models.generate_content(
+                model='gemini-3-flash-preview',
+                contents=contents,
+                config=types.GenerateContentConfig(
+                    system_instruction=instruction
+                )
+            )
+            
+            # Append new turn and sync to Firestore 
+            history.append({"role": "user", "parts": [{"text": prompt}]})
+            history.append({"role": "model", "parts": [{"text": response.text}]})
+            db.collection('users').document(uid).set({"ai_history": history}, merge=True)
+            
+            return response.text
+        except Exception as e:
+            print(f"AI Chat Error: {traceback.format_exc()}")
+            return f"Auditor Error: {str(e)}"

src/services/analysis.py

@@ -27,7 +27,7 @@
 
 ORIGINAL_MATCHED_HEADERS = ["Ticker", "Spot MrktCap", "Spot Volume", "Spot VTMR", "Futures Volume", "Futures VTMR", "OISS", "Funding Rate"]
 ORIGINAL_FUTURES_HEADERS = ["Ticker", "Market Cap", "Volume", "VTMR", "OISS", "Funding Rate"]
-ORIGINAL_SPOT_HEADERS = ["Ticker", "Market Cap", "Volume", "Spot VTMR"]
+ORIGINAL_SPOT_HEADERS = ["Ticker", "MarketCap", "Volume", "VTMR"]
 
 class FileScanner:
     """Locates the latest Spot and Futures data files in the USER directory."""
@@ -79,40 +79,44 @@ class DataProcessor:
     def load_spot(path: Path) -> pd.DataFrame:
         print(f"   Parsing Spot File: {path.name}")
         try:
+            # Explicit UTF-8 for Unicode preservation
             if path.suffix == '.html':
-                df = pd.read_html(path)[0]
+                df = pd.read_html(str(path), encoding='utf-8')[0]
             else:
-                df = pd.read_csv(path)
+                df = pd.read_csv(path, encoding='utf-8')
             df.columns = [c.lower().replace(' ', '_') for c in df.columns]
 
             col_map = {
                 'ticker': 'ticker',
                 'symbol': 'ticker', 
-                'spot_vtmr': 'spot_flip', 
-                'flipping_multiple': 'spot_flip',
-                'market_cap': 'spot_mc',
-                'marketcap': 'spot_mc',
-                'volume_24h': 'spot_vol',
-                'volume': 'spot_vol'
+                'vtmr': 'vtmr',           # <--- Ensures VTMR isn't blank
+                'spot_vtmr': 'vtmr', 
+                'flipping_multiple': 'vtmr',
+                'market_cap': 'market_cap',
+                'marketcap': 'market_cap',
+                'volume_24h': 'volume',
+                'volume': 'volume'
             }
 
             df = df.rename(columns=col_map, errors='ignore')
 
-            # Normalize ticker column
+            # Normalize ticker column (Find it if it's missing)
             if 'ticker' not in df.columns:
                  for col in df.columns:
                     if 'sym' in col or 'tick' in col or 'tok' in col:
                         df = df.rename(columns={col: 'ticker'})
                         break
 
+            # Unicode-safe cleaning (Protects Chinese characters)
             if 'ticker' in df.columns:
-                df['ticker'] = df['ticker'].apply(lambda x: re.sub(r'[^A-Z0-9]', '', str(x).upper()))
+                df['ticker'] = df['ticker'].apply(lambda x: str(x).strip().upper())
+                
             print(f"   Extracted {len(df)} spot tokens")
             return df
         except Exception as e:
             print(f"   Spot File Error: {e}")
             return pd.DataFrame()
-
+            
     @staticmethod
     def _generate_table_html(title: str, df: pd.DataFrame, headers: List[str], df_cols: List[str]) -> str:
         if df.empty:
@@ -123,6 +127,7 @@ def _generate_table_html(title: str, df: pd.DataFrame, headers: List[str], df_co
             df_display[m] = ""
         df_display = df_display[df_cols]
         df_display.columns = headers
+        # escape=False is critical for rendering ticker links
         table_html = df_display.to_html(index=False, classes='table', escape=False)
         return f'<div class="table-container"><h2>{title}</h2>{table_html}</div>'
 
@@ -139,46 +144,47 @@ def generate_html_report(futures_df: pd.DataFrame, spot_df: pd.DataFrame) -> Opt
         try:
             if 'vtmr' in valid_futures.columns:
                 valid_futures = valid_futures[valid_futures['vtmr'] >= 0.50]
-                valid_futures['vtmr_display'] = valid_futures['vtmr'].apply(lambda x: f"{x:.1f}x")
+                valid_futures['vtmr_display'] = valid_futures['vtmr'].apply(lambda x: f"{x:.2f}x")
         except Exception as e:
             print(f"   Futures high-quality filtering error: {e}")
             valid_futures['vtmr_display'] = valid_futures['vtmr']
 
-        # Create the 3 main datasets: Overlap, Futures-Only, Spot-Only
+        # Suffix-based merge to prevent blank column mapping issues
         merged = pd.merge(spot_df, valid_futures, on='ticker', how='inner', suffixes=('_spot', '_fut'))
-        if 'vtmr' in merged.columns:
-            merged = merged.sort_values('vtmr', ascending=False)
+        if 'vtmr_fut' in merged.columns:
+            merged = merged.sort_values('vtmr_fut', ascending=False)
 
         futures_only = valid_futures[~valid_futures['ticker'].isin(spot_df['ticker'])].copy()
         if 'vtmr' in futures_only.columns:
             futures_only = futures_only.sort_values('vtmr', ascending=False)
 
         spot_only = spot_df[~spot_df['ticker'].isin(merged['ticker'])].copy()
 
-        if 'spot_flip' in spot_only.columns:
+        if 'vtmr' in spot_only.columns:
             try:
                 spot_only = spot_only.copy()
-                spot_only.loc[:, 'flip_numeric'] = spot_only['spot_flip'].astype(str).str.replace('x', '', case=False).astype(float)
+                spot_only.loc[:, 'flip_numeric'] = spot_only['vtmr'].astype(str).str.replace('x', '', case=False).astype(float)
                 spot_only = spot_only[spot_only['flip_numeric'] >= 0.50]
                 spot_only = spot_only.drop(columns=['flip_numeric'])
             except Exception as e:
                 print(f"   Spot filtering error: {e}")
 
-        if 'spot_flip' in spot_only.columns:
+        if 'vtmr' in spot_only.columns:
             try:
                 spot_only = spot_only.copy()
-                spot_only.loc[:, 'sort_val'] = spot_only['spot_flip'].astype(str).str.replace('x', '', case=False).astype(float)
+                spot_only.loc[:, 'sort_val'] = spot_only['vtmr'].astype(str).str.replace('x', '', case=False).astype(float)
                 spot_only = spot_only.sort_values('sort_val', ascending=False).drop(columns=['sort_val'])
             except Exception:
                 pass
 
-        merged_cols = ['ticker', 'spot_mc', 'spot_vol', 'spot_flip', 'volume', 'vtmr_display', 'oiss', 'funding']
+        merged_cols = ['ticker', 'market_cap_spot', 'volume_spot', 'vtmr_spot', 'volume_fut', 'vtmr_display', 'oiss', 'funding']
         futures_cols = ['ticker', 'market_cap', 'volume', 'vtmr_display', 'oiss', 'funding']
+        spot_cols = ['ticker', 'market_cap', 'volume', 'vtmr']
 
         html_content = ""
         html_content += DataProcessor._generate_table_html("Tokens in Both Futures & Spot Markets", merged, ORIGINAL_MATCHED_HEADERS, merged_cols)
         html_content += DataProcessor._generate_table_html("Remaining Futures-Only Tokens", futures_only, ORIGINAL_FUTURES_HEADERS, futures_cols)
-        html_content += DataProcessor._generate_table_html("Remaining Spot-Only Tokens", spot_only, ORIGINAL_SPOT_HEADERS, ['ticker', 'spot_mc', 'spot_vol', 'spot_flip'])
+        html_content += DataProcessor._generate_table_html("Remaining Spot-Only Tokens", spot_only, ORIGINAL_SPOT_HEADERS, spot_cols)
         current_time = now_str("%d-%m-%Y %H:%M:%S")
 
         cheat_sheet_pdf_footer = """
@@ -212,14 +218,14 @@ def generate_html_report(futures_df: pd.DataFrame, spot_df: pd.DataFrame) -> Opt
                 <h2 style="color: #2c3e50; border-bottom: 2px solid #3498db; padding-bottom: 5px; margin-top: 20px;">Remaining Spot Only Tokens</h2>
                 <p>Remember those remaining spot only tokens because there is plenty opportunity there too. So, check them out. Don't fade on them.</p>
            <h2 style="color: #2c3e50; border-bottom: 2px solid #3498db; padding-bottom: 5px; margin-top: 20px;">Disclaimer</h2>
-                <small>This analysis was generated by you using the <strong>Crypto Volume Analysis Toolkit</strong> by <strong>@heisbuba</strong>. It empowers your market research but does not replace your due diligence. Verify the data, back your own instincts, and trade entirely at your own risk.</small>
+                <small>This analysis was generated by you using the <strong>QuantVAT</strong> by <strong>@heisbuba</strong>. It empowers your market research but does not replace your due diligence. Verify the data, back your own instincts, and trade entirely at your own risk.</small>
             </div>
         """
         html = f"""
         <!DOCTYPE html>
         <html>
         <head>
-            <title>Crypto Volume-driven Data Analysis Report</title>
+            <title>Quantitative Crypto Volume-driven Data Analysis Report</title>
             <meta charset="UTF-8">
             <style>{ORIGINAL_HTML_STYLE}</style>
         </head>
@@ -232,7 +238,7 @@ def generate_html_report(futures_df: pd.DataFrame, spot_df: pd.DataFrame) -> Opt
             {html_content}
               {cheat_sheet_pdf_footer}
             <div class="footer">
-                <p>Generated by Crypto Volume Analysis Toolkit 4.0 | By (@heisbuba)</p>
+                <p>Generated by QuantVAT | By (@heisbuba)</p>
             </div>
         </body>
         </html>
@@ -241,25 +247,23 @@ def generate_html_report(futures_df: pd.DataFrame, spot_df: pd.DataFrame) -> Opt
 
 def crypto_analysis_v4(user_keys, user_id) -> None:
     """Main execution flow for Advanced Analysis."""
-    print("   ADVANCED CRYPTO VOLUME ANALYSIS v4.0")
+    print("   ADVANCED QUANT CRYPTO VOLUME ANALYSIS")
     print("   Scanning for Futures PDF and Spot CSV/HTML files")
     print("   " + "=" * 50)
 
-    # 1. Find Files
+    # Find Files
     spot_file, futures_file = FileScanner.find_files(user_id)
     if not spot_file or not futures_file:
         print("   Required files not found.")
         raise FileNotFoundError("   You Need CoinAlyze Futures PDF and Spot Market Data. Kindly Generate Spot Data And Upload Futures PDF First.")
 
-    # 2. Parse Files
+    # Parse Files
     futures_df = PDFParser.extract(futures_file)
     spot_df = DataProcessor.load_spot(spot_file)
 
-    # 3. Generate HTML
     html_content = DataProcessor.generate_html_report(futures_df, spot_df)
-    
     if html_content:
-        # 4. Create PDF
+        # Create PDF
         pdf_path = convert_html_to_pdf(html_content, user_id)
 
         print("   🧹 Cleaning up source files after analysis...")