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

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

@@ -0,0 +1,394 @@
+"""Source for Abfallwirtschaft Wiener Neustadt waste collection schedule.
+
+This source fetches waste collection schedules from abfall.wiener-neustadt.at
+for municipalities in Wiener Neustadt, Austria.
+"""
+
+import re
+from datetime import datetime
+from typing import Literal
+
+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 = "Abfallwirtschaft Wiener Neustadt"
+DESCRIPTION = "Source for abfall.wiener-neustadt.at waste collection schedule for Wiener Neustadt, Austria"
+URL = "https://abfall.wiener-neustadt.at/"
+
+# TEST_CASES: Each test should return a list[Collection] with date, type, and icon
+# Expected waste types: Restmüll, Biotonne, Wertstoffe, Altkleider, Christbaum
+# Note: All waste types are always fetched; filtering is done via customize feature
+TEST_CASES = {
+    "Martinsgasse Monthly": {
+        "street": "Martinsgasse",
+        "rm_art": "monatlich",
+    },
+    "Hauptplatz Weekly": {
+        "street": "Hauptplatz",
+        "rm_art": "wöchentlich",
+    },
+    "Leithakoloniestrasse Default": {
+        "street": "Leithakoloniestraße",
+    },
+    "Leithakoloniestrasse Bi-Weekly": {
+        "street": "Leithakoloniestraße",
+        "rm_art": "14-tägig",
+    },
+}
+
+ICON_MAP = {
+    "Restmüll": Icons.GENERAL_WASTE,
+    "Biotonne": Icons.BIO_KITCHEN,
+    "Wertstoffe": Icons.RECYCLING,
+    "Altpapier": Icons.PAPER,
+    "Altkleider": Icons.TEXTILE,
+    "Christbaum": Icons.CHRISTMAS_TREE,
+}
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": "Visit the website https://abfall.wiener-neustadt.at/ and select your street from the dropdown menu. Note your street name and select the waste collection frequency that applies to your address.",
+    "de": "Besuchen Sie die Website https://abfall.wiener-neustadt.at/ und wählen Sie Ihre Straße aus dem Dropdown-Menü. Notieren Sie sich Ihren Straßennamen und wählen Sie die Abfuhrhäufigkeit, die für Ihre Adresse gilt.",
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "street": "Street name in Wiener Neustadt (e.g., 'Martinsgasse', 'Hauptplatz'). Must match exactly as shown on the website.",
+        "str_id": "Optional: Street ID if known (skips street lookup)",
+        "rm_art": "Collection frequency for residual waste: 'wöchentlich' (weekly), '14-tägig' (bi-weekly), or 'monatlich' (monthly)",
+    },
+    "de": {
+        "street": "Straßenname in Wiener Neustadt (z.B. 'Martinsgasse', 'Hauptplatz'). Die Straße muss exakt so geschrieben werden, wie sie auf der Website erscheint.",
+        "str_id": "Optional: Straßen-ID falls bekannt. Wenn angegeben, wird die Straßensuche übersprungen.",
+        "rm_art": "Abfuhrhäufigkeit für Restmüll. Wählen Sie 'wöchentlich' für wöchentliche Abfuhr, '14-tägig' für zweiwöchentliche Abfuhr, oder 'monatlich' für monatliche Abfuhr.",
+    },
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "street": "Street Name",
+        "str_id": "Street ID",
+        "rm_art": "Collection Frequency",
+    },
+    "de": {
+        "street": "Straße",
+        "str_id": "Straßen-ID",
+        "rm_art": "Abfuhrhäufigkeit (Restmüll)",
+    },
+}
+
+# Map user-friendly frequency names to internal codes
+# Website codes: 31=wöchentlich, 33=14-tägig, 36=monatlich
+RM_ART_MAP = {
+    "wöchentlich": "31",
+    "weekly": "31",
+    "31": "31",
+    "14-tägig": "33",
+    "2weeks": "33",
+    "bi-weekly": "33",
+    "33": "33",
+    "monatlich": "36",
+    "monthly": "36",
+    "36": "36",
+}
+
+
+class Source:
+    def __init__(
+        self,
+        street: str,
+        str_id: str | None = None,
+        rm_art: Literal["wöchentlich", "14-tägig", "monatlich"] = "monatlich",
+    ):
+        """Initialize the Wiener Neustadt waste collection source.
+
+        Args:
+            street: Street name in Wiener Neustadt
+            str_id: Optional street ID (if known, skips street lookup)
+            rm_art: Collection frequency: 'wöchentlich', '14-tägig', or 'monatlich'
+
+        Note:
+            All waste types are always fetched.
+            Use the integration's customize feature to filter or hide specific waste types.
+        """
+        self._street = street
+        self._str_id = str_id
+        self._rm_art = RM_ART_MAP.get(rm_art.lower(), "36")  # Default to monthly
+        self._base_url = "https://abfall.wiener-neustadt.at"
+
+    def fetch(self) -> list[Collection]:
+        """Fetch waste collection schedule for Wiener Neustadt.
+
+        Returns:
+            List of Collection objects
+
+        Raises:
+            Exception: If street not found or data cannot be retrieved
+        """
+        # Step 1: Get street ID if not provided
+        if not self._str_id:
+            self._str_id, str_name_full, tn_ez_zone = self._lookup_street()
+        else:
+            str_name_full = None
+            tn_ez_zone = None
+
+        # Step 2: Fetch collection schedule
+        entries = self._fetch_schedule(self._str_id, str_name_full, tn_ez_zone)
+        return entries
+
+    def _lookup_street(self) -> tuple[str, str | None, str | None]:
+        """Look up street ID from street name using the ASP backend.
+
+        Returns:
+            Tuple of (street_id, full_street_name, tn_ez_zone)
+
+        Raises:
+            SourceArgumentNotFoundWithSuggestions: If street not found
+        """
+        # The website uses vb_wn_termine.asp with street selection
+        # Step 1: Determine first letter for page loading
+        current_year = datetime.now().year
+        first_letter = self._street[0].upper() if self._street else "A"
+
+        # Step 2: Load initial page with first letter to get street dropdown
+        initial_url = (
+            f"{self._base_url}/vb_wn_termine.asp?bst={first_letter}&jahr={current_year}"
+        )
+        try:
+            response = requests.get(initial_url, timeout=30)
+            response.raise_for_status()
+        except requests.exceptions.RequestException as e:
+            raise Exception(
+                f"Failed to connect to {self._base_url}. "
+                f"Please check your internet connection and verify the website is accessible. Error: {e}"
+            ) from e
+
+        soup = BeautifulSoup(response.text, "html.parser")
+
+        # Step 3: Find street in select/option elements
+        str_id = None
+        str_name_full = None
+        tn_ez_zone = None
+
+        street_normalized = (
+            self._street.lower()
+            .replace("ß", "ss")
+            .replace("ä", "a")
+            .replace("ö", "o")
+            .replace("ü", "u")
+        )
+
+        found_streets = []  # For suggestions if exact match fails
+
+        for select in soup.find_all("select", {"name": "str_id"}):
+            for option in select.find_all("option"):
+                option_text = option.get_text().strip()
+                option_value = option.get("value", "").strip()
+
+                if not option_value or option_value == "0":
+                    continue
+
+                option_normalized = (
+                    option_text.lower()
+                    .replace("ß", "ss")
+                    .replace("ä", "a")
+                    .replace("ö", "o")
+                    .replace("ü", "u")
+                )
+                found_streets.append((option_text, option_value))
+
+                # Try exact match only
+                if street_normalized == option_normalized:
+                    str_id = option_value
+                    str_name_full = option_text
+                    break
+            if str_id:
+                break
+
+        if not str_id:
+            # Street not found - provide suggestions
+            suggestions = [s[0] for s in found_streets[:20]]
+            raise SourceArgumentNotFoundWithSuggestions(
+                "street",
+                self._street,
+                suggestions,
+            )
+
+        # Step 4: Extract tn_ez_zone from hidden input (if present)
+        tn_ez_zone_input = soup.find("input", {"name": "tn_ez_zone", "type": "hidden"})
+        if tn_ez_zone_input:
+            tn_ez_zone = tn_ez_zone_input.get("value")
+
+        # Step 5: Reload page with selected street to get correct tn_ez_zone
+        try:
+            reload_response = requests.post(
+                initial_url, data={"str_id": str_id}, timeout=30
+            )
+            reload_response.raise_for_status()
+        except requests.exceptions.RequestException as e:
+            raise Exception(
+                f"Failed to retrieve zone information for street '{str_name_full}'. "
+                f"The website may be temporarily unavailable. Error: {e}"
+            ) from e
+
+        reload_soup = BeautifulSoup(reload_response.text, "html.parser")
+        tn_ez_zone_input = reload_soup.find(
+            "input", {"name": "tn_ez_zone", "type": "hidden"}
+        )
+        if tn_ez_zone_input:
+            tn_ez_zone = tn_ez_zone_input.get("value")
+
+        # Also get str_name from hidden input if present
+        str_name_input = reload_soup.find(
+            "input", {"name": "str_name", "type": "hidden"}
+        )
+        if str_name_input:
+            str_name_full = str_name_input.get("value")
+
+        return (str_id, str_name_full, tn_ez_zone)
+
+    def _fetch_schedule(
+        self,
+        str_id: str,
+        str_name_full: str | None,
+        tn_ez_zone: str | None,
+    ) -> list[Collection]:
+        """Fetch and parse the waste collection schedule.
+
+        Args:
+            str_id: Street ID
+            str_name_full: Full street name (optional)
+            tn_ez_zone: Zone information (optional)
+
+        Returns:
+            List of Collection objects
+        """
+        # Determine year - use next year if we're in December
+        current_year = datetime.now().year
+        if datetime.now().month == 12:
+            year = current_year + 1
+        else:
+            year = current_year
+
+        # Determine first letter parameter for URL
+        if str_name_full:
+            first_letter = str_name_full[0].upper()
+        else:
+            first_letter = self._street[0].upper()
+
+        # Build POST request URL
+        post_url = f"{self._base_url}/vb_wn_termine.asp?bst={first_letter}&jahr={year}"
+
+        # Build form data
+        post_data = {
+            "str_id": str_id,
+            "rm_art": self._rm_art,
+            # always include all waste types; customization/filtering is handled elsewhere
+            "chk_biotonne": "ja",
+            "chk_wertstoffe": "ja",
+            "chk_altkleider": "ja",
+            "chk_christbaum": "ja",
+        }
+
+        if tn_ez_zone:
+            post_data["tn_ez_zone"] = tn_ez_zone
+        if str_name_full:
+            post_data["str_name"] = str_name_full
+
+        # Submit form
+        try:
+            response = requests.post(post_url, data=post_data, timeout=30)
+            response.raise_for_status()
+        except requests.exceptions.RequestException as e:
+            raise Exception(
+                f"Failed to fetch collection schedule for street ID '{str_id}'. "
+                f"The website may be temporarily unavailable or the street ID is invalid. Error: {e}"
+            ) from e
+
+        # Parse response
+        return self._parse_schedule(response.text)
+
+    def _parse_schedule(self, html: str) -> list[Collection]:
+        """Parse collection schedule from HTML response.
+
+        Args:
+            html: HTML response text
+
+        Returns:
+            List of Collection objects
+
+        Raises:
+            Exception: If no collection dates found
+        """
+        entries = []
+
+        soup = BeautifulSoup(html, "html.parser")
+        date_pattern = re.compile(r"(\d{2})\.(\d{2})\.(\d{4})\s+(.*)")
+
+        for div in soup.find_all("div"):
+            text = div.get_text(" ", strip=True)
+            match = date_pattern.match(text)
+            if not match:
+                continue
+
+            day, month, year = (int(match.group(i)) for i in range(1, 4))
+            waste_text = match.group(4).strip()
+
+            waste_type = self._normalize_waste_type(waste_text)
+
+            try:
+                date_obj = datetime(year, month, day).date()
+            except ValueError:
+                continue
+
+            if waste_type:
+                entries.append(
+                    Collection(
+                        date=date_obj,
+                        t=waste_type,
+                        icon=ICON_MAP.get(waste_type),
+                    )
+                )
+
+        if not entries:
+            raise Exception(
+                f"No collection dates found for street '{self._street}'. "
+                "The website structure may have changed or no data is available for this address. "
+                "Please verify your street name on https://abfall.wiener-neustadt.at/"
+            )
+
+        return sorted(entries, key=lambda x: x.date)
+
+    @staticmethod
+    def _normalize_waste_type(waste_text: str) -> str:
+        """Normalize waste type text to standard names.
+
+        Args:
+            waste_text: Raw waste type text from website
+
+        Returns:
+            Normalized waste type name; returns the original text if not recognized
+        """
+        waste_lower = waste_text.lower()
+
+        # Check specific types FIRST before generic patterns
+        # Order matters: check "bio" before "müll" to avoid misclassifying "Biomüll"
+        if "bio" in waste_lower:
+            return "Biotonne"
+        if "christbaum" in waste_lower or "tannenbaum" in waste_lower:
+            return "Christbaum"
+        if "wertstoff" in waste_lower or "gelb" in waste_lower:
+            return "Wertstoffe"
+        if "papier" in waste_lower:
+            return "Altpapier"
+        if "kleider" in waste_lower or "textil" in waste_lower:
+            return "Altkleider"
+        # Check "rest" and "müll" LAST as they are generic
+        if any(x in waste_lower for x in ["rest", "müll", "m�ll"]):
+            return "Restmüll"
+
+        # Default: return original text to avoid losing unknown/new types
+        return waste_text

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

