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

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

@@ -0,0 +1,132 @@
+import re
+import urllib.parse
+
+import requests
+from bs4 import BeautifulSoup
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import (
+    SourceArgumentNotFoundWithSuggestions,
+)
+from waste_collection_schedule.service.ICS import ICS
+
+TITLE = "AWIGO Abfallwirtschaft Landkreis Osnabrück GmbH"
+DESCRIPTION = "Source for AWIGO Abfallwirtschaft Landkreis Osnabrück GmbH."
+URL = "https://www.awigo.de/"
+TEST_CASES = {
+    "Bippen Am Bad 4": {"ort": "Bippen", "strasse": "Am Bad", "hnr": 4},
+    "fürstenau, Am Gültum, 9": {"ort": "Fürstenau", "strasse": "Am Gültum", "hnr": 9},
+    "Melle, Allee, 78-80": {"ort": "Melle", "strasse": "Allee", "hnr": "78-80"},
+    "Berge": {"ort": "Berge", "strasse": "Poststr.", "hnr": 3},
+}
+
+
+ICON_MAP = {
+    "Restmülltonne": Icons.GENERAL_WASTE,
+    "Glass": Icons.GLASS,
+    "Bio-Tonne": Icons.ORGANIC,
+    "Papiermülltonne": Icons.PAPER,
+    "Gelbe Tonne/Gelben Sack": Icons.PLASTIC_PACKAGING,
+}
+
+
+API_URL = "https://www.awigo.de/index.php"
+
+
+def compare_cities(a: str, b: str) -> bool:
+    return (
+        re.sub(r"\([0-9]+\)", "", a.lower()).strip()
+        == re.sub(r"\([0-9]+\)", "", b.lower()).strip()
+    )
+
+
+class Source:
+    def __init__(self, ort: str, strasse: str, hnr: str | int):
+        self._ort: str = str(ort)
+        self._strasse: str = strasse
+        self._hnr: str = str(hnr)
+        self._ics = ICS()
+
+    def fetch(self):
+        entries = []
+        waste_types = ["rest", "paper", "yellow", "brown", "mobile"]
+
+        # Note: the AWIGO API has a bug where requesting getICSfile with only
+        # a single waste type enabled (e.g. only "rest" or only "paper")
+        # returns an ICS file containing only headers and no events. As soon
+        # as at least two waste types are requested together, it works fine.
+        # We therefore always request all waste types together in a single
+        # call; each ICS event already carries its own waste-type name, so no
+        # server-side filtering is lost by doing this. See GitHub issue #4562.
+        s = requests.Session()
+        args = {
+            "legacy_eID": "awigoCalendar",
+            "calendar[method]": "getCities",
+        }
+
+        for wt in waste_types:
+            args[f"calendar[{wt}]"] = "1"
+
+        r = s.post(API_URL, params=urllib.parse.urlencode(args, safe="[]"))
+
+        r.raise_for_status()
+
+        soup = BeautifulSoup(r.text, features="html.parser")
+        for option in soup.find_all("option"):
+            if compare_cities(self._ort, option.text):
+                args["calendar[cityID]"] = str(option.get("value"))
+                break
+        if "calendar[cityID]" not in args:
+            raise SourceArgumentNotFoundWithSuggestions(
+                "ort", self._ort, [option.text for option in soup.find_all("option")]
+            )
+
+        args["calendar[method]"] = "getStreets"
+
+        r = s.post(API_URL, params=urllib.parse.urlencode(args, safe="[]"))
+        r.raise_for_status()
+
+        soup = BeautifulSoup(r.text, features="html.parser")
+        for option in soup.find_all("option"):
+            if option.text.lower().strip() == self._strasse.lower().strip():
+                value = option.get("value")
+                if value:
+                    args["calendar[streetID]"] = str(value)
+                break
+        if "calendar[streetID]" not in args:
+            raise SourceArgumentNotFoundWithSuggestions(
+                "strasse",
+                self._strasse,
+                [option.text for option in soup.find_all("option")],
+            )
+
+        args["calendar[method]"] = "getNumbers"
+        r = s.post(API_URL, params=urllib.parse.urlencode(args, safe="[]"))
+        r.raise_for_status()
+        soup = BeautifulSoup(r.text, features="html.parser")
+        for option in soup.find_all("option"):
+            if option.text.lower().strip().replace(
+                " ", ""
+            ) == self._hnr.lower().strip().replace(" ", ""):
+                value = option.get("value")
+                if value:
+                    args["calendar[locationID]"] = str(value)
+                break
+        if "calendar[locationID]" not in args:
+            raise SourceArgumentNotFoundWithSuggestions(
+                "hnr", self._hnr, [option.text for option in soup.find_all("option")]
+            )
+
+        args["calendar[method]"] = "getICSfile"
+        r = s.post(API_URL, params=urllib.parse.urlencode(args, safe="[]"))
+        r.raise_for_status()
+        ics_url = r.text.strip()
+        r = s.get(ics_url)
+        r.raise_for_status()
+        r.encoding = "utf-8"
+
+        dates = self._ics.convert(r.text)
+        for d in dates:
+            bin_type = d[1].replace("wird abgeholt.", "").strip()
+            entries.append(Collection(d[0], bin_type, ICON_MAP.get(bin_type)))
+
+        return entries

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

