minting 2.2.5__tar.gz → 2.2.7__tar.gz

{minting-2.2.5 → minting-2.2.7}/Minting/__init__.py

@@ -1,3 +1,3 @@
 from .client import Client
 
-__version__ = "2.2.5"
+__version__ = "2.2.7"

minting-2.2.7/Minting/client.py

@@ -0,0 +1,489 @@
+
+import requests
+import pandas as pd
+import io
+import time
+import os
+import sys
+import hashlib
+from datetime import datetime
+from pymongo import MongoClient
+from colorama import Fore, Style, init as colorama_init
+
+colorama_init(autoreset=True)
+
+# ----------------- Database Layer -----------------
+class Database:
+    def __init__(self, mongo_uri, db_name):
+        try:
+            self.client = MongoClient(
+                mongo_uri,
+                serverSelectionTimeoutMS=50000,
+                connectTimeoutMS=100000
+            )
+            self.client.server_info()
+            self.db = self.client[db_name]
+        except Exception as e:
+            print(f"❌ Connection Error: {e}")
+            raise
+
+        self.users        = self.db["users"]
+        self.access_tokens = self.db["accesstokens"]
+        self.user_plans   = self.db["userplans"]
+        self.plans        = self.db["plans"]
+
+
+# ----------------- Token Manager -----------------
+class TokenManager:
+    def __init__(self, db: Database, raw_token: str):
+        self.db           = db
+        self.raw_token    = raw_token.strip()
+        self.hashed_token = self._hash_token(self.raw_token)
+
+    def _hash_token(self, token: str) -> str:
+        return hashlib.sha256(token.encode("utf-8")).hexdigest()
+
+    def check_token_and_credits(self):
+        token_doc = self.db.access_tokens.find_one(
+            {"token": self.hashed_token, "isActive": True}
+        )
+        if not token_doc:
+            return {"valid": False, "error": "Invalid or inactive access token"}
+
+        user_id  = token_doc["userId"]
+        plan_doc = self.db.user_plans.find_one({
+            "userId":   user_id,
+            "isActive": True,
+            "expiresAt": {"$gte": datetime.utcnow()},
+        })
+        if not plan_doc:
+            return {"valid": False, "error": "No active subscription plan found"}
+
+        credits = plan_doc.get("creditsRemaining", 0)
+        if credits <= 0:
+            return {
+                "valid": False,
+                "error": "Credits exhausted. Please subscribe to a plan to continue.",
+                "creditsRemaining": 0,
+            }
+        return {
+            "valid":            True,
+            "userId":           user_id,
+            "planId":           plan_doc["_id"],
+            "creditsRemaining": credits,
+        }
+
+    def deduct_credit(self):
+        token_doc = self.db.access_tokens.find_one(
+            {"token": self.hashed_token, "isActive": True}
+        )
+        if not token_doc:
+            return False
+
+        user_id  = token_doc["userId"]
+        plan_doc = self.db.user_plans.find_one({
+            "userId":   user_id,
+            "isActive": True,
+            "expiresAt": {"$gte": datetime.utcnow()},
+        })
+        if not plan_doc:
+            return False
+        if plan_doc.get("creditsRemaining", 0) <= 0:
+            return False
+
+        result = self.db.user_plans.update_one(
+            {"_id": plan_doc["_id"], "creditsRemaining": {"$gt": 0}},
+            {
+                "$inc": {"creditsRemaining": -1},
+                "$set": {"updatedAt": datetime.utcnow()},
+            },
+        )
+        return result.modified_count > 0
+
+    def get_remaining_credits(self):
+        token_doc = self.db.access_tokens.find_one(
+            {"token": self.hashed_token, "isActive": True}
+        )
+        if not token_doc:
+            return 0
+
+        user_id  = token_doc["userId"]
+        plan_doc = self.db.user_plans.find_one({
+            "userId":   user_id,
+            "isActive": True,
+            "expiresAt": {"$gte": datetime.utcnow()},
+        })
+        if not plan_doc:
+            return 0
+        return max(plan_doc.get("creditsRemaining", 0), 0)
+
+
+# ----------------- Client Class -----------------
+class Client:
+    SUPPORTED_TICKERS = {
+        "ABB", "ACC", "ADANIGREEN", "ADANITOTAL", "APOLLOHOSP",
+    "BAJAJHLDNG", "BANDHANBNK", "BERGEPAINT", "BOSCHLTD", "CANBK",
+    "CIPLA", "DABUR", "DLF", "DRREDDY", "HAVELLS",
+    "HDFCAMC", "ICICIGI", "ICICIPRULI", "INDUSTOWER", "INFOEDGE",
+    "JINDALSTEL", "JSWENERGY", "LUPIN", "MARICO", "MOTHERSON",
+    "MUTHOOTFIN", "NMDC", "OIL", "PAGEIND", "PIIND",
+    "PNB", "RECLTD", "SHREECEM", "SIEMENS", "SRF",
+    "TATACHEM", "TATACONSUM", "TATAELXSI", "TORNTPHARM", "TRENT",
+    "UBL", "ZOMATO", "ALKEM", "ASTRAL", "AUROPHARMA",
+    "COLPAL", "CONCOR", "FEDERALBNK", "LICI", "MRF",
+    "NAUKRI", "TORNTPOWER","TCS","HDFCBANK","BHARTIARTL","ICICIBANK","SBIN","INFY","BAJFINANCE",
+    "HINDUNILVR","ITC","MARUTI","HCLTECH","SUNPHARMA","KOTAKBANK","AXISBANK",
+    "ULTRACEMCO","BAJAJFINSV","ADANIPORTS","NTPC","ONGC","ASIANPAINT",
+    "JSWSTEEL","ADANIPOWER","WIPRO","ADANIENT","POWERGRID","NESTLEIND",
+    "COALINDIA","INDIGO","HINDZINC","TATASTEEL","VEDL","SBILIFE","EICHERMOT",
+    "GRASIM","HINDALCO","LTIM","TVSMOTOR","DIVISLAB","HDFCLIFE","PIDILITIND",
+    "CHOLAFIN","BRITANNIA","AMBUJACEM","GAIL","BANKBARODA","GODREJCP",
+    "HEROMOTOCO","TATAPOWER"
+    }
+
+    def __init__(
+        self,
+        access_token=None,
+        token=None,
+        base_url="http://34.70.223.89:8000/predict",
+        mongo_uri="mongodb+srv://ankitarrow:ankitarrow@cluster0.zcajdur.mongodb.net/?retryWrites=true&w=majority&appName=Cluster0",
+        db_name="test",
+    ):
+        if access_token is None and token is None:
+            raise ValueError("Access token must be provided as 'access_token' or 'token'.")
+
+        self.access_token = (access_token or token).strip()
+        self.base_url     = base_url
+
+        print("=" * 60)
+        print(" Initializing Mintzy")
+        print("=" * 60)
+
+        self.db            = Database(mongo_uri, db_name)
+        self.token_manager = TokenManager(self.db, self.access_token)
+
+    # ------------------------------------------------------------------
+    # INTERNAL: parse server response → dict  { ticker -> list[dict] }
+    # ------------------------------------------------------------------
+    def _parse_response(self, response_json, tickers, parameters):
+        """
+        Returns:
+            parsed   : { ticker: [ {Date, Time, Predicted Price}, ... ] }
+            warnings : [ string ]
+        """
+        parsed   = {}
+        warnings = []
+
+        if not isinstance(response_json, dict):
+            warnings.append(f"Unexpected response type: {type(response_json)}")
+            return parsed, warnings
+
+        result = response_json.get("result", response_json)
+
+        for ticker in tickers:
+            ticker_data = result.get(ticker) if isinstance(result, dict) else None
+
+            if ticker_data is None:
+                warnings.append(f"No data returned for {ticker}")
+                continue
+
+            if isinstance(ticker_data, str):
+                warnings.append(f"{ticker}: server error — {ticker_data}")
+                continue
+
+            ticker_rows = []
+
+            for param in parameters:
+                param_data = (
+                    ticker_data.get(param)
+                    if isinstance(ticker_data, dict)
+                    else None
+                )
+
+                if param_data is None:
+                    warnings.append(f"{param} data missing for {ticker}")
+                    continue
+
+                # ── structured dict response ──────────────────────────
+                if isinstance(param_data, dict):
+                    timestamps       = param_data.get("timestamps", [])
+                    predicted_prices = param_data.get("predicted_prices", [])
+                    dates            = param_data.get("dates", [])
+                    times            = param_data.get("times", [])
+
+                    if not predicted_prices:
+                        warnings.append(f"Empty prediction data for {ticker}.{param}")
+                        continue
+
+                    for i, price in enumerate(predicted_prices):
+                        if price is None:
+                            price = 0.0   # keep slot visible rather than silently dropping it
+
+                        # resolve timestamp
+                        if i < len(timestamps):
+                            ts_str = str(timestamps[i])
+                            try:
+                                dt       = datetime.fromisoformat(ts_str)
+                                date_str = dt.strftime("%Y-%m-%d")
+                                time_str = dt.strftime("%H:%M:%S")
+                            except Exception:
+                                date_str = str(dates[i]) if i < len(dates) else ts_str
+                                time_str = str(times[i]) if i < len(times) else ""
+                        else:
+                            date_str = str(dates[i]) if i < len(dates) else ""
+                            time_str = str(times[i]) if i < len(times) else ""
+
+                        ticker_rows.append({
+                            "Date":            date_str,
+                            "Time":            time_str,
+                            "Predicted Price": float(price),
+                        })
+
+                # ── legacy CSV string response ────────────────────────
+                # ── legacy CSV string response ────────────────────────
+                elif isinstance(param_data, str):
+                    for line in param_data.strip().split("\n")[1:]:
+                        parts = line.split()
+                        if len(parts) >= 3:
+                            ticker_rows.append({
+                                "Date":            parts[0],
+                                "Time":            parts[1],
+                                "Predicted Price": float(parts[2]),
+                            })
+
+                # ── flat list response (safety net for any unstructured list) ──
+                elif isinstance(param_data, list):
+                    for i, price in enumerate(param_data):
+                        if price is None:
+                            continue
+                        ticker_rows.append({
+                            "Date":            "",
+                            "Time":            f"slot_{i}",
+                            "Predicted Price": float(price),
+                        })
+                else:
+                    warnings.append(
+                        f"Unsupported payload type for {ticker}.{param}: {type(param_data)}"
+                    )
+
+            if ticker_rows:
+                parsed[ticker] = ticker_rows
+            else:
+                warnings.append(f"No valid rows parsed for {ticker}")
+
+        return parsed, warnings
+
+    # ------------------------------------------------------------------
+    # INTERNAL: print one ticker's block immediately (avoids buffering)
+    # ------------------------------------------------------------------
+    def _print_ticker_block(self, ticker, rows, col_widths, spacing, divider_width, param=""):
+        """Print a single ticker's rows directly to stdout and flush."""
+
+        thin_div = "-" * divider_width
+
+        def fmt(values):
+            return spacing.join(
+                f"{str(v):<{w}}" for v, w in zip(values, col_widths)
+            )
+
+        for row in rows:
+            if param in ("rrr",):
+                price = f"{float(row['Predicted Price']):.6f}"
+            else:
+                price = f"{float(row['Predicted Price']):.2f}"
+            line  = fmt([ticker, row["Date"], row["Time"], price])
+            print(line)
+
+        print(thin_div)
+        sys.stdout.flush()        # ← force flush after every ticker block
+
+    # ------------------------------------------------------------------
+    # PUBLIC: format + stream-print the full prediction table
+    # ------------------------------------------------------------------
+    def _render_and_print(self, parsed, tickers, param=""):
+        if not parsed:
+            print("  No prediction data available.")
+            return
+
+        headers = ["Ticker", "Date", "Time", "Predicted Price"]
+        spacing = "       "
+
+        # ── compute column widths using ROUNDED prices ─────────────────
+        all_rows_flat = []
+        for ticker, rows in parsed.items():
+            for r in rows:
+                if param in ("rrr",):
+                    price_str = f"{float(r['Predicted Price']):.6f}"
+                else:
+                    price_str = f"{float(r['Predicted Price']):.2f}"
+                all_rows_flat.append(
+                    [ticker, r["Date"], r["Time"], price_str]
+                )
+        col_widths = []
+        for idx, header in enumerate(headers):
+            col_values = [row[idx] for row in all_rows_flat]
+            col_widths.append(
+                max(len(header), max((len(v) for v in col_values), default=0))
+            )
+
+        divider_width = sum(col_widths) + len(spacing) * (len(headers) - 1)
+        divider       = "=" * divider_width
+
+        def fmt(values):
+            return spacing.join(
+                f"{str(v):<{w}}" for v, w in zip(values, col_widths)
+            )
+
+        # ── header ─────────────────────────────────────────────────────
+        print(divider)
+        print(Fore.CYAN + fmt(headers) + Fore.RESET)
+        print(divider)
+        sys.stdout.flush()
+
+        # ── one block per ticker — flush after each ─────────────────────
+        for ticker in tickers:
+            rows = parsed.get(ticker)
+            if not rows:
+                continue
+            self._print_ticker_block(
+                ticker, rows, col_widths, spacing, divider_width, param=param
+            )
+
+        sys.stdout.flush()
+    # ------------------------------------------------------------------
+    # INTERNAL: build combined DataFrame (returned to caller)
+    # ------------------------------------------------------------------
+    def _build_dataframe(self, parsed, tickers):
+        frames = []
+        for ticker in tickers:
+            rows = parsed.get(ticker)
+            if not rows:
+                continue
+            df = pd.DataFrame(rows)
+            df.insert(0, "Ticker", ticker)
+            frames.append(df[["Ticker", "Date", "Time", "Predicted Price"]])
+
+        if frames:
+            return pd.concat(frames, ignore_index=True)
+        return pd.DataFrame(columns=["Ticker", "Date", "Time", "Predicted Price"])
+
+    # ------------------------------------------------------------------
+    # PUBLIC API
+    # ------------------------------------------------------------------
+    def get_prediction(self, tickers, time_frame, parameters, candle="1m"):
+        # normalise inputs
+        if isinstance(tickers, str):
+            tickers = [tickers]
+        if not isinstance(tickers, list):
+            return {"success": False, "error": "Tickers must be a string or list"}
+
+        invalid = [t for t in tickers if t.upper() not in self.SUPPORTED_TICKERS]
+        if invalid:
+            msg = f"Ticker(s) not supported currently: {', '.join(invalid)}"
+            print(f"❌ {msg}")
+            print(f"\n✅ Supported tickers: {', '.join(sorted(self.SUPPORTED_TICKERS))}")
+            return {"success": False, "error": msg}
+
+        tickers = [t.upper() for t in tickers]
+
+        if isinstance(parameters, str):
+            parameters = [parameters]
+
+        try:
+            print("\n" + "=" * 60)
+            print("Getting Predictions")
+            print("=" * 60)
+
+            token_check = self.token_manager.check_token_and_credits()
+            if not token_check["valid"]:
+                print(f"❌ {token_check['error']}")
+                return {"success": False, "error": token_check["error"]}
+
+            print(f"📊 Tickers   : {', '.join(tickers)}")
+            print(f"⏰ Time Frame: {time_frame}")
+            print(f"🕒 Candle    : {candle}")
+            print(f"📈 Parameters: {', '.join(parameters)}")
+
+            payload = {
+                "action": {
+                    "action_type": "predict",
+                    "predict": {
+                        "given": {
+                            "ticker":     tickers,
+                            "time_frame": time_frame,
+                            "candle":     candle,
+                        },
+                        "required": {"parameters": parameters},
+                    },
+                }
+            }
+
+            print("\n🔄 Fetching Predictions ...")
+            response = requests.post(
+                self.base_url,
+                json=payload,
+                headers={"X-Access-Token": self.access_token},
+                timeout=300,
+            )
+            response.raise_for_status()
+            response_json = response.json()
+
+            # parse
+            parsed, warnings = self._parse_response(response_json, tickers, parameters)
+
+            # print any warnings first
+            for w in warnings:
+                print(f"⚠️  {w}")
+                sys.stdout.flush()
+
+            # stream-print table (flush per ticker — no truncation)
+            print("\n" + "=" * 60)
+            print(f"✅ Predictions ({time_frame}, candle={candle})")
+            print("=" * 60)
+            self._render_and_print(parsed, tickers, param=parameters[0] if parameters else "")
+
+            # deduct credit
+            if self.token_manager.deduct_credit():
+                remaining = self.token_manager.get_remaining_credits()
+            else:
+                remaining = 0
+
+            print(f"💳 Remaining credits: {remaining}")
+            if remaining <= 10:
+                print(f"⚠️  Warning: Only {remaining} credits remaining!")
+            if remaining == 0:
+                print("❌ Credits exhausted! Please subscribe to a plan.")
+            print("=" * 60)
+            sys.stdout.flush()
+
+            # build DataFrame for return value
+            df = self._build_dataframe(parsed, tickers)
+
+            return {
+                "success":          True,
+                "data":             df,
+                "credits_remaining": remaining,
+                "timestamp":        datetime.now().isoformat(),
+            }
+
+        except requests.exceptions.Timeout:
+            msg = "Request timed out. Please try again."
+            print(f" {msg}")
+            return {"success": False, "error": msg}
+
+        except requests.exceptions.RequestException as e:
+            msg = f"API request failed: {str(e)}"
+            print(f" {msg}")
+            return {"success": False, "error": msg}
+
+        except Exception as e:
+            import traceback
+            traceback.print_exc()
+            msg = f"Unexpected error: {str(e)}"
+            print(f" {msg}")
+            return {"success": False, "error": msg}
+
+    def get_credits(self):
+        credits = self.token_manager.get_remaining_credits()
+        print(f"💳 Remaining credits: {credits}")
+        return credits

