bakery-ia/services/data/app/external/aemet.py

# ================================================================
# services/data/app/external/aemet.py - REFACTORED VERSION
# ================================================================
"""AEMET (Spanish Weather Service) API client with improved modularity"""

import math
from typing import List, Dict, Any, Optional, Tuple
from datetime import datetime, timedelta
from dataclasses import dataclass
from enum import Enum
import structlog

from app.external.base_client import BaseAPIClient
from app.core.config import settings

logger = structlog.get_logger()


class WeatherSource(Enum):
    """Weather data source types"""
    AEMET = "aemet"
    SYNTHETIC = "synthetic"
    DEFAULT = "default"


@dataclass
class WeatherStation:
    """Weather station data"""
    id: str
    name: str
    latitude: float
    longitude: float


@dataclass
class GeographicBounds:
    """Geographic boundary definition"""
    min_lat: float
    max_lat: float
    min_lon: float
    max_lon: float
    
    def contains(self, latitude: float, longitude: float) -> bool:
        """Check if coordinates are within bounds"""
        return (self.min_lat <= latitude <= self.max_lat and 
                self.min_lon <= longitude <= self.max_lon)


class AEMETConstants:
    """AEMET API constants and configuration"""
    
    # API Configuration
    MAX_DAYS_PER_REQUEST = 30
    MADRID_MUNICIPALITY_CODE = "28079"
    
    # Madrid geographic bounds
    MADRID_BOUNDS = GeographicBounds(
        min_lat=40.3, max_lat=40.6,
        min_lon=-3.9, max_lon=-3.5
    )
    
    # Weather stations in Madrid area
    MADRID_STATIONS = [
        WeatherStation("3195", "Madrid Centro", 40.4117, -3.6780),
        WeatherStation("3129", "Madrid Norte", 40.4677, -3.5552),
        WeatherStation("3197", "Madrid Sur", 40.2987, -3.7216),
    ]
    
    # Climate simulation parameters
    BASE_TEMPERATURE_SEASONAL = 5.0
    TEMPERATURE_SEASONAL_MULTIPLIER = 2.5
    DAILY_TEMPERATURE_AMPLITUDE = 8.0
    EARTH_RADIUS_KM = 6371.0


