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

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

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

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

{kuhl_haus_mdp-0.1.9 → kuhl_haus_mdp-0.1.11}/src/kuhl_haus/mdp/analyzers/massive_data_analyzer.py

@@ -50,7 +50,7 @@ class MassiveDataAnalyzer:
         return [MarketDataAnalyzerResult(
             data=data,
             cache_key=f"{MarketDataCacheKeys.HALTS.value}:{symbol}",
-            cache_ttl=MarketDataCacheTTL.THREE_DAYS.value,
+            cache_ttl=MarketDataCacheTTL.HALTS.value,
             publish_key=f"{MarketDataCacheKeys.HALTS.value}:{symbol}",
         )]
 
@@ -58,8 +58,8 @@ class MassiveDataAnalyzer:
     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,
+            # cache_key=f"{MarketDataCacheKeys.AGGREGATE.value}:{symbol}",
+            # cache_ttl=MarketDataCacheTTL.AGGREGATE.value,
             publish_key=f"{MarketDataCacheKeys.AGGREGATE.value}:{symbol}",
         )]
 
@@ -67,8 +67,8 @@ class MassiveDataAnalyzer:
     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,
+            # cache_key=f"{MarketDataCacheKeys.TRADES.value}:{symbol}",
+            # cache_ttl=MarketDataCacheTTL.TRADES.value,
             publish_key=f"{MarketDataCacheKeys.TRADES.value}:{symbol}",
         )]
 
@@ -76,8 +76,8 @@ class MassiveDataAnalyzer:
     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,
+            # cache_key=f"{MarketDataCacheKeys.QUOTES.value}:{symbol}",
+            # cache_ttl=MarketDataCacheTTL.QUOTES.value,
             publish_key=f"{MarketDataCacheKeys.QUOTES.value}:{symbol}",
         )]
 
@@ -88,6 +88,6 @@ class MassiveDataAnalyzer:
         return [MarketDataAnalyzerResult(
             data=data,
             cache_key=cache_key,
-            cache_ttl=MarketDataCacheTTL.ONE_DAY.value,
+            cache_ttl=MarketDataCacheTTL.UNKNOWN.value,
             publish_key=f"{MarketDataCacheKeys.UNKNOWN.value}",
         )]

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

@@ -1,15 +1,9 @@
 import logging
 import time
-from datetime import datetime, timezone, timedelta
-from typing import Optional, List, Iterator
+from datetime import datetime, timezone
+from typing import Optional, List
 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 (
     EquityAgg,
     EventType
@@ -19,6 +13,7 @@ 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
 
@@ -94,24 +89,24 @@ class TopStocksAnalyzer(Analyzer):
             MarketDataAnalyzerResult(
                 data=self.cache_item.to_dict(),
                 cache_key=self.cache_key,
-                cache_ttl=28500,  # 7 hours, 55 minutes
+                cache_ttl=MarketDataCacheTTL.TOP_STOCKS_SCANNER.value,
             ),
             MarketDataAnalyzerResult(
                 data=self.cache_item.top_volume(100),
                 cache_key=MarketDataPubSubKeys.TOP_VOLUME_SCANNER.value,
-                cache_ttl=259200,  # 3 days
+                cache_ttl=MarketDataCacheTTL.TOP_VOLUME_SCANNER.value,
                 publish_key=MarketDataPubSubKeys.TOP_VOLUME_SCANNER.value,
             ),
             MarketDataAnalyzerResult(
                 data=self.cache_item.top_gainers(500),
                 cache_key=MarketDataPubSubKeys.TOP_GAINERS_SCANNER.value,
-                cache_ttl=259200,  # 3 days
+                cache_ttl=MarketDataCacheTTL.TOP_GAINERS_SCANNER.value,
                 publish_key=MarketDataPubSubKeys.TOP_GAINERS_SCANNER.value,
             ),
             MarketDataAnalyzerResult(
                 data=self.cache_item.top_gappers(500),
                 cache_key=MarketDataPubSubKeys.TOP_GAPPERS_SCANNER.value,
-                cache_ttl=259200,  # 3 days
+                cache_ttl=MarketDataCacheTTL.TOP_GAPPERS_SCANNER.value,
                 publish_key=MarketDataPubSubKeys.TOP_GAPPERS_SCANNER.value,
             )
         ]
@@ -141,7 +136,11 @@ class TopStocksAnalyzer(Analyzer):
                     prev_day_volume = snapshot.prev_day.volume
                     prev_day_vwap = snapshot.prev_day.vwap
                     break
-                except Exception:
+                except KeyError:
+                    retry_count += 1
+                    await self.cache.delete_ticker_snapshot(event.symbol)
+                except Exception as e:
+                    self.logger.error(f"Failed to get snapshot for {event.symbol}: {e}")
                     retry_count += 1
             if retry_count == max_tries and prev_day_close == 0:
                 self.logger.error(f"Failed to get snapshot for {event.symbol} after {max_tries} tries.")
