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

weathergrabber/application/weathergrabber_application.py

@@ -0,0 +1,92 @@
+import logging
+from time import sleep
+from weathergrabber.adapter.repository.forecast_repository import ForecastRepository
+from weathergrabber.domain.adapter.params import Params
+from weathergrabber.domain.adapter.output_enum import OutputEnum
+from weathergrabber.adapter.client.weather_api import WeatherApi
+from weathergrabber.adapter.client.weather_search_api import WeatherSearchApi
+from .services.search_location_service import SearchLocationService
+from .services.read_weather_service import ReadWeatherService
+from .services.retrieve_statistics_service import RetrieveStatisticsService
+from .services.retrieve_forecast_from_cache_service import RetrieveForecastFromCacheService
+from .services.save_forecast_to_cache_service import SaveForecastToCacheService
+from .services.extract_current_conditions_service import ExtractCurrentConditionsService
+from .services.extract_today_details_service import ExtractTodayDetailsService
+from .services.extract_aqi_service import ExtractAQIService
+from .services.extract_health_activities_service import ExtractHealthActivitiesService
+from .services.extract_hourly_forecast_service import ExtractHourlyForecastService
+from .services.extract_hourly_forecast_oldstyle_service import ExtractHourlyForecastOldstyleService
+from .services.extract_daily_forecast_service import ExtractDailyForecastService
+from .services.extract_daily_forecast_oldstyle_service import ExtractDailyForecastOldstyleService
+from .usecases.weather_forecast_uc import WeatherForecastUC
+from .usecases.statistics_uc import StatisticsUC
+
+
+class WeatherGrabberApplication:
+
+    def _beans(self):
+        self.weather_search_api = WeatherSearchApi()
+        self.weather_api = WeatherApi()
+        self.forecast_repository = ForecastRepository()
+        self.search_location_service = SearchLocationService(self.weather_search_api)
+        self.read_weather_service = ReadWeatherService(self.weather_api)
+        self.extract_current_conditions_service = ExtractCurrentConditionsService()
+        self.extract_today_details_service = ExtractTodayDetailsService()
+        self.extract_aqi_service = ExtractAQIService()
+        self.extract_health_activities_service = ExtractHealthActivitiesService()
+        self.extract_hourly_forecast_service = ExtractHourlyForecastService()
+        self.extract_hourly_forecast_oldstyle_service = ExtractHourlyForecastOldstyleService()
+        self.extract_daily_forecast_service = ExtractDailyForecastService()
+        self.extract_daily_forecast_oldstyle_service = ExtractDailyForecastOldstyleService()
+        self.retrieve_forecast_from_cache_service = RetrieveForecastFromCacheService(self.forecast_repository)
+        self.save_forecast_to_cache_service = SaveForecastToCacheService(self.forecast_repository)
+        self.retrieve_statistics_service = RetrieveStatisticsService(self.forecast_repository)
+        self.weather_forecast_uc = WeatherForecastUC(
+                self.search_location_service,
+                self.read_weather_service,
+                self.extract_current_conditions_service,
+                self.extract_today_details_service,
+                self.extract_aqi_service,
+                self.extract_health_activities_service,
+                self.extract_hourly_forecast_service,
+                self.extract_hourly_forecast_oldstyle_service,
+                self.extract_daily_forecast_service,
+                self.extract_daily_forecast_oldstyle_service,
+                self.retrieve_forecast_from_cache_service,
+                self.save_forecast_to_cache_service,
+            )
+        self.statistics_uc = StatisticsUC(self.retrieve_statistics_service)
+        
+    def _define_controller(self, params: Params):
+        if params.cache_statistics:
+            from weathergrabber.adapter.tty.statistics_tty import StatisticsTTY
+            self.controller = StatisticsTTY(self.statistics_uc)
+            
+        elif params.output_format == OutputEnum.CONSOLE:
+            from weathergrabber.adapter.tty.console_tty import ConsoleTTY
+            self.controller = ConsoleTTY(self.weather_forecast_uc)
+
+        elif params.output_format == OutputEnum.JSON:
+            from weathergrabber.adapter.tty.json_tty import JsonTTY
+            self.controller = JsonTTY(self.weather_forecast_uc)
+
+        elif params.output_format == OutputEnum.WAYBAR:
+            from weathergrabber.adapter.tty.waybar_tty import WaybarTTY
+            self.controller = WaybarTTY(self.weather_forecast_uc)
+        else:
+            self.logger.error(f"Unsupported output")
+            raise ValueError(f"Unsupported output")
+        
+    def __init__(self, params: Params):
+        self.logger = logging.getLogger(__name__)
+        self._beans()
+        self._define_controller(params)
+        self.logger.info("Starting WeatherGrabber Application")
+        if params.keep_open:
+            self.logger.info("Keep open mode enabled, the application will refresh every 5 minutes")
+            while True:
+                self.controller.execute(params)
+                sleep(1)  # Sleep for 5 minutes
+        else:
+            self.controller.execute(params)
+        self.logger.info("WeatherGrabber Application finished")

