kuhl-haus-mdp 0.1.2__tar.gz → 0.1.5__tar.gz

{kuhl_haus_mdp-0.1.2 → kuhl_haus_mdp-0.1.5}/PKG-INFO

@@ -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 → kuhl_haus_mdp-0.1.5}/pyproject.toml

@@ -19,17 +19,18 @@ classifiers = [
     "Programming Language :: Python",
 ]
 dependencies = [
-    "websockets",
+    "aiohttp",
     "aio-pika",
-    "redis[asyncio]",
-    "tenacity",
     "fastapi",
-    "uvicorn[standard]",
+    "massive",
     "pydantic-settings",
     "python-dotenv",
-    "massive",
+    "redis[asyncio]",
+    "tenacity",
+    "uvicorn[standard]",
+    "websockets",
 ]
-version = "0.1.2"
+version = "0.1.5"
 
 [project.license]
 file = "LICENSE.txt"
@@ -47,6 +48,7 @@ testing = [
     "pdm-backend",
     "pytest",
     "pytest-cov",
+    "pytest-asyncio",
 ]
 
 [tool.setuptools_scm]

kuhl_haus_mdp-0.1.5/src/kuhl_haus/mdp/analyzers/top_stocks.py

@@ -0,0 +1,220 @@
+import logging
+import time
+from datetime import datetime, timezone, timedelta
+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 (
+    EquityAgg,
+    EventType
+)
+
+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
+from kuhl_haus.mdp.models.top_stocks_cache_item import TopStocksCacheItem
+
+
+class TopStocksAnalyzer(Analyzer):
+
+    def __init__(self, cache: MarketDataCache, **kwargs):
+        if "cache_key" not in kwargs:
+            kwargs["cache_key"] = MarketDataCacheKeys.TOP_STOCKS_SCANNER.value
+        super().__init__(**kwargs)
+        self.cache = cache
+        self.logger = logging.getLogger(__name__)
+        self.cache_item = TopStocksCacheItem()
+        self.last_update_time = 0
+        self.pre_market_reset = False
+
+    async def rehydrate(self, data: dict):
+        if not data:
+            self.cache_item = TopStocksCacheItem()
+            self.logger.info("No data to rehydrate TopStocksCacheItem.")
+            return
+
+        # Get current time in UTC, then convert to Eastern Time
+        utc_now = datetime.now(timezone.utc)
+        et_now = utc_now.astimezone(ZoneInfo("America/New_York"))
+
+        # Check if within trading hours: Mon-Fri, 04:00-19:59 ET
+        is_weekday = et_now.weekday() < 5
+        is_trading_hours = 4 <= et_now.hour < 20
+        if not is_weekday or not is_trading_hours:
+            self.cache_item = TopStocksCacheItem()
+            self.logger.info(f"Outside market hours ({et_now.strftime('%H:%M:%S %Z')}), clearing cache.")
+            return
+        self.cache_item = TopStocksCacheItem(**data)
+        self.logger.info("Rehydrated TopStocksCacheItem")
+
+    async def analyze_data(self, data: dict) -> Optional[List[MarketDataAnalyzerResult]]:
+        utc_now = datetime.now(timezone.utc)
+        et_now = utc_now.astimezone(ZoneInfo("America/New_York"))
+        current_day = et_now.replace(hour=4, minute=0, second=0, microsecond=0).timestamp()
+        if current_day != self.cache_item.day_start_time:
+            self.logger.info(f"New day: {current_day} - resetting cache.")
+            self.cache_item = TopStocksCacheItem()
+            self.cache_item.day_start_time = current_day
+        elif et_now.hour == 9 and et_now.minute == 30 and not self.pre_market_reset:
+            self.logger.info("Market is now open; resetting symbol data cache.")
+            self.cache_item.symbol_data_cache = {}
+            self.pre_market_reset = True
+
+        event_type = data.get("event_type")
+        symbol = data.get("symbol")
+        if not event_type:
+            self.logger.info(f"Discarding data: {data}")
+            return None
+        elif not symbol:
+            self.logger.info(f"Discarding data: {data}")
+            return None
+        elif event_type == EventType.EquityAgg.value:
+            self.logger.debug(f"Processing EquityAgg: {data.get('symbol')}")
+            await self.handle_equity_agg(EquityAgg(**data))
+        elif event_type == EventType.EquityAggMin.value:
+            self.logger.debug(f"Processing EquityAggMin: {data.get('symbol')}")
+            await self.handle_equity_agg(EquityAgg(**data))
+        else:
+            self.logger.info(f"Discarding data: {data}")
+            return None
+        current_time = int(time.time())
+        # return results once per second
+        if current_time <= self.last_update_time:
+            return None
+        self.last_update_time = current_time
+
+        result = [
+            MarketDataAnalyzerResult(
+                data=self.cache_item.to_dict(),
+                cache_key=self.cache_key,
+                cache_ttl=28500,  # 7 hours, 55 minutes
+            ),
+            MarketDataAnalyzerResult(
+                data=self.cache_item.top_volume(100),
+                cache_key=MarketDataPubSubKeys.TOP_VOLUME_SCANNER.value,
+                cache_ttl=259200,  # 3 days
+                publish_key=MarketDataPubSubKeys.TOP_VOLUME_SCANNER.value,
+            ),
+            MarketDataAnalyzerResult(
+                data=self.cache_item.top_gainers(500),
+                cache_key=MarketDataPubSubKeys.TOP_GAINERS_SCANNER.value,
+                cache_ttl=259200,  # 3 days
+                publish_key=MarketDataPubSubKeys.TOP_GAINERS_SCANNER.value,
+            ),
+            MarketDataAnalyzerResult(
+                data=self.cache_item.top_gappers(500),
+                cache_key=MarketDataPubSubKeys.TOP_GAPPERS_SCANNER.value,
+                cache_ttl=259200,  # 3 days
+                publish_key=MarketDataPubSubKeys.TOP_GAPPERS_SCANNER.value,
+            )
+        ]
+
+        return result
+
+    async def handle_equity_agg(self, event: EquityAgg):
+        # Get data from symbol data cache or Rest API
+        if event.symbol in self.cache_item.symbol_data_cache:
+            cached_data = self.cache_item.symbol_data_cache[event.symbol]
+            avg_volume = cached_data["avg_volume"]
+            prev_day_close = cached_data["prev_day_close"]
+            prev_day_volume = cached_data["prev_day_volume"]
+            prev_day_vwap = cached_data["prev_day_vwap"]
+        else:
+            # Get snapshot for previous day's data
+            retry_count = 0
+            max_tries = 3
+            prev_day_close = 0
+            prev_day_volume = 0
+            prev_day_vwap = 0
+            while retry_count < max_tries:
+                try:
+                    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
+                    break
+                except BadResponse as e:
+                    self.logger.error(f"Error getting snapshot for {event.symbol}: {repr(e)}", exc_info=e, stack_info=True)
+                    retry_count += 1
+            if retry_count == max_tries and prev_day_close == 0:
+                self.logger.error(f"Failed to get snapshot for {event.symbol} after {max_tries} tries.")
+                return
+
+            # Get average volume
+            retry_count = 0
+            max_tries = 3
+            avg_volume = 0
+            while retry_count < max_tries:
+                try:
+                    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)
+                    retry_count += 1
+            if retry_count == max_tries and avg_volume == 0:
+                self.logger.error(f"Failed to get average volume for {event.symbol} after {max_tries} tries.")
+                return
+
+        # Calculate relative volume
+        if avg_volume == 0:
+            relative_volume = 0
+        else:
+            relative_volume = event.accumulated_volume / avg_volume
+
+        # Calculate percentage change since previous close
+        if prev_day_close == 0:
+            change = 0
+            pct_change = 0
+        else:
+            change = event.close - prev_day_close
+            pct_change = change / prev_day_close * 100
+
+        # Calculate percentage change since opening bell
+        change_since_open = 0
+        pct_change_since_open = 0
+        if event.official_open_price:
+            change_since_open = event.close - event.official_open_price
+            pct_change_since_open = change_since_open / event.official_open_price * 100
+
+        # Sort top tickers by accumulated volume
+        self.cache_item.top_volume_map[event.symbol] = event.accumulated_volume
+
+        # Sort top gappers by percentage gain since the previous day's close
+        self.cache_item.top_gappers_map[event.symbol] = pct_change
+
+        # Sort top gainers by percentage gain since the opening bell
+        self.cache_item.top_gainers_map[event.symbol] = pct_change_since_open
+
+        # Update symbol data cache
+        self.cache_item.symbol_data_cache[event.symbol] = {
+            "symbol": event.symbol,
+            "volume": event.volume,
+            "accumulated_volume": event.accumulated_volume,
+            "relative_volume": relative_volume,
+            "official_open_price": event.official_open_price,
+            "vwap": event.vwap,
+            "open": event.open,
+            "close": event.close,
+            "high": event.high,
+            "low": event.low,
+            "aggregate_vwap": event.aggregate_vwap,
+            "average_size": event.average_size,
+            "avg_volume": avg_volume,
+            "prev_day_close": prev_day_close,
+            "prev_day_volume": prev_day_volume,
+            "prev_day_vwap": prev_day_vwap,
+            "change": change,
+            "pct_change": pct_change,
+            "change_since_open": change_since_open,
+            "pct_change_since_open": pct_change_since_open,
+            "start_timestamp": event.start_timestamp,
+            "end_timestamp": event.end_timestamp,
+        }

