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

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

@@ -0,0 +1,274 @@
+import calendar as cal_mod
+import logging
+import re
+from datetime import date, timedelta
+from io import BytesIO
+
+import requests
+from pdfminer.high_level import extract_pages
+from pdfminer.layout import LAParams, LTCurve, LTLayoutContainer, LTRect, LTTextBox
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+
+TITLE = "Brimbank City Council"
+DESCRIPTION = "Source for Brimbank City Council waste collection."
+URL = "https://www.brimbank.vic.gov.au"
+COUNTRY = "au"
+
+TEST_CASES = {
+    "Monday A": {"day": "Monday", "calendar": "A"},
+    "Friday B": {"day": "Friday", "calendar": "B"},
+    "Wednesday A": {"day": "Wednesday", "calendar": "A"},
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "day": "Your collection day (Monday to Friday). Check the map on the back of the waste calendar PDF.",
+        "calendar": "Your calendar cycle (A or B). Check the map on the back of the waste calendar PDF.",
+    }
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "day": "Collection day",
+        "calendar": "Calendar cycle",
+    }
+}
+
+ICON_MAP = {
+    "General Waste": Icons.GENERAL_WASTE,
+    "Recycling": Icons.RECYCLING,
+    "Food & Garden Organics": Icons.BIO_KITCHEN,
+}
+
+PDF_URL = (
+    "https://serviceapi.brimbank.vic.gov.au/CMServiceAPI/Record/7854806/file/document"
+)
+
+# Color thresholds for PDF parsing (RGB float tuples)
+_GREEN = (0.584, 0.795, 0.392)
+_YELLOW = (1.0, 0.888, 0.312)
+_RED = (0.818, 0.408, 0.361)
+_COLOR_TOL = 0.15
+
+# Calendar grid layout constants
+_MONTH_COL_X = [(87, 167), (167, 247), (247, 326), (326, 406)]
+_CAL_A_ROW_Y = [66, 142, 219]
+_CAL_B_ROW_Y = [314, 391, 467]
+_MONTHS_PER_ROW = [
+    [(2, 2026), (3, 2026), (4, 2026), (5, 2026)],
+    [(6, 2026), (7, 2026), (8, 2026), (9, 2026)],
+    [(10, 2026), (11, 2026), (12, 2026), (1, 2027)],
+]
+
+_WEEKDAY_MAP = {
+    "monday": 0,
+    "tuesday": 1,
+    "wednesday": 2,
+    "thursday": 3,
+    "friday": 4,
+}
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def _color_match(c, target):
+    if not c or not isinstance(c, tuple) or len(c) != 3:
+        return False
+    return all(abs(c[i] - target[i]) < _COLOR_TOL for i in range(3))
+
+
+def _classify_color(fill):
+    if _color_match(fill, _GREEN):
+        return "FOGO"
+    if _color_match(fill, _YELLOW):
+        return "RECYCLE"
+    if _color_match(fill, _RED):
+        return "NONE"
+    return None
+
+
+def _iter_elements(container):
+    for el in container:
+        yield el
+        if isinstance(el, LTLayoutContainer):
+            yield from _iter_elements(el)
+
+
+def _parse_pdf(pdf_bytes):
+    """Parse the Brimbank waste calendar PDF and return (schedule_a, schedule_b).
+
+    Each schedule is a dict mapping date -> 'RECYCLE' | 'FOGO' | 'NONE'.
+    Only weekday dates (Mon-Fri) plus holiday-shifted Saturdays are included.
+    """
+    pages = list(extract_pages(BytesIO(pdf_bytes), laparams=LAParams()))
+    if not pages:
+        raise ValueError("PDF contains no pages")
+
+    page = pages[0]
+    ph = page.height
+
+    # Collect colored curve cells
+    colored_cells = []
+    for el in _iter_elements(page):
+        if isinstance(el, LTCurve) and not isinstance(el, LTRect):
+            fill = el.non_stroking_color
+            if fill and isinstance(fill, tuple) and len(fill) == 3:
+                label = _classify_color(fill)
+                if label:
+                    x0, y0, x1, y1 = el.bbox
+                    colored_cells.append(
+                        {
+                            "color": label,
+                            "cx": (x0 + x1) / 2,
+                            "cy": ph - (y0 + y1) / 2,
+                        }
+                    )
+
+    # Parse day number text boxes
+    day_boxes = []
+    for el in page:
+        if isinstance(el, LTTextBox):
+            x0, y0, x1, y1 = el.bbox
+            top = ph - y1
+            text = el.get_text().strip()
+            nums = re.findall(r"\d+", text)
+            if nums and all(1 <= int(n) <= 31 for n in nums):
+                day_boxes.append(
+                    {"nums": [int(n) for n in nums], "x0": x0, "x1": x1, "top": top}
+                )
+
+    def build_schedule(row_y_starts):
+        schedule = {}
+        for row_idx, row_y in enumerate(row_y_starts):
+            for col_idx, (month, year) in enumerate(_MONTHS_PER_ROW[row_idx]):
+                mx0, mx1 = _MONTH_COL_X[col_idx]
+                days_in_month = cal_mod.monthrange(year, month)[1]
+
+                month_boxes = [
+                    b
+                    for b in day_boxes
+                    if b["x0"] >= mx0 - 5
+                    and b["x1"] <= mx1 + 5
+                    and row_y + 5 < b["top"] < row_y + 80
+                ]
+
+                for box in month_boxes:
+                    col_width = (box["x1"] - box["x0"]) / 7
+                    for day_num in box["nums"]:
+                        if day_num < 1 or day_num > days_in_month:
+                            continue
+                        d = date(year, month, day_num)
+                        # Skip Sun (6) and Sat (5) unless it's a holiday shift
+                        if d.weekday() == 6:  # Sunday
+                            continue
+
+                        # Grid column: Sun=0, Mon=1 ... Sat=6
+                        grid_col = (d.weekday() + 1) % 7
+                        day_cx = box["x0"] + (grid_col + 0.5) * col_width
+                        day_cy = box["top"] + 3
+
+                        best = None
+                        best_dist = 999
+                        for cell in colored_cells:
+                            dx = abs(cell["cx"] - day_cx)
+                            dy = abs(cell["cy"] - day_cy)
+                            dist = (dx**2 + dy**2) ** 0.5
+                            if dist < best_dist and dist < 10:
+                                best_dist = dist
+                                best = cell
+
+                        if best:
+                            schedule[d] = best["color"]
+
+        # Remove spurious Saturday entries that aren't holiday shifts
+        # A Saturday is only valid if the preceding Friday is NONE (holiday)
+        to_remove = []
+        for d, _color in schedule.items():
+            if d.weekday() == 5:  # Saturday
+                friday = d - timedelta(days=1)
+                if schedule.get(friday) != "NONE":
+                    to_remove.append(d)
+        for d in to_remove:
+            del schedule[d]
+
+        return schedule
+
+    schedule_a = build_schedule(_CAL_A_ROW_Y)
+    schedule_b = build_schedule(_CAL_B_ROW_Y)
+    return schedule_a, schedule_b
+
+
+class Source:
+    def __init__(self, day: str, calendar: str):
+        day_lower = day.strip().lower()
+        if day_lower not in _WEEKDAY_MAP:
+            raise ValueError(
+                f"Invalid day '{day}'. Must be one of: Monday, Tuesday, Wednesday, Thursday, Friday"
+            )
+        self._weekday = _WEEKDAY_MAP[day_lower]
+        self._day_name = day_lower
+
+        cal_upper = calendar.strip().upper()
+        if cal_upper not in ("A", "B"):
+            raise ValueError(f"Invalid calendar '{calendar}'. Must be A or B")
+        self._calendar = cal_upper
+
+    def fetch(self):
+        r = requests.get(PDF_URL, timeout=30)
+        r.raise_for_status()
+
+        schedule_a, schedule_b = _parse_pdf(r.content)
+        schedule = schedule_a if self._calendar == "A" else schedule_b
+
+        entries = []
+        for d, color in sorted(schedule.items()):
+            # Skip NONE dates (holidays with no collection)
+            if color == "NONE":
+                continue
+
+            # Check if this date is for the user's collection day
+            if d.weekday() == self._weekday:
+                # Regular collection day
+                entries.append(
+                    Collection(
+                        date=d, t="General Waste", icon=ICON_MAP["General Waste"]
+                    )
+                )
+                if color == "RECYCLE":
+                    entries.append(
+                        Collection(date=d, t="Recycling", icon=ICON_MAP["Recycling"])
+                    )
+                elif color == "FOGO":
+                    entries.append(
+                        Collection(
+                            date=d,
+                            t="Food & Garden Organics",
+                            icon=ICON_MAP["Food & Garden Organics"],
+                        )
+                    )
+            elif d.weekday() == 5:  # Saturday (holiday shift)
+                # This is a shifted collection for Friday users
+                if self._weekday == 4:  # Friday
+                    entries.append(
+                        Collection(
+                            date=d,
+                            t="General Waste",
+                            icon=ICON_MAP["General Waste"],
+                        )
+                    )
+                    if color == "RECYCLE":
+                        entries.append(
+                            Collection(
+                                date=d, t="Recycling", icon=ICON_MAP["Recycling"]
+                            )
+                        )
+                    elif color == "FOGO":
+                        entries.append(
+                            Collection(
+                                date=d,
+                                t="Food & Garden Organics",
+                                icon=ICON_MAP["Food & Garden Organics"],
+                            )
+                        )
+
+        return entries

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

