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

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

@@ -0,0 +1,320 @@
+"""Source for Hemar (ichisystem.eu), Poland."""
+
+import re
+from datetime import date, datetime
+from html.parser import HTMLParser
+
+import requests
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import SourceArgumentNotFoundWithSuggestions
+
+TITLE = "Hemar (ichisystem.eu)"
+DESCRIPTION = (
+    "Source for the Hemar waste collection schedule platform "
+    "(harmonogram.ichisystem.eu) used by several Polish municipalities."
+)
+URL = "https://harmonogram.ichisystem.eu/hemar/"
+COUNTRY = "pl"
+
+TEST_CASES = {
+    "Pobiedziska, Boczna 2": {
+        "city": "Pobiedziska",
+        "street": "Boczna",
+        "house_number": "2",
+    },
+    "Pobiedziska, Dworcowa 1": {
+        "city": "POBIEDZISKA",
+        "street": "DWORCOWA",
+        "house_number": "1",
+    },
+}
+
+EXTRA_INFO = [
+    {
+        "title": "Pobiedziska",
+        "url": "https://harmonogram.ichisystem.eu/hemar/",
+        "default_params": {"city": "Pobiedziska"},
+    },
+    {
+        "title": "Kiszkowo",
+        "url": "https://harmonogram.ichisystem.eu/hemar/",
+        "default_params": {"city": "Kiszkowo"},
+    },
+]
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": (
+        "Open https://harmonogram.ichisystem.eu/hemar/ and pick your city, "
+        "street, and house number from the dropdowns. Use those exact values "
+        "for the city, street, and house_number arguments (matching is "
+        "case-insensitive)."
+    ),
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "city": "City / town name as listed on the Hemar portal.",
+        "street": "Street name as listed on the Hemar portal.",
+        "house_number": "House number as listed on the Hemar portal.",
+    },
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "city": "City",
+        "street": "Street",
+        "house_number": "House number",
+    },
+}
+
+ICON_MAP = {
+    "zmieszane": Icons.GENERAL_WASTE,
+    "papier": Icons.PAPER,
+    "metale": Icons.METAL,
+    "tworzywa": Icons.RECYCLING,
+    "szk": Icons.GLASS_COLORED,
+    "bio": Icons.ORGANIC,
+    "drzewka": Icons.CHRISTMAS_TREE,
+    "wystawkow": Icons.BULKY,
+    "gabaryt": Icons.BULKY,
+    "popi": Icons.GENERAL_WASTE,
+    "choink": Icons.CHRISTMAS_TREE,
+}
+
+API_BASE = "https://harmonogram.ichisystem.eu/hemar"
+
+# Polish month names as used in the schedule HTML, mapped to month numbers.
+PL_MONTHS = {
+    "styczen": 1,
+    "luty": 2,
+    "marzec": 3,
+    "kwiecien": 4,
+    "maj": 5,
+    "czerwiec": 6,
+    "lipiec": 7,
+    "sierpien": 8,
+    "wrzesien": 9,
+    "pazdziernik": 10,
+    "listopad": 11,
+    "grudzien": 12,
+}
+
+
+def _strip_pl(text: str) -> str:
+    """Normalise Polish text: lowercase + drop diacritics + collapse whitespace."""
+    table = str.maketrans(
+        {
+            "ą": "a",
+            "Ą": "a",
+            "ć": "c",
+            "Ć": "c",
+            "ę": "e",
+            "Ę": "e",
+            "ł": "l",
+            "Ł": "l",
+            "ń": "n",
+            "Ń": "n",
+            "ó": "o",
+            "Ó": "o",
+            "ś": "s",
+            "Ś": "s",
+            "ź": "z",
+            "Ź": "z",
+            "ż": "z",
+            "Ż": "z",
+        }
+    )
+    return re.sub(r"\s+", " ", text.translate(table).lower()).strip()
+
+
+def _icon_for(waste_type: str) -> str | None:
+    key = _strip_pl(waste_type)
+    for needle, icon in ICON_MAP.items():
+        if needle in key:
+            return icon
+    return None
+
+
+class _ScheduleTableParser(HTMLParser):
+    """Extract the first schedule table from the Hemar report HTML.
+
+    The table has a header row with waste-type names and one body row per
+    month. The first cell of each body row is a Polish month name; the
+    remaining cells contain comma-separated day numbers (or empty).
+    """
+
+    def __init__(self) -> None:
+        super().__init__()
+        self._in_table = False
+        self._in_thead = False
+        self._in_tbody = False
+        self._in_tr = False
+        self._in_cell = False
+        self._cell_text: list[str] = []
+        self._current_row: list[str] = []
+        self.headers: list[str] = []
+        self.rows: list[list[str]] = []
+        self._captured = False
+
+    def handle_starttag(self, tag: str, attrs):  # type: ignore[override]
+        if self._captured:
+            return
+        if tag == "table":
+            self._in_table = True
+        elif tag == "thead" and self._in_table:
+            self._in_thead = True
+        elif tag == "tbody" and self._in_table:
+            self._in_tbody = True
+        elif tag == "tr" and self._in_table:
+            self._in_tr = True
+            self._current_row = []
+        elif tag in ("td", "th") and self._in_tr:
+            self._in_cell = True
+            self._cell_text = []
+
+    def handle_endtag(self, tag: str):  # type: ignore[override]
+        if self._captured:
+            return
+        if tag in ("td", "th") and self._in_cell:
+            self._current_row.append("".join(self._cell_text).strip())
+            self._in_cell = False
+        elif tag == "tr" and self._in_tr:
+            if self._in_thead:
+                # Take the longest header row (real header may be the 2nd row).
+                if len(self._current_row) > len(self.headers):
+                    self.headers = self._current_row
+            elif self._in_tbody:
+                self.rows.append(self._current_row)
+            self._in_tr = False
+        elif tag == "thead":
+            self._in_thead = False
+        elif tag == "tbody":
+            self._in_tbody = False
+            if self.headers and self.rows:
+                self._captured = True
+        elif tag == "table":
+            self._in_table = False
+
+    def handle_data(self, data: str):  # type: ignore[override]
+        if self._in_cell:
+            self._cell_text.append(data)
+
+
+class Source:
+    def __init__(self, city: str, street: str, house_number: str):
+        self._city = str(city).strip()
+        self._street = str(street).strip()
+        self._house_number = str(house_number).strip()
+        self._session = requests.Session()
+
+    def _get_json(self, path: str):
+        r = self._session.get(f"{API_BASE}{path}", timeout=30)
+        r.raise_for_status()
+        return r.json()
+
+    def _find(self, items, target: str, arg_name: str):
+        norm_target = _strip_pl(target)
+        for item in items:
+            if _strip_pl(item["value"]) == norm_target:
+                return item
+        suggestions = [item["value"] for item in items]
+        raise SourceArgumentNotFoundWithSuggestions(
+            arg_name, target, suggestions=suggestions
+        )
+
+    def fetch(self) -> list[Collection]:
+        cities = self._get_json("/addresses/cities")
+        city = self._find(cities, self._city, "city")
+
+        streets = self._get_json(f"/addresses/streets/{city['id']}")
+        street = self._find(streets, self._street, "street")
+
+        numbers = self._get_json(f"/addresses/numbers/{city['id']}/{street['id']}")
+        number = self._find(numbers, self._house_number, "house_number")
+
+        years = self._get_json("/years")
+        if not years:
+            return []
+
+        today = date.today()
+        entries: list[Collection] = []
+        seen: set = set()
+
+        for year_entry in years:
+            year_id = year_entry["id"]
+            year_value = int(year_entry["value"])
+            report = self._session.get(
+                f"{API_BASE}/reports",
+                params={
+                    "type": "html",
+                    "id": number["id"],
+                    "responseType": "json",
+                    "token": number["token"],
+                    "yearId": year_id,
+                },
+                timeout=30,
+            )
+            report.raise_for_status()
+            payload = report.json()
+            if payload.get("status") != "success" or not payload.get("filePath"):
+                continue
+
+            html_resp = self._session.get(payload["filePath"], timeout=30)
+            html_resp.raise_for_status()
+            html_resp.encoding = "utf-8"
+
+            for collection in self._parse_schedule(html_resp.text, year_value):
+                key = (collection.date, collection.type)
+                if key in seen:
+                    continue
+                seen.add(key)
+                # Skip dates more than 30 days in the past to keep payload small.
+                if (today - collection.date).days > 30:
+                    continue
+                entries.append(collection)
+
+        return entries
+
+    @staticmethod
+    def _parse_schedule(html: str, year: int) -> list[Collection]:
+        parser = _ScheduleTableParser()
+        parser.feed(html)
+
+        if not parser.headers or not parser.rows:
+            return []
+
+        # First header column is the month name; remaining are waste types.
+        waste_types = parser.headers[1:]
+        results: list[Collection] = []
+
+        for row in parser.rows:
+            if not row:
+                continue
+            month_name = _strip_pl(row[0])
+            month = PL_MONTHS.get(month_name)
+            if month is None:
+                continue
+            for col_idx, cell in enumerate(row[1:], start=0):
+                if col_idx >= len(waste_types):
+                    break
+                cell = cell.strip()
+                if not cell:
+                    continue
+                waste_type = waste_types[col_idx].strip()
+                for piece in re.split(r"[,;/]", cell):
+                    piece = piece.strip()
+                    if not piece.isdigit():
+                        continue
+                    day = int(piece)
+                    try:
+                        collection_date = datetime(year, month, day).date()
+                    except ValueError:
+                        continue
+                    results.append(
+                        Collection(
+                            date=collection_date,
+                            t=waste_type,
+                            icon=_icon_for(waste_type),
+                        )
+                    )
+        return results

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

