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

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

@@ -0,0 +1,183 @@
+import json
+import logging
+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 (
+    SourceArgumentException,
+    SourceArgumentNotFoundWithSuggestions,
+)
+
+TITLE = "Roslagsvatten"
+DESCRIPTION = (
+    "Source for Roslagsvatten waste collection (Österåker, Vaxholm and Ekerö)."
+)
+URL = "https://roslagsvatten.se"
+
+VALID_MUNICIPALITIES = {
+    "osteraker": "Österåker",
+    "vaxholm": "Vaxholm",
+    "ekero": "Ekerö",
+}
+
+TEST_CASES = {
+    "Österaker Test": {
+        "street_address": "Andromedavägen 1, Åkersberga",
+        "municipality": "osteraker",
+    },
+    "Vaxholm Test": {
+        "street_address": "Hamngatan 1, Vaxholm",
+        "municipality": "vaxholm",
+    },
+    "Ekerö Test": {
+        "street_address": "Ekerö Kyrkväg 1, Ekerö",
+        "municipality": "ekero",
+    },
+}
+
+EXTRA_INFO = [
+    {"title": v, "default_params": {"municipality": k}}
+    for k, v in VALID_MUNICIPALITIES.items()
+]
+
+_LOGGER = logging.getLogger(__name__)
+
+ICON_MAP = {
+    "Restavfall": Icons.GENERAL_WASTE,
+    "Matavfall": Icons.BIO_KITCHEN,
+    "Rest- matavfall": Icons.BIO_KITCHEN,
+    "Slam": Icons.GENERAL_WASTE,
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "street_address": "Street Address (e.g., Andromedavägen 1, Åkersberga)",
+        "municipality": "Municipality, one of: 'osteraker', 'vaxholm', or 'ekero'",
+    },
+    "de": {
+        "street_address": "Straßenadresse (z.B. Andromedavägen 1, Åkersberga)",
+        "municipality": "Gemeinde, eine von: 'osteraker', 'vaxholm' oder 'ekero'",
+    },
+    "it": {
+        "street_address": "Indirizzo (es. Andromedavägen 1, Åkersberga)",
+        "municipality": "Comune, uno di: 'osteraker', 'vaxholm' o 'ekero'",
+    },
+    "fr": {
+        "street_address": "Adresse (par ex. Andromedavägen 1, Åkersberga)",
+        "municipality": "Municipalité, l'une des suivantes : 'osteraker', 'vaxholm' ou 'ekero'",
+    },
+}
+
+
+class Source:
+    def __init__(self, street_address: str, municipality: str):
+        self._street_address = street_address
+        self._municipality = municipality.lower()
+        self._api_url = "https://roslagsvatten.se/schedule"
+
+        if self._municipality not in VALID_MUNICIPALITIES:
+            raise SourceArgumentNotFoundWithSuggestions(
+                "municipality", self._municipality, VALID_MUNICIPALITIES.keys()
+            )
+
+    def fetch(self):
+        # 1. SEARCH for the building ID
+        search_payload = {
+            "searchText": self._street_address,
+            "municipality": self._municipality,
+        }
+
+        headers = {
+            "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8",
+            "X-Requested-With": "XMLHttpRequest",
+            "User-Agent": "Mozilla/5.0",
+        }
+
+        r = requests.post(
+            f"{self._api_url}/search", data=json.dumps(search_payload), headers=headers
+        )
+        r.raise_for_status()
+
+        search_results = r.json()
+        if (
+            not isinstance(search_results, list)
+            or not search_results
+            or "data" not in search_results[0]
+        ):
+            raise SourceArgumentException(
+                "street_address",
+                "Unexpected response format from Roslagsvatten API. Please try again later.",
+            )
+
+        # Extract data-bid="12345" from the HTML response
+        html_search = search_results[0]["data"]
+        bid_match = re.search(r'data-bid="(\d+)"', html_search)
+
+        if not bid_match:
+            raise SourceArgumentException(
+                "street_address",
+                f"Address '{self._street_address}' not found in municipality '{self._municipality}'. "
+                "Please check the spelling or format, test the address on the Roslagsvatten website and try again.",
+            )
+
+        building_id = bid_match.group(1)
+
+        # 2. FETCH the schedule using the building ID
+        fetch_payload = {"buildingId": building_id, "municipality": self._municipality}
+
+        r = requests.post(
+            f"{self._api_url}/fetch", data=json.dumps(fetch_payload), headers=headers
+        )
+        r.raise_for_status()
+
+        fetch_results = r.json()
+        if not fetch_results or "data" not in fetch_results[0]:
+            return []
+
+        html_schedule = fetch_results[0]["data"]
+        entries = []
+
+        # Regex to find all schedule blocks
+        pattern = re.compile(r"<h3>(.*?)</h3>[\s\S]*?Nästa hämtning: (.*?)</p>")
+        matches = pattern.findall(html_schedule)
+
+        for waste_type, date_raw in matches:
+            date_raw = date_raw.strip()
+            pickup_date = None
+
+            # Pattern 1: Standard YYYY-MM-DD
+            if re.match(r"\d{4}-\d{2}-\d{2}", date_raw):
+                pickup_date = datetime.strptime(date_raw, "%Y-%m-%d").date()
+
+            # Pattern 2: Week format like "v41 Okt 2026"
+            elif "v" in date_raw:
+                try:
+                    week_match = re.search(r"v(\d+).*?(\d{4})", date_raw)
+                    if week_match:
+                        week = int(week_match.group(1))
+                        year = int(week_match.group(2))
+                        # Use ISO week format
+                        pickup_date = datetime.strptime(
+                            f"{year}-W{week}-1", "%G-W%V-%u"
+                        ).date()
+                except Exception as e:
+                    _LOGGER.warning(f"Failed to parse week-based date {date_raw}: {e}")
+
+            if pickup_date:
+                icon = ICON_MAP.get(waste_type, "mdi:trash-can")
+                entries.append(
+                    Collection(
+                        date=pickup_date,
+                        t=waste_type,
+                        icon=icon,
+                    )
+                )
+
+        if not entries:
+            _LOGGER.info(
+                f"No collection entries found for address: {self._street_address}"
+            )
+
+        return entries

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