@@ -0,0 +1,139 @@
+import json
+from datetime import date, timedelta
+
+import requests
+from waste_collection_schedule import Collection  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import (
+    SourceArgumentNotFoundWithSuggestions,
+)
+
+TITLE = "Brisbane City Council"
+DESCRIPTION = "Source for Brisbane City Council rubbish collection."
+URL = "https://www.brisbane.qld.gov.au"
+TEST_CASES = {
+    "Suburban Social": {
+        "suburb": "Chapel Hill",
+        "street_name": "Moordale St",
+        "street_number": "3",
+    },
+    "The Scratch Bar": {
+        "suburb": "Milton",
+        "street_name": "Park Rd",
+        "street_number": "8/1",
+    },
+    "Green Beacon": {
+        "suburb": "Teneriffe",
+        "street_name": "Helen St",
+        "street_number": "26",
+    },
+}
+
+HEADERS = {"user-agent": "Mozilla/5.0"}
+
+
+class Source:
+    def __init__(self, suburb, street_name, street_number):
+        self.suburb = suburb
+        self.street_name = street_name
+        self.street_number = street_number
+
+    def fetch(self):
+        suburb_id = 0
+        street_id = 0
+        property_id = 0
+        today = date.today()
+        nextyear = today + timedelta(365)
+
+        # Retrieve suburbs
+        r = requests.get(
+            "https://brisbane.waste-info.com.au/api/v1/localities.json", headers=HEADERS
+        )
+        data = json.loads(r.text)
+
+        # Find the ID for our suburb
+        for item in data["localities"]:
+            if item["name"] == self.suburb:
+                suburb_id = item["id"]
+                break
+
+        if suburb_id == 0:
+            raise SourceArgumentNotFoundWithSuggestions(
+                "suburb", self.suburb, [x["name"] for x in data["localities"]]
+            )
+
+        # Retrieve the streets in our suburb
+        r = requests.get(
+            f"https://brisbane.waste-info.com.au/api/v1/streets.json?locality={suburb_id}",
+            headers=HEADERS,
+        )
+        data = json.loads(r.text)
+
+        # Find the ID for our street
+        for item in data["streets"]:
+            if item["name"] == self.street_name:
+                street_id = item["id"]
+                break
+
+        if street_id == 0:
+            raise SourceArgumentNotFoundWithSuggestions(
+                "street_name", self.street_name, [x["name"] for x in data["streets"]]
+            )
+
+        # Retrieve the properties in our street
+        r = requests.get(
+            f"https://brisbane.waste-info.com.au/api/v1/properties.json?street={street_id}",
+            headers=HEADERS,
+        )
+        data = json.loads(r.text)
+
+        # Find the ID for our property
+        for item in data["properties"]:
+            if item["name"] == f"{self.street_number} {self.street_name} {self.suburb}":
+                property_id = item["id"]
+                break
+
+        if property_id == 0:
+            raise SourceArgumentNotFoundWithSuggestions(
+                "street_number",
+                self.street_number,
+                [
+                    x["name"].split(f" {self.street_name}")[0]
+                    for x in data["properties"]
+                    if self.street_name in x["name"]
+                ],
+            )
+
+        # Retrieve the upcoming collections for our property
+        r = requests.get(
+            f"https://brisbane.waste-info.com.au/api/v1/properties/{property_id}.json?start={today}&end={nextyear}",
+            headers=HEADERS,
+        )
+
+        data = json.loads(r.text)
+
+        entries = []
+
+        for item in data:
+            if "start" not in item:
+                continue
+            collection_date = date.fromisoformat(item["start"])
+            if (collection_date - today).days < 0:
+                continue
+            # Only consider recycle and organic events
+            if item["event_type"] in ["recycle", "organic"]:
+                # Every collection day includes rubbish
+                entries.append(
+                    Collection(date=collection_date, t="Rubbish", icon="mdi:trash-can")
+                )
+                if item["event_type"] == "recycle":
+                    entries.append(
+                        Collection(
+                            date=collection_date, t="Recycling", icon="mdi:recycle"
+                        )
+                    )
+                if item["event_type"] == "organic":
+                    entries.append(
+                        Collection(date=collection_date, t="Garden", icon="mdi:leaf")
+                    )
+
+        return entries

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

