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

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

@@ -0,0 +1,294 @@
+import re
+import unicodedata
+from datetime import date, timedelta
+
+import requests
+from bs4 import BeautifulSoup
+from dateutil.rrule import FR, MO, SA, SU, TH, TU, WE, WEEKLY, rrule
+from waste_collection_schedule import Collection, Icons
+from waste_collection_schedule.exceptions import SourceArgumentNotFoundWithSuggestions
+
+TITLE = "Terres Touloises"  # Title will show up in README.md and info.md
+DESCRIPTION = "Source script for terrestouloises.com (Communauté de Communes Terres Touloises, France)"  # Describe your source
+URL = "https://www.terrestouloises.com"  # Insert url to service homepage. URL will show up in README.md and info.md
+DATA_URL = "https://www.terrestouloises.com/terres-touloises-au-quotidien/gestion-des-dechets/collectes-des-ordures-menageres-et-recyclables/"
+COUNTRY = "fr"
+
+# Note: "Toul" is intentionally excluded. Unlike every other commune on this
+# page, Toul is split into several sub-zones (Saint-Michel Briffoux, Saint
+# Mansuy, Croix de Metz, Saint Èvre) each with its own household-waste
+# calendar, disambiguated by street rather than by commune name. Supporting
+# it would require a street-level parameter this source does not yet expose.
+COMMUNES = [
+    "Aingeray",
+    "Andilly",
+    "Ansauville",
+    "Avrainville",
+    "Bicqueley",
+    "Bois-de-Haye",
+    "Boucq",
+    "Bouvron",
+    "Bruley",
+    "Charmes-la-Côte",
+    "Chaudeney-sur-Moselle",
+    "Choloy-Ménillot",
+    "Domèvre-en-Haye",
+    "Domgermain",
+    "Dommartin-lès-Toul",
+    "Écrouves",
+    "Fontenoy-sur-Moselle",
+    "Foug",
+    "Francheville",
+    "Gondreville",
+    "Grosrouvres",
+    "Gye",
+    "Jaillon",
+    "Lagney",
+    "Laneuveville-derrière-Foug",
+    "Lay-Saint-Rémy",
+    "Lucey",
+    "Manoncourt-en-Woëvre",
+    "Manonville",
+    "Ménil-la-Tour",
+    "Minorville",
+    "Noviant-aux-Prés",
+    "Pagney-derrière-Barine",
+    "Pierre-la-Treiche",
+    "Royaumeix",
+    "Sanzey",
+    "Tremblecourt",
+    "Trondes",
+    "Villey-le-Sec",
+    "Villey-Saint-Étienne",
+]
+
+
+def _strip_accents(s: str) -> str:
+    return "".join(
+        c for c in unicodedata.normalize("NFD", s) if unicodedata.category(c) != "Mn"
+    )
+
+
+def _normalize_commune(s: str) -> str:
+    """Remove accents, uppercase, and collapse separators for fuzzy name matching."""
+    s = _strip_accents(s)
+    return re.sub(r"[-'’ ]", "", s.upper())
+
+
+COMMUNES_NORMALIZED = {_normalize_commune(c): c for c in COMMUNES}
+
+EXTRA_INFO = [
+    {
+        "title": commune,
+        "url": URL,
+        "default_params": {"commune": commune},
+    }
+    for commune in COMMUNES
+]
+
+TEST_CASES = {
+    "Bois-de-Haye": {"commune": "Bois-de-Haye"},
+    "Ansauville (self-service bins)": {"commune": "Ansauville"},
+    "Ecrouves (inline holiday exception)": {"commune": "Ecrouves"},
+    "Gondreville": {"commune": "Gondreville"},
+}
+
+ICON_MAP = {
+    "Ordures ménagères": Icons.GENERAL_WASTE,
+    "Emballages": Icons.RECYCLING,
+}
+
+WEEKDAY_MAP = {
+    "lundi": MO,
+    "mardi": TU,
+    "mercredi": WE,
+    "jeudi": TH,
+    "vendredi": FR,
+    "samedi": SA,
+    "dimanche": SU,
+}
+
+MOIS_MAP = {
+    "janvier": 1,
+    "fevrier": 2,
+    "mars": 3,
+    "avril": 4,
+    "mai": 5,
+    "juin": 6,
+    "juillet": 7,
+    "aout": 8,
+    "septembre": 9,
+    "octobre": 10,
+    "novembre": 11,
+    "decembre": 12,
+}
+
+# Matches sentences describing a holiday shift, e.g.:
+#   "vendredi 1er mai 2026 reporté au samedi 2 mai 2026"
+#   "mardi 14 juillet 2026 reportée au samedi 18 juillet 2026"
+# The origin year is optional, some entries omit it (e.g. "jeudi 14 mai
+# reporté au samedi 16 mai 2026") in which case the destination year applies.
+EXCEPTION_PATTERN = re.compile(
+    r"(\d{1,2})(?:er)?\s+([a-zA-Zàâäéèêëïîôöùûüÿçñ]+)(?:\s+(\d{4}))?\s+"
+    r"report[ée]e?\s+au\s+"
+    r"(\d{1,2})(?:er)?\s+([a-zA-Zàâäéèêëïîôöùûüÿçñ]+)\s+(\d{4})",
+    re.IGNORECASE,
+)
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "commune": "Your commune within the Terres Touloises area: "
+        + ", ".join(COMMUNES)
+    },
+    "fr": {
+        "commune": "Votre commune du territoire des Terres Touloises : "
+        + ", ".join(COMMUNES)
+    },
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {"commune": "Commune"},
+    "fr": {"commune": "Commune"},
+    "de": {"commune": "Gemeinde"},
+}
+
+
+class Source:
+    def __init__(self, commune: str):
+        canonical = COMMUNES_NORMALIZED.get(_normalize_commune(commune))
+        if canonical is None:
+            raise SourceArgumentNotFoundWithSuggestions("commune", commune, COMMUNES)
+        self.commune = canonical
+
+    def fetch(self) -> list[Collection]:
+        response = requests.get(DATA_URL, timeout=30)
+        response.raise_for_status()
+        soup = BeautifulSoup(response.text, "html.parser")
+
+        panel_text = self._get_panel_text(soup, self.commune)
+        if panel_text is None:
+            raise SourceArgumentNotFoundWithSuggestions(
+                "commune", self.commune, COMMUNES
+            )
+
+        entries: list[Collection] = []
+        entries.extend(self._parse_ordures_menageres(panel_text))
+        entries.extend(self._parse_emballages(panel_text))
+        return entries
+
+    @staticmethod
+    def _get_panel_text(soup: BeautifulSoup, commune: str) -> str | None:
+        """Find the accordion panel matching `commune` and return its plain text."""
+        for heading in soup.select("h4.panel-title"):
+            link = heading.find("a")
+            if not link:
+                continue
+            name = link.get_text(strip=True)
+            if _normalize_commune(name) != _normalize_commune(commune):
+                continue
+            href = link.get("href", "")
+            if not isinstance(href, str) or not href.startswith("#"):
+                continue
+            panel = soup.find(id=href[1:])
+            if panel is None:
+                continue
+            return panel.get_text("\n", strip=True)
+        return None
+
+    @staticmethod
+    def _parse_ordures_menageres(text: str) -> list[Collection]:
+        """Parse the explicit "Calendrier/Collectes <year>" household-waste dates."""
+        match = re.search(
+            r"(?:Calendrier|Collectes)\s+(\d{4})\s*\n(.*?)\nEmballages\s*:",
+            text,
+            re.DOTALL,
+        )
+        if not match:
+            return []
+        year = int(match.group(1))
+        block = match.group(2)
+
+        entries = []
+        for line in block.splitlines():
+            line = line.strip()
+            if not line:
+                continue
+            low = _strip_accents(line).lower()
+            month = None
+            for mois_name, mois_num in MOIS_MAP.items():
+                if re.search(rf"\b{mois_name}\b", low):
+                    month = mois_num
+                    break
+            if month is None:
+                continue
+            for day_match in re.finditer(r"(\d{1,2})(?:er)?\b", line):
+                try:
+                    collection_date = date(year, month, int(day_match.group(1)))
+                except ValueError:
+                    continue
+                entries.append(
+                    Collection(
+                        date=collection_date,
+                        t="Ordures ménagères",
+                        icon=ICON_MAP.get("Ordures ménagères"),
+                    )
+                )
+        return entries
+
+    @staticmethod
+    def _parse_emballages(text: str) -> list[Collection]:
+        """Parse the weekly recycling ("Emballages") collection, applying holiday shifts."""
+        match = re.search(r"Emballages\s*:\s*\n(.*?)\nPapiers", text, re.DOTALL)
+        if not match:
+            return []
+        block = match.group(1)
+
+        if "conteneur" in block.lower():
+            # Self-service drop-off point, no scheduled collection date.
+            return []
+
+        weekday_match = re.search(
+            r"chaque semaine le (\w+)", _strip_accents(block).lower()
+        )
+        if not weekday_match:
+            return []
+        weekday = WEEKDAY_MAP.get(weekday_match.group(1))
+        if weekday is None:
+            return []
+
+        today = date.today()
+        occurrences = {
+            dt.date()
+            for dt in rrule(
+                freq=WEEKLY,
+                dtstart=today - timedelta(days=7),
+                count=60,
+                byweekday=weekday,
+            )
+        }
+
+        for exc_match in EXCEPTION_PATTERN.finditer(block):
+            orig_day, orig_month_str, orig_year, dest_day, dest_month_str, dest_year = (
+                exc_match.groups()
+            )
+            orig_month = MOIS_MAP.get(_strip_accents(orig_month_str).lower())
+            dest_month = MOIS_MAP.get(_strip_accents(dest_month_str).lower())
+            if orig_month is None or dest_month is None:
+                continue
+            resolved_orig_year = int(orig_year) if orig_year else int(dest_year)
+            try:
+                orig_date = date(resolved_orig_year, orig_month, int(orig_day))
+                dest_date = date(int(dest_year), dest_month, int(dest_day))
+            except ValueError:
+                continue
+            occurrences.discard(orig_date)
+            occurrences.add(dest_date)
+
+        return [
+            Collection(
+                date=collection_date,
+                t="Emballages",
+                icon=ICON_MAP.get("Emballages"),
+            )
+            for collection_date in sorted(occurrences)
+        ]

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