@@ -0,0 +1,112 @@
+import re
+from datetime import datetime
+
+import requests
+import urllib3
+from bs4 import BeautifulSoup
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+
+# With verify=True the POST fails due to a SSLCertVerificationError.
+urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
+
+TITLE = "Rother District Council"
+DESCRIPTION = "Source for Rother District Council."
+URL = "https://www.rother.gov.uk"
+TEST_CASES = {
+    "Test_01": {"uprn": 10002653856},
+    "Test_02": {"uprn": 100060102891},
+}
+
+
+ICON_MAP = {
+    "refuse": Icons.GENERAL_WASTE,
+    "garden": Icons.GARDEN,
+    "recycling": Icons.RECYCLING,
+}
+
+
+API_URL = "https://www.rother.gov.uk/wp-admin/admin-ajax.php"
+
+
+HEADERS = {
+    "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8",
+    "User-Agent": "Mozilla/5.0",
+}
+
+
+class Source:
+    def __init__(self, uprn: str | int):
+        self._uprn: str | int = uprn
+
+    def fetch(self):
+        data = {"action": "get_address_data", "uprn": self._uprn}
+
+        r = requests.post(API_URL, headers=HEADERS, data=data, timeout=10, verify=False)
+        r.raise_for_status()
+
+        # Response is JSON with fields: success(boolean) and data (string containing HTML fragment)
+        bin_collection_data = r.json()
+        self.__validate_response(bin_collection_data)
+
+        soup = BeautifulSoup(bin_collection_data["data"], "html.parser")
+
+        entries = []
+        for bin_type in ICON_MAP:
+            date_span = soup.find("span", class_=f"find-my-nearest-bindays-{bin_type}")
+            if date_span:
+                date_str = date_span.text.strip()
+
+                if date_str.startswith("Sign up"):
+                    # Garden waste requires a subscription and may not be available for all
+                    continue
+
+                parsed_collection_date = datetime.strptime(
+                    self.__remove_ordinal_indicators(date_str), "%A %d %B"
+                )
+
+                # The returned bin day does not include the year
+                collection_year = self.__resolve_bin_collection_year(
+                    parsed_collection_date.month
+                )
+
+                parsed_collection_date = parsed_collection_date.replace(
+                    year=collection_year
+                )
+
+                icon = ICON_MAP.get(bin_type)
+                entries.append(
+                    Collection(
+                        date=parsed_collection_date.date(), t=bin_type, icon=icon
+                    )
+                )
+
+        if not entries:
+            raise Exception("Unable to find any bin collection schedules")
+
+        return entries
+
+    def __validate_response(self, bin_collection_data):
+        if "success" not in bin_collection_data or "data" not in bin_collection_data:
+            raise Exception("Rother Disctrict Council returned an invalid response")
+
+        if not bin_collection_data["success"]:
+            raise Exception(
+                "Rother Disctrict Council returned a non-successful response"
+            )
+
+    def __remove_ordinal_indicators(self, original_str: str) -> str:
+        return re.sub(r"(\d)(st|nd|rd|th)", r"\1", original_str)
+
+    def __resolve_bin_collection_year(self, collection_month: int) -> int:
+        today = datetime.now()
+        collection_year = today.year
+
+        # Collection date is in previous year
+        if collection_month == 12 and today.month == 1:
+            collection_year -= 1
+
+        # Collection date is in the next year
+        elif collection_month == 1 and today.month == 12:
+            collection_year += 1
+
+        return collection_year

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

