weathergrabber 0.0.1__py3-none-any.whl

weathergrabber/adapter/client/weather_api.py

@@ -0,0 +1,27 @@
+from pyquery import PyQuery
+from urllib.error import HTTPError
+import logging
+
+class WeatherApi:
+
+    def __init__(self):
+        self.logger = logging.getLogger(__name__)
+        pass
+
+    def get_weather(self,language: str, location: str) -> PyQuery:
+        url = f"https://weather.com/{language}/weather/today/l/{location}"
+
+        if location == None:
+            url = f"https://weather.com/{language}/weather/today"       
+        elif len(location) < 64 :
+            raise ValueError("Invalid location")
+        
+        if language == None:
+            raise ValueError("language must be specified")
+        
+        try:
+            self.logger.debug(f"Fetching weather data from URL: %s.", url)
+            return PyQuery(url=url)
+        except HTTPError as e:
+            self.logger.error("HTTP '%s' error when fetching weather data from URL: '%s'.", e.code, url)
+            raise ValueError(f"HTTP error {e.code} when fetching weather data.")

weathergrabber/adapter/client/weather_search_api.py

@@ -0,0 +1,50 @@
+import logging
+import requests
+
+class WeatherSearchApi:
+    def __init__(self):
+        self.logger = logging.getLogger(__name__)
+        self.cache = {}
+
+    def search(self, location_name: str, lang: str = 'en-US'):
+
+        if not location_name or len(location_name) < 1:
+            raise ValueError("Location name must be provided and cannot be empty.")
+        if len(location_name) > 100:
+            raise ValueError("Location name is too long.")
+        
+        key = (location_name, lang)
+        
+        if key in self.cache:
+            self.logger.debug("Cache hit for location '%s' and language '%s'.", location_name, lang)
+            return self.cache[key]
+
+        url = "https://weather.com/api/v1/p/redux-dal"
+        headers = {"content-type": "application/json"}
+
+        payload = [
+            {
+                "name": "getSunV3LocationSearchUrlConfig",
+                "params": {
+                    "query": location_name,
+                    "language": lang,
+                    "locationType": "locale"
+                }
+            }
+        ]
+
+        self.logger.debug("Sending request to Weather Search API '%s' for location '%s' with language '%s'...", url, location_name, lang)
+
+        resp = requests.post(url, json=payload, headers=headers)
+
+        if resp.status_code != 200:
+            self.logger.error("HTTP '%s' error when searching for location '%s' with language '%s'.", resp.status_code, location_name, lang)
+            raise ValueError(f"HTTP error {resp.status_code} when searching for location.")
+        
+        self.logger.debug("Received successful response from Weather Search API.")
+
+        data = resp.json()
+
+        self.cache[key] = data
+
+        return data

weathergrabber/adapter/tty/console_tty.py

