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

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

@@ -0,0 +1,264 @@
+from datetime import datetime
+from typing import Literal
+
+import requests
+from waste_collection_schedule import Collection, Icons
+from waste_collection_schedule.exceptions import (
+    SourceArgumentNotFoundWithSuggestions,
+)
+from waste_collection_schedule.service.ICS import ICS
+
+TITLE = "Lobbe App"
+DESCRIPTION = "Source for Lobbe App."
+URL = "https://lobbe.app/"
+TEST_CASES = {
+    "Hessen Diemelsee Am Breuschelt": {
+        "state": "Hessen",
+        "city": "Diemelsee",
+        "street": "Am Breuschelt",
+    },
+    "Nordrhein-Westfalen Meschede Alte Henne": {
+        "state": "Nordrhein-Westfalen",
+        "city": "Meschede",
+        "street": "Alte Henne",
+    },
+    "Nordrhein-Westfalen Willebadessen Ächternstraße": {
+        "state": "Nordrhein-Westfalen",
+        "city": "Willebadessen",
+        "street": "Ächternstraße",
+    },
+}
+
+
+ICON_MAP = {
+    "restabfall": Icons.GENERAL_WASTE,
+    "Glass": Icons.GLASS,
+    "bioabfall": Icons.BIO_KITCHEN,
+    "altpapier": Icons.PAPER,
+    "gelber": Icons.RECYCLING,
+    "elektroschrott": Icons.ELECTRONICS,
+}
+
+STATES = Literal["Hessen", "Nordrhein-Westfalen"]
+
+
+API_URL = "https://lobbe.app/wp-admin/admin-ajax.php"
+TYPES = {"gelber", "biobfall", "restabfall", "altpapier", "additional_types"}
+
+
+def make_comparable(s: str) -> str:
+    return (
+        s.lower()
+        .replace(" ", "")
+        .replace("-", "")
+        .replace("str.", "straße")
+        .replace("ß", "ss")
+        .replace(".", "")
+        .replace(",", "")
+    )
+
+
+COUNTRY = "de"
+
+PLACES = {
+    "Hessen": [
+        "Allendorf",
+        "Bad Arolsen",
+        "Battenberg",
+        "Bromskirchen",
+        "Burgwald",
+        "Diemelsee",
+        "Diemelstadt",
+        "Edertal",
+        "Frankenau",
+        "Hatzfeld",
+        "Korbach",
+        "Lichtenfels",
+        "Rosenthal",
+        "Twistetal",
+        "Vöhl",
+        "Willingen",
+    ],
+    "Nordrhein-Westfalen": [
+        "Altena",
+        "Altenbeken",
+        "Arnsberg",
+        "Bad Berleburg",
+        "Bad Driburg",
+        "Bad Wünnenberg",
+        "Balve",
+        "Bestwig",
+        "Borchen",
+        "Borgentreich",
+        "Brakel",
+        "Breckerfeld",
+        "Brilon",
+        "Büren",
+        "Delbrück",
+        "Eslohe",
+        "Hallenberg",
+        "Halver",
+        "Hemer",
+        "Iserlohn",
+        "Kierspe",
+        "Lichtenau",
+        "Marienmünster",
+        "Marsberg",
+        "Medebach",
+        "Meinerzhagen",
+        "Menden",
+        "Meschede",
+        "Nachrodt-Wiblingwerde",
+        "Olsberg",
+        "Plettenberg",
+        "Rüthen",
+        "Schalksmühle",
+        # "Schmallenberg", # Listed but is not the current service provider
+        "Steinheim",
+        "Sundern",
+        "Warburg",
+        "Warstein",
+        "Werdohl",
+        "Willebadessen",
+        "Winterberg",
+    ],
+}
+
+
+EXTRA_INFO = [
+    {
+        "title": city,
+        "default_params": {"state": state, "city": city},
+    }
+    for state, cities in PLACES.items()
+    for city in cities
+]
+
+
+class Source:
+    def __init__(self, state: STATES, city: str, street: str):
+        self._state: str = state
+        self._city: str = city
+        self._street: str = street
+        self._ics = ICS()
+
+        self._state_id: int | None = None
+        self._state_name: str | None = None
+        self._city_id: int | None = None
+        self._city_name: str | None = None
+        self._street_id: int | None = None
+        self._street_name: str | None = None
+
+    @staticmethod
+    def _get_id(
+        action: str,
+        compare_to: str,
+        param_name: str,
+        params: dict[str, str | int] | None = None,
+    ) -> tuple[int, str]:
+        if params is None:
+            params = {}
+        params = {"action": action, **params}
+        original_compare_to = compare_to
+        compare_to = make_comparable(compare_to)
+        r = requests.get(API_URL, params=params)
+        r.raise_for_status()
+        data = r.json()
+        for d in data:
+            if make_comparable(d["text"]) == compare_to:
+                return d["id"], d["text"]
+
+        raise SourceArgumentNotFoundWithSuggestions(
+            param_name,
+            original_compare_to,
+            [d["text"] for d in data],
+        )
+
+    def _get_ids(self) -> None:
+        self._state_id, self._state_name = self._get_id("state", self._state, "state")
+        self._city_id, self._city_name = self._get_id(
+            "place", self._city, "city", {"id": self._state_id}
+        )
+        self._street_id, self._street_name = self._get_id(
+            "street", self._street, "street", {"id": self._city_id}
+        )
+
+    def fetch(self) -> list[Collection]:
+        now = datetime.now()
+        entries = self._fetch_year(now.year)
+        if now.month != 12:
+            return entries
+        try:
+            return entries + self._fetch_year(now.year + 1)
+        except Exception:
+            return entries
+
+    def _fetch_year(self, year: int) -> list[Collection]:
+        fresh_id = False
+        if self._street_id is None:
+            self._get_ids()
+            fresh_id = True
+        try:
+            return self._get_collections(year)
+        except Exception:
+            if fresh_id:
+                raise
+            self._get_ids()
+            return self._get_collections(year)
+
+    def _get_collections(self, year: int) -> list[Collection]:
+        params = {
+            "year[id]": 1,
+            "year[text]": year,
+            "state[id]": self._state_id,
+            "state[text]": self._state_name,
+            "place[id]": self._city_id,
+            "place[text]": self._city_name,
+            "street[id]": self._street_id,
+            "street[text]": self._street_name,
+            **dict.fromkeys(TYPES, 1),
+            "hours": 18,
+            "minutes": 00,
+            "action": "create_ical",
+        }
+        r = requests.get(API_URL, params=params)
+        r.raise_for_status()
+
+        ics_url = r.json()["url"]
+
+        r = requests.get(ics_url)
+        r.raise_for_status()
+
+        dates = self._ics.convert(r.text)
+        entries = []
+        for d in dates:
+            entries.append(
+                Collection(d[0], d[1], ICON_MAP.get(d[1].split()[0].lower()))
+            )
+        return entries
+
+
+def _print_extra_info() -> None:
+    params = {
+        "action": "state",
+    }
+    r = requests.get(API_URL, params=params)
+    r.raise_for_status()
+
+    places: dict[str, list[str]] = {}
+
+    for state in r.json():
+        params = {"action": "place", "id": state["id"]}
+        if state["text"] not in places:
+            places[state["text"]] = []
+
+        r = requests.get(API_URL, params=params)
+        r.raise_for_status()
+        for place in r.json():
+            places[state["text"]].append(place["text"])
+
+    print(places, len(places))
+
+
+if __name__ == "__main__":
+    _print_extra_info()

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

