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

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

@@ -0,0 +1,138 @@
+from datetime import datetime
+
+import requests
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import SourceArgumentNotFoundWithSuggestions
+
+TITLE = "Gore, Invercargill & Southland"
+DESCRIPTION = "Source for Wastenet.org.nz."
+URL = "https://www.wastenet.org.nz"
+SOURCE_CODEOWNERS = ["@etamtlosz"]
+
+TEST_CASES = {
+    "166 Lewis Street, Invercargill": {"address": "166 Lewis Street, Invercargill"},
+    "Old Format: 199 Crawford Street INVERCARGILL": {
+        "address": "199 Crawford Street INVERCARGILL"
+    },
+    "Old Format: 156 Tay Street INVERCARGILL": {
+        "address": "156 Tay Street INVERCARGILL"
+    },
+    "Gore: 1 Anderson Place": {"address": "1 Anderson Place, Gore"},
+    "ICC: 32 Gladstone Terrace, Invercargill": {
+        "address": "32 Gladstone Terrace, Invercargill"
+    },
+    "ICC: 15 King Street, Invercargill": {"address": "15 King Street, Invercargill"},
+    "ICC: 132 Leet Street, Invercargill": {"address": "132 Leet Street, Invercargill"},
+    "ICC: 20 Rodney Street, Invercargill": {
+        "address": "20 Rodney Street, Invercargill"
+    },
+    "ICC: 34 Lothian Crescent, Invercargill": {
+        "address": "34 Lothian Crescent, Invercargill"
+    },
+    "ICC: 69 Chesney Street, Invercargill": {
+        "address": "69 Chesney Street, Invercargill"
+    },
+}
+
+ICON_MAP = {
+    "General Waste": Icons.GENERAL_WASTE,
+    "Recycling": Icons.RECYCLING,
+}
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": "Visit WasteNet (https://www.wastenet.org.nz) and find your property address.",
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "address": "Full street address, e.g. '166 Lewis Street, Invercargill' or '1 Anderson Place, Gore'",
+    },
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "address": "Street Address",
+    },
+}
+
+HEADERS = {
+    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+    "Referer": "https://www.wastenet.org.nz/3-bin-day-finder",
+}
+
+ADDRESS_LIST_URL = "https://www.wastenet.org.nz/client-api/icc/rubbish/address-list"
+SEARCH_URL = "https://www.wastenet.org.nz/client-api/icc/rubbish/search"
+
+# Council identifier returned by the API
+COUNCIL_ICC = 1  # Invercargill City Council
+
+
+class Source:
+    def __init__(self, address: str):
+        # Normalise old-style "STREET INVERCARGILL" format to "STREET, Invercargill"
+        self._address = address.replace(" INVERCARGILL", ", Invercargill").strip()
+
+    def _resolve_address(self, session: requests.Session) -> str:
+        """Look up the canonical address from the provider's address list."""
+        r = session.get(ADDRESS_LIST_URL, timeout=30)
+        r.raise_for_status()
+        candidates: list[dict] = r.json()
+
+        # Exact match (case-insensitive)
+        for candidate in candidates:
+            if candidate["address"].lower() == self._address.lower():
+                return candidate["address"]
+
+        # Partial match: find entries that contain the search string
+        partial = [
+            c["address"]
+            for c in candidates
+            if self._address.lower() in c["address"].lower()
+        ]
+        if len(partial) == 1:
+            return partial[0]
+        if len(partial) > 1:
+            raise SourceArgumentNotFoundWithSuggestions(
+                "address", self._address, partial[:10]
+            )
+
+        raise SourceArgumentNotFoundWithSuggestions(
+            "address",
+            self._address,
+            [c["address"] for c in candidates[:5]],
+        )
+
+    def fetch(self) -> list[Collection]:
+        session = requests.Session()
+        session.headers.update(HEADERS)
+
+        canonical_address = self._resolve_address(session)
+
+        today = datetime.now().date().isoformat()
+        r = session.get(
+            SEARCH_URL,
+            params={"address": canonical_address, "date": today},
+            timeout=30,
+        )
+        r.raise_for_status()
+
+        data = r.json()
+        council: int = data.get("Council", COUNCIL_ICC)
+        entries: list[Collection] = []
+
+        for item in data.get("NextDates", []):
+            date = datetime.fromisoformat(item["Date"]).date()
+            week = item["Week"]  # "Red Week" or "Yellow Week"
+
+            if week == "Red Week":
+                entries.append(
+                    Collection(date, "General Waste", ICON_MAP["General Waste"])
+                )
+            elif week == "Yellow Week":
+                if council == COUNCIL_ICC:
+                    entries.append(
+                        Collection(date, "General Waste", ICON_MAP["General Waste"])
+                    )
+                entries.append(Collection(date, "Recycling", ICON_MAP["Recycling"]))
+
+        return entries

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

