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

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

@@ -0,0 +1,178 @@
+from datetime import datetime
+
+import requests
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import (
+    SourceArgumentNotFoundWithSuggestions,
+)
+
+TITLE = "Apps by imactivate"
+DESCRIPTION = "Source for Apps by imactivate."
+URL = "https://imactivate.com/"
+TEST_CASES = {
+    "Leeds: LS6 2SE Leeds sharp mews 2": {
+        "postcode": "LS62SE",
+        "town": "Leeds",
+        "street": "sharp mews",
+        "number": 2,
+    },
+    "Fenland: PE15 8RD March 90 Creek Rd": {
+        "postcode": "PE158RD",
+        "town": "March",
+        "street": "Creek Road",
+        "number": "90",
+    },
+    "Rotherham: S61 4BH 2 Eskdale Rd, Rotherham": {
+        "postcode": "S614BH",
+        "town": "Rotherham",
+        "street": "Eskdale Road",
+        "number": 2,
+    },
+    "Luton: LU2 9DF 23 Marshall Rd": {
+        "postcode": "LU2 9DF",
+        "town": "Luton",
+        "street": "Marshall Rd",
+        "number": 23,
+    },
+}
+
+COUNTRY = "uk"
+
+EXTRA_INFO = [
+    {
+        "title": "Leeds",
+        "url": "https://www.leeds.gov.uk",
+        "default_params": {"town": "Leeds"},
+    },
+    {
+        "title": "Fenland",
+        "url": "https://www.fenland.gov.uk",
+    },
+    {
+        "title": "Rotherham",
+        "url": "https://www.rotherham.gov.uk",
+        "default_params": {"town": "Rotherham"},
+    },
+    {
+        "title": "Luton",
+        "url": "https://www.luton.gov.uk",
+        "default_params": {"town": "Luton"},
+    },
+]
+
+
+ICON_MAP = {
+    "waste": Icons.GENERAL_WASTE,
+    "black": Icons.GENERAL_WASTE,
+    "pink bin": Icons.GENERAL_WASTE,
+    "residual": Icons.GENERAL_WASTE,
+    "glass": Icons.GLASS,
+    "garden": Icons.GARDEN,
+    "brown": Icons.ORGANIC,
+    "recycling": Icons.RECYCLING,
+    "green": Icons.RECYCLING,
+    "black bin": Icons.RECYCLING,
+    "green bin": Icons.PAPER,
+}
+
+
+API_URL = "https://bins.azurewebsites.net/api/"
+
+
+class Source:
+    def __init__(self, postcode: str, town: str, street: str, number: str | int):
+        self._postcode: str = postcode
+        self._town: str = town.lower().replace(" ", "")
+        self._street: str = street.lower().replace(" ", "").replace("road", "rd")
+        self._number: str = str(number).lower().replace(" ", "")
+        self._premises_id: int | None = None
+        self._local_authority: str | None = None
+
+    def _retrieve_premise_id(self) -> None:
+        r = requests.get(f"{API_URL}getlocation", params={"postcode": self._postcode})
+        r.raise_for_status()
+        real_post_code: str = r.json()[0]["Postcode"]
+
+        r = requests.get(f"{API_URL}getaddress", params={"postcode": real_post_code})
+        r.raise_for_status()
+
+        data = r.json()
+        street_matches = []
+        for location in data:
+            if (
+                location["Street"].lower().replace(" ", "").replace("road", "rd")
+                == self._street
+                and location["Town"].lower().replace(" ", "") == self._town
+            ):
+                street_matches.append(location)
+
+        if len(street_matches) == 0:
+            possibilities = {
+                location["Street"]
+                for location in data
+                if location["Town"].lower().replace(" ", "") == self._town
+            }
+            raise SourceArgumentNotFoundWithSuggestions(
+                "street", f"{self._street}, {self._town}", suggestions=possibilities
+            )
+
+        for location in street_matches:
+            number1 = (
+                (location["Address1"].strip() + location["Address2"].strip())
+                .replace(" ", "")
+                .replace("\u0000", "")
+                .lower()
+            )
+            number2 = (
+                (location["Address2"].strip() + location["Address1"].strip())
+                .replace(" ", "")
+                .replace("\u0000", "")
+                .lower()
+            )
+            if number1 == self._number or number2 == self._number:
+                self._premises_id = location["PremiseID"]
+                self._local_authority = location["LocalAuthority"]
+                return
+
+        possibilities = {
+            location["Address1"] + location["Address2"] for location in street_matches
+        }
+        raise SourceArgumentNotFoundWithSuggestions(
+            "number", self._number, suggestions=possibilities
+        )
+
+    def _fetch_premise(self) -> list[Collection]:
+        if self._premises_id is None or self._local_authority is None:
+            raise ValueError("Premise ID and Local Authority required")
+
+        params: dict[str, str | int] = {
+            "premisesid": self._premises_id,
+            "localauthority": self._local_authority,
+        }
+
+        r = requests.get(
+            f"{API_URL}getcollections",
+            params=params,
+        )
+        r.raise_for_status()
+        data = r.json()
+        entries = []
+        for collection in data:
+            if "BinType" not in collection or "CollectionDate" not in collection:
+                continue
+            icon = ICON_MAP.get(collection["BinType"].lower())
+            date_str = collection["CollectionDate"]
+            date = datetime.strptime(date_str, "%Y-%m-%d").date()
+            entries.append(Collection(date, collection["BinType"], icon))
+
+        if not entries:
+            raise ValueError("No collections found")
+        return entries
+
+    def fetch(self) -> list[Collection]:
+        try:
+            return self._fetch_premise()
+        except Exception:
+            pass
+        self._retrieve_premise_id()
+        return self._fetch_premise()

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

