@camstack/addon-waste-collections 0.0.0-stage → 0.1.1

package/python/vendor/waste_collection_schedule/source/shawinigan_ca.py

@@ -0,0 +1,330 @@
+"""Source for Shawinigan, Canada waste collection schedule.
+
+Uses ArcGIS REST API with spatial queries to determine collection districts
+based on address coordinates, then extracts collection schedules from districts.
+"""
+
+import logging
+from datetime import date, datetime, timedelta
+
+from waste_collection_schedule import Collection  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import SourceArgumentNotFound
+from waste_collection_schedule.service.ArcGis import (
+    ArcGisError,
+    epoch_ms_to_date,
+    geocode,
+    query_feature_layer,
+)
+
+_LOGGER = logging.getLogger(__name__)
+
+TITLE = "Shawinigan"
+DESCRIPTION = "Source for Shawinigan, Canada waste collection schedule."
+URL = "https://geoweb.shawinigan.ca/CollecteMatieresResiduelles/"
+COUNTRY = "ca"
+
+TEST_CASES = {
+    "Shawinigan": {"address": "1760 Avenue de la Paix, Shawinigan, QC G9N 6H7"},
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "address": "Street address including city and postal code (e.g., '1760 Avenue de la Paix, Shawinigan, QC G9N 6H7')",
+    },
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "address": "Street Address",
+    },
+}
+
+# Layer IDs for collection types
+LAYERS = {
+    0: {"type": "RECYCLAGE", "icon": "mdi:recycle"},  # Blue Bin Pickup
+    1: {"type": "ORDURES", "icon": "mdi:trash-can"},  # Grey Bin Pickup
+    # Christmas Tree Collection
+    2: {"type": "SAPIN", "icon": "mdi:pine-tree"},
+    3: {"type": "FEUILLES", "icon": "mdi:leaf-maple"},  # Leaf Pickup
+    4: {"type": "COMPOST", "icon": "mdi:leaf"},  # Green Bin Pickup
+}
+
+MAPSERVER_BASE = "https://geoweb.shawinigan.ca/arcgis/rest/services/MunicipalServices_DeTravail/MapServer"
+HOLIDAYS_LAYER = 6
+
+_WEEKDAY_MAP = {
+    "lundi": 0,
+    "mardi": 1,
+    "mercredi": 2,
+    "jeudi": 3,
+    "vendredi": 4,
+    "samedi": 5,
+    "dimanche": 6,
+    "monday": 0,
+    "tuesday": 1,
+    "wednesday": 2,
+    "thursday": 3,
+    "friday": 4,
+    "saturday": 5,
+    "sunday": 6,
+}
+
+
+class Source:
+    def __init__(self, address: str):
+        self._address = address.strip()
+
+    def fetch(self) -> list[Collection]:
+        """Fetch waste collection schedule for the specified address."""
+        try:
+            location = geocode(self._address, timeout=20)
+        except ArcGisError as e:
+            raise SourceArgumentNotFound("address", self._address) from e
+
+        today = date.today()
+        end_date = today + timedelta(days=365)
+
+        # Step 1: fetch all raw layer attributes
+        raw_layers: dict[int, dict] = {}
+        for layer_id in LAYERS:
+            try:
+                features = query_feature_layer(
+                    f"{MAPSERVER_BASE}/{layer_id}",
+                    geometry=location,
+                    out_fields="*",
+                )
+                if features:
+                    raw_layers[layer_id] = features[0]
+            except ArcGisError:
+                _LOGGER.debug("No data for layer %d", layer_id)
+
+        if not raw_layers:
+            raise SourceArgumentNotFound("address", self._address)
+
+        # Step 2: (no-op — bi-weekly phase is read directly from the SCHEDULE digit)
+
+        # Step 3: fetch holidays per impact field
+        all_holidays = _get_holidays_by_field()
+
+        # Step 4: generate Collection entries
+        entries: list[Collection] = []
+        for layer_id, attrs in raw_layers.items():
+            layer_info = LAYERS[layer_id]
+            schedule_str = attrs.get("SCHEDULE", "")
+            schedule_type = attrs.get("SCHEDULETYPE", "").lower()
+            day_name = attrs.get("NAME", "")
+            holiday_field = attrs.get("HOLIDAYFIELD") or "IMPACTGARB"
+            layer_holidays = all_holidays.get(holiday_field, {})
+            description = attrs.get("DESCRIPT") or None
+
+            collection_dates = _parse_schedule(
+                schedule_str,
+                schedule_type,
+                day_name,
+                today,
+                end_date,
+            )
+            for d in collection_dates:
+                adjusted = layer_holidays.get(d, d)
+                if adjusted is None:
+                    continue  # Collection cancelled due to holiday
+                entries.append(
+                    Collection(
+                        date=adjusted,
+                        t=layer_info["type"],
+                        icon=layer_info["icon"],
+                        description=description,
+                    )
+                )
+
+        if not entries:
+            raise SourceArgumentNotFound("address", self._address)
+
+        return sorted(entries, key=lambda x: x.date)
+
+
+# ---------------------------------------------------------------------------
+# Module-level helpers (stateless, easy to unit-test)
+# ---------------------------------------------------------------------------
+
+
+def _weekday_num(day_name: str) -> int:
+    return _WEEKDAY_MAP.get((day_name or "").strip().lower(), -1)
+
+
+def _parse_irregular(schedule_str: str, start_date: date, end_date: date) -> list[date]:
+    dates = []
+    for part in schedule_str.split(","):
+        part = part.strip()
+        try:
+            d = datetime.strptime(part, "%Y-%m-%d").date()
+            if start_date <= d <= end_date:
+                dates.append(d)
+        except ValueError:
+            continue
+    return dates
+
+
+def _parse_biweekly_schedule(
+    schedule_str: str, start_date: date, end_date: date
+) -> list[date]:
+    """Parse a '2 Week' SCHEDULE string like '0001000' or '0020000'.
+
+    The city encodes both the weekday and the ISO-week parity directly in the
+    SCHEDULE field.  The 7-character string maps positions 0-6 to Sun-Sat; the
+    non-zero digit in the string carries the phase:
+
+      digit 1 → collect on odd  ISO weeks  (isocalendar().week % 2 == 1)
+      digit 2 → collect on even ISO weeks  (isocalendar().week % 2 == 0)
+
+    Python weekday = (position - 1) % 7  (since position 0 = Sunday = Python 6).
+
+    Edge case: when a year has ISO week 53 (e.g. 2026), two consecutive matching
+    weekdays can share the same parity, yielding an extra entry.  This is rare
+    and matches the city's own web-app behaviour.
+    """
+    if len(schedule_str) != 7:
+        return []
+
+    position = -1
+    phase = 0
+    for i, c in enumerate(schedule_str):
+        if c in ("1", "2"):
+            position = i
+            phase = int(c)
+            break
+
+    if position < 0:
+        return []
+
+    python_weekday = (position - 1) % 7  # 0=Mon … 6=Sun
+    expected_parity = phase % 2  # 1→odd(1), 2→even(0)
+
+    days_ahead = (python_weekday - start_date.weekday()) % 7
+    current = start_date + timedelta(days=days_ahead)
+
+    dates = []
+    while current <= end_date:
+        if current.isocalendar().week % 2 == expected_parity:
+            dates.append(current)
+        current += timedelta(days=7)
+    return dates
+
+
+def _parse_schedule(
+    schedule_str: str,
+    schedule_type: str,
+    day_name: str,
+    start_date: date,
+    end_date: date,
+    exclude_dates: dict | None = None,  # kept for backward compatibility; unused
+) -> list[date]:
+    """Parse a Shawinigan MapServer SCHEDULE field and return collection dates.
+
+    For bi-weekly ('2 Week') layers the SCHEDULE string encodes both the weekday
+    and the ISO-week parity (digit 1 = odd weeks, digit 2 = even weeks), so no
+    cross-layer calibration is needed.
+
+    ``exclude_dates`` is accepted but ignored (preserved for test compatibility).
+    """
+    if not schedule_str:
+        return []
+
+    schedule_type = (schedule_type or "").lower()
+    weekday = _weekday_num(day_name)
+
+    # --- Explicit list of dates ("Irregularly") ---
+    if "irregularly" in schedule_type or "," in schedule_str:
+        return _parse_irregular(schedule_str, start_date, end_date)
+
+    # --- Bi-weekly: phase encoded in SCHEDULE digit ---
+    if "2" in schedule_type or "bi" in schedule_type:
+        result = _parse_biweekly_schedule(schedule_str, start_date, end_date)
+        if result:
+            return result
+        # Fallback: SCHEDULE format unexpected, use NAME weekday without phase
+        if weekday < 0:
+            return []
+        _LOGGER.warning(
+            "Unexpected bi-weekly SCHEDULE %r — falling back to every-other-week from start",
+            schedule_str,
+        )
+        days_ahead = (weekday - start_date.weekday()) % 7
+        anchor = start_date + timedelta(days=days_ahead)
+        out = []
+        current = anchor
+        while current <= end_date:
+            out.append(current)
+            current += timedelta(days=14)
+        return out
+
+    # --- Weekly / other periodic ---
+    if "week" not in schedule_type or weekday < 0:
+        return []
+
+    days_ahead = (weekday - start_date.weekday()) % 7
+    dates = []
+    current = start_date + timedelta(days=days_ahead)
+    while current <= end_date:
+        dates.append(current)
+        current += timedelta(days=7)
+    return dates
+
+
+def _get_holidays_by_field() -> dict[str, dict[date, date | None]]:
+    """Return holiday adjustments grouped by impact field name.
+
+    Maps holiday_date -> adjusted_date, or None when the collection is
+    cancelled.  query_feature_layer already unwraps the 'attributes' dict.
+
+    Actual coded values from the API domain ``piHolidayImpact``:
+      "None"       -> no change (skip entry)
+      "OneDayFrwd" -> +1 day
+      "TwoDayFrwd" -> +2 days
+      "Shift Forw" -> +1 day  (synonym used by the city)
+      "OneDayBack" -> -1 day
+      "Shift Back" -> -1 day  (synonym)
+      "Cancel"     -> collection cancelled (mapped to None)
+      Others (Next Sat, Prev Sat, Next Sun, Prev Sun) -> logged and skipped
+    """
+    result: dict[str, dict[date, date | None]] = {}
+    try:
+        features = query_feature_layer(
+            f"{MAPSERVER_BASE}/{HOLIDAYS_LAYER}",
+            where="1=1",
+            out_fields="*",
+        )
+        for attrs in features:  # attrs is already the attributes dict
+            holiday_ms = attrs.get("HOLIDAYDATE")
+            if not holiday_ms:
+                continue
+            holiday_date = epoch_ms_to_date(holiday_ms)
+            # Iterate over all IMPACT* fields dynamically — robust against new collection types
+            impact_fields = [k for k in attrs if k.startswith("IMPACT")]
+            for field in impact_fields:
+                val = (attrs.get(field) or "").strip()
+                val_lower = val.lower()
+                if not val_lower or val_lower == "none":
+                    continue
+                if val_lower == "twodayfrwd":
+                    adjusted: date | None = holiday_date + timedelta(days=2)
+                elif (
+                    "frwd" in val_lower or "forward" in val_lower or "forw" in val_lower
+                ):
+                    adjusted = holiday_date + timedelta(days=1)
+                elif "back" in val_lower:
+                    adjusted = holiday_date - timedelta(days=1)
+                elif val_lower == "cancel":
+                    adjusted = None
+                else:
+                    _LOGGER.debug(
+                        "Unhandled holiday impact code %r for %s on %s",
+                        val,
+                        field,
+                        holiday_date,
+                    )
+                    continue
+                result.setdefault(field, {})[holiday_date] = adjusted
+    except ArcGisError:
+        _LOGGER.debug("Could not fetch holidays")
+    return result