@@ -0,0 +1,217 @@
+import re
+import time
+from datetime import date
+from html import unescape
+
+import requests
+from waste_collection_schedule import Collection, Icons
+from waste_collection_schedule.exceptions import (
+    SourceArgumentException,
+    SourceArgumentExceptionMultiple,
+)
+
+TEST_CASES = {
+    "1 Coningsby Drive, Watford": {
+        "uprn": "100080932722",
+    }
+}
+
+TITLE = "Watford Borough Council"
+DESCRIPTION = "Source for waste collection services for Watford Borough Council"
+URL = "https://www.watford.gov.uk/"
+
+BASE_URL = "https://watfordbc-self.achieveservice.com"
+INITIAL_URL = f"{BASE_URL}/en/service/Bin_Collections?accept=yes&consentMessageIds[]=9"
+API_URL = f"{BASE_URL}/apibroker/runLookup"
+
+LOOKUP_ADDRESS_POINT = "5e57d2f638e6d"
+LOOKUP_NEXT_COLLECTIONS = "5e79edf15b2ec"
+LOOKUP_CALENDAR = "6750598d8b177"
+FORM_ID = "AF-Form-a139d516-46fc-4e1d-a94e-5e072681bcf0"
+REQUEST_TIMEOUT = 30
+
+ICON_MAP = {
+    "garden": Icons.GARDEN,
+    "black": Icons.GENERAL_WASTE,
+    "non-recyclable": Icons.GENERAL_WASTE,
+    "blue-lidded": Icons.RECYCLING,
+    "recycling": Icons.RECYCLING,
+    "brown": Icons.BIO_KITCHEN,
+    "food": Icons.BIO_KITCHEN,
+}
+
+
+class Source:
+    """Watford source.
+
+    Watford's public postcode lookup currently appears unreliable/broken when called
+    directly, but once the property token / UPRN is known the subsequent collection
+    lookups work consistently.
+
+    Preferred argument:
+      - uprn: property UPRN / selected address value from the Watford form
+
+    Optional:
+      - address: explicit selected address token from the Watford form
+    """
+
+    def __init__(self, uprn: str | int | None = None, address: str | int | None = None):
+        self._uprn = str(uprn).strip() if uprn is not None else None
+        self._address = str(address).strip() if address is not None else None
+        self._session = requests.Session()
+
+        if not self._uprn and not self._address:
+            raise SourceArgumentExceptionMultiple(
+                ["uprn", "address"],
+                "Either uprn or address must be provided.",
+            )
+
+    def _init_session(self) -> str:
+        r = self._session.get(INITIAL_URL, timeout=REQUEST_TIMEOUT)
+        r.raise_for_status()
+        match = re.search(r'"auth-session":"([^"]+)"', r.text)
+        if not match:
+            raise ValueError("Failed to obtain Watford auth session")
+        return match.group(1)
+
+    def _run_lookup(self, sid: str, lookup_id: str, form_values: dict) -> dict:
+        params = {
+            "id": lookup_id,
+            "repeat_against": "",
+            "noRetry": "false",
+            "getOnlyTokens": "undefined",
+            "log_id": "",
+            "app_name": "AF-Renderer::Self",
+            "_": str(int(time.time() * 1000)),
+            "sid": sid,
+        }
+        payload = {"formId": FORM_ID, "formValues": form_values}
+        r = self._session.post(
+            API_URL, params=params, json=payload, timeout=REQUEST_TIMEOUT
+        )
+        r.raise_for_status()
+        data = r.json()
+        transformed = data.get("integration", {}).get("transformed", {})
+        if data.get("status") == "error" or transformed.get("error"):
+            raise ValueError(
+                f"Watford lookup {lookup_id} failed: {data.get('error') or transformed.get('error') or data.get('data')}"
+            )
+        return transformed
+
+    def _resolve_identifiers(self, sid: str) -> tuple[str, str, str]:
+        address_token = self._address or self._uprn
+        uprn_value = self._uprn or self._address
+        # Normalise UPRN once: strip leading zeros for the echoUprn field and
+        # reuse the same normalised value in all subsequent lookups.
+        normalised_uprn = str(uprn_value).lstrip("0")
+        transformed = self._run_lookup(
+            sid,
+            LOOKUP_ADDRESS_POINT,
+            {
+                "Address": {
+                    "echoUprn": {"value": normalised_uprn},
+                    "address": {"value": str(address_token)},
+                }
+            },
+        )
+        row = transformed.get("rows_data", {}).get("0", {})
+        echo_address_point = row.get("echoAddressPoint")
+        if not echo_address_point:
+            raise ValueError("Watford source could not resolve echoAddressPoint")
+        return str(address_token), normalised_uprn, str(echo_address_point)
+
+    def _fetch_collections(
+        self, sid: str, address_token: str, uprn_value: str, echo_address_point: str
+    ) -> dict:
+        return self._run_lookup(
+            sid,
+            LOOKUP_NEXT_COLLECTIONS,
+            {
+                "Address": {
+                    "address": {"value": address_token},
+                    "echoUprn": {"value": uprn_value},
+                    "echoAddressPoint": {"value": echo_address_point},
+                }
+            },
+        )
+
+    def _fetch_calendar(
+        self, sid: str, address_token: str, uprn_value: str, echo_address_point: str
+    ) -> dict:
+        return self._run_lookup(
+            sid,
+            LOOKUP_CALENDAR,
+            {
+                "Address": {
+                    "address": {"value": address_token},
+                    "echoUprn": {"value": uprn_value},
+                    "echoAddressPoint": {"value": echo_address_point},
+                }
+            },
+        )
+
+    def _extract_collections_from_html(self, html_text: str) -> list[Collection]:
+        html_text = unescape(html_text)
+        items = re.findall(
+            r'<li class="binItem">(.*?)</li>', html_text, flags=re.DOTALL
+        )
+        entries = []
+
+        for item in items:
+            title_match = re.search(r"<h3>(.*?)</h3>", item, flags=re.DOTALL)
+            date_match = re.search(r"(\d{2}/\d{2}/\d{4})", item)
+            if not title_match or not date_match:
+                continue
+
+            waste_type = re.sub(r"\s+", " ", unescape(title_match.group(1))).strip()
+            day, month, year = date_match.group(1).split("/")
+            icon = None
+            lowered = waste_type.lower()
+            for token, mapped_icon in ICON_MAP.items():
+                if token in lowered:
+                    icon = mapped_icon
+                    break
+
+            entries.append(
+                Collection(
+                    date=date(int(year), int(month), int(day)),
+                    t=waste_type,
+                    icon=icon,
+                )
+            )
+
+        return entries
+
+    def fetch(self) -> list[Collection]:
+        sid = self._init_session()
+        address_token, uprn_value, echo_address_point = self._resolve_identifiers(sid)
+
+        collections_data = self._fetch_collections(
+            sid, address_token, uprn_value, echo_address_point
+        )
+
+        row = collections_data.get("rows_data", {}).get("0", {})
+        html_text = row.get("dispHTML", "")
+        entries = self._extract_collections_from_html(html_text)
+
+        if entries:
+            return entries
+
+        # Report errors against whichever argument the user actually configured.
+        arg = "uprn" if self._uprn else "address"
+
+        # Only fetch the calendar when needed (to diagnose why no entries were returned).
+        if row.get("lastCollection") == "NaN-aN-aN":
+            calendar_data = self._fetch_calendar(
+                sid, address_token, uprn_value, echo_address_point
+            )
+            calendar = calendar_data.get("rows_data", {}).get("0", {}).get("calendar")
+            raise SourceArgumentException(
+                arg,
+                f"Watford did not return collection data for this property token (calendar: {calendar or 'unknown'}).",
+            )
+
+        raise SourceArgumentException(
+            arg,
+            "Watford returned an unexpected response for this property token.",
+        )

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

