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

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

@@ -0,0 +1,189 @@
+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
+
+TITLE = "City of Tea Tree Gully"
+DESCRIPTION = "Source for City of Tea Tree Gully waste collection."
+URL = "https://www.teatreegully.sa.gov.au"
+COUNTRY = "au"
+
+TEST_CASES = {
+    "Erica Street": {"address": "4 Erica Street, Tea Tree Gully"},
+    "Smart Road": {"address": "1 Smart Road, Modbury"},
+}
+
+ICON_MAP = {
+    "General Waste": Icons.GENERAL_WASTE,
+    "Recycling": Icons.RECYCLING,
+    "Organics": Icons.ORGANIC,
+}
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": "Enter your street address (e.g. '4 Erica Street, Tea Tree Gully'). "
+    "Search at https://www.teatreegully.sa.gov.au/services/bins-and-waste/bin-collection-days",
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "address": "Street address (e.g. '4 Erica Street, Tea Tree Gully')",
+    },
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "address": "Street Address",
+    },
+}
+
+GEOCODE_URL = "https://utility.arcgis.com/usrsvcs/servers/5c770a0bb67f4b8d893e21dccad13b70/rest/services/World/GeocodeServer/findAddressCandidates"
+ZONE_URL = "https://services9.arcgis.com/CsUMpO9iTKFFwe1O/arcgis/rest/services/Waste_View_Public/FeatureServer/4/query"
+
+# Reference: Monday 5 Jan 2025 = Week A
+REF_DATE = date(2025, 1, 5)
+
+# JS-style day numbering (Sunday=0) used for offset from reference date
+WEEKDAY_OFFSET = {
+    "Monday": 1,
+    "Tuesday": 2,
+    "Wednesday": 3,
+    "Thursday": 4,
+    "Friday": 5,
+    "Saturday": 6,
+    "Sunday": 0,
+}
+
+# Public holidays where collection shifts to the next day (from functions.js)
+HOLIDAYS = {
+    date(2025, 1, 1),
+    date(2025, 1, 2),
+    date(2025, 1, 3),
+    date(2025, 4, 18),
+    date(2025, 12, 25),
+    date(2025, 12, 26),
+    date(2026, 1, 1),
+    date(2026, 1, 2),
+    date(2026, 4, 3),
+    date(2026, 12, 25),
+    date(2027, 1, 1),
+    date(2027, 3, 26),
+    date(2027, 12, 25),
+    date(2028, 1, 1),
+    date(2028, 4, 14),
+    date(2028, 12, 25),
+    date(2028, 12, 26),
+    date(2028, 12, 27),
+    date(2028, 12, 28),
+    date(2028, 12, 29),
+}
+
+
+def _adjust_holiday(d: date) -> date:
+    """Shift collection date forward by one day if it falls on a holiday."""
+    if d in HOLIDAYS:
+        return d + timedelta(days=1)
+    return d
+
+
+class Source:
+    def __init__(self, address: str):
+        self._address = address.strip()
+
+    def fetch(self) -> list[Collection]:
+        # Step 1: Geocode address
+        r = requests.get(
+            GEOCODE_URL,
+            params={
+                "SingleLine": self._address,
+                "forStorage": "false",
+                "maxLocations": "6",
+                "outFields": "*",
+                "outSR": '{"wkid":4326}',
+                "f": "json",
+            },
+            headers={
+                "Referer": "https://survey123.arcgis.com/",
+            },
+            timeout=30,
+        )
+        r.raise_for_status()
+        candidates = r.json().get("candidates", [])
+        if not candidates:
+            raise SourceArgumentNotFound("address", self._address)
+
+        location = candidates[0]["location"]
+
+        # Step 2: Query waste collection zone
+        r = requests.get(
+            ZONE_URL,
+            params={
+                "where": "1=1",
+                "geometry": f'{{"x": {location["x"]}, "y": {location["y"]}}}',
+                "geometryType": "esriGeometryPoint",
+                "inSR": "4326",
+                "spatialRel": "esriSpatialRelIntersects",
+                "outFields": "Collection,Week",
+                "returnGeometry": "false",
+                "resultRecordCount": "1",
+                "f": "json",
+            },
+            headers={
+                "Referer": "https://survey123.arcgis.com/",
+            },
+            timeout=30,
+        )
+        r.raise_for_status()
+        features = r.json().get("features", [])
+        if not features:
+            raise SourceArgumentNotFound("address", self._address)
+
+        attrs = features[0]["attributes"]
+        collection_day = attrs["Collection"]
+        week_letter = attrs["Week"]
+
+        day_offset = WEEKDAY_OFFSET.get(collection_day)
+        if day_offset is None:
+            raise SourceArgumentNotFound("address", self._address)
+
+        # Step 3: Generate collection dates
+        # JS-style offsets from REF_DATE (Monday Jan 5, 2025)
+        week_a_start = REF_DATE + timedelta(days=day_offset)
+        week_b_start = REF_DATE + timedelta(days=7 + day_offset)
+
+        # Determine which fortnightly week gets recycling vs organics
+        if week_letter == "A":
+            recycling_start = week_a_start
+        else:
+            recycling_start = week_b_start
+
+        # Find next collection day from today (using Python weekday)
+        py_weekday = (day_offset - 1) % 7  # convert JS Sunday=0 to Python Monday=0
+        today = date.today()
+        days_until = (py_weekday - today.weekday() + 7) % 7
+        next_day = today + timedelta(days=days_until)
+
+        entries = []
+        for i in range(26):  # ~6 months of weekly collections
+            collection_date = next_day + timedelta(weeks=i)
+            adjusted = _adjust_holiday(collection_date)
+
+            # General Waste: every week
+            entries.append(
+                Collection(
+                    date=adjusted, t="General Waste", icon=ICON_MAP["General Waste"]
+                )
+            )
+
+            # Check if this is a recycling or organics week
+            days_from_recycling = (collection_date - recycling_start).days
+            if days_from_recycling % 14 == 0:
+                entries.append(
+                    Collection(date=adjusted, t="Recycling", icon=ICON_MAP["Recycling"])
+                )
+            else:
+                entries.append(
+                    Collection(date=adjusted, t="Organics", icon=ICON_MAP["Organics"])
+                )
+
+        return entries

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

