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

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

@@ -0,0 +1,77 @@
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.service.OpenCities import (
+    OpenCitiesClient,
+    OpenCitiesConfig,
+)
+
+TITLE = "Mackay Regional Council"
+DESCRIPTION = "Source for Mackay Regional Council rubbish collection."
+URL = "https://www.mackay.qld.gov.au"
+COUNTRY = "au"
+TEST_CASES = {
+    "Mackay (Monday)": {"address": "77 Wood Street Mackay"},
+    "West Mackay (Thursday)": {"address": "115 Nebo Road West Mackay"},
+    "Sarina Beach (Wednesday)": {"address": "891 Sarina Beach Road Sarina Beach"},
+    "Alligator Creek (Tuesday)": {"address": "184 Hay Point Road Alligator Creek"},
+}
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": (
+        "Enter your street address as used on the council's rubbish and bins page "
+        "(https://www.mackay.qld.gov.au/residents/services/waste), for example "
+        "'77 Wood Street Mackay'."
+    )
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "address": "Street Address",
+    },
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "address": (
+            "Your street address, e.g. '77 Wood Street Mackay'. The closest match "
+            "from the council's address search is used."
+        ),
+    },
+}
+
+# Mackay sits behind Akamai, which scores the TLS/HTTP fingerprint as well as
+# the headers: plain `requests` carrying a browser User-Agent is served a 403
+# "Access Denied" page. curl_cffi's Chrome impersonation passes.
+HEADERS = {
+    "accept": "application/json, text/javascript, */*; q=0.01",
+    "referer": URL + "/residents/services/waste",
+    "user-agent": (
+        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
+        "AppleWebKit/537.36 (KHTML, like Gecko) "
+        "Chrome/124.0.0.0 Safari/537.36"
+    ),
+    "x-requested-with": "XMLHttpRequest",
+}
+
+ICON_MAP = {
+    "general waste": Icons.GENERAL_WASTE,
+    "recycling": Icons.RECYCLING,
+    "green waste": Icons.ORGANIC,
+}
+
+_CONFIG = OpenCitiesConfig(
+    domain=URL,
+    argument_name="address",
+    max_results=1,
+    headers=HEADERS,
+    use_curl_cffi=True,
+    icon_keywords=ICON_MAP,
+)
+
+
+class Source:
+    def __init__(self, address: str):
+        self._address = " ".join(address.split())
+        self._client = OpenCitiesClient(_CONFIG)
+
+    def fetch(self) -> list[Collection]:
+        return self._client.fetch(address=self._address)

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