kuhl_haus_mdp-0.1.5/src/kuhl_haus/mdp/components/market_data_cache.py

@@ -0,0 +1,143 @@
+import json
+import logging
+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, 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)."""
+        value = await self.redis_client.get(cache_key)
+        if value:
+            return json.loads(value)
+        return None
+
+    async def cache_data(self, data: Any, cache_key: str, cache_ttl: int = 0):
+        if cache_ttl > 0:
+            await self.redis_client.setex(cache_key, cache_ttl, json.dumps(data))
+        else:
+            await self.redis_client.set(cache_key, json.dumps(data))
+        self.logger.debug(f"Cached data for {cache_key}")
+
+    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-0.1.2 → kuhl_haus_mdp-0.1.5}/src/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-0.1.2 → kuhl_haus_mdp-0.1.5}/src/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-0.1.2 → kuhl_haus_mdp-0.1.5}/src/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-0.1.5/src/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/tests → kuhl_haus_mdp-0.1.5/tests/analyzers}/test_massive_data_analyzer.py

@@ -2,10 +2,10 @@ from unittest.mock import MagicMock
 
 import pytest
 from massive.websocket.models import EventType
+
+from kuhl_haus.mdp.models.market_data_cache_ttl import MarketDataCacheTTL
 from src.kuhl_haus.mdp.analyzers.massive_data_analyzer import MassiveDataAnalyzer
-from src.kuhl_haus.mdp.models.market_data_analyzer_result import MarketDataAnalyzerResult
 from src.kuhl_haus.mdp.models.market_data_cache_keys import MarketDataCacheKeys
-from kuhl_haus.mdp.models.market_data_cache_ttl import MarketDataCacheTTL
 
 
 @pytest.fixture