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

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

@@ -0,0 +1,217 @@
+import json
+import re
+from datetime import datetime
+
+import requests
+from bs4 import BeautifulSoup
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+
+TITLE = "Croydon Council"
+DESCRIPTION = "Source for croydon.gov.uk services for Croydon Council, UK."
+URL = "https://croydon.gov.uk"
+TEST_CASES = {
+    "Test_001": {"postcode": "CR0 6LN", "houseID": "64 Coniston Road"},
+    "Test_002": {"postcode": "SE25 5BU", "houseID": "23B Howard Road"},
+    "Test_003": {"postcode": "CR0 6EG", "houseID": "48 Exeter Road"},
+    "Test_004": {"postcode": "CR5 2BG", "houseID": "18 South Drive"},
+}
+ICON_MAP = {
+    "Food waste": Icons.BIO_KITCHEN,
+    "General rubbish": Icons.GENERAL_WASTE,
+    "Paper and card recycling": Icons.PAPER,
+    "Glass, plastics, cans and cartons recycling": Icons.PLASTIC_PACKAGING,
+}
+API_URLS = {
+    "BASE": "https://service.croydon.gov.uk",
+    "CSRF": "/wasteservices/w/webpage/bin-day-enter-address",
+    "SEARCH": "/wasteservices/w/webpage/bin-day-enter-address?webpage_subpage_id=PAG0000898EECEC1&webpage_token=faab02e1f62a58f7bad4c2ae5b8622e19846b97dde2a76f546c4bb1230cee044&widget_action=fragment_action",
+    "SCHEDULE": "/wasteservices/w/webpage/bin-day-enter-address?webpage_subpage_id=PAG0000898EECEC1&webpage_token=faab02e1f62a58f7bad4c2ae5b8622e19846b97dde2a76f546c4bb1230cee044",
+}
+HEADER_COMPONENTS = {
+    "BASE": {
+        "Accept-Encoding": "gzip, deflate, br",
+        "Accept-Language": "en-GB,en-US;q=0.9,en;q=0.8",
+        "Cache-Control": "max-age=0",
+        "Connection": "keep-alive",
+        "Host": "service.croydon.gov.uk",
+        "Origin": API_URLS["BASE"],
+        "sec-ch-ua": '"Not_A Brand";v="99", "Google Chrome";v="109", "Chromium";v="109"',
+        "sec-ch-ua-mobile": "?0",
+        "sec-ch-ua-platform": "Windows",
+        "Sec-Fetch-Dest": "document",
+        "Sec-Fetch-User": "?1",
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/109.0.0.0 Safari/537.36",
+    },
+    "GET": {
+        "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.9",
+        "Sec-Fetch-Mode": "none",
+    },
+    "POST": {
+        "Accept": "application/json, text/javascript, */*; q=0.01",
+        "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8",
+        "Sec-Fetch-Mode": "same-origin",
+        "X-Requested-With": "XMLHttpRequest",
+    },
+}
+SESSION_STORAGE = {
+    "destination_stack": [
+        "w/webpage/bin-day-enter-address",
+        "w/webpage/your-bin-collection-details?context_record_id=86086077"
+        "&webpage_token=5c047b2c10b4aad66bef2054aac6bea52ad7a5e185ffdf7090b01f8ddc96728f",
+        "w/webpage/bin-day-enter-address",
+        "w/webpage/your-bin-collection-details?context_record_id=86085229"
+        "&webpage_token=cf1b8fd6213f4823277d98c1dd8a992e6ebef1fabc7d892714e5d9dade448c37",
+        "w/webpage/bin-day-enter-address",
+        "w/webpage/your-bin-collection-details?context_record_id=86084221"
+        "&webpage_token=7f52fb51019bf0e6bfe9647b1b31000124bd92a9d95781f1557f58b3ed40da52",
+        "w/webpage/bin-day-enter-address",
+        "w/webpage/your-bin-collection-details?context_record_id=86083209"
+        "&webpage_token=de50c265da927336f526d9d9a44947595c3aa38965aa8c495ac2fb73d272ece8",
+        "w/webpage/bin-day-enter-address",
+    ],
+    "last_context_record_id": "86086077",
+}
+
+
+class Source:
+    def __init__(self, postcode, houseID):
+        self._postcode = str(postcode).upper()
+        self._houseID = str(houseID)
+
+    def fetch(self):
+        s = requests.Session()
+
+        # Get token
+        csrf_token = ""
+        url = API_URLS["BASE"] + API_URLS["CSRF"]
+        headers = {**HEADER_COMPONENTS["BASE"], **HEADER_COMPONENTS["GET"]}
+        r0 = s.get(url, headers=headers)
+
+        soup = BeautifulSoup(r0.text, features="html.parser")
+        app_body = soup.find("div", {"class": "app-body"})
+        script = app_body.find("script", {"type": "text/javascript"}).string
+        p = re.compile("var CSRF = ('|\")(.*?)('|\");")
+        m = p.search(script)
+        csrf_token = m.groups()[1]
+
+        # Get additional tokens
+        form_data = {
+            "_dummy": "1",
+            "_session_storage": '{"_global":{}}',
+            "_update_page_content_request": "1",
+            "form_check_ajax": csrf_token,
+        }
+        headers = {
+            **HEADER_COMPONENTS["BASE"],
+            **HEADER_COMPONENTS["POST"],
+        }
+
+        r1 = s.post(
+            "https://service.croydon.gov.uk/wasteservices/w/webpage/bin-day-enter-address",
+            headers=headers,
+            data=form_data,
+        )
+        r1.raise_for_status()
+
+        page_data = r1.json()["data"]
+        key = (
+            re.findall(r"data-unique_key=\"C_[a-f0-9]+\"", page_data)[-1]
+            .replace('data-unique_key="', "")
+            .replace('"', "")
+        )
+        soup = BeautifulSoup(page_data, features="html.parser")
+        submitted_widget_group_id = soup.findAll(
+            "input", {"name": "submitted_widget_group_id"}
+        )[-1].attrs["value"]
+        submission_token = soup.find("input", {"name": "submission_token"}).attrs[
+            "value"
+        ]
+        submitted_page_id = soup.find("input", {"name": "submitted_page_id"}).attrs[
+            "value"
+        ]
+
+        # Use postcode and houseID to find address
+        addressID = "0"
+        url = API_URLS["BASE"] + API_URLS["SEARCH"]
+        headers = {
+            **HEADER_COMPONENTS["BASE"],
+            **HEADER_COMPONENTS["POST"],
+        }
+        form_data = {
+            "code_action": "search",
+            "code_params": '{"search_item":"' + self._postcode + '","is_ss":true}',
+            "fragment_action": "handle_event",
+            "fragment_id": "PCF0020408EECEC1",
+            "fragment_collection_class": "formtable",
+            "fragment_collection_editable_values": '{"PCF0021449EECEC1":"1"}',
+            "_session_storage": json.dumps(
+                {
+                    "/wasteservices/w/webpage/bin-day-enter-address": {},
+                    "_global": SESSION_STORAGE,
+                }
+            ),
+            "action_cell_id": "PCL0005629EECEC1",
+            "action_page_id": "PAG0000898EECEC1",
+            "form_check_ajax": csrf_token,
+        }
+        r2 = s.post(url, headers=headers, data=form_data)
+
+        addresses = json.loads(r2.text)["response"]["items"]
+        for address in addresses:
+            if self._houseID in str(address["address_single_line"]):
+                addressID = str(address["id"])
+
+        # Use addressID to get schedule
+        collection_data = ""
+        url = API_URLS["BASE"] + API_URLS["SCHEDULE"]
+        headers = {**HEADER_COMPONENTS["BASE"], **HEADER_COMPONENTS["POST"]}
+        form_data = {
+            "form_check": csrf_token,
+            "submitted_page_id": submitted_page_id,
+            "submitted_widget_group_id": submitted_widget_group_id,
+            "submitted_widget_group_type": "modify",
+            "submission_token": submission_token,
+            f"payload[PAG0000898EECEC1][PWG0002644EECEC1][PCL0005629EECEC1][formtable][{key}][PCF0020408EECEC1]": addressID,
+            f"payload[PAG0000898EECEC1][PWG0002644EECEC1][PCL0005629EECEC1][formtable][{key}][PCF0021449EECEC1]": "1",
+            f"payload[PAG0000898EECEC1][PWG0002644EECEC1][PCL0005629EECEC1][formtable][{key}][PCF0020072EECEC1]": "Next",
+            "submit_fragment_id": "PCF0020072EECEC1",
+            "_session_storage": json.dumps({"_global": SESSION_STORAGE}),
+            "_update_page_content_request": 1,
+            "form_check_ajax": csrf_token,
+        }
+        r3 = s.post(url, headers=headers, data=form_data)
+        json_response = json.loads(r3.text)
+        url = API_URLS["BASE"] + json_response["redirect_url"]
+        headers = {**HEADER_COMPONENTS["BASE"], **HEADER_COMPONENTS["POST"]}
+        form_data = {
+            "_dummy": 1,
+            "_session_storage": json.dumps({"_global": SESSION_STORAGE}),
+            "_update_page_content_request": 1,
+            "form_check_ajax": csrf_token,
+        }
+        r4 = s.post(url, headers=headers, data=form_data)
+
+        json_response = json.loads(r4.text)
+        collection_data = json_response["data"]
+        soup = BeautifulSoup(collection_data, features="html.parser")
+        schedule = soup.find_all("div", {"class": "listing_template_record"})
+
+        entries = []
+        for pickup in schedule:
+            # Get the waste type
+            waste_type = pickup.find_all(
+                "div", {"class": "fragment_presenter_template_show"}
+            )[0].text.strip()
+            waste_date = pickup.find("span", {"class": "value-as-text"}).get_text(
+                strip=True
+            )
+
+            entries.append(
+                Collection(
+                    date=datetime.strptime(waste_date, "%A %d %B %Y").date(),
+                    t=waste_type,
+                    icon=ICON_MAP.get(waste_type),
+                )
+            )
+
+        return entries

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

