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

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

@@ -0,0 +1,215 @@
+import re
+from datetime import datetime
+
+import requests
+from bs4 import BeautifulSoup
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import (
+    SourceArgumentNotFound,
+    SourceArgumentNotFoundWithSuggestions,
+)
+
+TITLE = "Fairfield City Council"
+DESCRIPTION = "Source for Fairfield City Council bin collection, NSW, Australia."
+URL = "https://kerbside.fairfieldcity.nsw.gov.au/kerbside/"
+COUNTRY = "au"
+TEST_CASES = {
+    "1 Dawson Street, FAIRFIELD HEIGHTS": {
+        "street_number": "1",
+        "street_and_suburb": "Dawson Street, FAIRFIELD HEIGHTS",
+    },
+    "12 Zadro Avenue, BOSSLEY PARK": {
+        "street_number": "12",
+        "street_and_suburb": "Zadro Avenue, BOSSLEY PARK",
+    },
+    # Abbreviated street types: what the council's autocomplete used to emit,
+    # and therefore what most existing configurations still contain.
+    "1 Dawson ST, FAIRFIELD HEIGHTS (abbreviated)": {
+        "street_number": "1",
+        "street_and_suburb": "Dawson ST, FAIRFIELD HEIGHTS",
+    },
+    "12 Zadro AVE, BOSSLEY PARK (abbreviated)": {
+        "street_number": "12",
+        "street_and_suburb": "Zadro AVE, BOSSLEY PARK",
+    },
+}
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": (
+        "Visit https://kerbside.fairfieldcity.nsw.gov.au/kerbside/ and start typing "
+        "your street name and suburb into the 'Street name & Suburb' field. "
+        "Use the autocomplete suggestion (e.g. 'Dawson Street, FAIRFIELD HEIGHTS') "
+        "as the value for street_and_suburb, and enter just your street number "
+        "for street_number. Abbreviated street types from older configurations "
+        "(e.g. 'Dawson ST, FAIRFIELD HEIGHTS') are still accepted."
+    )
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "street_number": "Street Number",
+        "street_and_suburb": "Street Name & Suburb",
+    }
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "street_number": "Your street number (e.g. 1, 7A, 7/10).",
+        "street_and_suburb": (
+            "Street name and suburb as shown in the autocomplete list "
+            "(e.g. 'Dawson Street, FAIRFIELD HEIGHTS'). Abbreviated street "
+            "types such as 'Dawson ST, FAIRFIELD HEIGHTS' also work."
+        ),
+    }
+}
+
+ICON_MAP = {
+    "Red bin": Icons.GENERAL_WASTE,
+    "Yellow bin": Icons.RECYCLING,
+    "Green bin": Icons.ORGANIC,
+}
+
+API_URL = "https://kerbside.fairfieldcity.nsw.gov.au/kerbside/"
+# The council's own autocomplete list. The form only answers for a value taken
+# verbatim from it, and the list was switched from abbreviated street types
+# ("Dawson ST") to spelled-out ones ("Dawson Street"), which silently broke
+# every previously valid saved value.
+AUTOCOMPLETE_URL = f"{API_URL}fcc-autocomplete.js"
+AUTOCOMPLETE_ARRAY = "arrAddressStreetAndSuburb"
+
+# Street-type abbreviations seen in the old list and in what people type.
+STREET_TYPES = {
+    "AV": "AVENUE",
+    "AVE": "AVENUE",
+    "BVD": "BOULEVARD",
+    "CCT": "CIRCUIT",
+    "CH": "CHASE",
+    "CL": "CLOSE",
+    "CR": "CRESCENT",
+    "CRES": "CRESCENT",
+    "CT": "COURT",
+    "DR": "DRIVE",
+    "ESP": "ESPLANADE",
+    "GDNS": "GARDENS",
+    "GR": "GROVE",
+    "GRV": "GROVE",
+    "HWY": "HIGHWAY",
+    "LN": "LANE",
+    "LP": "LOOP",
+    "PDE": "PARADE",
+    "PKWY": "PARKWAY",
+    "PL": "PLACE",
+    "RD": "ROAD",
+    "RSE": "RISE",
+    "SQ": "SQUARE",
+    "ST": "STREET",
+    "TCE": "TERRACE",
+    "WY": "WAY",
+}
+
+
+def _canonical(value: str) -> str:
+    """Upper-case words only, single-spaced, street types spelled out.
+
+    Comparing on this lets a stored "Dawson ST, FAIRFIELD HEIGHTS" match the
+    list's current "Dawson Street, FAIRFIELD HEIGHTS", and vice versa.
+    Punctuation and repeated spaces are dropped rather than preserved, so a
+    missing comma or a doubled space is not the thing that fails a lookup.
+    """
+    words = re.findall(r"\w+", value.upper())
+    return " ".join(STREET_TYPES.get(w, w) for w in words)
+
+
+class Source:
+    def __init__(self, street_number: str, street_and_suburb: str):
+        self._street_number = str(street_number).strip()
+        self._street_and_suburb = street_and_suburb.strip()
+
+    def _known_streets(self, session: requests.Session) -> list[str]:
+        try:
+            response = session.get(AUTOCOMPLETE_URL, timeout=30)
+            response.raise_for_status()
+        except requests.RequestException:
+            # The list is a convenience, not the lookup itself. A timeout, a
+            # refused connection or a 5xx must not stop the POST that would
+            # otherwise have worked, so treat it as "no list" and fall back.
+            return []
+        match = re.search(
+            AUTOCOMPLETE_ARRAY + r"\s*=\s*\[(.*?)\]", response.text, re.DOTALL
+        )
+        if not match:
+            return []
+        return re.findall(r'"([^"]+)"', match.group(1))
+
+    def _resolve_street_and_suburb(self, session: requests.Session) -> str:
+        streets = self._known_streets(session)
+        if not streets:
+            # Autocomplete unavailable or restructured; send what we were given
+            # rather than refusing outright.
+            return self._street_and_suburb
+        wanted = _canonical(self._street_and_suburb)
+        for street in streets:
+            if _canonical(street) == wanted:
+                return street
+        raise SourceArgumentNotFoundWithSuggestions(
+            "street_and_suburb", self._street_and_suburb, streets
+        )
+
+    def fetch(self) -> list[Collection]:
+        session = requests.Session()
+        street_and_suburb = self._resolve_street_and_suburb(session)
+
+        response = session.post(
+            API_URL,
+            data={
+                "myStreetNumber": self._street_number,
+                "myStreetAndSuburb": street_and_suburb,
+            },
+            timeout=30,
+        )
+        response.raise_for_status()
+
+        soup = BeautifulSoup(response.text, "html.parser")
+
+        results_area = soup.find("div", id="fcc-results-area")
+        if results_area is None:
+            raise SourceArgumentNotFound(
+                "street_and_suburb",
+                self._street_and_suburb,
+            )
+
+        entries: list[Collection] = []
+        seen_types: set[str] = set()
+
+        for p in results_area.find_all("p"):
+            img = p.find("img")
+            strong = p.find("strong")
+            if img is None or strong is None:
+                continue
+
+            bin_type = img.get("alt", "").strip()
+            if not bin_type or bin_type in seen_types:
+                continue
+
+            date_text = strong.get_text(strip=True)
+            try:
+                collection_date = datetime.strptime(date_text, "%A, %d/%m/%Y").date()
+            except ValueError:
+                continue
+
+            seen_types.add(bin_type)
+            entries.append(
+                Collection(
+                    date=collection_date,
+                    t=bin_type,
+                    icon=ICON_MAP.get(bin_type),
+                )
+            )
+
+        if not entries:
+            raise SourceArgumentNotFound(
+                "street_and_suburb",
+                self._street_and_suburb,
+            )
+
+        return entries

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

