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

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

@@ -0,0 +1,81 @@
+import datetime
+import time
+
+import requests
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.service.AchieveForms import init_session, run_lookup
+
+TITLE = "Stevenage Borough Council"
+DESCRIPTION = "Source for Stevenage."
+URL = "https://www.stevenage.gov.uk/"
+TEST_CASES = {
+    "Chepstow Close": {"uprn": "100080879233"},
+    "Rectory Lane": {"uprn": "100081137566"},
+    "Neptune Gate": {"uprn": "200000585910"},
+}
+
+ICON_MAP = {
+    "general waste": Icons.GENERAL_WASTE,
+    "recycling": Icons.RECYCLING,
+}
+
+BASE_URL = "https://stevenage-self.achieveservice.com"
+INITIAL_URL = f"{BASE_URL}/en/service/Check_your_household_bin_collection_days"
+AUTH_URL = f"{BASE_URL}/authapi/isauthenticated"
+TOKEN_URL = f"{BASE_URL}/apibroker/runLookup?id=5e55337a540d4"
+API_URL = f"{BASE_URL}/apibroker/runLookup"
+LOOKUP_ID = "64ba8cee353e6"
+HOSTNAME = "stevenage-self.achieveservice.com"
+
+
+class Source:
+    def __init__(self, uprn):
+        self._uprn = str(uprn)
+
+    def fetch(self):
+        session = requests.Session()
+        sid = init_session(session, INITIAL_URL, AUTH_URL, HOSTNAME)
+
+        # Stevenage-specific: GET a one-time token before the main lookup
+        t = session.get(TOKEN_URL)
+        t.raise_for_status()
+        token = t.json()["integration"]["transformed"]["rows_data"]["0"]["token"]
+
+        form_values = {
+            "Section 1": {
+                "token": {"value": token},
+                "LLPGUPRN": {"value": self._uprn},
+                "MinimumDateLookAhead": {"value": time.strftime("%Y-%m-%d")},
+                "MaximumDateLookAhead": {
+                    "value": str(int(time.strftime("%Y")) + 1)
+                    + time.strftime("-%m-%d"),
+                },
+            }
+        }
+
+        result = run_lookup(session, API_URL, sid, LOOKUP_ID, form_values)
+        rows_data = result["integration"]["transformed"]["rows_data"]
+        if not isinstance(rows_data, dict):
+            raise ValueError("Invalid data returned from API")
+
+        entries = []
+        for key in rows_data:
+            value = rows_data[key]
+            bin_type = value["bintype"].strip()
+
+            try:
+                date = datetime.datetime.strptime(
+                    value["collectiondate"], "%A %d %B %Y"
+                ).date()
+            except ValueError:
+                continue
+
+            entries.append(
+                Collection(
+                    date=date,
+                    t=bin_type,
+                    icon=ICON_MAP.get(bin_type.lower()),
+                )
+            )
+
+        return entries

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

@@ -0,0 +1,70 @@
+from typing import ClassVar
+
+from waste_collection_schedule import Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.service.RiSKommunalAT import RiSKommunalSource
+
+TITLE = "Stadtbetriebe Steyr GmbH"
+DESCRIPTION = "Source for Stadtbetriebe Steyr GmbH waste collection schedule."
+URL = "https://www.steyr.at"
+COUNTRY = "at"
+
+SOURCE_CODEOWNERS = ["@bbr111"]
+
+TEST_CASES = {
+    "Wolfernstraße 7": {
+        "strasse": "Wolfernstraße",
+        "hausnummer": "7",
+    },
+    "Aichetgasse 1": {
+        "strasse": "Aichetgasse",
+        "hausnummer": "1",
+    },
+}
+
+ICON_MAP = {
+    "Restabfall": Icons.GENERAL_WASTE,
+    "Bioabfall": Icons.ORGANIC,
+    "Altpapier": Icons.PAPER,
+    "Gelber Sack": Icons.PLASTIC_PACKAGING,
+    "Altglas": Icons.GLASS,
+    "Problemstoff": Icons.HAZARDOUS,
+    "Sperrmüll": Icons.BULKY,
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "strasse": "Street",
+        "hausnummer": "House number",
+    },
+    "de": {
+        "strasse": "Straße",
+        "hausnummer": "Hausnummer",
+    },
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "strasse": "Street name as listed in the Steyr waste calendar.",
+        "hausnummer": "House number as listed in the Steyr waste calendar.",
+    },
+    "de": {
+        "strasse": "Straßenname wie im Steyrer Abfallkalender aufgelistet.",
+        "hausnummer": "Hausnummer wie im Steyrer Abfallkalender aufgelistet.",
+    },
+}
+
+
+class Source(RiSKommunalSource):
+    BASE_URL = "https://www.steyr.at"
+    ICON_MAP = ICON_MAP
+    SELECTION_URL = (
+        "https://www.steyr.at/system/web/kalender.aspx?sprache=1&menuonr=227376864"
+    )
+    RAISE_ON_EMPTY = True
+    QUERY_PARAMS: ClassVar = {
+        "sprache": "1",
+        "menuonr": "227376864",
+    }
+
+    def __init__(self, strasse: str, hausnummer: str | int):
+        super().__init__(strasse=strasse, hausnummer=hausnummer)

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

