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

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

@@ -0,0 +1,64 @@
+from datetime import datetime
+
+import requests
+from waste_collection_schedule import Collection, Icons
+from waste_collection_schedule.exceptions import SourceArgumentNotFound
+
+TITLE = "EAD Darmstadt"  # Title will show up in README.md and info.md
+DESCRIPTION = "Source script for waste collection in Darmstadt ead.darmstadt.de"  # Describe your source
+URL = "https://ead.darmstadt.de/"  # Insert url to service homepage. URL will show up in README.md and info.md
+TEST_CASES = {  # Insert arguments for test cases to be used by test_sources.py script
+    "Stresemannstraße": {"street": "Stresemannstraße"},
+    "Trondheimstraße": {"street": "Trondheimstraße"},
+    "Mühltalstraße": {"street": "Mühltalstraße"},
+    "Heinheimer Straße": {"street": "Heinheimer Straße 1-15, 2-16"},
+    "Kleyerstraße": {"street": "Kleyerstraße"},
+    "Untere Mühlstraße": {"street": "Untere Mühlstraße 1-29, 2-36"},
+}
+
+API_URL = "https://ead.darmstadt.de/unser-angebot/privathaushalte/abfallkalender/singleStreet/"
+ICON_MAP = {
+    "RM1": Icons.GENERAL_WASTE,
+    "RM2": Icons.GENERAL_WASTE,
+    "RM4": Icons.GENERAL_WASTE,
+    "WET": Icons.RECYCLING,
+    "BIO": Icons.ORGANIC,
+    "PPK": Icons.PAPER,
+}
+
+PARAM_TRANSLATIONS = {
+    "de": {
+        "street": "Straße",
+    }
+}
+
+
+class Source:
+    def __init__(
+        self, street
+    ):  # argX correspond to the args dict in the source configuration
+        self.street = street
+
+    def fetch(self):
+        params = {"type": "742394", "street": self.street}
+        r = requests.get(API_URL, params=params)
+        r.raise_for_status()
+
+        schedule = r.json()
+        if schedule is None or len(schedule) == 0:
+            raise SourceArgumentNotFound("street", self.street)
+
+        entries = []  # List that holds collection schedule
+        for date, waste_type_list in schedule.items():
+            for waste_type in waste_type_list:
+                entries.append(
+                    Collection(
+                        date=datetime.strptime(
+                            date, "%d.%m.%Y"
+                        ).date(),  # Collection date
+                        t=waste_type,  # Collection type
+                        icon=ICON_MAP.get(waste_type),  # Collection icon
+                    )
+                )
+
+        return entries

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

@@ -0,0 +1,46 @@
+from datetime import datetime
+
+import requests
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+
+TITLE = "Ealing Council"
+DESCRIPTION = "Source for Ealing Council."
+URL = "https://www.ealing.gov.uk"
+TEST_CASES = {
+    "11 LOTHAIR ROAD, EALING, LONDON, W5 4TA": {"uprn": 12081500},
+    "53 CREIGHTON ROAD, EALING, LONDON, W5 4SH": {"uprn": "12082293"},
+}
+
+
+ICON_MAP = {
+    "BLACK": Icons.GENERAL_WASTE,
+    "GARDEN": Icons.GARDEN,
+    "BLUE": Icons.RECYCLING,
+    "FOOD": Icons.BIO_KITCHEN,
+}
+
+
+API_URL = "https://www.ealing.gov.uk/site/custom_scripts/WasteCollectionWS/home/FindCollection"
+
+
+class Source:
+    def __init__(self, uprn: str | int):
+        self._uprn: str | int = uprn
+
+    def fetch(self) -> list[Collection]:
+        args = {"UPRN": self._uprn}
+
+        r = requests.post(API_URL, data=args)
+        r.raise_for_status()
+
+        data = r.json()
+
+        entries = []
+        for d in data["param2"]:
+            bin_type = d["Service"]
+            icon = ICON_MAP.get(bin_type.split()[0])  # Collection icon
+            for date_str in d["collectionDate"]:
+                date = datetime.strptime(date_str, "%d/%m/%Y").date()
+                entries.append(Collection(date=date, t=bin_type, icon=icon))
+
+        return entries

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

