kuhl-haus-mdp 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

kuhl_haus/mdp/analyzers/massive_data_analyzer.py

@@ -5,6 +5,7 @@ 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:
@@ -18,7 +19,7 @@ class MassiveDataAnalyzer:
             EventType.EquityQuote.value: self.handle_equity_quote_event,
         }
 
-    async def analyze_data(self, data: dict) -> Optional[List[MarketDataAnalyzerResult]]:
+    def analyze_data(self, data: dict) -> Optional[List[MarketDataAnalyzerResult]]:
         """
         Process raw market data message
 
@@ -30,73 +31,63 @@ class MassiveDataAnalyzer:
         """
         if "event_type" not in data:
             self.logger.info("Message missing 'event_type'")
-            return await self.handle_unknown_event(data)
+            return self.handle_unknown_event(data)
         event_type = data.get("event_type")
 
         if "symbol" not in data:
             self.logger.info("Message missing 'symbol'")
-            return await self.handle_unknown_event(data)
+            return self.handle_unknown_event(data)
         symbol = data.get("symbol")
 
         if event_type in self.event_handlers:
-            return await self.event_handlers[event_type](**{"data": data, "symbol": symbol})
+            return self.event_handlers[event_type](**{"data": data, "symbol": symbol})
         else:
             self.logger.warning(f"Unsupported message type: {event_type}")
-            return await self.handle_unknown_event(data)
+            return self.handle_unknown_event(data)
 
-    async def handle_luld_event(self, data: dict, symbol: str) -> Optional[List[MarketDataAnalyzerResult]]:
-        try:
-            return [MarketDataAnalyzerResult(
-                data=data,
-                cache_key=f"{MarketDataCacheKeys.HALTS.value}:{symbol}",
-                cache_ttl=28500,  # 7 hours, 55 minutes
-                publish_key=f"{MarketDataCacheKeys.HALTS.value}:{symbol}",
-            )]
-        except Exception as e:
-            self.logger.error(f"Error processing LULD message for {symbol}: {data}", e)
+    @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.THREE_DAYS.value,
+            publish_key=f"{MarketDataCacheKeys.HALTS.value}:{symbol}",
+        )]
 
-    async def handle_equity_agg_event(self, data: dict, symbol: str) -> Optional[List[MarketDataAnalyzerResult]]:
-        try:
-            return [MarketDataAnalyzerResult(
-                data=data,
-                # cache_key=f"{MarketDataCacheKeys.AGGREGATE.value}:{symbol}",
-                # cache_ttl=259200,  # 3 days
-                publish_key=f"{MarketDataCacheKeys.AGGREGATE.value}:{symbol}",
-            )]
-        except Exception as e:
-            self.logger.error(f"Error processing EquityAgg message for {symbol}: {data}", e)
+    @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.THREE_DAYS.value,
+            publish_key=f"{MarketDataCacheKeys.AGGREGATE.value}:{symbol}",
+        )]
 
-    async def handle_equity_trade_event(self, data: dict, symbol: str) -> Optional[List[MarketDataAnalyzerResult]]:
-        try:
-            return [MarketDataAnalyzerResult(
-                data=data,
-                # cache_key=f"{MarketDataCacheKeys.TRADES.value}:{symbol}",
-                # cache_ttl=28500,  # 7 hours, 55 minutes
-                publish_key=f"{MarketDataCacheKeys.TRADES.value}:{symbol}",
-            )]
-        except Exception as e:
-            self.logger.error(f"Error processing EquityTrade message for {symbol}: {data}", e)
+    @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.EIGHT_HOURS.value,
+            publish_key=f"{MarketDataCacheKeys.TRADES.value}:{symbol}",
+        )]
 
-    async def handle_equity_quote_event(self, data: dict, symbol: str) -> Optional[List[MarketDataAnalyzerResult]]:
-        try:
-            return [MarketDataAnalyzerResult(
-                data=data,
-                # cache_key=f"{MarketDataCacheKeys.QUOTES.value}:{symbol}",
-                # cache_ttl=259200,  # 3 days
-                publish_key=f"{MarketDataCacheKeys.QUOTES.value}:{symbol}",
-            )]
-        except Exception as e:
-            self.logger.error(f"Error processing EquityQuote message for {symbol}: {data}", e)
+    @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.THREE_DAYS.value,
+            publish_key=f"{MarketDataCacheKeys.QUOTES.value}:{symbol}",
+        )]
 