@@ -0,0 +1,80 @@
+import logging
+from datetime import datetime
+from urllib.parse import quote as urlquote
+
+import requests
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import SourceArgumentRequired
+
+TITLE = "Tewkesbury Borough Council"
+DESCRIPTION = "Home waste collection schedule for Tewkesbury Borough Council"
+URL = "https://www.tewkesbury.gov.uk"
+TEST_CASES = {
+    "UPRN example": {"uprn": 100120544973},
+    "Deprecated postcode": {"postcode": "GL20 5TT"},
+    "Deprecated postcode No Spaces": {"postcode": "GL205TT"},
+}
+
+DEPRECATED_API_URL = "https://api-2.tewkesbury.gov.uk/general/rounds/%s/nextCollection"
+API_URL = "https://api-2.tewkesbury.gov.uk/incab/rounds/%s/next-collection"
+
+ICON_MAP = {
+    "Refuse": Icons.GENERAL_WASTE,
+    "Recycling": Icons.RECYCLING,
+    "Garden": Icons.GARDEN,
+    "Food": Icons.BIO_KITCHEN,
+}
+
+LOGGER = logging.getLogger(__name__)
+
+
+class Source:
+    def __init__(self, postcode: str | None = None, uprn: str | None = None):
+        self.uprn = str(uprn) if uprn is not None else None
+        self.postcode = str(postcode) if postcode is not None else None
+
+    def fetch(self):
+        if self.uprn is None:
+            LOGGER.warning(
+                "Using deprecated API might not work in the future. Please provide a UPRN."
+            )
+            return self.get_data(self.postcode, DEPRECATED_API_URL)
+        return self.get_data(self.uprn)
+
+    def get_data(self, uprn, api_url=API_URL):
+        if uprn is None:
+            raise SourceArgumentRequired(
+                "uprn", "UPRN is required to fetch collection data"
+            )
+
+        encoded_uprn = urlquote(uprn)
+        request_url = api_url % encoded_uprn
+        response = requests.get(request_url)
+
+        response.raise_for_status()
+        data = response.json()
+
+        entries = []
+
+        waste_type_map = {
+            "refuse": "Refuse",
+            "recycling": "Recycling",
+            "food": "Food",
+            "garden": "Garden",
+        }
+        for waste_key, waste_label in waste_type_map.items():
+            if waste_key not in data:
+                continue
+            date_str = data[waste_key].get("nextCollectionDate")
+            if not date_str:
+                continue
+            entries.append(
+                Collection(
+                    date=datetime.fromisoformat(date_str.replace("Z", "+00:00")).date(),
+                    t=waste_label,
+                    icon=ICON_MAP.get(waste_label),
+                )
+            )
+        if not entries:
+            raise Exception(f"No collection data returned for identifier: {uprn!r}")
+        return entries

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