@@ -0,0 +1,102 @@
+from weathergrabber.usecase.use_case import UseCase
+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
+import logging
+
+class ConsoleTTY:
+
+    def __init__(self, use_case: UseCase):
+        self.logger = logging.getLogger(__name__)
+        self.use_case = use_case
+        pass
+
+    def execute(self, params: Params) -> None:
+        self.logger.info("Executing Console output")
+
+        is_fa = params.icons == IconEnum.FA
+
+        forecast = self.use_case.execute(params)
+
+        rain_icon = WeatherIconEnum.RAIN.fa_icon if is_fa else WeatherIconEnum.RAIN.emoji_icon
+
+        city = forecast.current_conditions.location.city
+        state_province = forecast.current_conditions.location.state_province
+        icon = forecast.current_conditions.icon.fa_icon if is_fa else forecast.current_conditions.icon.emoji_icon
+        temperature = forecast.current_conditions.temperature
+        
+        day_temp_label = WeatherIconEnum.DAY.fa_icon if is_fa else WeatherIconEnum.DAY.emoji_icon
+        day_temp_value = forecast.current_conditions.day_night.day.value
+        night_temp_label = WeatherIconEnum.NIGHT.fa_icon if is_fa else WeatherIconEnum.NIGHT.emoji_icon
+        night_temp_value = forecast.current_conditions.day_night.night.value
+        
+        moon_icon = forecast.today_details.moon_phase.icon.fa_icon if is_fa else forecast.today_details.moon_phase.icon.emoji_icon
+        moon_phase = forecast.today_details.moon_phase.phase
+        summary = forecast.current_conditions.summary
+
+        feelslike_icon = WeatherIconEnum.FEEL.fa_icon if is_fa else WeatherIconEnum.FEEL.emoji_icon
+        feelslike = forecast.today_details.feelslike.value
+
+        sunrise_icon = forecast.today_details.sunrise_sunset.sunrise.icon.fa_icon if is_fa else forecast.today_details.sunrise_sunset.sunrise.icon.emoji_icon
+        sunset_icon = forecast.today_details.sunrise_sunset.sunset.icon.fa_icon if is_fa else forecast.today_details.sunrise_sunset.sunset.icon.emoji_icon
+
+        sunrise_value = forecast.today_details.sunrise_sunset.sunrise.value
+        sunset_value = forecast.today_details.sunrise_sunset.sunset.value
+
+        wind_icon = WeatherIconEnum.WIND.fa_icon if is_fa else WeatherIconEnum.WIND.emoji_icon
+        wind = forecast.today_details.wind.value
+
+        humidity_icon = WeatherIconEnum.HUMIDITY.fa_icon if is_fa else WeatherIconEnum.HUMIDITY.emoji_icon
+        humidity = forecast.today_details.humidity.value
+
+        pressure = forecast.today_details.pressure
+
+        uv_index = forecast.today_details.uv_index
+
+        visibility_icon = WeatherIconEnum.VISIBILITY.fa_icon if is_fa else WeatherIconEnum.VISIBILITY.emoji_icon
+        visibility = forecast.today_details.visibility.value
+
+        r, g, b = forecast.air_quality_index.color.red, forecast.air_quality_index.color.green, forecast.air_quality_index.color.blue
+        aqi_category = f"\033[38;2;{r};{g};{b}m{forecast.air_quality_index.category}\033[0m"
+        aqi_acronym = forecast.air_quality_index.acronym
+        aqi_value = forecast.air_quality_index.value
+
+        hourly_predictions = [
+            f"{h.title}\t{h.temperature}\t{h.icon.fa_icon if is_fa else h.icon.emoji_icon}\t{rain_icon  if h.precipitation.percentage else ''}  {h.precipitation.percentage}"
+            for h in forecast.hourly_predictions
+        ]
+        daily_predictions = [
+            f"{d.title}\t{d.high_low}\t{d.icon.fa_icon if is_fa else d.icon.emoji_icon}\t{rain_icon}  {d.precipitation.percentage}"
+            for d in forecast.daily_predictions
+        ]
+
+        print_value = (
+            "\n"
+            f"{city}, {state_province}\n"
+            "\n"
+            f"{icon}       {temperature}\n"
+            "\n"
+            f"{summary}\n"
+            f"{day_temp_label} {day_temp_value}/{night_temp_label} {night_temp_value}\t{feelslike_icon} {feelslike}\n"
+            "\n"
+            f"{sunrise_icon} {sunrise_value} • {sunset_icon} {sunset_value}\n"
+            "\n"
+            f"{moon_icon} {moon_phase}\n"
+            "\n"
+            f"{wind_icon} {wind}\t {uv_index}\n"
+            f"{humidity_icon} {humidity}\t\t {pressure}\n"
+            f"{visibility_icon} {visibility}\t {aqi_acronym} {aqi_category} {aqi_value}\n"
+            "\n"
+            f"{'\n'.join(hourly_predictions)}\n"
+            "\n"
+            f"{'\n'.join(daily_predictions)}\n"
+            "\n"
+            f"{forecast.current_conditions.timestamp}"
+        )
+        
+        print(print_value)
+        if(params.keep_open):
+            lines_count = print_value.count("\n") + 1
+            ret_prev_line = f"\033[{lines_count}A"              
+            print(ret_prev_line, end='')  # Move cursor back to the beginning for overwriting, the application is responsable for executing again

