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

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

@@ -0,0 +1,70 @@
+# Credit where it's due:
+# This is predominantly a refactoring of the Bristol City Council script from the UKBinCollectionData repo
+# https://github.com/robbrad/UKBinCollectionData
+
+from datetime import datetime
+
+import requests
+from bs4 import BeautifulSoup
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+
+TITLE = "Shropshire Council"
+DESCRIPTION = "Source for Shropshire Council."
+URL = "https://shropshire.gov.uk"
+TEST_CASES = {
+    "100070056686": {"uprn": 100070056686},
+    "200000119191": {"uprn": "200000119191"},
+}
+
+
+ICON_MAP = {
+    "General": Icons.GENERAL_WASTE,
+    "Garden": Icons.GARDEN,
+    "Recycling": Icons.RECYCLING,
+}
+
+
+API_URL = "https://bins.shropshire.gov.uk/property/{uprn}"
+
+
+class Source:
+    def __init__(self, uprn: str | int):
+        self._uprn: str | int = uprn
+
+    def fetch(self):
+        page = requests.get(API_URL.format(uprn=self._uprn))
+        page.raise_for_status()
+
+        # Make a BS4 object
+        soup = BeautifulSoup(page.text, features="html.parser")
+        soup.prettify()
+
+        # Form a JSON wrapper
+        entries = []
+
+        # Find section with bins in
+        sections = (
+            soup.find("div", {"class": "container results-table-wrapper"})
+            .find("tbody")
+            .find_all("tr")
+        )
+
+        # For each bin section, get the text and the list elements
+        for item in sections:
+            words = item.find_next("a").text.split()[:-1]
+            bin_type = " ".join(words).capitalize()
+            date = (
+                item.find("td", {"class": "next-service"})
+                .find_next("span")
+                .next_sibling.strip()
+            )
+            next_collection = datetime.strptime(date, "%d/%m/%Y").date()
+            entries.append(
+                Collection(
+                    t=bin_type,
+                    date=next_collection,
+                    icon=ICON_MAP.get(bin_type.split(" ")[0].lower()),
+                )
+            )
+
+        return entries

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

