kuhl-haus-mdp 0.1.1__tar.gz → 0.1.3__tar.gz

{kuhl_haus_mdp-0.1.1 → kuhl_haus_mdp-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kuhl-haus-mdp
-Version: 0.1.1
+Version: 0.1.3
 Summary: Market data processing pipeline for stock market scanner
 Author-Email: Tom Pounders <git@oldschool.engineer>
 License: The MIT License (MIT)

{kuhl_haus_mdp-0.1.1 → kuhl_haus_mdp-0.1.3}/pyproject.toml

@@ -29,7 +29,7 @@ dependencies = [
     "python-dotenv",
     "massive",
 ]
-version = "0.1.1"
+version = "0.1.3"
 
 [project.license]
 file = "LICENSE.txt"

kuhl_haus_mdp-0.1.3/src/kuhl_haus/mdp/analyzers/massive_data_analyzer.py

@@ -0,0 +1,93 @@
+import logging
+from time import time
+from typing import List, Optional
+from massive.websocket.models import EventType
+
+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_cache_ttl import MarketDataCacheTTL
+
+
+class MassiveDataAnalyzer:
+    def __init__(self):
+        self.logger = logging.getLogger(__name__)
+        self.event_handlers = {
+            EventType.LimitUpLimitDown.value: self.handle_luld_event,
+            EventType.EquityAgg.value: self.handle_equity_agg_event,
+            EventType.EquityAggMin.value: self.handle_equity_agg_event,
+            EventType.EquityTrade.value: self.handle_equity_trade_event,
+            EventType.EquityQuote.value: self.handle_equity_quote_event,
+        }
+
+    def analyze_data(self, data: dict) -> Optional[List[MarketDataAnalyzerResult]]:
+        """
+        Process raw market data message
+
+        Args:
+            data: serialized message from Massive/Polygon.io
+
+        Returns:
+            Processed result dict or None if message should be discarded
+        """
+        if "event_type" not in data:
+            self.logger.info("Message missing 'event_type'")
+            return self.handle_unknown_event(data)
+        event_type = data.get("event_type")
+
+        if "symbol" not in data:
+            self.logger.info("Message missing 'symbol'")
+            return self.handle_unknown_event(data)
+        symbol = data.get("symbol")
+
+        if event_type in self.event_handlers:
+            return self.event_handlers[event_type](**{"data": data, "symbol": symbol})
+        else:
+            self.logger.warning(f"Unsupported message type: {event_type}")
+            return self.handle_unknown_event(data)
+
+    @staticmethod
+    def handle_luld_event(data: dict, symbol: str) -> Optional[List[MarketDataAnalyzerResult]]:
+        return [MarketDataAnalyzerResult(
+            data=data,
+            cache_key=f"{MarketDataCacheKeys.HALTS.value}:{symbol}",
+            cache_ttl=MarketDataCacheTTL.THREE_DAYS.value,
+            publish_key=f"{MarketDataCacheKeys.HALTS.value}:{symbol}",
+        )]
+
+    @staticmethod
+    def handle_equity_agg_event(data: dict, symbol: str) -> Optional[List[MarketDataAnalyzerResult]]:
+        return [MarketDataAnalyzerResult(
+            data=data,
+            cache_key=f"{MarketDataCacheKeys.AGGREGATE.value}:{symbol}",
+            cache_ttl=MarketDataCacheTTL.THREE_DAYS.value,
+            publish_key=f"{MarketDataCacheKeys.AGGREGATE.value}:{symbol}",
+        )]
+
+    @staticmethod
+    def handle_equity_trade_event(data: dict, symbol: str) -> Optional[List[MarketDataAnalyzerResult]]:
+        return [MarketDataAnalyzerResult(
+            data=data,
+            cache_key=f"{MarketDataCacheKeys.TRADES.value}:{symbol}",
+            cache_ttl=MarketDataCacheTTL.EIGHT_HOURS.value,
+            publish_key=f"{MarketDataCacheKeys.TRADES.value}:{symbol}",
+        )]
+
+    @staticmethod
+    def handle_equity_quote_event(data: dict, symbol: str) -> Optional[List[MarketDataAnalyzerResult]]:
+        return [MarketDataAnalyzerResult(
+            data=data,
+            cache_key=f"{MarketDataCacheKeys.QUOTES.value}:{symbol}",
+            cache_ttl=MarketDataCacheTTL.THREE_DAYS.value,
+            publish_key=f"{MarketDataCacheKeys.QUOTES.value}:{symbol}",
+        )]
+
+    @staticmethod
+    def handle_unknown_event(data: dict) -> Optional[List[MarketDataAnalyzerResult]]:
+        timestamp = f"{time()}".replace('.','')
+        cache_key = f"{MarketDataCacheKeys.UNKNOWN.value}:{timestamp}"
+        return [MarketDataAnalyzerResult(
+            data=data,
+            cache_key=cache_key,
+            cache_ttl=MarketDataCacheTTL.ONE_DAY.value,
+            publish_key=f"{MarketDataCacheKeys.UNKNOWN.value}",
+        )]

{kuhl_haus_mdp-0.1.1 → kuhl_haus_mdp-0.1.3}/src/kuhl_haus/mdp/analyzers/top_stocks.py

@@ -1,167 +1,25 @@
 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.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):