@@ -0,0 +1,88 @@
+from datetime import datetime
+
+from bs4 import BeautifulSoup
+from curl_cffi import requests
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+
+TITLE = "Teignbridge District Council"
+DESCRIPTION = "Source for teignbridge.gov.uk waste collection."
+URL = "https://www.teignbridge.gov.uk"
+TEST_CASES = {
+    "EX4 2JR": {"postcode": "EX4 2JR", "uprn": "010032968474"},
+    "TQ12": {"postcode": "TQ12 4QQ", "uprn": "100040270498"},
+}
+
+COUNTRY = "uk"
+
+ICON_MAP = {
+    "Food waste container": Icons.BIO_KITCHEN,
+    "Black box": Icons.RECYCLING,
+    "Green box": Icons.GLASS,
+    "Sack for paper": Icons.PAPER,
+    "Refuse - black bin": Icons.GENERAL_WASTE,
+}
+
+ADDRESS_URL = "https://www.teignbridge.gov.uk/repositories/hidden-pages/address-finder"
+BIN_URL = "https://www.teignbridge.gov.uk/umbraco/surface/bincollection/GetCollections"
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": "Visit <a href='https://www.teignbridge.gov.uk/recycling-and-waste/forms/download-your-collection-calendar/'>Download your collection calendar</a>, enter your postcode and note the UPRN from the address dropdown.",
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "postcode": "Postcode (e.g. EX4 2JR)",
+        "uprn": "Unique Property Reference Number",
+    },
+}
+
+
+class Source:
+    def __init__(self, postcode: str, uprn: str | int):
+        self._postcode = postcode
+        self._uprn = str(uprn)
+
+    def fetch(self) -> list[Collection]:
+        # Fetch collection schedule
+        r = requests.get(BIN_URL, params={"uprn": self._uprn}, impersonate="chrome124")
+        r.raise_for_status()
+
+        soup = BeautifulSoup(r.text, "html.parser")
+        entries = []
+
+        # Each collection date is in an h3 with class "binCollectionH3"
+        headings = soup.find_all("h3", class_="binCollectionH3")
+
+        for h3 in headings:
+            # Extract date text (e.g. "7 April 2026")
+            date_text = h3.get_text(strip=True)
+            # Remove the day name descriptor at the end (e.g. "Tuesday")
+            span = h3.find("span", class_="binDayDescriptor")
+            if span:
+                day_name = span.get_text(strip=True)
+                date_text = date_text.replace(day_name, "").strip()
+
+            try:
+                collection_date = datetime.strptime(date_text, "%d %B %Y").date()
+            except ValueError:
+                continue
+
+            # Find the following binInfoContainer
+            container = h3.find_next_sibling("div", class_="binInfoContainer")
+            if not container:
+                continue
+
+            # Extract bin types from img title attributes
+            for line in container.find_all("div", class_="binInfoLine"):
+                img = line.find("img")
+                if img and img.get("title"):
+                    bin_type = img["title"]
+                    entries.append(
+                        Collection(
+                            date=collection_date,
+                            t=bin_type,
+                            icon=ICON_MAP.get(bin_type),
+                        )
+                    )
+
+        return entries

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