@@ -0,0 +1,127 @@
+import re
+
+import requests
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import (
+    SourceArgumentNotFound,
+    SourceArgumentNotFoundWithSuggestions,
+    SourceArgumentRequired,
+)
+from waste_collection_schedule.service.ICS import ICS
+
+TITLE = "Städtischer Abfallwirtschaftsbetrieb Magdeburg"
+DESCRIPTION = "Source for SAB Magdeburg waste collection schedule."
+URL = "https://www.magdeburg.de"
+COUNTRY = "de"
+
+ICS_URL = "https://st-magdeburg.server.smart-village.app/waste_calendar/export"
+STREET_LIST_URL = "https://sab.ssl.metageneric.de/app/sab_i_tp/index.php"
+
+TEST_CASES = {
+    "Halberstädter Chaussee 66": {"street": "Halberstädter Chaussee 66"},
+    "Agnetenstraße 10": {"street": "Agnetenstraße 10"},
+}
+
+EXTRA_INFO = [
+    {
+        "title": "SAB Magdeburg Abfuhrkalender",
+        "url": "https://sab.ssl.metageneric.de/app/sab_i_tp/index.php",
+        "country": "de",
+    },
+]
+
+ICON_MAP = {
+    "Restabfall": Icons.GENERAL_WASTE,
+    "Altpapier": Icons.PAPER,
+    "Gelbe Tonne": Icons.PLASTIC_PACKAGING,
+    "Bioabfall": Icons.BIO_KITCHEN,
+}
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": "Enter your street name and house number as shown on the "
+    "SAB Magdeburg website (e.g. 'Halberstädter Chaussee 66'). "
+    "Search at https://sab.ssl.metageneric.de/app/sab_i_tp/index.php",
+    "de": "Geben Sie Ihren Straßennamen und die Hausnummer ein, wie auf der "
+    "SAB Magdeburg Webseite angezeigt (z.B. 'Halberstädter Chaussee 66'). "
+    "Suchen Sie unter https://sab.ssl.metageneric.de/app/sab_i_tp/index.php",
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "street": "Street and house number",
+    },
+    "de": {
+        "street": "Straße und Hausnummer",
+    },
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "street": "Street name and house number (e.g. 'Halberstädter Chaussee 66')",
+    },
+    "de": {
+        "street": "Straßenname und Hausnummer (z.B. 'Halberstädter Chaussee 66')",
+    },
+}
+
+PREFIX = "Abfallkalender: "
+
+
+class Source:
+    def __init__(self, street: str):
+        if not street:
+            raise SourceArgumentRequired(
+                "street", "A street name and house number is required"
+            )
+        self._street = street.strip()
+
+    def fetch(self) -> list[Collection]:
+        r = requests.get(
+            ICS_URL,
+            params={"street": self._street, "city": "Magdeburg"},
+            timeout=30,
+        )
+        r.raise_for_status()
+
+        # Remove DTEND lines — they use datetime format while DTSTART uses date-only,
+        # which causes icalevents comparison errors. DTEND is not needed for parsing.
+        ics_data = re.sub(r"DTEND:[^\r\n]+\r?\n", "", r.text)
+
+        ics = ICS()
+        dates = ics.convert(ics_data)
+
+        if not dates:
+            suggestions = self._get_street_suggestions()
+            if suggestions:
+                raise SourceArgumentNotFoundWithSuggestions(
+                    "street", self._street, suggestions
+                )
+            raise SourceArgumentNotFound("street", self._street)
+
+        entries = []
+        for dt, waste_type in dates:
+            if waste_type.startswith(PREFIX):
+                waste_type = waste_type[len(PREFIX) :]
+
+            icon = None
+            for key, value in ICON_MAP.items():
+                if key in waste_type:
+                    icon = value
+                    break
+
+            entries.append(Collection(date=dt, t=waste_type, icon=icon))
+
+        return entries
+
+    def _get_street_suggestions(self) -> list[str]:
+        try:
+            r = requests.get(STREET_LIST_URL, timeout=15)
+            r.raise_for_status()
+        except Exception:
+            return []
+
+        import re
+
+        streets = re.findall(r'option value="([^"]+)"', r.text)
+        query = self._street.split()[0].lower() if self._street else ""
+        return [s for s in streets if query in s.lower()][:20]

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

@@ -0,0 +1,79 @@
+from datetime import datetime
+
+import requests
+from waste_collection_schedule import Collection, Icons
+from waste_collection_schedule.service.ICS import ICS
+
+TITLE = "mags Mönchengladbacher Abfall-, Grün- und Straßenbetriebe AöR"
+DESCRIPTION = "Source for Stadt Mönchengladbach"
+URL = "https://mags.de"
+COUNTRY = "de"
+TEST_CASES = {
+    "Schlossacker 43": {"street": "Schlossacker", "number": 43, "turnus": 2},
+    "Azaleenweg 24": {"street": "Azaleenweg", "number": 24, "turnus": 2},
+}
+
+API_URL = "https://mags.de/ics/icscal.php"
+
+ICON_MAP = {
+    "Restmüll (Grau)": Icons.GENERAL_WASTE,
+    "Bioabfall (Braun)": Icons.BIO_KITCHEN,
+    "Verpackungen (Gelb)": Icons.RECYCLING,
+    "Altpapier (Blau)": Icons.PAPER,
+    "Papiermobil": Icons.PAPER,
+    "Grünschnitt": Icons.GARDEN,
+    "Elektrokleingeräte-Sammlung": Icons.ELECTRONICS,
+}
+
+PARAM_TRANSLATIONS = {
+    "de": {
+        "street": "Straße",
+        "number": "Hausnummer",
+        "turnus": "Turnus",
+    },
+}
+
+
+class Source:
+    def __init__(self, street, number, turnus=2):
+        self._ics = ICS(split_at="/")
+        self._street = street
+        self._number = number
+        self._turnus = turnus
+
+    def fetch(self):
+        # fetch the ical
+        now = datetime.now()
+        r = requests.get(
+            API_URL,
+            params={
+                "building_number": self._number,
+                "building_number_addition": "",
+                "street_name": self._street,
+                "start_month": 1,
+                "end_month": 12,
+                "start_year": now.year,
+                "end_year": now.year,
+                "turnus": self._turnus,
+            },
+        )
+        r.raise_for_status()
+
+        # replace non-ascii character in UID, otherwise ICS converter will fail
+        ics = ""
+        for line in r.text.splitlines():
+            if line.startswith("UID"):
+                line = line.replace("ä", "ae")
+                line = line.replace("ö", "oe")
+                line = line.replace("ü", "ue")
+            ics += line.replace("// GEM", "")
+            ics += "\n"
+
+        dates = self._ics.convert(ics)
+
+        entries = []
+
+        for d in dates:
+            entries.append(Collection(date=d[0], t=d[1], icon=ICON_MAP.get(d[1])))
+
+        return entries

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

