kuhl-haus-mdp 0.1.11__tar.gz → 0.1.12__tar.gz

{kuhl_haus_mdp-0.1.11 → kuhl_haus_mdp-0.1.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kuhl-haus-mdp
-Version: 0.1.11
+Version: 0.1.12
 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.11 → kuhl_haus_mdp-0.1.12}/pyproject.toml

@@ -30,7 +30,7 @@ dependencies = [
     "uvicorn[standard]",
     "websockets",
 ]
-version = "0.1.11"
+version = "0.1.12"
 
 [project.license]
 file = "LICENSE.txt"

{kuhl_haus_mdp-0.1.11 → kuhl_haus_mdp-0.1.12}/src/kuhl_haus/mdp/analyzers/analyzer.py

@@ -1,5 +1,5 @@
 from typing import Optional, List
-from kuhl_haus.mdp.models.market_data_analyzer_result import MarketDataAnalyzerResult
+from kuhl_haus.mdp.data.market_data_analyzer_result import MarketDataAnalyzerResult
 from kuhl_haus.mdp.components.market_data_cache import MarketDataCache
 
 

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

@@ -0,0 +1,117 @@
+import logging
+from time import time
+from typing import List, Optional
+from massive.websocket.models import EventType
+
+from kuhl_haus.mdp.data.market_data_analyzer_result import MarketDataAnalyzerResult
+from kuhl_haus.mdp.enum.market_data_cache_keys import MarketDataCacheKeys
+from kuhl_haus.mdp.enum.market_data_cache_ttl import MarketDataCacheTTL
+
+
+class MassiveDataAnalyzer:
+    cache_agg_event: bool
+    cache_trade_event: bool
+    cache_quote_event: bool
+
+    def __init__(self, cache_agg_event: bool = False, cache_trade_event: bool = False, cache_quote_event: bool = False):
+        self.logger = logging.getLogger(__name__)
+        self.cache_agg_event = cache_agg_event
+        self.cache_trade_event = cache_trade_event
+        self.cache_quote_event = cache_quote_event
+        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.HALTS.value,
+            publish_key=f"{MarketDataCacheKeys.HALTS.value}:{symbol}",
+        )]
+
+    def handle_equity_agg_event(self, data: dict, symbol: str) -> Optional[List[MarketDataAnalyzerResult]]:
+        if self.cache_agg_event:
+            return [MarketDataAnalyzerResult(
+                data=data,
+                cache_key=f"{MarketDataCacheKeys.AGGREGATE.value}:{symbol}",
+                cache_ttl=MarketDataCacheTTL.AGGREGATE.value,
+                publish_key=f"{MarketDataCacheKeys.AGGREGATE.value}:{symbol}",
+            )]
+        else:
+            return [MarketDataAnalyzerResult(
+                data=data,
+                publish_key=f"{MarketDataCacheKeys.AGGREGATE.value}:{symbol}",
+            )]
+
+    def handle_equity_trade_event(self, data: dict, symbol: str) -> Optional[List[MarketDataAnalyzerResult]]:
+        if self.cache_trade_event:
+            return [MarketDataAnalyzerResult(
+                data=data,
+                cache_key=f"{MarketDataCacheKeys.TRADES.value}:{symbol}",
+                cache_ttl=MarketDataCacheTTL.TRADES.value,
+                publish_key=f"{MarketDataCacheKeys.TRADES.value}:{symbol}",
+            )]
+        else:
+            return [MarketDataAnalyzerResult(
+                data=data,
+                publish_key=f"{MarketDataCacheKeys.TRADES.value}:{symbol}",
+            )]
+
+    def handle_equity_quote_event(self, data: dict, symbol: str) -> Optional[List[MarketDataAnalyzerResult]]:
+        if self.cache_quote_event:
+            return [MarketDataAnalyzerResult(
+                data=data,
+                cache_key=f"{MarketDataCacheKeys.QUOTES.value}:{symbol}",
+                cache_ttl=MarketDataCacheTTL.QUOTES.value,
+                publish_key=f"{MarketDataCacheKeys.QUOTES.value}:{symbol}",
+            )]
+        else:
+            return [MarketDataAnalyzerResult(
+                data=data,
+                # cache_key=f"{MarketDataCacheKeys.QUOTES.value}:{symbol}",
+                # cache_ttl=MarketDataCacheTTL.QUOTES.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.UNKNOWN.value,
+            publish_key=f"{MarketDataCacheKeys.UNKNOWN.value}",
+        )]

