kuhl-haus-mdp 0.1.3__py3-none-any.whl → 0.1.6__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

@@ -16,6 +16,7 @@ from massive.websocket.models import (
 )
 
 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_pubsub_keys import MarketDataPubSubKeys
@@ -24,22 +25,16 @@ from kuhl_haus.mdp.models.top_stocks_cache_item import TopStocksCacheItem
 
 class TopStocksAnalyzer(Analyzer):
 
-    def __init__(self, rest_client: RESTClient, **kwargs):
-        if "cache_key" not in kwargs:
-            kwargs["cache_key"] = MarketDataCacheKeys.TOP_STOCKS_SCANNER.value
-        super().__init__(**kwargs)
-        self.rest_client = rest_client
+    def __init__(self, cache: MarketDataCache, **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"))
@@ -51,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")
 
@@ -135,7 +135,7 @@ class TopStocksAnalyzer(Analyzer):
             prev_day_vwap = 0
             while retry_count < max_tries:
                 try:
-                    snapshot = await self.get_ticker_snapshot(event.symbol)
+                    snapshot = await self.cache.get_ticker_snapshot(event.symbol)
                     prev_day_close = snapshot.prev_day.close
                     prev_day_volume = snapshot.prev_day.volume
                     prev_day_vwap = snapshot.prev_day.vwap
@@ -153,7 +153,7 @@ class TopStocksAnalyzer(Analyzer):
             avg_volume = 0
             while retry_count < max_tries:
                 try:
-                    avg_volume = await self.get_avg_volume(event.symbol)
+                    avg_volume = await self.cache.get_avg_volume(event.symbol)
                     break
                 except (BadResponse, ZeroDivisionError) as e:
                     self.logger.error(f"Error getting average volume for {event.symbol}: {repr(e)}", exc_info=e, stack_info=True)
@@ -217,44 +217,3 @@ class TopStocksAnalyzer(Analyzer):
             "start_timestamp": event.start_timestamp,
             "end_timestamp": event.end_timestamp,
         }
-
-    async def get_ticker_snapshot(self, ticker: str) -> TickerSnapshot:
-        self.logger.debug(f"Getting snapshot for {ticker}")
-        result: TickerSnapshot = self.rest_client.get_snapshot_ticker(
-            market_type="stocks",
-            ticker=ticker
-        )
-        self.logger.debug(f"Snapshot result: {result}")
-        return result
-
-    async def get_avg_volume(self, ticker: str):
-        self.logger.debug(f"Getting average volume for {ticker}")
-        # 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.debug(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}")
-        return avg_volume

kuhl_haus/mdp/components/market_data_cache.py

@@ -1,14 +1,26 @@
 import json
 import logging
-from typing import Any, Optional
+from typing import Any, Optional, Iterator, List
 
+import aiohttp
 import redis.asyncio as aioredis
+from massive.rest import RESTClient
+from massive.rest.models import (
+    TickerSnapshot,
+    FinancialRatio,
+)
+
+from kuhl_haus.mdp.models.market_data_cache_keys import MarketDataCacheKeys
+from kuhl_haus.mdp.models.market_data_cache_ttl import MarketDataCacheTTL
 
 
 class MarketDataCache:
-    def __init__(self, redis_client: aioredis.Redis):
+    def __init__(self, rest_client: RESTClient, redis_client: aioredis.Redis, massive_api_key: str):
         self.logger = logging.getLogger(__name__)
+        self.rest_client = rest_client
+        self.massive_api_key = massive_api_key
         self.redis_client = redis_client
+        self.http_session = None
 
     async def get_cache(self, cache_key: str) -> Optional[dict]:
         """Fetch current value from Redis cache (for snapshot requests)."""
@@ -27,3 +39,105 @@ class MarketDataCache:
     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}")
