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

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

@@ -0,0 +1,62 @@
+import json
+from datetime import datetime
+
+import requests
+from waste_collection_schedule import Collection  # type: ignore[attr-defined]
+
+TITLE = "RecycleSmart"
+DESCRIPTION = "Source for RecycleSmart collection."
+URL = "https://www.recyclesmart.com/"
+COUNTRY = "au"
+TEST_CASES = {
+    "pickup": {
+        "email": "!secret recyclesmart_email",
+        "password": "!secret recyclesmart_password",
+    },
+}
+
+
+class Source:
+    def __init__(self, email, password):
+        self._email = email
+        self._password = password
+
+    def fetch(self):
+        # login is via Google Identity Toolkit, providing username and password.
+        r = requests.post(
+            "https://identitytoolkit.googleapis.com/v1/accounts:signInWithPassword",
+            json={
+                "returnSecureToken": True,
+                "email": self._email,
+                "password": self._password,
+            },
+            params={"key": "AIzaSyBnup3QFYYGwnvjZi7r5a39c8b94SNospU"},
+        )
+        data = json.loads(r.text)
+
+        # take the token returned from Google Identity Toolkit to get the API auth token (JWT) from Firebase
+        r = requests.post(
+            "https://www.app.recyclesmart.com/api/sessions/firebase",
+            json={"id_token": data["idToken"]},
+            headers={"content-type": "application/json"},
+        )
+        data = json.loads(r.text)
+
+        # use the auth token (jwt) from firebase to get pickups
+        r = requests.get(
+            "https://www.app.recyclesmart.com/api/pickups",
+            # retrieves future pickups (if scheduled), then past pickups, until per_page is reached
+            # the average user is scheduled for monthly pickups
+            params={"page": "1", "per_page": "5"},
+            headers={"Authorization": data["data"]["attributes"]["auth_token"]},
+        )
+
+        data = json.loads(r.text)
+
+        entries = []
+        for item in data["data"]:
+            collection_date = datetime.strptime(
+                item["attributes"]["pickup_on"], "%Y-%m-%d"
+            )
+            entries.append(Collection(collection_date.date(), "Pickup"))
+        return entries

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