@@ -233,12 +91,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,

{kuhl_haus_mdp-0.1.1 → kuhl_haus_mdp-0.1.3}/src/kuhl_haus/mdp/integ/massive_data_processor.py

@@ -114,8 +114,8 @@ class MassiveDataProcessor:
                     web_socket_message = json.loads(message.body.decode())
                     data = WebSocketMessageSerde.to_dict(web_socket_message)
 
-                    # Delegate to analyzer (async)
-                    analyzer_results = await self.analyzer.analyze_data(data)
+                    # Delegate to analyzer
+                    analyzer_results = self.analyzer.analyze_data(data)
                     if analyzer_results:
                         self.processed += 1
                         for analyzer_result in analyzer_results:

kuhl_haus_mdp-0.1.3/src/kuhl_haus/mdp/models/market_data_cache_ttl.py

@@ -0,0 +1,19 @@
+from enum import Enum
+
+
+class MarketDataCacheTTL(Enum):
+    # Hours
+    ONE_HOUR = 3600
+    TWO_HOURS = 7200
+    FOUR_HOURS = 14400
+    SIX_HOURS = 21600
+    EIGHT_HOURS = 28800
+
+    # Days
+    ONE_DAY = 86400
+    TWO_DAYS = 172800
+    THREE_DAYS = 259200
+    FOUR_DAYS = 345600
+    FIVE_DAYS = 432000
+    SIX_DAYS = 518400
+    SEVEN_DAYS = 604800

kuhl_haus_mdp-0.1.3/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.3/tests/analyzers/test_massive_data_analyzer.py