@@ -0,0 +1,72 @@
+from datetime import datetime
+
+import requests
+from bs4 import BeautifulSoup
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+
+TITLE = "Cumberland Council"
+DESCRIPTION = "Source for cumberland.gov.uk services for Cumberland Council, UK."
+URL = "https://cumberland.gov.uk"
+TEST_CASES = {
+    "Test_001": {"postcode": "CA28 7QS", "uprn": "100110319463"},
+    "Test_002": {"postcode": "CA28 8LG", "uprn": 100110320734},
+    "Test_003": {"postcode": "CA28 6SW", "uprn": "10000895390"},
+    "Test_004": {"uprn": 10000895390},
+}
+ICON_MAP = {
+    "Recycling": Icons.RECYCLING,
+    "Refuse": Icons.GENERAL_WASTE,
+    "Paper": Icons.PAPER,
+}
+HEADERS = {"user-agent": "Mozilla/5.0"}
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": "An easy way to discover your Unique Property Reference Number (UPRN) is by going to https://www.findmyaddress.co.uk/ and entering in your address details.",
+}
+PARAM_TRANSLATIONS = {
+    "en": {
+        "postcode": "Postcode of your property",
+        "uprn": "Unique Property Reference Number (UPRN)",
+    }
+}
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "postcode": "Postcode of your property",
+        "uprn": "An easy way to discover your Unique Property Reference Number (UPRN) is by going to https://www.findmyaddress.co.uk/ and entering in your address details.",
+    }
+}
+
+
+class Source:
+    def __init__(
+        self,
+        uprn: str | int,
+        postcode: str | None = None,
+    ):
+        # postcode is no longer needed, provide default value to make it optional for newer configs
+        self._uprn: str = str(uprn)
+
+    def fetch(self) -> list[Collection]:
+        s = requests.Session()
+        r = s.get(
+            f"https://www.cumberland.gov.uk/bins-recycling-and-street-cleaning/waste-collections/bin-collection-schedule/view/{self._uprn}",
+            headers=HEADERS,
+        )
+        r.raise_for_status()
+        soup = BeautifulSoup(r.content, "lxml")
+
+        entries = []
+        for item in soup.select("li.waste-collection__day"):
+            waste_date = item.select_one("time")["datetime"]
+            waste_type = item.select_one(".waste-collection__day--colour").get_text(
+                strip=True
+            )
+            entries.append(
+                Collection(
+                    date=datetime.strptime(waste_date, "%Y-%m-%d").date(),
+                    t=waste_type,
+                    icon=ICON_MAP.get(waste_type),
+                )
+            )
+
+        return entries

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