@@ -0,0 +1,196 @@
+import json
+import re
+from collections.abc import Iterable
+from datetime import date
+
+import requests
+from dateutil.parser import parse as date_parse
+from waste_collection_schedule import Collection, Icons
+from waste_collection_schedule.exceptions import (
+    SourceArgumentNotFound,
+    SourceArgumentRequired,
+)
+
+TITLE = "Fareham Borough Council"
+DESCRIPTION = "Source for fareham.gov.uk"
+URL = "https://www.fareham.gov.uk"
+TEST_CASES = {
+    "HUNTS_POND_ROAD": {"road_name": "Hunts pond road", "postcode": "PO14 4PL"},
+    "CHRUCH_ROAD": {"road_name": "Church road", "postcode": "SO31 6LW"},
+    "BRIDGE_ROAD": {"road_name": "Bridge road", "postcode": "SO31 7GD"},
+    "SEGENSWORTH_ROAD": {"road_name": "203 Segensworth road", "postcode": "PO15 5EL"},
+}
+
+API_URL = "https://www.fareham.gov.uk/internetlookups/search_data.aspx"
+API_LIST = "DomesticBinCollections2025on"
+DEFAULT_ICON = "mdi:trash-can"
+ICON_MAP = {
+    "Refuse": Icons.GENERAL_WASTE,
+    "Recycling": Icons.RECYCLING,
+    "Garden Waste": Icons.GARDEN,
+}
+
+
+class Source:
+    def __init__(self, road_name: str, postcode: str):
+        if not road_name or not road_name.strip():
+            raise SourceArgumentRequired(
+                "road_name", "please provide the road name as listed by the council"
+            )
+        if not postcode or not postcode.strip():
+            raise SourceArgumentRequired(
+                "postcode", "please provide the postcode recognised by the council"
+            )
+
+        self._road_name = road_name.strip()
+        self._postcode = postcode.strip()
+
+    def fetch(self) -> list[Collection]:
+        rows = self._request_rows(self._postcode)
+        if not rows:
+            raise SourceArgumentNotFound(
+                "postcode",
+                self._postcode,
+                "please verify the postcode on recent council correspondence",
+            )
+
+        matches = self._filter_rows(rows)
+
+        if not matches:
+            raise SourceArgumentNotFound(
+                "road_name",
+                self._road_name,
+                "please ensure it matches the selected postcode",
+            )
+
+        collections = []
+        seen = set()
+        for row in matches:
+            bin_info = row.get("BinCollectionInformation", "")
+            for collection in self.extract_collections(bin_info):
+                key = (collection.date, collection.type)
+                if key in seen:
+                    continue
+                seen.add(key)
+                collections.append(collection)
+
+            garden_info = row.get("GardenWasteBinDay<br/>(seenotesabove)")
+            if garden_info:
+                for collection in self.extract_garden_collection(garden_info):
+                    key = (collection.date, collection.type)
+                    if key in seen:
+                        continue
+                    seen.add(key)
+                    collections.append(collection)
+
+        return sorted(collections, key=lambda col: col.date)
+
+    def _request_rows(self, query: str):
+        if not query:
+            raise SourceArgumentRequired(
+                "postcode", "please provide the postcode recognised by the council"
+            )
+        params = {
+            "type": "JSON",
+            "list": API_LIST,
+            "Road or Postcode": query,
+        }
+        headers = {
+            "user-agent": "Mozilla/5.0",
+        }
+        response = requests.get(API_URL, params=params, headers=headers, timeout=30)
+        response.raise_for_status()
+        payload = json.loads(self._fix_json(response.text))
+        return payload.get("data", {}).get("rows", [])
+
+    def _filter_rows(self, rows: Iterable[dict]):
+        postcode_norm = self._normalize(self._postcode)
+        house_number, street_name = self._split_house_number(self._road_name)
+        street_tokens = set(self._tokenize(street_name))
+        matches = []
+
+        for row in rows:
+            address = row.get("Address", "")
+            address_norm = self._normalize(address)
+            address_tokens = set(self._tokenize(address))
+
+            if postcode_norm and postcode_norm not in address_norm:
+                continue
+
+            if street_tokens and not street_tokens.issubset(address_tokens):
+                continue
+
+            if house_number and house_number.lower() not in address_tokens:
+                continue
+
+            matches.append(row)
+
+        return matches
+
+    @staticmethod
+    def _fix_json(text: str) -> str:
+        rows_start = text.find('"rows": [')
+        if rows_start == -1:
+            return text
+        prefix = text[:rows_start]
+        rows_section = text[rows_start:]
+        # Remove incomplete stub entries: { "Row": "N", immediately followed by another {
+        rows_section = re.sub(r'\{\s*"Row":\s*"\d+",\s*(?=\{)', "", rows_section)
+        # Add missing { after }, when the next token is a property key
+        rows_section = re.sub(r"(},)(\s*)(\")", r"\1\2{\3", rows_section)
+        return prefix + rows_section
+
+    @staticmethod
+    def _normalize(value: str):
+        return re.sub(r"[^a-z0-9]", "", value.lower())
+
+    @staticmethod
+    def _tokenize(value: str):
+        if not value:
+            return []
+        return re.findall(r"[a-z0-9]+", value.lower())
+
+    @staticmethod
+    def _split_house_number(value: str):
+        match = re.match(r"\s*(\d+[a-zA-Z]?)\s+(.+)", value)
+        if match:
+            return match.group(1), match.group(2).strip()
+        return None, value.strip()
+
+    def extract_collections(self, string: str) -> list[Collection]:
+        """Parse collection entries like '03/11/2025 (Refuse) and 10/11/2025 (Recycling)'."""
+        collections: list[Collection] = []
+        if not string:
+            return collections
+        pattern = r"(?P<date>\d{1,2}\/\d{1,2}\/\d{4}|today) \((?P<waste_type>[^)]+)\)"
+        for match in re.finditer(pattern, string):
+            if match.group("date") == "today":
+                collection_date = date.today()
+            else:
+                collection_date = date_parse(match.group("date"), dayfirst=True).date()
+
+            waste_type = match.group("waste_type")
+            collections.append(
+                Collection(
+                    date=collection_date,
+                    t=waste_type,
+                    icon=ICON_MAP.get(waste_type, DEFAULT_ICON),
+                )
+            )
+        return collections
+
+    def extract_garden_collection(self, string: str) -> list[Collection]:
+        collections: list[Collection] = []
+        if not string:
+            return collections
+        match = re.search(r"(?P<date>\d{1,2}\/\d{1,2}\/\d{4})", string)
+        if match:
+            collection_date = date_parse(match.group("date"), dayfirst=True).date()
+            collections.append(
+                Collection(
+                    date=collection_date,
+                    t="Garden Waste",
+                    icon=ICON_MAP.get("Garden Waste", DEFAULT_ICON),
+                )
+            )
+        return collections

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

