weathergrabber 0.0.8b6__py3-none-any.whl → 0.0.9__py3-none-any.whl

weathergrabber/__init__.py

@@ -4,7 +4,7 @@ from .core import main
 from .cli import main_cli
 
 __all__ = ["main", "main_cli"]
-__version__ = "0.0.8b6"
+__version__ = "0.0.9"
 
 def get_version():
     return __version__

weathergrabber/adapter/repository/forecast_repository.py

@@ -0,0 +1,135 @@
+import sqlite3
+import json
+import os
+import tempfile
+from datetime import datetime
+from typing import Optional
+import logging
+from weathergrabber.domain.entities.forecast import Forecast
+from weathergrabber.domain.adapter.mappers.forecast_mapper import forecast_to_dict, dict_to_forecast
+
+class ForecastRepository:
+    def __init__(self, db_path: str = None):
+        # Use /tmp directory for ephemeral storage by default
+        if db_path is None:
+            db_path = os.path.join(tempfile.gettempdir(), "weather_forecasts.db")
+        
+        self.logger = logging.getLogger(__name__)
+        self.logger.info(f"Initializing ForecastRepository with DB path: {db_path}")
+        self.db_path = db_path
+        self._initialize_database()
+
+    def _initialize_database(self):
+        self.logger.debug("Initializing database and creating tables if they do not exist.")
+        try:
+            with sqlite3.connect(self.db_path) as conn:
+                cursor = conn.cursor()
+                cursor.execute('''
+                    CREATE TABLE IF NOT EXISTS forecasts (
+                        id INTEGER PRIMARY KEY AUTOINCREMENT,
+                        location_id TEXT NOT NULL,
+                        search_name TEXT,
+                        forecast_data TEXT NOT NULL,
+                        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+                    )
+                ''')
+                # Create indexes for fast retrieval
+                cursor.execute("CREATE INDEX IF NOT EXISTS idx_location_id ON forecasts (location_id)")
+                conn.commit()
+                self.logger.debug(f"Database initialized successfully at {self.db_path}")
+        except sqlite3.Error as e:
+            self.logger.error(f"Error initializing database: {e}")
+            raise
+
+    def save_forecast(self, location_id: str, search_name: str, forecast_data: Forecast) -> None:
+        forecast_dict_data = forecast_to_dict(forecast_data)
+        now = datetime.now().isoformat()
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.cursor()
+            cursor.execute('''
+                INSERT INTO forecasts (location_id, search_name, forecast_data, created_at, updated_at)
+                VALUES (?, ?, ?, ?, ?)
+            ''', (
+                location_id,
+                search_name,
+                json.dumps(forecast_dict_data),
+                now,
+                now
+            ))
+            conn.commit()
+
+    def get_by_location_id(self, location_id: str) -> Optional[Forecast]:
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.cursor()
+            cursor.execute('''
+                SELECT forecast_data FROM forecasts
+                WHERE location_id = ? ORDER BY created_at DESC
+                LIMIT 1
+            ''', (location_id,))
+            row = cursor.fetchone()
+            forecast_dict_data = json.loads(row[0]) if row else None
+            return dict_to_forecast(forecast_dict_data) if forecast_dict_data else None
+        
+    def get_by_search_name(self, search_name: str) -> Optional[Forecast]:
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.cursor()
+            cursor.execute('''
+                SELECT forecast_data FROM forecasts
+                WHERE search_name = ? ORDER BY created_at DESC
+                LIMIT 1
+            ''', (search_name,))
+            row = cursor.fetchone()
+            forecast_dict_data = json.loads(row[0]) if row else None
+            return dict_to_forecast(forecast_dict_data) if forecast_dict_data else None
+
+    def clear_cache(self) -> None:
+        """Clear all cached forecasts from the database."""
+        try:
+            with sqlite3.connect(self.db_path) as conn:
+                cursor = conn.cursor()
+                cursor.execute("DELETE FROM forecasts")
+                conn.commit()
+                self.logger.info("Cache cleared successfully")
+        except sqlite3.Error as e:
+            self.logger.error(f"Error clearing cache: {e}")
+
+    def get_cache_stats(self) -> dict:
+        """Get statistics about the cached forecasts."""
+        try:
+            with sqlite3.connect(self.db_path) as conn:
+                cursor = conn.cursor()
+                cursor.execute("SELECT COUNT(*) FROM forecasts")
+                total_count = cursor.fetchone()[0]
+                
+                cursor.execute("""
+                    SELECT COUNT(DISTINCT location_id) as unique_locations,
+                           COUNT(DISTINCT search_name) as unique_search_names
+                    FROM forecasts
+                """)
+                stats = cursor.fetchone()
+                
+                return {
+                    'total_forecasts': total_count,
+                    'unique_locations': stats[0],
+                    'unique_search_names': stats[1],
+                    'database_path': self.db_path
+                }
+        except sqlite3.Error as e:
+            self.logger.error(f"Error getting cache stats: {e}")
+            return {'error': str(e)}
+
+    def cleanup_old_forecasts(self, hours_old: int = 24) -> None:
+        """Remove forecasts older than specified hours."""
+        try:
+            with sqlite3.connect(self.db_path) as conn:
+                cursor = conn.cursor()
+                cursor.execute("""
+                    DELETE FROM forecasts 
+                    WHERE created_at < datetime('now', '-{} hours')
+                """.format(hours_old))
+                deleted_count = cursor.rowcount
+                conn.commit()
+                self.logger.info(f"Cleaned up {deleted_count} old forecasts")
+        except sqlite3.Error as e:
+            self.logger.error(f"Error cleaning up old forecasts: {e}")

