WIP: refactor

main.py

@@ -20,12 +20,14 @@ POLLEN_MAX_INDEX = 12.0
 POLLEN_PERCENTAGE_SCALE = 100
 HTTP_TIMEOUT = 10.0
 
+
 class WeatherCondition(TypedDict):
     description: str
     main: str
     id: int
     icon: str
 
+
 class CurrentWeather(TypedDict):
     dt: int
     sunrise: int
@@ -36,10 +38,12 @@ class CurrentWeather(TypedDict):
     humidity: int
     weather: list[WeatherCondition]
 
+
 class DailyTemperature(TypedDict):
     min: float
     max: float
 
+
 class DailyWeather(TypedDict):
     dt: int
     sunrise: int
@@ -49,17 +53,21 @@ class DailyWeather(TypedDict):
     pressure: int
     weather: list[WeatherCondition]
 
+
 class WeatherApiResponse(TypedDict):
     current: CurrentWeather
     daily: list[DailyWeather]
 
+
 class PollenLocation(TypedDict):
     periods: list[dict[str, Union[str, int, float]]]
 
+
 class PollenApiResponse(TypedDict):
     ForecastDate: str
     Location: PollenLocation
 
+
 class WeatherPeriod(TypedDict):
     low: int
     high: int
@@ -70,10 +78,12 @@ class WeatherPeriod(TypedDict):
     pressure: int
     period: str
 
+
 class PollenPeriod(TypedDict):
     index: int
     period: str
 
+
 class WeatherReport(TypedDict):
     forecast_date: str
     current_temp: int
@@ -85,10 +95,12 @@ class WeatherReport(TypedDict):
     current_desc: str
     periods: list[WeatherPeriod]
 
+
 class PollenReport(TypedDict):
     forecast_date: str
     periods: list[PollenPeriod]
 
+
 class CurrentWeatherData(TypedDict):
     temp: int
     feels_like: int
@@ -96,6 +108,7 @@ class CurrentWeatherData(TypedDict):
     humidity: int
     pressure: int
 
+
 class DailyData(TypedDict, total=False):
     pollen: int
     low: int
@@ -106,12 +119,14 @@ class DailyData(TypedDict, total=False):
     sunset: str
     pressure: int
 
+
 class FinalReport(TypedDict):
     fetched_at: str
     current: CurrentWeatherData
     today: DailyData
     tomorrow: DailyData
 
+
 app = FastAPI(title="TRMNL Weather & Pollen Report")
 
 weather_cache: TTLCache = TTLCache(maxsize=CACHE_MAX_SIZE, ttl=CACHE_TTL_SECONDS)
@@ -158,7 +173,9 @@ class DateTimeFormatter:
     @staticmethod
     def format_datetime(dt: datetime) -> str:
         """Format datetime as date and time string."""
-        return f"{DateTimeFormatter.format_date(dt)} {DateTimeFormatter.format_time(dt)}"
+        return (
+            f"{DateTimeFormatter.format_date(dt)} {DateTimeFormatter.format_time(dt)}"
+        )
 
     @staticmethod
     def relative_day_to_date(relative_day: str) -> str:
@@ -234,18 +251,27 @@ class PollenData:
             if period_type in ["today", "tomorrow"]:
                 index_value = float(period.get("Index", 0))
                 # Convert pollen index to percentage scale (0-100)
-                pollen_percentage = int(index_value / POLLEN_MAX_INDEX * POLLEN_PERCENTAGE_SCALE)
+                pollen_percentage = int(
+                    index_value / POLLEN_MAX_INDEX * POLLEN_PERCENTAGE_SCALE
+                )
 
-                valid_periods.append(PollenPeriod({
+                valid_periods.append(
+                    PollenPeriod(
+                        {
                             "index": pollen_percentage,
-                    "period": DateTimeFormatter.relative_day_to_date(period_type),
+                            "period": DateTimeFormatter.relative_day_to_date(
-                }))
+                                period_type
+                            ),
+                        }
+                    )
+                )
 
         return valid_periods
 
 
 def error_handler(func):
     """Decorator to handle exceptions in async functions."""
