python-google-weather-api 0.0.10__tar.gz → 0.0.11__tar.gz

{python_google_weather_api-0.0.10 → python_google_weather_api-0.0.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-google-weather-api
-Version: 0.0.10
+Version: 0.0.11
 Summary: A python client library for Google Weather API
 Author-email: tronikos <tronikos@gmail.com>
 License-Expression: Apache-2.0

{python_google_weather_api-0.0.10 → python_google_weather_api-0.0.11}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "python-google-weather-api"
-version = "0.0.10"
+version = "0.0.11"
 license = "Apache-2.0"
 authors = [
     { name="tronikos", email="tronikos@gmail.com" },

{python_google_weather_api-0.0.10 → python_google_weather_api-0.0.11}/src/google_weather_api/api.py

@@ -4,9 +4,10 @@ from __future__ import annotations
 
 import logging
 from http import HTTPStatus
-from typing import Any
+from typing import Any, TypeVar
 
 import aiohttp
+from mashumaro.exceptions import InvalidFieldValue, MissingField
 
 from .exceptions import (
     GoogleWeatherApiAuthError,
@@ -15,6 +16,7 @@ from .exceptions import (
     GoogleWeatherApiResponseError,
 )
 from .model import (
+    BaseModel,
     CurrentConditionsResponse,
     DailyForecastResponse,
     HourlyForecastResponse,
@@ -23,6 +25,17 @@ from .model import (
 
 _LOGGER = logging.getLogger(__name__)
 
+_ResponseT = TypeVar("_ResponseT", bound=BaseModel)
+
+
+def _parse_response(model: type[_ResponseT], data: dict[str, Any]) -> _ResponseT:
+    """Deserialize an API response dictionary, wrapping schema errors."""
+    try:
+        return model.from_dict(data)
+    except (InvalidFieldValue, MissingField) as err:
+        raise GoogleWeatherApiResponseError(str(err)) from err
+
+
 _BASE_URL = "https://weather.googleapis.com/v1"
 # See https://docs.cloud.google.com/docs/authentication/api-keys-use
 _API_KEY_HEADER = "X-Goog-Api-Key"
@@ -140,7 +153,7 @@ class GoogleWeatherApi:
                 "location.longitude": longitude,
             },
         )
-        return CurrentConditionsResponse.from_dict(data)
+        return _parse_response(CurrentConditionsResponse, data)
 
     async def async_get_hourly_forecast(self, latitude: float, longitude: float, hours: int = 48) -> HourlyForecastResponse:
         """Fetch hourly weather forecast.
@@ -157,7 +170,7 @@ class GoogleWeatherApi:
             "forecastHours",
             hours,
         )
-        return HourlyForecastResponse.from_dict(data)
+        return _parse_response(HourlyForecastResponse, data)
 
     async def async_get_daily_forecast(self, latitude: float, longitude: float, days: int = 10) -> DailyForecastResponse:
         """Fetch daily weather forecast.
@@ -174,7 +187,7 @@ class GoogleWeatherApi:
             "forecastDays",
             days,
         )
-        return DailyForecastResponse.from_dict(data)
+        return _parse_response(DailyForecastResponse, data)
 
     async def async_get_minute_forecast(
         self, latitude: float, longitude: float, page_size: int = 360
@@ -197,4 +210,4 @@ class GoogleWeatherApi:
             page_size,
             include_language_code=False,
         )
-        return MinuteForecastResponse.from_dict(data)
+        return _parse_response(MinuteForecastResponse, data)

{python_google_weather_api-0.0.10 → python_google_weather_api-0.0.11}/src/google_weather_api/model.py

@@ -93,14 +93,14 @@ class Temperature(BaseModel):
     class TemperatureUnit(ApiStrEnum):
         """Represents a unit used to measure temperatures."""
 
-        TEMPERATURE_UNIT_UNSPECIFIED = "TEMPERATURE_UNIT_UNSPECIFIED"
+        UNIT_UNSPECIFIED = "UNIT_UNSPECIFIED"
         CELSIUS = "CELSIUS"
         FAHRENHEIT = "FAHRENHEIT"
 
-    degrees: float
+    degrees: float | None = None
     """The temperature value (in degrees) in the specified unit."""
 
-    unit: TemperatureUnit
+    unit: TemperatureUnit = TemperatureUnit.UNIT_UNSPECIFIED
     """The code for the unit used to measure the temperature value."""
 
 
@@ -115,10 +115,10 @@ class QuantitativePrecipitationForecast(BaseModel):
         MILLIMETERS = "MILLIMETERS"
         INCHES = "INCHES"
 
-    quantity: float
+    quantity: float | None = None
     """The amount of precipitation, measured as liquid water equivalent."""
 
-    unit: Unit
+    unit: Unit = Unit.UNIT_UNSPECIFIED
     """The code of the unit used to measure the amount of accumulated precipitation."""
 
 
@@ -129,7 +129,7 @@ class PrecipitationProbability(BaseModel):
     class PrecipitationType(ApiStrEnum):
         """Represents the type of precipitation at a given location."""
 
-        PRECIPITATION_TYPE_UNSPECIFIED = "PRECIPITATION_TYPE_UNSPECIFIED"
+        TYPE_UNSPECIFIED = "TYPE_UNSPECIFIED"
         NONE = "NONE"
         SNOW = "SNOW"
         RAIN = "RAIN"
@@ -138,6 +138,7 @@ class PrecipitationProbability(BaseModel):
         RAIN_AND_SNOW = "RAIN_AND_SNOW"
         SLEET = "SLEET"
         FREEZING_RAIN = "FREEZING_RAIN"
+        PRECIPITATION_TYPE_HAIL = "PRECIPITATION_TYPE_HAIL"
 
     type: PrecipitationType
     """A code that indicates the type of precipitation."""
@@ -167,14 +168,14 @@ class WindSpeed(BaseModel):
     class SpeedUnit(ApiStrEnum):
         """Represents the unit used to measure speed."""
 
-        SPEED_UNIT_UNSPECIFIED = "SPEED_UNIT_UNSPECIFIED"
+        UNIT_UNSPECIFIED = "UNIT_UNSPECIFIED"
         KILOMETERS_PER_HOUR = "KILOMETERS_PER_HOUR"
         MILES_PER_HOUR = "MILES_PER_HOUR"
 
-    value: float
+    value: float | None = None
     """The value of the wind speed."""
 
-    unit: SpeedUnit
+    unit: SpeedUnit = SpeedUnit.UNIT_UNSPECIFIED
     """The code that represents the unit used to measure the wind speed."""
 
 
@@ -185,7 +186,7 @@ class WindDirection(BaseModel):
     class CardinalDirection(ApiStrEnum):
         """Represents a cardinal direction (including ordinal directions)."""
 
-        CARDINAL_DIRECTION_UNSPECIFIED = "CARDINAL_DIRECTION_UNSPECIFIED"
+        CARDINAL_UNSPECIFIED = "CARDINAL_UNSPECIFIED"
         NORTH = "NORTH"
         NORTH_NORTHEAST = "NORTH_NORTHEAST"
         NORTHEAST = "NORTHEAST"
@@ -220,7 +221,7 @@ class Wind(BaseModel):
     speed: WindSpeed
     """The speed of the wind."""
 
-    gust: WindSpeed
+    gust: WindSpeed | None = None
     """The wind gust (sudden increase in the wind speed)."""
 
 
@@ -235,10 +236,10 @@ class Visibility(BaseModel):
         KILOMETERS = "KILOMETERS"
         MILES = "MILES"
 
-    distance: float
+    distance: float | None = None
     """The visibility distance in the specified unit."""
 
-    unit: Unit
+    unit: Unit = Unit.UNIT_UNSPECIFIED
     """The code that represents the unit used to measure the distance."""
 
 
@@ -290,6 +291,120 @@ class WeatherCondition(BaseModel):
         LIGHT_THUNDERSTORM_RAIN = "LIGHT_THUNDERSTORM_RAIN"
         SCATTERED_THUNDERSTORMS = "SCATTERED_THUNDERSTORMS"
         HEAVY_THUNDERSTORM = "HEAVY_THUNDERSTORM"
+        CLEAR_AFTER_FOG_IN_THE_MORNING = "CLEAR_AFTER_FOG_IN_THE_MORNING"
+        CLEAR_BUT_LATER_TURNING_CLOUDY = "CLEAR_BUT_LATER_TURNING_CLOUDY"
+        CLEAR_BUT_LATER_TURNING_TO_RAIN_AND_SNOW_MAIN_CONSTITUENT_RAIN = (
+            "CLEAR_BUT_LATER_TURNING_TO_RAIN_AND_SNOW_MAIN_CONSTITUENT_RAIN"
+        )
+        CLEAR_BUT_LATER_TURNING_TO_SNOW_AND_RAIN_MAIN_CONSTITUENT_SNOW = (
+            "CLEAR_BUT_LATER_TURNING_TO_SNOW_AND_RAIN_MAIN_CONSTITUENT_SNOW"
+        )
+        CLEAR_BUT_THUNDERSTORMS_LATER = "CLEAR_BUT_THUNDERSTORMS_LATER"
+        CLEAR_IN_THE_MORNING_BUT_CLOUDY_IN_THE_EVENING = "CLEAR_IN_THE_MORNING_BUT_CLOUDY_IN_THE_EVENING"
+        CLEAR_IN_THE_MORNING_WITH_BRIEF_RAIN_IN_THE_EVENING = "CLEAR_IN_THE_MORNING_WITH_BRIEF_RAIN_IN_THE_EVENING"
+        CLEAR_MORNING_WITH_BRIEF_RAIN = "CLEAR_MORNING_WITH_BRIEF_RAIN"
+        CLEAR_WITH_BRIEF_RAIN = "CLEAR_WITH_BRIEF_RAIN"
+        CLEAR_WITH_BRIEF_RAIN_AND_SNOW_RAIN_AS_MAIN_CONSTITUENT = "CLEAR_WITH_BRIEF_RAIN_AND_SNOW_RAIN_AS_MAIN_CONSTITUENT"
+        CLEAR_WITH_BRIEF_RAIN_LATER = "CLEAR_WITH_BRIEF_RAIN_LATER"
+        CLEAR_WITH_BRIEF_SNOW = "CLEAR_WITH_BRIEF_SNOW"
+        CLEAR_WITH_BRIEF_SNOW_AND_RAIN_SNOW_AS_MAIN_CONSTITUENT = "CLEAR_WITH_BRIEF_SNOW_AND_RAIN_SNOW_AS_MAIN_CONSTITUENT"
+        CLEAR_WITH_BRIEF_SNOW_LATER = "CLEAR_WITH_BRIEF_SNOW_LATER"
+        CLEAR_WITH_PERIODIC_CLOUDS_LATER = "CLEAR_WITH_PERIODIC_CLOUDS_LATER"
+        CLEAR_WITH_PERIODIC_RAIN = "CLEAR_WITH_PERIODIC_RAIN"
+        CLEAR_WITH_PERIODIC_RAIN_ACCOMPANIED_BY_THUNDER = "CLEAR_WITH_PERIODIC_RAIN_ACCOMPANIED_BY_THUNDER"
+        CLEAR_WITH_PERIODIC_RAIN_AND_SNOW_RAIN_AS_MAIN_CONSTITUENT = (
+            "CLEAR_WITH_PERIODIC_RAIN_AND_SNOW_RAIN_AS_MAIN_CONSTITUENT"
+        )
+        CLEAR_WITH_PERIODIC_RAIN_LATER = "CLEAR_WITH_PERIODIC_RAIN_LATER"
+        CLEAR_WITH_PERIODIC_SNOW = "CLEAR_WITH_PERIODIC_SNOW"
+        CLEAR_WITH_PERIODIC_SNOW_AND_RAIN_SNOW_AS_MAIN_CONSTITUENT = (
+            "CLEAR_WITH_PERIODIC_SNOW_AND_RAIN_SNOW_AS_MAIN_CONSTITUENT"
+        )
+        CLEAR_WITH_PERIODIC_SNOW_LATER = "CLEAR_WITH_PERIODIC_SNOW_LATER"
+        CLEAR_WITH_RAIN_AFTER_MIDNIGHT = "CLEAR_WITH_RAIN_AFTER_MIDNIGHT"
+        CLEAR_WITH_RAIN_IN_THE_NIGHT = "CLEAR_WITH_RAIN_IN_THE_NIGHT"
+        CLEAR_WITH_RAIN_LATER = "CLEAR_WITH_RAIN_LATER"
+        CLEAR_WITH_SNOW_ALONG_THE_MOUNTAINS = "CLEAR_WITH_SNOW_ALONG_THE_MOUNTAINS"
+        CLEAR_WITH_SNOW_LATER = "CLEAR_WITH_SNOW_LATER"
+        CLEAR_WITH_THUNDERSTORMS_ALONG_THE_MOUNTAINS = "CLEAR_WITH_THUNDERSTORMS_ALONG_THE_MOUNTAINS"
+        CLEAR_WITH_THUNDERSTORMS_IN_THE_AFTERNOON = "CLEAR_WITH_THUNDERSTORMS_IN_THE_AFTERNOON"
+        CLOUDY_BUT_CLEAR_LATER = "CLOUDY_BUT_CLEAR_LATER"
+        CLOUDY_BUT_LATER_TURNING_TO_RAIN_AND_SNOW_MAIN_CONSTITUENT_RAIN = (
+            "CLOUDY_BUT_LATER_TURNING_TO_RAIN_AND_SNOW_MAIN_CONSTITUENT_RAIN"
+        )
+        CLOUDY_BUT_LATER_TURNING_TO_SNOW_AND_RAIN_MAIN_CONSTITUENT_SNOW = (
+            "CLOUDY_BUT_LATER_TURNING_TO_SNOW_AND_RAIN_MAIN_CONSTITUENT_SNOW"
+        )
+        CLOUDY_BUT_PERIODICALLY_CLEAR_LATER = "CLOUDY_BUT_PERIODICALLY_CLEAR_LATER"
+        CLOUDY_BUT_THUNDERSTORMS_LATER = "CLOUDY_BUT_THUNDERSTORMS_LATER"
+        CLOUDY_MORNING_WITH_BRIEF_RAIN = "CLOUDY_MORNING_WITH_BRIEF_RAIN"
+        CLOUDY_PERIODICALLY_CLEAR = "CLOUDY_PERIODICALLY_CLEAR"
+        CLOUDY_SNOWING_IN_THE_EVENING = "CLOUDY_SNOWING_IN_THE_EVENING"
+        CLOUDY_SNOWING_IN_THE_NIGHT = "CLOUDY_SNOWING_IN_THE_NIGHT"
+        CLOUDY_WITH_BRIEF_RAIN = "CLOUDY_WITH_BRIEF_RAIN"
+        CLOUDY_WITH_BRIEF_RAIN_AND_SNOW_RAIN_AS_MAIN_CONSTITUENT = "CLOUDY_WITH_BRIEF_RAIN_AND_SNOW_RAIN_AS_MAIN_CONSTITUENT"
+        CLOUDY_WITH_BRIEF_RAIN_LATER = "CLOUDY_WITH_BRIEF_RAIN_LATER"
+        CLOUDY_WITH_BRIEF_SNOW = "CLOUDY_WITH_BRIEF_SNOW"
+        CLOUDY_WITH_BRIEF_SNOW_AND_RAIN_SNOW_AS_MAIN_CONSTITUENT = "CLOUDY_WITH_BRIEF_SNOW_AND_RAIN_SNOW_AS_MAIN_CONSTITUENT"
+        CLOUDY_WITH_BRIEF_SNOW_LATER = "CLOUDY_WITH_BRIEF_SNOW_LATER"
+        CLOUDY_WITH_BRIEF_THUNDERSTORM = "CLOUDY_WITH_BRIEF_THUNDERSTORM"
+        CLOUDY_WITH_FOG_ON_THE_OCEAN_AND_AT_THE_SEASHORE = "CLOUDY_WITH_FOG_ON_THE_OCEAN_AND_AT_THE_SEASHORE"
+        CLOUDY_WITH_PERIODIC_RAIN = "CLOUDY_WITH_PERIODIC_RAIN"
+        CLOUDY_WITH_PERIODIC_RAIN_ACCOMPANIED_BY_THUNDER = "CLOUDY_WITH_PERIODIC_RAIN_ACCOMPANIED_BY_THUNDER"
+        CLOUDY_WITH_PERIODIC_RAIN_AND_SNOW_RAIN_AS_MAIN_CONSTITUENT = (
+            "CLOUDY_WITH_PERIODIC_RAIN_AND_SNOW_RAIN_AS_MAIN_CONSTITUENT"
+        )
+        CLOUDY_WITH_PERIODIC_RAIN_LATER = "CLOUDY_WITH_PERIODIC_RAIN_LATER"
+        CLOUDY_WITH_PERIODIC_SNOW = "CLOUDY_WITH_PERIODIC_SNOW"
+        CLOUDY_WITH_PERIODIC_SNOW_ACCOMPANIED_BY_THUNDER = "CLOUDY_WITH_PERIODIC_SNOW_ACCOMPANIED_BY_THUNDER"
+        CLOUDY_WITH_PERIODIC_SNOW_AND_RAIN_SNOW_AS_MAIN_CONSTITUENT = (
+            "CLOUDY_WITH_PERIODIC_SNOW_AND_RAIN_SNOW_AS_MAIN_CONSTITUENT"
+        )
+        CLOUDY_WITH_PERIODIC_SNOW_LATER = "CLOUDY_WITH_PERIODIC_SNOW_LATER"
+        CLOUDY_WITH_RAIN_AFTER_MIDNIGHT = "CLOUDY_WITH_RAIN_AFTER_MIDNIGHT"
+        CLOUDY_WITH_RAIN_FROM_ABOUT_NOON = "CLOUDY_WITH_RAIN_FROM_ABOUT_NOON"
+        CLOUDY_WITH_RAIN_FROM_EVENING = "CLOUDY_WITH_RAIN_FROM_EVENING"
+        CLOUDY_WITH_RAIN_LATER = "CLOUDY_WITH_RAIN_LATER"
+        CLOUDY_WITH_SNOW_FROM_AROUND_NOON = "CLOUDY_WITH_SNOW_FROM_AROUND_NOON"
+        CLOUDY_WITH_SNOW_LATER = "CLOUDY_WITH_SNOW_LATER"
+        FOG = "FOG"
+        RAINSNOW_MIX_LATER_BECOMING_CLEAR_RAIN_AS_MAIN = "RAINSNOW_MIX_LATER_BECOMING_CLEAR_RAIN_AS_MAIN"
+        RAINSNOW_MIX_RAIN_AS_MAIN = "RAINSNOW_MIX_RAIN_AS_MAIN"
+        RAINY_BUT_PERIODICALLY_CLEAR = "RAINY_BUT_PERIODICALLY_CLEAR"
+        RAIN_ACCOMPANIED_BY_LIGHTNING = "RAIN_ACCOMPANIED_BY_LIGHTNING"
+        RAIN_ACCOMPANIED_BY_WINDSTORM = "RAIN_ACCOMPANIED_BY_WINDSTORM"
+        RAIN_CLEAR_AT_NIGHT = "RAIN_CLEAR_AT_NIGHT"
+        RAIN_CLEAR_FROM_AROUND_EVENING = "RAIN_CLEAR_FROM_AROUND_EVENING"
+        RAIN_CLEAR_FROM_AROUND_NOON = "RAIN_CLEAR_FROM_AROUND_NOON"
+        RAIN_LATER_BECOMING_CLEAR = "RAIN_LATER_BECOMING_CLEAR"
+        RAIN_LATER_BECOMING_CLOUDY = "RAIN_LATER_BECOMING_CLOUDY"
+        RAIN_LATER_BECOMING_SNOW = "RAIN_LATER_BECOMING_SNOW"
+        RAIN_LATER_WITH_PERIODIC_SNOW = "RAIN_LATER_WITH_PERIODIC_SNOW"
+        RAIN_SNOW_AT_NIGHT = "RAIN_SNOW_AT_NIGHT"
+        RAIN_SNOW_IN_THE_EVENING = "RAIN_SNOW_IN_THE_EVENING"
+        RAIN_TEMPORARILY_BECOMING_SLEET = "RAIN_TEMPORARILY_BECOMING_SLEET"
+        RAIN_THAT_PERIODICALLY_STOPS = "RAIN_THAT_PERIODICALLY_STOPS"
+        RAIN_WITH_BRIEF_SNOW = "RAIN_WITH_BRIEF_SNOW"
+        RAIN_WITH_PERIODIC_SNOW = "RAIN_WITH_PERIODIC_SNOW"
+        SNOWRAIN_MIX_LATER_BECOMING_CLEAR_SNOW_AS_MAIN = "SNOWRAIN_MIX_LATER_BECOMING_CLEAR_SNOW_AS_MAIN"
+        SNOWRAIN_MIX_LATER_BECOMING_CLOUDY_SNOW_AS_MAIN = "SNOWRAIN_MIX_LATER_BECOMING_CLOUDY_SNOW_AS_MAIN"
+        SNOWRAIN_MIX_SNOW_AS_MAIN = "SNOWRAIN_MIX_SNOW_AS_MAIN"
+        SNOW_ACCOMPANIED_BY_LIGHTNING = "SNOW_ACCOMPANIED_BY_LIGHTNING"
+        SNOW_BECOMING_SLEET = "SNOW_BECOMING_SLEET"
+        SNOW_LATER_CLEAR = "SNOW_LATER_CLEAR"
+        SNOW_LATER_CLOUDY = "SNOW_LATER_CLOUDY"
+        SNOW_LATER_RAIN = "SNOW_LATER_RAIN"
+        SNOW_PERIODICALLY_CLEAR = "SNOW_PERIODICALLY_CLEAR"
+        SNOW_THAT_PERIODICALLY_STOPS = "SNOW_THAT_PERIODICALLY_STOPS"
+        SNOW_TURNING_TO_RAIN_AROUND_NOON = "SNOW_TURNING_TO_RAIN_AROUND_NOON"
+        SNOW_TURNING_TO_RAIN_IN_THE_EVENING = "SNOW_TURNING_TO_RAIN_IN_THE_EVENING"
+        SNOW_TURNING_TO_RAIN_IN_THE_NIGHT = "SNOW_TURNING_TO_RAIN_IN_THE_NIGHT"
+        SNOW_WITH_BRIEF_RAIN = "SNOW_WITH_BRIEF_RAIN"
+        SNOW_WITH_BRIEF_SLEET = "SNOW_WITH_BRIEF_SLEET"
+        SNOW_WITH_PERIODIC_RAIN = "SNOW_WITH_PERIODIC_RAIN"
+        VERY_HOT = "VERY_HOT"
+        SLEET = "SLEET"
+        HEAVY_RAIN_TO_RAINSTORM = "HEAVY_RAIN_TO_RAINSTORM"
 
     icon_base_uri: str = field(metadata={"alias": "iconBaseUri"})
     """The base URI for the icon not including the file type extension."""
@@ -312,10 +427,10 @@ class IceThickness(BaseModel):
         MILLIMETERS = "MILLIMETERS"
         INCHES = "INCHES"
 
-    thickness: float
+    thickness: float | None = None
     """The ice thickness value."""
 
-    unit: Unit
+    unit: Unit = Unit.UNIT_UNSPECIFIED
     """The code that represents the unit used to measure the ice thickness."""
 
 
@@ -335,6 +450,9 @@ class CurrentConditionsHistory(BaseModel):
     qpf: QuantitativePrecipitationForecast
     """The amount of precipitation (rain or snow) accumulated over the last 24 hours."""
 
+    snow_qpf: QuantitativePrecipitationForecast | None = field(default=None, metadata={"alias": "snowQpf"})
+    """The amount of snow accumulation over the last 24 hours, measured as liquid water equivalent."""
+
 
 @dataclass
 class CurrentConditionsResponse(BaseModel):
@@ -388,11 +506,11 @@ class CurrentConditionsResponse(BaseModel):
     uv_index: int = field(metadata={"alias": "uvIndex"})
     """The current ultraviolet (UV) index."""
 
-    thunderstorm_probability: int = field(metadata={"alias": "thunderstormProbability"})
-    """The current thunderstorm probability (0-100)."""
+    thunderstorm_probability: int | None = field(default=None, metadata={"alias": "thunderstormProbability"})
+    """The current thunderstorm probability (0-100). Omitted in some regions (e.g. Japan and South Korea)."""
 
-    cloud_cover: int = field(metadata={"alias": "cloudCover"})
-    """The current percentage of the sky covered by clouds (0-100)."""
+    cloud_cover: int | None = field(default=None, metadata={"alias": "cloudCover"})
+    """The current percentage of the sky covered by clouds (0-100). Omitted in some regions (e.g. Japan and South Korea)."""
 
 
 @dataclass
@@ -411,7 +529,7 @@ class Date(BaseModel):
 
 @dataclass
 class ForecastDayPart(BaseModel):
-    """Represents a forecast record for a part of the day (daytime or nighttime)."""
+    """Represents a forecast record for a part of the day (daytime, nighttime, or full day)."""
 
     interval: Interval
     """The UTC date and time when this part of the day starts and ends."""
@@ -431,11 +549,11 @@ class ForecastDayPart(BaseModel):
     uv_index: int = field(metadata={"alias": "uvIndex"})
     """The maximum forecasted ultraviolet (UV) index."""
 
-    thunderstorm_probability: int = field(metadata={"alias": "thunderstormProbability"})
-    """The average thunderstorm probability."""
+    thunderstorm_probability: int | None = field(default=None, metadata={"alias": "thunderstormProbability"})
+    """The average thunderstorm probability. Omitted in some regions (e.g. Japan and South Korea)."""
 
-    cloud_cover: int = field(metadata={"alias": "cloudCover"})
-    """Average cloud cover percent."""
+    cloud_cover: int | None = field(default=None, metadata={"alias": "cloudCover"})
+    """Average cloud cover percent. Omitted in some regions (e.g. Japan and South Korea)."""
 
     ice_thickness: IceThickness | None = field(default=None, metadata={"alias": "iceThickness"})
     """The forecasted ice thickness."""
@@ -459,7 +577,7 @@ class MoonEvents(BaseModel):
     class MoonPhase(ApiStrEnum):
         """Marks the moon phase (a.k.a. lunar phase)."""
 
-        MOON_PHASE_UNSPECIFIED = "MOON_PHASE_UNSPECIFIED"
+        PHASE_UNSPECIFIED = "PHASE_UNSPECIFIED"
         NEW_MOON = "NEW_MOON"
         WAXING_CRESCENT = "WAXING_CRESCENT"
         FIRST_QUARTER = "FIRST_QUARTER"
@@ -489,12 +607,6 @@ class ForecastDay(BaseModel):
     display_date: Date = field(metadata={"alias": "displayDate"})
     """The local date in the time zone of the location."""
 
-    daytime_forecast: ForecastDayPart = field(metadata={"alias": "daytimeForecast"})
-    """The forecasted weather conditions for the daytime part of the day."""
-
-    nighttime_forecast: ForecastDayPart = field(metadata={"alias": "nighttimeForecast"})
-    """The forecasted weather conditions for the nighttime part of the day."""
-
     max_temperature: Temperature = field(metadata={"alias": "maxTemperature"})
     """The maximum (high) temperature throughout the day."""
 
@@ -516,6 +628,15 @@ class ForecastDay(BaseModel):
     moon_events: MoonEvents = field(metadata={"alias": "moonEvents"})
     """The events related to the moon (e.g. moonrise, moonset)."""
 
+    daytime_forecast: ForecastDayPart | None = field(default=None, metadata={"alias": "daytimeForecast"})
+    """The forecasted weather conditions for the daytime part of the day."""
+
+    nighttime_forecast: ForecastDayPart | None = field(default=None, metadata={"alias": "nighttimeForecast"})
+    """The forecasted weather conditions for the nighttime part of the day."""
+
+    full_day_forecast: ForecastDayPart | None = field(default=None, metadata={"alias": "fullDayForecast"})
+    """The forecasted weather conditions for the full day (returned instead of daytime/nighttime in Japan and South Korea)."""
+
     ice_thickness: IceThickness | None = field(default=None, metadata={"alias": "iceThickness"})
     """The accumulated amount of ice throughout the entire day."""
 
@@ -618,11 +739,11 @@ class ForecastHour(BaseModel):
     uv_index: int = field(metadata={"alias": "uvIndex"})
     """The forecasted ultraviolet (UV) index."""
 
-    thunderstorm_probability: int = field(metadata={"alias": "thunderstormProbability"})
-    """The forecasted thunderstorm probability (0-100)."""
+    thunderstorm_probability: int | None = field(default=None, metadata={"alias": "thunderstormProbability"})
+    """The forecasted thunderstorm probability (0-100). Omitted in some regions (e.g. Japan and South Korea)."""
 
-    cloud_cover: int = field(metadata={"alias": "cloudCover"})
-    """The forecasted percentage of the sky covered by clouds (0-100)."""
+    cloud_cover: int | None = field(default=None, metadata={"alias": "cloudCover"})
+    """The forecasted percentage of the sky covered by clouds (0-100). Omitted in some regions (e.g. Japan and South Korea)."""
 
     ice_thickness: IceThickness | None = field(default=None, metadata={"alias": "iceThickness"})
     """The forecasted ice thickness."""

{python_google_weather_api-0.0.10 → python_google_weather_api-0.0.11}/src/python_google_weather_api.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-google-weather-api
-Version: 0.0.10
+Version: 0.0.11
 Summary: A python client library for Google Weather API
 Author-email: tronikos <tronikos@gmail.com>
 License-Expression: Apache-2.0

{python_google_weather_api-0.0.10 → python_google_weather_api-0.0.11}/tests/test_api.py

@@ -94,8 +94,12 @@ async def test_get_daily_forecast(api: GoogleWeatherApi, mock_server: MockServer
 
     assert len(result.forecast_days) == 2
     day = result.forecast_days[0]
+    assert day.max_temperature.degrees is not None
+    assert day.min_temperature.degrees is not None
     assert day.max_temperature.degrees >= day.min_temperature.degrees
+    assert day.daytime_forecast is not None
     assert day.daytime_forecast.weather_condition.type
+    assert day.nighttime_forecast is not None
     assert day.nighttime_forecast.weather_condition.type
     assert day.sun_events.sunrise_time
     assert day.moon_events.moon_phase
@@ -332,6 +336,14 @@ async def test_get_minute_forecast(api: GoogleWeatherApi, mock_server: MockServe
     assert "language_code" not in request.query
 
 
+async def test_malformed_response_raises_response_error(api: GoogleWeatherApi, mock_server: MockServer) -> None:
+    """Test a 200 OK response missing required schema fields raises GoogleWeatherApiResponseError."""
+    mock_server.add_response({})
+
+    with pytest.raises(GoogleWeatherApiResponseError):
+        await api.async_get_current_conditions(LATITUDE, LONGITUDE)
+
+
 def _load_dotenv() -> dict[str, str]:
     """Load credentials from .env or environment variables."""
     env: dict[str, str] = {}
@@ -372,3 +384,19 @@ async def test_live_weather_endpoints(session: aiohttp.ClientSession) -> None:
 
     minute = await client.async_get_minute_forecast(LATITUDE, LONGITUDE, page_size=10)
     assert minute.time_zone.id
+
+    # Japan (Tokyo) and South Korea (Seoul) use fullDayForecast and omit several fields.
+    for lat, lon, expected_tz in (
+        (35.6762, 139.6503, "Asia/Tokyo"),
+        (37.5665, 126.9780, "Asia/Seoul"),
+    ):
+        regional_current = await client.async_get_current_conditions(lat, lon)
+        assert regional_current.time_zone.id == expected_tz
+        assert regional_current.temperature.degrees is not None
+
+        regional_daily = await client.async_get_daily_forecast(lat, lon, days=2)
+        assert len(regional_daily.forecast_days) == 2
+        assert regional_daily.forecast_days[0].full_day_forecast is not None
+
+        regional_hourly = await client.async_get_hourly_forecast(lat, lon, hours=2)
+        assert len(regional_hourly.forecast_hours) == 2

{python_google_weather_api-0.0.10 → python_google_weather_api-0.0.11}/tests/test_model.py

@@ -135,6 +135,7 @@ def test_optional_fields_may_be_absent() -> None:
     assert parsed.moon_events.moonrise_times == []
     assert parsed.moon_events.moonset_times == []
     assert parsed.ice_thickness is None
+    assert parsed.daytime_forecast is not None
     assert parsed.daytime_forecast.ice_thickness is None
     assert parsed.daytime_forecast.precipitation.snow_qpf is None
     assert parsed.interval.end_time is None
@@ -186,3 +187,104 @@ def test_daily_and_hourly_forecasts_without_records() -> None:
     hourly = HourlyForecastResponse.from_dict({"timeZone": {"id": "America/New_York"}})
     assert hourly.forecast_hours == []
     assert "nextPageToken" not in hourly.to_dict()
+
+
+def test_japan_and_south_korea_current_conditions(caplog: pytest.LogCaptureFixture) -> None:
+    """Test parsing current conditions with Japan/South Korea omitted and UNIT_UNSPECIFIED fields."""
+    data = load_fixture("current_conditions")
+    data["timeZone"] = {"id": "Asia/Tokyo", "version": ""}
+    data["heatIndex"] = {"unit": "UNIT_UNSPECIFIED"}
+    data["windChill"] = {"unit": "UNIT_UNSPECIFIED"}
+    data["visibility"] = {"unit": "UNIT_UNSPECIFIED"}
+    data["precipitation"]["snowQpf"] = {"unit": "UNIT_UNSPECIFIED"}
+    data["currentConditionsHistory"]["snowQpf"] = {"unit": "UNIT_UNSPECIFIED"}
+    data["wind"].pop("gust", None)
+    data.pop("cloudCover", None)
+    data.pop("thunderstormProbability", None)
+
+    with caplog.at_level(logging.WARNING, logger="google_weather_api"):
+        parsed = CurrentConditionsResponse.from_dict(data)
+
+    assert caplog.records == []
+    assert parsed.heat_index.degrees is None
+    assert parsed.heat_index.unit is Temperature.TemperatureUnit.UNIT_UNSPECIFIED
+    assert parsed.wind_chill.degrees is None
+    assert parsed.visibility.distance is None
+    assert parsed.visibility.unit is Visibility.Unit.UNIT_UNSPECIFIED
+    assert parsed.precipitation.snow_qpf is not None
+    assert parsed.precipitation.snow_qpf.quantity is None
+    assert parsed.current_conditions_history.snow_qpf is not None
+    assert parsed.current_conditions_history.snow_qpf.quantity is None
+    assert parsed.wind.gust is None
+    assert parsed.cloud_cover is None
+    assert parsed.thunderstorm_probability is None
+    assert CurrentConditionsResponse.from_dict(parsed.to_dict()) == parsed
+
+
+def test_japan_and_south_korea_daily_forecast(caplog: pytest.LogCaptureFixture) -> None:
+    """Test parsing Japan/South Korea fullDayForecast, regional condition types, and omitted fields."""
+    daily_data = load_fixture("daily_forecast")
+    day: dict[str, Any] = daily_data["forecastDays"][0]
+    full_day = day.pop("daytimeForecast")
+    day.pop("nighttimeForecast")
+    full_day["weatherCondition"]["type"] = "CLOUDY_PERIODICALLY_CLEAR"
+    full_day["wind"].pop("gust", None)
+    full_day.pop("cloudCover", None)
+    full_day.pop("thunderstormProbability", None)
+    full_day["iceThickness"] = {"unit": "UNIT_UNSPECIFIED"}
+    full_day["precipitation"]["snowQpf"] = {"unit": "UNIT_UNSPECIFIED"}
+    day["fullDayForecast"] = full_day
+    day["feelsLikeMaxTemperature"] = {"unit": "UNIT_UNSPECIFIED"}
+    day["feelsLikeMinTemperature"] = {"unit": "UNIT_UNSPECIFIED"}
+    day["maxHeatIndex"] = {"unit": "UNIT_UNSPECIFIED"}
+    day.pop("iceThickness", None)
+
+    with caplog.at_level(logging.WARNING, logger="google_weather_api"):
+        parsed_daily = DailyForecastResponse.from_dict(daily_data)
+
+    assert caplog.records == []
+    parsed_day = parsed_daily.forecast_days[0]
+    assert parsed_day.daytime_forecast is None
+    assert parsed_day.nighttime_forecast is None
+    assert parsed_day.full_day_forecast is not None
+    assert parsed_day.full_day_forecast.weather_condition.type is WeatherCondition.Type.CLOUDY_PERIODICALLY_CLEAR
+    assert parsed_day.full_day_forecast.wind.gust is None
+    assert parsed_day.full_day_forecast.cloud_cover is None
+    assert parsed_day.full_day_forecast.thunderstorm_probability is None
+    assert parsed_day.full_day_forecast.ice_thickness is not None
+    assert parsed_day.full_day_forecast.ice_thickness.thickness is None
+    assert parsed_day.feels_like_max_temperature.degrees is None
+    assert parsed_day.feels_like_min_temperature.degrees is None
+    assert parsed_day.max_heat_index.degrees is None
+    assert DailyForecastResponse.from_dict(parsed_daily.to_dict()) == parsed_daily
+    assert len(WeatherCondition.Type) == 139
+
+
+def test_japan_and_south_korea_hourly_forecast(caplog: pytest.LogCaptureFixture) -> None:
+    """Test parsing Japan/South Korea hourly forecast with omitted and UNIT_UNSPECIFIED fields."""
+    hourly_data = load_fixture("hourly_forecast_page1")
+    hour: dict[str, Any] = hourly_data["forecastHours"][0]
+    hour["heatIndex"] = {"unit": "UNIT_UNSPECIFIED"}
+    hour["windChill"] = {"unit": "UNIT_UNSPECIFIED"}
+    hour["wetBulbTemperature"] = {"unit": "UNIT_UNSPECIFIED"}
+    hour["visibility"] = {"unit": "UNIT_UNSPECIFIED"}
+    hour["iceThickness"] = {"unit": "UNIT_UNSPECIFIED"}
+    hour["wind"].pop("gust", None)
+    hour.pop("cloudCover", None)
+    hour.pop("thunderstormProbability", None)
+
+    with caplog.at_level(logging.WARNING, logger="google_weather_api"):
+        parsed_hourly = HourlyForecastResponse.from_dict(hourly_data)
+
+    assert caplog.records == []
+    parsed_hour = parsed_hourly.forecast_hours[0]
+    assert parsed_hour.heat_index.degrees is None
+    assert parsed_hour.wind_chill.degrees is None
+    assert parsed_hour.wet_bulb_temperature.degrees is None
+    assert parsed_hour.visibility.distance is None
+    assert parsed_hour.ice_thickness is not None
+    assert parsed_hour.ice_thickness.thickness is None
+    assert parsed_hour.wind.gust is None
+    assert parsed_hour.cloud_cover is None
+    assert parsed_hour.thunderstorm_probability is None
+    assert HourlyForecastResponse.from_dict(parsed_hourly.to_dict()) == parsed_hourly