@@ -0,0 +1,284 @@
+import datetime
+import logging
+import re
+from os import getcwd
+from pathlib import Path
+from typing import Literal
+
+from curl_cffi import requests
+from waste_collection_schedule import Collection  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import (
+    SourceArgumentException,
+    SourceArgumentExceptionMultiple,
+    SourceArgumentNotFoundWithSuggestions,
+)
+from waste_collection_schedule.service.ICS import ICS
+
+TITLE = "ICS"
+DESCRIPTION = "Source for ICS based schedules."
+URL = None
+TEST_CASES = {
+    "Esslingen, Bahnhof": {
+        "url": "https://api.abfall.io/?kh=DaA02103019b46345f1998698563DaAd&t=ics&s=1a862df26f6943997cef90233877a4fe"
+    },
+    "Test File": {
+        # Path is used here to allow to call the Source from any location.
+        # This is not required in a yaml configuration!
+        "file": str(Path(__file__).resolve().parents[1].joinpath("test/test.ics"))
+    },
+    "Test File (recurring)": {
+        # Path is used here to allow to call the Source from any location.
+        # This is not required in a yaml configuration!
+        "file": str(Path(__file__).resolve().parents[1].joinpath("test/recurring.ics"))
+    },
+    "München, Bahnstr. 11": {
+        "url": "https://www.awm-muenchen.de/entsorgen/abfuhrkalender?tx_awmabfuhrkalender_abfuhrkalender%5Bhausnummer%5D=11&tx_awmabfuhrkalender_abfuhrkalender%5Bleerungszyklus%5D%5BB%5D=1%2F2%3BU&tx_awmabfuhrkalender_abfuhrkalender%5Bleerungszyklus%5D%5BP%5D=1%2F2%3BG&tx_awmabfuhrkalender_abfuhrkalender%5Bleerungszyklus%5D%5BR%5D=001%3BU&tx_awmabfuhrkalender_abfuhrkalender%5Bsection%5D=ics&tx_awmabfuhrkalender_abfuhrkalender%5Bsinglestandplatz%5D=false&tx_awmabfuhrkalender_abfuhrkalender%5Bstandplatzwahl%5D=true&tx_awmabfuhrkalender_abfuhrkalender%5Bstellplatz%5D%5Bbio%5D=70024507&tx_awmabfuhrkalender_abfuhrkalender%5Bstellplatz%5D%5Bpapier%5D=70024507&tx_awmabfuhrkalender_abfuhrkalender%5Bstellplatz%5D%5Brestmuell%5D=70024507&tx_awmabfuhrkalender_abfuhrkalender%5Bstrasse%5D=bahnstr.&tx_awmabfuhrkalender_abfuhrkalender%5Byear%5D={%Y}",
+        "version": 1,
+    },
+    #    "Hausmüllinfo: ASR Chemnitz": {
+    #        "url": "https://asc.hausmuell.info/ics/ics.php",
+    #        "method": "POST",
+    #        "params": {
+    #            "hidden_id_egebiet": 439087,
+    #            "input_ort": "Chemnitz",
+    #            "input_str": "Straße der Nationen",
+    #            "input_hnr": 2,
+    #            "hidden_send_btn": "ics",
+    #            # "hiddenYear": 2021,
+    #            "hidden_id_ort": 10,
+    #            "hidden_id_ortsteil": 0,
+    #            "hidden_id_str": 17814,
+    #            "hidden_id_hnr": 5538100,
+    #            "hidden_kalenderart": "privat",
+    #            "showBinsBio": "on",
+    #            "showBinsRest": "on",
+    #            "showBinsRest_rc": "on",
+    #            "showBinsPapier": "on",
+    #            "showBinsOrganic": "on",
+    #            "showBinsXmas": "on",
+    #            "showBinsDsd": "on",
+    #            "showBinsProb": "on",
+    #        },
+    #        "year_field": "hiddenYear",
+    #    },
+    "Abfall Zollernalbkreis, Ebingen": {
+        "url": "https://www.abfallkalender-zak.de",
+        "params": {
+            "city": "2,3,4",
+            "street": "3",
+            "types[]": [
+                "restmuell",
+                "gelbersack",
+                "papiertonne",
+                "biomuell",
+                "gruenabfall",
+                "schadstoffsammlung",
+                "altpapiersammlung",
+                "schrottsammlung",
+                "weihnachtsbaeume",
+                "elektrosammlung",
+            ],
+            "go_ics": "Download",
+        },
+        "year_field": "year",
+    },
+    "ReCollect, Ottawa": {
+        "url": "https://recollect.a.ssl.fastly.net/api/places/BCCDF30E-578B-11E4-AD38-5839C200407A/services/208/events.en.ics",
+        "split_at": "\\, (?:and )?|(?: and )",
+    },
+    "ReCollect, Simcoe County": {
+        "url": "https://recollect.a.ssl.fastly.net/api/places/08E862E8-8190-11E2-A8A6-C758AE7205AF/services/226/events.en.ics",
+        "split_at": "\\, (?:and )?|(?: and )",
+    },
+    "Erlensee, Am Haspel": {
+        "url": "https://sperrmuell.erlensee.de/?type=reminder",
+        "method": "POST",
+        "params": {
+            "street": 8,
+            "eventType[]": [27, 23, 19, 20, 21, 24, 22, 25, 26],
+            "timeframe": 23,
+            "download": "ical",
+        },
+    },
+    "UTF-8-SIG (UTF-8 with BOM)": {
+        "url": "https://servicebetrieb.koblenz.de/abfallwirtschaft/entsorgungstermine-digital/entsorgungstermine-2023-digital/altstadt-2023.ics?cid=2ui7",
+    },
+}
+
+
+HEADERS = {"user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)"}
+_LOGGER = logging.getLogger(__name__)
+
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "version": "(Deprecated) Version, has no effect anymore",
+        "impersonate": "Browser to impersonate (e.g. 'chrome') to pass TLS-fingerprinting WAFs",
+    },
+    "de": {
+        "url": "URL",
+        "file": "Datei",
+        "offset": "Offset",
+        "params": "Parameter",
+        "year_field": "Jahresfeld",
+        "method": "Methode",
+        "regex": "Regulärer Ausdruck",
+        "title_template": "Titelvorlage",
+        "split_at": "Trennen bei",
+        "version": "(Veraltet) Version, hat keine Auswirkung mehr",
+        "verify_ssl": "SSL-Verifizierung aktivieren",
+        "headers": "Headers",
+        "impersonate": "Zu imitierender Browser (z.B. 'chrome'), um TLS-Fingerprinting-WAFs zu passieren",
+    },
+}
+
+
+class Source:
+    def __init__(
+        self,
+        url: str | None = None,
+        file: str | None = None,
+        offset: int | None = None,
+        params: dict | None = None,
+        year_field: str | None = None,
+        method: Literal["POST", "GET"] = "GET",
+        regex: str | None = None,
+        title_template: str = "{{date.summary}}",
+        split_at: str | None = None,
+        version: int | None = None,
+        verify_ssl: bool = True,
+        headers: dict | None = None,
+        impersonate: str | None = None,
+    ):
+        if headers is None:
+            headers = {}
+        self._url = re.sub("^webcal", "https", url) if url else None
+        self._file = file
+        if bool(self._url is not None) == bool(self._file is not None):
+            raise SourceArgumentExceptionMultiple(
+                ("url", "file"), "Specify either url or file"
+            )
+        if version is not None:
+            _LOGGER.warning(
+                "The 'version' parameter is deprecated and has no effect anymore."
+            )
+
+        self._ics = ICS(
+            offset=offset,
+            split_at=split_at,
+            regex=regex,
+            title_template=title_template,
+        )
+        self._params = params
+        self._year_field = year_field  # replace this field in params with current year
+        self._method = method  # The method to send the params
+        self._verify_ssl = verify_ssl
+        self._headers = HEADERS
+        self._headers.update(headers)
+        self._impersonate = impersonate
+
+    def fetch(self):
+        if self._url is not None:
+            if "{%Y}" in self._url or self._year_field is not None:
+                # url contains wildcard or params contains year field
+                now = datetime.datetime.now()
+
+                # replace year in url
+                url = self._url.replace("{%Y}", str(now.year))
+
+                # replace year in params
+                if self._year_field is not None:
+                    if self._params is None:
+                        raise SourceArgumentExceptionMultiple(
+                            ("params", "year_field"),
+                            "year_field specified without params",
+                        )
+                    self._params[self._year_field] = str(now.year)
+
+                entries = self.fetch_url(url, self._params)
+
+                if now.month == 12:
+                    # also get data for next year if we are already in december
+                    url = self._url.replace("{%Y}", str(now.year + 1))
+                    if self._year_field is not None:
+                        self._params[self._year_field] = str(now.year + 1)
+
+                    try:
+                        entries.extend(self.fetch_url(url, self._params))
+                    except Exception:
+                        # ignore if fetch for next year fails
+                        pass
+                return entries
+            return self.fetch_url(self._url, self._params)
+        if self._file is not None:
+            return self.fetch_file(self._file)
+
+    def fetch_url(self, url, params=None):
+        # curl_cffi stringifies list-valued params as Python repr instead of
+        # repeating the key like `requests` does; flatten to (key, value) pairs.
+        flat_params = (
+            [
+                (k, item)
+                for k, v in params.items()
+                for item in (v if isinstance(v, list) else [v])
+            ]
+            if params
+            else None
+        )
+
+        if self._method == "GET":
+            r = requests.get(
+                url,
+                params=flat_params,
+                headers=self._headers,
+                verify=self._verify_ssl,
+                impersonate=self._impersonate,
+            )
+        elif self._method == "POST":
+            r = requests.post(
+                url,
+                data=flat_params,
+                headers=self._headers,
+                verify=self._verify_ssl,
+                impersonate=self._impersonate,
+            )
+        else:
+            raise SourceArgumentNotFoundWithSuggestions(
+                "method",
+                self._method,
+                ["GET", "POST"],
+            )
+
+        r.raise_for_status()
+
+        if r.content.startswith(b"\xef\xbb\xbf"):
+            r.encoding = "UTF-8-SIG"
+        else:
+            r.encoding = "utf-8"
+
+        return self._convert(r.text)
+
+    def fetch_file(self, file: str):
+        try:
+            path = Path(file)
+            with path.open() as f:
+                text = f.read()
+        except FileNotFoundError as e:
+            _LOGGER.error(f"Working directory: '{getcwd()}'")
+            raise SourceArgumentException(
+                "file", f"File '{path.resolve()}' not found"
+            ) from e
+        return self._convert(text)
+
+    def _convert(self, data):
+        entries = []
+        for ev in self._ics.convert_events(data):
+            entries.append(
+                Collection(
+                    ev.date,
+                    ev.title,
+                    location=ev.location,
+                    description=ev.description,
+                )
+            )
+        return entries

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