@@ -0,0 +1,246 @@
+from datetime import datetime
+from typing import Literal, TypedDict
+
+import requests
+from dateutil.parser import parse
+from waste_collection_schedule import Collection, Icons
+from waste_collection_schedule.exceptions import (
+    SourceArgumentNotFoundWithSuggestions,
+    SourceArgumentRequiredWithSuggestions,
+)
+
+TITLE = "fcc Environment"
+DESCRIPTION = "Source for fcc Environment."
+URL = "https://www.fcc-group.eu/"
+TEST_CASES = {
+    "Cífer J. Kubányiho": {
+        "city": "Cífer",
+        "location": "J. Kubányiho",
+    },
+    "Borinka Weekly": {"city": "Borinka", "frequency": "weekly"},
+    "Cerová Monthly": {"city": "Cerová", "frequency": "monthly"},
+}
+
+COUNTRY = "sk"
+
+
+ICON_MAP = {
+    "Komunálny": Icons.GENERAL_WASTE,
+    "Plasty": Icons.PLASTIC_PACKAGING,
+    "Papier": Icons.PAPER,
+    "Separovaný": Icons.RECYCLING,
+}
+
+
+class City(TypedDict):
+    locationId: int
+    city: str
+    code: str
+    defaultFrequencyTitle: None | str
+    locations: None | list[str]
+
+
+class Waste(TypedDict):
+    wasteId: int
+    title: str
+    type: int
+
+
+class OptionsResult(TypedDict):
+    defaultFrequencyTitle: str | None
+    frequencies: list[int]
+    wastes: list[Waste]
+
+
+class CollecctionEntry(TypedDict):
+    scheduleId: int
+    wasteId: int
+    wasteType: int
+    date: str
+    isBiweekly: bool
+    isMonthly: bool
+
+
+API_URL = "https://vylozsmeti.kabernet.sk/api/public"
+
+
+def cmp(a: str, b: str) -> bool:  # type: ignore[attr-defined]
+    return a.lower().replace(" ", "") == b.lower().replace(" ", "")
+
+
+FREQUENCIES_LITERAL = Literal["weekly", "biweekly", "monthly"]
+FREQUENCIES: list[FREQUENCIES_LITERAL] = ["weekly", "biweekly", "monthly"]
+
+DEFAULT_FREQUENCY_MAP: dict[str, FREQUENCIES_LITERAL] = {
+    "dvojtýždenne": "biweekly",
+    "týždenne": "weekly",
+    "": "weekly",
+}
+
+
+class Source:
+    def __init__(
+        self,
+        city: str,
+        location: str | None = None,
+        frequency: FREQUENCIES_LITERAL | None = None,
+    ):
+        self._city: str = city
+        self._location: str | None = location
+        self._frequency: FREQUENCIES_LITERAL | None = frequency
+
+        if frequency and frequency not in FREQUENCIES:
+            raise ValueError(
+                f"Invalid frequency: {frequency}, must be one of {FREQUENCIES}"
+            )
+
+        self._location_id: int | None = None
+        self._waste_dict: dict[int, str] | None = None
+
+    def fetch_city(self) -> City:
+        r = requests.get(API_URL + "/location", params={"includeLocations": "True"})
+        r.raise_for_status()
+        data: list[City] = r.json()
+        matches = []
+        for city in data:
+            if cmp(city["city"], self._city) or cmp(city["code"], self._city):
+                matches.append(city)
+        if len(matches) == 0:
+            raise SourceArgumentNotFoundWithSuggestions(
+                "city", self._city, [city["city"] for city in data]
+            )
+        if len(matches) == 1:
+            return matches[0]
+
+        if not self._location:
+            raise SourceArgumentRequiredWithSuggestions(
+                "location",
+                "for this city",
+                [
+                    location
+                    for city in matches
+                    for location in (city["locations"] or [])
+                ],
+            )
+
+        for city in matches:
+            if any(
+                cmp(location, self._location) for location in (city["locations"] or [])
+            ):
+                return city
+
+        raise SourceArgumentNotFoundWithSuggestions(
+            "location",
+            self._location,
+            [location for city in matches for location in (city["locations"] or [])],
+        )
+
+    def fetch_options(self, location_id: int) -> OptionsResult:
+        r = requests.get(
+            API_URL + "/schedule/options", params={"locationId": location_id}
+        )
+        r.raise_for_status()
+        data: OptionsResult = r.json()
+        if len(data["frequencies"]) == 0:
+            self._frequency = "weekly"
+            return data
+        if len(data["frequencies"]) == 1:
+            self._frequency = FREQUENCIES[data["frequencies"][0] - 1]
+
+        available_freqs: list[FREQUENCIES_LITERAL] = [
+            FREQUENCIES[freq - 1] for freq in data["frequencies"]
+        ]
+        if self._frequency in available_freqs:
+            return data
+
+        changed: dict[str, FREQUENCIES_LITERAL] = {}
+
+        if (
+            data["defaultFrequencyTitle"]
+            and data["defaultFrequencyTitle"] in DEFAULT_FREQUENCY_MAP
+            and "weekly" in available_freqs
+        ):
+            available_freqs.remove("weekly")
+            available_freqs.append(DEFAULT_FREQUENCY_MAP[data["defaultFrequencyTitle"]])
+            changed[DEFAULT_FREQUENCY_MAP[data["defaultFrequencyTitle"]]] = "weekly"
+
+        if len(data["frequencies"]) > 1:
+            if not self._frequency:
+                raise SourceArgumentRequiredWithSuggestions(
+                    "frequency", "for this location", available_freqs
+                )
+
+            if self._frequency not in available_freqs:
+                raise SourceArgumentNotFoundWithSuggestions(
+                    "frequency", self._frequency, available_freqs
+                )
+            if self._frequency in changed:
+                self._frequency = changed[self._frequency]
+
+        return data
+
+    def get_waste_dict(self, location_id: int) -> dict[int, str]:
+        options = self.fetch_options(location_id)
+        return {waste["wasteId"]: waste["title"] for waste in options["wastes"]}
+
+    def fetch_schedule(self, location_id: int, year: int) -> list[CollecctionEntry]:
+        r = requests.get(
+            API_URL + "/schedule", params={"locationId": location_id, "year": year}
+        )
+        r.raise_for_status()
+        return r.json()
+
+    def fetch(self) -> list[Collection]:
+        fresh_data = False
+        if not self._location_id:
+            fresh_data = True
+            city = self.fetch_city()
+            self._location_id = city["locationId"]
+        if not self._waste_dict:
+            self._waste_dict = self.get_waste_dict(self._location_id)
+
+        try:
+            return self._get_collections()
+        except Exception:
+            if fresh_data:
+                raise
+            self._location_id = self.fetch_city()["locationId"]
+            self._waste_dict = self.get_waste_dict(self._location_id)
+            return self._get_collections()
+
+    def _get_collections(self) -> list[Collection]:
+        now = datetime.now()
+        year = now.year
+        entries = self._get_collections_with_year(year)
+        if now.month == 12:
+            try:
+                entries += self._get_collections_with_year(year + 1)
+            except Exception:
+                pass
+        return entries
+
+    def _match_frequency(self, entry: CollecctionEntry) -> bool:
+        if entry["wasteType"] != 1:
+            return True
+        if self._frequency == "weekly":
+            return True
+        if self._frequency == "biweekly":
+            return entry["isBiweekly"]
+        if self._frequency == "monthly":
+            return entry["isMonthly"]
+        return False
+
+    def _get_collections_with_year(self, year: int) -> list[Collection]:
+        if not self._location_id or not self._waste_dict:  # Should not happen
+            raise Exception("Location ID and waste dict must be set")
+
+        schedule = self.fetch_schedule(self._location_id, year)
+        entries: list[Collection] = []
+        for entry in schedule:
+            if not self._match_frequency(entry):
+                continue
+            waste_type = self._waste_dict[entry["wasteId"]]
+            date = parse(entry["date"]).date()
+            icon = ICON_MAP.get(waste_type.split()[0])
+            entries.append(Collection(date=date, t=waste_type, icon=icon))
+        return entries