@@ -0,0 +1,313 @@
+import datetime
+import json
+import re
+
+import requests
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import (
+    SourceArgAmbiguousWithSuggestions,
+    SourceArgumentNotFound,
+)
+
+TITLE = "Red Bank, Tennessee"
+DESCRIPTION = "Source for residential trash collection in the City of Red Bank, TN."
+URL = "https://www.redbanktn.gov/257/Solid-Waste"
+COUNTRY = "us"
+TEST_CASES = {
+    "Monday route": {"street_address": "1107 Ashmore Ave"},
+    "Tuesday route": {"street_address": "3121 Dayton Blvd"},
+    "Friday route": {"street_address": "145 Ivy Row Ln"},
+    "With city/state/zip": {"street_address": "20 Mason Dr, Red Bank, TN 37415"},
+}
+
+# Public, token-free ArcGIS Feature Service backing the city's "trash day" map.
+# Layer 1  = parcels (each carries STNUM / STNAME / ADDRESS, polygon geometry).
+# Layers 2-6 = the Monday..Friday collection-zone polygons.
+_FEATURE_SERVER = (
+    "https://services9.arcgis.com/b7VbpZSIoQ7S1Sl6/arcgis/rest/services/"
+    "Red_Bank_Garbage_Pickup_Schedule_WFL1/FeatureServer"
+)
+_PARCELS_LAYER = 1
+# day-zone layer id -> Python weekday() index (Mon=0 .. Fri=4)
+_DAY_LAYERS = {2: 0, 3: 1, 4: 2, 5: 3, 6: 4}
+_WKID = 102100  # Web Mercator, the service's native spatial reference
+
+# How far ahead to project the recurring weekly schedule.
+_HORIZON_DAYS = 365
+
+ICON_MAP = {
+    "Trash": Icons.GENERAL_WASTE,
+}
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": (
+        "Enter your street address as it appears in Red Bank (e.g. '1107 Ashmore "
+        "Ave'). The city/state/ZIP are optional. Your collection weekday is looked "
+        "up from the city's official trash-day map."
+    ),
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "street_address": "Street address within the City of Red Bank, TN.",
+    },
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "street_address": "Street Address",
+    },
+}
+
+# Street-type suffixes dropped before matching so 'Ave' vs 'Avenue' etc. don't
+# cause a miss (the parcel layer stores the bare street name in STNAME).
+_SUFFIXES = {
+    "ST",
+    "STREET",
+    "AVE",
+    "AVENUE",
+    "RD",
+    "ROAD",
+    "DR",
+    "DRIVE",
+    "LN",
+    "LANE",
+    "BLVD",
+    "BOULEVARD",
+    "CT",
+    "COURT",
+    "PL",
+    "PLACE",
+    "TER",
+    "TERR",
+    "TERRACE",
+    "CIR",
+    "CIRCLE",
+    "WAY",
+    "PKWY",
+    "PARKWAY",
+    "HWY",
+    "HIGHWAY",
+    "TRL",
+    "TRAIL",
+    "ROW",
+    "PT",
+    "POINT",
+    "LOOP",
+    "RUN",
+    "PASS",
+    "COVE",
+    "CV",
+    "XING",
+    "CROSSING",
+    "SQ",
+    "SQUARE",
+    "PIKE",
+    "PARK",
+}
+_UNIT_MARKERS = {"APT", "UNIT", "STE", "SUITE", "LOT", "#"}
+
+
+def _easter(year: int) -> datetime.date:
+    """Gregorian Easter Sunday (Anonymous algorithm)."""
+    a = year % 19
+    b = year // 100
+    c = year % 100
+    d = b // 4
+    e = b % 4
+    f = (b + 8) // 25
+    g = (b - f + 1) // 3
+    h = (19 * a + b - d - g + 15) % 30
+    i = c // 4
+    k = c % 4
+    l = (32 + 2 * e + 2 * i - h - k) % 7  # noqa: E741
+    m = (a + 11 * h + 22 * l) // 451
+    month = (h + l - 7 * m + 114) // 31
+    day = ((h + l - 7 * m + 114) % 31) + 1
+    return datetime.date(year, month, day)
+
+
+def _nth_weekday(year: int, month: int, weekday: int, n: int) -> datetime.date:
+    """Date of the n-th given weekday (Mon=0) in a month."""
+    first = datetime.date(year, month, 1)
+    offset = (weekday - first.weekday()) % 7
+    return first + datetime.timedelta(days=offset + 7 * (n - 1))
+
+
+def _last_weekday(year: int, month: int, weekday: int) -> datetime.date:
+    """Date of the last given weekday (Mon=0) in a month."""
+    if month == 12:
+        nxt = datetime.date(year + 1, 1, 1)
+    else:
+        nxt = datetime.date(year, month + 1, 1)
+    last = nxt - datetime.timedelta(days=1)
+    return last - datetime.timedelta(days=(last.weekday() - weekday) % 7)
+
+
+def _observed_weekday(d: datetime.date) -> datetime.date:
+    """City observes a weekend fixed-date holiday on the adjacent weekday."""
+    if d.weekday() == 5:  # Saturday -> Friday before
+        return d - datetime.timedelta(days=1)
+    if d.weekday() == 6:  # Sunday -> Monday after
+        return d + datetime.timedelta(days=1)
+    return d
+
+
+def _red_bank_holidays(year: int) -> set:
+    """Weekdays the City of Red Bank does not collect, per its published
+    holiday schedule (federal holidays + Good Friday + day after Thanksgiving).
+
+    Note: in some years the city additionally closes the day before/after
+    Christmas and New Year's, which is announced ad hoc and not modelled here;
+    such weeks may differ by a day from the city's posted makeup table.
+    """
+    h = set()
+    for month, day in ((1, 1), (6, 19), (7, 4), (11, 11), (12, 25)):
+        h.add(_observed_weekday(datetime.date(year, month, day)))
+    h.add(_nth_weekday(year, 1, 0, 3))  # MLK Jr Day (3rd Mon Jan)
+    h.add(_nth_weekday(year, 2, 0, 3))  # Presidents Day (3rd Mon Feb)
+    h.add(_last_weekday(year, 5, 0))  # Memorial Day (last Mon May)
+    h.add(_nth_weekday(year, 9, 0, 1))  # Labor Day (1st Mon Sep)
+    thanksgiving = _nth_weekday(year, 11, 3, 4)  # 4th Thu Nov
+    h.add(thanksgiving)
+    h.add(thanksgiving + datetime.timedelta(days=1))  # day after Thanksgiving
+    h.add(_easter(year) - datetime.timedelta(days=2))  # Good Friday
+    return h
+
+
+class Source:
+    def __init__(self, street_address: str):
+        self._street_address = street_address.strip()
+
+    def _parse_address(self) -> tuple:
+        """Split a free-text address into (house number, bare street name)."""
+        text = self._street_address.split(",")[0].upper()
+        text = re.sub(r"[^0-9A-Z ]", " ", text)
+        tokens = [t for t in text.split() if t]
+
+        stnum = None
+        rest = []
+        for token in tokens:
+            if stnum is None and any(ch.isdigit() for ch in token):
+                stnum = token
+            elif stnum is not None:
+                rest.append(token)
+
+        # drop unit designators and a trailing street-type suffix
+        cleaned = []
+        skip_next = False
+        for token in rest:
+            if skip_next:
+                skip_next = False
+                continue
+            if token in _UNIT_MARKERS:
+                skip_next = True
+                continue
+            cleaned.append(token)
+        if cleaned and cleaned[-1] in _SUFFIXES:
+            cleaned = cleaned[:-1]
+
+        return stnum, " ".join(cleaned)
+
+    def _find_centroid(self, session: requests.Session) -> dict:
+        stnum, street_name = self._parse_address()
+        if not stnum or not street_name:
+            raise SourceArgumentNotFound("street_address", self._street_address)
+
+        # escape single quotes for the SQL-style where clause
+        esc = street_name.replace("'", "''")
+        where = f"STNUM='{stnum}' AND UPPER(STNAME) LIKE '{esc}%'"
+
+        r = session.get(
+            f"{_FEATURE_SERVER}/{_PARCELS_LAYER}/query",
+            params={
+                "f": "json",
+                "where": where,
+                "outFields": "ADDRESS,STNUM,STNAME",
+                "returnGeometry": "false",
+                "returnCentroid": "true",
+                "resultRecordCount": 50,
+            },
+            timeout=30,
+        )
+        r.raise_for_status()
+        features = r.json().get("features", [])
+        if not features:
+            raise SourceArgumentNotFound("street_address", self._street_address)
+
+        # collapse multi-polygon parcels that share one address
+        by_address: dict = {}
+        for feat in features:
+            addr = feat.get("attributes", {}).get("ADDRESS") or ""
+            by_address.setdefault(addr, feat)
+
+        if len(by_address) > 1:
+            raise SourceArgAmbiguousWithSuggestions(
+                "street_address",
+                self._street_address,
+                sorted(by_address.keys()),
+            )
+
+        feat = next(iter(by_address.values()))
+        centroid = feat.get("centroid")
+        if not centroid:
+            raise SourceArgumentNotFound("street_address", self._street_address)
+        return centroid
+
+    def _weekday_for_centroid(self, session: requests.Session, centroid: dict) -> int:
+        geometry = json.dumps(
+            {
+                "x": centroid["x"],
+                "y": centroid["y"],
+                "spatialReference": {"wkid": _WKID},
+            }
+        )
+        for layer_id, weekday in _DAY_LAYERS.items():
+            r = session.get(
+                f"{_FEATURE_SERVER}/{layer_id}/query",
+                params={
+                    "f": "json",
+                    "geometry": geometry,
+                    "geometryType": "esriGeometryPoint",
+                    "inSR": _WKID,
+                    "spatialRel": "esriSpatialRelIntersects",
+                    "where": "1=1",
+                    "returnCountOnly": "true",
+                },
+                timeout=30,
+            )
+            r.raise_for_status()
+            if r.json().get("count", 0) > 0:
+                return weekday
+        # parcel exists but isn't covered by any day zone
+        raise SourceArgumentNotFound("street_address", self._street_address)
+
+    def fetch(self) -> list[Collection]:
+        session = requests.Session()
+        centroid = self._find_centroid(session)
+        weekday = self._weekday_for_centroid(session, centroid)
+
+        today = datetime.date.today()
+        end = today + datetime.timedelta(days=_HORIZON_DAYS)
+
+        holidays: set = set()
+        for year in range(today.year, end.year + 2):
+            holidays |= _red_bank_holidays(year)
+
+        icon = ICON_MAP["Trash"]
+        entries = []
+        # start from this week's occurrence of the collection weekday
+        current = (
+            today
+            - datetime.timedelta(days=today.weekday())
+            + datetime.timedelta(days=weekday)
+        )
+        while current <= end:
+            collection_date = current
+            # delay onto the next non-holiday weekday (Mon-Fri)
+            while collection_date.weekday() >= 5 or collection_date in holidays:
+                collection_date += datetime.timedelta(days=1)
+            entries.append(Collection(date=collection_date, t="Trash", icon=icon))
+            current += datetime.timedelta(weeks=1)
+
+        return entries

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