weathergrabber/adapter/tty/console_tty.py

@@ -1,13 +1,13 @@
-from weathergrabber.usecase.use_case import UseCase
+from weathergrabber.application.usecases.weather_forecast_uc import WeatherForecastUC
 from weathergrabber.domain.adapter.params import Params
 from weathergrabber.domain.adapter.icon_enum import IconEnum
-from weathergrabber.domain.weather_icon_enum import WeatherIconEnum
-from weathergrabber.weathergrabber_application import WeatherGrabberApplication
+from weathergrabber.domain.entities.weather_icon_enum import WeatherIconEnum
+from weathergrabber.application.weathergrabber_application import WeatherGrabberApplication
 import logging
 
 class ConsoleTTY:
 
-    def __init__(self, use_case: UseCase):
+    def __init__(self, use_case: WeatherForecastUC):
         self.logger = logging.getLogger(__name__)
         self.use_case = use_case
         pass

weathergrabber/adapter/tty/json_tty.py

@@ -1,12 +1,12 @@
-from weathergrabber.usecase.use_case import UseCase
+from weathergrabber.application.usecases.weather_forecast_uc import WeatherForecastUC
 from weathergrabber.domain.adapter.params import Params
-from weathergrabber.domain.adapter.mapper.forecast_mapper import forecast_to_dict
+from weathergrabber.domain.adapter.mappers.forecast_mapper import forecast_to_dict
 import logging
 import json
 
 class JsonTTY:
 
-    def __init__(self, use_case: UseCase):
+    def __init__(self, use_case: WeatherForecastUC):
         self.logger = logging.getLogger(__name__)
         self.use_case = use_case
         pass

weathergrabber/adapter/tty/statistics_tty.py