@@ -0,0 +1,126 @@
+import datetime
+import logging
+import re
+
+import requests
+from waste_collection_schedule import Collection, Icons
+
+_LOGGER = logging.getLogger(__name__)
+
+TITLE = "Rotorua Lakes Council"
+DESCRIPTION = "Source for Rotorua Lakes Council"
+URL = "https://www.rotorualakescouncil.nz"
+API_URL = (
+    "https://gis.rdc.govt.nz/server/rest/services/Core/RdcServices/MapServer/160/query"
+)
+ICON_MAP = {
+    "Rubbish": Icons.GENERAL_WASTE,
+    "Recycling": Icons.RECYCLING,
+    "FOGO": Icons.ORGANIC,
+}
+HEADERS = {"User-Agent": "waste-collection-schedule"}
+
+# RubbishCollection3/4 hold the next two collections under the FOGO schedule
+# introduced on 1 October 2026. RubbishCollection1/2 hold the legacy schedule.
+SCHEDULE_FIELDS = ("RubbishCollection3", "RubbishCollection4")
+
+# e.g. "Monday 05/10/2026 Recycling and FOGO"
+#      "Wednesday 07/10/2026 Recycling and Rubbish (and FOGO for food premises)"
+ENTRY_REGEX = re.compile(r"^\s*\w+\s+(\d{1,2}/\d{1,2}/\d{4})\s+(.+?)\s*$")
+
+TEST_CASES = {
+    "Test1": {"address": "1061 Haupapa Street"},
+    "Test2": {"address": "369 state highway 33"},
+    "Test3": {"address": "17 Tihi road"},
+    "Test4": {"address": "12a robin st"},
+    "Test5": {"address": "25 kaska rd"},
+}
+
+
+class Source:
+    def __init__(self, address):
+        self._address = address
+
+    def fetch_coordinates(self):
+        params = {
+            "format": "json",
+            "q": self._address,
+        }
+        try:
+            response = requests.get(
+                "https://nominatim.openstreetmap.org/search",
+                params=params,
+                headers=HEADERS,
+                timeout=10,
+            )
+            response.raise_for_status()
+            data = response.json()
+            if not data:
+                raise ValueError(f"Geolocation failed for address: {self._address}")
+            return float(data[0]["lat"]), float(data[0]["lon"])
+        except Exception as e:
+            raise ValueError(
+                f"Geolocation failed for address: {self._address} with error: {e}"
+            ) from e
+
+    def fetch(self):
+        lat, lon = self.fetch_coordinates()
+
+        params = {
+            "f": "json",
+            "geometryType": "esriGeometryPoint",
+            "geometry": f"{lon},{lat}",
+            "inSR": 4326,
+            "spatialRel": "esriSpatialRelIntersects",
+            "outFields": ",".join(("OBJECTID", "Name", "Day", *SCHEDULE_FIELDS)),
+            "returnGeometry": "false",
+        }
+        try:
+            response = requests.get(API_URL, params=params, timeout=10)
+            response.raise_for_status()
+            data = response.json()
+        except requests.RequestException as e:
+            raise ValueError(f"API request failed: {e}") from e
+
+        entries = []
+        for feature in data.get("features", []):
+            attributes = feature.get("attributes", {})
+            for field in SCHEDULE_FIELDS:
+                value = (attributes.get(field) or "").strip()
+                match = ENTRY_REGEX.match(value)
+                if not match:
+                    if value:
+                        _LOGGER.debug("Skipping non-date schedule value: %s", value)
+                    continue
+
+                date_str, types_str = match.groups()
+                try:
+                    date = datetime.datetime.strptime(date_str, "%d/%m/%Y").date()
+                except ValueError:
+                    _LOGGER.error("Date parsing error for value: %s", date_str)
+                    continue
+
+                # Drop notes such as "(and FOGO for food premises)" and "only"
+                types_str = re.sub(r"\(.*?\)", "", types_str)
+                types_str = types_str.strip().removesuffix("only").strip()
+
+                for bin_type in types_str.split(" and "):
+                    bin_type = bin_type.strip()
+                    if not bin_type:
+                        continue
+                    if bin_type.upper() != "FOGO":
+                        bin_type = bin_type.capitalize()
+                    entries.append(
+                        Collection(
+                            date=date,
+                            t=bin_type,
+                            icon=ICON_MAP.get(bin_type),
+                        )
+                    )
+
+        if not entries:
+            raise ValueError(
+                f"No collection entries found for address: {self._address}"
+            )
+
+        return entries

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