-    async def handle_unknown_event(self, data: dict) -> Optional[List[MarketDataAnalyzerResult]]:
-        try:
-            timestamp = f"{time()}".replace('.','')
-            cache_key = f"{MarketDataCacheKeys.UNKNOWN.value}:{timestamp}"
-            return [MarketDataAnalyzerResult(
-                data=data,
-                cache_key=cache_key,
-                cache_ttl=86400,  # 1 days
-                publish_key=f"{MarketDataCacheKeys.UNKNOWN.value}",
-            )]
-        except Exception as e:
-            self.logger.error(f"Error processing unknown message type: {data}", e)
+    @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.ONE_DAY.value,
+            publish_key=f"{MarketDataCacheKeys.UNKNOWN.value}",
+        )]

kuhl_haus/mdp/analyzers/top_stocks.py

@@ -1,167 +1,25 @@
 import logging
 import time
-from collections import defaultdict
-from dataclasses import dataclass, field
 from datetime import datetime, timezone, timedelta
-from typing import Dict, Optional, List, Iterator
+from typing import Optional, List, Iterator
 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 (
-    EquityTrade,
     EquityAgg,
     EventType
 )
-from massive.exceptions import BadResponse
 
 from kuhl_haus.mdp.analyzers.analyzer import Analyzer
 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
