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

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

@@ -0,0 +1,103 @@
+import datetime
+import re
+
+import requests
+from bs4 import BeautifulSoup
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+
+TITLE = "Cederbaum Braunschweig"
+DESCRIPTION = "Cederbaum Braunschweig Paperimüll"
+URL = "https://www.cederbaum.de"
+TEST_CASES = {
+    "Hans-Sommer-Str": {"street": "Hans-Sommer-Str."},
+    "Adolfstr 31-42": {"street": "Adolfstr. 31-42"},
+    "Am Schwarzen Berge": {"street": "am Schwarzen Berge "},
+}
+
+API_URL = "https://www.cederbaum.de/blaue-tonne/"
+ICON_MAP = {
+    "PAPER": Icons.PAPER,
+}
+
+PARAM_TRANSLATIONS = {
+    "de": {
+        "street": "Straße",
+    }
+}
+
+
+class Source:
+    def __init__(self, street):
+        self._street = street
+
+        self.page_source = None
+        self.street_id = None
+        self.collection_data = None
+
+    def fetch_page_source(self):
+        resp = requests.get(API_URL)
+        soup = BeautifulSoup(resp.text, "html.parser")
+        self.page_source = soup
+
+    def get_street_id(self):
+        if not self.page_source:
+            raise ValueError("No page source found")
+
+        select = self.page_source.find("select")
+
+        if not select:
+            raise ValueError("No <select> tag found")
+
+        options = select.find_all("option")
+        for option in options:
+            value = option.get("value")
+            text = option.get_text()
+            if text.lower().strip() == self._street.lower().strip():
+                self.street_id = int(value)
+                break
+
+    def get_collection_data(self):
+        if not self.page_source:
+            raise ValueError("No page source found")
+
+        script_tags = self.page_source.find_all("script")
+        script_with_text = [tag for tag in script_tags if tag.string]
+        pattern = re.compile(r"var rate = \[(.*?)\];")
+
+        # the dates are stored in a hardcoded js array
+        raw_date_text = None
+        for script_tag in script_with_text:
+            match = pattern.search(script_tag.string)
+            if match:
+                raw_date_text = match.group(1)
+                break
+
+        if not raw_date_text:
+            raise ValueError("Raw date text not found")
+
+        # one list of dates per location
+        raw_dates = [text.strip('"') for text in raw_date_text.split('","')]
+        self.collection_data = [dates.split(",") for dates in raw_dates]
+
+    def fetch(self):
+        self.fetch_page_source()
+        self.get_street_id()
+        self.get_collection_data()
+
+        if not self.collection_data:
+            raise ValueError("No collection data found")
+
+        entries = []
+        waste_dates = self.collection_data[self.street_id]  # type: ignore
+        for waste_date in waste_dates:
+            date = datetime.datetime.strptime(waste_date, "%d.%m.%Y")
+
+            entries.append(
+                Collection(
+                    date=date.date(),
+                    t="Paper",
+                    icon=ICON_MAP.get("PAPER"),
+                )
+            )
+
+        return entries

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