@@ -0,0 +1,122 @@
+import datetime
+import json
+import re
+
+import requests
+from waste_collection_schedule import Collection, Icons
+from waste_collection_schedule.exceptions import (
+    SourceArgumentException,
+    SourceArgumentNotFound,
+    SourceArgumentNotFoundWithSuggestions,
+)
+
+TITLE = "Telford and Wrekin Council"
+DESCRIPTION = "Source for telford.gov.uk, Telford and Wrekin Council, UK"
+URL = "https://www.telford.gov.uk"
+
+TEST_CASES = {
+    "10 Long Row Drive, Lawley": {"uprn": "000452097493"},
+    "126 Dunsheath, Telford": {"post_code": "TF3 2DA", "name_number": "126"},
+    "11 Pinewoods, Telford": {"post_code": "TF10 9LN", "name_number": "11"},
+}
+
+API_URLS = {
+    "address_search": "https://dac.telford.gov.uk/BinDayFinder/Find/PostcodeSearch",
+    "collection": "https://dac.telford.gov.uk/BinDayFinder/Find/PropertySearch",
+}
+
+# Map the names to icons
+ICON_MAP = {
+    "Red Top Container": Icons.GENERAL_WASTE,
+    "Purple / Blue Containers": Icons.RECYCLING,
+    "Green Container": Icons.ORGANIC,
+    "Silver Containers": Icons.BIO_KITCHEN,
+}
+
+# Path to the images provided by the council for the containers
+IMAGEPATH = "https://dac.telford.gov.uk/BinDayFinder/Content/BinIcons/"
+
+
+class Source:
+    def __init__(self, post_code=None, name_number=None, uprn=None):
+        self._post_code = post_code
+        self._name_number = name_number
+        self._uprn = uprn
+
+    def fetch(self):
+        if not self._uprn:
+            # look up the UPRN for the address
+
+            params = {"postcode": self._post_code}
+            r = requests.get(API_URLS["address_search"], params=params)
+            if r.status_code == 500:
+                raise SourceArgumentException(
+                    "post_code",
+                    "Postcode is not in the correct format or service is unavailable",
+                )
+
+            r.raise_for_status()
+
+            # Required to parse the returned JSON
+            addresses = json.loads(r.json())
+            if len(addresses["properties"]) == 0:
+                raise SourceArgumentNotFound("post_code", self._post_code)
+
+            for property in addresses["properties"]:
+                if property["PrimaryName"].lower() == self._name_number.lower():
+                    self._uprn = property["UPRN"]
+
+            if not self._uprn:
+                raise SourceArgumentNotFoundWithSuggestions(
+                    "name_number",
+                    self._name_number,
+                    [property["PrimaryName"] for property in addresses["properties"]],
+                )
+
+        # Get the collection information
+
+        params = {"uprn": self._uprn}
+
+        r = requests.get(API_URLS["collection"], params=params)
+
+        r.raise_for_status()
+
+        x = json.loads(r.json())
+        collections = x["bincollections"]
+
+        entries = []
+
+        if collections:
+            for collection in collections:
+                # Parse the data as the council JSON API returns no year for the collections
+                # and so it needs to be calculated to format the date correctly
+
+                today = datetime.date.today()
+                year = today.year
+
+                # Remove nd,rd,th,st from the date so it can be parsed
+
+                datestring = (
+                    re.sub(r"(\d)(st|nd|rd|th)", r"\1", collection["nextDate"])
+                    + " "
+                    + str(year)
+                )
+
+                date = datetime.datetime.strptime(datestring, "%A %d %B %Y").date()
+
+                # Calculate the year. As we only get collections 2 weeks in advance we can assume the current
+                # year unless the month is January in December where it will be next year
+
+                if (date.month == 1) and (today.month == 12):
+                    date = date.replace(year=year + 1)
+
+                entries.append(
+                    Collection(
+                        date=date,
+                        t=collection["name"],
+                        icon=ICON_MAP.get(collection["name"]),
+                        picture=IMAGEPATH + collection["imageURL"],
+                    )
+                )
+
+        return entries

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