package/python/vendor/waste_collection_schedule/source/sheffield_gov_uk.py

@@ -0,0 +1,77 @@
+import logging
+
+import requests
+from dateutil import parser
+from waste_collection_schedule import Collection, Icons
+
+TITLE = "Sheffield City Council"
+DESCRIPTION = "Source for waste collection services from Sheffield City Council (SCC)"
+URL = "https://sheffield.gov.uk/"
+TEST_CASES = {
+    # These are random addresses around Sheffield
+    # If your property is listed here and you don't want it, please raise an issue and I'll amend
+    "test001": {"uprn": 100050938234},
+    "test002": {"uprn": 100050961380},
+    "test003": {"uprn": "100050920796"},
+    "test004": {"uprn": "100051085306"},
+}
+
+
+API_URL = "https://wasteservices.sheffield.gov.uk/"
+
+# Headers to mimic the browser
+HEADERS = {
+    "user-agent": "Mozilla/5.0",
+    "Content-type": "application/json",
+}
+
+# Icons for the different bin types
+ICON_MAP = {
+    "BLACK": Icons.GENERAL_WASTE,
+    "BROWN": Icons.GLASS,
+    "BLUE": Icons.NEWSPAPER,
+    "GREEN": Icons.ORGANIC,
+}
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class Source:
+    def __init__(self, uprn=None):
+        self._uprn = str(uprn)
+
+    def fetch(self):
+        if self._uprn:
+            payload = {"councilId": "1", "uprn": f"{self._uprn}"}
+
+            response = requests.post(f"{API_URL}api/getCalendarData", json=payload)
+            response.raise_for_status()
+            json_doc = response.json()
+
+            if "data" not in json_doc:
+                raise ValueError(
+                    "The returned API data does not contain expected data element"
+                )
+            if "message" in json_doc and json_doc["message"] != "OK":
+                raise ValueError(f"API advised error: {json_doc['message']}")
+
+            entries = []
+            for data_item in json_doc["data"]:
+                if "records" not in data_item:
+                    continue
+                for record in data_item["records"]:
+                    collection_date = parser.parse(
+                        record["actual_scheduled_date"]
+                    ).date()
+                    collection_icon = ICON_MAP.get(
+                        record["service"].replace(" Bin", "").upper()
+                    )
+                    entries.append(
+                        Collection(
+                            date=collection_date,
+                            t=record["service"],
+                            icon=collection_icon,
+                        )
+                    )
+            return entries
+        raise ValueError("No result information found when collected, recheck UPN")