{kuhl_haus_mdp-0.1.11 → kuhl_haus_mdp-0.1.12}/src/kuhl_haus/mdp/analyzers/top_stocks.py

@@ -11,11 +11,11 @@ from massive.websocket.models import (
 
 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_cache_ttl import MarketDataCacheTTL
-from kuhl_haus.mdp.models.market_data_pubsub_keys import MarketDataPubSubKeys
-from kuhl_haus.mdp.models.top_stocks_cache_item import TopStocksCacheItem
+from kuhl_haus.mdp.data.market_data_analyzer_result import MarketDataAnalyzerResult
+from kuhl_haus.mdp.data.top_stocks_cache_item import TopStocksCacheItem
+from kuhl_haus.mdp.enum.market_data_cache_keys import MarketDataCacheKeys
+from kuhl_haus.mdp.enum.market_data_cache_ttl import MarketDataCacheTTL
+from kuhl_haus.mdp.enum.market_data_pubsub_keys import MarketDataPubSubKeys
 
 
 class TopStocksAnalyzer(Analyzer):
@@ -41,7 +41,7 @@ class TopStocksAnalyzer(Analyzer):
             self.cache_item = TopStocksCacheItem()
             self.logger.info(f"Outside market hours ({et_now.strftime('%H:%M:%S %Z')}), clearing cache.")
             return
-        data = await self.cache.get_cache(self.cache_key)
+        data = await self.cache.read(self.cache_key)
         if not data:
             self.cache_item = TopStocksCacheItem()
             self.logger.info("No data to rehydrate TopStocksCacheItem.")

{kuhl_haus_mdp-0.1.11 → kuhl_haus_mdp-0.1.12}/src/kuhl_haus/mdp/components/market_data_cache.py

@@ -14,8 +14,8 @@ from massive.rest.models import (
 )
 
 from kuhl_haus.mdp.helpers.utils import ticker_snapshot_to_dict
-from kuhl_haus.mdp.models.market_data_cache_keys import MarketDataCacheKeys
-from kuhl_haus.mdp.models.market_data_cache_ttl import MarketDataCacheTTL
+from kuhl_haus.mdp.enum.market_data_cache_keys import MarketDataCacheKeys
+from kuhl_haus.mdp.enum.market_data_cache_ttl import MarketDataCacheTTL
 
 
 class MarketDataCache:
@@ -26,7 +26,7 @@ class MarketDataCache:
         self.redis_client = redis_client
         self.http_session = None
 
-    async def delete_cache(self, cache_key: str):
+    async def delete(self, cache_key: str):
         """
             Delete cache entry.
 
@@ -38,21 +38,21 @@ class MarketDataCache:
         except Exception as e:
             self.logger.error(f"Error deleting cache entry: {e}")
 
-    async def get_cache(self, cache_key: str) -> Optional[dict]:
+    async def read(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):
+    async def write(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.info(f"Cached data for {cache_key}")
 
-    async def publish_data(self, data: Any, publish_key: str = None):
+    async def broadcast(self, data: Any, publish_key: str = None):
         await self.redis_client.publish(publish_key, json.dumps(data))
         self.logger.info(f"Published data for {publish_key}")
 
@@ -64,12 +64,12 @@ class MarketDataCache:
         :return: None
         """
         cache_key = f"{MarketDataCacheKeys.TICKER_SNAPSHOTS.value}:{ticker}"
-        await self.delete_cache(cache_key=cache_key)
+        await self.delete(cache_key=cache_key)
 
     async def get_ticker_snapshot(self, ticker: str) -> TickerSnapshot:
         self.logger.info(f"Getting snapshot for {ticker}")
         cache_key = f"{MarketDataCacheKeys.TICKER_SNAPSHOTS.value}:{ticker}"
-        result = await self.get_cache(cache_key=cache_key)
+        result = await self.read(cache_key=cache_key)
         if result:
             self.logger.info(f"Returning cached snapshot for {ticker}")
             snapshot = TickerSnapshot(**result)
@@ -80,7 +80,7 @@ class MarketDataCache:
             )
             self.logger.info(f"Snapshot result: {snapshot}")
             data = ticker_snapshot_to_dict(snapshot)