@@ -0,0 +1,117 @@
+from datetime import date, timedelta
+
+import requests
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import (
+    SourceArgAmbiguousWithSuggestions,
+    SourceArgumentNotFound,
+)
+
+TITLE = "Stirling Council"
+DESCRIPTION = "Source for Stirling Council waste collection services."
+URL = "https://www.stirling.gov.uk/"
+COUNTRY = "uk"
+TEST_CASES = {
+    "Kildean Road 38": {"address": "38 Kildean Road"},
+    "Merlo Buchanan Castle Estate": {"address": "Merlo"},
+}
+
+# Stirling Council uses Routeware's ReCollect platform (area "StirlingUK").
+# The address lookup and collection events are provided by the ReCollect API.
+API_BASE = "https://api.eu.recollect.net/api"
+AREA_URL = f"{API_BASE}/areas/StirlingUK/services/waste"
+
+# Waste types returned by Stirling's ReCollect service (flag name -> icon).
+ICON_MAP = {
+    "REFUSE": Icons.GENERAL_WASTE,
+    "GARDEN": Icons.ORGANIC,
+    "RECYCLING": Icons.PAPER,
+    "PLASTIC": Icons.RECYCLING,
+    "GLASS": Icons.GLASS,
+}
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": "Visit https://www.stirling.gov.uk/bins-and-recycling/bin-collection-dates-search/ and type your address into the search to see the exact wording, then use the same here. House number and street (e.g. '38 Kildean Road'), property name (e.g. 'Merlo'), or a single-dwelling postcode work.",
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "address": "Your address as entered on the Stirling Council bin collection dates search (house number and street, property name, or single-dwelling postcode)",
+    },
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {"address": "Address"},
+}
+
+SOURCE_CODEOWNERS = ["@nagug"]
+
+
+class Source:
+    def __init__(self, address: str):
+        self._address = address
+
+    def _resolve_place_id(self) -> str:
+        """Resolve the configured address to a ReCollect place ID."""
+        response = requests.get(
+            f"{AREA_URL}/address-suggest",
+            params={"q": self._address, "locale": "en-GB"},
+            timeout=30,
+        )
+        response.raise_for_status()
+        suggestions = response.json()
+
+        if not suggestions:
+            raise SourceArgumentNotFound("address", self._address)
+
+        if len(suggestions) > 1:
+            raise SourceArgAmbiguousWithSuggestions(
+                "address", self._address, [s["name"] for s in suggestions]
+            )
+
+        suggestion = suggestions[0]
+        if suggestion.get("type") != "parcel" or "place_id" not in suggestion:
+            # Multi-dwelling postcodes return a "place_qualifier" which needs a
+            # more specific address to resolve to a single property.
+            raise SourceArgumentNotFound(
+                "address",
+                self._address,
+                "this looks like a multi-dwelling postcode, please add your house number or property name.",
+            )
+        return suggestion["place_id"]
+
+    def fetch(self) -> list[Collection]:
+        place_id = self._resolve_place_id()
+
+        response = requests.get(
+            f"{API_BASE}/places/{place_id}/services/waste/events",
+            params={
+                "hide": "reminder_only",
+                "after": (date.today() - timedelta(days=30)).isoformat(),
+                "before": (date.today() + timedelta(days=365)).isoformat(),
+                "locale": "en-GB",
+            },
+            timeout=30,
+        )
+        response.raise_for_status()
+        events = response.json().get("events", [])
+
+        entries: list[Collection] = []
+        for event in events:
+            collection_date = date.fromisoformat(event["day"])
+            for flag in event.get("flags", []):
+                # Skip non-pickup flags (e.g. holiday notices) so they don't
+                # surface as bogus collection types.
+                if flag.get("event_type") != "pickup":
+                    continue
+                waste_type = flag.get("subject") or flag.get("name")
+                if not waste_type:
+                    continue
+                entries.append(
+                    Collection(
+                        date=collection_date,
+                        t=waste_type,
+                        icon=ICON_MAP.get(flag.get("name")),
+                    )
+                )
+        return entries

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

