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

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

@@ -0,0 +1,308 @@
+from datetime import date as datetime_date
+from datetime import datetime as datetime_datetime
+from datetime import timedelta
+
+import requests
+from icalendar import Calendar
+from waste_collection_schedule import Collection, Icons
+from waste_collection_schedule.exceptions import SourceArgumentNotFoundWithSuggestions
+
+TITLE = "RITL"
+DESCRIPTION = (
+    "Source for Régie intermunicipale des Trois-Lacs (RITL) waste collection schedule."
+)
+URL = "https://ritl.ca/"
+COUNTRY = "ca"
+
+# Declare codeowners (the user can customize this)
+SOURCE_CODEOWNERS = ["@Jean-PascalComeau"]
+
+# List of all supported municipalities and their sectors
+MUNICIPALITIES: dict[str, dict[str, list[int]]] = {
+    "Ivry-sur-le-Lac": {
+        "all": [29, 30, 31],
+    },
+    "Lac-Supérieur": {
+        "Secteur 1": [20, 21, 22],
+        "Secteur 2": [39, 40, 41],
+    },
+    "Lantier": {
+        "all": [23, 24, 25],
+    },
+    "Montcalm": {
+        "Secteur 1": [69, 70, 71],
+    },
+    "Mont-Blanc": {
+        "Secteur Est": [15, 16, 38],
+        "Secteur Ouest": [35, 36, 37],
+    },
+    "Sainte-Agathe-des-Monts": {
+        "Secteur Centre-ville": [26, 27, 28],
+        "Secteur Nord": [42, 43, 44],
+        "Secteur Sud / Fatima": [45, 46, 47],
+    },
+    "Sainte-Lucie-des-Laurentides": {
+        "all": [12, 13, 14],
+    },
+    "Val-des-Lacs": {
+        "all": [32, 33, 34],
+    },
+    "Val-David": {
+        "Secteur 1": [53, 56, 76],
+        "Secteur 2": [54, 57, 59, 60],
+        "Secteur 3": [55, 58, 77],
+    },
+    "Val-Morin": {
+        "Val-Morin Est": [65, 66, 67],
+        "Val-Morin Ouest": [61, 62, 63],
+    },
+}
+
+TEST_CASES = {
+    "Lac-Supérieur Secteur 1": {
+        "municipality": "Lac-Supérieur",
+        "sector": "Secteur 1",
+    },
+    "Lac-Supérieur Secteur 2": {
+        "municipality": "Lac-Supérieur",
+        "sector": "Secteur 2",
+    },
+    "Ivry-sur-le-Lac": {
+        "municipality": "Ivry-sur-le-Lac",
+    },
+    "Val-David Secteur 2": {
+        "municipality": "Val-David",
+        "sector": "Secteur 2",
+    },
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "municipality": "Name of the municipality (e.g., Lac-Supérieur, Lantier, Sainte-Agathe-des-Monts...)",
+        "sector": "Sector name (only required for municipalities with sectors)",
+    },
+    "fr": {
+        "municipality": "Nom de la municipalité (ex: Lac-Supérieur, Lantier, Sainte-Agathe-des-Monts...)",
+        "sector": "Nom du secteur (requis uniquement pour les municipalités avec secteurs)",
+    },
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "municipality": "Municipality",
+        "sector": "Sector",
+    },
+    "fr": {
+        "municipality": "Municipalité",
+        "sector": "Secteur",
+    },
+}
+
+ICON_MAP = {
+    "Déchets": Icons.GENERAL_WASTE,
+    "Recyclage": Icons.RECYCLING,
+    "Compost": Icons.ORGANIC,
+}
+
+SECTOR_SYNONYMS = {
+    "1": "secteur-1",
+    "a": "secteur-1",
+    "secteur-a": "secteur-1",
+    "2": "secteur-2",
+    "b": "secteur-2",
+    "secteur-b": "secteur-2",
+    "3": "secteur-3",
+    "est": "secteur-est",
+    "ouest": "secteur-ouest",
+    "centre-ville": "secteur-centre-ville",
+    "nord": "secteur-nord",
+    "sud-fatima": "secteur-sud-/-fatima",
+    "sud": "secteur-sud-/-fatima",
+    "fatima": "secteur-sud-/-fatima",
+    "secteur-sud-fatima": "secteur-sud-/-fatima",
+    "est-val-morin": "val-morin-est",
+    "ouest-val-morin": "val-morin-ouest",
+}
+
+
+def normalize(s: str) -> str:
+    s = s.strip().lower()
+    for a, b in [
+        ("é", "e"),
+        ("è", "e"),
+        ("ê", "e"),
+        ("ë", "e"),
+        ("à", "a"),
+        ("â", "a"),
+        ("ô", "o"),
+        ("û", "u"),
+        ("ù", "u"),
+        ("ï", "i"),
+        ("î", "i"),
+        ("ç", "c"),
+    ]:
+        s = s.replace(a, b)
+    return s.replace(" ", "-").replace("_", "-")
+
+
+MUNICIPALITIES_NORMALIZED = {}
+for m_name, sectors in MUNICIPALITIES.items():
+    norm_m = normalize(m_name)
+    norm_sectors = {}
+    for s_name, ids in sectors.items():
+        norm_s = normalize(s_name)
+        norm_sectors[norm_s] = (s_name, ids)
+    MUNICIPALITIES_NORMALIZED[norm_m] = (m_name, norm_sectors)
+
+
+class Source:
+    def __init__(self, municipality: str, sector: str | None = None):
+        norm_m = normalize(municipality)
+        if norm_m not in MUNICIPALITIES_NORMALIZED:
+            raise SourceArgumentNotFoundWithSuggestions(
+                "municipality", municipality, MUNICIPALITIES.keys()
+            )
+
+        _m_display, norm_sectors = MUNICIPALITIES_NORMALIZED[norm_m]
+
+        if len(norm_sectors) == 1 and "all" in norm_sectors:
+            chosen_sector_norm = "all"
+        else:
+            if not sector:
+                raise SourceArgumentNotFoundWithSuggestions(
+                    "sector",
+                    sector,
+                    [name for name, _ in norm_sectors.values()],
+                )
+
+            norm_s = normalize(str(sector))
+            if norm_s in norm_sectors:
+                chosen_sector_norm = norm_s
+            else:
+                resolved = SECTOR_SYNONYMS.get(norm_s)
+                if resolved in norm_sectors:
+                    chosen_sector_norm = resolved
+                elif norm_m == "val-morin":
+                    if norm_s in ("est", "val-morin-est"):
+                        chosen_sector_norm = "val-morin-est"
+                    elif norm_s in ("ouest", "val-morin-ouest"):
+                        chosen_sector_norm = "val-morin-ouest"
+                    else:
+                        chosen_sector_norm = None
+                elif norm_m == "mont-blanc":
+                    if norm_s == "est":
+                        chosen_sector_norm = "secteur-est"
+                    elif norm_s == "ouest":
+                        chosen_sector_norm = "secteur-ouest"
+                    else:
+                        chosen_sector_norm = None
+                else:
+                    chosen_sector_norm = None
+
+            if not chosen_sector_norm or chosen_sector_norm not in norm_sectors:
+                raise SourceArgumentNotFoundWithSuggestions(
+                    "sector",
+                    sector,
+                    [name for name, _ in norm_sectors.values()],
+                )
+
+        _, self._cat_ids = norm_sectors[chosen_sector_norm]
+
+    def fetch(self) -> list[Collection]:
+        cat_ids_str = ",".join(str(cid) for cid in self._cat_ids)
+        params = {
+            "plugin": "all-in-one-event-calendar",
+            "controller": "ai1ec_exporter_controller",
+            "action": "export_events",
+            "ai1ec_cat_ids": cat_ids_str,
+        }
+        headers = {"User-Agent": "Mozilla/5.0"}
+        r = requests.get("https://ritl.ca/", params=params, headers=headers, timeout=30)
+        r.raise_for_status()
+
+        cal = Calendar.from_ical(r.text)
+
+        today = datetime_date.today()
+        start_date = today
+        end_date = today + timedelta(days=365)
+
+        entries = []
+
+        for component in cal.walk():
+            if component.name == "VEVENT":
+                summary = component.get("summary")
+                categories = component.get("categories")
+
+                # Combine categories and summary to identify waste type
+                check_strings = []
+                if summary:
+                    check_strings.append(str(summary))
+                if categories:
+                    if hasattr(categories, "cats"):
+                        check_strings.extend(str(c) for c in categories.cats)
+                    elif isinstance(categories, list):
+                        check_strings.extend(str(c) for c in categories)
+                    else:
+                        check_strings.append(str(categories))
+
+                check_text = " ".join(check_strings).lower()
+
+                if "compost" in check_text or "organique" in check_text:
+                    t = "Compost"
+                elif any(
+                    w in check_text
+                    for w in [
+                        "récupération",
+                        "recuperation",
+                        "recyclage",
+                        "recup",
+                        "bleu",
+                    ]
+                ):
+                    t = "Recyclage"
+                elif any(w in check_text for w in ["déchets", "dechets", "ordures"]):
+                    t = "Déchets"
+                else:
+                    t = str(summary) if summary else "Unknown"
+
+                # Extract dates
+                dates = []
+
+                # DTSTART
+                dtstart_prop = component.get("dtstart")
+                if dtstart_prop:
+                    dt = dtstart_prop.dt
+                    if isinstance(dt, datetime_datetime):
+                        dates.append(dt.date())
+                    elif isinstance(dt, datetime_date):
+                        dates.append(dt)
+
+                # RDATEs
+                rdate_prop = component.get("rdate")
+                if rdate_prop:
+                    if not isinstance(rdate_prop, list):
+                        rdate_prop = [rdate_prop]
+                    for r in rdate_prop:
+                        if hasattr(r, "dts"):
+                            for dt_item in r.dts:
+                                dt = dt_item.dt
+                                if isinstance(dt, datetime_datetime):
+                                    dates.append(dt.date())
+                                elif isinstance(dt, datetime_date):
+                                    dates.append(dt)
+                        elif hasattr(r, "dt"):
+                            dt = r.dt
+                            if isinstance(dt, datetime_datetime):
+                                dates.append(dt.date())
+                            elif isinstance(dt, datetime_date):
+                                dates.append(dt)
+
+                # Filter and add collections
+                icon = ICON_MAP.get(t)
+                seen_dates = set()
+                for d in dates:
+                    if start_date <= d <= end_date and d not in seen_dates:
+                        seen_dates.add(d)
+                        entries.append(Collection(date=d, t=t, icon=icon))
+
+        return entries

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

