bakery-ia/services/training/app/ml/poi_feature_integrator.py

"""
POI Feature Integrator

Integrates POI features into ML training pipeline.
Fetches POI context from External service and merges features into training data.
"""

from typing import Dict, Any, Optional, List
import structlog
import pandas as pd

from shared.clients.external_client import ExternalServiceClient

logger = structlog.get_logger()


class POIFeatureIntegrator:
    """
    POI feature integration for ML training.

    Fetches POI context from External service and adds features
    to training dataframes for location-based demand forecasting.
    """

    def __init__(self, external_client: ExternalServiceClient = None):
        """
        Initialize POI feature integrator.

        Args:
            external_client: External service client instance (optional)
        """
        if external_client is None:
            from app.core.config import settings
            self.external_client = ExternalServiceClient(settings, "training-service")
        else:
            self.external_client = external_client

    async def fetch_poi_features(
        self,
        tenant_id: str,
        latitude: float,
        longitude: float,
        force_refresh: bool = False
    ) -> Optional[Dict[str, Any]]:
        """
        Fetch POI features for tenant location.

        First checks if POI context exists, if not, triggers detection.

        Args:
            tenant_id: Tenant UUID
            latitude: Bakery latitude
            longitude: Bakery longitude
            force_refresh: Force re-detection

        Returns:
            Dictionary with POI features or None if detection fails
        """
        try:
            # Try to get existing POI context first
            if not force_refresh:
                existing_context = await self.external_client.get_poi_context(tenant_id)
                if existing_context:
                    poi_context = existing_context.get("poi_context", {})
                    ml_features = poi_context.get("ml_features", {})

                    # Check if stale
                    is_stale = existing_context.get("is_stale", False)
                    if not is_stale:
                        logger.info(
                            "Using existing POI context",
                            tenant_id=tenant_id
                        )
                        return ml_features
                    else:
                        logger.info(
                            "POI context is stale, refreshing",
                            tenant_id=tenant_id
                        )
                        force_refresh = True
                else:
                    logger.info(
                        "No existing POI context, will detect",
                        tenant_id=tenant_id
                    )

            # Detect or refresh POIs
            logger.info(
                "Detecting POIs for tenant",
                tenant_id=tenant_id,
                location=(latitude, longitude)
            )

            detection_result = await self.external_client.detect_poi_for_tenant(
                tenant_id=tenant_id,
                latitude=latitude,
                longitude=longitude,
                force_refresh=force_refresh
            )

            if detection_result:
                poi_context = detection_result.get("poi_context", {})
                ml_features = poi_context.get("ml_features", {})

                logger.info(
                    "POI detection completed",
                    tenant_id=tenant_id,
                    total_pois=poi_context.get("total_pois_detected", 0),
                    feature_count=len(ml_features)
                )

                return ml_features
            else:
                logger.error(
                    "POI detection failed",
                    tenant_id=tenant_id
                )
                return None

        except Exception as e:
            logger.error(
                "Unexpected error fetching POI features",
                tenant_id=tenant_id,
                error=str(e),
                exc_info=True
            )
            return None

    def add_poi_features_to_dataframe(
        self,
        df: pd.DataFrame,
        poi_features: Dict[str, Any]
    ) -> pd.DataFrame:
        """
        Add POI features to training dataframe.

        POI features are static (don't vary by date), so they're
        broadcast to all rows in the dataframe.

        Args:
            df: Training dataframe
            poi_features: Dictionary of POI ML features

        Returns:
            Dataframe with POI features added as columns
        """
        if not poi_features:
            logger.warning("No POI features to add")
            return df

        logger.info(
            "Adding POI features to dataframe",
            feature_count=len(poi_features),
            dataframe_rows=len(df)
        )

        # Add each POI feature as a column with constant value
        for feature_name, feature_value in poi_features.items():
            df[feature_name] = feature_value

        logger.info(
            "POI features added successfully",
            new_columns=list(poi_features.keys())
        )

        return df

    def get_poi_feature_names(self, poi_features: Dict[str, Any]) -> List[str]:
        """
        Get list of POI feature names for model registration.

        Args:
            poi_features: Dictionary of POI ML features

        Returns:
            List of feature names
        """
        return list(poi_features.keys()) if poi_features else []

    async def check_poi_service_health(self) -> bool:
        """
        Check if POI service is accessible through the external client.

        Returns:
            True if service is healthy, False otherwise
        """
        try:
            # We can test the external service health by attempting to get POI context for a dummy tenant
            # This will go through the proper authentication and routing
            dummy_context = await self.external_client.get_poi_context("test-tenant")
            # If we can successfully make a request (even if it returns None for missing tenant),
            # it means the service is accessible
            return True
        except Exception as e:
            logger.error(
                "POI service health check failed",
                error=str(e)
            )
            return False