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

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

@@ -0,0 +1,285 @@
+import datetime
+import logging
+from datetime import date, timedelta
+
+import requests
+from waste_collection_schedule import Collection, Icons
+
+TITLE = "City of Plano"  # Title will show up in README.md and info.md
+DESCRIPTION = "Source script for plano.gov"  # Describe your source
+COUNTRY = "us"  # ISO 3166-1 alpha-2 country code, e.g. "DE" for Germany, "US" for United States
+URL = "https://www.plano.gov/630/Residential-Collection-Schedules"  # 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
+    "GoodObjectId3Days": {
+        "objectId": "72866",
+        "daysToGenerate": "3",
+    },  # Example object ID, This is an public art center run out of a residential address but its a historic home so not PII
+    "GoodObjectId5Days": {
+        "objectId": "72866",
+        "daysToGenerate": "5",
+    },  # Example object ID, This is an public art center run out of a residential address but its a historic home so not PII
+    "GoodObjectId0Days": {
+        "objectId": "72866",
+        "daysToGenerate": "0",
+    },  # Example object ID, This is an public art center run out of a residential address but its a historic home so not PII,
+    # days to generate being 0 should result in the same output at the default (3)
+    # "GoodObjectIdBadDays": {
+    #      "objectId": "72866",
+    #      "daysToGenerate": "f",
+    # }, # This is commented because it fails (on purpose) and I don't know how we indicate to the test_sources script that we expect failure
+}
+
+API_URL = "https://maps.planogis.org/arcgiswad/rest/services/Sustainability/ServicedAddresses/MapServer/0/query?"
+ICON_MAP = {
+    "TRASH": Icons.GENERAL_WASTE,
+    "RECYCLE": Icons.RECYCLING,
+    "BULKY": Icons.BULKY,
+}
+WEEKDAYMAP = {
+    "Monday": 0,
+    "Tuesday": 1,
+    "Wednesday": 2,
+    "Thursday": 3,
+    "Friday": 4,
+    "Saturday": 5,
+    "Sunday": 6,
+}
+
+# ### Arguments affecting the configuration GUI ####
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {  # Optional dictionary to describe how to get the arguments, will be shown in the GUI configuration form above the input fields, does not need to be translated in all languages
+    "en": "Use [The Plano interactive waste map](https://www.plano.gov/630/Residential-Collection-Schedules) to search for and retrieve your object ID using browser dev tools or a capture tool like Fiddler"
+}
+
+PARAM_DESCRIPTIONS = {  # Optional dict to describe the arguments, will be shown in the GUI configuration below the respective input field
+    "en": {
+        "objectId": "A valid object ID from the Plano GIS service. You can find this by searching for your address on the Plano GIS map and clicking on the address to get the object ID.",
+    }
+}
+
+PARAM_TRANSLATIONS = {  # Optional dict to translate the arguments, will be shown in the GUI configuration form as placeholder text
+    "en": {
+        "objectId": "Object ID",
+        "daysToGenerate": "Number of days to generate for default collection (default: 3)",
+    },
+    "de": {
+        "objectId": "Objekt-ID",
+        "daysToGenerate": "Anzahl der Tage, die für die Standardkollektion generiert werden sollen (Standard: 3)",
+    },
+    "it": {
+        "objectId": "ID oggetto",
+        "daysToGenerate": "Numero di giorni da generare per la collezione predefinita (predefinito: 3)",
+    },
+    "fr": {
+        "objectId": "ID d'objet",
+        "daysToGenerate": "Nombre de jours à générer pour la collection par défaut (par défaut : 3)",
+    },
+}
+
+# ### End of arguments affecting the configuration GUI ####
+
+
+class Source:
+    def __init__(
+        self, objectId: str, daysToGenerate: int = 3
+    ):  # argX correspond to the args dict in the source configuration
+        self.object_id = objectId
+        self.trash_days_to_generate = (
+            # the int check here could cause issues if the passed value isn't coercible to an int, but the UI presently does insist this be a number
+            daysToGenerate
+            if daysToGenerate is not None and int(daysToGenerate) > 0
+            else 3
+        )  # Default to 3 days if not provided
+
+    def is_us_federal_holiday(self, check_date: date) -> bool:
+        year = check_date.year
+
+        # Fixed-date holidays
+        fixed_holidays = {
+            date(year, 1, 1),  # New Year's Day
+            date(year, 6, 19),  # Juneteenth National Independence Day
+            date(year, 7, 4),  # Independence Day
+            date(year, 11, 11),  # Veterans Day
+            date(year, 12, 25),  # Christmas Day
+        }
+
+        # Helper to find nth weekday in a month
+        def nth_weekday(month, weekday, n):
+            first_day = date(year, month, 1)
+            days_to_add = (weekday - first_day.weekday() + 7) % 7 + (n - 1) * 7
+            return first_day + timedelta(days=days_to_add)
+
+        # Helper to find last weekday in a month
+        def last_weekday(month, weekday):
+            last_day = (
+                date(year, month + 1, 1) - timedelta(days=1)
+                if month < 12
+                else date(year, 12, 31)
+            )
+            days_back = (last_day.weekday() - weekday + 7) % 7
+            return last_day - timedelta(days=days_back)
+
+        # Variable-date holidays
+        variable_holidays = {
+            nth_weekday(1, 0, 3),  # Martin Luther King Jr. Day: 3rd Monday in January
+            nth_weekday(2, 0, 3),  # Presidents' Day: 3rd Monday in February
+            last_weekday(5, 0),  # Memorial Day: last Monday in May
+            nth_weekday(9, 0, 1),  # Labor Day: 1st Monday in September
+            nth_weekday(10, 0, 2),  # Columbus Day: 2nd Monday in October
+            nth_weekday(11, 3, 4),  # Thanksgiving Day: 4th Thursday in November
+        }
+
+        return check_date in fixed_holidays or check_date in variable_holidays
+
+    def next_weekday(self, d: datetime.date, weekday: int):
+        days_ahead = weekday - d.weekday()
+        if days_ahead < 0:  # Target day already happened this week
+            days_ahead += 7
+        return d + datetime.timedelta(days_ahead)
+
+    def fetch(self) -> list[Collection]:
+        logger = logging.getLogger("plano_gov")
+        params: dict[str, str | int | bool] = {
+            "f": "json",
+            "objectIds": self.object_id,
+            "outFields": "ADDRESS,BLKY_COLOR,BLKY_CURR,BLKY_NEXT1,BLKY_NEXT2,BULKY_DAY,DAY_2017,HouseNo,REC_CURR,REC_NEXT1,REC_NEXT2,REC_WEEK_2017,SERVICE,OBJECTID",
+            "outSR": 102100,
+            "returnGeometry": False,
+            "spatialRel": "esriSpatialRelIntersects",
+            "where": "1=1",
+        }
+
+        resp = requests.get(API_URL, params=params)
+
+        if resp.status_code != 200:
+            raise Exception(
+                f"Something went wrong in ArcGIS land: {resp.text}"
+            )  # DO NOT JUST return []
+
+        parsed_resp = resp.json()
+        if "features" not in parsed_resp or len(parsed_resp["features"]) == 0:
+            raise Exception(
+                f"No data found for object ID {self.object_id}. Please check your object ID."
+            )
+
+        bulky_dates_str = [
+            parsed_resp["features"][0]["attributes"]["BLKY_CURR"],
+            parsed_resp["features"][0]["attributes"]["BLKY_NEXT1"],
+            parsed_resp["features"][0]["attributes"]["BLKY_NEXT2"],
+        ]
+
+        recycle_dates_str = [
+            parsed_resp["features"][0]["attributes"]["REC_CURR"],
+            parsed_resp["features"][0]["attributes"]["REC_NEXT1"],
+            parsed_resp["features"][0]["attributes"]["REC_NEXT2"],
+        ]
+
+        trash_day = parsed_resp["features"][0]["attributes"]["DAY_2017"]
+
+        today = datetime.date.today()
+        curr_year = today.year
+
+        entries = []  # List that holds collection schedule
+
+        # standard trash
+
+        # For standard trash we only get the day of the week, so we need to convert it to a date
+
+        trash_day_num = WEEKDAYMAP.get(trash_day)
+
+        if trash_day_num is None:
+            raise Exception(f"Invalid trash day: {trash_day}")
+
+        next_trash_days = []
+
+        for i in range(int(self.trash_days_to_generate)):
+            # Calculate the next trash day based on the current date and the trash day number
+            next_trash_day = self.next_weekday(
+                today + datetime.timedelta(weeks=i), trash_day_num
+            )
+
+            # If the next trash day is a holiday, bump it to the next day
+            if self.is_us_federal_holiday(next_trash_day):
+                logger.warning(
+                    f"Next trash day {next_trash_day} is a holiday, bumping to next day"
+                )
+                next_trash_day += datetime.timedelta(days=1)
+
+            next_trash_days.append(next_trash_day)
+
+        ttype = "TRASH"
+
+        for next_trash_day in next_trash_days:
+            entries.append(
+                Collection(
+                    date=next_trash_day,  # Collection date
+                    t=ttype,  # Collection type
+                    icon=ICON_MAP.get(ttype),  # Collection icon
+                )
+            )
+        # bulky trash
+        # bulky trash comes back as a month / day, so we need to tack on the year and get a date
+
+        bulky_dates_str = [
+            bulky + " " + str(curr_year) for bulky in bulky_dates_str
+        ]  # e.g. "January 1 2023"
+        bulky_dates = [
+            datetime.datetime.strptime(bulky, "%B %d %Y").date()
+            for bulky in bulky_dates_str
+        ]
+
+        ttype = "BULKY"
+        for bulky_date in bulky_dates:
+            entries.append(
+                Collection(
+                    date=bulky_date,  # Collection date
+                    t=ttype,  # Collection type
+                    icon=ICON_MAP.get(ttype),  # Collection icon
+                )
+            )
+
+        # recycling
+        ttype = "RECYCLE"
+        # recycling is returned with a similar curr, next1, next2 format like bulky
+        # however, it actually returns 2-3 dates in the curr depending on how many recycling occurrences there will be
+        # because recycling is every other week.
+        recycle_dates = []
+
+        for recycle in recycle_dates_str:
+            recycle_parts = recycle.split(",")
+            recycle_date = datetime.datetime.strptime(
+                recycle_parts[0] + " " + str(curr_year), "%B %d %Y"
+            ).date()
+            recycle_dates.append(recycle_date)
+            if len(recycle_parts) > 1:
+                recycle_dates.append(
+                    datetime.datetime.strptime(
+                        str(recycle_date.month)
+                        + " "
+                        + recycle_parts[1]
+                        + " "
+                        + str(curr_year),
+                        "%m %d %Y",
+                    ).date()
+                )
+            if len(recycle_parts) > 2:
+                recycle_dates.append(
+                    datetime.datetime.strptime(
+                        str(recycle_date.month)
+                        + " "
+                        + recycle_parts[2]
+                        + " "
+                        + str(curr_year),
+                        "%m %d %Y",
+                    ).date()
+                )
+
+        for recycle_date in recycle_dates:
+            entries.append(
+                Collection(
+                    date=recycle_date,  # Collection date
+                    t=ttype,  # Collection type
+                    icon=ICON_MAP.get(ttype),  # Collection icon
+                )
+            )
+        return entries

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