@@ -0,0 +1,339 @@
+import re
+from datetime import date, datetime, timedelta
+
+import requests
+from bs4 import BeautifulSoup
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import SourceArgumentNotFoundWithSuggestions
+
+TITLE = "localcities.ch"
+DESCRIPTION = "Source for waste collection schedules from localcities.ch (Switzerland)."
+URL = "https://www.localcities.ch"
+COUNTRY = "ch"
+
+TEST_CASES = {
+    "Volketswil - Hegnau": {
+        "municipality": "volketswil",
+        "municipality_id": "529",
+        "zone": "Hegnau",
+    },
+    "Volketswil - Kindhausen, Zimikon, Gutenswil": {
+        "municipality": "volketswil",
+        "municipality_id": "529",
+        "zone": "Kindhausen, Zimikon, Gutenswil",
+    },
+    "Grenchen - Zone Ost": {
+        "municipality": "grenchen",
+        "municipality_id": "3533",
+        "zone": "Zone Ost",
+    },
+    "Grenchen - Zone West": {
+        "municipality": "grenchen",
+        "municipality_id": "3533",
+        "zone": "Zone West",
+    },
+    "Büren an der Aare": {
+        "municipality": "bueren-an-der-aare",
+        "municipality_id": "849",
+        "zone": "",
+    },
+    "Liestal - Kreis 1": {
+        "municipality": "liestal",
+        "municipality_id": "3833",
+        "zone": "Kreis 1",
+    },
+    "Therwil": {
+        "municipality": "therwil",
+        "municipality_id": "3757",
+        "zone": "",
+    },
+    "Beinwil am See (zoneless)": {
+        "municipality": "beinwil-am-see",
+        "municipality_id": "5313",
+    },
+    "Monthey (zoneless)": {
+        "municipality": "monthey",
+        "municipality_id": "8085",
+    },
+    "Zofingen": {
+        "municipality": "zofingen",
+        "municipality_id": "5741",
+    },
+}
+
+EXTRA_INFO = [
+    {
+        "title": "Volketswil",
+        "url": "https://www.volketswil.ch",
+        "country": "ch",
+        "default_params": {
+            "municipality": "volketswil",
+            "municipality_id": "529",
+        },
+    },
+    {
+        "title": "Grenchen",
+        "url": "https://www.grenchen.ch",
+        "country": "ch",
+        "default_params": {
+            "municipality": "grenchen",
+            "municipality_id": "3533",
+        },
+    },
+    {
+        "title": "Wangen bei Olten",
+        "url": "https://www.wangen-bei-olten.ch",
+        "country": "ch",
+        "default_params": {
+            "municipality": "wangen-bei-olten",
+            "municipality_id": "3629",
+        },
+    },
+    {
+        "title": "Büren an der Aare",
+        "url": "https://www.bueren.ch",
+        "country": "ch",
+        "default_params": {
+            "municipality": "bueren-an-der-aare",
+            "municipality_id": "849",
+        },
+    },
+    {
+        "title": "Liestal",
+        "url": "https://www.liestal.ch",
+        "country": "ch",
+        "default_params": {
+            "municipality": "liestal",
+            "municipality_id": "3833",
+        },
+    },
+    {
+        "title": "Therwil",
+        "url": "https://www.therwil.ch",
+        "country": "ch",
+        "default_params": {
+            "municipality": "therwil",
+            "municipality_id": "3757",
+        },
+    },
+    {
+        "title": "Beinwil am See",
+        "url": "https://www.beinwil-am-see.ch",
+        "country": "ch",
+        "default_params": {
+            "municipality": "beinwil-am-see",
+            "municipality_id": "5313",
+        },
+    },
+    {
+        "title": "Monthey",
+        "url": "https://www.monthey.ch",
+        "country": "ch",
+        "default_params": {
+            "municipality": "monthey",
+            "municipality_id": "8085",
+        },
+    },
+    {
+        "title": "Zofingen",
+        "url": "https://www.zofingen.ch",
+        "country": "ch",
+        "default_params": {
+            "municipality": "zofingen",
+            "municipality_id": "5741",
+        },
+    },
+]
+
+ICON_MAP = {
+    "Altpapier": Icons.PAPER,
+    "Grünabfälle": Icons.ORGANIC,
+    "Karton": Icons.PAPER,
+    "Altglas": Icons.GLASS,
+    "Altmetall": Icons.METAL,
+}
+
+BASE_URL = "https://www.localcities.ch/de/entsorgung"
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": "Visit your municipality's page on localcities.ch. The municipality name and ID are in the URL (e.g. /de/entsorgung/volketswil/529). The zone is shown next to each waste collection entry on the calendar. If your municipality does not use zones, you may omit the zone parameter.",
+    "de": "Besuchen Sie die Seite Ihrer Gemeinde auf localcities.ch. Der Gemeindename und die ID sind in der URL (z.B. /de/entsorgung/volketswil/529). Die Zone wird neben jedem Entsorgungstermin angezeigt. Wenn Ihre Gemeinde keine Zonen verwendet, kann der Zone-Parameter weggelassen werden.",
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "municipality": "Municipality URL slug (from the localcities.ch URL)",
+        "municipality_id": "Municipality ID number (from the localcities.ch URL)",
+        "zone": "Collection zone or locality name (optional — omit for municipalities without zones)",
+    },
+    "de": {
+        "municipality": "URL-Name der Gemeinde (aus der localcities.ch URL)",
+        "municipality_id": "Gemeinde-ID (aus der localcities.ch URL)",
+        "zone": "Sammelzone oder Ortsname (optional – weglassen für Gemeinden ohne Zonen)",
+    },
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "municipality": "Municipality",
+        "municipality_id": "Municipality ID",
+        "zone": "Zone",
+    },
+    "de": {
+        "municipality": "Gemeinde",
+        "municipality_id": "Gemeinde-ID",
+        "zone": "Zone",
+    },
+}
+
+HEADERS = {
+    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+    "Accept-Language": "de-CH,de;q=0.9",
+    "User-Agent": (
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) "
+        "AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.0 Safari/605.1.15"
+    ),
+}
+
+
+class Source:
+    def __init__(
+        self, municipality: str, municipality_id: str | int, zone: str | None = None
+    ):
+        self._municipality = municipality.strip().lower()
+        self._municipality_id = str(municipality_id).strip()
+        self._zone = (
+            zone.strip() if isinstance(zone, str) and zone.strip() != "" else None
+        )
+
+    def fetch(self) -> list[Collection]:
+        base_url = f"{BASE_URL}/{self._municipality}/{self._municipality_id}"
+        entries: list[Collection] = []
+        discovered_zones: set[str] = set()
+        page = 1
+
+        while True:
+            url = base_url if page == 1 else f"{base_url}?page={page}"
+            response = requests.get(url, headers=HEADERS, timeout=30)
+            response.raise_for_status()
+
+            soup = BeautifulSoup(response.text, "html.parser")
+            result_list = soup.find("div", attrs={"data-js-result-list": True})
+            if result_list is None:
+                break
+
+            date_rows = result_list.find_all("div", class_="row", recursive=False)
+            if not date_rows:
+                break
+
+            for row in date_rows:
+                date_col = row.find("div", class_="waste-calender-list__date")
+                if date_col is None:
+                    continue
+                date_heading = date_col.find(["h2", "h3"])
+                if date_heading is None:
+                    continue
+
+                date_text = date_heading.get_text(strip=True)
+                today = date.today()
+
+                if date_text == "Heute":
+                    collection_date = today
+                elif date_text == "Morgen":
+                    collection_date = today + timedelta(days=1)
+                else:
+                    year = self._find_year_for_date(result_list, row)
+                    try:
+                        collection_date = datetime.strptime(
+                            f"{date_text}.{year}", "%d.%m.%Y"
+                        ).date()
+                    except ValueError:
+                        continue
+
+                waste_items = row.find_all(
+                    "div",
+                    class_=re.compile(r"waste-calendar-list-item-small"),
+                )
+
+                for item in waste_items:
+                    img = item.find("img", alt=True)
+                    if not img:
+                        continue
+
+                    waste_type = str(img["alt"])
+                    zone_text = self._extract_zone_text(item, waste_type)
+                    discovered_zones.add(zone_text)
+
+                    if self._zone is None or zone_text == self._zone:
+                        entries.append(
+                            Collection(
+                                date=collection_date,
+                                t=waste_type,
+                                icon=ICON_MAP.get(waste_type),
+                            )
+                        )
+
+            load_more = soup.find(
+                "input",
+                attrs={"data-js-results-load-more-next-page": True},
+            )
+            if load_more is None:
+                # Also check for button element
+                load_more = soup.find(
+                    "button",
+                    attrs={"data-js-results-load-more-next-page": True},
+                )
+            if load_more is None:
+                break
+
+            next_page_str = load_more.get("data-js-results-load-more-next-page")
+            if next_page_str is None:
+                break
+            if isinstance(next_page_str, list):
+                next_page_str = next_page_str[0] if next_page_str else None
+            if next_page_str is None:
+                break
+            try:
+                next_page = int(next_page_str)
+            except (ValueError, TypeError):
+                break
+
+            if next_page <= page:
+                break
+            page = next_page
+
+        if not entries and self._zone is not None and discovered_zones:
+            raise SourceArgumentNotFoundWithSuggestions(
+                "zone", self._zone, sorted(discovered_zones)
+            )
+
+        return entries
+
+    @staticmethod
+    def _extract_zone_text(waste_item, waste_type: str) -> str:
+        item_text = waste_item.get_text(strip=True)
+        if item_text.startswith(waste_type):
+            item_text = item_text[len(waste_type) :].strip()
+        return item_text
+
+    @staticmethod
+    def _find_year_for_date(result_list, current_row) -> int:
+        children = list(result_list.children)
+        current_year = datetime.now().year
+        last_year = current_year
+
+        for child in children:
+            if child == current_row:
+                return last_year
+
+            if hasattr(child, "name") and child.name == "h1":
+                headline_class = child.get("class", [])
+                if any("calendar-list__headline" in c for c in headline_class):
+                    span = child.find("span")
+                    if span:
+                        try:
+                            last_year = int(span.get_text(strip=True))
+                        except ValueError:
+                            pass
+
+        return last_year