@@ -0,0 +1,148 @@
+import re
+from datetime import datetime
+from io import BytesIO
+
+import requests
+from pypdf import PdfReader
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+
+TITLE = "Redbridge Council"
+DESCRIPTION = "Source for redbridge.gov.uk services for Redbridge Council, UK."
+URL = "https://redbridge.gov.uk"
+TEST_CASES = {
+    "council office recycling only": {"uprn": 10034922090},
+    "refuse and recycling only": {"uprn": 10013585215},
+    "a church vicarage, garden, recycling, refuse": {"uprn": 10034912354},
+    "food, refuse, recycling": {"uprn": 10034926463},
+}
+ICON_MAP = {
+    "REFUSE": Icons.GENERAL_WASTE,
+    "RECYCLING": Icons.RECYCLING,
+    "GARDEN": Icons.GARDEN,
+    "FOOD": Icons.BIO_KITCHEN,
+}
+
+KNOWN_SERVICES = {"REFUSE", "RECYCLING", "GARDEN", "FOOD"}
+
+
+def _extract_text_from_pdf(pdf_bytes: bytes) -> str:
+    reader = PdfReader(BytesIO(pdf_bytes))
+    text = ""
+    for page in reader.pages:
+        text += page.extract_text() or ""
+    return text
+
+
+def _extract_collections_from_text(text: str) -> list[Collection]:
+    # Normalise and split into non‑empty trimmed lines
+    lines = [line.strip() for line in text.splitlines() if line.strip()]
+
+    # Headers and structure
+    month_regex = re.compile(
+        r"^(January|February|March|April|May|June|July|August|September|October|November|December)\s+(\d{4})$",
+        re.I,
+    )
+    weekday_header_regex = re.compile(
+        r"^(Sun\s+Mon\s+Tue\s+Wed\s+Thu\s+Fri\s+Sat)$", re.I
+    )
+
+    # A day row contains one or more day numbers separated by spaces, e.g. "1 2" or "3 4 5 6 7"
+    day_group_regex = re.compile(r"^(?:\d{1,2})(?:\s+\d{1,2})*$")
+
+    # PDF lists only the type name per line, e.g. "Refuse", "Food", "Garden", "Recycling"
+    service_regex = re.compile(r"^(.+)$")
+
+    current_month_name: str | None = None
+    current_year: int | None = None
+
+    def month_number(name: str) -> int:
+        return datetime.strptime(name, "%B").month
+
+    entries: list[Collection] = []
+    i = 0
+    while i < len(lines):
+        line = lines[i]
+
+        # Detect month header, e.g. "March 2026"
+        m = month_regex.match(line)
+        if m:
+            current_month_name = m.group(1)
+            current_year = int(m.group(2))
+            i += 1
+            continue
+
+        # Skip weekday header rows and other non‑data noise
+        lower = line.lower()
+        if (
+            weekday_header_regex.match(line)
+            or lower.startswith("london borough of redbridge")
+            or "your collection schedule" in lower
+        ):
+            i += 1
+            continue
+
+        # Detect a calendar day ROW (e.g. "1 2" or "3 4 5 6 7") once we know the month/year
+        if current_month_name and current_year and day_group_regex.match(line):
+            # Parse all day numbers on the row
+            days: list[int] = []
+            for token in line.split():
+                try:
+                    d = int(token)
+                    if 1 <= d <= 31:
+                        days.append(d)
+                except ValueError:
+                    pass
+
+            # Gather following service lines until next structural boundary
+            services: list[str] = []
+            j = i + 1
+            while j < len(lines):
+                next_line = lines[j]
+                lower_next = next_line.lower()
+
+                if (
+                    month_regex.match(next_line)
+                    or weekday_header_regex.match(next_line)
+                    or day_group_regex.match(next_line)
+                    or "your collection schedule" in lower_next
+                ):
+                    break
+
+                s = service_regex.match(next_line)
+                if s:
+                    wt = s.group(1).strip()
+                    key = wt.split(" ")[0].upper()
+                    if key in KNOWN_SERVICES:
+                        services.append(wt)
+                j += 1
+
+            # For this layout, all services on the row belong to the last day number
+            if days and services:
+                month = month_number(current_month_name)
+                target_day = max(days)
+                date = datetime(current_year, month, target_day).date()
+                for wt in services:
+                    key = wt.split(" ")[0].upper()
+                    entries.append(Collection(date=date, t=wt, icon=ICON_MAP.get(key)))
+
+            i = j
+            continue
+
+        i += 1
+
+    return entries
+
+
+class Source:
+    def __init__(self, uprn):
+        self._uprn = str(uprn)
+
+    def fetch(self):
+        r = requests.get(
+            "https://my.redbridge.gov.uk/RecycleRefuse/GetFile",
+            params={"uprn": self._uprn},
+        )
+        r.raise_for_status()
+
+        pdf_text = _extract_text_from_pdf(r.content)
+        return _extract_collections_from_text(pdf_text)

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