weathergrabber/adapter/tty/json_tty.py

@@ -0,0 +1,19 @@
+from weathergrabber.usecase.use_case import UseCase
+from weathergrabber.domain.adapter.params import Params
+from weathergrabber.domain.adapter.mapper.forecast_mapper import forecast_to_dict
+import logging
+import json
+
+class JsonTTY:
+
+    def __init__(self, use_case: UseCase):
+        self.logger = logging.getLogger(__name__)
+        self.use_case = use_case
+        pass
+
+    def execute(self, params: Params) -> None:
+        self.logger.info("Executing JSON output")
+        forecast = self.use_case.execute(params)
+        output: dict = forecast_to_dict(forecast)
+        output_json = json.dumps(output, indent=4)
+        print(output_json)

weathergrabber/adapter/tty/waybar_tty.py

@@ -0,0 +1,110 @@
+from weathergrabber.usecase.use_case import UseCase
+from weathergrabber.domain.adapter.params import Params
+from weathergrabber.domain.adapter.icon_enum import IconEnum
+from weathergrabber.domain.weather_icon_enum import WeatherIconEnum
+import logging
+import json
+
+class WaybarTTY:
+
+    def __init__(self, use_case: UseCase):
+        self.logger = logging.getLogger(__name__)
+        self.use_case = use_case
+        pass
+
+    def execute(self, params: Params) -> None:
+        self.logger.info("Executing Waybar output")
+
+        is_fa = params.icons == IconEnum.FA
+        forecast = self.use_case.execute(params)
+
+        # Forecast icon and temperature
+        icon = forecast.current_conditions.icon.fa_icon if is_fa else forecast.current_conditions.icon.emoji_icon
+        temperature = forecast.current_conditions.temperature
+
+        # City and state/province
+        city = forecast.current_conditions.location.city
+        state_province = forecast.current_conditions.location.state_province
+
+        # Summary
+        summary = forecast.current_conditions.summary
+
+        #Day/Night temperatures
+        day_temp_label = WeatherIconEnum.DAY.fa_icon if is_fa else WeatherIconEnum.DAY.emoji_icon
+        day_temp_value = forecast.current_conditions.day_night.day.value
+        night_temp_label = WeatherIconEnum.NIGHT.fa_icon if is_fa else WeatherIconEnum.NIGHT.emoji_icon
+        night_temp_value = forecast.current_conditions.day_night.night.value
+
+        # Feels like
+        feelslike_icon = WeatherIconEnum.FEEL.fa_icon if is_fa else WeatherIconEnum.FEEL.emoji_icon
+        feelslike = forecast.today_details.feelslike.value
+
+        # Sunrise and Sunset
+        sunrise_icon = forecast.today_details.sunrise_sunset.sunrise.icon.fa_icon if is_fa else forecast.today_details.sunrise_sunset.sunrise.icon.emoji_icon
+        sunrise_value = forecast.today_details.sunrise_sunset.sunrise.value
+        sunset_icon = forecast.today_details.sunrise_sunset.sunset.icon.fa_icon if is_fa else forecast.today_details.sunrise_sunset.sunset.icon.emoji_icon
+        sunset_value = forecast.today_details.sunrise_sunset.sunset.value
+
+        # Moon phase
+        moon_icon = forecast.today_details.moon_phase.icon.fa_icon if is_fa else forecast.today_details.moon_phase.icon.emoji_icon
+        moon_phase = forecast.today_details.moon_phase.phase
+
+        #Summary data
+        wind_icon = WeatherIconEnum.WIND.fa_icon if is_fa else WeatherIconEnum.WIND.emoji_icon
+        wind = forecast.today_details.wind.value
+        uv_index = forecast.today_details.uv_index
+        humidity_icon = WeatherIconEnum.HUMIDITY.fa_icon if is_fa else WeatherIconEnum.HUMIDITY.emoji_icon
+        humidity = forecast.today_details.humidity.value
+        pressure = forecast.today_details.pressure
+        visibility_icon = WeatherIconEnum.VISIBILITY.fa_icon if is_fa else WeatherIconEnum.VISIBILITY.emoji_icon
+        visibility = forecast.today_details.visibility.value
+
+        #Air quality index
+        color = forecast.air_quality_index.color.hex
+        aqi_category = f" <span color=\"{color}\">{forecast.air_quality_index.category}</span>"
+        aqi_acronym = forecast.air_quality_index.acronym
+        aqi_value = forecast.air_quality_index.value
+
+        # Hourly predictions and daily predictions
+        rain_icon = WeatherIconEnum.RAIN.fa_icon if is_fa else WeatherIconEnum.RAIN.emoji_icon
+        hourly_predictions = [
+            f"{h.title}{'\t' if len(h.title) < 5 else ''}\t{h.temperature}\t\t{h.icon.fa_icon if is_fa else h.icon.emoji_icon}\t{rain_icon  if h.precipitation.percentage else ''}  {h.precipitation.percentage}"
+            for h in forecast.hourly_predictions
+        ]
+        daily_predictions = [
+            f"{d.title}{'\t' if len(d.title) < 5 else ''}\t{d.high_low.high}/<span size='small'>{d.high_low.low}</span>\t{d.icon.fa_icon if is_fa else d.icon.emoji_icon}\t{rain_icon}  {d.precipitation.percentage}"
+            for d in forecast.daily_predictions
+        ]
+
+        tooltip = (
+            f"{city}, {state_province}\n"
+            "\n"
+            f"<span size='xx-large'>{icon}\t\t{temperature}</span>\n"
+            "\n"
+            f"{summary}\n"
+            "\n"
+            f"{day_temp_label} {day_temp_value} {night_temp_label} {night_temp_value}\t\t{feelslike_icon} {feelslike}\n"
+            "\n"
+            f"{sunrise_icon} {sunrise_value} • {sunset_icon} {sunset_value}\n"
+            "\n"
+            f"{moon_icon} {moon_phase}\n"
+            "\n"
+            f"{wind_icon} {wind}\t {uv_index}\n"
+            f"{humidity_icon} {humidity}\t\t {pressure}\n"
+            f"{visibility_icon} {visibility}\t {aqi_acronym} {aqi_category} {aqi_value}\n"
+            "\n"
+            f"{'\n'.join(hourly_predictions)}\n"
+            "\n"
+            f"{'\n'.join(daily_predictions)}\n"
+            "\n"
+            f"<span size='small' style='italic' weight='light' gravity='east'>{forecast.current_conditions.timestamp}</span>"
+        )
+
+        waybar_output = {
+            "text" : f"{icon} {temperature}",
+            "alt": f"{summary}",
+            "tooltip": f"{tooltip}",
+            "class": f"{forecast.current_conditions.icon.name.lower() if forecast.current_conditions.icon else 'na'}",
+        }
+
+        print(json.dumps(waybar_output))