@@ -0,0 +1,63 @@
+from datetime import datetime
+
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.service.WhitespaceWRP import WhitespaceClient
+
+TITLE = "Waverley Borough Council"
+DESCRIPTION = "Source for www.waverley.gov.uk services for Waverley Borough Council."
+URL = "https://waverley.gov.uk"
+TEST_CASES = {
+    "Example": {
+        "address_postcode": "GU8 5QQ",
+        "address_name_numer": "1",
+        "address_street": "Gasden Drive",
+    },
+    "Example No Postcode Space": {
+        "address_postcode": "GU85QQ",
+        "address_name_numer": "1",
+        "address_street": "Gasden Drive",
+    },
+}
+ICON_MAP = {
+    "Domestic Waste": Icons.GENERAL_WASTE,
+    "Recycling": Icons.RECYCLING,
+    "Garden Waste": Icons.GARDEN,
+    "Food Waste": Icons.BIO_KITCHEN,
+}
+
+API_URL = "https://wav-wrp.whitespacews.com/"
+
+
+class Source:
+    def __init__(
+        self,
+        address_name_numer=None,
+        address_street=None,
+        street_town=None,
+        address_postcode=None,
+    ):
+        self._address_name_numer = address_name_numer
+        self._address_street = address_street
+        self._street_town = street_town
+        self._address_postcode = address_postcode
+        self._client = WhitespaceClient(API_URL)
+
+    def fetch(self):
+        schedule = self._client.fetch_schedule(
+            address_name_number=self._address_name_numer,
+            address_postcode=self._address_postcode,
+            address_street=self._address_street,
+            street_town=self._street_town,
+        )
+
+        entries = []
+        for date_str, type_str in schedule:
+            collection_type = type_str.replace(" Collection Service", "")
+            entries.append(
+                Collection(
+                    date=datetime.strptime(date_str, "%d/%m/%Y").date(),
+                    t=type_str,
+                    icon=ICON_MAP.get(collection_type),
+                )
+            )
+        return entries

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

