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

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

@@ -0,0 +1,154 @@
+import re
+from datetime import datetime, timedelta
+
+import requests
+from waste_collection_schedule import (
+    Collection,  # type: ignore[attr-defined]
+    Icons,
+)
+from waste_collection_schedule.exceptions import (
+    SourceArgumentNotFound,
+    SourceArgumentNotFoundWithSuggestions,
+)
+
+TITLE = "Waikato District Council"
+DESCRIPTION = (
+    "Source for Waikato District Council kerbside rubbish and recycling "
+    "collection, New Zealand."
+)
+URL = "https://www.waikatodistrict.govt.nz/"
+COUNTRY = "nz"
+
+TEST_CASES = {
+    "Rotowaro, Monday": {"address": "42B Mahuta Station Road, Rotowaro"},
+    "Raglan, Tuesday": {"address": "90 Upper Wainui Road, Raglan"},
+    "Tuakau, Tuesday": {"address": "11 Gordon Paul Place, Tuakau"},
+    "Pokeno, Thursday": {"address": "53 Market Street, Pokeno"},
+}
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": "Enter your address as it appears on the council's rubbish and "
+    "recycling collection page, e.g. '18 Example Drive, Huntly'. If the "
+    "address cannot be found uniquely, the error message will list the "
+    "closest matches known to the council."
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "address": "Address",
+    }
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "address": "Street address within the Waikato District, e.g. "
+        "'18 Example Drive, Huntly'.",
+    }
+}
+
+API_URL = "https://www.waikatodistrict.govt.nz/widgetApi/RubbishAndRecyclingCollections/search"
+
+COLLECTION_TYPE = "Rubbish and Recycling"
+
+ICON_MAP = {
+    COLLECTION_TYPE: Icons.GENERAL_WASTE,
+}
+
+# Number of weeks of weekly collections to generate.
+WEEKS_AHEAD = 26
+
+# Cap the disambiguation suggestions returned to the user.
+MAX_SUGGESTIONS = 10
+
+WEEKDAYS = {
+    "monday",
+    "tuesday",
+    "wednesday",
+    "thursday",
+    "friday",
+    "saturday",
+    "sunday",
+}
+
+# Collection areas / days that don't have a fixed weekly kerbside collection
+# (e.g. monthly resource-recovery drop-off points, self-service transfer
+# stations, or properties outside the serviced area).
+NO_WEEKLY_SERVICE_DAYS = {"", "selfservice", "monthlydropoff"}
+
+# The API's search matches on a punctuation-free string; strip commas etc.
+_PUNCTUATION_RE = re.compile(r"[,\n\r]+")
+_WHITESPACE_RE = re.compile(r"\s+")
+
+
+def _normalize(address: str) -> str:
+    address = _PUNCTUATION_RE.sub(" ", address)
+    address = _WHITESPACE_RE.sub(" ", address)
+    return address.strip().lower()
+
+
+class Source:
+    def __init__(self, address: str):
+        self._address: str = address.strip()
+
+    def fetch(self) -> list[Collection]:
+        query = _normalize(self._address)
+
+        r = requests.get(API_URL, params={"address": query}, timeout=30)
+        r.raise_for_status()
+        results = r.json()
+
+        # Deduplicate by normalized address, keeping the first record and the
+        # original (nicely cased) address string for suggestions.
+        unique: dict[str, dict] = {}
+        for entry in results:
+            raw_address = entry.get("address")
+            if not raw_address:
+                continue
+            key = _normalize(raw_address)
+            unique.setdefault(key, entry)
+
+        if not unique:
+            raise SourceArgumentNotFoundWithSuggestions("address", self._address, [])
+
+        exact = unique.get(query)
+        if exact is not None:
+            target = exact
+        elif len(unique) == 1:
+            target = next(iter(unique.values()))
+        else:
+            suggestions = sorted(e["address"] for e in unique.values())
+            raise SourceArgumentNotFoundWithSuggestions(
+                "address", self._address, suggestions[:MAX_SUGGESTIONS]
+            )
+
+        collection_day = (target.get("collectionDay") or "").strip().lower()
+        collection_area = target.get("collectionArea")
+        next_date_str = target.get("nextDate")
+
+        if (
+            collection_day in NO_WEEKLY_SERVICE_DAYS
+            or collection_day not in WEEKDAYS
+            or collection_area in (None, "None")
+            or not next_date_str
+        ):
+            raise SourceArgumentNotFound(
+                "address",
+                self._address,
+                message_addition=(
+                    "this address does not have a fixed weekly rubbish and "
+                    "recycling collection day (it may use a monthly drop-off "
+                    "point, a self-service transfer station, or no kerbside "
+                    "service). Please check the council's website."
+                ),
+            )
+
+        next_date = datetime.fromisoformat(next_date_str).date()
+
+        return [
+            Collection(
+                date=next_date + timedelta(weeks=i),
+                t=COLLECTION_TYPE,
+                icon=ICON_MAP[COLLECTION_TYPE],
+            )
+            for i in range(WEEKS_AHEAD)
+        ]

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