@@ -0,0 +1,147 @@
+import re
+from datetime import datetime
+
+import requests
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import SourceArgumentNotFound
+from waste_collection_schedule.service.ICS import ICS
+
+TITLE = "PreZero"
+DESCRIPTION = "Source for PreZero waste collection calendar"
+URL = "https://abfallkalender.prezero.network"
+COUNTRY = "de"
+
+EXTRA_INFO = [
+    {
+        "title": "Bad Oeynhausen",
+        "url": "https://abfallkalender.prezero.network/bad-oeynhausen",
+        "default_params": {"city": "bad-oeynhausen"},
+    },
+]
+
+TEST_CASES = {
+    "Bad Oeynhausen Aalstraße": {
+        "street": "Aalstraße",
+        "house_number": "1",
+    },
+    "Bad Oeynhausen Ackerstraße": {
+        "street": "Ackerstraße",
+        "house_number": "2",
+    },
+}
+
+ICON_MAP = {
+    "Biotonne": Icons.BIO_KITCHEN,
+    "Gelbe Tonne": Icons.PLASTIC_PACKAGING,
+    "Restmülltonne": Icons.GENERAL_WASTE,
+    "Restmülltonne 4-wl.": Icons.GENERAL_WASTE,
+    "Papiertonne": Icons.PAPER,
+    "Schadstoffsammlung": Icons.HAZARDOUS,
+}
+
+PARAM_TRANSLATIONS = {
+    "de": {
+        "city": "Stadt",
+        "street": "Straße",
+        "house_number": "Hausnummer",
+    },
+    "en": {
+        "city": "City",
+        "street": "Street",
+        "house_number": "House Number",
+    },
+}
+
+PARAM_DESCRIPTIONS = {
+    "de": {
+        "city": "Stadt-Kennung (Standard und einzig unterstützter Wert: 'bad-oeynhausen')",
+        "street": "Straßenname (z.B. 'Aalstraße')",
+        "house_number": "Hausnummer (z.B. '1')",
+    },
+    "en": {
+        "city": "City identifier (default and only supported value: 'bad-oeynhausen')",
+        "street": "Street name (e.g. 'Aalstraße')",
+        "house_number": "House number (e.g. '1')",
+    },
+}
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "de": "Geben Sie Ihre Straße und Hausnummer ein. Diese Quelle unterstützt derzeit nur Bad Oeynhausen.",
+    "en": "Enter your street and house number. This source currently only supports Bad Oeynhausen.",
+}
+
+
+class Source:
+    def __init__(self, street: str, house_number: str, city: str = "bad-oeynhausen"):
+        self._city = city
+        self._street = street
+        self._house_number = house_number
+        self._ics = ICS()
+
+    def fetch(self) -> list[Collection]:
+        # Step 1: Submit form to get redirect with street_id
+        base_url = f"https://abfallkalender.prezero.network/{self._city}"
+        form_data = {"street": self._street, "houseNo": self._house_number}
+
+        # Submit form
+        r = requests.post(base_url, data=form_data, allow_redirects=False)
+
+        # Check if redirect was returned
+        if r.status_code not in (301, 302, 303, 307, 308):
+            # If no redirect, the street or house number might be invalid
+            raise SourceArgumentNotFound(
+                "street",
+                self._street,
+                "Street not found. Please verify the street name is correct and matches exactly as shown on the PreZero website.",
+            )
+
+        # Extract redirect location
+        location = r.headers.get("Location")
+        if not location:
+            # Check if there's a meta refresh redirect in the HTML
+            if "http-equiv" in r.text and "refresh" in r.text.lower():
+                # Parse meta refresh: <meta http-equiv="refresh" content="0;url='/path'" />
+                match = re.search(r'url=[\'"]?([^\'" >]+)', r.text)
+                if match:
+                    location = match.group(1)
+
+        if not location:
+            raise SourceArgumentNotFound(
+                "street",
+                self._street,
+                "Could not determine calendar URL. Please verify your street and house number.",
+            )
+
+        # Extract street_id from redirect URL
+        # Format: /city/calendar/{street_id}/{house_number}?...
+        match = re.search(r"/calendar/(\d+)/", location)
+        if not match:
+            raise SourceArgumentNotFound(
+                "street",
+                self._street,
+                "Could not extract street ID from response. The street name might be incorrect.",
+            )
+
+        street_id = match.group(1)
+
+        # Step 2: Fetch current and next year's data
+        now = datetime.now()
+        entries = []
+
+        for year in [now.year, now.year + 1]:
+            ical_url = f"https://abfallkalender.prezero.network/{self._city}/download/ical/{street_id}/{self._house_number}/{year}"
+
+            # Download iCal file
+            r = requests.post(ical_url)
+            r.raise_for_status()
+
+            # Parse iCal
+            dates = self._ics.convert(r.text)
+
+            for d in dates:
+                waste_type = d[1]
+                entries.append(
+                    Collection(date=d[0], t=waste_type, icon=ICON_MAP.get(waste_type))
+                )
+
+        return entries

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