@@ -0,0 +1,97 @@
+# Credit where it's due:
+# This is predominantly a refactoring of the Bristol City Council script from the UKBinCollectionData repo
+# https://github.com/robbrad/UKBinCollectionData
+
+from datetime import datetime
+
+import requests
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+
+TITLE = "Bristol City Council"
+DESCRIPTION = "Source for bristol.gov.uk services for Bristol City Council, UK."
+URL = "https://bristol.gov.uk"
+
+TEST_CASES = {
+    "Test_001": {"uprn": "107652"},
+    "Test_002": {"uprn": "2987"},
+    "Test_003": {"uprn": 17929},
+}
+ICON_MAP = {
+    "90L BLUE SACK": Icons.RECYCLING,
+    "240L GARDEN WASTE BIN": Icons.GARDEN,
+    "180L GENERAL WASTE": Icons.GENERAL_WASTE,
+    "45L BLACK RECYCLING BOX": Icons.RECYCLING,
+    "23L FOOD WASTE BIN": Icons.BIO_KITCHEN,
+    "55L GREEN RECYCLING BOX": Icons.RECYCLING,
+    "140L FOOD WASTE BIN": Icons.BIO_KITCHEN,
+    "240L RECYCLING MIXED GLASS": Icons.GLASS,
+    "240L RECYCLING PAPER": Icons.PAPER,
+    "1100L GENERAL WASTE": Icons.GENERAL_WASTE,
+    "1100L RECYCLING CARD": Icons.PAPER,
+    "360L RECYCLING PLASTIC/CANS": Icons.PLASTIC_PACKAGING,
+}
+HEADERS = {
+    "Accept": "*/*",
+    "Accept-Language": "en-GB,en;q=0.9",
+    "Connection": "keep-alive",
+    "Ocp-Apim-Subscription-Key": "47ffd667d69c4a858f92fc38dc24b150",
+    "Ocp-Apim-Trace": "true",
+    "Origin": "https://bristolcouncil.powerappsportals.com",
+    "Referer": "https://bristolcouncil.powerappsportals.com/",
+    "Sec-Fetch-Dest": "empty",
+    "Sec-Fetch-Mode": "cors",
+    "Sec-Fetch-Site": "cross-site",
+    "Sec-GPC": "1",
+    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/105.0.0.0 Safari/537.36",
+}
+
+
+class Source:
+    def __init__(self, uprn):
+        self._uprn = str(uprn).zfill(12)
+
+    def fetch(self):
+        s = requests.Session()
+
+        # Initialise form
+        payload = {"servicetypeid": "7dce896c-b3ba-ea11-a812-000d3a7f1cdc"}
+        response = s.get(
+            "https://bristolcouncil.powerappsportals.com/completedynamicformunauth/",
+            headers=HEADERS,
+            params=payload,
+        )
+
+        # Set the search criteria
+        payload = {"Uprn": "UPRN" + self._uprn}
+        response = s.post(
+            "https://bcprdapidyna002.azure-api.net/bcprdfundyna001-llpg/DetailedLLPG",
+            headers=HEADERS,
+            json=payload,
+        )
+
+        # Retrieve the schedule
+        payload = {"uprn": self._uprn}
+        response = s.post(
+            "https://bcprdapidyna002.azure-api.net/bcprdfundyna001-alloy/NextCollectionDates",
+            headers=HEADERS,
+            json=payload,
+        )
+        data = response.json()["data"]
+
+        entries = []
+        for item in data:
+            for collection in item["collection"]:
+                for collection_date_key in ["nextCollectionDate", "lastCollectionDate"]:
+                    date_string = collection[collection_date_key].split("T")[0]
+                    entries.append(
+                        Collection(
+                            date=datetime.strptime(
+                                date_string,
+                                "%Y-%m-%d",
+                            ).date(),
+                            t=item["containerName"],
+                            icon=ICON_MAP.get(item["containerName"].upper()),
+                        )
+                    )
+
+        return entries

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