@@ -155,7 +154,8 @@ class TopStocksAnalyzer(Analyzer):
                 try:
                     avg_volume = await self.cache.get_avg_volume(event.symbol)
                     break
-                except Exception:
+                except Exception as e:
+                    self.logger.error(f"Failed to get average volume for {event.symbol}: {e}")
                     retry_count += 1
             if retry_count == max_tries and avg_volume == 0:
                 self.logger.error(f"Failed to get average volume for {event.symbol} after {max_tries} tries.")
@@ -169,7 +169,8 @@ class TopStocksAnalyzer(Analyzer):
                 try:
                     free_float = await self.cache.get_free_float(event.symbol)
                     break
-                except Exception:
+                except Exception as e:
+                    self.logger.error(f"Failed to get free float for {event.symbol}: {e}")
                     retry_count += 1
             if retry_count == max_tries and free_float == 0:
                 self.logger.error(f"Failed to get free float for {event.symbol} after {max_tries} tries.")

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

@@ -26,6 +26,18 @@ class MarketDataCache:
         self.redis_client = redis_client
         self.http_session = None
 
+    async def delete_cache(self, cache_key: str):
+        """
+            Delete cache entry.
+
+            :arg cache_key: Cache key to delete
+        """
+        try:
+            await self.redis_client.delete(cache_key)
+            self.logger.info(f"Deleted cache entry: {cache_key}")
+        except Exception as e:
+            self.logger.error(f"Error deleting cache entry: {e}")
+
     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)
@@ -44,6 +56,16 @@ class MarketDataCache:
         await self.redis_client.publish(publish_key, json.dumps(data))
         self.logger.info(f"Published data for {publish_key}")
 
+    async def delete_ticker_snapshot(self, ticker: str):
+        """
+        Delete ticker snapshot from cache.
+
+        :param ticker: symbol of ticker to delete snapshot for
+        :return: None
+        """
+        cache_key = f"{MarketDataCacheKeys.TICKER_SNAPSHOTS.value}:{ticker}"
+        await self.delete_cache(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}"
@@ -61,7 +83,7 @@ class MarketDataCache:
             await self.cache_data(
                 data=data,
                 cache_key=cache_key,
-                cache_ttl=MarketDataCacheTTL.EIGHT_HOURS.value
+                cache_ttl=MarketDataCacheTTL.TICKER_SNAPSHOTS.value
             )
         return snapshot
 
@@ -109,13 +131,15 @@ class MarketDataCache:
                     periods_calculated += 1
                 else:
                     break
+            if periods_calculated == 0:
+                raise Exception(f"No volume data returned for {ticker}")
             avg_volume = total_volume / periods_calculated
 
         self.logger.info(f"average volume {ticker}: {avg_volume}")
         await self.cache_data(
             data=avg_volume,
             cache_key=cache_key,
-            cache_ttl=MarketDataCacheTTL.TWELVE_HOURS.value
+            cache_ttl=MarketDataCacheTTL.TICKER_AVG_VOLUME.value
         )
         return avg_volume
 
@@ -162,7 +186,7 @@ class MarketDataCache:
         await self.cache_data(
             data=free_float,
             cache_key=cache_key,
-            cache_ttl=MarketDataCacheTTL.TWELVE_HOURS.value
+            cache_ttl=MarketDataCacheTTL.TICKER_FREE_FLOAT.value
         )
         return free_float
 

kuhl_haus_mdp-0.1.11/src/kuhl_haus/mdp/models/constants.py

@@ -0,0 +1,24 @@
+# Minutes in seconds
+ONE_MINUTE = 60
+FIVE_MINUTES = 300
+TEN_MINUTES = 600
+FIFTEEN_MINUTES = 900
+TWENTY_MINUTES = 1200
+THIRTY_MINUTES = 1800
+
+# Hours in seconds
+ONE_HOUR = 3600
+TWO_HOURS = 7200
+FOUR_HOURS = 14400
+SIX_HOURS = 21600
+EIGHT_HOURS = 28800
+TWELVE_HOURS = 43200
+
+# Days in seconds
+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.11/src/kuhl_haus/mdp/models/market_data_cache_ttl.py

