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

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

@@ -0,0 +1,54 @@
+import datetime
+
+import requests
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+
+TITLE = "Gmina Miękinia"
+DESCRIPTION = "Source for Gmina Miękinia, Poland"
+URL = "https://api.skycms.com.pl"
+TEST_CASES = {
+    "Brzezina": {"location_id": 8},
+}
+
+ICON_MAP = {
+    "Zmieszane": Icons.GENERAL_WASTE,
+    "Tworzywa sztuczne": Icons.RECYCLING,
+    "Bioodpady": Icons.ORGANIC,
+    "Papier": Icons.PAPER,
+    "Szkło": Icons.GLASS,
+    "Wielkogabaryty": Icons.BULKY,
+}
+
+API_URL = "https://api.skycms.com.pl/api/v1/rest/garbage/disposals/"
+
+
+class Source:
+    def __init__(self, location_id):
+        self._location_id = location_id
+
+    def fetch(self):
+        api_headers = {
+            "x-skycms-key": "5d0123032115904c9d4ff70522405e60",
+            "x-skycms-type": "iOS",
+            "x-skycms-device": "04C977DF-F4BB-4541-AEF2-EB2F454CB4D2",
+        }
+        api_response = requests.get(
+            API_URL + str(self._location_id), headers=api_headers
+        )
+
+        entries = []
+
+        kinds = api_response.json()["data"]["garbage_kinds"]
+
+        for k in kinds:
+            name = k["name"]
+            for d in k["disposals"]:
+                entries.append(
+                    Collection(
+                        date=datetime.datetime.strptime(d["id"], "%Y-%m-%d").date(),
+                        t=name.capitalize(),
+                        icon=ICON_MAP.get(name),
+                    )
+                )
+
+        return entries

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

