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

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

@@ -0,0 +1,243 @@
+import re
+import xml.etree.ElementTree as ET
+import zipfile
+from datetime import date, timedelta
+from io import BytesIO
+
+import requests
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import (
+    SourceArgumentNotFoundWithSuggestions,
+    SourceArgumentRequired,
+)
+
+TITLE = "Amberg"
+DESCRIPTION = "Source for the city of Amberg (Bavaria), Germany."
+URL = "https://www.amberg.de"
+COUNTRY = "de"
+
+TEST_CASES = {
+    "Street: Adalbert-Stifter-Str. (zone A1)": {"street": "Adalbert-Stifter-Str."},
+    "Zone: C4 direct": {"zone": "C4"},
+    "Street: Barbarastr. (zone B2)": {"street": "Barbarastr."},
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {"street": "Street", "zone": "Zone"},
+    "de": {"street": "Straße", "zone": "Abfuhrgebiet"},
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "street": "Street name as it appears in the city's street directory (e.g. Adalbert-Stifter-Str.). Either street or zone must be provided.",
+        "zone": "Zone code (e.g. A1, C4). Either street or zone must be provided.",
+    },
+    "de": {
+        "street": "Straßenname wie im Strassenverzeichnis der Stadt (z. B. Adalbert-Stifter-Str.). Entweder Straße oder Abfuhrgebiet muss angegeben werden.",
+        "zone": "Abfuhrgebiet (z. B. A1, C4). Entweder Straße oder Abfuhrgebiet muss angegeben werden.",
+    },
+}
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": "Visit https://amberg.de/abfallberatung/abfuhrkalender-2026, look up your street in the table, and note the zone code (e.g. A1). You can then use either the street name or the zone code directly.",
+    "de": "Besuchen Sie https://amberg.de/abfallberatung/abfuhrkalender-2026, suchen Sie Ihre Straße in der Tabelle, und notieren Sie das Abfuhrgebiet (z. B. A1). Sie können dann entweder den Straßennamen oder das Abfuhrgebiet direkt verwenden.",
+}
+
+ICON_MAP = {
+    "Rest- und Biomüll": Icons.BIO_KITCHEN,
+    "Papiertonne": Icons.PAPER,
+    "Gelber Sack": Icons.PLASTIC_PACKAGING,
+    "Sperrmüll": Icons.BULKY,
+    "Häckselgut": Icons.GARDEN,
+    "Problemmüll": Icons.HAZARDOUS,
+}
+
+# All valid zone codes (letter A–E, sub-number 1–4)
+VALID_ZONES = [
+    f"{letter}{num}"
+    for letter in ("A", "B", "C", "D", "E")
+    for num in ("1", "2", "3", "4")
+]
+
+# Mapping of Dateneingabe column index to waste type name
+# Col F (idx 5) = Rest, Col G (idx 6) = Bio (same bin as Rest, skip)
+# Col H (idx 7) = Papiertonne, Col I (idx 8) = Gelber Sack
+# Col J (idx 9) = Problemmüll, Col K (idx 10) = Häckselgut, Col L (idx 11) = Sperrmüll
+WASTE_COLUMNS = {
+    5: "Rest- und Biomüll",
+    7: "Papiertonne",
+    8: "Gelber Sack",
+    9: "Problemmüll",
+    10: "Häckselgut",
+    11: "Sperrmüll",
+}
+
+# Excel serial date epoch
+_EXCEL_EPOCH = date(1899, 12, 30)
+
+# Base URL for Abfallberatung page (used for year discovery)
+_ABFALL_PAGE = "https://amberg.de/abfallberatung/"
+# URL templates
+_STREET_DIR_URL = "https://amberg.de/fileadmin/Abfallberatung/Abfuhrkalender/{year}/ICS/{year}_Strassenverzeichnis.json"
+_XLSX_URL = "https://amberg.de/fileadmin/Abfallberatung/Abfuhrkalender/{year}/ICS/Abfuhrkalender_{year}_Online{zone}.xlsx"
+
+
+def _discover_year() -> str:
+    """Discover the current Abfuhrkalender year from the Abfallberatung overview page."""
+    response = requests.get(_ABFALL_PAGE, timeout=30)
+    response.raise_for_status()
+    match = re.search(r"/abfallberatung/abfuhrkalender-(\d{4})", response.text)
+    if match:
+        return match.group(1)
+    # Fall back to the current calendar year if no match
+    return str(date.today().year)
+
+
+def _parse_xlsx(data: bytes, zone_letter: str, sub_number: str) -> list[Collection]:
+    """Parse the Dateneingabe sheet from an xlsx file for the given zone."""
+    collections: list[Collection] = []
+
+    with zipfile.ZipFile(BytesIO(data)) as zf:
+        # Read shared strings
+        ns = {"ns": "http://schemas.openxmlformats.org/spreadsheetml/2006/main"}
+        ss_root = ET.fromstring(zf.read("xl/sharedStrings.xml"))
+        shared_strings: list[str] = []
+        for si in ss_root.findall("ns:si", ns):
+            texts = si.findall(".//ns:t", ns)
+            shared_strings.append("".join(t.text or "" for t in texts))
+
+        def _cell_value(cell: ET.Element) -> str | None:
+            t = cell.get("t", "")
+            v_el = cell.find("ns:v", ns)
+            if v_el is None:
+                return None
+            v = v_el.text
+            if t == "s" and v is not None:
+                return shared_strings[int(v)]
+            return v
+
+        def _row_to_list(row: ET.Element, max_cols: int = 14) -> list[str | None]:
+            result: list[str | None] = [None] * max_cols
+            for cell in row.findall("ns:c", ns):
+                ref = cell.get("r", "")
+                col_letters = "".join(c for c in ref if c.isalpha())
+                col_idx = sum((ord(c) - ord("A") + 1) for c in col_letters) - 1
+                if col_idx < max_cols:
+                    result[col_idx] = _cell_value(cell)
+            return result
+
+        # Locate the Dateneingabe sheet via workbook.xml / relationships
+        wb_root = ET.fromstring(zf.read("xl/workbook.xml"))
+        rels_root = ET.fromstring(zf.read("xl/_rels/workbook.xml.rels"))
+        ns_r = {"r": "http://schemas.openxmlformats.org/package/2006/relationships"}
+        rel_map = {
+            r.get("Id"): r.get("Target")
+            for r in rels_root.findall("r:Relationship", ns_r)
+        }
+        sheet_path = None
+        for sheet_el in wb_root.findall(".//ns:sheet", ns):
+            if sheet_el.get("name") == "Dateneingabe":
+                rid = sheet_el.get(
+                    "{http://schemas.openxmlformats.org/officeDocument/2006/relationships}id"
+                )
+                if rid and rid in rel_map:
+                    sheet_path = "xl/" + rel_map[rid]
+                break
+
+        if sheet_path is None:
+            raise ValueError("Dateneingabe sheet not found in xlsx")
+
+        sheet_root = ET.fromstring(zf.read(sheet_path))
+        rows = sheet_root.findall(".//ns:row", ns)
+
+        # Skip header row (index 0); process data rows
+        for row in rows[1:]:
+            vals = _row_to_list(row)
+            # Column A (idx 0): Excel serial date
+            # Column C (idx 2): zone letter
+            if not vals[0] or vals[2] != zone_letter:
+                continue
+            try:
+                serial = int(float(vals[0]))
+            except (ValueError, TypeError):
+                continue
+            event_date = _EXCEL_EPOCH + timedelta(days=serial)
+
+            for col_idx, waste_name in WASTE_COLUMNS.items():
+                col_val = vals[col_idx]
+                if col_val and sub_number in str(col_val):
+                    collections.append(
+                        Collection(
+                            date=event_date,
+                            t=waste_name,
+                            icon=ICON_MAP.get(waste_name),
+                        )
+                    )
+
+    return collections
+
+
+class Source:
+    def __init__(
+        self,
+        street: str | None = None,
+        zone: str | None = None,
+    ):
+        if street is None and zone is None:
+            raise SourceArgumentRequired(
+                "street or zone",
+                "Either 'street' or 'zone' must be provided.",
+            )
+        self._street = street
+        self._zone = zone
+
+    def fetch(self) -> list[Collection]:
+        year = _discover_year()
+
+        zone: str
+        if self._street is not None:
+            # Resolve street name to zone via JSON directory
+            dir_url = _STREET_DIR_URL.format(year=year)
+            resp = requests.get(dir_url, timeout=30)
+            resp.raise_for_status()
+            directory = resp.json()
+            # The JSON key for the street name is "straße" (unicode ß)
+            street_key = (
+                next((k for k in directory[0].keys() if k != "gebiet"), None)
+                if directory
+                else None
+            )
+            if street_key is None:
+                raise ValueError("Unexpected street directory format")
+
+            match = next(
+                (entry for entry in directory if entry[street_key] == self._street),
+                None,
+            )
+            if match is None:
+                all_streets = sorted(
+                    entry[street_key] for entry in directory if street_key in entry
+                )
+                raise SourceArgumentNotFoundWithSuggestions(
+                    "street",
+                    self._street,
+                    all_streets,
+                )
+            zone = match["gebiet"].upper()
+        else:
+            zone = str(self._zone).upper()
+            if zone not in VALID_ZONES:
+                raise SourceArgumentNotFoundWithSuggestions(
+                    "zone",
+                    zone,
+                    VALID_ZONES,
+                )
+
+        zone_letter = zone[0]
+        sub_number = zone[1]
+
+        xlsx_url = _XLSX_URL.format(year=year, zone=zone)
+        resp = requests.get(xlsx_url, timeout=60)
+        resp.raise_for_status()
+
+        return _parse_xlsx(resp.content, zone_letter, sub_number)

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

