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

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

@@ -0,0 +1,248 @@
+from datetime import datetime
+from html.parser import HTMLParser
+
+import requests
+from waste_collection_schedule import Collection  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import (
+    SourceArgumentNotFound,
+    SourceArgumentNotFoundWithSuggestions,
+)
+from waste_collection_schedule.service.ICS import ICS
+
+TITLE = "RegioEntsorgung Städteregion Aachen"
+DESCRIPTION = "RegioEntsorgung Städteregion Aachen"
+URL = "https://regioentsorgung.de"
+TEST_CASES = {
+    "Merzbrück": {"city": "Würselen", "street": "Merzbrück", "house_number": 200},
+    "Krefelder Straße": {
+        "city": "Würselen",
+        "street": "Krefelder Straße",
+        "house_number": 10,
+    },
+}
+
+API_URL = "https://tonnen.regioentsorgung.de/WasteManagementRegioentsorgung/WasteManagementServlet"
+
+HEADERS = {
+    "User-Agent": "Mozilla/5.0 (Windows NT 6.1; Win64; x64)",
+}
+
+
+PARAM_TRANSLATIONS = {
+    "de": {
+        "city": "Ort",
+        "street": "Straße",
+        "house_number": "Hausnummer",
+    },
+}
+
+CITIES = [
+    "Alsdorf",
+    "Baesweiler",
+    "Eschweiler",
+    "Heimbach",
+    "Herzogenrath",
+    "Inden",
+    "Langerwehe",
+    "Linnich",
+    "Monschau",
+    "Nideggen",
+    "Niederzier",
+    "Nörvenich",
+    "Roetgen",
+    "Simmerath",
+    "Stolberg",
+    "Vettweiß",
+    "Würselen",
+]
+
+EXTRA_INFO = [{"title": city, "default_params": {"city": city}} for city in CITIES]
+
+
+class FormStateParser(HTMLParser):
+    def __init__(self):
+        super().__init__()
+        self.select_options = {}
+        self._current_select = None
+        self._current_option_value = None
+        self._current_option_text = []
+
+    def _finalize_option(self):
+        if self._current_select is None or self._current_option_value is None:
+            return
+
+        text = " ".join(part.strip() for part in self._current_option_text).strip()
+        self.select_options[self._current_select].append(
+            (self._current_option_value or "", text)
+        )
+        self._current_option_value = None
+        self._current_option_text = []
+
+    def finalize(self):
+        self._finalize_option()
+
+    def handle_starttag(self, tag, attrs):
+        attributes = dict(attrs)
+        if tag == "select" and "name" in attributes:
+            self._finalize_option()
+            self._current_select = attributes["name"]
+            self.select_options.setdefault(self._current_select, [])
+        elif tag == "option" and self._current_select is not None:
+            self._finalize_option()
+            self._current_option_value = attributes.get("value", "")
+            self._current_option_text = []
+
+    def handle_data(self, data):
+        if self._current_option_value is not None:
+            self._current_option_text.append(data)
+
+    def handle_endtag(self, tag):
+        if tag == "option":
+            self._finalize_option()
+        elif tag == "select":
+            self._finalize_option()
+            self._current_select = None
+
+    def get_options(self, field_name):
+        return [
+            text or value
+            for value, text in self.select_options.get(field_name, [])
+            if (text or value)
+        ]
+
+
+def parse_form_state(content):
+    parser = FormStateParser()
+    parser.feed(content)
+    parser.finalize()
+    parser.close()
+    return parser
+
+
+def normalize_option_value(value):
+    return " ".join(str(value).split()).casefold()
+
+
+def resolve_option(field_name, value, options):
+    if value in options:
+        return value
+
+    normalized_options = {normalize_option_value(option): option for option in options}
+    normalized_value = normalize_option_value(value)
+
+    if normalized_value in normalized_options:
+        return normalized_options[normalized_value]
+
+    if options:
+        raise SourceArgumentNotFoundWithSuggestions(field_name, value, options)
+    raise SourceArgumentNotFound(
+        field_name,
+        value,
+        "please check the other address arguments and try again.",
+    )
+
+
+class Source:
+    def __init__(self, city, street, house_number):
+        self.city = city
+        self.street = street
+        self.house_number = house_number
+        self._ics = ICS()
+
+    def fetch(self):
+        now = datetime.now()
+        year = now.year
+        entries = self.get_collection(year)
+        if now.month == 12:
+            entries += self.get_collection(year + 1)
+        return entries
+
+    def get_collection(self, year):
+        # Use a session to keep cookies
+        session = requests.Session()
+
+        payload = {
+            "SubmitAction": "wasteDisposalServices",
+        }
+        r = session.get(API_URL, headers=HEADERS, params=payload)
+        r.raise_for_status()
+        r.encoding = "utf-8"
+
+        form_state = parse_form_state(r.text)
+        city = resolve_option("city", self.city, form_state.get_options("Ort"))
+
+        payload = {
+            "ApplicationName": "com.athos.kd.regioentsorgung.CheckAbfuhrtermineModel",
+            "SubmitAction": "CITYCHANGED",
+            "Ort": city,
+            "Strasse": "",
+            "Hausnummer": "",
+        }
+        r = session.post(API_URL, headers=HEADERS, data=payload)
+        r.raise_for_status()
+        r.encoding = "utf-8"
+
+        form_state = parse_form_state(r.text)
+        street = resolve_option(
+            "street", self.street, form_state.get_options("Strasse")
+        )
+
+        payload = {
+            "ApplicationName": "com.athos.kd.regioentsorgung.CheckAbfuhrtermineModel",
+            "SubmitAction": "STREETCHANGED",
+            "Ort": city,
+            "Strasse": street,
+            "Hausnummer": "",
+        }
+        r = session.post(API_URL, headers=HEADERS, data=payload)
+        r.raise_for_status()
+        r.encoding = "utf-8"
+
+        form_state = parse_form_state(r.text)
+        house_number = resolve_option(
+            "house_number", str(self.house_number), form_state.get_options("Hausnummer")
+        )
+
+        payload = {
+            "ApplicationName": "com.athos.kd.regioentsorgung.CheckAbfuhrtermineModel",
+            "SubmitAction": "forward",
+            "Ort": city,
+            "Strasse": street,
+            "Hausnummer": house_number,
+            "Zeitraum": f"Jahresübersicht {year}",
+        }
+        r = session.post(API_URL, headers=HEADERS, data=payload)
+        r.raise_for_status()
+
+        payload = {
+            "ApplicationName": "com.athos.kd.regioentsorgung.AbfuhrTerminModel",
+            "SubmitAction": "forward",
+        }
+        r = session.post(API_URL, headers=HEADERS, data=payload)
+        r.raise_for_status()
+
+        payload = {
+            "ApplicationName": "com.athos.kd.regioentsorgung.AbfuhrTerminDownloadModel",
+            "ContainerGewaehlt_1": "on",
+            "ContainerGewaehlt_2": "on",
+            "ContainerGewaehlt_3": "on",
+            "ContainerGewaehlt_4": "on",
+            "ContainerGewaehlt_5": "on",
+            "ContainerGewaehlt_6": "on",
+            "ContainerGewaehlt_7": "on",
+            "ContainerGewaehlt_8": "on",
+            "ContainerGewaehlt_9": "on",
+            "ICalErinnerung": "keine Erinnerung",
+            "ICalZeit": "06:00 Uhr",
+            "SubmitAction": "filedownload_ICAL",
+        }
+        r = session.post(API_URL, headers=HEADERS, data=payload)
+        r.raise_for_status()
+
+        # Parse ics file
+        dates = self._ics.convert(r.text)
+
+        entries = []
+        for d in dates:
+            entries.append(Collection(d[0], d[1]))
+        return entries

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

