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

{python_google_weather_api-0.0.9/src/python_google_weather_api.egg-info → 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.9
+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.9 → python_google_weather_api-0.0.11}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "python-google-weather-api"
-version = "0.0.9"
+version = "0.0.11"
 license = "Apache-2.0"
 authors = [
     { name="tronikos", email="tronikos@gmail.com" },
@@ -31,7 +31,10 @@ build-backend = "setuptools.build_meta"
 
 [tool.pytest.ini_options]
 asyncio_mode = "auto"
-addopts = "--cov=google_weather_api --cov-report=term-missing --cov-fail-under=90"
+addopts = "-m 'not network' --cov=google_weather_api --cov-report=term-missing --cov-fail-under=90"
+markers = [
+    "network: tests that hit the live Google Weather API (deselected by default)",
+]
 
 [tool.coverage.run]
 branch = true

{python_google_weather_api-0.0.9 → python_google_weather_api-0.0.11}/src/google_weather_api/__init__.py

@@ -4,6 +4,7 @@ from .api import GoogleWeatherApi
 from .exceptions import (
     GoogleWeatherApiAuthError,
     GoogleWeatherApiConnectionError,
+    GoogleWeatherApiConnectionTimeoutError,
     GoogleWeatherApiError,
     GoogleWeatherApiResponseError,
 )
@@ -50,6 +51,7 @@ __all__ = [
     "GoogleWeatherApi",
     "GoogleWeatherApiAuthError",
     "GoogleWeatherApiConnectionError",
+    "GoogleWeatherApiConnectionTimeoutError",
     "GoogleWeatherApiError",
     "GoogleWeatherApiResponseError",
     "HourlyForecastResponse",

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

@@ -4,16 +4,19 @@ 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,
     GoogleWeatherApiConnectionError,
+    GoogleWeatherApiConnectionTimeoutError,
     GoogleWeatherApiResponseError,
 )
 from .model import (
+    BaseModel,
     CurrentConditionsResponse,
     DailyForecastResponse,
     HourlyForecastResponse,
@@ -22,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"
@@ -71,28 +85,33 @@ class GoogleWeatherApi:
                 headers=headers,
                 timeout=self.timeout,
             ) as resp:
-                res: dict[str, Any] = await resp.json()
                 _LOGGER.debug("Got %s for %s", resp.status, url)
-                if resp.status != HTTPStatus.OK:
-                    error_data = res.get("error", {})
-                    error_msg = error_data.get("message", "Unknown API error")
-
-                    if resp.status in (HTTPStatus.UNAUTHORIZED, HTTPStatus.FORBIDDEN):
-                        raise GoogleWeatherApiAuthError(error_msg)
-
-                    # Google APIs often return 400 Bad Request for invalid API keys
-                    if resp.status == HTTPStatus.BAD_REQUEST:
-                        for detail in error_data.get("details", []):
-                            if detail.get("reason") == "API_KEY_INVALID":
-                                raise GoogleWeatherApiAuthError(error_msg)
-
-                    raise GoogleWeatherApiResponseError(error_msg)
-                return res
+                status_code = resp.status
+                body = None if status_code == HTTPStatus.GATEWAY_TIMEOUT else await resp.json()
         except TimeoutError as err:
-            raise GoogleWeatherApiConnectionError("Timeout") from err
+            raise GoogleWeatherApiConnectionTimeoutError("Timeout") from err
         except aiohttp.ClientError as err:
             raise GoogleWeatherApiConnectionError(err) from err
 
+        if status_code == HTTPStatus.GATEWAY_TIMEOUT:
+            raise GoogleWeatherApiConnectionTimeoutError("Timeout")
+        res: dict[str, Any] = body if isinstance(body, dict) else {}
+        if status_code != HTTPStatus.OK:
+            error_data = res.get("error", {})
+            error_msg = error_data.get("message", "Unknown API error")
+
+            if status_code in (HTTPStatus.UNAUTHORIZED, HTTPStatus.FORBIDDEN):
+                raise GoogleWeatherApiAuthError(error_msg)
+
+            # Google APIs often return 400 Bad Request for invalid API keys
+            if status_code == HTTPStatus.BAD_REQUEST:
+                for detail in error_data.get("details", []):
+                    if detail.get("reason") == "API_KEY_INVALID":
+                        raise GoogleWeatherApiAuthError(error_msg)
+
+            raise GoogleWeatherApiResponseError(error_msg)
+        return res
+
     async def _async_get_all_pages(
         self,
         endpoint: str,
@@ -134,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.
@@ -151,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.
@@ -168,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
@@ -191,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.9 → python_google_weather_api-0.0.11}/src/google_weather_api/exceptions.py

@@ -9,6 +9,10 @@ class GoogleWeatherApiConnectionError(GoogleWeatherApiError):
     """Exception connecting to the Google Weather API."""
 
 
+class GoogleWeatherApiConnectionTimeoutError(GoogleWeatherApiConnectionError, TimeoutError):
+    """Exception raised when a request to the Google Weather API times out."""
+
+
 class GoogleWeatherApiAuthError(GoogleWeatherApiError):
     """Exception raised for authentication errors in the Google Weather API."""
 

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

@@ -42,6 +42,7 @@ class BaseModel(DataClassJSONMixin):
 
         serialize_by_alias = True
         allow_deserialization_not_by_alias = True
+        omit_none = True
 
 
 @dataclass
@@ -92,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."""
 
 
@@ -114,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."""
 
 
@@ -128,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"
@@ -137,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."""
@@ -166,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."""
 
 
@@ -184,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"
@@ -219,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)."""
 
 
@@ -234,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."""
 
 
@@ -289,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."""
@@ -311,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."""
 
 
@@ -334,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):
@@ -387,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
@@ -410,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."""
@@ -430,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."""
@@ -458,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"
@@ -488,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."""
 
@@ -515,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."""
 