@@ -0,0 +1,136 @@
+import logging
+from datetime import datetime
+from typing import Literal
+
+import requests
+import urllib3
+from bs4 import BeautifulSoup
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import (
+    SourceArgumentNotFoundWithSuggestions,
+)
+
+# With verify=True the POST fails due to a SSLCertVerificationError.
+# Using verify=False works, but is not ideal. The following links may provide a better way of dealing with this:
+# https://urllib3.readthedocs.io/en/1.26.x/advanced-usage.html#ssl-warnings
+# https://urllib3.readthedocs.io/en/1.26.x/user-guide.html#ssl
+# This line suppresses the InsecureRequestWarning when using verify=False
+urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
+
+
+_LOGGER = logging.getLogger(__name__)
+
+TITLE = "Malvern Hills District Council"
+DESCRIPTION = "Source for Malvern Hills District Council."
+URL = "https://www.malvernhills.gov.uk/"
+TEST_CASES = {
+    "1Malvern Hill: s00120597618": {"uprn": 100120597618, "council": "Malvern Hills"},
+    "Malvern Hills: 100121268004": {
+        "uprn": "100121268004",
+        "council": "Malvern Hills",
+    },
+    "Worcester City: 100120656169": {
+        "uprn": 100120656169,
+        "council": "Worcester City",
+    },
+    "Wychavon: 10095592085": {"uprn": 10095592085, "council": "Wychavon"},
+}
+
+
+ICON_MAP = {
+    "Non-recyclable": Icons.GENERAL_WASTE,
+    "Garden": Icons.GARDEN,
+    "Recycling": Icons.RECYCLING,
+}
+
+
+SERVICE_MAP = {
+    "Malvern Hills": {
+        "api_url": "https://swict.malvernhills.gov.uk/mhdcroundlookup/HandleSearchScreen",
+        "url": "https://www.malvernhills.gov.uk/",
+    },
+    "Wychavon": {
+        "api_url": "https://selfservice.wychavon.gov.uk/wdcroundlookup/HandleSearchScreen",
+        "url": "https://www.wychavon.gov.uk/",
+    },
+    "Worcester City": {
+        "api_url": "https://selfserve.worcester.gov.uk/wccroundlookup/HandleSearchScreen",
+        "url": "https://www.worcester.gov.uk/",
+    },
+}
+
+EXTRA_INFO = [
+    {
+        "url": value["url"],
+        "title": key,
+        "default_params": {"council": key},
+    }
+    for key, value in SERVICE_MAP.items()
+]
+
+COUNIL_LITERAL = Literal["Malvern Hills", "Wychavon", "Worcester City"]
+
+
+class Source:
+    def __init__(self, uprn: str | int, council: COUNIL_LITERAL) -> None:
+        self._api_url = SERVICE_MAP.get(council, {}).get("api_url", "")
+        if not self._api_url:
+            raise SourceArgumentNotFoundWithSuggestions(
+                "council",
+                council,
+                SERVICE_MAP.keys(),
+            )
+        self._uprn: str | int = uprn
+
+    def fetch(self) -> list[Collection]:
+        data: dict[str, str | int] = {
+            "alAddrsel": self._uprn,
+            "txtPage": "std",
+            "txtSearchPerformedFlag": "false",
+            "futuredate": "",
+            "address": "",
+            "btnSubmit": "Next",
+        }
+
+        r = requests.post(self._api_url, data=data, verify=False)
+        r.raise_for_status()
+
+        soup = BeautifulSoup(r.text, "html.parser")
+
+        table = soup.select_one("table")
+        if not table:
+            raise ValueError("collection table not, maybe wrong/unsupported address")
+
+        entries = []
+        for tr in table.select("tr"):
+            tds = tr.select("td")
+            if not len(tds) == 3:
+                continue
+
+            bin_type_tag = tds[1]
+            # remove all divs
+            div = bin_type_tag.select_one("div")
+            if div:
+                div.decompose()
+
+            bin_type = bin_type_tag.text.strip().removesuffix("collection").strip()
+            date_text = tds[2].text.strip()
+            if "Not applicable" in date_text:
+                continue
+            icon = ICON_MAP.get(bin_type.split()[0])
+
+            # Thursday 22/08/2024
+            for date_str in date_text.split("\n"):
+                date_str = date_str.strip()
+                if not date_str:
+                    continue
+                try:
+                    date = datetime.strptime(date_str, "%A %d/%m/%Y").date()
+                except ValueError:
+                    _LOGGER.warning(
+                        "Could not parse date '%s', unknown format", date_str
+                    )
+                    continue
+                entries.append(Collection(date=date, t=bin_type, icon=icon))
+
+        return entries

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

