haystack-ml-stack 0.1.0__tar.gz

haystack_ml_stack-0.1.0/PKG-INFO

@@ -0,0 +1,96 @@
+Metadata-Version: 2.4
+Name: haystack-ml-stack
+Version: 0.1.0
+Summary: Functions related to Haystack ML
+Author-email: Oscar Vega <oscar@haystack.tv>
+License: MIT
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: pydantic==2.5.0
+Requires-Dist: cachetools==5.5.2
+Requires-Dist: cloudpickle==2.2.1
+Requires-Dist: aioboto3==12.0.0
+Requires-Dist: fastapi==0.104.1
+Requires-Dist: pydantic-settings==2.2
+
+# Haystack ML Stack
+
+Currently this project contains a FastAPI-based service designed for low-latency scoring of streams data coming from http requests
+
+## 🚀 Features
+
+* **FastAPI Service:** Lightweight and fast web service for ML inference.
+    * **Asynchronous I/O:** Utilizes `aiobotocore` for non-blocking S3 and DynamoDB operations.
+    * **Model Loading:** Downloads and loads the ML model (using `cloudpickle`) from a configurable S3 path on startup.
+    * **Feature Caching:** Implements a thread-safe Time-To-Live (TTL) / Least-Recently-Used (LRU) cache (`cachetools.TLRUCache`) for DynamoDB features, reducing latency and database load.
+    * **DynamoDB Integration:** Fetches stream-specific features from DynamoDB to enrich the data before scoring.
+    * **Health Check:** Provides a `/health` endpoint to monitor service status and model loading.
+
+## 📦 Installation
+
+This project requires Python 3.11 or later.
+
+1.  **Install package:**
+    The dependencies associated are listed in `pyproject.toml`.
+
+    ```bash
+    pip install haystack-ml-stack
+    ```
+
+## ⚙️ Configuration
+
+The service is configured using environment variables, managed by `pydantic-settings`. You can use a `.env` file for local development.
+
+| Variable Name | Alias | Default | Description |
+| :--- | :--- | :--- | :--- |
+| `S3_MODEL_PATH` | `S3_MODEL_PATH` | `None` | **Required.** The `s3://bucket/key` URL for the cloudpickled ML model file. |
+| `FEATURES_TABLE`| `FEATURES_TABLE`| `"features"` | Name of the DynamoDB table storing stream features. |
+| `LOGS_FRACTION` | `LOGS_FRACTION` | `0.01` | Fraction of requests to log detailed stream data for sampling/debugging (0.0 to 1.0). |
+| `CACHE_MAXSIZE` | *(none)* | `50000` | Maximum size of the in-memory feature cache. |
+
+**Example env vars**
+
+```env
+S3_MODEL_PATH="s3://my-ml-models/stream-scorer/latest.pkl"
+FEATURES_TABLE="features"
+LOGS_FRACTION=0.05
+```
+
+## 🌐 Endpoints
+| Method | Path | Description |
+| :--- | :--- | :--- |
+| **GET** | `/` | Root endpoint, returns a simple running message. |
+| **GET** | `/health` | Checks if the service is running and if the ML model has been loaded. |
+| **POST** | `/score` | **Main scoring endpoint.** Accepts stream data and returns model predictions. |
+
+## 💻 Technical Details
+
+### Model Structure
+The ML model file downloaded from S3 is expected to be a cloudpickle-serialized Python dictionary with the following structure:
+
+``` python
+
+model = {
+    "preprocess": <function>,  # Function to transform request data into model input.
+    "predict": <function>,     # Function to perform the actual model inference.
+    "params": <dict/any>,      # Optional parameters passed to preprocess/predict.
+    "stream_features": <list[str]>, # Optional list of feature names to fetch from DynamoDB.
+}
+```
+
+### Feature Caching (cache.py)
+The `ThreadSafeTLRUCache` ensures that feature lookups and updates are thread-safe.
+The `_ttu` (time-to-use) policy allows features to specify their own TTL via a `cache_ttl_in_seconds` key in the stored value.
+
+### DynamoDB Feature Fetching (dynamo.py)
+The set_stream_features function handles:
+
+- Checking the in-memory cache for required `stream_features`.
+
+- Batch-fetching any missing features from DynamoDB.
+
+- Parsing the low-level DynamoDB items into Python types.
+
+- Populating the cache with the fetched data, respecting the feature's TTL.
+
+- Injecting the fetched feature values back into the streams list in the request payload.

haystack_ml_stack-0.1.0/README.md

