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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kuhl-haus-mdp
-Version: 0.1.3
+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)
@@ -33,20 +33,22 @@ Project-URL: Source, https://github.com/kuhl-haus/kuhl-haus-mdp.git
 Project-URL: Changelog, https://github.com/kuhl-haus/kuhl-haus-mdp/commits
 Project-URL: Tracker, https://github.com/kuhl-haus/kuhl-haus-mdp/issues
 Requires-Python: <3.13,>=3.9.21
-Requires-Dist: websockets
+Requires-Dist: aiohttp
 Requires-Dist: aio-pika
-Requires-Dist: redis[asyncio]
-Requires-Dist: tenacity
 Requires-Dist: fastapi
-Requires-Dist: uvicorn[standard]
+Requires-Dist: massive
 Requires-Dist: pydantic-settings
 Requires-Dist: python-dotenv
-Requires-Dist: massive
+Requires-Dist: redis[asyncio]
+Requires-Dist: tenacity
+Requires-Dist: uvicorn[standard]
+Requires-Dist: websockets
 Provides-Extra: testing
 Requires-Dist: setuptools; extra == "testing"
 Requires-Dist: pdm-backend; extra == "testing"
 Requires-Dist: pytest; extra == "testing"
 Requires-Dist: pytest-cov; extra == "testing"
+Requires-Dist: pytest-asyncio; extra == "testing"
 Description-Content-Type: text/markdown
 
 <!-- These are examples of badges you might want to add to your README:
@@ -66,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.3 → 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.3 → kuhl_haus_mdp-0.1.6}/pyproject.toml

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

{kuhl_haus_mdp-0.1.3 → 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.3 → kuhl_haus_mdp-0.1.6}/src/kuhl_haus/mdp/analyzers/top_stocks.py

@@ -16,6 +16,7 @@ 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_pubsub_keys import MarketDataPubSubKeys
@@ -24,22 +25,16 @@ from kuhl_haus.mdp.models.top_stocks_cache_item import TopStocksCacheItem
 
 class TopStocksAnalyzer(Analyzer):
 
-    def __init__(self, rest_client: RESTClient, **kwargs):
-        if "cache_key" not in kwargs:
-            kwargs["cache_key"] = MarketDataCacheKeys.TOP_STOCKS_SCANNER.value
-        super().__init__(**kwargs)
-        self.rest_client = rest_client
+    def __init__(self, cache: MarketDataCache, **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"))
@@ -51,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")
 
@@ -135,7 +135,7 @@ class TopStocksAnalyzer(Analyzer):
             prev_day_vwap = 0
             while retry_count < max_tries:
                 try:
-                    snapshot = await self.get_ticker_snapshot(event.symbol)
+                    snapshot = await self.cache.get_ticker_snapshot(event.symbol)
                     prev_day_close = snapshot.prev_day.close
                     prev_day_volume = snapshot.prev_day.volume
                     prev_day_vwap = snapshot.prev_day.vwap
@@ -153,7 +153,7 @@ class TopStocksAnalyzer(Analyzer):
             avg_volume = 0
             while retry_count < max_tries:
                 try:
-                    avg_volume = await self.get_avg_volume(event.symbol)
+                    avg_volume = await self.cache.get_avg_volume(event.symbol)
                     break
                 except (BadResponse, ZeroDivisionError) as e:
                     self.logger.error(f"Error getting average volume for {event.symbol}: {repr(e)}", exc_info=e, stack_info=True)
@@ -217,44 +217,3 @@ class TopStocksAnalyzer(Analyzer):
             "start_timestamp": event.start_timestamp,
             "end_timestamp": event.end_timestamp,
         }