@@ -0,0 +1,35 @@
+from weathergrabber.application.usecases.statistics_uc import StatisticsUC
+from weathergrabber.domain.adapter.params import Params
+from weathergrabber.domain.adapter.output_enum import OutputEnum
+from weathergrabber.domain.adapter.mappers.statistics_mapper import statistics_to_dict
+from weathergrabber.domain.entities.statistics import Statistics
+import logging
+import json
+
+class StatisticsTTY:
+    def __init__(self, statistics_uc: StatisticsUC):
+        self.logger = logging.getLogger(__name__)
+        self.statistics_uc = statistics_uc
+
+    def execute(self, params : Params):
+        statistics = self.statistics_uc.execute(params)
+        print_value = self.json_print(statistics) if (params.output_format == OutputEnum.JSON) else self.tty_print(statistics)
+        print(print_value)
+            
+    def tty_print(self, statistics: Statistics):
+        self.logger.info("Preparing TTY output for statistics")
+        lines = [
+            "",
+            "WeatherGrabber Statistics",
+            "=========================",
+            f"Total Forecasts: {statistics.total_forecasts}",
+            f"Unique Locations: {statistics.unique_locations}",
+            f"Unique Search Names: {statistics.unique_search_names}",
+            f"Database Path: {statistics.database_path}",
+            "",
+        ]
+        return "\n".join(lines)
+    
+    def json_print(self, statistics: Statistics):
+        self.logger.info("Preparing JSON output for statistics")
+        return json.dumps(statistics_to_dict(statistics))

weathergrabber/adapter/tty/waybar_tty.py

@@ -1,13 +1,13 @@
-from weathergrabber.usecase.use_case import UseCase
+from weathergrabber.application.usecases.weather_forecast_uc import WeatherForecastUC
 from weathergrabber.domain.adapter.params import Params
 from weathergrabber.domain.adapter.icon_enum import IconEnum
-from weathergrabber.domain.weather_icon_enum import WeatherIconEnum
+from weathergrabber.domain.entities.weather_icon_enum import WeatherIconEnum
 import logging
 import json
 
 class WaybarTTY:
 
-    def __init__(self, use_case: UseCase):
+    def __init__(self, use_case: WeatherForecastUC):
         self.logger = logging.getLogger(__name__)
         self.use_case = use_case
         pass
@@ -97,7 +97,7 @@ class WaybarTTY:
                 f"{d['title']}"
                 f"{'\t\t' if len(d['title']) < 5 else '\t'}"
                 f"{d['high_low']}"
-                f"{'\t\t' if len(d['high_low']) < 32 else '\t'}"
+                f"{'\t\t' if len(d['high_low']) < 33 else '\t'}"
                 f"{d['icon']}\t"
                 f"{rain_icon} {d['precipitation']}"
             for d in daily_predictions_format

weathergrabber/{service → application/services}/extract_aqi_service.py

@@ -1,5 +1,5 @@
 import logging
-from weathergrabber.domain.air_quality_index import AirQualityIndex
+from weathergrabber.domain.entities.air_quality_index import AirQualityIndex
 from pyquery import PyQuery
 
 class ExtractAQIService:

weathergrabber/{service → application/services}/extract_current_conditions_service.py

@@ -1,10 +1,10 @@
 import logging
 from pyquery import PyQuery
-from weathergrabber.domain.weather_icon_enum import WeatherIconEnum
-from weathergrabber.domain.city_location import CityLocation
-from weathergrabber.domain.timestamp import Timestamp
-from weathergrabber.domain.day_night import DayNight
-from weathergrabber.domain.current_conditions import CurrentConditions
+from weathergrabber.domain.entities.weather_icon_enum import WeatherIconEnum
+from weathergrabber.domain.entities.city_location import CityLocation
+from weathergrabber.domain.entities.timestamp import Timestamp
+from weathergrabber.domain.entities.day_night import DayNight
+from weathergrabber.domain.entities.current_conditions import CurrentConditions
 
 class ExtractCurrentConditionsService:
     def __init__(self):

weathergrabber/{service → application/services}/extract_daily_forecast_oldstyle_service.py

@@ -1,9 +1,9 @@
 import logging
 from pyquery import PyQuery