@@ -523,12 +645,12 @@ class ForecastDay(BaseModel):
 class DailyForecastResponse(BaseModel):
     """Response model for the forecast.days.lookup method."""
 
-    forecast_days: list[ForecastDay] = field(metadata={"alias": "forecastDays"})
-    """The daily forecast records."""
-
     time_zone: TimeZone = field(metadata={"alias": "timeZone"})
     """The time zone at the requested location."""
 
+    forecast_days: list[ForecastDay] = field(default_factory=list, metadata={"alias": "forecastDays"})
+    """The daily forecast records."""
+
     next_page_token: str | None = field(default=None, metadata={"alias": "nextPageToken"})
     """The token to retrieve the next page."""
 
@@ -617,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."""
@@ -631,12 +753,12 @@ class ForecastHour(BaseModel):
 class HourlyForecastResponse(BaseModel):
     """Response model for the forecast.hours.lookup method."""
 
-    forecast_hours: list[ForecastHour] = field(metadata={"alias": "forecastHours"})
-    """The hourly forecast records."""
-
     time_zone: TimeZone = field(metadata={"alias": "timeZone"})
     """The time zone at the requested location."""
 
+    forecast_hours: list[ForecastHour] = field(default_factory=list, metadata={"alias": "forecastHours"})
+    """The hourly forecast records."""
+
     next_page_token: str | None = field(default=None, metadata={"alias": "nextPageToken"})
     """The token to retrieve the next page."""
 

{python_google_weather_api-0.0.9 → 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.9
+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.9 → python_google_weather_api-0.0.11}/tests/test_api.py

@@ -3,8 +3,10 @@
 from __future__ import annotations
 
 import logging
+import os
 import re
 from http import HTTPStatus
+from pathlib import Path
 from typing import Any
 
 import aiohttp
@@ -14,6 +16,7 @@ from google_weather_api import (
     GoogleWeatherApi,
     GoogleWeatherApiAuthError,
     GoogleWeatherApiConnectionError,
+    GoogleWeatherApiConnectionTimeoutError,
     GoogleWeatherApiResponseError,
 )
 
@@ -91,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
@@ -231,6 +238,32 @@ async def test_error_responses(
         await api.async_get_current_conditions(LATITUDE, LONGITUDE)
 
 
+@pytest.mark.parametrize(
+    "payload",
+    [
+        {"error": {"code": 504, "message": "Deadline expired.", "status": "DEADLINE_EXCEEDED"}},
+        "<html>504 Gateway Timeout</html>",
+    ],
+)
+async def test_gateway_timeout_is_a_timeout_error(api: GoogleWeatherApi, mock_server: MockServer, payload: Any) -> None:
+    """Test an HTTP 504 is reported as a timeout, like a client side timeout."""
+    mock_server.add_response(payload, status=HTTPStatus.GATEWAY_TIMEOUT)
+
+    with pytest.raises(GoogleWeatherApiConnectionTimeoutError, match="Timeout") as exc_info:
+        await api.async_get_current_conditions(LATITUDE, LONGITUDE)
+
+    assert isinstance(exc_info.value, GoogleWeatherApiConnectionError)
+    assert isinstance(exc_info.value, TimeoutError)
+
+
+async def test_empty_error_body(api: GoogleWeatherApi, mock_server: MockServer) -> None:
+    """Test an error response without a JSON object is still mapped to an exception."""
+    mock_server.add_response(None, status=HTTPStatus.INTERNAL_SERVER_ERROR)
+
+    with pytest.raises(GoogleWeatherApiResponseError, match="Unknown API error"):
+        await api.async_get_current_conditions(LATITUDE, LONGITUDE)
+
+
 async def test_non_json_response(api: GoogleWeatherApi, mock_server: MockServer) -> None:
     """Test a non-JSON body is reported as a connection error."""
     mock_server.add_response("<html>502 Bad Gateway</html>", status=HTTPStatus.BAD_GATEWAY)
@@ -301,3 +334,69 @@ async def test_get_minute_forecast(api: GoogleWeatherApi, mock_server: MockServe
     assert request.path == "/v1/forecast/minutes:lookup"
     assert request.query["page_size"] == "360"
     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] = {}
+    env_file = Path(__file__).resolve().parent.parent / ".env"
+    if env_file.is_file():
+        for raw_line in env_file.read_text().splitlines():
+            line = raw_line.strip()
+            if line and not line.startswith("#") and "=" in line:
+                key, _, value = line.partition("=")
+                env[key.strip()] = value.strip()
+    for key in ("GOOGLE_API_KEY", "GOOGLE_REFERRER"):
+        if val := os.environ.get(key):
+            env[key] = val
+    return env
+
+
+@pytest.mark.network
+async def test_live_weather_endpoints(session: aiohttp.ClientSession) -> None:
+    """Test fetching live weather data from the Google Weather API using .env credentials."""
+    env = _load_dotenv()
+    api_key = env.get("GOOGLE_API_KEY")
+    if not api_key:
+        pytest.skip("GOOGLE_API_KEY not set in .env or environment")
+    client = GoogleWeatherApi(
+        session=session,
+        api_key=api_key,
+        referrer=env.get("GOOGLE_REFERRER"),
+    )
+    current = await client.async_get_current_conditions(LATITUDE, LONGITUDE)
+    assert current.time_zone.id
+    assert current.temperature.unit == "CELSIUS"
+
+    daily = await client.async_get_daily_forecast(LATITUDE, LONGITUDE, days=2)
+    assert len(daily.forecast_days) == 2
+
+    hourly = await client.async_get_hourly_forecast(LATITUDE, LONGITUDE, hours=2)
+    assert len(hourly.forecast_hours) == 2
+
+    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.9 → 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
@@ -175,3 +176,115 @@ def test_minute_forecast_without_segments() -> None:
         }
     )
     assert response.segments == []
+
+
+def test_daily_and_hourly_forecasts_without_records() -> None:
+    """Test parsing daily and hourly forecast responses when records lists are omitted."""
+    daily = DailyForecastResponse.from_dict({"timeZone": {"id": "America/New_York"}})
+    assert daily.forecast_days == []
+    assert "nextPageToken" not in daily.to_dict()
+
+    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