@@ -0,0 +1,220 @@
+import datetime
+from typing import Literal
+
+import requests
+from bs4 import BeautifulSoup, Tag
+from waste_collection_schedule import Collection, Icons
+from waste_collection_schedule.exceptions import (
+    SourceArgumentNotFoundWithSuggestions,
+    SourceArgumentRequired,
+)
+
+TITLE = "Gmina Środa Śląska"
+DESCRIPTION = "Source for Gmina Środa Śląska, Poland"
+URL = "https://srodowisko.srodaslaska.pl/gospodarka-odpadami/harmonogram-odbioru-odpadow-komunalnych/"
+COUNTRY = "pl"
+
+BASE_URL = "https://www.com-d.pl"
+SCHEDULE_URL = f"{BASE_URL}/komunalne/harm/sroda-slaska"
+
+TEST_CASES = {
+    "Szczepanów": {"location": "szczepanow"},
+    "Środa Śląska I rejon": {"location": "sroda-slaska-i-rejon"},
+    "Ciechów": {"location": "ciechow"},
+    "Ciechów single-family": {"location": "ciechow", "property_type": "single_family"},
+    "Ciechów multifamily": {"location": "ciechow", "property_type": "multi_family"},
+}
+
+ICON_MAP = {
+    "1xmc-odpady-szklo": Icons.GLASS,
+    "inne-odpady-rozne": Icons.TEXTILE,
+    "inne-odpady-zbiorki": Icons.BULKY,
+    "inne-odpady-papier": Icons.PAPER,
+    "t-odpady-biodegradowalne": Icons.ORGANIC,
+    "t-odpady-zmieszane": Icons.GENERAL_WASTE,
+    "tp-odpady-metaletworzywa": Icons.RECYCLING,
+}
+
+TYPE_MAP = {
+    "1xmc-odpady-szklo": "Szkło",
+    "inne-odpady-rozne": "Tekstylia i odzież",
+    "inne-odpady-zbiorki": "Odpady wielkogabarytowe",
+    "inne-odpady-papier": "Papier",
+    "t-odpady-biodegradowalne": "Odpady biodegradowalne",
+    "t-odpady-zmieszane": "Zmieszane odpady komunalne",
+    "tp-odpady-metaletworzywa": "Metale i tworzywa sztuczne",
+}
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": "Visit https://www.com-d.pl/komunalne/harm/sroda-slaska, select your locality or Środa Śląska district, and enter the final part of its URL.",
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "location": "Location",
+        "location_id": "Location ID (obsolete)",
+        "property_type": "Property type",
+    },
+    "de": {
+        "location": "Ort",
+        "location_id": "Orts-ID (veraltet)",
+        "property_type": "Gebäudetyp",
+    },
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "location": "Locality or district URL slug from the COM-D schedule page",
+        "location_id": "No longer supported, use 'location' instead",
+        "property_type": "all (default), single_family or multi_family; select the dwelling type when the provider publishes separate schedules",
+    },
+    "de": {
+        "location": "URL-Kürzel des Ortes bzw. Stadtteils von der COM-D Abfuhrplan-Seite",
+        "location_id": "Wird nicht mehr unterstützt, bitte stattdessen 'location' verwenden",
+        "property_type": "all (Standard), single_family (Einfamilienhaus) oder multi_family (Mehrfamilienhaus)",
+    },
+}
+
+HOW_TO_GET_LOCATION = (
+    f"open {SCHEDULE_URL}, select your locality or Środa Śląska district and use the "
+    "last part of its URL"
+)
+LEGACY_ARGUMENT_REASON = (
+    "the waste collection provider changed, so the old 'location_id' groups no longer "
+    f"exist; {HOW_TO_GET_LOCATION}"
+)
+
+
+def _get_locations(session: requests.Session) -> list[str]:
+    """Return all locality/district slugs published by COM-D."""
+    response = session.get(SCHEDULE_URL, timeout=30)
+    response.raise_for_status()
+    soup = BeautifulSoup(response.text, "html.parser")
+    return sorted(
+        {
+            link["href"].rsplit("/", 1)[-1]
+            for link in soup.find_all("a", href=True)
+            if "sroda-slaska/" in link["href"]
+        }
+    )
+
+
+PROPERTY_TYPES = {
+    "single_family": "zabudowa jednorodzinna",
+    "multi_family": "zabudowa wielorodzinna",
+}
+
+
+def _collection_days(soup: BeautifulSoup, property_type: str) -> list[Tag]:
+    """Associate dates with the preceding COM-D frequency/dwelling heading."""
+    if property_type == "all":
+        return list(soup.select("td.highlighted[data-date]"))
+
+    days: list[tuple[str | None, Tag]] = []
+    current_type = None
+    available_types: set[str] = set()
+    # A category page repeats frequency headers and calendars for each schedule.
+    # Read them in document order, resetting at EVERY frequency header, including
+    # unqualified schedules shared by all property types.
+    for element in soup.select("p, td.highlighted[data-date]"):
+        if element.name == "p":
+            text = " ".join(element.get_text(" ", strip=True).split()).casefold()
+            if not text.startswith("częstotliwość"):
+                continue
+            current_type = next(
+                (key for key, label in PROPERTY_TYPES.items() if label in text), None
+            )
+            if current_type is None and "zabudowa" in text:
+                raise ValueError(f"Unrecognized COM-D property type heading: {text}")
+            if current_type is not None:
+                available_types.add(current_type)
+        else:
+            days.append((current_type, element))
+
+    if available_types and property_type not in available_types:
+        raise SourceArgumentNotFoundWithSuggestions(
+            "property_type", property_type, sorted(available_types)
+        )
+    return [day for kind, day in days if kind is None or kind == property_type]
+
+
+class Source:
+    def __init__(
+        self,
+        location: str | None = None,
+        location_id: str | int | None = None,
+        property_type: Literal["all", "single_family", "multi_family"] = "all",
+    ):
+        # location_id was used by the previous provider. Its values grouped several
+        # localities together and cannot be mapped to a COM-D location automatically,
+        # so existing configurations get a helpful message instead of a TypeError.
+        if not location:
+            raise SourceArgumentRequired(
+                "location",
+                LEGACY_ARGUMENT_REASON
+                if location_id is not None
+                else HOW_TO_GET_LOCATION,
+            )
+        if property_type not in {"all", *PROPERTY_TYPES}:
+            raise SourceArgumentNotFoundWithSuggestions(
+                "property_type", property_type, ["all", *PROPERTY_TYPES]
+            )
+        self._location: str = location
+        self._property_type = property_type
+
+    def fetch(self) -> list[Collection]:
+        session = requests.Session()
+
+        response = session.get(f"{SCHEDULE_URL}/{self._location}", timeout=30)
+        if response.status_code == 404:
+            raise SourceArgumentNotFoundWithSuggestions(
+                "location", self._location, _get_locations(session)
+            )
+        response.raise_for_status()
+        soup = BeautifulSoup(response.text, "html.parser")
+
+        schedule_table = next(
+            (
+                table
+                for table in soup.find_all("table")
+                if table.find("th", string="Frakcja")
+            ),
+            None,
+        )
+        if schedule_table is None:
+            raise ValueError(
+                "Could not find a collection schedule for the location "
+                f"'{self._location}' at {SCHEDULE_URL}/{self._location}. "
+                "The website layout may have changed."
+            )
+
+        category_urls = {
+            link["href"] for link in schedule_table.select('a[href*="/sroda-slaska/"]')
+        }
+
+        entries: list[Collection] = []
+        seen = set()
+
+        for category_url in sorted(category_urls):
+            category = category_url.rsplit("/", 1)[-1]
+            category_response = session.get(f"{BASE_URL}{category_url}", timeout=30)
+            category_response.raise_for_status()
+            category_soup = BeautifulSoup(category_response.text, "html.parser")
+
+            for collection_day in _collection_days(category_soup, self._property_type):
+                collection_date = datetime.datetime.strptime(
+                    collection_day["data-date"], "%Y-%m-%d"
+                ).date()
+                entry = (collection_date, category)
+                if entry in seen:
+                    continue
+                seen.add(entry)
+                entries.append(
+                    Collection(
+                        date=collection_date,
+                        t=TYPE_MAP.get(category, category.capitalize()),
+                        icon=ICON_MAP.get(category),
+                    )
+                )
+
+        return entries

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