-from weathergrabber.domain.daily_predictions import DailyPredictions
-from weathergrabber.domain.temperature_hight_low import TemperatureHighLow
-from weathergrabber.domain.weather_icon_enum import WeatherIconEnum
-from weathergrabber.domain.precipitation import Precipitation
+from weathergrabber.domain.entities.daily_predictions import DailyPredictions
+from weathergrabber.domain.entities.temperature_hight_low import TemperatureHighLow
+from weathergrabber.domain.entities.weather_icon_enum import WeatherIconEnum
+from weathergrabber.domain.entities.precipitation import Precipitation
 from typing import List
 
 class ExtractDailyForecastOldstyleService:

weathergrabber/{service → application/services}/extract_daily_forecast_service.py

@@ -1,11 +1,11 @@
 import logging
 from pyquery import PyQuery
-from weathergrabber.domain.precipitation import Precipitation
-from weathergrabber.domain.weather_icon_enum import WeatherIconEnum
-from weathergrabber.domain.moon_phase_enum import MoonPhaseEnum
-from weathergrabber.domain.moon_phase import MoonPhase
-from weathergrabber.domain.temperature_hight_low import TemperatureHighLow
-from weathergrabber.domain.daily_predictions import DailyPredictions
+from weathergrabber.domain.entities.precipitation import Precipitation
+from weathergrabber.domain.entities.weather_icon_enum import WeatherIconEnum
+from weathergrabber.domain.entities.moon_phase_enum import MoonPhaseEnum
+from weathergrabber.domain.entities.moon_phase import MoonPhase
+from weathergrabber.domain.entities.temperature_hight_low import TemperatureHighLow
+from weathergrabber.domain.entities.daily_predictions import DailyPredictions
 
 from typing import List
 

weathergrabber/{service → application/services}/extract_health_activities_service.py

@@ -1,6 +1,6 @@
 import logging
 from pyquery import PyQuery
-from weathergrabber.domain.health_activities import HealthActivities
+from weathergrabber.domain.entities.health_activities import HealthActivities
 
 class ExtractHealthActivitiesService:
     def __init__(self):

weathergrabber/{service → application/services}/extract_hourly_forecast_oldstyle_service.py

@@ -1,8 +1,8 @@
 import logging
 from pyquery import PyQuery
-from weathergrabber.domain.hourly_predictions import HourlyPredictions
-from weathergrabber.domain.weather_icon_enum import WeatherIconEnum
-from weathergrabber.domain.precipitation import Precipitation
+from weathergrabber.domain.entities.hourly_predictions import HourlyPredictions
+from weathergrabber.domain.entities.weather_icon_enum import WeatherIconEnum
+from weathergrabber.domain.entities.precipitation import Precipitation
 from typing import List
 
 class ExtractHourlyForecastOldstyleService:

weathergrabber/{service → application/services}/extract_hourly_forecast_service.py

@@ -1,10 +1,10 @@
 import logging
 from pyquery import PyQuery
-from weathergrabber.domain.hourly_predictions import HourlyPredictions
-from weathergrabber.domain.weather_icon_enum import WeatherIconEnum
-from weathergrabber.domain.uv_index import UVIndex
-from weathergrabber.domain.precipitation import Precipitation
-from weathergrabber.domain.wind import Wind
+from weathergrabber.domain.entities.hourly_predictions import HourlyPredictions
+from weathergrabber.domain.entities.weather_icon_enum import WeatherIconEnum
+from weathergrabber.domain.entities.uv_index import UVIndex
+from weathergrabber.domain.entities.precipitation import Precipitation
+from weathergrabber.domain.entities.wind import Wind
 from typing import List
 
 

weathergrabber/{service → application/services}/extract_today_details_service.py

@@ -1,12 +1,12 @@
 import logging
 from pyquery import PyQuery