@@ -0,0 +1,29 @@
+from enum import Enum
+from kuhl_haus.mdp.models.constants import (
+    EIGHT_HOURS,
+    FIVE_MINUTES,
+    ONE_DAY,
+    ONE_HOUR,
+    THREE_DAYS,
+    TWELVE_HOURS,
+)
+
+
+class MarketDataCacheTTL(Enum):
+    # Raw market data caches
+    AGGREGATE = FIVE_MINUTES
+    HALTS = ONE_DAY
+    QUOTES = ONE_HOUR
+    TRADES = ONE_HOUR
+    UNKNOWN = ONE_DAY
+
+    # Ticker caches
+    TICKER_AVG_VOLUME = TWELVE_HOURS
+    TICKER_FREE_FLOAT = TWELVE_HOURS
+    TICKER_SNAPSHOTS = EIGHT_HOURS
+
+    # Scanner caches
+    TOP_STOCKS_SCANNER = EIGHT_HOURS
+    TOP_VOLUME_SCANNER = THREE_DAYS
+    TOP_GAINERS_SCANNER = THREE_DAYS
+    TOP_GAPPERS_SCANNER = THREE_DAYS

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

@@ -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.THREE_DAYS.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
 
@@ -64,8 +64,8 @@ def test_analyze_data_with_equity_agg_event_happy_path(valid_symbol, valid_equit
 
     # 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].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
 
@@ -79,8 +79,8 @@ def test_analyze_data_with_equity_agg_min_event_happy_path(valid_symbol, valid_e
 
     # 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].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_minute_data
 
@@ -94,8 +94,8 @@ def test_analyze_data_with_equity_trade_event_happy_path(valid_symbol, valid_equ
 
     # 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].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
 
@@ -109,8 +109,8 @@ def test_analyze_data_equity_quote_event_happy_path(valid_symbol, valid_equity_q
 
     # 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].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
 
@@ -167,7 +167,7 @@ def test_handle_luld_event_happy_path(valid_symbol, valid_luld_data):
     # 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].cache_ttl == MarketDataCacheTTL.HALTS.value
     assert result[0].publish_key == f"{MarketDataCacheKeys.HALTS.value}:{valid_symbol}"
     assert result[0].data == valid_luld_data
 
@@ -181,8 +181,8 @@ 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.THREE_DAYS.value
+    # 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
 
@@ -196,8 +196,8 @@ 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.EIGHT_HOURS.value
+    # 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
 
@@ -211,8 +211,8 @@ 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.THREE_DAYS.value
+    # 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
 
@@ -228,6 +228,6 @@ def test_handle_unknown_event_happy_path():
     # 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].cache_ttl == MarketDataCacheTTL.UNKNOWN.value
     assert result[0].publish_key == MarketDataCacheKeys.UNKNOWN.value
     assert result[0].data == data

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

@@ -6,6 +6,7 @@ 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
 
 
 @pytest.fixture
@@ -289,10 +290,10 @@ async def test_get_avg_volume_caches_with_correct_ttl():
     # Assert
     mock_redis_client.get.assert_awaited_once_with(mock_cache_key)
     mock_rest_client.list_financials_ratios.assert_called_once_with(ticker="TEST")
-    # Verify setex was called with the correct TTL (TWELVE_HOURS = 43200 seconds)
+    # Verify setex was called with the correct TTL
     call_args = mock_redis_client.setex.await_args
     assert call_args[0][0] == mock_cache_key
-    assert call_args[0][1] == 43200  # MarketDataCacheTTL.TWELVE_HOURS.value
+    assert call_args[0][1] == MarketDataCacheTTL.TICKER_AVG_VOLUME.value
     assert result == mock_avg_volume
 
 
@@ -318,10 +319,10 @@ async def test_get_avg_volume_caches_with_correct_ttl():
     # Assert
     mock_redis_client.get.assert_awaited_once_with(mock_cache_key)
     mock_rest_client.list_financials_ratios.assert_called_once_with(ticker="TEST")
-    # Verify setex was called with the correct TTL (TWELVE_HOURS = 43200 seconds)
+    # Verify setex was called with the correct TTL
     call_args = mock_redis_client.setex.await_args
     assert call_args[0][0] == mock_cache_key
-    assert call_args[0][1] == 43200  # MarketDataCacheTTL.TWELVE_HOURS.value
+    assert call_args[0][1] == MarketDataCacheTTL.TICKER_AVG_VOLUME.value
     assert result == mock_avg_volume
 
 
@@ -445,7 +446,7 @@ async def test_get_free_float_caches_with_correct_ttl():
     # Verify setex was called with the correct TTL (TWELVE_HOURS = 43200 seconds)
     call_args = mock_redis_client.setex.await_args
     assert call_args[0][0] == mock_cache_key
-    assert call_args[0][1] == 43200  # MarketDataCacheTTL.TWELVE_HOURS.value
+    assert call_args[0][1] == MarketDataCacheTTL.TICKER_FREE_FLOAT.value
     assert result == mock_free_float
 
 
@@ -780,4 +781,105 @@ async def test_get_http_session_singleton_behavior(mock_client_session):
     # Assert
     mock_client_session.assert_called_once()  # Should only be called once
     assert result1 == result2 == result3 == mock_session  # All should return same instance
-    assert id(result1) == id(result2) == id(result3)  # Verify same object in memory
+    assert id(result1) == id(result2) == id(result3)  # Verify same object in memory
+
+
+@pytest.mark.asyncio
+async def test_delete_ticker_snapshot_with_valid_ticker_expect_cache_deleted():
+    # Arrange
+    mock_redis_client = AsyncMock()
+    mock_rest_client = MagicMock()
+    sut = MarketDataCache(rest_client=mock_rest_client, redis_client=mock_redis_client, massive_api_key="test_key")
+    ticker = "TEST"
+    cache_key = f"{MarketDataCacheKeys.TICKER_SNAPSHOTS.value}:{ticker}"
+
+    # Act
+    await sut.delete_ticker_snapshot(ticker)
+
+    # Assert
+    mock_redis_client.delete.assert_awaited_once_with(cache_key)
+
+
+@pytest.mark.asyncio
+async def test_delete_ticker_snapshot_with_empty_ticker_expect_no_side_effect():
+    # Arrange
+    mock_redis_client = AsyncMock()
+    mock_rest_client = MagicMock()
+    sut = MarketDataCache(rest_client=mock_rest_client, redis_client=mock_redis_client, massive_api_key="test_key")
+    ticker = ""
+    cache_key = f"{MarketDataCacheKeys.TICKER_SNAPSHOTS.value}:{ticker}"
+
+    # Act
+    await sut.delete_ticker_snapshot(ticker)
+
+    # Assert
+    mock_redis_client.delete.assert_awaited_once_with(cache_key)
+
+
+@pytest.mark.asyncio
+@patch("logging.Logger.error")
+async def test_delete_ticker_snapshot_with_redis_error_expect_logged_error(mock_logger):
+    # Arrange
+    mock_redis_client = AsyncMock()
+    mock_redis_client.delete = AsyncMock(side_effect=Exception("Redis connection error"))
+    mock_rest_client = MagicMock()
+    sut = MarketDataCache(rest_client=mock_rest_client, redis_client=mock_redis_client, massive_api_key="test_key")
+    ticker = "TEST"
+    cache_key = f"{MarketDataCacheKeys.TICKER_SNAPSHOTS.value}:{ticker}"
+
+    # Act
+    await sut.delete_ticker_snapshot(ticker)
+
+    # Assert
+    mock_redis_client.delete.assert_awaited_once_with(cache_key)
+    mock_logger.assert_called_once_with("Error deleting cache entry: Redis connection error")
+
+
+@pytest.mark.asyncio
+async def test_delete_cache_with_existing_key_expect_cache_deleted():
+    # Arrange
+    mock_redis_client = AsyncMock()
+    mock_rest_client = MagicMock()
+    sut = MarketDataCache(rest_client=mock_rest_client, redis_client=mock_redis_client, massive_api_key="test_key")
+    test_cache_key = "test:cache:key"
+
+    # Act
+    await sut.delete_cache(test_cache_key)
+
+    # Assert
+    mock_redis_client.delete.assert_awaited_once_with(test_cache_key)
+
+
+@pytest.mark.asyncio
+@patch("logging.Logger.error")
+async def test_delete_cache_with_redis_error_expect_error_logged(mock_logger):
+    # Arrange
+    mock_redis_client = AsyncMock()
+    mock_redis_client.delete = AsyncMock(side_effect=Exception("Redis connection error"))
+    mock_rest_client = MagicMock()
+    sut = MarketDataCache(rest_client=mock_rest_client, redis_client=mock_redis_client, massive_api_key="test_key")
+    test_cache_key = "test:cache:key"
+
+    # Act
+    await sut.delete_cache(test_cache_key)
+
+    # Assert
+    mock_redis_client.delete.assert_awaited_once_with(test_cache_key)
+    mock_logger.assert_called_once_with(f"Error deleting cache entry: Redis connection error")
+
+
+@pytest.mark.asyncio
+@patch("logging.Logger.info")
+async def test_delete_cache_with_successful_deletion_expect_info_logged(mock_logger):
+    # Arrange
+    mock_redis_client = AsyncMock()
+    mock_rest_client = MagicMock()
+    sut = MarketDataCache(rest_client=mock_rest_client, redis_client=mock_redis_client, massive_api_key="test_key")
+    test_cache_key = "test:cache:key"
+
+    # Act
+    await sut.delete_cache(test_cache_key)
+
+    # Assert
+    mock_redis_client.delete.assert_awaited_once_with(test_cache_key)
+    mock_logger.assert_called_once_with(f"Deleted cache entry: {test_cache_key}")

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

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