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

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "python-google-weather-api"
-version = "0.0.8"
+version = "0.0.10"
 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.8 → python_google_weather_api-0.0.10}/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.8 → python_google_weather_api-0.0.10}/src/google_weather_api/api.py

@@ -11,6 +11,7 @@ import aiohttp
 from .exceptions import (
     GoogleWeatherApiAuthError,
     GoogleWeatherApiConnectionError,
+    GoogleWeatherApiConnectionTimeoutError,
     GoogleWeatherApiResponseError,
 )
 from .model import (
@@ -23,6 +24,8 @@ from .model import (
 _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"
 
 
@@ -49,7 +52,10 @@ class GoogleWeatherApi:
     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 = {
@@ -58,9 +64,7 @@ class GoogleWeatherApi:
         }
         if include_language_code:
             params["language_code"] = self.language_code
-        # Log before adding the API key so it doesn't end up in debug logs.
         _LOGGER.debug("GET %s with params: %s", url, params)
-        params["key"] = self.api_key
         try:
             async with self.session.get(
                 url,
@@ -68,28 +72,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,

{python_google_weather_api-0.0.8 → python_google_weather_api-0.0.10}/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.8 → python_google_weather_api-0.0.10}/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
@@ -523,12 +524,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."""
 
@@ -631,12 +632,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.8 → python_google_weather_api-0.0.10/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.8
+Version: 0.0.10
 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.8 → python_google_weather_api-0.0.10}/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,
 )
 
@@ -41,7 +44,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 +130,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:
@@ -230,6 +234,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)
@@ -238,6 +268,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"),
     [
@@ -283,3 +330,45 @@ 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
+
+
+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

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

@@ -175,3 +175,14 @@ 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()