@@ -0,0 +1,48 @@
+import requests
+from bs4 import BeautifulSoup
+from dateutil import parser
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+
+TITLE = "East Ayrshire Council"
+DESCRIPTION = "Source for east-ayrshire.gov.uk services for East Ayrshire"
+URL = "https://www.east-ayrshire.gov.uk/"
+API_URL = "https://www.east-ayrshire.gov.uk/Housing/RubbishAndRecycling/Collection-days/ViewYourRecyclingCalendar.aspx?r="
+
+TEST_CASES = {
+    "Test_001": {"uprn": "127071649"},
+    "Test_002": {"uprn": 127072649},
+    "Test_003": {"uprn": 127072016},
+}
+
+ICON_MAP = {
+    "General waste bin": Icons.GENERAL_WASTE,
+    "Garden waste bin": Icons.GARDEN,
+    "Recycling trolley": Icons.RECYCLING,
+}
+
+
+class Source:
+    def __init__(self, uprn):
+        self._uprn = str(uprn)
+
+    def fetch(self):
+        session = requests.Session()
+        return self.__get_bin_collection_info_page(session, self._uprn)
+
+    def __get_bin_collection_info_page(self, session, uprn):
+        r = session.get(API_URL + uprn)
+        r.raise_for_status()
+        soup = BeautifulSoup(r.text, "html.parser")
+        bin_list = soup.find_all("time")
+        entries = []
+        for bins in bin_list:
+            entries.append(
+                Collection(
+                    date=parser.parse(bins["datetime"]).date(),
+                    t=bins.select_one("span.ScheduleItem").get_text().strip(),
+                    icon=ICON_MAP.get(
+                        bins.select_one("span.ScheduleItem").get_text().strip()
+                    ),
+                )
+            )
+        return entries

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

@@ -0,0 +1,61 @@
+from datetime import datetime, timedelta
+
+import requests
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+
+TITLE = "East Northamptonshire and Wellingborough"
+DESCRIPTION = "Source for East Northamptonshire and Wellingborough"
+URL = "east-northamptonshire.gov.uk"
+TEST_CASES = {
+    "Raunds": {"uprn": "100031046896"},
+    "Rusheden": {"uprn": "100031028202"},
+    "Easton on the Hill": {"uprn": 100031040850},
+    "Lutton": {"uprn": 200000735573},
+    "Wellingborough": {"uprn": 100031193921},
+}
+
+ICON_MAP = {
+    "general": Icons.GENERAL_WASTE,
+    "recycling": Icons.RECYCLING,
+}
+
+
+API_URL = "https://api.northnorthants.gov.uk/test/wc-info/{uprn}"
+
+DAYS = {"MON": 0, "TUE": 1, "WED": 2, "THU": 3, "FRI": 4}
+
+
+class Source:
+    def __init__(self, uprn: str):
+        self._uprn: str = uprn
+
+    def fetch(self):
+        r = requests.get(API_URL.format(uprn=self._uprn))
+        r.raise_for_status()
+        r.json()
+
+        data = r.json()
+
+        process_day = datetime.now()
+        while process_day.weekday() != DAYS.get(data["day"]):
+            process_day = process_day + timedelta(days=1)
+
+        reference_date = datetime(2022, 6, 20)
+        entries = []
+
+        for _ in range(10):
+            weeks_diff: int = int((process_day - reference_date).days / 7)
+            if weeks_diff % 2 == 0:
+                bin_type = "general" if data["schedule"] == "B" else "recycling"
+            else:
+                bin_type = "recycling" if data["schedule"] == "B" else "general"
+
+            entries.append(
+                Collection(
+                    date=process_day.date(), t=bin_type, icon=ICON_MAP.get(bin_type)
+                )
+            )
+
+            process_day = process_day + timedelta(days=7)
+
+        return entries

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