@@ -0,0 +1,57 @@
+import time
+
+import requests
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.service.ICS import ICS
+
+TITLE = "London Borough of Bromley"
+DESCRIPTION = "Source for bromley.gov.uk services for London Borough of Bromley, UK."
+URL = "https://bromley.gov.uk"
+TEST_CASES = {
+    "Test_001": {"property": 6328436},
+    "Test_002": {"property": "6146611"},
+    "Test_003": {"property": 6283460},
+}
+
+ICON_MAP = {
+    "NON-RECYCLABLE": Icons.GENERAL_WASTE,
+    "FOOD": Icons.BIO_KITCHEN,
+    "GARDEN": Icons.GARDEN,
+    "PAPER": Icons.PAPER,
+    "MIXED": Icons.GLASS,
+}
+
+MAX_COUNT = 15
+
+
+class Source:
+    def __init__(self, property):
+        self._property = str(property)
+        self._ics = ICS()
+
+    def fetch(self):
+        s = requests.Session()
+        r = s.get(f"https://recyclingservices.bromley.gov.uk/waste/{self._property}")
+
+        for _ in range(MAX_COUNT):
+            r = s.get(
+                f"https://recyclingservices.bromley.gov.uk/waste/{self._property}/calendar.ics"
+            )
+            try:
+                dates = self._ics.convert(r.text)
+                break
+            except ValueError:
+                time.sleep(2)  # identical to website behaviour (hx-trigger="every 2s")
+
+        entries = []
+        for item in dates:
+            bin_type = item[1].replace(" collection", "")
+            entries.append(
+                Collection(
+                    date=item[0],
+                    t=bin_type,
+                    icon=ICON_MAP.get(bin_type.split(" ")[0].upper()),
+                )
+            )
+
+        return entries

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