@@ -0,0 +1,81 @@
+# Haystack ML Stack
+
+Currently this project contains a FastAPI-based service designed for low-latency scoring of streams data coming from http requests
+
+## 🚀 Features
+
+* **FastAPI Service:** Lightweight and fast web service for ML inference.
+    * **Asynchronous I/O:** Utilizes `aiobotocore` for non-blocking S3 and DynamoDB operations.
+    * **Model Loading:** Downloads and loads the ML model (using `cloudpickle`) from a configurable S3 path on startup.
+    * **Feature Caching:** Implements a thread-safe Time-To-Live (TTL) / Least-Recently-Used (LRU) cache (`cachetools.TLRUCache`) for DynamoDB features, reducing latency and database load.
+    * **DynamoDB Integration:** Fetches stream-specific features from DynamoDB to enrich the data before scoring.
+    * **Health Check:** Provides a `/health` endpoint to monitor service status and model loading.
+
+## 📦 Installation
+
+This project requires Python 3.11 or later.
+
+1.  **Install package:**
+    The dependencies associated are listed in `pyproject.toml`.
+
+    ```bash
+    pip install haystack-ml-stack
+    ```
+
+## ⚙️ Configuration
+
+The service is configured using environment variables, managed by `pydantic-settings`. You can use a `.env` file for local development.
+
+| Variable Name | Alias | Default | Description |
+| :--- | :--- | :--- | :--- |
+| `S3_MODEL_PATH` | `S3_MODEL_PATH` | `None` | **Required.** The `s3://bucket/key` URL for the cloudpickled ML model file. |
+| `FEATURES_TABLE`| `FEATURES_TABLE`| `"features"` | Name of the DynamoDB table storing stream features. |
+| `LOGS_FRACTION` | `LOGS_FRACTION` | `0.01` | Fraction of requests to log detailed stream data for sampling/debugging (0.0 to 1.0). |
+| `CACHE_MAXSIZE` | *(none)* | `50000` | Maximum size of the in-memory feature cache. |
+
+**Example env vars**
+
+```env
+S3_MODEL_PATH="s3://my-ml-models/stream-scorer/latest.pkl"
+FEATURES_TABLE="features"
+LOGS_FRACTION=0.05
+```
+
+## 🌐 Endpoints
+| Method | Path | Description |
+| :--- | :--- | :--- |
+| **GET** | `/` | Root endpoint, returns a simple running message. |
+| **GET** | `/health` | Checks if the service is running and if the ML model has been loaded. |
+| **POST** | `/score` | **Main scoring endpoint.** Accepts stream data and returns model predictions. |
+
+## 💻 Technical Details
+
+### Model Structure
+The ML model file downloaded from S3 is expected to be a cloudpickle-serialized Python dictionary with the following structure:
+
+``` python
+
+model = {
+    "preprocess": <function>,  # Function to transform request data into model input.
+    "predict": <function>,     # Function to perform the actual model inference.
+    "params": <dict/any>,      # Optional parameters passed to preprocess/predict.
+    "stream_features": <list[str]>, # Optional list of feature names to fetch from DynamoDB.
+}
+```
+
+### Feature Caching (cache.py)
+The `ThreadSafeTLRUCache` ensures that feature lookups and updates are thread-safe.
+The `_ttu` (time-to-use) policy allows features to specify their own TTL via a `cache_ttl_in_seconds` key in the stored value.
+
+### DynamoDB Feature Fetching (dynamo.py)
+The set_stream_features function handles:
+
+- Checking the in-memory cache for required `stream_features`.
+
+- Batch-fetching any missing features from DynamoDB.
+
+- Parsing the low-level DynamoDB items into Python types.
+
+- Populating the cache with the fetched data, respecting the feature's TTL.
+
+- Injecting the fetched feature values back into the streams list in the request payload.

haystack_ml_stack-0.1.0/pyproject.toml

