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

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

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

@@ -29,7 +29,7 @@ dependencies = [
     "python-dotenv",
     "massive",
 ]
-version = "0.1.2"
+version = "0.1.3"
 
 [project.license]
 file = "LICENSE.txt"

{kuhl_haus_mdp-0.1.2 → kuhl_haus_mdp-0.1.3}/src/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-0.1.3/src/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.3/tests/models/test_top_stocks_cache_item.py

@@ -0,0 +1,109 @@
+# tests/test_top_stocks_cache_item.py
+import unittest
+from collections import defaultdict
+
+from src.kuhl_haus.mdp.models.top_stocks_cache_item import TopStocksCacheItem
+
+
+class TestTopStocksCacheItem(unittest.TestCase):
+    """Unit tests for the TopStocksCacheItem class."""
+
+    def setUp(self):
+        """Set up a TopStocksCacheItem instance for testing."""
+        self.cache_item = TopStocksCacheItem()
+
+    def test_initialization(self):
+        """Test the default initialization of TopStocksCacheItem."""
+        self.assertEqual(self.cache_item.day_start_time, 0.0)
+        self.assertIsInstance(self.cache_item.symbol_data_cache, defaultdict)
+        self.assertIsInstance(self.cache_item.top_volume_map, defaultdict)
+        self.assertIsInstance(self.cache_item.top_gappers_map, defaultdict)
+        self.assertIsInstance(self.cache_item.top_gainers_map, defaultdict)
+
+    def test_to_dict_method(self):
+        """Test the to_dict method of TopStocksCacheItem."""
+        expected_dict = {
+            "day_start_time": 0.0,
+            "symbol_data_cache": self.cache_item.symbol_data_cache,
+            "top_volume_map": self.cache_item.top_volume_map,
+            "top_gappers_map": self.cache_item.top_gappers_map,
+            "top_gainers_map": self.cache_item.top_gainers_map,
+        }
+        self.assertEqual(self.cache_item.to_dict(), expected_dict)
+
+    def test_top_volume_method(self):
+        """Test the top_volume method with a limit."""
+        self.cache_item.top_volume_map = {"AAPL": 1200, "GOOG": 600, "AMZN": 500}
+        self.cache_item.symbol_data_cache = {
+            "AAPL": {"volume": 1000, "accumulated_volume": 1200, "relative_volume": 1.2, "official_open_price": 150,
+                     "vwap": 155, "open": 145, "close": 152, "high": 160, "low": 142, "aggregate_vwap": 156,
+                     "average_size": 50, "avg_volume": 1000, "prev_day_close": 148, "prev_day_volume": 900,
+                     "prev_day_vwap": 154, "change": 4, "pct_change": 2.7, "change_since_open": 7,
+                     "pct_change_since_open": 4.8, "start_timestamp": 100000, "end_timestamp": 110000},
+            "AMZN": {"volume": 300, "accumulated_volume": 500, "relative_volume": 1.2, "official_open_price": 3300,
+                     "vwap": 3500, "open": 3250, "close": 3520, "high": 3600, "low": 3200, "aggregate_vwap": 3450,
+                     "average_size": 85, "avg_volume": 4000, "prev_day_close": 3200, "prev_day_volume": 3900,
+                     "prev_day_vwap": 3400, "change": 200, "pct_change": 10.0, "change_since_open": 270,
+                     "pct_change_since_open": 8.3, "start_timestamp": 300000, "end_timestamp": 310000},
+            "GOOG": {"volume": 500, "accumulated_volume": 600, "relative_volume": 1.0, "official_open_price": 2500,
+                     "vwap": 2550, "open": 2450, "close": 2520, "high": 2600, "low": 2400, "aggregate_vwap": 2560,
+                     "average_size": 65, "avg_volume": 2000, "prev_day_close": 2510, "prev_day_volume": 1900,
+                     "prev_day_vwap": 2530, "change": 10, "pct_change": 0.4, "change_since_open": 70,
+                     "pct_change_since_open": 2.9, "start_timestamp": 200000, "end_timestamp": 210000},
+        }
+        result = self.cache_item.top_volume(2)
+        self.assertEqual(2, len(result))
+        self.assertEqual(result[0]["symbol"], "AAPL")
+        self.assertEqual(result[1]["symbol"], "GOOG")
+
+    def test_top_gappers_method(self):
+        """Test the top_gappers method with a limit."""
+        self.cache_item.top_gappers_map = {"AAPL": 5.0, "GOOG": -3.0, "AMZN": 10.0}
+        self.cache_item.symbol_data_cache = {
+            "AAPL": {"volume": 1000, "accumulated_volume": 1200, "relative_volume": 1.5, "official_open_price": 150,
+                     "vwap": 155, "open": 145, "close": 152, "high": 160, "low": 142, "aggregate_vwap": 156,
+                     "average_size": 50, "avg_volume": 1000, "prev_day_close": 148, "prev_day_volume": 900,
+                     "prev_day_vwap": 154, "change": 4, "pct_change": 5.0, "change_since_open": 7,
+                     "pct_change_since_open": 2.5, "start_timestamp": 100000, "end_timestamp": 110000},
+            "AMZN": {"volume": 300, "accumulated_volume": 500, "relative_volume": 1.2, "official_open_price": 3300,
+                     "vwap": 3500, "open": 3250, "close": 3520, "high": 3600, "low": 3200, "aggregate_vwap": 3450,
+                     "average_size": 85, "avg_volume": 4000, "prev_day_close": 3200, "prev_day_volume": 3900,
+                     "prev_day_vwap": 3400, "change": 200, "pct_change": 10.0, "change_since_open": 270,
+                     "pct_change_since_open": 8.3, "start_timestamp": 300000, "end_timestamp": 310000},
+            "GOOG": {"volume": 500, "accumulated_volume": 600, "relative_volume": 1.0, "official_open_price": 2500,
+                     "vwap": 2550, "open": 2450, "close": 2520, "high": 2600, "low": 2400, "aggregate_vwap": 2560,
+                     "average_size": 65, "avg_volume": 2000, "prev_day_close": 2510, "prev_day_volume": 1900,
+                     "prev_day_vwap": 2530, "change": 10, "pct_change": 0.4, "change_since_open": 70,
+                     "pct_change_since_open": 2.9, "start_timestamp": 200000, "end_timestamp": 210000},
+        }
+        result = self.cache_item.top_gappers(1)
+        self.assertEqual(len(result), 1)
+        self.assertEqual(result[0]["symbol"], "AMZN")
+
+    def test_top_gainers_method(self):
+        """Test the top_gainers method with a limit."""
+        self.cache_item.top_gainers_map = {"AAPL": 2.5, "GOOG": -0.5, "AMZN": 8.3}
+        self.cache_item.symbol_data_cache = {
+            "AAPL": {"volume": 500, "accumulated_volume": 800, "relative_volume": 1.6, "official_open_price": 140,
+                     "vwap": 145, "open": 130, "close": 150, "high": 155, "low": 128, "aggregate_vwap": 150,
+                     "average_size": 45, "avg_volume": 900, "prev_day_close": 142, "prev_day_volume": 850,
+                     "prev_day_vwap": 145, "change": 8, "pct_change": 2.5, "change_since_open": 20,
+                     "pct_change_since_open": 15.4, "start_timestamp": 150000, "end_timestamp": 160000},
+            "AMZN": {"volume": 800, "accumulated_volume": 1200, "relative_volume": 1.4, "official_open_price": 3200,
+                     "vwap": 3300, "open": 3150, "close": 3400, "high": 3450, "low": 3100, "aggregate_vwap": 3350,
+                     "average_size": 70, "avg_volume": 3900, "prev_day_close": 3250, "prev_day_volume": 3800,
+                     "prev_day_vwap": 3300, "change": 150, "pct_change": 4.6, "change_since_open": 250,
+                     "pct_change_since_open": 8.3, "start_timestamp": 170000, "end_timestamp": 180000},
+            "GOOG": {"volume": 500, "accumulated_volume": 600, "relative_volume": 1.0, "official_open_price": 2500,
+                     "vwap": 2550, "open": 2450, "close": 2520, "high": 2600, "low": 2400, "aggregate_vwap": 2560,
+                     "average_size": 65, "avg_volume": 2000, "prev_day_close": 2510, "prev_day_volume": 1900,
+                     "prev_day_vwap": 2530, "change": 10, "pct_change": 0.4, "change_since_open": 70,
+                     "pct_change_since_open": 2.9, "start_timestamp": 200000, "end_timestamp": 210000},
+        }
+        result = self.cache_item.top_gainers(1)
+        self.assertEqual(len(result), 1)
+        self.assertEqual(result[0]["symbol"], "AMZN")
+
+
+if __name__ == "__main__":
+    unittest.main()