minting 2.2.4__tar.gz → 2.2.5__tar.gz

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

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

{minting-2.2.4 → minting-2.2.5}/Minting/client.py

@@ -14,8 +14,6 @@ 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):
@@ -198,7 +196,6 @@ class Client:
     "GODREJCP",
     "HEROMOTOCO",
     "TATAPOWER",
-
     }
     
     def __init__(
@@ -239,122 +236,153 @@ class Client:
             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}")
+                    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 = None
-                    if isinstance(ticker_data, dict):
-                        param_data = ticker_data.get(param)
+                    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}")
+                        print(f"⚠️  {param} data missing for {ticker}")
                         continue
 
-                    # ---- NEW: handle structured list response ----
                     if isinstance(param_data, dict):
-                        timestamps = param_data.get("timestamps", [])
+                        timestamps       = param_data.get("timestamps", [])
                         predicted_prices = param_data.get("predicted_prices", [])
-                        dates = param_data.get("dates", [])
-                        times = param_data.get("times", [])
+                        dates            = param_data.get("dates", [])
+                        times            = param_data.get("times", [])
+
+                        if not predicted_prices:
+                            print(f"⚠️  Empty prediction data for {ticker}.{param}")
+                            continue
 
-                        if timestamps and predicted_prices:
-                            data_rows = []
-                            for i, ts in enumerate(timestamps):
+                        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:
-                                    # Parse "2026-02-22 09:15" into date and time
-                                    dt = datetime.strptime(ts, "%Y-%m-%d %H:%M")
+                                    dt = datetime.fromisoformat(ts)
                                     date_str = dt.strftime("%Y-%m-%d")
-                                    time_str = dt.strftime("%H:%M")
-                                except:
-                                    # Fallback to pre-split dates/times if available
-                                    date_str = dates[i] if i < len(dates) else ts
-                                    time_str = times[i] if i < len(times) else ""
-
-                                price = predicted_prices[i] if i < len(predicted_prices) else None
-                                if price is not None:
-                                    data_rows.append({
-                                        "Date": date_str,
-                                        "Time": time_str,
-                                        "Predicted Price": float(price)
-                                    })
-
-                            if data_rows:
-                                df = pd.DataFrame(data_rows)
-                                df["Ticker"] = ticker
-                                rows.append(df[["Ticker", "Date", "Time", "Predicted Price"]])
+                                    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:
-                                print(f"⚠️ No valid rows parsed for {ticker}.{param}")
+                                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"⚠️ Empty prediction data for {ticker}.{param}")
+                            print(f"⚠️  No valid rows parsed for {ticker}.{param}")
 
-                    # ---- OLD: handle legacy CSV string response ----
                     elif isinstance(param_data, str):
-                        raw_data = param_data
-                        if not raw_data:
-                            print(f"⚠️ Empty prediction data for {ticker}.{param}")
-                            continue
-                        lines = raw_data.strip().split('\n')
-                        if len(lines) < 2:
-                            print(f"⚠️ Insufficient rows for {ticker}.{param}")
-                            continue
+                        # Legacy CSV string response
+                        lines = param_data.strip().split('\n')
                         data_rows = []
-                        for line in lines[1:]:
+                        for line in lines[1:]:          # skip header
                             parts = line.split()
                             if len(parts) >= 3:
                                 data_rows.append({
-                                    "Date": parts[0],
-                                    "Time": parts[1],
-                                    "Predicted Price": float(parts[2])
+                                    "Ticker":          ticker,
+                                    "Date":            parts[0],
+                                    "Time":            parts[1],
+                                    "Predicted Price": float(parts[2]),
                                 })
                         if data_rows:
-                            df = pd.DataFrame(data_rows)
-                            df["Ticker"] = ticker
-                            rows.append(df[["Ticker", "Date", "Time", "Predicted Price"]])
+                            rows.append(pd.DataFrame(data_rows))
                     else:
-                        print(f"⚠️ Unsupported payload type for {ticker}.{param}: {type(param_data)}")
+                        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"]]
-            else:
-                return pd.DataFrame([{"Error": "No data to display"}])
+
+            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:
-            return "  No prediction data available."
+        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"]
-        values = df[headers].astype(str).values.tolist()
 
-        col_widths = [max(len(str(item)) for item in col) for col in zip(*([headers] + values))]
+        # 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):
-            cells = [f"{str(val):<{width}}" for val, width in zip(row, col_widths)]
-            return spacing.join(cells)
+
+        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
-
-        rows_lines = []
-        for idx, row in enumerate(values):
-            row_line = format_row(row)
-            rows_lines.append(row_line)
-            next_ticker = values[idx + 1][0] if idx + 1 < len(values) else None
-            if next_ticker != row[0]:
-                rows_lines.append("-" * total_width)
-
-        lines = [divider, Fore.CYAN + format_row(headers) + Fore.RESET, divider]
-        lines.extend(rows_lines)
+        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)
-        return "\n".join(lines)
 
-    
+        # ── 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):

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

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

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

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

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

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