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

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

@@ -0,0 +1,86 @@
+import re
+from datetime import datetime
+
+import requests
+from bs4 import BeautifulSoup
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+
+TITLE = "Glasgow City Council"
+DESCRIPTION = "Source for www.glasgow.gov.uk services for Glasgow City Council, UK."
+URL = "https://www.glasgow.gov.uk/"
+TEST_CASES = {
+    "test 1 - house": {"uprn": "906700099060"},
+    "test 2 - flat": {"uprn": "906700335412"},
+}
+
+API_URL = "https://onlineservices.glasgow.gov.uk/forms/refuseandrecyclingcalendar/CollectionsCalendar.aspx?UPRN="
+ICON_MAP = {
+    "purple bins": Icons.GLASS,
+    "brown bins": Icons.BIO_KITCHEN,
+    "green bins": Icons.GENERAL_WASTE,
+    "blue bins": Icons.RECYCLING,
+    "grey bins": Icons.BIO_KITCHEN,
+}
+
+
+class Source:
+    def __init__(self, uprn: str):
+        self._uprn = uprn
+
+    def _parseBins(self, text):
+        soup = BeautifulSoup(text, features="html.parser")
+        entries = []
+
+        days = soup.find_all("td", {"class": "CalendarDayStyle"})
+        for day in days:
+            bins = day.find_all("img")
+
+            if len(bins) < 1:
+                continue
+
+            date = datetime.strptime(
+                day["title"].replace("today is ", ""), "%A, %d %B %Y"
+            ).date()
+
+            for bin in bins:
+                binname = bin["title"].split()
+                binname = f"{binname[0]} {binname[1]}"
+                entries.append(
+                    Collection(
+                        date=date,
+                        t=binname,
+                        icon=ICON_MAP.get(binname),
+                    )
+                )
+
+        return entries
+
+    def fetch(self):
+        entries = []
+
+        session = requests.Session()
+
+        # get current month
+        r = session.get(f"{API_URL}{self._uprn}")
+        entries = entries + self._parseBins(r.text)
+
+        # Get the next two months so that 56-day collection cycles are covered.
+        for _ in range(2):
+            soup = BeautifulSoup(r.text, features="html.parser")
+            nextlink = soup.find("a", title="Go to the next month")
+            if not nextlink:
+                break
+
+            match = re.search(r"__doPostBack\('(.*?)','(.*?)'", nextlink["href"])
+            data = {
+                "__EVENTTARGET": match.group(1),
+                "__EVENTARGUMENT": match.group(2),
+                "__EVENTVALIDATION": soup.find("input", id="__EVENTVALIDATION")[
+                    "value"
+                ],
+                "__VIEWSTATE": soup.find("input", id="__VIEWSTATE")["value"],
+            }
+            r = session.post(f"{API_URL}{self._uprn}", data=data)
+            entries = entries + self._parseBins(r.text)
+
+        return entries

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

