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

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

@@ -0,0 +1,473 @@
+import datetime
+import logging
+import re
+from typing import Any
+
+import requests
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import (
+    SourceArgAmbiguousWithSuggestions,
+    SourceArgumentException,
+    SourceArgumentNotFound,
+    SourceArgumentRequired,
+)
+
+TITLE = "Pendle Borough Council"
+DESCRIPTION = "Source for Pendle Borough Council."
+URL = "https://www.pendle.gov.uk/binday"
+TEST_CASES = {
+    "Pendle Market Street": {
+        "postcode": "BB9 7LJ",
+        "address": "PENDLE LEISURE TRUST, 1, MARKET STREET, NELSON",
+    }
+}
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": (
+        "Enter the postcode and address as returned by Pendle Borough Council. "
+        "Set garden_waste_bin to true when the property has a green garden waste "
+        "bin, and set collection_zone only if Pendle returns multiple schedules "
+        "for the address."
+    )
+}
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "address": "Address as returned by Pendle Borough Council.",
+        "collection_zone": (
+            "Collection zone, only needed if Pendle returns multiple schedules "
+            "for your address."
+        ),
+        "future_collection_dates": "Generate future collection dates.",
+        "garden_waste_bin": (
+            "Set to true when the property has a green garden waste bin collected "
+            "with the blue and brown bins."
+        ),
+        "postcode": "Postcode for the property.",
+    }
+}
+PARAM_TRANSLATIONS = {
+    "en": {
+        "postcode": "Postcode",
+        "address": "Address",
+        "collection_zone": "Collection Zone",
+        "future_collection_dates": "Include Future Collection Dates",
+        "garden_waste_bin": "Has Garden Waste Bin",
+    }
+}
+
+ICON_MAP = {
+    "blue collection": Icons.RECYCLING,
+    "brown collection": Icons.ORGANIC,
+    "food collection": Icons.BIO_KITCHEN,
+    "food waste collection": Icons.BIO_KITCHEN,
+    "green collection": Icons.ORGANIC,
+    "grey collection": Icons.GENERAL_WASTE,
+}
+
+MAP_CONFIG_URL = "https://opus4.co.uk/api/v1/map-configs/{map_id}"
+ADDRESS_SEARCH_URL = "https://opus4.co.uk/api/v1/address-search"
+DEFAULT_CLIENT = "pendle"
+DEFAULT_CLIENT_ID = 5
+DEFAULT_MAP_ID = 3606
+DEFAULT_LANGUAGE = "en-GB"
+DEFAULT_WEEKS_AHEAD = 12
+_LOGGER = logging.getLogger(__name__)
+REQUEST_HEADERS = {
+    "User-Agent": (
+        "Mozilla/5.0 (X11; Linux x86_64; rv:128.0) Gecko/20100101 Firefox/128.0"
+    )
+}
+WEEKDAYS = {
+    "monday": 0,
+    "tuesday": 1,
+    "wednesday": 2,
+    "thursday": 3,
+    "friday": 4,
+    "saturday": 5,
+    "sunday": 6,
+}
+
+
+class Source:
+    def __init__(
+        self,
+        postcode: str,
+        address: str,
+        collection_zone: str | None = None,
+        garden_waste_bin: bool = False,
+        future_collection_dates: bool = False,
+    ):
+        if not postcode:
+            raise SourceArgumentRequired(
+                "postcode", "it is needed to look up Pendle addresses"
+            )
+        if not address:
+            raise SourceArgumentRequired(
+                "address", "it is needed to pick the correct Pendle property"
+            )
+
+        self._postcode = postcode
+        self._address = address
+        self._collection_zone = (
+            str(collection_zone).strip() if collection_zone else None
+        )
+        self._garden_waste_bin = garden_waste_bin
+        self._future_collection_dates = future_collection_dates
+        self._session = requests.Session()
+        self._session.headers.update(REQUEST_HEADERS)
+
+    @staticmethod
+    def _normalize(value: str | None) -> str:
+        if value is None:
+            return ""
+        return re.sub(r"[^A-Za-z0-9]", "", value).upper()
+
+    @staticmethod
+    def _parse_relative_date(value: str | None) -> datetime.date | None:
+        if not value:
+            return None
+
+        today = datetime.date.today()
+        text = value.strip().lower()
+
+        match = re.search(r"\(in (\d+) days?\)", text)
+        if match:
+            return today + datetime.timedelta(days=int(match.group(1)))
+
+        match = re.search(r"\bin (\d+) days?\b", text)
+        if match:
+            return today + datetime.timedelta(days=int(match.group(1)))
+
+        match = re.search(
+            r"\bin (\d+) weeks?\s+on\s+(monday|tuesday|wednesday|thursday|friday|saturday|sunday)\b",
+            text,
+        )
+        if match:
+            weeks = int(match.group(1))
+            target = WEEKDAYS[match.group(2)]
+            days_ahead = (target - today.weekday()) % 7
+            return today + datetime.timedelta(days=days_ahead, weeks=weeks)
+
+        match = re.search(r"\bin (\d+) weeks?\b", text)
+        if match:
+            return today + datetime.timedelta(weeks=int(match.group(1)))
+
+        if text == "today":
+            return today
+        if text == "tomorrow":
+            return today + datetime.timedelta(days=1)
+
+        match = re.search(
+            r"\bnext (monday|tuesday|wednesday|thursday|friday|saturday|sunday)\b",
+            text,
+        )
+        if match:
+            target = WEEKDAYS[match.group(1)]
+            days_ahead = (target - today.weekday()) % 7
+            if days_ahead == 0:
+                days_ahead = 7
+            return today + datetime.timedelta(days=days_ahead)
+
+        return None
+
+    @staticmethod
+    def _parse_start_date(value: str | None) -> datetime.date | None:
+        if not value:
+            return None
+        try:
+            return datetime.datetime.strptime(value.strip(), "%d %B, %Y").date()
+        except ValueError:
+            return None
+
+    @staticmethod
+    def _next_occurrence_from_anchor(
+        start_date: datetime.date | None, frequency_weeks: int | None
+    ) -> datetime.date | None:
+        if start_date is None:
+            return None
+
+        if not frequency_weeks or frequency_weeks < 1:
+            return start_date
+
+        today = datetime.date.today()
+        next_date = start_date
+        while next_date < today:
+            next_date += datetime.timedelta(weeks=frequency_weeks)
+        return next_date
+
+    @staticmethod
+    def _parse_weekday(value: str | None) -> int | None:
+        if not value:
+            return None
+        return WEEKDAYS.get(value.strip().lower())
+
+    def _resolve_next_collection_date(
+        self, item: dict[str, Any], title: str, frequency_weeks: int | None
+    ) -> datetime.date | None:
+        expected_date = self._next_occurrence_from_anchor(
+            self._parse_start_date(item.get("startDate")),
+            frequency_weeks,
+        )
+        actual_date = self._parse_relative_date(item.get("when"))
+        weekday = self._parse_weekday(item.get("day"))
+
+        if (
+            actual_date is not None
+            and weekday is not None
+            and actual_date.weekday() != weekday
+        ):
+            _LOGGER.warning(
+                "Pendle parsed when mismatch for %s: parsed %s but council day is %s. "
+                "Ignoring parsed date and falling back to schedule anchor.",
+                title,
+                actual_date.isoformat(),
+                item.get("day"),
+            )
+            actual_date = None
+
+        next_date = actual_date or expected_date
+        if next_date is None:
+            return None
+
+        if (
+            actual_date is not None
+            and expected_date is not None
+            and actual_date != expected_date
+        ):
+            _LOGGER.warning(
+                "Pendle schedule override for %s: expected %s from startDate/frequency, "
+                "but council when says %s. Using council date.",
+                title,
+                expected_date.isoformat(),
+                actual_date.isoformat(),
+            )
+
+        if weekday is not None and next_date.weekday() != weekday:
+            _LOGGER.warning(
+                "Pendle weekday mismatch for %s: resolved %s but council day is %s.",
+                title,
+                next_date.isoformat(),
+                item.get("day"),
+            )
+
+        return next_date
+
+    @staticmethod
+    def _get_icon(title: str) -> str | None:
+        key = title.strip().lower()
+        return ICON_MAP.get(key)
+
+    def _expand_optional_collections(self, title: str) -> list[str]:
+        titles = [title]
+        normalized = title.strip().lower()
+        if self._garden_waste_bin and normalized in {
+            "blue collection",
+            "brown collection",
+        }:
+            titles.append("Green Collection")
+        return titles
+
+    @staticmethod
+    def _expand_dates(
+        first_date: datetime.date, frequency_weeks: int | None
+    ) -> list[datetime.date]:
+        if not frequency_weeks or frequency_weeks < 1:
+            return [first_date]
+
+        dates = [first_date]
+        next_date = first_date
+        while True:
+            next_date = next_date + datetime.timedelta(weeks=frequency_weeks)
+            if (next_date - first_date).days > DEFAULT_WEEKS_AHEAD * 7:
+                break
+            dates.append(next_date)
+        return dates
+
+    def _get_map_config(self) -> dict[str, Any]:
+        response = self._session.get(
+            MAP_CONFIG_URL.format(map_id=DEFAULT_MAP_ID),
+            params={"c": DEFAULT_CLIENT_ID, "l": DEFAULT_LANGUAGE},
+            timeout=30,
+        )
+        response.raise_for_status()
+        return response.json()
+
+    def _lookup_addresses(self) -> list[dict[str, Any]]:
+        response = self._session.get(
+            ADDRESS_SEARCH_URL,
+            params={
+                "address": self._address,
+                "postcode": self._postcode,
+                "page": 1,
+                "size": 25,
+                "client": DEFAULT_CLIENT,
+            },
+            timeout=30,
+        )
+        response.raise_for_status()
+        payload = response.json()
+
+        addresses = payload.get("Results", {}).get("Addresses", {}).get("Address")
+        if addresses is None:
+            raise SourceArgumentNotFound(
+                "postcode",
+                self._postcode,
+                "Pendle did not return any matching addresses",
+            )
+
+        if isinstance(addresses, dict):
+            return [addresses]
+        return list(addresses)
+
+    def _select_address(self, addresses: list[dict[str, Any]]) -> dict[str, Any]:
+        expected = self._normalize(self._address)
+        exact = [
+            item
+            for item in addresses
+            if self._normalize(item.get("FullAddress")) == expected
+        ]
+        if len(exact) == 1:
+            return exact[0]
+        if len(exact) > 1:
+            raise SourceArgAmbiguousWithSuggestions(
+                "address",
+                self._address,
+                [item.get("FullAddress") for item in exact],
+            )
+
+        matches = [
+            item
+            for item in addresses
+            if expected in self._normalize(item.get("FullAddress"))
+        ]
+        if len(matches) == 1:
+            return matches[0]
+        if len(matches) > 1:
+            raise SourceArgAmbiguousWithSuggestions(
+                "address",
+                self._address,
+                [item.get("FullAddress") for item in matches],
+            )
+
+        raise SourceArgumentNotFound(
+            "address",
+            self._address,
+            "no Pendle address matched that text within the postcode",
+        )
+
+    def _select_zone(self, collections: list[dict[str, Any]]) -> list[dict[str, Any]]:
+        locations = sorted(
+            {
+                str(item.get("location")).strip()
+                for item in collections
+                if item.get("location") is not None
+                and str(item.get("location")).strip()
+            }
+        )
+        if len(locations) <= 1:
+            return collections
+
+        if self._collection_zone:
+            selected = [
+                item
+                for item in collections
+                if str(item.get("location", "")).strip() == self._collection_zone
+            ]
+            if selected:
+                return selected
+            raise SourceArgumentNotFound(
+                "collection_zone",
+                self._collection_zone,
+                "Pendle did not return that collection zone for the selected address",
+            )
+
+        raise SourceArgAmbiguousWithSuggestions(
+            "collection_zone",
+            "multiple Pendle collection zones were returned for this address",
+            locations,
+        )
+
+    def _fetch_collections(
+        self, x: float, y: float, wms_url: str, layer_id: str
+    ) -> list[dict[str, Any]]:
+        for buffer_size in (500, 1000, 1500):
+            response = self._session.get(
+                wms_url,
+                params={
+                    "service": "WMS",
+                    "version": "1.1.1",
+                    "request": "GetFeatureInfo",
+                    "layers": "none",
+                    "styles": "",
+                    "srs": "EPSG:27700",
+                    "bbox": f"{x - buffer_size},{y - buffer_size},{x + buffer_size},{y + buffer_size}",
+                    "width": 256,
+                    "height": 256,
+                    "query_layers": layer_id,
+                    "info_format": "application/json",
+                    "x": 128,
+                    "y": 128,
+                },
+                timeout=30,
+            )
+            response.raise_for_status()
+            data = response.json()
+            if data:
+                return list(data)
+
+        return []
+
+    def fetch(self) -> list[Collection]:
+        map_config = self._get_map_config()
+        addresses = self._lookup_addresses()
+        selected_address = self._select_address(addresses)
+
+        layer_groups = map_config.get("legend", {}).get("layerGroups", [])
+        layers = layer_groups[0].get("layers", []) if layer_groups else []
+        layer_id = layers[0].get("id") if layers else None
+        wms_url = map_config.get("doubleClick", {}).get("url")
+
+        if not layer_id or not wms_url:
+            raise SourceArgumentException(
+                "address", "Pendle map configuration is missing the query layer details"
+            )
+
+        collections = self._fetch_collections(
+            float(selected_address["X"]),
+            float(selected_address["Y"]),
+            wms_url,
+            layer_id,
+        )
+        collections = self._select_zone(collections)
+
+        if not collections:
+            raise SourceArgumentNotFound("address", self._address)
+
+        entries: list[Collection] = []
+        for item in collections:
+            title = item.get("title", "Collection")
+            frequency_weeks = item.get("frequency")
+            next_date = self._resolve_next_collection_date(
+                item,
+                title,
+                frequency_weeks,
+            )
+            if next_date is None:
+                continue
+
+            if self._future_collection_dates:
+                collection_dates = self._expand_dates(next_date, frequency_weeks)
+            else:
+                collection_dates = [next_date]
+            for collection_date in collection_dates:
+                for expanded_title in self._expand_optional_collections(title):
+                    entries.append(
+                        Collection(
+                            date=collection_date,
+                            t=expanded_title,
+                            icon=self._get_icon(expanded_title),
+                        )
+                    )
+
+        entries.sort(key=lambda item: (item.date, item.type))
+        return entries

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