@@ -0,0 +1,116 @@
+from datetime import datetime
+
+from curl_cffi import requests
+from waste_collection_schedule import Collection
+from waste_collection_schedule.exceptions import (
+    SourceArgumentNotFoundWithSuggestions,
+    SourceArgumentRequired,
+    SourceArgumentRequiredWithSuggestions,
+)
+
+TITLE = "Thanet District Council"
+DESCRIPTION = "Source for thanet.gov.uk services for Thanet District Council"
+URL = "https://thanet.gov.uk"
+
+TEST_CASES = {
+    "uprn": {"uprn": "100061108233"},
+    "houseName": {"postcode": "CT7 9SL", "street_address": "Forus"},
+    "houseNumber": {"postcode": "CT7 9SL", "street_address": "6 Gordon Square"},
+}
+
+TYPES = {
+    "Refuse": {"icon": "mdi:trash-can", "alias": "Rubbish"},
+    "BlueRecycling": {"icon": "mdi:recycle", "alias": "Mixed Recycling (Blue)"},
+    "RedRecycling": {"icon": "mdi:note-multiple", "alias": "Paper & Card (Red)"},
+    "Food": {"icon": "mdi:food-apple", "alias": "Food Waste"},
+    "Garden": {"icon": "mdi:leaf", "alias": "Garden"},
+}
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {  # Optional dictionary to describe how to get the arguments, will be shown in the GUI configuration form above the input fields, does not need to be translated in all languages
+    "en": "Enter either your UPRN (available from [FindMyAddress.co.uk](https://www.findmyaddress.co.uk/))"
+    "OR Enter your postcode and the first line of your address for street address e.g. '2 London Road' (anything before the first comma)"
+    "UPRNs should work all of the time, Postcodes and Street Addresses will work if a match can be found."
+}
+
+PARAM_DESCRIPTIONS = {  # Optional dict to describe the arguments, will be shown in the GUI configuration below the respective input field
+    "en": {
+        "uprn": "Unique Property Reference Number (UPRN)",
+        "street_address": "House name OR Number and Street name",
+        "postcode": "Postcode",
+    }
+}
+
+
+class Source:
+    def __init__(self, uprn=None, postcode=None, street_address=None):
+        self._postcode = postcode
+        self._street_address = str(street_address).upper()
+        self._uprn = uprn
+        self._session = requests.Session(impersonate="chrome124")
+
+    def fetch(self) -> list[Collection]:
+        if self._uprn is None:
+            self._uprn = self.get_uprn()
+
+        url = "https://www.thanet.gov.uk/wp-content/mu-plugins/collection-day/incl/mu-collection-day-calls.php"
+        r = self._session.get(url, params={"pAddress": self._uprn}, timeout=30)
+        r.raise_for_status()
+        collections_json = r.json()
+
+        entries = []
+
+        for collection in collections_json:
+            for bin_type in TYPES:
+                if collection["type"] == bin_type:
+                    entries.append(
+                        Collection(
+                            date=datetime.strptime(
+                                collection["nextDate"][:10], "%d/%m/%Y"
+                            ).date(),
+                            t=TYPES[bin_type]["alias"],
+                            icon=TYPES[bin_type]["icon"],
+                        )
+                    )
+                    entries.append(
+                        Collection(
+                            date=datetime.strptime(
+                                collection["previousDate"][:10], "%d/%m/%Y"
+                            ).date(),
+                            t=TYPES[bin_type]["alias"],
+                            icon=TYPES[bin_type]["icon"],
+                        )
+                    )
+        return entries
+
+    def get_uprn(self) -> str:
+        if self._postcode is None:
+            raise SourceArgumentRequired(
+                "postcode",
+                "A postcode is required if no UPRN has been used. This allows the script to obtain the UPRN for you.",
+            )
+        url = "https://www.thanet.gov.uk/wp-content/mu-plugins/collection-day/incl/mu-collection-day-calls.php"
+        r = self._session.get(url, params={"searchAddress": self._postcode}, timeout=30)
+        r.raise_for_status()
+        addresses_json = r.json()
+        uprn = next(
+            (
+                key
+                for key, value in addresses_json.items()
+                if value[: len(self._street_address)] == self._street_address
+            ),
+            None,
+        )
+        if self._street_address is None:
+            raise SourceArgumentRequiredWithSuggestions(
+                "street_address",
+                "A street address is needed, please select one from the list.",
+                [value.split(",")[0] for value, value in addresses_json.items()],
+            )
+        if uprn is None:
+            raise SourceArgumentNotFoundWithSuggestions(
+                "Street Address",
+                self._street_address,
+                [value.split(",")[0] for value, value in addresses_json.items()],
+            )
+
+        return uprn

