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

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

@@ -0,0 +1,144 @@
+import urllib.parse
+from datetime import datetime
+
+from curl_cffi import requests
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import SourceArgumentNotFoundWithSuggestions
+
+TITLE = "KOMA"
+DESCRIPTION = "Source for KOMA waste collection (e.g. Nowy Dwór Gdański, Poland)."
+URL = "https://koma.pl"
+COUNTRY = "pl"
+
+API_URL = "https://bok.koma.pl"
+
+TEST_CASES = {
+    "Nowy Dwór Gdański, Kanałowa 5": {
+        "gmina": "Nowy Dwór Gdański",
+        "miejscowosc": "Nowy Dwór Gdański",
+        "ulica": "Kanałowa",
+        "numer_domu": "5",
+    },
+    "Nowy Dwór Gdański, Kanałowa 4/1": {
+        "gmina": "Nowy Dwór Gdański",
+        "miejscowosc": "Nowy Dwór Gdański",
+        "ulica": "Kanałowa",
+        "numer_domu": "4/1",
+    },
+}
+
+ICON_MAP = {
+    "Zmieszane": Icons.GENERAL_WASTE,
+    "Bio": Icons.ORGANIC,
+    "Odpady zielone": Icons.GARDEN,
+    "Papier": Icons.PAPER,
+    "Szkło": Icons.GLASS,
+    "Metale i tworzywa sztuczne": Icons.RECYCLING,
+    "Gabaryty": Icons.BULKY,
+    "Elektro": Icons.ELECTRONICS,
+}
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": (
+        "Open https://koma.pl/harmonogram-odpadow/ and step through the dropdowns "
+        "(Wybierz Miasto -> miejscowość -> ulica -> numer domu) to find the exact "
+        "spelling of your gmina, town, street and house number."
+    ),
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "gmina": "Commune (gmina)",
+        "miejscowosc": "Town",
+        "ulica": "Street",
+        "numer_domu": "House number",
+    },
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "gmina": "Name of the commune (gmina) as listed on koma.pl.",
+        "miejscowosc": "Name of the town/village.",
+        "ulica": "Street name (leave empty for towns without streets).",
+        "numer_domu": "House number.",
+    },
+}
+
+
+class Source:
+    def __init__(
+        self, gmina: str, miejscowosc: str, numer_domu: str | int, ulica: str = ""
+    ):
+        self._gmina = str(gmina).strip()
+        self._miejscowosc = str(miejscowosc).strip()
+        self._ulica = str(ulica).strip()
+        self._numer_domu = str(numer_domu).strip()
+
+    def _get_json(self, session, path_segments, params=None):
+        url = (
+            API_URL
+            + "/"
+            + "/".join(urllib.parse.quote(segment) for segment in path_segments)
+        )
+        response = session.get(url, params=params, timeout=30)
+        response.raise_for_status()
+        return response.json()
+
+    def fetch(self) -> list[Collection]:
+        session = requests.Session(impersonate="chrome")
+
+        # The API "prefix" path segment equals the gmina name.
+        prefix = self._gmina
+
+        # 1. Resolve the property id (numer_posesji) for the given house number.
+        posesje_path = ["api", "posesje", prefix, self._gmina, self._miejscowosc]
+        if self._ulica:
+            posesje_path.append(self._ulica)
+        properties = self._get_json(session, posesje_path)
+
+        if not properties:
+            if self._ulica:
+                streets = self._get_json(
+                    session, ["api", "ulice", prefix, self._gmina, self._miejscowosc]
+                )
+                raise SourceArgumentNotFoundWithSuggestions(
+                    "ulica",
+                    self._ulica,
+                    sorted({s["ulica"] for s in streets if s.get("ulica")}),
+                )
+            raise SourceArgumentNotFoundWithSuggestions(
+                "miejscowosc", self._miejscowosc, []
+            )
+
+        match = next(
+            (
+                p
+                for p in properties
+                if str(p.get("numer_domu")).strip().casefold()
+                == self._numer_domu.casefold()
+            ),
+            None,
+        )
+        if match is None:
+            raise SourceArgumentNotFoundWithSuggestions(
+                "numer_domu",
+                self._numer_domu,
+                sorted({str(p.get("numer_domu")) for p in properties}),
+            )
+
+        # 2. Fetch the schedule for the resolved property.
+        schedule = self._get_json(
+            session,
+            ["api", "apiharmonogram"],
+            {"value": f"{prefix}/{match['numer_posesji']}"},
+        )
+
+        entries: list[Collection] = []
+        for collection in schedule.get("odbior", []):
+            try:
+                day = datetime.strptime(collection["data"], "%Y-%m-%d").date()
+            except (ValueError, KeyError):
+                continue
+            waste_type = collection.get("typ", "")
+            entries.append(Collection(day, waste_type, icon=ICON_MAP.get(waste_type)))
+        return entries

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