-from weathergrabber.domain.today_details import TodayDetails
-from weathergrabber.domain.temperature_hight_low import TemperatureHighLow
-from weathergrabber.domain.uv_index import UVIndex
-from weathergrabber.domain.moon_phase import MoonPhase
-from weathergrabber.domain.moon_phase_enum import MoonPhaseEnum
-from weathergrabber.domain.label_value import LabelValue
-from weathergrabber.domain.sunrise_sunset import SunriseSunset
+from weathergrabber.domain.entities.today_details import TodayDetails
+from weathergrabber.domain.entities.temperature_hight_low import TemperatureHighLow
+from weathergrabber.domain.entities.uv_index import UVIndex
+from weathergrabber.domain.entities.moon_phase import MoonPhase
+from weathergrabber.domain.entities.moon_phase_enum import MoonPhaseEnum
+from weathergrabber.domain.entities.label_value import LabelValue
+from weathergrabber.domain.entities.sunrise_sunset import SunriseSunset
 
 class ExtractTodayDetailsService:
     def __init__(self):
@@ -57,7 +57,7 @@ class ExtractTodayDetailsService:
         moon_phase_icon = icons.eq(7).attr('name')  #'phase-2'
         moon_phase_value = values.eq(7).text()  #'Waxing Crescent'
 
-        self.logger.debug(f"Creating domain objects for today details...")
+        self.logger.debug("Creating domain objects for today details...")
 
         sunrise_sunset = SunriseSunset(sunrise=sunrise, sunset=sunset)
         high_low = TemperatureHighLow.from_string(high_low_value, label=high_low_label)

weathergrabber/application/services/retrieve_forecast_from_cache_service.py

@@ -0,0 +1,27 @@
+from weathergrabber.adapter.repository.forecast_repository import ForecastRepository
+from weathergrabber.domain.adapter.params import Params
+from weathergrabber.domain.entities.forecast import Forecast
+from typing import Optional
+import logging
+
+class RetrieveForecastFromCacheService:
+    def __init__(self, forecast_repository: ForecastRepository):
+        self.forecast_repository = forecast_repository
+        self.log = logging.getLogger(__name__)
+
+    def execute(self, params: Params) -> Optional[Forecast]:
+        """Retrieve forecast from cache based on parameters."""
+        if params.location.id:
+            forecast = self.forecast_repository.get_by_location_id(params.location.id)
+        elif params.location.search_name:
+            forecast = self.forecast_repository.get_by_search_name(params.location.search_name)
+        else:
+            self.log.debug("No location_id provided in params; cannot retrieve from cache.")
+            raise ValueError("Location ID must be provided to retrieve forecast from cache.")
+
+        if forecast:
+            self.log.debug("Forecast retrieved from cache successfully.")
+            return forecast
+        else:
+            self.log.debug("No forecast found in cache.")
+            raise ValueError("No forecast found in cache for the given location.")

weathergrabber/application/services/retrieve_statistics_service.py

@@ -0,0 +1,20 @@
+from weathergrabber.adapter.repository.forecast_repository import ForecastRepository
+from weathergrabber.domain.entities.statistics import Statistics
+from weathergrabber.domain.adapter.mappers.statistics_mapper import dict_to_statistics
+import logging
+
+class RetrieveStatisticsService:
+    def __init__(self, weather_repository: ForecastRepository):
+        self.log = logging.getLogger(__name__)
+        self.weather_repository = weather_repository
+    
+    def execute(self) -> Statistics:
+        """Retrieve and process database."""
+        self.log.debug("Retrieving statistics from repository...")
+        
+        result = self.weather_repository.get_cache_stats()
+        statistics = dict_to_statistics(result)
+        
+        self.log.debug(f"Statistics retrieved successfully: {statistics}")
+        return statistics
+        

weathergrabber/application/services/save_forecast_to_cache_service.py