@@ -0,0 +1,180 @@
+from urllib.parse import parse_qs, urlparse
+
+from bs4 import BeautifulSoup
+from curl_cffi import requests
+from dateutil import parser
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+
+TITLE = "East Renfrewshire Council"
+DESCRIPTION = "Source for eastrenfrewshire.gov.uk services for East Renfrewshire"
+URL = "https://eastrenfrewshire.gov.uk"  # apex host (no www)
+FORM_PAGE = f"{URL}/bin-days"
+
+TEST_CASES = {
+    "Test_001": {"postcode": "G78 2TJ", "uprn": "131016859"},
+    "Test_002": {"postcode": "g775ar", "uprn": 131019331},
+    "Test_003": {"postcode": "g78 3er", "uprn": "000131020112"},
+}
+
+ICON_MAP = {
+    "Grey": Icons.GENERAL_WASTE,
+    "Brown": Icons.ORGANIC,
+    "Green": Icons.GLASS,
+    "Blue": Icons.EVENT,
+}
+
+
+class Source:
+    def __init__(self, postcode, uprn):
+        if not postcode or not uprn:
+            raise ValueError("Both 'postcode' and 'uprn' must be provided.")
+        self._postcode = postcode
+        self._uprn = str(uprn).zfill(12)
+
+    def fetch(self):
+        # Cloudflare-aware session
+        session = requests.Session(impersonate="chrome124")
+        session.headers.update(
+            {
+                "User-Agent": (
+                    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
+                    "AppleWebKit/537.36 (KHTML, like Gecko) "
+                    "Chrome/129.0.0.0 Safari/537.36"
+                ),
+                "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+                "Accept-Language": "en-GB,en;q=0.9",
+            }
+        )
+
+        address_page = self.__get_address_page(session, self._postcode)
+        bin_collection_info_page = self.__get_bin_collection_info_page(
+            session, address_page, self._uprn
+        )
+        return self.__get_bin_collection_info(bin_collection_info_page)
+
+    def __get_address_page(self, s, postcode):
+        r = s.get(FORM_PAGE, timeout=30)
+        r.raise_for_status()
+        soup = BeautifulSoup(r.text, "html.parser")
+        form = soup.find(id="BINDAYSV2_FORM")
+        if not form or not form.has_attr("action"):
+            raise Exception(
+                "Form with id 'BINDAYSV2_FORM' and 'action' attribute not found on PAGE1."
+            )
+
+        # Prefer hidden inputs if present; fallback to action query params
+        def _val(name):
+            el = form.find("input", attrs={"name": name})
+            return el["value"] if el and el.has_attr("value") else ""
+
+        page_session_id = _val("BINDAYSV2_PAGESESSIONID")
+        session_id = _val("BINDAYSV2_SESSIONID")
+        nonce = _val("BINDAYSV2_NONCE")
+        if not (page_session_id and session_id and nonce):
+            goss_ids = self.__get_goss_form_ids(form["action"])
+            page_session_id = page_session_id or goss_ids["page_session_id"]
+            session_id = session_id or goss_ids["session_id"]
+            nonce = nonce or goss_ids["nonce"]
+
+        r = s.post(
+            form["action"],
+            headers={"Origin": URL, "Referer": FORM_PAGE},
+            data={
+                "BINDAYSV2_PAGESESSIONID": page_session_id,
+                "BINDAYSV2_SESSIONID": session_id,
+                "BINDAYSV2_NONCE": nonce,
+                "BINDAYSV2_VARIABLES": "e30=",
+                "BINDAYSV2_PAGENAME": "PAGE1",
+                "BINDAYSV2_PAGEINSTANCE": "0",
+                "BINDAYSV2_PAGE1_POSTCODE": postcode,
+                "BINDAYSV2_FORMACTION_NEXT": "BINDAYSV2_PAGE1_FIELD290",
+            },
+            timeout=30,
+        )
+        r.raise_for_status()
+        return r.text
+
+    def __get_bin_collection_info_page(self, session, address_page, uprn):
+        soup = BeautifulSoup(address_page, "html.parser")
+        form = soup.find(id="BINDAYSV2_FORM")
+        if not form or not form.has_attr("action"):
+            raise Exception(
+                "Form with id 'BINDAYSV2_FORM' and 'action' attribute not found on PAGE2."
+            )
+
+        def _val(name):
+            el = form.find("input", attrs={"name": name})
+            return el["value"] if el and el.has_attr("value") else ""
+
+        page_session_id = _val("BINDAYSV2_PAGESESSIONID")
+        session_id = _val("BINDAYSV2_SESSIONID")
+        nonce = _val("BINDAYSV2_NONCE")
+        if not (page_session_id and session_id and nonce):
+            goss_ids = self.__get_goss_form_ids(form["action"])
+            page_session_id = page_session_id or goss_ids["page_session_id"]
+            session_id = session_id or goss_ids["session_id"]
+            nonce = nonce or goss_ids["nonce"]
+
+        r = session.post(
+            form["action"],
+            headers={"Origin": URL, "Referer": FORM_PAGE},
+            data={
+                "BINDAYSV2_PAGESESSIONID": page_session_id,
+                "BINDAYSV2_SESSIONID": session_id,
+                "BINDAYSV2_NONCE": nonce,
+                "BINDAYSV2_VARIABLES": "e30=",
+                "BINDAYSV2_PAGENAME": "PAGE2",
+                "BINDAYSV2_PAGEINSTANCE": "0",
+                "BINDAYSV2_PAGE2_FIELD293": "true",
+                "BINDAYSV2_PAGE2_UPRN": uprn,
+                "BINDAYSV2_FORMACTION_NEXT": "BINDAYSV2_PAGE2_FIELD294",
+                "BINDAYSV2_PAGE2_FIELD295": "false",
+                "BINDAYSV2_PAGE2_FIELD297": "false",
+            },
+            timeout=30,
+        )
+        r.raise_for_status()
+        return r.text
+
+    def __get_bin_collection_info(self, html_page):
+        soup = BeautifulSoup(html_page, "html.parser")
+        table_div = soup.find("div", id="BINDAYSV2_RESULTS_NEXTCOLLECTIONLISTV4")
+        if not table_div:
+            raise Exception("Could not find bin collection results table.")
+
+        rows = table_div.find_all("tr")[1:]  # skip header
+        entries = []
+
+        for row in rows:
+            cols = row.find_all("td")
+            if len(cols) < 3:
+                continue
+
+            date_str = cols[0].get_text(strip=True)
+            bin_types_html = cols[2]
+
+            try:
+                date = parser.parse(date_str, dayfirst=True).date()
+            except Exception:
+                continue
+
+            for img in bin_types_html.find_all("img"):
+                color = img.get("alt", "").split()[0]
+                entries.append(
+                    Collection(
+                        date=date,
+                        t=color,
+                        icon=ICON_MAP.get(color),
+                    )
+                )
+
+        return entries
+
+    def __get_goss_form_ids(self, url):
+        parsed = urlparse(url)
+        qs = parse_qs(parsed.query)
+        return {
+            "page_session_id": qs.get("pageSessionId", [""])[0],
+            "session_id": qs.get("fsid", [""])[0],
+            "nonce": qs.get("fsn", [""])[0],
+        }

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