@@ -0,0 +1,272 @@
+import logging
+import re
+from datetime import datetime
+
+import requests
+from bs4 import BeautifulSoup
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import (
+    SourceArgAmbiguousWithSuggestions,
+    SourceArgumentNotFound,
+    SourceArgumentRequired,
+)
+
+_STREET_ADDRESS_ARG_NAME = "street_address"
+_LOGGER = logging.getLogger(__name__)
+
+TITLE = "City of Glen Eira"
+DESCRIPTION = "Source for the Glen Eira City Council rubbish collection."
+URL = "https://www.gleneira.vic.gov.au/"
+TEST_CASES = {
+    # "Empty Address": {_STREET_ADDRESS_ARG_NAME: ""},
+    # "Invalid Address": {_STREET_ADDRESS_ARG_NAME: "Blah blah i dont exist"},
+    # "Ambiguous Address": {_STREET_ADDRESS_ARG_NAME: "55 Vi"},
+    "Elsternwick Library": {
+        _STREET_ADDRESS_ARG_NAME: "4 Staniland Grove ELSTERNWICK VIC 3185"
+    },
+    # The formats people actually type, none of which the results page accepts
+    # verbatim -- they are resolved through the council's own autocomplete.
+    "Comma separated": {
+        _STREET_ADDRESS_ARG_NAME: "4 Staniland Grove, Elsternwick VIC 3185"
+    },
+    "No suburb": {_STREET_ADDRESS_ARG_NAME: "4 Staniland Grove"},
+    "Abbreviated street type": {_STREET_ADDRESS_ARG_NAME: "1 Nepean Hwy, Elsternwick"},
+}
+
+SEARCH_PAGE_URL = "https://www.gleneira.vic.gov.au/our-city/in-your-area"
+API_URL = SEARCH_PAGE_URL
+
+# The results page only answers for an address written exactly the way the
+# council's register holds it ("4 Staniland Grove ELSTERNWICK VIC 3185"): no
+# commas, spelled-out street type, upper-case suburb. Anything else -- and a
+# comma is the single most common thing a visitor types -- silently returns the
+# no-results page. The site's own address box does not send what was typed
+# either; it sends the `value` of the autocomplete entry the visitor picked, so
+# resolve through the same endpoint before asking for the collections.
+AUTOCOMPLETE_URL = "https://www.gleneira.vic.gov.au/api/nearby/addressautocomplete"
+
+# Street-type abbreviations -> what the register spells out. The autocomplete
+# matches on substrings, so "Nepean Hwy" finds nothing while "Nepean Highway"
+# finds the street.
+_STREET_TYPES = {
+    "AV": "AVENUE",
+    "AVE": "AVENUE",
+    "BVD": "BOULEVARD",
+    "BLVD": "BOULEVARD",
+    "CCT": "CIRCUIT",
+    "CL": "CLOSE",
+    "CR": "CRESCENT",
+    "CRES": "CRESCENT",
+    "CT": "COURT",
+    "DR": "DRIVE",
+    "ESP": "ESPLANADE",
+    "GDNS": "GARDENS",
+    "GR": "GROVE",
+    "GRV": "GROVE",
+    "HWY": "HIGHWAY",
+    "LN": "LANE",
+    "PDE": "PARADE",
+    "PL": "PLACE",
+    "RD": "ROAD",
+    "SQ": "SQUARE",
+    "ST": "STREET",
+    "TCE": "TERRACE",
+    "WY": "WAY",
+}
+
+# Trailing tokens that carry no weight in the register's own substring search
+# but do stop it matching, dropped one "layer" at a time when the full query
+# comes back empty.
+_STATES = {"VIC", "VICTORIA"}
+
+
+def _normalise(value: str) -> str:
+    """Upper-case, drop commas and collapse whitespace, for comparison."""
+    return " ".join(value.upper().replace(",", " ").split())
+
+
+def _expand_street_types(value: str) -> str:
+    return " ".join(_STREET_TYPES.get(word, word) for word in value.split())
+
+
+def _house_number(value: str) -> str | None:
+    """The leading street number of an address, e.g. "4" or "12A"."""
+    match = re.match(r"\s*(\d+[A-Za-z]?(?:[-/]\d+[A-Za-z]?)?)\b", value)
+    return match.group(1).upper() if match else None
+
+
+def _query_variants(address: str) -> list[str]:
+    """Progressively shorter queries to try against the autocomplete.
+
+    The endpoint matches on a substring of its canonical address, so a query
+    carrying a postcode or state the register writes differently returns
+    nothing at all. Shedding those trailing parts recovers the match without
+    ever loosening what we then accept as the answer.
+    """
+    full = _expand_street_types(_normalise(address))
+    variants = [full]
+    words = full.split()
+    while len(words) > 2:
+        last = words[-1]
+        if last.isdigit() and len(last) == 4:  # postcode
+            words = words[:-1]
+        elif last in _STATES:
+            words = words[:-1]
+        else:
+            break
+        variants.append(" ".join(words))
+    # Last resort: number + street only, dropping the suburb.
+    if len(words) > 3:
+        variants.append(" ".join(words[:3]))
+    return list(dict.fromkeys(v for v in variants if v))
+
+
+# Define waste type icons
+ICON_MAP = {
+    "Next organic collection": Icons.ORGANIC,
+    "Next rubbish collection": Icons.GENERAL_WASTE,
+    "Next recycling collection": Icons.RECYCLING,
+}
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": f'Visit the [Glen Eira City Council]({SEARCH_PAGE_URL}) "Find your bin collection day" page and search for your address, for example: 4 Staniland Grove ELSTERNWICK VIC 3185. The address is resolved through the council\'s own address lookup, so commas, lower case suburbs and abbreviated street types (e.g. "Hwy" for "Highway") are accepted as well.',
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        _STREET_ADDRESS_ARG_NAME: "Full street address, ideally including suburb, state and postal code. Commas and abbreviated street types are accepted.",
+    },
+    "de": {
+        _STREET_ADDRESS_ARG_NAME: "Vollständige Straßenadresse, idealerweise mit Stadtteil, Bundesstaat und Postleitzahl. Kommas und abgekürzte Straßentypen sind zulässig.",
+    },
+    "it": {
+        _STREET_ADDRESS_ARG_NAME: "Indirizzo completo, preferibilmente con quartiere, stato e CAP. Sono ammesse le virgole e le abbreviazioni del tipo di strada.",
+    },
+    "fr": {
+        _STREET_ADDRESS_ARG_NAME: "Adresse complète, de préférence avec le quartier, l'État et le code postal. Les virgules et les types de voie abrégés sont acceptés.",
+    },
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        _STREET_ADDRESS_ARG_NAME: "Street Address",
+    },
+    "de": {
+        _STREET_ADDRESS_ARG_NAME: "Straßenadresse",
+    },
+    "it": {
+        _STREET_ADDRESS_ARG_NAME: "Indirizzo completo",
+    },
+    "fr": {
+        _STREET_ADDRESS_ARG_NAME: "Adresse complète",
+    },
+}
+
+
+class Source:
+    def __init__(self, street_address: str):
+        self._street_address = street_address
+
+    def _autocomplete(self, session: requests.Session, text: str) -> list[dict]:
+        """Candidates for a query, or [] when the council knows of none."""
+        response = session.get(AUTOCOMPLETE_URL, params={"text": text}, timeout=30)
+        # The endpoint answers 404 for "nothing matched", which is a normal
+        # outcome here, not a transport failure.
+        if response.status_code == 404:
+            return []
+        response.raise_for_status()
+        payload = response.json()
+        return payload if isinstance(payload, list) else []
+
+    def _resolve_address(self, session: requests.Session) -> str:
+        """Turn what the visitor typed into the register's own wording."""
+        wanted = _expand_street_types(_normalise(self._street_address))
+        wanted_number = _house_number(wanted)
+
+        candidates: list[dict] = []
+        for query in _query_variants(self._street_address):
+            candidates = self._autocomplete(session, query)
+            if candidates:
+                break
+
+        if not candidates:
+            # Nothing to resolve against; let the results page have its own say
+            # on the address as typed rather than refusing outright.
+            return self._street_address
+
+        values = [c["value"] for c in candidates if c.get("value")]
+
+        exact = [v for v in values if _normalise(v) == wanted]
+        if len(exact) == 1:
+            return exact[0]
+
+        # The autocomplete matches on a substring, so a query for "68 Glen Eira
+        # Road" also returns "268 Glen Eira Road". Keep only the properties
+        # whose street number is the one that was actually asked for.
+        if wanted_number:
+            same_number = [v for v in values if _house_number(v) == wanted_number]
+            if len(same_number) == 1:
+                return same_number[0]
+            if same_number:
+                values = same_number
+
+        if len(values) == 1:
+            return values[0]
+
+        raise SourceArgAmbiguousWithSuggestions(
+            _STREET_ADDRESS_ARG_NAME, self._street_address, values
+        )
+
+    def fetch(self) -> list[Collection]:
+        if not self._street_address:
+            raise SourceArgumentRequired(
+                _STREET_ADDRESS_ARG_NAME, "A street address was not provided."
+            )
+
+        session = requests.Session()
+        response = session.get(SEARCH_PAGE_URL)
+        response.raise_for_status()
+
+        address = self._resolve_address(session)
+
+        _LOGGER.debug(
+            "Requesting collections from '%s' for resolved address '%s'...",
+            API_URL,
+            address,
+        )
+        params: dict[str, str | int] = {
+            "address": address,
+        }
+
+        response = session.get(
+            API_URL,
+            params=params,
+        )
+        response.raise_for_status()
+        if "rubbish-and-street-cleaning" not in response.text:
+            raise SourceArgumentNotFound(
+                _STREET_ADDRESS_ARG_NAME,
+                self._street_address,
+                f"The provided address returned no results. Check your address on {SEARCH_PAGE_URL}",
+            )
+        soup = BeautifulSoup(response.text, "html.parser")
+
+        div = soup.find("div", id="rubbish-and-street-cleaning")
+        if div is None:
+            raise SourceArgumentNotFound(
+                _STREET_ADDRESS_ARG_NAME,
+                self._street_address,
+                f"The provided address returned no results. Check your address on {SEARCH_PAGE_URL}",
+            )
+        entries = []
+
+        for child in div.find_all("div"):
+            rubbish_type = child.find("h3").get_text()
+            when = child.find("p").get_text()
+            if rubbish_type in ICON_MAP:
+                date = datetime.strptime(when, "%A %d %B %Y").date()
+                entries.append(
+                    Collection(date=date, t=rubbish_type, icon=ICON_MAP[rubbish_type])
+                )
+
+        return entries

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

