kuhl-haus-mdp 0.1.2__py3-none-any.whl → 0.1.5__py3-none-any.whl

kuhl_haus/mdp/analyzers/top_stocks.py

@@ -1,176 +1,35 @@
 import logging
 import time
-from collections import defaultdict
-from dataclasses import dataclass, field
 from datetime import datetime, timezone, timedelta
-from typing import Dict, Optional, List, Iterator
+from typing import Optional, List, Iterator
 from zoneinfo import ZoneInfo
 
+from massive.exceptions import BadResponse
 from massive.rest import RESTClient
 from massive.rest.models import (
     TickerSnapshot,
     Agg,
 )
 from massive.websocket.models import (
-    EquityTrade,
     EquityAgg,
     EventType
 )
-from massive.exceptions import BadResponse
 
 from kuhl_haus.mdp.analyzers.analyzer import Analyzer
+from kuhl_haus.mdp.components.market_data_cache import MarketDataCache
 from kuhl_haus.mdp.models.market_data_analyzer_result import MarketDataAnalyzerResult
 from kuhl_haus.mdp.models.market_data_cache_keys import MarketDataCacheKeys
 from kuhl_haus.mdp.models.market_data_pubsub_keys import MarketDataPubSubKeys
-
-
-# docs
-# https://massive.com/docs/stocks/ws_stocks_am
-# https://massive.com/docs/websocket/stocks/trades
-
-@dataclass()
-class TopStocksCacheItem:
-    day_start_time: Optional[float] = 0.0
-
-    # Cached details for each ticker
-    symbol_data_cache: Optional[Dict[str, dict]] = field(default_factory=lambda: defaultdict(dict))
-
-    # Top Volume map
-    top_volume_map: Optional[Dict[str, float]] = field(default_factory=lambda: defaultdict(dict))
-
-    # Top Gappers map
-    top_gappers_map: Optional[Dict[str, float]] = field(default_factory=lambda: defaultdict(dict))
-
-    # Top Gainers map
-    top_gainers_map: Optional[Dict[str, float]] = field(default_factory=lambda: defaultdict(dict))
-
-    def to_dict(self):
-        ret = {
-            # Cache start time
-            "day_start_time": self.day_start_time,
-
-            # Maps
-            "symbol_data_cache": self.symbol_data_cache,
-            "top_volume_map": self.top_volume_map,
-            "top_gappers_map": self.top_gappers_map,
-            "top_gainers_map": self.top_gainers_map,
-        }
-        return ret
-
-    def top_volume(self, limit):
-        ret = []
-        for ticker, volume in sorted(self.top_volume_map.items(), key=lambda x: x[1], reverse=True)[
-            :limit
-        ]:
-            try:
-                ret.append({
-                    "symbol": ticker,
-                    "volume": self.symbol_data_cache[ticker]["volume"],
-                    "accumulated_volume": self.symbol_data_cache[ticker]["accumulated_volume"],
-                    "relative_volume": self.symbol_data_cache[ticker]["relative_volume"],
-                    "official_open_price": self.symbol_data_cache[ticker]["official_open_price"],
-                    "vwap": self.symbol_data_cache[ticker]["vwap"],
-                    "open": self.symbol_data_cache[ticker]["open"],
-                    "close": self.symbol_data_cache[ticker]["close"],
-                    "high": self.symbol_data_cache[ticker]["high"],
-                    "low": self.symbol_data_cache[ticker]["low"],
-                    "aggregate_vwap": self.symbol_data_cache[ticker]["aggregate_vwap"],
-                    "average_size": self.symbol_data_cache[ticker]["average_size"],
-                    "avg_volume": self.symbol_data_cache[ticker]["avg_volume"],
-                    "prev_day_close": self.symbol_data_cache[ticker]["prev_day_close"],
-                    "prev_day_volume": self.symbol_data_cache[ticker]["prev_day_volume"],
-                    "prev_day_vwap": self.symbol_data_cache[ticker]["prev_day_vwap"],
-                    "change": self.symbol_data_cache[ticker]["change"],
-                    "pct_change": self.symbol_data_cache[ticker]["pct_change"],
-                    "change_since_open": self.symbol_data_cache[ticker]["change_since_open"],
-                    "pct_change_since_open": self.symbol_data_cache[ticker]["pct_change_since_open"],
-                    "start_timestamp": self.symbol_data_cache[ticker]["start_timestamp"],
-                    "end_timestamp": self.symbol_data_cache[ticker]["end_timestamp"],
-                })
-            except KeyError:
-                del self.top_volume_map[ticker]
-        return ret
-
-    def top_gappers(self, limit):
-        ret = []
-        for ticker, pct_change in sorted(self.top_gappers_map.items(), key=lambda x: x[1], reverse=True)[
-            :limit
-        ]:
-            try:
-                if pct_change <= 0:
-                    break
-                ret.append({
-                    "symbol": ticker,
-                    "volume": self.symbol_data_cache[ticker]["volume"],
-                    "accumulated_volume": self.symbol_data_cache[ticker]["accumulated_volume"],
-                    "relative_volume": self.symbol_data_cache[ticker]["relative_volume"],
-                    "official_open_price": self.symbol_data_cache[ticker]["official_open_price"],
-                    "vwap": self.symbol_data_cache[ticker]["vwap"],
-                    "open": self.symbol_data_cache[ticker]["open"],
-                    "close": self.symbol_data_cache[ticker]["close"],
-                    "high": self.symbol_data_cache[ticker]["high"],
-                    "low": self.symbol_data_cache[ticker]["low"],
-                    "aggregate_vwap": self.symbol_data_cache[ticker]["aggregate_vwap"],
-                    "average_size": self.symbol_data_cache[ticker]["average_size"],
-                    "avg_volume": self.symbol_data_cache[ticker]["avg_volume"],
-                    "prev_day_close": self.symbol_data_cache[ticker]["prev_day_close"],
-                    "prev_day_volume": self.symbol_data_cache[ticker]["prev_day_volume"],
-                    "prev_day_vwap": self.symbol_data_cache[ticker]["prev_day_vwap"],
-                    "change": self.symbol_data_cache[ticker]["change"],
-                    "pct_change": self.symbol_data_cache[ticker]["pct_change"],
-                    "change_since_open": self.symbol_data_cache[ticker]["change_since_open"],
-                    "pct_change_since_open": self.symbol_data_cache[ticker]["pct_change_since_open"],
-                    "start_timestamp": self.symbol_data_cache[ticker]["start_timestamp"],
-                    "end_timestamp": self.symbol_data_cache[ticker]["end_timestamp"],
-                })
-            except KeyError:
-                del self.top_gappers_map[ticker]
-        return ret
-
-    def top_gainers(self, limit):
-        ret = []
-        for ticker, pct_change in sorted(self.top_gainers_map.items(), key=lambda x: x[1], reverse=True)[
-            :limit
-        ]:
-            try:
-                if pct_change <= 0:
-                    break
-                ret.append({
-                    "symbol": ticker,
-                    "volume": self.symbol_data_cache[ticker]["volume"],
-                    "accumulated_volume": self.symbol_data_cache[ticker]["accumulated_volume"],
-                    "relative_volume": self.symbol_data_cache[ticker]["relative_volume"],
-                    "official_open_price": self.symbol_data_cache[ticker]["official_open_price"],
-                    "vwap": self.symbol_data_cache[ticker]["vwap"],
-                    "open": self.symbol_data_cache[ticker]["open"],
-                    "close": self.symbol_data_cache[ticker]["close"],
-                    "high": self.symbol_data_cache[ticker]["high"],
-                    "low": self.symbol_data_cache[ticker]["low"],
-                    "aggregate_vwap": self.symbol_data_cache[ticker]["aggregate_vwap"],
-                    "average_size": self.symbol_data_cache[ticker]["average_size"],
-                    "avg_volume": self.symbol_data_cache[ticker]["avg_volume"],
-                    "prev_day_close": self.symbol_data_cache[ticker]["prev_day_close"],
-                    "prev_day_volume": self.symbol_data_cache[ticker]["prev_day_volume"],
-                    "prev_day_vwap": self.symbol_data_cache[ticker]["prev_day_vwap"],
-                    "change": self.symbol_data_cache[ticker]["change"],
-                    "pct_change": self.symbol_data_cache[ticker]["pct_change"],
-                    "change_since_open": self.symbol_data_cache[ticker]["change_since_open"],
-                    "pct_change_since_open": self.symbol_data_cache[ticker]["pct_change_since_open"],
-                    "start_timestamp": self.symbol_data_cache[ticker]["start_timestamp"],
-                    "end_timestamp": self.symbol_data_cache[ticker]["end_timestamp"],
-                })
-            except KeyError:
-                del self.top_gainers_map[ticker]
-        return ret
+from kuhl_haus.mdp.models.top_stocks_cache_item import TopStocksCacheItem
 
 
 class TopStocksAnalyzer(Analyzer):
 