@@ -0,0 +1,130 @@
+from datetime import datetime, timedelta
+
+import requests
+from waste_collection_schedule import Collection, Icons
+from waste_collection_schedule.service.AchieveForms import init_session, run_lookup
+
+TITLE = "Plymouth City Council"
+DESCRIPTION = "Source for waste collection services for Plymouth City Council"
+URL = "https://www.plymouth.gov.uk/"
+
+TEST_CASES = {
+    "Test_001": {"uprn": 100040429524},
+    "Test_002": {"uprn": "100040425325"},
+    "Test_003": {"uprn": 100040472543},
+    "Test_004": {"uprn": "100040462838"},
+    "Test_005": {"uprn": 100040461084},
+}
+
+HOSTNAME = "plymouth-self.achieveservice.com"
+BASE_URL = f"https://{HOSTNAME}"
+INITIAL_URL = f"{BASE_URL}/en/AchieveForms/?form_uri=sandbox-publish://AF-Process-084d6742-3572-41ba-ac1a-430750451f9d/AF-Stage-67ba684d-0a5b-48f8-9c50-1c01cc43c396/definition.json&redirectlink=%2Fen&cancelRedirectLink=%2Fen&consentMessage=yes"
+AUTH_URL = f"{BASE_URL}/authapi/isauthenticated"
+AUTH_TEST = f"{BASE_URL}/apibroker/domain/{HOSTNAME}"
+API_URL = f"{BASE_URL}/apibroker/runLookup"
+
+# Plymouth rebuilt their "Check your collection days" form on 2026-07-31 to add
+# food waste. The old single "5c99439d85f83" lookup (UPRN + next-N-collections)
+# no longer returns data. It has been replaced by a two-step lookup chain:
+#   1. "collectiveAuthenticator" - no inputs, returns a short-lived opaque
+#      "collectiveKey" token required by every other lookup in the new form.
+#   2. "collectionDays" - takes the UPRN, the collectiveKey, and an explicit
+#      start/end date window, and returns the actual collection rows.
+AUTHENTICATOR_LOOKUP_ID = "6936e38f6d376"
+COLLECTION_DAYS_LOOKUP_ID = "698b9c49a3c13"
+
+# How far ahead to request collections for. The live form itself only asks for
+# a 15-day window (today .. today+15), we ask for a wider one to surface more
+# upcoming collections in one fetch.
+LOOKAHEAD_DAYS = 60
+
+# collectiveWasteType values look like "Empty Food 23L" / "Empty Residual 240L"
+# / "Empty Recycling 1100L" / "Empty Garden 240L" - the bin size suffix varies
+# per property, so match on the waste-type keyword rather than the full string.
+ICON_MAP = {
+    "residual": Icons.GENERAL_WASTE,
+    "recycling": Icons.RECYCLING,
+    "garden": Icons.GARDEN,
+    "food": Icons.BIO_KITCHEN,
+}
+
+COLLECTION_TYPE = {
+    "residual": "Residual Waste",
+    "recycling": "Recycling",
+    "garden": "Garden Waste",
+    "food": "Food Waste",
+}
+
+
+class Source:
+    def __init__(self, uprn: str | int):
+        self._uprn = str(uprn).strip()
+
+    def _get_collective_key(self, session_key: str, session: requests.Session) -> str:
+        result = run_lookup(
+            session,
+            API_URL,
+            session_key,
+            AUTHENTICATOR_LOOKUP_ID,
+            {"Section 1": {}},
+        )
+        rows_data = result["integration"]["transformed"]["rows_data"]
+        first_row = next(iter(rows_data.values())) if rows_data else {}
+        return first_row["collectiveKey"]
+
+    def get_collections(
+        self, session_key: str, session: requests.Session
+    ) -> list[Collection]:
+        collective_key = self._get_collective_key(session_key, session)
+
+        start = datetime.now()
+        end = start + timedelta(days=LOOKAHEAD_DAYS)
+        result = run_lookup(
+            session,
+            API_URL,
+            session_key,
+            COLLECTION_DAYS_LOOKUP_ID,
+            {
+                "Section 1": {
+                    "collectiveUPRN": {"value": self._uprn},
+                    "collectiveKey": {"value": collective_key},
+                    "collectiveGetJobStartDate": {
+                        "value": start.strftime("%Y-%m-%dT00:00:00")
+                    },
+                    "collectiveGetJobEndDate": {
+                        "value": end.strftime("%Y-%m-%dT00:00:00")
+                    },
+                }
+            },
+        )
+        rows_data = result["integration"]["transformed"]["rows_data"]
+        return (
+            list(rows_data.values()) if isinstance(rows_data, dict) else list(rows_data)
+        )
+
+    def fetch(self) -> list[Collection]:
+        session = requests.Session()
+        session_key = init_session(
+            session,
+            INITIAL_URL,
+            AUTH_URL,
+            HOSTNAME,
+            auth_test_url=AUTH_TEST,
+        )
+        collections = self.get_collections(session_key, session)
+
+        entries = []
+        for collection in collections:
+            date_string = collection["collectiveCollectionDate"]
+            date = datetime.strptime(date_string, "%d/%m/%Y").date()
+            waste_type = collection["collectiveWasteType"].lower()
+            service = next((key for key in COLLECTION_TYPE if key in waste_type), None)
+            icon = ICON_MAP.get(service)
+            collection_type = (
+                COLLECTION_TYPE[service]
+                if service is not None
+                else collection["collectiveWasteType"]
+            )
+            entries.append(Collection(date=date, t=collection_type, icon=icon))
+
+        return entries

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