@@ -0,0 +1,106 @@
+from waste_collection_schedule import Collection  # type: ignore[attr-defined]
+from waste_collection_schedule.service.AbfallnaviDe import SERVICE_DOMAINS, AbfallnaviDe
+
+TITLE = "AbfallNavi (RegioIT.de)"
+DESCRIPTION = (
+    "Source for AbfallNavi waste collection. AbfallNavi is a brand name of regioit.de."
+)
+URL = "https://www.regioit.de"
+
+
+def EXTRA_INFO():
+    return [
+        {
+            "title": s["title"],
+            "url": s["url"],
+            "default_params": {"service": s["service_id"]},
+        }
+        for s in SERVICE_DOMAINS
+    ]
+
+
+TEST_CASES = {
+    "Aachen, Abteiplatz 7": {
+        "service": "aachen",
+        "ort": "Aachen",
+        "strasse": "Abteiplatz",
+        "hausnummer": "7",
+    },
+    "Lindlar, Aggerweg": {
+        "service": "bav",
+        "ort": "Lindlar",
+        "strasse": "Aggerweg",
+    },
+    "Overath, Hauptstraße": {
+        "service": "bav",
+        "ort": "Overath",
+        "strasse": "Hauptstraße",
+    },
+    "Roetgen, Am Sportplatz 2": {
+        "service": "zew2",
+        "ort": "Roetgen",
+        "strasse": "Am Sportplatz",
+        "hausnummer": "2",
+    },
+    "nds Norderstedt Adenauerplatz": {
+        "service": "nds",
+        "ort": "Norderstedt",
+        "strasse": "Distelweg",
+    },
+    "nds Norderstedt Friedrichsgaber Weg (house number range as street)": {
+        "service": "nds",
+        "ort": "Norderstedt",
+        "strasse": "Friedrichsgaber Weg 1 - 57",
+    },
+    "una Bergkamen, Agnes-Miegel-Str.": {
+        "service": "unna",
+        "ort": "Bergkamen",
+        "strasse": "Agnes-Miegel-Str.",
+    },
+    "Pinneberg Kummerfeld no Street": {
+        "service": "pi",
+        "ort": "Kummerfeld",
+        "strasse": "alle Straßen",
+    },
+    "Cuxhaven": {
+        "service": "cux",
+        "ort": "Cuxhaven",
+        "strasse": "Zur Holter Höhe",
+    },
+    "frankenthal, Am Martinspfad": {
+        "service": "frankenthal",
+        "ort": "Frankenthal",
+        "strasse": "Am Martinspfad",
+    },
+    "Solingen, Katternberger Straße 95 (street split by district)": {
+        "service": "solingen",
+        "ort": "Solingen",
+        "strasse": "Katternberger Straße",
+        "hausnummer": "95",
+    },
+}
+
+
+class Source:
+    def __init__(
+        self,
+        service: str,
+        ort: str,
+        strasse: str | None = None,
+        hausnummer: str | int | None = None,
+    ):
+        self._api = AbfallnaviDe(service)
+        self._ort = ort
+        self._strasse = strasse
+        self._hausnummer = (
+            str(hausnummer) if isinstance(hausnummer, int) else hausnummer
+        )
+
+    def fetch(self):
+        dates = self._api.get_dates(self._ort, self._strasse, self._hausnummer)
+
+        entries = []
+        for d in dates:
+            entries.append(Collection(d[0], d[1]))
+
+        return sorted(entries, key=lambda e: e.date)

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