{minting-2.2.5 → minting-2.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: minting
-Version: 2.2.5
+Version: 2.2.7
 Summary: Mintzy SDK for stock price prediction
 Author: Om Kulthe
 Author-email: mintzy01.ai@gmail.com

{minting-2.2.5 → minting-2.2.7}/minting.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: minting
-Version: 2.2.5
+Version: 2.2.7
 Summary: Mintzy SDK for stock price prediction
 Author: Om Kulthe
 Author-email: mintzy01.ai@gmail.com

{minting-2.2.5 → minting-2.2.7}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="minting",
-    version="2.2.5",
+    version="2.2.7",
     description="Mintzy SDK for stock price prediction",
     author="Om Kulthe",
     author_email="mintzy01.ai@gmail.com",

minting-2.2.5/Minting/client.py

@@ -1,497 +0,0 @@
-
-# updated code for client 
-import requests
-import pandas as pd
-import io
-import time
-import os
-import sys
-import hashlib
-from datetime import datetime
-from pymongo import MongoClient
-from colorama import Fore, init as colorama_init
-
-# # ----------------- Database Layer -----------------
-# Initialize ANSI support for Windows terminals
-colorama_init(autoreset=True)
-# ----------------- Database Layer -----------------
-class Database:
-    def __init__(self, mongo_uri, db_name):
-        
-        try:
-            self.client = MongoClient(
-                mongo_uri,
-                serverSelectionTimeoutMS=50000,
-                connectTimeoutMS=100000
-            )
-            # Test connection
-            self.client.server_info()
-            self.db = self.client[db_name]
-            
-        except Exception as e:
-            print(f"❌ Connection Error: {e}")
-            raise
-
-        self.users = self.db["users"]
-        self.access_tokens = self.db["accesstokens"]
-        self.user_plans = self.db["userplans"]
-        self.plans = self.db["plans"]
-
-
-# ----------------- Token Manager -----------------
-class TokenManager:
-    def __init__(self, db: Database, raw_token: str):
-        self.db = db
-        self.raw_token = raw_token.strip()
-        self.hashed_token = self._hash_token(self.raw_token)
-
-    def _hash_token(self, token: str) -> str:
-        """Hash token using SHA-256 (equivalent to Node.js crypto.createHash)"""
-        return hashlib.sha256(token.encode('utf-8')).hexdigest()
-
-    def check_token_and_credits(self):
-        """Validate token and check if user has credits"""
-        token_doc = self.db.access_tokens.find_one({
-            "token": self.hashed_token,
-            "isActive": True
-        })
-        
-        if not token_doc:
-            return {"valid": False, "error": "Invalid or inactive access token"}
-
-        user_id = token_doc["userId"]
-
-        plan_doc = self.db.user_plans.find_one({
-            "userId": user_id,
-            "isActive": True,
-            "expiresAt": {"$gte": datetime.utcnow()}
-        })
-
-        if not plan_doc:
-            return {"valid": False, "error": "No active subscription plan found"}
-
-        credits = plan_doc.get("creditsRemaining", 0)
-
-        if credits <= 0:
-            return {
-                "valid": False, 
-                "error": "Credits exhausted. Please subscribe to a plan to continue.",
-                "creditsRemaining": 0
-            }
-
-        return {
-            "valid": True,
-            "userId": user_id,
-            "planId": plan_doc["_id"],
-            "creditsRemaining": credits
-        }
-
-    def deduct_credit(self):
-        """Deduct one credit (only if credits > 0)"""
-        token_doc = self.db.access_tokens.find_one({
-            "token": self.hashed_token,
-            "isActive": True
-        })
-        
-        if not token_doc:
-            return False
-
-        user_id = token_doc["userId"]
-
-        plan_doc = self.db.user_plans.find_one({
-            "userId": user_id,
-            "isActive": True,
-            "expiresAt": {"$gte": datetime.utcnow()}
-        })
-
-        if not plan_doc:
-            return False
-
-        current_credits = plan_doc.get("creditsRemaining", 0)
-        if current_credits <= 0:
-            return False
-
-        result = self.db.user_plans.update_one(
-            {"_id": plan_doc["_id"], "creditsRemaining": {"$gt": 0}},
-            {
-                "$inc": {"creditsRemaining": -1},
-                "$set": {"updatedAt": datetime.utcnow()}
-            }
-        )
-        return result.modified_count > 0
-
-    def get_remaining_credits(self):
-        """Get remaining credits"""
-        token_doc = self.db.access_tokens.find_one({
-            "token": self.hashed_token,
-            "isActive": True
-        })
-        
-        if not token_doc:
-            return 0
-
-        user_id = token_doc["userId"]
-
-        plan_doc = self.db.user_plans.find_one({
-            "userId": user_id,
-            "isActive": True,
-            "expiresAt": {"$gte": datetime.utcnow()}
-        })
-
-        if not plan_doc:
-            return 0
-
-        return max(plan_doc.get("creditsRemaining", 0), 0)
-
-# ----------------- Client Class -----------------
-class Client:
-    # Supported tickers - only these are allowed
-    SUPPORTED_TICKERS = {
-    "TCS",
-    "HDFCBANK",
-    "BHARTIARTL",
-    "ICICIBANK",
-    "SBIN",
-    "INFY",
-    "BAJFINANCE",
-    "HINDUNILVR",
-    "ITC",
-    "MARUTI",
-    "HCLTECH",
-    "SUNPHARMA",
-    "KOTAKBANK",
-    "AXISBANK",
-    "TATAMOTORS",
-    "ULTRACEMCO",
-    "BAJAJFINSV",
-    "ADANIPORTS",
-    "NTPC",
-    "ONGC",
-    "ASIANPAINT",
-    "JSWSTEEL",
-    "ADANIPOWER",
-    "WIPRO",
-    "ADANIENT",
-    "POWERGRID",
-    "NESTLEIND",
-    "COALINDIA",
-    "INDIGO",
-    "HINDZINC",
-    "TATASTEEL",
-    "VEDL",
-    "SBILIFE",
-    "EICHERMOT",
-    "GRASIM",
-    "HINDALCO",
-    "LTIM",
-    "TVSMOTOR",
-    "DIVISLAB",
-    "HDFCLIFE",
-    "PIDILITIND",
-    "CHOLAFIN",
-    "BRITANNIA",
-    "AMBUJACEM",
-    "GAIL",
-    "BANKBARODA",
-    "GODREJCP",
-    "HEROMOTOCO",
-    "TATAPOWER",
-    }
-    
-    def __init__(
-        self,
-        access_token=None,   # new kw
-        token=None,          # old kw / positional
-        base_url="http://34.70.223.89:8000/predict",
-        mongo_uri="mongodb+srv://ankitarrow:ankitarrow@cluster0.zcajdur.mongodb.net/?retryWrites=true&w=majority&appName=Cluster0",
-        db_name="test"
-    ):
-        # allow: Client(access_token="..."), Client(token="..."), Client("...")
-        if access_token is None and token is None:
-            raise ValueError("Access token must be provided as 'access_token' or 'token'.")
-
-        # if called positionally, first arg will land in access_token
-        self.access_token = (access_token or token).strip()
-        self.base_url = base_url
-        
-        print("="*60)
-        print(" Initializing Mintzy")
-        print("="*60)
-
-        self.db = Database(mongo_uri, db_name)
-        self.token_manager = TokenManager(self.db, self.access_token)
-
-    def _format_table(self, response_json, tickers, parameters):
-        """Format API response into pandas DataFrame"""
-        try:
-            if isinstance(response_json, str):
-                return pd.DataFrame([{"Error": response_json}])
-
-            if not isinstance(response_json, dict):
-                return pd.DataFrame([{"Error": f"Unexpected response type: {type(response_json)}"}])
-
-            result = response_json.get("result", response_json)
-            rows = []
-
-            for ticker in tickers:
-                ticker_data = result.get(ticker) if isinstance(result, dict) else None
-                if ticker_data is None:
-                    print(f"⚠️  No data returned for {ticker}")
-                    continue
-
-                if isinstance(ticker_data, str):
-                    # ticker-level error string from the server
-                    print(f"⚠️  {ticker}: {ticker_data}")
-                    continue
-
-                for param in parameters:
-                    param_data = ticker_data.get(param) if isinstance(ticker_data, dict) else None
-
-                    if param_data is None:
-                        print(f"⚠️  {param} data missing for {ticker}")
-                        continue
-
-                    if isinstance(param_data, dict):
-                        timestamps       = param_data.get("timestamps", [])
-                        predicted_prices = param_data.get("predicted_prices", [])
-                        dates            = param_data.get("dates", [])
-                        times            = param_data.get("times", [])
-
-                        if not predicted_prices:
-                            print(f"⚠️  Empty prediction data for {ticker}.{param}")
-                            continue
-
-                        data_rows = []
-                        for i, price in enumerate(predicted_prices):
-                            if price is None:
-                                continue
-
-                            # Resolve date + time strings
-                            if i < len(timestamps):
-                                ts = str(timestamps[i])
-                                try:
-                                    dt = datetime.fromisoformat(ts)
-                                    date_str = dt.strftime("%Y-%m-%d")
-                                    time_str = dt.strftime("%H:%M:%S")
-                                except Exception:
-                                    # fall back to pre-split fields
-                                    date_str = str(dates[i]) if i < len(dates) else ts
-                                    time_str = str(times[i]) if i < len(times) else ""
-                            else:
-                                date_str = str(dates[i]) if i < len(dates) else ""
-                                time_str = str(times[i]) if i < len(times) else ""
-
-                            data_rows.append({
-                                "Ticker":          ticker,
-                                "Date":            date_str,
-                                "Time":            time_str,
-                                "Predicted Price": float(price),
-                            })
-
-                        if data_rows:
-                            rows.append(pd.DataFrame(data_rows))
-                        else:
-                            print(f"⚠️  No valid rows parsed for {ticker}.{param}")
-
-                    elif isinstance(param_data, str):
-                        # Legacy CSV string response
-                        lines = param_data.strip().split('\n')
-                        data_rows = []
-                        for line in lines[1:]:          # skip header
-                            parts = line.split()
-                            if len(parts) >= 3:
-                                data_rows.append({
-                                    "Ticker":          ticker,
-                                    "Date":            parts[0],
-                                    "Time":            parts[1],
-                                    "Predicted Price": float(parts[2]),
-                                })
-                        if data_rows:
-                            rows.append(pd.DataFrame(data_rows))
-                    else:
-                        print(f"⚠️  Unsupported payload type for {ticker}.{param}: "
-                            f"{type(param_data)}")
-
-            if rows:
-                combined = pd.concat(rows, ignore_index=True)
-                return combined[["Ticker", "Date", "Time", "Predicted Price"]]
-
-            return pd.DataFrame([{"Error": "No data to display"}])
-
-        except Exception as e:
-            import traceback
-            traceback.print_exc()
-            return pd.DataFrame([{"Error": str(e)}])
-
-
-    def _render_table(self, df: pd.DataFrame) -> str:
-        """Return a formatted string for the console with a colored header."""
-        if df.empty or "Error" in df.columns:
-            msg = df.iloc[0].get("Error", "No prediction data available.")
-            return f"  ⚠️  {msg}"
-
-        headers = ["Ticker", "Date", "Time", "Predicted Price"]
-
-        # Ensure all expected columns exist
-        for col in headers:
-            if col not in df.columns:
-                df[col] = ""
-
-        # ── FIX: compute col widths safely, never rely on zip truncation ──────
-        col_widths = []
-        for col in headers:
-            values_in_col = df[col].astype(str).tolist()
-            col_widths.append(max(len(col), max((len(v) for v in values_in_col), default=0)))
-        # ──────────────────────────────────────────────────────────────────────
-
-        spacing = "       "
-
-        def format_row(row_values):
-            return spacing.join(
-                f"{str(val):<{width}}"
-                for val, width in zip(row_values, col_widths)
-            )
-
-        total_width = sum(col_widths) + len(spacing) * (len(headers) - 1)
-        divider     = "=" * total_width
-        thin_div    = "-" * total_width
-
-        lines = [
-            divider,
-            Fore.CYAN + format_row(headers) + Fore.RESET,
-            divider,
-        ]
-
-        # ── FIX: iterate rows directly from DataFrame, not from a values list ─
-        prev_ticker = None
-        for _, row in df.iterrows():
-            row_values  = [str(row[col]) for col in headers]
-            curr_ticker = row_values[0]
-
-            # Insert separator between tickers
-            if prev_ticker is not None and curr_ticker != prev_ticker:
-                lines.append(thin_div)
-
-            lines.append(format_row(row_values))
-            prev_ticker = curr_ticker
-        # ──────────────────────────────────────────────────────────────────────
-
-        lines.append(divider)
-
-        # ── FIX: flush immediately so Jupyter/terminal doesn't buffer-truncate ─
-        result = "\n".join(lines)
-        sys.stdout.flush()
-        return result
-
-    def get_prediction(self, tickers, time_frame, parameters, candle="1m"):
-        # Normalize tickers
-        if isinstance(tickers, str):
-            tickers = [tickers]
-        if not isinstance(tickers, list):
-            return {"success": False, "error": "Tickers must be a string or list"}
-
-        
-        invalid_tickers = [t for t in tickers if t.upper() not in self.SUPPORTED_TICKERS]
-        if invalid_tickers:
-            error_msg = f"Ticker(s) not supported currently: {', '.join(invalid_tickers)}"
-            print(f"❌ {error_msg}")
-            print(f"\n✅ Supported tickers: {', '.join(sorted(self.SUPPORTED_TICKERS))}")
-            return {"success": False, "error": error_msg}
-        
-        tickers = [t.upper() for t in tickers]
-
-        if isinstance(parameters, str):
-            parameters = [parameters]
-
-        try:
-            print("\n" + "="*60)
-            print("Getting Predictions")
-            print("="*60)
-            
-            token_check = self.token_manager.check_token_and_credits()
-            if not token_check["valid"]:
-                print(f"❌ {token_check['error']}")
-                return {"success": False, "error": token_check["error"]}
-
-            print(f"📊 Tickers: {', '.join(tickers)}")
-            print(f"⏰ Time Frame: {time_frame}")
-            print(f"🕒 Candle: {candle}")
-            print(f"📈 Parameters: {', '.join(parameters)}")
-
-            payload = {
-                "action": {
-                    "action_type": "predict",
-                    "predict": {
-                        "given": {
-                            "ticker": tickers,
-                            "time_frame": time_frame,
-                            "candle": candle
-                        },
-                        "required": {
-                            "parameters": parameters
-                        }
-                    }
-                }
-            }
-
-            print("\n🔄 Fetching Predictions ...")
-            response = requests.post(
-                self.base_url,
-                json=payload,
-                headers={"X-Access-Token": self.access_token},
-                timeout=300
-            )
-            response.raise_for_status()
-            response_json = response.json()
-
-            df = self._format_table(response_json, tickers, parameters)
-
-            if self.token_manager.deduct_credit():
-                remaining = self.token_manager.get_remaining_credits()
-            else:
-                remaining = 0
-
-            print("\n" + "="*60)
-            print(f"✅ Predictions ({time_frame}, candle={candle})")
-            print("="*60)
-            print(self._render_table(df))
-            print("="*60)
-            print(f"💳 Remaining credits: {remaining}")
-            
-            if remaining <= 10:
-                print(f"⚠️  Warning: Only {remaining} credits remaining!")
-            if remaining == 0:
-                print("❌ Credits exhausted! Please subscribe to a plan to continue.")
-            
-            print("="*60)
-
-            return {
-                "success": True,
-                "data": df,
-                "credits_remaining": remaining,
-                "timestamp": datetime.now().isoformat()
-            }
-
-        except requests.exceptions.Timeout:
-            error_msg = "Request timed out. Please try again."
-            print(f"❌ {error_msg}")
-            return {"success": False, "error": error_msg}
-
-        except requests.exceptions.RequestException as e:
-            error_msg = f"API request failed: {str(e)}"
-            print(f"❌ {error_msg}")
-            return {"success": False, "error": error_msg}
-
-        except Exception as e:
-            error_msg = f"Unexpected error: {str(e)}"
-            print(f"❌ {error_msg}")
-            return {"success": False, "error": error_msg}
-
-    def get_credits(self):
-        """Get remaining credits for the current token"""
-        credits = self.token_manager.get_remaining_credits()
-        print(f"💳 Remaining credits: {credits}")
-        return credits
-
-
-# -------------- local test --------------