-
-    async def get_ticker_snapshot(self, ticker: str) -> TickerSnapshot:
-        self.logger.debug(f"Getting snapshot for {ticker}")
-        result: TickerSnapshot = self.rest_client.get_snapshot_ticker(
-            market_type="stocks",
-            ticker=ticker
-        )
-        self.logger.debug(f"Snapshot result: {result}")
-        return result
-
-    async def get_avg_volume(self, ticker: str):
-        self.logger.debug(f"Getting average volume for {ticker}")
-        # Get date string in YYYY-MM-DD format
-        end_date = datetime.now(timezone.utc).strftime("%Y-%m-%d")
-        # Get date from 30 trading sessions ago in YYYY-MM-DD format
-        start_date = (datetime.now(timezone.utc) - timedelta(days=42)).strftime("%Y-%m-%d")
-
-        result: Iterator[Agg] = self.rest_client.list_aggs(
-            ticker=ticker,
-            multiplier=1,
-            timespan="day",
-            from_=start_date,
-            to=end_date,
-            adjusted=True,
-            sort="desc"
-        )
-        self.logger.debug(f"average volume result: {result}")
-
-        total_volume = 0
-        max_periods = 30
-        periods_calculated = 0
-        for agg in result:
-            if periods_calculated < max_periods:
-                total_volume += agg.volume
-                periods_calculated += 1
-            else:
-                break
-        avg_volume = total_volume / periods_calculated
-
-        self.logger.debug(f"average volume {ticker}: {avg_volume}")
-        return avg_volume

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

@@ -0,0 +1,143 @@
+import json
+import logging
+from typing import Any, Optional, Iterator, List
+
+import aiohttp
+import redis.asyncio as aioredis
+from massive.rest import RESTClient
+from massive.rest.models import (
+    TickerSnapshot,
+    FinancialRatio,
+)
+
+from kuhl_haus.mdp.models.market_data_cache_keys import MarketDataCacheKeys
+from kuhl_haus.mdp.models.market_data_cache_ttl import MarketDataCacheTTL
+
+
+class MarketDataCache:
+    def __init__(self, rest_client: RESTClient, redis_client: aioredis.Redis, massive_api_key: str):
+        self.logger = logging.getLogger(__name__)
+        self.rest_client = rest_client
+        self.massive_api_key = massive_api_key
+        self.redis_client = redis_client
+        self.http_session = None
+
+    async def get_cache(self, cache_key: str) -> Optional[dict]:
+        """Fetch current value from Redis cache (for snapshot requests)."""
+        value = await self.redis_client.get(cache_key)
+        if value:
+            return json.loads(value)
+        return None
+
+    async def cache_data(self, data: Any, cache_key: str, cache_ttl: int = 0):
+        if cache_ttl > 0:
+            await self.redis_client.setex(cache_key, cache_ttl, json.dumps(data))
+        else:
+            await self.redis_client.set(cache_key, json.dumps(data))
+        self.logger.debug(f"Cached data for {cache_key}")
+
+    async def publish_data(self, data: Any, publish_key: str = None):
+        await self.redis_client.publish(publish_key, json.dumps(data))
+        self.logger.debug(f"Published data for {publish_key}")
+
+    async def get_ticker_snapshot(self, ticker: str) -> TickerSnapshot:
+        self.logger.debug(f"Getting snapshot for {ticker}")
+        cache_key = f"{MarketDataCacheKeys.TICKER_SNAPSHOTS.value}:{ticker}"
+        result = await self.get_cache(cache_key=cache_key)
+        if result:
+            snapshot = TickerSnapshot.from_dict(**result)
+        else:
+            snapshot: TickerSnapshot = self.rest_client.get_snapshot_ticker(
+                market_type="stocks",
+                ticker=ticker
+            )
+            self.logger.debug(f"Snapshot result: {snapshot}")
+            await self.cache_data(
+                data=snapshot,
+                cache_key=cache_key,
+                cache_ttl=MarketDataCacheTTL.EIGHT_HOURS.value
+            )
+        return snapshot
+
+    async def get_avg_volume(self, ticker: str):
+        self.logger.debug(f"Getting average volume for {ticker}")
+        cache_key = f"{MarketDataCacheKeys.TICKER_AVG_VOLUME.value}:{ticker}"
+        avg_volume = await self.get_cache(cache_key=cache_key)
+        if avg_volume:
+            self.logger.debug(f"Returning cached value for {ticker}: {avg_volume}")
+            return avg_volume
+
+        results: Iterator[FinancialRatio] = self.rest_client.list_financials_ratios(ticker=ticker)
+        ratios: List[FinancialRatio] = []
+        for financial_ratio in results:
+            ratios.append(financial_ratio)
+        if len(ratios) == 1:
+            avg_volume = ratios[0].average_volume
+        else:
+            raise Exception(f"Unexpected number of financial ratios for {ticker}: {len(ratios)}")
+
+        self.logger.debug(f"average volume {ticker}: {avg_volume}")
+        await self.cache_data(
+            data=avg_volume,
+            cache_key=cache_key,
+            cache_ttl=MarketDataCacheTTL.TWELVE_HOURS.value
+        )
+        return avg_volume
+
+    async def get_free_float(self, ticker: str):
+        self.logger.debug(f"Getting free float for {ticker}")
+        cache_key = f"{MarketDataCacheKeys.TICKER_FREE_FLOAT.value}:{ticker}"
+        free_float = await self.get_cache(cache_key=cache_key)
+        if free_float:
+            self.logger.debug(f"Returning cached value for {ticker}: {free_float}")
+            return free_float
+
+        # NOTE: This endpoint is experimental and the interface may change.
+        # https://massive.com/docs/rest/stocks/fundamentals/float
+        url = f"https://api.massive.com/stocks/vX/float"
+        params = {
+            "ticker": ticker,
+            "apiKey": self.massive_api_key
+        }
+
+        session = await self.get_http_session()
+        try:
+            async with session.get(url, params=params, timeout=aiohttp.ClientTimeout(total=10)) as response:
+                response.raise_for_status()
+                data = await response.json()
+
+                # Extract free_float from response
+                if data.get("status") == "OK" and data.get("results") is not None:
+                    results = data["results"]
+                    if len(results) > 0:
+                        free_float = results[0].get("free_float")
+                    else:
+                        raise Exception(f"No free float data returned for {ticker}")
+                else:
+                    raise Exception(f"Invalid response from Massive API for {ticker}: {data}")
+
+        except aiohttp.ClientError as e:
+            self.logger.error(f"HTTP error fetching free float for {ticker}: {e}")
+            raise
+        except Exception as e:
+            self.logger.error(f"Error fetching free float for {ticker}: {e}")
+            raise
+
+        self.logger.debug(f"free float {ticker}: {free_float}")
+        await self.cache_data(
+            data=free_float,
+            cache_key=cache_key,
+            cache_ttl=MarketDataCacheTTL.TWELVE_HOURS.value
+        )
+        return free_float
+
+    async def get_http_session(self) -> aiohttp.ClientSession:
+        """Get or create aiohttp session for async HTTP requests."""
+        if self.http_session is None or self.http_session.closed:
+            self.http_session = aiohttp.ClientSession()
+        return self.http_session
+
+    async def close(self):
+        """Close aiohttp session."""
+        if self.http_session and not self.http_session.closed:
+            await self.http_session.close()