@@ -0,0 +1,127 @@
+import logging
+
+import requests
+from dateutil import parser
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import SourceArgumentNotFound
+from waste_collection_schedule.service.ArcGis import ArcGisGeocodeError, geocode
+
+_LOGGER = logging.getLogger(__name__)
+
+TITLE = "Stirling"
+DESCRIPTION = "Source for Stirling."
+URL = "https://www.stirling.wa.gov.au"
+TEST_CASES = {
+    "by_address": {"address": "100 Cedric Street, Stirling, WA, Australia"},
+    "by_coords": {"lat": -31.9034183, "lon": 115.8320855},
+    "by_coords_str": {"lat": "-31.8783052", "lon": "115.8157741"},
+}
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": "Enter your street address including suburb "
+    "(e.g. '100 Cedric Street, Stirling, WA, Australia'), "
+    "or provide latitude and longitude coordinates.",
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "address": "Street address with suburb (e.g. '100 Cedric Street, Stirling, WA, Australia')",
+        "lat": "Latitude (optional if address is provided)",
+        "lon": "Longitude (optional if address is provided)",
+    },
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "address": "Street Address",
+        "lat": "Latitude",
+        "lon": "Longitude",
+    },
+}
+
+SOURCE_CODEOWNERS = ["@markvp"]
+
+ICON_MAP = {
+    "red": Icons.GENERAL_WASTE,
+    "green": Icons.ORGANIC,
+    "greenverge": Icons.CHRISTMAS_TREE,
+    "yellow": Icons.RECYCLING,
+}
+
+API_PATH = "/bincollectioncheck/getresult"
+REFERER_PATH = "/waste-and-environment/waste-and-recycling/bin-collections"
+
+
+class Source:
+    def __init__(
+        self,
+        address: str | None = None,
+        lat: float | None = None,
+        lon: float | None = None,
+    ):
+        self._address = address
+        self._lat = float(lat) if lat is not None else None
+        self._lon = float(lon) if lon is not None else None
+
+        if not self._address and (self._lat is None or self._lon is None):
+            raise ValueError(
+                "Either 'address' or both 'lat' and 'lon' must be provided"
+            )
+
+    def _resolve_coordinates(self) -> tuple[float, float]:
+        """Return (lat, lon), geocoding from address if needed."""
+        if self._lat is not None and self._lon is not None:
+            return self._lat, self._lon
+
+        try:
+            location = geocode(self._address)
+        except ArcGisGeocodeError as e:
+            raise SourceArgumentNotFound("address", self._address) from e
+
+        return location["y"], location["x"]
+
+    def fetch(self) -> list[Collection]:
+        lat, lon = self._resolve_coordinates()
+
+        headers = {
+            "Accept": "application/json, text/javascript, */*; q=0.01",
+            "configid": "7c833520-7b62-4228-8522-fb1a220b32e8",
+            "form": "57753bab-f589-44d7-8934-098b6d5c572f",
+            "fields": f"{lon},{lat}",
+            "apikeylookup": "Bin Day",
+            "Origin": URL,
+            "Referer": f"{URL}{REFERER_PATH}",
+        }
+        r = requests.get(f"{URL}{API_PATH}", headers=headers)
+        r.raise_for_status()
+
+        data = r.json()
+        entries = []
+        for collection in data:
+            bin_type = None
+            bin_date_str = None
+            bin_date = None
+
+            for arg in collection:
+                if arg.get("name") == "type":
+                    bin_type = arg.get("value")
+                if arg.get("name") == "date":
+                    bin_date_str = arg.get("value")
+                    if not isinstance(bin_date_str, str):
+                        continue
+                    bin_date_str = bin_date_str.replace("  ", " ").strip()
+                    try:
+                        # Aug  7 2024
+                        bin_date = parser.parse(bin_date_str).date()
+                    except ValueError:
+                        _LOGGER.warning("Could not parse date %s", bin_date_str)
+
+            if bin_date is None:
+                _LOGGER.warning("Could not find date for collection %s", bin_type)
+                continue
+            if bin_type is None:
+                _LOGGER.warning("Skipping invalid collection record")
+                continue
+            icon = ICON_MAP.get(bin_type.lower())  # Collection icon
+            entries.append(Collection(date=bin_date, t=bin_type, icon=icon))
+        return entries

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

