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

env_canada/constants.py

@@ -1 +1 @@
-USER_AGENT = "env_canada/0.7.0"
+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-0.7.0.dist-info → env_canada-0.7.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: env_canada
-Version: 0.7.0
+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.7.0?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.7.0.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-0.7.0.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=xUcfT4fpHqhAnvC1GZ_gpYYrJYozfitwFiOBKN65xXg,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_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=M7nPeZIKLirRIcCENB8z2B8aBDZHrjltzMYPgRz9lz0,16789
-env_canada-0.7.0.dist-info/LICENSE,sha256=c037dTHQWAgRgDqZNN-5d-CZvcteSYN37u39SNklO0I,1072
-env_canada-0.7.0.dist-info/METADATA,sha256=IueyWyN-i8vtUD8G4p8kMumCncfOUyPUrUS_TMEfw7w,10707
-env_canada-0.7.0.dist-info/WHEEL,sha256=cpQTJ5IWu9CdaPViMhC9YzF8gZuS5-vlfoFihTBC86A,91
-env_canada-0.7.0.dist-info/top_level.txt,sha256=fw7Pcl9ULBXYvqnAdyBdmwPXW8GSRFmhO0sLZWVfOCc,11
-env_canada-0.7.0.dist-info/RECORD,,