env-canada 0.7.2__py3-none-any.whl → 0.9.0__py3-none-any.whl

env_canada/__init__.py

@@ -1,5 +1,15 @@
+__all__ = [
+    "ECAirQuality",
+    "ECHistorical",
+    "ECHistoricalRange",
+    "ECHydro",
+    "ECRadar",
+    "ECWeather",
+    "ECWeatherUpdateFailed",
+]
+
 from .ec_aqhi import ECAirQuality
 from .ec_historical import ECHistorical, ECHistoricalRange
 from .ec_hydro import ECHydro
 from .ec_radar import ECRadar
-from .ec_weather import ECWeather
+from .ec_weather import ECWeather, ECWeatherUpdateFailed

env_canada/constants.py

@@ -1 +1 @@
-USER_AGENT = "env_canada/0.7.2"
+USER_AGENT = "env_canada/0.8.0"

env_canada/ec_aqhi.py

@@ -1,10 +1,10 @@
-from datetime import datetime, timezone
 import logging
+from datetime import datetime, timezone
 
+import voluptuous as vol
 from aiohttp import ClientSession
-import defusedxml.ElementTree as et
 from geopy import distance
-import voluptuous as vol
+from lxml import etree as et
 
 from .constants import USER_AGENT
 
@@ -43,7 +43,7 @@ async def get_aqhi_regions(language):
         )
         result = await response.read()
 
-    site_xml = result.decode("utf-8")
+    site_xml = result
     xml_object = et.fromstring(site_xml)
 
     for zone in xml_object.findall("./EC_administrativeZone"):
@@ -83,7 +83,7 @@ async def find_closest_region(language, lat, lon):
     return min(region_list, key=site_distance)
 
 
-class ECAirQuality(object):
+class ECAirQuality:
     """Get air quality data from Environment Canada."""
 
     def __init__(self, **kwargs):
@@ -152,7 +152,7 @@ class ECAirQuality(object):
                 return None
 
             result = await response.read()
-            aqhi_xml = result.decode("ISO-8859-1")
+            aqhi_xml = result
             return et.fromstring(aqhi_xml)
 
     async def update(self):

env_canada/ec_cache.py

@@ -1,8 +1,9 @@
 from datetime import datetime
+from typing import Any, ClassVar
 
 
 class Cache:
-    _cache = {}
+    _cache: ClassVar[dict[str, tuple[datetime, Any]]] = {}
 
     @classmethod
     def add(cls, cache_key, item, cache_time):

env_canada/ec_historical.py

@@ -1,26 +1,28 @@
+import asyncio
 import copy
 import csv
+import logging
 from datetime import datetime
-from dateutil.relativedelta import relativedelta
 from io import StringIO
-import logging
-import xml.etree.ElementTree as et
-import pandas as pd
-import asyncio
 
-from aiohttp import ClientSession
-from dateutil import parser, tz
-import defusedxml.ElementTree as et
 import lxml.html
+import pandas as pd
 import voluptuous as vol
+from aiohttp import ClientSession
+from dateutil import parser, tz
+from dateutil.relativedelta import relativedelta
+from lxml import etree as et
 
 from .constants import USER_AGENT
 
-
 STATIONS_URL = "https://climate.weather.gc.ca/historical_data/search_historic_data_stations_{}.html"
 
 WEATHER_URL = "https://climate.weather.gc.ca/climate_data/bulk_data_{}.html"
 
+_TODAY = datetime.today().date()
+_ONE_YEAR_AGO = _TODAY - relativedelta(years=1, months=1, day=1)
+_YEAR = datetime.today().year
+
 LOG = logging.getLogger(__name__)
 
 __all__ = ["ECHistorical"]