@@ -0,0 +1,254 @@
+"""Source for STKH Sopron és Térsége Nonprofit Kft., Hungary."""
+
+import re
+import unicodedata
+from dataclasses import dataclass, field
+from datetime import date, timedelta
+from io import BytesIO
+
+import requests
+from bs4 import BeautifulSoup
+from pypdf import PdfReader
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import SourceArgumentNotFoundWithSuggestions
+
+TITLE = "STKH Sopron és Térsége Nonprofit Kft."
+DESCRIPTION = "Source script for stkh.hu"
+URL = "https://stkh.hu"
+COUNTRY = "hu"
+
+TEST_CASES = {
+    "Újkér": {"municipality": "Újkér"},
+    "Fertőd": {"municipality": "Fertőd"},
+    "Zsira": {"municipality": "Zsira"},
+}
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": "Open https://stkh.hu and look for your settlement in the waste calendar list on the home page. Use the settlement name exactly as it is shown there, for example 'Újkér'. Accents, spaces and capitalisation are ignored when matching.",
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {"municipality": "Settlement"},
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {"municipality": "Name of the settlement as listed on stkh.hu"},
+}
+
+ICON_MAP = {
+    "Szelektív": Icons.RECYCLING,
+    "Zöldhulladék": Icons.GARDEN,
+    "Vegyes": Icons.GENERAL_WASTE,
+}
+
+HOMEPAGE_URL = "https://stkh.hu/"
+HEADERS = {
+    "User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0 Safari/537.36"
+}
+
+# Single-page settlement calendars look like ".../9472_Ujker_Hulladeknaptar2026.pdf".
+# The leading number is a postcode, but it is not unique per settlement, so it is
+# deliberately not used for the lookup.
+PDF_LINK_PATTERN = re.compile(
+    r"/\d{4}_([^/]+)_Hulladeknaptar(\d{4})\.pdf$", re.IGNORECASE
+)
+UPLOAD_PATH_PATTERN = re.compile(r"/uploads/(\d{4})/(\d{2})/")
+YEAR_PATTERN = re.compile(r"(\d{4})\.\s*évi")
+DATE_PATTERN = re.compile(r"\b(\d{2})\.(\d{2})\.")
+MIXED_DAY_PATTERN = re.compile(r"Vegyes hulladékgyűjtési nap:([^\n]*)")
+
+# Everything after this word is prose that contains stray numbers.
+TABLE_END_MARKER = "Kérjük"
+
+# Row labels of the collection table, mapped to the waste type reported by this source.
+WASTE_TYPES = {
+    "szelektív": "Szelektív",
+    "zöldhulladék": "Zöldhulladék",
+}
+MIXED_WASTE_TYPE = "Vegyes"
+
+MONTHS = {
+    "januar": 1,
+    "februar": 2,
+    "marcius": 3,
+    "aprilis": 4,
+    "majus": 5,
+    "junius": 6,
+    "julius": 7,
+    "augusztus": 8,
+    "szeptember": 9,
+    "oktober": 10,
+    "november": 11,
+    "december": 12,
+}
+
+WEEKDAYS = {
+    "hetfo": 0,
+    "kedd": 1,
+    "szerda": 2,
+    "csutortok": 3,
+    "pentek": 4,
+    "szombat": 5,
+    "vasarnap": 6,
+}
+
+
+def normalize(value: str) -> str:
+    """Fold a name to lowercase ASCII letters and digits only.
+
+    Makes matching tolerant of accents, casing, spaces and hyphens, which differ
+    between the link labels, the PDF file names and user input.
+    """
+    decomposed = unicodedata.normalize("NFKD", value)
+    stripped = "".join(c for c in decomposed if not unicodedata.combining(c))
+    return re.sub(r"[^a-z0-9]+", "", stripped.lower())
+
+
+@dataclass
+class Calendar:
+    """One edition of a settlement's waste calendar PDF."""
+
+    year: int
+    months: set = field(default_factory=set)
+    dates: dict = field(default_factory=dict)
+    weekday: int = -1
+
+
+def extract_text(content: bytes) -> str:
+    """Extract the full text of a calendar PDF."""
+    reader = PdfReader(BytesIO(content))
+    return "".join(page.extract_text() or "" for page in reader.pages)
+
+
+def parse_calendar(text: str):
+    """Parse a single calendar PDF into a Calendar, or None if unusable."""
+    year_match = YEAR_PATTERN.search(text)
+    if not year_match:
+        return None
+    calendar = Calendar(year=int(year_match.group(1)))
+
+    table = text.split(TABLE_END_MARKER)[0]
+    lowered = table.lower()
+
+    # Locate the row label of every waste type present in this edition.
+    positions = []
+    for label, waste_type in WASTE_TYPES.items():
+        index = lowered.find(label)
+        if index >= 0:
+            positions.append((index, waste_type))
+    positions.sort()
+
+    # The table header, in front of the first row label, lists the covered months.
+    header = normalize(table[: positions[0][0]] if positions else table)
+    calendar.months = {number for name, number in MONTHS.items() if name in header}
+    if not calendar.months:
+        calendar.months = set(range(1, 13))
+
+    for i, (start, waste_type) in enumerate(positions):
+        end = positions[i + 1][0] if i + 1 < len(positions) else len(table)
+        days = set()
+        for month, day in DATE_PATTERN.findall(table[start:end]):
+            try:
+                date(calendar.year, int(month), int(day))
+            except ValueError:
+                continue
+            days.add((int(month), int(day)))
+        calendar.dates[waste_type] = days
+
+    # Mixed waste is published as a weekday rather than as a list of dates. Some
+    # settlements say "körzetbeosztás szerint" (by district) instead; skip those.
+    mixed_match = MIXED_DAY_PATTERN.search(text)
+    if mixed_match:
+        calendar.weekday = WEEKDAYS.get(normalize(mixed_match.group(1)), -1)
+
+    return calendar
+
+
+def edition_order(href: str):
+    """Sort key that puts older editions of a calendar first.
+
+    The upload folder (/uploads/YYYY/MM/) tells which edition is newer, which
+    matters because a later edition supersedes the earlier one for the months it
+    covers (collection days do get changed mid-year).
+    """
+    match = UPLOAD_PATH_PATTERN.search(href)
+    if not match:
+        return (0, 0)
+    return (int(match.group(1)), int(match.group(2)))
+
+
+class Source:
+    def __init__(self, municipality: str):
+        self._municipality: str = municipality
+
+    def fetch(self) -> list[Collection]:
+        session = requests.Session()
+        session.headers.update(HEADERS)
+
+        response = session.get(HOMEPAGE_URL, timeout=30)
+        response.raise_for_status()
+        soup = BeautifulSoup(response.text, "html.parser")
+
+        # Index every settlement calendar linked from the home page, which always
+        # points at the current editions. Both the file name stem and the link
+        # label are indexed, because they occasionally disagree (typos).
+        links: dict = {}
+        names: set = set()
+        for anchor in soup.select("a.hn.sor"):
+            href = anchor.get("href") or ""
+            match = PDF_LINK_PATTERN.search(href)
+            if not match:
+                # Per-street PDFs of the larger towns and district calendars use a
+                # different layout and are not supported.
+                continue
+            label = anchor.get_text(strip=True)
+            names.add(label or match.group(1))
+            for key in {normalize(match.group(1)), normalize(label)}:
+                if not key:
+                    continue
+                hrefs = links.setdefault(key, [])
+                if href not in hrefs:
+                    hrefs.append(href)
+
+        key = normalize(self._municipality)
+        if key not in links:
+            raise SourceArgumentNotFoundWithSuggestions(
+                "municipality", self._municipality, sorted(names)
+            )
+
+        # A settlement normally has two editions (first and second half of the
+        # year). They are not interchangeable: one may cover only part of the
+        # year, and a newer one may change the collection days.
+        editions = []
+        for href in sorted(links[key], key=edition_order):
+            pdf = session.get(href, timeout=60)
+            pdf.raise_for_status()
+            calendar = parse_calendar(extract_text(pdf.content))
+            if calendar:
+                editions.append(calendar)
+
+        # Resolve every calendar month to the newest edition covering it.
+        resolved: dict = {}
+        for calendar in editions:
+            for month in calendar.months:
+                resolved[(calendar.year, month)] = calendar
+
+        collections: set = set()
+        for (year, month), calendar in resolved.items():
+            for waste_type, days in calendar.dates.items():
+                for day_month, day in days:
+                    if day_month != month:
+                        continue
+                    collections.add((date(year, month, day), waste_type))
+
+            if calendar.weekday >= 0:
+                day = date(year, month, 1)
+                day += timedelta(days=(calendar.weekday - day.weekday()) % 7)
+                while day.month == month:
+                    collections.add((day, MIXED_WASTE_TYPE))
+                    day += timedelta(days=7)
+
+        return [
+            Collection(date=day, t=waste_type, icon=ICON_MAP.get(waste_type))
+            for day, waste_type in sorted(collections)
+        ]