liquidator-indicator 0.0.4__py3-none-any.whl → 0.0.6__py3-none-any.whl

liquidator_indicator/__init__.py

@@ -0,0 +1,6 @@
+"""Liquidator indicator package - lightweight core API."""
+from .core import Liquidator
+from .indicators import compute_vwap, compute_atr
+
+__all__ = ["Liquidator", "compute_vwap", "compute_atr"]
+__version__ = "0.0.2"

liquidator_indicator/collectors/__init__.py

@@ -0,0 +1,11 @@
+"""
+Data stream collectors for liquidator_indicator package.
+
+These are OPTIONAL utilities that help users collect public data feeds.
+Users can either:
+1. Use these collectors to automate data gathering
+2. Implement their own collectors
+3. Feed data from existing sources (files, APIs, etc.)
+
+The indicator package itself is data-source agnostic.
+"""

liquidator_indicator/collectors/funding.py

@@ -0,0 +1,202 @@
+"""
+FundingRateCollector - Collect live funding rates and open interest from Hyperliquid WebSocket.
+
+Based on src/data/funding_ws_connection.py pattern but simplified for package distribution.
+
+Usage:
+    from liquidator_indicator.collectors.funding import FundingRateCollector
+    
+    collector = FundingRateCollector(symbols=['BTC', 'ETH'])
+    collector.start()
+    
+    # Get latest data
+    data = collector.get_latest()
+    print(data)
+    # {'BTC': {'funding_rate': 0.0001, 'open_interest': 12345.67, 'timestamp': '2026-02-02T...'}}
+    
+    # Feed to indicator
+    liq.ingest_funding_rates(data)
+    
+    collector.stop()
+"""
+import json
+import time
+import threading
+from datetime import datetime, timezone
+from typing import List, Dict, Optional, Callable
+import logging
+
+try:
+    import websocket
+except ImportError:
+    raise ImportError("websocket-client required: pip install websocket-client")
+
+logger = logging.getLogger("liquidator_indicator.funding_collector")
+
+
+class FundingRateCollector:
+    """Collect live funding rates and open interest from Hyperliquid WebSocket."""
+    
+    def __init__(
+        self,
+        symbols: List[str],
+        ws_url: str = "wss://api.hyperliquid.xyz/ws",
+        callback: Optional[Callable] = None
+    ):
+        """
+        Args:
+            symbols: List of coin symbols to track (e.g. ['BTC', 'ETH'])
+            ws_url: WebSocket endpoint URL
+            callback: Optional function called on each update: callback(symbol, data)
+        """
+        self.symbols = [s.upper() for s in symbols]
+        self.ws_url = ws_url
+        self.callback = callback
+        
+        self._data = {}  # {symbol: {funding_rate, open_interest, timestamp}}
+        self._ws = None
+        self._thread = None
+        self._running = False
+        self._lock = threading.Lock()
+    
+    def start(self):
+        """Start WebSocket connection in background thread."""
+        if self._running:
+            logger.warning("Collector already running")
+            return
+        
+        self._running = True
+        self._thread = threading.Thread(target=self._run_ws, daemon=True)
+        self._thread.start()
+        logger.info(f"FundingRateCollector started for {self.symbols}")
+    
+    def stop(self):
+        """Stop WebSocket connection."""
+        self._running = False
+        if self._ws:
+            try:
+                self._ws.close()
+            except Exception:
+                pass
+        if self._thread:
+            self._thread.join(timeout=2)
+        logger.info("FundingRateCollector stopped")
+    
+    def get_latest(self) -> Dict[str, Dict]:
+        """Get latest funding data for all symbols.
+        
+        Returns:
+            {symbol: {funding_rate, open_interest, timestamp}}
+        """
+        with self._lock:
+            return self._data.copy()
+    
+    def get_symbol(self, symbol: str) -> Optional[Dict]:
+        """Get latest data for specific symbol."""
+        with self._lock:
+            return self._data.get(symbol.upper())
+    
+    def _run_ws(self):
+        """WebSocket main loop (runs in background thread)."""
+        while self._running:
+            try:
+                self._ws = websocket.WebSocketApp(
+                    self.ws_url,
+                    on_message=self._on_message,
+                    on_error=self._on_error,
+                    on_close=self._on_close,
+                    on_open=self._on_open
+                )
+                self._ws.run_forever()
+            except Exception as e:
+                logger.error(f"WebSocket error: {e}")
+            
+            if self._running:
+                logger.info("Reconnecting in 5s...")
+                time.sleep(5)
+    
+    def _on_open(self, ws):
+        """Subscribe to activeAssetCtx channel for funding rates."""
+        logger.info("WebSocket connected")
+        for symbol in self.symbols:
+            sub_msg = json.dumps({
+                "method": "subscribe",
+                "subscription": {
+                    "type": "activeAssetCtx",
+                    "coin": symbol
+                }
+            })
+            ws.send(sub_msg)
+            logger.info(f"Subscribed to {symbol} funding/OI")
+    
+    def _on_message(self, ws, message):
+        """Process funding rate updates."""
+        try:
+            if message == '{"channel":"pong"}':
+                return
+            
+            data = json.loads(message)
+            channel = data.get('channel', '')
+            
+            if channel == 'activeAssetCtx':
+                asset_data = data.get('data', {})
+                coin = asset_data.get('coin', '')
+                ctx = asset_data.get('ctx', {})
+                
+                if coin and ctx and coin in self.symbols:
+                    funding_rate = float(ctx.get('funding', 0))
+                    open_interest = float(ctx.get('openInterest', 0))
+                    timestamp = datetime.now(timezone.utc).isoformat()
+                    
+                    update = {
+                        'funding_rate': funding_rate,
+                        'open_interest': open_interest,
+                        'timestamp': timestamp
+                    }
+                    
+                    with self._lock:
+                        self._data[coin] = update
+                    
+                    logger.debug(f"{coin}: funding={funding_rate:.6f}, oi={open_interest:.2f}")
+                    
+                    # Call user callback if provided
+                    if self.callback:
+                        try:
+                            self.callback(coin, update)
+                        except Exception as e:
+                            logger.error(f"Callback error: {e}")
+        
+        except Exception as e:
+            logger.error(f"Message parse error: {e}")
+    
+    def _on_error(self, ws, error):
+        logger.error(f"WebSocket error: {error}")
+    
+    def _on_close(self, ws, close_status_code, close_msg):
+        logger.info(f"WebSocket closed: {close_status_code} {close_msg}")
+
+
+# Example usage
+if __name__ == '__main__':
+    logging.basicConfig(level=logging.INFO)
+    
+    def on_update(symbol, data):
+        print(f"UPDATE: {symbol} @ {data['timestamp']}")
+        print(f"  Funding: {data['funding_rate']:.6f}")
+        print(f"  OI: {data['open_interest']:.2f}")
+    
+    collector = FundingRateCollector(
+        symbols=['BTC', 'ETH', 'SOL'],
+        callback=on_update
+    )
+    
+    collector.start()
+    
+    try:
+        while True:
+            time.sleep(10)
+            latest = collector.get_latest()
+            print(f"\nLatest data: {len(latest)} symbols")
+    except KeyboardInterrupt:
+        print("\nStopping...")
+        collector.stop()