@@ -0,0 +1,21 @@
+from weathergrabber.adapter.repository.forecast_repository import ForecastRepository
+from weathergrabber.domain.entities.forecast import Forecast
+import logging
+
+
+class SaveForecastToCacheService:
+    def __init__(self, forecast_repository: ForecastRepository):
+        self.forecast_repository = forecast_repository
+        self.logger = logging.getLogger(__name__)
+
+    def execute(self, forecast : Forecast) -> None:
+
+        self.logger.info("Saving forecast to cache")
+        
+        self.forecast_repository.save_forecast(
+            location_id=forecast.search.id,
+            search_name=forecast.search.search_name,
+            forecast_data=forecast
+        )
+        
+        self.logger.debug("Forecast saved to cache successfully")

weathergrabber/application/usecases/statistics_uc.py

@@ -0,0 +1,19 @@
+import logging
+from weathergrabber.application.services.retrieve_statistics_service import RetrieveStatisticsService
+from weathergrabber.domain.entities.statistics import Statistics
+from weathergrabber.domain.adapter.params import Params
+
+class StatisticsUC:
+    def __init__(self, retrieve_statistics_service: RetrieveStatisticsService):
+        self.retrieve_statistics_service = retrieve_statistics_service
+        self.log = logging.getLogger(__name__)
+
+
+    def execute(self, params: Params) -> Statistics:
+        """Execute the use case to retrieve weather statistics."""
+        
+        self.log.info("Executing StatisticsUC to retrieve weather statistics...")
+        statistics = self.retrieve_statistics_service.execute()
+        self.log.info("Weather statistics retrieved successfully.")
+        
+        return statistics

weathergrabber/application/usecases/weather_forecast_uc.py