weathergrabber/cli.py

@@ -8,9 +8,11 @@ def main_cli():
     parser.add_argument("location_name", type=str, nargs='?', help="Location (city name, zip code, etc.)")
     parser.add_argument("--location-id", "-l", type=str, help="64-character-hex code for location obtained from weather.com")
     parser.add_argument("--lang", "-L", type=str, help="Language (pt-BR, fr-FR, etc.), If not set, uses the machine one.")
-    parser.add_argument("--output", "-o", type=str, choices=['console','json','waybar'], default='console', help="Output format. console, json or waybar")
+    parser.add_argument("--output", "-o", type=str, choices=['console','json','waybar','statistics'], default='console', help="Output format. console, json, waybar or statistics")
     parser.add_argument("--keep-open", "-k",action='store_true', default=False, help="Keep open and refreshing every 5 minutes instead of exiting after execution. Does only makes sense for --output=console")
     parser.add_argument("--icons", "-i", type=str, choices=['fa','emoji'], default='emoji', help="Icon set. 'fa' for Font-Awesome, or 'emoji'")
+    parser.add_argument("--force-cache", "-f", action='store_true', default=False, help="Force retrieve data from cache instead of fetching new data")
+    parser.add_argument("--cache-statistics", "-s", action='store_true', default=False, help="Show cache statistics and exit")
     parser.add_argument("--version", "-v", action='version', version=f'Weathergrabber {weathergrabber.get_version()}', help="Show version and exit")
     parser.add_argument(
         "--log",
@@ -33,5 +35,7 @@ def main_cli():
         lang=lang,
         output=args.output,
         keep_open=args.keep_open,
-        icons=args.icons
+        icons=args.icons,
+        force_cache=args.force_cache,
+        cache_statistics=args.cache_statistics,
     )

weathergrabber/core.py

@@ -1,5 +1,5 @@
 import logging
-from weathergrabber.weathergrabber_application import WeatherGrabberApplication
+from weathergrabber.application.weathergrabber_application import WeatherGrabberApplication
 from weathergrabber.domain.adapter.params import Params
 from weathergrabber.domain.adapter.output_enum import OutputEnum
 from weathergrabber.domain.adapter.icon_enum import IconEnum
@@ -9,7 +9,7 @@ logging.basicConfig(
     format="[%(levelname)s] %(message)s"
 )
 
-def main(log_level: str, location_name: str, location_id: str, lang: str, output: str, keep_open: bool, icons: str):
+def main(log_level: str, location_name: str, location_id: str, lang: str, output: str, keep_open: bool, icons: str, force_cache: bool, cache_statistics: bool):
     logging.getLogger().setLevel(log_level.upper())
 
     logging.info(f"Log level set to {log_level}")