@@ -0,0 +1,135 @@
+import datetime
+import logging
+
+import requests
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import (
+    SourceArgumentNotFound,
+    SourceArgumentNotFoundWithSuggestions,
+)
+
+_LOGGER = logging.getLogger(__name__)
+
+TITLE = "Gmina Trzebnica"
+DESCRIPTION = "Source for Gmina Trzebnica, Poland (SkyCMS municipal app API)"
+URL = "https://trzebnica.pl"
+COUNTRY = "pl"
+
+TEST_CASES = {
+    "Trzebnica - Brzyków (Sołectwa 8)": {"region_id": 88},
+    "Trzebnica 2": {"region_id": 8},
+}
+
+SOURCE_CODEOWNERS = ["@Tymon3310"]
+
+API_BASE = "https://api.skycms.com.pl/api/v1/rest"
+# Public API key of the "Gmina Trzebnica" SkyCMS app. It identifies the
+# municipality (tenant), not a user, and is shipped with the public app.
+# Other SkyCMS municipalities use their own key and their own region IDs,
+# so this source is scoped to Gmina Trzebnica.
+API_KEY = "a90a376c6b19307acf1334b1a3937235"
+
+HEADERS = {
+    "x-skycms-key": API_KEY,
+    "x-skycms-device": "waste-collection-schedule",
+    "x-skycms-type": "web",
+    "x-skycms-model": "waste-collection-schedule",
+    "x-skycms-version": "1.0.0",
+    "x-skycms-app-version": "1.0.0",
+    "x-skycms-language": "pl",
+}
+
+ICON_MAP = {
+    "Odpady Zielone / Kuchenne": Icons.ORGANIC,
+    "Odpady Zielone": Icons.GARDEN,
+    "Wielkogabarytowe": Icons.BULKY,
+    "Tworzywa sztuczne": Icons.PLASTIC_PACKAGING,
+    "Zmieszane": Icons.GENERAL_WASTE,
+    "Papier": Icons.PAPER,
+    "Szkło": Icons.GLASS,
+    "Bio": Icons.ORGANIC,
+}
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": "Install the 'Gmina Trzebnica' app and look up your waste collection region. The region ID can be found in the app's waste calendar section, or in the region list linked from the documentation of this source.",
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "region_id": "Waste collection region ID of the Gmina Trzebnica SkyCMS app",
+    },
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "region_id": "Region ID",
+    },
+}
+
+
+def _get_icon(waste_name: str) -> Icons | None:
+    """Return the icon matching a waste type name.
+
+    Keys are matched longest-first so that a more specific waste type
+    (e.g. "Odpady Zielone / Kuchenne") is never shadowed by a shorter key
+    that happens to be a substring of it (e.g. "Odpady Zielone").
+    """
+    name = waste_name.lower()
+    for key in sorted(ICON_MAP, key=len, reverse=True):
+        if key.lower() in name:
+            return ICON_MAP[key]
+    return None
+
+
+class Source:
+    def __init__(self, region_id):
+        try:
+            self._region_id = int(region_id)
+        except (ValueError, TypeError) as e:
+            raise SourceArgumentNotFound(
+                "region_id", region_id, "it must be a numeric region ID."
+            ) from e
+
+    def fetch(self) -> list[Collection]:
+        session = requests.Session()
+        session.headers.update(HEADERS)
+
+        response = session.get(
+            f"{API_BASE}/garbage/disposals/{self._region_id}", timeout=30
+        )
+        response.raise_for_status()
+
+        data = response.json().get("data") or {}
+        # Unknown region IDs still return HTTP 200 with success=true, but the
+        # payload only contains a message instead of the schedule.
+        if "garbage_kinds" not in data:
+            raise SourceArgumentNotFoundWithSuggestions(
+                "region_id", self._region_id, self._fetch_region_ids(session)
+            )
+
+        entries: list[Collection] = []
+
+        for waste in data["garbage_kinds"] or []:
+            waste_name = waste["name"]
+            icon = _get_icon(waste_name)
+
+            for disposal in waste.get("disposals", []):
+                try:
+                    pickup_date = datetime.date.fromisoformat(disposal["id"])
+                except ValueError:
+                    _LOGGER.warning("Invalid date: %s", disposal["id"])
+                    continue
+                entries.append(Collection(pickup_date, waste_name, icon=icon))
+
+        return entries
+
+    @staticmethod
+    def _fetch_region_ids(session: requests.Session) -> list[int]:
+        """Return all region IDs known to the app, used as error suggestions."""
+        try:
+            response = session.get(f"{API_BASE}/garbage/regions", timeout=30)
+            response.raise_for_status()
+            regions = (response.json().get("data") or {}).get("regions") or []
+        except (requests.RequestException, ValueError):
+            return []
+        return [region["id"] for region in regions if "id" in region]

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