-
-
-# docs
-# https://massive.com/docs/stocks/ws_stocks_am
-# https://massive.com/docs/websocket/stocks/trades
-
-@dataclass()
-class TopStocksCacheItem:
-    day_start_time: Optional[float] = 0.0
-
-    # Cached details for each ticker
-    symbol_data_cache: Optional[Dict[str, dict]] = field(default_factory=lambda: defaultdict(dict))
-
-    # Top Volume map
-    top_volume_map: Optional[Dict[str, float]] = field(default_factory=lambda: defaultdict(dict))
-
-    # Top Gappers map
-    top_gappers_map: Optional[Dict[str, float]] = field(default_factory=lambda: defaultdict(dict))
-
-    # Top Gainers map
-    top_gainers_map: Optional[Dict[str, float]] = field(default_factory=lambda: defaultdict(dict))
-
-    def to_dict(self):
-        ret = {
-            # Cache start time
-            "day_start_time": self.day_start_time,
-
-            # Maps
-            "symbol_data_cache": self.symbol_data_cache,
-            "top_volume_map": self.top_volume_map,
-            "top_gappers_map": self.top_gappers_map,
-            "top_gainers_map": self.top_gainers_map,
-        }
-        return ret
-
-    def top_volume(self, limit):
-        ret = []
-        for ticker, volume in sorted(self.top_volume_map.items(), key=lambda x: x[1], reverse=True)[
-            :limit
-        ]:
-            try:
-                ret.append({
-                    "symbol": ticker,
-                    "volume": self.symbol_data_cache[ticker]["volume"],
-                    "accumulated_volume": self.symbol_data_cache[ticker]["accumulated_volume"],
-                    "relative_volume": self.symbol_data_cache[ticker]["relative_volume"],
-                    "official_open_price": self.symbol_data_cache[ticker]["official_open_price"],
-                    "vwap": self.symbol_data_cache[ticker]["vwap"],
-                    "open": self.symbol_data_cache[ticker]["open"],
-                    "close": self.symbol_data_cache[ticker]["close"],
-                    "high": self.symbol_data_cache[ticker]["high"],
-                    "low": self.symbol_data_cache[ticker]["low"],
-                    "aggregate_vwap": self.symbol_data_cache[ticker]["aggregate_vwap"],
-                    "average_size": self.symbol_data_cache[ticker]["average_size"],
-                    "avg_volume": self.symbol_data_cache[ticker]["avg_volume"],
-                    "prev_day_close": self.symbol_data_cache[ticker]["prev_day_close"],
-                    "prev_day_volume": self.symbol_data_cache[ticker]["prev_day_volume"],
-                    "prev_day_vwap": self.symbol_data_cache[ticker]["prev_day_vwap"],
-                    "change": self.symbol_data_cache[ticker]["change"],
-                    "pct_change": self.symbol_data_cache[ticker]["pct_change"],
-                    "change_since_open": self.symbol_data_cache[ticker]["change_since_open"],
-                    "pct_change_since_open": self.symbol_data_cache[ticker]["pct_change_since_open"],
-                    "start_timestamp": self.symbol_data_cache[ticker]["start_timestamp"],
-                    "end_timestamp": self.symbol_data_cache[ticker]["end_timestamp"],
-                })
-            except KeyError:
-                del self.top_volume_map[ticker]
-        return ret
-
-    def top_gappers(self, limit):
-        ret = []
-        for ticker, pct_change in sorted(self.top_gappers_map.items(), key=lambda x: x[1], reverse=True)[
-            :limit
-        ]:
-            try:
-                if pct_change <= 0:
-                    break
-                ret.append({
-                    "symbol": ticker,
-                    "volume": self.symbol_data_cache[ticker]["volume"],
-                    "accumulated_volume": self.symbol_data_cache[ticker]["accumulated_volume"],
-                    "relative_volume": self.symbol_data_cache[ticker]["relative_volume"],
-                    "official_open_price": self.symbol_data_cache[ticker]["official_open_price"],
-                    "vwap": self.symbol_data_cache[ticker]["vwap"],
-                    "open": self.symbol_data_cache[ticker]["open"],
-                    "close": self.symbol_data_cache[ticker]["close"],
-                    "high": self.symbol_data_cache[ticker]["high"],
-                    "low": self.symbol_data_cache[ticker]["low"],
-                    "aggregate_vwap": self.symbol_data_cache[ticker]["aggregate_vwap"],
-                    "average_size": self.symbol_data_cache[ticker]["average_size"],
-                    "avg_volume": self.symbol_data_cache[ticker]["avg_volume"],
-                    "prev_day_close": self.symbol_data_cache[ticker]["prev_day_close"],
-                    "prev_day_volume": self.symbol_data_cache[ticker]["prev_day_volume"],
-                    "prev_day_vwap": self.symbol_data_cache[ticker]["prev_day_vwap"],
-                    "change": self.symbol_data_cache[ticker]["change"],
-                    "pct_change": self.symbol_data_cache[ticker]["pct_change"],
-                    "change_since_open": self.symbol_data_cache[ticker]["change_since_open"],
-                    "pct_change_since_open": self.symbol_data_cache[ticker]["pct_change_since_open"],
-                    "start_timestamp": self.symbol_data_cache[ticker]["start_timestamp"],
-                    "end_timestamp": self.symbol_data_cache[ticker]["end_timestamp"],
-                })
-            except KeyError:
-                del self.top_gappers_map[ticker]
-        return ret
-
-    def top_gainers(self, limit):
-        ret = []
-        for ticker, pct_change in sorted(self.top_gainers_map.items(), key=lambda x: x[1], reverse=True)[
-            :limit
-        ]:
-            try:
-                if pct_change <= 0:
-                    break
-                ret.append({
-                    "symbol": ticker,
-                    "volume": self.symbol_data_cache[ticker]["volume"],
-                    "accumulated_volume": self.symbol_data_cache[ticker]["accumulated_volume"],
-                    "relative_volume": self.symbol_data_cache[ticker]["relative_volume"],
-                    "official_open_price": self.symbol_data_cache[ticker]["official_open_price"],
-                    "vwap": self.symbol_data_cache[ticker]["vwap"],
-                    "open": self.symbol_data_cache[ticker]["open"],
-                    "close": self.symbol_data_cache[ticker]["close"],
-                    "high": self.symbol_data_cache[ticker]["high"],
-                    "low": self.symbol_data_cache[ticker]["low"],
-                    "aggregate_vwap": self.symbol_data_cache[ticker]["aggregate_vwap"],
-                    "average_size": self.symbol_data_cache[ticker]["average_size"],
-                    "avg_volume": self.symbol_data_cache[ticker]["avg_volume"],
-                    "prev_day_close": self.symbol_data_cache[ticker]["prev_day_close"],
-                    "prev_day_volume": self.symbol_data_cache[ticker]["prev_day_volume"],
-                    "prev_day_vwap": self.symbol_data_cache[ticker]["prev_day_vwap"],
-                    "change": self.symbol_data_cache[ticker]["change"],
-                    "pct_change": self.symbol_data_cache[ticker]["pct_change"],
-                    "change_since_open": self.symbol_data_cache[ticker]["change_since_open"],
-                    "pct_change_since_open": self.symbol_data_cache[ticker]["pct_change_since_open"],
-                    "start_timestamp": self.symbol_data_cache[ticker]["start_timestamp"],
-                    "end_timestamp": self.symbol_data_cache[ticker]["end_timestamp"],
-                })
-            except KeyError:
-                del self.top_gainers_map[ticker]
-        return ret
+from kuhl_haus.mdp.models.top_stocks_cache_item import TopStocksCacheItem
 
 
 class TopStocksAnalyzer(Analyzer):