liquidator_indicator/core.py

@@ -0,0 +1,447 @@
+"""Core logic for liquidator indicator: infer liquidation zones from public trade data.
+
+Instead of using private liquidation feeds, this analyzes PUBLIC TRADE DATA to detect
+liquidation-like patterns and cluster them into zones. Works with data anyone can collect
+from public websocket feeds.
+"""
+from typing import List, Dict, Optional
+import pandas as pd
+import numpy as np
+import math
+from datetime import datetime, timezone
+
+# Try to import numba optimizations, fall back to pure Python if not available
+try:
+    from . import numba_optimized
+    NUMBA_AVAILABLE = True
+except ImportError:
+    NUMBA_AVAILABLE = False
+
+DEFAULT_PCT_MERGE = 0.003  # 0.3%
+DEFAULT_LIQ_SIZE_THRESHOLD = 0.1  # BTC minimum for liquidation inference
+
+class Liquidator:
+    """Infer liquidation zones from public trade data.
+
+    Detects liquidation-like patterns from public trades:
+    - Large sudden trades (size threshold)
+    - Rapid price moves with volume spikes
+    - Clustered trades at price levels
+
+    Usage:
+        L = Liquidator()
+        L.ingest_trades(trades_list)  # public trade data
+        zones = L.compute_zones()
+    """
+    def __init__(self, coin: str = 'BTC', pct_merge: float = DEFAULT_PCT_MERGE, zone_vol_mult: float = 1.5, window_minutes: int = 30, liq_size_threshold: float = DEFAULT_LIQ_SIZE_THRESHOLD):
+        self.coin = coin
+        self._trades = pd.DataFrame()
+        self._inferred_liqs = pd.DataFrame()
+        self._funding_data = pd.DataFrame()  # NEW: funding rates + open interest
+        self._candles = None
+        self._zone_history = []  # track zone width over time for expansion/contraction
+        # configuration
+        self.pct_merge = float(pct_merge)
+        self.zone_vol_mult = float(zone_vol_mult)
+        self.window_minutes = int(window_minutes)
+        self.liq_size_threshold = float(liq_size_threshold)
+
+    def ingest_trades(self, data):
+        """Ingest public trade data and infer liquidation events.
+        
+        Accepts list[dict] or DataFrame with fields:
+        - time/timestamp: trade timestamp (ms or ISO)
+        - px/price: trade price
+        - sz/size: trade size
+        - side: 'A' (ask/sell) or 'B' (bid/buy)
+        - coin: asset symbol
+        """
+        if data is None:
+            return
+        if isinstance(data, pd.DataFrame):
+            df = data.copy()
+        else:
+            df = pd.DataFrame(data)
+        if df.empty:
+            return
+        
+        # normalize timestamp
+        if 'time' in df.columns:
+            try:
+                df['timestamp'] = pd.to_datetime(df['time'], unit='ms', errors='coerce', utc=True)
+            except Exception:
+                df['timestamp'] = pd.to_datetime(df['time'], errors='coerce', utc=True)
+        elif 'timestamp' in df.columns:
+            df['timestamp'] = pd.to_datetime(df['timestamp'], errors='coerce', utc=True)
+        else:
+            df['timestamp'] = pd.to_datetime(df.iloc[:,0], errors='coerce', utc=True)
+        
+        # normalize price/size
+        if 'px' in df.columns:
+            df['price'] = pd.to_numeric(df['px'], errors='coerce')
+        elif 'price' not in df.columns:
+            df['price'] = pd.to_numeric(df.iloc[:,2], errors='coerce')
+        else:
+            df['price'] = pd.to_numeric(df['price'], errors='coerce')
+            
+        if 'sz' in df.columns:
+            df['size'] = pd.to_numeric(df['sz'], errors='coerce')
+        elif 'size' not in df.columns:
+            df['size'] = pd.to_numeric(df.iloc[:,3], errors='coerce')
+        else:
+            df['size'] = pd.to_numeric(df['size'], errors='coerce')
+        
+        # normalize side
+        if 'side' in df.columns:
+            df['side'] = df['side'].astype(str).str.upper()
+        df['coin'] = df.get('coin', self.coin)
+        df['usd_value'] = df['price'] * df['size']
+        
+        df = df[['timestamp','side','coin','price','size','usd_value']]
+        df = df.dropna(subset=['timestamp','price','size'])
+        df = df.sort_values('timestamp')
+        
+        # store raw trades
+        if self._trades.empty:
+            self._trades = df
+        else:
+            self._trades = pd.concat([self._trades, df], ignore_index=True).drop_duplicates().sort_values('timestamp')
+        
+        # filter to keep only recent trades (last 48h by default)
+        cutoff_time = pd.Timestamp.now(tz='UTC') - pd.Timedelta(hours=48)
+        self._trades = self._trades[self._trades['timestamp'] >= cutoff_time]
+        
+        # infer liquidations from trade patterns
+        self._infer_liquidations()
+    
+    def _infer_liquidations(self):
+        """Detect liquidation-like events from trade patterns + funding/OI signals."""
+        if self._trades.empty:
+            return
+        
+        df = self._trades.copy()
+        
+        # Pattern 1: Large trades (likely forced liquidations)
+        large_trades = df[df['size'] >= self.liq_size_threshold].copy()
+        
+        # Pattern 2: Rapid price moves with volume spikes (cascade indicator)
+        df['price_change'] = df['price'].pct_change().abs()
+        df['vol_spike'] = df['size'] > df['size'].rolling(20, min_periods=1).mean() * 2
+        cascades = df[(df['price_change'] > 0.001) & df['vol_spike']].copy()
+        
+        # Pattern 3: Funding rate extremes (NEW)
+        # Extreme funding (>0.1% or <-0.1%) indicates overleveraged positions
+        funding_liqs = pd.DataFrame()
+        if not self._funding_data.empty:
+            try:
+                # Get latest funding for this coin
+                coin_funding = self._funding_data[self._funding_data['symbol'] == self.coin]
+                if not coin_funding.empty:
+                    latest_funding = coin_funding.iloc[-1]
+                    funding_rate = float(latest_funding.get('funding_rate', 0))
+                    
+                    # Extreme funding threshold
+                    if abs(funding_rate) > 0.001:  # 0.1%
+                        # Trades during extreme funding = higher liquidation probability
+                        # Apply 1.5x weight multiplier to these trades
+                        funding_liqs = df.copy()
+                        funding_liqs['usd_value'] = funding_liqs['usd_value'] * 1.5
+                        funding_liqs = funding_liqs.head(int(len(funding_liqs) * 0.3))  # Top 30% by recency
+            except Exception:
+                pass
+        
+        # Pattern 4: Open interest drops (NEW)
+        # Sudden OI drops indicate liquidations happening NOW
+        oi_liqs = pd.DataFrame()
+        if not self._funding_data.empty and len(self._funding_data) > 1:
+            try:
+                coin_oi = self._funding_data[self._funding_data['symbol'] == self.coin].sort_values('timestamp')
+                if len(coin_oi) >= 2:
+                    oi_change_pct = (coin_oi['open_interest'].iloc[-1] - coin_oi['open_interest'].iloc[-2]) / coin_oi['open_interest'].iloc[-2]
+                    
+                    # OI drop >5% = confirmed liquidation event
+                    if oi_change_pct < -0.05:
+                        # Recent trades during OI drop = confirmed liquidations
+                        # Apply 2x weight multiplier
+                        recent_window = pd.Timestamp.now(tz='UTC') - pd.Timedelta(minutes=5)
+                        oi_liqs = df[df['timestamp'] > recent_window].copy()
+                        oi_liqs['usd_value'] = oi_liqs['usd_value'] * 2.0
+            except Exception:
+                pass
+        
+        # Combine all patterns
+        patterns = [large_trades, cascades]
+        if not funding_liqs.empty:
+            patterns.append(funding_liqs)
+        if not oi_liqs.empty:
+            patterns.append(oi_liqs)
+        
+        inferred = pd.concat(patterns, ignore_index=True).drop_duplicates(subset=['timestamp','price'])
+        
+        if inferred.empty:
+            self._inferred_liqs = pd.DataFrame()
+            return
+        
+        # Map side: A (ask/sell) = long liquidation, B (bid/buy) = short liquidation
+        inferred['side'] = inferred['side'].map({'A': 'long', 'B': 'short'})
+        
+        self._inferred_liqs = inferred[['timestamp','side','coin','price','usd_value']].sort_values('timestamp')
+    
+    def ingest_funding_rates(self, data):
+        """Ingest funding rate and open interest data.
+        
+        Accepts dict {symbol: {funding_rate, open_interest, timestamp}} or DataFrame.
+        Used to enhance liquidation detection with funding/OI signals.
+        
+        Example:
+            funding = {'BTC': {'funding_rate': 0.0001, 'open_interest': 12345.67, 'timestamp': '...'}}
+            liq.ingest_funding_rates(funding)
+        """
+        if data is None:
+            return
+        
+        if isinstance(data, dict):
+            # Convert dict to DataFrame
+            rows = []
+            for symbol, vals in data.items():
+                rows.append({
+                    'symbol': symbol,
+                    'funding_rate': float(vals.get('funding_rate', 0)),
+                    'open_interest': float(vals.get('open_interest', 0)),
+                    'timestamp': vals.get('timestamp', datetime.now(timezone.utc).isoformat())
+                })
+            df = pd.DataFrame(rows)
+        else:
+            df = data.copy() if isinstance(data, pd.DataFrame) else pd.DataFrame(data)
+        
+        if df.empty:
+            return
+        
+        # Normalize timestamp
+        if 'timestamp' in df.columns:
+            df['timestamp'] = pd.to_datetime(df['timestamp'], utc=True, errors='coerce')
+        
+        # Merge with existing data
+        if self._funding_data.empty:
+            self._funding_data = df
+        else:
+            # Keep most recent data per symbol
+            combined = pd.concat([self._funding_data, df], ignore_index=True)
+            self._funding_data = combined.sort_values('timestamp').groupby('symbol').tail(1).reset_index(drop=True)
+    
+    def ingest_liqs(self, data):
+        """Legacy method for backward compatibility. Redirects to ingest_trades."""
+        self.ingest_trades(data)
+
+    def update_candles(self, df: pd.DataFrame):
+        """Optional candle series used to compute volatility-adjusted bands."""
+        self._candles = df.copy()
+
+    def compute_zones(self, window_minutes: Optional[int] = None, pct_merge: Optional[float] = None, use_atr: bool = True):
+        """Cluster inferred liquidations by price into zones.
+        Returns DataFrame of zones: price_mean, price_min, price_max, total_usd, count, first_ts, last_ts, strength
+        """
+        if self._inferred_liqs.empty:
+            return pd.DataFrame()
+        # determine params
+        window_minutes = int(window_minutes) if window_minutes is not None else int(self.window_minutes)
+        pct_merge = float(pct_merge) if pct_merge is not None else float(self.pct_merge)
+        # limit to recent window
+        now = pd.Timestamp.utcnow()
+        window_start = now - pd.Timedelta(minutes=window_minutes)
+        df = self._inferred_liqs[self._inferred_liqs['timestamp'] >= window_start].copy()
+        # If filtering by recent window returns nothing (e.g., test data with static timestamps),
+        # fall back to using all available inferred liquidations so the algorithms can still run.
+        if df.empty:
+            df = self._inferred_liqs.copy()
+        # sort by price and iterate to form clusters
+        df = df.sort_values('price').reset_index(drop=True)
+        
+        # Use Numba-optimized clustering if available
+        if NUMBA_AVAILABLE and len(df) > 100:  # Worth it for larger datasets
+            # Prepare numpy arrays for numba
+            prices = df['price'].to_numpy(dtype=np.float64)
+            usd_values = df['usd_value'].fillna(0.0).to_numpy(dtype=np.float64)
+            timestamps_seconds = (df['timestamp'].astype(np.int64).to_numpy() / 1e9).astype(np.float64)
+            
+            # Encode sides: 0=unknown, 1=long, 2=short
+            side_map = {'long': 1, 'short': 2}
+            sides_encoded = df['side'].map(side_map).fillna(0).astype(np.int32).to_numpy()
+            
+            # Run numba clustering
+            (cluster_ids, cluster_means, cluster_mins, cluster_maxs, cluster_usds,
+             cluster_cnts, cluster_ts_firsts, cluster_ts_lasts, cluster_longs, cluster_shorts) = \
+                numba_optimized.cluster_prices_numba(prices, usd_values, timestamps_seconds, 
+                                                      sides_encoded, pct_merge)
+            
+            # Determine dominant side per cluster
+            dominant_sides = []
+            for i in range(len(cluster_means)):
+                if cluster_longs[i] > cluster_shorts[i]:
+                    dominant_sides.append('long')
+                elif cluster_shorts[i] > cluster_longs[i]:
+                    dominant_sides.append('short')
+                else:
+                    dominant_sides.append('unknown')
+            
+            # Compute strength using numba
+            current_time_sec = pd.Timestamp.utcnow().timestamp()
+            strengths = numba_optimized.compute_strength_batch(
+                cluster_usds, cluster_cnts, cluster_ts_lasts, current_time_sec
+            )
+            
+            # Build output DataFrame
+            zones_df = pd.DataFrame({
+                'price_mean': cluster_means,
+                'price_min': cluster_mins,
+                'price_max': cluster_maxs,
+                'total_usd': cluster_usds,
+                'count': cluster_cnts,
+                'first_ts': pd.to_datetime(cluster_ts_firsts, unit='s', utc=True),
+                'last_ts': pd.to_datetime(cluster_ts_lasts, unit='s', utc=True),
+                'dominant_side': dominant_sides,
+                'strength': strengths
+            }).sort_values('strength', ascending=False)
+        else:
+            # Fallback to original Python implementation
+            clusters = []
+            cur = {'prices': [], 'usd': 0.0, 'count': 0, 'ts_first': None, 'ts_last': None, 'sides': {}}
+            for _, row in df.iterrows():
+                p = float(row['price'])
+                u = float(row.get('usd_value') or 0.0)
+                ts = pd.to_datetime(row['timestamp'])
+                side_val = str(row['side']) if pd.notna(row['side']) else 'unknown'
+                if cur['count'] == 0:
+                    cur['prices'] = [p]
+                    cur['usd'] = u
+                    cur['count'] = 1
+                    cur['ts_first'] = ts
+                    cur['ts_last'] = ts
+                    cur['sides'] = {side_val: 1}
+                    continue
+                pm = np.mean(cur['prices'])
+                # pct distance
+                if abs(p - pm) / pm <= pct_merge:
+                    cur['prices'].append(p)
+                    cur['usd'] += u
+                    cur['count'] += 1
+                    cur['ts_last'] = max(cur['ts_last'], ts)
+                    cur['sides'][side_val] = cur['sides'].get(side_val,0) + 1
+                else:
+                    clusters.append(cur)
+                    cur = {'prices':[p], 'usd':u, 'count':1, 'ts_first':ts, 'ts_last':ts, 'sides':{side_val:1}}
+            if cur['count'] > 0:
+                clusters.append(cur)
+            # build DataFrame
+            out = []
+            for c in clusters:
+                prices = np.array(c['prices'], dtype=float)
+                price_mean = float(prices.mean())
+                price_min = float(prices.min())
+                price_max = float(prices.max())
+                total_usd = float(c['usd'])
+                count = int(c['count'])
+                first_ts = c['ts_first']
+                last_ts = c['ts_last']
+                sides = c['sides']
+                dominant_side = max(sides.items(), key=lambda x: x[1])[0] if sides else None
+                strength = self._compute_strength(total_usd, count, last_ts)
+                out_item = {'price_mean':price_mean,'price_min':price_min,'price_max':price_max,'total_usd':total_usd,'count':count,'first_ts':first_ts,'last_ts':last_ts,'dominant_side':dominant_side,'strength':strength}
+                out.append(out_item)
+            zones_df = pd.DataFrame(out).sort_values('strength', ascending=False)
+
+        # compute volatility band (ATR) if requested and candles available
+        if use_atr and self._candles is not None and not self._candles.empty and 'high' in self._candles.columns and 'low' in self._candles.columns and 'close' in self._candles.columns:
+            try:
+                if NUMBA_AVAILABLE:
+                    # Use numba-optimized ATR
+                    high = self._candles['high'].to_numpy(dtype=np.float64)
+                    low = self._candles['low'].to_numpy(dtype=np.float64)
+                    close = self._candles['close'].to_numpy(dtype=np.float64)
+                    atr_array = numba_optimized.compute_atr_numba(high, low, close, per=14)
+                    last_atr = float(atr_array[-1]) if len(atr_array) > 0 else 0.0
+                else:
+                    atr = self._compute_atr(self._candles)
+                    last_atr = float(atr.iloc[-1]) if not atr.empty else 0.0
+            except Exception:
+                last_atr = 0.0
+        else:
+            last_atr = 0.0
+
+        # apply band: band = max(perc-based pad, atr*zone_vol_mult)
+        if NUMBA_AVAILABLE and not zones_df.empty:
+            # Use numba-optimized band computation
+            price_means = zones_df['price_mean'].to_numpy(dtype=np.float64)
+            band_widths, entry_lows, entry_highs, band_pcts = \
+                numba_optimized.compute_zone_bands(price_means, pct_merge, last_atr, self.zone_vol_mult)
+            
+            zones_df['atr'] = last_atr
+            zones_df['band'] = band_widths
+            zones_df['band_pct'] = band_pcts
+            zones_df['entry_low'] = entry_lows
+            zones_df['entry_high'] = entry_highs
+        else:
+            # Fallback to original implementation
+            bands = []
+            for _, row in zones_df.iterrows():
+                pm = float(row['price_mean'])
+                # percent padding fallback (small)
+                pct_pad = max(0.001, pct_merge)
+                pad_by_pct = pm * pct_pad
+                pad_by_atr = last_atr * float(self.zone_vol_mult)
+                pad = max(pad_by_pct, pad_by_atr)
+                entry_low = pm - pad
+                entry_high = pm + pad
+                band_pct = pad / pm if pm else 0.0
+                bands.append({'atr': last_atr, 'band': pad, 'band_pct': band_pct, 'entry_low': entry_low, 'entry_high': entry_high})
+            if bands:
+                bands_df = pd.DataFrame(bands)
+                zones_df = pd.concat([zones_df.reset_index(drop=True), bands_df.reset_index(drop=True)], axis=1)
+        
+        # Track zone width for regime detection
+        if not zones_df.empty and 'band' in zones_df.columns:
+            avg_width = float(zones_df['band'].mean())
+            self._zone_history.append({'timestamp': pd.Timestamp.utcnow(), 'avg_width': avg_width})
+            # Keep last 20 measurements
+            if len(self._zone_history) > 20:
+                self._zone_history = self._zone_history[-20:]
+        
+        return zones_df
+
+    def _compute_strength(self, usd_total: float, count: int, last_ts: Optional[pd.Timestamp]):
+        """Heuristic scoring: combine usd_total (log), count, and recency (time decay)."""
+        a = math.log1p(usd_total)
+        b = math.log1p(count)
+        recency_weight = 1.0
+        try:
+            if last_ts is not None:
+                age_sec = (pd.Timestamp.utcnow() - pd.to_datetime(last_ts)).total_seconds()
+                # recent events score higher — decay with half-life of 1 hour
+                recency_weight = 1.0 / (1.0 + (age_sec / 3600.0))
+        except Exception:
+            recency_weight = 1.0
+        score = (a * 0.6 + b * 0.4) * recency_weight
+        return float(score)
+
+    def _compute_atr(self, candles: pd.DataFrame, per: int = 14) -> pd.Series:
+        """Compute ATR series (Wilder) from candle DF with high/low/close columns."""
+        df = candles.copy()
+        df['high'] = pd.to_numeric(df['high'], errors='coerce')
+        df['low'] = pd.to_numeric(df['low'], errors='coerce')
+        df['close'] = pd.to_numeric(df['close'], errors='coerce')
+        tr1 = df['high'] - df['low']
+        tr2 = (df['high'] - df['close'].shift(1)).abs()
+        tr3 = (df['low'] - df['close'].shift(1)).abs()
+        tr = pd.concat([tr1, tr2, tr3], axis=1).max(axis=1).dropna()
+        atr = tr.ewm(alpha=1.0/per, adjust=False).mean()
+        return atr
+
+    def get_nearest_zone(self, price: float, zones_df: Optional[pd.DataFrame] = None):
+        """Return nearest zone row (as dict) to `price` or None."""
+        if zones_df is None:
+            zones_df = self.compute_zones()
+        if zones_df is None or zones_df.empty:
+            return None
+        zones_df['dist'] = (zones_df['price_mean'] - price).abs() / zones_df['price_mean']
+        r = zones_df.sort_values('dist').iloc[0]
+        return r.to_dict()