@@ -0,0 +1,202 @@
+import datetime
+import json
+import logging
+import re
+
+import requests
+from bs4 import BeautifulSoup
+from waste_collection_schedule import Collection, Icons
+from waste_collection_schedule.exceptions import SourceArgumentNotFoundWithSuggestions
+
+TITLE = "Gmina Zgierz"
+DESCRIPTION = "Source for Gmina Zgierz garbage collection"
+URL = "https://gminazgierz.pl"
+TEST_CASES = {
+    "Grotniki": {"location_name": "Grotniki"},
+    "Biała": {"location_name": "Biała"},
+    "Kębliny": {"location_name": "Kębliny"},
+    "Rosanów": {"location_name": "Rosanów"},
+}
+
+_LOGGER = logging.getLogger(__name__)
+
+API_URL = "https://bip.gminazgierz.pl/api/articles/59717"
+
+ICON_MAP = {
+    "Segregowane i zmieszane": Icons.GENERAL_WASTE,
+    "BIO": Icons.ORGANIC,
+    "Gabaryty": Icons.BULKY,
+}
+
+MONTH_MAP = {
+    "styczeń": 1,
+    "stycznia": 1,
+    "luty": 2,
+    "lutego": 2,
+    "marzec": 3,
+    "marca": 3,
+    "kwiecień": 4,
+    "kwietnia": 4,
+    "maj": 5,
+    "maja": 5,
+    "czerwiec": 6,
+    "czerwca": 6,
+    "lipiec": 7,
+    "lipca": 7,
+    "sierpień": 8,
+    "sierpnia": 8,
+    "wrzesień": 9,
+    "września": 9,
+    "październik": 10,
+    "października": 10,
+    "listopad": 11,
+    "listopada": 11,
+    "grudzień": 12,
+    "grudnia": 12,
+}
+
+
+class Source:
+    def __init__(self, location_name: str):
+        self.location_name = location_name.strip().title()
+
+    def fetch(self) -> list[Collection]:
+        try:
+            r = requests.get(API_URL)
+            r.raise_for_status()
+            data = r.json()
+        except (requests.RequestException, json.JSONDecodeError) as e:
+            raise Exception("Error fetching or parsing data") from e
+
+        html_content = data.get("content")
+        if not html_content:
+            raise Exception("HTML content not found in JSON response")
+
+        soup = BeautifulSoup(html_content, "html.parser")
+
+        # --- Step 1: Find the region for the given location ---
+        found_region_name = None
+        search_location_lower = self.location_name.lower()
+        for p_tag in soup.find_all("p"):
+            if search_location_lower in p_tag.get_text().lower():
+                strong_tag = p_tag.find("strong")
+                if strong_tag:
+                    region_text = strong_tag.get_text(strip=True)
+                    if region_text.lower().startswith("rejon"):
+                        found_region_name = region_text.replace(":", "")
+                        break
+
+        if not found_region_name:
+            # offer regions we discovered in the page
+            available_regions = sorted({"Rejon I", "Rejon II", "Rejon III", "Rejon IV"})
+            raise SourceArgumentNotFoundWithSuggestions(
+                "location_name",
+                self.location_name,
+                suggestions=available_regions,
+            )
+
+        # --- Step 2: Find the correct table ---
+        target_table = None
+        all_tables = soup.find_all("table")
+        for table in all_tables:
+            header_row = table.find("tr")
+            if not header_row:
+                continue
+
+            header_text = header_row.get_text(separator=" ")
+
+            if re.search(r"\b" + re.escape(found_region_name) + r"\b", header_text):
+                target_table = table
+                break
+
+        if not target_table:
+            raise Exception(
+                f"Could not find schedule table for region: {found_region_name}"
+            )
+
+        # --- Step 2a: Extract the year from the title ---
+        year = None
+        title_text = data.get("title", "")
+        if title_text:
+            match = re.search(r"\b(20\d{2})\b", title_text)
+            if match:
+                year = int(match.group(1))
+
+        if not year:
+            _LOGGER.warning(
+                "Could not find year in title, falling back to current year."
+            )
+            year = datetime.date.today().year
+
+        # --- Step 3: Process the table and create Collection objects ---
+        entries = []
+
+        header_cells = target_table.find("tr").find_all("td")
+        headers = [h.get_text(" ", strip=True) for h in header_cells]
+
+        headers = [h.replace("Rejon I I", "Rejon II") for h in headers]
+
+        schedule_columns = {}
+        for i, header in enumerate(headers):
+            if re.match(r"\b" + re.escape(found_region_name) + r"\b", header):
+                waste_type = "BIO" if "BIO" in header else "Segregowane i zmieszane"
+                schedule_columns[i] = waste_type
+
+        for row in target_table.find_all("tr")[1:]:
+            cells = row.find_all("td")
+            if not cells or len(cells) < 2:
+                continue
+
+            month_str_raw = cells[0].get_text(strip=True).lower()
+
+            month_num = MONTH_MAP.get(month_str_raw)
+            if month_num:
+                for col_index, waste_type in schedule_columns.items():
+                    if col_index < len(cells):
+                        days_text = cells[col_index].get_text(strip=True)
+                        days_text_cleaned = re.sub(r"\(.*\)", "", days_text)
+                        days = re.findall(r"\d+", days_text_cleaned)
+                        for day in days:
+                            try:
+                                date = datetime.date(year, month_num, int(day))
+                                entries.append(
+                                    Collection(
+                                        date=date,
+                                        t=waste_type,
+                                        icon=ICON_MAP.get(waste_type),
+                                    )
+                                )
+                            except ValueError:
+                                _LOGGER.warning(
+                                    f"Invalid date created for {day}/{month_num}/{year}"
+                                )
+
+            elif "gabaryty" in month_str_raw:
+                dates_text = None
+                if found_region_name in ["Rejon I", "Rejon III"]:
+                    if len(cells) > 1:
+                        dates_text = cells[1].get_text(strip=True)
+                elif found_region_name in ["Rejon II", "Rejon IV"]:
+                    if len(cells) > 2:
+                        dates_text = cells[2].get_text(strip=True)
+
+                if dates_text:
+                    matches = re.findall(r"(\d+)\s+([a-zA-Zśńćźżęółą]+)", dates_text)
+                    for day, month_name in matches:
+                        month_num_gabaryty = MONTH_MAP.get(month_name.lower())
+                        if month_num_gabaryty:
+                            try:
+                                date = datetime.date(year, month_num_gabaryty, int(day))
+                                entries.append(
+                                    Collection(
+                                        date=date,
+                                        t="Gabaryty",
+                                        icon=ICON_MAP.get("Gabaryty"),
+                                    )
+                                )
+                            except ValueError:
+                                _LOGGER.warning(
+                                    f"Invalid gabaryty date for {day}/{month_name}"
+                                )
+
+        return entries