@@ -0,0 +1,138 @@
+import datetime
+from typing import TypedDict
+
+import requests
+from waste_collection_schedule import Collection, Icons
+from waste_collection_schedule.exceptions import SourceArgumentNotFoundWithSuggestions
+
+TITLE = "SICA"
+DESCRIPTION = "Source script for sica.lu served municipalities"
+URL = "https://sica.lu"
+TEST_CASES = {
+    "Habscht": {"municipality": "habscht"},
+    "Steinfort": {"municipality": "Steinfort"},
+}
+
+BASE_URL = "https://dashboard.sicaapp.lu"
+API_URL = f"{BASE_URL}/api/api/app"
+HEADERS = {"User-Agent": "SicaAPP", "Accept": "application/json"}
+ICON_MAP = {
+    "Residual waste": Icons.GENERAL_WASTE,
+    "Valorlux - blue bag": Icons.RECYCLING,
+    "Organic waste": Icons.ORGANIC,
+    "Glass": Icons.GLASS,
+    "Paper /Carton": Icons.PAPER,
+    "Scrap and electrical appliances": Icons.METAL,
+    "Clothing and Shoes": Icons.TEXTILE,
+    "Hedges, Shrubs and Trees": Icons.GARDEN,
+    "Bulky waste": Icons.BULKY,
+}
+
+
+class LanguageDict(TypedDict):
+    en: str
+    fr: str
+    de: str
+    lb: str
+
+
+class MunicipalityData(TypedDict):
+    id: int
+    name: LanguageDict
+    feeData: list[dict[str, LanguageDict]]
+    isDisabled: bool
+    parentCommunity_id: int | None
+    children: list["MunicipalityData"]
+
+
+class MunicipalitiesResult(TypedDict):
+    data: list[MunicipalityData]
+
+
+class PickupType(TypedDict):
+    id: int
+    name: LanguageDict
+    description: str | None
+    collectionInfo: LanguageDict
+    color: str
+    isBookable: bool
+    isDisabled: bool
+    icon_id: int
+    created_at: str
+    updated_at: str
+    icon: dict[str, str | None | int]
+
+
+class CollectionEntry(TypedDict):
+    id: int
+    date: str
+    note: None | str
+    description: LanguageDict | None
+    isDisabled: bool
+    status: str
+    community_id: int
+    comunity_id: int
+    creator_id: int
+    pickupType_id: int
+    created_at: str
+    updated_at: str
+    pickup_type: PickupType
+
+
+class Source:
+    def __init__(self, municipality: str) -> None:
+        self._municipality = municipality.lower()
+        self._municipality_id: int | None = None
+
+    @staticmethod
+    def _fetch_json(
+        url: str, headers: dict
+    ) -> MunicipalitiesResult | list[CollectionEntry]:
+        r = requests.get(url, headers)
+        if r.status_code != 200:
+            r.raise_for_status()
+        try:
+            data = r.json()
+        except ValueError as e:
+            raise ValueError(f"Error decoding JSON from API: {e} - {r.text}") from e
+        return data
+
+    def _get_municipality_id(self) -> None:
+        url = f"{API_URL}/community"
+        data = self._fetch_json(url, HEADERS)
+        if not isinstance(data, dict):
+            raise ValueError(f"Unexpected data type: {type(data)}")
+        _municipalities: dict[str, int] = {}
+        _municipalities.update(
+            {
+                item["name"]["en"].lower(): item["id"]
+                for m in data.get("data", [])
+                for item in [m, *m.get("children", [])]
+                if not item["isDisabled"] and not item.get("children", [])
+            }
+        )
+        self._municipality_id = _municipalities.get(self._municipality)
+        if not self._municipality_id:
+            raise SourceArgumentNotFoundWithSuggestions(
+                "municipality", self._municipality, list(_municipalities.keys())
+            )
+
+    def fetch(self) -> list[Collection]:
+        if not self._municipality_id:
+            self._get_municipality_id()
+
+        url = f"{API_URL}/pickup-date"
+        data = self._fetch_json(url, HEADERS)
+        if not isinstance(data, list):
+            raise ValueError(f"Unexpected data type: {type(data)}")
+        entries = [
+            Collection(
+                date=datetime.date.fromisoformat(e["date"].split(" ")[0]),
+                t=e["pickup_type"]["name"]["en"],
+                picture=f"{BASE_URL}{e['pickup_type']['icon']['url']}",
+                icon=ICON_MAP.get(e["pickup_type"]["name"]["en"]),
+            )
+            for e in data
+            if not e["isDisabled"] and e["community_id"] == self._municipality_id
+        ]
+        return entries

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