@@ -0,0 +1,150 @@
+import json
+from datetime import date, timedelta
+
+import requests
+from waste_collection_schedule import Collection  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import (
+    SourceArgumentNotFoundWithSuggestions,
+)
+from waste_collection_schedule.service.WasteInfo import (
+    property_matches,
+    same,
+    street_number_suggestions,
+)
+
+TITLE = "Cumberland Council (NSW)"
+DESCRIPTION = "Source for Cumberland Council (NSW) rubbish collection."
+URL = "https://www.cumberland.nsw.gov.au"
+TEST_CASES = {
+    "Berala Community Centre": {
+        "suburb": "Berala",
+        "street_name": "Woodburn Road",
+        "street_number": "98 to 104",
+    },
+    "McDonald's Auburn": {
+        "suburb": "Auburn",
+        "street_name": "Parramatta Road",
+        "street_number": "116",
+    },
+    "Chickenlicious Guildford": {
+        "suburb": "Guildford",
+        "street_name": "Woodville Road",
+        "street_number": 283,
+    },
+}
+
+HEADERS = {"user-agent": "Mozilla/5.0"}
+
+
+class Source:
+    def __init__(self, suburb, street_name, street_number):
+        self.suburb = suburb
+        self.street_name = street_name
+        self.street_number = street_number
+
+    def fetch(self):
+
+        suburb_id = 0
+        street_id = 0
+        property_id = 0
+        today = date.today()
+        nextmonth = today + timedelta(days=365)
+
+        # Retrieve suburbs
+        r = requests.get(
+            "https://cumberland.waste-info.com.au/api/v1/localities.json",
+            headers=HEADERS,
+        )
+        data = json.loads(r.text)
+
+        # Find the ID for our suburb
+        for item in data["localities"]:
+            if same(item["name"], self.suburb):
+                suburb_id = item["id"]
+                break
+
+        if suburb_id == 0:
+            raise SourceArgumentNotFoundWithSuggestions(
+                "suburb", self.suburb, [x["name"] for x in data["localities"]]
+            )
+
+        # Retrieve the streets in our suburb
+        r = requests.get(
+            f"https://cumberland.waste-info.com.au/api/v1/streets.json?locality={suburb_id}",
+            headers=HEADERS,
+        )
+        data = json.loads(r.text)
+
+        # Find the ID for our street
+        for item in data["streets"]:
+            if same(item["name"], self.street_name):
+                street_id = item["id"]
+                break
+
+        if street_id == 0:
+            raise SourceArgumentNotFoundWithSuggestions(
+                "street_name", self.street_name, [x["name"] for x in data["streets"]]
+            )
+
+        # Retrieve the properties in our street
+        r = requests.get(
+            f"https://cumberland.waste-info.com.au/api/v1/properties.json?street={street_id}",
+            headers=HEADERS,
+        )
+        data = json.loads(r.text)
+
+        # Find the ID for our property
+        for item in data["properties"]:
+            if property_matches(
+                item["name"], self.street_number, self.street_name, self.suburb
+            ):
+                property_id = item["id"]
+                break
+
+        if property_id == 0:
+            raise SourceArgumentNotFoundWithSuggestions(
+                "street_number",
+                self.street_number,
+                street_number_suggestions(
+                    (x["name"] for x in data["properties"]), self.street_name
+                ),
+            )
+
+        # Retrieve the upcoming collections for our property
+        r = requests.get(
+            f"https://cumberland.waste-info.com.au/api/v1/properties/{property_id}.json?start={today}&end={nextmonth}",
+            headers=HEADERS,
+        )
+
+        data = json.loads(r.text)
+
+        entries = []
+
+        for item in data:
+            if "start" in item:
+                collection_date = date.fromisoformat(item["start"])
+                if (collection_date - today).days >= 0:
+                    # Only consider recycle and organic events
+                    if item["event_type"] in ["recycle", "organic"]:
+                        # Every collection day includes rubbish
+                        entries.append(
+                            Collection(
+                                date=collection_date, t="Rubbish", icon="mdi:trash-can"
+                            )
+                        )
+                        if item["event_type"] == "recycle":
+                            entries.append(
+                                Collection(
+                                    date=collection_date,
+                                    t="Recycling",
+                                    icon="mdi:recycle",
+                                )
+                            )
+                        if item["event_type"] == "organic":
+                            entries.append(
+                                Collection(
+                                    date=collection_date, t="Garden", icon="mdi:leaf"
+                                )
+                            )
+
+        return entries

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