@@ -0,0 +1,78 @@
+import re
+from datetime import datetime
+
+from waste_collection_schedule import Collection, Icons
+from waste_collection_schedule.exceptions import SourceArgumentNotFound
+from waste_collection_schedule.service.IntraMaps import (
+    IntraMapsSearchError,
+    MapsClient,
+    MapsClientConfig,
+    extract_panel_fields,
+)
+
+TITLE = "Waipa District Council"
+DESCRIPTION = (
+    "Source for Waipa District Council. Finds both general and glass recycling dates."
+)
+URL = "https://www.waipadc.govt.nz/"
+TEST_CASES = {
+    "10 Queen Street": {"address": "10 Queen Street"},  # Monday
+    "1 Acacia Avenue": {"address": "1 Acacia Avenue"},  # Wednesday
+}
+
+ICON_MAP = {
+    "Recycling": Icons.RECYCLING,
+    "Glass": Icons.GLASS,
+}
+
+INTRAMAPS_CONFIG = MapsClientConfig(
+    base_url="https://waipadc.spatial.t1cloud.com",
+    instance="spatial/IntraMaps",
+    config_id="6aa41407-1db8-44e1-8487-0b9a08965283",
+    project="b5bc138e-edce-4b01-b159-ec44539ab455",
+    module_id="5373c4e1-c975-4c8f-b51a-0ac976f5313c",
+    default_selection_layer="e7163a17-2f10-42b1-8dbf-8c53adf089a8",
+)
+
+# Match field names containing "Recycling" or "Glass" (they have verbose names)
+RECYCLING_PATTERN = re.compile(r"Mixed Recycling", re.IGNORECASE)
+GLASS_PATTERN = re.compile(r"Glass Recycling", re.IGNORECASE)
+
+# Extract dates in format "DD-Mon-YYYY"
+DATE_PATTERN = re.compile(r"\b(\d{1,2}-[A-Za-z]{3}-\d{4})\b")
+
+
+class Source:
+    def __init__(self, address):
+        self._address = address
+
+    def fetch(self):
+        try:
+            with MapsClient(INTRAMAPS_CONFIG) as client:
+                result = client.select_address(self._address)
+        except IntraMapsSearchError as e:
+            raise SourceArgumentNotFound("address", self._address) from e
+
+        fields = extract_panel_fields(result["response"])
+
+        entries = []
+        for field_name, field_value in fields.items():
+            if RECYCLING_PATTERN.search(field_name):
+                entries.extend(self._parse_dates(field_value, "Recycling"))
+            elif GLASS_PATTERN.search(field_name):
+                entries.extend(self._parse_dates(field_value, "Glass"))
+
+        return entries
+
+    @staticmethod
+    def _parse_dates(text: str, collection_type: str) -> list[Collection]:
+        icon = ICON_MAP.get(collection_type)
+        dates = DATE_PATTERN.findall(text)
+        entries = []
+        for date_str in dates:
+            try:
+                d = datetime.strptime(date_str, "%d-%b-%Y").date()
+                entries.append(Collection(date=d, t=collection_type, icon=icon))
+            except ValueError:
+                continue
+        return entries

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