weathergrabber/cli.py

@@ -0,0 +1,37 @@
+import argparse
+import os
+from .core import main
+
+def main_cli():
+    ## Get current locale, or use the default one
+    parser = argparse.ArgumentParser(description="Weather forecast grabber from weather.com")
+    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("--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(
+        "--log",
+        default="critical",
+        choices=["debug", "info", "warning", "error", "critical", "DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"],
+        help="Set the logging level (default: CRITICAL)"
+    )
+    args = parser.parse_args()
+
+    # Check for language and location from environment variables if not provided as arguments
+    lang = args.lang if args.lang else os.getenv("LANG","en_US.UTF-8").split(".")[0].replace("_","-")
+    location_id = args.location_id if args.location_id else os.getenv('WEATHER_LOCATION_ID') if not args.location_name else args.location_name
+
+    main(
+        log_level=args.log,
+        location_name = args.location_name,
+        location_id = location_id,
+        lang=lang,
+        output=args.output,
+        keep_open=args.keep_open,
+        icons=args.icons
+    )
+
+if __name__ == "__main__":
+    main_cli()

weathergrabber/core.py

@@ -0,0 +1,31 @@
+import logging
+from weathergrabber.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
+
+logging.basicConfig(
+    level=logging.INFO,
+    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):
+    logging.getLogger().setLevel(log_level.upper())
+
+    logging.info(f"Log level set to {log_level}")
+    logging.info(f"Location name: {location_name}")
+    logging.info(f"Location id: {location_id}")
+    logging.info(f"Language: {lang}")
+    logging.info(f"Output: {output}")
+    logging.info(f"Keep open: {keep_open}")
+    logging.info(f"Icons: {icons}")
+
+    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)
+    )
+
+    app = WeatherGrabberApplication(params)