@@ -0,0 +1,148 @@
+import datetime
+import re
+
+import requests
+from bs4 import BeautifulSoup
+from bs4.element import Tag
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import SourceArgumentNotFoundWithSuggestions
+
+TITLE = "Marktgemeinde Pernitz"
+DESCRIPTION = "Source for Marktgemeinde Pernitz, Austria."
+URL = "https://www.pernitz.gv.at"
+COUNTRY = "at"
+SOURCE_CODEOWNERS = ["@bbr111"]
+
+TEST_CASES: dict[str, dict] = {
+    "Rayon 1": {"rayon": 1},
+    "Rayon 2": {"rayon": 2},
+}
+
+ICON_MAP = {
+    "Restmüll": Icons.GENERAL_WASTE,
+    "Biotonne": Icons.ORGANIC,
+    "Gelber Sack": Icons.PLASTIC_PACKAGING,
+    "Gelber Container": Icons.PLASTIC_PACKAGING,
+    "Papier": Icons.PAPER,
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "rayon": "Rayon (collection zone)",
+    },
+    "de": {
+        "rayon": "Rayon (Abfuhrbezirk)",
+    },
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "rayon": "The general waste (Restmüll) collection zone, 1 or 2, that your street belongs to. "
+        "See the street list at https://www.pernitz.gv.at/muellabfuhr/ to determine your zone.",
+    },
+    "de": {
+        "rayon": "Der Restmüll-Abfuhrbezirk (Rayon), 1 oder 2, zu dem Ihre Straße gehört. "
+        "Die Straßenliste finden Sie unter https://www.pernitz.gv.at/muellabfuhr/.",
+    },
+}
+
+API_URL = "https://www.pernitz.gv.at/muellabfuhr/"
+
+DATE_REGEX = re.compile(r"(\d{1,2})\.\s*(\d{1,2})\.\s*(\d{4})")
+
+# Number of upcoming months to generate for collections that are only
+# announced as a recurring rule (e.g. "every 1st Saturday of the month")
+# instead of an explicit list of dates.
+_RECURRING_MONTHS_AHEAD = 18
+
+
+class Source:
+    def __init__(self, rayon: int):
+        rayon = int(rayon)
+        if rayon not in (1, 2):
+            raise SourceArgumentNotFoundWithSuggestions("rayon", rayon, [1, 2])
+        self._rayon = rayon
+
+    def fetch(self) -> list[Collection]:
+        r = requests.get(API_URL, timeout=30)
+        r.raise_for_status()
+        soup = BeautifulSoup(r.text, "html.parser")
+
+        accordion_items = soup.find_all("div", class_="wp-block-advgb-accordion-item")
+        sections: dict[str, Tag] = {}
+        for item in accordion_items:
+            header_el = item.find("h4", class_="advgb-accordion-header-title")
+            if header_el is None:
+                continue
+            header = header_el.get_text(strip=True)
+            sections[header] = item
+
+        entries: list[Collection] = []
+
+        entries += self._parse_date_table(
+            sections.get(f"Restmüll Rayon {self._rayon}"), "Restmüll"
+        )
+        entries += self._parse_date_table(sections.get("Biotonne"), "Biotonne")
+        entries += self._parse_date_table(sections.get("Gelber Sack"), "Gelber Sack")
+        entries += self._parse_date_table(
+            sections.get("Gelber Container"), "Gelber Container"
+        )
+
+        # Paper collection is only published as a recurring rule ("every 1st
+        # Saturday of the month"), not as a list of explicit dates.
+        entries += self._first_weekday_of_month_series(
+            "Papier",
+            weekday=5,  # Saturday
+        )
+
+        return entries
+
+    @staticmethod
+    def _parse_date_table(item: Tag | None, waste_type: str) -> list[Collection]:
+        collections: list[Collection] = []
+        if item is None:
+            return collections
+        table = item.find("table")
+        if table is None:
+            return collections
+        for row in table.find_all("tr"):
+            cells = row.find_all("td")
+            if not cells:
+                continue
+            row_text = " ".join(cell.get_text(strip=True) for cell in cells)
+            match = DATE_REGEX.search(row_text)
+            if not match:
+                continue
+            day, month, year = (int(group) for group in match.groups())
+            try:
+                date = datetime.date(year, month, day)
+            except ValueError:
+                continue
+            collections.append(
+                Collection(date=date, t=waste_type, icon=ICON_MAP.get(waste_type))
+            )
+        return collections
+
+    @staticmethod
+    def _first_weekday_of_month_series(
+        waste_type: str, weekday: int
+    ) -> list[Collection]:
+        collections: list[Collection] = []
+        today = datetime.date.today()
+        year, month = today.year, today.month
+        for _ in range(_RECURRING_MONTHS_AHEAD):
+            first_day = datetime.date(year, month, 1)
+            days_ahead = (weekday - first_day.weekday()) % 7
+            collection_date = first_day + datetime.timedelta(days=days_ahead)
+            collections.append(
+                Collection(
+                    date=collection_date,
+                    t=waste_type,
+                    icon=ICON_MAP.get(waste_type),
+                )
+            )
+            month += 1
+            if month > 12:
+                month = 1
+                year += 1
+        return collections

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

