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

env_canada/__init__.py

@@ -1,5 +1,5 @@
-from .ec_aqhi import *
-from .ec_historical import *
-from .ec_hydro import *
-from .ec_radar import *
-from .ec_weather import *
+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

env_canada/constants.py

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

env_canada/ec_data.py

@@ -0,0 +1,501 @@
+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/ec_radar.py

@@ -1,17 +1,18 @@
-from aiohttp.client_exceptions import ClientConnectorError
 import asyncio
 import datetime
-from io import BytesIO
 import logging
 import math
 import os
-from PIL import Image, ImageDraw, ImageFont
+from io import BytesIO
 
-from .ec_cache import CacheClientSession as ClientSession
 import dateutil.parser
 import defusedxml.ElementTree as et
 import imageio.v2 as imageio
 import voluptuous as vol
+from aiohttp.client_exceptions import ClientConnectorError
+from PIL import Image, ImageDraw, ImageFont
+
+from .ec_cache import CacheClientSession as ClientSession
 
 ATTRIBUTION = {
     "english": "Data provided by Environment Canada",
@@ -156,16 +157,12 @@ class ECRadar(object):
         # Get overlay parameters
 
         self.show_legend = kwargs["legend"]
-        if self.show_legend:
-            self.legend_layer = None
-            self.legend_image = None
-            self.legend_position = None
+        self.legend_layer = None
+        self.legend_image = None
+        self.legend_position = None
 
         self.show_timestamp = kwargs["timestamp"]
-        if self.show_timestamp:
-            self.font = ImageFont.load(
-                os.path.join(os.path.dirname(__file__), "10x20.pil")
-            )
+        self.font = None
 
     @property
     def precip_type(self):
@@ -197,22 +194,20 @@ class ECRadar(object):
             async with ClientSession(raise_for_status=True) as session:
                 response = await session.get(url=basemap_url, params=basemap_params)
                 base_bytes = await response.read()
-                self.map_image = Image.open(BytesIO(base_bytes)).convert("RGBA")
 
         except ClientConnectorError as e:
             logging.warning("NRCan base map could not be retrieved: %s" % e)
-
             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()
-                    self.map_image = Image.open(BytesIO(base_bytes)).convert("RGBA")
             except ClientConnectorError:
                 logging.warning("Mapbox base map could not be retrieved")
+                return None
 
-        return
+        return base_bytes
 
     async def _get_legend(self):
         """Fetch legend image."""
@@ -221,13 +216,13 @@ class ECRadar(object):
                 layer=precip_layers[self.layer_key], style=legend_style[self.layer_key]
             )
         )
-        async with ClientSession(raise_for_status=True) as session:
-            response = await session.get(url=geomet_url, params=legend_params)
-            legend_bytes = await response.read()
-        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
+        try:
+            async with ClientSession(raise_for_status=True) as session:
+                response = await session.get(url=geomet_url, params=legend_params)
+                return await response.read()
+        except ClientConnectorError:
+            logging.warning("Legend could not be retrieved")
+            return None
 
     async def _get_dimensions(self):
         """Get time range of available data."""
@@ -255,54 +250,73 @@ class ECRadar(object):
     async def _combine_layers(self, radar_bytes, frame_time):
         """Add radar overlay to base layer and add timestamp."""
 
-        radar = Image.open(BytesIO(radar_bytes)).convert("RGBA")
-
-        # Add transparency to radar
-
-        if self.radar_opacity < 100:
-            alpha = round((self.radar_opacity / 100) * 255)
-            radar_copy = radar.copy()
-            radar_copy.putalpha(alpha)
-            radar.paste(radar_copy, radar)
-
-        # Overlay radar on basemap
-
+        base_bytes = None
         if not self.map_image:
-            await self._get_basemap()
-        if self.map_image:
-            frame = Image.alpha_composite(self.map_image, radar)
-        else:
-            frame = radar
-
-        # Add legend
+            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:
-                await self._get_legend()
-            frame.paste(self.legend_image, self.legend_position)
+                legend_bytes = await self._get_legend()
 
-        # Add timestamp
+        # All the synchronous PIL stuff here
+        def _create_image():
+            radar = Image.open(BytesIO(radar_bytes)).convert("RGBA")
 
-        if self.show_timestamp:
-            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
-
-        img_byte_arr = BytesIO()
-        frame.save(img_byte_arr, format="PNG")
-        frame_bytes = img_byte_arr.getvalue()
+            if base_bytes:
+                self.map_image = Image.open(BytesIO(base_bytes)).convert("RGBA")
 