+
+    async def get_ticker_snapshot(self, ticker: str) -> TickerSnapshot:
+        self.logger.debug(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)
+        else:
+            snapshot: TickerSnapshot = self.rest_client.get_snapshot_ticker(
+                market_type="stocks",
+                ticker=ticker
+            )
+            self.logger.debug(f"Snapshot result: {snapshot}")
+            await self.cache_data(
+                data=snapshot,
+                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}")
+        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}")
+            return avg_volume
+
+        results: Iterator[FinancialRatio] = self.rest_client.list_financials_ratios(ticker=ticker)
+        ratios: List[FinancialRatio] = []
+        for financial_ratio in results:
+            ratios.append(financial_ratio)
+        if len(ratios) == 1:
+            avg_volume = ratios[0].average_volume
+        else:
+            raise Exception(f"Unexpected number of financial ratios for {ticker}: {len(ratios)}")
+
+        self.logger.debug(f"average volume {ticker}: {avg_volume}")
+        await self.cache_data(
+            data=avg_volume,
+            cache_key=cache_key,
+            cache_ttl=MarketDataCacheTTL.TWELVE_HOURS.value
+        )
+        return avg_volume
+
+    async def get_free_float(self, ticker: str):
+        self.logger.debug(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}")
+            return free_float
+
+        # NOTE: This endpoint is experimental and the interface may change.
+        # https://massive.com/docs/rest/stocks/fundamentals/float
+        url = f"https://api.massive.com/stocks/vX/float"
+        params = {
+            "ticker": ticker,
+            "apiKey": self.massive_api_key
+        }
+
+        session = await self.get_http_session()
+        try:
+            async with session.get(url, params=params, timeout=aiohttp.ClientTimeout(total=10)) as response:
+                response.raise_for_status()
+                data = await response.json()
+
+                # Extract free_float from response
+                if data.get("status") == "OK" and data.get("results") is not None:
+                    results = data["results"]
+                    if len(results) > 0:
+                        free_float = results[0].get("free_float")
+                    else:
+                        raise Exception(f"No free float data returned for {ticker}")
+                else:
+                    raise Exception(f"Invalid response from Massive API for {ticker}: {data}")
+
+        except aiohttp.ClientError as e:
+            self.logger.error(f"HTTP error fetching free float for {ticker}: {e}")
+            raise
+        except Exception as e:
+            self.logger.error(f"Error fetching free float for {ticker}: {e}")
+            raise
+
+        self.logger.debug(f"free float {ticker}: {free_float}")
+        await self.cache_data(
+            data=free_float,
+            cache_key=cache_key,
+            cache_ttl=MarketDataCacheTTL.TWELVE_HOURS.value
+        )
+        return free_float
+
+    async def get_http_session(self) -> aiohttp.ClientSession:
+        """Get or create aiohttp session for async HTTP requests."""
+        if self.http_session is None or self.http_session.closed:
+            self.http_session = aiohttp.ClientSession()
+        return self.http_session
+
+    async def close(self):
+        """Close aiohttp session."""
+        if self.http_session and not self.http_session.closed:
+            await self.http_session.close()

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/integ/massive_data_processor.py

@@ -1,17 +1,14 @@
 import asyncio
 import json
 import logging
-from typing import Dict
 
 import aio_pika
-import redis
 import redis.asyncio as aioredis
 from aio_pika.abc import AbstractIncomingMessage
-from aio_pika.exceptions import AMQPConnectionError
 
 from kuhl_haus.mdp.analyzers.massive_data_analyzer import MassiveDataAnalyzer
-from kuhl_haus.mdp.models.market_data_analyzer_result import MarketDataAnalyzerResult
 from kuhl_haus.mdp.integ.web_socket_message_serde import WebSocketMessageSerde
+from kuhl_haus.mdp.models.market_data_analyzer_result import MarketDataAnalyzerResult
 
 
 class MassiveDataProcessor:

kuhl_haus/mdp/models/market_data_cache_keys.py

@@ -16,6 +16,9 @@ class MarketDataCacheKeys(Enum):
 
     # MARKET DATA CACHE
     DAILY_AGGREGATES = 'aggregate:daily'
+    TICKER_SNAPSHOTS = 'snapshots'
+    TICKER_AVG_VOLUME = 'avg_volume'
+    TICKER_FREE_FLOAT = 'free_float'
 
     # MARKET DATA PROCESSOR CACHE
     TOP_TRADES_SCANNER = f'cache:{MarketDataScannerNames.TOP_TRADES.value}'

