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

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

@@ -0,0 +1,167 @@
+import datetime
+import re
+
+import requests
+from bs4 import BeautifulSoup
+from waste_collection_schedule import Collection, Icons
+from waste_collection_schedule.exceptions import SourceArgumentNotFound
+
+TITLE = "Kempsey Shire Council"
+DESCRIPTION = "Source script for kempsey.nsw.gov.au waste collection services."
+URL = "https://www.kempsey.nsw.gov.au"
+COUNTRY = "au"
+TEST_CASES = {
+    "10-12 Smith Street Kempsey": {"address": "10-12 Smith Street Kempsey"},
+    "1 Belgrave Street Kempsey": {"address": "1 Belgrave Street Kempsey"},
+}
+
+API_SEARCH_URL = "https://www.kempsey.nsw.gov.au/api/v1/myarea/search"
+API_WASTE_URL = "https://www.kempsey.nsw.gov.au/ocapi/Public/myarea/wasteservices"
+API_WASTE_PAGE_LINK = "/$b9015858-988c-48a4-9473-7c193df083e4$/Residents/Waste-recycling/Waste-bin-collection"
+
+# How many weeks ahead to generate the schedule
+SCHEDULE_WEEKS = 26
+
+ICON_MAP = {
+    "Green Organics Bin": Icons.ORGANIC,
+    "Red Rubbish Bin": Icons.GENERAL_WASTE,
+    "Yellow Recycling Bin": Icons.RECYCLING,
+}
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": "Enter your full street address as it appears on the Kempsey Shire Council website, e.g. '10-12 Smith Street Kempsey'.",
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "address": "Your full street address including suburb, e.g. '10-12 Smith Street Kempsey'",
+    },
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "address": "Full Street Address",
+    },
+}
+
+
+class Source:
+    def __init__(self, address: str):
+        self._address = address
+
+    def fetch(self) -> list[Collection]:
+        # Step 1: Search for the address to get the geolocationid
+        search_response = requests.get(
+            API_SEARCH_URL,
+            params={"keywords": self._address},
+            timeout=30,
+        )
+        search_response.raise_for_status()
+        search_data = search_response.json()
+
+        items = search_data.get("Items", [])
+        if not items:
+            raise SourceArgumentNotFound("address", self._address)
+
+        geolocation_id = items[0].get("Id")
+        if not geolocation_id:
+            raise SourceArgumentNotFound("address", self._address)
+
+        # Step 2: Fetch waste services using the geolocationid
+        waste_response = requests.get(
+            API_WASTE_URL,
+            params={
+                "geolocationid": geolocation_id,
+                "ocsvclang": "en-AU",
+                "pageLink": API_WASTE_PAGE_LINK,
+            },
+            timeout=30,
+        )
+        waste_response.raise_for_status()
+
+        # Step 3: Response is JSON — extract the HTML from responseContent
+        waste_data = waste_response.json()
+        html_content = waste_data.get("responseContent", "")
+        if not html_content:
+            raise Exception(
+                f"Empty response from waste services API for address '{self._address}'."
+            )
+
+        soup = BeautifulSoup(html_content, "html.parser")
+        results = soup.select(".waste-services-result")
+
+        if not results:
+            raise Exception(
+                f"No waste services data found for address '{self._address}'. "
+                "The address may not be serviced or the page structure may have changed."
+            )
+
+        # Step 4: Extract anchor dates for General Waste and Recycling
+        general_waste_date = None
+        recycling_date = None
+
+        for result in results:
+            heading = result.find("h3")
+            if not heading:
+                continue
+            waste_type = heading.get_text(strip=True)
+
+            next_service_div = result.select_one(".next-service")
+            if not next_service_div:
+                continue
+
+            date_text = next_service_div.get_text(separator=" ", strip=True)
+            date_matches = re.findall(r"\d{1,2}/\d{1,2}/\d{4}", date_text)
+
+            if date_matches:
+                first_date = datetime.datetime.strptime(
+                    date_matches[0], "%d/%m/%Y"
+                ).date()
+                if waste_type == "General Waste":
+                    general_waste_date = first_date
+                elif waste_type == "Recycling":
+                    recycling_date = first_date
+
+        if not general_waste_date and not recycling_date:
+            raise Exception(
+                f"Could not parse any collection dates for address '{self._address}'."
+            )
+
+        # Step 5: Build 26-week schedule.
+        # Green Waste every week.
+        # Week A (anchor) = General Waste + Green Waste
+        # Week B = Recycling + Green Waste
+        anchor_date = general_waste_date or recycling_date
+        if anchor_date is None:
+            return []
+        entries = []
+
+        for week in range(SCHEDULE_WEEKS):
+            collection_date = anchor_date + datetime.timedelta(weeks=week)
+
+            entries.append(
+                Collection(
+                    date=collection_date,
+                    t="Green Organics Bin",
+                    icon=ICON_MAP["Green Organics Bin"],
+                )
+            )
+
+            if week % 2 == 0:
+                entries.append(
+                    Collection(
+                        date=collection_date,
+                        t="Red Rubbish Bin",
+                        icon=ICON_MAP["Red Rubbish Bin"],
+                    )
+                )
+            else:
+                entries.append(
+                    Collection(
+                        date=collection_date,
+                        t="Yellow Recycling Bin",
+                        icon=ICON_MAP["Yellow Recycling Bin"],
+                    )
+                )
+
+        return entries

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