-        return frame_bytes
+            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
+
+            # Add transparency to radar
+            if self.radar_opacity < 100:
+                alpha = round((self.radar_opacity / 100) * 255)
+                radar_copy = radar.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")
+                )
+
+            # Overlay radar on basemap
+            if self.map_image:
+                frame = Image.alpha_composite(self.map_image, radar)
+            else:
+                frame = radar
+
+            # Add legend
+            if self.show_legend and self.legend_image:
+                frame.paste(self.legend_image, self.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
+            img_byte_arr = BytesIO()
+            frame.save(img_byte_arr, format="PNG")
+            frame_bytes = img_byte_arr.getvalue()
+
+            return frame_bytes
+
+        # Since PIL is synchronous, run it all in another thread
+        return await asyncio.get_event_loop().run_in_executor(None, _create_image)
 
     async def _get_radar_image(self, session, frame_time):
         params = dict(
@@ -331,6 +345,17 @@ class ECRadar(object):
     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,
+                format="GIF",
+                duration=duration,
+                subrectangles=True,
+            )
+            return gif_bytes
+
         """Build list of frame timestamps."""
         start, end = await self._get_dimensions()
         frame_times = [start]
@@ -361,12 +386,6 @@ class ECRadar(object):
         """Assemble animated GIF."""
         duration = 1000 / fps
 
-        gif_frames = [imageio.imread(f, mode="RGBA") for f in frames]
-        gif_bytes = imageio.mimwrite(
-            imageio.RETURN_BYTES,
-            gif_frames,
-            format="GIF",
-            duration=duration,
-            subrectangles=True,
-        )
+        loop = asyncio.get_running_loop()
+        gif_bytes = await loop.run_in_executor(None, build_image)
         return gif_bytes

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
-Name: env-canada
-Version: 0.6.1
+Name: env_canada
+Version: 0.6.3
 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.1?utm_source=badge)
+[![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)
 
 This package provides access to various data sources published by [Environment and Climate Change Canada](https://www.canada.ca/en/environment-climate-change.html).
 
@@ -116,7 +116,8 @@ Once updated asynchronously, historical weather data is contained with the `stat
 ```python
 import asyncio
 
-from env_canada import ECHistorical, get_historical_stations
+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]
@@ -165,7 +166,8 @@ For example :
 ```python
 import pandas as pd
 import asyncio
-from env_canada import ECHistoricalRange, get_historical_stations
+from env_canada import ECHistoricalRange
+from env_canada.ec_historical import get_historical_stations
 from datetime import datetime
 
 coordinates = ['48.508333', '-68.467667']
@@ -205,4 +207,4 @@ of `datetime(2022, 7, 1, 12, 12)`
 
 # License
 
-The code is available under terms of [MIT License](LICENSE.md)
+The code is available under terms of [MIT License](https://github.com/michaeldavie/env_canada/tree/master/LICENSE.md)

{env_canada-0.6.1.dist-info → env_canada-0.6.3.dist-info}/RECORD

@@ -1,16 +1,17 @@
 env_canada/10x20.pbm,sha256=ClKTs2WUmhUhTHAQzPuGwPTICGVBzCvos5l-vHRBE5M,2463
 env_canada/10x20.pil,sha256=Oki6-TD7b0xFtfm6vxCKsmpEpsZ5Jaia_0v_aDz8bfE,5143
-env_canada/__init__.py,sha256=wQpbGVmwROrIR06RWinatD-qX7fbJvxBFOd6U0xoek4,126
-env_canada/constants.py,sha256=IsaGrjrg-YGadCHWyT0ZkBjbTDaF14W1gBPGQylncUY,32
+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=WaJHtNnuQa3XoidvymOjJxNHqRLORTcy6_mczjIwd_A,12217
+env_canada/ec_radar.py,sha256=gcLa2z5T_CkrY-NLEJRqaLDHODJRcO5unW5MGxjKxF8,13115
 env_canada/ec_weather.py,sha256=uBY6qd0-hVyZDhqPcpipfMDImXpJGiNIzMOjIzqNBfo,17358
-env_canada-0.6.1.dist-info/LICENSE,sha256=c037dTHQWAgRgDqZNN-5d-CZvcteSYN37u39SNklO0I,1072
-env_canada-0.6.1.dist-info/METADATA,sha256=yy2_dg0TKwYxaIwyc1UfBHiuIQpt3hyETSkzvnRPGU0,10580
-env_canada-0.6.1.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-env_canada-0.6.1.dist-info/top_level.txt,sha256=fw7Pcl9ULBXYvqnAdyBdmwPXW8GSRFmhO0sLZWVfOCc,11
-env_canada-0.6.1.dist-info/RECORD,,
+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,,

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

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