@@ -0,0 +1,80 @@
+import re
+from typing import Literal
+
+import requests
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import SourceArgumentNotFoundWithSuggestions
+from waste_collection_schedule.service.ICS import ICS
+
+TITLE = "Pointe-Claire (QC)"
+DESCRIPTION = "Source for Pointe-Claire, Québec waste collection schedules."
+URL = "https://www.pointe-claire.ca"
+TEST_CASES = {
+    "Sector A": {"sector": "A"},
+    "Sector B": {"sector": "B"},
+}
+
+ICON_MAP = {
+    "Organic Waste": Icons.ORGANIC,
+    "Recyclables": Icons.RECYCLING,
+    "Household Waste": Icons.GENERAL_WASTE,
+    "Bulky Items": Icons.BULKY,
+    "Christmas Tree Collection": Icons.CHRISTMAS_TREE,
+}
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": "Find your collection sector on the City of Pointe-Claire website at https://www.pointe-claire.ca/en/residents/public-works/waste-management/",
+    "fr": "Trouvez votre secteur de collecte sur le site de la Ville de Pointe-Claire à https://www.pointe-claire.ca/residents/travaux-publics/gestion-des-dechets/",
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "sector": "Collection sector (A or B)",
+    },
+    "fr": {
+        "sector": "Secteur de collecte (A ou B)",
+    },
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "sector": "Sector",
+    },
+    "fr": {
+        "sector": "Secteur",
+    },
+}
+
+SECTOR_URL_MAP: dict[str, str] = {
+    "A": "https://raw.githubusercontent.com/jordanconway/pointe-claire-waste-calendars/refs/heads/main/pointe-claire-a.ics",
+    "B": "https://raw.githubusercontent.com/jordanconway/pointe-claire-waste-calendars/refs/heads/main/pointe-claire-b.ics",
+}
+
+SECTOR_LITERAL = Literal["A", "B"]
+
+
+class Source:
+    def __init__(self, sector: SECTOR_LITERAL):
+        self._sector = str(sector).upper().strip()
+        self._ics = ICS()
+
+    def fetch(self) -> list[Collection]:
+        url = SECTOR_URL_MAP.get(self._sector)
+        if url is None:
+            raise SourceArgumentNotFoundWithSuggestions(
+                "sector", self._sector, list(SECTOR_URL_MAP.keys())
+            )
+
+        r = requests.get(url, timeout=30)
+        r.raise_for_status()
+
+        dates = self._ics.convert(r.text)
+        entries = []
+        for d in dates:
+            # Strip " (Sector A)" / " (Sector B)" suffix — the sector is already
+            # captured by the source configuration, so it's redundant in the type.
+            collection_type = re.sub(r"\s*\(Sector [AB]\)$", "", d[1]).strip()
+            entries.append(
+                Collection(d[0], collection_type, ICON_MAP.get(collection_type))
+            )
+        return entries

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