@@ -0,0 +1,136 @@
+import json
+from datetime import datetime
+from time import time_ns
+
+import requests
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+
+TITLE = "Maidstone Borough Council"
+DESCRIPTION = "Source for maidstone.gov.uk services for Maidstone Borough Council."
+URL = "https://maidstone.gov.uk"
+TEST_CASES = {
+    "Test_001": {"uprn": "10022892379"},
+    "Test_002": {"uprn": 10014307164},
+    "Test_003": {"uprn": "200003674881"},
+}
+HEADERS = {
+    "user-agent": "Mozilla/5.0",
+}
+
+ICON_MAP = {
+    "clinical": Icons.HAZARDOUS,
+    "bulky": Icons.BULKY,
+    "residual": Icons.GENERAL_WASTE,
+    "recycling": Icons.RECYCLING,
+    "garden": Icons.GARDEN,
+    "food": Icons.BIO_KITCHEN,
+}
+
+
+class Source:
+    def __init__(self, uprn):
+        self._uprn = str(uprn).strip()
+
+    def fetch(self):
+        s = requests.Session()
+
+        # Set up session
+        timestamp = time_ns() // 1_000_000
+        s.get(
+            f"https://my.maidstone.gov.uk/apibroker/domain/my.maidstone.gov.uk?_={timestamp}&sid=979631f89458fc974cc2aa69ebbd7996",
+            headers=HEADERS,
+        )
+
+        # Get Session ID
+        timestamp = time_ns() // 1_000_000
+        sid_request = s.get(
+            "https://my.maidstone.gov.uk/authapi/isauthenticated?uri=https%3A%2F%2Fmy.maidstone.gov.uk%2Fservice%2FFind-your-bin-day&hostname=my.maidstone.gov.uk&withCredentials=true",
+            headers=HEADERS,
+        )
+        sid_data = sid_request.json()
+        sid = sid_data["auth-session"]
+
+        # Retrieve Schedule
+        timestamp = time_ns() // 1_000_000
+        payload = {
+            "formValues": {
+                "Lookup": {
+                    "AddressData": {"value": self._uprn},
+                    "AddressUPRN": {"value": self._uprn},
+                }
+            }
+        }
+
+        schedule_request = s.post(
+            f"https://my.maidstone.gov.uk/apibroker/runLookup?id=654b7b6478deb&repeat_against=&noRetry=true&getOnlyTokens=undefined&log_id=&app_name=AF-Renderer::Self&_={timestamp}&sid={sid}",
+            headers=HEADERS,
+            json=payload,
+        )
+
+        try:
+            rowdata = json.loads(schedule_request.content)["integration"][
+                "transformed"
+            ]["rows_data"][self._uprn]
+        except KeyError:
+            return []
+
+        entries = []
+        collections = {}
+
+        for key, value in rowdata.items():
+            # Extract the bin type prefix (e.g., "DomesticResidual")
+            collection_key = key.split("_")[0]
+
+            # Check if this service is active for the property
+            # The API returns keys like "DomesticResidual_Active": "Y" or "N"
+            active_key = f"{collection_key}_Active"
+            if rowdata.get(active_key) == "N":
+                continue
+
+            # Parse Dates
+            # Logic updated to exclude "Default" and "Original" dates to prevent duplicates during holiday rescheduling
+            if (
+                key.endswith("_NextCollectionDateMM")
+                and "Default" not in key
+                and "Original" not in key
+                and value != ""
+            ):
+                if collection_key not in collections:
+                    collections[collection_key] = {"dates": []}
+
+                try:
+                    collections[collection_key]["dates"].append(
+                        datetime.strptime(value, "%d/%m/%Y").date()
+                    )
+                except ValueError:
+                    pass
+
+            # Parse Description
+            if "_Description" in key and "Default" not in key:
+                if collection_key not in collections:
+                    collections[collection_key] = {"dates": []}
+                collections[collection_key]["description"] = value
+
+        for key, collection in collections.items():
+            bin_name = collection.get("description") or key
+
+            # Map icons
+            clean_name = (
+                bin_name.lower()
+                .replace("domestic ", "")
+                .replace("communal ", "")
+                .replace("waste", "")
+                .strip()
+            )
+            icon = ICON_MAP.get(clean_name, "mdi:trash-can")
+
+            for collectionDate in set(collection["dates"]):
+                entries.append(
+                    Collection(
+                        t=bin_name,
+                        date=collectionDate,
+                        icon=icon,
+                    )
+                )
+
+        return entries

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

