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

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

@@ -0,0 +1,131 @@
+import logging
+from datetime import datetime
+
+import requests
+from bs4 import BeautifulSoup, Tag
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+
+_LOGGER = logging.getLogger(__name__)
+
+TITLE = "Dacorum Borough Council"
+DESCRIPTION = "Source for Dacorum Borough Council."
+URL = "https://www.dacorum.gov.uk/"
+TEST_CASES = {
+    "Test_001": {"postcode": "HP1 1AB", "uprn": 200004054631},
+    "Test_002": {"postcode": "HP4 2EZ", "uprn": "100081111531"},
+    "Test_003": {
+        "postcode": "HP23 6BE",
+        "uprn": "100080716575",
+    },
+}
+
+ICON_MAP = {
+    "grey bin": Icons.GENERAL_WASTE,
+    "grey bin and kerbside caddy": Icons.GENERAL_WASTE,
+    "kerbside caddy": Icons.BIO_KITCHEN,
+    "blue bin": Icons.RECYCLING,
+    "blue bin and kerbside caddy": Icons.RECYCLING,
+    "green bin": Icons.ORGANIC,
+}
+
+API_URL = "https://webapps.dacorum.gov.uk/bincollections/"
+FORM_ARG_IDS = [
+    "__VIEWSTATE",
+    "__EVENTVALIDATION",
+    "btnFindAddr",
+    "txtBxPCode",
+    "lstBxAddrList",
+    "MainContent_btnGetSchedules",
+]
+
+
+class Source:
+    def __init__(self, postcode: str, uprn: str | int):
+        self._postcode: str = postcode.strip()
+        self._uprn: str = str(uprn)
+
+    def _get_form_args(self, soup: BeautifulSoup) -> dict[str, str]:
+        return {
+            i.get("name"): i.get("value")
+            for i in soup.find_all(["input", "select"])
+            if i.get("id") in FORM_ARG_IDS
+        }
+
+    def _parse_address_list(self, select_element: Tag) -> dict[str, str]:
+        uprn_addresses = {}
+        for row in select_element.children:
+            # Ensure child element is a Tag
+            if isinstance(row, Tag):
+                # Extract uprn from address line
+                row_value = row.get("value", "")
+                row_parts = row_value.split(";")
+                if len(row_parts) == 2:
+                    uprn_addresses[row_parts[1]] = row_value
+
+        return uprn_addresses
+
+    def _parse_collection_entry(self, div: Tag) -> Collection | None:
+        # bin types are in strong tags
+        for strong in div.find_all("strong"):
+            bin_type = strong.get_text(strip=True)
+            # skip any non-bin finds
+            if "bin" not in bin_type.lower():
+                continue
+            # Find the nearest following cell containing a date
+            date_cell = strong.find_parent("div").find_next(
+                "div", string=lambda s: s and "Next collection on" in s
+            )
+            if date_cell:
+                collection_date = date_cell.find_next("div").get_text(strip=True)
+            # set bin icon
+            bin_type_icon = ICON_MAP.get(bin_type.lower())
+            # try and add the collection details
+            try:
+                dt = datetime.strptime(collection_date, "%a, %d %b %Y").date()
+                return Collection(date=dt, t=bin_type, icon=bin_type_icon)
+            except ValueError:
+                return None
+        return None
+
+    def fetch(self) -> list[Collection]:
+        # Start a session and fetch state args
+        session = requests.Session()
+        r = session.get(API_URL)
+        r.raise_for_status()
+        soup = BeautifulSoup(r.text, "html.parser")
+        postcode_input = soup.find(id="txtBxPCode")
+        if postcode_input is None:
+            raise Exception("Postcode input tag not found")
+
+        # Fetch addresses for postcode
+        postcode_input["value"] = self._postcode
+        r = session.post(API_URL, data=self._get_form_args(soup))
+        soup = BeautifulSoup(r.text, features="html.parser")
+        address_input = soup.find(id="lstBxAddrList")
+        if address_input is None:
+            raise Exception("Address input tag not found")
+
+        # Find address value for uprn
+        addresses = self._parse_address_list(address_input)
+        if self._uprn not in addresses:
+            raise Exception(
+                f"uprn '{self._uprn}' not found for postcode '{self._postcode}'"
+            )
+        address_input["value"] = addresses[self._uprn]
+
+        # Find collections for address
+        r = session.post(API_URL, data=self._get_form_args(soup))
+        soup = BeautifulSoup(r.text, features="html.parser")
+        collection_content = soup.find("div", id="MainContent_updPnl")
+        if collection_content is None:
+            raise Exception("MainContent_updPnl tag not found")
+
+        # Parse entries into collections
+        collections = []
+        entries = collection_content.findChildren("div", recursive=False)
+        for e in entries:
+            c = self._parse_collection_entry(e)
+            if c is not None:
+                collections.append(c)
+
+        return collections

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