weathergrabber/domain/adapter/icon_enum.py

@@ -0,0 +1,5 @@
+from enum import StrEnum
+
+class IconEnum(StrEnum):
+    FA = "fa"
+    EMOJI = "emoji"

weathergrabber/domain/adapter/mapper/air_quality_index_mapper.py

@@ -0,0 +1,13 @@
+
+from weathergrabber.domain.air_quality_index import AirQualityIndex
+from weathergrabber.domain.adapter.mapper.color_mapper import color_to_dict
+
+def air_quality_index_to_dict(aqi: AirQualityIndex) -> 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,
+    }

weathergrabber/domain/adapter/mapper/city_location_mapper.py

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

weathergrabber/domain/adapter/mapper/color_mapper.py

@@ -0,0 +1,10 @@
+from weathergrabber.domain.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,
+    }

weathergrabber/domain/adapter/mapper/current_conditions_mapper.py

@@ -0,0 +1,16 @@
+
+from weathergrabber.domain.current_conditions import CurrentConditions
+from weathergrabber.domain.adapter.mapper.city_location_mapper import city_location_to_dict
+from weathergrabber.domain.adapter.mapper.timestamp_mapper import timestamp_to_dict
+from weathergrabber.domain.adapter.mapper.weather_icon_enum_mapper import weather_icon_enum_to_dict
+from weathergrabber.domain.adapter.mapper.day_night_mapper import day_night_to_dict
+
+def current_conditions_to_dict(cc: CurrentConditions) -> 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,
+    }

weathergrabber/domain/adapter/mapper/daily_predictions_mapper.py

@@ -0,0 +1,15 @@
+from weathergrabber.domain.daily_predictions import DailyPredictions
+from weathergrabber.domain.adapter.mapper.temperature_high_low_mapper import temperature_high_low_to_dict
+from weathergrabber.domain.adapter.mapper.weather_icon_enum_mapper import weather_icon_enum_to_dict
+from weathergrabber.domain.adapter.mapper.precipitation_mapper import precipitation_to_dict
+from weathergrabber.domain.adapter.mapper.moon_phase_mapper import moon_phase_to_dict
+
+def daily_predictions_to_dict(dp: DailyPredictions) -> 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,
+    }

weathergrabber/domain/adapter/mapper/day_night_mapper.py

@@ -0,0 +1,12 @@
+from weathergrabber.domain.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,
+    }

weathergrabber/domain/adapter/mapper/forecast_mapper.py

@@ -0,0 +1,20 @@
+from weathergrabber.domain.forecast import Forecast
+
+from weathergrabber.domain.adapter.mapper.search_mapper import search_to_dict
+from weathergrabber.domain.adapter.mapper.current_conditions_mapper import current_conditions_to_dict
+from weathergrabber.domain.adapter.mapper.today_details_mapper import today_details_to_dict
+from weathergrabber.domain.adapter.mapper.air_quality_index_mapper import air_quality_index_to_dict
+from weathergrabber.domain.adapter.mapper.health_activities_mapper import health_activities_to_dict
+from weathergrabber.domain.adapter.mapper.hourly_predictions_mapper import hourly_predictions_to_dict
+from weathergrabber.domain.adapter.mapper.daily_predictions_mapper import daily_predictions_to_dict
+
+def forecast_to_dict(forecast: Forecast) -> 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],
+    }

weathergrabber/domain/adapter/mapper/health_activities_mapper.py