liquidator_indicator/indicators.py

@@ -0,0 +1,52 @@
+"""Common indicator helpers: VWAP and ATR that are useful for zone banding."""
+from typing import Optional
+import pandas as pd
+
+
+def compute_vwap(candles: pd.DataFrame, period: Optional[int] = None, price_col: str = 'close', vol_col: str = 'volume') -> pd.Series:
+    """Compute VWAP series from candles.
+
+    If `period` is None returns cumulative VWAP, otherwise a rolling-window VWAP of given length.
+    Candles must contain price and volume columns.
+    """
+    if candles is None or candles.empty:
+        return pd.Series(dtype=float)
+    df = candles.copy()
+    # normalize column names
+    if price_col not in df.columns:
+        if 'close' in df.columns:
+            price_col = 'close'
+        elif 'px' in df.columns:
+            price_col = 'px'
+    if vol_col not in df.columns:
+        if 'volume' in df.columns:
+            vol_col = 'volume'
+    df[price_col] = pd.to_numeric(df[price_col], errors='coerce')
+    df[vol_col] = pd.to_numeric(df[vol_col], errors='coerce').fillna(0.0)
+    tp_vol = df[price_col] * df[vol_col]
+    if period is None:
+        cum_tp_vol = tp_vol.cumsum()
+        cum_vol = df[vol_col].cumsum()
+        vwap = cum_tp_vol / cum_vol.replace({0: pd.NA})
+        return vwap.ffill().fillna(0.0)
+    else:
+        tp_vol_r = tp_vol.rolling(window=period, min_periods=1).sum()
+        vol_r = df[vol_col].rolling(window=period, min_periods=1).sum()
+        vwap = tp_vol_r / vol_r.replace({0: pd.NA})
+        return vwap.ffill().fillna(0.0)
+
+
+def compute_atr(candles: pd.DataFrame, per: int = 14) -> pd.Series:
+    """Public ATR computation (Wilder-style) from candles with high/low/close columns."""
+    if candles is None or candles.empty:
+        return pd.Series(dtype=float)
+    df = candles.copy()
+    df['high'] = pd.to_numeric(df['high'], errors='coerce')
+    df['low'] = pd.to_numeric(df['low'], errors='coerce')
+    df['close'] = pd.to_numeric(df['close'], errors='coerce')
+    tr1 = df['high'] - df['low']
+    tr2 = (df['high'] - df['close'].shift(1)).abs()
+    tr3 = (df['low'] - df['close'].shift(1)).abs()
+    tr = pd.concat([tr1, tr2, tr3], axis=1).max(axis=1).dropna()
+    atr = tr.ewm(alpha=1.0/per, adjust=False).mean()
+    return atr

