env-canada 0.6.3__py3-none-any.whl → 0.7.1__py3-none-any.whl

env_canada/constants.py

@@ -1 +1 @@
-USER_AGENT = "env_canada/0.6.3"
+USER_AGENT = "env_canada/0.7.1"

env_canada/ec_aqhi.py

@@ -84,7 +84,6 @@ async def find_closest_region(language, lat, lon):
 
 
 class ECAirQuality(object):
-
     """Get air quality data from Environment Canada."""
 
     def __init__(self, **kwargs):
@@ -172,7 +171,7 @@ class ECAirQuality(object):
         # Fetch current measurement
         aqhi_current = await self.get_aqhi_data(url=AQHI_OBSERVATION_URL)
 
-        if aqhi_current:
+        if aqhi_current is not None:
             # Update region name
             element = aqhi_current.find("region")
             self.region_name = element.attrib[
@@ -202,7 +201,7 @@ class ECAirQuality(object):
         # Update AQHI forecasts
         aqhi_forecast = await self.get_aqhi_data(url=AQHI_FORECAST_URL)
 
-        if aqhi_forecast:
+        if aqhi_forecast is not None:
             # Update AQHI daily forecasts
             for f in aqhi_forecast.findall("./forecastGroup/forecast"):
                 for p in f.findall("./period"):
@@ -214,6 +213,6 @@ class ECAirQuality(object):
 
             # Update AQHI hourly forecasts
             for f in aqhi_forecast.findall("./hourlyForecastGroup/hourlyForecast"):
-                self.forecasts["hourly"][
-                    timestamp_to_datetime(f.attrib["UTCTime"])
-                ] = int(f.text or 0)
+                self.forecasts["hourly"][timestamp_to_datetime(f.attrib["UTCTime"])] = (
+                    int(f.text or 0)
+                )

env_canada/ec_cache.py

@@ -1,38 +1,25 @@
-from aiohttp import ClientSession
-from datetime import datetime, timedelta
+from datetime import datetime
 
-from .constants import USER_AGENT
-
-CACHE_EXPIRE_TIME = timedelta(minutes=200)  # Time is tuned for 3h radar image
 
+class Cache:
+    _cache = {}
 
-class CacheClientSession(ClientSession):
-    """Shim to cache ClientSession requests."""
+    @classmethod
+    def add(cls, cache_key, item, cache_time):
+        """Add an entry to the cache."""
 
-    _cache = {}
+        cls._cache[cache_key] = (datetime.now() + cache_time, item)
+        return item  # Returning item useful for chaining calls
 
-    def _flush_cache(self):
-        """Flush expired cache entries."""
+    @classmethod
+    def get(cls, cache_key):
+        """Get an entry from the cache."""
 
+        # Delete expired entries at start so we don't use expired entries
         now = datetime.now()
-        expired = [key for key, value in self._cache.items() if value[0] < now]
+        expired = [key for key, value in cls._cache.items() if value[0] < now]
         for key in expired:
-            del self._cache[key]
-
-    async def get(self, url, params, cache_time=CACHE_EXPIRE_TIME):
-        """Thin wrapper around ClientSession.get to cache responses."""
-
-        self._flush_cache()  # Flush at start so we don't use expired entries
-
-        cache_key = (url, tuple(sorted(params.items())))
-        result = self._cache.get(cache_key)
-        if not result:
-            result = (
-                datetime.now() + cache_time,
-                await super().get(
-                    url=url, params=params, headers={"User-Agent": USER_AGENT}
-                ),
-            )
-            self._cache[cache_key] = result
+            del cls._cache[key]
 
-        return result[1]
+        result = cls._cache.get(cache_key)
+        return result[1] if result else None

env_canada/ec_radar.py

@@ -1,18 +1,20 @@
 import asyncio
-import datetime
+from datetime import date, timedelta
 import logging
 import math
 import os
 from io import BytesIO
+from typing import cast
 
 import dateutil.parser
 import defusedxml.ElementTree as et
-import imageio.v2 as imageio
 import voluptuous as vol
+from aiohttp import ClientSession
 from aiohttp.client_exceptions import ClientConnectorError
 from PIL import Image, ImageDraw, ImageFont
 
-from .ec_cache import CacheClientSession as ClientSession
+from .constants import USER_AGENT
+from .ec_cache import Cache
 
 ATTRIBUTION = {
     "english": "Data provided by Environment Canada",
@@ -69,7 +71,7 @@ legend_params = {
     "sld_version": "1.1.0",
     "format": "image/png",
 }
-radar_interval = 6
+radar_interval = timedelta(minutes=6)
 
 timestamp_label = {
     "rain": {"english": "Rain", "french": "Pluie"},
@@ -77,7 +79,7 @@ timestamp_label = {
 }
 
 
-def compute_bounding_box(distance, latittude, longitude):
+def _compute_bounding_box(distance, latittude, longitude):
     """
     Modified from https://gist.github.com/alexcpn/f95ae83a7ee0293a5225
     """
@@ -102,6 +104,16 @@ def compute_bounding_box(distance, latittude, longitude):
     return lat_min, lon_min, lat_max, lon_max
 
 
+async def _get_resource(url, params, bytes=True):
+    async with ClientSession(raise_for_status=True) as session:
+        response = await session.get(
+            url=url, params=params, headers={"User-Agent": USER_AGENT}
+        )
+        if bytes:
+            return await response.read()
+        return await response.text()
+
+
 class ECRadar(object):
     def __init__(self, **kwargs):
         """Initialize the radar object."""
@@ -133,259 +145,233 @@ class ECRadar(object):
         self.language = kwargs["language"]
         self.metadata = {"attribution": ATTRIBUTION[self.language]}
 
-        # Set precipitation type
-
-        if "precip_type" in kwargs and kwargs["precip_type"] is not None:
-            self.precip_type = kwargs["precip_type"]
-        else:
-            self.precip_type = "auto"
+        self._precip_type_setting = kwargs.get("precip_type")
+        self._precip_type_actual = self.precip_type[1]
 
         # Get map parameters
-
         self.image = None
         self.width = kwargs["width"]
         self.height = kwargs["height"]
-        self.bbox = compute_bounding_box(kwargs["radius"], *kwargs["coordinates"])
+        self.bbox = _compute_bounding_box(kwargs["radius"], *kwargs["coordinates"])
         self.map_params = {
             "bbox": ",".join([str(coord) for coord in self.bbox]),
             "width": self.width,
             "height": self.height,
         }
-        self.map_image = None
         self.radar_opacity = kwargs["radar_opacity"]
 
         # Get overlay parameters
-
         self.show_legend = kwargs["legend"]
-        self.legend_layer = None
-        self.legend_image = None
-        self.legend_position = None
-
         self.show_timestamp = kwargs["timestamp"]
-        self.font = None
+
+        self._font = None
 
     @property
     def precip_type(self):
-        return self._precip_setting
+        # NOTE: this is a breaking change for this lib; HA doesn't use this so not breaking for that
+        if self._precip_type_setting in ["rain", "snow"]:
+            return (self._precip_type_setting, self._precip_type_setting)
+        self._precip_type_actual = (
+            "rain" if date.today().month in range(4, 11) else "snow"
+        )
+        return ("auto", self._precip_type_actual)
 
     @precip_type.setter
     def precip_type(self, user_input):
         if user_input not in ["rain", "snow", "auto"]:
             raise ValueError("precip_type must be 'rain', 'snow', or 'auto'")
-
-        self._precip_setting = user_input
-
-        if self._precip_setting in ["rain", "snow"]:
-            self.layer_key = self._precip_setting
-        else:
-            self._auto_precip_type()
-
-    def _auto_precip_type(self):
-        if datetime.date.today().month in range(4, 11):
-            self.layer_key = "rain"
-        else:
-            self.layer_key = "snow"
+        self._precip_type_setting = user_input
+        self._precip_type_actual = self.precip_type[1]
 
     async def _get_basemap(self):
         """Fetch the background map image."""
-        basemap_params.update(self.map_params)
-
-        try:
-            async with ClientSession(raise_for_status=True) as session:
-                response = await session.get(url=basemap_url, params=basemap_params)
-                base_bytes = await response.read()
+        if base_bytes := Cache.get("basemap"):
+            return base_bytes
 
-        except ClientConnectorError as e:
-            logging.warning("NRCan base map could not be retrieved: %s" % e)
+        basemap_params.update(self.map_params)
+        for map_url in [basemap_url, backup_map_url]:
             try:
-                async with ClientSession(raise_for_status=True) as session:
-                    response = await session.get(
-                        url=backup_map_url, params=basemap_params
-                    )
-                    base_bytes = await response.read()
-            except ClientConnectorError:
-                logging.warning("Mapbox base map could not be retrieved")
-                return None
+                base_bytes = await _get_resource(map_url, basemap_params)
+                return Cache.add("basemap", base_bytes, timedelta(days=7))
 
-        return base_bytes
+            except ClientConnectorError as e:
+                logging.warning("Map from %s could not be retrieved: %s" % map_url, e)
 
     async def _get_legend(self):
         """Fetch legend image."""
+
+        legend_cache_key = f"legend-{self._precip_type_actual}"
+        if legend := Cache.get(legend_cache_key):
+            return legend
+
         legend_params.update(
             dict(
-                layer=precip_layers[self.layer_key], style=legend_style[self.layer_key]
+                layer=precip_layers[self._precip_type_actual],
+                style=legend_style[self._precip_type_actual],
             )
         )
         try:
-            async with ClientSession(raise_for_status=True) as session:
-                response = await session.get(url=geomet_url, params=legend_params)
-                return await response.read()
+            legend = await _get_resource(geomet_url, legend_params)
+            return Cache.add(legend_cache_key, legend, timedelta(days=7))
+
         except ClientConnectorError:
             logging.warning("Legend could not be retrieved")
             return None
 
     async def _get_dimensions(self):
-        """Get time range of available data."""
-        capabilities_params["layer"] = precip_layers[self.layer_key]
-
-        async with ClientSession(raise_for_status=True) as session:
-            response = await session.get(
-                url=geomet_url,
-                params=capabilities_params,
-                cache_time=datetime.timedelta(minutes=5),
+        """Get time range of available radar images."""
+
+        capabilities_cache_key = f"capabilities-{self._precip_type_actual}"
+
+        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
             )
-            capabilities_xml = await response.text()
+            Cache.add(capabilities_cache_key, capabilities_xml, timedelta(minutes=5))
 
-        capabilities_tree = et.fromstring(capabilities_xml)
-        dimension_string = capabilities_tree.find(
-            dimension_xpath.format(layer=precip_layers[self.layer_key]),
+        dimension_string = et.fromstring(capabilities_xml).find(
+            dimension_xpath.format(layer=precip_layers[self._precip_type_actual]),
             namespaces=wms_namespace,
-        ).text
-        start, end = [
-            dateutil.parser.isoparse(t) for t in dimension_string.split("/")[:2]
-        ]
-        self.timestamp = end.isoformat()
-        return start, end
-
-    async def _combine_layers(self, radar_bytes, frame_time):
-        """Add radar overlay to base layer and add timestamp."""
-
-        base_bytes = None
-        if not self.map_image:
-            base_bytes = await self._get_basemap()
-
-        legend_bytes = None
-        if self.show_legend:
-            if not self.legend_image or self.legend_layer != self.layer_key:
-                legend_bytes = await self._get_legend()
-
-        # All the synchronous PIL stuff here
+        )
+        if dimension_string is not None:
+            if dimension_string := dimension_string.text:
+                start, end = [
+                    dateutil.parser.isoparse(t) for t in dimension_string.split("/")[:2]
+                ]
+                self.timestamp = end.isoformat()
+                return (start, end)
+        return None
+
+    async def _get_radar_image(self, frame_time):
         def _create_image():
-            radar = Image.open(BytesIO(radar_bytes)).convert("RGBA")
+            """Contains all the PIL calls; run in another thread."""
 
+            radar_image = Image.open(BytesIO(cast(bytes, radar_bytes))).convert("RGBA")
+
+            map_image = None
             if base_bytes:
-                self.map_image = Image.open(BytesIO(base_bytes)).convert("RGBA")
+                map_image = Image.open(BytesIO(base_bytes)).convert("RGBA")
 
             if legend_bytes:
-                self.legend_image = Image.open(BytesIO(legend_bytes)).convert("RGB")
-                legend_width = self.legend_image.size[0]
-                self.legend_position = (self.width - legend_width, 0)
-                self.legend_layer = self.layer_key
+                legend_image = Image.open(BytesIO(legend_bytes)).convert("RGB")
+                legend_position = (self.width - legend_image.size[0], 0)
+            else:
+                legend_image = None
+                legend_position = None
 
             # Add transparency to radar
             if self.radar_opacity < 100:
                 alpha = round((self.radar_opacity / 100) * 255)
-                radar_copy = radar.copy()
+                radar_copy = radar_image.copy()
                 radar_copy.putalpha(alpha)
-                radar.paste(radar_copy, radar)
-
-            if self.show_timestamp and not self.font:
-                self.font = ImageFont.load(
-                    os.path.join(os.path.dirname(__file__), "10x20.pil")
-                )
+                radar_image.paste(radar_copy, radar_image)
 
             # Overlay radar on basemap
-            if self.map_image:
-                frame = Image.alpha_composite(self.map_image, radar)
+            if map_image:
+                frame = Image.alpha_composite(map_image, radar_image)
             else:
-                frame = radar
+                frame = radar_image
 
             # Add legend
-            if self.show_legend and self.legend_image:
-                frame.paste(self.legend_image, self.legend_position)
+            if legend_image:
+                frame.paste(legend_image, legend_position)
 
             # Add timestamp
-            if self.show_timestamp and self.font:
-                timestamp = (
-                    timestamp_label[self.layer_key][self.language]
-                    + " @ "
-                    + frame_time.astimezone().strftime("%H:%M")
-                )
-                text_box = Image.new("RGBA", self.font.getbbox(timestamp)[2:], "white")
-                box_draw = ImageDraw.Draw(text_box)
-                box_draw.text(xy=(0, 0), text=timestamp, fill=(0, 0, 0), font=self.font)
-                double_box = text_box.resize((text_box.width * 2, text_box.height * 2))
-                frame.paste(double_box)
-                frame = frame.quantize()
-
-            # Return frame as PNG bytes
+            if self.show_timestamp:
+                if not self._font:
+                    self._font = ImageFont.load(
+                        os.path.join(os.path.dirname(__file__), "10x20.pil")
+                    )
+
+                if self._font:
+                    label = timestamp_label[self._precip_type_actual][self.language]
+                    timestamp = f"{label} @ {frame_time.astimezone().strftime('%H:%M')}"
+                    text_box = Image.new(
+                        "RGBA", self._font.getbbox(timestamp)[2:], "white"
+                    )
+                    box_draw = ImageDraw.Draw(text_box)
+                    box_draw.text(
+                        xy=(0, 0), text=timestamp, fill=(0, 0, 0), font=self._font
+                    )
+                    double_box = text_box.resize(
+                        (text_box.width * 2, text_box.height * 2)
+                    )
+                    frame.paste(double_box)
+                    frame = frame.quantize()
+
+            # Convert frame to PNG for return
             img_byte_arr = BytesIO()
             frame.save(img_byte_arr, format="PNG")
-            frame_bytes = img_byte_arr.getvalue()
 
-            return frame_bytes
+            # Time is tuned for 3h radar image
+            return Cache.add(
+                f"radar-{time}", img_byte_arr.getvalue(), timedelta(minutes=200)
+            )
 
-        # Since PIL is synchronous, run it all in another thread
-        return await asyncio.get_event_loop().run_in_executor(None, _create_image)
+        time = frame_time.strftime("%Y-%m-%dT%H:%M:00Z")
+
+        if img := Cache.get(f"radar-{time}"):
+            return img
+
+        base_bytes = await self._get_basemap()
+        legend_bytes = await self._get_legend() if self.show_legend else None
 
-    async def _get_radar_image(self, session, frame_time):
         params = dict(
             **radar_params,
             **self.map_params,
-            layers=precip_layers[self.layer_key],
-            time=frame_time.strftime("%Y-%m-%dT%H:%M:00Z")
+            layers=precip_layers[self._precip_type_actual],
+            time=time,
         )
-        response = await session.get(url=geomet_url, params=params)
-        return await response.read()
+        radar_bytes = await _get_resource(geomet_url, params)
+        return await asyncio.get_event_loop().run_in_executor(None, _create_image)
 
     async def get_latest_frame(self):
         """Get the latest image from Environment Canada."""
         dimensions = await self._get_dimensions()
-        latest = dimensions[1]
-        async with ClientSession(raise_for_status=True) as session:
-            frame = await self._get_radar_image(session=session, frame_time=latest)
-        return await self._combine_layers(frame, latest)
+        if not dimensions:
+            return None
+        return await self._get_radar_image(frame_time=dimensions[1])
 
     async def update(self):
-        if self.precip_type == "auto":
-            self._auto_precip_type()
-
         self.image = await self.get_loop()
 
     async def get_loop(self, fps=5):
         """Build an animated GIF of recent radar images."""
 
-        def build_image():
-            gif_frames = [imageio.imread(f, mode="RGBA") for f in frames]
-            gif_bytes = imageio.mimwrite(
-                imageio.RETURN_BYTES,
-                gif_frames,
+        def create_gif():
+            """Assemble animated GIF."""
+            duration = 1000 / fps
+            imgs = [Image.open(BytesIO(img)).convert("RGBA") for img in radar_layers]
+            gif = BytesIO()
+            imgs[0].save(
+                gif,
                 format="GIF",
+                save_all=True,
+                append_images=imgs[1:],
                 duration=duration,
-                subrectangles=True,
+                loop=0,
             )
-            return gif_bytes
+            return gif.getvalue()
 
-        """Build list of frame timestamps."""
-        start, end = await self._get_dimensions()
-        frame_times = [start]
+        # Without this cache priming the tasks below each compete to load map/legend
+        # at the same time, resulting in them getting retrieved for each radar image.
+        await self._get_basemap()
+        await self._get_legend() if self.show_legend else None
 
-        while True:
-            next_frame = frame_times[-1] + datetime.timedelta(minutes=radar_interval)
-            if next_frame > end:
-                break
-            else:
-                frame_times.append(next_frame)
-
-        """Fetch frames."""
+        timespan = await self._get_dimensions()
+        if not timespan:
+            logging.error("Cannot retrieve radar times.")
+            return None
 
         tasks = []
-        async with ClientSession(raise_for_status=True) as session:
-            for t in frame_times:
-                tasks.append(self._get_radar_image(session=session, frame_time=t))
-            radar_layers = await asyncio.gather(*tasks)
-
-        frames = []
-
-        for i, f in enumerate(radar_layers):
-            frames.append(await self._combine_layers(f, frame_times[i]))
-
-        for f in range(3):
-            frames.append(frames[-1])
+        curr = timespan[0]
+        while curr <= timespan[1]:
+            tasks.append(self._get_radar_image(frame_time=curr))
+            curr = curr + radar_interval
+        radar_layers = await asyncio.gather(*tasks)
 
-        """Assemble animated GIF."""
-        duration = 1000 / fps
+        for _ in range(3):
+            radar_layers.append(radar_layers[-1])
 
-        loop = asyncio.get_running_loop()
-        gif_bytes = await loop.run_in_executor(None, build_image)
-        return gif_bytes
+        return await asyncio.get_running_loop().run_in_executor(None, create_gif)

env_canada/ec_weather.py

@@ -137,24 +137,6 @@ conditions_meta = {
         "english": "Icon Code",
         "french": "Code icône",
     },
-    "high_temp_yesterday": {
-        "xpath": './yesterdayConditions/temperature[@class="high"]',
-        "type": "float",
-        "english": "High Temperature Yesterday",
-        "french": "Haute température d'hier",
-    },
-    "low_temp_yesterday": {
-        "xpath": './yesterdayConditions/temperature[@class="low"]',
-        "type": "float",
-        "english": "Low Temperature Yesterday",
-        "french": "Basse température d'hier",
-    },
-    "precip_yesterday": {
-        "xpath": "./yesterdayConditions/precip",
-        "type": "float",
-        "english": "Precipitation Yesterday",
-        "french": "Précipitation d'hier",
-    },
     "normal_high": {
         "xpath": './forecastGroup/regionalNormals/temperature[@class="high"]',
         "type": "int",
@@ -183,7 +165,7 @@ conditions_meta = {
         "xpath": "./currentConditions/dateTime/timeStamp",
         "type": "timestamp",
         "english": "Observation Time",
-        "french": "Temps d'observation"
+        "french": "Temps d'observation",
     },
 }
 
@@ -278,7 +260,6 @@ def closest_site(site_list, lat, lon):
 
 
 class ECWeather(object):
-
     """Get weather data from Environment Canada."""
 
     def __init__(self, **kwargs):
@@ -432,7 +413,9 @@ class ECWeather(object):
                 self.conditions[c].update(get_condition(meta))
 
             # Update station metadata
-            self.metadata["station"] = weather_tree.find("./currentConditions/station").text
+            self.metadata["station"] = weather_tree.find(
+                "./currentConditions/station"
+            ).text
 
             # Update text summary
             period = get_condition(summary_meta["forecast_period"])["value"]
@@ -494,7 +477,9 @@ class ECWeather(object):
                     "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.isnumeric() else 0
+                    ),
                     "wind_direction": f.findtext("./wind/direction"),
                 }
             )

{env_canada-0.6.3.dist-info → env_canada-0.7.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: env_canada
-Version: 0.6.3
+Version: 0.7.1
 Summary: A package to access meteorological data from Environment Canada
 Home-page: https://github.com/michaeldavie/env_canada
 Author: Michael Davie
@@ -25,7 +25,7 @@ Requires-Dist: voluptuous
 # 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.6.3?utm_source=badge)
+[![Snyk rating](https://snyk-widget.herokuapp.com/badge/pip/env-canada/badge.svg)](https://snyk.io/vuln/pip:env-canada@0.7.1?utm_source=badge)
 
 This package provides access to various data sources published by [Environment and Climate Change Canada](https://www.canada.ca/en/environment-climate-change.html).
 

env_canada-0.7.1.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=wEx1BCwVUH__GoosSlhNMHuUKCKNZAvv5uuSa5ZWq_g,187
+env_canada/constants.py,sha256=6oDJe86s1hRPyA0pj_MK0S_HHM8kCXd_RuHMWu0fh3E,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=M7nPeZIKLirRIcCENB8z2B8aBDZHrjltzMYPgRz9lz0,16789
+env_canada-0.7.1.dist-info/LICENSE,sha256=c037dTHQWAgRgDqZNN-5d-CZvcteSYN37u39SNklO0I,1072
+env_canada-0.7.1.dist-info/METADATA,sha256=y5JONQes6DXUWQlw4zN-XL4TjmOBdYvlVmuoxT4M0B8,10707
+env_canada-0.7.1.dist-info/WHEEL,sha256=mguMlWGMX-VHnMpKOjjQidIo1ssRlCFu4a4mBpz1s2M,91
+env_canada-0.7.1.dist-info/top_level.txt,sha256=fw7Pcl9ULBXYvqnAdyBdmwPXW8GSRFmhO0sLZWVfOCc,11
+env_canada-0.7.1.dist-info/RECORD,,

{env_canada-0.6.3.dist-info → env_canada-0.7.1.dist-info}/WHEEL

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

env_canada/ec_data.py

@@ -1,501 +0,0 @@
-from datetime import datetime, timezone
-import logging
-import re
-import xml.etree.ElementTree as et
-
-from geopy import distance
-from ratelimit import limits, RateLimitException
-import requests
-
-SITE_LIST_URL = "https://dd.weather.gc.ca/citypage_weather/docs/site_list_en.csv"
-AQHI_SITE_LIST_URL = "https://dd.weather.gc.ca/air_quality/doc/AQHI_XML_File_List.xml"
-
-WEATHER_URL = "https://hpfx.collab.science.gc.ca/{date}/WXO-DD/citypage_weather/xml/{site}_{language}.xml"
-AQHI_OBSERVATION_URL = "https://dd.weather.gc.ca/air_quality/aqhi/{}/observation/realtime/xml/AQ_OBS_{}_CURRENT.xml"
-AQHI_FORECAST_URL = "https://dd.weather.gc.ca/air_quality/aqhi/{}/forecast/realtime/xml/AQ_FCST_{}_CURRENT.xml"
-
-LOG = logging.getLogger(__name__)
-
-conditions_meta = {
-    "temperature": {
-        "xpath": "./currentConditions/temperature",
-        "english": "Temperature",
-        "french": "Température",
-    },
-    "dewpoint": {
-        "xpath": "./currentConditions/dewpoint",
-        "english": "Dew Point",
-        "french": "Point de rosée",
-    },
-    "wind_chill": {
-        "xpath": "./currentConditions/windChill",
-        "english": "Wind Chill",
-        "french": "Refroidissement éolien",
-    },
-    "humidex": {
-        "xpath": "./currentConditions/humidex",
-        "english": "Humidex",
-        "french": "Humidex",
-    },
-    "pressure": {
-        "xpath": "./currentConditions/pressure",
-        "english": "Pressure",
-        "french": "Pression",
-    },
-    "tendency": {
-        "xpath": "./currentConditions/pressure",
-        "attribute": "tendency",
-        "english": "Tendency",
-        "french": "Tendance",
-    },
-    "humidity": {
-        "xpath": "./currentConditions/relativeHumidity",
-        "english": "Humidity",
-        "french": "Humidité",
-    },
-    "visibility": {
-        "xpath": "./currentConditions/visibility",
-        "english": "Visibility",
-        "french": "Visibilité",
-    },
-    "condition": {
-        "xpath": "./currentConditions/condition",
-        "english": "Condition",
-        "french": "Condition",
-    },
-    "wind_speed": {
-        "xpath": "./currentConditions/wind/speed",
-        "english": "Wind Speed",
-        "french": "Vitesse de vent",
-    },
-    "wind_gust": {
-        "xpath": "./currentConditions/wind/gust",
-        "english": "Wind Gust",
-        "french": "Rafale de vent",
-    },
-    "wind_dir": {
-        "xpath": "./currentConditions/wind/direction",
-        "english": "Wind Direction",
-        "french": "Direction de vent",
-    },
-    "wind_bearing": {
-        "xpath": "./currentConditions/wind/bearing",
-        "english": "Wind Bearing",
-        "french": "Palier de vent",
-    },
-    "high_temp": {
-        "xpath": './forecastGroup/forecast/temperatures/temperature[@class="high"]',
-        "english": "High Temperature",
-        "french": "Haute température",
-    },
-    "low_temp": {
-        "xpath": './forecastGroup/forecast/temperatures/temperature[@class="low"]',
-        "english": "Low Temperature",
-        "french": "Basse température",
-    },
-    "uv_index": {
-        "xpath": "./forecastGroup/forecast/uv/index",
-        "english": "UV Index",
-        "french": "Indice UV",
-    },
-    "pop": {
-        "xpath": "./forecastGroup/forecast/abbreviatedForecast/pop",
-        "english": "Chance of Precip.",
-        "french": "Probabilité d'averses",
-    },
-    "icon_code": {
-        "xpath": "./currentConditions/iconCode",
-        "english": "Icon Code",
-        "french": "Code icône",
-    },
-    "precip_yesterday": {
-        "xpath": "./yesterdayConditions/precip",
-        "english": "Precipitation Yesterday",
-        "french": "Précipitation d'hier",
-    },
-}
-
-aqhi_meta = {
-    "label": {"english": "Air Quality Health Index", "french": "Cote air santé"}
-}
-
-summary_meta = {
-    "forecast_period": {
-        "xpath": "./forecastGroup/forecast/period",
-        "attribute": "textForecastName",
-    },
-    "text_summary": {
-        "xpath": "./forecastGroup/forecast/textSummary",
-    },
-    "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É).)*$"},
-    },
-    "endings": {
-        "english": {"label": "Endings", "pattern": ".*ENDED"},
-        "french": {"label": "Terminaisons", "pattern": ".*TERMINÉE?"},
-    },
-}
-
-metadata_meta = {
-    "timestamp": {
-        "xpath": "./currentConditions/dateTime/timeStamp",
-    },
-    "location": {
-        "xpath": "./location/name",
-    },
-    "station": {
-        "xpath": "./currentConditions/station",
-    },
-}
-
-
-def ignore_ratelimit_error(fun):
-    def res(*args, **kwargs):
-        try:
-            return fun(*args, **kwargs)
-        except RateLimitException:
-            return None
-
-    return res
-
-
-class ECData(object):
-
-    """Get weather data from Environment Canada."""
-
-    def __init__(self, station_id=None, coordinates=(0, 0), language="english"):
-        """Initialize the data object."""
-        self.language = language
-        self.language_abr = language[:2].upper()
-        self.zone_name_tag = "name_%s_CA" % self.language_abr.lower()
-        self.region_name_tag = "name%s" % self.language_abr.title()
-
-        self.metadata = {}
-        self.conditions = {}
-        self.alerts = {}
-        self.daily_forecasts = []
-        self.hourly_forecasts = []
-        self.aqhi = {}
-        self.forecast_time = ""
-        self.aqhi_id = None
-        self.lat = 0
-        self.lon = 0
-
-        site_list = self.get_ec_sites()
-        if station_id:
-            self.station_id = station_id
-            stn = station_id.split("/")
-            if len(stn) == 2:
-                for site in site_list:
-                    if stn[1] == site["Codes"] and stn[0] == site["Province Codes"]:
-                        self.lat = site["Latitude"]
-                        self.lon = site["Longitude"]
-                        break
-        else:
-            self.station_id = self.closest_site(
-                site_list, coordinates[0], coordinates[1]
-            )
-            self.lat = coordinates[0]
-            self.lon = coordinates[1]
-
-        self.update()
-
-    @ignore_ratelimit_error
-    @limits(calls=5, period=120)
-    def update(self):
-        """Get the latest data from Environment Canada."""
-        url = WEATHER_URL.format(
-            date=datetime.now(tz=timezone.utc).strftime("%Y%m%d"),
-            site=self.station_id,
-            language=self.language[0],
-        )
-        try:
-            weather_result = requests.get(url)
-
-        except requests.exceptions.RequestException as e:
-            LOG.warning("Unable to retrieve weather forecast: %s", e)
-            return
-
-        if weather_result.status_code != 200:
-            LOG.warning(
-                "Unable to retrieve weather forecast, status code: %d, url: %s",
-                weather_result.status_code,
-                url,
-            )
-            return
-
-        weather_xml = weather_result.content.decode("iso-8859-1")
-        try:
-            weather_tree = et.fromstring(weather_xml)
-        except Exception as e:
-            LOG.warning("Unable to parse XML returned")
-            return
-
-        # 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
-            else:
-                self.metadata[m] = None
-
-        # Update current conditions
-        def get_condition(meta):
-            condition = {}
-
-            element = weather_tree.find(meta["xpath"])
-
-            if element is not None:
-                if meta.get("attribute"):
-                    condition["value"] = element.attrib.get(meta["attribute"])
-                else:
-                    condition["value"] = element.text
-                    if element.attrib.get("units"):
-                        condition["unit"] = element.attrib.get("units")
-            return condition
-
-        for c, meta in conditions_meta.items():
-            self.conditions[c] = {"label": meta[self.language]}
-            self.conditions[c].update(get_condition(meta))
-
-        # Update text summary
-        period = get_condition(summary_meta["forecast_period"])["value"]
-        summary = get_condition(summary_meta["text_summary"])["value"]
-
-        self.conditions["text_summary"] = {
-            "label": summary_meta["label"][self.language],
-            "value": ". ".join([period, summary]),
-        }
-
-        # Update alerts
-        for category, meta in alerts_meta.items():
-            self.alerts[category] = {"value": [], "label": meta[self.language]["label"]}
-
-        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,
-                    }
-                    self.alerts[category]["value"].append(alert)
-
-        # Update daily forecasts
-        self.forecast_time = weather_tree.findtext("./forecastGroup/dateTime/timeStamp")
-        self.daily_forecasts = []
-        self.hourly_forecasts = []
-
-        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": f.findtext("./temperatures/temperature"),
-                    "temperature_class": f.find(
-                        "./temperatures/temperature"
-                    ).attrib.get("class"),
-                    "precip_probability": f.findtext("./abbreviatedForecast/pop")
-                    or "0",
-                }
-            )
-
-        # Update hourly forecasts
-        for f in weather_tree.findall("./hourlyForecastGroup/hourlyForecast"):
-            self.hourly_forecasts.append(
-                {
-                    "period": f.attrib.get("dateTimeUTC"),
-                    "condition": f.findtext("./condition"),
-                    "temperature": f.findtext("./temperature"),
-                    "icon_code": f.findtext("./iconCode"),
-                    "precip_probability": f.findtext("./lop") or "0",
-                }
-            )
-
-        # Update AQHI current condition
-
-        if self.aqhi_id is None:
-            lat = weather_tree.find("./location/name").attrib.get("lat")[:-1]
-            lon = weather_tree.find("./location/name").attrib.get("lon")[:-1]
-            aqhi_coordinates = (float(lat), float(lon) * -1)
-            self.aqhi_id = self.closest_aqhi(aqhi_coordinates[0], aqhi_coordinates[1])
-
-        success = True
-        try:
-            aqhi_result = requests.get(
-                AQHI_OBSERVATION_URL.format(self.aqhi_id[0], self.aqhi_id[1]),
-                timeout=10,
-            )
-        except requests.exceptions.RequestException as e:
-            LOG.warning("Unable to retrieve current AQHI observation: %s", e)
-            success = False
-
-        if not success or aqhi_result.status_code == 404:
-            self.aqhi["current"] = None
-        else:
-            aqhi_xml = aqhi_result.content.decode("utf-8")
-            aqhi_tree = et.fromstring(aqhi_xml)
-
-            element = aqhi_tree.find("airQualityHealthIndex")
-            if element is not None:
-                self.aqhi["current"] = element.text
-            else:
-                self.aqhi["current"] = None
-
-            self.conditions["air_quality"] = {
-                "label": aqhi_meta["label"][self.language],
-                "value": self.aqhi["current"],
-            }
-
-            element = aqhi_tree.find("./dateStamp/UTCStamp")
-            if element is not None:
-                self.aqhi["utc_time"] = element.text
-            else:
-                self.aqhi["utc_time"] = None
-
-        # Update AQHI forecasts
-        success = True
-        try:
-            aqhi_result = requests.get(
-                AQHI_FORECAST_URL.format(self.aqhi_id[0], self.aqhi_id[1]), timeout=10
-            )
-        except requests.exceptions.RequestException as e:
-            LOG.warning("Unable to retrieve forecast AQHI observation: %s", e)
-            success = False
-
-        if not success or aqhi_result.status_code == 404:
-            self.aqhi["forecasts"] = None
-        else:
-            aqhi_xml = aqhi_result.content.decode("ISO-8859-1")
-            aqhi_tree = et.fromstring(aqhi_xml)
-
-            self.aqhi["forecasts"] = {"daily": [], "hourly": []}
-
-            # Update AQHI daily forecasts
-            period = None
-            for f in aqhi_tree.findall("./forecastGroup/forecast"):
-                for p in f.findall("./period"):
-                    if self.language_abr == p.attrib["lang"]:
-                        period = p.attrib["forecastName"]
-                self.aqhi["forecasts"]["daily"].append(
-                    {
-                        "period": period,
-                        "aqhi": f.findtext("./airQualityHealthIndex"),
-                    }
-                )
-
-            # Update AQHI hourly forecasts
-            for f in aqhi_tree.findall("./hourlyForecastGroup/hourlyForecast"):
-                self.aqhi["forecasts"]["hourly"].append(
-                    {"period": f.attrib["UTCTime"], "aqhi": f.text}
-                )
-
-    def get_ec_sites(self):
-        """Get list of all sites from Environment Canada, for auto-config."""
-        import csv
-        import io
-
-        sites = []
-
-        try:
-            sites_result = requests.get(SITE_LIST_URL, timeout=10)
-            sites_csv_string = sites_result.text
-        except requests.exceptions.RequestException as e:
-            LOG.warning("Unable to retrieve site list csv: %s", e)
-            return sites
-
-        sites_csv_stream = io.StringIO(sites_csv_string)
-
-        sites_csv_stream.seek(0)
-        next(sites_csv_stream)
-
-        sites_reader = csv.DictReader(sites_csv_stream)
-
-        for site in sites_reader:
-            if site["Province Codes"] != "HEF":
-                site["Latitude"] = float(site["Latitude"].replace("N", ""))
-                site["Longitude"] = -1 * float(site["Longitude"].replace("W", ""))
-                sites.append(site)
-
-        return sites
-
-    def closest_site(self, site_list, lat, lon):
-        """Return the province/site_code of the closest station to our lat/lon."""
-
-        def site_distance(site):
-            """Calculate distance to a site."""
-            return distance.distance((lat, lon), (site["Latitude"], site["Longitude"]))
-
-        closest = min(site_list, key=site_distance)
-
-        return "{}/{}".format(closest["Province Codes"], closest["Codes"])
-
-    def get_aqhi_regions(self):
-        """Get list of all AQHI regions from Environment Canada, for auto-config."""
-        regions = []
-        try:
-            result = requests.get(AQHI_SITE_LIST_URL, timeout=10)
-        except requests.exceptions.RequestException as e:
-            LOG.warning("Unable to retrieve AQHI regions: %s", e)
-            return regions
-
-        site_xml = result.content.decode("utf-8")
-        xml_object = et.fromstring(site_xml)
-
-        for zone in xml_object.findall("./EC_administrativeZone"):
-            _zone_attribs = zone.attrib
-            _zone_attrib = {
-                "abbreviation": _zone_attribs["abreviation"],
-                "zone_name": _zone_attribs[self.zone_name_tag],
-            }
-            for region in zone.findall("./regionList/region"):
-                _region_attribs = region.attrib
-
-                _region_attrib = {
-                    "region_name": _region_attribs[self.region_name_tag],
-                    "cgndb": _region_attribs["cgndb"],
-                    "latitude": float(_region_attribs["latitude"]),
-                    "longitude": float(_region_attribs["longitude"]),
-                }
-                _children = list(region)
-                for child in _children:
-                    _region_attrib[child.tag] = child.text
-                _region_attrib.update(_zone_attrib)
-                regions.append(_region_attrib)
-        return regions
-
-    def closest_aqhi(self, lat, lon):
-        """Return the AQHI region and site ID of the closest site."""
-        region_list = self.get_aqhi_regions()
-
-        def site_distance(site):
-            """Calculate distance to a region."""
-            return distance.distance((lat, lon), (site["latitude"], site["longitude"]))
-
-        closest = min(region_list, key=site_distance)
-
-        return closest["abbreviation"], closest["cgndb"]