@@ -126,7 +128,7 @@ async def get_historical_stations(
     coordinates,
     radius=25,
     start_year=1840,
-    end_year=datetime.today().year,
+    end_year=_YEAR,
     limit=25,
     language="english",
     timeframe=2,
@@ -204,8 +206,7 @@ async def get_historical_stations(
         return stations
 
 
-class ECHistorical(object):
-
+class ECHistorical:
     """Get historical weather data from Environment Canada."""
 
     def __init__(self, **kwargs):
@@ -353,30 +354,30 @@ def flip_daterange(f):
     return wrapper
 
 
-class ECHistoricalRange(object):
+class ECHistoricalRange:
     """Get historical weather data from Environment Canada in the given range for the given station.
 
-    options are daily or hourly data
+        options are daily or hourly data
 
-    Example:
-        import pandas as pd
-        import asyncio
-        from env_canada import ECHistoricalRange, get_historical_stations
-        from datetime import datetime
+        Example:
+            import pandas as pd
+            import asyncio
+            from env_canada import ECHistoricalRange, get_historical_stations
+            from datetime import datetime
 
-        coordinates = ['48.508333', '-68.467667']
+            coordinates = ['48.508333', '-68.467667']
 
-        stations = pd.DataFrame(asyncio.run(get_historical_stations(coordinates, start_year=2022,
-                                                        end_year=2022, radius=200, limit=100))).T
+            stations = pd.DataFrame(asyncio.run(get_historical_stations(coordinates, start_year=2022,
+                                                            end_year=2022, radius=200, limit=100))).T
 
-        ec = ECHistoricalRange(station_id=int(stations.iloc[0,2]), timeframe="hourly",
-                                daterange=(datetime(2022, 7, 1, 12, 12), datetime(2022, 8, 1, 12, 12)))
+            ec = ECHistoricalRange(station_id=int(stations.iloc[0,2]), timeframe="hourly",
+                                    daterange=(datetime(2022, 7, 1, 12, 12), datetime(2022, 8, 1, 12, 12)))
 
-        ec.get_data()
+            ec.get_data()
 
-        ec.xml #yield an XML formatted str. For more options, use ec.to_xml(*arg, **kwargs) with pandas options
-
-        ec.csv #yield an CSV formatted str. For more options, use ec.to_csv(*arg, **kwargs) with pandas options
+            ec.xml #yield an XML formatted str. For more options, use ec.to_xml(*arg, **kwargs) with pandas options
+    =
+            ec.csv #yield an CSV formatted str. For more options, use ec.to_csv(*arg, **kwargs) with pandas options
     """
 
     @flip_daterange
@@ -384,8 +385,8 @@ class ECHistoricalRange(object):
         self,
         station_id,
         daterange=(
-            datetime.today().date() - relativedelta(years=1, months=1, day=1),
-            datetime.today().date(),
+            _ONE_YEAR_AGO,
+            _TODAY,
         ),
         language="english",
         timeframe="daily",
@@ -409,7 +410,14 @@ class ECHistoricalRange(object):
         self.months = self.monthlist(daterange=daterange)
         self.language = language
         _tf = {"hourly": 1, "daily": 2, "monthly": 3}
-        self.timeframe = _tf[timeframe]
+        timeframe_int = _tf[timeframe]
+        if timeframe_int == 2:
+            # prune the months list so it only has unique years. if daily is selected.
+            years = set()
+            for year, _ in self.months:
+                years.add(year)
+            self.months = [(year, 1) for year in years]
+        self.timeframe = timeframe_int
 
     def get_data(self):
         """
@@ -419,7 +427,6 @@ class ECHistoricalRange(object):
         """
         if not self.df.empty:
             self.df = pd.DataFrame()
-
         ec = [
             ECHistorical(
                 station_id=self.station_id,
@@ -437,7 +444,7 @@ class ECHistoricalRange(object):
             self.df = pd.concat((self.df, pd.read_csv(data.station_data)))
 
         self.df = self.df.set_index(
-            self.df.filter(regex="Date/*", axis=1).columns.values[0]
+            self.df.filter(regex="Date/*", axis=1).columns.to_numpy()[0]
         )
         self.df.index = pd.to_datetime(self.df.index)
 
@@ -477,7 +484,10 @@ class ECHistoricalRange(object):
     @flip_daterange
     def monthlist(self, daterange):
         startdate, stopdate = daterange
-        total_months = lambda dt: dt.month + 12 * dt.year
+
+        def total_months(dt):
+            return dt.month + 12 * dt.year
+
         mlist = []
         for tot_m in range(total_months(startdate) - 1, total_months(stopdate)):
             y, m = divmod(tot_m, 12)

env_canada/ec_hydro.py

@@ -1,10 +1,10 @@
 import csv
 import io
 
+import voluptuous as vol
 from aiohttp import ClientSession
 from dateutil.parser import isoparse
 from geopy import distance
-import voluptuous as vol
 
 from .constants import USER_AGENT
 
@@ -54,8 +54,7 @@ async def closest_site(lat, lon):
     return closest
 
 
-class ECHydro(object):
-
+class ECHydro:
     """Get hydrometric data from Environment Canada."""
 
     def __init__(self, **kwargs):

env_canada/ec_radar.py

@@ -1,16 +1,16 @@
 import asyncio
-from datetime import date, timedelta
 import logging
 import math
 import os
+from datetime import date, timedelta
 from io import BytesIO
 from typing import cast
 
 import dateutil.parser
-import defusedxml.ElementTree as et
 import voluptuous as vol
 from aiohttp import ClientSession
 from aiohttp.client_exceptions import ClientConnectorError
+from lxml import etree as et
 from PIL import Image, ImageDraw, ImageFont
 
 from .constants import USER_AGENT
@@ -114,7 +114,7 @@ async def _get_resource(url, params, bytes=True):
         return await response.text()
 
 
-class ECRadar(object):
+class ECRadar:
     def __init__(self, **kwargs):
         """Initialize the radar object."""
 
@@ -195,7 +195,7 @@ class ECRadar(object):
                 return Cache.add("basemap", base_bytes, timedelta(days=7))
 
             except ClientConnectorError as e:
-                logging.warning("Map from %s could not be retrieved: %s" % map_url, e)
+                logging.warning("Map from %s could not be retrieved: %s", map_url, e)
 
     async def _get_legend(self):
         """Fetch legend image."""
@@ -226,7 +226,7 @@ class ECRadar(object):
         if not (capabilities_xml := Cache.get(capabilities_cache_key)):
             capabilities_params["layer"] = precip_layers[self._precip_type_actual]
             capabilities_xml = await _get_resource(
-                geomet_url, capabilities_params, bytes=False
+                geomet_url, capabilities_params, bytes=True
             )
             Cache.add(capabilities_cache_key, capabilities_xml, timedelta(minutes=5))
 
@@ -236,9 +236,9 @@ class ECRadar(object):
         )
         if dimension_string is not None:
             if dimension_string := dimension_string.text:
-                start, end = [
+                start, end = (
                     dateutil.parser.isoparse(t) for t in dimension_string.split("/")[:2]
-                ]
+                )
                 self.timestamp = end.isoformat()
                 return (start, end)
         return None

env_canada/ec_weather.py

@@ -1,13 +1,19 @@
 import csv
-import datetime
 import logging
 import re
-
-from aiohttp import ClientSession
-from dateutil import parser, relativedelta, tz
-import defusedxml.ElementTree as et
-from geopy import distance
+from dataclasses import dataclass
+from datetime import datetime, timedelta, timezone
 import voluptuous as vol
+from aiohttp import (
+    ClientConnectorDNSError,
+    ClientResponseError,
+    ClientSession,
+    ClientTimeout,
+)
+from dateutil import parser, tz
+from geopy import distance
+from lxml import etree as et
+from lxml.etree import _Element
 
 from . import ec_exc
 from .constants import USER_AGENT
@@ -16,6 +22,8 @@ SITE_LIST_URL = "https://dd.weather.gc.ca/citypage_weather/docs/site_list_en.csv
 
 WEATHER_URL = "https://dd.weather.gc.ca/citypage_weather/xml/{}_{}.xml"
 
+CLIENT_TIMEOUT = ClientTimeout(10)
+
 LOG = logging.getLogger(__name__)
 
 ATTRIBUTION = {
@@ -24,7 +32,17 @@ ATTRIBUTION = {
 }
 
 
-__all__ = ["ECWeather"]
+__all__ = ["ECWeather", "ECWeatherUpdateFailed"]
+
+
+@dataclass
+class MetaData:
+    attribution: str
+    timestamp: datetime = datetime(1970, 1, 1, 0, 0, tzinfo=timezone.utc)
+    station: str | None = None
+    location: str | None = None
+    cache_returned_on_update: int = 0  # Resets to 0 after successful update
+    last_update_error: str = ""
 
 
 conditions_meta = {
@@ -179,35 +197,30 @@ summary_meta = {
     "label": {"english": "Forecast", "french": "Prévision"},
 }
 
-alerts_meta = {
-    "warnings": {
-        "english": {"label": "Warnings", "pattern": ".*WARNING((?!ENDED).)*$"},
-        "french": {
-            "label": "Alertes",
-            "pattern": ".*(ALERTE|AVERTISSEMENT)((?!TERMINÉ).)*$",
-        },
-    },
-    "watches": {
-        "english": {"label": "Watches", "pattern": ".*WATCH((?!ENDED).)*$"},
-        "french": {"label": "Veilles", "pattern": ".*VEILLE((?!TERMINÉ).)*$"},
-    },
-    "advisories": {
-        "english": {"label": "Advisories", "pattern": ".*ADVISORY((?!ENDED).)*$"},
-        "french": {"label": "Avis", "pattern": ".*AVIS((?!TERMINÉ).)*$"},
-    },
-    "statements": {
-        "english": {"label": "Statements", "pattern": ".*STATEMENT((?!ENDED).)*$"},
-        "french": {"label": "Bulletins", "pattern": ".*BULLETIN((?!TERMINÉ).)*$"},
+ALERTS_INIT = {
+    "english": {
+        "warnings": {"label": "Warnings", "value": []},
+        "watches": {"label": "Watches", "value": []},
+        "advisories": {"label": "Advisories", "value": []},
+        "statements": {"label": "Statements", "value": []},
+        "endings": {"label": "Endings", "value": []},
     },
-    "endings": {
-        "english": {"label": "Endings", "pattern": ".*ENDED"},
-        "french": {"label": "Terminaisons", "pattern": ".*TERMINÉE?"},
+    "french": {
+        "warnings": {"label": "Alertes", "value": []},
+        "watches": {"label": "Veilles", "value": []},
+        "advisories": {"label": "Avis", "value": []},
+        "statements": {"label": "Bulletins", "value": []},
+        "endings": {"label": "Terminaisons", "value": []},
     },
 }
 
-metadata_meta = {
-    "timestamp": {"xpath": "./dateTime/timeStamp"},
-    "location": {"xpath": "./location/name"},
+# Maps "type" in XML alert attribute to name used
+ALERT_TYPE_TO_NAME = {
+    "advisory": "advisories",
+    "ending": "endings",
+    "statement": "statements",
+    "warning": "warnings",
+    "watch": "watches",
 }
 
 
@@ -220,8 +233,15 @@ def validate_station(station):
     return station
 
 
-def parse_timestamp(t):
-    return parser.parse(t).replace(tzinfo=tz.UTC)
+def _parse_timestamp(time_str: str | None) -> datetime | None:
+    if time_str is not None:
+        return parser.parse(time_str).replace(tzinfo=tz.UTC)
+    return None
+
+
+def _get_xml_text(xml_root: _Element, xpath: str) -> str | None:
+    element = xml_root.find(xpath)
+    return None if element is None or element.text is None else element.text
 
 
 async def get_ec_sites():
@@ -231,7 +251,7 @@ async def get_ec_sites():
 
     async with ClientSession(raise_for_status=True) as session:
         response = await session.get(
-            SITE_LIST_URL, headers={"User-Agent": USER_AGENT}, timeout=10
+            SITE_LIST_URL, headers={"User-Agent": USER_AGENT}, timeout=CLIENT_TIMEOUT
         )
         sites_csv_string = await response.text()
 
@@ -259,7 +279,7 @@ def closest_site(site_list, lat, lon):
     return "{}/{}".format(closest["Province Codes"], closest["Codes"])
 
 
-class ECWeather(object):
+class ECWeather:
     """Get weather data from Environment Canada."""
 
     def __init__(self, **kwargs):
@@ -292,7 +312,7 @@ class ECWeather(object):
 
         self.language = kwargs["language"]
         self.max_data_age = kwargs["max_data_age"]
-        self.metadata = {"attribution": ATTRIBUTION[self.language]}
+        self.metadata = MetaData(ATTRIBUTION[self.language])
         self.conditions = {}
         self.alerts = {}
         self.daily_forecasts = []
@@ -309,9 +329,29 @@ class ECWeather(object):
             self.lat = kwargs["coordinates"][0]
             self.lon = kwargs["coordinates"][1]
 
-    async def update(self):
+    def handle_error(self, err: Exception | None, msg: str) -> None:
+        """
+        Handle an known error, returning previous results if they have not expired, or
+        raising an exception if previous results have expired. Set the last_update_error
+        to the error no matter what.
+
+        On returning previous results, bump the cache returned counter else clear the counter.
+        """
+        expiry = self.metadata.timestamp + timedelta(hours=self.max_data_age)
+        self.metadata.last_update_error = msg
+        if expiry > datetime.now(timezone.utc):
+            self.metadata.cache_returned_on_update += 1
+            return
+
+        self.metadata.cache_returned_on_update = 0
+        raise ECWeatherUpdateFailed(msg) from err
+
+    async def update(self) -> None:
         """Get the latest data from Environment Canada."""
 
+        # Clear error at start, any error that is handled will set it
+        self.metadata.last_update_error = ""
+
         # Determine station ID or coordinates if not provided
         if not self.site_list:
             self.site_list = await get_ec_sites()
@@ -335,40 +375,43 @@ class ECWeather(object):
         )
 
         # Get weather data
-        async with ClientSession(raise_for_status=True) as session:
-            response = await session.get(
-                WEATHER_URL.format(self.station_id, self.language[0]),
-                headers={"User-Agent": USER_AGENT},
-                timeout=10,
+        try:
+            async with ClientSession(raise_for_status=True) as session:
+                response = await session.get(
+                    WEATHER_URL.format(self.station_id, self.language[0]),
+                    headers={"User-Agent": USER_AGENT},
+                    timeout=CLIENT_TIMEOUT,
+                )
+                weather_xml = await response.text()
+        except (ClientConnectorDNSError, TimeoutError) as err:
+            return self.handle_error(err, f"Unable to retrieve weather: {err}")
+        except ClientResponseError as err:
+            return self.handle_error(
+                err,
+                f"Unable to retrieve weather '{err.request_info.url}': {err.message} ({err.status})",
             )
-            result = await response.read()
-        weather_xml = result.decode()
 
         try:
-            weather_tree = et.fromstring(weather_xml)
-        except et.ParseError:
-            raise ECWeatherUpdateFailed("Weather update failed; could not parse result")
-
-        # Update metadata
-        for m, meta in metadata_meta.items():
-            element = weather_tree.find(meta["xpath"])
-            if element is not None:
-                self.metadata[m] = weather_tree.find(meta["xpath"]).text
-                if m == "timestamp":
-                    self.metadata[m] = parse_timestamp(self.metadata[m])
-            else:
-                self.metadata[m] = None
-
-        # Check data age
-        if self.metadata["timestamp"] is None:
-            raise ECWeatherUpdateFailed("Weather update failed; no timestamp found")
-
-        max_age = datetime.datetime.now(
-            datetime.timezone.utc
-        ) - relativedelta.relativedelta(hours=self.max_data_age)
+            weather_tree = et.fromstring(bytes(weather_xml, encoding="utf-8"))
+        except et.ParseError as err:
+            # Parse error happens when data return is malformed (truncated, possibly because of network error)
+            return self.handle_error(
+                err, f"Could not parse retrieved weather; length {len(weather_xml)}"
+            )
 
-        if self.metadata["timestamp"] < max_age:
-            raise ECWeatherUpdateFailed("Weather update failed; outdated data returned")
+        timestamp = _parse_timestamp(
+            _get_xml_text(weather_tree, "./dateTime/timeStamp")
+        )
+        if timestamp is None:
+            return self.handle_error(
+                None, "Timestamp not found in retrieved weather; response ignored"
+            )
+        expiry = timestamp + timedelta(hours=self.max_data_age)
+        if expiry < datetime.now(timezone.utc):
+            return self.handle_error(
+                None,
+                f"Outdated conditions returned from Environment Canada '{timestamp}'; not used",
+            )
 
         # Parse condition
         def get_condition(meta):
@@ -402,21 +445,17 @@ class ECWeather(object):
                     elif meta["type"] == "str":
                         condition["value"] = element.text
                     elif meta["type"] == "timestamp":
-                        condition["value"] = parse_timestamp(element.text)
+                        condition["value"] = _parse_timestamp(element.text)
 
             return condition
 
         # Update current conditions
-        if len(weather_tree.find("./currentConditions")) > 0:
+        current_conditions = weather_tree.find("./currentConditions")
+        if current_conditions is not None and len(current_conditions) > 0:
             for c, meta in conditions_meta.items():
                 self.conditions[c] = {"label": meta[self.language]}
                 self.conditions[c].update(get_condition(meta))
 
-            # Update station metadata
-            self.metadata["station"] = weather_tree.find(
-                "./currentConditions/station"
-            ).text
-
             # Update text summary
             period = get_condition(summary_meta["forecast_period"])["value"]
             summary = get_condition(summary_meta["text_summary"])["value"]
@@ -427,67 +466,76 @@ class ECWeather(object):
             }
 
         # Update alerts
-        for category, meta in alerts_meta.items():
-            self.alerts[category] = {"value": [], "label": meta[self.language]["label"]}
-
+        self.alerts = ALERTS_INIT[self.language].copy()
         alert_elements = weather_tree.findall("./warnings/event")
-
-        for a in alert_elements:
-            title = a.attrib.get("description").strip()
-            for category, meta in alerts_meta.items():
-                category_match = re.search(meta[self.language]["pattern"], title)
-                if category_match:
-                    alert = {
-                        "title": title.title(),
-                        "date": a.find("./dateTime[last()]/textSummary").text,
+        for alert in alert_elements:
+            title = alert.attrib.get("description")
+            type_ = alert.attrib.get("type")
+            if title is not None and type_ is not None and type_ in ALERT_TYPE_TO_NAME:
+                self.alerts[ALERT_TYPE_TO_NAME[type_]]["value"].append(  # type: ignore[attr-defined]
+                    {
+                        "title": title.strip().title(),
+                        "date": _get_xml_text(alert, "./dateTime[last()]/textSummary"),
                     }
-                    self.alerts[category]["value"].append(alert)
+                )
 
         # Update forecasts
-        self.forecast_time = parse_timestamp(
-            weather_tree.findtext("./forecastGroup/dateTime/timeStamp")
+        self.forecast_time = _parse_timestamp(
+            _get_xml_text(weather_tree, "./forecastGroup/dateTime/timeStamp")
         )
         self.daily_forecasts = []
         self.hourly_forecasts = []
 
         # Update daily forecasts
-        forecast_time = self.forecast_time
-        for f in weather_tree.findall("./forecastGroup/forecast"):
-            self.daily_forecasts.append(
-                {
-                    "period": f.findtext("period"),
-                    "text_summary": f.findtext("textSummary"),
-                    "icon_code": f.findtext("./abbreviatedForecast/iconCode"),
-                    "temperature": int(f.findtext("./temperatures/temperature") or 0),
-                    "temperature_class": f.find(
-                        "./temperatures/temperature"
-                    ).attrib.get("class"),
-                    "precip_probability": int(
-                        f.findtext("./abbreviatedForecast/pop") or "0"
-                    ),
-                    "timestamp": forecast_time,
-                }
-            )
-            if self.daily_forecasts[-1]["temperature_class"] == "low":
-                forecast_time = forecast_time + datetime.timedelta(days=1)
+        if self.forecast_time is not None:
+            forecast_time = self.forecast_time
+            for f in weather_tree.findall("./forecastGroup/forecast"):
+                temperature_element = f.find("./temperatures/temperature")
+                self.daily_forecasts.append(
+                    {
+                        "period": f.findtext("period"),
+                        "text_summary": f.findtext("textSummary"),
+                        "icon_code": f.findtext("./abbreviatedForecast/iconCode"),
+                        "temperature": int(
+                            f.findtext("./temperatures/temperature") or 0
+                        ),
+                        "temperature_class": temperature_element.attrib.get("class")
+                        if temperature_element is not None
+                        else None,
+                        "precip_probability": int(
+                            f.findtext("./abbreviatedForecast/pop") or "0"
+                        ),
+                        "timestamp": forecast_time,
+                    }
+                )
+                if self.daily_forecasts[-1]["temperature_class"] == "low":
+                    forecast_time = forecast_time + timedelta(days=1)
 
         # Update hourly forecasts
         for f in weather_tree.findall("./hourlyForecastGroup/hourlyForecast"):
             wind_speed_text = f.findtext("./wind/speed")
             self.hourly_forecasts.append(
                 {
-                    "period": parse_timestamp(f.attrib.get("dateTimeUTC")),
+                    "period": _parse_timestamp(f.attrib.get("dateTimeUTC")),
                     "condition": f.findtext("./condition"),
                     "temperature": int(f.findtext("./temperature") or 0),
                     "icon_code": f.findtext("./iconCode"),
                     "precip_probability": int(f.findtext("./lop") or "0"),
-                    "wind_speed": int(
-                        wind_speed_text if wind_speed_text.isnumeric() else 0
-                    ),
+                    "wind_speed": int(wind_speed_text)
+                    if wind_speed_text and wind_speed_text.isnumeric()
+                    else 0,
                     "wind_direction": f.findtext("./wind/direction"),
                 }
             )
 
+        # Update metadata at the end
+        self.metadata.cache_returned_on_update = 0
+        self.metadata.timestamp = timestamp
+        self.metadata.location = _get_xml_text(weather_tree, "./location/name")
+        self.metadata.station = _get_xml_text(
+            weather_tree, "./currentConditions/station"
+        )
+
 
 class ECWeatherUpdateFailed(Exception):
     """Raised when an update fails to get usable data."""

{env_canada-0.7.2.dist-info → env_canada-0.9.0.dist-info}/METADATA

@@ -1,34 +1,72 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: env_canada
-Version: 0.7.2
+Version: 0.9.0
 Summary: A package to access meteorological data from Environment Canada
-Home-page: https://github.com/michaeldavie/env_canada
-Author: Michael Davie
-Author-email: michael.davie@gmail.com
-License: MIT
+Author-email: Michael Davie <michael.davie@gmail.com>
+Maintainer-email: Michael Davie <michael.davie@gmail.com>
+License: Copyright (c) 2018 The Python Packaging Authority
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE
+        
+Project-URL: Homepage, https://github.com/michaeldavie/env_canada
+Project-URL: Documentation, https://github.com/michaeldavie/env_canada
+Project-URL: Repository, https://github.com/michaeldavie/env_canada
+Project-URL: Issues, https://github.com/michaeldavie/env_canada/issues
+Project-URL: Changelog, https://github.com/michaeldavie/env_canada/blob/master/CHANGELOG.md
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: aiohttp >=3.9.0
-Requires-Dist: defusedxml
-Requires-Dist: geopy
-Requires-Dist: imageio >=2.28.0
-Requires-Dist: lxml
-Requires-Dist: numpy >=1.22.2
-Requires-Dist: pandas >=1.3.0
-Requires-Dist: Pillow >=10.0.1
-Requires-Dist: python-dateutil
-Requires-Dist: voluptuous
+Requires-Dist: aiohttp>=3.9.0
+Requires-Dist: geopy>=2.4.1
+Requires-Dist: imageio>=2.28.0
+Requires-Dist: lxml>=5.3.0
+Requires-Dist: numpy>=1.22.2
+Requires-Dist: pandas>=2.2.3
+Requires-Dist: Pillow>=10.0.1
+Requires-Dist: python-dateutil>=2.9
+Requires-Dist: voluptuous>=0.15.2
+Dynamic: license-file
 
 # Environment Canada (env_canada)
 
 [![PyPI version](https://badge.fury.io/py/env-canada.svg)](https://badge.fury.io/py/env-canada)
-[![Snyk rating](https://snyk-widget.herokuapp.com/badge/pip/env-canada/badge.svg)](https://snyk.io/vuln/pip:env-canada@0.7.2?utm_source=badge)
+[![Snyk rating](https://snyk-widget.herokuapp.com/badge/pip/env-canada/badge.svg)](https://snyk.io/vuln/pip:env-canada@0.8.0?utm_source=badge)
+[![Python Lint and Test](../..//actions/workflows/python-app.yml/badge.svg)](../../actions/workflows/python-app.yml)
 
 This package provides access to various data sources published by [Environment and Climate Change Canada](https://www.canada.ca/en/environment-climate-change.html).
 
+> [!IMPORTANT]
+> If you're using the library in a Jupyter notebook, replace `asyncio.run(...)` with `await ...` in the examples below. For example:
+>
+> ```python
+> asyncio.run(ec_en.update())
+> ```
+>
+> becomes
+>
+> ```python
+> await ec_en.update()
+> ```
+
 ## Weather Observations and Forecasts
 
 `ECWeather` provides current conditions and forecasts. It automatically determines which weather station to use based on latitude/longitude provided. It is also possible to specify a specific station code of the form `AB/s0000123` based on those listed in [this CSV file](https://dd.weather.gc.ca/citypage_weather/docs/site_list_towns_en.csv). For example:
@@ -39,7 +77,7 @@ import asyncio
 from env_canada import ECWeather
 
 ec_en = ECWeather(coordinates=(50, -100))
-ec_fr = ECWeather(station_id='ON/s0000430', language='french')
+ec_fr = ECWeather(station_id="ON/s0000430", language="french")
 
 asyncio.run(ec_en.update())
 
@@ -120,7 +158,7 @@ from env_canada import ECHistorical
 from env_canada.ec_historical import get_historical_stations
 
 # search for stations, response contains station_ids
-coordinates = [53.916944, -122.749444] # [lat, long]
+coordinates = [53.916944, -122.749444]  # [lat, long]
 
 # coordinates: [lat, long]
 # radius: km
@@ -136,8 +174,12 @@ ec_fr_csv = ECHistorical(station_id=31688, year=2020, language="french", format=
 # timeframe argument can be passed to change the granularity
 # timeframe=1 hourly (need to create of for every month in that case, use ECHistoricalRange to handle it automatically)
 # timeframe=2 daily (default)
-ec_en_xml = ECHistorical(station_id=31688, year=2020, month=1, language="english", format="xml", timeframe=1)
-ec_en_csv = ECHistorical(station_id=31688, year=2020, month=1, language="english", format="csv", timeframe=1)
+ec_en_xml = ECHistorical(
+    station_id=31688, year=2020, month=1, language="english", format="xml", timeframe=1
+)
+ec_en_csv = ECHistorical(
+    station_id=31688, year=2020, month=1, language="english", format="csv", timeframe=1
+)
 
 asyncio.run(ec_en_xml.update())
 asyncio.run(ec_en_csv.update())
@@ -150,8 +192,8 @@ ec_en_xml.station_data
 
 # csv-generated responses return csv-like station data
 import pandas as pd
-df = pd.read_csv(ec_en_csv.station_data)
 
+df = pd.read_csv(ec_en_csv.station_data)
 ```
 
 `ECHistoricalRange` provides historical weather data within a specific range and handles the update by itself.
@@ -170,21 +212,29 @@ from env_canada import ECHistoricalRange
 from env_canada.ec_historical import get_historical_stations
 from datetime import datetime
 
-coordinates = ['48.508333', '-68.467667']
+coordinates = ["48.508333", "-68.467667"]
 
-stations = pd.DataFrame(asyncio.run(get_historical_stations(coordinates, start_year=2022,
-                                                end_year=2022, radius=200, limit=100))).T
+stations = pd.DataFrame(
+    asyncio.run(
+        get_historical_stations(
+            coordinates, start_year=2022, end_year=2022, radius=200, limit=100
+        )
+    )
+).T
 
-ec = ECHistoricalRange(station_id=int(stations.iloc[0,2]), timeframe="daily",
-                        daterange=(datetime(2022, 7, 1, 12, 12), datetime(2022, 8, 1, 12, 12)))
+ec = ECHistoricalRange(
+    station_id=int(stations.iloc[0, 2]),
+    timeframe="daily",
+    daterange=(datetime(2022, 7, 1, 12, 12), datetime(2022, 8, 1, 12, 12)),
+)
 
 ec.get_data()
 
-#yield an XML formated str.
+# yield an XML formated str.
 # For more options, use ec.to_xml(*arg, **kwargs) with pandas options
 ec.xml
 
-#yield an CSV formated str.
+# yield an CSV formated str.
 # For more options, use ec.to_csv(*arg, **kwargs) with pandas options
 ec.csv
 ```

env_canada-0.9.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+env_canada/10x20.pbm,sha256=ClKTs2WUmhUhTHAQzPuGwPTICGVBzCvos5l-vHRBE5M,2463
+env_canada/10x20.pil,sha256=Oki6-TD7b0xFtfm6vxCKsmpEpsZ5Jaia_0v_aDz8bfE,5143
+env_canada/__init__.py,sha256=O1KVC2GAPTmxAP46FXo9jd8Tq3YMefViowGjuxJ5JJM,366
+env_canada/constants.py,sha256=RHa-Hp2H6XroFE9Z5-H0MIUPWlFXUVKmWEidwuWzakE,32
+env_canada/ec_aqhi.py,sha256=-N4XLLgApaWZvtepJvS2lvqDSNjwV2X_fkmbtKQv8rA,7741
+env_canada/ec_cache.py,sha256=zb3n79ul7hUTE0IohDfZbRBLY-siOHPjYzWldMbuPVk,798
+env_canada/ec_exc.py,sha256=SBJwzmLf94lTx7KYVLfQYrMXYNYUoIxeVXc-BLkuXoE,67
+env_canada/ec_historical.py,sha256=qMr4RE6vfNiNa_zFolQ0PQGraok8bQtIVjs_o6sJKD4,16276
+env_canada/ec_hydro.py,sha256=JoBe-QVV8GEeZXCNFscIs2R_spgkbxCZpLt7tL6-NUI,4889
+env_canada/ec_radar.py,sha256=0SKusJWDTFODdn3D9yrhlkOS-Bv9hhBJM9EBh8TNRlk,12965
+env_canada/ec_weather.py,sha256=l-gyXePkHBLW9vidFgiPEm81xevbZCeBKzKDLiLr7Y8,19200
+env_canada-0.9.0.dist-info/licenses/LICENSE,sha256=BkgGIGgy9sv-OsI7mRi9dIQ3Su0m4IbjpZlfxv8oBbM,1073
+env_canada-0.9.0.dist-info/METADATA,sha256=divVpZpbuU3Ch7_l1hno2So0e3ePrPoDr9nLOg9_8To,12709
+env_canada-0.9.0.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+env_canada-0.9.0.dist-info/top_level.txt,sha256=fw7Pcl9ULBXYvqnAdyBdmwPXW8GSRFmhO0sLZWVfOCc,11
+env_canada-0.9.0.dist-info/RECORD,,

{env_canada-0.7.2.dist-info → env_canada-0.9.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (70.3.0)
+Generator: setuptools (78.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

{env_canada-0.7.2.dist-info → env_canada-0.9.0.dist-info/licenses}/LICENSE

@@ -16,4 +16,4 @@ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE
+SOFTWARE

env_canada-0.7.2.dist-info/RECORD

@@ -1,16 +0,0 @@
-env_canada/10x20.pbm,sha256=ClKTs2WUmhUhTHAQzPuGwPTICGVBzCvos5l-vHRBE5M,2463
-env_canada/10x20.pil,sha256=Oki6-TD7b0xFtfm6vxCKsmpEpsZ5Jaia_0v_aDz8bfE,5143
-env_canada/__init__.py,sha256=wEx1BCwVUH__GoosSlhNMHuUKCKNZAvv5uuSa5ZWq_g,187
-env_canada/constants.py,sha256=DlW7o9XEpZNQry99jZ1vF0wX7Xm7ZRcK41n0YAwzp9U,32
-env_canada/ec_aqhi.py,sha256=zEEt2U8gCxaLlePexl23r9zCfQYgmfhsP0ur2ZiupZc,7793
-env_canada/ec_cache.py,sha256=xPlXBRLyrD6dTJWLRBy12J8kzBxMUC-20-xRuc56Hts,722
-env_canada/ec_exc.py,sha256=SBJwzmLf94lTx7KYVLfQYrMXYNYUoIxeVXc-BLkuXoE,67
-env_canada/ec_historical.py,sha256=slHaFwsoyW16uCVtE3_-IF3_BFhFD4IuWl7rpIRsCm4,15901
-env_canada/ec_hydro.py,sha256=LBsWreTlaTKec6ObjI0ih8-zOKBNjD02oiXKTyUa1EQ,4898
-env_canada/ec_radar.py,sha256=zh0tbazBbvLpuxrY0yfRm9EIaXNkM6HXPe1us99h4xM,12982
-env_canada/ec_weather.py,sha256=cLWMTuvASrxYeGnXvGwsNZxd_SfD1sdfInBU51QLFCo,17026
-env_canada-0.7.2.dist-info/LICENSE,sha256=c037dTHQWAgRgDqZNN-5d-CZvcteSYN37u39SNklO0I,1072
-env_canada-0.7.2.dist-info/METADATA,sha256=M-fb4_i9Je1a2e6T5M7RIYDW33nknvWN6GHSKg60Sds,10707
-env_canada-0.7.2.dist-info/WHEEL,sha256=Z4pYXqR_rTB7OWNDYFOm1qRk0RX6GFP2o8LgvP453Hk,91
-env_canada-0.7.2.dist-info/top_level.txt,sha256=fw7Pcl9ULBXYvqnAdyBdmwPXW8GSRFmhO0sLZWVfOCc,11
-env_canada-0.7.2.dist-info/RECORD,,