package/python/vendor/waste_collection_schedule/source/shellharbourwaste_com_au.py

@@ -0,0 +1,62 @@
+from datetime import datetime
+
+from bs4 import BeautifulSoup
+from curl_cffi import requests
+from waste_collection_schedule import Collection, Icons
+
+TITLE = "Shellharbour City Council"
+DESCRIPTION = "Source script for shellharbourwaste.com.au"
+URL = "https://shellharbourwaste.com.au"
+COUNTRY = "au"
+TEST_CASES = {"TestName1": {"zoneID": "Monday A"}, "TestName2": {"zoneID": "Friday A"}}
+
+API_URL = "https://www.shellharbourwaste.com.au/waste-collection"
+
+ICON_MAP = {
+    "General Waste": Icons.GENERAL_WASTE,
+    "Garden Waste": Icons.GARDEN,
+    "Recycling": Icons.RECYCLING,
+}
+
+
+def findUrl(zoneID, session):
+    # Take Zone ID and find url to parse
+    r = session.get(
+        f"https://www.shellharbourwaste.com.au/wp-json/rb_co/v1/get-waste-url?zone={zoneID}"
+    )
+    r.raise_for_status()
+    d = r.json()
+    return d["url"]
+
+
+class Source:
+    def __init__(self, zoneID):
+        self._zoneID = zoneID
+
+    def fetch(self):
+        session = requests.Session(impersonate="chrome")
+        pageurl = findUrl(self._zoneID, session)
+        r = session.get(
+            pageurl,
+            headers={
+                "Referer": "https://www.shellharbourwaste.com.au/find-my-bin-day/"
+            },
+        )
+        r.raise_for_status()
+        soup = BeautifulSoup(r.content, "html.parser")
+        collections = soup.select("div.waste-block__content")
+        entries = []
+        for entry in collections:
+            waste_type = entry.find("h3", class_="waste-block__title").text.strip()
+            # Strip trailing bin-colour hint, e.g. "General Waste (Red lid)" -> "General Waste"
+            waste_type = waste_type.split(" (")[0]
+            date_string = entry.find("time", class_="waste-block__time").text.strip()
+            pickupdate = datetime.strptime(date_string, "%d/%m/%Y")
+            entries.append(
+                Collection(
+                    date=pickupdate.date(),
+                    t=waste_type,
+                    icon=ICON_MAP.get(waste_type),
+                )
+            )
+        return entries