liquidator_indicator/numba_optimized.py

@@ -0,0 +1,351 @@
+"""Numba-optimized functions for performance-critical operations.
+
+These JIT-compiled functions provide 10-100x speedup for numerical loops:
+- Price clustering algorithm
+- Strength computation with time decay
+- ATR (Average True Range) calculation
+"""
+import numpy as np
+from numba import jit
+
+
+@jit(nopython=True, cache=True)
+def cluster_prices_numba(prices, usd_values, timestamps_seconds, sides_encoded, pct_merge):
+    """Fast clustering of prices into zones using numba JIT.
+    
+    Args:
+        prices: np.array of float prices (sorted)
+        usd_values: np.array of float USD values
+        timestamps_seconds: np.array of float timestamps (seconds since epoch)
+        sides_encoded: np.array of int (0=unknown, 1=long, 2=short)
+        pct_merge: float percentage threshold for merging (e.g., 0.003 for 0.3%)
+    
+    Returns:
+        Tuple of arrays defining clusters:
+        - cluster_ids: array mapping each price to its cluster ID
+        - cluster_price_means: mean price per cluster
+        - cluster_price_mins: min price per cluster
+        - cluster_price_maxs: max price per cluster
+        - cluster_usd_totals: total USD per cluster
+        - cluster_counts: count per cluster
+        - cluster_ts_first: first timestamp per cluster
+        - cluster_ts_last: last timestamp per cluster
+        - cluster_side_long: count of longs per cluster
+        - cluster_side_short: count of shorts per cluster
+    """
+    n = len(prices)
+    if n == 0:
+        return (np.empty(0, dtype=np.int32), np.empty(0), np.empty(0), np.empty(0),
+                np.empty(0), np.empty(0, dtype=np.int32), np.empty(0), np.empty(0),
+                np.empty(0, dtype=np.int32), np.empty(0, dtype=np.int32))
+    
+    cluster_ids = np.zeros(n, dtype=np.int32)
+    current_cluster = 0
+    
+    # Track cluster stats
+    cluster_price_sum = prices[0]
+    cluster_price_min = prices[0]
+    cluster_price_max = prices[0]
+    cluster_usd_sum = usd_values[0]
+    cluster_count = 1
+    cluster_ts_min = timestamps_seconds[0]
+    cluster_ts_max = timestamps_seconds[0]
+    cluster_long_count = 1 if sides_encoded[0] == 1 else 0
+    cluster_short_count = 1 if sides_encoded[0] == 2 else 0
+    
+    cluster_ids[0] = current_cluster
+    
+    # Output lists (will convert to arrays)
+    cluster_means = [0.0] * n  # Pre-allocate max size
+    cluster_mins = [0.0] * n
+    cluster_maxs = [0.0] * n
+    cluster_usds = [0.0] * n
+    cluster_cnts = [0] * n
+    cluster_ts_firsts = [0.0] * n
+    cluster_ts_lasts = [0.0] * n
+    cluster_longs = [0] * n
+    cluster_shorts = [0] * n
+    
+    for i in range(1, n):
+        p = prices[i]
+        cluster_mean = cluster_price_sum / cluster_count
+        
+        # Check if within merge threshold
+        if abs(p - cluster_mean) / cluster_mean <= pct_merge:
+            # Add to current cluster
+            cluster_price_sum += p
+            cluster_price_min = min(cluster_price_min, p)
+            cluster_price_max = max(cluster_price_max, p)
+            cluster_usd_sum += usd_values[i]
+            cluster_count += 1
+            cluster_ts_min = min(cluster_ts_min, timestamps_seconds[i])
+            cluster_ts_max = max(cluster_ts_max, timestamps_seconds[i])
+            if sides_encoded[i] == 1:
+                cluster_long_count += 1
+            elif sides_encoded[i] == 2:
+                cluster_short_count += 1
+            cluster_ids[i] = current_cluster
+        else:
+            # Save current cluster stats
+            cluster_means[current_cluster] = cluster_mean
+            cluster_mins[current_cluster] = cluster_price_min
+            cluster_maxs[current_cluster] = cluster_price_max
+            cluster_usds[current_cluster] = cluster_usd_sum
+            cluster_cnts[current_cluster] = cluster_count
+            cluster_ts_firsts[current_cluster] = cluster_ts_min
+            cluster_ts_lasts[current_cluster] = cluster_ts_max
+            cluster_longs[current_cluster] = cluster_long_count
+            cluster_shorts[current_cluster] = cluster_short_count
+            
+            # Start new cluster
+            current_cluster += 1
+            cluster_price_sum = p
+            cluster_price_min = p
+            cluster_price_max = p
+            cluster_usd_sum = usd_values[i]
+            cluster_count = 1
+            cluster_ts_min = timestamps_seconds[i]
+            cluster_ts_max = timestamps_seconds[i]
+            cluster_long_count = 1 if sides_encoded[i] == 1 else 0
+            cluster_short_count = 1 if sides_encoded[i] == 2 else 0
+            cluster_ids[i] = current_cluster
+    
+    # Save final cluster
+    cluster_means[current_cluster] = cluster_price_sum / cluster_count
+    cluster_mins[current_cluster] = cluster_price_min
+    cluster_maxs[current_cluster] = cluster_price_max
+    cluster_usds[current_cluster] = cluster_usd_sum
+    cluster_cnts[current_cluster] = cluster_count
+    cluster_ts_firsts[current_cluster] = cluster_ts_min
+    cluster_ts_lasts[current_cluster] = cluster_ts_max
+    cluster_longs[current_cluster] = cluster_long_count
+    cluster_shorts[current_cluster] = cluster_short_count
+    
+    # Trim to actual number of clusters
+    num_clusters = current_cluster + 1
+    
+    return (
+        cluster_ids,
+        np.array(cluster_means[:num_clusters]),
+        np.array(cluster_mins[:num_clusters]),
+        np.array(cluster_maxs[:num_clusters]),
+        np.array(cluster_usds[:num_clusters]),
+        np.array(cluster_cnts[:num_clusters], dtype=np.int32),
+        np.array(cluster_ts_firsts[:num_clusters]),
+        np.array(cluster_ts_lasts[:num_clusters]),
+        np.array(cluster_longs[:num_clusters], dtype=np.int32),
+        np.array(cluster_shorts[:num_clusters], dtype=np.int32)
+    )
+
+
+@jit(nopython=True, cache=True)
+def compute_strength_batch(usd_totals, counts, last_ts_seconds, current_time_seconds):
+    """Vectorized strength computation with time decay.
+    
+    Args:
+        usd_totals: array of USD totals per zone
+        counts: array of trade counts per zone
+        last_ts_seconds: array of last timestamp (seconds since epoch) per zone
+        current_time_seconds: current time in seconds since epoch
+    
+    Returns:
+        Array of strength scores
+    """
+    n = len(usd_totals)
+    strengths = np.zeros(n)
+    
+    for i in range(n):
+        # Log-scaled components
+        a = np.log1p(usd_totals[i])
+        b = np.log1p(counts[i])
+        
+        # Time decay: recent events score higher (half-life = 1 hour = 3600 seconds)
+        age_sec = current_time_seconds - last_ts_seconds[i]
+        recency_weight = 1.0 / (1.0 + (age_sec / 3600.0))
+        
+        # Weighted combination
+        strengths[i] = (a * 0.6 + b * 0.4) * recency_weight
+    
+    return strengths
+
+
+@jit(nopython=True, cache=True)
+def compute_atr_numba(high, low, close, period=14):
+    """Fast ATR (Average True Range) calculation using Wilder's smoothing.
+    
+    Args:
+        high: array of high prices
+        low: array of low prices
+        close: array of close prices
+        period: ATR period (default 14)
+    
+    Returns:
+        Array of ATR values (same length as input)
+    """
+    n = len(high)
+    if n == 0:
+        return np.empty(0)
+    
+    # Compute True Range
+    tr = np.zeros(n)
+    tr[0] = high[0] - low[0]  # First TR is just high-low
+    
+    for i in range(1, n):
+        tr1 = high[i] - low[i]
+        tr2 = abs(high[i] - close[i-1])
+        tr3 = abs(low[i] - close[i-1])
+        tr[i] = max(tr1, max(tr2, tr3))
+    
+    # Wilder's smoothing (exponential moving average)
+    atr = np.zeros(n)
+    
+    # First ATR is simple average
+    if n >= period:
+        atr[period-1] = np.mean(tr[:period])
+        
+        # Subsequent values use Wilder's smoothing
+        alpha = 1.0 / period
+        for i in range(period, n):
+            atr[i] = atr[i-1] * (1 - alpha) + tr[i] * alpha
+        
+        # Fill early values with first computed ATR
+        for i in range(period-1):
+            atr[i] = atr[period-1]
+    else:
+        # Not enough data for full period, use cumulative mean
+        for i in range(n):
+            atr[i] = np.mean(tr[:i+1])
+    
+    return atr
+
+
+@jit(nopython=True, cache=True)
+def compute_zone_bands(price_means, pct_merge, last_atr, zone_vol_mult):
+    """Compute entry bands for zones using ATR and percentage thresholds.
+    
+    Args:
+        price_means: array of zone mean prices
+        pct_merge: percentage merge threshold (fallback)
+        last_atr: last ATR value from candles
+        zone_vol_mult: multiplier for ATR-based band
+    
+    Returns:
+        Tuple of (band_widths, entry_lows, entry_highs, band_pcts)
+    """
+    n = len(price_means)
+    bands = np.zeros(n)
+    entry_lows = np.zeros(n)
+    entry_highs = np.zeros(n)
+    band_pcts = np.zeros(n)
+    
+    for i in range(n):
+        pm = price_means[i]
+        
+        # Percent-based padding (fallback)
+        pct_pad = max(0.001, pct_merge)
+        pad_by_pct = pm * pct_pad
+        
+        # ATR-based padding (preferred for volatility adjustment)
+        pad_by_atr = last_atr * zone_vol_mult
+        
+        # Take maximum
+        pad = max(pad_by_pct, pad_by_atr)
+        
+        bands[i] = pad
+        entry_lows[i] = pm - pad
+        entry_highs[i] = pm + pad
+        band_pcts[i] = pad / pm if pm > 0 else 0.0
+    
+    return bands, entry_lows, entry_highs, band_pcts
+
+
+@jit(nopython=True, cache=True)
+def detect_volume_spikes(sizes, threshold_multiplier=2.0, window=20):
+    """Detect volume spikes using rolling mean comparison.
+    
+    Args:
+        sizes: array of trade sizes
+        threshold_multiplier: multiplier for mean (default 2.0)
+        window: rolling window size
+    
+    Returns:
+        Boolean array indicating spike locations
+    """
+    n = len(sizes)
+    spikes = np.zeros(n, dtype=np.bool_)
+    
+    for i in range(n):
+        start_idx = max(0, i - window + 1)
+        window_mean = np.mean(sizes[start_idx:i+1])
+        
+        if sizes[i] > window_mean * threshold_multiplier:
+            spikes[i] = True
+    
+    return spikes
+
+
+@jit(nopython=True, cache=True)
+def compute_price_changes(prices):
+    """Fast percentage change calculation for prices.
+    
+    Args:
+        prices: array of prices
+    
+    Returns:
+        Array of absolute percentage changes
+    """
+    n = len(prices)
+    if n < 2:
+        return np.zeros(n)
+    
+    changes = np.zeros(n)
+    changes[0] = 0.0
+    
+    for i in range(1, n):
+        if prices[i-1] != 0:
+            changes[i] = abs((prices[i] - prices[i-1]) / prices[i-1])
+    
+    return changes
+
+
+@jit(nopython=True, cache=True)
+def filter_large_trades(sizes, usd_values, threshold):
+    """Filter for large trades exceeding threshold.
+    
+    Args:
+        sizes: array of trade sizes
+        usd_values: array of USD values
+        threshold: minimum size threshold
+    
+    Returns:
+        Boolean array of large trades
+    """
+    n = len(sizes)
+    large = np.zeros(n, dtype=np.bool_)
+    
+    for i in range(n):
+        if sizes[i] >= threshold:
+            large[i] = True
+    
+    return large
+
+
+@jit(nopython=True, cache=True)
+def rolling_mean(arr, window):
+    """Fast rolling mean calculation.
+    
+    Args:
+        arr: input array
+        window: window size
+    
+    Returns:
+        Array of rolling means
+    """
+    n = len(arr)
+    result = np.zeros(n)
+    
+    for i in range(n):
+        start_idx = max(0, i - window + 1)
+        result[i] = np.mean(arr[start_idx:i+1])
+    
+    return result