@@ -0,0 +1,56 @@
+import requests
+from waste_collection_schedule import Collection, Icons
+from waste_collection_schedule.exceptions import SourceArgumentNotFound
+from waste_collection_schedule.service.ICS import ICS
+
+TITLE = "Peterborough City Council"
+DESCRIPTION = "Source for peterborough.gov.uk services for Peterborough"
+URL = "https://peterborough.gov.uk"
+TEST_CASES = {
+    "houseUprn": {"post_code": "PE57AX", "uprn": "100090214774"},
+}
+
+API_URLS = {
+    "collection": "https://report.peterborough.gov.uk/waste/{post_code}:{uprn}/calendar.ics",
+}
+
+ICON_MAP = {
+    "Empty Bin 240L Black": Icons.GENERAL_WASTE,
+    "Empty Bin 240L Green": Icons.RECYCLING,
+    "Empty Bin 240L Brown": Icons.ORGANIC,
+}
+
+
+class Source:
+    def __init__(self, post_code, uprn):
+        self._post_code = post_code
+        self._uprn = uprn
+        self._ics = ICS()
+
+    def fetch(self):
+        if not self._post_code:
+            raise SourceArgumentNotFound("post_code", "Postcode is required")
+
+        if not self._uprn:
+            raise SourceArgumentNotFound("uprn", "UPRN is required")
+
+        ics_url = API_URLS["collection"].format(
+            post_code=self._post_code, uprn=self._uprn
+        )
+        r = requests.get(ics_url, timeout=10)
+        r.raise_for_status()
+
+        dates = self._ics.convert(r.text)
+
+        entries = []
+        for item in dates:
+            bin_type = item[1]
+            entries.append(
+                Collection(
+                    date=item[0],
+                    t=bin_type,
+                    icon=ICON_MAP.get(bin_type),
+                )
+            )
+
+        return entries