@@ -0,0 +1,111 @@
+import json
+import xml.etree.ElementTree as ET
+from datetime import datetime, timedelta
+from time import time_ns
+
+import bs4
+import requests
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+
+TITLE = "Reigate & Banstead Borough Council"
+DESCRIPTION = "Source for reigate-banstead.gov.uk services for the Reigate & Banstead Borough, UK."
+URL = "https://reigate-banstead.gov.uk"
+TEST_CASES = {
+    "Test_001": {"uprn": 68110755},
+    "Test_002": {"uprn": "000068110755"},
+    "Test_003": {"uprn": "68101147"},  # commercial refuse collection
+    "Test_004": {"uprn": "000068101147"},  # commercial refuse collection
+}
+HEADERS = {
+    "user-agent": "Mozilla/5.0",
+}
+ICON_MAP = {
+    "FOOD WASTE": Icons.BIO_KITCHEN,
+    "MIXED RECYCLING": Icons.RECYCLING,
+    "GLASS": Icons.GLASS,
+    "MIXED CANS": Icons.METAL,
+    "PLASTIC": Icons.PLASTIC_PACKAGING,
+    "PAPER AND CARDBOARD": Icons.PAPER,
+    "TRADE - PAPER AND CARDBOARD": Icons.PAPER,
+    "REFUSE": Icons.GENERAL_WASTE,
+    "TRADE - REFUSE": Icons.GENERAL_WASTE,
+    "GARDEN WASTE": Icons.GARDEN,
+}
+
+
+class Source:
+    def __init__(self, uprn):
+        self._uprn = str(uprn)
+
+    def fetch(self):
+
+        s = requests.Session()
+
+        # This request gets the session ID
+        sid_request = s.get(
+            "https://my.reigate-banstead.gov.uk/authapi/isauthenticated?uri=https%3A%2F%2Fmy.reigate-banstead.gov.uk%2Fservice%2FBins_and_recycling___collections_calendar&hostname=my.reigate-banstead.gov.uk&withCredentials=true",
+            headers=HEADERS,
+        )
+        sid_data = sid_request.json()
+        sid = sid_data["auth-session"]
+
+        # this request gets the 'tokenString' for use later
+        timestamp = time_ns() // 1_000_000  # epoch time in milliseconds
+        token_request = s.get(
+            f"https://my.reigate-banstead.gov.uk/apibroker/runLookup?id=595ce0f243541&repeat_against=&noRetry=true&getOnlyTokens=undefined&log_id=&app_name=AF-Renderer::Self&_={timestamp}&sid={sid}",
+            headers=HEADERS,
+        )
+        token_data = token_request.json()
+        token_string = ET.fromstring(token_data["data"])[0][0][1][0][  # nosec B314
+            0
+        ].text
+
+        # This request retrieves the schedule
+        timestamp = time_ns() // 1_000_000  # epoch time in milliseconds
+
+        min_date = datetime.today().strftime("%Y-%m-%d")  # today
+        max_date = datetime.today() + timedelta(days=28)  # max of 28 days ahead
+        max_date = max_date.strftime("%Y-%m-%d")
+
+        payload = {
+            "formValues": {
+                "Section 1": {
+                    "uprnPWB": {"value": self._uprn},
+                    "minDate": {"value": min_date},
+                    "maxDate": {"value": max_date},
+                    "tokenString": {"value": token_string},
+                }
+            }
+        }
+
+        schedule_request = s.post(
+            f"https://my.reigate-banstead.gov.uk/apibroker/runLookup?id=609d41ca89251&repeat_against=&noRetry=true&getOnlyTokens=undefined&log_id=&app_name=AF-Renderer::Self&_={timestamp}&sid={sid}",
+            headers=HEADERS,
+            json=payload,
+        )
+
+        # oh good, response in JSON... that contains XML... that contains HTML...
+        rowdata = json.loads(schedule_request.content)["data"]
+        html_rowdata = ET.fromstring(rowdata)[0][0][1][0][0].text  # nosec B314
+        rowdata = bs4.BeautifulSoup(html_rowdata, "html.parser")
+        datedata = rowdata.findAll("h3")
+        bindata = rowdata.findAll("ul")
+
+        # Extract bin types and next collection dates
+        x = 0
+        entries = []
+        for item in bindata:
+            bin_date = datedata[x].text.strip()
+            x = x + 1
+            bins = item.findAll("span")
+            for bin_name in bins:
+                bin_type = bin_name.text.strip()
+                entries.append(
+                    Collection(
+                        t=bin_type,
+                        date=datetime.strptime(bin_date, "%A %d %B %Y").date(),
+                        icon=ICON_MAP.get(bin_name.text.upper()),
+                    )
+                )
+
+        return entries

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