@@ -0,0 +1,300 @@
+import datetime
+from typing import Any
+
+import requests
+from waste_collection_schedule import Collection, Icons
+from waste_collection_schedule.exceptions import (
+    SourceArgumentException,
+    SourceArgumentExceptionMultiple,
+    SourceArgumentNotFound,
+    SourceArgumentRequired,
+)
+
+TITLE = "Aprica S.p.A."
+DESCRIPTION = "Source for Aprica S.p.A. (Gruppo A2A) waste collection."
+URL = "https://www.apricaspa.it"
+COUNTRY = "it"
+
+TEST_CASES = {
+    "borgo_san_giacomo_via_pascoli_18": {
+        "address": "Via Giovanni Pascoli",
+        "house_number": "18",
+        "city": "Borgo San Giacomo",
+    },
+    "brescia_via_triumplina_90": {
+        "address": "Via Triumplina",
+        "house_number": "90",
+        "city": "Brescia",
+    },
+    "bergamo_via_moroni_337": {
+        "address": "Via Giovanni Battista Moroni",
+        "house_number": "337",
+        "city": "Bergamo",
+    },
+}
+
+BASE_URL = "https://www.apricaspa.it"
+API_URL = BASE_URL + "/it?popup=services&serviceType=sdz"
+
+ICON_MAP = {
+    "indifferenziato": Icons.GENERAL_WASTE,
+    "organico": Icons.BIO_KITCHEN,
+    "carta e cartone": Icons.PAPER,
+    "carta": Icons.PAPER,
+    "plastica": Icons.RECYCLING,
+    "plastica e metallo": Icons.METAL,
+    "imballaggi in plastica e metallo": Icons.METAL,
+    "imballaggi in plastica": Icons.RECYCLING,
+    "vetro": Icons.GLASS,
+    "vetro e metallo": Icons.GLASS,
+    "vetro e metalli": Icons.GLASS,
+    "vetro e lattine": Icons.GLASS,
+    "sfalci e potature": Icons.GARDEN,
+    "verde": Icons.GARDEN,
+    "tessili sanitari": Icons.TEXTILE,
+    "pannolini": Icons.GENERAL_WASTE,
+}
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": "You need to provide the street name, house number, and city "
+    "of your address. Aprica serves cities like Brescia, Bergamo, Como, "
+    "Cremona, Crema, Lodi and their provinces.",
+    "it": "Devi fornire il nome della via, il numero civico e la città "
+    "del tuo indirizzo. Aprica serve città come Brescia, Bergamo, Como, "
+    "Cremona, Crema, Lodi e relative province.",
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "address": "The street name of your address (e.g., 'Via Triumplina').",
+        "house_number": "The house number of your address (e.g., '90').",
+        "city": "The city of your address (e.g., 'Brescia').",
+    },
+    "it": {
+        "address": "Il nome della via del tuo indirizzo "
+        "(ad esempio, 'Via Triumplina').",
+        "house_number": "Il numero civico del tuo indirizzo (ad esempio, '90').",
+        "city": "La città del tuo indirizzo (ad esempio, 'Brescia').",
+    },
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "address": "Address",
+        "house_number": "House Number",
+        "city": "City",
+    },
+    "it": {
+        "address": "Indirizzo",
+        "house_number": "Numero Civico",
+        "city": "Città",
+    },
+}
+
+
+class Source:
+    def __init__(self, address: Any, house_number: Any, city: Any):
+        """Create a new source for Aprica S.p.A. and validate inputs.
+
+        Validation rules:
+        - `address` is required and must be a non-empty string.
+        - `house_number` is required and must be a non-empty string or int.
+        - `city` is required and must be a non-empty string.
+        """
+        errors: list[tuple[str, str]] = []
+
+        # Validate address
+        if address is None or not isinstance(address, str) or address.strip() == "":
+            errors.append(("address", "address must be a non-empty string"))
+
+        # Validate house_number
+        if (
+            house_number is None
+            or not isinstance(house_number, (str, int))
+            or (isinstance(house_number, str) and house_number.strip() == "")
+        ):
+            errors.append(
+                (
+                    "house_number",
+                    "house_number must be provided and non-empty",
+                )
+            )
+
+        # Validate city (required for Aprica, which serves multiple cities)
+        if city is None or not isinstance(city, str) or city.strip() == "":
+            errors.append(("city", "city is required for Aprica"))
+
+        # Raise exceptions based on validation
+        if len(errors) > 1:
+            arg_names = [arg for arg, _ in errors]
+            message = ", ".join([f"{a}: {m}" for a, m in errors])
+            raise SourceArgumentExceptionMultiple(arg_names, message)
+
+        if len(errors) == 1:
+            arg, msg = errors[0]
+            if arg in ("address", "house_number", "city"):
+                raise SourceArgumentRequired(arg, msg)
+            raise SourceArgumentException(arg, msg)
+
+        # Store sanitized values
+        self._address = str(address).strip()
+        self._house_number = str(house_number).strip()
+        self._city = str(city).strip()
+
+    def _build_address_query(self) -> str:
+        return f"{self._address} {self._house_number}, {self._city}"
+
+    def collect_waste_collection_schedule(self) -> dict[str, list[str]]:
+        """
+        Fetch calendar items by emulating the site's XHR API calls.
+
+        Flow (same as AMSA, both are A2A group companies):
+        1) POST /api/service/area-services/address-autocomplete with address
+        2) POST /api/service/area-services/address-search with the chosen id
+        3) POST /api/service/area-services/calendar-items with geociv (civic id)
+
+        Returns a dict mapping ISO date strings (YYYY-MM-DD) to list of event
+        keys (lowercase).
+        """
+        session = requests.Session()
+        headers = {
+            "Content-Type": "application/json",
+            "Accept": "application/json, text/javascript, */*; q=0.01",
+            "Origin": BASE_URL,
+            "Referer": API_URL,
+            "User-Agent": "Mozilla/5.0 (compatible; waste-collection-scraper/1.0)",
+        }
+
+        address_query = self._build_address_query()
+
+        # 1) suggestions
+        try:
+            resp = session.post(
+                f"{BASE_URL}/api/service/area-services/address-autocomplete",
+                json={
+                    "address": address_query,
+                    "city": self._city,
+                    "source": "database",
+                },
+                headers=headers,
+                timeout=15,
+            )
+            resp.raise_for_status()
+            j = resp.json()
+        except Exception as e:
+            raise Exception("Could not fetch address suggestions: " + str(e)) from e
+
+        try:
+            suggestions = j.get("data", [])
+            if not suggestions:
+                raise SourceArgumentNotFound("address", self._address)
+            suggestion = suggestions[0]
+            suggestion_id = suggestion.get("id")
+        except Exception as e:
+            raise Exception("Could not parse suggestion response: " + str(e)) from e
+
+        # 2) select suggestion -> obtain civic id / place detail
+        street = suggestion.get("value") or self._address
+        try:
+            civic_raw = self._house_number
+            try:
+                civic_val = int(civic_raw)
+            except Exception:  # e.g. "40B" - remove non-numeric characters
+                civic_val = int("".join(filter(str.isdigit, civic_raw)))
+
+            resp2 = session.post(
+                f"{BASE_URL}/api/service/area-services/address-search",
+                json={
+                    "id": suggestion_id,
+                    "street": suggestion.get("details", {}).get("via", street),
+                    "city": self._city,
+                    "civic": civic_val,
+                },
+                headers=headers,
+                timeout=15,
+            )
+            resp2.raise_for_status()
+            j2 = resp2.json()
+        except Exception as e:
+            raise Exception(
+                "Could not select address / fetch place details: " + str(e)
+            ) from e
+
+        try:
+            data: dict[str, Any] = j2.get("data") or {}
+            geociv = data.get("idCivico") or data.get("place_id") or suggestion_id
+            if geociv is None:
+                raise SourceArgumentNotFound("house_number", self._house_number)
+        except Exception as e:
+            raise Exception("Could not parse address-search response: " + str(e)) from e
+
+        # 3) fetch calendar items
+        try:
+            resp3 = session.post(
+                f"{BASE_URL}/api/service/area-services/calendar-items",
+                json={"geociv": str(geociv)},
+                headers=headers,
+                timeout=30,
+            )
+            resp3.raise_for_status()
+            j3 = resp3.json()
+        except Exception as e:
+            raise Exception("Could not fetch calendar items: " + str(e)) from e
+
+        collections: dict[str, list[str]] = {}
+        try:
+            items = j3.get("data", [])
+            for item in items:
+                ms = item.get("date")
+                if ms is None:
+                    continue
+                try:
+                    dt = datetime.datetime.fromtimestamp(ms / 1000.0).date()
+                except Exception:
+                    continue
+                date_str = dt.isoformat()
+
+                desc = (item.get("desc") or "").lower()
+                if desc.startswith("raccolta "):
+                    desc = desc[len("raccolta ") :]
+                desc = desc.strip()
+
+                # Prefer exact match, then longest substring match
+                if desc in ICON_MAP:
+                    matched = [desc]
+                else:
+                    # Find longest matching key to avoid subset matches
+                    # e.g. "vetro e metallo" should match that key, not "vetro"
+                    candidates = [key for key in ICON_MAP if key in desc]
+                    if candidates:
+                        matched = [max(candidates, key=len)]
+                    else:
+                        matched = [desc]
+
+                existing = set(collections.get(date_str, []))
+                for m in matched:
+                    if m not in existing:
+                        existing.add(m)
+                if existing:
+                    collections[date_str] = sorted(existing)
+        except Exception as e:
+            raise Exception("Could not parse calendar items: " + str(e)) from e
+
+        return collections
+
+    def fetch(self) -> list[Collection]:
+        calendar_data = self.collect_waste_collection_schedule()
+
+        entries: list[Collection] = []
+        for date_str, events in calendar_data.items():
+            try:
+                date = datetime.datetime.strptime(date_str, "%Y-%m-%d").date()
+            except Exception:
+                continue
+            for event in events:
+                event_lower = event.lower()
+                icon = ICON_MAP.get(event_lower, "mdi:trash-can")
+                entries.append(Collection(date=date, t=event, icon=icon))
+
+        entries.sort(key=lambda x: x.date)
+        return entries

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

