Start fixing forecast service API 3

services/forecasting/app/services/forecasting_service.py

@@ -21,6 +21,8 @@ from app.services.prediction_service import PredictionService
 from app.services.messaging import publish_forecast_completed, publish_alert_created
 from app.core.config import settings
 from shared.monitoring.metrics import MetricsCollector
+from app.services.model_client import ModelClient
+from app.services.data_client import DataClient
 
 logger = structlog.get_logger()
 metrics = MetricsCollector("forecasting-service")
@@ -33,6 +35,8 @@ class ForecastingService:
     
     def __init__(self):
         self.prediction_service = PredictionService()
+        self.model_client = ModelClient()
+        self.data_client = DataClient()
     
     async def generate_forecast(self, request: ForecastRequest, db: AsyncSession) -> Forecast:
         """Generate a single forecast for a product"""
@@ -47,8 +51,7 @@ class ForecastingService:
             # Get the latest trained model for this tenant/product
             model_info = await self._get_latest_model(
                 request.tenant_id, 
-                request.product_name, 
-                request.location
+                request.product_name,
             )
             
             if not model_info:
@@ -66,10 +69,9 @@ class ForecastingService:
             
             # Create forecast record
             forecast = Forecast(
-                tenant_id=uuid.UUID(request.tenant_id),
-                product_name=request.product_name,
-                location=request.location,
-                forecast_date=datetime.combine(request.forecast_date, datetime.min.time()),
+                tenant_id=uuid.UUID(tenant_id),
+                product_name=product_name,
+                forecast_date=datetime.combine(forecast_date, datetime.min.time()),
                 
                 # Prediction results
                 predicted_demand=prediction_result["demand"],
@@ -243,27 +245,12 @@ class ForecastingService:
             logger.error("Error retrieving forecasts", error=str(e))
             raise
     
-    async def _get_latest_model(self, tenant_id: str, product_name: str, location: str) -> Optional[Dict[str, Any]]:
+    async def _get_latest_model(self, tenant_id: str, product_name: str) -> Optional[Dict[str, Any]]:
         """Get the latest trained model for a tenant/product combination"""
         
         try:
-            # Call training service to get model information
-            async with httpx.AsyncClient() as client:
-                response = await client.get(
-                    f"{settings.TRAINING_SERVICE_URL}/tenants/{tenant_id}/models/{product_name}/active",
-                    params={},
-                    headers={"X-Service-Auth": settings.SERVICE_AUTH_TOKEN}
-                )
-                
-                if response.status_code == 200:
-                    return response.json()
-                elif response.status_code == 404:
-                    logger.warning("No model found", 
-                                 tenant_id=tenant_id, 
-                                 product=product_name)
-                    return None
-                else:
-                    response.raise_for_status()
+            model_data = await self.data_client.get_best_model_for_forecasting(tenant_id, product_name)
+            return model_data
                     
         except Exception as e:
             logger.error("Error getting latest model", error=str(e))
@@ -275,22 +262,15 @@ class ForecastingService:
         features = {
             "date": request.forecast_date.isoformat(),
             "day_of_week": request.forecast_date.weekday(),
-            "is_weekend": request.forecast_date.weekday() >= 5,
-            "business_type": request.business_type.value
+            "is_weekend": request.forecast_date.weekday() >= 5
         }
         
         # Add Spanish holidays
         features["is_holiday"] = await self._is_spanish_holiday(request.forecast_date)
         
-        # Add weather data if requested
-        if request.include_weather:
-            weather_data = await self._get_weather_forecast(request.forecast_date)
-            features.update(weather_data)
-        
-        # Add traffic data if requested
-        if request.include_traffic:
-            traffic_data = await self._get_traffic_forecast(request.forecast_date, request.location)
-            features.update(traffic_data)
+   
+        weather_data = await self._get_weather_forecast(request.tenant_id, 1)
+        features.update(weather_data)
         
         return features
     
@@ -315,61 +295,16 @@ class ForecastingService:
             logger.warning("Error checking holiday status", error=str(e))
             return False
     
-    async def _get_weather_forecast(self, forecast_date: date) -> Dict[str, Any]:
+    async def _get_weather_forecast(self, tenant_id: str, days: str) -> Dict[str, Any]:
         """Get weather forecast for the date"""
         
         try:
-            # Call data service for weather forecast
-            async with httpx.AsyncClient() as client:
-                response = await client.get(
-                    f"{settings.DATA_SERVICE_URL}/api/v1/weather/forecast",
-                    params={"date": forecast_date.isoformat()},
-                    headers={"X-Service-Auth": settings.SERVICE_AUTH_TOKEN}
-                )
-                
-                if response.status_code == 200:
-                    weather = response.json()
-                    return {
-                        "temperature": weather.get("temperature"),
-                        "precipitation": weather.get("precipitation"),
-                        "humidity": weather.get("humidity"),
-                        "weather_description": weather.get("description")
-                    }
-                else:
-                    return {}
-                    
+            weather_data = await self.data_client.fetch_weather_forecast(tenant_id, days)
+            return weather_data       
         except Exception as e:
             logger.warning("Error getting weather forecast", error=str(e))
             return {}
     
-    async def _get_traffic_forecast(self, forecast_date: date, location: str) -> Dict[str, Any]:
-        """Get traffic forecast for the date and location"""
-        
-        try:
-            # Call data service for traffic forecast
-            async with httpx.AsyncClient() as client:
-                response = await client.get(
-                    f"{settings.DATA_SERVICE_URL}/api/v1/traffic/forecast",
-                    params={
-                        "date": forecast_date.isoformat(),
-                        "location": location
-                    },
-                    headers={"X-Service-Auth": settings.SERVICE_AUTH_TOKEN}
-                )
-                
-                if response.status_code == 200:
-                    traffic = response.json()
-                    return {
-                        "traffic_volume": traffic.get("volume"),
-                        "pedestrian_count": traffic.get("pedestrian_count")
-                    }
-                else:
-                    return {}
-                    
-        except Exception as e:
-            logger.warning("Error getting traffic forecast", error=str(e))
-            return {}
-    
     async def _check_and_create_alerts(self, forecast: Forecast, db: AsyncSession):
         """Check forecast and create alerts if needed"""