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

{python_google_weather_api-0.0.9/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.9
+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.9 → python_google_weather_api-0.0.10}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "python-google-weather-api"
-version = "0.0.9"
+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.9 → 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.9 → 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 (
@@ -71,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.9 → 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.9 → 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.9 → 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.9
+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.9 → 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,
 )
 
@@ -231,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)
@@ -301,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.9 → 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()