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

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

@@ -0,0 +1,179 @@
+import math
+from datetime import date, timedelta
+
+import requests
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import (
+    SourceArgumentNotFound,
+    SourceArgumentNotFoundWithSuggestions,
+)
+
+TITLE = "City of Tallahassee"
+DESCRIPTION = "Source for City of Tallahassee, FL waste, recycling and bulky item/yard waste collection."
+URL = "https://www.talgov.com/you/swslookup"
+COUNTRY = "us"
+
+TEST_CASES = {
+    "400 S Monroe St": {"address": "400 S Monroe St"},
+    "2001 Trescott Dr (Red Thursday bulk)": {"address": "2001 Trescott Dr"},
+    "1004 Piney Z Plantation Rd (Blue Friday bulk)": {
+        "address": "1004 Piney Z Plantation Rd"
+    },
+}
+
+ICON_MAP = {
+    "Garbage/Recycling": Icons.GENERAL_WASTE,
+    "Bulky Items/Yard Waste": Icons.BULKY,
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "address": "Street address as shown in the City of Tallahassee lookup tool (e.g. '400 S Monroe St')",
+    },
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "address": "Street Address",
+    },
+}
+
+ADDRESS_URL = "https://handlersp.talgov.com/autosuggest/UtilSWAddressListUmax.ashx"
+SCHEDULE_URL = "https://handlersp.talgov.com/solidwaste/UtilSWRedBlueUmax.ashx"
+
+WEEKDAYS = {
+    "Monday": 0,
+    "Tuesday": 1,
+    "Wednesday": 2,
+    "Thursday": 3,
+    "Friday": 4,
+    "Saturday": 5,
+    "Sunday": 6,
+}
+
+GARBAGE_RECYCLING = "Garbage/Recycling"
+BULKY_YARD_WASTE = "Bulky Items/Yard Waste"
+
+# How many weeks ahead to project the weekly garbage/recycling schedule.
+WEEKLY_WEEKS_AHEAD = 26
+
+# How many weeks ahead to scan for the biweekly Red/Blue bulky/yard waste
+# schedule (produces roughly half as many actual collection dates).
+BULK_WEEKS_AHEAD = 52
+
+
+def _normalize(address: str) -> str:
+    return " ".join(address.split()).strip().lower()
+
+
+def _week_color(d: date) -> str:
+    """Replicate the Red/Blue week calculation used by talgov.com's own
+    client-side script (see the `RedBlueWeek` logic on
+    https://www.talgov.com/you/swslookup): a simple (non-ISO) week-of-year
+    count where week 1 is always "Red".
+    """
+    year_start = date(d.year, 1, 1)
+    days_diff = (d - year_start).days
+    # JavaScript's Date.getDay(): Sunday=0 ... Saturday=6.
+    js_year_start_weekday = (year_start.weekday() + 1) % 7
+    week_no = math.ceil((days_diff + js_year_start_weekday + 1) / 7)
+    return "Red" if week_no % 2 == 0 else "Blue"
+
+
+def _weekly_dates(weekday: int, waste_type: str) -> list[Collection]:
+    today = date.today()
+    days_ahead = (weekday - today.weekday()) % 7
+    first = today + timedelta(days=days_ahead)
+    icon = ICON_MAP.get(waste_type)
+    return [
+        Collection(date=first + timedelta(weeks=i), t=waste_type, icon=icon)
+        for i in range(WEEKLY_WEEKS_AHEAD)
+    ]
+
+
+def _biweekly_dates(weekday: int, color: str, waste_type: str) -> list[Collection]:
+    today = date.today()
+    days_ahead = (weekday - today.weekday()) % 7
+    first = today + timedelta(days=days_ahead)
+    icon = ICON_MAP.get(waste_type)
+    candidates = [first + timedelta(weeks=i) for i in range(BULK_WEEKS_AHEAD)]
+    return [
+        Collection(date=d, t=waste_type, icon=icon)
+        for d in candidates
+        if _week_color(d) == color
+    ]
+
+
+class Source:
+    def __init__(self, address: str):
+        self._address = address.strip()
+
+    def fetch(self) -> list[Collection]:
+        r = requests.get(ADDRESS_URL, params={"address": self._address}, timeout=30)
+        r.raise_for_status()
+        suggestions_raw = r.json()
+
+        target = _normalize(self._address)
+        matches = [
+            entry
+            for entry in suggestions_raw
+            if _normalize(entry.get("address", "")) == target
+        ]
+
+        if not matches:
+            suggestions = sorted(
+                {
+                    entry["address"].strip()
+                    for entry in suggestions_raw
+                    if entry.get("address")
+                }
+            )
+            if suggestions:
+                raise SourceArgumentNotFoundWithSuggestions(
+                    "address", self._address, suggestions[:10]
+                )
+            raise SourceArgumentNotFound("address", self._address)
+
+        entries: list[Collection] = []
+        for match in matches:
+            r = requests.get(
+                SCHEDULE_URL,
+                params={
+                    "customernumber": match["customernumber"],
+                    "serviceid": match["serviceid"],
+                },
+                timeout=30,
+            )
+            r.raise_for_status()
+            for row in r.json():
+                entries.extend(self._parse_row(row))
+
+        if not entries:
+            raise SourceArgumentNotFound("address", self._address)
+
+        # De-duplicate in case multiple service ids at the same address share
+        # the same pickup day.
+        unique = {(c.date, c.type): c for c in entries}
+        return sorted(unique.values(), key=lambda c: c.date)
+
+    @staticmethod
+    def _parse_row(row: dict) -> list[Collection]:
+        collections: list[Collection] = []
+
+        for day_name, weekday in WEEKDAYS.items():
+            if row.get(f"pickup{day_name.lower()}") == "Yes":
+                collections.extend(_weekly_dates(weekday, GARBAGE_RECYCLING))
+                break
+
+        bulk = (row.get("yw_bulk") or "").strip()
+        if bulk:
+            parts = bulk.split()
+            if len(parts) == 2:
+                color, day_name = parts
+                weekday = WEEKDAYS.get(day_name)
+                if weekday is not None and color in ("Red", "Blue"):
+                    collections.extend(
+                        _biweekly_dates(weekday, color, BULKY_YARD_WASTE)
+                    )
+
+        return collections

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