package/python/vendor/waste_collection_schedule/source/thanet_gov_uk.py.bak

@@ -0,0 +1,104 @@
+from datetime import datetime
+from typing import List
+import json
+import requests
+
+
+from waste_collection_schedule import Collection
+from waste_collection_schedule.exceptions import (
+    SourceArgumentNotFoundWithSuggestions,
+    SourceArgumentRequired,
+    SourceArgumentRequiredWithSuggestions,
+)
+# Include work around for SSL UNSAFE_LEGACY_RENEGOTIATION_DISABLED error
+from waste_collection_schedule.service.SSLError import get_legacy_session
+
+TITLE = "Thanet District Council"
+DESCRIPTION = (
+    "Source for thanet.gov.uk services for Thanet District Council"
+)
+URL = "https://thanet.gov.uk"
+
+TEST_CASES = {
+    "uprn": {"uprn": "100061108233"},
+    "houseName": {"postcode": "CT7 9SL", "street_address": "Forus"},
+    "houseNumber": {"postcode": "CT7 9SL", "street_address": "6 Gordon Square"},
+}
+
+TYPES = {
+    "Refuse": {"icon": "mdi:trash-can", "alias": "Rubbish"},
+    "BlueRecycling": {"icon": "mdi:recycle", "alias": "Mixed Recycling (Blue)"},
+    "RedRecycling": {"icon": "mdi:note-multiple", "alias": "Paper & Card (Red)"},
+    "Food": {"icon": "mdi:food-apple", "alias": "Food Waste"},
+    "Garden": {"icon": "mdi:leaf", "alias": "Garden"},
+}
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {  # Optional dictionary to describe how to get the arguments, will be shown in the GUI configuration form above the input fields, does not need to be translated in all languages
+    "en": "Enter either your UPRN (available from [FindMyAddress.co.uk](https://www.findmyaddress.co.uk/))"
+    "OR Enter your postcode and the first line of your address for street address e.g. '2 London Road' (anything before the first comma)"
+    "UPRNs should work all of the time, Postcodes and Street Addresses will work if a match can be found."
+}
+
+PARAM_DESCRIPTIONS = {  # Optional dict to describe the arguments, will be shown in the GUI configuration below the respective input field
+    "en": {
+        "uprn": "Unique Property Reference Number (UPRN)",
+        "street_address": "House name OR Number and Street name",
+        "postcode": "Postcode",
+    }
+}
+
+
+class Source:
+    
+    header_text = { 'Accept-Language' :"en-GB,en;q=0.9,en-US;q=0.8",
+            'User-Agent': "Mozilla/5.0",
+            }
+    
+    
+    def __init__(self, uprn=None, postcode=None, street_address=None):
+        self._postcode = postcode
+        self._street_address = str(street_address).upper()
+        self._uprn = uprn
+
+    def fetch(self) -> List[Collection]:
+        if self._uprn is None:
+            self._uprn = self.get_uprn()
+
+        url = "https://www.thanet.gov.uk/wp-content/mu-plugins/collection-day/incl/mu-collection-day-calls.php"
+        collections_json = requests.get(url, headers= self.header_text, params={"pAddress": self._uprn}).json()
+        
+        entries = []
+        
+        for collection in collections_json:
+            for bin_type in TYPES:
+                if collection["type"] == bin_type:
+                    entries.append(
+                        Collection(
+                            date=datetime.strptime(collection['nextDate'][:10], "%d/%m/%Y").date(),
+                            t=TYPES[bin_type]['alias'],
+                            icon=TYPES[bin_type]['icon'],
+                        )
+                    )
+                    entries.append(
+                        Collection(
+                            date=datetime.strptime(collection['previousDate'][:10], "%d/%m/%Y").date(),
+                            t=TYPES[bin_type]['alias'],
+                            icon=TYPES[bin_type]['icon'],
+                        )
+                    )
+        return entries
+        
+    def get_uprn(self) -> str:
+        url = f"https://www.thanet.gov.uk/wp-content/mu-plugins/collection-day/incl/mu-collection-day-calls.php"
+        addresses_json = requests.get(url, headers= self.header_text, params = {"searchAddress": self._postcode}).json()
+        uprn = next((key for key,
+                     value in addresses_json.items() if value[:len(self._street_address)] == self._street_address),
+                     None)
+        if uprn is None:
+                    raise SourceArgumentNotFoundWithSuggestions(
+                        "Street Address",
+                        self._street_address,
+                        [value.split(",")[0] for value, value in addresses_json.items()],
+                    )
+
+        return uprn