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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kuhl-haus-mdp
-Version: 0.1.1
+Version: 0.1.2
 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.2}/pyproject.toml

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

kuhl_haus_mdp-0.1.2/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.2}/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.2/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.2/tests/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.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)