@@ -0,0 +1,181 @@
+import datetime
+
+import requests
+from waste_collection_schedule import Collection  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import (
+    SourceArgumentNotFoundWithSuggestions,
+)
+
+TITLE = "SICTOM de Lons-le-Saunier"
+DESCRIPTION = "Source for SICTOM de Lons-le-Saunier waste collection (Jura, France)."
+URL = "https://sictom-lons-le-saunier.fr"
+COUNTRY = "fr"
+
+API_URL = "https://new-sictomlons.letri.com/graphql"
+
+COMMUNES_QUERY = """
+query SearchCommunes($search: String!) {
+    communes(where: {search: $search}, first: 10) {
+        nodes {
+            title
+            slug
+            collecte_bac_bleu {
+                frequenceBleu
+                jourCollecteBleu
+            }
+            collecte_bac_gris {
+                frequenceGris
+                jourCollecteGris
+            }
+        }
+    }
+}
+"""
+
+COMMUNE_QUERY = """
+query GetCommune($slug: ID!) {
+    commune(id: $slug, idType: SLUG) {
+        title
+        slug
+        collecte_bac_bleu {
+            frequenceBleu
+            jourCollecteBleu
+        }
+        collecte_bac_gris {
+            frequenceGris
+            jourCollecteGris
+        }
+    }
+}
+"""
+
+# French day names to Python weekday number (Monday=0 ... Sunday=6)
+FRENCH_DAYS = {
+    "Lundi": 0,
+    "Mardi": 1,
+    "Mercredi": 2,
+    "Jeudi": 3,
+    "Vendredi": 4,
+    "Samedi": 5,
+    "Dimanche": 6,
+}
+
+TEST_CASES = {
+    "Courbouzon": {"commune": "courbouzon"},
+    "Lons-le-Saunier (Les Toupes)": {"commune": "lons-le-saunier-les-toupes"},
+    "Saint Amour": {"commune": "saint-amour-les-ecarts"},
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "commune": "Commune",
+    },
+    "fr": {
+        "commune": "Commune",
+    },
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "commune": (
+            "The slug of your commune (e.g. 'courbouzon'). "
+            "Search on https://sictom-lons-le-saunier.fr/quand-passe-le-camion-benne.html "
+            "to find your commune name, then convert to lowercase with hyphens."
+        ),
+    },
+    "fr": {
+        "commune": (
+            "Le slug de votre commune (ex: 'courbouzon'). "
+            "Cherchez votre commune sur https://sictom-lons-le-saunier.fr/quand-passe-le-camion-benne.html."
+        ),
+    },
+}
+
+
+def _is_parity_match(d: datetime.date, frequence: str) -> bool:
+    """Return True if the ISO week number of date matches the required parity."""
+    iso_week = d.isocalendar()[1]
+    if frequence == "Paire":
+        return iso_week % 2 == 0
+    # Impaire
+    return iso_week % 2 == 1
+
+
+def _generate_dates(
+    days: list[str], frequence: str, today: datetime.date, lookahead_days: int = 365
+) -> list[datetime.date]:
+    """Generate all collection dates matching given French day names and week parity."""
+    end_date = today + datetime.timedelta(days=lookahead_days)
+    results = []
+
+    for day_fr in days:
+        weekday = FRENCH_DAYS.get(day_fr)
+        if weekday is None:
+            continue
+
+        # Find the first occurrence of this weekday on or after today
+        days_ahead = (weekday - today.weekday()) % 7
+        current = today + datetime.timedelta(days=days_ahead)
+
+        while current <= end_date:
+            if _is_parity_match(current, frequence):
+                results.append(current)
+            current += datetime.timedelta(days=7)
+
+    return results
+
+
+class Source:
+    def __init__(self, commune: str):
+        self._commune = commune.strip().lower()
+
+    def fetch(self) -> list[Collection]:
+        # Try direct slug lookup first
+        r = requests.post(
+            API_URL,
+            json={"query": COMMUNE_QUERY, "variables": {"slug": self._commune}},
+            headers={"Content-Type": "application/json"},
+        )
+        r.raise_for_status()
+        data = r.json()
+
+        commune_data = data.get("data", {}).get("commune")
+
+        if commune_data is None:
+            # Slug not found — search by name to offer suggestions
+            r2 = requests.post(
+                API_URL,
+                json={
+                    "query": COMMUNES_QUERY,
+                    "variables": {"search": self._commune},
+                },
+                headers={"Content-Type": "application/json"},
+            )
+            r2.raise_for_status()
+            search_data = r2.json()
+            nodes = search_data.get("data", {}).get("communes", {}).get("nodes", [])
+            suggestions = [n["slug"] for n in nodes]
+            raise SourceArgumentNotFoundWithSuggestions(
+                "commune", self._commune, suggestions
+            )
+
+        today = datetime.date.today()
+        entries = []
+
+        # Blue bin (bac bleu — recycling / emballages)
+        bleu = commune_data.get("collecte_bac_bleu") or {}
+        frequence_bleu = bleu.get("frequenceBleu")
+        jours_bleu = bleu.get("jourCollecteBleu") or []
+        if frequence_bleu and jours_bleu:
+            for d in _generate_dates(jours_bleu, frequence_bleu, today):
+                entries.append(Collection(date=d, t="Bac bleu", icon="mdi:recycle"))
+
+        # Grey bin (bac gris — ordures ménagères)
+        gris = commune_data.get("collecte_bac_gris") or {}
+        frequence_gris = gris.get("frequenceGris")
+        jours_gris = gris.get("jourCollecteGris") or []
+        if frequence_gris and jours_gris:
+            for d in _generate_dates(jours_gris, frequence_gris, today):
+                entries.append(Collection(date=d, t="Bac gris", icon="mdi:trash-can"))
+
+        return entries

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