+
     @functools.wraps(func)
     async def wrapper(*args, **kwargs):
         try:
@@ -253,6 +279,7 @@ def error_handler(func):
         except Exception as e:
             logger.exception(f"Error in {func.__name__}: {e}")
             return []
+
     return wrapper
 
 
@@ -261,7 +288,9 @@ class WeatherService:
 
     @staticmethod
     @error_handler
-    async def fetch_weather(latitude: str, longitude: str, api_key: str) -> list[WeatherReport]:
+    async def fetch_weather(
+        latitude: str, longitude: str, api_key: str
+    ) -> list[WeatherReport]:
         """Fetch weather data from OpenWeatherMap API."""
         cache_key = (latitude, longitude)
 
@@ -292,36 +321,50 @@ class WeatherService:
 
         current_dt = datetime.fromtimestamp(current["dt"])
 
-        return [WeatherReport({
+        return [
+            WeatherReport(
+                {
                     "forecast_date": DateTimeFormatter.format_datetime(current_dt),
                     "current_temp": int(round(current["temp"])),
                     "current_feels_like": int(round(current["feels_like"])),
                     "current_humidity": current["humidity"],
-            "sunrise": DateTimeFormatter.format_time(datetime.fromtimestamp(current["sunrise"])),
+                    "sunrise": DateTimeFormatter.format_time(
-            "sunset": DateTimeFormatter.format_time(datetime.fromtimestamp(current["sunset"])),
+                        datetime.fromtimestamp(current["sunrise"])
+                    ),
+                    "sunset": DateTimeFormatter.format_time(
+                        datetime.fromtimestamp(current["sunset"])
+                    ),
                     "current_pressure": current["pressure"],
                     "current_desc": current["weather"][0]["description"],
                     "periods": [
                         WeatherService._format_daily_period(period)
                         for period in daily_periods
                     ],
-        })]
+                }
+            )
+        ]
 
     @staticmethod
     def _format_daily_period(period: DailyWeather) -> WeatherPeriod:
         """Format a single daily weather period."""
         period_dt = datetime.fromtimestamp(period["dt"])
 
-        return WeatherPeriod({
+        return WeatherPeriod(
+            {
                 "low": int(round(period["temp"]["min"])),
                 "high": int(round(period["temp"]["max"])),
                 "desc": period["weather"][0]["description"],
                 "humidity": period["humidity"],
-            "sunrise": DateTimeFormatter.format_time(datetime.fromtimestamp(period["sunrise"])),
+                "sunrise": DateTimeFormatter.format_time(
-            "sunset": DateTimeFormatter.format_time(datetime.fromtimestamp(period["sunset"])),
+                    datetime.fromtimestamp(period["sunrise"])
+                ),
+                "sunset": DateTimeFormatter.format_time(
+                    datetime.fromtimestamp(period["sunset"])
+                ),
                 "pressure": period["pressure"],
                 "period": DateTimeFormatter.format_date(period_dt),
-        })
+            }
+        )
 
 
 class PollenService:
@@ -352,10 +395,14 @@ class PollenService:
             raw_data = response.json()
 
             pollen_data = PollenData(raw_data)
-            result = [PollenReport({
+            result = [
+                PollenReport(
+                    {
                         "forecast_date": pollen_data.forecast_date,
                         "periods": pollen_data.periods,
-            })]
+                    }
+                )
+            ]
 
             pollen_cache[zip_code] = result
             return result
@@ -368,7 +415,7 @@ class DataAggregator:
     def build_daily_data(
         date: str,
         pollen_periods: dict[str, PollenPeriod],
-        weather_periods: dict[str, WeatherPeriod]
+        weather_periods: dict[str, WeatherPeriod],
     ) -> DailyData:
         """Build daily data combining weather and pollen information."""
         daily_data: DailyData = {}
@@ -378,7 +425,8 @@ class DataAggregator:
 
         if date in weather_periods:
             weather_data = weather_periods[date]