@@ -0,0 +1,219 @@
+import re
+from datetime import date, timedelta
+
+import requests
+from bs4 import BeautifulSoup
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import (
+    SourceArgumentNotFound,
+    SourceArgumentNotFoundWithSuggestions,
+)
+
+TITLE = "Shire of Dardanup"
+DESCRIPTION = "Source for Shire of Dardanup (WA) waste collection."
+URL = "https://www.dardanup.wa.gov.au"
+COUNTRY = "au"
+TEST_CASES = {
+    "Hale Street (Area 1, Tuesday)": {
+        "street": "Hale Street",
+        "recycling_in_even_week": True,
+    },
+    "Burekup": {
+        "street": "Burekup",
+        "recycling_in_even_week": True,
+    },
+    "Dardanup West via collection_day": {
+        "collection_day": "Monday",
+        "recycling_in_even_week": True,
+    },
+}
+
+ICON_MAP = {
+    "FOGO": Icons.BIO_KITCHEN,
+    "Recycling": Icons.RECYCLING,
+    "General Waste": Icons.GENERAL_WASTE,
+}
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": (
+        "Visit https://www.dardanup.wa.gov.au/our-services/waste-and-recycling/"
+        "find-your-bin-day.aspx and find your street in the list to determine "
+        "your collection day. Enter your street name (without house number) as "
+        "the 'street' argument, or enter the day directly as 'collection_day' "
+        "(for Dardanup West / Ferguson Valley residents). "
+        "For recycling_in_even_week: check your last recycling collection date "
+        "and see if its ISO week number (https://whatweekisit.org/) was even "
+        "(True) or odd (False)."
+    ),
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "street": (
+            "Your street name without a house number, e.g. 'Hale Street' or "
+            "'Flinders Street'. Used to look up your collection day automatically."
+        ),
+        "collection_day": (
+            "Your collection day as a string: 'Monday', 'Tuesday', 'Wednesday', "
+            "'Thursday', or 'Friday'. Use this instead of 'street' for Dardanup "
+            "West (Monday) and Ferguson Valley residents, or if street lookup fails."
+        ),
+        "recycling_in_even_week": (
+            "Set to True if your recycling bin is collected on even ISO week "
+            "numbers, False if on odd ISO week numbers. Check your last recycling "
+            "collection date to determine this."
+        ),
+    },
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "street": "Street Name",
+        "collection_day": "Collection Day (override)",
+        "recycling_in_even_week": "Recycling collected on even ISO weeks",
+    },
+}
+
+COLLECTION_URL = (
+    "https://www.dardanup.wa.gov.au/our-services/waste-and-recycling/"
+    "find-your-bin-day.aspx"
+)
+
+DAY_NAME_TO_WEEKDAY = {
+    "monday": 0,
+    "tuesday": 1,
+    "wednesday": 2,
+    "thursday": 3,
+    "friday": 4,
+}
+
+
+def _next_weekday(ref: date, weekday: int) -> date:
+    days_ahead = weekday - ref.weekday()
+    if days_ahead < 0:
+        days_ahead += 7
+    return ref + timedelta(days=days_ahead)
+
+
+def _clean_street(raw: str) -> str:
+    """Strip range qualifiers like '(numbers 4-64)' or '(odd numbers 2-46)'."""
+    return re.sub(r"\s*\([^)]+\)", "", raw).strip()
+
+
+class Source:
+    def __init__(
+        self,
+        street: str | None = None,
+        collection_day: str | None = None,
+        recycling_in_even_week: bool = True,
+    ):
+        if not street and not collection_day:
+            raise SourceArgumentNotFound(
+                "street",
+                "Provide either 'street' (your street name) or 'collection_day' "
+                "('Monday'–'Friday').",
+            )
+        self._street = street.strip() if street else None
+        self._collection_day = (
+            collection_day.strip().lower() if collection_day else None
+        )
+        self._recycling_in_even_week = recycling_in_even_week
+
+    def fetch(self) -> list[Collection]:
+        if self._collection_day:
+            if self._collection_day not in DAY_NAME_TO_WEEKDAY:
+                raise SourceArgumentNotFound(
+                    "collection_day",
+                    f"'{self._collection_day}' is not a valid day. "
+                    f"Use one of: {', '.join(DAY_NAME_TO_WEEKDAY)}.",
+                )
+            weekday = DAY_NAME_TO_WEEKDAY[self._collection_day]
+        else:
+            weekday = self._lookup_street_day()
+
+        return self._build_entries(weekday)
+
+    def _lookup_street_day(self) -> int:
+        r = requests.get(COLLECTION_URL, timeout=30)
+        r.raise_for_status()
+        soup = BeautifulSoup(r.text, "html.parser")
+
+        street_lower = self._street.lower()
+        all_streets: list[str] = []
+        found_weekday: int | None = None
+
+        for accordion in soup.select("div.accordion div.accordion"):
+            current_day: int | None = None
+
+            for child in accordion.children:
+                if not hasattr(child, "name"):
+                    continue
+
+                if child.name == "h2":
+                    heading = child.get_text(strip=True).lower()
+                    current_day = None
+                    for day_name, wd in DAY_NAME_TO_WEEKDAY.items():
+                        if heading.startswith(day_name):
+                            current_day = wd
+                            break
+
+                elif child.name == "p":
+                    para_text = child.get_text(strip=True)
+                    if not para_text:
+                        continue
+
+                    thursday_match = re.match(
+                        r"^(.+?)\s*[-–]\s*(monday|tuesday|wednesday|thursday|friday)",
+                        para_text,
+                        re.IGNORECASE,
+                    )
+                    if thursday_match:
+                        suburb = thursday_match.group(1).strip().lower()
+                        day_str = thursday_match.group(2).strip().lower()
+                        all_streets.append(thursday_match.group(1).strip())
+                        if suburb in street_lower or street_lower in suburb:
+                            found_weekday = DAY_NAME_TO_WEEKDAY.get(day_str)
+                        continue
+
+                    if current_day is not None:
+                        for raw in para_text.split(","):
+                            cleaned = _clean_street(raw)
+                            if cleaned:
+                                all_streets.append(cleaned)
+                                if (
+                                    cleaned.lower() == street_lower
+                                    or street_lower in cleaned.lower()
+                                ):
+                                    found_weekday = current_day
+
+        if found_weekday is None:
+            raise SourceArgumentNotFoundWithSuggestions(
+                "street", self._street, sorted(set(all_streets))
+            )
+
+        return found_weekday
+
+    def _build_entries(self, weekday: int) -> list[Collection]:
+        entries: list[Collection] = []
+        today = date.today()
+        first_day = _next_weekday(today, weekday)
+
+        for week in range(26):
+            d = first_day + timedelta(weeks=week)
+            iso_week = d.isocalendar()[1]
+            even_week = iso_week % 2 == 0
+
+            entries.append(Collection(date=d, t="FOGO", icon=ICON_MAP["FOGO"]))
+
+            if even_week == self._recycling_in_even_week:
+                entries.append(
+                    Collection(date=d, t="Recycling", icon=ICON_MAP["Recycling"])
+                )
+            else:
+                entries.append(
+                    Collection(
+                        date=d, t="General Waste", icon=ICON_MAP["General Waste"]
+                    )
+                )
+
+        return entries

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