@@ -0,0 +1,171 @@
+import difflib
+import io
+import json
+import re
+import unicodedata
+from datetime import date, timedelta
+
+from curl_cffi import requests
+from pdfminer.high_level import extract_text
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import SourceArgumentNotFoundWithSuggestions
+
+TITLE = "SICTOM du Val de Saône"
+DESCRIPTION = "Source for SICTOM du Val de Saône waste collection schedules in Haute-Saône, France."
+URL = "https://www.sictomvds.com"
+COUNTRY = "fr"
+SOURCE_CODEOWNERS = ["@KingKemar"]
+
+TEST_CASES = {
+    "Velleminfroy": {"commune": "Velleminfroy"},
+    "Ancier": {"commune": "Ancier"},
+    "Mantoche": {"commune": "Mantoche"},
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {"commune": "Municipality"},
+    "fr": {"commune": "Commune"},
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "commune": "Name of the municipality as shown on the SICTOM map (e.g. 'Velleminfroy')."
+    },
+    "fr": {
+        "commune": "Nom de la commune tel qu'affiché sur la carte SICTOM (ex. 'Velleminfroy')."
+    },
+}
+
+ICON_MAP = {
+    "Ordures ménagères": Icons.GENERAL_WASTE,
+    "Tri": Icons.RECYCLING,
+}
+
+_JS_URL = "https://www.sictomvds.com/map/image-map-pro.min.js"
+
+# Only these three public holidays defer collection by one day; all others are worked normally.
+_DEFERRED_HOLIDAYS = {(1, 1), (5, 1), (12, 25)}
+
+_DAYS_FR = {
+    "LUNDI": 0,
+    "MARDI": 1,
+    "MERCREDI": 2,
+    "JEUDI": 3,
+    "VENDREDI": 4,
+    "SAMEDI": 5,
+}
+
+
+def _normalize(s: str) -> str:
+    s = s.strip().casefold()
+    s = unicodedata.normalize("NFKD", s)
+    return "".join(c for c in s if not unicodedata.combining(c))
+
+
+def _normalize_text(text: str) -> str:
+    """Strip accents from extracted PDF text for reliable regex matching."""
+    text = unicodedata.normalize("NFKD", text)
+    return "".join(c for c in text if not unicodedata.combining(c))
+
+
+def _load_mapping(session) -> tuple[dict[str, str], list[str]]:
+    """Return ({normalized_title: pdf_url}, [original_titles])."""
+    r = session.get(_JS_URL)
+    r.raise_for_status()
+    # Locate the data call (second occurrence of imageMapPro)
+    m = re.search(r"imageMapPro\((\{.*?\})\);", r.text[100_000:], re.DOTALL)
+    if not m:
+        raise ValueError("Could not locate imageMapPro config in JS")
+    config = json.loads(m.group(1))
+    mapping: dict[str, str] = {}
+    titles: list[str] = []
+    for spot in config.get("spots", []):
+        title = spot.get("title", "")
+        link = (spot.get("actions") or {}).get("link", "")
+        if link.lower().endswith(".pdf"):
+            mapping[_normalize(title)] = link
+            titles.append(title)
+    return mapping, titles
+
+
+def _parse_schedule(pdf_bytes: bytes) -> list[tuple[str, int, int]]:
+    """
+    Return list of (waste_type, weekday, parity) parsed from a collection PDF.
+    weekday: 0=Mon … 5=Sat. parity: 0=even ISO weeks (PAIRES), 1=odd (IMPAIRES).
+    """
+    raw_text = extract_text(io.BytesIO(pdf_bytes))
+    text = _normalize_text(raw_text).upper()
+
+    results = []
+
+    # TRI (recyclables) — text example: "COLLECTES DU TRITOUS LES JEUDIS SEMAINES PAIRES"
+    m_tri = re.search(
+        r"COLLECTES\s+DU\s+TRI\s*(?:TOUS\s+LES\s+)?"
+        r"(LUNDI|MARDI|MERCREDI|JEUDI|VENDREDI|SAMEDI)S?\s+SEMAINES?\s+(PAIRES|IMPAIRES)",
+        text,
+    )
+    if m_tri:
+        day = _DAYS_FR[m_tri.group(1)]
+        parity = 0 if m_tri.group(2) == "PAIRES" else 1
+        results.append(("Tri", day, parity))
+
+    # Ordures ménagères — text example: "COLLECTES DES  ORDURES MENAGERES TOUS LES MERCREDIS SEMAINES PAIRES"
+    m_om = re.search(
+        r"COLLECTES\s+DES\s+ORDURES\s+MENAGERES\s*(?:TOUS\s+LES\s+)?"
+        r"(LUNDI|MARDI|MERCREDI|JEUDI|VENDREDI|SAMEDI)S?\s+SEMAINES?\s+(PAIRES|IMPAIRES)",
+        text,
+    )
+    if m_om:
+        day = _DAYS_FR[m_om.group(1)]
+        parity = 0 if m_om.group(2) == "PAIRES" else 1
+        results.append(("Ordures ménagères", day, parity))
+
+    return results
+
+
+def _project_dates(weekday: int, parity: int, days: int = 365) -> list[date]:
+    """Yield collection dates for the next `days` days matching weekday and ISO-week parity."""
+    today = date.today()
+    end = today + timedelta(days=days)
+    days_ahead = (weekday - today.weekday()) % 7
+    current = today + timedelta(days=days_ahead)
+    result = []
+    while current <= end:
+        if current.isocalendar()[1] % 2 == parity:
+            d = current
+            if (d.month, d.day) in _DEFERRED_HOLIDAYS:
+                d += timedelta(days=1)
+            result.append(d)
+        current += timedelta(weeks=1)
+    return result
+
+
+class Source:
+    def __init__(self, commune: str):
+        self._commune = commune
+        self._session = requests.Session(impersonate="chrome")
+
+    def fetch(self) -> list[Collection]:
+        mapping, titles = _load_mapping(self._session)
+
+        norm = _normalize(self._commune)
+        if norm not in mapping:
+            norm_titles = [_normalize(t) for t in titles]
+            close = difflib.get_close_matches(norm, norm_titles, n=5, cutoff=0.5)
+            suggestions = [titles[norm_titles.index(c)] for c in close]
+            raise SourceArgumentNotFoundWithSuggestions(
+                "commune", self._commune, suggestions
+            )
+
+        pdf_url = mapping[norm]
+        r = self._session.get(pdf_url)
+        r.raise_for_status()
+
+        schedule = _parse_schedule(r.content)
+
+        entries: list[Collection] = []
+        for waste_type, weekday, parity in schedule:
+            for d in _project_dates(weekday, parity):
+                entries.append(Collection(d, waste_type, icon=ICON_MAP.get(waste_type)))
+
+        return entries

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