@@ -0,0 +1,71 @@
+from datetime import datetime
+
+import requests
+from bs4 import BeautifulSoup
+from waste_collection_schedule import Collection
+
+TITLE = "Wakefield Council"
+DESCRIPTION = "Source for Wakefield.gov.uk services for Wakefield Council"
+URL = "https://wakefield.gov.uk"
+
+TEST_CASES = {
+    "uprn1": {"uprn": "63024087"},
+    "uprn2": {"uprn": 63105305},
+    "uprn3": {"uprn": "63012193"},
+}
+
+TYPES = {
+    "Household": {"icon": "mdi:trash-can", "alias": "Household"},
+    "Mixed": {"icon": "mdi:recycle", "alias": "Mixed Recycling"},
+    "Garden": {"icon": "mdi:leaf", "alias": "Garden"},
+}
+
+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": "Enter your UPRN (available from [FindMyAddress.co.uk](https://www.findmyaddress.co.uk/))."
+    "Alternatively: you can also see it in the URL/location bar of your browser when you search the Wakefield site manually, look for 'uprn=' in the url and take the numbers immediately after."
+}
+
+PARAM_DESCRIPTIONS = {  # Optional dict to describe the arguments, will be shown in the GUI configuration below the respective input field
+    "en": {
+        "uprn": "Unique Property Reference Number (UPRN)",
+    }
+}
+
+
+class Source:
+    def __init__(self, uprn):
+        self._uprn = uprn
+
+    def fetch(self) -> list[Collection]:
+        entries = []
+        with requests.Session() as sess:
+            url = "https://www.wakefield.gov.uk/where-i-live/"  # the a parameter is needed for page to load but contents doesn't matter
+            request = sess.get(url, params={"uprn": self._uprn, "a": "Your Address"})
+            soup = BeautifulSoup(request.content, "html.parser")
+            collection_sections = soup.select(".tablet\\:l-col-fb-4.u-mt-10")
+            for section in collection_sections:
+                collection_dates = set()
+                bin_type_raw = section.find("strong").text.split(" ")[0]
+                bin_type = TYPES.get(bin_type_raw)
+                if not bin_type:
+                    continue
+                date_elements = section.select(".u-mb-2")
+                date_elements.extend(section.find_all("li"))
+                for element in date_elements:
+                    if ", " not in element.text:
+                        continue
+                    try:
+                        date_str = element.text.split(", ")[1].strip()
+                        clean_date = datetime.strptime(date_str, "%d %B %Y").date()
+                        collection_dates.add(clean_date)
+                    except (ValueError, IndexError):
+                        continue
+                for collection_date in collection_dates:
+                    entries.append(
+                        Collection(
+                            date=collection_date,
+                            t=bin_type["alias"],
+                            icon=bin_type["icon"],
+                        )
+                    )
+        return entries

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

@@ -0,0 +1,74 @@
+import logging
+from datetime import datetime
+
+import requests
+from bs4 import BeautifulSoup
+from waste_collection_schedule import Collection, Icons
+
+TITLE = "Walsall Council"
+DESCRIPTION = "Source for waste collection services from Walsall Council"
+URL = "https://www.walsall.gov.uk/"
+TEST_CASES = {
+    "test001": {"uprn": "100071103746"},
+    "test002": {"uprn": 100071105627},
+    "test003": {"uprn": "100071095946"},
+    "test004": {"uprn": 100071048794},
+}
+
+API_URL = "https://cag.walsall.gov.uk"
+ICON_MAP = {
+    "GREY": Icons.GENERAL_WASTE,
+    "GREEN": Icons.RECYCLING,
+    "BROWN": Icons.ORGANIC,
+}
+HEADERS = {
+    "user-agent": "Mozilla/5.0",
+}
+
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class Source:
+    def __init__(self, uprn=None):
+        self._uprn = str(uprn)
+
+    def fetch(self):
+        s = requests.Session()
+
+        if self._uprn:
+            # GET request returns page containing links to separate collection schedules
+            r = s.get(
+                f"https://cag.walsall.gov.uk/BinCollections/GetBins?uprn={self._uprn}",
+                headers=HEADERS,
+            )
+            responseContent = r.text
+            soup = BeautifulSoup(responseContent, "html.parser")
+            # Extract links to collection schedule pages and iterate through the pages
+            schedule_links = soup.findAll("a", {"class": "select-bin"}, href=True)
+            entries = []
+            for item in schedule_links:
+                if "roundname" in item["href"]:
+                    # get bin colour
+                    bincolour = item["href"].split("=")[-1].split("%")[0].upper()
+                    binURL = API_URL + item["href"]
+                    r = s.get(binURL, headers=HEADERS)
+                    responseContent = r.text
+                    soup = BeautifulSoup(responseContent, "html.parser")
+                    table = soup.findAll("td")
+                    for td in table:
+                        try:
+                            collection_date = datetime.strptime(
+                                td.text.strip(), "%d/%m/%Y"
+                            )
+                            entries.append(
+                                Collection(
+                                    date=collection_date.date(),
+                                    t=bincolour,
+                                    icon=ICON_MAP.get(bincolour),
+                                )
+                            )
+                        except ValueError:
+                            pass
+
+        return entries

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

@@ -0,0 +1,107 @@
+import logging
+from datetime import datetime, timedelta
+from time import time_ns
+
+import requests
+from waste_collection_schedule import Collection, Icons
+
+LOGGER = logging.getLogger(__name__)
+TITLE = "Waltham Forest"
+DESCRIPTION = "Source for Waltham Forest."
+URL = "https://walthamforest.gov.uk/"
+TEST_CASES = {
+    "200001421821": {"uprn": "200001421821"},
+    "100023583909": {"uprn": 100022551607},
+}
+
+
+ICON_MAP = {
+    "DOMESTIC WASTE COLLECTION SERVICE": Icons.GENERAL_WASTE,
+    "FOOD WASTE COLLECTION SERVICE": Icons.BIO_KITCHEN,
+    "ORGANIC COLLECTION SERVICE": Icons.ORGANIC,
+    "RECYCLING COLLECTION SERVICE": Icons.RECYCLING,
+}
+
+
+HEADERS = {
+    "user-agent": "Mozilla/5.0",
+}
+
+
+class Source:
+    def __init__(self, uprn: str | int):
+        self._uprn: str | int = uprn
+
+    def fetch(self):
+        s = requests.Session()
+
+        # Set up session
+        timestamp = time_ns() // 1_000_000  # epoch time in milliseconds
+        # This request gets the session ID
+        sid_request = s.get(
+            "https://portal.walthamforest.gov.uk/authapi/isauthenticated?uri=https%253A%252F%252Fportal.walthamforest.gov.uk%252FAchieveForms%252F%253Fmode%253Dfill%2526consentMessage%253Dyes%2526form_uri%253Dsandbox-publish%253A%252F%252FAF-Process-d62ccdd2-3de9-48eb-a229-8e20cbdd6393%252FAF-Stage-8bf39bf9-5391-4c24-857f-0dc2025c67f4%252Fdefinition.json%2526process%253D1%2526process_uri%253Dsandbox-processes%253A%252F%252FAF-Process-d62ccdd2-3de9-48eb-a229-8e20cbdd6393%2526process_id%253DAF-Process-d62ccdd2-3de9-48eb-a229-8e20cbdd6393&hostname=portal.walthamforest.gov.uk&withCredentials=true",
+            headers=HEADERS,
+        )
+        sid_data = sid_request.json()
+        sid = sid_data["auth-session"]
+
+        # This request retrieves the schedule
+        timestamp = time_ns() // 1_000_000  # epoch time in milliseconds
+        payload = {
+            "formValues": {
+                "Property": {
+                    key: {"value": self._uprn}
+                    for key in [
+                        "AccountSiteUprn",
+                        "UPRNSearch",
+                        "calcUPRN",
+                        "customerUPRN",
+                        "inputUPRN",
+                    ]
+                }
+            }
+        }
+
+        schedule_request = s.post(
+            f"https://portal.walthamforest.gov.uk/apibroker/runLookup?id=5e208cda0d0a0&repeat_against=&noRetry=False&getOnlyTokens=undefined&log_id=&app_name=AF-Renderer::Self&_={timestamp}sid={sid}",
+            headers=HEADERS,
+            json=payload,
+        )
+        rowdata = schedule_request.json()["integration"]["transformed"]["rows_data"]
+
+        # Extract bin types and next collection dates
+        entries = []
+        today = datetime.today()
+        for item in rowdata.values():
+            bin_type = item["ServiceName"]
+            next_date = item["NextCollectionDate"]
+            if next_date == " NaN ":
+                continue
+            # Schedule reported in %A %d %B format, e.g. Thursday 20 February
+            # This is an awful format at a year boundary and requires iteration to pull out a real date object.
+            # Would use %-d for day of month with no leading 0, but that is not OS independent, hence horrible strip
+            attempts = 40
+            attempt_date = today
+            attempt_formatted_for_comparison = f"{attempt_date.strftime('%A')} {attempt_date.strftime('%d').lstrip('0')} {attempt_date.strftime('%B')}"
+            found = attempt_formatted_for_comparison == next_date
+            while not found and attempts > 0:
+                attempt_date += timedelta(days=1)
+                attempt_formatted_for_comparison = f"{attempt_date.strftime('%A')} {attempt_date.strftime('%d').lstrip('0')} {attempt_date.strftime('%B')}"
+                found = attempt_formatted_for_comparison == next_date
+                attempts -= 1
+
+            if not found:
+                LOGGER.error(
+                    f"Failing to find the date - API returned {next_date}, last date attempted was {attempt_date}"
+                )
+                continue
+
+            entries.append(
+                Collection(
+                    t=bin_type,
+                    date=attempt_date.date(),
+                    icon=ICON_MAP.get(bin_type.upper()),
+                )
+            )
+
+        return entries

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

@@ -0,0 +1,169 @@
+import datetime
+import logging
+
+import requests
+from bs4 import BeautifulSoup
+from waste_collection_schedule import Collection, Icons
+from waste_collection_schedule.exceptions import (
+    SourceArgumentException,
+    SourceArgumentNotFound,
+)
+
+_LOGGER = logging.getLogger(__name__)
+
+TITLE = "Wandsworth Council"
+DESCRIPTION = "Source for Wandsworth Council for the London Borough of Wandsworth, UK."
+URL = "https://www.wandsworth.gov.uk"
+
+COUNTRY = "uk"
+
+TEST_CASES = {
+    "100022659217": {"uprn": 100022659217},
+    "100022611611": {"uprn": 100022611611},
+    "10091501435": {"uprn": "10091501435"},
+}
+
+API_URL = "https://www.wandsworth.gov.uk/my-property/"
+
+ICON_MAP = {
+    "Food waste": Icons.BIO_KITCHEN,
+    "Recycling": Icons.RECYCLING,
+    "Rubbish": Icons.GENERAL_WASTE,
+    "Rubbish/Garden waste": Icons.GARDEN,
+    "Small electrical items": Icons.ELECTRONICS,
+}
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": "You can find your UPRN by visiting [Find My Address](https://www.findmyaddress.co.uk) and entering your address details."
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "uprn": "Unique Property Reference Number (UPRN)",
+    }
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "uprn": "Unique Property Reference Number (UPRN)",
+    }
+}
+
+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",
+    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+    "Accept-Language": "en-GB,en;q=0.5",
+    "Referer": "https://www.wandsworth.gov.uk",
+}
+
+
+class Source:
+    def __init__(self, uprn: str | int):
+        self._uprn = str(uprn)
+
+        if not self._uprn.isdigit():
+            raise SourceArgumentException("uprn", "UPRN must be numeric")
+
+    def fetch(self) -> list[Collection]:
+
+        try:
+            # Wandsworth site can be slow; using a 90s timeout to avoid false failures
+            r = requests.get(
+                API_URL,
+                params={"UPRN": self._uprn, "propertyidentified": "Select"},
+                headers=HEADERS,
+                timeout=90,
+            )
+
+            r.raise_for_status()
+
+        # Check for Website Errors
+        except requests.RequestException as e:
+            raise SourceArgumentException(
+                "uprn", "Wandsworth Council website unreachable"
+            ) from e
+
+        soup = BeautifulSoup(r.text, "html.parser")
+
+        # Check for unexpected page My Property H1
+        if not soup.find("h1", string="My Property"):
+            raise SourceArgumentException(
+                "uprn", "Unexpected page content from Wandsworth Council"
+            )
+
+        # Check if UPRN is correct by if Results Div is returned
+        if not soup.find("div", id="result"):
+            raise SourceArgumentException(
+                "uprn",
+                f"UPRN {self._uprn} is invalid or outside the Wandsworth Council area. Make sure your address returns entries on the council website: {API_URL}",
+            )
+
+        # Find the heading for the Rubbish & Recycling section
+        rubbish_heading = soup.find(
+            "h3", string=lambda text: text and "Rubbish and recycling" in text
+        )
+
+        if rubbish_heading:
+            # Look for the next <p> sibling immediately after the heading
+            next_p = rubbish_heading.find_next_sibling("p")
+
+            # Check to see if source data currently unavailable
+            if next_p and "currently unavailable" in next_p.get_text():
+                raise SourceArgumentException(
+                    "uprn", "Source data currently unavailable."
+                )
+
+        entries = []
+
+        waste_headings = soup.find_all("h4", class_="collection-heading")
+
+        for waste_heading in waste_headings:
+            # Get Waste Type from Heading Name
+            waste_type = waste_heading.get_text(strip=True)
+
+            #  Navigate to Next Div
+            collections = waste_heading.find_next_sibling("div", class_="collections")
+
+            if not collections:
+                continue
+
+            for collection in collections.find_all("div", class_="collection"):
+                # Remove Strong Element
+                strong = collection.find("strong")
+                if strong:
+                    strong.extract()
+
+                # Remove Completed Badge
+                badge = collection.find("span", class_="badge")
+                if badge:
+                    badge.extract()
+
+                # Extracted Date String
+                date_str = collection.get_text(strip=True)
+
+                # Format Date String
+                try:
+                    collection_date = datetime.datetime.strptime(
+                        date_str, "%A %d %B %Y"
+                    ).date()
+
+                except ValueError:
+                    _LOGGER.warning(
+                        "Source date format not recognised. Unable to parse %s date: %r",
+                        waste_type,
+                        date_str,
+                    )
+                    continue
+
+                entries.append(
+                    Collection(
+                        date=collection_date,
+                        t=waste_type,
+                        icon=ICON_MAP.get(waste_type, "mdi:trash-can"),
+                    )
+                )
+
+        if not entries:
+            raise SourceArgumentNotFound("uprn", self._uprn)
+
+        return entries

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