-    def __init__(self, rest_client: RESTClient, **kwargs):
+    def __init__(self, cache: MarketDataCache, **kwargs):
         if "cache_key" not in kwargs:
             kwargs["cache_key"] = MarketDataCacheKeys.TOP_STOCKS_SCANNER.value
         super().__init__(**kwargs)
-        self.rest_client = rest_client
+        self.cache = cache
         self.logger = logging.getLogger(__name__)
         self.cache_item = TopStocksCacheItem()
         self.last_update_time = 0
@@ -233,12 +92,6 @@ class TopStocksAnalyzer(Analyzer):
         self.last_update_time = current_time
 
         result = [
-            # MarketDataAnalyzerResult(
-            #     data=data,
-            #     cache_key=f"{MarketDataCacheKeys.AGGREGATE.value}:{symbol}",
-            #     cache_ttl=86400,  # 1 day
-            #     # publish_key=f"{MarketDataCacheKeys.AGGREGATE.value}:{symbol}",
-            # ),
             MarketDataAnalyzerResult(
                 data=self.cache_item.to_dict(),
                 cache_key=self.cache_key,
@@ -283,7 +136,7 @@ class TopStocksAnalyzer(Analyzer):
             prev_day_vwap = 0
             while retry_count < max_tries:
                 try:
-                    snapshot = await self.get_ticker_snapshot(event.symbol)
+                    snapshot = await self.cache.get_ticker_snapshot(event.symbol)
                     prev_day_close = snapshot.prev_day.close
                     prev_day_volume = snapshot.prev_day.volume
                     prev_day_vwap = snapshot.prev_day.vwap
@@ -301,7 +154,7 @@ class TopStocksAnalyzer(Analyzer):
             avg_volume = 0
             while retry_count < max_tries:
                 try:
-                    avg_volume = await self.get_avg_volume(event.symbol)
+                    avg_volume = await self.cache.get_avg_volume(event.symbol)
                     break
                 except (BadResponse, ZeroDivisionError) as e:
                     self.logger.error(f"Error getting average volume for {event.symbol}: {repr(e)}", exc_info=e, stack_info=True)
@@ -365,44 +218,3 @@ class TopStocksAnalyzer(Analyzer):
             "start_timestamp": event.start_timestamp,
             "end_timestamp": event.end_timestamp,
         }
-
-    async def get_ticker_snapshot(self, ticker: str) -> TickerSnapshot:
-        self.logger.debug(f"Getting snapshot for {ticker}")
-        result: TickerSnapshot = self.rest_client.get_snapshot_ticker(
-            market_type="stocks",
-            ticker=ticker
-        )
-        self.logger.debug(f"Snapshot result: {result}")
-        return result
-
-    async def get_avg_volume(self, ticker: str):
-        self.logger.debug(f"Getting average volume for {ticker}")
-        # Get date string in YYYY-MM-DD format
-        end_date = datetime.now(timezone.utc).strftime("%Y-%m-%d")
-        # Get date from 30 trading sessions ago in YYYY-MM-DD format
-        start_date = (datetime.now(timezone.utc) - timedelta(days=42)).strftime("%Y-%m-%d")
-
-        result: Iterator[Agg] = self.rest_client.list_aggs(
-            ticker=ticker,
-            multiplier=1,
-            timespan="day",
-            from_=start_date,
-            to=end_date,
-            adjusted=True,
-            sort="desc"
-        )
-        self.logger.debug(f"average volume result: {result}")
-
-        total_volume = 0
-        max_periods = 30
-        periods_calculated = 0
-        for agg in result:
-            if periods_calculated < max_periods:
-                total_volume += agg.volume
-                periods_calculated += 1
-            else:
-                break
-        avg_volume = total_volume / periods_calculated
-
-        self.logger.debug(f"average volume {ticker}: {avg_volume}")
-        return avg_volume

kuhl_haus/mdp/components/market_data_cache.py

@@ -1,14 +1,26 @@
 import json
 import logging
-from typing import Any, Optional
+from typing import Any, Optional, Iterator, List
 
+import aiohttp
 import redis.asyncio as aioredis
+from massive.rest import RESTClient
+from massive.rest.models import (
+    TickerSnapshot,
+    FinancialRatio,
+)
+
+from kuhl_haus.mdp.models.market_data_cache_keys import MarketDataCacheKeys
+from kuhl_haus.mdp.models.market_data_cache_ttl import MarketDataCacheTTL
 
 
 class MarketDataCache:
-    def __init__(self, redis_client: aioredis.Redis):
+    def __init__(self, rest_client: RESTClient, redis_client: aioredis.Redis, massive_api_key: str):
         self.logger = logging.getLogger(__name__)
+        self.rest_client = rest_client
+        self.massive_api_key = massive_api_key
         self.redis_client = redis_client
+        self.http_session = None
 
     async def get_cache(self, cache_key: str) -> Optional[dict]:
         """Fetch current value from Redis cache (for snapshot requests)."""
@@ -27,3 +39,105 @@ class MarketDataCache:
     async def publish_data(self, data: Any, publish_key: str = None):
         await self.redis_client.publish(publish_key, json.dumps(data))
         self.logger.debug(f"Published data for {publish_key}")
+
+    async def get_ticker_snapshot(self, ticker: str) -> TickerSnapshot:
+        self.logger.debug(f"Getting snapshot for {ticker}")
+        cache_key = f"{MarketDataCacheKeys.TICKER_SNAPSHOTS.value}:{ticker}"
+        result = await self.get_cache(cache_key=cache_key)
+        if result:
+            snapshot = TickerSnapshot.from_dict(**result)
+        else:
+            snapshot: TickerSnapshot = self.rest_client.get_snapshot_ticker(
+                market_type="stocks",
+                ticker=ticker
+            )
+            self.logger.debug(f"Snapshot result: {snapshot}")
+            await self.cache_data(
+                data=snapshot,
+                cache_key=cache_key,
+                cache_ttl=MarketDataCacheTTL.EIGHT_HOURS.value
+            )
+        return snapshot
+
+    async def get_avg_volume(self, ticker: str):
+        self.logger.debug(f"Getting average volume for {ticker}")
+        cache_key = f"{MarketDataCacheKeys.TICKER_AVG_VOLUME.value}:{ticker}"
+        avg_volume = await self.get_cache(cache_key=cache_key)
+        if avg_volume:
+            self.logger.debug(f"Returning cached value for {ticker}: {avg_volume}")
+            return avg_volume
+
+        results: Iterator[FinancialRatio] = self.rest_client.list_financials_ratios(ticker=ticker)
+        ratios: List[FinancialRatio] = []
+        for financial_ratio in results:
+            ratios.append(financial_ratio)
+        if len(ratios) == 1:
+            avg_volume = ratios[0].average_volume
+        else:
+            raise Exception(f"Unexpected number of financial ratios for {ticker}: {len(ratios)}")
+
+        self.logger.debug(f"average volume {ticker}: {avg_volume}")
+        await self.cache_data(
+            data=avg_volume,
+            cache_key=cache_key,
+            cache_ttl=MarketDataCacheTTL.TWELVE_HOURS.value
+        )
+        return avg_volume
+
+    async def get_free_float(self, ticker: str):
+        self.logger.debug(f"Getting free float for {ticker}")
+        cache_key = f"{MarketDataCacheKeys.TICKER_FREE_FLOAT.value}:{ticker}"
+        free_float = await self.get_cache(cache_key=cache_key)
+        if free_float:
+            self.logger.debug(f"Returning cached value for {ticker}: {free_float}")
+            return free_float
+
+        # NOTE: This endpoint is experimental and the interface may change.
+        # https://massive.com/docs/rest/stocks/fundamentals/float
+        url = f"https://api.massive.com/stocks/vX/float"
+        params = {
+            "ticker": ticker,
+            "apiKey": self.massive_api_key
+        }
+
+        session = await self.get_http_session()
+        try:
+            async with session.get(url, params=params, timeout=aiohttp.ClientTimeout(total=10)) as response:
+                response.raise_for_status()
+                data = await response.json()
+
+                # Extract free_float from response
+                if data.get("status") == "OK" and data.get("results") is not None:
+                    results = data["results"]
+                    if len(results) > 0:
+                        free_float = results[0].get("free_float")
+                    else:
+                        raise Exception(f"No free float data returned for {ticker}")
+                else:
+                    raise Exception(f"Invalid response from Massive API for {ticker}: {data}")
+
+        except aiohttp.ClientError as e:
+            self.logger.error(f"HTTP error fetching free float for {ticker}: {e}")
+            raise
+        except Exception as e:
+            self.logger.error(f"Error fetching free float for {ticker}: {e}")
+            raise
+
+        self.logger.debug(f"free float {ticker}: {free_float}")
+        await self.cache_data(
+            data=free_float,
+            cache_key=cache_key,
+            cache_ttl=MarketDataCacheTTL.TWELVE_HOURS.value
+        )
+        return free_float
+
+    async def get_http_session(self) -> aiohttp.ClientSession:
+        """Get or create aiohttp session for async HTTP requests."""
+        if self.http_session is None or self.http_session.closed:
+            self.http_session = aiohttp.ClientSession()
+        return self.http_session
+
+    async def close(self):
+        """Close aiohttp session."""
+        if self.http_session and not self.http_session.closed:
+            await self.http_session.close()

kuhl_haus/mdp/integ/massive_data_processor.py

@@ -1,17 +1,14 @@
 import asyncio
 import json
 import logging
-from typing import Dict
 
 import aio_pika
-import redis
 import redis.asyncio as aioredis
 from aio_pika.abc import AbstractIncomingMessage
-from aio_pika.exceptions import AMQPConnectionError
 
 from kuhl_haus.mdp.analyzers.massive_data_analyzer import MassiveDataAnalyzer
-from kuhl_haus.mdp.models.market_data_analyzer_result import MarketDataAnalyzerResult
 from kuhl_haus.mdp.integ.web_socket_message_serde import WebSocketMessageSerde
+from kuhl_haus.mdp.models.market_data_analyzer_result import MarketDataAnalyzerResult
 
 
 class MassiveDataProcessor:

kuhl_haus/mdp/models/market_data_cache_keys.py

@@ -16,6 +16,9 @@ class MarketDataCacheKeys(Enum):
 
     # MARKET DATA CACHE
     DAILY_AGGREGATES = 'aggregate:daily'
+    TICKER_SNAPSHOTS = 'snapshots'
+    TICKER_AVG_VOLUME = 'avg_volume'
+    TICKER_FREE_FLOAT = 'free_float'
 
     # MARKET DATA PROCESSOR CACHE
     TOP_TRADES_SCANNER = f'cache:{MarketDataScannerNames.TOP_TRADES.value}'

kuhl_haus/mdp/models/market_data_cache_ttl.py

@@ -8,6 +8,7 @@ class MarketDataCacheTTL(Enum):
     FOUR_HOURS = 14400
     SIX_HOURS = 21600
     EIGHT_HOURS = 28800
+    TWELVE_HOURS = 43200
 
     # Days
     ONE_DAY = 86400

kuhl_haus/mdp/models/top_stocks_cache_item.py

@@ -0,0 +1,143 @@
+from collections import defaultdict
+from dataclasses import dataclass, field
+from typing import Dict, Optional
+
+
+# docs
+# https://massive.com/docs/stocks/ws_stocks_am
+# https://massive.com/docs/websocket/stocks/trades
+
+@dataclass()
+class TopStocksCacheItem:
+    day_start_time: Optional[float] = 0.0
+
+    # Cached details for each ticker
+    symbol_data_cache: Optional[Dict[str, dict]] = field(default_factory=lambda: defaultdict(dict))
+
+    # Top Volume map
+    top_volume_map: Optional[Dict[str, float]] = field(default_factory=lambda: defaultdict(dict))
+
+    # Top Gappers map
+    top_gappers_map: Optional[Dict[str, float]] = field(default_factory=lambda: defaultdict(dict))
+
+    # Top Gainers map
+    top_gainers_map: Optional[Dict[str, float]] = field(default_factory=lambda: defaultdict(dict))
+
+    def to_dict(self):
+        ret = {
+            # Cache start time
+            "day_start_time": self.day_start_time,
+
+            # Maps
+            "symbol_data_cache": self.symbol_data_cache,
+            "top_volume_map": self.top_volume_map,
+            "top_gappers_map": self.top_gappers_map,
+            "top_gainers_map": self.top_gainers_map,
+        }
+        return ret
+
+    def top_volume(self, limit):
+        ret = []
+        for ticker, volume in sorted(self.top_volume_map.items(), key=lambda x: x[1], reverse=True)[
+            :limit
+        ]:
+            try:
+                ret.append({
+                    "symbol": ticker,
+                    "volume": self.symbol_data_cache[ticker]["volume"],
+                    "accumulated_volume": self.symbol_data_cache[ticker]["accumulated_volume"],
+                    "relative_volume": self.symbol_data_cache[ticker]["relative_volume"],
+                    "official_open_price": self.symbol_data_cache[ticker]["official_open_price"],
+                    "vwap": self.symbol_data_cache[ticker]["vwap"],
+                    "open": self.symbol_data_cache[ticker]["open"],
+                    "close": self.symbol_data_cache[ticker]["close"],
+                    "high": self.symbol_data_cache[ticker]["high"],
+                    "low": self.symbol_data_cache[ticker]["low"],
+                    "aggregate_vwap": self.symbol_data_cache[ticker]["aggregate_vwap"],
+                    "average_size": self.symbol_data_cache[ticker]["average_size"],
+                    "avg_volume": self.symbol_data_cache[ticker]["avg_volume"],
+                    "prev_day_close": self.symbol_data_cache[ticker]["prev_day_close"],
+                    "prev_day_volume": self.symbol_data_cache[ticker]["prev_day_volume"],
+                    "prev_day_vwap": self.symbol_data_cache[ticker]["prev_day_vwap"],
+                    "change": self.symbol_data_cache[ticker]["change"],
+                    "pct_change": self.symbol_data_cache[ticker]["pct_change"],
+                    "change_since_open": self.symbol_data_cache[ticker]["change_since_open"],
+                    "pct_change_since_open": self.symbol_data_cache[ticker]["pct_change_since_open"],
+                    "start_timestamp": self.symbol_data_cache[ticker]["start_timestamp"],
+                    "end_timestamp": self.symbol_data_cache[ticker]["end_timestamp"],
+                })
+            except KeyError:
+                del self.top_volume_map[ticker]
+        return ret
+
+    def top_gappers(self, limit):
+        ret = []
+        for ticker, pct_change in sorted(self.top_gappers_map.items(), key=lambda x: x[1], reverse=True)[
+            :limit
+        ]:
+            try:
+                if pct_change <= 0:
+                    break
+                ret.append({
+                    "symbol": ticker,
+                    "volume": self.symbol_data_cache[ticker]["volume"],
+                    "accumulated_volume": self.symbol_data_cache[ticker]["accumulated_volume"],
+                    "relative_volume": self.symbol_data_cache[ticker]["relative_volume"],
+                    "official_open_price": self.symbol_data_cache[ticker]["official_open_price"],
+                    "vwap": self.symbol_data_cache[ticker]["vwap"],
+                    "open": self.symbol_data_cache[ticker]["open"],
+                    "close": self.symbol_data_cache[ticker]["close"],
+                    "high": self.symbol_data_cache[ticker]["high"],
+                    "low": self.symbol_data_cache[ticker]["low"],
+                    "aggregate_vwap": self.symbol_data_cache[ticker]["aggregate_vwap"],
+                    "average_size": self.symbol_data_cache[ticker]["average_size"],
+                    "avg_volume": self.symbol_data_cache[ticker]["avg_volume"],
+                    "prev_day_close": self.symbol_data_cache[ticker]["prev_day_close"],
+                    "prev_day_volume": self.symbol_data_cache[ticker]["prev_day_volume"],
+                    "prev_day_vwap": self.symbol_data_cache[ticker]["prev_day_vwap"],
+                    "change": self.symbol_data_cache[ticker]["change"],
+                    "pct_change": self.symbol_data_cache[ticker]["pct_change"],
+                    "change_since_open": self.symbol_data_cache[ticker]["change_since_open"],
+                    "pct_change_since_open": self.symbol_data_cache[ticker]["pct_change_since_open"],
+                    "start_timestamp": self.symbol_data_cache[ticker]["start_timestamp"],
+                    "end_timestamp": self.symbol_data_cache[ticker]["end_timestamp"],
+                })
+            except KeyError:
+                del self.top_gappers_map[ticker]
+        return ret
+
+    def top_gainers(self, limit):
+        ret = []
+        for ticker, pct_change in sorted(self.top_gainers_map.items(), key=lambda x: x[1], reverse=True)[
+            :limit
+        ]:
+            try:
+                if pct_change <= 0:
+                    break
+                ret.append({
+                    "symbol": ticker,
+                    "volume": self.symbol_data_cache[ticker]["volume"],
+                    "accumulated_volume": self.symbol_data_cache[ticker]["accumulated_volume"],
+                    "relative_volume": self.symbol_data_cache[ticker]["relative_volume"],
+                    "official_open_price": self.symbol_data_cache[ticker]["official_open_price"],
+                    "vwap": self.symbol_data_cache[ticker]["vwap"],
+                    "open": self.symbol_data_cache[ticker]["open"],
+                    "close": self.symbol_data_cache[ticker]["close"],
+                    "high": self.symbol_data_cache[ticker]["high"],
+                    "low": self.symbol_data_cache[ticker]["low"],
+                    "aggregate_vwap": self.symbol_data_cache[ticker]["aggregate_vwap"],
+                    "average_size": self.symbol_data_cache[ticker]["average_size"],
+                    "avg_volume": self.symbol_data_cache[ticker]["avg_volume"],
+                    "prev_day_close": self.symbol_data_cache[ticker]["prev_day_close"],
+                    "prev_day_volume": self.symbol_data_cache[ticker]["prev_day_volume"],
+                    "prev_day_vwap": self.symbol_data_cache[ticker]["prev_day_vwap"],
+                    "change": self.symbol_data_cache[ticker]["change"],
+                    "pct_change": self.symbol_data_cache[ticker]["pct_change"],
+                    "change_since_open": self.symbol_data_cache[ticker]["change_since_open"],
+                    "pct_change_since_open": self.symbol_data_cache[ticker]["pct_change_since_open"],
+                    "start_timestamp": self.symbol_data_cache[ticker]["start_timestamp"],
+                    "end_timestamp": self.symbol_data_cache[ticker]["end_timestamp"],
+                })
+            except KeyError:
+                del self.top_gainers_map[ticker]
+        return ret

{kuhl_haus_mdp-0.1.2.dist-info → kuhl_haus_mdp-0.1.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kuhl-haus-mdp
-Version: 0.1.2
+Version: 0.1.5
 Summary: Market data processing pipeline for stock market scanner
 Author-Email: Tom Pounders <git@oldschool.engineer>
 License: The MIT License (MIT)
@@ -33,20 +33,22 @@ Project-URL: Source, https://github.com/kuhl-haus/kuhl-haus-mdp.git
 Project-URL: Changelog, https://github.com/kuhl-haus/kuhl-haus-mdp/commits
 Project-URL: Tracker, https://github.com/kuhl-haus/kuhl-haus-mdp/issues
 Requires-Python: <3.13,>=3.9.21
-Requires-Dist: websockets
+Requires-Dist: aiohttp
 Requires-Dist: aio-pika
-Requires-Dist: redis[asyncio]
-Requires-Dist: tenacity
 Requires-Dist: fastapi
-Requires-Dist: uvicorn[standard]
+Requires-Dist: massive
 Requires-Dist: pydantic-settings
 Requires-Dist: python-dotenv
-Requires-Dist: massive
+Requires-Dist: redis[asyncio]
+Requires-Dist: tenacity
+Requires-Dist: uvicorn[standard]
+Requires-Dist: websockets
 Provides-Extra: testing
 Requires-Dist: setuptools; extra == "testing"
 Requires-Dist: pdm-backend; extra == "testing"
 Requires-Dist: pytest; extra == "testing"
 Requires-Dist: pytest-cov; extra == "testing"
+Requires-Dist: pytest-asyncio; extra == "testing"
 Description-Content-Type: text/markdown
 
 <!-- These are examples of badges you might want to add to your README:

{kuhl_haus_mdp-0.1.2.dist-info → kuhl_haus_mdp-0.1.5.dist-info}/RECORD

@@ -2,29 +2,30 @@ kuhl_haus/mdp/__init__.py,sha256=5dEpAdB3kypH8tCRECoXwbly1WV9kFU5kh8ldGSa0VI,349
 kuhl_haus/mdp/analyzers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 kuhl_haus/mdp/analyzers/analyzer.py,sha256=eluYM2Iib5kgbpNZUSk2qEUL-j83ZTb3zmEmRazrmiM,404
 kuhl_haus/mdp/analyzers/massive_data_analyzer.py,sha256=WSb7T8X4u2ue7Du7sf_fqxjgjEbR6ThllSNT1CncIM0,3866
-kuhl_haus/mdp/analyzers/top_stocks.py,sha256=AbRnPHSVrJgUq3CDV8SaNstldqoimlI23gpG69lzYBM,18759
+kuhl_haus/mdp/analyzers/top_stocks.py,sha256=aE8Z4PHkfudM02xLAgqgCMeIGqsioq18SQLs81Z8qvM,9452
 kuhl_haus/mdp/components/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-kuhl_haus/mdp/components/market_data_cache.py,sha256=r5sJHuSuLiw9BVckW--aWZHHIMqOTCf-pFURA7kef3Q,1070
+kuhl_haus/mdp/components/market_data_cache.py,sha256=EmRDlh_GTKyYDvAbbAPQrE8n91JKNFKH8myAM4UTPLM,5835
 kuhl_haus/mdp/components/market_data_scanner.py,sha256=vA0HPqVIvuZb93wzJhtER6fcH6bf85AgXCbu7yVFOFE,9152
 kuhl_haus/mdp/components/widget_data_service.py,sha256=ikygD9NRpidcXBEqft5Q11rHy_eUOwKGyOLEezo-Dd4,7439
 kuhl_haus/mdp/helpers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 kuhl_haus/mdp/helpers/process_manager.py,sha256=Is3Jx8nlBWvywQ1acdsdaSJTAG0olKskpPvrRB4VMDE,9024
 kuhl_haus/mdp/helpers/queue_name_resolver.py,sha256=l_zfRLxrjR9uwRCV2VDO4vPWLK_lj5KVG2p4Lh8xWiw,770
+kuhl_haus/mdp/helpers/utils.py,sha256=9JEpl2yr2LghOLrJUDxi-4dtDK3DZ1wBTZ1uxBJsFbQ,1309
 kuhl_haus/mdp/integ/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 kuhl_haus/mdp/integ/massive_data_listener.py,sha256=fPEYc6zZzHzFFjbP3zFInajKtEGInj8UQKKo3nKQEwQ,5098
-kuhl_haus/mdp/integ/massive_data_processor.py,sha256=qktzLfuqrOgE4C9iZs4mXFvHt2BckgevRP8pEakzggA,8694
+kuhl_haus/mdp/integ/massive_data_processor.py,sha256=H1WlbGtuSF45n7qLTLleuNlG-OlIXz4llJ7q3XRSS-s,8605
 kuhl_haus/mdp/integ/massive_data_queues.py,sha256=zC_uV2vwZCMyVerDQ18RAQwIMMF75iK4qUSqwuWqgwc,5050
-kuhl_haus/mdp/integ/utils.py,sha256=9JEpl2yr2LghOLrJUDxi-4dtDK3DZ1wBTZ1uxBJsFbQ,1309
 kuhl_haus/mdp/integ/web_socket_message_serde.py,sha256=XdaoaByc7IhtzbPDXBtXKOTjyDzfPSDuZVCoHSIaTl4,5468
 kuhl_haus/mdp/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 kuhl_haus/mdp/models/market_data_analyzer_result.py,sha256=iICb5GVCtuqARNbR1JNCAfbxMijM3uppDNdL8_FB3eI,422
-kuhl_haus/mdp/models/market_data_cache_keys.py,sha256=5iScBMhVQaG3p9P45veE-uRT7c6JY7k6j4DcvSEXENA,942
-kuhl_haus/mdp/models/market_data_cache_ttl.py,sha256=4KvsPeg84-sp4viUX6reN8CZYiM2aF9FgfXQmPbj3hw,348
+kuhl_haus/mdp/models/market_data_cache_keys.py,sha256=04nFRdNZtvEeKFnpjZ6CNSu-4MiUgifPXPHGAZhZRsE,1051
+kuhl_haus/mdp/models/market_data_cache_ttl.py,sha256=a43ys3S61Y0ADdb03ThgrRd9x7B1EsI6FplCjecdNLY,373
 kuhl_haus/mdp/models/market_data_pubsub_keys.py,sha256=PEIPXK9jBehJB7G4pqoSuQZcfMZgOQq8Yho1itqv-1A,1306
 kuhl_haus/mdp/models/market_data_scanner_names.py,sha256=BYn1C0rYgGF1Sq583BkHADKUu-28ytNZQ-XgptuCH-Y,260
 kuhl_haus/mdp/models/massive_data_queue.py,sha256=MfYBcjVc4Fi61DWIvvhhWLUOiLmRpE9egtW-2KH6FTE,188
-kuhl_haus_mdp-0.1.2.dist-info/METADATA,sha256=iOqk7u1RoyY-mBiIDGVI06TSDGulUuHo0GF9G6JYcdQ,8688
-kuhl_haus_mdp-0.1.2.dist-info/WHEEL,sha256=tsUv_t7BDeJeRHaSrczbGeuK-TtDpGsWi_JfpzD255I,90
-kuhl_haus_mdp-0.1.2.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
-kuhl_haus_mdp-0.1.2.dist-info/licenses/LICENSE.txt,sha256=DRkJftAJcMqoTkQ_Y6-HtKj3nm4pZah_p8XBZiYnw-c,1079
-kuhl_haus_mdp-0.1.2.dist-info/RECORD,,
+kuhl_haus/mdp/models/top_stocks_cache_item.py,sha256=4vwwPTMkRRf1ct6iFInJnLSbBadM-tRk-zhqdD_ITE0,7676
+kuhl_haus_mdp-0.1.5.dist-info/METADATA,sha256=h3NksGfUJk-bpw4YWVtjcCrd8HxrxmDD4PxPn-MTg3k,8761
+kuhl_haus_mdp-0.1.5.dist-info/WHEEL,sha256=tsUv_t7BDeJeRHaSrczbGeuK-TtDpGsWi_JfpzD255I,90
+kuhl_haus_mdp-0.1.5.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
+kuhl_haus_mdp-0.1.5.dist-info/licenses/LICENSE.txt,sha256=DRkJftAJcMqoTkQ_Y6-HtKj3nm4pZah_p8XBZiYnw-c,1079
+kuhl_haus_mdp-0.1.5.dist-info/RECORD,,