{kuhl_haus_mdp-0.1.3 → 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.3 → kuhl_haus_mdp-0.1.6}/src/kuhl_haus/mdp/integ/massive_data_processor.py

@@ -1,17 +1,14 @@
 import asyncio
 import json
 import logging
-from typing import Dict
 
 import aio_pika
-import redis
 import redis.asyncio as aioredis
 from aio_pika.abc import AbstractIncomingMessage
-from aio_pika.exceptions import AMQPConnectionError
 
 from kuhl_haus.mdp.analyzers.massive_data_analyzer import MassiveDataAnalyzer
-from kuhl_haus.mdp.models.market_data_analyzer_result import MarketDataAnalyzerResult
 from kuhl_haus.mdp.integ.web_socket_message_serde import WebSocketMessageSerde
+from kuhl_haus.mdp.models.market_data_analyzer_result import MarketDataAnalyzerResult
 
 
 class MassiveDataProcessor:

{kuhl_haus_mdp-0.1.3 → kuhl_haus_mdp-0.1.6}/src/kuhl_haus/mdp/models/market_data_cache_keys.py

@@ -16,6 +16,9 @@ class MarketDataCacheKeys(Enum):
 
     # MARKET DATA CACHE
     DAILY_AGGREGATES = 'aggregate:daily'