liquidator_indicator/parsers.py

@@ -0,0 +1,119 @@
+"""Small parser helpers to normalize common liquidation and bbo messages into DataFrame rows."""
+from typing import Any, Dict
+import pandas as pd
+import json
+import os
+import glob
+
+def parse_liq_msg(msg: Dict[str, Any]) -> Dict:
+    """Attempt to extract fields from a liq message dict into canonical form.
+    Canonical keys: timestamp, side, coin, price, usd_value, size
+    """
+    out = {}
+    # timestamp variants
+    for k in ('timestamp','time','t'):
+        if k in msg:
+            out['timestamp'] = msg[k]
+            break
+    # side
+    side = msg.get('side') or msg.get('direction') or msg.get('dir')
+    if side is not None:
+        out['side'] = str(side).lower()
+    # price
+    for pk in ('price','px','p'):
+        if pk in msg:
+            out['price'] = msg[pk]
+            break
+    # usd value
+    out['usd_value'] = msg.get('usd_value') or msg.get('value') or msg.get('usd') or msg.get('usdValue') or 0.0
+    out['coin'] = msg.get('coin') or msg.get('market') or 'BTC'
+    out['size'] = msg.get('size') or msg.get('qty') or msg.get('quantity')
+    return out
+
+def parse_bbo_msg(msg: Dict[str, Any]) -> Dict:
+    out = {}
+    # simple extraction
+    out['timestamp'] = msg.get('timestamp') or msg.get('t')
+    out['bid'] = msg.get('bid') or msg.get('bidPrice') or None
+    out['ask'] = msg.get('ask') or msg.get('askPrice') or None
+    return out
+
+
+def read_liquidations_jsonl(path: str) -> pd.DataFrame:
+    """Read a JSONL file of liquidation events and normalize into a DataFrame using `parse_liq_msg`.
+
+    Returns empty DataFrame on error.
+    """
+    out = []
+    try:
+        with open(path, 'r', encoding='utf-8') as f:
+            for line in f:
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    obj = json.loads(line)
+                except Exception:
+                    # some files may contain 'data' wrapper
+                    try:
+                        obj = json.loads(line.split('\t')[-1])
+                    except Exception:
+                        continue
+                row = parse_liq_msg(obj if isinstance(obj, dict) else obj.get('data', {}))
+                out.append(row)
+        if not out:
+            return pd.DataFrame()
+        df = pd.DataFrame(out)
+        # normalize timestamp
+        if 'timestamp' in df.columns:
+            df['timestamp'] = pd.to_datetime(df['timestamp'], errors='coerce')
+        return df
+    except Exception:
+        return pd.DataFrame()
+
+
+def read_bbo_jsonl(path: str) -> pd.DataFrame:
+    """Read BBO JSONL file into DataFrame using `parse_bbo_msg`.
+
+    If path is a directory, will glob for *.jsonl and concat.
+    """
+    rows = []
+    try:
+        paths = [path]
+        if os.path.isdir(path):
+            paths = glob.glob(os.path.join(path, '*.jsonl'))
+        for p in paths:
+            with open(p, 'r', encoding='utf-8') as f:
+                for line in f:
+                    line = line.strip()
+                    if not line:
+                        continue
+                    try:
+                        obj = json.loads(line)
+                    except Exception:
+                        continue
+                    rows.append(parse_bbo_msg(obj if isinstance(obj, dict) else obj.get('data', {})))
+        if not rows:
+            return pd.DataFrame()
+        df = pd.DataFrame(rows)
+        if 'timestamp' in df.columns:
+            df['timestamp'] = pd.to_datetime(df['timestamp'], errors='coerce')
+        return df
+    except Exception:
+        return pd.DataFrame()
+
+
+def tail_last_jsonl(path: str) -> Dict:
+    """Read last non-empty JSON line from a file and return parsed dict, or {} on error.
+
+    This implementation reads the file in text mode and returns the last non-empty line parsed as JSON.
+    """
+    try:
+        with open(path, 'r', encoding='utf-8') as f:
+            lines = [ln.strip() for ln in f if ln.strip()]
+        if not lines:
+            return {}
+        last = lines[-1]
+        return json.loads(last)
+    except Exception:
+        return {}