@@ -0,0 +1,70 @@
+import json
+from datetime import datetime
+
+import requests
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+
+TITLE = "Wealden District Council"
+DESCRIPTION = "Source for Wealden City services for Wealden District Council, UK."
+URL = "https://www.wealden.gov.uk"
+TEST_CASES = {
+    "Test_001": {"uprn": "10094620272"},
+    "Test_002": {"uprn": "200001678582"},
+    "Test_003": {"uprn": 100060120819},
+    "Test_004": {"uprn": 100060122306},
+}
+
+API_URL = "https://www.wealden.gov.uk/wp-admin/admin-ajax.php"
+ICON_MAP = {
+    "refuseCollectionDate": Icons.GENERAL_WASTE,
+    "recyclingCollectionDate": Icons.RECYCLING,
+    "gardenCollectionDate": Icons.GARDEN,
+    "foodCollectionDate": Icons.BIO_KITCHEN,
+}
+
+COLLECTIONS = {
+    "refuseCollectionDate": "Rubbish",
+    "recyclingCollectionDate": "Recycling",
+    "gardenCollectionDate": "Garden",
+    "foodCollectionDate": "Food",
+}
+
+HEADERS = {
+    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/113.0.0.0 Safari/537.36 Edg/113.0.1774.57",
+    "content-type": "application/x-www-form-urlencoded; charset=UTF-8",
+    "origin": "https://wealden.gov.uk",
+    "sec-ch-ua-mobile": "?0",
+    "sec-ch-ua-platform": "Windows",
+    "sec-fetch-dest": "empty",
+    "sec-fetch-mode": "cors",
+    "sec-fetch-site": "same-origin",
+    "x-requested-with": "XMLHttpRequest",
+}
+
+
+class Source:
+    def __init__(self, uprn):
+        self._uprn = str(uprn)
+
+    def fetch(self):
+        # s = requests.Session()
+        params = {"action": "wealden_get_collections_for_uprn", "uprn": self._uprn}
+        r = requests.post(API_URL, headers=HEADERS, data=params)
+        json_data = json.loads(r.text)["collection"]
+        entries = []
+
+        for collection in ICON_MAP:
+            try:
+                entries.append(
+                    Collection(
+                        datetime.strptime(
+                            json_data[collection], "%Y-%m-%dT%H:%M:%S"
+                        ).date(),
+                        t=COLLECTIONS[collection].title(),
+                        icon=ICON_MAP[collection],
+                    )
+                )
+            except ValueError:
+                pass  # ignore date conversion errors
+
+        return entries

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