@@ -0,0 +1,45 @@
+from waste_collection_schedule import Collection, Icons
+from waste_collection_schedule.service.OpenCities import (
+    OpenCitiesClient,
+    OpenCitiesConfig,
+)
+
+TITLE = "Kiama City Council"
+DESCRIPTION = "Source script for kiama.nsw.gov.au"
+URL = "https://kiama.nsw.gov.au"
+COUNTRY = "au"
+TEST_CASES = {
+    "TestName1": {"geolocationid": "3e54d9b4-e0b8-41cf-8518-d48c1cc5407b"},
+    "TestName2": {"geolocationid": "0d96e409-7a81-4ccb-a0d8-d8435e066182"},
+}
+
+ICON_MAP = {
+    "Urban garbage": Icons.GENERAL_WASTE,
+    "Urban food & garden organics": Icons.BIO_KITCHEN,
+    "Urban recycling": Icons.RECYCLING,
+}
+
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": """Go to <https://www.kiama.nsw.gov.au/Services/Waste-and-recycling/Find-my-bin-collection-dates>
+Open the developer tools (F12), Go to the Network tab
+Put in your address, and click Search.
+
+Look for a network call to the wasteservices endpoint, it will have geolocationid=<GUID>
+This GUID is what you need, it is unique to your service address.""",
+}
+
+_CONFIG = OpenCitiesConfig(
+    domain="https://www.kiama.nsw.gov.au",
+    argument_name="geolocationid",
+    icon_keywords=ICON_MAP,
+)
+
+
+class Source:
+    def __init__(self, geolocationid: str):
+        self._geolocationid = geolocationid
+        self._client = OpenCitiesClient(_CONFIG)
+
+    def fetch(self) -> list[Collection]:
+        return self._client.fetch(geolocation_id=self._geolocationid)

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

@@ -0,0 +1,258 @@
+from datetime import date, datetime, timedelta
+
+import requests
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import SourceArgumentNotFoundWithSuggestions
+
+TITLE = "Kiedy Odpady (kiedyodpady.pl)"
+DESCRIPTION = (
+    "Source for Polish municipalities using the kiedyodpady.pl "
+    "(mOdpady / mMieszkaniec) waste collection platform."
+)
+URL = "https://kiedyodpady.pl"
+COUNTRY = "pl"
+
+EXTRA_INFO = [
+    {
+        "title": "Wieliczka",
+        "url": "https://wieliczka.kiedyodpady.pl",
+        "country": "pl",
+        "default_params": {"municipality": "wieliczka"},
+    },
+    {
+        "title": "Pabianice",
+        "url": "https://pabianice.kiedyodpady.pl",
+        "country": "pl",
+        "default_params": {"municipality": "pabianice"},
+    },
+]
+
+TEST_CASES = {
+    "Wieliczka (miasto), ul. Adama Asnyka, pozostałe": {
+        "municipality": "wieliczka",
+        "city": "Wieliczka (miasto)",
+        "street": "ul. Adama Asnyka",
+        "number": "pozostałe",
+    },
+    'Pabianice (miasto), ul. 15 Pułku Piechoty "Wilków", pozostałe': {
+        "municipality": "pabianice",
+        "city": "Pabianice (miasto)",
+        "street": 'ul. 15 Pułku Piechoty "Wilków"',
+        "number": "pozostałe",
+    },
+}
+
+API_URL = "https://api.kiedyodpady.pl/public"
+DEFAULT_LOOKAHEAD_DAYS = 365
+
+ICON_MAP = {
+    "bio": Icons.ORGANIC,
+    "paper": Icons.PAPER,
+    "plastics": Icons.PLASTIC_PACKAGING,
+    "glass": Icons.GLASS,
+    "mixed": Icons.GENERAL_WASTE,
+    "bulky": Icons.BULKY,
+    "constructionWaste": Icons.BULKY,
+    "hazardous": Icons.HAZARDOUS,
+    "ewaste": Icons.ELECTRONICS,
+    "battery": Icons.BATTERY,
+    "textile": Icons.TEXTILE,
+    "tree": Icons.CHRISTMAS_TREE,
+    "garden": Icons.GARDEN,
+    "metal": Icons.METAL,
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "municipality": "Municipality",
+        "city": "City Name",
+        "street": "Street Name",
+        "number": "House Number",
+        "lookahead_days": "Lookahead Days",
+    },
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "municipality": (
+            "Subdomain slug for your municipality on kiedyodpady.pl, "
+            "e.g. 'pabianice' for pabianice.kiedyodpady.pl."
+        ),
+        "city": "City/locality name as shown in the kiedyodpady.pl UI.",
+        "street": "Street name as shown in the kiedyodpady.pl UI (optional for some localities).",
+        "number": "House number / address entry as shown in the kiedyodpady.pl UI (optional).",
+        "lookahead_days": (
+            "Number of days ahead to fetch the schedule. "
+            "Defaults to 365, matching the official Android app."
+        ),
+    },
+}
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": (
+        "Open https://{municipality}.kiedyodpady.pl (e.g. https://pabianice.kiedyodpady.pl) "
+        "and step through the address selection. "
+        "The municipality value is the subdomain prefix (everything before '.kiedyodpady.pl'). "
+        "Copy the city, street, and house-number values exactly as displayed in the dropdown lists."
+    ),
+}
+
+SOURCE_CODEOWNERS = ["@dominik-korsa"]
+
+
+def _normalize(value: str) -> str:
+    return value.strip().lower().casefold()
+
+
+def _pick_icon(icon_slug: str | None) -> str | None:
+    if not icon_slug:
+        return None
+    return ICON_MAP.get(icon_slug)
+
+
+class Source:
+    def __init__(
+        self,
+        municipality: str,
+        city: str,
+        street: str | None = None,
+        number: str | None = None,
+        lookahead_days: int = DEFAULT_LOOKAHEAD_DAYS,
+    ):
+        self._municipality = municipality.strip().lower()
+        self._city = city.strip()
+        self._street = street.strip() if isinstance(street, str) else None
+        self._number = number.strip() if isinstance(number, str) else None
+        self._lookahead_days = int(lookahead_days)
+        self._session = requests.Session()
+        self._session.headers.update(
+            {
+                "Origin": f"https://{self._municipality}.kiedyodpady.pl",
+                "User-Agent": "Mozilla/5.0",
+                "Accept": "application/json",
+            }
+        )
+
+    def _get_localities(self) -> list[dict]:
+        response = self._session.get(f"{API_URL}/territory/localities", timeout=30)
+        response.raise_for_status()
+        return response.json()
+
+    def _resolve_city_id(self) -> str:
+        localities = self._get_localities()
+        target = _normalize(self._city)
+
+        for locality in localities:
+            extended_name = locality.get("extendedName", "")
+            if extended_name and _normalize(extended_name) == target:
+                return locality["id"]
+
+        suggestions = [
+            locality.get("extendedName")
+            for locality in localities
+            if locality.get("extendedName")
+        ]
+        raise SourceArgumentNotFoundWithSuggestions(
+            "city",
+            self._city,
+            suggestions=suggestions,
+        )
+
+    def _get_streets(self, locality_id: str) -> list[dict]:
+        response = self._session.get(
+            f"{API_URL}/territory/localities/{locality_id}/streets",
+            timeout=30,
+        )
+        response.raise_for_status()
+        return response.json()
+
+    def _resolve_street_id(self, locality_id: str) -> str | None:
+        if not self._street:
+            return None
+        streets = self._get_streets(locality_id)
+        target = _normalize(self._street)
+
+        for street in streets:
+            extended_name = street.get("extendedName", "")
+            if extended_name and _normalize(extended_name) == target:
+                return street["id"]
+
+        suggestions = [
+            street.get("extendedName")
+            for street in streets
+            if street.get("extendedName")
+        ]
+        raise SourceArgumentNotFoundWithSuggestions(
+            "street",
+            self._street,
+            suggestions=suggestions,
+        )
+
+    def _validate_number(self, locality_id: str, street_id: str | None) -> None:
+        if not street_id or not self._number:
+            return
+        response = self._session.get(
+            f"{API_URL}/territory/localities/{locality_id}/addresses/{street_id}",
+            timeout=30,
+        )
+        response.raise_for_status()
+        numbers = response.json()
+        if self._number not in numbers:
+            raise SourceArgumentNotFoundWithSuggestions(
+                "number",
+                self._number,
+                suggestions=numbers,
+            )
+
+    def _get_waste_type_map(self) -> dict[str, tuple[str, str | None]]:
+        response = self._session.get(f"{API_URL}/waste-types", timeout=30)
+        response.raise_for_status()
+        result: dict[str, tuple[str, str | None]] = {}
+        for item in response.json():
+            if "id" in item:
+                result[item["id"]] = (item.get("name", item["id"]), item.get("icon"))
+        return result
+
+    def fetch(self) -> list[Collection]:
+        locality_id = self._resolve_city_id()
+        street_id = self._resolve_street_id(locality_id)
+        self._validate_number(locality_id, street_id)
+        waste_type_map = self._get_waste_type_map()
+
+        today = date.today()
+        date_to = today + timedelta(days=self._lookahead_days)
+        payload = {
+            "from": today.isoformat(),
+            "to": date_to.isoformat(),
+            "queries": [
+                {
+                    "localityId": locality_id,
+                    "streetId": street_id or "",
+                    "number": self._number or "",
+                    "propertyType": "",
+                    "buildingType": "",
+                }
+            ],
+        }
+
+        response = self._session.post(
+            f"{API_URL}/schedules/find",
+            json=payload,
+            timeout=30,
+        )
+        response.raise_for_status()
+        data = response.json()
+
+        entries: list[Collection] = []
+        for occurrence in data.get("occurrences", []):
+            waste_id = occurrence.get("what", "")
+            waste_name, icon_slug = waste_type_map.get(waste_id, (waste_id, None))
+            entries.append(
+                Collection(
+                    date=datetime.fromisoformat(occurrence["when"]).date(),
+                    t=waste_name,
+                    icon=_pick_icon(icon_slug),
+                )
+            )
+
+        return entries

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

@@ -0,0 +1,210 @@
+import datetime
+from typing import Any
+
+import requests
+from waste_collection_schedule import Collection, Icons
+from waste_collection_schedule.exceptions import (
+    SourceArgumentExceptionMultiple,
+    SourceArgumentNotFoundWithSuggestions,
+)
+
+TITLE = "Kiedy śmieci"
+DESCRIPTION = "Source script for Kiedy śmieci, Poland"
+URL = "https://kiedysmieci.info"
+COUNTRY = "pl"
+TEST_CASES = {
+    "Nadolany, podkarpackie, sanocki, Bukowsko": {
+        "voivodeship": "podkarpackie",
+        "district": "sanocki",
+        "municipality": "Bukowsko",
+        "street": "Nadolany",
+    },
+    "Kędzierz, podkarpackie, dębicki, Dębica": {
+        "voivodeship": "podkarpackie",
+        "district": "dębicki",
+        "municipality": "Dębica",
+        "street": "Kędzierz",
+    },
+    "Parkowa, lubelskie, zamojski, Szczebrzeszyn": {
+        "voivodeship": "lubelskie",
+        "district": "zamojski",
+        "municipality": "Szczebrzeszyn",
+        "street": "Parkowa",
+    },
+}
+
+API_URL = "https://kiedysmieci.info/schedule-proxy.php"
+
+ICON_MAP = {
+    "zmieszane": Icons.GENERAL_WASTE,
+    "metale i tworzywa sztuczne": Icons.METAL,
+    "papier i tektura": Icons.PAPER,
+    "szkło": Icons.GLASS,
+    "biodegradowalne": Icons.BIO_KITCHEN,
+}
+
+# Beside the five streams above, municipalities announce extra pickups under
+# free-text names that vary between them (and contain the occasional typo), so
+# these are matched on a keyword instead of being listed exhaustively. Grouped
+# for readability only - the keyword found earliest in the name wins, see
+# _icon_for().
+ICON_KEYWORDS: tuple[tuple[str, Icons], ...] = (
+    # "gabaryt" also covers the "wielkogabaryt-" and "wielogabaryt-" (sic)
+    # prefixes.
+    ("gabaryt", Icons.BULKY),
+    ("meble", Icons.BULKY),
+    # Not pickups: the same feed carries payment deadlines, drop-off point
+    # (PSZOK) openings and bin-washing rounds. EVENT keeps them from looking
+    # like a waste collection.
+    ("płatnoś", Icons.EVENT),
+    ("opłata", Icons.EVENT),
+    ("pszok", Icons.EVENT),
+    ("punkt selektywnej", Icons.EVENT),
+    ("mycie", Icons.EVENT),
+    ("odbiór odpadów z pojemników", Icons.EVENT),
+    # Electronics. "elekto" is the provider's misspelling of "elektro".
+    ("elektro", Icons.ELECTRONICS),
+    ("elekto", Icons.ELECTRONICS),
+    ("sprzęt agd i rtv", Icons.ELECTRONICS),
+    # Textiles.
+    ("tekstyl", Icons.TEXTILE),
+    ("odzież", Icons.TEXTILE),
+    ("ubrania", Icons.TEXTILE),
+)
+
+# Streams this source cannot label yet because the icon catalogue has no
+# member for them. They still have to be recognised: a name that leads with
+# one of these ("opony i tekstylia") must not be labelled after the stream it
+# merely mentions second.
+UNMAPPED_STREAMS = ("opony", "popi", "gruz", "budowlan")
+
+# A leading "*" marks a pickup that has to be requested; it is not part of the
+# waste type's name.
+ON_REQUEST_MARKER = "*"
+
+# The location cascade, from the widest to the narrowest level:
+# source argument -> query parameter (which doubles as the key of a returned
+# item) -> key holding the list of options in the response.
+LOCATION_LEVELS = (
+    ("voivodeship", "wojewodztwo", "listaWojewodztw"),
+    ("district", "powiat", "listaPowiatow"),
+    ("municipality", "gmina", "listaGmin"),
+    ("street", "ulica", "listaUlic"),
+)
+
+# A known location without a published schedule yields a single placeholder
+# entry instead of an empty list.
+NO_SCHEDULE_MARKER = "brak harmonogramu"
+
+
+def _icon_for(waste_type: str) -> Icons:
+    """Pick an icon for a waste type, falling back to general waste.
+
+    Some municipalities collect several streams in one round and name them all
+    ("odpady wielkogabarytowe, opony, elektrośmieci"), so the stream named
+    first decides the icon. If that one is a stream this source cannot label,
+    the round stays on the default rather than being named after a stream that
+    is only part of it.
+    """
+    name = waste_type.lstrip(ON_REQUEST_MARKER).strip().lower()
+
+    if name in ICON_MAP:
+        return ICON_MAP[name]
+
+    matches = [(name.find(kw), icon) for kw, icon in ICON_KEYWORDS if kw in name]
+    if not matches:
+        return Icons.GENERAL_WASTE
+
+    first, icon = min(matches)
+    unmapped = [name.find(kw) for kw in UNMAPPED_STREAMS if kw in name]
+    if any(pos < first for pos in unmapped):
+        return Icons.GENERAL_WASTE
+
+    return icon
+
+
+class Source:
+    def __init__(self, voivodeship: str, district: str, municipality: str, street: str):
+        self._location = {
+            "wojewodztwo": voivodeship,
+            "powiat": district,
+            "gmina": municipality,
+            "ulica": street,
+        }
+
+    def _get(self, request_type: str, params: dict[str, str]) -> dict[str, Any]:
+        response = requests.get(
+            API_URL, params={"type": request_type} | params, timeout=30
+        )
+
+        # Errors are reported in the JSON envelope (with a 4xx/5xx status), so
+        # parse the body before looking at the status code.
+        try:
+            payload = response.json()
+        except ValueError:
+            response.raise_for_status()
+            raise
+
+        if not payload.get("ok"):
+            raise Exception(
+                payload.get("message") or "Unexpected response from kiedysmieci.info"
+            )
+
+        return payload.get("data") or {}
+
+    def _validate_location(self) -> None:
+        """Walk the location cascade and report the first argument that is unknown.
+
+        Returns without raising if every level matches, which means the request
+        failed for another reason.
+        """
+        selection: dict[str, str] = {}
+
+        for argument, param, list_key in LOCATION_LEVELS:
+            try:
+                items = self._get("locations", selection).get(list_key) or []
+            except Exception:
+                # The cascade itself is unreachable, so it cannot tell us
+                # anything - leave the original error to the caller.
+                return
+
+            options = [item[param] for item in items if item.get(param)]
+            value = self._location[param]
+            match = next((o for o in options if o.lower() == value.lower()), None)
+
+            if match is None:
+                raise SourceArgumentNotFoundWithSuggestions(argument, value, options)
+
+            selection[param] = match
+
+    def fetch(self) -> list[Collection]:
+        try:
+            data = self._get("terms", self._location)
+        except Exception:
+            # Turn a generic "not found" from the API into an error pointing at
+            # the argument that is actually wrong.
+            self._validate_location()
+            raise
+
+        schedule = data.get("listaTerminow") or []
+        entries = [
+            Collection(
+                date=datetime.datetime.strptime(
+                    entry["dataOdbioru"], "%Y-%m-%d"
+                ).date(),
+                t=entry["nazwaTypuSmieci"],
+                icon=_icon_for(entry["nazwaTypuSmieci"]),
+            )
+            for entry in schedule
+            if entry.get("dzienTygodnia") != NO_SCHEDULE_MARKER
+        ]
+
+        if not entries:
+            self._validate_location()
+            raise SourceArgumentExceptionMultiple(
+                ("municipality", "street"),
+                f"No schedule published for {self._location['ulica']}, "
+                f"{self._location['gmina']}",
+            )
+
+        return entries