@@ -0,0 +1,208 @@
+import datetime
+
+import requests
+from bs4 import BeautifulSoup
+from waste_collection_schedule import Collection, Icons
+from waste_collection_schedule.exceptions import SourceArgumentNotFound
+
+TITLE = "RMR Lac-Saint-Jean (QC)"
+DESCRIPTION = "Source script for RMR Lac-Saint-Jean waste collection"
+URL = "https://calendrier.rmrlac.qc.ca"
+COUNTRY = "ca"
+
+TEST_CASES = {
+    "Métabetchouan-Lac-à-la-Croix (en)": {
+        "street_number_and_name": "1201 16e Chemin",
+        "locality": "Métabetchouan-Lac-à-la-Croix",
+        "province_or_state": "QC",
+        "language": "en",
+    },
+    "Métabetchouan-Lac-à-la-Croix (fr)": {
+        "street_number_and_name": "1201 16e Chemin",
+        "locality": "Métabetchouan-Lac-à-la-Croix",
+        "province_or_state": "QC",
+        "language": "fr",
+    },
+}
+
+ICON_MAP = {
+    "trash": Icons.GENERAL_WASTE,
+    "recycling": Icons.RECYCLING,
+    "compost": Icons.ORGANIC,
+}
+
+TYPE_MAP = {
+    "fr": {
+        "trash": "Déchets",
+        "recycling": "Recyclage",
+        "compost": "Matières organiques",
+    },
+    "en": {
+        "trash": "Garbage",
+        "recycling": "Recycling",
+        "compost": "Organic",
+    },
+}
+
+TYPE_KEYS = ["trash", "recycling", "compost"]
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "street_number_and_name": "Street number and name (e.g. '1201 16e Chemin')",
+        "locality": "Municipality name (e.g. 'Métabetchouan-Lac-à-la-Croix')",
+        "province_or_state": "Province or state code (default: QC)",
+        "language": "Language code for collection type names (default: en, supported: en, fr)",
+    },
+    "fr": {
+        "street_number_and_name": "Numéro et nom de rue (ex. '1201 16e Chemin')",
+        "locality": "Nom de la municipalité (ex. 'Métabetchouan-Lac-à-la-Croix')",
+        "province_or_state": "Province ou état (défaut: QC)",
+        "language": "Code de langue pour les types de collecte (défaut: fr, supporté: en, fr)",
+    },
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "street_number_and_name": "Street Number and Name",
+        "locality": "Municipality",
+        "province_or_state": "Province/State",
+        "language": "Language",
+    },
+    "fr": {
+        "street_number_and_name": "Numéro et nom de rue",
+        "locality": "Municipalité",
+        "province_or_state": "Province/État",
+        "language": "Langue",
+    },
+}
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": "Enter your street number and name along with your municipality.",
+    "fr": "Entrez votre numéro et nom de rue ainsi que votre municipalite.",
+}
+
+
+def _submit_address(address: str) -> dict:
+    headers = {
+        "User-Agent": (
+            "Mozilla/5.0 (Linux; Android 6.0; Nexus 6) "
+            "AppleWebKit/537.36 (KHTML, like Gecko) "
+            "Chrome/148.0.0.0 Safari/537.36"
+        ),
+        "Accept": "*/*",
+        "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8",
+        "X-Requested-With": "XMLHttpRequest",
+        "X-October-Request-Flash": "1",
+        "X-October-Request-Handler": "wasteCollectionComposanteSearch0::onSubmitAddress",
+        "X-October-Request-Partials": (
+            "wasteCollectionComposanteSearch0::not-found&"
+            "wasteCollectionComposanteSearch0::calendar"
+        ),
+        "sec-ch-ua": '"Chromium";v="148"',
+        "sec-ch-ua-platform": '"Linux"',
+        "sec-fetch-mode": "cors",
+        "sec-fetch-site": "same-origin",
+    }
+
+    body = (
+        f"address={requests.utils.quote(address)}&localisation_lat=&localisation_lng="
+    )
+
+    r = requests.post(
+        f"{URL}/calendrier-de-collectes",
+        headers=headers,
+        data=body.encode("utf-8"),
+        params={
+            "url": "/calendrier-de-collectes",
+            "component": "wasteCollectionComposanteSearch0",
+        },
+    )
+    r.raise_for_status()
+    return r.json()
+
+
+def _parse_entries(data: dict, lang: str = "en") -> list[Collection]:
+    entries: list[Collection] = []
+
+    not_found = data.get("wasteCollectionComposanteSearch0::not-found", "")
+    if not_found and not_found.strip():
+        raise SourceArgumentNotFound(
+            argument="street_number_and_name",
+            value="",
+            message_addition="Address not found by RMR calendar system",
+        )
+
+    calendar_html = data.get("wasteCollectionComposanteSearch0::calendar", "")
+    if not calendar_html:
+        raise SourceArgumentNotFound(
+            argument="street_number_and_name",
+            value="",
+            message_addition="No calendar returned for address",
+        )
+
+    soup = BeautifulSoup(calendar_html, "html.parser")
+    calendar = soup.find("div", {"class": "collection-calendar"})
+    if not calendar:
+        raise SourceArgumentNotFound(
+            argument="street_number_and_name",
+            value="",
+            message_addition="Calendar HTML not found",
+        )
+
+    fc_types = TYPE_MAP.get(lang, TYPE_MAP["en"])
+
+    icon_types = [
+        ("trash", "data-dates-trash"),
+        ("recycling", "data-dates-recycling"),
+        ("compost", "data-dates-compost"),
+    ]
+
+    for icon_key, attr in icon_types:
+        dates_raw = calendar.get(attr, "").strip()
+        if not dates_raw:
+            continue
+
+        fc_type = fc_types.get(icon_key)
+        fc_icon = ICON_MAP.get(icon_key)
+        if not fc_type:
+            continue
+
+        for date_str in dates_raw.split(","):
+            date_str = date_str.strip()
+            if not date_str:
+                continue
+
+            try:
+                dt = datetime.datetime.strptime(date_str, "%Y-%m-%d")
+            except ValueError:
+                continue
+
+            entries.append(Collection(date=dt.date(), t=fc_type, icon=fc_icon))
+
+    return entries
+
+
+class Source:
+    def __init__(
+        self,
+        street_number_and_name: str,
+        locality: str,
+        province_or_state: str = "QC",
+        language: str = "en",
+    ):
+        self._street_number_and_name = street_number_and_name
+        self._locality = locality
+        self._province_or_state = province_or_state
+        self._language = language
+
+    def fetch(self) -> list[Collection]:
+        address = f"{self._street_number_and_name}, {self._locality}"
+        data = _submit_address(address)
+        entries = _parse_entries(data, lang=self._language)
+        if not entries:
+            raise SourceArgumentNotFound(
+                argument="street_number_and_name",
+                value=self._street_number_and_name,
+                message_addition="Calendar found but no collections parsed",
+            )
+        return entries

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