@@ -0,0 +1,37 @@
+import urllib
+
+import requests
+from waste_collection_schedule import Collection  # type: ignore[attr-defined]
+from waste_collection_schedule.service.ICS import ICS
+
+TITLE = "Abfalltermine Forchheim"
+DESCRIPTION = "Source for Landkreis Forchheim"
+URL = "https://www.abfalltermine-forchheim.de/"
+TEST_CASES = {
+    "Dormitz": {"city": "Dormitz", "area": "Dormitz"},
+    "Rüsselbach": {"city": "Igensdorf", "area": "Oberrüsselbach"},
+    "Kellerstraße": {
+        "city": "Forchheim",
+        "area": "Untere Kellerstraße (ab Adenauerallee bis Piastenbrücke)",
+    },
+}
+
+
+class Source:
+    def __init__(self, city, area):
+        self._city = city
+        self._area = area
+        self._ics = ICS()
+
+    def fetch(self):
+        place = urllib.parse.quote(self._city + " - " + self._area)
+        r = requests.get(
+            f"https://www.abfalltermine-forchheim.de/Forchheim/Landkreis/{place}/ics?RESTMUELL=true&RESTMUELL_SINGLE=true&BIO=true&YELLOW_SACK=true&PAPER=true"
+        )
+        r.encoding = "utf-8"
+        dates = self._ics.convert(r.text)
+
+        entries = []
+        for d in dates:
+            entries.append(Collection(d[0], d[1]))
+        return entries