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

{python_google_weather_api-0.0.7/src/python_google_weather_api.egg-info → python_google_weather_api-0.0.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-google-weather-api
-Version: 0.0.7
+Version: 0.0.9
 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.7 → python_google_weather_api-0.0.9}/pyproject.toml

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

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

@@ -21,9 +21,11 @@ from .model import (
     IceThickness,
     Interval,
     LocalizedText,
+    MinuteForecastResponse,
     MoonEvents,
     Precipitation,
     PrecipitationProbability,
+    PrecipitationSegment,
     QuantitativePrecipitationForecast,
     SunEvents,
     Temperature,
@@ -54,9 +56,11 @@ __all__ = [
     "IceThickness",
     "Interval",
     "LocalizedText",
+    "MinuteForecastResponse",
     "MoonEvents",
     "Precipitation",
     "PrecipitationProbability",
+    "PrecipitationSegment",
     "QuantitativePrecipitationForecast",
     "SunEvents",
     "Temperature",

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

@@ -17,11 +17,14 @@ from .model import (
     CurrentConditionsResponse,
     DailyForecastResponse,
     HourlyForecastResponse,
+    MinuteForecastResponse,
 )
 
 _LOGGER = logging.getLogger(__name__)
 
 _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"
 _USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36"
 
 
@@ -45,20 +48,22 @@ class GoogleWeatherApi:
         self.referrer = referrer
         self.timeout = aiohttp.ClientTimeout(total=timeout)
 
-    async def _async_get(self, endpoint: str, params: dict[str, Any]) -> dict[str, Any]:
+    async def _async_get(self, endpoint: str, params: dict[str, Any], *, include_language_code: bool = True) -> dict[str, Any]:
         """Perform a GET request."""
         url = f"{_BASE_URL}/{endpoint}"
-        headers = {aiohttp.hdrs.USER_AGENT: _USER_AGENT}
+        # Send the API key in a header rather than the "key" query parameter so it
+        # never ends up in a URL, which aiohttp includes in exceptions such as
+        # ContentTypeError and which callers commonly log.
+        headers = {aiohttp.hdrs.USER_AGENT: _USER_AGENT, _API_KEY_HEADER: self.api_key}
         if self.referrer:
             headers[aiohttp.hdrs.REFERER] = self.referrer
         params = {
             **params,
-            "language_code": self.language_code,
             "units_system": self.units_system,
         }
-        # Log before adding the API key so it doesn't end up in debug logs.
+        if include_language_code:
+            params["language_code"] = self.language_code
         _LOGGER.debug("GET %s with params: %s", url, params)
-        params["key"] = self.api_key
         try:
             async with self.session.get(
                 url,
@@ -89,18 +94,27 @@ class GoogleWeatherApi:
             raise GoogleWeatherApiConnectionError(err) from err
 
     async def _async_get_all_pages(
-        self, endpoint: str, params: dict[str, Any], records_key: str, limit: int
+        self,
+        endpoint: str,
+        params: dict[str, Any],
+        records_key: str,
+        limit: int,
+        *,
+        include_language_code: bool = True,
     ) -> dict[str, Any]:
         """Perform a GET request, following pagination until `limit` records are collected.
 
-        The API caps the number of records it returns per page (24 for hourly forecasts),
-        regardless of the requested page size, so a single request is not enough.
+        Some endpoints cap the number of records they return per page regardless of the
+        requested page size, for example 24 for hourly forecasts, so a single request is
+        not always enough.
         """
         params = {**params, "page_size": limit}
-        data = await self._async_get(endpoint, params)
+        data = await self._async_get(endpoint, params, include_language_code=include_language_code)
         records: list[Any] = data.get(records_key, [])
         while len(records) < limit and (page_token := data.get("nextPageToken")):
-            data = await self._async_get(endpoint, {**params, "page_token": page_token})
+            data = await self._async_get(
+                endpoint, {**params, "page_token": page_token}, include_language_code=include_language_code
+            )
             page_records: list[Any] = data.get(records_key, [])
             if not page_records:
                 break
@@ -155,3 +169,26 @@ class GoogleWeatherApi:
             days,
         )
         return DailyForecastResponse.from_dict(data)
+
+    async def async_get_minute_forecast(
+        self, latitude: float, longitude: float, page_size: int = 360
+    ) -> MinuteForecastResponse:
+        """Fetch the precipitation nowcast for up to 6 hours.
+
+        Segments cover 2- or 15-minute intervals depending on the location. The endpoint
+        does not accept language_code (a reserved field in google.maps.weather.v1), so it
+        is omitted from these requests.
+
+        See https://developers.google.com/maps/documentation/weather/minute-forecast
+        """
+        data = await self._async_get_all_pages(
+            "forecast/minutes:lookup",
+            {
+                "location.latitude": latitude,
+                "location.longitude": longitude,
+            },
+            "segments",
+            page_size,
+            include_language_code=False,
+        )
+        return MinuteForecastResponse.from_dict(data)

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

@@ -639,3 +639,64 @@ class HourlyForecastResponse(BaseModel):
 
     next_page_token: str | None = field(default=None, metadata={"alias": "nextPageToken"})
     """The token to retrieve the next page."""
+
+
+@dataclass
+class PrecipitationSegment(BaseModel):
+    """Represents a segment of precipitation forecast data."""
+
+    class DominantPrecipitationType(ApiStrEnum):
+        """Represents the type of precipitation of a segment."""
+
+        DOMINANT_PRECIPITATION_TYPE_UNSPECIFIED = "DOMINANT_PRECIPITATION_TYPE_UNSPECIFIED"
+        NONE = "NONE"
+        RAIN = "RAIN"
+        SNOW = "SNOW"
+        HAIL = "HAIL"
+
+    class PrecipitationIntensity(ApiStrEnum):
+        """Represents the precipitation intensity of a segment."""
+
+        PRECIPITATION_INTENSITY_UNSPECIFIED = "PRECIPITATION_INTENSITY_UNSPECIFIED"
+        NO_INTENSITY = "NO_INTENSITY"
+        LIGHT = "LIGHT"
+        MID_LIGHT = "MID_LIGHT"
+        MODERATE = "MODERATE"
+        MID_MODERATE = "MID_MODERATE"
+        HEAVY = "HEAVY"
+        MID_HEAVY = "MID_HEAVY"
+
+    time_frame: Interval = field(metadata={"alias": "timeFrame"})
+    """The timeframe relevant to the segment."""
+
+    type: DominantPrecipitationType = DominantPrecipitationType.DOMINANT_PRECIPITATION_TYPE_UNSPECIFIED
+    """A code that indicates the type of precipitation."""
+
+    probability: int = 0
+    """The chance of precipitation (values from 0 to 100)."""
+
+    qpf: QuantitativePrecipitationForecast | None = None
+    """The amount of precipitation, measured as liquid water equivalent."""
+
+    snowfall_amount: QuantitativePrecipitationForecast | None = field(default=None, metadata={"alias": "snowfallAmount"})
+    """The amount of snow accumulation, measured as liquid water equivalent."""
+
+    intensity: PrecipitationIntensity = PrecipitationIntensity.PRECIPITATION_INTENSITY_UNSPECIFIED
+    """A code that indicates the precipitation intensity of the segment."""
+
+
+@dataclass
+class MinuteForecastResponse(BaseModel):
+    """Response model for the forecast.minutes.lookup method."""
+
+    overall_prediction_timeframe: Interval = field(metadata={"alias": "overallPredictionTimeframe"})
+    """The overall timeframe for the predictions."""
+
+    time_zone: TimeZone = field(metadata={"alias": "timeZone"})
+    """The time zone at the requested location."""
+
+    segments: list[PrecipitationSegment] = field(default_factory=list)
+    """The minute-level prediction segments."""
+
+    next_page_token: str | None = field(default=None, metadata={"alias": "nextPageToken"})
+    """The token to retrieve the next page."""

{python_google_weather_api-0.0.7 → python_google_weather_api-0.0.9/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.7
+Version: 0.0.9
 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.7 → python_google_weather_api-0.0.9}/tests/test_api.py

@@ -41,7 +41,8 @@ async def test_request_params_and_headers(api: GoogleWeatherApi, mock_server: Mo
     await api.async_get_current_conditions(LATITUDE, LONGITUDE)
 
     request = mock_server.requests[0]
-    assert request.query["key"] == API_KEY
+    assert request.headers["X-Goog-Api-Key"] == API_KEY
+    assert "key" not in request.query
     assert request.query["location.latitude"] == str(LATITUDE)
     assert request.query["location.longitude"] == str(LONGITUDE)
     assert request.query["language_code"] == "en"
@@ -126,7 +127,7 @@ async def test_get_hourly_forecast_follows_pagination(api: GoogleWeatherApi, moc
     assert first.query["hours"] == "4"
     assert second.query["page_token"] == page1["nextPageToken"]
     assert second.query["hours"] == "4"
-    assert second.query["key"] == API_KEY
+    assert second.headers["X-Goog-Api-Key"] == API_KEY
 
 
 async def test_hourly_forecast_stops_once_enough_records(api: GoogleWeatherApi, mock_server: MockServer) -> None:
@@ -238,6 +239,23 @@ async def test_non_json_response(api: GoogleWeatherApi, mock_server: MockServer)
         await api.async_get_current_conditions(LATITUDE, LONGITUDE)
 
 
+async def test_api_key_not_in_error_message(api: GoogleWeatherApi, mock_server: MockServer) -> None:
+    """Test the API key does not leak into errors that include the request URL.
+
+    aiohttp includes the full request URL in ContentTypeError, which callers
+    commonly log, e.g. for a 502 HTML page from a proxy in front of the API.
+    """
+    mock_server.add_response("<html>502 Bad Gateway</html>", status=HTTPStatus.BAD_GATEWAY)
+
+    with pytest.raises(GoogleWeatherApiConnectionError) as exc_info:
+        await api.async_get_current_conditions(LATITUDE, LONGITUDE)
+
+    assert "currentConditions:lookup" in str(exc_info.value)
+    assert API_KEY not in str(exc_info.value)
+    # Tracebacks render chained exceptions with str(), so the cause must be clean too.
+    assert API_KEY not in str(exc_info.value.__cause__)
+
+
 @pytest.mark.parametrize(
     ("raised", "expected_message"),
     [
@@ -267,3 +285,19 @@ async def test_custom_timeout(session: aiohttp.ClientSession) -> None:
     api = GoogleWeatherApi(session=session, api_key=API_KEY, timeout=30)
 
     assert api.timeout.total == 30
+
+
+async def test_get_minute_forecast(api: GoogleWeatherApi, mock_server: MockServer) -> None:
+    """Test fetching the minute forecast, which must not send language_code."""
+    mock_server.add_response(load_fixture("minute_forecast"))
+
+    result = await api.async_get_minute_forecast(LATITUDE, LONGITUDE)
+
+    assert result.time_zone.id == "America/New_York"
+    assert result.overall_prediction_timeframe.start_time == "2026-08-11T14:17:00Z"
+    assert len(result.segments) == 2
+    assert result.segments[0].probability == 62
+    request = mock_server.requests[0]
+    assert request.path == "/v1/forecast/minutes:lookup"
+    assert request.query["page_size"] == "360"
+    assert "language_code" not in request.query

{python_google_weather_api-0.0.7 → python_google_weather_api-0.0.9}/tests/test_model.py

@@ -13,8 +13,10 @@ from google_weather_api import (
     HourlyForecastResponse,
     IceThickness,
     Interval,
+    MinuteForecastResponse,
     MoonEvents,
     PrecipitationProbability,
+    PrecipitationSegment,
     QuantitativePrecipitationForecast,
     Temperature,
     Visibility,
@@ -32,12 +34,15 @@ _RESPONSES = [
     (CurrentConditionsResponse, "current_conditions"),
     (DailyForecastResponse, "daily_forecast"),
     (HourlyForecastResponse, "hourly_forecast_page1"),
+    (MinuteForecastResponse, "minute_forecast"),
 ]
 
 _ENUMS = [
     IceThickness.Unit,
     MoonEvents.MoonPhase,
     PrecipitationProbability.PrecipitationType,
+    PrecipitationSegment.DominantPrecipitationType,
+    PrecipitationSegment.PrecipitationIntensity,
     QuantitativePrecipitationForecast.Unit,
     Temperature.TemperatureUnit,
     Visibility.Unit,
@@ -141,3 +146,32 @@ def test_next_page_token_is_optional() -> None:
     data.pop("nextPageToken", None)
 
     assert DailyForecastResponse.from_dict(data).next_page_token is None
+
+
+def test_minute_forecast_segment_defaults() -> None:
+    """Test parsing a minute forecast where proto3-default segment fields are omitted."""
+    response = MinuteForecastResponse.from_dict(
+        {
+            "overallPredictionTimeframe": {"startTime": "2026-08-11T14:17:00Z"},
+            "timeZone": {"id": "America/New_York"},
+            "segments": [{"timeFrame": {"startTime": "2026-08-11T14:16:00Z"}, "type": "NONE"}],
+        }
+    )
+    segment = response.segments[0]
+    assert segment.type is PrecipitationSegment.DominantPrecipitationType.NONE
+    assert segment.probability == 0
+    assert segment.qpf is None
+    assert segment.snowfall_amount is None
+    assert segment.intensity is PrecipitationSegment.PrecipitationIntensity.PRECIPITATION_INTENSITY_UNSPECIFIED
+    assert response.next_page_token is None
+
+
+def test_minute_forecast_without_segments() -> None:
+    """Test parsing a minute forecast response where the segments list is omitted."""
+    response = MinuteForecastResponse.from_dict(
+        {
+            "overallPredictionTimeframe": {"startTime": "2026-08-11T14:17:00Z"},
+            "timeZone": {"id": "America/New_York"},
+        }
+    )
+    assert response.segments == []