@@ -0,0 +1,239 @@
+from datetime import datetime
+from difflib import get_close_matches
+
+import requests
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import SourceArgumentNotFoundWithSuggestions
+
+TITLE = "CEM Ambiente"
+DESCRIPTION = "Source for CEM Ambiente (CEM FACILE), covering municipalities in the Milano / Monza e Brianza / Lodi area of Italy."
+URL = "https://www.cemambiente.it"
+COUNTRY = "it"
+
+API_URL = "https://cemfacile.cemambiente.it"
+
+# The API rejects requests carrying the default python-requests User-Agent
+# (and similarly "bare" requests) with a 403. Sending headers that mimic a
+# regular browser/app request avoids the block.
+HEADERS = {
+    "User-Agent": (
+        "Mozilla/5.0 (iPhone; CPU iPhone OS 17_0 like Mac OS X) "
+        "AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Mobile/15E148 Safari/604.1"
+    ),
+    "Content-Type": "application/json",
+}
+
+EXTRA_INFO = [
+    {"title": "Agrate Brianza", "country": "it"},
+    {"title": "Aicurzio", "country": "it"},
+    {"title": "Arcore", "country": "it"},
+    {"title": "Basiano", "country": "it"},
+    {"title": "Bellinzago Lombardo", "country": "it"},
+    {"title": "Bellusco", "country": "it"},
+    {"title": "Bernareggio", "country": "it"},
+    {"title": "Borgo San Giovanni", "country": "it"},
+    {"title": "Brugherio", "country": "it"},
+    {"title": "Burago Di Molgora", "country": "it"},
+    {"title": "Busnago", "country": "it"},
+    {"title": "Bussero", "country": "it"},
+    {"title": "Cambiago", "country": "it"},
+    {"title": "Camparada", "country": "it"},
+    {"title": "Caponago", "country": "it"},
+    {"title": "Carnate", "country": "it"},
+    {"title": "Carpiano", "country": "it"},
+    {"title": "Carugate", "country": "it"},
+    {"title": "Casaletto Lodigiano", "country": "it"},
+    {"title": "Casalmaiocco", "country": "it"},
+    {"title": "Caselle Lurani", "country": "it"},
+    {"title": "Cassano D'Adda", "country": "it"},
+    {"title": "Cassina De' Pecchi", "country": "it"},
+    {"title": "Cavenago Di Brianza", "country": "it"},
+    {"title": "Cernusco Sul Naviglio", "country": "it"},
+    {"title": "Cerro Al Lambro", "country": "it"},
+    {"title": "Cervignano D'Adda", "country": "it"},
+    {"title": "Cologno Monzese", "country": "it"},
+    {"title": "Colturano", "country": "it"},
+    {"title": "Comazzo", "country": "it"},
+    {"title": "Concorezzo", "country": "it"},
+    {"title": "Cornate D'Adda", "country": "it"},
+    {"title": "Correzzana", "country": "it"},
+    {"title": "Dresano", "country": "it"},
+    {"title": "Gessate", "country": "it"},
+    {"title": "Gorgonzola", "country": "it"},
+    {"title": "Grezzago", "country": "it"},
+    {"title": "Inzago", "country": "it"},
+    {"title": "Lesmo", "country": "it"},
+    {"title": "Liscate", "country": "it"},
+    {"title": "Macherio", "country": "it"},
+    {"title": "Masate", "country": "it"},
+    {"title": "Massalengo", "country": "it"},
+    {"title": "Mediglia", "country": "it"},
+    {"title": "Melegnano", "country": "it"},
+    {"title": "Melzo", "country": "it"},
+    {"title": "Merlino", "country": "it"},
+    {"title": "Mezzago", "country": "it"},
+    {"title": "Mulazzano", "country": "it"},
+    {"title": "Ornago", "country": "it"},
+    {"title": "Pantigliate", "country": "it"},
+    {"title": "Paullo", "country": "it"},
+    {"title": "Pessano Con Bornago", "country": "it"},
+    {"title": "Pozzo D'Adda", "country": "it"},
+    {"title": "Pozzuolo Martesana", "country": "it"},
+    {"title": "Rodano", "country": "it"},
+    {"title": "Roncello", "country": "it"},
+    {"title": "Ronco Briantino", "country": "it"},
+    {"title": "Salerano sul Lambro", "country": "it"},
+    {"title": "San Zenone Al Lambro", "country": "it"},
+    {"title": "Sant'Angelo Lodigiano", "country": "it"},
+    {"title": "Settala", "country": "it"},
+    {"title": "Sordio", "country": "it"},
+    {"title": "Sulbiate", "country": "it"},
+    {"title": "Torrevecchia Pia", "country": "it"},
+    {"title": "Trezzano Rosa", "country": "it"},
+    {"title": "Trezzo Sull'Adda", "country": "it"},
+    {"title": "Tribiano", "country": "it"},
+    {"title": "Truccazzano", "country": "it"},
+    {"title": "Usmate Velate", "country": "it"},
+    {"title": "Vaprio D'Adda", "country": "it"},
+    {"title": "Vedano Al Lambro", "country": "it"},
+    {"title": "Vignate", "country": "it"},
+    {"title": "Villasanta", "country": "it"},
+    {"title": "Vimercate", "country": "it"},
+    {"title": "Vimodrone", "country": "it"},
+    {"title": "Vizzolo Predabissi", "country": "it"},
+]
+
+TEST_CASES = {
+    "Vimodrone, Via Aldo Moro": {"city": "Vimodrone", "street": "Via Aldo Moro"},
+    "Cologno Monzese, Via Cadore": {"city": "Cologno Monzese", "street": "Via Cadore"},
+    "Vimercate, Via Cesare Battisti": {
+        "city": "Vimercate",
+        "street": "Via Cesare Battisti",
+    },
+}
+
+ICON_MAP = {
+    "UMI": Icons.BIO_KITCHEN,  # Raccolta Umido (food waste)
+    "VER": Icons.GARDEN,  # Raccolta Verde (garden waste)
+    "CAR": Icons.PAPER,  # Raccolta Carta
+    "VET": Icons.GLASS,  # Raccolta Vetro
+    "MUL": Icons.PLASTIC_PACKAGING,  # Raccolta Multipak (plastic + metal)
+    "APL": Icons.PLASTIC_PACKAGING,  # Raccolta Altre Plastiche
+    "SEC": Icons.GENERAL_WASTE,  # Raccolta Secco
+    "ECU": Icons.GENERAL_WASTE,  # Raccolta Ecuosacco
+    "STP": Icons.GENERAL_WASTE,  # Raccolta Ecuosacco puntuale
+}
+
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": "Enter the municipality (comune) and street (via) exactly as they are "
+    "known to CEM Ambiente, e.g. as shown on https://www.cemambiente.it/cemfacile/. "
+    "If the exact spelling isn't found, the error message will list the closest "
+    "matching street names for your municipality.",
+    "it": "Inserisci il comune e la via esattamente come sono indicati da CEM "
+    "Ambiente, ad esempio come mostrato su https://www.cemambiente.it/cemfacile/. "
+    "Se l'ortografia esatta non viene trovata, il messaggio di errore elencherà le "
+    "vie più simili per il tuo comune.",
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "city": "The municipality served by CEM Ambiente (e.g. 'Vimodrone').",
+        "street": "The street name as listed by CEM Ambiente for the selected "
+        "municipality (e.g. 'Via Aldo Moro').",
+    },
+    "it": {
+        "city": "Il comune servito da CEM Ambiente (ad esempio 'Vimodrone').",
+        "street": "Il nome della via come indicato da CEM Ambiente per il comune "
+        "selezionato (ad esempio 'Via Aldo Moro').",
+    },
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "city": "City",
+        "street": "Street",
+    },
+    "it": {
+        "city": "Comune",
+        "street": "Via",
+    },
+}
+
+
+class Source:
+    def __init__(self, city: str, street: str):
+        self._city: str = city
+        self._street: str = street
+
+    def fetch(self) -> list[Collection]:
+        session = requests.Session()
+        session.headers.update(HEADERS)
+
+        r = session.post(f"{API_URL}/public/listComuni", json={})
+        r.raise_for_status()
+        comuni = r.json().get("body", [])
+
+        comune = next(
+            (
+                c
+                for c in comuni
+                if str(c.get("nome", "")).casefold() == self._city.strip().casefold()
+            ),
+            None,
+        )
+        if comune is None:
+            all_names = [c.get("nome", "") for c in comuni]
+            suggestions = get_close_matches(self._city, all_names, n=5, cutoff=0.4)
+            raise SourceArgumentNotFoundWithSuggestions(
+                "city", self._city, suggestions or sorted(all_names)
+            )
+
+        id_siunet = comune["idSiunet"]
+
+        r = session.post(f"{API_URL}/public/listVie", json={"idSiunet": id_siunet})
+        r.raise_for_status()
+        vie = r.json().get("body", [])
+
+        via = next(
+            (
+                v
+                for v in vie
+                if str(v.get("nome", "")).casefold() == self._street.strip().casefold()
+            ),
+            None,
+        )
+        if via is None:
+            all_streets = [v.get("nome", "") for v in vie]
+            suggestions = get_close_matches(self._street, all_streets, n=5, cutoff=0.4)
+            raise SourceArgumentNotFoundWithSuggestions(
+                "street", self._street, suggestions or sorted(all_streets)
+            )
+
+        r = session.post(
+            f"{API_URL}/public/getCalendario",
+            json={
+                "idSiunet": id_siunet,
+                "idVia": via["idVia"],
+                "nomeVia": via["nome"],
+            },
+        )
+        r.raise_for_status()
+        servizi = r.json().get("body", [])
+
+        entries: list[Collection] = []
+        for item in servizi:
+            date_str = item.get("data")
+            servizio = item.get("servizio")
+            if not date_str or not servizio:
+                continue
+
+            date = datetime.fromisoformat(date_str).date()
+
+            tipologia = item.get("tipologiaServizio") or ""
+            code = tipologia.split(" - ")[0].strip()
+            icon = ICON_MAP.get(code)
+
+            entries.append(Collection(date=date, t=servizio, icon=icon))
+
+        return entries

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