@@ -0,0 +1,232 @@
+import re
+from datetime import date, datetime, timedelta
+
+import requests
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import SourceArgumentNotFound
+
+TITLE = "Maitland City Council"
+DESCRIPTION = "Source for Maitland City Council (NSW) waste collection."
+URL = "https://www.maitland.nsw.gov.au"
+COUNTRY = "au"
+
+TEST_CASES = {
+    "1 High Street, Maitland": {"address": "1 High Street, Maitland"},
+    "2 Acer Terrace, Thornton": {"address": "2 Acer Terrace, Thornton"},
+    "1 Adele Crescent, Ashtonfield": {"address": "1 Adele Crescent, Ashtonfield"},
+    "14 Mistfly Street Chisholm NSW 2322": {
+        "address": "14 Mistfly Street Chisholm NSW 2322"
+    },
+}
+
+ICON_MAP = {
+    "General Waste": Icons.GENERAL_WASTE,
+    "Recycling": Icons.RECYCLING,
+    "Green Waste": Icons.GARDEN,
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "address": "Street address within the Maitland City Council area",
+    },
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "address": "Street Address",
+    },
+}
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": "Visit the Maitland City Council bin collection page, search for your address, and use the street address as shown.",
+}
+
+MAITLAND_API_BASE = "https://integration.maitland.nsw.gov.au/api"
+HRR_SEARCH_URL = "https://www5.wastedge.com/publicaddresssearch_549/_search"
+HRR_COLLECTION_URL = (
+    "https://www5.wastedge.com/web/wsrms/we_resportal/HRRCollectionval.p"
+)
+HRR_HEADERS = {
+    "Content-Type": "application/json",
+    "Authorization": "Basic YWRkcmVzc3NlYXJjaDphZGRyZXNzc2VhcmNo",
+    "User-Agent": (
+        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 "
+        "(KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
+    ),
+    "Accept": "application/json, text/plain, */*",
+    "Accept-Language": "en-US,en;q=0.9",
+    "Origin": "https://hrr.com.au",
+    "Referer": "https://hrr.com.au/",
+    "Sec-Fetch-Dest": "empty",
+    "Sec-Fetch-Mode": "cors",
+    "Sec-Fetch-Site": "cross-site",
+}
+
+HEADERS = {
+    "User-Agent": (
+        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 "
+        "(KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
+    ),
+    "Accept": "application/json, text/plain, */*",
+}
+
+DATE_FORMAT = "%A, %d %B %Y"
+
+
+class Source:
+    def __init__(self, address: str):
+        self._address = address.strip()
+
+    def fetch(self) -> list[Collection]:
+        # Step 1: Search Maitland API for the property
+        maitland_properties = self._search_maitland(self._address)
+        if not maitland_properties:
+            raise SourceArgumentNotFound("address", self._address)
+
+        # Step 2: Select the best property (first result is usually best)
+        property_data = maitland_properties[0]
+        property_id = property_data.get("property_id")
+        if not property_id:
+            raise SourceArgumentNotFound(
+                "address",
+                self._address,
+            )
+        full_address = property_data.get("full_address", self._address)
+
+        # Step 3: Get collection day from Maitland API
+        collection_info = self._get_bin_collection(property_id)
+        next_collection_str = collection_info.get("nextCollection", "")
+        next_collection_date = datetime.strptime(
+            next_collection_str, DATE_FORMAT
+        ).date()
+
+        # Step 4: Search HRR API for recycling schedule
+        hrr_cust_number = self._search_hrr(full_address)
+        if hrr_cust_number is None:
+            raise SourceArgumentNotFound(
+                "address",
+                self._address,
+            )
+
+        # Step 5: Get next recycling date from HRR
+        hrr_date = self._get_hrr_collection_date(hrr_cust_number)
+
+        # Step 6: Generate entries
+        entries: list[Collection] = []
+
+        # Red bin (General Waste) - weekly
+        entries.extend(self._generate_weekly(next_collection_date, "General Waste"))
+
+        # Green bin (Organics) - weekly
+        entries.extend(self._generate_weekly(next_collection_date, "Green Waste"))
+
+        # Yellow bin (Recycling) - fortnightly from HRR anchor date
+        entries.extend(self._generate_fortnightly(hrr_date, "Recycling"))
+
+        return entries
+
+    @staticmethod
+    def _search_maitland(address: str) -> list[dict]:
+        url = f"{MAITLAND_API_BASE}/wastetrack/search-bin"
+        # The API rejects queries that include the state "NSW" (case-insensitive).
+        # Strip it out so "14 Mistfly Street Chisholm NSW 2322"
+        # becomes "14 Mistfly Street Chisholm 2322".
+        cleaned = re.sub(r"\s+NSW", "", address, flags=re.IGNORECASE).strip()
+        params = {"addressText": cleaned}
+        response = requests.get(url, params=params, headers=HEADERS, timeout=30)
+        response.raise_for_status()
+        data = response.json()
+        return data if isinstance(data, list) else []
+
+    @staticmethod
+    def _get_bin_collection(property_id: str) -> dict:
+        url = f"{MAITLAND_API_BASE}/wastetrack/bin-collection"
+        params = {"propertyId": property_id}
+        response = requests.get(url, params=params, headers=HEADERS, timeout=30)
+        response.raise_for_status()
+        return response.json()
+
+    @staticmethod
+    def _search_hrr(full_address: str) -> str | None:
+        # HRR expects the address without the trailing 4-digit postcode.
+        # Only strip the last token if it looks like a postcode.
+        parts = full_address.rsplit(" ", 1)
+        if len(parts) == 2 and re.fullmatch(r"\d{4}", parts[1]):
+            query = parts[0].lower()
+        else:
+            query = full_address.lower()
+        post_data = {
+            "query": {
+                "bool": {
+                    "should": {"match_phrase_prefix": {"address": query}},
+                    "must_not": {"match_phrase": {"st": "T"}},
+                }
+            }
+        }
+        response = requests.post(
+            HRR_SEARCH_URL, json=post_data, headers=HRR_HEADERS, timeout=30
+        )
+        response.raise_for_status()
+        data = response.json()
+        hits = data.get("hits", {}).get("hits", [])
+        if not hits:
+            return None
+        return str(hits[0]["_source"]["cust_number"])
+
+    @staticmethod
+    def _get_hrr_collection_date(cust_number: str) -> date:
+        params = {
+            "ID": "e347cd965f6a92ef2ccd61ded7c597b9",
+            "custNo": cust_number,
+        }
+        response = requests.get(
+            HRR_COLLECTION_URL, params=params, headers=HRR_HEADERS, timeout=30
+        )
+        response.raise_for_status()
+        data = response.json()
+
+        if data.get("message") == "WARNING":
+            raise SourceArgumentNotFound(
+                "address",
+                f"HRR returned no collection data for customer {cust_number}",
+            )
+        if data.get("message") == "ERROR":
+            raise RuntimeError(f"HRR API returned an error for customer {cust_number}")
+
+        records = data.get("records", [])
+        if not records:
+            raise SourceArgumentNotFound(
+                "address",
+                f"HRR returned no collection records for customer {cust_number}",
+            )
+
+        service_date = records[0].get("ServiceDate", "")
+        return date.fromisoformat(service_date)
+
+    @staticmethod
+    def _generate_weekly(start_date: date, waste_type: str) -> list[Collection]:
+        icon = ICON_MAP.get(waste_type)
+        return [
+            Collection(
+                date=start_date + timedelta(weeks=i),
+                t=waste_type,
+                icon=icon,
+            )
+            for i in range(26)
+        ]
+
+    @staticmethod
+    def _generate_fortnightly(start_date: date, waste_type: str) -> list[Collection]:
+        icon = ICON_MAP.get(waste_type)
+        today = date.today()
+        # Ensure start_date is not in the past
+        while start_date < today:
+            start_date += timedelta(days=14)
+        return [
+            Collection(
+                date=start_date + timedelta(days=i * 14),
+                t=waste_type,
+                icon=icon,
+            )
+            for i in range(13)
+        ]