@@ -0,0 +1,114 @@
+"""Source for Reinach BL, Switzerland."""
+
+import re
+from datetime import datetime
+from xml.etree import ElementTree
+
+import requests
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import (
+    SourceArgumentNotFoundWithSuggestions,
+)
+
+TITLE = "Reinach BL"
+DESCRIPTION = (
+    "Source for waste collection schedule of Gemeinde Reinach BL, Switzerland."
+)
+URL = "https://www.reinach-bl.ch"
+COUNTRY = "ch"
+
+RSS_URL = "https://www.reinach-bl.ch/de/abfallwirtschaft/abfallkalender/rss.php"
+
+VALID_ZONES = ["Kreis Ost", "Kreis West"]
+
+TEST_CASES = {
+    "Kreis Ost": {"zone": "Kreis Ost"},
+    "Kreis West": {"zone": "Kreis West"},
+}
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": (
+        "Select your collection zone (Kreis Ost or Kreis West). "
+        "You can find your zone on the official Reinach BL waste calendar "
+        "page at https://www.reinach-bl.ch/de/abfallwirtschaft/abfallkalender."
+    ),
+    "de": (
+        "Wählen Sie Ihren Abfuhrkreis (Kreis Ost oder Kreis West). "
+        "Den Kreis finden Sie auf dem Abfallkalender der Gemeinde Reinach BL "
+        "unter https://www.reinach-bl.ch/de/abfallwirtschaft/abfallkalender."
+    ),
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {"zone": "Collection zone"},
+    "de": {"zone": "Abfuhrkreis"},
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {"zone": "Collection zone: 'Kreis Ost' or 'Kreis West'."},
+    "de": {"zone": "Abfuhrkreis: 'Kreis Ost' oder 'Kreis West'."},
+}
+
+ICON_MAP = {
+    "Hauskehricht": Icons.GENERAL_WASTE,
+    "Grünabfuhr/Bioabfall": Icons.BIO_KITCHEN,
+    "Häckseldienst": Icons.GARDEN,
+    "Papier": Icons.PAPER,
+    "Karton": Icons.PAPER,
+    "Metalle": Icons.METAL,
+}
+
+
+class Source:
+    def __init__(self, zone: str):
+        if zone not in VALID_ZONES:
+            raise SourceArgumentNotFoundWithSuggestions(
+                "zone",
+                zone,
+                suggestions=VALID_ZONES,
+            )
+        self._zone = zone
+
+    def fetch(self) -> list[Collection]:
+        response = requests.get(RSS_URL, timeout=30)
+        response.raise_for_status()
+
+        root = ElementTree.fromstring(response.content)
+
+        entries: list[Collection] = []
+        for item in root.iter("item"):
+            title_el = item.find("title")
+            description_el = item.find("description")
+            if title_el is None or description_el is None:
+                continue
+
+            waste_type = (title_el.text or "").strip()
+            description = (description_el.text or "").strip()
+
+            # Description format: "DD.MM.YYYY<br/>Zone: Kreis Ost"
+            date_match = re.search(r"(\d{2})\.(\d{2})\.(\d{4})", description)
+            zone_match = re.search(r"Zone:\s*(.+?)\s*$", description)
+
+            if not date_match or not zone_match:
+                continue
+
+            zone = zone_match.group(1).strip()
+            if zone != self._zone:
+                continue
+
+            try:
+                collection_date = datetime.strptime(
+                    date_match.group(0), "%d.%m.%Y"
+                ).date()
+            except ValueError:
+                continue
+
+            entries.append(
+                Collection(
+                    date=collection_date,
+                    t=waste_type,
+                    icon=ICON_MAP.get(waste_type),
+                )
+            )
+
+        return entries

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