@@ -0,0 +1,193 @@
+"""
+Central Bedfordshire Council waste collection source.
+
+Rewritten for the council's new site, which runs on the
+"LocalGov Drupal Waste Collection" module
+(https://www.drupal.org/project/localgov_waste_collection).
+
+That module documents two useful GET-only URLs, which is why this version
+is much simpler than the old one (no more multi-step POST + session cookie
+dance):
+    Postcode search : {base}/find?postcode={postcode}
+    Direct schedule : {base}/view/{uprn}
+
+On this council's site {base} = /waste-and-recycling/waste-collection-schedule
+
+Address lookup:
+    The /find?postcode=... page has a <select id="edit-uprn" name="uprn">
+    with one <option value="{uprn}">{full address}</option> per property.
+
+Results page:
+    Each collection day is a <li class="waste-collection__day"> containing:
+        <span class="waste-collection__day--day"><time datetime="DD-MM-YYYY">
+        <span class="waste-collection__day--type">Recycling, garden waste
+            and food waste collections</span>
+    Note the type is a single natural-language sentence combining every bin
+    collected that day (e.g. "Refuse (black bin) and food waste
+    collections"), not one element per bin - so it has to be split apart
+    rather than read as one string.
+
+    Some properties (e.g. those with a separate garden waste subscription)
+    have TWO <li> rows sharing the same date - one standalone "Garden Waste
+    Collection" row plus the usual combined "Recycling, garden waste and
+    food waste collections" row. Bin types are therefore deduplicated per
+    calendar date across all rows, not just within a single row's text.
+"""
+
+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 (
+    SourceArgumentNotFound,
+    SourceArgumentNotFoundWithSuggestions,
+)
+
+TITLE = "Central Bedfordshire Council"
+DESCRIPTION = (
+    "Source for www.centralbedfordshire.gov.uk services for Central Bedfordshire"
+)
+URL = "https://www.centralbedfordshire.gov.uk"
+
+BASE_PATH = "/waste-and-recycling/waste-collection-schedule"
+FIND_URL = f"{URL}{BASE_PATH}/find"
+VIEW_URL_TEMPLATE = f"{URL}{BASE_PATH}/view/{{uprn}}"
+
+TEST_CASES = {
+    "Buttermere Avenue, Dunstable": {
+        "postcode": "LU6 3PD",
+        "house_name": "1 Buttermere Avenue",
+    },
+    # Postcode deliberately unspaced here: the site accepts both forms, and
+    # this keeps the "postcode without space" coverage the old test cases had.
+    # This address also has a separate garden waste row, exercising the
+    # per-date deduplication below.
+    "Chestnut Avenue, Biggleswade (unspaced postcode, separate garden waste row)": {
+        "postcode": "SG180LL",
+        "house_name": "1 Chestnut Avenue",
+    },
+}
+
+
+# Keyed by lowercased bin name, since the site capitalises the first item of
+# each sentence but not the rest (e.g. "Refuse (black bin) and food waste
+# collections" vs "Recycling, garden waste and food waste collections").
+BIN_TYPES = {
+    "refuse (black bin)": ("Refuse (black bin)", Icons.GENERAL_WASTE),
+    "recycling": ("Recycling", Icons.RECYCLING),
+    "garden waste": ("Garden waste", Icons.GARDEN),
+    "food waste": ("Food waste", Icons.BIO_KITCHEN),
+}
+
+# Matches the trailing "collection"/"collections" the site appends, e.g.
+# "Recycling, garden waste and food waste collections".
+_TRAILING_COLLECTIONS_RE = re.compile(r"\s+collections?\s*$", re.IGNORECASE)
+
+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": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
+    "Accept-Language": "en-GB,en;q=0.9",
+}
+
+
+class Source:
+    def __init__(self, postcode, house_name):
+        self._postcode = postcode
+        self._house_name = house_name
+
+    def fetch(self):
+        session = requests.Session()
+        session.headers.update(HEADERS)
+
+        uprn = self._lookup_uprn(session)
+        r = session.get(VIEW_URL_TEMPLATE.format(uprn=uprn), timeout=30)
+        r.raise_for_status()
+
+        soup = BeautifulSoup(r.text, features="html.parser")
+        return self._parse_collections(soup)
+
+    def _lookup_uprn(self, session):
+        r = session.get(FIND_URL, params={"postcode": self._postcode}, timeout=30)
+        r.raise_for_status()
+        soup = BeautifulSoup(r.text, features="html.parser")
+
+        address_select = soup.find("select", id="edit-uprn")
+        if not address_select:
+            # The site omits the address dropdown entirely when the postcode
+            # is not recognised, so this is far more likely to be a bad
+            # postcode than a change in page structure.
+            raise SourceArgumentNotFound(
+                "postcode",
+                self._postcode,
+                "no addresses were returned for this postcode, please check "
+                "it and try again.",
+            )
+
+        option = address_select.find(
+            "option",
+            string=lambda value: value and value.strip().startswith(self._house_name),
+        )
+        if option is None:
+            addresses = {
+                opt.text.strip()
+                for opt in address_select.select("option")
+                if opt.get("value")
+            }
+            raise SourceArgumentNotFoundWithSuggestions(
+                "house_name",
+                self._house_name,
+                addresses,
+            )
+
+        return option["value"]
+
+    def _parse_collections(self, soup):
+        days = soup.select(".waste-collection__day")
+        if not days:
+            raise ValueError(
+                "Could not find any collections for this address - the page "
+                "structure may have changed."
+            )
+
+        # Some addresses (e.g. properties with a separate garden waste
+        # subscription) have two <li> rows sharing the same date - one for
+        # "Garden Waste Collection" on its own, one for the combined
+        # "Recycling, garden waste and food waste collections" row. Collect
+        # everything per date first so a bin type mentioned in more than one
+        # row for the same day is only reported once.
+        bins_by_date = {}
+        for day in days:
+            time_el = day.select_one(".waste-collection__day--day time")
+            type_el = day.select_one(".waste-collection__day--type")
+            if time_el is None or type_el is None or not time_el.get("datetime"):
+                continue
+
+            try:
+                date = datetime.strptime(time_el["datetime"], "%d-%m-%Y").date()
+            except ValueError:
+                continue
+
+            day_bins = bins_by_date.setdefault(date, {})
+            for bin_type in self._split_bin_types(type_el.text):
+                key = bin_type.lower()
+                label, icon = BIN_TYPES.get(key, (bin_type, None))
+                day_bins[key] = (label, icon)
+
+        entries = [
+            Collection(date=date, t=label, icon=icon)
+            for date, day_bins in bins_by_date.items()
+            for label, icon in day_bins.values()
+        ]
+
+        return entries
+
+    @staticmethod
+    def _split_bin_types(text):
+        """Split "Recycling, garden waste and food waste collections" into
+        ["Recycling", "garden waste", "food waste"]."""
+        text = _TRAILING_COLLECTIONS_RE.sub("", text.strip())
+        text = text.replace(" and ", ", ")
+        return [part.strip() for part in text.split(",") if part.strip()]

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