@@ -0,0 +1,140 @@
+import datetime
+
+import requests
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import (
+    SourceArgumentNotFound,
+    SourceArgumentNotFoundWithSuggestions,
+)
+
+TITLE = "GLØR"
+DESCRIPTION = (
+    "Source for GLØR (Gudbrandsdal Lillehammer Øyer Ringebu Renovasjon), Norway."
+)
+URL = "https://glor.no"
+COUNTRY = "no"
+
+TEST_CASES = {
+    "Storgata 1, Lillehammer": {"address": "Storgata 1, Lillehammer"},
+    "Segalstadsetervegen 33, Gausdal": {"address": "Segalstadsetervegen 33, Gausdal"},
+    "Gudbrandsdalsvegen 187 (without city)": {"address": "Gudbrandsdalsvegen 187"},
+}
+
+SEARCH_URL = "https://proaktiv.glor.offcenit.no/search"
+DETAILS_URL = "https://proaktiv.glor.offcenit.no/details"
+REQUEST_TIMEOUT = 30
+
+ICON_MAP = {
+    "Restavfall": Icons.GENERAL_WASTE,
+    "Papir, papp": Icons.PAPER,
+    "Plast blandet": Icons.PLASTIC_PACKAGING,
+    "Matavfall": Icons.BIO_KITCHEN,
+    "Hermetikk- og glassemballasje": Icons.GLASS,
+}
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": (
+        "Search for your address at glor.no/tømmeplan. Use the address exactly "
+        "as shown in the result list, optionally followed by the municipality "
+        "name, for example 'Storgata 1, Lillehammer'."
+    )
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "address": "Address, optionally followed by the municipality, e.g. 'Storgata 1, Lillehammer'.",
+    }
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "address": "Address",
+    }
+}
+
+
+def _normalize(value: str) -> str:
+    return "".join(value.casefold().replace(".", "").replace(",", "").split())
+
+
+class Source:
+    def __init__(self, address: str):
+        self._address = address
+
+    def fetch(self) -> list[Collection]:
+        candidates = self._lookup_properties()
+
+        entries: list[Collection] = []
+        seen: set[tuple[str, str]] = set()
+        for candidate in candidates:
+            r = requests.get(
+                DETAILS_URL,
+                params={"id": candidate["id"]},
+                timeout=REQUEST_TIMEOUT,
+            )
+            r.raise_for_status()
+            for item in r.json():
+                date_str = item["dato"][:10]
+                waste_type = item["fraksjon"]
+                key = (date_str, waste_type)
+                if key in seen:
+                    continue
+                seen.add(key)
+                entries.append(
+                    Collection(
+                        date=datetime.date.fromisoformat(date_str),
+                        t=waste_type,
+                        icon=ICON_MAP.get(waste_type),
+                    )
+                )
+
+        if not entries:
+            raise SourceArgumentNotFound(
+                "address",
+                self._address,
+                "no collection schedule found for this address",
+            )
+
+        return entries
+
+    def _lookup_properties(self) -> list[dict]:
+        # The municipality name may optionally be appended after a comma, e.g.
+        # "Storgata 1, Lillehammer". The search API only matches on the
+        # street + house number part, so that is what is used as the query.
+        address_part = self._address.split(",")[0].strip()
+        kommune_part = (
+            self._address.split(",", 1)[1].strip() if "," in self._address else None
+        )
+
+        r = requests.get(
+            SEARCH_URL, params={"q": address_part}, timeout=REQUEST_TIMEOUT
+        )
+        r.raise_for_status()
+        matches = r.json()
+
+        addr_norm = _normalize(address_part)
+        candidates = [m for m in matches if _normalize(m["adresse"]) == addr_norm]
+
+        if kommune_part:
+            kommune_norm = _normalize(kommune_part)
+            candidates = [
+                m for m in candidates if _normalize(m["kommune"]) == kommune_norm
+            ]
+        elif len({m["kommune"] for m in candidates}) > 1:
+            # The same street name exists in more than one municipality served
+            # by GLØR — the user needs to disambiguate by adding the
+            # municipality name after a comma.
+            suggestions = sorted(
+                {f"{m['adresse']}, {m['kommune']}" for m in candidates}
+            )
+            raise SourceArgumentNotFoundWithSuggestions(
+                "address", self._address, suggestions
+            )
+
+        if not candidates:
+            suggestions = sorted({f"{m['adresse']}, {m['kommune']}" for m in matches})
+            raise SourceArgumentNotFoundWithSuggestions(
+                "address", self._address, suggestions
+            )
+
+        return candidates

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