@@ -0,0 +1,100 @@
+import dateutil.parser as parser
+import requests
+from bs4 import BeautifulSoup
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+
+TITLE = "Welwyn Hatfield Borough Council"
+DESCRIPTION = (
+    "Source for www.welhat.gov.uk services for Welwyn Hatfield Borough Council, UK."
+)
+URL = "https://www.welhat.gov.uk"
+TEST_CASES = {
+    "test 1 - South Red": {"uprn": "100080965745", "postcode": "AL9 5EA"},
+    "test 2 - Blue North": {"uprn": "100080977050", "postcode": "AL7 3ET"},
+}
+
+ICON_MAP = {
+    "food": Icons.BIO_KITCHEN,
+    "garden": Icons.GARDEN,
+    "refuse": Icons.GENERAL_WASTE,
+    "recycling": Icons.RECYCLING,
+}
+
+
+class Source:
+    def __init__(self, uprn: str, postcode: str):
+        self._uprn = uprn
+        self._postcode = postcode
+
+    def fetch(self):
+        # Request #1 - obtain "__token" value
+        headers_1 = {
+            "Host": "www.welhat.gov.uk",
+            "Cache-Control": "max-age=0",
+            "Upgrade-Insecure-Requests": "1",
+            "Origin": "https://www.welhat.gov.uk",
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36",
+            "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
+            "Referer": "https://www.welhat.gov.uk/xfp/form/214",
+            "Accept-Language": "en-GB,en-US;q=0.9,en;q=0.8",
+        }
+
+        url = "https://www.welhat.gov.uk/xfp/form/214"
+        response = requests.get(url, headers=headers_1)
+        html = response.text
+        soup = BeautifulSoup(html, "html.parser")
+        form = soup.find("form", action="/xfp/form/214")
+
+        token = form.find("input", {"name": "__token"}).get("value")
+
+        # Request #2 - retrieve next bin collection dates
+        headers_2 = {
+            "Host": "www.welhat.gov.uk",
+            "Cache-Control": "max-age=0",
+            "Upgrade-Insecure-Requests": "1",
+            "Origin": "https://www.welhat.gov.uk",
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36",
+            "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
+            "Referer": "https://www.welhat.gov.uk/xfp/form/214",
+            "Accept-Language": "en-GB,en-US;q=0.9,en;q=0.8",
+            "Content-Type": "multipart/form-data; boundary=----WebKitFormBoundaryuNcUUJl6BCDBZ9JO",
+        }
+
+        data = (
+            '------WebKitFormBoundaryuNcUUJl6BCDBZ9JO\r\nContent-Disposition: form-data; name="__token"\r\n\r\n'
+            + token
+            + '\r\n------WebKitFormBoundaryuNcUUJl6BCDBZ9JO\r\nContent-Disposition: form-data; name="page"\r\n\r\n492\r\n------WebKitFormBoundaryuNcUUJl6BCDBZ9JO\r\nContent-Disposition: form-data; name="locale"\r\n\r\nen_GB\r\n------WebKitFormBoundaryuNcUUJl6BCDBZ9JO\r\nContent-Disposition: form-data; name="q9f451fe0ca70775687eeedd1e54b359e55f7c10c_0_0"\r\n\r\n'
+            + self._postcode
+            + '\r\n------WebKitFormBoundaryuNcUUJl6BCDBZ9JO\r\nContent-Disposition: form-data; name="q9f451fe0ca70775687eeedd1e54b359e55f7c10c_1_0"\r\n\r\n'
+            + self._uprn
+            + '\r\n------WebKitFormBoundaryuNcUUJl6BCDBZ9JO\r\nContent-Disposition: form-data; name="qc3b0352c12fed5336c22352db2780a94ba369763"\r\n\r\nDomestic Waste Collection Service\r\n------WebKitFormBoundaryuNcUUJl6BCDBZ9JO\r\nContent-Disposition: form-data; name="q17867a1a3aa5a53e67cceb42ae4c4fa70dade69d"\r\n\r\nGarden Waste Collection Service\r\n------WebKitFormBoundaryuNcUUJl6BCDBZ9JO\r\nContent-Disposition: form-data; name="q0144c9059f13b2db9178a6c6fca02addc03829f5"\r\n\r\nDomestic Waste Sack Collection Service\r\n------WebKitFormBoundaryuNcUUJl6BCDBZ9JO\r\nContent-Disposition: form-data; name="qbaf6e9054b74213122e216f782a221f97eb98ce5"\r\n\r\nRecycling Collection Service\r\n------WebKitFormBoundaryuNcUUJl6BCDBZ9JO\r\nContent-Disposition: form-data; name="q5176b7585f1db820bff96c617966eb586c4b8687"\r\n\r\nFood Waste Collection Service\r\n------WebKitFormBoundaryuNcUUJl6BCDBZ9JO\r\nContent-Disposition: form-data; name="q90aa73493450c00b4651493354808f4e7cb26454"\r\n\r\nPM\r\n------WebKitFormBoundaryuNcUUJl6BCDBZ9JO\r\nContent-Disposition: form-data; name="q73adcf07adf82c347e258dcce449ad7a6104e225"\r\n\r\n2023-05-10\r\n------WebKitFormBoundaryuNcUUJl6BCDBZ9JO\r\nContent-Disposition: form-data; name="q8d79140ae1240f397891c65bd01c65e4c5003804"\r\n\r\n2023-05-06\r\n------WebKitFormBoundaryuNcUUJl6BCDBZ9JO\r\nContent-Disposition: form-data; name="q5c1829b11ffbb34009248f4706ec98c9558b5e34"\r\n\r\n2023-05-13\r\n------WebKitFormBoundaryuNcUUJl6BCDBZ9JO\r\nContent-Disposition: form-data; name="q38f336d0c9beb90a6345002e6d913800fb4f04fa"\r\n\r\n\r\n------WebKitFormBoundaryuNcUUJl6BCDBZ9JO\r\nContent-Disposition: form-data; name="next"\r\n\r\nNext\r\n------WebKitFormBoundaryuNcUUJl6BCDBZ9JO--\r\n'
+        )
+
+        response = requests.post(
+            "https://www.welhat.gov.uk/xfp/form/214", headers=headers_2, data=data
+        )
+        html = response.text
+        soup = BeautifulSoup(html, "html.parser")
+        table = soup.table
+        entries = []
+
+        for row in table.tbody.find_all("tr"):
+            columns = row.find_all("td")
+            collection = columns[0].text.strip()
+            if collection == "Food Waste Collection Service":
+                collection = "food"
+            elif collection == "Garden Waste Collection Service":
+                collection = "garden"
+            elif collection == "Recycling Collection Service":
+                collection = "recycling"
+            elif collection == "Domestic Waste Collection Service":
+                collection = "refuse"
+            else:
+                collection = "unknown"
+            date = columns[1].text.strip()
+            date = parser.parse(date).date()
+            entries.append(
+                Collection(date=date, t=collection, icon=ICON_MAP.get(collection))
+            )
+
+        return entries

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