@@ -0,0 +1,35 @@
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.service.OpenCities import (
+    OpenCitiesClient,
+    OpenCitiesConfig,
+)
+
+TITLE = "Rural City of Wangaratta"
+DESCRIPTION = "Source for Rural City of Wangaratta rubbish collection."
+URL = "https://www.wangaratta.vic.gov.au"
+TEST_CASES = {
+    "Wangaratta High School": {"street_address": "Edwards Street WANGARATTA VIC 3677"},
+    "KFC Wangaratta": {"street_address": "23-27 Ryley Street WANGARATTA VIC 3677"},
+}
+
+ICON_MAP = {
+    "General Waste": Icons.GENERAL_WASTE,
+    "Organics": Icons.ORGANIC,
+    "Recycling": Icons.RECYCLING,
+}
+
+_CONFIG = OpenCitiesConfig(
+    domain="https://www.wangaratta.vic.gov.au",
+    argument_name="street_address",
+    warm_up_url="https://www.wangaratta.vic.gov.au/Services/Waste-Recycling/Kerbside-Collection/Check-your-bin-day",
+    icon_keywords=ICON_MAP,
+)
+
+
+class Source:
+    def __init__(self, street_address: str):
+        self._street_address = street_address
+        self._client = OpenCitiesClient(_CONFIG)
+
+    def fetch(self) -> list[Collection]:
+        return self._client.fetch(address=self._street_address)