kuhl-haus-mdp 0.1.5__py3-none-any.whl → 0.1.7__py3-none-any.whl

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/analyzers/top_stocks.py

@@ -26,21 +26,15 @@ from kuhl_haus.mdp.models.top_stocks_cache_item import TopStocksCacheItem
 class TopStocksAnalyzer(Analyzer):
 
     def __init__(self, cache: MarketDataCache, **kwargs):
-        if "cache_key" not in kwargs:
-            kwargs["cache_key"] = MarketDataCacheKeys.TOP_STOCKS_SCANNER.value
-        super().__init__(**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"))
@@ -52,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")
 

kuhl_haus/mdp/components/market_data_cache.py

@@ -1,6 +1,8 @@
 import json
 import logging
 from typing import Any, Optional, Iterator, List
+from datetime import datetime, timezone, timedelta
+from zoneinfo import ZoneInfo
 
 import aiohttp
 import redis.asyncio as aioredis
@@ -8,8 +10,10 @@ from massive.rest import RESTClient
 from massive.rest.models import (
     TickerSnapshot,
     FinancialRatio,
+    Agg,
 )
 
+from kuhl_haus.mdp.helpers.utils import ticker_snapshot_to_dict
 from kuhl_haus.mdp.models.market_data_cache_keys import MarketDataCacheKeys
 from kuhl_haus.mdp.models.market_data_cache_ttl import MarketDataCacheTTL
 
@@ -34,49 +38,151 @@ class MarketDataCache:
             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}")
+        self.logger.info(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}")
+        self.logger.info(f"Published data for {publish_key}")
 
     async def get_ticker_snapshot(self, ticker: str) -> TickerSnapshot:
-        self.logger.debug(f"Getting snapshot for {ticker}")
+        self.logger.info(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)
+            self.logger.info(f"Returning cached snapshot for {ticker}")
+            snapshot = TickerSnapshot(**result)
         else:
             snapshot: TickerSnapshot = self.rest_client.get_snapshot_ticker(
                 market_type="stocks",
                 ticker=ticker
             )
-            self.logger.debug(f"Snapshot result: {snapshot}")
+            self.logger.info(f"Snapshot result: {snapshot}")
+            # data = {
+            #     "day": {
+            #         "open": snapshot.day.open,
+            #         "high": snapshot.day.high,
+            #         "low": snapshot.day.low,
+            #         "close": snapshot.day.close,
+            #         "volume": snapshot.day.volume,
+            #         "vwap": snapshot.day.vwap,
+            #         "timestamp": snapshot.day.timestamp,
+            #         "transactions": snapshot.day.transactions,
+            #         "otc": snapshot.day.otc,
+            #     },
+            #     "last_quote": {
+            #         "ticker": snapshot.last_quote.ticker,
+            #         "trf_timestamp": snapshot.last_quote.trf_timestamp,
+            #         "sequence_number": snapshot.last_quote.sequence_number,
+            #         "sip_timestamp": snapshot.last_quote.sip_timestamp,
+            #         "participant_timestamp": snapshot.last_quote.participant_timestamp,
+            #         "ask_price": snapshot.last_quote.ask_price,
+            #         "ask_size": snapshot.last_quote.ask_size,
+            #         "ask_exchange": snapshot.last_quote.ask_exchange,
+            #         "conditions": snapshot.last_quote.conditions,
+            #         "indicators": snapshot.last_quote.indicators,
+            #         "bid_price": snapshot.last_quote.bid_price,
+            #         "bid_size": snapshot.last_quote.bid_size,
+            #         "bid_exchange": snapshot.last_quote.bid_exchange,
+            #         "tape": snapshot.last_quote.tape,
+            #     },
+            #     "last_trade": {
+            #         "ticker": snapshot.last_trade.ticker,
+            #         "trf_timestamp": snapshot.last_trade.trf_timestamp,
+            #         "sequence_number": snapshot.last_trade.sequence_number,
+            #         "sip_timestamp": snapshot.last_trade.sip_timestamp,
+            #         "participant_timestamp": snapshot.last_trade.participant_timestamp,
+            #         "conditions": snapshot.last_trade.conditions,
+            #         "correction": snapshot.last_trade.correction,
+            #         "id": snapshot.last_trade.id,
+            #         "price": snapshot.last_trade.price,
+            #         "trf_id": snapshot.last_trade.trf_id,
+            #         "size": snapshot.last_trade.size,
+            #         "exchange": snapshot.last_trade.exchange,
+            #         "tape": snapshot.last_trade.tape,
+            #     },
+            #     "min": {
+            #         "accumulated_volume": snapshot.min.accumulated_volume,
+            #         "open": snapshot.min.open,
+            #         "high": snapshot.min.high,
+            #         "low": snapshot.min.low,
+            #         "close": snapshot.min.close,
+            #         "volume": snapshot.min.volume,
+            #         "vwap": snapshot.min.vwap,
+            #         "otc": snapshot.min.otc,
+            #         "timestamp": snapshot.min.timestamp,
+            #         "transactions": snapshot.min.transactions,
+            #     },
+            #     "prev_day": {
+            #         "open": snapshot.prev_day.open,
+            #         "high": snapshot.prev_day.high,
+            #         "low": snapshot.prev_day.low,
+            #         "close": snapshot.prev_day.close,
+            #         "volume": snapshot.prev_day.volume,
+            #         "vwap": snapshot.prev_day.vwap,
+            #         "timestamp": snapshot.prev_day.timestamp,
+            #         "transactions": snapshot.prev_day.transactions,
+            #         "otc": snapshot.prev_day.otc,
+            #     },
+            #     "ticker": snapshot.ticker,
+            #     "todaysChange": snapshot.todays_change,
+            #     "todaysChangePerc": snapshot.todays_change_percent,
+            #     "updated": snapshot.updated,
+            # }
+            data = ticker_snapshot_to_dict(snapshot)
             await self.cache_data(
-                data=snapshot,
+                data=data,
                 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}")