@@ -0,0 +1,236 @@
+from datetime import timedelta
+
+import requests
+from waste_collection_schedule import Collection  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import (
+    SourceArgAmbiguousWithSuggestions,
+    SourceArgumentNotFound,
+)
+from waste_collection_schedule.service.ArcGis import (
+    epoch_ms_to_date,
+    get_next_n_dates,
+    most_recent_weekday,
+)
+
+TITLE = "City of Darebin"
+DESCRIPTION = "Source for City of Darebin waste collection."
+URL = "https://www.darebin.vic.gov.au/"
+TEST_CASES = {
+    "266 Gower Street PRESTON 3072": {
+        "property_location": "266 Gower Street PRESTON 3072"
+    },
+    "23 EDWARDES STREET RESERVOIR 3073": {
+        "property_location": "23 EDWARDES STREET RESERVOIR 3073"
+    },
+    # The shapes people type. The register holds none of them verbatim.
+    "Comma separated with state": {
+        "property_location": "266 Gower Street, Preston VIC 3072"
+    },
+    "Abbreviated street type": {"property_location": "266 Gower St Preston"},
+}
+API_URL = "https://services-ap1.arcgis.com/1WJBRkF3v1EEG5gz/arcgis/rest/services/Waste_Collection_Date3/FeatureServer/0/query"
+_ARG = "property_location"
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "property_location": "Property location",
+    }
+}
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "property_location": "Address as held by the council's address register: street number, street name, suburb and postcode, for example '266 Gower Street PRESTON 3072'.",
+    }
+}
+
+# EZI_ADDRESS is the Vicmap address string: upper case, no commas, street type
+# spelled out, suburb then postcode ("266 GOWER STREET PRESTON 3072"). The
+# query below is a prefix LIKE against it, so a comma, a "VIC", or an
+# abbreviated street type matches nothing at all -- which is most of what
+# visitors actually type.
+_STREET_TYPES = {
+    "AV": "AVENUE",
+    "AVE": "AVENUE",
+    "BVD": "BOULEVARD",
+    "BLVD": "BOULEVARD",
+    "CCT": "CIRCUIT",
+    "CL": "CLOSE",
+    "CR": "CRESCENT",
+    "CRES": "CRESCENT",
+    "CT": "COURT",
+    "DR": "DRIVE",
+    "ESP": "ESPLANADE",
+    "GDNS": "GARDENS",
+    "GR": "GROVE",
+    "GRV": "GROVE",
+    "HWY": "HIGHWAY",
+    "LN": "LANE",
+    "PDE": "PARADE",
+    "PL": "PLACE",
+    "RD": "ROAD",
+    "SQ": "SQUARE",
+    "ST": "STREET",
+    "TCE": "TERRACE",
+    "WY": "WAY",
+}
+_STATES = {"VIC", "VICTORIA"}
+
+# Enough to show the visitor which property they meant, without pulling the
+# whole municipality back when someone searches for a bare street name.
+_MAX_SUGGESTIONS = 10
+
+WEEKDAY_MAP = {
+    "Monday": 0,
+    "Tuesday": 1,
+    "Wednesday": 2,
+    "Thursday": 3,
+    "Friday": 4,
+    "Saturday": 5,
+    "Sunday": 6,
+}
+
+
+def _normalise(value: str) -> str:
+    """Upper case, drop commas and collapse whitespace."""
+    return " ".join(value.upper().replace(",", " ").split())
+
+
+def _register_form(value: str) -> str:
+    """What the visitor typed, written the way EZI_ADDRESS holds it."""
+    words = [_STREET_TYPES.get(word, word) for word in _normalise(value).split()]
+    while words and words[-1] in _STATES:
+        words.pop()
+    return " ".join(words)
+
+
+def _prefixes(value: str) -> list[str]:
+    """Progressively shorter prefixes of the address, longest first.
+
+    EZI_ADDRESS ends with the suburb and postcode, and a visitor who gets
+    either of those slightly wrong (or omits them) would otherwise match
+    nothing. Shortening the prefix recovers the match; the caller still has to
+    decide what to do when more than one property comes back.
+    """
+    address = _register_form(value)
+    words = address.split()
+    candidates = [address]
+    # Trailing postcode, then the suburb one word at a time, never past the
+    # street number and street name.
+    if words and words[-1].isdigit() and len(words[-1]) == 4:
+        words = words[:-1]
+        candidates.append(" ".join(words))
+    while len(words) > 2:
+        words = words[:-1]
+        candidates.append(" ".join(words))
+    return list(dict.fromkeys(c for c in candidates if c))
+
+
+class Source:
+    def __init__(self, property_location: str):
+        self.property_location = property_location
+
+    def _query(self, where: str, out_fields: str, **extra) -> list[dict]:
+        params = {"where": where, "outFields": out_fields, "f": "json", **extra}
+        r = requests.get(API_URL, params=params)
+        r.raise_for_status()
+        return r.json().get("features") or []
+
+    def _resolve_object_id(self) -> int:
+        wanted = _register_form(self.property_location)
+        for prefix in _prefixes(self.property_location):
+            # ArcGIS `where` is SQL-ish, so a quote in the address (O'Hea
+            # Street) would otherwise end the literal early.
+            escaped = prefix.replace("'", "''")
+            features = self._query(
+                f"UPPER(EZI_ADDRESS) LIKE '{escaped}%'",
+                "EZI_ADDRESS,OBJECTID",
+                resultRecordCount=_MAX_SUGGESTIONS + 1,
+            )
+            if not features:
+                continue
+
+            exact = [
+                f
+                for f in features
+                if _normalise(f["attributes"]["EZI_ADDRESS"]) == wanted
+            ]
+            if len(exact) == 1:
+                return exact[0]["attributes"]["OBJECTID"]
+            if len(features) == 1:
+                return features[0]["attributes"]["OBJECTID"]
+
+            raise SourceArgAmbiguousWithSuggestions(
+                _ARG,
+                self.property_location,
+                [f["attributes"]["EZI_ADDRESS"] for f in features[:_MAX_SUGGESTIONS]],
+            )
+
+        raise SourceArgumentNotFound(
+            _ARG,
+            self.property_location,
+            "Darebin holds addresses as street number, street name, suburb and "
+            "postcode, for example '266 Gower Street PRESTON 3072'.",
+        )
+
+    def fetch(self) -> list[Collection]:
+        object_id = self._resolve_object_id()
+
+        features = self._query(
+            "1=1",
+            "Collection_Day,Condition,EZI_ADDRESS,Green_Collection,"
+            "Recycle_Collection,Street_Sweeping",
+            objectIds=object_id,
+        )
+        if not features:
+            raise SourceArgumentNotFound(
+                _ARG,
+                self.property_location,
+                "Darebin found the address but holds no collection details for it.",
+            )
+        attributes = features[0]["attributes"]
+
+        collection_day = attributes["Collection_Day"]
+
+        next_collection_date = most_recent_weekday(WEEKDAY_MAP[collection_day])
+
+        green_collection = epoch_ms_to_date(attributes["Green_Collection"])
+        recycle_collection = epoch_ms_to_date(attributes["Recycle_Collection"])
+        street_sweeping = epoch_ms_to_date(attributes["Street_Sweeping"])
+
+        green_collection_dates = get_next_n_dates(
+            green_collection, 26, timedelta(days=14)
+        )
+        recycle_collection_dates = get_next_n_dates(
+            recycle_collection, 26, timedelta(days=14)
+        )
+        waste_collection_dates = get_next_n_dates(
+            next_collection_date, 52, timedelta(days=7)
+        )
+        street_sweeping_dates = get_next_n_dates(street_sweeping, 1, timedelta(weeks=6))
+
+        entries = []
+
+        entries.extend(
+            [
+                Collection(date=collection_date, t="Green Waste", icon="mdi:leaf")
+                for collection_date in green_collection_dates
+            ]
+        )
+        entries.extend(
+            [
+                Collection(date=collection_date, t="Recycling", icon="mdi:recycle")
+                for collection_date in recycle_collection_dates
+            ]
+        )
+        entries.extend(
+            [
+                Collection(date=collection_day, t="Rubbish", icon="mdi:trash-can")
+                for collection_day in waste_collection_dates
+            ]
+        )
+        entries.extend(
+            [
+                Collection(date=collection_day, t="Street Sweeping", icon="mdi:broom")
+                for collection_day in street_sweeping_dates
+            ]
+        )
+        return entries

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