@@ -0,0 +1,220 @@
+import json
+import re
+
+import requests
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import (
+    SourceArgumentNotFoundWithSuggestions,
+    SourceArgumentRequired,
+)
+
+from ..service.ICS import ICS
+
+TITLE = "AWISTA Kommunal GmbH (Düsseldorf)"
+DESCRIPTION = "Source for AWISTA Kommunal GmbH, Düsseldorf, Germany."
+URL = "https://www.awista-kommunal.de/abfallkalender"
+COUNTRY = "de"
+
+TEST_CASES = {
+    "Merkurstraße 45": {"street": "Merkurstraße", "house_number": "45"},
+    "Freiligrathstraße 19": {"street": "Freiligrathstraße", "house_number": "19"},
+    "Sommersstraße 9 (UUID)": {"uuid": "5d1c4832-fd49-4fa7-a4e3-60dbe116cbc0"},
+}
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": (
+        "Provide your 'street' and 'house_number' as you would type them into the "
+        "address search at https://www.awista-kommunal.de/abfallkalender. "
+        "Alternatively, search for your address on that page and copy the UUID "
+        "from the browser URL bar (e.g. "
+        "https://www.awista-kommunal.de/abfallkalender/<uuid>) into the 'uuid' "
+        "argument; if 'uuid' is given, the address arguments are ignored."
+    ),
+    "de": (
+        "Geben Sie 'street' (Straße) und 'house_number' (Hausnummer) so an, wie Sie "
+        "sie in die Adresssuche auf "
+        "https://www.awista-kommunal.de/abfallkalender eingeben würden. "
+        "Alternativ können Sie Ihre Adresse auf dieser Seite suchen und die UUID aus "
+        "der Adresszeile des Browsers kopieren (z. B. "
+        "https://www.awista-kommunal.de/abfallkalender/<uuid>) und als Argument "
+        "'uuid' angeben; wird 'uuid' angegeben, werden die Adressargumente ignoriert."
+    ),
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "street": "Street",
+        "house_number": "House number",
+        "uuid": "UUID (optional)",
+    },
+    "de": {
+        "street": "Straße",
+        "house_number": "Hausnummer",
+        "uuid": "UUID (optional)",
+    },
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "street": "Street name, e.g. 'Merkurstraße'.",
+        "house_number": "House number, e.g. '45'.",
+        "uuid": "Pre-resolved address UUID. If set, the address lookup is skipped.",
+    },
+    "de": {
+        "street": "Straßenname, z. B. 'Merkurstraße'.",
+        "house_number": "Hausnummer, z. B. '45'.",
+        "uuid": "Vorab aufgelöste Adress-UUID. Wenn gesetzt, entfällt die Adresssuche.",
+    },
+}
+
+SOURCE_CODEOWNERS = ["@Zaunei"]
+
+ICON_MAP = {
+    "Restmüll": Icons.GENERAL_WASTE,
+    "Bioabfall": Icons.BIO_KITCHEN,
+    "Papier": Icons.PAPER,
+    "Wertstofftonne": Icons.RECYCLING,
+}
+
+DOMAIN = "https://www.awista-kommunal.de"
+BASE_URL = f"{DOMAIN}/abfallkalender"
+
+
+class Source:
+    def __init__(
+        self,
+        street: str | None = None,
+        house_number: str | None = None,
+        uuid: str | None = None,
+    ):
+        self._street = street
+        self._house_number = house_number
+        self._uuid = uuid
+        self._next_action: str | None = None
+        self._action_candidates: list[str] | None = None
+        self._ics = ICS()
+
+        if not uuid and not (street and house_number):
+            raise SourceArgumentRequired(
+                "street",
+                "either 'uuid' or both 'street' and 'house_number' must be provided.",
+            )
+
+    def _action_id_candidates(self, session: requests.Session) -> list[str]:
+        """Scrape candidate Next.js server-action ids from the page's JS chunks.
+
+        The bundles contain several 40+ hex strings tagged ``searchAddressAction``
+        (the current id plus stale ones from older builds), so we collect every
+        candidate rather than trusting the first match and let the caller
+        validate which one the live deployment actually accepts.
+        """
+        if self._action_candidates is not None:
+            return self._action_candidates
+
+        page = session.get(BASE_URL, timeout=30)
+        page.raise_for_status()
+
+        # Script tags carry a `?dpl=<deployment>` query suffix, so match the
+        # `.js` path and allow (and discard) the trailing query string.
+        chunk_paths = re.findall(
+            r'src="(/_next/static/chunks/[^"?]+\.js)(?:\?[^"]*)?"', page.text
+        )
+
+        candidates: list[str] = []
+        for path in dict.fromkeys(chunk_paths):
+            try:
+                chunk = session.get(DOMAIN + path, timeout=30)
+                chunk.raise_for_status()
+            except requests.RequestException:
+                continue
+
+            for match in re.finditer(
+                r'"([0-9a-f]{40,})"[\s\S]{0,120}?searchAddressAction', chunk.text
+            ):
+                if match.group(1) not in candidates:
+                    candidates.append(match.group(1))
+
+        self._action_candidates = candidates
+        return candidates
+
+    def _search_address(
+        self, session: requests.Session, action: str, address: str
+    ) -> dict | None:
+        """Run the address search for one action id.
+
+        Returns the parsed payload if ``action`` is honored by the live
+        deployment, or ``None`` if the id is stale/invalid so the caller can
+        fall through to the next candidate.
+        """
+        response = session.post(
+            BASE_URL,
+            headers={
+                "content-type": "text/plain;charset=UTF-8",
+                "accept": "text/x-component",
+                "next-action": action,
+            },
+            data=json.dumps([address]),
+            timeout=30,
+        )
+        if response.status_code != 200:
+            return None
+
+        for line in response.text.splitlines():
+            if line.startswith("1:"):
+                return json.loads(line[2:])
+        return None
+
+    def _resolve_uuid(self, session: requests.Session) -> str:
+        address = f"{self._street} {self._house_number}"
+
+        candidates = self._action_id_candidates(session)
+        # Prefer an id already validated on a previous fetch of this instance.
+        if self._next_action and self._next_action in candidates:
+            candidates = [self._next_action] + [
+                c for c in candidates if c != self._next_action
+            ]
+
+        payload: dict | None = None
+        for action in candidates:
+            payload = self._search_address(session, action, address)
+            if payload is not None:
+                self._next_action = action
+                break
+
+        if payload is None:
+            raise RuntimeError(
+                "Could not find a working searchAddressAction id at "
+                f"{BASE_URL}; the site layout may have changed."
+            )
+
+        items = payload.get("items") or []
+        if not items and payload.get("addressIdForQuery"):
+            return payload["addressIdForQuery"]
+
+        if not items:
+            raise SourceArgumentNotFoundWithSuggestions(
+                "street",
+                address,
+                [],
+            )
+
+        return items[0]["id"]
+
+    def fetch(self) -> list[Collection]:
+        session = requests.Session()
+
+        uuid = self._uuid or self._resolve_uuid(session)
+
+        response = session.get(f"{BASE_URL}/{uuid}/calendar.ics", timeout=30)
+        response.raise_for_status()
+
+        dates = self._ics.convert(response.text)
+
+        entries: list[Collection] = []
+        for d, summary in dates:
+            # Summaries look like "Restmüll (Vollservice)"; strip the service-tier suffix.
+            waste_type = summary.split(" (")[0].strip()
+            icon = ICON_MAP.get(waste_type)
+            entries.append(Collection(d, waste_type, icon=icon))
+
+        return entries

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