@@ -0,0 +1,136 @@
+from datetime import datetime, timedelta
+from time import time_ns
+
+import requests
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+
+TITLE = "Rochdale Borough Council"
+DESCRIPTION = "Source for Rochdale Borough Council, UK."
+URL = "https://www.rochdale.gov.uk"
+TEST_CASES = {
+    "Test_001": {"uprn": "10094359340"},
+    "Test_002": {"uprn": "23030658"},
+    "Test_003": {"uprn": "23011384"},
+    "Test_004": {"uprn": "23045922"},
+}
+
+ICON_MAP = {
+    "General Waste": Icons.GENERAL_WASTE,
+    "Paper and Cardboard": Icons.PAPER,
+    "Glass and Bottles": Icons.GLASS,
+    "Food and Garden": Icons.BIO_KITCHEN,
+}
+
+
+class Source:
+    def __init__(self, uprn: str | int):
+        self._uprn = str(uprn)
+        self._base_url = "https://rochdale-self.achieveservice.com"
+
+    def fetch(self):
+        s = requests.Session()
+
+        headers = {
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
+            "Accept": "application/json, text/javascript, */*; q=0.01",
+            "X-Requested-With": "XMLHttpRequest",
+            "Referer": f"{self._base_url}/service/Bins___view_your_waste_collection_calendar",
+        }
+
+        # 1. Initialize session and get SID
+        ts = time_ns() // 1_000_000
+        sGet = s.get(
+            f"{self._base_url}/apibroker/domain/rochdale-self.achieveservice.com?_={ts}",
+            headers=headers,
+            timeout=30,
+        )
+        sGet.raise_for_status()
+
+        auth_url = f"{self._base_url}/authapi/isauthenticated?uri=https%3A%2F%2Frochdale-self.achieveservice.com%2Fservice%2FBins___view_your_waste_collection_calendar&hostname=rochdale-self.achieveservice.com&withCredentials=true"
+        sidGet = s.get(auth_url, headers=headers, timeout=30)
+        sidGet.raise_for_status()
+
+        sid = sidGet.json().get("auth-session")
+
+        if not sid:
+            raise Exception("Rochdale API: Failed to obtain a session ID.")
+
+        # 2. STEP 1: Fetch the required Bartec Token using the UPRN
+        # Lookup 6846c784a46b5 returns the server-side {bartecToken}
+        payload_token = {
+            "formId": "AF-Form-d7812e2d-2876-47c2-9802-8a4a3b1a2264",
+            "formValues": {"Location details": {"propertyUPRN": {"value": self._uprn}}},
+        }
+
+        ts = time_ns() // 1_000_000
+        token_url = f"{self._base_url}/apibroker/runLookup?id=6846c784a46b5&repeat_against=&noRetry=false&getOnlyTokens=undefined&log_id=&app_name=AF-Renderer::Self&_={ts}&sid={sid}"
+        r_token = s.post(token_url, headers=headers, json=payload_token, timeout=30)
+        r_token.raise_for_status()
+
+        # Fetch the Bartec Token
+        try:
+            bartec_token = r_token.json()["integration"]["transformed"]["rows_data"][
+                "0"
+            ]["bartecToken"]
+        except KeyError:
+            raise ValueError(
+                f"Rochdale API: Failed to retrieve bartecToken for UPRN {self._uprn}."
+            ) from None
+
+        # 3. STEP 2: Fetch the Calendar
+        # Lookup 68b58a1364572 returns the annual calendar using the token and date bounds
+        now = datetime.now()
+        min_date = now.strftime("%Y-%m-%dT00:00:00")
+        max_date = (now + timedelta(days=365)).strftime("%Y-%m-%dT23:59:59")
+
+        payload_data = {
+            "formId": "AF-Form-d7812e2d-2876-47c2-9802-8a4a3b1a2264",
+            "formValues": {
+                "Location details": {
+                    "propertyUPRN": {"value": self._uprn},
+                    "bartecToken": {"value": bartec_token},
+                    "dateAnnualMinimum": {"value": min_date},
+                    "dateAnnualMaximum": {"value": max_date},
+                }
+            },
+        }
+
+        ts = time_ns() // 1_000_000
+        api_url = f"{self._base_url}/apibroker/runLookup?id=68b58a1364572&repeat_against=&noRetry=true&getOnlyTokens=undefined&log_id=&app_name=AF-Renderer::Self&_={ts}&sid={sid}"
+        r_data = s.post(api_url, headers=headers, json=payload_data, timeout=30)
+        r_data.raise_for_status()
+        data = r_data.json()
+
+        # Fetch the Calendar
+        rows_data = (
+            data.get("integration", {}).get("transformed", {}).get("rows_data", {})
+        )
+        row = rows_data.get("0")
+
+        if not row or "bartecAnnualBin1Type" not in row:
+            raise ValueError(
+                "Rochdale API: Failed to fetch calendar data or missing required fields."
+            )
+
+        entries = []
+        for i in range(1, 17):
+            bin_type = row.get(f"bartecAnnualBin{i}Type")
+            day = row.get(f"bartecAnnualBin{i}Day")
+            month = row.get(f"bartecAnnualBin{i}Month")
+
+            if bin_type and day and month:
+                try:
+                    # Construct date using current year
+                    date_str = f"{day} {month} {now.year}"
+                    date_obj = datetime.strptime(date_str, "%d %B %Y").date()
+
+                    # Handle year rollover if the date parsed is older than ~1 month ago
+                    if date_obj < now.date() - timedelta(days=31):
+                        date_obj = date_obj.replace(year=now.year + 1)
+
+                    icon = ICON_MAP.get(bin_type, "mdi:trash-can")
+                    entries.append(Collection(date=date_obj, t=bin_type, icon=icon))
+                except KeyError:
+                    continue
+
+        return entries