package/python/vendor/waste_collection_schedule/source/shoalhaven_nsw_gov_au.py

@@ -0,0 +1,113 @@
+from waste_collection_schedule import Collection, Icons
+from waste_collection_schedule.exceptions import SourceArgumentExceptionMultiple
+from waste_collection_schedule.service.OpenCities import (
+    OpenCitiesClient,
+    OpenCitiesConfig,
+)
+
+TITLE = "Shoalhaven City Council"
+DESCRIPTION = "Source script for shoalhaven.nsw.gov.au"
+URL = "https://www.shoalhaven.nsw.gov.au/"
+TEST_CASES = {
+    "2 Cherry Plum Way, WORRIGEE": {"street_address": "2 Cherry Plum Way, WORRIGEE"},
+    "10 Station Street, NOWRA": {"street_address": "10 Station Street, NOWRA"},
+    "3 The Park Drive, SANCTUARY POINT": {
+        "street_address": "3 The Park Drive, SANCTUARY POINT"
+    },
+    # Example Geolocation ID from the provided URL.
+    "Elizabeth Dr, VINCENTIA": {
+        "geolocation_id": "2ea7b0c7-b627-421d-8436-248b8da384b6"
+    },
+    "The Park Dr, SANCTUARY POINT": {
+        "geolocation_id": "b0b35bab-76c1-4b58-b609-115da3fa3829"
+    },
+    "Station St, NOWRA": {"geolocation_id": "984061de-cd63-43f4-bbd3-694b4e8af4d5"},
+}
+
+ICON_MAP = {
+    "general waste": Icons.GENERAL_WASTE,
+    "recycling": Icons.RECYCLING,
+}
+
+# ### Arguments affecting the configuration GUI ####
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": """
+    Enter your street address as the council's own address search shows it,
+    e.g. "2 Cherry Plum Way, WORRIGEE". You can check it on the
+    <https://www.shoalhaven.nsw.gov.au/My-Area> page.
+
+    A Geolocation ID may be given instead of an address, and takes precedence
+    when both are set. To find it:
+    1. Go to the Shoalhaven City Council 'My Area' page: <https://www.shoalhaven.nsw.gov.au/My-Area>
+    2. Open Developer Tools in your browser by pressing F12 and go to the Network tab.
+    3. Enter your address in the search bar and select it from the suggestions.
+    4. Once your address information is displayed, look at the 'wasteservices' URL in the Network tab.
+    5. Copy the long string of letters and numbers that follows 'geolocationid=' (e.g., 2ea7b0c7-b627-421d-8436-248b8da384b6). This is your Geolocation ID.
+    """,
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "street_address": "Your street address, e.g. 2 Cherry Plum Way, WORRIGEE",
+        "geolocation_id": "Your unique Geolocation ID for the address (e.g., 2ea7b0c7-b627-421d-8436-248b8da384b6). Only needed if the address search cannot find your property.",
+    }
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "street_address": "Street address",
+        "geolocation_id": "Geolocation ID",
+    },
+}
+
+# ### End of arguments affecting the configuration GUI ####
+
+_CONFIG = OpenCitiesConfig(
+    domain="https://www.shoalhaven.nsw.gov.au",
+    # The address-only path is the one users take, so name that argument in
+    # the exceptions the client raises -- except when the visitor supplied the
+    # geolocation id instead, which is the argument to flag then.
+    argument_name="street_address",
+    direct_argument_name="geolocation_id",
+    icon_keywords=ICON_MAP,
+    require_date_precise=True,
+    # The council sits behind Akamai, which fingerprints the TLS handshake as
+    # well as the headers: the address search answers 403 to plain
+    # requests/urllib3 no matter what User-Agent it announces. curl_cffi's
+    # Chrome impersonation makes the handshake match the claim and passes.
+    use_curl_cffi=True,
+    # Without an explicit Accept header the search endpoint returns XML
+    # instead of JSON.
+    headers={"Accept": "application/json"},
+)
+
+
+class Source:
+    def __init__(
+        self,
+        street_address: str | None = None,
+        geolocation_id: str | None = None,
+    ):
+        """
+        Initialize the Source with a street address or a geolocation ID.
+
+        :param street_address: The address to look up, as the council's address
+            search shows it, e.g. "2 Cherry Plum Way, WORRIGEE".
+        :param geolocation_id: The unique ID for the address to fetch waste
+            services for, used in preference to ``street_address`` when given.
+        """
+        if street_address is None and geolocation_id is None:
+            raise SourceArgumentExceptionMultiple(
+                ["street_address", "geolocation_id"],
+                "Either street_address or geolocation_id must have a value",
+            )
+
+        self._street_address = street_address
+        self._geolocation_id = geolocation_id
+        self._client = OpenCitiesClient(_CONFIG)
+
+    def fetch(self) -> list[Collection]:
+        return self._client.fetch(
+            address=self._street_address, geolocation_id=self._geolocation_id
+        )

package/python/vendor/waste_collection_schedule/source/sholland_gov_uk.py

@@ -0,0 +1,106 @@
+import datetime
+import re
+
+import requests
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+
+TITLE = "South Holland District Council"
+DESCRIPTION = "Source for South Holland District Council."
+URL = "https://www.sholland.gov.uk/"
+
+TEST_CASES = {
+    "10002546801": {"uprn": 10002546801, "postcode": "PE11 2FR"},
+    "PE12 7AR": {"uprn": "100030897036", "postcode": "PE12 7AR"},
+}
+
+ICON_MAP = {
+    "refuse": Icons.GENERAL_WASTE,
+    "garden": Icons.GARDEN,
+    "recycling": Icons.RECYCLING,
+}
+
+TYPE_LABELS = {
+    "refuse": "Refuse",
+    "recycling": "Recycling",
+    "garden": "Garden",
+}
+
+API_URL = "https://www.sholland.gov.uk/apiserver/ajaxlibrary"
+
+HEADERS = {
+    "User-Agent": "Mozilla/5.0",
+    "Accept": "application/json",
+    "Content-Type": "application/json",
+    "Referer": "https://www.sholland.gov.uk/mycollections",
+}
+
+
+class Source:
+    def __init__(self, uprn: str | int, postcode: str):
+        self._uprn = str(uprn)
+        self._postcode = postcode
+
+    def _parse_display_date(self, date_str: str) -> datetime.date | None:
+        if not date_str:
+            return None
+
+        # sanitize
+        clean = re.sub(r"(\d)(st|nd|rd|th)", r"\1", date_str)
+        clean = clean.replace("*", "")
+        clean = clean.split("(")[0].strip()
+        today = datetime.date.today()
+
+        # try with year first, if not possible calculate year
+        for fmt in ("%A %d %B %Y", "%A %d %B"):
+            try:
+                dt = datetime.datetime.strptime(clean, fmt)
+                if fmt == "%A %d %B":
+                    dt = dt.replace(year=today.year)
+                d = dt.date()
+                if d < today:
+                    d = d.replace(year=d.year + 1)
+                return d
+            except ValueError:
+                continue
+        return None
+
+    def fetch(self):
+        payload = {
+            "jsonrpc": "2.0",
+            "id": "1",
+            "method": "SouthHolland.Waste.getCollectionDaysAjax",
+            "params": {"UPRN": self._uprn},
+        }
+
+        with requests.Session() as session:
+            r = session.post(API_URL, json=payload, headers=HEADERS)
+            r.raise_for_status()
+            data = r.json()
+
+        result = data.get("result", {})
+        if not result.get("success"):
+            raise Exception(f"API call unsuccessful: {result!r}")
+
+        entries: list[Collection] = []
+        date_map = {
+            "refuse": result.get("nextRefuseDateDisplay"),
+            "recycling": result.get("nextRecyclingDateDisplay"),
+            "garden": result.get("nextGardenDateDisplay"),
+        }
+
+        # Uncomment below line for debugging fetched data
+        # print("API result:", date_map)
+
+        for bin_type, display in date_map.items():
+            date = self._parse_display_date(display or "")
+            if date is None:
+                continue
+            entries.append(
+                Collection(
+                    date=date,
+                    t=TYPE_LABELS[bin_type],
+                    icon=ICON_MAP.get(bin_type),
+                )
+            )
+
+        return entries