@@ -0,0 +1,54 @@
+import datetime
+import urllib
+
+import requests
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+
+TITLE = "ReMidt Orkland muni"
+DESCRIPTION = "Source for Orkland muni."
+URL = "https://www.remidt.no"
+TEST_CASES = {
+    "Follovegen": {"address": "Follovegen 1 B"},
+    "Makrellsvingen": {"address": "Makrellsvingen 14 - 20"},
+    "Taubaneveien": {"address": "Taubaneveien 46"},
+    "Mistfjordveien": {"address": "Mistfjordveien 1299"},
+}
+
+API_URL = "https://kalender.renovasjonsportal.no/api/address/"  # or station"
+
+ICON_MAP = {
+    "Restavfall": Icons.GENERAL_WASTE,
+    "Glass og metallemballasje": Icons.GLASS,
+    "Matavfall": Icons.BIO_KITCHEN,
+    "Papir": Icons.PAPER,
+    "Plastemballasje": Icons.RECYCLING,
+}
+
+
+class Source:
+    def __init__(self, address: str):
+        self.address = address
+
+    def fetch(self):
+        entries = []
+
+        r = requests.get(API_URL + urllib.parse.quote(self.address))
+        r.raise_for_status()
+        address_id = r.json()["searchResults"][0]["id"]
+
+        r = requests.get(API_URL + address_id + "/details/")
+        r.raise_for_status()
+        disposals = r.json()["disposals"]
+
+        for disposal in disposals:
+            entries.append(
+                Collection(
+                    date=datetime.datetime.fromisoformat(
+                        disposal["date"]
+                    ).date(),  # Collection date
+                    t=disposal["fraction"],  # Collection type
+                    icon=ICON_MAP.get(disposal["fraction"]),  # Collection icon
+                )
+            )
+
+        return entries

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