@@ -0,0 +1,148 @@
+import json
+from datetime import date, timedelta
+
+import requests
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import (
+    SourceArgumentNotFoundWithSuggestions,
+)
+
+TITLE = "Redland City Council (QLD)"
+DESCRIPTION = "Source for Redland City Council (QLD) rubbish collection."
+URL = "https://www.redland.qld.gov.au"
+TEST_CASES = {
+    "Mount Cotton": {
+        "suburb": "Mount Cotton",
+        "street_name": "Mount Cotton Road",
+        "street_number": "1,261",
+    },
+    "Random Redland Bay": {
+        "suburb": "Redland Bay",
+        "street_name": "Boundary Street",
+        "street_number": "1",
+    },
+    "Random Victoria Point": {
+        "suburb": "Victoria Point",
+        "street_name": "Colburn Avenue",
+        "street_number": "25",
+    },
+}
+
+HEADERS = {"user-agent": "Mozilla/5.0"}
+
+API = "https://redland.waste-info.com.au/api/v1"
+
+ICON_MAP = {
+    "waste": Icons.GENERAL_WASTE,
+    "recycle": Icons.RECYCLING,
+    "organic": Icons.ORGANIC,
+}
+
+
+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(f"{API}/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"{API}/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"{API}/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} {self.suburb}")[0]
+                    for x in data["properties"]
+                    if f" {self.street_name} {self.suburb}" in x["name"]
+                ],
+            )
+            raise Exception(
+                f"{self.street_number} {self.street_name} {self.suburb} not found"
+            )
+
+        # Retrieve the upcoming collections for our property
+        r = requests.get(
+            f"{API}/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"] not in ["recycle", "organic"]:
+                continue
+            # 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