class WeatherDataParser:
    """Handles parsing of different weather data formats"""
    
    @staticmethod
    def safe_float(value: Any, default: Optional[float] = None) -> Optional[float]:
        """Safely convert value to float with fallback"""
        try:
            if value is None:
                return default
            return float(value)
        except (ValueError, TypeError):
            return default
    
    @staticmethod
    def extract_temperature_value(temp_data: Any) -> Optional[float]:
        """Extract temperature value from AEMET complex temperature structure"""
        if temp_data is None:
            return None
            
        if isinstance(temp_data, (int, float)):
            return float(temp_data)
            
        if isinstance(temp_data, str):
            try:
                return float(temp_data)
            except ValueError:
                return None
                
        if isinstance(temp_data, dict) and 'valor' in temp_data:
            return WeatherDataParser.safe_float(temp_data['valor'])
            
        if isinstance(temp_data, list) and len(temp_data) > 0:
            first_item = temp_data[0]
            if isinstance(first_item, dict) and 'valor' in first_item:
                return WeatherDataParser.safe_float(first_item['valor'])
        
        return None
    
    @staticmethod
    def generate_weather_description(temperature: Optional[float], 
                                   precipitation: Optional[float], 
                                   humidity: Optional[float]) -> str:
        """Generate weather description based on conditions"""
        if precipitation and precipitation > 5.0:
            return "Lluvioso"
        elif precipitation and precipitation > 0.1:
            return "Nuboso con lluvia"
        elif humidity and humidity > 80:
            return "Nuboso"
        elif temperature and temperature > 25:
            return "Soleado y cálido"
        elif temperature and temperature < 5:
            return "Frío"
        else:
            return "Variable"
    
    def parse_current_weather(self, data: Dict[str, Any]) -> Dict[str, Any]:
        """Parse AEMET current weather data format"""
        if not isinstance(data, dict):
            logger.warning("Weather data is not a dictionary", data_type=type(data))
            return self._get_default_weather_data()
        
        try:
            return {
                "date": datetime.now(),
                "temperature": self.safe_float(data.get("ta"), 15.0),
                "precipitation": self.safe_float(data.get("prec"), 0.0),
                "humidity": self.safe_float(data.get("hr"), 50.0),
                "wind_speed": self.safe_float(data.get("vv"), 10.0),
                "pressure": self.safe_float(data.get("pres"), 1013.0),
                "description": str(data.get("descripcion", "Partly cloudy")),
                "source": WeatherSource.AEMET.value
            }
        except Exception as e:
            logger.error("Error parsing weather data", error=str(e), data=data)
            return self._get_default_weather_data()
    
    def parse_historical_data(self, data: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
        """Parse AEMET historical weather data"""
        parsed_data = []
        
        try:
            for record in data:
                if not isinstance(record, dict):
                    continue
                
                parsed_record = self._parse_single_historical_record(record)
                if parsed_record:
                    parsed_data.append(parsed_record)
                    
        except Exception as e:
            logger.error("Error parsing historical weather data", error=str(e))
        
        return parsed_data
    
    def parse_forecast_data(self, data: List[Dict[str, Any]], days: int) -> List[Dict[str, Any]]:
        """Parse AEMET forecast data"""
        forecast = []
        base_date = datetime.now().date()
        
        if not isinstance(data, list):
            logger.warning("Forecast data is not a list", data_type=type(data))
            return []
        
        try:
            if len(data) > 0 and isinstance(data[0], dict):
                aemet_data = data[0]
                dias = aemet_data.get('prediccion', {}).get('dia', [])
                
                if isinstance(dias, list) and len(dias) > 0:
                    forecast = self._parse_forecast_days(dias, days, base_date)
            
            # Fill remaining days with synthetic data if needed
            forecast = self._ensure_forecast_completeness(forecast, days)
                
        except Exception as e:
            logger.error("Error parsing AEMET forecast data", error=str(e))
            forecast = []
        
        return forecast
    
    def _parse_single_historical_record(self, record: Dict[str, Any]) -> Optional[Dict[str, Any]]:
        """Parse a single historical weather record"""
        fecha_str = record.get('fecha')
        if not fecha_str:
            return None
            
        try:
            record_date = datetime.strptime(fecha_str, '%Y-%m-%d')
        except ValueError:
            logger.warning("Invalid date format in historical data", fecha=fecha_str)
            return None
        
        # Extract and calculate temperature
        temp_max = self.safe_float(record.get('tmax'))
        temp_min = self.safe_float(record.get('tmin'))
        temperature = self._calculate_average_temperature(temp_max, temp_min)
        
        # Extract other weather parameters
        precipitation = self.safe_float(record.get('prec'), 0.0)
        humidity = self.safe_float(record.get('hr'))
        wind_speed = self.safe_float(record.get('velmedia'))
        pressure = self._extract_pressure(record)
        
        return {
            "date": record_date,
            "temperature": temperature,
            "precipitation": precipitation,
            "humidity": humidity,
            "wind_speed": wind_speed,
            "pressure": pressure,
            "description": self.generate_weather_description(temperature, precipitation, humidity),
            "source": WeatherSource.AEMET.value
        }
    
    def _calculate_average_temperature(self, temp_max: Optional[float], temp_min: Optional[float]) -> Optional[float]:
        """Calculate average temperature from max and min values"""
        if temp_max and temp_min:
            return (temp_max + temp_min) / 2
        elif temp_max:
            return temp_max - 5  # Estimate average from max
        elif temp_min:
            return temp_min + 5  # Estimate average from min
        return None
    
    def _extract_pressure(self, record: Dict[str, Any]) -> Optional[float]:
        """Extract pressure from historical record"""
        pressure = self.safe_float(record.get('presMax'))
        if not pressure:
            pressure = self.safe_float(record.get('presMin'))
        return pressure
    
    def _parse_forecast_days(self, dias: List[Dict[str, Any]], days: int, base_date: datetime.date) -> List[Dict[str, Any]]:
        """Parse forecast days from AEMET data"""
        forecast = []
        
        for i, dia in enumerate(dias[:days]):
            if not isinstance(dia, dict):
                continue
                
            forecast_date = base_date + timedelta(days=i)
            forecast_day = self._parse_single_forecast_day(dia, forecast_date, i)
            forecast.append(forecast_day)
            
        return forecast
    
    def _parse_single_forecast_day(self, dia: Dict[str, Any], forecast_date: datetime.date, day_index: int) -> Dict[str, Any]:
        """Parse a single forecast day"""
        # Extract temperature
        temp_data = dia.get('temperatura', {})
        avg_temp = self._extract_forecast_temperature(temp_data)
        
        # Extract precipitation probability
        precip_prob = self._extract_precipitation_probability(dia.get('probPrecipitacion', []))
        
        # Extract wind speed
        wind_speed = self._extract_wind_speed(dia.get('viento', []))
        
        # Generate description
        description = self._generate_forecast_description(precip_prob)
        
        return {
            "forecast_date": datetime.combine(forecast_date, datetime.min.time()),
            "generated_at": datetime.now(),
            "temperature": round(avg_temp, 1),
            "precipitation": precip_prob / 10,  # Convert percentage to mm estimate
            "humidity": 50.0 + (day_index % 20),  # Estimate
            "wind_speed": round(wind_speed, 1),
            "description": description,
            "source": WeatherSource.AEMET.value
        }
    
    def _extract_forecast_temperature(self, temp_data: Dict[str, Any]) -> float:
        """Extract temperature from forecast temperature data"""
        if isinstance(temp_data, dict):
            temp_max = self.extract_temperature_value(temp_data.get('maxima'))
            temp_min = self.extract_temperature_value(temp_data.get('minima'))
            if temp_max and temp_min:
                return (temp_max + temp_min) / 2
        return 15.0
    
    def _extract_precipitation_probability(self, precip_data: List[Dict[str, Any]]) -> float:
        """Extract precipitation probability from forecast data"""
        precip_prob = 0.0
        if isinstance(precip_data, list):
            for precip_item in precip_data:
                if isinstance(precip_item, dict) and 'value' in precip_item:
                    precip_prob = max(precip_prob, self.safe_float(precip_item.get('value'), 0.0))
        return precip_prob
    
    def _extract_wind_speed(self, viento_data: List[Dict[str, Any]]) -> float:
        """Extract wind speed from forecast data"""
        wind_speed = 10.0
        if isinstance(viento_data, list):
            for viento_item in viento_data:
                if isinstance(viento_item, dict) and 'velocidad' in viento_item:
                    speed_values = viento_item.get('velocidad', [])
                    if isinstance(speed_values, list) and len(speed_values) > 0:
                        wind_speed = self.safe_float(speed_values[0], 10.0)
                        break
        return wind_speed
    
    def _generate_forecast_description(self, precip_prob: float) -> str:
        """Generate description based on precipitation probability"""
        if precip_prob > 70:
            return "Lluvioso"
        elif precip_prob > 30:
            return "Parcialmente nublado"
        else:
            return "Soleado"
    
    def _ensure_forecast_completeness(self, forecast: List[Dict[str, Any]], days: int) -> List[Dict[str, Any]]:
        """Ensure forecast has the requested number of days"""
        if len(forecast) < days:
            remaining_days = days - len(forecast)
            synthetic_generator = SyntheticWeatherGenerator()
            synthetic_forecast = synthetic_generator.generate_forecast_sync(remaining_days, len(forecast))
            forecast.extend(synthetic_forecast)
        
        return forecast[:days]
    
    def _get_default_weather_data(self) -> Dict[str, Any]:
        """Get default weather data structure"""
        return {
            "date": datetime.now(),
            "temperature": 15.0,
            "precipitation": 0.0,
            "humidity": 50.0,
            "wind_speed": 10.0,
            "pressure": 1013.0,
            "description": "Data not available",
            "source": WeatherSource.DEFAULT.value
        }


class SyntheticWeatherGenerator:
    """Generates realistic synthetic weather data for Madrid"""
    
    def generate_current_weather(self) -> Dict[str, Any]:
        """Generate realistic synthetic current weather for Madrid"""
        now = datetime.now()
        month = now.month
        hour = now.hour
        
        # Madrid climate simulation
        temperature = self._calculate_current_temperature(month, hour)
        precipitation = self._calculate_current_precipitation(now, month)
        
        return {
            "date": now,
            "temperature": round(temperature, 1),
            "precipitation": precipitation,
            "humidity": 45 + (month % 6) * 5,
            "wind_speed": 8 + (hour % 12),
            "pressure": 1013 + math.sin(now.day * 0.2) * 15,
            "description": "Lluvioso" if precipitation > 0 else "Soleado",
            "source": WeatherSource.SYNTHETIC.value
        }
    
    def generate_forecast_sync(self, days: int, start_offset: int = 0) -> List[Dict[str, Any]]:
        """Generate synthetic forecast data synchronously"""
        forecast = []
        base_date = datetime.now().date()
        
        for i in range(days):
            forecast_date = base_date + timedelta(days=start_offset + i)
            forecast_day = self._generate_forecast_day(forecast_date, start_offset + i)
            forecast.append(forecast_day)
        
        return forecast
    
    async def generate_forecast(self, days: int) -> List[Dict[str, Any]]:
        """Generate synthetic forecast data (async version for compatibility)"""
        return self.generate_forecast_sync(days, 0)
    
    def generate_historical_data(self, start_date: datetime, end_date: datetime) -> List[Dict[str, Any]]:
        """Generate synthetic historical weather data"""
        historical_data = []
        current_date = start_date
        
        while current_date <= end_date:
            historical_day = self._generate_historical_day(current_date)
            historical_data.append(historical_day)
            current_date += timedelta(days=1)
        
        return historical_data
    
    def _calculate_current_temperature(self, month: int, hour: int) -> float:
        """Calculate current temperature based on seasonal and daily patterns"""
        base_temp = AEMETConstants.BASE_TEMPERATURE_SEASONAL + (month - 1) * AEMETConstants.TEMPERATURE_SEASONAL_MULTIPLIER
        temp_variation = math.sin((hour - 6) * math.pi / 12) * AEMETConstants.DAILY_TEMPERATURE_AMPLITUDE
        return base_temp + temp_variation
    
    def _calculate_current_precipitation(self, now: datetime, month: int) -> float:
        """Calculate current precipitation based on seasonal patterns"""
        rain_prob = 0.3 if month in [11, 12, 1, 2, 3] else 0.1
        return 2.5 if hash(now.date()) % 100 < rain_prob * 100 else 0.0
    
    def _generate_forecast_day(self, forecast_date: datetime.date, day_offset: int) -> Dict[str, Any]:
        """Generate a single forecast day"""
        month = forecast_date.month
        base_temp = AEMETConstants.BASE_TEMPERATURE_SEASONAL + (month - 1) * AEMETConstants.TEMPERATURE_SEASONAL_MULTIPLIER
        temp_variation = ((day_offset) % 7 - 3) * 2  # Weekly variation
        
        return {
            "forecast_date": datetime.combine(forecast_date, datetime.min.time()),
            "generated_at": datetime.now(),
            "temperature": round(base_temp + temp_variation, 1),
            "precipitation": 2.0 if day_offset % 5 == 0 else 0.0,
            "humidity": 50 + (day_offset % 30),
            "wind_speed": 10 + (day_offset % 15),
            "description": "Lluvioso" if day_offset % 5 == 0 else "Soleado",
            "source": WeatherSource.SYNTHETIC.value
        }
    
    def _generate_historical_day(self, date: datetime) -> Dict[str, Any]:
        """Generate a single historical day"""
        month = date.month
        base_temp = AEMETConstants.BASE_TEMPERATURE_SEASONAL + (month - 1) * AEMETConstants.TEMPERATURE_SEASONAL_MULTIPLIER
        temp_variation = math.sin(date.day * 0.3) * 5
        
        return {
            "date": date,
            "temperature": round(base_temp + temp_variation, 1),
            "precipitation": 1.5 if date.day % 7 == 0 else 0.0,
            "humidity": 45 + (date.day % 40),
            "wind_speed": 8 + (date.day % 20),
            "pressure": 1013 + math.sin(date.day * 0.2) * 20,
            "description": "Variable",
            "source": WeatherSource.SYNTHETIC.value
        }


class LocationService:
    """Handles location-related operations"""
    
    @staticmethod
    def find_nearest_station(latitude: float, longitude: float) -> Optional[str]:
        """Find nearest weather station to given coordinates"""
        try:
            # Check if coordinates are reasonable (not extreme values)
            if not (-90 <= latitude <= 90 and -180 <= longitude <= 180):
                logger.warning("Invalid coordinate range", lat=latitude, lon=longitude)
                return None
            
            # Check if coordinates are too far from Madrid area (more than 1000km away)
            madrid_center = (40.4168, -3.7038)
            distance_to_madrid = LocationService.calculate_distance(
                latitude, longitude, madrid_center[0], madrid_center[1]
            )
            
            if distance_to_madrid > 1000:  # More than 1000km from Madrid
                logger.warning("Coordinates too far from Madrid", 
                            lat=latitude, lon=longitude, distance_km=distance_to_madrid)
                return None
            
            closest_station = None
            min_distance = float('inf')
            
            for station in AEMETConstants.MADRID_STATIONS:
                distance = LocationService.calculate_distance(
                    latitude, longitude, station.latitude, station.longitude
                )
                if distance < min_distance:
                    min_distance = distance
                    closest_station = station.id
            
            return closest_station
            
        except Exception as e:
            logger.error("Failed to find nearest station", error=str(e))
            return None
    
    @staticmethod
    def get_municipality_code(latitude: float, longitude: float) -> Optional[str]:
        """Get municipality code for coordinates"""
        if AEMETConstants.MADRID_BOUNDS.contains(latitude, longitude):
            return AEMETConstants.MADRID_MUNICIPALITY_CODE
        return None
    
    @staticmethod
    def calculate_distance(lat1: float, lon1: float, lat2: float, lon2: float) -> float:
        """Calculate distance between two coordinates using Haversine formula"""
        dlat = math.radians(lat2 - lat1)
        dlon = math.radians(lon2 - lon1)
        
        a = (math.sin(dlat/2) * math.sin(dlat/2) +
             math.cos(math.radians(lat1)) * math.cos(math.radians(lat2)) *
             math.sin(dlon/2) * math.sin(dlon/2))
        
        c = 2 * math.atan2(math.sqrt(a), math.sqrt(1-a))
        return AEMETConstants.EARTH_RADIUS_KM * c


class AEMETClient(BaseAPIClient):
    """AEMET (Spanish Weather Service) API client with improved modularity"""
    
    def __init__(self):
        super().__init__(
            base_url="https://opendata.aemet.es/opendata/api",
            api_key=settings.AEMET_API_KEY
        )
        self.parser = WeatherDataParser()
        self.synthetic_generator = SyntheticWeatherGenerator()
        self.location_service = LocationService()
    
    async def get_current_weather(self, latitude: float, longitude: float) -> Optional[Dict[str, Any]]:
        """Get current weather for coordinates"""
        try:
            station_id = self.location_service.find_nearest_station(latitude, longitude)
            if not station_id:
                logger.warning("No weather station found", lat=latitude, lon=longitude)
                return await self._get_synthetic_current_weather()
            
            weather_data = await self._fetch_current_weather_data(station_id)
            if weather_data:
                return self.parser.parse_current_weather(weather_data)
            
            logger.info("Falling back to synthetic weather data", reason="invalid_weather_data")
            return await self._get_synthetic_current_weather()
            
        except Exception as e:
            logger.error("Failed to get current weather", error=str(e))
            return await self._get_synthetic_current_weather()
    
    async def get_forecast(self, latitude: float, longitude: float, days: int = 7) -> List[Dict[str, Any]]:
        """Get weather forecast for coordinates"""
        try:
            municipality_code = self.location_service.get_municipality_code(latitude, longitude)
            if not municipality_code:
                logger.info("No municipality code found, using synthetic data")
                return await self.synthetic_generator.generate_forecast(days)
            
            forecast_data = await self._fetch_forecast_data(municipality_code)
            if forecast_data:
                parsed_forecast = self.parser.parse_forecast_data(forecast_data, days)
                if parsed_forecast:
                    return parsed_forecast
            
            logger.info("Falling back to synthetic forecast data", reason="invalid_forecast_data")
            return await self.synthetic_generator.generate_forecast(days)
            
        except Exception as e:
            logger.error("Failed to get weather forecast", error=str(e))
            return await self.synthetic_generator.generate_forecast(days)
    
    async def get_historical_weather(self, 
                                   latitude: float, 
                                   longitude: float, 
                                   start_date: datetime, 
                                   end_date: datetime) -> List[Dict[str, Any]]:
        """Get historical weather data"""
        try:
            logger.debug("Getting historical weather from AEMET API", 
                        lat=latitude, lon=longitude, 
                        start=start_date, end=end_date)
            
            station_id = self.location_service.find_nearest_station(latitude, longitude)
            if not station_id:
                logger.warning("No weather station found for historical data", 
                             lat=latitude, lon=longitude)
                return self.synthetic_generator.generate_historical_data(start_date, end_date)
            
            historical_data = await self._fetch_historical_data_in_chunks(
                station_id, start_date, end_date
            )
            
            if historical_data:
                logger.debug("Successfully fetched historical weather data", 
                           total_count=len(historical_data))
                return historical_data
            else:
                logger.info("No real historical data available, using synthetic data")
                return self.synthetic_generator.generate_historical_data(start_date, end_date)
                
        except Exception as e:
            logger.error("Failed to get historical weather from AEMET API", error=str(e))
            return self.synthetic_generator.generate_historical_data(start_date, end_date)
    
    async def _fetch_current_weather_data(self, station_id: str) -> Optional[Dict[str, Any]]:
        """Fetch current weather data from AEMET API"""
        endpoint = f"/observacion/convencional/datos/estacion/{station_id}"
        initial_response = await self._get(endpoint)
        
        if not self._is_valid_initial_response(initial_response):
            return None
        
        datos_url = initial_response.get("datos")
        actual_weather_data = await self._fetch_from_url(datos_url)
        
        if (actual_weather_data and isinstance(actual_weather_data, list) 
            and len(actual_weather_data) > 0):
            return actual_weather_data[0]
        
        return None
    
    async def _fetch_forecast_data(self, municipality_code: str) -> Optional[List[Dict[str, Any]]]:
        """Fetch forecast data from AEMET API"""
        endpoint = f"/prediccion/especifica/municipio/diaria/{municipality_code}"
        initial_response = await self._get(endpoint)
        
        if not self._is_valid_initial_response(initial_response):
            return None
        
        datos_url = initial_response.get("datos")
        return await self._fetch_from_url(datos_url)
    
    async def _fetch_historical_data_in_chunks(self, 
                                             station_id: str, 
                                             start_date: datetime, 
                                             end_date: datetime) -> List[Dict[str, Any]]:
        """Fetch historical data in chunks due to AEMET API limitations"""
        historical_data = []
        current_date = start_date
        
        while current_date <= end_date:
            chunk_end_date = min(
                current_date + timedelta(days=AEMETConstants.MAX_DAYS_PER_REQUEST), 
                end_date
            )
            
            chunk_data = await self._fetch_historical_chunk(
                station_id, current_date, chunk_end_date
            )
            
            if chunk_data:
                historical_data.extend(chunk_data)
            
            current_date = chunk_end_date + timedelta(days=1)
        
        return historical_data
    
    async def _fetch_historical_chunk(self, 
                                    station_id: str, 
                                    start_date: datetime, 
                                    end_date: datetime) -> List[Dict[str, Any]]:
        """Fetch a single chunk of historical data"""
        start_str = start_date.strftime("%Y-%m-%dT00:00:00UTC")
        end_str = end_date.strftime("%Y-%m-%dT23:59:59UTC")
        
        endpoint = f"/valores/climatologicos/diarios/datos/fechaini/{start_str}/fechafin/{end_str}/estacion/{station_id}"
        initial_response = await self._get(endpoint)
        
        if not self._is_valid_initial_response(initial_response):
            logger.warning("Invalid initial response from AEMET historical API", 
                         start=start_str, end=end_str)
            return []
        
        datos_url = initial_response.get("datos")
        if not datos_url:
            logger.warning("No datos URL in AEMET historical response", 
                         start=start_str, end=end_str)
            return []
        
        actual_historical_data = await self._fetch_from_url(datos_url)
        
        if actual_historical_data and isinstance(actual_historical_data, list):
            chunk_data = self.parser.parse_historical_data(actual_historical_data)
            logger.debug("Fetched historical data chunk", 
                       count=len(chunk_data), start=start_str, end=end_str)
            return chunk_data
        else:
            logger.warning("No valid historical data received for chunk", 
                         start=start_str, end=end_str)
            return []
    
    async def _fetch_from_url(self, url: str) -> Optional[List[Dict[str, Any]]]:
        """Fetch data from AEMET datos URL"""
        try:
            data = await self._fetch_url_directly(url)
            
            if data and isinstance(data, list):
                return data
            else:
                logger.warning("Expected list from datos URL", data_type=type(data))
                return None
                    
        except Exception as e:
            logger.error("Failed to fetch from datos URL", url=url, error=str(e))
            return None
    
    def _is_valid_initial_response(self, response: Any) -> bool:
        """Check if initial AEMET API response is valid"""
        return (response and isinstance(response, dict) and 
                response.get("datos") and isinstance(response.get("datos"), str))
    
    async def _get_synthetic_current_weather(self) -> Dict[str, Any]:
        """Get synthetic current weather data"""
        return self.synthetic_generator.generate_current_weather()