@@ -0,0 +1,83 @@
+import re
+from datetime import datetime
+
+import requests
+from bs4 import BeautifulSoup
+from waste_collection_schedule import Collection, Icons
+
+TITLE = "Tameside Metropolitan Borough Council"
+DESCRIPTION = "Source for tameside.gov.uk, Tameside Metropolitan Borough Council, UK"
+URL = "https://www.tameside.gov.uk"
+TEST_CASES = {
+    "Test_001": {"postcode": "M34 6AG", "uprn": "100011601683"},
+    "Test_002": {"postcode": "ol5 9jl", "uprn": "100011548952"},
+    "Test_003": {"postcode": "SK148JP", "uprn": 100011573345},
+}
+HEADERS = {
+    "user-agent": "Mozilla/5.0 (X11; Linux x86_64; rv:109.0) Gecko/20100101 Firefox/117.0",
+    "origin": "https://public.tameside.gov.uk",
+    "referrer": "https://public.tameside.gov.uk/forms/bin-dates.asp",
+}
+API_URL = "https://public.tameside.gov.uk/forms/bin-dates.asp"
+ICON_MAP = {
+    "GREEN BIN": Icons.GENERAL_WASTE,
+    "BROWN BIN": Icons.BIO_KITCHEN,
+    "BLUE BIN": Icons.NEWSPAPER,
+    "BLACK BIN": Icons.GLASS,
+}
+REGEX = r"(st|nd|rd|th)"
+
+
+class Source:
+    def __init__(self, postcode=None, uprn=None):
+        self._postcode = postcode.upper().strip().replace(" ", "")
+        self._uprn = str(uprn)
+
+    def fetch(self):
+
+        s = requests.Session()
+        # Get session cookies
+        r = s.get(API_URL, headers=HEADERS)
+
+        # Get collection schedule
+        address = self._uprn + "-" + self._postcode
+        payload = {
+            "F03_I01_SelectAddress": address,
+            "AdvanceSearch": "Continue",
+            "F01_I02_Postcode": self._postcode,
+            "F01_I03_Street": "",
+            "F01_I04_Town": "",
+            "history": ",1,3,",
+        }
+        r = s.post(API_URL, headers=HEADERS, data=payload)
+        soup = BeautifulSoup(r.text, "html.parser")
+
+        # Reconstruct dates and extract bins
+        entries = []
+        years = soup.find_all("fieldset", {"class": "year"})
+        for year in years:
+            y = year.find("h3").text
+
+            months = year.find_all("tr", {"class": "month"})
+            for month in months:
+                m = month.find("td", {"class": "month"}).text
+                m = m
+
+                days = month.find_all("td", {"class": "day"})
+                for day in days:
+                    d = re.sub(REGEX, "", day.text)
+                    dt = d + m + y
+                    dt = datetime.strptime(dt, "%d%B%Y").date()
+
+                    bins = day.find_all("img", alt=True)
+                    for bin in bins:
+                        b = bin.get("alt").replace("_Icon", "").replace("_", " ")
+                        entries.append(
+                            Collection(
+                                date=dt,
+                                t=b,
+                                icon=ICON_MAP.get(b.upper()),
+                            )
+                        )
+
+        return entries

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