kuhl_haus/mdp/models/market_data_cache_ttl.py

@@ -8,6 +8,7 @@ class MarketDataCacheTTL(Enum):
     FOUR_HOURS = 14400
     SIX_HOURS = 21600
     EIGHT_HOURS = 28800
+    TWELVE_HOURS = 43200
 
     # Days
     ONE_DAY = 86400

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kuhl-haus-mdp
-Version: 0.1.3
+Version: 0.1.6
 Summary: Market data processing pipeline for stock market scanner
 Author-Email: Tom Pounders <git@oldschool.engineer>
 License: The MIT License (MIT)
@@ -33,20 +33,22 @@ Project-URL: Source, https://github.com/kuhl-haus/kuhl-haus-mdp.git
 Project-URL: Changelog, https://github.com/kuhl-haus/kuhl-haus-mdp/commits
 Project-URL: Tracker, https://github.com/kuhl-haus/kuhl-haus-mdp/issues
 Requires-Python: <3.13,>=3.9.21
-Requires-Dist: websockets
+Requires-Dist: aiohttp
 Requires-Dist: aio-pika
-Requires-Dist: redis[asyncio]
-Requires-Dist: tenacity
 Requires-Dist: fastapi
-Requires-Dist: uvicorn[standard]
+Requires-Dist: massive
 Requires-Dist: pydantic-settings
 Requires-Dist: python-dotenv
-Requires-Dist: massive
+Requires-Dist: redis[asyncio]
+Requires-Dist: tenacity
+Requires-Dist: uvicorn[standard]
+Requires-Dist: websockets
 Provides-Extra: testing
 Requires-Dist: setuptools; extra == "testing"
 Requires-Dist: pdm-backend; extra == "testing"
 Requires-Dist: pytest; extra == "testing"
 Requires-Dist: pytest-cov; extra == "testing"
+Requires-Dist: pytest-asyncio; extra == "testing"
 Description-Content-Type: text/markdown
 
 <!-- These are examples of badges you might want to add to your README:
@@ -66,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.3.dist-info → kuhl_haus_mdp-0.1.6.dist-info}/RECORD

@@ -1,31 +1,31 @@
 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=nvNA-NkxMjVO0MqFuAvG-v3UdSP7iWDRGI7GxpPBzWw,10876
+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=r5sJHuSuLiw9BVckW--aWZHHIMqOTCf-pFURA7kef3Q,1070
-kuhl_haus/mdp/components/market_data_scanner.py,sha256=vA0HPqVIvuZb93wzJhtER6fcH6bf85AgXCbu7yVFOFE,9152
+kuhl_haus/mdp/components/market_data_cache.py,sha256=EmRDlh_GTKyYDvAbbAPQrE8n91JKNFKH8myAM4UTPLM,5835
+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/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=qktzLfuqrOgE4C9iZs4mXFvHt2BckgevRP8pEakzggA,8694
+kuhl_haus/mdp/integ/massive_data_processor.py,sha256=H1WlbGtuSF45n7qLTLleuNlG-OlIXz4llJ7q3XRSS-s,8605
 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_cache_keys.py,sha256=04nFRdNZtvEeKFnpjZ6CNSu-4MiUgifPXPHGAZhZRsE,1051
+kuhl_haus/mdp/models/market_data_cache_ttl.py,sha256=a43ys3S61Y0ADdb03ThgrRd9x7B1EsI6FplCjecdNLY,373
 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/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,,
+kuhl_haus_mdp-0.1.6.dist-info/METADATA,sha256=ecQ-j_82U-8JfxrpBMpJovbruVY2VSitRS-BgzG_cb8,8898
+kuhl_haus_mdp-0.1.6.dist-info/WHEEL,sha256=tsUv_t7BDeJeRHaSrczbGeuK-TtDpGsWi_JfpzD255I,90
+kuhl_haus_mdp-0.1.6.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
+kuhl_haus_mdp-0.1.6.dist-info/licenses/LICENSE.txt,sha256=DRkJftAJcMqoTkQ_Y6-HtKj3nm4pZah_p8XBZiYnw-c,1079
+kuhl_haus_mdp-0.1.6.dist-info/RECORD,,