@@ -0,0 +1,117 @@
+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 (
+    SourceArgumentNotFound,
+    SourceArgumentNotFoundWithSuggestions,
+    SourceArgumentRequired,
+)
+
+TITLE = "Telge Återvinning"
+DESCRIPTION = "Source for Telge Återvinning, household waste collection in Södertälje municipality"
+URL = "https://www.telge.se"
+COUNTRY = "se"
+API_URL = "https://www.telge.se/api/thorweb/garbagecollection"
+TEST_CASES = {
+    "Residential Södertälje": {"address": "BERGSGATAN 22, SÖDERTÄLJE"},
+    "Rural with latrine": {"address": "BERGA 1, JÄRNA"},
+    "Garden waste": {"address": "PALLSTIGEN 1, HÖLÖ"},
+    "Commercial sorting": {"address": "STORGATAN 13 VÅRDCENTRAL JÄRNA, JÄRNA"},
+    "Septic tank": {"address": "BACKA 3 MARIELUND, JÄRNA"},
+}
+
+ICON_MAP = {
+    "BRÄNN": Icons.GENERAL_WASTE,
+    "GLOF": Icons.GLASS_COLORED,
+    "HEMSORT": Icons.RECYCLING,
+    "HUSHSORT": Icons.GENERAL_WASTE,
+    "LATRIN": Icons.HAZARDOUS,
+    "MATAVF": Icons.BIO_KITCHEN,
+    "METFÖRP": Icons.METAL,
+    "PLASTFÖRP": Icons.GLASS,
+    "RETURPAPP": Icons.NEWSPAPER,
+    "SLAM": Icons.HAZARDOUS,
+    "TRÄDGÅRD": Icons.GARDEN,
+    "WELLPAPP": Icons.PAPER,
+}
+DEFAULT_ICON = "mdi:trash-can"
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": "Find your address at https://www.telge.se by searching for your street name in the waste collection schedule (Sopbilsschema). Use the exact address string shown in the autocomplete dropdown, e.g. 'BERGSGATAN 22, SÖDERTÄLJE'.",
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "address": "Address",
+    },
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "address": "Exact address as shown in the Telge autocomplete (uppercase, e.g. BERGSGATAN 22, SÖDERTÄLJE)",
+    },
+}
+
+
+class Source:
+    def __init__(self, address: str):
+        if not address:
+            raise SourceArgumentRequired(
+                "address",
+                "An address is required (use the autocomplete endpoint to find "
+                "the exact format, e.g. 'BERGSGATAN 22, SÖDERTÄLJE')",
+            )
+        self._address = address.strip().upper()
+
+    def fetch(self) -> list[Collection]:
+        r = requests.get(
+            f"{API_URL}/schedule/{self._address}",
+            timeout=30,
+        )
+        r.raise_for_status()
+
+        data = r.json()
+
+        if not isinstance(data, list) or not data:
+            suggestions = self._autocomplete(self._address.split(",")[0].strip())
+            if suggestions:
+                raise SourceArgumentNotFoundWithSuggestions(
+                    "address", self._address, suggestions
+                )
+            raise SourceArgumentNotFound("address", self._address)
+
+        entries = []
+        for item in data:
+            waste_type = item.get("typeOfWaste", "").strip()
+            waste_description = item.get("typeOfWasteDescription", waste_type).strip()
+            container_type = item.get("containerType", "").strip()
+            dt = datetime.fromisoformat(item["date"])
+
+            # Distinguish bins: K370L1 → "(kärl 1)", K140L → no suffix
+            m = re.search(r"L(\d+)$", container_type)
+            if m:
+                waste_description += f" (kärl {m.group(1)})"
+
+            entries.append(
+                Collection(
+                    date=dt.date(),
+                    t=waste_description,
+                    icon=ICON_MAP.get(waste_type, DEFAULT_ICON),
+                )
+            )
+
+        return entries
+
+    @staticmethod
+    def _autocomplete(query: str) -> list[str]:
+        try:
+            r = requests.get(
+                f"{API_URL}/autocomplete/{query}",
+                timeout=10,
+            )
+            r.raise_for_status()
+            return r.json()
+        except Exception:
+            return []

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