@@ -0,0 +1,174 @@
+from datetime import datetime
+from xml.etree import ElementTree as ET
+
+import requests
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import SourceArgumentNotFoundWithSuggestions
+
+TITLE = "Tandridge District Council"
+DESCRIPTION = "Source for Tandridge District Council, UK, waste collection."
+URL = "https://www.tandridge.gov.uk"
+COUNTRY = "uk"
+
+TEST_CASES = {
+    "14A Station Road East, Oxted": {
+        "postcode": "RH8 0PG",
+        "house_number": "14A",
+    },
+    "22A Station Road East, Oxted": {
+        "postcode": "RH8 0PG",
+        "house_number": "22A",
+    },
+    "No postcode space": {
+        "postcode": "RH80PG",
+        "house_number": "16A",
+    },
+}
+
+ICON_MAP = {
+    "Domestic Waste Collection Service": Icons.GENERAL_WASTE,
+    "Recycling Collection Service": Icons.RECYCLING,
+    "Food Waste Collection Service": Icons.BIO_KITCHEN,
+    "Garden Waste Collection Service": Icons.GARDEN,
+    "Electricals and textiles": Icons.ELECTRONICS,
+}
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": "Enter your postcode and your house number/name exactly as it appears "
+    "when you look up your address at "
+    "https://tdcws01.tandridge.gov.uk/TDCWebAppsPublic/tfaBranded/408 "
+    "(e.g. '14A').",
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "postcode": "Your postcode (e.g. RH8 0PG)",
+        "house_number": "Your house number or name (e.g. 14A)",
+    },
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "postcode": "Postcode",
+        "house_number": "House number/name",
+    },
+}
+
+_SEARCH_URL = (
+    "https://tdcws01.tandridge.gov.uk/TDCWebAppsPublic/WebServices/"
+    "wsLLPGSearch2018/LLPGQuery_v2_3.asmx?op=SearchByAllAddressDetails"
+)
+_COLLECTIONS_URL = (
+    "https://tdcws01.tandridge.gov.uk/TDCWebAppsPublic/TDCMiddleware/"
+    "RESTAPI/WhiteSpaceAPI/GetCompleteRecordByUPRN"
+)
+
+_NS = {
+    "soap": "http://www.w3.org/2003/05/soap-envelope",
+    "tdc": "http://www.tandridge.gov.uk/Webservices/",
+}
+
+_SEARCH_XML_TEMPLATE = """<?xml version="1.0" encoding="utf-8"?>
+<soap12:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:soap12="http://www.w3.org/2003/05/soap-envelope">
+  <soap12:Body>
+    <SearchByAllAddressDetails xmlns="http://www.tandridge.gov.uk/Webservices/">
+      <SearchAddress></SearchAddress>
+      <SearchTownName></SearchTownName>
+      <SearchLocalityName></SearchLocalityName>
+      <SearchPostCode>{postcode}</SearchPostCode>
+      <SearchReference></SearchReference>
+      <SearchXPos></SearchXPos>
+      <SearchYPos></SearchYPos>
+      <SearchDistance></SearchDistance>
+      <ReturnMaxRecords></ReturnMaxRecords>
+      <MustHaveRefType></MustHaveRefType>
+      <ShowXrefTypes></ShowXrefTypes>
+      <sUseDate></sUseDate>
+      <sSearchAlternatives>1,3,6</sSearchAlternatives>
+      <sPrimaryClassifications></sPrimaryClassifications>
+      <sSecondaryClassifications></sSecondaryClassifications>
+      <sTertiaryClassifications></sTertiaryClassifications>
+      <ShowNonAddressable></ShowNonAddressable>
+      <AllowSearchOrganisations></AllowSearchOrganisations>
+    </SearchByAllAddressDetails>
+  </soap12:Body>
+</soap12:Envelope>"""
+
+_HEADERS = {
+    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 "
+    "(KHTML, like Gecko) Chrome/124.0 Safari/537.36",
+}
+
+
+class Source:
+    def __init__(self, postcode: str, house_number: str):
+        self._postcode = postcode
+        self._house_number = str(house_number)
+
+    def _find_uprn(self, session: requests.Session) -> str:
+        xml_request = _SEARCH_XML_TEMPLATE.format(postcode=self._postcode)
+        r = session.post(
+            _SEARCH_URL,
+            data=xml_request.encode("utf-8"),
+            headers={**_HEADERS, "Content-Type": "text/xml; charset=utf-8"},
+        )
+        r.raise_for_status()
+
+        root = ET.fromstring(r.text)
+        records = root.findall(".//tdc:LLPGRecord", _NS)
+
+        target = self._house_number.strip().lower()
+        candidates: list[tuple[str, str]] = []
+        for record in records:
+            house_part = record.findtext(
+                "tdc:BS7666Format/tdc:HousePart", namespaces=_NS
+            )
+            uprn = record.findtext("tdc:BS7666Format/tdc:UPRN", namespaces=_NS)
+            if not uprn or not house_part:
+                continue
+            candidates.append((house_part.strip(), uprn))
+
+        for house_part, uprn in candidates:
+            if house_part.lower() == target:
+                return uprn
+
+        raise SourceArgumentNotFoundWithSuggestions(
+            "house_number",
+            self._house_number,
+            sorted({house_part for house_part, _ in candidates}),
+        )
+
+    def fetch(self) -> list[Collection]:
+        session = requests.Session()
+
+        uprn = self._find_uprn(session)
+
+        r = session.post(
+            _COLLECTIONS_URL,
+            json={"UPRN": uprn},
+            headers={
+                **_HEADERS,
+                "Accept": "application/json, text/javascript, */*; q=0.01",
+                "Content-Type": "application/json",
+            },
+        )
+        r.raise_for_status()
+        data = r.json()
+
+        if not data.get("SuccessFlag"):
+            raise SourceArgumentNotFoundWithSuggestions(
+                "house_number",
+                self._house_number,
+                [],
+            )
+
+        entries = []
+        for item in data.get("lstCollections") or []:
+            service = (item.get("Service") or "").strip()
+            date_str = item.get("Date")
+            if not service or not date_str:
+                continue
+            date = datetime.strptime(date_str, "%d/%m/%Y %H:%M:%S").date()
+            entries.append(Collection(date=date, t=service, icon=ICON_MAP.get(service)))
+
+        return entries

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