-            await self.cache_data(
+            await self.write(
                 data=data,
                 cache_key=cache_key,
                 cache_ttl=MarketDataCacheTTL.TICKER_SNAPSHOTS.value
@@ -90,7 +90,7 @@ class MarketDataCache:
     async def get_avg_volume(self, ticker: str):
         self.logger.info(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)
+        avg_volume = await self.read(cache_key=cache_key)
         if avg_volume:
             self.logger.info(f"Returning cached value for {ticker}: {avg_volume}")
             return avg_volume
@@ -136,7 +136,7 @@ class MarketDataCache:
             avg_volume = total_volume / periods_calculated
 
         self.logger.info(f"average volume {ticker}: {avg_volume}")
-        await self.cache_data(
+        await self.write(
             data=avg_volume,
             cache_key=cache_key,
             cache_ttl=MarketDataCacheTTL.TICKER_AVG_VOLUME.value
@@ -146,7 +146,7 @@ class MarketDataCache:
     async def get_free_float(self, ticker: str):
         self.logger.info(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)
+        free_float = await self.read(cache_key=cache_key)
         if free_float:
             self.logger.info(f"Returning cached value for {ticker}: {free_float}")
             return free_float
@@ -183,7 +183,7 @@ class MarketDataCache:
             raise
 
         self.logger.info(f"free float {ticker}: {free_float}")
-        await self.cache_data(
+        await self.write(
             data=free_float,
             cache_key=cache_key,
             cache_ttl=MarketDataCacheTTL.TICKER_FREE_FLOAT.value

{kuhl_haus_mdp-0.1.11 → kuhl_haus_mdp-0.1.12}/src/kuhl_haus/mdp/components/market_data_scanner.py

@@ -9,7 +9,7 @@ from redis.exceptions import ConnectionError
 from massive.rest import RESTClient
 
 from kuhl_haus.mdp.analyzers.analyzer import Analyzer
-from kuhl_haus.mdp.models.market_data_analyzer_result import MarketDataAnalyzerResult
+from kuhl_haus.mdp.data.market_data_analyzer_result import MarketDataAnalyzerResult
 from kuhl_haus.mdp.components.market_data_cache import MarketDataCache
 
 

{kuhl_haus_mdp-0.1.11/src/kuhl_haus/mdp/integ → kuhl_haus_mdp-0.1.12/src/kuhl_haus/mdp/components}/massive_data_processor.py

@@ -7,8 +7,8 @@ import redis.asyncio as aioredis
 from aio_pika.abc import AbstractIncomingMessage
 
 from kuhl_haus.mdp.analyzers.massive_data_analyzer import MassiveDataAnalyzer
-from kuhl_haus.mdp.integ.web_socket_message_serde import WebSocketMessageSerde
-from kuhl_haus.mdp.models.market_data_analyzer_result import MarketDataAnalyzerResult
+from kuhl_haus.mdp.helpers.web_socket_message_serde import WebSocketMessageSerde
+from kuhl_haus.mdp.data.market_data_analyzer_result import MarketDataAnalyzerResult
 
 
 class MassiveDataProcessor:

{kuhl_haus_mdp-0.1.11/src/kuhl_haus/mdp/integ → kuhl_haus_mdp-0.1.12/src/kuhl_haus/mdp/components}/massive_data_queues.py

@@ -6,9 +6,9 @@ from aio_pika import DeliveryMode
 from aio_pika.abc import AbstractConnection, AbstractChannel
 from massive.websocket.models import WebSocketMessage
 
-from kuhl_haus.mdp.models.massive_data_queue import MassiveDataQueue
+from kuhl_haus.mdp.enum.massive_data_queue import MassiveDataQueue
 from kuhl_haus.mdp.helpers.queue_name_resolver import QueueNameResolver
-from kuhl_haus.mdp.integ.web_socket_message_serde import WebSocketMessageSerde
+from kuhl_haus.mdp.helpers.web_socket_message_serde import WebSocketMessageSerde
 
 
 class MassiveDataQueues:

{kuhl_haus_mdp-0.1.11/src/kuhl_haus/mdp/models → kuhl_haus_mdp-0.1.12/src/kuhl_haus/mdp/enum}/market_data_cache_keys.py

@@ -1,6 +1,6 @@
 from enum import Enum
 
-from kuhl_haus.mdp.models.market_data_scanner_names import MarketDataScannerNames
+from kuhl_haus.mdp.enum.market_data_scanner_names import MarketDataScannerNames
 
 
 class MarketDataCacheKeys(Enum):

{kuhl_haus_mdp-0.1.11/src/kuhl_haus/mdp/models → kuhl_haus_mdp-0.1.12/src/kuhl_haus/mdp/enum}/market_data_cache_ttl.py

@@ -1,5 +1,5 @@
 from enum import Enum
-from kuhl_haus.mdp.models.constants import (
+from kuhl_haus.mdp.enum.constants import (
     EIGHT_HOURS,
     FIVE_MINUTES,
     ONE_DAY,

{kuhl_haus_mdp-0.1.11/src/kuhl_haus/mdp/models → kuhl_haus_mdp-0.1.12/src/kuhl_haus/mdp/enum}/market_data_pubsub_keys.py

@@ -1,6 +1,6 @@
 from enum import Enum
 
-from kuhl_haus.mdp.models.market_data_scanner_names import MarketDataScannerNames
+from kuhl_haus.mdp.enum.market_data_scanner_names import MarketDataScannerNames
 
 
 class MarketDataPubSubKeys(Enum):

{kuhl_haus_mdp-0.1.11 → kuhl_haus_mdp-0.1.12}/src/kuhl_haus/mdp/helpers/queue_name_resolver.py

@@ -6,7 +6,7 @@ from massive.websocket.models import (
     LimitUpLimitDown,
 )
 
-from kuhl_haus.mdp.models.massive_data_queue import MassiveDataQueue
+from kuhl_haus.mdp.enum.massive_data_queue import MassiveDataQueue
 
 
 class QueueNameResolver:

{kuhl_haus_mdp-0.1.11 → kuhl_haus_mdp-0.1.12}/tests/analyzers/test_massive_data_analyzer.py

@@ -3,9 +3,9 @@ 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 kuhl_haus.mdp.enum.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_cache_keys import MarketDataCacheKeys
+from src.kuhl_haus.mdp.enum.market_data_cache_keys import MarketDataCacheKeys
 
 
 @pytest.fixture
@@ -49,8 +49,8 @@ def test_analyze_data_with_valid_luld_event_expect_valid_result(valid_symbol, va
 
     # Assert
     assert len(result) == 1
-    # assert result[0].cache_key == f"{MarketDataCacheKeys.HALTS.value}:{symbol}"
-    # assert result[0].cache_ttl == MarketDataCacheTTL.HALTS.value
+    assert result[0].cache_key == f"{MarketDataCacheKeys.HALTS.value}:{symbol}"
+    assert result[0].cache_ttl == MarketDataCacheTTL.HALTS.value
     assert result[0].publish_key == f"{MarketDataCacheKeys.HALTS.value}:{symbol}"
     assert result[0].data == data
 
@@ -172,7 +172,7 @@ def test_handle_luld_event_happy_path(valid_symbol, valid_luld_data):
     assert result[0].data == valid_luld_data
 
 
-def test_handle_equity_agg_event_happy_path(valid_symbol, valid_equity_agg_data):
+def test_handle_equity_agg_event_with_no_cache_happy_path(valid_symbol, valid_equity_agg_data):
     # Arrange
     sut = MassiveDataAnalyzer()
 
@@ -181,13 +181,28 @@ def test_handle_equity_agg_event_happy_path(valid_symbol, 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.AGGREGATE.value
+    assert result[0].cache_key is None
+    assert result[0].cache_ttl == 0
+    assert result[0].publish_key == f"{MarketDataCacheKeys.AGGREGATE.value}:{valid_symbol}"
+    assert result[0].data == valid_equity_agg_data
+
+
+def test_handle_equity_agg_event_with_cache_happy_path(valid_symbol, valid_equity_agg_data):
+    # Arrange
+    sut = MassiveDataAnalyzer(cache_agg_event=True)
+
+    # 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.AGGREGATE.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):
+def test_handle_equity_trade_event_with_no_cache_happy_path(valid_symbol, valid_equity_trade_data):
     # Arrange
     sut = MassiveDataAnalyzer()
 
@@ -196,13 +211,28 @@ def test_handle_equity_trade_event_happy_path(valid_symbol, valid_equity_trade_d
 
     # Assert
     assert len(result) == 1
-    # assert result[0].cache_key == f"{MarketDataCacheKeys.TRADES.value}:{valid_symbol}"
-    # assert result[0].cache_ttl == MarketDataCacheTTL.TRADES.value
+    assert result[0].cache_key is None
+    assert result[0].cache_ttl == 0
+    assert result[0].publish_key == f"{MarketDataCacheKeys.TRADES.value}:{valid_symbol}"
+    assert result[0].data == valid_equity_trade_data
+
+
+def test_handle_equity_trade_event_with_cache_happy_path(valid_symbol, valid_equity_trade_data):
+    # Arrange
+    sut = MassiveDataAnalyzer(cache_trade_event=True)
+
+    # 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.TRADES.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):
+def test_handle_equity_quote_event_with_no_cache_happy_path(valid_symbol, valid_equity_quote_data):
     # Arrange
     sut = MassiveDataAnalyzer()
 
@@ -211,8 +241,23 @@ def test_handle_equity_quote_event_happy_path(valid_symbol, valid_equity_quote_d
 
     # Assert
     assert len(result) == 1
-    # assert result[0].cache_key == f"{MarketDataCacheKeys.QUOTES.value}:{valid_symbol}"
-    # assert result[0].cache_ttl == MarketDataCacheTTL.QUOTES.value
+    assert result[0].cache_key is None
+    assert result[0].cache_ttl == 0
+    assert result[0].publish_key == f"{MarketDataCacheKeys.QUOTES.value}:{valid_symbol}"
+    assert result[0].data == valid_equity_quote_data
+
+
+def test_handle_equity_quote_event_with_cache_happy_path(valid_symbol, valid_equity_quote_data):
+    # Arrange
+    sut = MassiveDataAnalyzer(cache_quote_event=True)
+
+    # 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.QUOTES.value
     assert result[0].publish_key == f"{MarketDataCacheKeys.QUOTES.value}:{valid_symbol}"
     assert result[0].data == valid_equity_quote_data
 

{kuhl_haus_mdp-0.1.11 → kuhl_haus_mdp-0.1.12}/tests/analyzers/test_top_stocks_rehydrate.py

@@ -5,7 +5,7 @@ from unittest.mock import patch, MagicMock, AsyncMock
 import pytest
 
 from kuhl_haus.mdp.analyzers.top_stocks import TopStocksAnalyzer
-from kuhl_haus.mdp.models.top_stocks_cache_item import TopStocksCacheItem
+from kuhl_haus.mdp.data.top_stocks_cache_item import TopStocksCacheItem
 from kuhl_haus.mdp.components.market_data_cache import MarketDataCache
 
 
@@ -65,7 +65,7 @@ async def test_rehydrate_no_data(mock_zoneinfo, top_stocks_analyzer, mock_logger
     # Configure ZoneInfo mock to return timezone.utc so astimezone works properly
     mock_zoneinfo.return_value = timezone.utc
     top_stocks_analyzer.logger = mock_logger
-    top_stocks_analyzer.cache.get_cache.return_value = None
+    top_stocks_analyzer.cache.read.return_value = None
 
     # Act
     _ = await top_stocks_analyzer.rehydrate()
@@ -84,7 +84,7 @@ async def test_rehydrate_outside_trading_hours(mock_zoneinfo, top_stocks_analyze
     mock_zoneinfo.return_value = timezone.utc
     top_stocks_analyzer.logger = mock_logger
     data = {"day_start_time": 1672531200}
-    top_stocks_analyzer.cache.get_cache.return_value = data
+    top_stocks_analyzer.cache.read.return_value = data
 
     # Act
     await top_stocks_analyzer.rehydrate()
@@ -105,7 +105,7 @@ async def test_rehydrate_within_trading_hours(mock_zoneinfo, top_stocks_analyzer
     # Configure ZoneInfo mock to return timezone.utc so astimezone works properly
     mock_zoneinfo.return_value = timezone.utc
     data = {"day_start_time": 1672531200}
-    top_stocks_analyzer.cache.get_cache.return_value = data
+    top_stocks_analyzer.cache.read.return_value = data
     top_stocks_analyzer.logger = mock_logger
 
     # Act

{kuhl_haus_mdp-0.1.11 → kuhl_haus_mdp-0.1.12}/tests/components/test_market_data_cache.py

@@ -5,8 +5,8 @@ import pytest
 from kuhl_haus.mdp.components.market_data_cache import MarketDataCache
 from massive.rest.models import TickerSnapshot
 
-from kuhl_haus.mdp.models.market_data_cache_keys import MarketDataCacheKeys
-from kuhl_haus.mdp.models.market_data_cache_ttl import MarketDataCacheTTL
+from kuhl_haus.mdp.enum.market_data_cache_keys import MarketDataCacheKeys
+from kuhl_haus.mdp.enum.market_data_cache_ttl import MarketDataCacheTTL
 
 
 @pytest.fixture
@@ -663,7 +663,7 @@ async def test_cache_data_without_ttl_expect_set_called():
     test_cache_key = "test:cache:key"
 
     # Act
-    await sut.cache_data(data=test_data, cache_key=test_cache_key, cache_ttl=0)
+    await sut.write(data=test_data, cache_key=test_cache_key, cache_ttl=0)
 
     # Assert
     mock_redis_client.set.assert_awaited_once_with(test_cache_key, json.dumps(test_data))
@@ -681,7 +681,7 @@ async def test_publish_data_expect_publish_called():
     test_publish_key = "market:updates:TEST"
 
     # Act
-    await sut.publish_data(data=test_data, publish_key=test_publish_key)
+    await sut.broadcast(data=test_data, publish_key=test_publish_key)
 
     # Assert
     mock_redis_client.publish.assert_awaited_once_with(test_publish_key, json.dumps(test_data))
@@ -844,7 +844,7 @@ async def test_delete_cache_with_existing_key_expect_cache_deleted():
     test_cache_key = "test:cache:key"
 
     # Act
-    await sut.delete_cache(test_cache_key)
+    await sut.delete(test_cache_key)
 
     # Assert
     mock_redis_client.delete.assert_awaited_once_with(test_cache_key)
@@ -861,7 +861,7 @@ async def test_delete_cache_with_redis_error_expect_error_logged(mock_logger):
     test_cache_key = "test:cache:key"
 
     # Act
-    await sut.delete_cache(test_cache_key)
+    await sut.delete(test_cache_key)
 
     # Assert
     mock_redis_client.delete.assert_awaited_once_with(test_cache_key)
@@ -878,7 +878,7 @@ async def test_delete_cache_with_successful_deletion_expect_info_logged(mock_log
     test_cache_key = "test:cache:key"
 
     # Act
-    await sut.delete_cache(test_cache_key)
+    await sut.delete(test_cache_key)
 
     # Assert
     mock_redis_client.delete.assert_awaited_once_with(test_cache_key)

{kuhl_haus_mdp-0.1.11/tests/models → kuhl_haus_mdp-0.1.12/tests/data}/test_top_stocks_cache_item.py

@@ -2,7 +2,7 @@
 import unittest
 from collections import defaultdict
 
-from src.kuhl_haus.mdp.models.top_stocks_cache_item import TopStocksCacheItem
+from kuhl_haus.mdp.data.top_stocks_cache_item import TopStocksCacheItem
 
 
 class TestTopStocksCacheItem(unittest.TestCase):

{kuhl_haus_mdp-0.1.11 → kuhl_haus_mdp-0.1.12}/tests/helpers/test_queue_name_resolver.py

@@ -4,7 +4,7 @@ import unittest
 from unittest.mock import MagicMock
 
 from kuhl_haus.mdp.helpers.queue_name_resolver import QueueNameResolver
-from kuhl_haus.mdp.models.massive_data_queue import MassiveDataQueue
+from kuhl_haus.mdp.enum.massive_data_queue import MassiveDataQueue
 from massive.websocket.models import EquityAgg, EquityTrade, EquityQuote, LimitUpLimitDown, WebSocketMessage
 
 

{kuhl_haus_mdp-0.1.11/tests/integ → kuhl_haus_mdp-0.1.12/tests/helpers}/test_web_socket_message_serde.py

@@ -11,7 +11,7 @@ from massive.websocket.models import (
     LimitUpLimitDown,
     EventType,
 )
-from src.kuhl_haus.mdp.integ.web_socket_message_serde import WebSocketMessageSerde
+from kuhl_haus.mdp.helpers.web_socket_message_serde import WebSocketMessageSerde
 
 
 class TestWebSocketMessageSerde(unittest.TestCase):

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

@@ -1,93 +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
-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.HALTS.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.AGGREGATE.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.TRADES.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.QUOTES.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.UNKNOWN.value,
-            publish_key=f"{MarketDataCacheKeys.UNKNOWN.value}",
-        )]