@@ -0,0 +1,233 @@
+from unittest.mock import MagicMock
+
+import pytest
+from massive.websocket.models import EventType
+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
+def valid_symbol():
+    return "TEST"
+
+
+@pytest.fixture
+def valid_luld_data(valid_symbol: str):
+    return {"event_type": EventType.LimitUpLimitDown.value, "symbol": valid_symbol, "test": "data"}
+
+
+@pytest.fixture
+def valid_equity_agg_data(valid_symbol: str):
+    return {"event_type": EventType.EquityAgg.value, "symbol": valid_symbol, "test": "data"}
+
+
+@pytest.fixture
+def valid_equity_agg_minute_data(valid_symbol: str):
+    return {"event_type": EventType.EquityAggMin.value, "symbol": valid_symbol, "test": "data"}
+
+
+@pytest.fixture
+def valid_equity_trade_data(valid_symbol: str):
+    return {"event_type": EventType.EquityTrade.value, "symbol": valid_symbol, "test": "data"}
+
+
+@pytest.fixture
+def valid_equity_quote_data(valid_symbol: str):
+    return {"event_type": EventType.EquityQuote.value, "symbol": valid_symbol, "test": "data"}
+
+
+def test_analyze_data_with_valid_luld_event_expect_valid_result(valid_symbol, valid_luld_data):
+    # Arrange
+    sut = MassiveDataAnalyzer()
+    symbol = valid_symbol
+    data = valid_luld_data
+
+    # Act
+    result = sut.analyze_data(data)
+
+    # Assert
+    assert len(result) == 1
+    assert result[0].cache_key == f"{MarketDataCacheKeys.HALTS.value}:{symbol}"
+    assert result[0].cache_ttl == MarketDataCacheTTL.THREE_DAYS.value
+    assert result[0].publish_key == f"{MarketDataCacheKeys.HALTS.value}:{symbol}"
+    assert result[0].data == data
+
+
+def test_analyze_data_with_equity_agg_event_happy_path(valid_symbol, valid_equity_agg_data):
+    # Arrange
+    sut = MassiveDataAnalyzer()
+
+    # Act
+    result = sut.analyze_data(data=valid_equity_agg_data)
+
+    # Assert
+    assert len(result) == 1
+    assert result[0].cache_key == f"{MarketDataCacheKeys.AGGREGATE.value}:{valid_symbol}"
+    assert result[0].cache_ttl == MarketDataCacheTTL.THREE_DAYS.value
+    assert result[0].publish_key == f"{MarketDataCacheKeys.AGGREGATE.value}:{valid_symbol}"
+    assert result[0].data == valid_equity_agg_data
+
+
+def test_analyze_data_with_equity_agg_min_event_happy_path(valid_symbol, valid_equity_agg_minute_data):
+    # Arrange
+    sut = MassiveDataAnalyzer()
+
+    # Act
+    result = sut.analyze_data(data=valid_equity_agg_minute_data)
+
+    # Assert
+    assert len(result) == 1
+    assert result[0].cache_key == f"{MarketDataCacheKeys.AGGREGATE.value}:{valid_symbol}"
+    assert result[0].cache_ttl == MarketDataCacheTTL.THREE_DAYS.value
+    assert result[0].publish_key == f"{MarketDataCacheKeys.AGGREGATE.value}:{valid_symbol}"
+    assert result[0].data == valid_equity_agg_minute_data
+
+
+def test_analyze_data_with_equity_trade_event_happy_path(valid_symbol, valid_equity_trade_data):
+    # Arrange
+    sut = MassiveDataAnalyzer()
+
+    # Act
+    result = sut.analyze_data(data=valid_equity_trade_data)
+
+    # Assert
+    assert len(result) == 1
+    assert result[0].cache_key == f"{MarketDataCacheKeys.TRADES.value}:{valid_symbol}"
+    assert result[0].cache_ttl == MarketDataCacheTTL.EIGHT_HOURS.value
+    assert result[0].publish_key == f"{MarketDataCacheKeys.TRADES.value}:{valid_symbol}"
+    assert result[0].data == valid_equity_trade_data
+
+
+def test_analyze_data_equity_quote_event_happy_path(valid_symbol, valid_equity_quote_data):
+    # Arrange
+    sut = MassiveDataAnalyzer()
+
+    # Act
+    result = sut.analyze_data(data=valid_equity_quote_data)
+
+    # Assert
+    assert len(result) == 1
+    assert result[0].cache_key == f"{MarketDataCacheKeys.QUOTES.value}:{valid_symbol}"
+    assert result[0].cache_ttl == MarketDataCacheTTL.THREE_DAYS.value
+    assert result[0].publish_key == f"{MarketDataCacheKeys.QUOTES.value}:{valid_symbol}"
+    assert result[0].data == valid_equity_quote_data
+
+
+def test_analyze_data_with_missing_event_type_expect_unknown_event():
+    # Arrange
+    sut = MassiveDataAnalyzer()
+    sut.handle_unknown_event = MagicMock(return_value=None)
+    data = {"symbol": "TEST", "data": "test"}
+
+    # Act
+    result = sut.analyze_data(data)
+
+    # Assert
+    sut.handle_unknown_event.assert_called_once_with(data)
+    assert result is None
+
+
+def test_analyze_data_with_missing_symbol_expect_unknown_event():
+    # Arrange
+    sut = MassiveDataAnalyzer()
+    sut.handle_unknown_event = MagicMock(return_value=None)
+    data = {"event_type": EventType.LimitUpLimitDown.value, "data": "test"}
+
+    # Act
+    result = sut.analyze_data(data)
+
+    # Assert
+    sut.handle_unknown_event.assert_called_once_with(data)
+    assert result is None
+
+
+def test_analyze_data_with_unsupported_event_expect_unknown_event():
+    # Arrange
+    sut = MassiveDataAnalyzer()
+    sut.handle_unknown_event = MagicMock(return_value=None)
+    data = {"event_type": "UnsupportedEvent", "symbol": "TEST", "test": "data"}
+
+    # Act
+    result = sut.analyze_data(data)
+
+    # Assert
+    sut.handle_unknown_event.assert_called_once_with(data)
+    assert result is None
+
+
+def test_handle_luld_event_happy_path(valid_symbol, valid_luld_data):
+    # Arrange
+    sut = MassiveDataAnalyzer()
+
+    # Act
+    result = sut.handle_luld_event(data=valid_luld_data, symbol=valid_symbol)
+
+    # Assert
+    assert len(result) == 1
+    assert result[0].cache_key == f"{MarketDataCacheKeys.HALTS.value}:{valid_symbol}"
+    assert result[0].cache_ttl == MarketDataCacheTTL.THREE_DAYS.value
+    assert result[0].publish_key == f"{MarketDataCacheKeys.HALTS.value}:{valid_symbol}"
+    assert result[0].data == valid_luld_data
+
+
+def test_handle_equity_agg_event_happy_path(valid_symbol, valid_equity_agg_data):
+    # Arrange
+    sut = MassiveDataAnalyzer()
+
+    # Act
+    result = sut.handle_equity_agg_event(data=valid_equity_agg_data, symbol=valid_symbol)
+
+    # Assert
+    assert len(result) == 1
+    assert result[0].cache_key == f"{MarketDataCacheKeys.AGGREGATE.value}:{valid_symbol}"
+    assert result[0].cache_ttl == MarketDataCacheTTL.THREE_DAYS.value
+    assert result[0].publish_key == f"{MarketDataCacheKeys.AGGREGATE.value}:{valid_symbol}"
+    assert result[0].data == valid_equity_agg_data
+
+
+def test_handle_equity_trade_event_happy_path(valid_symbol, valid_equity_trade_data):
+    # Arrange
+    sut = MassiveDataAnalyzer()
+
+    # Act
+    result = sut.handle_equity_trade_event(data=valid_equity_trade_data, symbol=valid_symbol)
+
+    # Assert
+    assert len(result) == 1
+    assert result[0].cache_key == f"{MarketDataCacheKeys.TRADES.value}:{valid_symbol}"
+    assert result[0].cache_ttl == MarketDataCacheTTL.EIGHT_HOURS.value
+    assert result[0].publish_key == f"{MarketDataCacheKeys.TRADES.value}:{valid_symbol}"
+    assert result[0].data == valid_equity_trade_data
+
+
+def test_handle_equity_quote_event_happy_path(valid_symbol, valid_equity_quote_data):
+    # Arrange
+    sut = MassiveDataAnalyzer()
+
+    # Act
+    result = sut.handle_equity_quote_event(data=valid_equity_quote_data, symbol=valid_symbol)
+
+    # Assert
+    assert len(result) == 1
+    assert result[0].cache_key == f"{MarketDataCacheKeys.QUOTES.value}:{valid_symbol}"
+    assert result[0].cache_ttl == MarketDataCacheTTL.THREE_DAYS.value
+    assert result[0].publish_key == f"{MarketDataCacheKeys.QUOTES.value}:{valid_symbol}"
+    assert result[0].data == valid_equity_quote_data
+
+
+def test_handle_unknown_event_happy_path():
+    # Arrange
+    sut = MassiveDataAnalyzer()
+    data = {"unknown": "event"}
+
+    # Act
+    result = sut.handle_unknown_event(data=data)
+
+    # Assert
+    assert len(result) == 1
+    assert result[0].cache_key.startswith(f"{MarketDataCacheKeys.UNKNOWN.value}:")
+    assert result[0].cache_ttl == MarketDataCacheTTL.ONE_DAY.value
+    assert result[0].publish_key == MarketDataCacheKeys.UNKNOWN.value
+    assert result[0].data == data