-            daily_data.update({
+            daily_data.update(
+                {
                     "low": weather_data["low"],
                     "high": weather_data["high"],
                     "desc": weather_data["desc"],
@@ -386,46 +434,46 @@ class DataAggregator:
                     "sunrise": weather_data["sunrise"],
                     "sunset": weather_data["sunset"],
                     "pressure": weather_data["pressure"],
-            })
+                }
+            )
 
         return daily_data
 
     @staticmethod
     def create_periods_lookup(
-        pollen_data: list[PollenReport],
+        pollen_data: list[PollenReport], weather_data: list[WeatherReport]
-        weather_data: list[WeatherReport]
     ) -> tuple[dict[str, PollenPeriod], dict[str, WeatherPeriod], CurrentWeatherData]:
         """Create lookup dictionaries for pollen and weather periods."""
         pollen_periods: dict[str, PollenPeriod] = {}
         weather_periods: dict[str, WeatherPeriod] = {}
 
         if pollen_data and pollen_data[0].get("periods"):
-            pollen_periods = {
+            pollen_periods = {p["period"]: p for p in pollen_data[0]["periods"]}
-                p["period"]: p for p in pollen_data[0]["periods"]
-            }
 
         if weather_data and weather_data[0].get("periods"):
-            weather_periods = {
+            weather_periods = {p["period"]: p for p in weather_data[0]["periods"]}
-                p["period"]: p for p in weather_data[0]["periods"]
-            }
 
-        current_weather_info = CurrentWeatherData({
+        current_weather_info = CurrentWeatherData(
+            {
                 "temp": 0,
                 "feels_like": 0,
                 "desc": "",
                 "humidity": 0,
                 "pressure": 0,
-        })
+            }
+        )
 
         if weather_data and weather_data[0]:
             data = weather_data[0]
-            current_weather_info = CurrentWeatherData({
+            current_weather_info = CurrentWeatherData(
+                {
                     "temp": data["current_temp"],
                     "feels_like": data["current_feels_like"],
                     "desc": data["current_desc"],
                     "humidity": data["current_humidity"],
                     "pressure": data["current_pressure"],
-            })
+                }
+            )
 
         return pollen_periods, weather_periods, current_weather_info
 
@@ -449,29 +497,37 @@ async def get_weather_pollen_report(token: str) -> FinalReport:
 
     pollen_data, weather_data = await asyncio.gather(
         PollenService.fetch_pollen(config.zip_code),
-        WeatherService.fetch_weather(config.latitude, config.longitude, config.weather_api_key),
+        WeatherService.fetch_weather(
+            config.latitude, config.longitude, config.weather_api_key
+        ),
     )
 
-    pollen_periods, weather_periods, current_weather_info = DataAggregator.create_periods_lookup(
+    pollen_periods, weather_periods, current_weather_info = (
-        pollen_data, weather_data
+        DataAggregator.create_periods_lookup(pollen_data, weather_data)
     )
 
     now = datetime.now()
     today_date = DateTimeFormatter.format_date(now)
     tomorrow_date = DateTimeFormatter.format_date(now + timedelta(days=1))
 
-    result: FinalReport = FinalReport({
+    result: FinalReport = FinalReport(
+        {
             "fetched_at": DateTimeFormatter.format_datetime(now),
             "current": current_weather_info,
             "today": DailyData({}),
             "tomorrow": DailyData({}),
-    })
+        }
+    )
 
-    today_data = DataAggregator.build_daily_data(today_date, pollen_periods, weather_periods)
+    today_data = DataAggregator.build_daily_data(
+        today_date, pollen_periods, weather_periods
+    )
     if today_data:
         result["today"] = today_data
 
-    tomorrow_data = DataAggregator.build_daily_data(tomorrow_date, pollen_periods, weather_periods)
+    tomorrow_data = DataAggregator.build_daily_data(
+        tomorrow_date, pollen_periods, weather_periods
+    )
     if tomorrow_data:
         result["tomorrow"] = tomorrow_data