@@ -0,0 +1,174 @@
+import html as html_lib
+import re
+from datetime import date
+
+import requests
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import SourceArgumentNotFoundWithSuggestions
+
+TITLE = "Popůvky"
+DESCRIPTION = (
+    "Source for the municipal waste collection calendar of Popůvky, Czech Republic."
+)
+URL = "https://www.popuvky.cz/obec/terminy-svozu/"
+COUNTRY = "cz"
+
+TEST_CASES = {
+    "Popůvky (Brno-venkov)": {"place": "Popůvky (Brno-venkov)"},
+    "Popůvky - chatová oblast": {"place": "Popůvky - chatová oblast"},
+}
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": (
+        "Open the collection calendar page and note which collection route matches "
+        "your address: 'Popůvky (Brno-venkov)' for the village itself, or "
+        "'Popůvky - chatová oblast' for the cottage/recreational area."
+    ),
+    "de": (
+        "Öffnen Sie die Abfuhrkalender-Seite und notieren Sie, welche Route zu Ihrer "
+        "Adresse passt: 'Popůvky (Brno-venkov)' für den Ort selbst oder "
+        "'Popůvky - chatová oblast' für das Hüttengebiet."
+    ),
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "place": "Collection route/area exactly as listed on the official calendar page",
+    },
+    "de": {
+        "place": "Abfuhrgebiet/-route, genau wie auf der offiziellen Kalenderseite aufgeführt",
+    },
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "place": "Collection area",
+    },
+    "de": {
+        "place": "Abfuhrgebiet",
+    },
+}
+
+ICON_MAP = {
+    "Komunální odpad": Icons.GENERAL_WASTE,
+    "Plasty od domu": Icons.PLASTIC_PACKAGING,
+    "Papír": Icons.PAPER,
+    "Sklo": Icons.GLASS,
+    "BIO odpad od domu": Icons.ORGANIC,
+}
+
+PAGE_URL = "https://www.popuvky.cz/obec/terminy-svozu/"
+API_URL = "https://www.popuvky.cz/modules/communal_services/ax_calendar.php"
+HEADERS = {"User-Agent": "Mozilla/5.0"}
+
+# Number of months (starting with the current one) to fetch. Covers a full
+# rolling year, similar to other calendar-widget-based sources.
+MONTHS_TO_FETCH = 13
+
+PLACE_SELECT_RE = re.compile(
+    r'<select name="communal_place"[^>]*>(.*?)</select>', re.DOTALL
+)
+OPTION_RE = re.compile(r"<option[^>]*value=['\"](\d+)['\"][^>]*>([^<]*)</option>")
+ACTIVE_RE = re.compile(r"active:\s*(\d+)")
+TOOLTIP_RE = re.compile(
+    r'<div class="sr-only" id="com-tooltip(\d{4})(\d{2})(\d{2})">\s*<dl>(.*?)</dl>',
+    re.DOTALL,
+)
+DT_RE = re.compile(r"<dt>(.*?)</dt>", re.DOTALL)
+TAG_RE = re.compile(r"<[^>]+>")
+
+
+class Source:
+    def __init__(self, place: str):
+        self._place = place.strip()
+
+    def fetch(self) -> list[Collection]:
+        session = requests.Session()
+
+        r = session.get(PAGE_URL, headers=HEADERS, timeout=30)
+        r.raise_for_status()
+        page_html = r.text
+
+        places = _parse_places(page_html)
+        if not places:
+            raise ValueError(
+                "Could not find any collection routes on the Popůvky waste calendar "
+                "page. The website layout may have changed."
+            )
+
+        place_id = None
+        for name, pid in places.items():
+            if name.casefold() == self._place.casefold():
+                place_id = pid
+                break
+        if place_id is None:
+            raise SourceArgumentNotFoundWithSuggestions(
+                "place", self._place, list(places.keys())
+            )
+
+        active_match = ACTIVE_RE.search(page_html)
+        if not active_match:
+            raise ValueError(
+                "Could not determine the waste-calendar widget id from the Popůvky "
+                "website. The website layout may have changed."
+            )
+        active_id = active_match.group(1)
+
+        entries: list[Collection] = []
+        today = date.today()
+        year, month = today.year, today.month
+        for _ in range(MONTHS_TO_FETCH):
+            params = {
+                "communal_month": month,
+                "communal_year": year,
+                "active": active_id,
+                "communal_place": place_id,
+                "communal_waste": 0,
+            }
+            resp = session.get(API_URL, params=params, headers=HEADERS, timeout=30)
+            resp.raise_for_status()
+            entries.extend(_parse_month(resp.text, year, month))
+
+            month += 1
+            if month > 12:
+                month = 1
+                year += 1
+
+        return entries
+
+
+def _parse_places(page_html: str) -> dict[str, str]:
+    select_match = PLACE_SELECT_RE.search(page_html)
+    if not select_match:
+        return {}
+    places: dict[str, str] = {}
+    for pid, name in OPTION_RE.findall(select_match.group(1)):
+        name = name.strip()
+        if name:
+            places[name] = pid
+    return places
+
+
+def _parse_month(month_html: str, year: int, month: int) -> list[Collection]:
+    entries: list[Collection] = []
+    for year_s, month_s, day_s, dl_content in TOOLTIP_RE.findall(month_html):
+        # The rendered grid also contains a few overflow days from the
+        # previous/next month to fill out the week rows. Skip those here;
+        # they are (and will be) picked up when that month is fetched.
+        if int(year_s) != year or int(month_s) != month:
+            continue
+        collection_date = date(int(year_s), int(month_s), int(day_s))
+        for dt in DT_RE.findall(dl_content):
+            waste_type = TAG_RE.sub("", dt)
+            waste_type = html_lib.unescape(waste_type)
+            waste_type = re.sub(r"\s+", " ", waste_type).strip()
+            if not waste_type:
+                continue
+            entries.append(
+                Collection(
+                    collection_date,
+                    waste_type,
+                    icon=ICON_MAP.get(waste_type),
+                )
+            )
+    return entries