@@ -0,0 +1,21 @@
+# pyproject.toml
+[build-system]
+requires = ["setuptools>=69", "wheel", "build"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "haystack-ml-stack"
+version = "0.1.0"
+description = "Functions related to Haystack ML"
+readme = "README.md"
+authors = [{ name = "Oscar Vega", email = "oscar@haystack.tv" }]
+requires-python = ">=3.11"
+dependencies = [
+    "pydantic==2.5.0",
+    "cachetools==5.5.2",
+    "cloudpickle==2.2.1",
+    "aioboto3==12.0.0",
+    "fastapi==0.104.1",
+    "pydantic-settings==2.2"
+]
+license = { text = "MIT" }

haystack_ml_stack-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

haystack_ml_stack-0.1.0/src/haystack_ml_stack/__init__.py

@@ -0,0 +1,4 @@
+from .app import create_app
+
+__all__ = ["create_app"]
+__version__ = "0.1.0"

haystack_ml_stack-0.1.0/src/haystack_ml_stack/app.py

@@ -0,0 +1,158 @@
+import logging
+import os
+import random
+import sys
+from http import HTTPStatus
+from typing import Any, Dict, List, Optional
+
+import aiobotocore.session
+from fastapi import FastAPI, HTTPException, Request, Response
+from fastapi.encoders import jsonable_encoder
+
+from .cache import make_features_cache
+from .dynamo import set_stream_features
+from .model_store import download_and_load_model
+from .settings import Settings
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="[%(levelname)s] [%(process)d] %(name)s : %(message)s",
+    handlers=[logging.StreamHandler(sys.stdout)],
+    force=True,
+)
+
+logger = logging.getLogger(__name__)
+
+
+def create_app(
+    settings: Optional[Settings] = None,
+    *,
+    preloaded_model: Optional[Dict[str, Any]] = None,
+) -> FastAPI:
+    """
+    Build a FastAPI app with injectable settings and model.
+    If `preloaded_model` is None, the app will load from S3 on startup.
+    """
+    cfg = settings or Settings()
+
+    app = FastAPI(
+        title="ML Stream Scorer",
+        description="Scores video streams using a pre-trained ML model and DynamoDB features.",
+        version="1.0.0",
+    )
+
+    # Mutable state: cache + model
+    features_cache = make_features_cache(cfg.cache_maxsize)
+    state: Dict[str, Any] = {
+        "model": preloaded_model,
+        "session": aiobotocore.session.get_session(),
+        "model_name": (
+            os.path.basename(cfg.s3_model_path) if cfg.s3_model_path else None
+        ),
+    }
+
+    @app.on_event("startup")
+    async def _startup() -> None:
+        if state["model"] is not None:
+            logger.info("Using preloaded model.")
+            return
+
+        if not cfg.s3_model_path:
+            logger.critical("S3_MODEL_PATH not set; service will be unhealthy.")
+            return
+
+        try:
+            state["model"] = await download_and_load_model(
+                cfg.s3_model_path, aio_session=state["session"]
+            )
+            state["stream_features"] = state["model"].get("stream_features", [])
+            logger.info("Model loaded on startup.")
+        except Exception as e:
+            logger.critical("Failed to load model: %s", e)
+
+    @app.get("/health", status_code=HTTPStatus.OK)
+    async def health():
+        model_ok = state["model"] is not None
+        if not model_ok:
+            raise HTTPException(
+                status_code=HTTPStatus.SERVICE_UNAVAILABLE,
+                detail="ML Model not loaded",
+            )
+        return {
+            "status": "ok",
+            "model_loaded": True,
+            "cache_size": len(features_cache),
+            "model_name": state.get("model_name"),
+            "stream_features": state.get("stream_features", []),
+        }
+
+    @app.post("/score", status_code=HTTPStatus.OK)
+    async def score_stream(request: Request, response: Response):
+        if state["model"] is None:
+            raise HTTPException(
+                status_code=HTTPStatus.SERVICE_UNAVAILABLE,
+                detail="ML Model not loaded",
+            )
+
+        try:
+            data = await request.json()
+        except Exception:
+            raise HTTPException(
+                status_code=HTTPStatus.BAD_REQUEST, detail="Invalid JSON payload"
+            )
+
+        user = data.get("user", {})
+        streams: List[Dict[str, Any]] = data.get("streams", [])
+        playlist = data.get("playlist", {})
+
+        if not streams:
+            logger.warning("No streams provided for user %s", user.get("userid", ""))
+            return {}
+
+        # Feature fetch (optional based on model)
+        model = state["model"]
+        stream_features = model.get("stream_features", []) or []
+        if stream_features:
+            logger.info("Fetching stream features for user %s", user.get("userid", ""))
+            await set_stream_features(
+                aio_session=state["session"],
+                streams=streams,
+                stream_features=stream_features,
+                features_cache=features_cache,
+                features_table=cfg.features_table,
+                stream_pk_prefix=cfg.stream_pk_prefix,
+                cache_sep=cfg.cache_separator,
+            )
+
+        # Sampling logs
+        if random.random() < cfg.logs_fraction:
+            logger.info("User %s streams: %s", user.get("userid", ""), streams)
+
+        # Synchronous model execution (user code)
+        try:
+            model_input = model["preprocess"](
+                user, streams, playlist, model.get("params")
+            )
+            model_output = model["predict"](model_input, model.get("params"))
+        except Exception as e:
+            logger.error("Model prediction failed: %s", e)
+            raise HTTPException(
+                status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
+                detail="Model prediction failed",
+            )
+
+        if model_output:
+            return jsonable_encoder(model_output)
+
+        raise HTTPException(
+            status_code=HTTPStatus.NOT_FOUND, detail="No model output generated"
+        )
+
+    @app.get("/", status_code=HTTPStatus.OK)
+    async def root():
+        return {
+            "message": "ML Scoring Service is running.",
+            "model_name": state.get("model_name"),
+        }
+
+    return app