@@ -0,0 +1,196 @@
+import datetime
+import re
+import time
+
+import requests
+from waste_collection_schedule import Collection, Icons
+from waste_collection_schedule.exceptions import SourceArgumentNotFound
+
+TITLE = "Gloucester City Council"
+DESCRIPTION = "Source for Gloucester City Council, UK, bin collection dates."
+URL = "https://www.gloucester.gov.uk"
+TEST_CASES = {
+    "1 Whimbrel Road": {"uprn": 200004478006},
+    "10 Whimbrel Road": {"uprn": "200004478021"},
+}
+
+COUNTRY = "uk"
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": (
+        "Find your UPRN by visiting "
+        "https://gloucester-self.achieveservice.com/en/service/Bins___Check_your_bin_day "
+        "and searching for your address. Your UPRN can also be found at https://www.findmyaddress.co.uk/."
+    )
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "uprn": "Unique Property Reference Number (UPRN) for your address.",
+    }
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "uprn": "Unique Property Reference Number",
+    }
+}
+
+HOSTNAME = "gloucester-self.achieveservice.com"
+PROCESS_ID = "04123e92-cea3-42df-8131-ff6a2964ca47"
+STAGE_ID = "3316d9fa-2c89-4ef6-ab0c-0adf1b5c0af8"
+INITIAL_URL = f"https://{HOSTNAME}/AchieveForms/"
+API_URL = f"https://{HOSTNAME}/apibroker/runLookup"
+
+BIN_IDS_LOOKUP_ID = "63f72ddc8ca25"
+
+# For each bin type, the chain is:
+#   1. bin-ids lookup returns e.g. "RefuseId" for the address's UPRN
+#   2. workflow lookup, keyed on that id, returns a "{Type}1" workflow token
+#      (plus a human readable "{Type}_Schedule1" description)
+#   3. next-date lookup, keyed on that workflow token, returns
+#      "Next{Type}1DateISO"
+BIN_TYPES = {
+    "Refuse": {
+        "id_field": "RefuseId",
+        "workflow_lookup_id": "63f731d2b50d7",
+        "next_lookup_id": "63ca72c70c3b1",
+        "label": "Household waste (black bin)",
+    },
+    "Recycling": {
+        "id_field": "RecyclingId",
+        "workflow_lookup_id": "63f89f73018c0",
+        "next_lookup_id": "63cfcf4756b5d",
+        "label": "Recycling",
+    },
+    "Food": {
+        "id_field": "FoodId",
+        "workflow_lookup_id": "63f8a11714712",
+        "next_lookup_id": "63cfcf8ac7877",
+        "label": "Food waste",
+    },
+    "Garden": {
+        "id_field": "GardenId",
+        "workflow_lookup_id": "63f8a15776b5d",
+        "next_lookup_id": "63cfcfc1c486c",
+        "label": "Garden waste",
+    },
+}
+
+ICON_MAP = {
+    "Household waste (black bin)": Icons.GENERAL_WASTE,
+    "Recycling": Icons.RECYCLING,
+    "Food waste": Icons.BIO_KITCHEN,
+    "Garden waste": Icons.GARDEN,
+}
+
+
+class Source:
+    def __init__(self, uprn: str | int):
+        self._uprn = str(uprn).strip()
+
+    def _run_lookup(
+        self, session: requests.Session, sid: str, lookup_id: str, section_fields: dict
+    ) -> dict:
+        timestamp = int(time.time() * 1000)
+        resp = session.post(
+            API_URL,
+            params={
+                "id": lookup_id,
+                "repeat_against": "",
+                "noRetry": "true",
+                "getOnlyTokens": "undefined",
+                "log_id": "",
+                "app_name": "AF-Renderer::Self",
+                "_": timestamp,
+                "sid": sid,
+            },
+            json={"formValues": {"Your waste collections": section_fields}},
+            timeout=30,
+        )
+        resp.raise_for_status()
+        data = resp.json()
+        rows = data.get("integration", {}).get("transformed", {}).get("rows_data", {})
+        return rows.get("0", {})
+
+    def fetch(self) -> list[Collection]:
+        session = requests.Session()
+        session.headers.update({"user-agent": "Mozilla/5.0"})
+
+        # Step 1: Load the AchieveForms page to obtain a session id
+        r = session.get(
+            INITIAL_URL,
+            params={
+                "mode": "fill",
+                "consentMessage": "yes",
+                "form_uri": (
+                    f"sandbox-publish://AF-Process-{PROCESS_ID}"
+                    f"/AF-Stage-{STAGE_ID}/definition.json"
+                ),
+                "process": "1",
+                "process_uri": f"sandbox-processes://AF-Process-{PROCESS_ID}",
+                "process_id": f"AF-Process-{PROCESS_ID}",
+            },
+            timeout=30,
+        )
+        r.raise_for_status()
+
+        sid_match = re.search(r'"auth-session":"([^"]+)"', r.text)
+        if not sid_match:
+            raise SourceArgumentNotFound("uprn", self._uprn)
+        sid = sid_match.group(1)
+
+        # Step 2: Resolve the bin-type ids configured for this UPRN
+        bins_row = self._run_lookup(
+            session, sid, BIN_IDS_LOOKUP_ID, {"binUprn": {"value": self._uprn}}
+        )
+        if not bins_row:
+            raise SourceArgumentNotFound("uprn", self._uprn)
+
+        entries: list[Collection] = []
+        for bin_type, config in BIN_TYPES.items():
+            bin_id = bins_row.get(config["id_field"])
+            if not bin_id:
+                continue
+
+            # Step 3: Resolve the workflow token for this bin type
+            workflow_row = self._run_lookup(
+                session,
+                sid,
+                config["workflow_lookup_id"],
+                {config["id_field"]: {"value": bin_id}},
+            )
+            workflow_id = workflow_row.get(f"{bin_type}1")
+            if not workflow_id:
+                continue
+
+            # Step 4: Resolve the next collection date for this workflow
+            next_row = self._run_lookup(
+                session,
+                sid,
+                config["next_lookup_id"],
+                {f"{bin_type}1": {"value": workflow_id}},
+            )
+            date_iso = next_row.get(f"Next{bin_type}1DateISO")
+            if not date_iso:
+                continue
+
+            try:
+                collection_date = datetime.datetime.strptime(
+                    date_iso, "%Y-%m-%d"
+                ).date()
+            except ValueError:
+                continue
+
+            entries.append(
+                Collection(
+                    date=collection_date,
+                    t=config["label"],
+                    icon=ICON_MAP.get(config["label"]),
+                )
+            )
+
+        if not entries:
+            raise SourceArgumentNotFound("uprn", self._uprn)
+
+        return entries