@@ -0,0 +1,67 @@
+from datetime import datetime
+
+import requests
+from bs4 import BeautifulSoup
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+
+TITLE = "Darlington Borough Council"
+DESCRIPTION = "Source for Darlington Borough Council."
+URL = "https://darlington.gov.uk"
+TEST_CASES = {
+    "10013321444": {"uprn": 10013321444},
+    "010013315817": {"uprn": 10013315817},
+    "100110560916": {"uprn": 100110560916},
+    "200002724471": {"uprn": "200002724471"},
+}
+
+ICON_MAP = {
+    "Food waste": Icons.ORGANIC,
+    "Recycling": Icons.RECYCLING,
+    "Refuse": Icons.GENERAL_WASTE,
+    "Garden Waste": Icons.GARDEN,
+}
+
+
+API_URL = (
+    "https://www.darlington.gov.uk/bins-waste-and-recycling/collection-day-lookup/"
+)
+
+
+class Source:
+    def __init__(self, uprn: str | int):
+        self._uprn = str(uprn)
+
+    def fetch(self) -> list[Collection]:
+        r = requests.get(API_URL, params={"uprn": self._uprn}, timeout=20)
+        r.raise_for_status()
+
+        soup = BeautifulSoup(r.text, "html.parser")
+
+        entries = []
+
+        cards = soup.select("div.refuse-results")
+
+        for card in cards:
+            date_element = card.select_one(".collectionDate p")
+            if not date_element:
+                continue
+
+            date_str = date_element.get_text(strip=True).split("(")[0].strip()
+            collection_date = datetime.strptime(
+                date_str,
+                "%A %d %B %Y",
+            ).date()
+            waste_types = [
+                x.get_text(strip=True) for x in card.select(".collection-result-text")
+            ]
+
+            for waste_type in waste_types:
+                entries.append(
+                    Collection(
+                        date=collection_date,
+                        t=waste_type,
+                        icon=ICON_MAP.get(waste_type),
+                    )
+                )
+
+        return entries