haystack_ml_stack-0.1.0/src/haystack_ml_stack/cache.py

@@ -0,0 +1,19 @@
+from typing import Any
+
+from cachetools import TLRUCache
+
+
+def _ttu(_, value: Any, now: float) -> float:
+    """Time-To-Use policy: allow per-item TTL via 'cache_ttl_in_seconds' or fallback."""
+    ONE_YEAR = 365 * 24 * 60 * 60
+    try:
+        ttl = int(value.get("cache_ttl_in_seconds", -1))
+        if ttl > 0:
+            return now + ttl
+    except Exception:
+        pass
+    return now + ONE_YEAR
+
+
+def make_features_cache(maxsize: int) -> TLRUCache:
+    return TLRUCache(maxsize=maxsize, ttu=_ttu)

haystack_ml_stack-0.1.0/src/haystack_ml_stack/dynamo.py

@@ -0,0 +1,103 @@
+from typing import Any, Dict, List
+import logging
+
+import aiobotocore.session
+
+logger = logging.getLogger(__name__)
+
+
+async def async_batch_get(
+    dynamo_client, table_name: str, keys: List[Dict[str, Any]]
+) -> List[Dict[str, Any]]:
+    """Asynchronous batch_get_item with unprocessed keys handling."""
+    all_items: List[Dict[str, Any]] = []
+    to_fetch = {table_name: {"Keys": keys}}
+
+    while to_fetch:
+        resp = await dynamo_client.batch_get_item(RequestItems=to_fetch)
+        all_items.extend(resp["Responses"].get(table_name, []))
+        unprocessed = resp.get("UnprocessedKeys", {})
+        to_fetch = unprocessed if unprocessed.get(table_name) else {}
+
+    return all_items
+
+
+def parse_dynamo_item(item: Dict[str, Any]) -> Dict[str, Any]:
+    """Parse a DynamoDB attribute map (low-level) to Python types."""
+    out: Dict[str, Any] = {}
+    for k, v in item.items():
+        if "N" in v:
+            out[k] = float(v["N"])
+        elif "S" in v:
+            out[k] = v["S"]
+        elif "SS" in v:
+            out[k] = v["SS"]
+        elif "NS" in v:
+            out[k] = [float(n) for n in v["NS"]]
+        elif "BOOL" in v:
+            out[k] = v["BOOL"]
+        elif "NULL" in v:
+            out[k] = None
+        elif "L" in v:
+            out[k] = [parse_dynamo_item({"value": i})["value"] for i in v["L"]]
+        elif "M" in v:
+            out[k] = parse_dynamo_item(v["M"])
+    return out
+
+
+async def set_stream_features(
+    *,
+    streams: List[Dict[str, Any]],
+    stream_features: List[str],
+    features_cache,
+    features_table: str,
+    stream_pk_prefix: str,
+    cache_sep: str,
+    aio_session: aiobotocore.session.Session | None = None,
+) -> None:
+    """Fetch missing features for streams from DynamoDB and fill them into streams."""
+    if not streams or not stream_features:
+        return
+
+    cache_miss: Dict[str, Dict[str, Any]] = {}
+    for f in stream_features:
+        for s in streams:
+            key = f"{s['streamUrl']}{cache_sep}{f}"
+            cached = features_cache.get(key)
+            if cached is not None:
+                s[f] = cached["value"]
+            else:
+                cache_miss[key] = s
+
+    if not cache_miss:
+        return
+
+    logger.info("Cache miss for %d items", len(cache_miss))
+
+    # Prepare keys
+    keys = []
+    for k in cache_miss.keys():
+        stream_url, sk = k.split(cache_sep, 1)
+        pk = f"{stream_pk_prefix}{stream_url}"
+        keys.append({"pk": {"S": pk}, "sk": {"S": sk}})
+
+    session = aio_session or aiobotocore.session.get_session()
+    async with session.create_client("dynamodb") as dynamodb:
+        try:
+            items = await async_batch_get(dynamodb, features_table, keys)
+        except Exception as e:
+            logger.error("DynamoDB batch_get failed: %s", e)
+            return
+
+    for item in items:
+        stream_url = item["pk"]["S"].removeprefix(stream_pk_prefix)
+        feature_name = item["sk"]["S"]
+        cache_key = f"{stream_url}{cache_sep}{feature_name}"
+        parsed = parse_dynamo_item(item)
+
+        features_cache[cache_key] = {
+            "value": parsed.get("value"),
+            "cache_ttl_in_seconds": int(parsed.get("cache_ttl_in_seconds", -1)),
+        }
+        if cache_key in cache_miss:
+            cache_miss[cache_key][feature_name] = parsed.get("value")