env_canada-0.6.3.dist-info/RECORD

@@ -1,17 +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=P8tdLi9F5nSq1VHsA5avWwtf2mXSANWRgf7-qjSB7pM,32
-env_canada/ec_aqhi.py,sha256=kJQ8xEgFnujGMYdxRXpoEK17B5e-ya-Y7rK0vLo_-w0,7768
-env_canada/ec_cache.py,sha256=qoFxmO-kOBT8jhgPeNWtVBRmguXcARIIOI54OaDh-20,1171
-env_canada/ec_data.py,sha256=DacCeZSDeMMVdN-Mx5WVa2ObooVm4SfEOK3J0kAV6H8,17597
-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=gcLa2z5T_CkrY-NLEJRqaLDHODJRcO5unW5MGxjKxF8,13115
-env_canada/ec_weather.py,sha256=uBY6qd0-hVyZDhqPcpipfMDImXpJGiNIzMOjIzqNBfo,17358
-env_canada-0.6.3.dist-info/LICENSE,sha256=c037dTHQWAgRgDqZNN-5d-CZvcteSYN37u39SNklO0I,1072
-env_canada-0.6.3.dist-info/METADATA,sha256=00ezEXuLV3vc0BkMlGRi4jPCqFjqFkXSI-M_KgxYBPo,10707
-env_canada-0.6.3.dist-info/WHEEL,sha256=cpQTJ5IWu9CdaPViMhC9YzF8gZuS5-vlfoFihTBC86A,91
-env_canada-0.6.3.dist-info/top_level.txt,sha256=fw7Pcl9ULBXYvqnAdyBdmwPXW8GSRFmhO0sLZWVfOCc,11
-env_canada-0.6.3.dist-info/RECORD,,