@@ -0,0 +1,8 @@
+from weathergrabber.domain.health_activities import HealthActivities
+
+def health_activities_to_dict(ha: HealthActivities) -> dict:
+    return {
+        "category_name": ha.category_name,
+        "title": ha.title,
+        "description": ha.description,
+    }

weathergrabber/domain/adapter/mapper/hourly_predictions_mapper.py

@@ -0,0 +1,19 @@
+from weathergrabber.domain.hourly_predictions import HourlyPredictions
+from weathergrabber.domain.adapter.mapper.weather_icon_enum_mapper import weather_icon_enum_to_dict
+from weathergrabber.domain.adapter.mapper.precipitation_mapper import precipitation_to_dict
+from weathergrabber.domain.adapter.mapper.wind_mapper import wind_to_dict
+from weathergrabber.domain.adapter.mapper.uv_index_mapper import uv_index_to_dict
+
+def hourly_predictions_to_dict(hp: HourlyPredictions) -> 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,
+    }

weathergrabber/domain/adapter/mapper/label_value_mapper.py

@@ -0,0 +1,7 @@
+from weathergrabber.domain.label_value import LabelValue
+
+def label_value_to_dict(lv: LabelValue) -> dict:
+    return {
+        "label": lv.label,
+        "value": lv.value,
+    }

weathergrabber/domain/adapter/mapper/moon_phase_mapper.py

@@ -0,0 +1,9 @@
+from weathergrabber.domain.moon_phase import MoonPhase
+from weathergrabber.domain.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,
+    }

weathergrabber/domain/adapter/mapper/precipitation_mapper.py

@@ -0,0 +1,7 @@
+from weathergrabber.domain.precipitation import Precipitation
+
+def precipitation_to_dict(p: Precipitation) -> dict:
+    return {
+        "percentage": p.percentage,
+        "amount": p.amount,
+    }

weathergrabber/domain/adapter/mapper/search_mapper.py

@@ -0,0 +1,7 @@
+from weathergrabber.domain.search import Search
+
+def search_to_dict(search: Search) -> dict:
+    return {
+        "id": search.id,
+        "search_name": search.search_name,
+    }

weathergrabber/domain/adapter/mapper/sunrise_sunset_mapper.py

@@ -0,0 +1,13 @@
+from weathergrabber.domain.sunrise_sunset import SunriseSunset
+from weathergrabber.domain.adapter.mapper.weather_icon_enum_mapper import weather_icon_enum_to_dict
+
+def sunrise_sunset_to_dict(ss: SunriseSunset) -> dict:
+    def icon_value_to_dict(iv):
+        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,
+    }

weathergrabber/domain/adapter/mapper/temperature_high_low_mapper.py

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

weathergrabber/domain/adapter/mapper/timestamp_mapper.py

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

weathergrabber/domain/adapter/mapper/today_details_mapper.py

@@ -0,0 +1,21 @@
+
+from weathergrabber.domain.today_details import TodayDetails
+from weathergrabber.domain.adapter.mapper.label_value_mapper import label_value_to_dict
+from weathergrabber.domain.adapter.mapper.sunrise_sunset_mapper import sunrise_sunset_to_dict
+from weathergrabber.domain.adapter.mapper.temperature_high_low_mapper import temperature_high_low_to_dict
+from weathergrabber.domain.adapter.mapper.uv_index_mapper import uv_index_to_dict
+from weathergrabber.domain.adapter.mapper.moon_phase_mapper import moon_phase_to_dict
+
+def today_details_to_dict(td: TodayDetails) -> 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,
+    }

weathergrabber/domain/adapter/mapper/uv_index_mapper.py

@@ -0,0 +1,9 @@
+from weathergrabber.domain.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,
+    }

weathergrabber/domain/adapter/mapper/weather_icon_enum_mapper.py

@@ -0,0 +1,8 @@
+from weathergrabber.domain.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,
+    }

weathergrabber/domain/adapter/mapper/wind_mapper.py

@@ -0,0 +1,7 @@
+def wind_to_dict(wind):
+    if wind is None:
+        return None
+    return {
+        "direction": wind.direction,
+        "speed": wind.speed
+    }