@@ -0,0 +1,91 @@
+import json
+from datetime import date, datetime, timedelta
+
+import requests
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+
+TITLE = "Amber Valley Borough Council"
+DESCRIPTION = (
+    "Source for ambervalley.gov.uk services for Amber Valley Borough Council, UK."
+)
+URL = "https://ambervalley.gov.uk"
+TEST_CASES = {
+    "Test_001": {"uprn": "100030011612", "predict": True},
+    "Test_002": {"uprn": "100030011654"},
+    "test_003": {"uprn": 100030041980, "predict": True},
+}
+
+ICON_MAP = {
+    "REFUSE": Icons.GENERAL_WASTE,
+    "RECYCLING": Icons.RECYCLING,
+    "GREEN": Icons.ORGANIC,
+    "COMMUNAL REFUSE": Icons.GENERAL_WASTE,
+    "COMMUNAL RECYCLING": Icons.RECYCLING,
+}
+
+WASTE_TYPES_DATE_KEY = {
+    "REFUSE": "refuseNextDate",
+    "RECYCLING": "recyclingNextDate",
+    "GREEN": "greenNextDate",
+    "COMMUNAL REFUSE": "communalRefNextDate",
+    "COMMUNAL RECYCLING": "communalRycNextDate",
+}
+
+WASTE_TYPE_FREQUENCY_KEY = {
+    "REFUSE": "weeklyCollection",
+    "RECYCLING": "weeklyCollection",
+    "GREEN": "weeklyCollection",
+    "COMMUNAL REFUSE": "communalRefWeekly",
+    "COMMUNAL RECYCLING": "communalRycWeekly",
+}
+
+
+def _get_date(date_string: str) -> date:
+    return datetime.strptime(date_string, "%Y-%m-%dT%H:%M:%S").date()
+
+
+class Source:
+    def __init__(self, uprn: str | int, predict: bool = False):
+        self._uprn = str(uprn)
+        self._predict = predict
+
+    @staticmethod
+    def _construct_waste_dict(data: dict, predict: bool) -> dict[str, list[date]]:
+        to_return = {}
+        for bin, datge_key in WASTE_TYPES_DATE_KEY.items():
+            date_ = _get_date(data[datge_key])
+            if date_ == date(1900, 1, 1):
+                continue
+            to_return[bin] = [date_]
+            if predict:
+                weekly: bool = data[WASTE_TYPE_FREQUENCY_KEY[bin]]
+                day_offset = 7 if weekly else 14
+                for i in range(1, 365 // day_offset):
+                    to_return[bin].append(date_ + timedelta(days=day_offset * i))
+
+        return to_return
+
+    def fetch(self) -> list[Collection]:
+        # get json file
+        r = requests.get(
+            f"https://info.ambervalley.gov.uk/WebServices/AVBCFeeds/WasteCollectionJSON.asmx/GetCollectionDetailsByUPRN?uprn={self._uprn}"
+        )
+
+        # extract data from json
+        data = json.loads(r.text)
+        wasteDict = self._construct_waste_dict(data, self._predict)
+
+        entries = []
+
+        for bin_type, dates in wasteDict.items():
+            for date_ in dates:
+                if date_ != "1900-01-01T00:00:00":
+                    entries.append(
+                        Collection(
+                            date=date_,
+                            t=bin_type,
+                            icon=ICON_MAP.get(bin_type),
+                        )
+                    )
+
+        return entries

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

@@ -0,0 +1,284 @@
+import datetime
+from typing import Any
+
+import requests
+from waste_collection_schedule import Collection, Icons
+from waste_collection_schedule.exceptions import (
+    SourceArgumentException,
+    SourceArgumentExceptionMultiple,
+    SourceArgumentNotFound,
+    SourceArgumentRequired,
+)
+
+TITLE = "AMSA"
+DESCRIPTION = "Source for AMSA (Milan, Italy) waste collection."
+URL = "https://www.amsa.it/it/milano"
+COUNTRY = "it"
+
+TEST_CASES = {
+    "monte_rosa_91": {
+        "address": "Via Monte Rosa",
+        "house_number": "91",
+        "city": "Milano",
+    },
+    "piazza_duomo_1": {
+        "address": "Piazza del Duomo",
+        "house_number": "1",
+    },
+    "viale_piave_40b": {
+        "address": "Viale Piave",
+        "house_number": "40B",
+        "city": "Milano",
+    },
+}
+
+API_URL = URL + "/servizi/raccolta-differenziata?popup=services&serviceType=sdz"
+ICON_MAP = {
+    "indifferenziato": Icons.GENERAL_WASTE,
+    "organico": Icons.BIO_KITCHEN,
+    "carta e cartone": Icons.PAPER,
+    "plastica e metallo": Icons.METAL,
+    "vetro": Icons.GLASS,
+}
+
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": "You need to provide the street name and house number "
+    "of your address, as well as the city.",
+    "it": "Devi fornire il nome della via e il numero civico "
+    "del tuo indirizzo, oltre alla città.",
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "address": "The street name of your address in Milan (e.g., 'Via Monte Rosa').",
+        "house_number": "The house number of your address in Milan (e.g., '91').",
+        "city": "The city of your address (e.g., 'Milano').",
+    },
+    "it": {
+        "address": "Il nome della via del tuo indirizzo a Milano "
+        "(ad esempio, 'Via Monte Rosa').",
+        "house_number": "Il numero civico del tuo indirizzo a Milano "
+        "(ad esempio, '91').",
+        "city": "La città del tuo indirizzo (ad esempio, 'Milano').",
+    },
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "address": "Address",
+        "house_number": "House Number",
+        "city": "City",
+    },
+    "it": {
+        "address": "Indirizzo",
+        "house_number": "Numero Civico",
+        "city": "Città",
+    },
+}
+
+
+class Source:
+    def __init__(self, address: Any, house_number: Any, city: Any | None = None):
+        """Create a new source for AMSA and validate inputs.
+
+        Validation rules:
+        - `address` is required and must be a non-empty string.
+        - `house_number` is required and must be a non-empty string or int.
+        - `city` is optional. If provided it must be a non-empty string.
+        """
+        errors: list[tuple[str, str]] = []
+
+        # Validate address
+        if address is None or not isinstance(address, str) or address.strip() == "":
+            errors.append(("address", "address must be a non-empty string"))
+
+        # Validate house_number
+        if (
+            house_number is None
+            or not isinstance(house_number, (str, int))
+            or (isinstance(house_number, str) and house_number.strip() == "")
+        ):
+            errors.append(
+                (
+                    "house_number",
+                    "house_number must be provided and non-empty",
+                )
+            )
+
+        # Validate city (optional)
+        if city is not None and (not isinstance(city, str) or city.strip() == ""):
+            errors.append(("city", "city must be a non-empty string when provided"))
+
+        # Raise exceptions based on validation
+        if len(errors) > 1:
+            arg_names = [arg for arg, _ in errors]
+            message = ", ".join([f"{a}: {m}" for a, m in errors])
+            raise SourceArgumentExceptionMultiple(arg_names, message)
+
+        if len(errors) == 1:
+            arg, msg = errors[0]
+            if arg in ("address", "house_number"):
+                raise SourceArgumentRequired(arg, msg)
+            raise SourceArgumentException(arg, msg)
+
+        # Store sanitized values
+        self._address = str(address).strip()
+        self._house_number = str(house_number).strip()
+        self._city = str(city).strip() if city is not None else None
+        self._session: requests.Session | None = None
+
+    def _build_address_query(self) -> str:
+        address_query = f"{self._address} {self._house_number}"
+        if self._city:
+            address_query = f"{address_query}, {self._city}"
+        return address_query
+
+    def collect_waste_collection_schedule(self) -> dict[str, list[str]]:
+        """
+        Fetch calendar items by emulating the site's XHR API calls (no Selenium).
+
+        Flow (based on captured requests):
+        1) POST /api/service/area-services/address-autocomplete with address
+        2) POST /api/service/area-services/address-search with the chosen id
+        3) POST /api/service/area-services/calendar-items with geociv (civic id)
+
+        Returns a dict mapping ISO date strings (YYYY-MM-DD) to list of event keys (lowercase).
+        """
+        session = requests.Session()
+        headers = {
+            "Content-Type": "application/json",
+            "Accept": "application/json, text/javascript, */*; q=0.01",
+            "Origin": "https://www.amsa.it",
+            "Referer": API_URL,
+            "User-Agent": "Mozilla/5.0 (compatible; waste-collection-scraper/1.0)",
+        }
+
+        address_query = self._build_address_query()
+
+        # 1) suggestions
+        try:
+            resp = session.post(
+                "https://www.amsa.it/api/service/area-services/address-autocomplete",
+                json={
+                    "address": address_query,
+                    "city": (self._city or ""),
+                    "source": "database",
+                },
+                headers=headers,
+                timeout=15,
+            )
+            resp.raise_for_status()
+            j = resp.json()
+        except Exception as e:
+            raise Exception("Could not fetch address suggestions: " + str(e)) from e
+
+        try:
+            suggestions = j.get("data", [])
+            if not suggestions:
+                raise SourceArgumentNotFound("address", self._address)
+            suggestion = suggestions[0]
+            suggestion_id = suggestion.get("id")
+        except Exception as e:
+            raise Exception("Could not parse suggestion response: " + str(e)) from e
+
+        # 2) click/select suggestion -> obtain civic id / place detail
+        street = suggestion.get("value") or self._address
+        try:
+            civic_raw = self._house_number
+            try:
+                civic_val = int(civic_raw)
+            except Exception:  # e.g. "40B". Remove non-numeric characters
+                civic_val = int("".join(filter(str.isdigit, civic_raw)))
+
+            resp2 = session.post(
+                "https://www.amsa.it/api/service/area-services/address-search",
+                json={
+                    "id": suggestion_id,
+                    "street": suggestion.get("details", {}).get("via", street),
+                    "city": (self._city or "Milano"),
+                    "civic": civic_val,
+                },
+                headers=headers,
+                timeout=15,
+            )
+            resp2.raise_for_status()
+            j2 = resp2.json()
+        except Exception as e:
+            raise Exception(
+                "Could not select address / fetch place details: " + str(e)
+            ) from e
+
+        try:
+            data: dict[str, Any] = j2.get("data") or {}
+            geociv = data.get("idCivico") or data.get("place_id") or suggestion_id
+            if geociv is None:
+                raise SourceArgumentNotFound("house_number", self._house_number)
+        except Exception as e:
+            raise Exception("Could not parse address-search response: " + str(e)) from e
+
+        # 3) fetch calendar items
+        try:
+            resp3 = session.post(
+                "https://www.amsa.it/api/service/area-services/calendar-items",
+                json={"geociv": str(geociv)},
+                headers=headers,
+                timeout=30,
+            )
+            resp3.raise_for_status()
+            j3 = resp3.json()
+        except Exception as e:
+            raise Exception("Could not fetch calendar items: " + str(e)) from e
+
+        collections: dict[str, list[str]] = {}
+        try:
+            items = j3.get("data", [])
+            for item in items:
+                ms = item.get("date")
+                if ms is None:
+                    continue
+                try:
+                    dt = datetime.datetime.fromtimestamp(ms / 1000.0).date()
+                except Exception:
+                    continue
+                date_str = dt.isoformat()
+
+                desc = (item.get("desc") or "").lower()
+                if desc.startswith("raccolta "):
+                    desc = desc[len("raccolta ") :]
+                desc = desc.strip()
+
+                matched: list[str] = []
+                for key in ICON_MAP:
+                    if key in desc:
+                        matched.append(key)
+                if not matched:
+                    matched = [desc]
+
+                existing = set(collections.get(date_str, []))
+                for m in matched:
+                    if m not in existing:
+                        existing.add(m)
+                if existing:
+                    collections[date_str] = sorted(existing)
+        except Exception as e:
+            raise Exception("Could not parse calendar items: " + str(e)) from e
+
+        return collections
+
+    def fetch(self) -> list[Collection]:
+        calendar_data = self.collect_waste_collection_schedule()
+
+        entries: list[Collection] = []
+        for date_str, events in calendar_data.items():
+            try:
+                date = datetime.datetime.strptime(date_str, "%Y-%m-%d").date()
+            except Exception:
+                continue
+            for event in events:
+                event_lower = event.lower()
+                icon = ICON_MAP.get(event_lower, "mdi:trash-can")
+                entries.append(Collection(date=date, t=event, icon=icon))
+
+        entries.sort(key=lambda x: x.date)
+        return entries

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