@@ -0,0 +1,123 @@
+from typing import List
+import logging
+
+from requests.exceptions import ConnectionError
+from weathergrabber.domain.adapter.params import Params
+from weathergrabber.application.services.search_location_service import SearchLocationService
+from weathergrabber.application.services.read_weather_service import ReadWeatherService
+from weathergrabber.application.services.extract_current_conditions_service import ExtractCurrentConditionsService
+from weathergrabber.application.services.extract_today_details_service import ExtractTodayDetailsService
+from weathergrabber.application.services.extract_aqi_service import ExtractAQIService
+from weathergrabber.application.services.extract_health_activities_service import ExtractHealthActivitiesService
+from weathergrabber.application.services.extract_hourly_forecast_service import ExtractHourlyForecastService
+from weathergrabber.application.services.extract_hourly_forecast_oldstyle_service import ExtractHourlyForecastOldstyleService
+from weathergrabber.application.services.extract_daily_forecast_service import ExtractDailyForecastService
+from weathergrabber.application.services.extract_daily_forecast_oldstyle_service import ExtractDailyForecastOldstyleService
+from weathergrabber.application.services.retrieve_forecast_from_cache_service import RetrieveForecastFromCacheService
+from weathergrabber.domain.entities.air_quality_index import AirQualityIndex
+from weathergrabber.domain.entities.daily_predictions import DailyPredictions
+from weathergrabber.domain.entities.health_activities import HealthActivities
+from weathergrabber.domain.entities.hourly_predictions import HourlyPredictions
+from weathergrabber.domain.entities.search import Search
+from weathergrabber.domain.entities.forecast import Forecast
+from weathergrabber.domain.entities.today_details import TodayDetails
+from weathergrabber.application.services.save_forecast_to_cache_service import SaveForecastToCacheService
+
+class WeatherForecastUC:
+    """Use case for retrieving weather forecast data."""
+    
+    # Constants for warning messages
+    HOURLY_FORECAST_FALLBACK_MSG = "Falling back to new style hourly forecast extraction"
+    DAILY_FORECAST_FALLBACK_MSG = "Falling back to new style daily forecast extraction"
+    
+    def __init__(
+        self,
+        search_location_service: SearchLocationService,
+        read_weather_service: ReadWeatherService,
+        extract_current_conditions_service: ExtractCurrentConditionsService,
+        extract_today_details_service: ExtractTodayDetailsService,
+        extract_aqi_service: ExtractAQIService,
+        extract_health_activities_service: ExtractHealthActivitiesService,
+        extract_hourly_forecast_service: ExtractHourlyForecastService,
+        extract_hourly_forecast_oldstyle_service: ExtractHourlyForecastOldstyleService,
+        extract_daily_forecast_service: ExtractDailyForecastService,
+        extract_daily_forecast_oldstyle_service: ExtractDailyForecastOldstyleService,
+        retrieve_forecast_from_cache_service: RetrieveForecastFromCacheService,
+        save_forecast_to_cache_service: SaveForecastToCacheService
+    ):
+        self.logger = logging.getLogger(__name__)
+        self.search_location_service = search_location_service
+        self.read_weather_service = read_weather_service
+        self.extract_current_conditions_service = extract_current_conditions_service
+        self.extract_today_details_service = extract_today_details_service
+        self.extract_aqi_service = extract_aqi_service
+        self.extract_health_activities_service = extract_health_activities_service
+        self.extract_hourly_forecast_service = extract_hourly_forecast_service
+        self.extract_hourly_forecast_oldstyle_service = extract_hourly_forecast_oldstyle_service
+        self.extract_daily_forecast_service = extract_daily_forecast_service
+        self.extract_daily_forecast_oldstyle_service = extract_daily_forecast_oldstyle_service
+        self.retrieve_forecast_from_cache_service = retrieve_forecast_from_cache_service
+        self.save_forecast_to_cache_service = save_forecast_to_cache_service
+
+    def execute(self, params: Params) -> Forecast:
+        """Execute the weather forecast retrieval use case."""
+        self.logger.debug("Starting weather forecast use case")
+
+        if params.force_cache:
+            return self.retrieve_forecast_from_cache_service.execute(params)
+        
+        try:
+            location_id = self._resolve_location_id(params)
+        except ConnectionError as e:
+            return self.retrieve_forecast_from_cache_service.execute(params)
+        
+        weather_data = self.read_weather_service.execute(params.language, location_id)
+
+        current_conditions = self.extract_current_conditions_service.execute(weather_data)
+        today_details = self.extract_today_details_service.execute(weather_data)
+        air_quality_index = self.extract_aqi_service.execute(weather_data)
+        health_activities = self.extract_health_activities_service.execute(weather_data)
+        
+        hourly_predictions = self._extract_hourly_predictions(weather_data)
+        daily_predictions = self._extract_daily_predictions(weather_data)
+
+        forecast = Forecast(
+            search=Search(id=location_id, search_name=params.location.search_name),
+            current_conditions=current_conditions,
+            today_details=today_details,
+            air_quality_index=air_quality_index,
+            health_activities=health_activities,
+            hourly_predictions=hourly_predictions,
+            daily_predictions=daily_predictions
+        )
+
+        self.save_forecast_to_cache_service.execute(forecast)
+
+        self.logger.debug("Forecast data obtained successfully")
+        return forecast
+    
+    def _resolve_location_id(self, params: Params) -> str:
+        """Resolve location ID from params, searching if necessary."""
+        location_id = params.location.id
+        if not location_id:
+            location_id = self.search_location_service.execute(
+                params.location.search_name, 
+                params.language
+            )
+        return location_id
+
+    def _extract_hourly_predictions(self, weather_data) -> List[HourlyPredictions]:
+        """Extract hourly predictions with fallback mechanism."""
+        try:
+            return self.extract_hourly_forecast_oldstyle_service.execute(weather_data)
+        except ValueError:
+            self.logger.warning(self.HOURLY_FORECAST_FALLBACK_MSG)
+            return self.extract_hourly_forecast_service.execute(weather_data)
+
+    def _extract_daily_predictions(self, weather_data) -> List[DailyPredictions]:
+        """Extract daily predictions with fallback mechanism."""
+        try:
+            return self.extract_daily_forecast_oldstyle_service.execute(weather_data)
+        except ValueError:
+            self.logger.warning(self.DAILY_FORECAST_FALLBACK_MSG)
+            return self.extract_daily_forecast_service.execute(weather_data)