@@ -0,0 +1,179 @@
+from __future__ import annotations
+
+from collections.abc import Iterable
+from dataclasses import dataclass
+from datetime import date, datetime
+
+import requests
+from waste_collection_schedule import Collection  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import (
+    SourceArgAmbiguousWithSuggestions,
+    SourceArgumentNotFound,
+)
+
+try:
+    # Python 3.11+
+    from datetime import UTC
+except ImportError:
+    # python <= 3.10
+    from datetime import timezone
+
+    UTC = timezone.utc
+
+TITLE = "Komunala Kranj"
+DESCRIPTION = "Source for Komunala Kranj."
+URL = "https://www.komunala-kranj.si/"
+TEST_CASES = {
+    "Kranj": {"address": "Koroška cesta 1, Kranj, 4000 Kranj"},
+    "BESNICA": {"address": "Vogel 10, Spodnja Besnica, 4201 Zgornja Besnica"},
+}
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": "Enter the street name and house number exactly as shown in the Komunala Kranj address search.",
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "address": "Address as accepted by the Komunala Kranj address search (e.g. 'Street 1, City').",
+    }
+}
+
+
+ADDRESS_URL = "https://gis.komunala-kranj.si/mapguide/KaliopaFDOService/Service.asmx/GetResultsSimplified"
+SCHEDULE_URL = (
+    "https://gis.komunala-kranj.si/ddmoduli/EkoloskiOtoki.asmx/GetKoledarOdvozov"
+)
+API_HEADERS = {
+    "Accept": "application/json",
+    "Content-Type": "application/json; charset=utf-8",
+}
+DEFAULT_DAYS_AHEAD = 60
+
+
+@dataclass(frozen=True)
+class _AddressMatch:
+    identifier: str
+    description: str
+
+
+def _parse_date(value: str | date | datetime) -> date:
+    if isinstance(value, date) and not isinstance(value, datetime):
+        return value
+    if isinstance(value, datetime):
+        return value.date()
+    text = str(value).strip()
+    for fmt in ("%d.%m.%Y", "%Y-%m-%d"):
+        try:
+            return datetime.strptime(text, fmt).date()
+        except ValueError:
+            continue
+    if text.startswith("/Date(") and text.endswith(")/"):
+        timestamp_text = text[len("/Date(") : -len(")/")]
+        # remove optional timezone information (e.g. +0200) if present
+        if "+" in timestamp_text or "-" in timestamp_text[1:]:
+            for sep in ("+", "-"):
+                if sep in timestamp_text[1:]:
+                    timestamp_text = timestamp_text.split(sep, 1)[0]
+                    break
+        timestamp = int(timestamp_text)
+        return datetime.fromtimestamp(timestamp / 1000, tz=UTC).date()
+    raise ValueError(f"Cannot parse date from value: {value!r}")
+
+
+def _suggestions(matches: Iterable[_AddressMatch]) -> list[str]:
+    return sorted({match.description for match in matches if match.description})
+
+
+def _guess_icon(text: str) -> str | None:
+    lowered = text.lower()
+    if "bio" in lowered:
+        return "mdi:leaf"
+    if "embala" in lowered or "plasti" in lowered:
+        return "mdi:recycle"
+    if "stek" in lowered:
+        return "mdi:glass-fragile"
+    if "papir" in lowered:
+        return "mdi:newspaper"
+    if "kosov" in lowered:
+        return "mdi:sofa"
+    if "mešan" in lowered or "mesan" in lowered:
+        return "mdi:trash-can"
+    return None
+
+
+class Source:
+    def __init__(self, address: str):
+        self._address = address
+
+    def fetch(self) -> list[Collection]:
+        match = self._get_address_match()
+
+        schedule_params = {
+            "a": "komunalakranj",
+            "hsMid": match.identifier,
+            "stDni": str(DEFAULT_DAYS_AHEAD),
+        }
+        response = requests.get(
+            SCHEDULE_URL, params=schedule_params, headers=API_HEADERS, timeout=30
+        )
+        response.raise_for_status()
+
+        entries: list[Collection] = []
+        for item in response.json().get("d", []):
+            raw_date = (
+                item.get("Datum")
+                or item.get("DatumSort")
+                or item.get("DatumSorten")
+                or item.get("DatumSortEn")
+            )
+            if not raw_date:
+                continue
+            collection_date = _parse_date(raw_date)
+
+            waste_type = str(item.get("VrstaOdpadka") or "").strip()
+            container_type = str(item.get("VrstaZabojnika") or "").strip()
+
+            if waste_type and container_type and container_type not in waste_type:
+                type_name = f"{waste_type} ({container_type})"
+            else:
+                type_name = waste_type or container_type or "Waste Collection"
+
+            icon = _guess_icon(waste_type or container_type)
+            entries.append(Collection(date=collection_date, t=type_name, icon=icon))
+
+        return entries
+
+    def _get_address_match(self) -> _AddressMatch:
+        params = {
+            "a": "hisnestevilkekranj",
+            "mapName": "map",
+            "locale": "SI",
+            "query": self._address,
+        }
+        response = requests.get(
+            ADDRESS_URL, params=params, headers=API_HEADERS, timeout=30
+        )
+        response.raise_for_status()
+
+        matches = [
+            _AddressMatch(
+                identifier=str(item.get("Id", "")),
+                description=str(item.get("Text", "")),
+            )
+            for item in response.json().get("d", [])
+        ]
+
+        matches = [m for m in matches if m.identifier]
+        if not matches:
+            raise SourceArgumentNotFound("address", self._address)
+
+        if len(matches) > 1:
+            normalized_query = self._address.strip().casefold()
+            for match in matches:
+                if match.description.strip().casefold() == normalized_query:
+                    return match
+            raise SourceArgAmbiguousWithSuggestions(
+                "address", self._address, _suggestions(matches)
+            )
+
+        return matches[0]

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