{liquidator_indicator-0.0.4.dist-info → liquidator_indicator-0.0.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: liquidator_indicator
-Version: 0.0.4
+Version: 0.0.6
 Summary: Lightweight liquidation zone indicator with multi-signal detection and visual chart integration
 Home-page: https://github.com/ViWarshawski/liquidator_indicator
 Author: ViWarshawski
@@ -18,8 +18,9 @@ Classifier: Topic :: Office/Business :: Financial :: Investment
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: pandas==2.3.3
-Requires-Dist: numpy==1.26.4
+Requires-Dist: pandas>=1.3.0
+Requires-Dist: numpy>=1.20.0
+Requires-Dist: numba>=0.56.0; python_version >= "3.9"
 Dynamic: license-file
 
 # liquidator_indicator

liquidator_indicator-0.0.6.dist-info/RECORD

@@ -0,0 +1,12 @@
+liquidator_indicator/__init__.py,sha256=YM8TAML-t-vOzvRmgAT0zgmAmiYQTwVj6Fc5ZvJ5_uY,223
+liquidator_indicator/core.py,sha256=7-lIJWVXV8x5s3RtJQ31ze3FYDCdYrlyHcK4ji6K_pI,21505
+liquidator_indicator/indicators.py,sha256=xLW98VzCNVhhr7tnzQl5k7MlVyGn9o8JDxaHWTvnM0Q,2243
+liquidator_indicator/numba_optimized.py,sha256=F39rELVhcR8ENod-cncL2nyxKjhphFtOnIeHDCceW4I,11799
+liquidator_indicator/parsers.py,sha256=1CBAdp_QOrL_u9SclqofBwoKt02QQcv6q2_axG4l7vg,4197
+liquidator_indicator/collectors/__init__.py,sha256=EQ2Po4fYM7Cfv7xHA8sVobwNxSSFu3XQ-D2KQOJ_v5s,362
+liquidator_indicator/collectors/funding.py,sha256=tEzHfuBUkuHDPOx_7GcvBXUwjwll0dyKs585xyESFb0,6913
+liquidator_indicator-0.0.6.dist-info/licenses/LICENSE,sha256=EMu9ano_EP7IAtdNLPdSshuUaGgxEc7uD1Rm8wTi9kQ,1091
+liquidator_indicator-0.0.6.dist-info/METADATA,sha256=Si46d8PXlAwiOK7tE2UBGBhIt6ePUR87un_dtr9G9Go,12178
+liquidator_indicator-0.0.6.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+liquidator_indicator-0.0.6.dist-info/top_level.txt,sha256=nu6L0DNbmTvoXWufe9v82_QOq78hUGwwFxXr9IoR6mU,21
+liquidator_indicator-0.0.6.dist-info/RECORD,,

liquidator_indicator-0.0.6.dist-info/top_level.txt

@@ -0,0 +1 @@
+liquidator_indicator

liquidator_indicator-0.0.4.dist-info/RECORD

@@ -1,5 +0,0 @@
-liquidator_indicator-0.0.4.dist-info/licenses/LICENSE,sha256=EMu9ano_EP7IAtdNLPdSshuUaGgxEc7uD1Rm8wTi9kQ,1091
-liquidator_indicator-0.0.4.dist-info/METADATA,sha256=YMxB6SU-ZJIVfN_OGlrieZUl3VzAglsHixczsC6jELE,12123
-liquidator_indicator-0.0.4.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-liquidator_indicator-0.0.4.dist-info/top_level.txt,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-liquidator_indicator-0.0.4.dist-info/RECORD,,

liquidator_indicator-0.0.4.dist-info/top_level.txt

@@ -1 +0,0 @@
-