@@ -0,0 +1,114 @@
+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 SourceArgumentNotFoundWithSuggestions
+
+TITLE = "Bromsgrove & Redditch Councils"
+DESCRIPTION = "Source for the shared bin collection lookup used by Bromsgrove District Council and Redditch Borough Council, UK."
+URL = "https://bromsgrove.gov.uk"
+EXTRA_INFO = [
+    {
+        "title": "Redditch Borough Council",
+        "url": "https://www.redditchbc.gov.uk",
+        "default_params": {"council": "redditch"},
+    },
+]
+TEST_CASES = {
+    "Shakespeare House": {"uprn": "10094552413", "postcode": "B61 8DA"},
+    "The Lodge": {"uprn": 10000218025, "postcode": "B60 2AA"},
+    "Ceader Lodge": {"uprn": 100120576392, "postcode": "B60 2JS"},
+    "Finstall Road": {"uprn": 100120571971, "postcode": "B60 3DE"},
+}
+
+HEADERS = {
+    "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/50.0.2661.102 Safari/537.36",
+}
+
+# Bromsgrove District Council and Redditch Borough Council run a shared waste
+# service and both publish the same "BinCollections" web app, one instance per
+# council domain.
+COUNCIL_DOMAINS = {
+    "bromsgrove": "bincollections.bromsgrove.gov.uk",
+    "redditch": "bincollections.redditchbc.gov.uk",
+}
+
+ICON_MAP = {
+    "Grey": Icons.GENERAL_WASTE,
+    "Green": Icons.RECYCLING,
+    "Brown": Icons.ORGANIC,
+}
+
+
+class Source:
+    def __init__(self, uprn: str, postcode: str, council: str = "bromsgrove"):
+        self._uprn = uprn
+        self._postcode = "".join(postcode.split()).upper()
+        if council not in COUNCIL_DOMAINS:
+            raise SourceArgumentNotFoundWithSuggestions(
+                "council", council, COUNCIL_DOMAINS.keys()
+            )
+        self._domain = COUNCIL_DOMAINS[council]
+
+    def fetch(self):
+        entries: list[Collection] = []
+
+        session = requests.Session()
+        session.headers.update(HEADERS)
+
+        form_data = {"UPRN": self._uprn}
+
+        collection_response = session.post(
+            f"https://{self._domain}/BinCollections/Details/", data=form_data
+        )
+
+        # Parse HTML
+        soup = BeautifulSoup(collection_response.text, "html.parser")
+
+        # Find postcode
+        postcode = "".join(soup.find("h3").text.split()[-2:]).upper()
+
+        # Find bins and their collection details
+        bins = soup.find_all(class_="collection-container")
+
+        # Initialize lists to store extracted information
+        bin_info = []
+
+        # Extract information for each bin
+        for bin in bins:
+            bin_name = bin.find(class_="heading").text.strip()
+            bin_color = bin.find("img")["alt"]
+            collection_dates = []
+            collection_details = bin.find_all(class_="caption")
+            for detail in collection_details:
+                date_string = detail.text.split()[-3:]
+                collection_date = " ".join(date_string)
+                collection_dates.append(
+                    datetime.strptime(collection_date, "%d %B %Y").date()
+                )
+            bin_info.append(
+                {
+                    "Bin Name": bin_name,
+                    "Bin Color": bin_color,
+                    "Collection Dates": collection_dates,
+                }
+            )
+
+        # Check if the postcode matches the one provided, otherwise don't fill in the output
+        if postcode == self._postcode:
+            for info in bin_info:
+                entries.append(
+                    Collection(
+                        date=info["Collection Dates"][0],
+                        t=info["Bin Name"],
+                        icon=ICON_MAP.get(info["Bin Color"], "mdi:help"),
+                    )
+                )
+
+        if not entries:
+            raise ValueError(
+                "Could not get collections for the given combination of UPRN and Postcode."
+            )
+
+        return entries