@@ -0,0 +1,154 @@
+import datetime
+import json
+
+import requests
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import (
+    SourceArgumentNotFound,
+    SourceArgumentNotFoundWithSuggestions,
+)
+
+TITLE = "Taupō District Council"
+DESCRIPTION = "Source for Taupō District Council kerbside collection."
+URL = "https://www.taupodc.govt.nz"
+COUNTRY = "nz"
+TEST_CASES = {
+    "9 Richmond Avenue Taupo": {"address": "9 Richmond Avenue Taupo"},
+    "72 Wharewaka Road Taupo": {"address": "72 Wharewaka Road Taupo"},
+    "48 Lake Terrace Taupo": {"address": "48 Lake Terrace Taupo"},
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "address": "Address",
+    }
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "address": "Full street address as it appears on the Taupō District Council property map, e.g. '9 Richmond Avenue Taupo'",
+    }
+}
+
+PROPERTY_URL = "https://maps.taupodc.govt.nz/server/rest/services/property/Rateable_Property/FeatureServer/0/query"
+REFUSE_URL = "https://services7.arcgis.com/S7DHOirgbYgdtrbR/arcgis/rest/services/Refuse_Collection/FeatureServer/0/query"
+
+WEEKDAYS = {
+    "Monday": 0,
+    "Tuesday": 1,
+    "Wednesday": 2,
+    "Thursday": 3,
+    "Friday": 4,
+    "Saturday": 5,
+    "Sunday": 6,
+}
+
+ICON_MAP = {
+    "Kerbside Collection": Icons.GENERAL_WASTE,
+}
+
+HEADERS = {"User-Agent": "Mozilla/5.0 (waste-collection-schedule)"}
+
+
+class Source:
+    def __init__(self, address: str):
+        self._address = address
+
+    def fetch(self) -> list[Collection]:
+        # Step 1: Geocode address via Rateable Property layer
+        params = {
+            "where": f"UPPER(address) LIKE UPPER('%{self._address}%')",
+            "outFields": "address,Latitude,Longitude",
+            "resultRecordCount": "5",
+            "f": "json",
+        }
+        r = requests.get(PROPERTY_URL, params=params, headers=HEADERS, timeout=20)
+        r.raise_for_status()
+        data = r.json()
+
+        features = data.get("features", [])
+        if not features:
+            raise SourceArgumentNotFound("address", self._address)
+
+        # Use the first matching property
+        attrs = features[0]["attributes"]
+        lat = attrs.get("Latitude")
+        lon = attrs.get("Longitude")
+
+        if lat is None or lon is None:
+            raise SourceArgumentNotFound("address", self._address)
+
+        # Step 2: Spatial query to find refuse collection zone
+        geometry = json.dumps({"x": lon, "y": lat, "spatialReference": {"wkid": 4326}})
+        params = {
+            "geometry": geometry,
+            "geometryType": "esriGeometryPoint",
+            "spatialRel": "esriSpatialRelIntersects",
+            "outFields": "Collection_Day,Location",
+            "f": "json",
+        }
+        r = requests.get(REFUSE_URL, params=params, headers=HEADERS, timeout=20)
+        r.raise_for_status()
+        data = r.json()
+
+        features = data.get("features", [])
+        if not features:
+            raise SourceArgumentNotFoundWithSuggestions(
+                "address",
+                self._address,
+                [],
+            )
+
+        collection_day = features[0]["attributes"].get("Collection_Day", "")
+        if not collection_day:
+            raise SourceArgumentNotFoundWithSuggestions(
+                "address",
+                self._address,
+                [],
+            )
+
+        # Parse one or two collection days (e.g. "Tuesday & Friday", "Wed & Friday")
+        day_names = [d.strip() for d in collection_day.replace("&", ",").split(",")]
+
+        # Normalise abbreviated day names
+        abbreviations = {
+            "Mon": "Monday",
+            "Tue": "Tuesday",
+            "Wed": "Wednesday",
+            "Thu": "Thursday",
+            "Fri": "Friday",
+            "Sat": "Saturday",
+            "Sun": "Sunday",
+        }
+        normalised = []
+        for d in day_names:
+            full = abbreviations.get(d, d)
+            if full not in WEEKDAYS:
+                continue
+            normalised.append(full)
+
+        if not normalised:
+            raise SourceArgumentNotFoundWithSuggestions(
+                "address",
+                self._address,
+                [],
+            )
+
+        # Step 3: Generate 52 weeks of upcoming dates for each day
+        today = datetime.date.today()
+        entries = []
+        for day_name in normalised:
+            target_weekday = WEEKDAYS[day_name]
+            days_ahead = (target_weekday - today.weekday()) % 7
+            next_date = today + datetime.timedelta(days=days_ahead)
+            for _ in range(52):
+                entries.append(
+                    Collection(
+                        date=next_date,
+                        t="Kerbside Collection",
+                        icon=ICON_MAP["Kerbside Collection"],
+                    )
+                )
+                next_date += datetime.timedelta(weeks=1)
+
+        return entries