@@ -0,0 +1,95 @@
+from datetime import datetime, timedelta
+
+import requests
+from bs4 import BeautifulSoup
+from waste_collection_schedule import Collection, Icons
+
+TITLE = "Taranto (araccolta.it)"
+DESCRIPTION = "Source for Taranto (araccolta.it)."
+URL = "https://araccolta.it/"
+TEST_CASES = {
+    "lama-san-vito-talsano Domestic": {
+        "district": "lama-san-vito-talsano",
+    },
+    "isola-amministrativa non Domestic": {
+        "district": "isola-amministrativa",
+        "domestic": False,
+    },
+}
+
+
+PARAM_TRANSLATIONS = {
+    "en": {"district": "District", "domestic": "Domestic"},
+    "it": {"district": "Quartiere", "domestic": "Utenze domestiche"},
+}
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": "Visit [https://araccolta.it/#calendario](https://araccolta.it/#calendario) and select your district (Quartiere) write the argument exactly like in the URL after clicking on your district.",
+    "it": "Visita [https://araccolta.it/#calendario](https://araccolta.it/#calendario) e seleziona il tuo quartiere, scrivi l'argomento esattamente come nell'URL dopo aver cliccato sul tuo quartiere.",
+}
+
+ICON_MAP = {
+    "Carta e cartone": Icons.PAPER,
+    "Organico": Icons.BIO_KITCHEN,
+    "Secco residuo": Icons.GENERAL_WASTE,
+    "Vetro": Icons.GLASS,
+    "Plastica e metalli": Icons.METAL,
+}
+
+
+ITALIAN_WEEKDAYS = [
+    "lunedì",
+    "martedì",
+    "mercoledì",
+    "giovedì",
+    "venerdì",
+    "sabato",
+    "domenica",
+]
+
+API_URL = "https://araccolta.it/{district}/"
+
+
+class Source:
+    def __init__(self, district: str, domestic: bool = True):
+        self._district: str = district.lower().strip().replace(" ", "-")
+        self._domestic: bool = domestic
+
+    def fetch(self) -> list[Collection]:
+        # get json file
+        r = requests.get(API_URL.format(district=self._district))
+        r.raise_for_status()
+
+        section_id = "ud" if self._domestic else "und"
+
+        soup = BeautifulSoup(r.text, "html.parser")
+
+        section = soup.select_one(f"section#{section_id}")
+        if not section:
+            raise ValueError("could not find calendar section for district")
+
+        entries: list[Collection] = []
+        for card in section.select("div.calendar-card"):
+            weekdays = (
+                card.select_one("div.day-wrapper").text.strip().lower().split("/")
+            )
+            if len(weekdays) == 1:
+                weekdays = weekdays[0].split(" - ")
+            waste_types = (t.text for t in card.select("h3"))
+            for weekday in weekdays:
+                weekday_int = ITALIAN_WEEKDAYS.index(weekday)
+                next_date = (
+                    datetime.now()
+                    + timedelta(days=(weekday_int - datetime.now().weekday()) % 7)
+                ).date()
+                for waste_type in waste_types:
+                    entries += [
+                        Collection(
+                            date=next_date + timedelta(weeks=i),
+                            t=waste_type,
+                            icon=ICON_MAP.get(waste_type),
+                        )
+                        for i in range(25)
+                    ]
+
+        return entries

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