@@ -0,0 +1,126 @@
+import re
+from datetime import datetime
+
+import requests
+from bs4 import BeautifulSoup
+from waste_collection_schedule import Collection, Icons
+from waste_collection_schedule.exceptions import (
+    SourceArgumentRequiredWithSuggestions,
+)
+
+TITLE = "SIDEC"
+DESCRIPTION = "Source for SIDEC waste collection."
+URL = "https://www.sidec.lu"
+TEST_CASES = {
+    "Parc Hosingen": {"commune": "Parc Hosingen (36777)"},
+    "Mersch": {"commune": "Mersch (2611)"},
+    "Invalid Commune": {"commune": "Invalid (12345)"},
+}
+
+API_URL = "https://www.sidec.lu/fr/Collectes/Calendrier"
+ICON_MAP = {
+    "BULKY": Icons.BULKY,
+    "GLASS": Icons.GLASS,
+    "ORGANIC": Icons.ORGANIC,
+    "PAPER": Icons.PAPER,
+    "RESIDUAL": Icons.GENERAL_WASTE,
+}
+
+WASTE_MAPPING = {
+    "encombrants": "BULKY",
+    "verre": "ORGANIC",
+    "dechets organiques": "GLASS",
+    "papiers cartons": "PAPER",
+    "dechets menagers": "RESIDUAL",
+}
+
+
+class Source:
+    def __init__(self, commune: str | None = None):
+        self._commune = commune
+        self._commune_id: str | None = None
+        if commune:
+            # Parse the ID from the formatted string, e.g., "Parc Hosingen (36777)"
+            match = re.search(r"\((\d+)\)", commune)
+            if match:
+                self._commune_id = match.group(1)
+
+    def fetch(self):
+        if not self._commune or not self._commune_id:
+            # Step 1: No commune provided, fetch list from website and raise exception
+            r = requests.get(API_URL)
+            r.raise_for_status()
+            soup = BeautifulSoup(r.text, "html.parser")
+            select = soup.find("select", {"name": "myCommune"})
+            if not select:
+                raise Exception("Could not find commune dropdown on SIDEC website.")
+
+            suggestions = []
+            for option in select.find_all("option"):
+                if option.get("value"):
+                    name = option.text.strip()
+                    commune_id = option["value"]
+                    suggestions.append(f"{name} ({commune_id})")
+
+            raise SourceArgumentRequiredWithSuggestions(
+                "commune", None, sorted(suggestions)
+            )
+
+        # If commune was provided but ID could not be parsed, raise error
+        # This happens if user enters a free-text value not from the dropdown
+        if not self._commune_id:
+            raise Exception(
+                f'Invalid commune format: "{self._commune}". Please select an entry from the dropdown list.'
+            )
+
+        # --- Proceed with fetching data ---
+        now = datetime.now()
+        year = now.year
+
+        collections = []
+        collections.extend(self._fetch_year(year))
+
+        if now.month >= 10:
+            try:
+                collections.extend(self._fetch_year(year + 1))
+            except Exception:
+                pass
+
+        return collections
+
+    def _fetch_year(self, year):
+        params = {"annee": year, "myCommune": self._commune_id}
+        r = requests.get(API_URL, params=params)
+        r.raise_for_status()
+
+        soup = BeautifulSoup(r.text, "html.parser")
+        collections = []
+
+        calendar_months = soup.select("#col-2 .calendar")
+        for month_index, month_div in enumerate(calendar_months):
+            month = month_index + 1
+            day_images = month_div.select(".calendar-day img")
+            for img in day_images:
+                src = img.get("src", "")
+                if "caption-" not in src:
+                    continue
+
+                try:
+                    item = src.split("caption-")[-1].split(".gif")[0]
+                    day_str = item.split("-")[-1]
+                    day = int(day_str)
+                    waste_type_str = "-".join(item.split("-")[:-1]).replace("_", " ")
+                    date = datetime(year, month, day).date()
+                    waste_type = WASTE_MAPPING.get(waste_type_str)
+                    if waste_type:
+                        collections.append(
+                            Collection(
+                                date=date,
+                                t=waste_type,
+                                icon=ICON_MAP.get(waste_type),
+                            )
+                        )
+                except (ValueError, IndexError):
+                    continue
+
+        return collections