@@ -0,0 +1,198 @@
+import datetime
+import re
+import time
+
+import requests
+from waste_collection_schedule import Collection, Icons
+from waste_collection_schedule.exceptions import SourceArgumentNotFound
+
+TITLE = "East Cambridgeshire District Council"
+DESCRIPTION = "Source for eastcambs.gov.uk, East Cambridgeshire District Council, UK"
+URL = "https://www.eastcambs.gov.uk"
+TEST_CASES = {
+    "14 Meadow Way Ely": {"uprn": 10002601730},
+    "20 Forehill Ely": {"uprn": "10002597181"},
+}
+
+COUNTRY = "uk"
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": (
+        "Find your UPRN by visiting "
+        "https://eastcambs-self.achieveservice.com/service/Check_your_waste_collection_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 = "eastcambs-self.achieveservice.com"
+PROCESS_ID = "2c7575a6-0139-4555-9d8a-ab504a44d989"
+STAGE_ID = "94ee5097-94db-474d-bc7a-d1796e3ab83a"
+INITIAL_URL = f"https://{HOSTNAME}/AchieveForms/"
+AUTH_LOOKUP_ID = "69d8f92eea3cf"
+COLLECTIONS_LOOKUP_ID = "6784e74793b68"
+API_URL = f"https://{HOSTNAME}/apibroker/runLookup"
+
+ICON_MAP = {
+    "RECYCLING BIN": Icons.RECYCLING,
+    "OUTDOOR FOOD CADDY": Icons.BIO_KITCHEN,
+    "INDOOR FOOD CADDY": Icons.BIO_KITCHEN,
+    "RUBBISH BIN": Icons.GENERAL_WASTE,
+    "GARDEN WASTE BIN": Icons.GARDEN,
+    "BROWN BAGS": Icons.GENERAL_WASTE,
+    "PURPLE BAGS": Icons.RECYCLING,
+    "CLEAR BAGS": Icons.RECYCLING,
+    "BLACK BAG": Icons.GENERAL_WASTE,
+    "BLUE BIN": Icons.RECYCLING,
+    "GREEN": Icons.GARDEN,
+}
+
+
+def _get_icon(collection_type: str) -> str | None:
+    upper = collection_type.upper()
+    for key, icon in ICON_MAP.items():
+        if key in upper:
+            return icon
+    return None
+
+
+class Source:
+    def __init__(self, uprn: str | int):
+        self._uprn = str(uprn).strip()
+
+    def fetch(self) -> list[Collection]:
+        session = requests.Session()
+        session.headers.update({"user-agent": "Mozilla/5.0"})
+
+        # Step 1: Load the AchieveForms page to get a session
+        r = session.get(
+            INITIAL_URL,
+            params={
+                "mode": "fill",
+                "consentMessage": "yes",
+                "form_uri": f"sandbox-publish://AF-Process-{PROCESS_ID}/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 ValueError("Could not obtain session ID from East Cambs service")
+        sid = sid_match.group(1)
+
+        # Step 2: Obtain authentication token
+        timestamp = int(time.time() * 1000)
+        r_auth = session.post(
+            API_URL,
+            params={
+                "id": AUTH_LOOKUP_ID,
+                "repeat_against": "",
+                "noRetry": "false",
+                "getOnlyTokens": "undefined",
+                "log_id": "",
+                "app_name": "AchieveForms",
+                "_": timestamp,
+                "sid": sid,
+            },
+            json={"formValues": {"Section 1": {}}},
+            timeout=30,
+        )
+        r_auth.raise_for_status()
+        auth_data = r_auth.json()
+        auth_token = (
+            auth_data.get("integration", {})
+            .get("transformed", {})
+            .get("rows_data", {})
+            .get("0", {})
+            .get("AuthenticateResponse", "")
+        )
+
+        # Step 3: Fetch upcoming bin collections
+        today = datetime.date.today()
+        # The new service started June 1 2026; use that as the earliest start date
+        service_start = datetime.date(2026, 6, 1)
+        start_date = max(today, service_start)
+        end_date = today + datetime.timedelta(days=90)
+
+        timestamp = int(time.time() * 1000)
+        r_col = session.post(
+            API_URL,
+            params={
+                "id": COLLECTIONS_LOOKUP_ID,
+                "repeat_against": "",
+                "noRetry": "false",
+                "getOnlyTokens": "undefined",
+                "log_id": "",
+                "app_name": "AchieveForms",
+                "_": timestamp,
+                "sid": sid,
+            },
+            json={
+                "formValues": {
+                    "Section 1": {
+                        "AuthenticateResponse": {"value": auth_token},
+                        "selected_uprn": {"value": self._uprn},
+                        "MinimumDateForNextDates": {
+                            "value": start_date.strftime("%Y-%m-%d")
+                        },
+                        "MaximumDateFormattedNext": {
+                            "value": end_date.strftime("%Y-%m-%d")
+                        },
+                    }
+                }
+            },
+            timeout=30,
+        )
+        r_col.raise_for_status()
+        col_data = r_col.json()
+
+        # select_data contains all collection occurrences in chronological order
+        # Each entry: {"label": "BIN TYPE - DD/MM/YYYY", "value": "BIN TYPE"}
+        select_data = (
+            col_data.get("integration", {})
+            .get("transformed", {})
+            .get("select_data", [])
+        )
+
+        if not select_data:
+            raise SourceArgumentNotFound("uprn", self._uprn)
+
+        entries: list[Collection] = []
+        for item in select_data:
+            label = item.get("label", "")
+            # Label format: "BIN TYPE - DD/MM/YYYY"
+            parts = label.rsplit(" - ", 1)
+            if len(parts) != 2:
+                continue
+            bin_type, date_str = parts
+            try:
+                collection_date = datetime.datetime.strptime(
+                    date_str, "%d/%m/%Y"
+                ).date()
+            except ValueError:
+                continue
+
+            entries.append(
+                Collection(
+                    date=collection_date,
+                    t=bin_type.strip(),
+                    icon=_get_icon(bin_type.strip()),
+                )
+            )
+
+        return entries

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

@@ -0,0 +1,72 @@
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import SourceArgumentRequired
+from waste_collection_schedule.service.uk_cloud9_apps import Cloud9Client
+
+TITLE = "East Devon District Council"
+DESCRIPTION = "Source for East Devon services for East Devon District Council, UK."
+URL = "https://eastdevon.gov.uk/"
+COUNTRY = "uk"
+TEST_CASES = {
+    "Test_001": {"uprn": "010000246114"},
+    "Test_002": {"uprn": 10000272679},
+    "Test_003": {"postcode": "EX8 2AN", "address": "1 Dagmar Road"},
+    "Test_004": {"postcode": "EX5 2AB", "address": "1 Blackhorse Cottages"},
+}
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": "Either give your UPRN, or give your postcode together with your address. You can find your UPRN by visiting [Find My Address](https://www.findmyaddress.co.uk) and entering your address details, or from the UPRN query parameter on the East Devon bin collection page."
+}
+PARAM_TRANSLATIONS = {
+    "en": {
+        "uprn": "Unique Property Reference Number (UPRN)",
+        "postcode": "Postcode",
+        "address": "Address",
+    }
+}
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "uprn": "Unique Property Reference Number (UPRN)",
+        "postcode": "Postcode, e.g. EX8 2AN. Use together with address instead of a UPRN.",
+        "address": "House name or number and street, e.g. 1 Dagmar Road. Use together with postcode instead of a UPRN.",
+    }
+}
+ICON_MAP = {
+    "refuse": Icons.GENERAL_WASTE,
+    "rubbish": Icons.GENERAL_WASTE,
+    "recycl": Icons.RECYCLING,
+    "food": Icons.BIO_KITCHEN,
+    "green": Icons.GARDEN,
+    "garden": Icons.GARDEN,
+}
+SOURCE_CODEOWNERS = ["@SimonRice"]
+
+
+class Source:
+    def __init__(
+        self,
+        uprn: str | int | None = None,
+        postcode: str | None = None,
+        address: str | None = None,
+    ):
+        self._client = Cloud9Client("eastdevon", icon_keywords=ICON_MAP)
+        # Existing configurations pass a bare UPRN, which this API wants
+        # zero-padded to 12 digits. Keep the padding so they keep working.
+        self._uprn = str(uprn).zfill(12) if uprn else None
+        self._postcode = postcode
+        self._address = address
+
+    def fetch(self) -> list[Collection]:
+        if self._uprn:
+            return self._client.fetch_by_uprn(self._uprn)
+        if not self._postcode:
+            raise SourceArgumentRequired(
+                "uprn", "Provide a UPRN, or a postcode together with an address"
+            )
+        return self._client.fetch_by_address(
+            postcode=self._postcode,
+            address_string=self._address or "",
+            # The client's suggestions are whole addresses and it reports the
+            # address it was given as the offending value, so they belong to
+            # the address argument: picking one has to refine `address`, not
+            # overwrite the postcode with a full address.
+            argument_name="address",
+        )