@@ -0,0 +1,73 @@
+import json
+from datetime import datetime
+
+import requests
+from bs4 import BeautifulSoup
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+
+TITLE = "Renfrewshire Council"
+DESCRIPTION = "Source for renfrewshire.gov.uk services for Renfrewshire"
+URL = "https://renfrewshire.gov.uk/"
+API_URL = "https://www.renfrewshire.gov.uk/bins-and-recycling/bin-collection/bin-collection-calendar/check-your-bin-collection-day/view/"
+
+TEST_CASES = {
+    "Test_001": {"postcode": "PA12 4JU", "uprn": "123033059"},
+    "Test_002": {"postcode": "PA12 4AJ", "uprn": "123034174"},
+    "Test_003": {"postcode": "PA2 9JB", "uprn": "123046497"},
+}
+
+ICON_MAP = {
+    "Grey": Icons.GENERAL_WASTE,
+    "Brown": Icons.ORGANIC,
+    "Green": Icons.GLASS,
+    "Blue": Icons.EVENT,
+}
+
+
+class Source:
+    def __init__(self, postcode, uprn):
+        self._postcode = postcode
+        self._uprn = str(uprn)
+
+    def fetch(self):
+        url = API_URL + self._uprn
+        headers = {
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36 Edg/131.0.0.0"
+        }
+
+        r = requests.get(url, headers=headers)
+        r.raise_for_status()
+
+        soup = BeautifulSoup(r.text, features="html.parser")
+        collections_data = soup.find(
+            "script", {"type": "application/json", "id": "collections-data"}
+        )
+
+        entries = []
+
+        if not collections_data:
+            raise Exception("Failed to get bin collection data")
+        try:
+            # Get the text content and parse JSON
+            binData = json.loads(collections_data.string.strip())
+        except json.JSONDecodeError as e:
+            raise Exception("JSON Decode Failed with: " + str(e)) from e
+
+        for date_str, bins in binData.items():
+            date = datetime.fromisoformat(date_str).date()
+
+            for _bin_name, details in bins.items():
+                if details is None:
+                    continue  # skip empty bins
+
+                collection_type = details["ShortName"]  # e.g. "Blue", "Brown", "Grey"
+
+                entries.append(
+                    Collection(
+                        date=date,
+                        t=collection_type,
+                        icon=ICON_MAP.get(collection_type),
+                    )
+                )
+
+        return entries

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

@@ -0,0 +1,65 @@
+import json
+import urllib
+from datetime import datetime
+
+import requests
+from waste_collection_schedule import Collection  # type: ignore[attr-defined]
+
+TITLE = "Kristianstad Renhållning"
+DESCRIPTION = "Source for Kristianstad Renhållning waste collection."
+URL = "https://renhallningen-kristianstad.se"
+TEST_CASES = {
+    "Case_0": {"street_address": "Östra Boulevarden 1"},
+    "Case_1": {"street_address": "Grenadjärvägen 1"},
+    "Case_2": {"street_address": "Skogsvägen 18"},
+    "Case_3": {"street_address": "Önnestadsvägen 7"},
+}
+
+
+class Source:
+    def __init__(self, street_address):
+        self._street_address = street_address
+
+    def fetch(self):
+        headers = {
+            "Module": "universal",
+            "Accept": "application/json, text/plain, */*",
+            "Unit": "dd905ce7-b16d-4422-be36-564169af4035",
+        }
+        query_street_address = urllib.parse.quote(self._street_address)
+        response = requests.get(
+            f"https://api-universal.appbolaget.se/waste/addresses/search?query={query_street_address}",
+            headers=headers,
+        )
+
+        building_data = json.loads(response.text)["data"]
+        building_id = None
+        if building_data and len(building_data) > 0:
+            building_id = building_data[0]["uuid"]
+
+        if not building_id:
+            raise ValueError("Unknown street address")
+
+        headers = {
+            "Module": "universal",
+            "Accept": "application/json, text/plain, */*",
+            "Unit": "dd905ce7-b16d-4422-be36-564169af4035",
+        }
+        response = requests.get(
+            f"https://api-universal.appbolaget.se/waste/addresses/{building_id}",
+            headers=headers,
+        )
+
+        data = json.loads(response.text)["data"]["services"]
+
+        entries = []
+        for item in data:
+            waste_type = item["type"]
+            icon = "mdi:trash-can"
+            if waste_type == "Trädgårdsavfall":
+                icon = "mdi:leaf"
+            next_pickup = item["collection_at"]
+            next_pickup_date = datetime.fromisoformat(next_pickup).date()
+            entries.append(Collection(date=next_pickup_date, t=waste_type, icon=icon))
+
+        return entries