kuhl_haus_mdp-0.1.3/tests/models/test_top_stocks_cache_item.py

@@ -0,0 +1,109 @@
+# tests/test_top_stocks_cache_item.py
+import unittest
+from collections import defaultdict
+
+from src.kuhl_haus.mdp.models.top_stocks_cache_item import TopStocksCacheItem
+
+
+class TestTopStocksCacheItem(unittest.TestCase):
+    """Unit tests for the TopStocksCacheItem class."""
+
+    def setUp(self):
+        """Set up a TopStocksCacheItem instance for testing."""
+        self.cache_item = TopStocksCacheItem()
+
+    def test_initialization(self):
+        """Test the default initialization of TopStocksCacheItem."""
+        self.assertEqual(self.cache_item.day_start_time, 0.0)
+        self.assertIsInstance(self.cache_item.symbol_data_cache, defaultdict)
+        self.assertIsInstance(self.cache_item.top_volume_map, defaultdict)
+        self.assertIsInstance(self.cache_item.top_gappers_map, defaultdict)
+        self.assertIsInstance(self.cache_item.top_gainers_map, defaultdict)
+
+    def test_to_dict_method(self):
+        """Test the to_dict method of TopStocksCacheItem."""
+        expected_dict = {
+            "day_start_time": 0.0,
+            "symbol_data_cache": self.cache_item.symbol_data_cache,
+            "top_volume_map": self.cache_item.top_volume_map,
+            "top_gappers_map": self.cache_item.top_gappers_map,
+            "top_gainers_map": self.cache_item.top_gainers_map,
+        }
+        self.assertEqual(self.cache_item.to_dict(), expected_dict)
+
+    def test_top_volume_method(self):
+        """Test the top_volume method with a limit."""
+        self.cache_item.top_volume_map = {"AAPL": 1200, "GOOG": 600, "AMZN": 500}
+        self.cache_item.symbol_data_cache = {
+            "AAPL": {"volume": 1000, "accumulated_volume": 1200, "relative_volume": 1.2, "official_open_price": 150,
+                     "vwap": 155, "open": 145, "close": 152, "high": 160, "low": 142, "aggregate_vwap": 156,
+                     "average_size": 50, "avg_volume": 1000, "prev_day_close": 148, "prev_day_volume": 900,
+                     "prev_day_vwap": 154, "change": 4, "pct_change": 2.7, "change_since_open": 7,
+                     "pct_change_since_open": 4.8, "start_timestamp": 100000, "end_timestamp": 110000},
+            "AMZN": {"volume": 300, "accumulated_volume": 500, "relative_volume": 1.2, "official_open_price": 3300,
+                     "vwap": 3500, "open": 3250, "close": 3520, "high": 3600, "low": 3200, "aggregate_vwap": 3450,
+                     "average_size": 85, "avg_volume": 4000, "prev_day_close": 3200, "prev_day_volume": 3900,
+                     "prev_day_vwap": 3400, "change": 200, "pct_change": 10.0, "change_since_open": 270,
+                     "pct_change_since_open": 8.3, "start_timestamp": 300000, "end_timestamp": 310000},
+            "GOOG": {"volume": 500, "accumulated_volume": 600, "relative_volume": 1.0, "official_open_price": 2500,
+                     "vwap": 2550, "open": 2450, "close": 2520, "high": 2600, "low": 2400, "aggregate_vwap": 2560,
+                     "average_size": 65, "avg_volume": 2000, "prev_day_close": 2510, "prev_day_volume": 1900,
+                     "prev_day_vwap": 2530, "change": 10, "pct_change": 0.4, "change_since_open": 70,
+                     "pct_change_since_open": 2.9, "start_timestamp": 200000, "end_timestamp": 210000},
+        }
+        result = self.cache_item.top_volume(2)
+        self.assertEqual(2, len(result))
+        self.assertEqual(result[0]["symbol"], "AAPL")
+        self.assertEqual(result[1]["symbol"], "GOOG")
+
+    def test_top_gappers_method(self):
+        """Test the top_gappers method with a limit."""
+        self.cache_item.top_gappers_map = {"AAPL": 5.0, "GOOG": -3.0, "AMZN": 10.0}
+        self.cache_item.symbol_data_cache = {
+            "AAPL": {"volume": 1000, "accumulated_volume": 1200, "relative_volume": 1.5, "official_open_price": 150,
+                     "vwap": 155, "open": 145, "close": 152, "high": 160, "low": 142, "aggregate_vwap": 156,
+                     "average_size": 50, "avg_volume": 1000, "prev_day_close": 148, "prev_day_volume": 900,
+                     "prev_day_vwap": 154, "change": 4, "pct_change": 5.0, "change_since_open": 7,
+                     "pct_change_since_open": 2.5, "start_timestamp": 100000, "end_timestamp": 110000},
+            "AMZN": {"volume": 300, "accumulated_volume": 500, "relative_volume": 1.2, "official_open_price": 3300,
+                     "vwap": 3500, "open": 3250, "close": 3520, "high": 3600, "low": 3200, "aggregate_vwap": 3450,
+                     "average_size": 85, "avg_volume": 4000, "prev_day_close": 3200, "prev_day_volume": 3900,
+                     "prev_day_vwap": 3400, "change": 200, "pct_change": 10.0, "change_since_open": 270,
+                     "pct_change_since_open": 8.3, "start_timestamp": 300000, "end_timestamp": 310000},
+            "GOOG": {"volume": 500, "accumulated_volume": 600, "relative_volume": 1.0, "official_open_price": 2500,
+                     "vwap": 2550, "open": 2450, "close": 2520, "high": 2600, "low": 2400, "aggregate_vwap": 2560,
+                     "average_size": 65, "avg_volume": 2000, "prev_day_close": 2510, "prev_day_volume": 1900,
+                     "prev_day_vwap": 2530, "change": 10, "pct_change": 0.4, "change_since_open": 70,
+                     "pct_change_since_open": 2.9, "start_timestamp": 200000, "end_timestamp": 210000},
+        }
+        result = self.cache_item.top_gappers(1)
+        self.assertEqual(len(result), 1)
+        self.assertEqual(result[0]["symbol"], "AMZN")
+
+    def test_top_gainers_method(self):
+        """Test the top_gainers method with a limit."""
+        self.cache_item.top_gainers_map = {"AAPL": 2.5, "GOOG": -0.5, "AMZN": 8.3}
+        self.cache_item.symbol_data_cache = {
+            "AAPL": {"volume": 500, "accumulated_volume": 800, "relative_volume": 1.6, "official_open_price": 140,
+                     "vwap": 145, "open": 130, "close": 150, "high": 155, "low": 128, "aggregate_vwap": 150,
+                     "average_size": 45, "avg_volume": 900, "prev_day_close": 142, "prev_day_volume": 850,
+                     "prev_day_vwap": 145, "change": 8, "pct_change": 2.5, "change_since_open": 20,
+                     "pct_change_since_open": 15.4, "start_timestamp": 150000, "end_timestamp": 160000},
+            "AMZN": {"volume": 800, "accumulated_volume": 1200, "relative_volume": 1.4, "official_open_price": 3200,
+                     "vwap": 3300, "open": 3150, "close": 3400, "high": 3450, "low": 3100, "aggregate_vwap": 3350,
+                     "average_size": 70, "avg_volume": 3900, "prev_day_close": 3250, "prev_day_volume": 3800,
+                     "prev_day_vwap": 3300, "change": 150, "pct_change": 4.6, "change_since_open": 250,
+                     "pct_change_since_open": 8.3, "start_timestamp": 170000, "end_timestamp": 180000},
+            "GOOG": {"volume": 500, "accumulated_volume": 600, "relative_volume": 1.0, "official_open_price": 2500,
+                     "vwap": 2550, "open": 2450, "close": 2520, "high": 2600, "low": 2400, "aggregate_vwap": 2560,
+                     "average_size": 65, "avg_volume": 2000, "prev_day_close": 2510, "prev_day_volume": 1900,
+                     "prev_day_vwap": 2530, "change": 10, "pct_change": 0.4, "change_since_open": 70,
+                     "pct_change_since_open": 2.9, "start_timestamp": 200000, "end_timestamp": 210000},
+        }
+        result = self.cache_item.top_gainers(1)
+        self.assertEqual(len(result), 1)
+        self.assertEqual(result[0]["symbol"], "AMZN")
+
+
+if __name__ == "__main__":
+    unittest.main()