@@ -19,13 +19,17 @@ def main(log_level: str, location_name: str, location_id: str, lang: str, output
     logging.info(f"Output: {output}")
     logging.info(f"Keep open: {keep_open}")
     logging.info(f"Icons: {icons}")
+    logging.info(f"Force cache: {force_cache}")
+    logging.info(f"Cache statistics: {cache_statistics}")
 
     params = Params(
         location=Params.Location(search_name=location_name, id=location_id),
         language=lang if lang else "en-US",
         output_format= OutputEnum(output),
         keep_open=keep_open,
-        icons=IconEnum(icons)
+        icons=IconEnum(icons),
+        force_cache=force_cache,
+        cache_statistics=cache_statistics,
     )
 
     app = WeatherGrabberApplication(params)

weathergrabber/domain/adapter/mappers/air_quality_index_mapper.py

@@ -0,0 +1,25 @@
+
+from weathergrabber.domain.entities.air_quality_index import AirQualityIndex
+
+
+def air_quality_index_to_dict(aqi: AirQualityIndex) -> dict:
+    from weathergrabber.domain.adapter.mappers.color_mapper import color_to_dict
+    return {
+        "title": aqi.title,
+        "value": aqi.value,
+        "category": aqi.category,
+        "description": aqi.description,
+        "acronym": aqi.acronym,
+        "color": color_to_dict(aqi.color) if aqi.color else None,
+    }
+
+def dict_to_air_quality_index(data: dict) -> AirQualityIndex:
+    from weathergrabber.domain.adapter.mappers.color_mapper import dict_to_color
+    return AirQualityIndex(
+        title=data["title"],
+        value=data["value"],
+        category=data["category"],
+        description=data["description"],
+        acronym=data["acronym"],
+        color=dict_to_color(data["color"]) if data.get("color") else None,
+    )

weathergrabber/domain/adapter/mappers/city_location_mapper.py

@@ -0,0 +1,15 @@
+from weathergrabber.domain.entities.city_location import CityLocation
+
+def city_location_to_dict(loc: CityLocation) -> dict:
+    return {
+        "city": loc.city,
+        "state_province": loc.state_province,
+        "country": loc.country,
+    }
+
+def dict_to_city_location(data: dict) -> CityLocation:
+    return CityLocation(
+        city=data.get("city"),
+        state_province=data.get("state_province"),
+        country=data.get("country"),
+    )

weathergrabber/domain/adapter/mappers/color_mapper.py

@@ -0,0 +1,17 @@
+from weathergrabber.domain.entities.color import Color
+
+def color_to_dict(color: Color) -> dict:
+    return {
+        "red": color.red,
+        "green": color.green,
+        "blue": color.blue,
+        "hex": color.hex,
+        "rgb": color.rgb,
+    }
+
+def dict_to_color(data: dict) -> Color:
+    return Color(
+        red=data["red"],
+        green=data["green"],
+        blue=data["blue"],
+    )

weathergrabber/domain/adapter/mappers/current_conditions_mapper.py

@@ -0,0 +1,32 @@
+from weathergrabber.domain.entities.current_conditions import CurrentConditions
+
+
+
+def current_conditions_to_dict(cc: CurrentConditions) -> dict:
+    from weathergrabber.domain.adapter.mappers.city_location_mapper import city_location_to_dict
+    from weathergrabber.domain.adapter.mappers.timestamp_mapper import timestamp_to_dict
+    from weathergrabber.domain.adapter.mappers.weather_icon_enum_mapper import weather_icon_enum_to_dict
+    from weathergrabber.domain.adapter.mappers.day_night_mapper import day_night_to_dict
+    return {
+        "location": city_location_to_dict(cc.location) if cc.location else None,
+        "timestamp": timestamp_to_dict(cc.timestamp) if cc.timestamp else None,
+        "temperature": cc.temperature,
+        "icon": weather_icon_enum_to_dict(cc.icon) if cc.icon else None,
+        "summary": cc.summary,
+        "day_night": day_night_to_dict(cc.day_night) if cc.day_night else None,
+    }
+
+def dict_to_current_conditions(data: dict) -> CurrentConditions:
+    from weathergrabber.domain.adapter.mappers.city_location_mapper import dict_to_city_location
+    from weathergrabber.domain.adapter.mappers.timestamp_mapper import dict_to_timestamp
+    from weathergrabber.domain.adapter.mappers.weather_icon_enum_mapper import dict_to_weather_icon_enum
+    from weathergrabber.domain.adapter.mappers.day_night_mapper import dict_to_day_night
+
+    return CurrentConditions(
+        location=dict_to_city_location(data["location"]) if data.get("location") else None,
+        timestamp=dict_to_timestamp(data["timestamp"]) if data.get("timestamp") else None,
+        temperature=data.get("temperature"),
+        icon=dict_to_weather_icon_enum(data["icon"]) if data.get("icon") else None,
+        summary=data.get("summary"),
+        day_night=dict_to_day_night(data["day_night"]) if data.get("day_night") else None,
+    )

weathergrabber/domain/adapter/mappers/daily_predictions_mapper.py

@@ -0,0 +1,30 @@
+from weathergrabber.domain.entities.daily_predictions import DailyPredictions
+
+
+def daily_predictions_to_dict(dp: DailyPredictions) -> dict:
+    from weathergrabber.domain.adapter.mappers.temperature_high_low_mapper import temperature_high_low_to_dict
+    from weathergrabber.domain.adapter.mappers.weather_icon_enum_mapper import weather_icon_enum_to_dict
+    from weathergrabber.domain.adapter.mappers.precipitation_mapper import precipitation_to_dict
+    from weathergrabber.domain.adapter.mappers.moon_phase_mapper import moon_phase_to_dict
+    return {
+        "title": dp.title,
+        "high_low": temperature_high_low_to_dict(dp.high_low) if dp.high_low else None,
+        "icon": weather_icon_enum_to_dict(dp.icon) if dp.icon else None,
+        "summary": dp.summary,
+        "precipitation": precipitation_to_dict(dp.precipitation) if dp.precipitation else None,
+        "moon_phase": moon_phase_to_dict(dp.moon_phase) if dp.moon_phase else None,
+    }
+
+def dict_to_daily_predictions(data: dict) -> DailyPredictions:
+    from weathergrabber.domain.adapter.mappers.temperature_high_low_mapper import dict_to_temperature_high_low
+    from weathergrabber.domain.adapter.mappers.weather_icon_enum_mapper import dict_to_weather_icon_enum
+    from weathergrabber.domain.adapter.mappers.precipitation_mapper import dict_to_precipitation
+    from weathergrabber.domain.adapter.mappers.moon_phase_mapper import dict_to_moon_phase
+    return DailyPredictions(
+        title=data.get("title"),
+        high_low=dict_to_temperature_high_low(data["high_low"]) if data.get("high_low") else None,
+        icon=dict_to_weather_icon_enum(data["icon"]) if data.get("icon") else None,
+        summary=data.get("summary"),
+        precipitation=dict_to_precipitation(data["precipitation"]) if data.get("precipitation") else None,
+        moon_phase=dict_to_moon_phase(data["moon_phase"]) if data.get("moon_phase") else None,
+    )

weathergrabber/domain/adapter/mappers/day_night_mapper.py

@@ -0,0 +1,23 @@
+from weathergrabber.domain.entities.day_night import DayNight
+
+def day_night_to_dict(dn: DayNight) -> dict:
+    def temp_to_dict(temp):
+        return {
+            "label": temp.label,
+            "value": temp.value,
+        } if temp else None
+    return {
+        "day": temp_to_dict(dn.day) if dn.day else None,
+        "night": temp_to_dict(dn.night) if dn.night else None,
+    }
+
+def dict_to_day_night(data: dict) -> DayNight:
+    def dict_to_temp(data):
+        return DayNight.Temperature(
+            label=data.get("label"),
+            value=data.get("value"),
+        ) if data else None
+    return DayNight(
+        day=dict_to_temp(data["day"]) if data.get("day") else None,
+        night=dict_to_temp(data["night"]) if data.get("night") else None,
+    )

weathergrabber/domain/adapter/mappers/forecast_mapper.py

@@ -0,0 +1,38 @@
+from weathergrabber.domain.entities.forecast import Forecast
+
+def forecast_to_dict(forecast: Forecast) -> dict:
+    from weathergrabber.domain.adapter.mappers.search_mapper import search_to_dict
+    from weathergrabber.domain.adapter.mappers.current_conditions_mapper import current_conditions_to_dict
+    from weathergrabber.domain.adapter.mappers.today_details_mapper import today_details_to_dict
+    from weathergrabber.domain.adapter.mappers.air_quality_index_mapper import air_quality_index_to_dict
+    from weathergrabber.domain.adapter.mappers.health_activities_mapper import health_activities_to_dict
+    from weathergrabber.domain.adapter.mappers.hourly_predictions_mapper import hourly_predictions_to_dict
+    from weathergrabber.domain.adapter.mappers.daily_predictions_mapper import daily_predictions_to_dict
+
+    return {
+        "search": search_to_dict(forecast.search) if forecast.search else None,
+        "current_conditions": current_conditions_to_dict(forecast.current_conditions) if forecast.current_conditions else None,
+        "today_details": today_details_to_dict(forecast.today_details) if forecast.today_details else None,
+        "air_quality_index": air_quality_index_to_dict(forecast.air_quality_index) if forecast.air_quality_index else None,
+        "health_activities": health_activities_to_dict(forecast.health_activities) if forecast.health_activities else None,
+        "hourly_predictions": [hourly_predictions_to_dict(h) for h in forecast.hourly_predictions],
+        "daily_predictions": [daily_predictions_to_dict(d) for d in forecast.daily_predictions],
+    }
+def dict_to_forecast(data: dict) -> Forecast:
+    from weathergrabber.domain.adapter.mappers.search_mapper import dict_to_search
+    from weathergrabber.domain.adapter.mappers.current_conditions_mapper import dict_to_current_conditions
+    from weathergrabber.domain.adapter.mappers.today_details_mapper import dict_to_today_details
+    from weathergrabber.domain.adapter.mappers.air_quality_index_mapper import dict_to_air_quality_index
+    from weathergrabber.domain.adapter.mappers.health_activities_mapper import dict_to_health_activities
+    from weathergrabber.domain.adapter.mappers.hourly_predictions_mapper import dict_to_hourly_predictions
+    from weathergrabber.domain.adapter.mappers.daily_predictions_mapper import dict_to_daily_predictions
+
+    return Forecast(
+        search=dict_to_search(data["search"]) if data.get("search") else None,
+        current_conditions=dict_to_current_conditions(data["current_conditions"]) if data.get("current_conditions") else None,
+        today_details=dict_to_today_details(data["today_details"]) if data.get("today_details") else None,
+        air_quality_index=dict_to_air_quality_index(data["air_quality_index"]) if data.get("air_quality_index") else None,
+        health_activities=dict_to_health_activities(data["health_activities"]) if data.get("health_activities") else None,
+        hourly_predictions=[dict_to_hourly_predictions(h) for h in data.get("hourly_predictions", [])],
+        daily_predictions=[dict_to_daily_predictions(d) for d in data.get("daily_predictions", [])],
+    )

weathergrabber/domain/adapter/mappers/health_activities_mapper.py

@@ -0,0 +1,15 @@
+from weathergrabber.domain.entities.health_activities import HealthActivities
+
+def health_activities_to_dict(ha: HealthActivities) -> dict:
+    return {
+        "category_name": ha.category_name,
+        "title": ha.title,
+        "description": ha.description,
+    }
+
+def dict_to_health_activities(data: dict) -> HealthActivities:
+    return HealthActivities(
+        category_name=data["category_name"],
+        title=data["title"],
+        description=data["description"],
+    )

weathergrabber/domain/adapter/mappers/hourly_predictions_mapper.py

@@ -0,0 +1,38 @@
+from weathergrabber.domain.entities.hourly_predictions import HourlyPredictions
+
+
+def hourly_predictions_to_dict(hp: HourlyPredictions) -> dict:
+    from weathergrabber.domain.adapter.mappers.weather_icon_enum_mapper import weather_icon_enum_to_dict
+    from weathergrabber.domain.adapter.mappers.precipitation_mapper import precipitation_to_dict
+    from weathergrabber.domain.adapter.mappers.wind_mapper import wind_to_dict
+    from weathergrabber.domain.adapter.mappers.uv_index_mapper import uv_index_to_dict
+    return {
+        "title": hp.title,
+        "temperature": hp.temperature,
+        "icon": weather_icon_enum_to_dict(hp.icon) if hp.icon else None,
+        "summary": hp.summary,
+        "precipitation": precipitation_to_dict(hp.precipitation) if hp.precipitation else None,
+        "wind": wind_to_dict(hp.wind) if hp.wind else None,
+        "feels_like": hp.feels_like,
+        "humidity": hp.humidity,
+        "uv_index": uv_index_to_dict(hp.uv_index) if hp.uv_index else None,
+        "cloud_cover": hp.cloud_cover,
+    }
+
+def dict_to_hourly_predictions(data: dict) -> HourlyPredictions:
+    from weathergrabber.domain.adapter.mappers.weather_icon_enum_mapper import dict_to_weather_icon_enum
+    from weathergrabber.domain.adapter.mappers.precipitation_mapper import dict_to_precipitation
+    from weathergrabber.domain.adapter.mappers.wind_mapper import dict_to_wind
+    from weathergrabber.domain.adapter.mappers.uv_index_mapper import dict_to_uv_index
+    return HourlyPredictions(
+        title=data["title"],
+        temperature=data["temperature"],
+        icon=dict_to_weather_icon_enum(data["icon"]) if data.get("icon") else None,
+        summary=data["summary"],
+        precipitation=dict_to_precipitation(data["precipitation"]) if data.get("precipitation") else None,
+        wind=dict_to_wind(data["wind"]) if data.get("wind") else None,
+        feels_like=data["feels_like"],
+        humidity=data["humidity"],
+        uv_index=dict_to_uv_index(data["uv_index"]) if data.get("uv_index") else None,
+        cloud_cover=data["cloud_cover"],
+    )

weathergrabber/domain/adapter/mappers/label_value_mapper.py

@@ -0,0 +1,13 @@
+from weathergrabber.domain.entities.label_value import LabelValue
+
+def label_value_to_dict(lv: LabelValue) -> dict:
+    return {
+        "label": lv.label,
+        "value": lv.value,
+    }
+
+def dict_to_label_value(data: dict) -> LabelValue:
+    return LabelValue(
+        label=data["label"],
+        value=data["value"],
+    )

weathergrabber/domain/adapter/mappers/moon_phase_mapper.py

@@ -0,0 +1,16 @@
+from weathergrabber.domain.entities.moon_phase import MoonPhase
+from weathergrabber.domain.entities.moon_phase_enum import MoonPhaseEnum
+
+def moon_phase_to_dict(mp: MoonPhase) -> dict:
+    return {
+        "icon": mp.icon.name if mp.icon else None,
+        "phase": mp.phase,
+        "label": mp.label,
+    }
+
+def dict_to_moon_phase(data: dict) -> MoonPhase:
+    return MoonPhase(
+        icon=MoonPhaseEnum.from_name(data["icon"]) if data.get("icon") else None,
+        phase=data.get("phase"),
+        label=data.get("label"),
+    )

weathergrabber/domain/adapter/mappers/precipitation_mapper.py

@@ -0,0 +1,13 @@
+from weathergrabber.domain.entities.precipitation import Precipitation
+
+def precipitation_to_dict(p: Precipitation) -> dict:
+    return {
+        "percentage": p.percentage,
+        "amount": p.amount,
+    }
+
+def dict_to_precipitation(data: dict) -> Precipitation:
+    return Precipitation(
+        percentage=data["percentage"],
+        amount=data["amount"],
+    )

weathergrabber/domain/adapter/mappers/search_mapper.py

@@ -0,0 +1,13 @@
+from weathergrabber.domain.entities.search import Search
+
+def search_to_dict(search: Search) -> dict:
+    return {
+        "id": search.id,
+        "search_name": search.search_name,
+    }
+
+def dict_to_search(data: dict) -> Search:
+    return Search(
+        id=data["id"],
+        search_name=data["search_name"],
+    )

weathergrabber/domain/adapter/mappers/statistics_mapper.py

@@ -0,0 +1,25 @@
+from weathergrabber.domain.entities.statistics import Statistics
+
+
+def statistics_to_dict(statistics: Statistics) -> dict:
+    """Convert a Statistics entity to a dictionary."""
+    data = {
+        "total_forecasts": statistics.total_forecasts,
+        "unique_locations": statistics.unique_locations,
+        "unique_search_names": statistics.unique_search_names,
+        "database_path": statistics.database_path,
+    }
+    if statistics.error:
+        data["error"] = statistics.error
+    return data
+
+
+def dict_to_statistics(data: dict) -> Statistics:
+    """Convert a dictionary to a Statistics entity."""
+    return Statistics(
+        total_forecasts=data.get("total_forecasts", 0),
+        unique_locations=data.get("unique_locations", 0),
+        unique_search_names=data.get("unique_search_names", 0),
+        database_path=data.get("database_path", ""),
+        error=data.get("error")
+    )

weathergrabber/domain/adapter/mappers/sunrise_sunset_mapper.py

@@ -0,0 +1,23 @@
+from weathergrabber.domain.entities.sunrise_sunset import SunriseSunset
+
+def sunrise_sunset_to_dict(ss: SunriseSunset) -> dict:
+    from weathergrabber.domain.adapter.mappers.weather_icon_enum_mapper import weather_icon_enum_to_dict
+    def icon_value_to_dict(iv: SunriseSunset.IconValue):
+        return {
+            "icon": weather_icon_enum_to_dict(iv.icon) if iv.icon else None,
+            "value": iv.value,
+        } if iv else None
+    return {
+        "sunrise": icon_value_to_dict(ss.sunrise) if ss.sunrise else None,
+        "sunset": icon_value_to_dict(ss.sunset) if ss.sunset else None,
+    }
+
+def dict_to_sunrise_sunset(data: dict) -> SunriseSunset:
+
+    if data is None:
+        return None
+
+    return SunriseSunset(
+        sunrise=data.get("sunrise").get("value") if data.get("sunrise") and data.get("sunrise").get("value") else None,
+        sunset=data.get("sunset").get("value") if data.get("sunset") and data.get("sunset").get("value") else None
+    )

weathergrabber/domain/adapter/mappers/temperature_high_low_mapper.py

@@ -0,0 +1,15 @@
+from weathergrabber.domain.entities.temperature_hight_low import TemperatureHighLow
+
+def temperature_high_low_to_dict(thl: TemperatureHighLow) -> dict:
+    return {
+        "high": thl.high,
+        "low": thl.low,
+        "label": thl.label,
+    }
+
+def dict_to_temperature_high_low(data: dict) -> TemperatureHighLow:
+    return TemperatureHighLow(
+        high=data.get("high"),
+        low=data.get("low"),
+        label=data.get("label"),
+    )

weathergrabber/domain/adapter/mappers/timestamp_mapper.py

@@ -0,0 +1,15 @@
+from weathergrabber.domain.entities.timestamp import Timestamp
+
+def timestamp_to_dict(ts: Timestamp) -> dict:
+    return {
+        "time": ts.time,
+        "gmt": ts.gmt,
+        "text": ts.text,
+    }
+
+def dict_to_timestamp(data: dict) -> Timestamp:
+    return Timestamp(
+        time=data.get("time"),
+        gmt=data.get("gmt"),
+        text=data.get("text"),
+    )

weathergrabber/domain/adapter/mappers/today_details_mapper.py

@@ -0,0 +1,42 @@
+
+from weathergrabber.domain.entities.today_details import TodayDetails
+
+def today_details_to_dict(td: TodayDetails) -> dict:
+    from weathergrabber.domain.adapter.mappers.label_value_mapper import label_value_to_dict
+    from weathergrabber.domain.adapter.mappers.sunrise_sunset_mapper import sunrise_sunset_to_dict
+    from weathergrabber.domain.adapter.mappers.temperature_high_low_mapper import temperature_high_low_to_dict
+    from weathergrabber.domain.adapter.mappers.uv_index_mapper import uv_index_to_dict
+    from weathergrabber.domain.adapter.mappers.moon_phase_mapper import moon_phase_to_dict
+
+    return {
+        "feelslike": label_value_to_dict(td.feelslike) if td.feelslike else None,
+        "sunrise_sunset": sunrise_sunset_to_dict(td.sunrise_sunset) if td.sunrise_sunset else None,
+        "high_low": temperature_high_low_to_dict(td.high_low) if td.high_low else None,
+        "wind": label_value_to_dict(td.wind) if td.wind else None,
+        "humidity": label_value_to_dict(td.humidity) if td.humidity else None,
+        "dew_point": label_value_to_dict(td.dew_point) if td.dew_point else None,
+        "pressure": label_value_to_dict(td.pressure) if td.pressure else None,
+        "uv_index": uv_index_to_dict(td.uv_index) if td.uv_index else None,
+        "visibility": label_value_to_dict(td.visibility) if td.visibility else None,
+        "moon_phase": moon_phase_to_dict(td.moon_phase) if td.moon_phase else None,
+    }
+
+def dict_to_today_details(data: dict) -> TodayDetails:
+    from weathergrabber.domain.adapter.mappers.label_value_mapper import dict_to_label_value
+    from weathergrabber.domain.adapter.mappers.sunrise_sunset_mapper import dict_to_sunrise_sunset
+    from weathergrabber.domain.adapter.mappers.temperature_high_low_mapper import dict_to_temperature_high_low
+    from weathergrabber.domain.adapter.mappers.uv_index_mapper import dict_to_uv_index
+    from weathergrabber.domain.adapter.mappers.moon_phase_mapper import dict_to_moon_phase
+
+    return TodayDetails(
+        feelslike=dict_to_label_value(data["feelslike"]) if data.get("feelslike") else None,
+        sunrise_sunset=dict_to_sunrise_sunset(data["sunrise_sunset"]) if data.get("sunrise_sunset") else None,
+        high_low=dict_to_temperature_high_low(data["high_low"]) if data.get("high_low") else None,
+        wind=dict_to_label_value(data["wind"]) if data.get("wind") else None,
+        humidity=dict_to_label_value(data["humidity"]) if data.get("humidity") else None,
+        dew_point=dict_to_label_value(data["dew_point"]) if data.get("dew_point") else None,
+        pressure=dict_to_label_value(data["pressure"]) if data.get("pressure") else None,
+        uv_index=dict_to_uv_index(data["uv_index"]) if data.get("uv_index") else None,
+        visibility=dict_to_label_value(data["visibility"]) if data.get("visibility") else None,
+        moon_phase=dict_to_moon_phase(data["moon_phase"]) if data.get("moon_phase") else None,
+    )

weathergrabber/domain/adapter/mappers/uv_index_mapper.py

@@ -0,0 +1,17 @@
+from weathergrabber.domain.entities.uv_index import UVIndex
+
+def uv_index_to_dict(uv: UVIndex) -> dict:
+    return {
+        "string_value": uv.string_value,
+        "index": uv.index,
+        "of": uv.of,
+        "label": uv.label,
+    }
+
+def dict_to_uv_index(data: dict) -> UVIndex:
+    return UVIndex(
+        string_value=data.get("string_value"),
+        index=data.get("index"),
+        of=data.get("of"),
+        label=data.get("label"),
+    )

weathergrabber/domain/adapter/mappers/weather_icon_enum_mapper.py

@@ -0,0 +1,11 @@
+from weathergrabber.domain.entities.weather_icon_enum import WeatherIconEnum
+
+def weather_icon_enum_to_dict(icon: WeatherIconEnum) -> dict:
+    return {
+        "name": icon.name,
+        "fa_icon": icon.fa_icon,
+        "emoji_icon": icon.emoji_icon,
+    }
+
+def dict_to_weather_icon_enum(data: dict) -> WeatherIconEnum:
+    return WeatherIconEnum.from_name(data.get("name"))

weathergrabber/domain/adapter/mappers/wind_mapper.py

@@ -0,0 +1,16 @@
+def wind_to_dict(wind):
+    if wind is None:
+        return None
+    return {
+        "direction": wind.direction,
+        "speed": wind.speed
+    }
+
+def dict_to_wind(data: dict):
+    if data is None:
+        return None
+    from weathergrabber.domain.entities.wind import Wind
+    return Wind(
+        direction=data["direction"],
+        speed=data["speed"]
+    )

weathergrabber/domain/adapter/output_enum.py

@@ -3,4 +3,4 @@ from enum import StrEnum
 class OutputEnum(StrEnum):
     CONSOLE = "console"
     JSON = "json"
-    WAYBAR = "waybar"
+    WAYBAR = "waybar"