@@ -0,0 +1,110 @@
+from datetime import datetime
+
+import requests
+from bs4 import BeautifulSoup, Tag
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+
+TITLE = "Ards and North Down Borough Council"
+DESCRIPTION = "Source for Ards and North Down Borough Council."
+URL = "https://ardsandnorthdown.gov.uk"
+TEST_CASES = {
+    "185833845": {"uprn": 185833845},
+    "187340776": {"uprn": "185928695"},
+    "185180798": {"uprn": 185180798},
+}
+
+
+ICON_MAP = {
+    "grey": Icons.GENERAL_WASTE,
+    "glass": Icons.GLASS,
+    "green": Icons.ORGANIC,
+    "blue": Icons.RECYCLING,
+}
+
+
+API_URL = (
+    "https://ardsandnorthdownbincalendar.azurewebsites.net/api/calendarhtml/{uprn}"
+)
+
+
+class Source:
+    def __init__(self, uprn: str | int):
+        self._uprn = str(uprn).strip()
+
+    def fetch(self) -> list[Collection]:
+        r = requests.get(API_URL.format(uprn=self._uprn))
+        r.raise_for_status()
+
+        html = r.json().get("calendarHTML", "")
+
+        entries: list[Collection] = []
+
+        soup = BeautifulSoup(html, "html.parser")
+        # find b/strong tag where text starts with "Key:"
+
+        self._bin_type_translation: dict[str, str] = {}
+
+        keys = soup.find_all(["b", "strong"])
+
+        key = None
+        for k in keys:
+            if k.text.strip().startswith("Key:"):
+                key = k
+                break
+
+        # Map all unique non-background fill colors to their bin names
+        if key:
+            svg_titles = key.find_all("svg")
+            for svg in svg_titles:
+                title_tag = svg.find("title")
+                if not (title_tag and title_tag.text):
+                    continue
+                bin_name = title_tag.text.strip()
+                fills = set()
+                for path in svg.find_all("path"):
+                    fill = path.get("fill")
+                    if fill and fill.lower() not in ("#ffffff", "#000000"):
+                        fills.add(fill)
+                for fill in fills:
+                    self._bin_type_translation[fill] = bin_name
+
+        calendar = soup.find("div", {"id": "NewCalendar"})
+        if not isinstance(calendar, Tag):
+            raise Exception("No calendar found")
+
+        for table in calendar.find_all("table"):
+            month_year = table.find("th").text
+            day = 0
+
+            for tr in table.find_all("tr"):
+                for td in tr.find_all("td"):
+                    if td.text.strip().isdigit():
+                        day = int(td.text.strip())
+                        continue
+
+                    svg = td.find("svg")
+                    if svg:
+                        day += 1
+                        for p in svg.find_all("path"):
+                            if not p.has_attr("fill"):
+                                continue
+                            fill = p["fill"]
+                            if fill.lower() == "#ffffff":
+                                continue
+                            bin_name = self._bin_type_translation.get(fill)
+                            if bin_name:
+                                try:
+                                    entries.append(
+                                        Collection(
+                                            date=datetime.strptime(
+                                                f"{day} {month_year}", "%d %B %Y"
+                                            ).date(),
+                                            t=bin_name,
+                                            icon=ICON_MAP.get(
+                                                bin_name.split()[0].lower()
+                                            ),
+                                        )
+                                    )
+                                except ValueError:
+                                    continue
+        return entries