@@ -0,0 +1,185 @@
+import io
+import re
+from calendar import monthcalendar
+from datetime import date, datetime
+
+import requests
+from pypdf import PdfReader
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import (
+    SourceArgumentNotFoundWithSuggestions,
+    SourceArgumentRequired,
+)
+
+TITLE = "Kópavogsbær"
+DESCRIPTION = "Source for Kópavogur, Iceland (Kubbur collection calendar)"
+URL = "https://www.kopavogur.is"
+COUNTRY = "is"
+SOURCE_CODEOWNERS = ["@rhubarbgarden"]
+
+DISTRICTS = [
+    "Vesturbær - Smárahverfi",
+    "Austurbær sunnan Álfhólsvegar",
+    "Austurbær norðan Álfhólsvegar",
+    "Lindir, Salir, Kórar, Hvörf og Þing",
+]
+
+# Highlight fill colors used in the PDF calendars, mapped to district index
+_DISTRICT_COLORS = {
+    (1.0, 1.0, 0.0): 0,  # yellow
+    (0.8, 0.4, 1.0): 1,  # purple
+    (1.0, 0.0, 0.0): 2,  # red
+    (0.0, 0.69, 0.941): 3,  # blue
+}
+_GRAY = 0.949  # fill of the weekday header bar above each mini calendar
+
+PDF_URLS = {
+    "Almennt sorp og matarleifar": "https://eldri.kopavogur.is/static/files/Sorphirda/sorphirdudagatal-{year}-almennt.pdf",
+    "Pappi/pappír og plast": "https://eldri.kopavogur.is/static/files/Sorphirda/sorphirdudagatal-{year}-pappi-plast.pdf",
+}
+
+ICON_MAP = {
+    "Almennt sorp og matarleifar": Icons.GENERAL_WASTE,
+    "Pappi/pappír og plast": Icons.RECYCLING,
+}
+
+TEST_CASES = {
+    "Vesturbær": {"district": "Vesturbær - Smárahverfi"},
+    "Austurbær sunnan": {"district": "Austurbær sunnan Álfhólsvegar"},
+    "Austurbær norðan": {"district": "Austurbær norðan Álfhólsvegar"},
+    "Lindir": {"district": "Lindir, Salir, Kórar, Hvörf og Þing"},
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "district": "District",
+    },
+    "de": {
+        "district": "Bezirk",
+    },
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "district": "Collection district (zone) as shown in the calendar legend. Partial, case-insensitive matches are accepted.",
+    },
+    "de": {
+        "district": "Abfuhrbezirk (Zone) wie in der Kalenderlegende angegeben. Teilweise Übereinstimmungen (Groß-/Kleinschreibung wird ignoriert) werden akzeptiert.",
+    },
+}
+
+# content stream operators: "r g b rg" (set rgb fill), "v g" (set gray fill),
+# "x y w h re" followed by "f*" (fill rectangle)
+_STREAM_RE = re.compile(
+    r"(?:([\d.]+) ([\d.]+) ([\d.]+) rg)"
+    r"|(?:([\d.]+) g\b)"
+    r"|(?:([\d.]+) ([\d.]+) ([\d.]+) ([\d.]+) re\s+f\*)"
+)
+
+
+def _extract_rects(stream: str):
+    """Yield (district_index_or_"gray", x, y, w) for filled rects of interest."""
+    color = None
+    for m in _STREAM_RE.finditer(stream):
+        if m.group(1) is not None:  # rgb fill color
+            color = tuple(round(float(m.group(i)), 3) for i in (1, 2, 3))
+        elif m.group(4) is not None:  # gray fill color
+            color = ("gray", round(float(m.group(4)), 3))
+        else:  # filled rectangle
+            x, y, w, _h = (float(m.group(i)) for i in range(5, 9))
+            if color == ("gray", _GRAY):
+                yield "gray", x, y, w
+            elif color in _DISTRICT_COLORS:
+                yield _DISTRICT_COLORS[color], x, y, w
+
+
+class Source:
+    def __init__(self, district: str | None = None):
+        if not district:
+            raise SourceArgumentRequired(
+                "district", "district (collection zone) is required"
+            )
+        normalized = district.strip().casefold()
+        matches = [d for d in DISTRICTS if normalized in d.casefold()]
+        if len(matches) != 1:
+            raise SourceArgumentNotFoundWithSuggestions("district", district, DISTRICTS)
+        self._district_index = DISTRICTS.index(matches[0])
+
+    def fetch(self) -> list[Collection]:
+        year = datetime.now().year
+        entries = self._fetch_year(year)
+        # Early in the year, last year's calendar may still contain
+        # upcoming dates (and the new PDF may not exist yet).
+        if not entries or datetime.now().month == 1:
+            try:
+                entries += [
+                    e for e in self._fetch_year(year - 1) if e.date >= date.today()
+                ]
+            except Exception:
+                pass
+        if not entries:
+            raise Exception("no collection dates found in calendar PDFs")
+        return entries
+
+    def _fetch_year(self, year: int) -> list[Collection]:
+        entries: list[Collection] = []
+        for waste_type, url_template in PDF_URLS.items():
+            r = requests.get(url_template.format(year=year), timeout=30)
+            r.raise_for_status()
+            for d in self._parse_pdf(r.content, year):
+                entries.append(
+                    Collection(date=d, t=waste_type, icon=ICON_MAP.get(waste_type))
+                )
+        return entries
+
+    def _parse_pdf(self, pdf_bytes: bytes, year: int) -> list[date]:
+        page = PdfReader(io.BytesIO(pdf_bytes)).pages[0]
+        stream = page.get_contents().get_data().decode("latin-1")
+
+        weekday_bars = []  # gray bar above each mini calendar: (x, y, w)
+        all_highlights = []  # (district_index, x, y, w)
+        for kind, x, y, w in _extract_rects(stream):
+            if kind == "gray":
+                weekday_bars.append((x, y, w))
+            else:
+                all_highlights.append((kind, x, y, w))
+
+        if len(weekday_bars) != 12:
+            raise Exception(
+                f"unexpected calendar layout: {len(weekday_bars)} month grids"
+            )
+
+        # month grid geometry: 4 columns x 3 bands, anchored on weekday bars
+        col_xs = sorted({round(b[0], 2) for b in weekday_bars})
+        band_ys = sorted({round(b[1], 2) for b in weekday_bars}, reverse=True)
+        if len(col_xs) != 4 or len(band_ys) != 3:
+            raise Exception("unexpected calendar layout: month grid mismatch")
+        cell_w = weekday_bars[0][2] / 7
+        # legend boxes at the bottom are wider than any highlight; drop them
+        all_highlights = [h for h in all_highlights if h[3] < 3 * cell_w]
+        # vertical row pitch: smallest gap between any highlight and its bar
+        pitch = min(
+            min(b - y for b in band_ys if b > y) for _i, _x, y, _w in all_highlights
+        )
+
+        dates: list[date] = []
+        for dist, x, y, w in all_highlights:
+            if dist != self._district_index:
+                continue
+            col = max(i for i in range(4) if col_xs[i] - 2 <= x)
+            band_y = min((b for b in band_ys if b > y), key=lambda b: b - y)
+            month = band_ys.index(band_y) * 4 + col + 1
+            weekday0 = round((x - col_xs[col]) / cell_w)
+            week0 = round((band_y - y) / pitch) - 1
+            weeks = monthcalendar(year, month)
+            for k in range(round(w / cell_w)):  # a wide rect spans 2 days
+                weekday = (weekday0 + k) % 7
+                week = week0 + (weekday0 + k) // 7
+                day = weeks[week][weekday] if 0 <= week < len(weeks) else 0
+                if day == 0:
+                    raise Exception(f"failed to decode calendar cell in month {month}")
+                d = date(year, month, day)
+                if d.weekday() != weekday:  # geometric sanity check
+                    raise Exception("calendar grid decoding mismatch")
+                dates.append(d)
+        return dates

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

