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

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

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

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

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

@@ -136,6 +136,9 @@ class TopStocksAnalyzer(Analyzer):
                     prev_day_volume = snapshot.prev_day.volume
                     prev_day_vwap = snapshot.prev_day.vwap
                     break
+                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

{kuhl_haus_mdp-0.1.10 → 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}"

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

@@ -27,4 +27,3 @@ class MarketDataCacheTTL(Enum):
     TOP_VOLUME_SCANNER = THREE_DAYS
     TOP_GAINERS_SCANNER = THREE_DAYS
     TOP_GAPPERS_SCANNER = THREE_DAYS
-

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

@@ -781,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}")