+        self.logger.info(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}")
+            self.logger.info(f"Returning cached value for {ticker}: {avg_volume}")
             return avg_volume
 
+        # Experimental version - unreliable
         results: Iterator[FinancialRatio] = self.rest_client.list_financials_ratios(ticker=ticker)
         ratios: List[FinancialRatio] = []
         for financial_ratio in results:
             ratios.append(financial_ratio)
+
+        # If there is only one financial ratio, use it's average volume.
+        # Otherwise, calculate average volume from 30 trading sessions.'
         if len(ratios) == 1:
             avg_volume = ratios[0].average_volume
         else:
-            raise Exception(f"Unexpected number of financial ratios for {ticker}: {len(ratios)}")
+            # 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.info(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}")
+        self.logger.info(f"average volume {ticker}: {avg_volume}")
         await self.cache_data(
             data=avg_volume,
             cache_key=cache_key,
@@ -85,11 +191,11 @@ class MarketDataCache:
         return avg_volume
 
     async def get_free_float(self, ticker: str):
-        self.logger.debug(f"Getting free float for {ticker}")
+        self.logger.info(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}")
+            self.logger.info(f"Returning cached value for {ticker}: {free_float}")
             return free_float
 
         # NOTE: This endpoint is experimental and the interface may change.
@@ -123,7 +229,7 @@ class MarketDataCache:
             self.logger.error(f"Error fetching free float for {ticker}: {e}")
             raise
 
-        self.logger.debug(f"free float {ticker}: {free_float}")
+        self.logger.info(f"free float {ticker}: {free_float}")
         await self.cache_data(
             data=free_float,
             cache_key=cache_key,

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/helpers/utils.py

@@ -1,6 +1,7 @@
 import logging
 import os
 
+from massive.rest.models import TickerSnapshot
 
 logging.basicConfig(
     level=logging.INFO,
@@ -35,3 +36,101 @@ def get_massive_api_key():
         raise ValueError("MASSIVE_API_KEY environment variable not set")
     logger.info("Done.")
     return api_key
+
+
+def ticker_snapshot_to_dict(snapshot: TickerSnapshot) -> dict:
+    """
+    Convert a TickerSnapshot instance into a JSON-serializable dictionary.
+
+    Args:
+        snapshot: TickerSnapshot instance to convert
+
+    Returns:
+        Dictionary with keys matching the from_dict format (camelCase)
+    """
+    data = {
+        "ticker": snapshot.ticker,
+        "todays_change": snapshot.todays_change,
+        "todays_change_perc": snapshot.todays_change_percent,
+        "updated": snapshot.updated,
+    }
+
+    if snapshot.day is not None:
+        data["day"] = {
+            "open": snapshot.day.open,
+            "high": snapshot.day.high,
+            "low": snapshot.day.low,
+            "close": snapshot.day.close,
+            "volume": snapshot.day.volume,
+            "vwap": snapshot.day.vwap,
+            "timestamp": snapshot.day.timestamp,
+            "transactions": snapshot.day.transactions,
+            "otc": snapshot.day.otc,
+        }
+
+    if snapshot.last_quote is not None:
+        data["last_quote"] = {
+            "ticker": snapshot.last_quote.ticker,
+            "trf_timestamp": snapshot.last_quote.trf_timestamp,
+            "sequence_number": snapshot.last_quote.sequence_number,
+            "sip_timestamp": snapshot.last_quote.sip_timestamp,
+            "participant_timestamp": snapshot.last_quote.participant_timestamp,
+            "ask_price": snapshot.last_quote.ask_price,
+            "ask_size": snapshot.last_quote.ask_size,
+            "ask_exchange": snapshot.last_quote.ask_exchange,
+            "conditions": snapshot.last_quote.conditions,
+            "indicators": snapshot.last_quote.indicators,
+            "bid_price": snapshot.last_quote.bid_price,
+            "bid_size": snapshot.last_quote.bid_size,
+            "bid_exchange": snapshot.last_quote.bid_exchange,
+            "tape": snapshot.last_quote.tape,
+        }
+
+    if snapshot.last_trade is not None:
+        data["last_trade"] = {
+            "ticker": snapshot.last_trade.ticker,
+            "trf_timestamp": snapshot.last_trade.trf_timestamp,
+            "sequence_number": snapshot.last_trade.sequence_number,
+            "sip_timestamp": snapshot.last_trade.sip_timestamp,
+            "participant_timestamp": snapshot.last_trade.participant_timestamp,
+            "conditions": snapshot.last_trade.conditions,
+            "correction": snapshot.last_trade.correction,
+            "id": snapshot.last_trade.id,
+            "price": snapshot.last_trade.price,
+            "trf_id": snapshot.last_trade.trf_id,
+            "size": snapshot.last_trade.size,
+            "exchange": snapshot.last_trade.exchange,
+            "tape": snapshot.last_trade.tape,
+        }
+
+    if snapshot.min is not None:
+        data["min"] = {
+            "accumulated_volume": snapshot.min.accumulated_volume,
+            "open": snapshot.min.open,
+            "high": snapshot.min.high,
+            "low": snapshot.min.low,
+            "close": snapshot.min.close,
+            "volume": snapshot.min.volume,
+            "vwap": snapshot.min.vwap,
+            "otc": snapshot.min.otc,
+            "timestamp": snapshot.min.timestamp,
+            "transactions": snapshot.min.transactions,
+        }
+
+    if snapshot.prev_day is not None:
+        data["prev_day"] = {
+            "open": snapshot.prev_day.open,
+            "high": snapshot.prev_day.high,
+            "low": snapshot.prev_day.low,
+            "close": snapshot.prev_day.close,
+            "volume": snapshot.prev_day.volume,
+            "vwap": snapshot.prev_day.vwap,
+            "timestamp": snapshot.prev_day.timestamp,
+            "transactions": snapshot.prev_day.transactions,
+            "otc": snapshot.prev_day.otc,
+        }
+
+    if snapshot.fair_market_value is not None:
+        data["fmv"] = snapshot.fair_market_value
+
+    return data

{kuhl_haus_mdp-0.1.5.dist-info → kuhl_haus_mdp-0.1.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kuhl-haus-mdp
-Version: 0.1.5
+Version: 0.1.7
 Summary: Market data processing pipeline for stock market scanner
 Author-Email: Tom Pounders <git@oldschool.engineer>
 License: The MIT License (MIT)
@@ -68,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.5.dist-info → kuhl_haus_mdp-0.1.7.dist-info}/RECORD

@@ -1,16 +1,16 @@
 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/analyzer.py,sha256=rIU1lcHwP2IBai0QLt0y-4ySg_ibWsutNU8JUgSxa1U,471
 kuhl_haus/mdp/analyzers/massive_data_analyzer.py,sha256=WSb7T8X4u2ue7Du7sf_fqxjgjEbR6ThllSNT1CncIM0,3866
-kuhl_haus/mdp/analyzers/top_stocks.py,sha256=aE8Z4PHkfudM02xLAgqgCMeIGqsioq18SQLs81Z8qvM,9452
+kuhl_haus/mdp/analyzers/top_stocks.py,sha256=GvNSa7yWZZ7WUgpaV2t1nVOxWA2R2qpISy16x2RGaQ8,9463
 kuhl_haus/mdp/components/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-kuhl_haus/mdp/components/market_data_cache.py,sha256=EmRDlh_GTKyYDvAbbAPQrE8n91JKNFKH8myAM4UTPLM,5835
-kuhl_haus/mdp/components/market_data_scanner.py,sha256=vA0HPqVIvuZb93wzJhtER6fcH6bf85AgXCbu7yVFOFE,9152
+kuhl_haus/mdp/components/market_data_cache.py,sha256=qc19TN05efgdpqobcF9rlNL8D8ZFDVYfKN-flTaZLks,11086
+kuhl_haus/mdp/components/market_data_scanner.py,sha256=45MgprFlq03MvmIRYXENsrc7UlTcBE_hIsPyOvNs1zc,9745
 kuhl_haus/mdp/components/widget_data_service.py,sha256=ikygD9NRpidcXBEqft5Q11rHy_eUOwKGyOLEezo-Dd4,7439
 kuhl_haus/mdp/helpers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 kuhl_haus/mdp/helpers/process_manager.py,sha256=Is3Jx8nlBWvywQ1acdsdaSJTAG0olKskpPvrRB4VMDE,9024
 kuhl_haus/mdp/helpers/queue_name_resolver.py,sha256=l_zfRLxrjR9uwRCV2VDO4vPWLK_lj5KVG2p4Lh8xWiw,770
-kuhl_haus/mdp/helpers/utils.py,sha256=9JEpl2yr2LghOLrJUDxi-4dtDK3DZ1wBTZ1uxBJsFbQ,1309
+kuhl_haus/mdp/helpers/utils.py,sha256=i6ILSa884jp7ijBsP_wBT3yHsUa91xSQEFkDhzqe1aQ,5164
 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=H1WlbGtuSF45n7qLTLleuNlG-OlIXz4llJ7q3XRSS-s,8605
@@ -24,8 +24,8 @@ kuhl_haus/mdp/models/market_data_pubsub_keys.py,sha256=PEIPXK9jBehJB7G4pqoSuQZcf
 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/models/top_stocks_cache_item.py,sha256=4vwwPTMkRRf1ct6iFInJnLSbBadM-tRk-zhqdD_ITE0,7676
-kuhl_haus_mdp-0.1.5.dist-info/METADATA,sha256=h3NksGfUJk-bpw4YWVtjcCrd8HxrxmDD4PxPn-MTg3k,8761
-kuhl_haus_mdp-0.1.5.dist-info/WHEEL,sha256=tsUv_t7BDeJeRHaSrczbGeuK-TtDpGsWi_JfpzD255I,90
-kuhl_haus_mdp-0.1.5.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
-kuhl_haus_mdp-0.1.5.dist-info/licenses/LICENSE.txt,sha256=DRkJftAJcMqoTkQ_Y6-HtKj3nm4pZah_p8XBZiYnw-c,1079
-kuhl_haus_mdp-0.1.5.dist-info/RECORD,,
+kuhl_haus_mdp-0.1.7.dist-info/METADATA,sha256=YbJ2dQ8MBJrdtgCtDtfuWYEtX7FZDCF-gilSTjxDTmw,8898
+kuhl_haus_mdp-0.1.7.dist-info/WHEEL,sha256=tsUv_t7BDeJeRHaSrczbGeuK-TtDpGsWi_JfpzD255I,90
+kuhl_haus_mdp-0.1.7.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
+kuhl_haus_mdp-0.1.7.dist-info/licenses/LICENSE.txt,sha256=DRkJftAJcMqoTkQ_Y6-HtKj3nm4pZah_p8XBZiYnw-c,1079
+kuhl_haus_mdp-0.1.7.dist-info/RECORD,,