@@ -0,0 +1,118 @@
+from datetime import datetime
+
+import requests
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import SourceArgumentNotFound
+from waste_collection_schedule.service.AchieveForms import init_session, run_lookup
+
+TITLE = "Tendring District Council"
+DESCRIPTION = "Source for Tendring District Council, Essex, UK."
+URL = "https://www.tendringdc.gov.uk"
+TEST_CASES = {
+    "1 Queens Road, Clacton-on-Sea": {"uprn": "100090613962"},
+    "18 High Street, Manningtree": {"uprn": 100091459763},
+}
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": (
+        "Find your UPRN by visiting "
+        "https://tendring-self.achieveservice.com/en/service/Rubbish_and_recycling_collection_days "
+        "and searching for your address. Your UPRN can also be found at "
+        "https://www.findmyaddress.co.uk/."
+    )
+}
+PARAM_TRANSLATIONS = {
+    "en": {
+        "uprn": "UPRN",
+    }
+}
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "uprn": "Unique Property Reference Number (UPRN) for your address.",
+    }
+}
+COUNTRY = "uk"
+
+BASE_URL = "https://tendring-self.achieveservice.com"
+SERVICE_URL = f"{BASE_URL}/en/service/Rubbish_and_recycling_collection_days"
+AUTH_URL = f"{BASE_URL}/authapi/isauthenticated"
+API_URL = f"{BASE_URL}/apibroker/runLookup"
+HOSTNAME = "tendring-self.achieveservice.com"
+
+LOOKUP_COLLECTIONS = "6347acbadc425"
+
+ICON_MAP = {
+    "residual": Icons.GENERAL_WASTE,
+    "green": Icons.RECYCLING,
+    "red": Icons.RECYCLING,
+    "food": Icons.BIO_KITCHEN,
+    "garden": Icons.GARDEN,
+}
+
+# (api_field, waste_type_label, icon_key, conditional_field)
+# conditional_field: if set, skip this waste type if the field value is falsy
+COLLECTION_FIELDS = [
+    ("nextResidualCollection", "Residual waste", "residual", None),
+    ("nextGreenCollection", "Green recycling box", "green", None),
+    ("nextRedCollection", "Red recycling box", "red", None),
+    ("nextFoodCollection", "Food waste", "food", "eligibleFoodCollection"),
+    ("nextGardenCollection", "Garden waste", "garden", "activeGardenCollection"),
+]
+
+
+class Source:
+    def __init__(self, uprn: str | int):
+        self._uprn = str(uprn).strip()
+
+    def fetch(self) -> list[Collection]:
+        session = requests.Session()
+        sid = init_session(
+            session,
+            SERVICE_URL,
+            AUTH_URL,
+            HOSTNAME,
+        )
+        result = run_lookup(
+            session,
+            API_URL,
+            sid,
+            LOOKUP_COLLECTIONS,
+            {"Address": {"selectedUPRN": {"value": self._uprn}}},
+        )
+
+        rows = result.get("integration", {}).get("transformed", {}).get("rows_data", {})
+        row = rows.get("0", {}) if isinstance(rows, dict) else (rows[0] if rows else {})
+
+        if not row:
+            raise SourceArgumentNotFound("uprn", self._uprn)
+
+        entries = []
+        for date_field, waste_type, icon_key, condition_field in COLLECTION_FIELDS:
+            # Skip conditional waste types if the service is not active
+            # API returns string "True"/"False" for boolean fields
+            if condition_field and row.get(condition_field, "").lower() != "true":
+                continue
+
+            date_str = row.get(date_field, "").strip()
+            if not date_str:
+                continue
+            try:
+                # API returns dates as "DD/MM/YYYY HH:MM:SS"
+                collection_date = datetime.strptime(date_str[:10], "%d/%m/%Y").date()
+            except ValueError:
+                continue
+            # Skip sentinel date returned when service has no next collection
+            if collection_date.year < 2000:
+                continue
+
+            entries.append(
+                Collection(
+                    date=collection_date,
+                    t=waste_type,
+                    icon=ICON_MAP.get(icon_key),
+                )
+            )
+
+        if not entries:
+            raise SourceArgumentNotFound("uprn", self._uprn)
+
+        return entries