@@ -0,0 +1,239 @@
+import json
+import re
+from datetime import datetime
+
+from curl_cffi import requests
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import (
+    SourceArgAmbiguousWithSuggestions,
+    SourceArgumentNotFoundWithSuggestions,
+)
+
+TITLE = "Czysty Region"
+DESCRIPTION = "Source for Związek Międzygminny Czysty Region waste collection (Opole/Silesia region, Poland)."
+URL = "https://www.czystyregion.pl"
+COUNTRY = "pl"
+
+HARMONOGRAMY_URL = f"{URL}/Harmonogramy"
+
+RODZAJ_CHOICES = {"wielorodzinna", "jednorodzinna", "firma"}
+
+TEST_CASES = {
+    "Cisek (jednorodzinna)": {
+        "gmina": "Cisek",
+        "miejscowosc": "Cisek",
+        "rodzaj": "jednorodzinna",
+    },
+    "Cisek (firma)": {
+        "gmina": "Cisek",
+        "miejscowosc": "Cisek",
+        "rodzaj": "firma",
+    },
+    "Kędzierzyn-Koźle, ul. Piastów (wielorodzinna)": {
+        "gmina": "Kędzierzyn-Koźle",
+        "miejscowosc": "Kędzierzyn-Koźle",
+        "rodzaj": "wielorodzinna",
+        "ulica": "Piastów",
+    },
+    "Polska Cerekiew, ul. Kozielska (jednorodzinna)": {
+        "gmina": "Polska Cerekiew",
+        "miejscowosc": "Polska Cerekiew",
+        "rodzaj": "jednorodzinna",
+        "ulica": "Kozielska",
+    },
+}
+
+ICON_MAP = {
+    "Odpady zmieszane": Icons.GENERAL_WASTE,
+    "Tworzywa sztuczne/ Metale": Icons.RECYCLING,
+    "Papier": Icons.PAPER,
+    "Szkło": Icons.GLASS,
+    "Odpady BIO": Icons.ORGANIC,
+    "Popiół": Icons.GENERAL_WASTE,
+    "Zbiórka Akcyjna": Icons.BULKY,
+}
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": (
+        "Open https://www.czystyregion.pl/Harmonogramy and step through the "
+        "dropdowns (Wybierz gminę -> Wybierz rodzaj -> Wybierz miejscowość) "
+        "to find the exact spelling of your commune (gmina) and town/village "
+        "(miejscowość). If the result table lists more than one row for your "
+        "town (e.g. large towns split into several 'Rejon' street groups), "
+        "also note a distinctive street name from the 'Rejon' description "
+        "shown for your area and pass it as 'ulica'."
+    ),
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "gmina": "Commune (gmina)",
+        "miejscowosc": "Town/village (miejscowość)",
+        "rodzaj": "Property type (rodzaj)",
+        "ulica": "Street (for disambiguation)",
+    },
+    "de": {
+        "gmina": "Gemeinde (gmina)",
+        "miejscowosc": "Ort (miejscowość)",
+        "rodzaj": "Immobilientyp (rodzaj)",
+        "ulica": "Straße (zur Unterscheidung)",
+    },
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "gmina": "Name of the commune (gmina) as listed on czystyregion.pl.",
+        "miejscowosc": "Name of the town/village as listed on czystyregion.pl.",
+        "rodzaj": "One of: wielorodzinna (multi-family), jednorodzinna (single-family), firma (business).",
+        "ulica": "Optional street name used to pick the right area when your town has several separate schedules (only needed if the source reports an ambiguous result).",
+    },
+    "de": {
+        "gmina": "Name der Gemeinde (gmina), wie auf czystyregion.pl gelistet.",
+        "miejscowosc": "Name des Ortes, wie auf czystyregion.pl gelistet.",
+        "rodzaj": "Einer von: wielorodzinna (Mehrfamilienhaus), jednorodzinna (Einfamilienhaus), firma (Gewerbe).",
+        "ulica": "Optionaler Straßenname zur Auswahl des richtigen Bereichs, falls der Ort mehrere separate Pläne hat (nur bei mehrdeutigem Ergebnis nötig).",
+    },
+}
+
+
+def _strip_tags(html: str) -> str:
+    text = re.sub(r"<[^>]+>", " ", html)
+    return re.sub(r"\s+", " ", text).strip()
+
+
+class Source:
+    def __init__(
+        self, gmina: str, miejscowosc: str, rodzaj: str, ulica: str = ""
+    ) -> None:
+        self._gmina = str(gmina).strip()
+        self._miejscowosc = str(miejscowosc).strip()
+        self._rodzaj = str(rodzaj).strip()
+        self._ulica = str(ulica).strip()
+        if self._rodzaj not in RODZAJ_CHOICES:
+            raise SourceArgumentNotFoundWithSuggestions(
+                "rodzaj", rodzaj, sorted(RODZAJ_CHOICES)
+            )
+
+    def fetch(self) -> list[Collection]:
+        session = requests.Session(impersonate="chrome")
+
+        r = session.get(HARMONOGRAMY_URL, timeout=30)
+        r.raise_for_status()
+        html = r.text
+
+        token_match = re.search(r'name="_token" value="([^"]*)"', html)
+        if not token_match:
+            raise SourceArgumentNotFoundWithSuggestions("gmina", self._gmina, [])
+        token = token_match.group(1)
+
+        gminy_block_match = re.search(r'id="gminy"[^>]*>(.*?)</select>', html, re.S)
+        gminy = {
+            name.strip(): gid
+            for gid, name in re.findall(
+                r'<option value="(\d*)">([^<]*)</option>',
+                gminy_block_match.group(1) if gminy_block_match else "",
+            )
+            if gid
+        }
+        gmina_id = next(
+            (
+                gid
+                for name, gid in gminy.items()
+                if name.casefold() == self._gmina.casefold()
+            ),
+            None,
+        )
+        if gmina_id is None:
+            raise SourceArgumentNotFoundWithSuggestions(
+                "gmina", self._gmina, sorted(gminy)
+            )
+
+        regiony_match = re.search(r"var regiony = (\[.*?\]);", html, re.S)
+        regiony = json.loads(regiony_match.group(1)) if regiony_match else []
+        candidate_region_ids = [
+            str(region["id"])
+            for region in regiony
+            if str(region.get("gmina_id")) == gmina_id
+            and str(region.get("name", "")).strip().casefold()
+            == self._miejscowosc.casefold()
+        ]
+        if not candidate_region_ids:
+            names_for_gmina = sorted(
+                {
+                    str(region.get("name"))
+                    for region in regiony
+                    if str(region.get("gmina_id")) == gmina_id
+                }
+            )
+            raise SourceArgumentNotFoundWithSuggestions(
+                "miejscowosc", self._miejscowosc, names_for_gmina
+            )
+
+        rows: list[tuple[str, str]] = []
+        for region_id in candidate_region_ids:
+            resp = session.post(
+                HARMONOGRAMY_URL,
+                data={
+                    "_token": token,
+                    "gminy": gmina_id,
+                    "rodzaj": self._rodzaj,
+                    "regiony": region_id,
+                },
+                timeout=30,
+            )
+            resp.raise_for_status()
+            tbody_match = re.search(
+                r'<table id="harmonogramy".*?<tbody>(.*?)</tbody>', resp.text, re.S
+            )
+            if not tbody_match:
+                continue
+            for cell, harmonogram_id in re.findall(
+                r"<tr>\s*<td>(.*?)</td>\s*<td>.*?</td>\s*<td>.*?</td>\s*"
+                r'<td>.*?/Harmonogramy/(\d+)".*?</tr>',
+                tbody_match.group(1),
+                re.S,
+            ):
+                rows.append((harmonogram_id, _strip_tags(cell)))
+
+        if not rows:
+            raise SourceArgumentNotFoundWithSuggestions(
+                "rodzaj", self._rodzaj, sorted(RODZAJ_CHOICES)
+            )
+
+        if len(rows) > 1 and self._ulica:
+            filtered_rows = [
+                (harmonogram_id, description)
+                for harmonogram_id, description in rows
+                if self._ulica.casefold() in description.casefold()
+            ]
+            if filtered_rows:
+                rows = filtered_rows
+
+        if len(rows) > 1:
+            raise SourceArgAmbiguousWithSuggestions(
+                "ulica",
+                self._ulica,
+                [description for _, description in rows],
+            )
+
+        harmonogram_id = rows[0][0]
+
+        detail = session.get(f"{HARMONOGRAMY_URL}/{harmonogram_id}", timeout=30)
+        detail.raise_for_status()
+
+        events_match = re.search(r"events:\s*JSON\.parse\(`(.*?)`\)", detail.text, re.S)
+        if not events_match:
+            raise SourceArgumentNotFoundWithSuggestions(
+                "miejscowosc", self._miejscowosc, []
+            )
+        events = json.loads(events_match.group(1))
+
+        entries = []
+        for event in events:
+            try:
+                date = datetime.strptime(event["start"], "%Y-%m-%d").date()
+            except (KeyError, ValueError):
+                continue
+            waste_type = event.get("title", "")
+            entries.append(Collection(date, waste_type, icon=ICON_MAP.get(waste_type)))
+        return entries