@@ -0,0 +1,107 @@
+from datetime import date, timedelta
+
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import SourceArgumentNotFound
+from waste_collection_schedule.service.ArcGis import (
+    ArcGisError,
+    geocode,
+    query_feature_layer,
+)
+
+TITLE = "Charleston, SC"
+DESCRIPTION = (
+    "Source for City of Charleston, SC garbage and trash/yard-waste collection."
+)
+URL = "https://www.charleston-sc.gov/345/Environmental-Services"
+COUNTRY = "us"
+
+TEST_CASES = {
+    "Downtown Charleston": {"address": "123 Coming St, Charleston, SC 29403"},
+    "Johns Island (Trident Waste)": {
+        "address": "2758 August Rd, Johns Island, SC 29455"
+    },
+    "Daniel Island (Berkeley County)": {
+        "address": "1865 Pierce St, Charleston, SC 29492"
+    },
+}
+
+SOURCE_CODEOWNERS = ["@dmkjr"]
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "address": "Full street address including city, state, and ZIP code.",
+    },
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "address": "Street Address",
+    },
+}
+
+MAP_SERVER = "https://gis.charleston-sc.gov/arcgis2/rest/services/External/mapnetExternal/MapServer"
+
+# Garbage and trash/yard-waste are collected on independent routes and can
+# fall on different weekdays for the same address, so each layer is queried
+# separately and surfaced as its own stream instead of being folded together.
+LAYERS = [
+    (f"{MAP_SERVER}/10", "Garbage", Icons.GENERAL_WASTE),
+    (f"{MAP_SERVER}/11", "Trash & Yard Waste", Icons.GARDEN),
+]
+
+WEEKDAYS = {
+    "Monday": 0,
+    "Tuesday": 1,
+    "Wednesday": 2,
+    "Thursday": 3,
+    "Friday": 4,
+    "Saturday": 5,
+    "Sunday": 6,
+}
+
+WEEKS_AHEAD = 26
+
+
+class Source:
+    def __init__(self, address: str):
+        self._address = address.strip()
+
+    def fetch(self) -> list[Collection]:
+        try:
+            location = geocode(self._address)
+        except ArcGisError as e:
+            raise SourceArgumentNotFound("address", self._address) from e
+
+        entries: list[Collection] = []
+        for feature_url, waste_type, icon in LAYERS:
+            try:
+                features = query_feature_layer(
+                    feature_url,
+                    geometry=location,
+                    out_fields="DAY",
+                )
+            except ArcGisError:
+                # Not every address falls inside every route layer.
+                continue
+
+            pickup_day = (features[0].get("DAY") or "").strip().title()
+            if pickup_day not in WEEKDAYS:
+                continue
+
+            today = date.today()
+            days_ahead = (WEEKDAYS[pickup_day] - today.weekday()) % 7
+            next_pickup = today + timedelta(days=days_ahead)
+
+            entries.extend(
+                Collection(
+                    date=next_pickup + timedelta(weeks=week),
+                    t=waste_type,
+                    icon=icon,
+                )
+                for week in range(WEEKS_AHEAD)
+            )
+
+        if not entries:
+            raise SourceArgumentNotFound("address", self._address)
+
+        return entries