@@ -0,0 +1,103 @@
+import json
+from datetime import datetime, timedelta
+
+import requests
+from dateutil.rrule import FR, MO, SA, SU, TH, TU, WE, WEEKLY, YEARLY, rrule
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+
+TITLE = "Round Rock Texas"
+DESCRIPTION = "Source for bin collection services for Round Rock, Texas"
+URL = "https://www.roundrocktexas.gov/"
+COUNTRY = "us"
+TEST_CASES = {
+    "Apache Oaks": {"neighborhood": "Apache Oaks"},
+    "Mayfield Ranch": {"neighborhood": "Mayfield Ranch"},
+    "Windy Park": {"neighborhood": "Windy Park"},
+}
+ICON_MAP = {
+    "Recycling": Icons.RECYCLING,
+    "Trash": Icons.GENERAL_WASTE,
+}
+DAYS = {
+    "Monday": MO,
+    "Tuesday": TU,
+    "Wednesday": WE,
+    "Thursday": TH,
+    "Friday": FR,
+    "Saturday": SA,
+    "Sunday": SU,
+}
+HOLIDAYS = {  # website indicates collections falling on these days will be shifted by 1 day
+    "Thanksgiving": next(
+        iter(rrule(YEARLY, bymonth=11, byweekday=TH(4), dtstart=datetime.now()))
+    ).date(),  # 4th Thursday in November
+    "Christmas Day": next(
+        iter(rrule(YEARLY, bymonth=12, bymonthday=25, dtstart=datetime.now()))
+    ).date(),  # 25th December
+    "New Years Day": next(
+        iter(rrule(YEARLY, bymonth=1, bymonthday=1, dtstart=datetime.now()))
+    ).date(),  # 1st January
+}
+
+
+class Source:
+    def __init__(self, neighborhood: str):
+        self._area = neighborhood
+
+    def check_holidays(self, dt):
+        for _, holiday in enumerate(HOLIDAYS):
+            if dt == HOLIDAYS[holiday]:
+                dt += timedelta(days=1)
+        return dt
+
+    def fetch(self):
+        today = datetime.now()
+        s = requests.Session()
+
+        # get recycling zone - determines which day of the week collections are made
+        r = s.get(
+            "https://devcorrpublicdatahub.blob.core.usgovcloudapi.net/garbage-recycling/garbagerecyclingzones.json"
+        )
+        r.raise_for_status()
+        areas = json.loads(r.text)
+        for _idx, area in enumerate(areas):
+            if self._area.upper() == area["Neighborhood Name"].upper():
+                recycling_zone = area["Recycling Zone"]
+
+        entries = []
+
+        # get recycling schedules - collections are every 2 weeks
+        r = s.get(
+            "https://devcorrpublicdatahub.blob.core.usgovcloudapi.net/garbage-recycling/garbagerecyclingdays.json"
+        )
+        r.raise_for_status()
+        recycling_schedule = json.loads(r.text)
+        for _idx, zone in enumerate(recycling_schedule):
+            if recycling_zone == zone["Recycling Zone"]:
+                end_date = datetime.strptime(zone["Date"], "%Y-%m-%d")
+                dt = datetime.strptime(zone["Date"], "%Y-%m-%d").date()
+                dt = self.check_holidays(dt)
+                entries.append(
+                    Collection(
+                        date=datetime.strptime(zone["Date"], "%Y-%m-%d").date(),
+                        t="Recycling",
+                        icon=ICON_MAP.get("Recycling"),
+                    )
+                )
+
+        # generate weekly trash schedule - occur weekly, the same week day as recycling collections
+        trash_day = recycling_zone.split(" ")[0]
+        trash_dates = list(
+            rrule(WEEKLY, byweekday=DAYS[trash_day], dtstart=today, until=end_date)
+        )
+        for _idx, item in enumerate(trash_dates):
+            item = self.check_holidays(item.date())
+            entries.append(
+                Collection(
+                    date=item,
+                    t="Trash",
+                    icon=ICON_MAP.get("Trash"),
+                )
+            )
+
+        return entries