@@ -0,0 +1,29 @@
+from waste_collection_schedule import Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.service.RiSKommunalAT import RiSKommunalSource
+
+TITLE = "Marktgemeinde Angern an der March"
+DESCRIPTION = "Source for Marktgemeinde Angern an der March, Austria."
+URL = "https://www.angern.at"
+COUNTRY = "at"
+
+TEST_CASES: dict[str, dict] = {"TestSource": {}}
+
+ICON_MAP = {
+    "Restmüll": Icons.GENERAL_WASTE,
+    "Biotonne": Icons.ORGANIC,
+    "Biomüll": Icons.ORGANIC,
+    "Altpapier": Icons.PAPER,
+    "Gelber Sack": Icons.PLASTIC_PACKAGING,
+    "Gelbe Tonne": Icons.PLASTIC_PACKAGING,
+    "Grünschnitt": Icons.GARDEN,
+    "Sperrmüll": Icons.BULKY,
+    "Altglas": Icons.GLASS,
+    "Recyclinghof": Icons.RECYCLING,
+    "Problemstoff": Icons.HAZARDOUS,
+}
+
+
+class Source(RiSKommunalSource):
+    BASE_URL = "https://www.angern.at"
+    ICON_MAP = ICON_MAP
+    RAISE_ON_EMPTY = True