@@ -0,0 +1,50 @@
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.service.SiteparkIES import SiteparkIES, match_icon
+
+TITLE = "Abfallwirtschaftsbetrieb Ilm-Kreis"
+DESCRIPTION = "Source for Abfallwirtschaftsbetrieb Ilm-Kreis waste collection."
+URL = "https://www.ilm-kreis.de"
+COUNTRY = "de"
+TEST_CASES = {
+    "Gerhart-Hauptmann-Straße (Arnstadt)": {
+        "strasse": "Gerhart-Hauptmann-Straße",
+        "ort": "Arnstadt",
+    },
+    "Ackermannstraße (Ilmenau)": {"strasse": "Ackermannstraße", "ort": "Ilmenau"},
+}
+
+API_URL = "https://aik.ilm-kreis.de"
+
+ICON_MAP = {
+    "Bioabfall": Icons.BIO_KITCHEN,
+    "Elektroschrott": Icons.ELECTRONICS,
+    "Leichtverpackung": Icons.PLASTIC_PACKAGING,
+    "Papier": Icons.PAPER,
+    "Restabfall": Icons.GENERAL_WASTE,
+    "Sonderabfall": Icons.HAZARDOUS,
+}
+
+PARAM_TRANSLATIONS = {
+    "de": {
+        "strasse": "Straße",
+        "ort": "Ort",
+    },
+    "en": {
+        "strasse": "Street",
+        "ort": "Place",
+    },
+}
+
+
+class Source:
+    def __init__(self, strasse, ort=None):
+        self._strasse = strasse
+        self._ort = ort
+        self._sitepark = SiteparkIES(API_URL)
+
+    def fetch(self):
+        dates = self._sitepark.fetch(strasse=self._strasse, ort=self._ort)
+        return [
+            Collection(date, waste_type, match_icon(waste_type, ICON_MAP))
+            for date, waste_type in dates
+        ]