kuhl_haus_mdp-0.1.1/src/kuhl_haus/mdp/analyzers/massive_data_analyzer.py

@@ -1,102 +0,0 @@
-import logging
-from time import time
-from typing import List, Optional
-from massive.websocket.models import EventType
-
-from kuhl_haus.mdp.models.market_data_analyzer_result import MarketDataAnalyzerResult
-from kuhl_haus.mdp.models.market_data_cache_keys import MarketDataCacheKeys
-
-
-class MassiveDataAnalyzer:
-    def __init__(self):
-        self.logger = logging.getLogger(__name__)
-        self.event_handlers = {
-            EventType.LimitUpLimitDown.value: self.handle_luld_event,
-            EventType.EquityAgg.value: self.handle_equity_agg_event,
-            EventType.EquityAggMin.value: self.handle_equity_agg_event,
-            EventType.EquityTrade.value: self.handle_equity_trade_event,
-            EventType.EquityQuote.value: self.handle_equity_quote_event,
-        }
-
-    async def analyze_data(self, data: dict) -> Optional[List[MarketDataAnalyzerResult]]:
-        """
-        Process raw market data message
-
-        Args:
-            data: serialized message from Massive/Polygon.io
-
-        Returns:
-            Processed result dict or None if message should be discarded
-        """
-        if "event_type" not in data:
-            self.logger.info("Message missing 'event_type'")
-            return await self.handle_unknown_event(data)
-        event_type = data.get("event_type")
-
-        if "symbol" not in data:
-            self.logger.info("Message missing 'symbol'")
-            return await self.handle_unknown_event(data)
-        symbol = data.get("symbol")
-
-        if event_type in self.event_handlers:
-            return await self.event_handlers[event_type](**{"data": data, "symbol": symbol})
-        else:
-            self.logger.warning(f"Unsupported message type: {event_type}")
-            return await self.handle_unknown_event(data)
-
-    async def handle_luld_event(self, data: dict, symbol: str) -> Optional[List[MarketDataAnalyzerResult]]:
-        try:
-            return [MarketDataAnalyzerResult(
-                data=data,
-                cache_key=f"{MarketDataCacheKeys.HALTS.value}:{symbol}",
-                cache_ttl=28500,  # 7 hours, 55 minutes
-                publish_key=f"{MarketDataCacheKeys.HALTS.value}:{symbol}",
-            )]
-        except Exception as e:
-            self.logger.error(f"Error processing LULD message for {symbol}: {data}", e)
-
-    async def handle_equity_agg_event(self, data: dict, symbol: str) -> Optional[List[MarketDataAnalyzerResult]]:
-        try:
-            return [MarketDataAnalyzerResult(
-                data=data,
-                # cache_key=f"{MarketDataCacheKeys.AGGREGATE.value}:{symbol}",
-                # cache_ttl=259200,  # 3 days
-                publish_key=f"{MarketDataCacheKeys.AGGREGATE.value}:{symbol}",
-            )]
-        except Exception as e:
-            self.logger.error(f"Error processing EquityAgg message for {symbol}: {data}", e)
-
-    async def handle_equity_trade_event(self, data: dict, symbol: str) -> Optional[List[MarketDataAnalyzerResult]]:
-        try:
-            return [MarketDataAnalyzerResult(
-                data=data,
-                # cache_key=f"{MarketDataCacheKeys.TRADES.value}:{symbol}",
-                # cache_ttl=28500,  # 7 hours, 55 minutes
-                publish_key=f"{MarketDataCacheKeys.TRADES.value}:{symbol}",
-            )]
-        except Exception as e:
-            self.logger.error(f"Error processing EquityTrade message for {symbol}: {data}", e)
-
-    async def handle_equity_quote_event(self, data: dict, symbol: str) -> Optional[List[MarketDataAnalyzerResult]]:
-        try:
-            return [MarketDataAnalyzerResult(
-                data=data,
-                # cache_key=f"{MarketDataCacheKeys.QUOTES.value}:{symbol}",
-                # cache_ttl=259200,  # 3 days
-                publish_key=f"{MarketDataCacheKeys.QUOTES.value}:{symbol}",
-            )]
-        except Exception as e:
-            self.logger.error(f"Error processing EquityQuote message for {symbol}: {data}", e)
-
-    async def handle_unknown_event(self, data: dict) -> Optional[List[MarketDataAnalyzerResult]]:
-        try:
-            timestamp = f"{time()}".replace('.','')
-            cache_key = f"{MarketDataCacheKeys.UNKNOWN.value}:{timestamp}"
-            return [MarketDataAnalyzerResult(
-                data=data,
-                cache_key=cache_key,
-                cache_ttl=86400,  # 1 days
-                publish_key=f"{MarketDataCacheKeys.UNKNOWN.value}",
-            )]
-        except Exception as e:
-            self.logger.error(f"Error processing unknown message type: {data}", e)