+    TICKER_SNAPSHOTS = 'snapshots'
+    TICKER_AVG_VOLUME = 'avg_volume'
+    TICKER_FREE_FLOAT = 'free_float'
 
     # MARKET DATA PROCESSOR CACHE
     TOP_TRADES_SCANNER = f'cache:{MarketDataScannerNames.TOP_TRADES.value}'

{kuhl_haus_mdp-0.1.3 → kuhl_haus_mdp-0.1.6}/src/kuhl_haus/mdp/models/market_data_cache_ttl.py

@@ -8,6 +8,7 @@ class MarketDataCacheTTL(Enum):
     FOUR_HOURS = 14400
     SIX_HOURS = 21600
     EIGHT_HOURS = 28800
+    TWELVE_HOURS = 43200
 
     # Days
     ONE_DAY = 86400

{kuhl_haus_mdp-0.1.3 → kuhl_haus_mdp-0.1.6}/tests/analyzers/test_massive_data_analyzer.py

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

kuhl_haus_mdp-0.1.6/tests/analyzers/test_top_stocks_rehydrate.py

@@ -0,0 +1,117 @@
+
+from datetime import datetime, timezone
+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.components.market_data_cache import MarketDataCache
+
+
+@pytest.fixture
+def mock_market_data_cache():
+    mock = MagicMock(spec=MarketDataCache)
+    mock.get_cache = AsyncMock()
+    return mock
+
+
+@pytest.fixture
+def top_stocks_analyzer(mock_market_data_cache):
+    return TopStocksAnalyzer(cache=mock_market_data_cache)
+
+
+@pytest.fixture
+def mock_logger():
+    return MagicMock()
+
+
+@pytest.fixture
+def analyzer(mock_market_data_cache, mock_logger):
+    """Fixture to set up the TopStocksAnalyzer system under test."""
+    sut = TopStocksAnalyzer(cache=mock_market_data_cache)
+    sut.logger = mock_logger
+    sut.cache_item = TopStocksCacheItem()
+    sut.cache_item.day_start_time = datetime(2026, 1, 1, 4, 0, 0, tzinfo=timezone.utc).timestamp()
+    sut.last_update_time = 0
+    return sut
+
+
+@pytest.fixture
+def trading_hour_patch():
+    # Patch datetime to simulate within trading hours
+    patcher = patch("kuhl_haus.mdp.analyzers.top_stocks.datetime", wraps=datetime)
+    mocked_datetime = patcher.start()
+    mocked_datetime.now.return_value = datetime(2023, 11, 1, 14, 0, 0, tzinfo=timezone.utc)  # Wed 14:00 UTC
+    yield mocked_datetime
+    patcher.stop()
+
+
+@pytest.fixture
+def outside_trading_hour_patch():
+    # Patch datetime to simulate outside trading hours
+    patcher = patch("kuhl_haus.mdp.analyzers.top_stocks.datetime", wraps=datetime)
+    mocked_datetime = patcher.start()
+    mocked_datetime.now.return_value = datetime(2023, 11, 1, 21, 0, 0, tzinfo=timezone.utc)  # Wed 21:00 UTC
+    yield mocked_datetime
+    patcher.stop()
+
+
+@pytest.mark.asyncio
+@patch("kuhl_haus.mdp.analyzers.top_stocks.ZoneInfo")
+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()
+
+    # Assert
+    assert isinstance(top_stocks_analyzer.cache_item, TopStocksCacheItem)
+    mock_logger.info.assert_called_once_with("No data to rehydrate TopStocksCacheItem.")
+
+
+@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, 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()
+
+    # Assert
+    assert isinstance(top_stocks_analyzer.cache_item, TopStocksCacheItem)
+    assert top_stocks_analyzer.cache_item.day_start_time == 0.0
+    mock_logger.info.assert_called_once_with(
+        "Outside market hours (21:00:00 UTC), clearing cache."
+    )
+
+
+@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, 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()
+
+    # 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")