@@ -0,0 +1,117 @@
+import datetime
+import json
+
+import requests
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import (
+    SourceArgumentExceptionMultiple,
+    SourceArgumentNotFoundWithSuggestions,
+)
+
+TITLE = "AWL Neuss"  # Title will show up in README.md and info.md
+DESCRIPTION = (
+    "Source for Bürgerportal AWL Neuss waste collection."  # Describe your source
+)
+URL = "https://buergerportal.awl-neuss.de/"  # Insert url to service homepage. URL will show up in README.md and info.md
+TEST_CASES = {  # Insert arguments for test cases to be used by test_sources.py script
+    "Neuss, Theodor-Heuss-Platz 13": {"street_code": 8650, "building_number": 13},
+    "Neuss, Niederstrasse 42": {"street_code": 6810, "building_number": 42},
+    "Neuss, Bahnhofstrasse 67": {
+        "street_name": "Bahnhofstrasse",
+        "building_number": 67,
+    },
+    "Neuss, Bismarckstrasse 52": {
+        "street_name": "Bismarckstrasse",
+        "building_number": 52,
+    },
+    "Neuss, Karlsstrasse 1 (5200)": {"street_code": "5200", "building_number": 1},
+}
+
+API_URL = "https://buergerportal.awl-neuss.de/api/v1/calendar"
+ICON_MAP = {
+    "grau": Icons.GENERAL_WASTE,
+    "pink": Icons.GENERAL_WASTE,
+    "braun": Icons.ORGANIC,
+    "blau": Icons.PAPER,
+    "gelb": Icons.RECYCLING,
+}
+
+
+PARAM_TRANSLATIONS = {
+    "de": {
+        "building_number": "Hausnummer",
+        "street_name": "Straßenname",
+        "street_code": "Straßencode",
+    }
+}
+
+
+class Source:
+    def __init__(
+        self,
+        building_number: int,
+        street_name: str | None = None,
+        street_code: int | None = None,
+    ):
+        self._street_name: str | None = street_name
+        self._street_code: int | None = street_code
+        self._building_number: int = building_number
+
+        if not self._street_name and not self._street_code:
+            raise SourceArgumentExceptionMultiple(
+                ["street_name", "street_code"],
+                "Please provide either street_name or street_code",
+            )
+
+    def fetch(self):
+        # get street code if not set with street
+        if self._street_code is None:
+            t = requests.get(API_URL + "/townarea-streets")
+            data_street = json.loads(t.text)
+
+            street_list = []
+            for item in data_street:
+                if item["strasseBezeichnung"] == self._street_name:
+                    street_list.append(item)
+
+            if len(street_list) == 0:
+                raise SourceArgumentNotFoundWithSuggestions(
+                    "street_name",
+                    self._street_name,
+                    suggestions=[item["strasseBezeichnung"] for item in data_street],
+                )
+            self._street_code = street_list[0]["strasseNummer"]
+
+        args = {
+            "streetNum": self._street_code,
+            "homeNummber": self._building_number,
+        }
+
+        now = datetime.datetime.now()
+        args["startMonth"] = now.year
+        args["isTreeMonthRange"] = "false"
+        args["isYear"] = "true"
+
+        # get json file
+        r = requests.get(API_URL, params=args)
+
+        data = json.loads(r.text)
+
+        entries = []  # List that holds collection schedule
+        for key, value in data.items():
+            month_year: list[str] = key.split("-")
+            month: int = int(month_year[0]) + 1
+            year: int = int(month_year[1])
+
+            for dayValue, wastes in value.items():
+                day: int = int(dayValue)
+                for waste in wastes:
+                    entries.append(
+                        Collection(
+                            date=datetime.date(year, month, day),  # Collection date
+                            t=waste,  # Collection type
+                            icon=ICON_MAP.get(waste),  # Collection icon
+                        )
+                    )
+
+        return entries