@@ -0,0 +1,39 @@
+from typing import ClassVar
+
+from waste_collection_schedule import Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.service.RiSKommunalAT import RiSKommunalSource
+
+TITLE = "Koppl"
+DESCRIPTION = "Waste collection schedule for Koppl, Austria."
+URL = "https://www.koppl.at"
+COUNTRY = "at"
+
+TEST_CASES = {
+    "Koppl": {},
+}
+
+ICON_MAP = {
+    "Restabfall 14-tägig": Icons.GENERAL_WASTE,
+    "Restabfall monatlich": Icons.GENERAL_WASTE,
+    "Restmüll": Icons.GENERAL_WASTE,
+    "Bioabfall": Icons.ORGANIC,
+    "Biomüll": Icons.ORGANIC,
+    "Altpapier": Icons.PAPER,
+    "Gelber Sack": Icons.PLASTIC_PACKAGING,
+    "Gelbe Tonne": Icons.PLASTIC_PACKAGING,
+    "Sperrmüll": Icons.BULKY,
+    "Altglas": Icons.GLASS,
+    "Problemstoff": Icons.HAZARDOUS,
+}
+
+
+class Source(RiSKommunalSource):
+    BASE_URL = "https://www.koppl.at"
+    ICON_MAP = ICON_MAP
+    RAISE_ON_EMPTY = True
+    QUERY_PARAMS: ClassVar = {
+        "bdatum": "31.12.9999",
+        "detailonr": "225241960",
+        "menuonr": "225241969",
+        "typids": "225241960",
+    }