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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kuhl-haus-mdp
-Version: 0.1.5
+Version: 0.1.6
 Summary: Market data processing pipeline for stock market scanner
 Author-Email: Tom Pounders <git@oldschool.engineer>
 License: The MIT License (MIT)
@@ -68,7 +68,7 @@ Description-Content-Type: text/markdown
 [![codecov](https://codecov.io/gh/kuhl-haus/kuhl-haus-mdp/branch/mainline/graph/badge.svg)](https://codecov.io/gh/kuhl-haus/kuhl-haus-mdp)
 [![GitHub issues](https://img.shields.io/github/issues/kuhl-haus/kuhl-haus-mdp)](https://github.com/kuhl-haus/kuhl-haus-mdp/issues)
 [![GitHub pull requests](https://img.shields.io/github/issues-pr/kuhl-haus/kuhl-haus-mdp)](https://github.com/kuhl-haus/kuhl-haus-mdp/pulls)
-
+[![Documentation](https://readthedocs.org/projects/kuhl-haus-mdp/badge/?version=latest)](https://kuhl-haus-mdp.readthedocs.io/en/latest/)
 
 # kuhl-haus-mdp
 

{kuhl_haus_mdp-0.1.5 → kuhl_haus_mdp-0.1.6}/README.md

@@ -15,7 +15,7 @@
 [![codecov](https://codecov.io/gh/kuhl-haus/kuhl-haus-mdp/branch/mainline/graph/badge.svg)](https://codecov.io/gh/kuhl-haus/kuhl-haus-mdp)
 [![GitHub issues](https://img.shields.io/github/issues/kuhl-haus/kuhl-haus-mdp)](https://github.com/kuhl-haus/kuhl-haus-mdp/issues)
 [![GitHub pull requests](https://img.shields.io/github/issues-pr/kuhl-haus/kuhl-haus-mdp)](https://github.com/kuhl-haus/kuhl-haus-mdp/pulls)
-
+[![Documentation](https://readthedocs.org/projects/kuhl-haus-mdp/badge/?version=latest)](https://kuhl-haus-mdp.readthedocs.io/en/latest/)
 
 # kuhl-haus-mdp
 

{kuhl_haus_mdp-0.1.5 → kuhl_haus_mdp-0.1.6}/pyproject.toml

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

{kuhl_haus_mdp-0.1.5 → kuhl_haus_mdp-0.1.6}/src/kuhl_haus/mdp/analyzers/analyzer.py

@@ -1,14 +1,15 @@
 from typing import Optional, List
 from kuhl_haus.mdp.models.market_data_analyzer_result import MarketDataAnalyzerResult
+from kuhl_haus.mdp.components.market_data_cache import MarketDataCache
 
 
 class Analyzer:
-    cache_key: str
+    cache: MarketDataCache
 
-    def __init__(self, cache_key: str, **kwargs):
-        self.cache_key = cache_key
+    def __init__(self, cache: MarketDataCache, **kwargs):
+        self.cache = cache
 
-    async def rehydrate(self, data: dict):
+    async def rehydrate(self):
         pass
 
     async def analyze_data(self, data: dict) -> Optional[List[MarketDataAnalyzerResult]]:

{kuhl_haus_mdp-0.1.5 → kuhl_haus_mdp-0.1.6}/src/kuhl_haus/mdp/analyzers/top_stocks.py

@@ -26,21 +26,15 @@ from kuhl_haus.mdp.models.top_stocks_cache_item import TopStocksCacheItem
 class TopStocksAnalyzer(Analyzer):
 
     def __init__(self, cache: MarketDataCache, **kwargs):
-        if "cache_key" not in kwargs:
-            kwargs["cache_key"] = MarketDataCacheKeys.TOP_STOCKS_SCANNER.value
-        super().__init__(**kwargs)
+        super().__init__(cache=cache, **kwargs)
         self.cache = cache
+        self.cache_key = MarketDataCacheKeys.TOP_STOCKS_SCANNER.value
         self.logger = logging.getLogger(__name__)
         self.cache_item = TopStocksCacheItem()
         self.last_update_time = 0
         self.pre_market_reset = False
 
-    async def rehydrate(self, data: dict):
-        if not data:
-            self.cache_item = TopStocksCacheItem()
-            self.logger.info("No data to rehydrate TopStocksCacheItem.")
-            return
-
+    async def rehydrate(self):
         # Get current time in UTC, then convert to Eastern Time
         utc_now = datetime.now(timezone.utc)
         et_now = utc_now.astimezone(ZoneInfo("America/New_York"))
@@ -52,6 +46,11 @@ 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)
+        if not data:
+            self.cache_item = TopStocksCacheItem()
+            self.logger.info("No data to rehydrate TopStocksCacheItem.")
+            return
         self.cache_item = TopStocksCacheItem(**data)
         self.logger.info("Rehydrated TopStocksCacheItem")
 

{kuhl_haus_mdp-0.1.5 → kuhl_haus_mdp-0.1.6}/src/kuhl_haus/mdp/components/market_data_scanner.py

@@ -1,13 +1,16 @@
 import asyncio
 import json
 import logging
-from typing import Union, Optional, List
+from typing import Any, Union, Optional, List
 
 import redis.asyncio as aioredis
 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.components.market_data_cache import MarketDataCache
 
 
 class MarketDataScanner:
@@ -18,11 +21,14 @@ class MarketDataScanner:
     error: int
     restarts: int
 
-    def __init__(self, redis_url: str, analyzer: Analyzer, subscriptions: List[str]):
+    def __init__(self, redis_url: str, massive_api_key: str, subscriptions: List[str], analyzer_class: Any):
         self.redis_url = redis_url
-        self.analyzer = analyzer
+        self.massive_api_key = massive_api_key
         self.logger = logging.getLogger(__name__)
 
+        self.analyzer: Analyzer = None
+        self.analyzer_class = analyzer_class
+
         # Connection objects
         self.redis_client = None  # : aioredis.Redis = None
         self.pubsub_client: Optional[aioredis.client.PubSub] = None
@@ -30,6 +36,7 @@ class MarketDataScanner:
         # State
         self.mdc_connected = False
         self.running = False
+        self.mdc: Optional[MarketDataCache] = None
 
         self.subscriptions: List[str] = subscriptions
         self._pubsub_task: Union[asyncio.Task, None] = None
@@ -48,9 +55,9 @@ class MarketDataScanner:
         await self.connect()
         self.pubsub_client = self.redis_client.pubsub()
 
-        scanner_cache = await self.get_cache(self.analyzer.cache_key)
+        self.analyzer = self.analyzer_class(cache=self.mdc)
         self.logger.info(f"mds rehydrating from cache")
-        await self.analyzer.rehydrate(scanner_cache)
+        await self.analyzer.rehydrate()
         self.logger.info("mds rehydration complete")
 
         for subscription in self.subscriptions:
@@ -73,6 +80,10 @@ class MarketDataScanner:
                 pass
             self._pubsub_task = None
 
+        if self.mdc:
+            await self.mdc.close()
+            self.mdc = None
+
         if self.pubsub_client:
             for subscription in self.subscriptions:
                 if subscription.endswith("*"):
@@ -104,6 +115,11 @@ class MarketDataScanner:
 
                 # Test Redis connection
                 await self.redis_client.ping()
+                self.mdc = MarketDataCache(
+                    rest_client=RESTClient(api_key=self.massive_api_key),
+                    redis_client=self.redis_client,
+                    massive_api_key=self.massive_api_key
+                )
                 self.mdc_connected = True
                 self.logger.debug(f"Connected to Redis: {self.redis_url}")
             except Exception as e:

{kuhl_haus_mdp-0.1.5 → kuhl_haus_mdp-0.1.6}/tests/analyzers/test_top_stocks_rehydrate.py

@@ -1,5 +1,6 @@
+
 from datetime import datetime, timezone
-from unittest.mock import patch, MagicMock
+from unittest.mock import patch, MagicMock, AsyncMock
 
 import pytest
 
@@ -10,7 +11,9 @@ from kuhl_haus.mdp.components.market_data_cache import MarketDataCache
 
 @pytest.fixture
 def mock_market_data_cache():
-    return MagicMock(spec=MarketDataCache)
+    mock = MagicMock(spec=MarketDataCache)
+    mock.get_cache = AsyncMock()
+    return mock
 
 
 @pytest.fixture
@@ -56,13 +59,16 @@ def outside_trading_hour_patch():
 
 @pytest.mark.asyncio
 @patch("kuhl_haus.mdp.analyzers.top_stocks.ZoneInfo")
-async def test_rehydrate_no_data(mock_zoneinfo, top_stocks_analyzer, mock_logger):
+async def test_rehydrate_no_data(mock_zoneinfo, top_stocks_analyzer, mock_logger, trading_hour_patch, mock_market_data_cache):
     """Test rehydrate when no data is passed."""
     # Arrange
+    # 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
 
     # Act
-    await top_stocks_analyzer.rehydrate(None)
+    _ = await top_stocks_analyzer.rehydrate()
 
     # Assert
     assert isinstance(top_stocks_analyzer.cache_item, TopStocksCacheItem)
@@ -71,15 +77,17 @@ async def test_rehydrate_no_data(mock_zoneinfo, top_stocks_analyzer, mock_logger
 
 @pytest.mark.asyncio
 @patch("kuhl_haus.mdp.analyzers.top_stocks.ZoneInfo")
-async def test_rehydrate_outside_trading_hours(mock_zoneinfo, top_stocks_analyzer, outside_trading_hour_patch, mock_logger):
+async def test_rehydrate_outside_trading_hours(mock_zoneinfo, top_stocks_analyzer, outside_trading_hour_patch, mock_logger, mock_market_data_cache):
     """Test rehydrate outside trading hours."""
     # Arrange
     # Configure ZoneInfo mock to return timezone.utc so astimezone works properly
     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
 
     # Act
-    await top_stocks_analyzer.rehydrate({"day_start_time": 1672531200})
+    await top_stocks_analyzer.rehydrate()
 
     # Assert
     assert isinstance(top_stocks_analyzer.cache_item, TopStocksCacheItem)
@@ -91,18 +99,19 @@ async def test_rehydrate_outside_trading_hours(mock_zoneinfo, top_stocks_analyze
 
 @pytest.mark.asyncio
 @patch("kuhl_haus.mdp.analyzers.top_stocks.ZoneInfo")
-async def test_rehydrate_within_trading_hours(mock_zoneinfo, top_stocks_analyzer, trading_hour_patch, mock_logger):
+async def test_rehydrate_within_trading_hours(mock_zoneinfo, top_stocks_analyzer, trading_hour_patch, mock_logger, mock_market_data_cache):
     """Test rehydrate within trading hours with valid data."""
     # Arrange
     # 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.logger = mock_logger
 
     # Act
-    await top_stocks_analyzer.rehydrate(data)
+    await top_stocks_analyzer.rehydrate()
 
     # Assert
     assert isinstance(top_stocks_analyzer.cache_item, TopStocksCacheItem)
     assert top_stocks_analyzer.cache_item.day_start_time == 1672531200
-    mock_logger.info.assert_called_once_with("Rehydrated TopStocksCacheItem")
+    mock_logger.info.assert_called_once_with("Rehydrated TopStocksCacheItem")

{kuhl_haus_mdp-0.1.5 → kuhl_haus_mdp-0.1.6}/tests/components/test_market_data_scanner.py

@@ -1,10 +1,9 @@
 # tests/test_market_data_scanner.py
-import asyncio
-import json
 import unittest
 from unittest.mock import AsyncMock, patch, MagicMock
 
 from kuhl_haus.mdp.analyzers.analyzer import Analyzer
+from kuhl_haus.mdp.analyzers.top_stocks import TopStocksAnalyzer
 from kuhl_haus.mdp.components.market_data_scanner import MarketDataScanner
 
 
@@ -14,22 +13,26 @@ class TestMarketDataScanner(unittest.IsolatedAsyncioTestCase):
     def setUp(self):
         """Set up a MarketDataScanner instance for testing."""
         self.redis_url = "redis://localhost:6379/0"
-        self.analyzer = MagicMock(spec=Analyzer)
+        self.analyzer = MagicMock(spec=TopStocksAnalyzer)
         self.analyzer.cache_key = MagicMock()
         self.analyzer.rehydrate = AsyncMock()
         self.analyzer.analyze_data = AsyncMock()
         self.subscriptions = ["channel_1"]
         self.scanner = MarketDataScanner(
             redis_url=self.redis_url,
-            analyzer=self.analyzer,
+            massive_api_key="test_key",
             subscriptions=self.subscriptions,
+            analyzer_class=Analyzer
         )
+        self.scanner.start()
 
+    @patch("kuhl_haus.mdp.analyzers.analyzer.Analyzer")
     @patch("kuhl_haus.mdp.components.market_data_scanner.asyncio.sleep", new_callable=AsyncMock)
     @patch("kuhl_haus.mdp.components.market_data_scanner.MarketDataScanner.start", new_callable=AsyncMock)
     @patch("kuhl_haus.mdp.components.market_data_scanner.MarketDataScanner.stop", new_callable=AsyncMock)
-    async def test_restart(self, mock_stop, mock_start, mock_sleep):
+    async def test_restart(self, mock_stop, mock_start, mock_sleep, mock_analyzer):
         """Test the restart method stops and starts the scanner."""
+        self.analyzer.return_value = mock_analyzer
         self.scanner.start = mock_start
         self.scanner.stop = mock_stop
         mock_stop.return_value = None
@@ -40,16 +43,3 @@ class TestMarketDataScanner(unittest.IsolatedAsyncioTestCase):
         mock_start.assert_called_once()
         self.assertEqual(self.scanner.restarts, 1)
 
-    async def test_process_message_success(self):
-        """Test _process_message handles and processes valid data."""
-        valid_data = {"key": "value"}
-        analyzer_results = [MagicMock(), MagicMock()]
-        self.analyzer.analyze_data = AsyncMock(return_value=analyzer_results)
-        self.scanner.cache_result = AsyncMock()
-
-        await self.scanner._process_message(valid_data)
-
-        self.analyzer.analyze_data.assert_called_once_with(valid_data)
-        self.scanner.cache_result.assert_any_call(analyzer_results[0])
-        self.scanner.cache_result.assert_any_call(analyzer_results[1])
-        self.assertEqual(self.scanner.processed, 1)