@@ -0,0 +1,93 @@
+import datetime
+import json
+
+import requests
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import (
+    SourceArgAmbiguousWithSuggestions,
+    SourceArgumentException,
+    SourceArgumentNotFound,
+)
+from waste_collection_schedule.service.ICS import ICS
+
+TITLE = "Wellington City Council"
+DESCRIPTION = "Source for Wellington City Council."
+URL = "https://wellington.govt.nz"
+TEST_CASES = {
+    "Chelsea St": {"streetName": "Cheltenham Terrace"},  # Friday
+    # "Campbell St (ID Only)": {"streetId": "6515"},  # Wednesday
+}
+
+
+ICON_MAP = {
+    "Rubbish Collection": Icons.GENERAL_WASTE,
+    "Glass crate": Icons.GLASS,
+    "Wheelie bin or recycling bags": Icons.RECYCLING,
+}
+
+PICTURE_MAP = {
+    "Rubbish Collection": "https://wellington.govt.nz/assets/images/rubbish-recycling/rubbish-bag.png",
+    "Glass crate": "https://wellington.govt.nz/assets/images/rubbish-recycling/glass-crate.png",
+    "Wheelie bin or recycling bags": "https://wellington.govt.nz/assets/images/rubbish-recycling/wheelie-bin.png",
+}
+
+HEADERS = {
+    "User-Agent": "Mozilla/5.0 Gecko/20100101 Firefox/136.0",
+}
+
+
+class Source:
+    def __init__(self, streetId=None, streetName=None):
+        self._streetId = streetId
+        self._streetName = streetName
+        self._ics = ICS()
+
+    def fetch(self):
+        # get token
+        if self._streetName:
+            url = "https://wellington.govt.nz/layouts/wcc/GeneralLayout.aspx/GetRubbishCollectionStreets"
+            data = {"partialStreetName": self._streetName}
+            r = requests.post(url, json=data, headers=HEADERS)
+            data = json.loads(r.text)
+            if len(data["d"]) == 0:
+                raise SourceArgumentNotFound("streetName", self._streetName)
+            if len(data["d"]) > 1:
+                print(data["d"])
+                raise SourceArgAmbiguousWithSuggestions(
+                    "streetName",
+                    self._streetName,
+                    [x["Value"].split(",")[0] for x in data["d"]],
+                )
+            self._streetId = data["d"][0].get("Key")
+
+        if not self._streetId:
+            raise Exception("No streetId or streetName supplied")
+
+        url = "https://wellington.govt.nz/~/ical/"
+        params = {
+            "type": "recycling",
+            "streetId": self._streetId,
+            "forDate": datetime.date.today(),
+        }
+        r = requests.get(url, params=params, headers=HEADERS)
+
+        if not r.text.startswith("BEGIN:VCALENDAR"):
+            raise SourceArgumentException(
+                "streetId", f"{self._streetId} is not a valid streetID"
+            )
+
+        dates = self._ics.convert(r.text)
+
+        entries = []
+        for d in dates:
+            for wasteType in d[1].split("&"):
+                wasteType = wasteType.strip()
+                entries.append(
+                    Collection(
+                        d[0],
+                        wasteType,
+                        picture=PICTURE_MAP.get(wasteType),
+                        icon=ICON_MAP.get(wasteType),
+                    )
+                )
+        return entries