haystack_ml_stack-0.1.0/src/haystack_ml_stack/model_store.py

@@ -0,0 +1,36 @@
+import logging
+import os
+from typing import Any, Dict
+
+import aiobotocore.session
+import cloudpickle
+
+logger = logging.getLogger(__name__)
+
+
+async def download_and_load_model(
+    s3_url: str, aio_session: aiobotocore.session.Session | None = None
+) -> Dict[str, Any]:
+    """
+    Downloads cloudpickled model dict from S3 and loads it.
+    Expected keys: 'preprocess', 'predict', 'params', optional 'stream_features'.
+    """
+    if not s3_url or not s3_url.startswith("s3://"):
+        raise ValueError("S3_MODEL_PATH must be a valid s3:// URL")
+
+    bucket, key = s3_url.replace("s3://", "").split("/", 1)
+    pid = os.getpid()
+    local_path = f"/tmp/model_{pid}.pkl"
+
+    session = aio_session or aiobotocore.session.get_session()
+    async with session.create_client("s3") as s3:
+        logger.info("Downloading model from %s...", s3_url)
+        resp = await s3.get_object(Bucket=bucket, Key=key)
+        data = await resp["Body"].read()
+        with open(local_path, "wb") as f:
+            f.write(data)
+        logger.info("Model downloaded to %s", local_path)
+
+    with open(local_path, "rb") as f:
+        model: Dict[str, Any] = cloudpickle.load(f)
+    return model

haystack_ml_stack-0.1.0/src/haystack_ml_stack/settings.py

@@ -0,0 +1,22 @@
+from pydantic_settings import BaseSettings
+from pydantic import Field
+
+class Settings(BaseSettings):
+    # Logging
+    logs_fraction: float = Field(0.01, alias="LOGS_FRACTION")
+
+    # Model (S3)
+    s3_model_path: str | None = Field(default=None, alias="S3_MODEL_PATH")
+
+    # DynamoDB
+    features_table: str = Field("features", alias="FEATURES_TABLE")
+    stream_pk_prefix: str = "STREAM#"
+
+    # Cache
+    cache_maxsize: int = 50_000
+    cache_separator: str = "--"
+
+    class Config:
+        env_file = ".env"
+        env_file_encoding = "utf-8"
+        extra = "ignore"

haystack_ml_stack-0.1.0/src/haystack_ml_stack.egg-info/PKG-INFO