@@ -233,12 +91,6 @@ class TopStocksAnalyzer(Analyzer):
         self.last_update_time = current_time
 
         result = [
-            # MarketDataAnalyzerResult(
-            #     data=data,
-            #     cache_key=f"{MarketDataCacheKeys.AGGREGATE.value}:{symbol}",
-            #     cache_ttl=86400,  # 1 day
-            #     # publish_key=f"{MarketDataCacheKeys.AGGREGATE.value}:{symbol}",
-            # ),
             MarketDataAnalyzerResult(
                 data=self.cache_item.to_dict(),
                 cache_key=self.cache_key,

kuhl_haus/mdp/integ/massive_data_processor.py

@@ -114,8 +114,8 @@ class MassiveDataProcessor:
                     web_socket_message = json.loads(message.body.decode())
                     data = WebSocketMessageSerde.to_dict(web_socket_message)
 
-                    # Delegate to analyzer (async)
-                    analyzer_results = await self.analyzer.analyze_data(data)
+                    # Delegate to analyzer
+                    analyzer_results = self.analyzer.analyze_data(data)
                     if analyzer_results:
                         self.processed += 1
                         for analyzer_result in analyzer_results:

kuhl_haus/mdp/models/market_data_cache_ttl.py

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

kuhl_haus/mdp/models/top_stocks_cache_item.py

@@ -0,0 +1,143 @@
+from collections import defaultdict
+from dataclasses import dataclass, field
+from typing import Dict, Optional
+
+
+# docs
+# https://massive.com/docs/stocks/ws_stocks_am
+# https://massive.com/docs/websocket/stocks/trades
+
+@dataclass()
+class TopStocksCacheItem:
+    day_start_time: Optional[float] = 0.0
+
+    # Cached details for each ticker
+    symbol_data_cache: Optional[Dict[str, dict]] = field(default_factory=lambda: defaultdict(dict))
+
+    # Top Volume map
+    top_volume_map: Optional[Dict[str, float]] = field(default_factory=lambda: defaultdict(dict))
+
+    # Top Gappers map
+    top_gappers_map: Optional[Dict[str, float]] = field(default_factory=lambda: defaultdict(dict))
+
+    # Top Gainers map
+    top_gainers_map: Optional[Dict[str, float]] = field(default_factory=lambda: defaultdict(dict))
+
+    def to_dict(self):
+        ret = {
+            # Cache start time
+            "day_start_time": self.day_start_time,
+
+            # Maps
+            "symbol_data_cache": self.symbol_data_cache,
+            "top_volume_map": self.top_volume_map,
+            "top_gappers_map": self.top_gappers_map,
+            "top_gainers_map": self.top_gainers_map,
+        }
+        return ret
+
+    def top_volume(self, limit):
+        ret = []
+        for ticker, volume in sorted(self.top_volume_map.items(), key=lambda x: x[1], reverse=True)[
+            :limit
+        ]:
+            try:
+                ret.append({
+                    "symbol": ticker,
+                    "volume": self.symbol_data_cache[ticker]["volume"],
+                    "accumulated_volume": self.symbol_data_cache[ticker]["accumulated_volume"],
+                    "relative_volume": self.symbol_data_cache[ticker]["relative_volume"],
+                    "official_open_price": self.symbol_data_cache[ticker]["official_open_price"],
+                    "vwap": self.symbol_data_cache[ticker]["vwap"],
+                    "open": self.symbol_data_cache[ticker]["open"],
+                    "close": self.symbol_data_cache[ticker]["close"],
+                    "high": self.symbol_data_cache[ticker]["high"],
+                    "low": self.symbol_data_cache[ticker]["low"],
+                    "aggregate_vwap": self.symbol_data_cache[ticker]["aggregate_vwap"],
+                    "average_size": self.symbol_data_cache[ticker]["average_size"],
+                    "avg_volume": self.symbol_data_cache[ticker]["avg_volume"],
+                    "prev_day_close": self.symbol_data_cache[ticker]["prev_day_close"],
+                    "prev_day_volume": self.symbol_data_cache[ticker]["prev_day_volume"],
+                    "prev_day_vwap": self.symbol_data_cache[ticker]["prev_day_vwap"],
+                    "change": self.symbol_data_cache[ticker]["change"],
+                    "pct_change": self.symbol_data_cache[ticker]["pct_change"],
+                    "change_since_open": self.symbol_data_cache[ticker]["change_since_open"],
+                    "pct_change_since_open": self.symbol_data_cache[ticker]["pct_change_since_open"],
+                    "start_timestamp": self.symbol_data_cache[ticker]["start_timestamp"],
+                    "end_timestamp": self.symbol_data_cache[ticker]["end_timestamp"],
+                })
+            except KeyError:
+                del self.top_volume_map[ticker]
+        return ret
+
+    def top_gappers(self, limit):
+        ret = []
+        for ticker, pct_change in sorted(self.top_gappers_map.items(), key=lambda x: x[1], reverse=True)[
+            :limit
+        ]:
+            try:
+                if pct_change <= 0:
+                    break
+                ret.append({
+                    "symbol": ticker,
+                    "volume": self.symbol_data_cache[ticker]["volume"],
+                    "accumulated_volume": self.symbol_data_cache[ticker]["accumulated_volume"],
+                    "relative_volume": self.symbol_data_cache[ticker]["relative_volume"],
+                    "official_open_price": self.symbol_data_cache[ticker]["official_open_price"],
+                    "vwap": self.symbol_data_cache[ticker]["vwap"],
+                    "open": self.symbol_data_cache[ticker]["open"],
+                    "close": self.symbol_data_cache[ticker]["close"],
+                    "high": self.symbol_data_cache[ticker]["high"],
+                    "low": self.symbol_data_cache[ticker]["low"],
+                    "aggregate_vwap": self.symbol_data_cache[ticker]["aggregate_vwap"],
+                    "average_size": self.symbol_data_cache[ticker]["average_size"],
+                    "avg_volume": self.symbol_data_cache[ticker]["avg_volume"],
+                    "prev_day_close": self.symbol_data_cache[ticker]["prev_day_close"],
+                    "prev_day_volume": self.symbol_data_cache[ticker]["prev_day_volume"],
+                    "prev_day_vwap": self.symbol_data_cache[ticker]["prev_day_vwap"],
+                    "change": self.symbol_data_cache[ticker]["change"],
+                    "pct_change": self.symbol_data_cache[ticker]["pct_change"],
+                    "change_since_open": self.symbol_data_cache[ticker]["change_since_open"],
+                    "pct_change_since_open": self.symbol_data_cache[ticker]["pct_change_since_open"],
+                    "start_timestamp": self.symbol_data_cache[ticker]["start_timestamp"],
+                    "end_timestamp": self.symbol_data_cache[ticker]["end_timestamp"],
+                })
+            except KeyError:
+                del self.top_gappers_map[ticker]
+        return ret
+
+    def top_gainers(self, limit):
+        ret = []
+        for ticker, pct_change in sorted(self.top_gainers_map.items(), key=lambda x: x[1], reverse=True)[
+            :limit
+        ]:
+            try:
+                if pct_change <= 0:
+                    break
+                ret.append({
+                    "symbol": ticker,
+                    "volume": self.symbol_data_cache[ticker]["volume"],
+                    "accumulated_volume": self.symbol_data_cache[ticker]["accumulated_volume"],
+                    "relative_volume": self.symbol_data_cache[ticker]["relative_volume"],
+                    "official_open_price": self.symbol_data_cache[ticker]["official_open_price"],
+                    "vwap": self.symbol_data_cache[ticker]["vwap"],
+                    "open": self.symbol_data_cache[ticker]["open"],
+                    "close": self.symbol_data_cache[ticker]["close"],
+                    "high": self.symbol_data_cache[ticker]["high"],
+                    "low": self.symbol_data_cache[ticker]["low"],
+                    "aggregate_vwap": self.symbol_data_cache[ticker]["aggregate_vwap"],
+                    "average_size": self.symbol_data_cache[ticker]["average_size"],
+                    "avg_volume": self.symbol_data_cache[ticker]["avg_volume"],
+                    "prev_day_close": self.symbol_data_cache[ticker]["prev_day_close"],
+                    "prev_day_volume": self.symbol_data_cache[ticker]["prev_day_volume"],
+                    "prev_day_vwap": self.symbol_data_cache[ticker]["prev_day_vwap"],
+                    "change": self.symbol_data_cache[ticker]["change"],
+                    "pct_change": self.symbol_data_cache[ticker]["pct_change"],
+                    "change_since_open": self.symbol_data_cache[ticker]["change_since_open"],
+                    "pct_change_since_open": self.symbol_data_cache[ticker]["pct_change_since_open"],
+                    "start_timestamp": self.symbol_data_cache[ticker]["start_timestamp"],
+                    "end_timestamp": self.symbol_data_cache[ticker]["end_timestamp"],
+                })
+            except KeyError:
+                del self.top_gainers_map[ticker]
+        return ret

{kuhl_haus_mdp-0.1.1.dist-info → kuhl_haus_mdp-0.1.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kuhl-haus-mdp
-Version: 0.1.1
+Version: 0.1.3
 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.1.dist-info → kuhl_haus_mdp-0.1.3.dist-info}/RECORD

@@ -1,8 +1,8 @@
 kuhl_haus/mdp/__init__.py,sha256=5dEpAdB3kypH8tCRECoXwbly1WV9kFU5kh8ldGSa0VI,349
 kuhl_haus/mdp/analyzers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 kuhl_haus/mdp/analyzers/analyzer.py,sha256=eluYM2Iib5kgbpNZUSk2qEUL-j83ZTb3zmEmRazrmiM,404
-kuhl_haus/mdp/analyzers/massive_data_analyzer.py,sha256=4EEKDJjJmxCdL5nFa87AogabBHgGVld02UuWTgqfFjI,4536
-kuhl_haus/mdp/analyzers/top_stocks.py,sha256=AbRnPHSVrJgUq3CDV8SaNstldqoimlI23gpG69lzYBM,18759
+kuhl_haus/mdp/analyzers/massive_data_analyzer.py,sha256=WSb7T8X4u2ue7Du7sf_fqxjgjEbR6ThllSNT1CncIM0,3866
+kuhl_haus/mdp/analyzers/top_stocks.py,sha256=nvNA-NkxMjVO0MqFuAvG-v3UdSP7iWDRGI7GxpPBzWw,10876
 kuhl_haus/mdp/components/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 kuhl_haus/mdp/components/market_data_cache.py,sha256=r5sJHuSuLiw9BVckW--aWZHHIMqOTCf-pFURA7kef3Q,1070
 kuhl_haus/mdp/components/market_data_scanner.py,sha256=vA0HPqVIvuZb93wzJhtER6fcH6bf85AgXCbu7yVFOFE,9152
@@ -12,18 +12,20 @@ kuhl_haus/mdp/helpers/process_manager.py,sha256=Is3Jx8nlBWvywQ1acdsdaSJTAG0olKsk
 kuhl_haus/mdp/helpers/queue_name_resolver.py,sha256=l_zfRLxrjR9uwRCV2VDO4vPWLK_lj5KVG2p4Lh8xWiw,770
 kuhl_haus/mdp/integ/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 kuhl_haus/mdp/integ/massive_data_listener.py,sha256=fPEYc6zZzHzFFjbP3zFInajKtEGInj8UQKKo3nKQEwQ,5098
-kuhl_haus/mdp/integ/massive_data_processor.py,sha256=9I0tH9sZNs9Y0TyKIBKix_qlEksEZt5NRfP-Zf3FovE,8708
+kuhl_haus/mdp/integ/massive_data_processor.py,sha256=qktzLfuqrOgE4C9iZs4mXFvHt2BckgevRP8pEakzggA,8694
 kuhl_haus/mdp/integ/massive_data_queues.py,sha256=zC_uV2vwZCMyVerDQ18RAQwIMMF75iK4qUSqwuWqgwc,5050
 kuhl_haus/mdp/integ/utils.py,sha256=9JEpl2yr2LghOLrJUDxi-4dtDK3DZ1wBTZ1uxBJsFbQ,1309
 kuhl_haus/mdp/integ/web_socket_message_serde.py,sha256=XdaoaByc7IhtzbPDXBtXKOTjyDzfPSDuZVCoHSIaTl4,5468
 kuhl_haus/mdp/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 kuhl_haus/mdp/models/market_data_analyzer_result.py,sha256=iICb5GVCtuqARNbR1JNCAfbxMijM3uppDNdL8_FB3eI,422
 kuhl_haus/mdp/models/market_data_cache_keys.py,sha256=5iScBMhVQaG3p9P45veE-uRT7c6JY7k6j4DcvSEXENA,942
+kuhl_haus/mdp/models/market_data_cache_ttl.py,sha256=4KvsPeg84-sp4viUX6reN8CZYiM2aF9FgfXQmPbj3hw,348
 kuhl_haus/mdp/models/market_data_pubsub_keys.py,sha256=PEIPXK9jBehJB7G4pqoSuQZcfMZgOQq8Yho1itqv-1A,1306
 kuhl_haus/mdp/models/market_data_scanner_names.py,sha256=BYn1C0rYgGF1Sq583BkHADKUu-28ytNZQ-XgptuCH-Y,260
 kuhl_haus/mdp/models/massive_data_queue.py,sha256=MfYBcjVc4Fi61DWIvvhhWLUOiLmRpE9egtW-2KH6FTE,188
-kuhl_haus_mdp-0.1.1.dist-info/METADATA,sha256=Pwfg52rEA4A6MQdJtiUdF4BgL-U2NjSFPDCAYJYdaYE,8688
-kuhl_haus_mdp-0.1.1.dist-info/WHEEL,sha256=tsUv_t7BDeJeRHaSrczbGeuK-TtDpGsWi_JfpzD255I,90
-kuhl_haus_mdp-0.1.1.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
-kuhl_haus_mdp-0.1.1.dist-info/licenses/LICENSE.txt,sha256=DRkJftAJcMqoTkQ_Y6-HtKj3nm4pZah_p8XBZiYnw-c,1079
-kuhl_haus_mdp-0.1.1.dist-info/RECORD,,
+kuhl_haus/mdp/models/top_stocks_cache_item.py,sha256=4vwwPTMkRRf1ct6iFInJnLSbBadM-tRk-zhqdD_ITE0,7676
+kuhl_haus_mdp-0.1.3.dist-info/METADATA,sha256=0SI4PelAQU2MlicnUa8LtzqrKLCKcNQxfONkjQldC3g,8688
+kuhl_haus_mdp-0.1.3.dist-info/WHEEL,sha256=tsUv_t7BDeJeRHaSrczbGeuK-TtDpGsWi_JfpzD255I,90
+kuhl_haus_mdp-0.1.3.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
+kuhl_haus_mdp-0.1.3.dist-info/licenses/LICENSE.txt,sha256=DRkJftAJcMqoTkQ_Y6-HtKj3nm4pZah_p8XBZiYnw-c,1079
+kuhl_haus_mdp-0.1.3.dist-info/RECORD,,