@@ -0,0 +1,96 @@
+Metadata-Version: 2.4
+Name: haystack-ml-stack
+Version: 0.1.0
+Summary: Functions related to Haystack ML
+Author-email: Oscar Vega <oscar@haystack.tv>
+License: MIT
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: pydantic==2.5.0
+Requires-Dist: cachetools==5.5.2
+Requires-Dist: cloudpickle==2.2.1
+Requires-Dist: aioboto3==12.0.0
+Requires-Dist: fastapi==0.104.1
+Requires-Dist: pydantic-settings==2.2
+
+# Haystack ML Stack
+
+Currently this project contains a FastAPI-based service designed for low-latency scoring of streams data coming from http requests
+
+## 🚀 Features
+
+* **FastAPI Service:** Lightweight and fast web service for ML inference.
+    * **Asynchronous I/O:** Utilizes `aiobotocore` for non-blocking S3 and DynamoDB operations.
+    * **Model Loading:** Downloads and loads the ML model (using `cloudpickle`) from a configurable S3 path on startup.
+    * **Feature Caching:** Implements a thread-safe Time-To-Live (TTL) / Least-Recently-Used (LRU) cache (`cachetools.TLRUCache`) for DynamoDB features, reducing latency and database load.
+    * **DynamoDB Integration:** Fetches stream-specific features from DynamoDB to enrich the data before scoring.
+    * **Health Check:** Provides a `/health` endpoint to monitor service status and model loading.
+
+## 📦 Installation
+
+This project requires Python 3.11 or later.
+
+1.  **Install package:**
+    The dependencies associated are listed in `pyproject.toml`.
+
+    ```bash
+    pip install haystack-ml-stack
+    ```
+
+## ⚙️ Configuration
+
+The service is configured using environment variables, managed by `pydantic-settings`. You can use a `.env` file for local development.
+
+| Variable Name | Alias | Default | Description |
+| :--- | :--- | :--- | :--- |
+| `S3_MODEL_PATH` | `S3_MODEL_PATH` | `None` | **Required.** The `s3://bucket/key` URL for the cloudpickled ML model file. |
+| `FEATURES_TABLE`| `FEATURES_TABLE`| `"features"` | Name of the DynamoDB table storing stream features. |
+| `LOGS_FRACTION` | `LOGS_FRACTION` | `0.01` | Fraction of requests to log detailed stream data for sampling/debugging (0.0 to 1.0). |
+| `CACHE_MAXSIZE` | *(none)* | `50000` | Maximum size of the in-memory feature cache. |
+
+**Example env vars**
+
+```env
+S3_MODEL_PATH="s3://my-ml-models/stream-scorer/latest.pkl"
+FEATURES_TABLE="features"
+LOGS_FRACTION=0.05
+```
+
+## 🌐 Endpoints
+| Method | Path | Description |
+| :--- | :--- | :--- |
+| **GET** | `/` | Root endpoint, returns a simple running message. |
+| **GET** | `/health` | Checks if the service is running and if the ML model has been loaded. |
+| **POST** | `/score` | **Main scoring endpoint.** Accepts stream data and returns model predictions. |
+
+## 💻 Technical Details
+
+### Model Structure
+The ML model file downloaded from S3 is expected to be a cloudpickle-serialized Python dictionary with the following structure:
+
+``` python
+
+model = {
+    "preprocess": <function>,  # Function to transform request data into model input.
+    "predict": <function>,     # Function to perform the actual model inference.
+    "params": <dict/any>,      # Optional parameters passed to preprocess/predict.
+    "stream_features": <list[str]>, # Optional list of feature names to fetch from DynamoDB.
+}
+```
+
+### Feature Caching (cache.py)
+The `ThreadSafeTLRUCache` ensures that feature lookups and updates are thread-safe.
+The `_ttu` (time-to-use) policy allows features to specify their own TTL via a `cache_ttl_in_seconds` key in the stored value.
+
+### DynamoDB Feature Fetching (dynamo.py)
+The set_stream_features function handles:
+
+- Checking the in-memory cache for required `stream_features`.
+
+- Batch-fetching any missing features from DynamoDB.
+
+- Parsing the low-level DynamoDB items into Python types.
+
+- Populating the cache with the fetched data, respecting the feature's TTL.
+
+- Injecting the fetched feature values back into the streams list in the request payload.

haystack_ml_stack-0.1.0/src/haystack_ml_stack.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+README.md
+pyproject.toml
+src/haystack_ml_stack/__init__.py
+src/haystack_ml_stack/app.py
+src/haystack_ml_stack/cache.py
+src/haystack_ml_stack/dynamo.py
+src/haystack_ml_stack/model_store.py
+src/haystack_ml_stack/settings.py
+src/haystack_ml_stack.egg-info/PKG-INFO
+src/haystack_ml_stack.egg-info/SOURCES.txt
+src/haystack_ml_stack.egg-info/dependency_links.txt
+src/haystack_ml_stack.egg-info/requires.txt
+src/haystack_ml_stack.egg-info/top_level.txt

haystack_ml_stack-0.1.0/src/haystack_ml_stack.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

haystack_ml_stack-0.1.0/src/haystack_ml_stack.egg-info/requires.txt

@@ -0,0 +1,6 @@
+pydantic==2.5.0
+cachetools==5.5.2
+cloudpickle==2.2.1
+aioboto3==12.0.0
+fastapi==0.104.1
+pydantic-settings==2.2

haystack_ml_stack-0.1.0/src/haystack_ml_stack.egg-info/top_level.txt

@@ -0,0 +1 @@
+haystack_ml_stack